--- /dev/null
+/*
+ * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
+ * Copyright (C) $$Year-Rel$$ The Jalview Authors
+ *
+ * This file is part of Jalview.
+ *
+ * Jalview is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * as published by the Free Software Foundation, either version 3
+ * of the License, or (at your option) any later version.
+ *
+ * Jalview is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty
+ * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+ * PURPOSE. See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Jalview. If not, see <http://www.gnu.org/licenses/>.
+ * The Jalview Authors are detailed in the 'AUTHORS' file.
+ */
+package jalview.ws.sifts;
+
+import jalview.analysis.AlignSeq;
+import jalview.api.DBRefEntryI;
+import jalview.api.SiftsClientI;
+import jalview.datamodel.DBRefEntry;
+import jalview.datamodel.DBRefSource;
+import jalview.datamodel.SequenceI;
+import jalview.schemes.ResidueProperties;
+import jalview.structure.StructureMapping;
+import jalview.util.Format;
+import jalview.xml.binding.sifts.Entry;
+import jalview.xml.binding.sifts.Entry.Entity;
+import jalview.xml.binding.sifts.Entry.Entity.Segment;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListMapRegion.MapRegion;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue;
+import jalview.xml.binding.sifts.Entry.Entity.Segment.ListResidue.Residue.CrossRefDb;
+import jalview.xml.binding.sifts.Entry.ListDB.Db;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintStream;
+import java.net.URL;
+import java.net.URLConnection;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.List;
+import java.util.TreeMap;
+import java.util.zip.GZIPInputStream;
+
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.Unmarshaller;
+import javax.xml.stream.FactoryConfigurationError;
+import javax.xml.stream.XMLInputFactory;
+import javax.xml.stream.XMLStreamException;
+import javax.xml.stream.XMLStreamReader;
+
+import MCview.Atom;
+import MCview.PDBChain;
+import MCview.PDBfile;
+
+public class SiftsClient implements SiftsClientI
+{
+ private Entry siftsEntry;
+
+ private PDBfile pdb;
+
+ private String pdbId;
+
+ private String structId;
+
+ private String segStartEnd;
+
+ private CoordinateSys seqCoordSys = CoordinateSys.UNIPROT;
+
+ private static final int BUFFER_SIZE = 4096;
+
+ public static final int UNASSIGNED = -1;
+
+ private static final int PDB_RES_POS = 0;
+
+ private static final int PDB_ATOM_POS = 1;
+
+ private static final String SIFTS_FTP_BASE_URL = "ftp://ftp.ebi.ac.uk/pub/databases/msd/sifts/xml/";
+
+ public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System
+ .getProperty("user.home")
+ + File.separatorChar
+ + ".sifts_downloads" + File.separatorChar;
+
+ public static final String SIFTS_DOWNLOAD_DIR = jalview.bin.Cache
+ .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR);
+
+ private final static String NEWLINE = System.lineSeparator();
+
+ private String curSourceDBRef;
+
+ private HashSet<String> curDBRefAccessionIdsString;
+
+ public enum CoordinateSys
+ {
+ UNIPROT("UniProt"), PDB("PDBresnum"), PDBe("PDBe");
+ private String name;
+
+ private CoordinateSys(String name)
+ {
+ this.name = name;
+ }
+
+ public String getName()
+ {
+ return name;
+ }
+ };
+
+ /**
+ * Fetch SIFTs file for the given PDB Id and construct an instance of
+ * SiftsClient
+ *
+ * @param pdbId
+ * @throws SiftsException
+ */
+ public SiftsClient(PDBfile pdb) throws SiftsException
+ {
+ this.pdb = pdb;
+ this.pdbId = pdb.id;
+ File siftsFile = getSiftsFile(pdbId);
+ siftsEntry = parseSIFTs(siftsFile);
+ }
+
+ /**
+ * Construct an instance of SiftsClient using the supplied SIFTs file - the
+ * SIFTs file should correspond to the given PDB Id
+ *
+ * @param pdbId
+ * @param siftsFile
+ * @throws SiftsException
+ * @throws Exception
+ */
+ public SiftsClient(PDBfile pdb, File siftsFile) throws SiftsException
+ {
+ this.pdb = pdb;
+ this.pdbId = pdb.id;
+ siftsEntry = parseSIFTs(siftsFile);
+ }
+
+ /**
+ * Parse the given SIFTs File and return a JAXB POJO of parsed data
+ *
+ * @param siftFile
+ * - the GZipped SIFTs XML file to parse
+ * @return
+ * @throws Exception
+ * if a problem occurs while parsing the SIFTs XML
+ */
+ private Entry parseSIFTs(File siftFile) throws SiftsException
+ {
+ try
+ {
+ System.out.println("File : " + siftFile.getAbsolutePath());
+ JAXBContext jc = JAXBContext.newInstance("jalview.xml.binding.sifts");
+ InputStream in = new FileInputStream(siftFile);
+ GZIPInputStream gzis = new GZIPInputStream(in);
+ XMLStreamReader streamReader = XMLInputFactory.newInstance()
+ .createXMLStreamReader(gzis);
+ Unmarshaller um = jc.createUnmarshaller();
+ return (Entry) um.unmarshal(streamReader);
+ } catch (JAXBException e)
+ {
+ e.printStackTrace();
+ } catch (FileNotFoundException e)
+ {
+ e.printStackTrace();
+ } catch (XMLStreamException e)
+ {
+ e.printStackTrace();
+ } catch (FactoryConfigurationError e)
+ {
+ e.printStackTrace();
+ } catch (IOException e)
+ {
+ e.printStackTrace();
+ }
+ throw new SiftsException("Error parsing siftFile");
+ }
+
+ /**
+ * Get a SIFTs XML file for a given PDB Id
+ *
+ * @param pdbId
+ * @return SIFTs XML file
+ */
+ public static File getSiftsFile(String pdbId)
+ {
+ File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ + ".xml.gz");
+ if (siftsFile.exists())
+ {
+ // TODO it may be worth performing an age check to determine if a
+ // new SIFTs file should be re-downloaded as SIFTs entries are usually
+ // updated weekly
+ System.out.println(">>> SIFTS File already downloaded for " + pdbId);
+ return siftsFile;
+ }
+ siftsFile = downloadSiftsFile(pdbId.toLowerCase());
+ return siftsFile;
+ }
+
+ /**
+ * Download a SIFTs XML file for a given PDB Id
+ *
+ * @param pdbId
+ * @return downloaded SIFTs XML file
+ */
+ public static File downloadSiftsFile(String pdbId)
+ {
+ String siftFile = pdbId + ".xml.gz";
+ String siftsFileFTPURL = SIFTS_FTP_BASE_URL + siftFile;
+ String downloadedSiftsFile = SIFTS_DOWNLOAD_DIR + siftFile;
+ File siftsDownloadDir = new File(SIFTS_DOWNLOAD_DIR);
+ if (!siftsDownloadDir.exists())
+ {
+ siftsDownloadDir.mkdirs();
+ }
+ try
+ {
+ System.out.println(">> Download ftp url : " + siftsFileFTPURL);
+ URL url = new URL(siftsFileFTPURL);
+ URLConnection conn = url.openConnection();
+ InputStream inputStream = conn.getInputStream();
+ FileOutputStream outputStream = new FileOutputStream(
+ downloadedSiftsFile);
+ byte[] buffer = new byte[BUFFER_SIZE];
+ int bytesRead = -1;
+ while ((bytesRead = inputStream.read(buffer)) != -1)
+ {
+ outputStream.write(buffer, 0, bytesRead);
+ }
+ outputStream.close();
+ inputStream.close();
+ System.out.println(">>> File downloaded : " + downloadedSiftsFile);
+ } catch (IOException ex)
+ {
+ ex.printStackTrace();
+ }
+ return new File(downloadedSiftsFile);
+ }
+
+ /**
+ * Delete the SIFTs file for the given PDB Id in the local SIFTs download
+ * directory
+ *
+ * @param pdbId
+ * @return true if the file was deleted or doesn't exist
+ */
+ public static boolean deleteSiftsFileByPDBId(String pdbId)
+ {
+ File siftsFile = new File(SIFTS_DOWNLOAD_DIR + pdbId.toLowerCase()
+ + ".xml.gz");
+ if (siftsFile.exists())
+ {
+ return siftsFile.delete();
+ }
+ return true;
+ }
+
+
+ /**
+ * Get a valid SIFTs DBRef for the given sequence current SIFTs entry
+ *
+ * @param seq
+ * - the target sequence for the operation
+ * @return a valid DBRefEntry that is SIFTs compatible
+ * @throws Exception
+ * if no valid source DBRefEntry was found for the given sequences
+ */
+ public DBRefEntryI getValidSourceDBRef(SequenceI seq)
+ throws SiftsException
+ {
+ DBRefEntryI sourceDBRef = null;
+ sourceDBRef = seq.getSourceDBRef();
+ if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
+ {
+ return sourceDBRef;
+ }
+ else
+ {
+ DBRefEntry[] dbRefs = seq.getDBRefs();
+ if (dbRefs == null || dbRefs.length < 1)
+ {
+ final SequenceI[] seqs = new SequenceI[] { seq };
+ new jalview.ws.DBRefFetcher(seqs, null, null, null, false)
+ .fetchDBRefs(true);
+ dbRefs = seq.getDBRefs();
+ }
+
+ if (dbRefs == null || dbRefs.length < 1)
+ {
+ throw new SiftsException("Could not get source DB Ref");
+ }
+
+ for (DBRefEntryI dbRef : dbRefs)
+ {
+ if (dbRef == null || dbRef.getAccessionId() == null
+ || dbRef.getSource() == null)
+ {
+ continue;
+ }
+ if (isFoundInSiftsEntry(dbRef.getAccessionId())
+ && (dbRef.getSource().equalsIgnoreCase(DBRefSource.UNIPROT) || dbRef
+ .getSource().equalsIgnoreCase(DBRefSource.PDB)))
+ {
+ return dbRef;
+ }
+ }
+ }
+ if (sourceDBRef != null && isValidDBRefEntry(sourceDBRef))
+ {
+ return sourceDBRef;
+ }
+ throw new SiftsException("Could not get source DB Ref");
+ }
+
+
+ /**
+ * Check that the DBRef Entry is properly populated and is available in the
+ * instantiated SIFTs Entry
+ *
+ * @param entry
+ * - DBRefEntry to validate
+ * @return true validation is successful otherwise false is returned.
+ */
+ private boolean isValidDBRefEntry(DBRefEntryI entry)
+ {
+ return entry != null && entry.getAccessionId() != null
+ && isFoundInSiftsEntry(entry.getAccessionId());
+ }
+
+ @Override
+ public HashSet<String> getAllMappingAccession()
+ {
+ HashSet<String> accessions = new HashSet<String>();
+ List<Entity> entities = siftsEntry.getEntity();
+ for (Entity entity : entities)
+ {
+ List<Segment> segments = entity.getSegment();
+ for (Segment segment : segments)
+ {
+ List<MapRegion> mapRegions = segment.getListMapRegion()
+ .getMapRegion();
+ for (MapRegion mapRegion : mapRegions)
+ {
+ accessions.add(mapRegion.getDb().getDbAccessionId());
+ }
+ }
+ }
+ return accessions;
+ }
+
+ @Override
+ public StructureMapping getSiftsStructureMapping(SequenceI seq,
+ String pdbFile, String chain) throws SiftsException
+ {
+ structId = (chain == null) ? pdbId : pdbId + "|" + chain;
+ System.out.println("Getting mapping for: " + pdbId + "|" + chain
+ + " : seq- " + seq.getName());
+
+ final StringBuilder mappingDetails = new StringBuilder(128);
+ PrintStream ps = new PrintStream(System.out)
+ {
+ @Override
+ public void print(String x)
+ {
+ mappingDetails.append(x);
+ }
+
+ @Override
+ public void println()
+ {
+ mappingDetails.append(NEWLINE);
+ }
+ };
+ int[][] mapping = getGreedyMapping(chain, seq, ps);
+
+ String mappingOutput = mappingDetails.toString();
+ StructureMapping siftsMapping = new StructureMapping(seq, pdbFile,
+ pdbId, chain, mapping,
+ mappingOutput);
+ return siftsMapping;
+ }
+
+ @Override
+ public int[][] getGreedyMapping(String entityId, SequenceI seq,
+ java.io.PrintStream os)
+ throws SiftsException
+ {
+
+ System.out.println("Generating mappings for : " + entityId);
+ Entity entity = null;
+ entity = getEntityById(entityId);
+ String originalSeq = AlignSeq.extractGaps(
+ jalview.util.Comparison.GapChars,
+ seq.getSequenceAsString());
+ int mapping[][] = new int[originalSeq.length() + seq.getStart()][2];
+ DBRefEntryI sourceDBRef = seq.getSourceDBRef();
+ if (sourceDBRef == null)
+ {
+ sourceDBRef = getValidSourceDBRef(seq);
+ // TODO ensure sequence start/end is in the same coordinate system and
+ // consistent with the choosen sourceDBRef
+ }
+
+ // set sequence coordinate system - default value is UniProt
+ if (sourceDBRef.getSource().equalsIgnoreCase(DBRefSource.PDB))
+ {
+ seqCoordSys = CoordinateSys.PDB;
+ }
+
+ HashSet<String> dbRefAccessionIdsString = new HashSet<String>();
+ for (DBRefEntry dbref : seq.getDBRefs())
+ {
+ dbRefAccessionIdsString.add(dbref.getAccessionId().toLowerCase());
+ }
+ dbRefAccessionIdsString.add(sourceDBRef.getAccessionId().toLowerCase());
+
+ curDBRefAccessionIdsString = dbRefAccessionIdsString;
+ curSourceDBRef = sourceDBRef.getAccessionId();
+
+ // initialise all mapping positions to unassigned
+ for (int residuePos[] : mapping)
+ {
+ residuePos[PDB_RES_POS] = UNASSIGNED;
+ residuePos[PDB_ATOM_POS] = UNASSIGNED;
+ }
+
+ TreeMap<Integer, String> resNumMap = new TreeMap<Integer, String>();
+ List<Segment> segments = entity.getSegment();
+ for (Segment segment : segments)
+ {
+ segStartEnd = segment.getStart() + " - " + segment.getEnd();
+ System.out.println("Mappging segments : " + segment.getSegId() + "\\"
+ + segStartEnd);
+ List<Residue> residues = segment.getListResidue().getResidue();
+ for (Residue residue : residues)
+ {
+ int currSeqIndex = UNASSIGNED;
+ List<CrossRefDb> cRefDbs = residue.getCrossRefDb();
+ CrossRefDb pdbRefDb = null;
+ for (CrossRefDb cRefDb : cRefDbs)
+ {
+ if (cRefDb.getDbSource().equalsIgnoreCase(DBRefSource.PDB))
+ {
+ pdbRefDb = cRefDb;
+ }
+ if (cRefDb.getDbCoordSys()
+ .equalsIgnoreCase(seqCoordSys.getName())
+ && hasAccessionId(cRefDb.getDbAccessionId()))
+ {
+ String resNumIndexString = cRefDb.getDbResNum()
+ .equalsIgnoreCase("None") ? String.valueOf(UNASSIGNED)
+ : cRefDb.getDbResNum();
+ currSeqIndex = Integer.valueOf(resNumIndexString);
+ if (pdbRefDb != null)
+ {
+ break;// exit loop if pdb and uniprot are already found
+ }
+ }
+ }
+ if (currSeqIndex == UNASSIGNED)
+ {
+ continue;
+ }
+ if (currSeqIndex > seq.getStart() && currSeqIndex <= seq.getEnd())
+ {
+ int resNum;
+ try
+ {
+ resNum = (pdbRefDb == null) ? Integer.valueOf(residue
+ .getDbResNum()) : Integer.valueOf(pdbRefDb.getDbResNum());
+ } catch (NumberFormatException nfe)
+ {
+ resNum = (pdbRefDb == null) ? Integer.valueOf(residue
+ .getDbResNum()) : Integer.valueOf(pdbRefDb
+ .getDbResNum().split("[a-zA-Z]")[0]);
+ }
+ try
+ {
+ mapping[currSeqIndex][PDB_RES_POS] = Integer.valueOf(resNum);
+ } catch (ArrayIndexOutOfBoundsException e)
+ {
+ // do nothing..
+ }
+ char resCharCode = ResidueProperties
+ .getSingleCharacterCode(residue.getDbResName());
+ resNumMap.put(currSeqIndex, String.valueOf(resCharCode));
+ }
+ }
+ }
+ try
+ {
+ populateAtomPositions(entityId, mapping);
+ } catch (Exception e)
+ {
+ e.printStackTrace();
+ }
+ padWithGaps(resNumMap);
+ int counter = 0;
+ int seqStart = UNASSIGNED;
+ int seqEnd = UNASSIGNED;
+ int pdbStart = UNASSIGNED;
+ int pdbEnd = UNASSIGNED;
+ boolean startDetected = false;
+ for (int[] x : mapping)
+ {
+ if (!startDetected && x[PDB_RES_POS] != UNASSIGNED)
+ {
+ seqStart = counter;
+ startDetected = true;
+ // System.out.println("Seq start: "+ seqStart);
+ }
+
+ if (startDetected && x[PDB_RES_POS] != UNASSIGNED)
+ {
+ seqEnd = counter;
+ }
+ ++counter;
+ }
+
+ String matchedSeq = originalSeq;
+ if (seqStart != UNASSIGNED)
+ {
+ seqEnd = (seqEnd == UNASSIGNED) ? counter : seqEnd;
+ pdbStart = mapping[seqStart][PDB_RES_POS];
+ pdbEnd = mapping[seqEnd][PDB_RES_POS];
+ int orignalSeqStart = seq.getStart();
+ if (orignalSeqStart >= 1)
+ {
+ int subSeqStart = seqStart - orignalSeqStart;
+ int subSeqEnd = seqEnd - (orignalSeqStart - 1);
+ matchedSeq = originalSeq.substring(subSeqStart, subSeqEnd);
+ }
+ }
+
+ StringBuilder targetStrucSeqs = new StringBuilder();
+ for (String res : resNumMap.values())
+ {
+ targetStrucSeqs.append(res);
+ }
+
+ if (os != null)
+ {
+ MappingOutputPojo mop = new MappingOutputPojo();
+ mop.setSeqStart(seqStart);
+ mop.setSeqEnd(seqEnd);
+ mop.setSeqName(seq.getName());
+ mop.setSeqResidue(matchedSeq);
+
+ mop.setStrStart(pdbStart);
+ mop.setStrEnd(pdbEnd);
+ mop.setStrName(structId);
+ mop.setStrResidue(targetStrucSeqs.toString());
+
+ mop.setType("pep");
+ os.print(getMappingOutput(mop).toString());
+ }
+ return mapping;
+ }
+
+ private boolean hasAccessionId(String accession)
+ {
+ boolean isStrictMatch = true;
+ return isStrictMatch ? curSourceDBRef.equalsIgnoreCase(accession)
+ : curDBRefAccessionIdsString.contains(accession.toLowerCase());
+ }
+
+ @Override
+ public boolean isFoundInSiftsEntry(String accessionId)
+ {
+ return accessionId != null
+ && getAllMappingAccession().contains(accessionId);
+ }
+
+ /**
+ * Pads missing positions with gaps
+ *
+ * @param resNumMap
+ */
+ void padWithGaps(TreeMap<Integer, String> resNumMap)
+ {
+ if (resNumMap == null || resNumMap.isEmpty())
+ {
+ return;
+ }
+ Integer[] keys = resNumMap.keySet().toArray(new Integer[0]);
+ Arrays.sort(keys);
+ int firstIndex = keys[0];
+ int lastIndex = keys[keys.length - 1];
+ System.out.println("Min value " + firstIndex);
+ System.out.println("Max value " + lastIndex);
+ for (int x = firstIndex; x <= lastIndex; x++)
+ {
+ if (!resNumMap.containsKey(x))
+ {
+ resNumMap.put(x, "-");
+ }
+ }
+ }
+
+ /**
+ *
+ * @param chainId
+ * Target chain to populate mapping of its atom positions.
+ * @param mapping
+ * Two dimension array of residue index versus atom position
+ * @throws IllegalArgumentException
+ * Thrown if chainId or mapping is null
+ */
+ void populateAtomPositions(String chainId, int[][] mapping)
+ throws IllegalArgumentException
+ {
+ PDBChain chain = pdb.findChain(chainId);
+ if (chain == null || mapping == null)
+ {
+ throw new IllegalArgumentException(
+ "Chain id or mapping must not be null.");
+ }
+ for (int[] map : mapping)
+ {
+ if (map[PDB_RES_POS] != UNASSIGNED)
+ {
+ map[PDB_ATOM_POS] = getAtomIndex(map[PDB_RES_POS], chain.atoms);
+ }
+ }
+ }
+
+ /**
+ *
+ * @param residueIndex
+ * The residue index used for the search
+ * @param atoms
+ * A collection of Atom to search
+ * @return atom position for the given residue index
+ */
+ int getAtomIndex(int residueIndex, Collection<Atom> atoms)
+ {
+ if (atoms == null)
+ {
+ throw new IllegalArgumentException(
+ "atoms collection must not be null!");
+ }
+ for (Atom atom : atoms)
+ {
+ if (atom.resNumber == residueIndex)
+ {
+ return atom.atomIndex;
+ }
+ }
+ return UNASSIGNED;
+ }
+
+ @Override
+ public Entity getEntityById(String id) throws SiftsException
+ {
+ List<Entity> entities = siftsEntry.getEntity();
+ for (Entity entity : entities)
+ {
+ if (!entity.getEntityId().equalsIgnoreCase(id))
+ {
+ continue;
+ }
+ return entity;
+ }
+ throw new SiftsException("Entity " + id + " not found");
+ }
+
+ @Override
+ public String[] getEntryDBs()
+ {
+ System.out.println("\nListing DB entries...");
+ List<String> availDbs = new ArrayList<String>();
+ List<Db> dbs = siftsEntry.getListDB().getDb();
+ for (Db db : dbs)
+ {
+ availDbs.add(db.getDbSource());
+ System.out.println(db.getDbSource() + " | " + db.getDbCoordSys());
+ }
+ return availDbs.toArray(new String[0]);
+ }
+
+ @Override
+ public StringBuffer getMappingOutput(MappingOutputPojo mp)
+ throws SiftsException
+ {
+ String seqRes = mp.getSeqResidue();
+ String seqName = mp.getSeqName();
+ int sStart = mp.getSeqStart();
+ int sEnd = mp.getSeqEnd();
+
+ String strRes = mp.getStrResidue();
+ String strName = mp.getStrName();
+ int pdbStart = mp.getStrStart();
+ int pdbEnd = mp.getStrEnd();
+
+ String type = mp.getType();
+
+ int maxid = (seqName.length() >= strName.length()) ? seqName.length()
+ : strName.length();
+ int len = 72 - maxid - 1;
+
+ int nochunks = ((seqRes.length()) / len)
+ + ((seqRes.length()) % len > 0 ? 1 : 0);
+ // output mappings
+ StringBuffer output = new StringBuffer();
+ output.append(NEWLINE);
+ output.append("Sequence ⟷ Structure mapping details").append(NEWLINE);
+ output.append("Method: SIFTS");
+ output.append(NEWLINE).append(NEWLINE);
+
+ output.append(new Format("%" + maxid + "s").form(seqName));
+ output.append(" : ");
+ output.append(String.valueOf(sStart));
+ output.append(" - ");
+ output.append(String.valueOf(sEnd));
+ output.append(" Maps to ");
+ output.append(NEWLINE);
+ output.append(new Format("%" + maxid + "s").form(structId));
+ output.append(" : ");
+ output.append(String.valueOf(pdbStart));
+ output.append(" - ");
+ output.append(String.valueOf(pdbEnd));
+ output.append(NEWLINE).append(NEWLINE);
+
+ int matchedSeqCount = 0;
+ for (int j = 0; j < nochunks; j++)
+ {
+ // Print the first aligned sequence
+ output.append(new Format("%" + (maxid) + "s").form(seqName)).append(
+ " ");
+
+ for (int i = 0; i < len; i++)
+ {
+ if ((i + (j * len)) < seqRes.length())
+ {
+ output.append(seqRes.charAt(i + (j * len)));
+ }
+ }
+
+ output.append(NEWLINE);
+ output.append(new Format("%" + (maxid) + "s").form(" ")).append(" ");
+
+ // Print out the matching chars
+ for (int i = 0; i < len; i++)
+ {
+ try
+ {
+ if ((i + (j * len)) < seqRes.length())
+ {
+ if (seqRes.charAt(i + (j * len)) == strRes.charAt(i + (j * len))
+ && !jalview.util.Comparison.isGap(seqRes.charAt(i
+ + (j * len))))
+ {
+ matchedSeqCount++;
+ output.append("|");
+ }
+ else if (type.equals("pep"))
+ {
+ if (ResidueProperties.getPAM250(seqRes.charAt(i + (j * len)),
+ strRes.charAt(i + (j * len))) > 0)
+ {
+ output.append(".");
+ }
+ else
+ {
+ output.append(" ");
+ }
+ }
+ else
+ {
+ output.append(" ");
+ }
+ }
+ } catch (IndexOutOfBoundsException e)
+ {
+ continue;
+ }
+ }
+ // Now print the second aligned sequence
+ output = output.append(NEWLINE);
+ output = output.append(new Format("%" + (maxid) + "s").form(strName))
+ .append(" ");
+ for (int i = 0; i < len; i++)
+ {
+ if ((i + (j * len)) < strRes.length())
+ {
+ output.append(strRes.charAt(i + (j * len)));
+ }
+ }
+ output.append(NEWLINE).append(NEWLINE);
+ }
+ float pid = (float) matchedSeqCount / seqRes.length() * 100;
+ if (pid < 2)
+ {
+ throw new SiftsException("Low PID detected for SIFTs mapping...");
+ }
+ output.append("Length of alignment = " + seqRes.length())
+ .append(NEWLINE);
+ output.append(new Format("Percentage ID = %2.2f").form(pid));
+ output.append(NEWLINE);
+ return output;
+ }
+
+ @Override
+ public int getEntityCount()
+ {
+ return siftsEntry.getEntity().size();
+ }
+
+ @Override
+ public String getDbAccessionId()
+ {
+ return siftsEntry.getDbAccessionId();
+ }
+
+ @Override
+ public String getDbCoordSys()
+ {
+ return siftsEntry.getDbCoordSys();
+ }
+
+ @Override
+ public String getDbEvidence()
+ {
+ return siftsEntry.getDbEvidence();
+ }
+
+ @Override
+ public String getDbSource()
+ {
+ return siftsEntry.getDbSource();
+ }
+
+ @Override
+ public String getDbVersion()
+ {
+ return siftsEntry.getDbVersion();
+ }
+}
git://source.jalview.org / jalview.git / blobdiff