src/jalview/ws/sifts/SiftsClient.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.ws.sifts;
  22
  23 import jalview.analysis.AlignSeq;
  24 import jalview.api.DBRefEntryI;
  25 import jalview.api.SiftsClientI;
  26 import jalview.datamodel.DBRefEntry;
  27 import jalview.datamodel.DBRefSource;
  28 import jalview.datamodel.SequenceI;
  29 import jalview.schemes.ResidueProperties;
  30 import jalview.structure.StructureMapping;
  31 import jalview.util.Format;
  32 import jalview.xml.binding.sifts.Entry;
  33 import jalview.xml.binding.sifts.Entry.Entity;
  34 import jalview.xml.binding.sifts.Entry.Entity.Segment;
  35 import jalview.xml.binding.sifts.Entry.Entity.Segment.ListMapRegion.MapRegion;
  36 import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue;
  37 import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.CrossRefDb;
  38 import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.ResidueDetail;
  39 import jalview.xml.binding.sifts.Entry.ListDB.Db;
  40
  41 import java.io.File;
  42 import java.io.FileInputStream;
  43 import java.io.FileNotFoundException;
  44 import java.io.FileOutputStream;
  45 import java.io.IOException;
  46 import java.io.InputStream;
  47 import java.io.PrintStream;
  48 import java.net.URL;
  49 import java.net.URLConnection;
  50 import java.nio.file.Files;
  51 import java.nio.file.Path;
  52 import java.nio.file.attribute.BasicFileAttributes;
  53 import java.util.ArrayList;
  54 import java.util.Arrays;
  55 import java.util.Collection;
  56 import java.util.Collections;
  57 import java.util.Date;
  58 import java.util.HashMap;
  59 import java.util.HashSet;
  60 import java.util.List;
  61 import java.util.TreeMap;
  62 import java.util.zip.GZIPInputStream;
  63
  64 import javax.xml.bind.JAXBContext;
  65 import javax.xml.bind.JAXBException;
  66 import javax.xml.bind.Unmarshaller;
  67 import javax.xml.stream.FactoryConfigurationError;
  68 import javax.xml.stream.XMLInputFactory;
  69 import javax.xml.stream.XMLStreamException;
  70 import javax.xml.stream.XMLStreamReader;
  71
  72 import MCview.Atom;
  73 import MCview.PDBChain;
  74 import MCview.PDBfile;
  75
  76 public class SiftsClient implements SiftsClientI
  77 {
  78   private Entry siftsEntry;
  79
  80   private PDBfile pdb;
  81
  82   private String pdbId;
  83
  84   private String structId;
  85
  86   private String segStartEnd;
  87
  88   private CoordinateSys seqCoordSys = CoordinateSys.UNIPROT;
  89
  90   private static final int BUFFER_SIZE = 4096;
  91
  92   public static final int UNASSIGNED = -1;
  93
  94   private static final int PDB_RES_POS = 0;
  95
  96   private static final int PDB_ATOM_POS = 1;
  97
  98   private static final String NOT_FOUND = "Not_Found";
  99
 100   private static final String NOT_OBSERVED = "Not_Observed";
 101
 102   private static final String SIFTS_FTP_BASE_URL = "ftp://ftp.ebi.ac.uk/pub/databases/msd/sifts/xml/";
 103
 104   private final static String NEWLINE = System.lineSeparator();
 105
 106   private final static int THRESHOLD_IN_DAYS = 2;
 107
 108   private String curSourceDBRef;
 109
 110   private HashSet<String> curDBRefAccessionIdsString;
 111
 112   public enum CoordinateSys
 113   {
 114     UNIPROT("UniProt"), PDB("PDBresnum"), PDBe("PDBe");
 115     private String name;
 116
 117     private CoordinateSys(String name)
 118     {
 119       this.name = name;
 120     }
 121
 122     public String getName()
 123     {
 124       return name;
 125     }
 126   };
 127
 128   public enum ResidueDetailType
 129   {
 130     NAME_SEC_STRUCTURE("nameSecondaryStructure"), CODE_SEC_STRUCTURE(
 131             "codeSecondaryStructure"), ANNOTATION("Annotation");
 132     private String code;
 133
 134     private ResidueDetailType(String code)
 135     {
 136       this.code = code;
 137     }
 138
 139     public String getCode()
 140     {
 141       return code;
 142     }
 143   };
 144
 145   /**
 146    * Fetch SIFTs file for the given PDBfile and construct an instance of
 147    * SiftsClient
 148    *
 149    * @param pdbId
 150    * @throws SiftsException
 151    */
 152   public SiftsClient(PDBfile pdb) throws SiftsException
 153   {
 154     this.pdb = pdb;
 155     this.pdbId = pdb.id;
 156     File siftsFile = getSiftsFile(pdbId);
 157     siftsEntry = parseSIFTs(siftsFile);
 158   }
 159
 160   /**
 161    * Construct an instance of SiftsClient using the supplied SIFTs file. Note:
 162    * The SIFTs file should correspond to the PDB Id in PDBfile instance
 163    *
 164    * @param pdbId
 165    * @param siftsFile
 166    * @throws SiftsException
 167    * @throws Exception
 168    */
 169   public SiftsClient(PDBfile pdb, File siftsFile) throws SiftsException
 170   {
 171     this.pdb = pdb;
 172     this.pdbId = pdb.id;
 173     siftsEntry = parseSIFTs(siftsFile);
 174   }
 175
 176   /**
 177    * Parse the given SIFTs File and return a JAXB POJO of parsed data
 178    *
 179    * @param siftFile
 180    *          - the GZipped SIFTs XML file to parse
 181    * @return
 182    * @throws Exception
 183    *           if a problem occurs while parsing the SIFTs XML
 184    */
 185   private Entry parseSIFTs(File siftFile) throws SiftsException
 186   {
 187     try (InputStream in = new FileInputStream(siftFile);
 188             GZIPInputStream gzis = new GZIPInputStream(in);)
 189     {
 190       // System.out.println("File : " + siftFile.getAbsolutePath());
 191       JAXBContext jc = JAXBContext.newInstance("jalview.xml.binding.sifts");
 192       XMLStreamReader streamReader = XMLInputFactory.newInstance()
 193               .createXMLStreamReader(gzis);
 194       Unmarshaller um = jc.createUnmarshaller();
 195       return (Entry) um.unmarshal(streamReader);
 196     } catch (JAXBException e)
 197     {
 198       e.printStackTrace();
 199       throw new SiftsException(e.getMessage());
 200     } catch (FileNotFoundException e)
 201     {
 202       e.printStackTrace();
 203       throw new SiftsException(e.getMessage());
 204     } catch (XMLStreamException e)
 205     {
 206       e.printStackTrace();
 207       throw new SiftsException(e.getMessage());
 208     } catch (FactoryConfigurationError e)
 209     {
 210       e.printStackTrace();
 211       throw new SiftsException(e.getMessage());
 212     } catch (IOException e)
 213     {
 214       e.printStackTrace();
 215       throw new SiftsException(e.getMessage());
 216     }
 217   }
 218
 219   /**
 220    * Get a SIFTs XML file for a given PDB Id from Cache or download from FTP
 221    * repository if not found in cache
 222    *
 223    * @param pdbId
 224    * @return SIFTs XML file
 225    * @throws SiftsException
 226    */
 227   public static File getSiftsFile(String pdbId) throws SiftsException
 228   {
 229     File siftsFile = new File(SiftsSettings.getSiftDownloadDirectory()
 230             + pdbId.toLowerCase() + ".xml.gz");
 231     if (siftsFile.exists())
 232     {
 233       // The line below is required for unit testing... don't comment it out!!!
 234       System.out.println(">>> SIFTS File already downloaded for " + pdbId);
 235
 236       if (isFileOlderThanThreshold(siftsFile, THRESHOLD_IN_DAYS))
 237       {
 238         // System.out.println("Downloaded file is out of date, hence re-downloading...");
 239         siftsFile = downloadSiftsFile(pdbId.toLowerCase());
 240       }
 241       return siftsFile;
 242     }
 243     siftsFile = downloadSiftsFile(pdbId.toLowerCase());
 244     return siftsFile;
 245   }
 246
 247   /**
 248    * This method enables checking if a cached file has exceeded a certain
 249    * threshold(in days)
 250    *
 251    * @param file
 252    *          the cached file
 253    * @param noOfDays
 254    *          the threshold in days
 255    * @return
 256    */
 257   public static boolean isFileOlderThanThreshold(File file, int noOfDays)
 258   {
 259     Path filePath = file.toPath();
 260     BasicFileAttributes attr;
 261     int diffInDays = 0;
 262     try
 263     {
 264       attr = Files.readAttributes(filePath, BasicFileAttributes.class);
 265       diffInDays = (int) ((new Date().getTime() - attr.lastModifiedTime()
 266               .toMillis()) / (1000 * 60 * 60 * 24));
 267       // System.out.println("Diff in days : " + diffInDays);
 268     } catch (IOException e)
 269     {
 270       e.printStackTrace();
 271     }
 272     return noOfDays <= diffInDays;
 273   }
 274
 275   /**
 276    * Download a SIFTs XML file for a given PDB Id from an FTP repository
 277    *
 278    * @param pdbId
 279    * @return downloaded SIFTs XML file
 280    * @throws SiftsException
 281    */
 282   public static File downloadSiftsFile(String pdbId) throws SiftsException
 283   {
 284     String siftFile = pdbId + ".xml.gz";
 285     String siftsFileFTPURL = SIFTS_FTP_BASE_URL + siftFile;
 286     String downloadedSiftsFile = SiftsSettings.getSiftDownloadDirectory()
 287             + siftFile;
 288     File siftsDownloadDir = new File(
 289             SiftsSettings.getSiftDownloadDirectory());
 290     if (!siftsDownloadDir.exists())
 291     {
 292       siftsDownloadDir.mkdirs();
 293     }
 294     try
 295     {
 296       // System.out.println(">> Download ftp url : " + siftsFileFTPURL);
 297       URL url = new URL(siftsFileFTPURL);
 298       URLConnection conn = url.openConnection();
 299       InputStream inputStream = conn.getInputStream();
 300       FileOutputStream outputStream = new FileOutputStream(
 301               downloadedSiftsFile);
 302       byte[] buffer = new byte[BUFFER_SIZE];
 303       int bytesRead = -1;
 304       while ((bytesRead = inputStream.read(buffer)) != -1)
 305       {
 306         outputStream.write(buffer, 0, bytesRead);
 307       }
 308       outputStream.close();
 309       inputStream.close();
 310       // System.out.println(">>> File downloaded : " + downloadedSiftsFile);
 311     } catch (IOException ex)
 312     {
 313       throw new SiftsException(ex.getMessage());
 314     }
 315     return new File(downloadedSiftsFile);
 316   }
 317
 318   /**
 319    * Delete the SIFTs file for the given PDB Id in the local SIFTs download
 320    * directory
 321    *
 322    * @param pdbId
 323    * @return true if the file was deleted or doesn't exist
 324    */
 325   public static boolean deleteSiftsFileByPDBId(String pdbId)
 326   {
 327     File siftsFile = new File(SiftsSettings.getSiftDownloadDirectory()
 328             + pdbId.toLowerCase() + ".xml.gz");
 329     if (siftsFile.exists())
 330     {
 331       return siftsFile.delete();
 332     }
 333     return true;
 334   }
 335
 336   /**
 337    * Get a valid SIFTs DBRef for the given sequence current SIFTs entry
 338    *
 339    * @param seq
 340    *          - the target sequence for the operation
 341    * @return a valid DBRefEntry that is SIFTs compatible
 342    * @throws Exception
 343    *           if no valid source DBRefEntry was found for the given sequences
 344    */
 345   public DBRefEntryI getValidSourceDBRef(SequenceI seq)
 346           throws SiftsException
 347   {
 348     DBRefEntryI sourceDBRef = null;
 349     sourceDBRef = seq.getSourceDBRef();
 350     if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
 351     {
 352       return sourceDBRef;
 353     }
 354     else
 355     {
 356       DBRefEntry[] dbRefs = seq.getDBRefs();
 357       if (dbRefs == null || dbRefs.length < 1)
 358       {
 359         throw new SiftsException("Could not get source DB Ref");
 360       }
 361
 362       for (DBRefEntryI dbRef : dbRefs)
 363       {
 364         if (dbRef == null || dbRef.getAccessionId() == null
 365                 || dbRef.getSource() == null)
 366         {
 367           continue;
 368         }
 369         if (isFoundInSiftsEntry(dbRef.getAccessionId())
 370                 && (dbRef.getSource().equalsIgnoreCase(DBRefSource.UNIPROT) || dbRef
 371                         .getSource().equalsIgnoreCase(DBRefSource.PDB)))
 372         {
 373           return dbRef;
 374         }
 375       }
 376     }
 377     if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
 378     {
 379       return sourceDBRef;
 380     }
 381     throw new SiftsException("Could not get source DB Ref");
 382   }
 383
 384   /**
 385    * Check that the DBRef Entry is properly populated and is available in this
 386    * SiftClient instance
 387    *
 388    * @param entry
 389    *          - DBRefEntry to validate
 390    * @return true validation is successful otherwise false is returned.
 391    */
 392   private boolean isValidDBRefEntry(DBRefEntryI entry)
 393   {
 394     return entry != null && entry.getAccessionId() != null
 395             && isFoundInSiftsEntry(entry.getAccessionId());
 396   }
 397
 398   @Override
 399   public HashSet<String> getAllMappingAccession()
 400   {
 401     HashSet<String> accessions = new HashSet<String>();
 402     List<Entity> entities = siftsEntry.getEntity();
 403     for (Entity entity : entities)
 404     {
 405       List<Segment> segments = entity.getSegment();
 406       for (Segment segment : segments)
 407       {
 408         List<MapRegion> mapRegions = segment.getListMapRegion()
 409                 .getMapRegion();
 410         for (MapRegion mapRegion : mapRegions)
 411         {
 412           accessions.add(mapRegion.getDb().getDbAccessionId());
 413         }
 414       }
 415     }
 416     return accessions;
 417   }
 418
 419   @Override
 420   public StructureMapping getSiftsStructureMapping(SequenceI seq,
 421           String pdbFile, String chain) throws SiftsException
 422   {
 423     structId = (chain == null) ? pdbId : pdbId + "|" + chain;
 424     System.out.println("Getting mapping for: " + pdbId + "|" + chain
 425             + " : seq- " + seq.getName());
 426
 427     final StringBuilder mappingDetails = new StringBuilder(128);
 428     PrintStream ps = new PrintStream(System.out)
 429     {
 430       @Override
 431       public void print(String x)
 432       {
 433         mappingDetails.append(x);
 434       }
 435
 436       @Override
 437       public void println()
 438       {
 439         mappingDetails.append(NEWLINE);
 440       }
 441     };
 442     HashMap<Integer, int[]> mapping = getGreedyMapping(chain, seq, ps);
 443
 444     String mappingOutput = mappingDetails.toString();
 445     StructureMapping siftsMapping = new StructureMapping(seq, pdbFile,
 446             pdbId, chain, mapping, mappingOutput);
 447     return siftsMapping;
 448   }
 449
 450   @Override
 451   public HashMap<Integer, int[]> getGreedyMapping(String entityId,
 452           SequenceI seq, java.io.PrintStream os) throws SiftsException
 453   {
 454     ArrayList<Integer> omitNonObserved = new ArrayList<Integer>();
 455     int nonObservedShiftIndex = 0;
 456     System.out.println("Generating mappings for : " + entityId);
 457     Entity entity = null;
 458     entity = getEntityById(entityId);
 459     String originalSeq = AlignSeq.extractGaps(
 460             jalview.util.Comparison.GapChars, seq.getSequenceAsString());
 461     HashMap<Integer, int[]> mapping = new HashMap<Integer, int[]>();
 462     DBRefEntryI sourceDBRef = seq.getSourceDBRef();
 463     if (sourceDBRef == null)
 464     {
 465       sourceDBRef = getValidSourceDBRef(seq);
 466       // TODO ensure sequence start/end is in the same coordinate system and
 467       // consistent with the choosen sourceDBRef
 468     }
 469
 470     // set sequence coordinate system - default value is UniProt
 471     if (sourceDBRef.getSource().equalsIgnoreCase(DBRefSource.PDB))
 472     {
 473       seqCoordSys = CoordinateSys.PDB;
 474     }
 475
 476     HashSet<String> dbRefAccessionIdsString = new HashSet<String>();
 477     for (DBRefEntry dbref : seq.getDBRefs())
 478     {
 479       dbRefAccessionIdsString.add(dbref.getAccessionId().toLowerCase());
 480     }
 481     dbRefAccessionIdsString.add(sourceDBRef.getAccessionId().toLowerCase());
 482
 483     curDBRefAccessionIdsString = dbRefAccessionIdsString;
 484     curSourceDBRef = sourceDBRef.getAccessionId();
 485
 486     TreeMap<Integer, String> resNumMap = new TreeMap<Integer, String>();
 487     List<Segment> segments = entity.getSegment();
 488     for (Segment segment : segments)
 489     {
 490       segStartEnd = segment.getStart() + " - " + segment.getEnd();
 491       System.out.println("Mappging segments : " + segment.getSegId() + "\\"
 492               + segStartEnd);
 493       List<Residue> residues = segment.getListResidue().getResidue();
 494       for (Residue residue : residues)
 495       {
 496         int currSeqIndex = UNASSIGNED;
 497         List<CrossRefDb> cRefDbs = residue.getCrossRefDb();
 498         CrossRefDb pdbRefDb = null;
 499         for (CrossRefDb cRefDb : cRefDbs)
 500         {
 501           if (cRefDb.getDbSource().equalsIgnoreCase(DBRefSource.PDB))
 502           {
 503             pdbRefDb = cRefDb;
 504           }
 505           if (cRefDb.getDbCoordSys()
 506                   .equalsIgnoreCase(seqCoordSys.getName())
 507                   && isAccessionMatched(cRefDb.getDbAccessionId()))
 508           {
 509             String resNumIndexString = cRefDb.getDbResNum()
 510                     .equalsIgnoreCase("None") ? String.valueOf(UNASSIGNED)
 511                     : cRefDb.getDbResNum();
 512             try
 513             {
 514               currSeqIndex = Integer.valueOf(resNumIndexString);
 515             } catch (NumberFormatException nfe)
 516             {
 517               currSeqIndex = Integer.valueOf(resNumIndexString
 518                       .split("[a-zA-Z]")[0]);
 519             }
 520             if (pdbRefDb != null)
 521             {
 522               break;// exit loop if pdb and uniprot are already found
 523             }
 524           }
 525         }
 526         if (currSeqIndex == UNASSIGNED)
 527         {
 528           continue;
 529         }
 530         if (currSeqIndex > seq.getStart() && currSeqIndex <= seq.getEnd())
 531         {
 532           int resNum;
 533           try
 534           {
 535             resNum = (pdbRefDb == null) ? Integer.valueOf(residue
 536                     .getDbResNum()) : Integer.valueOf(pdbRefDb
 537                     .getDbResNum());
 538           } catch (NumberFormatException nfe)
 539           {
 540             resNum = (pdbRefDb == null) ? Integer.valueOf(residue
 541                     .getDbResNum()) : Integer.valueOf(pdbRefDb
 542                     .getDbResNum().split("[a-zA-Z]")[0]);
 543           }
 544
 545           if (isResidueObserved(residue)
 546                   || seqCoordSys == CoordinateSys.UNIPROT)
 547           {
 548             char resCharCode = ResidueProperties
 549                     .getSingleCharacterCode(residue.getDbResName());
 550             resNumMap.put(currSeqIndex, String.valueOf(resCharCode));
 551           }
 552           else
 553           {
 554             omitNonObserved.add(currSeqIndex);
 555             ++nonObservedShiftIndex;
 556           }
 557           mapping.put(currSeqIndex - nonObservedShiftIndex, new int[] {
 558               Integer.valueOf(resNum), UNASSIGNED });
 559         }
 560       }
 561     }
 562     try
 563     {
 564       populateAtomPositions(entityId, mapping);
 565     } catch (Exception e)
 566     {
 567       e.printStackTrace();
 568     }
 569     if (seqCoordSys == CoordinateSys.UNIPROT)
 570     {
 571       padWithGaps(resNumMap, omitNonObserved);
 572     }
 573     int seqStart = UNASSIGNED;
 574     int seqEnd = UNASSIGNED;
 575     int pdbStart = UNASSIGNED;
 576     int pdbEnd = UNASSIGNED;
 577
 578     Integer[] keys = mapping.keySet().toArray(new Integer[0]);
 579     Arrays.sort(keys);
 580     seqStart = keys[0];
 581     seqEnd = keys[keys.length - 1];
 582
 583     String matchedSeq = originalSeq;
 584     if (seqStart != UNASSIGNED)
 585     {
 586       pdbStart = mapping.get(seqStart)[PDB_RES_POS];
 587       pdbEnd = mapping.get(seqEnd)[PDB_RES_POS];
 588       int orignalSeqStart = seq.getStart();
 589       if (orignalSeqStart >= 1)
 590       {
 591         int subSeqStart = seqStart - orignalSeqStart;
 592         int subSeqEnd = seqEnd - (orignalSeqStart - 1);
 593         subSeqEnd = originalSeq.length() < subSeqEnd ? originalSeq.length()
 594                 : subSeqEnd;
 595         matchedSeq = originalSeq.substring(subSeqStart, subSeqEnd);
 596       }
 597     }
 598
 599     StringBuilder targetStrucSeqs = new StringBuilder();
 600     for (String res : resNumMap.values())
 601     {
 602       targetStrucSeqs.append(res);
 603     }
 604
 605     if (os != null)
 606     {
 607       MappingOutputPojo mop = new MappingOutputPojo();
 608       mop.setSeqStart(seqStart);
 609       mop.setSeqEnd(seqEnd);
 610       mop.setSeqName(seq.getName());
 611       mop.setSeqResidue(matchedSeq);
 612
 613       mop.setStrStart(pdbStart);
 614       mop.setStrEnd(pdbEnd);
 615       mop.setStrName(structId);
 616       mop.setStrResidue(targetStrucSeqs.toString());
 617
 618       mop.setType("pep");
 619       os.print(getMappingOutput(mop).toString());
 620     }
 621     return mapping;
 622   }
 623
 624   /**
 625    * Checks if the residue instance is marked 'Not_observed' or not
 626    *
 627    * @param residue
 628    * @return
 629    */
 630   private boolean isResidueObserved(Residue residue)
 631   {
 632     String annotation = getResidueAnnotaiton(residue,
 633             ResidueDetailType.ANNOTATION);
 634     if (annotation == null)
 635     {
 636       return true;
 637     }
 638     if (!annotation.equalsIgnoreCase(NOT_FOUND)
 639             && annotation.equalsIgnoreCase(NOT_OBSERVED))
 640     {
 641       return false;
 642     }
 643     return true;
 644   }
 645
 646   /**
 647    * Get annotation String for a given residue and annotation type
 648    *
 649    * @param residue
 650    * @param type
 651    * @return
 652    */
 653   private String getResidueAnnotaiton(Residue residue,
 654           ResidueDetailType type)
 655   {
 656     List<ResidueDetail> resDetails = residue.getResidueDetail();
 657     for (ResidueDetail resDetail : resDetails)
 658     {
 659       if (resDetail.getProperty().equalsIgnoreCase(type.getCode()))
 660       {
 661         return resDetail.getContent();
 662       }
 663     }
 664     return NOT_FOUND;
 665   }
 666
 667   @Override
 668   public boolean isAccessionMatched(String accession)
 669   {
 670     boolean isStrictMatch = true;
 671     return isStrictMatch ? curSourceDBRef.equalsIgnoreCase(accession)
 672             : curDBRefAccessionIdsString.contains(accession.toLowerCase());
 673   }
 674
 675   private boolean isFoundInSiftsEntry(String accessionId)
 676   {
 677     return accessionId != null
 678             && getAllMappingAccession().contains(accessionId);
 679   }
 680
 681   /**
 682    * Pad omitted residue positions in PDB sequence with gaps
 683    *
 684    * @param resNumMap
 685    */
 686   void padWithGaps(TreeMap<Integer, String> resNumMap,
 687           ArrayList<Integer> omitNonObserved)
 688   {
 689     if (resNumMap == null || resNumMap.isEmpty())
 690     {
 691       return;
 692     }
 693     Integer[] keys = resNumMap.keySet().toArray(new Integer[0]);
 694     Arrays.sort(keys);
 695     int firstIndex = keys[0];
 696     int lastIndex = keys[keys.length - 1];
 697     System.out.println("Min value " + firstIndex);
 698     System.out.println("Max value " + lastIndex);
 699     for (int x = firstIndex; x <= lastIndex; x++)
 700     {
 701       if (!resNumMap.containsKey(x) && !omitNonObserved.contains(x))
 702       {
 703         resNumMap.put(x, "-");
 704       }
 705     }
 706   }
 707
 708   /**
 709    *
 710    * @param chainId
 711    *          Target chain to populate mapping of its atom positions.
 712    * @param mapping
 713    *          Two dimension array of residue index versus atom position
 714    * @throws IllegalArgumentException
 715    *           Thrown if chainId or mapping is null
 716    */
 717   void populateAtomPositions(String chainId, HashMap<Integer, int[]> mapping)
 718           throws IllegalArgumentException
 719   {
 720     PDBChain chain = pdb.findChain(chainId);
 721     if (chain == null || mapping == null)
 722     {
 723       throw new IllegalArgumentException(
 724               "Chain id or mapping must not be null.");
 725     }
 726     for (int[] map : mapping.values())
 727     {
 728       if (map[PDB_RES_POS] != UNASSIGNED)
 729       {
 730         map[PDB_ATOM_POS] = getAtomIndex(map[PDB_RES_POS], chain.atoms);
 731       }
 732     }
 733   }
 734
 735   /**
 736    *
 737    * @param residueIndex
 738    *          The residue index used for the search
 739    * @param atoms
 740    *          A collection of Atom to search
 741    * @return atom position for the given residue index
 742    */
 743   int getAtomIndex(int residueIndex, Collection<Atom> atoms)
 744   {
 745     if (atoms == null)
 746     {
 747       throw new IllegalArgumentException(
 748               "atoms collection must not be null!");
 749     }
 750     for (Atom atom : atoms)
 751     {
 752       if (atom.resNumber == residueIndex)
 753       {
 754         return atom.atomIndex;
 755       }
 756     }
 757     return UNASSIGNED;
 758   }
 759
 760   @Override
 761   public Entity getEntityById(String id) throws SiftsException
 762   {
 763     List<Entity> entities = siftsEntry.getEntity();
 764     for (Entity entity : entities)
 765     {
 766       if (!entity.getEntityId().equalsIgnoreCase(id))
 767       {
 768         continue;
 769       }
 770       return entity;
 771     }
 772     Entity entity = getEntityByMostOptimalMatchedId(id);
 773     if (entity != null)
 774     {
 775       return entity;
 776     }
 777     throw new SiftsException("Entity " + id + " not found");
 778   }
 779
 780   /**
 781    * This method was added because EntityId is NOT always equal to ChainId.
 782    * Hence, it provides the logic to greedily detect the "true" Entity for a
 783    * given chainId where discrepancies exist.
 784    *
 785    * @param chainId
 786    * @return
 787    */
 788   public Entity getEntityByMostOptimalMatchedId(String chainId)
 789   {
 790     System.out
 791             .println("--------------> advanced greedy entityId matching block entered..");
 792     List<Entity> entities = siftsEntry.getEntity();
 793     SiftsEntitySortPojo[] sPojo = new SiftsEntitySortPojo[entities.size()];
 794     int count = 0;
 795     for (Entity entity : entities)
 796     {
 797       sPojo[count] = new SiftsEntitySortPojo();
 798       sPojo[count].entityId = entity.getEntityId();
 799
 800       List<Segment> segments = entity.getSegment();
 801       for (Segment segment : segments)
 802       {
 803         List<Residue> residues = segment.getListResidue().getResidue();
 804         for (Residue residue : residues)
 805         {
 806           List<CrossRefDb> cRefDbs = residue.getCrossRefDb();
 807           for (CrossRefDb cRefDb : cRefDbs)
 808           {
 809             if (!cRefDb.getDbSource().equalsIgnoreCase("PDB"))
 810             {
 811               continue;
 812             }
 813             ++sPojo[count].resCount;
 814             if (cRefDb.getDbChainId().equalsIgnoreCase(chainId))
 815             {
 816               ++sPojo[count].chainIdFreq;
 817             }
 818           }
 819         }
 820       }
 821       sPojo[count].pid = 100 * (sPojo[count].chainIdFreq / sPojo[count].resCount);
 822       ++count;
 823     }
 824     Arrays.sort(sPojo, Collections.reverseOrder());
 825     System.out.println("highest matched entity : " + sPojo[0].entityId);
 826     System.out.println("highest matched pid : " + sPojo[0].pid);
 827
 828     if (sPojo[0].entityId != null)
 829     {
 830       for (Entity entity : entities)
 831       {
 832         if (!entity.getEntityId().equalsIgnoreCase(sPojo[0].entityId))
 833         {
 834           continue;
 835         }
 836         return entity;
 837       }
 838     }
 839     return null;
 840   }
 841
 842   public class SiftsEntitySortPojo implements
 843           Comparable<SiftsEntitySortPojo>
 844   {
 845     public String entityId;
 846
 847     public int chainIdFreq;
 848
 849     public int pid;
 850
 851     public int resCount;
 852
 853     @Override
 854     public int compareTo(SiftsEntitySortPojo o)
 855     {
 856       return this.pid - o.pid;
 857     }
 858   }
 859
 860   @Override
 861   public String[] getEntryDBs()
 862   {
 863     System.out.println("\nListing DB entries...");
 864     List<String> availDbs = new ArrayList<String>();
 865     List<Db> dbs = siftsEntry.getListDB().getDb();
 866     for (Db db : dbs)
 867     {
 868       availDbs.add(db.getDbSource());
 869       System.out.println(db.getDbSource() + " | " + db.getDbCoordSys());
 870     }
 871     return availDbs.toArray(new String[0]);
 872   }
 873
 874   @Override
 875   public StringBuffer getMappingOutput(MappingOutputPojo mp)
 876           throws SiftsException
 877   {
 878     String seqRes = mp.getSeqResidue();
 879     String seqName = mp.getSeqName();
 880     int sStart = mp.getSeqStart();
 881     int sEnd = mp.getSeqEnd();
 882
 883     String strRes = mp.getStrResidue();
 884     String strName = mp.getStrName();
 885     int pdbStart = mp.getStrStart();
 886     int pdbEnd = mp.getStrEnd();
 887
 888     String type = mp.getType();
 889
 890     int maxid = (seqName.length() >= strName.length()) ? seqName.length()
 891             : strName.length();
 892     int len = 72 - maxid - 1;
 893
 894     int nochunks = ((seqRes.length()) / len)
 895             + ((seqRes.length()) % len > 0 ? 1 : 0);
 896     // output mappings
 897     StringBuffer output = new StringBuffer();
 898     output.append(NEWLINE);
 899     output.append("Sequence ⟷ Structure mapping details").append(NEWLINE);
 900     output.append("Method: SIFTS");
 901     output.append(NEWLINE).append(NEWLINE);
 902
 903     output.append(new Format("%" + maxid + "s").form(seqName));
 904     output.append(" :  ");
 905     output.append(String.valueOf(sStart));
 906     output.append(" - ");
 907     output.append(String.valueOf(sEnd));
 908     output.append(" Maps to ");
 909     output.append(NEWLINE);
 910     output.append(new Format("%" + maxid + "s").form(structId));
 911     output.append(" :  ");
 912     output.append(String.valueOf(pdbStart));
 913     output.append(" - ");
 914     output.append(String.valueOf(pdbEnd));
 915     output.append(NEWLINE).append(NEWLINE);
 916
 917     int matchedSeqCount = 0;
 918     for (int j = 0; j < nochunks; j++)
 919     {
 920       // Print the first aligned sequence
 921       output.append(new Format("%" + (maxid) + "s").form(seqName)).append(
 922               " ");
 923
 924       for (int i = 0; i < len; i++)
 925       {
 926         if ((i + (j * len)) < seqRes.length())
 927         {
 928           output.append(seqRes.charAt(i + (j * len)));
 929         }
 930       }
 931
 932       output.append(NEWLINE);
 933       output.append(new Format("%" + (maxid) + "s").form(" ")).append(" ");
 934
 935       // Print out the matching chars
 936       for (int i = 0; i < len; i++)
 937       {
 938         try
 939         {
 940           if ((i + (j * len)) < seqRes.length())
 941           {
 942             if (seqRes.charAt(i + (j * len)) == strRes
 943                     .charAt(i + (j * len))
 944                     && !jalview.util.Comparison.isGap(seqRes.charAt(i
 945                             + (j * len))))
 946             {
 947               matchedSeqCount++;
 948               output.append("|");
 949             }
 950             else if (type.equals("pep"))
 951             {
 952               if (ResidueProperties.getPAM250(seqRes.charAt(i + (j * len)),
 953                       strRes.charAt(i + (j * len))) > 0)
 954               {
 955                 output.append(".");
 956               }
 957               else
 958               {
 959                 output.append(" ");
 960               }
 961             }
 962             else
 963             {
 964               output.append(" ");
 965             }
 966           }
 967         } catch (IndexOutOfBoundsException e)
 968         {
 969           continue;
 970         }
 971       }
 972       // Now print the second aligned sequence
 973       output = output.append(NEWLINE);
 974       output = output.append(new Format("%" + (maxid) + "s").form(strName))
 975               .append(" ");
 976       for (int i = 0; i < len; i++)
 977       {
 978         if ((i + (j * len)) < strRes.length())
 979         {
 980           output.append(strRes.charAt(i + (j * len)));
 981         }
 982       }
 983       output.append(NEWLINE).append(NEWLINE);
 984     }
 985     float pid = (float) matchedSeqCount / seqRes.length() * 100;
 986     if (pid < 2)
 987     {
 988       throw new SiftsException("Low PID detected for SIFTs mapping...");
 989     }
 990     output.append("Length of alignment = " + seqRes.length()).append(
 991             NEWLINE);
 992     output.append(new Format("Percentage ID = %2.2f").form(pid));
 993     output.append(NEWLINE);
 994     return output;
 995   }
 996
 997   @Override
 998   public int getEntityCount()
 999   {
1000     return siftsEntry.getEntity().size();
1001   }
1002
1003   @Override
1004   public String getDbAccessionId()
1005   {
1006     return siftsEntry.getDbAccessionId();
1007   }
1008
1009   @Override
1010   public String getDbCoordSys()
1011   {
1012     return siftsEntry.getDbCoordSys();
1013   }
1014
1015   @Override
1016   public String getDbEvidence()
1017   {
1018     return siftsEntry.getDbEvidence();
1019   }
1020
1021   @Override
1022   public String getDbSource()
1023   {
1024     return siftsEntry.getDbSource();
1025   }
1026
1027   @Override
1028   public String getDbVersion()
1029   {
1030     return siftsEntry.getDbVersion();
1031   }
1032
1033 }