Correct significance criteria for internal symmetry

lafita · lafita · commit e7235d4c1c7c · 2016-03-03T10:32:25.000+01:00
The score threhold is imposed on the self-alignment, and a 90% of the
threshold is imposed after refinement.
diff --git a/biojava-structure-gui/src/main/java/org/biojava/nbio/structure/symmetry/gui/SymmetryDisplay.java b/biojava-structure-gui/src/main/java/org/biojava/nbio/structure/symmetry/gui/SymmetryDisplay.java
@@ -102,7 +102,7 @@ public static MultipleAlignmentJmol displayFull(CeSymmResult symm)
 	public static AbstractAlignmentJmol display(CeSymmResult symmResult)
 			throws StructureException {
 
-		if (symmResult.isSignificant()) {
+		if (symmResult.isRefined()) {
 			MultipleAlignment msa = symmResult.getMultipleAlignment();
 			List<Atom[]> atoms = msa.getAtomArrays();
 			MultipleAlignmentJmol jmol = new MultipleAlignmentJmol(msa, atoms);
@@ -211,10 +211,11 @@ public static String printSymmetryAxes(CeSymmResult symm, boolean elementary) {
 	 * @param symm
 	 *            CeSymmResult
 	 * @return
+	 * @throws StructureException 
 	 */
-	public static String printSymmetryGroup(CeSymmResult symm) {
+	public static String printSymmetryGroup(CeSymmResult symm) throws StructureException {
 
-		QuatSymmetryResults gSymmetry = symm.getSymmGroup();
+		QuatSymmetryResults gSymmetry = SymmetryTools.getQuaternarySymmetry(symm);
 
 		AxisAligner axes = AxisAligner.getInstance(gSymmetry);
 
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/internal/CeSymm.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/internal/CeSymm.java
@@ -248,6 +248,12 @@ protected static CeSymmResult align(Atom[] atoms, CESymmParameters params)
 		// Store the optimal self-alignment
 		result.setSelfAlignment(optimalAFP);
 		result.setStructureId(id);
+		
+		// Do not try the refinement if the self-alignment is not significant
+		if (optimalAFP.getTMScore() < params.getScoreThreshold()){
+			result.setSymmOrder(1);
+			return result;
+		}
 
 		// Determine the symmetry Type or get the one in params
 		if (params.getSymmType() == SymmetryType.AUTO) {
@@ -407,7 +413,7 @@ public static CeSymmResult analyze(Atom[] atoms, CESymmParameters params)
 		CeSymmIterative iter = new CeSymmIterative(params);
 		CeSymmResult result = iter.execute(atoms);
 
-		if (result.isSignificant()) {
+		if (result.isRefined()) {
 			// Optimize the global alignment freely once more (final step)
 			if (params.getOptimization() && result.getSymmLevels() > 1) {
 				// Remove the axes to do free superposition optimization TODO
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/internal/CeSymmResult.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/internal/CeSymmResult.java
@@ -14,7 +14,6 @@
 import org.biojava.nbio.structure.align.multiple.Block;
 import org.biojava.nbio.structure.align.multiple.MultipleAlignment;
 import org.biojava.nbio.structure.align.multiple.util.MultipleAlignmentScorer;
-import org.biojava.nbio.structure.symmetry.core.QuatSymmetryResults;
 import org.biojava.nbio.structure.symmetry.internal.CESymmParameters.RefineMethod;
 import org.biojava.nbio.structure.symmetry.internal.CESymmParameters.SymmetryType;
 import org.biojava.nbio.structure.symmetry.utils.SymmetryTools;
@@ -38,48 +37,42 @@ public class CeSymmResult {
 
 	private CESymmParameters params;
 	private SymmetryAxes axes;
-	private QuatSymmetryResults symmGroup;
+	private String symmGroup;
 
 	private int symmOrder;
 	private int symmLevels;
 	private boolean refined;
 	private SymmetryType type;
 
 	/**
-	 * Return true if the symmetry result is significant, false otherwise.
+	 * Conditions checked are: score above the threshold, order higher than 1
+	 * and refinement succeeded.
 	 * 
 	 * @return true if significant, false otherwise
 	 */
 	public boolean isSignificant() {
 
 		// In any case if the order is 1 it is asymmetric
-		if (symmOrder < 1)
+		if (symmOrder < 2)
 			return false;
 
-		// If the old version was turned ON
-		if (params.getRefineMethod() == RefineMethod.NOT_REFINED) {
-			if (selfAlignment.getTMScore() < params.getScoreThreshold())
-				return false;
-			else
-				return true;
-		}
+		// If the TM-Score is below the threshold
+		if (selfAlignment.getTMScore() < params.getScoreThreshold())
+			return false;
 
-		// For the new version
-		if (refined) {
-			// Length is over min length
-			if (symmLevels > 1)
-				return true; // significance already checked
-			else if (multipleAlignment.getCoreLength() < params
-					.getMinCoreLength())
+		// If the refinement was attempted
+		if (params.getRefineMethod() != RefineMethod.NOT_REFINED) {
+			// Check for minimum length
+			if (multipleAlignment.getCoreLength() < params.getMinCoreLength())
 				return false;
-			else if (multipleAlignment
-					.getScore(MultipleAlignmentScorer.AVGTM_SCORE) < params
-					.getScoreThreshold())
+			// Allow 90% of original TM-Score theshold
+			if (multipleAlignment.getScore(MultipleAlignmentScorer.AVGTM_SCORE) < params
+					.getScoreThreshold() * 0.9)
 				return false;
-			else
-				return true;
-		} else
-			return false;
+			return true;
+		}
+
+		return true;
 	}
 
 	/**
@@ -91,12 +84,9 @@ else if (multipleAlignment
 	 */
 	public List<StructureIdentifier> getRepeatsID() throws StructureException {
 
-		if (!isSignificant())
-			return null;
-		
-		if(!isRefined())
+		if (!isRefined())
 			return null;
-		
+
 		List<StructureIdentifier> repeats = new ArrayList<StructureIdentifier>(
 				symmOrder);
 
@@ -121,9 +111,9 @@ public List<StructureIdentifier> getRepeatsID() throws StructureException {
 
 	@Override
 	public String toString() {
-		return structureId + ", symmGroup=" + symmGroup.getSymmetry()
-				+ ", symmOrder=" + symmOrder + ", symmLevels=" + symmLevels
-				+ ", refined=" + refined + ", type=" + type + " | " + params;
+		return structureId + ", symmGroup=" + symmGroup + ", symmOrder="
+				+ symmOrder + ", symmLevels=" + symmLevels + ", refined="
+				+ refined + ", type=" + type + " | " + params;
 	}
 
 	public MultipleAlignment getMultipleAlignment() {
@@ -183,19 +173,25 @@ public void setRefined(boolean refined) {
 		this.refined = refined;
 	}
 
-	public QuatSymmetryResults getSymmGroup() {
-		// Lazily calculate the symmetry group
+	public String getSymmGroup() {
+		// Lazily calculate the symmetry group if significant
 		if (symmGroup == null) {
-			try {
-				symmGroup = SymmetryTools.getQuaternarySymmetry(this);
-			} catch (StructureException e) {
-				e.printStackTrace();
+			if (isRefined() && isSignificant()) {
+				try {
+					symmGroup = SymmetryTools.getQuaternarySymmetry(this)
+							.getSymmetry();
+				} catch (StructureException e) {
+					symmGroup = "C1";
+				}
+				if (symmGroup.equals("C1"))
+					symmGroup = "R";
 			}
+			symmGroup = "C1";
 		}
 		return symmGroup;
 	}
 
-	public void setSymmGroup(QuatSymmetryResults symmGroup) {
+	public void setSymmGroup(String symmGroup) {
 		this.symmGroup = symmGroup;
 	}
 
@@ -231,31 +227,4 @@ public void setStructureId(StructureIdentifier structureId) {
 		this.structureId = structureId;
 	}
 
-	/**
-	 * Returns the TM-Score of the symmetry alignment, independently of the
-	 * state of the result (MultipleAlignment or AFPChain).
-	 * 
-	 * @return TM-score
-	 */
-	public double getTMScore() {
-		if (multipleAlignment != null)
-			return multipleAlignment
-					.getScore(MultipleAlignmentScorer.AVGTM_SCORE);
-		else
-			return selfAlignment.getTMScore();
-	}
-
-	/**
-	 * Returns the RMSD of the symmetry alignment, independently of the state of
-	 * the result (MultipleAlignment or AFPChain).
-	 * 
-	 * @return RMSD
-	 */
-	public double getRMSD() {
-		if (multipleAlignment != null)
-			return multipleAlignment.getScore(MultipleAlignmentScorer.RMSD);
-		else
-			return selfAlignment.getTotalRmsdOpt();
-	}
-
 }
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/utils/SymmetryTools.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/symmetry/utils/SymmetryTools.java
@@ -516,7 +516,7 @@ public static Structure getQuaternaryStructure(CeSymmResult symmetry) {
 		char chainID = 'A';
 
 		// Create new structure containing the repeat atoms
-		for (int i = 0; i < symmetry.getSymmOrder(); i++) {
+		for (int i = 0; i < symmetry.getMultipleAlignment().size(); i++) {
 
 			Chain newCh = new ChainImpl();
 
@@ -849,15 +849,15 @@ public static boolean isSignificant(MultipleAlignment msa,
 			return false;
 
 		// TM-score cutoff
-		if (msa.getScore(MultipleAlignmentScorer.AVGTM_SCORE) == null) {
-			double tm = MultipleAlignmentScorer.getAvgTMScore(msa);
-			if (tm < symmetryThreshold)
-				return false;
-		} else {
-			double tm = msa.getScore(MultipleAlignmentScorer.AVGTM_SCORE);
-			if (tm < symmetryThreshold)
-				return false;
-		}
+		double tm = 0.0;
+		if (msa.getScore(MultipleAlignmentScorer.AVGTM_SCORE) == null)
+			tm = MultipleAlignmentScorer.getAvgTMScore(msa);
+		else
+			tm = msa.getScore(MultipleAlignmentScorer.AVGTM_SCORE);
+		
+		if (tm < symmetryThreshold)
+			return false;
+		
 		return true;
 	}
 
diff --git a/biojava-structure/src/test/java/org/biojava/nbio/structure/symmetry/internal/TestCeSymm.java b/biojava-structure/src/test/java/org/biojava/nbio/structure/symmetry/internal/TestCeSymm.java
@@ -42,7 +42,7 @@
 public class TestCeSymm {
 
 	@Test
-	public void testIndependence() throws IOException, StructureException {
+	public void testEasyCases() throws IOException, StructureException {
 
 		String[] names = new String[] { "1hiv.A", "4i4q", "1n0r.A"};
 		int[] orders = new int[] { 2, 3, 4 };
