src/jalview/structure/StructureMapping.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.structure;
  22
  23 import jalview.datamodel.AlignmentAnnotation;
  24 import jalview.datamodel.SequenceI;
  25
  26 import java.util.ArrayList;
  27 import java.util.HashMap;
  28 import java.util.List;
  29
  30 public class StructureMapping
  31 {
  32   String mappingDetails;
  33
  34   SequenceI sequence;
  35
  36   String pdbfile;
  37
  38   String pdbid;
  39
  40   String pdbchain;
  41
  42   public static final int UNASSIGNED_VALUE = -1;
  43
  44   private static final int PDB_RES_NUM_INDEX = 0;
  45
  46   private static final int PDB_ATOM_NUM_INDEX = 1;
  47
  48   // Mapping key is residue index while value is an array containing PDB resNum,
  49   // and atomNo
  50   HashMap<Integer, int[]> mapping;
  51
  52   /**
  53    * Constructor
  54    *
  55    * @param seq
  56    * @param pdbfile
  57    * @param pdbid
  58    * @param chain
  59    * @param mapping
  60    *          a map from sequence to two values, { resNo, atomNo } in the
  61    *          structure
  62    * @param mappingDetails
  63    */
  64   public StructureMapping(SequenceI seq, String pdbfile, String pdbid,
  65           String chain, HashMap<Integer, int[]> mapping,
  66           String mappingDetails)
  67   {
  68     sequence = seq;
  69     this.pdbfile = pdbfile;
  70     this.pdbid = pdbid;
  71     this.pdbchain = chain;
  72     this.mapping = mapping;
  73     this.mappingDetails = mappingDetails;
  74   }
  75
  76   public SequenceI getSequence()
  77   {
  78     return sequence;
  79   }
  80
  81   public String getChain()
  82   {
  83     return pdbchain;
  84   }
  85
  86   public String getPdbId()
  87   {
  88     return pdbid;
  89   }
  90
  91   /**
  92    *
  93    * @param seqpos
  94    * @return 0 or corresponding atom number for the sequence position
  95    */
  96   public int getAtomNum(int seqpos)
  97   {
  98     int[] resNumAtomMap = mapping.get(seqpos);
  99     if (resNumAtomMap != null)
 100     {
 101       return resNumAtomMap[PDB_ATOM_NUM_INDEX];
 102     }
 103     else
 104     {
 105       return UNASSIGNED_VALUE;
 106     }
 107   }
 108
 109   /**
 110    *
 111    * @param seqpos
 112    * @return 0 or the corresponding residue number for the sequence position
 113    */
 114   public int getPDBResNum(int seqpos)
 115   {
 116     int[] resNumAtomMap = mapping.get(seqpos);
 117     if (resNumAtomMap != null)
 118     {
 119       return resNumAtomMap[PDB_RES_NUM_INDEX];
 120     }
 121     else
 122     {
 123       return UNASSIGNED_VALUE;
 124     }
 125   }
 126
 127   /**
 128    * Returns a (possibly empty) list of [start, end] residue positions in the
 129    * mapped structure, corresponding to the given range of sequence positions
 130    *
 131    * @param fromSeqPos
 132    * @param toSeqPos
 133    * @return
 134    */
 135   public List<int[]> getPDBResNumRanges(int fromSeqPos, int toSeqPos)
 136   {
 137     List<int[]> result = new ArrayList<int[]>();
 138     int startRes = -1;
 139     int endRes = -1;
 140
 141     for (int i = fromSeqPos; i <= toSeqPos; i++)
 142     {
 143       int resNo = getPDBResNum(i);
 144       if (resNo == UNASSIGNED_VALUE)
 145       {
 146         continue; // no mapping from this sequence position
 147       }
 148       if (startRes == -1)
 149       {
 150         startRes = resNo;
 151         endRes = resNo;
 152       }
 153       if (resNo >= startRes && resNo <= endRes)
 154       {
 155         // within the current range - no change
 156         continue;
 157       }
 158       if (resNo == startRes - 1)
 159       {
 160         // extend beginning of current range
 161         startRes--;
 162         continue;
 163       }
 164       if (resNo == endRes + 1)
 165       {
 166         // extend end of current range
 167         endRes++;
 168         continue;
 169       }
 170
 171       /*
 172        * resNo is not within or contiguous with last range,
 173        * so write out the last range
 174        */
 175       result.add(new int[] { startRes, endRes });
 176       startRes = resNo;
 177       endRes = resNo;
 178     }
 179
 180     /*
 181      * and add the last range
 182      */
 183     if (startRes != -1)
 184     {
 185       result.add(new int[] { startRes, endRes });
 186     }
 187
 188     return result;
 189   }
 190
 191   /**
 192    *
 193    * @param pdbResNum
 194    * @return -1 or the corresponding sequence position for a pdb residue number
 195    */
 196   public int getSeqPos(int pdbResNum)
 197   {
 198     for (Integer seqPos : mapping.keySet())
 199     {
 200       if (pdbResNum == getPDBResNum(seqPos))
 201       {
 202         return seqPos;
 203       }
 204     }
 205     return UNASSIGNED_VALUE;
 206   }
 207
 208   /**
 209    * transfer a copy of an alignment annotation row in the PDB chain coordinate
 210    * system onto the mapped sequence
 211    *
 212    * @param ana
 213    * @return the copy that was remapped to the mapped sequence
 214    * @note this method will create a copy and add it to the dataset sequence for
 215    *       the mapped sequence as well as the mapped sequence (if it is not a
 216    *       dataset sequence).
 217    */
 218   public AlignmentAnnotation transfer(AlignmentAnnotation ana)
 219   {
 220     AlignmentAnnotation ala_copy = new AlignmentAnnotation(ana);
 221     SequenceI ds = sequence;
 222     while (ds.getDatasetSequence() != null)
 223     {
 224       ds = ds.getDatasetSequence();
 225     }
 226     // need to relocate annotation from pdb coordinates to local sequence
 227     // -1,-1 doesn't look at pdbresnum but fails to remap sequence positions...
 228
 229     ala_copy.remap(ds, mapping, -1, -1, 0);
 230     ds.addAlignmentAnnotation(ala_copy);
 231     if (ds != sequence)
 232     {
 233       // mapping wasn't to an original dataset sequence, so we make a copy on
 234       // the mapped sequence too
 235       ala_copy = new AlignmentAnnotation(ala_copy);
 236       sequence.addAlignmentAnnotation(ala_copy);
 237     }
 238     return ala_copy;
 239   }
 240
 241   public String getMappingDetailsOutput()
 242   {
 243     return mappingDetails;
 244   }
 245
 246   public HashMap<Integer, int[]> getMapping()
 247   {
 248     return mapping;
 249   }
 250 }