Introduced optimization: now if switch is provided subunit clustering uses entity id infor.

josemduarte · josemduarte · commit f3515a7e18c7 · 2020-01-05T09:15:34.000-08:00
Some tests are failing
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitCluster.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitCluster.java
@@ -31,6 +31,8 @@
 import org.biojava.nbio.core.sequence.ProteinSequence;
 import org.biojava.nbio.core.sequence.compound.AminoAcidCompound;
 import org.biojava.nbio.structure.Atom;
+import org.biojava.nbio.structure.Chain;
+import org.biojava.nbio.structure.Structure;
 import org.biojava.nbio.structure.StructureException;
 import org.biojava.nbio.structure.align.StructureAlignment;
 import org.biojava.nbio.structure.align.StructureAlignmentFactory;
@@ -45,6 +47,7 @@
 import org.biojava.nbio.structure.align.multiple.MultipleAlignmentImpl;
 import org.biojava.nbio.structure.align.multiple.util.MultipleAlignmentScorer;
 import org.biojava.nbio.structure.align.multiple.util.ReferenceSuperimposer;
+import org.biojava.nbio.structure.quaternary.BiologicalAssemblyBuilder;
 import org.biojava.nbio.structure.symmetry.core.QuatSymmetrySubunits;
 import org.biojava.nbio.structure.symmetry.internal.CESymmParameters;
 import org.biojava.nbio.structure.symmetry.internal.CeSymm;
@@ -178,6 +181,38 @@ public boolean isIdenticalTo(SubunitCluster other) {
 		return thisSequence.equals(otherSequence);
 	}
 
+	/**
+	 * Tells whether the other SubunitCluster contains exactly the same Subunit.
+	 * This is checked by equality of their entity identifiers if they are present.
+	 *
+	 * @param other
+	 *            SubunitCluster
+	 * @return true if the SubunitClusters are identical, false otherwise
+	 */
+	public boolean isIdenticalByEntityIdTo(SubunitCluster other) {
+		Structure thisStruct = this.subunits.get(this.representative).getStructure();
+		Structure otherStruct = other.subunits.get(other.representative).getStructure();
+		String thisName = this.subunits.get(this.representative).getName();
+		String otherName = other.subunits.get(this.representative).getName();
+		Chain thisChain = thisStruct.getChain(thisName);
+		Chain otherChain = otherStruct.getChain(otherName);
+		if (thisChain == null || otherChain == null) {
+			logger.info("Can't determine entity ids of SubunitClusters {}-{}. Ignoring identity check by entity id",
+					this.subunits.get(this.representative).getName(),
+					other.subunits.get(other.representative).getName());
+			return false;
+		}
+		if (thisChain.getEntityInfo() == null || otherChain.getEntityInfo() == null) {
+			logger.info("Can't determine entity ids of SubunitClusters {}-{}. Ignoring identity check by entity id",
+					this.subunits.get(this.representative).getName(),
+					other.subunits.get(other.representative).getName());
+			return false;
+		}
+		int thisEntityId = thisChain.getEntityInfo().getMolId();
+		int otherEntityId = otherChain.getEntityInfo().getMolId();
+		return thisEntityId == otherEntityId;
+	}
+
 	/**
 	 * Merges the other SubunitCluster into this one if it contains exactly the
 	 * same Subunit. This is checked by {@link #isIdenticalTo(SubunitCluster)}.
@@ -191,7 +226,35 @@ public boolean mergeIdentical(SubunitCluster other) {
 		if (!isIdenticalTo(other))
 			return false;
 
-		logger.info("SubunitClusters are identical");
+		logger.info("SubunitClusters {}-{} are identical in sequence",
+				this.subunits.get(this.representative).getName(),
+				other.subunits.get(other.representative).getName());
+
+		this.subunits.addAll(other.subunits);
+		this.subunitEQR.addAll(other.subunitEQR);
+
+		return true;
+	}
+
+	/**
+	 * Merges the other SubunitCluster into this one if it contains exactly the
+	 * same Subunit. This is checked by comparing the entity identifiers of the subunits
+	 * if one can be found.
+	 * Thus this only makes sense when the subunits are complete chains of a
+	 * deposited PDB entry. I
+	 *
+	 * @param other
+	 *            SubunitCluster
+	 * @return true if the SubunitClusters were merged, false otherwise
+	 */
+	public boolean mergeIdenticalByEntityId(SubunitCluster other) {
+
+		if (!isIdenticalByEntityIdTo(other))
+			return false;
+
+		logger.info("SubunitClusters {}-{} belong to same entity. Assuming they are identical",
+				this.subunits.get(this.representative).getName(),
+				other.subunits.get(other.representative).getName());
 
 		this.subunits.addAll(other.subunits);
 		this.subunitEQR.addAll(other.subunitEQR);
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitClusterer.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitClusterer.java
@@ -71,7 +71,18 @@ public static Stoichiometry cluster(List<Subunit> subunits, SubunitClustererPara
 			for (int c1 = 0; c1 < clusters.size(); c1++) {
 				for (int c2 = clusters.size() - 1; c2 > c1; c2--) {
 					try {
-						if (clusters.get(c1).mergeSequence(clusters.get(c2), params)) {
+						if (params.isUseEntityIdForSeqIdentityDetermination() &&
+								clusters.get(c1).mergeIdenticalByEntityId(clusters.get(c2))) {
+							// This we will only do if the switch is for entity id comparison is on.
+							// In some cases in can save enormous amounts of time, e.g. for clustering full
+							// chains of deposited PDB entries. For instance for 6NHJ: with pure alignments it
+							// takes ~ 6 hours, with entity id comparisons it takes 2 minutes.
+							clusters.remove(c2);
+						} else if (clusters.get(c1).mergeIdentical(clusters.get(c2))) {
+							// This always makes sense as an optimization: it's far cheaper to compare the sequence
+							// string than doing a full S-W alignment
+							clusters.remove(c2);
+						} else if (clusters.get(c1).mergeSequence(clusters.get(c2), params)) {
 							clusters.remove(c2);
 						}
 
diff --git a/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitClustererParameters.java b/biojava-structure/src/main/java/org/biojava/nbio/structure/cluster/SubunitClustererParameters.java
@@ -45,6 +45,8 @@ public class SubunitClustererParameters implements Serializable {
 	private double sequenceIdentityThreshold;
 	private double sequenceCoverageThreshold = 0.75;
 
+	private boolean useEntityIdForSeqIdentityDetermination = false;
+
 	private double rmsdThreshold = 3.0;
 	private double structureCoverageThreshold = 0.75;
 	private double tmThreshold = 0.5;
@@ -506,5 +508,21 @@ public boolean isHighConfidenceScores(double sequenceIdentity, double sequenceCo
 			return sequenceIdentity>=hcSequenceIdentityLocal && sequenceCoverage >= hcSequenceCoverageLocal;
 	}
 
+	/**
+	 * Whether to use the entity id of subunits to infer that sequences are identical.
+	 * Only applies if the {@link SubunitClustererMethod} is a sequence based one.
+	 * @return
+	 */
+	public boolean isUseEntityIdForSeqIdentityDetermination() {
+		return useEntityIdForSeqIdentityDetermination;
+	}
 
+	/**
+	 * Whether to use the entity id of subunits to infer that sequences are identical.
+	 * Only applies if the {@link SubunitClustererMethod} is a sequence based one.
+	 * @param useEntityIdForSeqIdentityDetermination the flag to be set
+	 */
+	public void setUseEntityIdForSeqIdentityDetermination(boolean useEntityIdForSeqIdentityDetermination) {
+		this.useEntityIdForSeqIdentityDetermination = useEntityIdForSeqIdentityDetermination;
+	}
 }
