/*
* PDB web development code
*
* This code may be freely distributed and modified under the
* terms of the GNU Lesser General Public Licence. This should
* be distributed with the code. If you do not have a copy,
* see:
*
* http://www.gnu.org/copyleft/lesser.html
*
* Copyright for this code is held jointly by the individual
* authors. These should be listed in @author doc comments.
*
*
* Created on Jun 17, 2009
* Created by ap3
*
*/
package org.biojava.nbio.structure.align.model;
import org.biojava.nbio.structure.Atom;
import org.biojava.nbio.structure.align.ce.CeMain;
import org.biojava.nbio.structure.align.ce.CeSideChainMain;
import org.biojava.nbio.structure.align.util.AFPAlignmentDisplay;
import org.biojava.nbio.structure.jama.Matrix;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* A bean to contain the core of a structure alignment.
* The FatCat aligner class is working on the AFPChain class.
*
* @author Andreas Prlic
* @author Aleix Lafita
*
*/
public class AFPChain implements Serializable, Cloneable {
private static final long serialVersionUID = -4474029015606617947L;
public static final String newline = System.getProperty("line.separator");
public static final String UNKNOWN_ALGORITHM = "unknown";
private String algorithmName;
private String version;
private String name1;
private String name2;
private long ioTime;
private long calculationTime;
private long id;
// results:
private double alignScore;
private double alignScoreUpdate;
private int afpChainTwiNum;
// end of results
private double tmScore;
// utility
private int minLen ; // the length of the shorter 2 proteins.
private List<AFP> afpSet;
private int[][] afpIndex;
private int[][] afpAftIndex;
private int[][] afpBefIndex;
private Matrix disTable1;
private Matrix disTable2;
private int[] twi = null ; //the number of twists making the best score ending at each AFP
private int afpChainLen;
private int[] afpChainList;
private double[] afpChainTwiBin;
private double[] afpChainTwiList;
private double chainRmsd;
private int chainLen,misLen,gapLen;
private int blockNum; //the final block number
private int blockNumIni; //block number before block clustering and split
private int blockNumClu; //block number after clustering blocks
private int blockNumSpt; //block number after spliting blocks
private double[] blockRmsd; //the RMSD of each block
private int[] block2Afp; //the index of afp for each block
private int[] blockSize; //the number of AFPs involved in a block
private double[] blockScore; //the score associated with each block
private int[] blockGap; //the gaps in each block
private int[] blockResSize; //the number of residues involved in a block
private int[][][] blockResList;//the list of AFP for each block
private Matrix[] blockRotationMatrix;
private Atom[] blockShiftVector;
private int focusResn; //the size of the set
private int[] focusRes1; //the residues from protein 1
private int[] focusRes2; //the residues from protein 2
private int focusAfpn; //the AFP number
private int[] focusAfpList; //the AFP list
private boolean shortAlign;
private String [][][] pdbAln; // only needed temp. during XML serialization, since we don;t have coordinates loaded at that time and can map from PDB res numbers to atom positions.
private int[][][] optAln;
private int[] optLen ;
private double[] optRmsd ;
private int optLength;
private char[] alnsymb;
private char[] alnseq1;
private char[] alnseq2;
private int alnLength;
private int alnbeg1;
private int alnbeg2;
private int totalLenIni;
private int totalLenOpt = 0;
private double totalRmsdIni;
private double totalRmsdOpt;
private int ca1Length;
private int ca2Length;
// this one is special. it comes from the FatCatParameters...
// default is flexible alignment...
private int maxTra = 5;
private Double conn;
private Double dvar;
private double probability;
private double identity;
private double similarity;
private double normAlignScore;
private int myResultsEQR;
private int myResultsSimilarity1;
private int myResultsSimilarity2;
// Mark whether the alignment topology is sequential
// false if a circular permutation has occured
private boolean sequentialAlignment;
// background distances
private Matrix distanceMatrix;
private String description2;
/**
* Construction of an AFPChain needs the algorithm name, since downstream
* analysis methods (scores, display, etc) behave differently if the
* alignment is flexible (created with FatCat).
*
* @param algorithmName
*/
public AFPChain(String algorithmName){
this.algorithmName = algorithmName;
init();
}
/**
* Use the constructor with the algorithmName (design condition).
* @see AFPChain#AFPChain(String)
*/
@Deprecated
public AFPChain(){
algorithmName = UNKNOWN_ALGORITHM;
init();
}
/**
* Copy constructor
* @param o AFPChain to duplicate
*/
public AFPChain(AFPChain o) {
this.algorithmName = o.algorithmName;
this.version = o.version;
this.name1 = o.name1;
this.name2 = o.name2;
this.ioTime = o.ioTime;
this.calculationTime = o.calculationTime;
this.id = o.id;
this.alignScore = o.alignScore;
this.alignScoreUpdate = o.alignScoreUpdate;
this.afpChainTwiNum = o.afpChainTwiNum;
this.minLen = o.minLen;
this.afpSet = new ArrayList<AFP>(o.afpSet);
this.afpIndex = o.afpIndex == null? null: o.afpIndex.clone();
this.afpAftIndex = o.afpAftIndex == null? null: o.afpAftIndex.clone();
this.afpBefIndex = o.afpBefIndex == null? null: o.afpBefIndex.clone();
this.disTable1 = o.disTable1 == null? null: (Matrix) o.disTable1.clone();
this.disTable2 = o.disTable2 == null? null: (Matrix) o.disTable2.clone();
this.twi = o.twi == null ? null : o.twi.clone();
this.afpChainLen = o.afpChainLen;
this.afpChainList = o.afpChainList == null? null: o.afpChainList.clone();
this.afpChainTwiBin = o.afpChainTwiBin == null? null: o.afpChainTwiBin.clone();
this.afpChainTwiList = o.afpChainTwiList == null? null: o.afpChainTwiList.clone();
this.chainRmsd = o.chainRmsd;
this.chainLen = o.chainLen;
this.misLen = o.misLen;
this.gapLen = o.gapLen;
this.blockNum = o.blockNum;
this.blockNumIni = o.blockNumIni;
this.blockNumClu = o.blockNumClu;
this.blockNumSpt = o.blockNumSpt;
this.blockRmsd = o.blockRmsd == null ? null : o.blockRmsd.clone();
this.block2Afp = o.block2Afp == null ? null : o.block2Afp.clone();
this.blockSize = o.blockSize == null ? null : o.blockSize.clone();
this.blockScore = o.blockScore == null ? null : o.blockScore.clone();
this.blockGap = o.blockGap == null ? null : o.blockGap.clone();
this.blockResSize = o.blockResSize == null ? null : o.blockResSize.clone();
this.blockResList = o.blockResList == null ? null : o.blockResList.clone();
this.blockRotationMatrix = o.blockRotationMatrix == null ? null : o.blockRotationMatrix.clone();
this.blockShiftVector = o.blockShiftVector == null ? null : o.blockShiftVector.clone();
this.focusResn = o.focusResn;
this.focusRes1 = o.focusRes1 == null ? null : o.focusRes1.clone();
this.focusRes2 = o.focusRes2 == null ? null : o.focusRes2.clone();
this.focusAfpn = o.focusAfpn;
this.focusAfpList = o.focusAfpList == null ? null : o.focusAfpList.clone();
this.shortAlign = o.shortAlign;
this.pdbAln = o.pdbAln == null ? null : o.pdbAln.clone();
this.optAln = o.optAln == null ? null : o.optAln.clone();
this.optLen = o.optLen == null ? null : o.optLen.clone();
this.optRmsd = o.optRmsd == null ? null : o.optRmsd.clone();
this.optLength = o.optLength;
this.alnsymb = o.alnsymb == null ? null : o.alnsymb.clone();
this.alnseq1 = o.alnseq1 == null ? null : o.alnseq1.clone();
this.alnseq2 = o.alnseq2 == null ? null : o.alnseq2.clone();
this.alnLength = o.alnLength;
this.alnbeg1 = o.alnbeg1;
this.alnbeg2 = o.alnbeg2;
this.totalLenIni = o.totalLenIni;
this.totalLenOpt = o.totalLenOpt;
this.totalRmsdIni = o.totalRmsdIni;
this.totalRmsdOpt = o.totalRmsdOpt;
this.ca1Length = o.ca1Length;
this.ca2Length = o.ca2Length;
this.maxTra = o.maxTra;
this.conn = new Double(o.conn);
this.dvar = new Double(o.dvar);
this.probability = o.probability;
this.identity = o.identity;
this.similarity = o.similarity;
this.normAlignScore = o.normAlignScore;
this.myResultsEQR = o.myResultsEQR;
this.myResultsSimilarity1 = o.myResultsSimilarity1;
this.myResultsSimilarity2 = o.myResultsSimilarity2;
this.distanceMatrix = o.distanceMatrix;
}
/**
* Creates and returns a copy of this object.
*/
@Override
public Object clone() {
return new AFPChain(this);
}
public long getId()
{
return id;
}
public void setId(long id)
{
this.id = id;
}
public String toCE(Atom[] ca1, Atom[]ca2) {
return AfpChainWriter.toCE(this,ca1,ca2);
}
public String toRotMat(){
return AfpChainWriter.toRotMat(this);
}
public String toFatcat(Atom[] ca1, Atom[]ca2){
return AfpChainWriter.toFatCat(this,ca1,ca2);
}
public String toDBSearchResult(){
return AfpChainWriter.toDBSearchResult(this);
}
protected void calcSimilarity() {
Map<String,Double> idMap = AFPAlignmentDisplay.calcIdSimilarity(alnseq1,alnseq2,alnLength);
//probability = idMap.get("probability");
similarity = idMap.get("similarity");
identity = idMap.get("identity");
}
/**
* Get the number of structurally equivalent residues
*
* @return nr of EQR
*/
public int getNrEQR(){
if (myResultsEQR < 0){
if ( optLen == null) {
myResultsEQR = 0;
return 0;
}
int nrEqr = 0;
for(int bk = 0; bk < blockNum; bk ++) {
for ( int i=0;i< optLen[bk];i++){
nrEqr++;
}
}
myResultsEQR = nrEqr;
}
return myResultsEQR;
}
/** Get the coverage of protein 1 with the alignment
*
* @return percentage of coverage, between 0 and 100.
*/
public int getCoverage1(){
if ( myResultsSimilarity1 < 0 ) {
int distance = ca1Length + ca2Length - 2 * getNrEQR();
int similarity = (ca1Length + ca2Length - distance ) / 2;
myResultsSimilarity1 = Math.round(similarity /(float) ca1Length * 100);
}
return myResultsSimilarity1;
}
/** Get the coverage of protein 2 with the alignment
*
* @return percentage of coverage, between 0 and 100.
*/
public int getCoverage2(){
if ( myResultsSimilarity2 < 0 ) {
int distance = ca1Length + ca2Length - 2 * getNrEQR();
int similarity = (ca1Length + ca2Length - distance ) / 2;
myResultsSimilarity2 = Math.round(similarity /(float) ca2Length * 100);
}
return myResultsSimilarity2;
}
/** get the coverage of protein 1 with the alignment
*
* @return percentage of coverage, between 0 and 100.
* @deprecated use getCoverage1() instead
*/
@Deprecated
public int getSimilarity1(){
return getCoverage1();
}
/** get the coverage of protein 2 with the alignment
*
* @return percentage of coverage, between 0 and 100.
* @deprecated use getCoverage2() instead
*/
@Deprecated
public int getSimilarity2(){
return getCoverage2();
}
@Override
public String toString(){
//int lA = ca1Length;
//int lB = ca2Length;
//int distance = lA + lB - 2 * getNrEQR();
StringBuffer str = new StringBuffer("");
str.append("EQR:");
str.append(getNrEQR());
str.append("\tLen1:");
str.append(this.getCa1Length());
str.append("\tLen2:");
str.append(this.getCa2Length());
str.append(String.format("\tscore: %.2f",this.getAlignScore()));
str.append("\t");
if ( algorithmName.equalsIgnoreCase(CeMain.algorithmName) || algorithmName.equalsIgnoreCase(CeSideChainMain.algorithmName)){
str.append("Z-score:");
str.append(String.format("%.2f",this.getProbability()));
} else {
str.append("Probability:");
str.append(String.format("%.2e",this.getProbability()));
}
str.append("\tRMSD:");
str.append(String.format("%.2f",this.getTotalRmsdOpt()));
str.append("\tSeqID:");
str.append(String.format("%.0f",getIdentity()*100));
str.append("%\tSeqSim:");
str.append(String.format("%.0f",getSimilarity()*100));
str.append("%\tCov1:");
str.append(this.getCoverage1());
str.append("%\tCov2:");
str.append(this.getCoverage2());
str.append("%");
if ( tmScore != -1) {
str.append("\ttmScore:");
str.append(String.format("%.2f",tmScore));
}
str.append(newline);
return str.toString();
}
public boolean isSignificantResult(){
if ( algorithmName.equalsIgnoreCase(CeMain.algorithmName) || algorithmName.equalsIgnoreCase(CeSideChainMain.algorithmName)){
if (probability >= 3.5)
return true;
} else {
if (probability < 0.01)
return true;
}
return false;
}
private void init(){
shortAlign = false;
afpChainLen = 0;
afpChainList = null;
afpChainTwiBin = null;
afpChainTwiList = null;
chainRmsd=0;
chainLen = misLen = gapLen = 0;
blockResSize = null;
blockScore = null;
blockGap = null;
optAln = null;
pdbAln = null;
optLen = null;
optRmsd = null;
block2Afp = new int[maxTra+1];
blockSize = new int[maxTra+1];
blockRmsd = new double[maxTra+1];
blockScore = new double[maxTra+1];
blockGap = new int[maxTra+1];
blockResSize = new int[maxTra+1];
afpSet = new ArrayList<AFP>();
totalLenIni = totalLenOpt = 0;
totalRmsdIni = totalRmsdOpt = 0.0;
afpChainTwiNum = 0;
alignScore = 0;
alignScoreUpdate = 0;
conn = new Double(0);
dvar = new Double(0);
calculationTime = 0;
similarity = -1;
identity = -1;
myResultsEQR = -1;
myResultsSimilarity1 = -1;
myResultsSimilarity2 = -1;
version = "1.0";
sequentialAlignment = true;
distanceMatrix = null;
tmScore = -1;
description2=null;
}
/**
* Resets properties which can be calculated on the fly
*/
private void invalidate() {
myResultsEQR = -1;
myResultsSimilarity1 = -1;
myResultsSimilarity2 = -1;
identity = -1;
similarity = -1;
}
/** used temporarily during XML serialization to track the PDB positions of the alignmnet
*
* @return String array
*/
public String[][][] getPdbAln() {
return pdbAln;
}
public void setPdbAln(String[][][] pdbAln) {
this.pdbAln = pdbAln;
}
public Double getConn()
{
return conn;
}
public void setConn(Double conn)
{
this.conn = conn;
}
public Double getDVar()
{
return dvar;
}
public void setDVar(Double dvar)
{
this.dvar = dvar;
}
/** get the maximum nr of Twists that are allowed...
*
* @return maxTra, the max nr of twists
*/
public int getMaxTra()
{
return maxTra;
}
/**
* Set the maximum number of Twists that are allowed...
* @param maxTra
*/
public void setMaxTra(int maxTra)
{
this.maxTra = maxTra;
}
public double getAlignScore()
{
return alignScore;
}
public void setAlignScore(double alignScore)
{
this.alignScore = alignScore;
}
public double getAlignScoreUpdate()
{
return alignScoreUpdate;
}
public void setAlignScoreUpdate(double alignScoreUpdate)
{
this.alignScoreUpdate = alignScoreUpdate;
}
public int getAfpChainTwiNum()
{
return afpChainTwiNum;
}
public void setAfpChainTwiNum(int afpChainTwiNum)
{
this.afpChainTwiNum = afpChainTwiNum;
}
public int getMinLen()
{
return minLen;
}
public void setMinLen(int minLen)
{
this.minLen = minLen;
}
/**
* Get the set of AFPs for this alignment.
* An AFP is a local ungapped alignment between the two peptides.
*
* AFPs are set before the final optimization step. To get the final
* alignment, look at the aligned pairs from {@link #getOptAln()}.
*
* @return The optimal set of AFPs
* @see #getOptAln()
*/
public List<AFP> getAfpSet()
{
return afpSet;
}
/**
* Set the set of AFPs for this alignment.
* An AFP is a local ungapped alignment between the two peptides.
*
* AFPs are set before the final optimization step. To get the final
* alignment, look at the aligned pairs from {@link #getOptAln()}.
*/
public void setAfpSet(List<AFP> afpSet)
{
this.afpSet = afpSet;
}
public int[][] getAfpIndex()
{
return afpIndex;
}
public void setAfpIndex(int[][] afpIndex)
{
this.afpIndex = afpIndex;
}
public int[][] getAfpAftIndex()
{
return afpAftIndex;
}
public void setAfpAftIndex(int[][] afpAftIndex)
{
this.afpAftIndex = afpAftIndex;
}
public int[][] getAfpBefIndex()
{
return afpBefIndex;
}
public void setAfpBefIndex(int[][] afpBefIndex)
{
this.afpBefIndex = afpBefIndex;
}
public Matrix getDisTable1()
{
return disTable1;
}
public void setDisTable1(Matrix disTable1)
{
this.disTable1 = disTable1;
}
public Matrix getDisTable2()
{
return disTable2;
}
public void setDisTable2(Matrix disTable2)
{
this.disTable2 = disTable2;
}
public int[] getTwi()
{
return twi;
}
public void setTwi(int[] twi)
{
this.twi = twi;
}
public int getAfpChainLen()
{
return afpChainLen;
}
public void setAfpChainLen(int afpChainLen)
{
this.afpChainLen = afpChainLen;
}
public int[] getAfpChainList()
{
return afpChainList;
}
public void setAfpChainList(int[] afpChainList)
{
this.afpChainList = afpChainList;
}
public double[] getAfpChainTwiBin()
{
return afpChainTwiBin;
}
public void setAfpChainTwiBin(double[] afpChainTwiBin)
{
this.afpChainTwiBin = afpChainTwiBin;
}
public double[] getAfpChainTwiList()
{
return afpChainTwiList;
}
public void setAfpChainTwiList(double[] afpChainTwiList)
{
this.afpChainTwiList = afpChainTwiList;
}
public double getChainRmsd()
{
return chainRmsd;
}
/** The RMSD of the chain of AFPs. Set during AFPCHainer.traceBack();
*
* @param chainRmsd
*/
public void setChainRmsd(double chainRmsd)
{
this.chainRmsd = chainRmsd;
}
public int getChainLen()
{
return chainLen;
}
public void setChainLen(int chainLen)
{
this.chainLen = chainLen;
}
public int getMisLen()
{
return misLen;
}
public void setMisLen(int misLen)
{
this.misLen = misLen;
}
public int getGapLen()
{
return gapLen;
}
public void setGapLen(int gapLen)
{
this.gapLen = gapLen;
}
/** The number of blocks in the alignment
*
* @return the nr of blocks in alignment
*/
public int getBlockNum()
{
return blockNum;
}
public void setBlockNum(int blockNum)
{
this.blockNum = blockNum;
}
public int getBlockNumIni()
{
return blockNumIni;
}
public void setBlockNumIni(int blockNumIni)
{
this.blockNumIni = blockNumIni;
}
public int getBlockNumClu()
{
return blockNumClu;
}
public void setBlockNumClu(int blockNumClu)
{
this.blockNumClu = blockNumClu;
}
public int getBlockNumSpt()
{
return blockNumSpt;
}
public void setBlockNumSpt(int blockNumSpt)
{
this.blockNumSpt = blockNumSpt;
}
public double[] getBlockRmsd()
{
return blockRmsd;
}
public void setBlockRmsd(double[] blockRmsd)
{
this.blockRmsd = blockRmsd;
}
public int[] getBlock2Afp()
{
return block2Afp;
}
public void setBlock2Afp(int[] block2Afp)
{
this.block2Afp = block2Afp;
}
public int[] getBlockSize()
{
return blockSize;
}
public void setBlockSize(int[] blockSize)
{
this.blockSize = blockSize;
}
public double[] getBlockScore()
{
return blockScore;
}
public void setBlockScore(double[] blockScore)
{
this.blockScore = blockScore;
}
public int[] getBlockGap()
{
return blockGap;
}
public void setBlockGap(int[] blockGap)
{
this.blockGap = blockGap;
}
public int[] getBlockResSize()
{
return blockResSize;
}
public void setBlockResSize(int[] blockResSize)
{
this.blockResSize = blockResSize;
}
/** tracks the residues of the initial blocks (before optimization)
*
*
* @return list of block residues
*/
public int[][][] getBlockResList()
{
return blockResList;
}
public void setBlockResList(int[][][] blockResList)
{
this.blockResList = blockResList;
}
public int getFocusResn()
{
return focusResn;
}
public void setFocusResn(int focusResn)
{
this.focusResn = focusResn;
}
public int[] getFocusRes1()
{
return focusRes1;
}
public void setFocusRes1(int[] focusRes1)
{
this.focusRes1 = focusRes1;
}
public int[] getFocusRes2()
{
return focusRes2;
}
public void setFocusRes2(int[] focusRes2)
{
this.focusRes2 = focusRes2;
}
public int getFocusAfpn()
{
return focusAfpn;
}
public void setFocusAfpn(int focusAfpn)
{
this.focusAfpn = focusAfpn;
}
public int[] getFocusAfpList()
{
return focusAfpList;
}
public void setFocusAfpList(int[] focusAfpList)
{
this.focusAfpList = focusAfpList;
}
public boolean isShortAlign()
{
return shortAlign;
}
public void setShortAlign(boolean shortAlign)
{
this.shortAlign = shortAlign;
}
/** Tracks the Atom positions in the optimal alignment. Note: only considers the equivalent positions, gaps are ignored...
* first dimension is the block nr
* second dimension is 0 or 1 (the alignment chain index)
* third is the position
* @return int array
*/
public int[][][] getOptAln()
{
return optAln;
}
public void setOptAln(int[][][] optAln)
{
invalidate();
this.optAln = optAln;
}
/**
* The length of each block
* @return lengths
*/
public int[] getOptLen()
{
return optLen;
}
public void setOptLen(int[] optLen)
{
this.optLen = optLen;
}
public double[] getOptRmsd()
{
return optRmsd;
}
public void setOptRmsd(double[] optRmsd)
{
this.optRmsd = optRmsd;
}
public int getOptLength()
{
return optLength;
}
/** The length of the optimal alignment. Set by AFPOptimizer.optimizeAln().
* This should be the sum of the elements in optLen
* @param optLength
*/
public void setOptLength(int optLength)
{
this.optLength = optLength;
}
public char[] getAlnsymb()
{
return alnsymb;
}
public void setAlnsymb(char[] alnsymb)
{
this.alnsymb = alnsymb;
}
public char[] getAlnseq1()
{
return alnseq1;
}
public void setAlnseq1(char[] alnseq1)
{
this.alnseq1 = alnseq1;
}
public char[] getAlnseq2()
{
return alnseq2;
}
public void setAlnseq2(char[] alnseq2)
{
this.alnseq2 = alnseq2;
}
/**
* @return The total length of the alignment, including gaps
* @see #getOptLength(), the number of aligned residues in the final alignment.
*/
public int getAlnLength()
{
return alnLength;
}
public void setAlnLength(int alnLength)
{
this.alnLength = alnLength;
}
/**
* @return The index of the first aligned residue in protein 1
*/
public int getAlnbeg1()
{
return alnbeg1;
}
public void setAlnbeg1(int alnbeg1)
{
this.alnbeg1 = alnbeg1;
}
/**
* @return The index of the first aligned residue in protein 2
*/
public int getAlnbeg2()
{
return alnbeg2;
}
public void setAlnbeg2(int alnbeg2)
{
this.alnbeg2 = alnbeg2;
}
public int getTotalLenIni()
{
return totalLenIni;
}
public void setTotalLenIni(int totalLenIni)
{
this.totalLenIni = totalLenIni;
}
public int getTotalLenOpt()
{
return totalLenOpt;
}
public void setTotalLenOpt(int totalLenOpt)
{
this.totalLenOpt = totalLenOpt;
}
/** this is the init-RMSD, not the final RMSD after refinement.
*
* @return totalRmsdIni
*/
public double getTotalRmsdIni()
{
return totalRmsdIni;
}
/** this is the init-RMSD, not the final RMSD after refinement.
*
* @param totalRmsdIni
*/
public void setTotalRmsdIni(double totalRmsdIni)
{
this.totalRmsdIni = totalRmsdIni;
}
/** The RMSD of the final alignment. Use this to print overal alignment RMSD.
*
* @return total RMSD of the optimal alignment.
*/
public double getTotalRmsdOpt()
{
return totalRmsdOpt;
}
/** The RMSD of the final alignment. Use this to print overal alignment RMSD.
*
* @param totalRmsdOpt : total RMSD of the optimal alignment
*/
public void setTotalRmsdOpt(double totalRmsdOpt)
{
this.totalRmsdOpt = totalRmsdOpt;
}
public String getName1()
{
return name1;
}
public void setName1(String name1)
{
this.name1 = name1;
}
public String getName2()
{
return name2;
}
public void setName2(String name2)
{
this.name2 = name2;
}
public long getCalculationTime()
{
return calculationTime;
}
public void setCalculationTime(long calculationTime)
{
this.calculationTime = calculationTime;
}
public int getCa1Length()
{
return ca1Length;
}
public void setCa1Length(int ca1Length)
{
this.ca1Length = ca1Length;
}
public int getCa2Length()
{
return ca2Length;
}
public void setCa2Length(int ca2Length)
{
this.ca2Length = ca2Length;
}
public long getIoTime()
{
return ioTime;
}
public void setIoTime(long ioTime)
{
this.ioTime = ioTime;
}
/** The probability (FATCAT) or Z-score (CE) of the alignment.
*
* @return either the probability (FATCAT) or the Z-score (CE) of the alignment.
*/
public double getProbability()
{
return probability;
}
public void setProbability(double probability)
{
this.probability = probability;
}
/** The percent of residues that are sequence-identical in the alignment.
*
* @return a value between 0 and 1
*/
public double getIdentity() {
if ( identity <= 0) {
calcSimilarity();
}
return identity;
}
public void setIdentity(double identity) {
this.identity = identity;
}
/** Returns the similarity score for the alignment. This gives the percent of
* sequence similar residues in the alignment.
*
* @return a double between 0 and 1
*/
public double getSimilarity() {
if ( similarity < 0)
calcSimilarity();
return similarity;
}
public void setSimilarity(double similarity) {
this.similarity = similarity;
}
public double getNormAlignScore()
{
return normAlignScore;
}
public void setNormAlignScore(double normAlignScore)
{
this.normAlignScore = normAlignScore;
}
public Matrix[] getBlockRotationMatrix()
{
return blockRotationMatrix;
}
public void setBlockRotationMatrix(Matrix[] blockRotationMatrix)
{
this.blockRotationMatrix = blockRotationMatrix;
}
public Atom[] getBlockShiftVector()
{
return blockShiftVector;
}
public void setBlockShiftVector(Atom[] blockShiftVector)
{
this.blockShiftVector = blockShiftVector;
}
public String getAlgorithmName() {
return algorithmName;
}
/**
* Caution has to be made when changing the algorithmName of an AFPChain,
* since downstream analysis methods (scores, display, etc) behave
* differently if the alignment is flexible (created with FatCat).
*
* @param algorithmName
*/
public void setAlgorithmName(String algorithmName) {
this.algorithmName = algorithmName;
}
public String getVersion() {
return version;
}
public void setVersion(String version) {
this.version = version;
}
/**
* Get whether this alignment has the normal topology, ie the residues
* aligned in each block increase sequentially over the original protein.
*
* This will be false if a circular permutation was detected.
* @return true if the alignment is sequential
*/
public boolean isSequentialAlignment() {
return sequentialAlignment;
}
/**
* Set whether this alignment has the normal topology, ie the residues
* aligned in each block increase sequentially over the original protein.
*
* This will be false if a circular permutation was detected.
*/
public void setSequentialAlignment(boolean sequentialAlignment) {
this.sequentialAlignment = sequentialAlignment;
}
/**
* A matrix with <i>ca1length</i> rows and <i>ca2length</i> columns.
* For CE this is the distance matrix, but the exact interpretation is left
* up to the alignment algorithm.
*
* <p>Note:
* A {@link org.biojava.nbio.structure.gui.JMatrixPanel}, which is used in
* the structure-gui package to display distance matrices, will display the
* transpose of this matrix. Be sure to take that into account when debugging
* visually.
*
* @return A matrix with dimensions ca1length x ca2length, or null
*/
public Matrix getDistanceMatrix() {
return distanceMatrix;
}
/**
* A matrix with <i>ca1length</i> rows and <i>ca2length</i> columns.
* For CE this is the distance matrix, but the exact interpretation is left
* up to the alignment algorithm.
* @param distanceMatrix A matrix with dimensions ca1length x ca2length
*/
public void setDistanceMatrix(Matrix distanceMatrix) {
this.distanceMatrix = distanceMatrix;
//System.out.println("Setting distMatrix "+(distanceMatrix==null?"null":"not null"));
}
public void setTMScore(double tmScore){
this.tmScore = tmScore;
}
/** Returns the tmScore of the alignment. If the score has not been calcualted yet,
* returns -1. To calculate it call AFPChainScorer.getTMScore(afpChain, ca1, ca2);
*
* @return -1, if not calculated, or the TM-score, a score between 0 and 1
*/
public double getTMScore()
{
return tmScore;
}
/** Get a textual description for the protein 2 of the alignment.
*
* @return
*/
public String getDescription2() {
return description2;
}
/** Set the textual description for protein 2.
*
* @param desc
*/
public void setDescription2(String desc){
this.description2 = desc;
}
/* (non-Javadoc)
* @see java.lang.Object#hashCode()
*/
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + blockNum;
result = prime * result + ca1Length;
result = prime * result + ca2Length;
result = prime * result + Arrays.hashCode(optAln);
result = prime * result + Arrays.hashCode(optLen);
result = prime * result + optLength;
return result;
}
/**
* A week equality metric.
*
* Checks if the optAlign is the same, and if the objects being compared
* seem to be the same (same names, lengths). Does not check properties
* of the alignment such as scores or superposition matrices.
* @see java.lang.Object#equals(java.lang.Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AFPChain other = (AFPChain) obj;
if (blockNum != other.blockNum)
return false;
if (ca1Length != other.ca1Length)
return false;
if (ca2Length != other.ca2Length)
return false;
if (!Arrays.deepEquals(optAln, other.optAln))
return false;
if (!Arrays.equals(optLen, other.optLen))
return false;
if (optLength != other.optLength)
return false;
return true;
}
}