org.biojava.nbio.structure.symmetry.internal.CESymmParameters Maven / Gradle / Ivy
Show all versions of biojava-structure Show documentation
/*
* BioJava 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.
*
* For more information on the BioJava project and its aims,
* or to join the biojava-l mailing list, visit the home page
* at:
*
* http://www.biojava.org/
*
*/
package org.biojava.nbio.structure.symmetry.internal;
import java.util.List;
import java.util.Random;
import org.biojava.nbio.structure.align.ce.CeParameters;
/**
* Provides parameters to {@link CeSymm}.
*
* @author Spencer Bliven
* @author Aleix Lafita
* @since 4.1.1
*
*/
public class CESymmParameters extends CeParameters {
private int maxSymmOrder;
private int userOrder;
private SymmetryType symmType;
private OrderDetectorMethod orderDetectorMethod;
private RefineMethod refineMethod;
private boolean optimization;
private int rndSeed;
private int symmLevels;
private double unrefinedScoreThreshold;
private double refinedScoreThreshold;
private int sseThreshold;
private int minCoreLength;
private double distanceCutoff;
private boolean gaps;
private int optimizationSteps;
public static enum OrderDetectorMethod {
SEQUENCE_FUNCTION, GRAPH_COMPONENT, ANGLE, USER_INPUT;
public static final OrderDetectorMethod DEFAULT = SEQUENCE_FUNCTION;
}
public static enum RefineMethod {
NOT_REFINED, SEQUENCE_FUNCTION, GRAPH_COMPONENT;
public static final RefineMethod DEFAULT = SEQUENCE_FUNCTION;
}
public static final double DEFAULT_SYMMETRY_THRESHOLD = 0.4;
/**
* The internal symmetry detection can be divided into two types: CLOSE:
* includes the circular and dihedral symmetries, and OPEN: includes the
* helical and protein repeats symmetries.
*
* All internal symmetry cases share one property: all the repeats have the
* same 3D transformation.
*
* AUTO option automatically identifies the type. The criterion for
* classification is that the CLOSE symmetry generates CeSymm alignments
* with circular permutations (2 blocks in AFPChain), whereas the OPEN
* symmetry generates alignments without a CP (only one block in AFPChain).
*/
public enum SymmetryType {
CLOSED, OPEN, AUTO;
public static final SymmetryType DEFAULT = AUTO;
}
public CESymmParameters() {
reset();
}
@Override
public CESymmParameters clone() {
return new CESymmParameters(this);
}
public CESymmParameters(CESymmParameters o) {
this.maxSymmOrder = o.maxSymmOrder;
this.symmType = o.symmType;
this.orderDetectorMethod = o.orderDetectorMethod;
this.userOrder = o.userOrder;
this.refineMethod = o.refineMethod;
this.optimization = o.optimization;
this.rndSeed = o.rndSeed;
this.symmLevels = o.symmLevels;
this.unrefinedScoreThreshold = o.unrefinedScoreThreshold;
this.refinedScoreThreshold = o.refinedScoreThreshold;
this.sseThreshold = o.sseThreshold;
this.minCoreLength = o.minCoreLength;
this.distanceCutoff = o.distanceCutoff;
this.gaps = o.gaps;
this.optimizationSteps = o.optimizationSteps;
this.winSize = o.winSize;
this.rmsdThr = o.rmsdThr;
this.rmsdThrJoin = o.rmsdThrJoin;
this.scoringStrategy = o.scoringStrategy;
this.maxGapSize = o.maxGapSize;
this.showAFPRanges = o.showAFPRanges;
this.maxOptRMSD = o.maxOptRMSD;
this.gapOpen = o.gapOpen;
this.gapExtension = o.gapExtension;
this.distanceIncrement = o.distanceIncrement;
this.oRmsdThr = o.oRmsdThr;
this.maxNrIterationsForOptimization = o.maxNrIterationsForOptimization;
this.seqWeight = o.seqWeight;
}
@Override
public void reset() {
super.reset();
maxSymmOrder = 8;
symmType = SymmetryType.DEFAULT;
orderDetectorMethod = OrderDetectorMethod.DEFAULT;
userOrder = 0;
refineMethod = RefineMethod.DEFAULT;
optimization = true;
rndSeed = new Random().nextInt(10000);
symmLevels = 0;
unrefinedScoreThreshold = DEFAULT_SYMMETRY_THRESHOLD;
refinedScoreThreshold = DEFAULT_SYMMETRY_THRESHOLD * 0.9;
sseThreshold = 0;
minCoreLength = 15;
distanceCutoff = 7.0;
gaps = true;
optimizationSteps = 0;
}
@Override
public List getUserConfigHelp() {
List params = super.getUserConfigHelp();
// maxSymmOrder help explanation
params.add("Sets the maximum order of symmetry of the protein.");
// userOrder help explanation
params.add("Order of symmetry determined by the user. "
+ "Use it with the USER_INPUT order option. Imposes an order"
+ " of symmetry to the alignment. If 0 the order is set "
+ "automatically.");
StringBuilder symmTypes = new StringBuilder("Type of Symmetry: ");
SymmetryType[] vals = SymmetryType.values();
if (vals.length == 1) {
symmTypes.append(vals[0].name());
} else if (vals.length > 1) {
for (int i = 0; i < vals.length - 1; i++) {
symmTypes.append(vals[i].name());
symmTypes.append(", ");
}
symmTypes.append("or ");
symmTypes.append(vals[vals.length - 1].name());
}
params.add(symmTypes.toString());
StringBuilder orderTypes = new StringBuilder("Order Detection Method: ");
OrderDetectorMethod[] vals2 = OrderDetectorMethod.values();
if (vals2.length == 1) {
orderTypes.append(vals2[0].name());
} else if (vals2.length > 1) {
for (int i = 0; i < vals2.length - 1; i++) {
orderTypes.append(vals2[i].name());
orderTypes.append(", ");
}
orderTypes.append("or ");
orderTypes.append(vals[vals.length - 1].name());
}
params.add(orderTypes.toString());
StringBuilder refineTypes = new StringBuilder("Refinement Method: ");
RefineMethod[] values = RefineMethod.values();
if (values.length == 1) {
refineTypes.append(values[0].name());
} else if (values.length > 1) {
for (int i = 0; i < values.length - 1; i++) {
refineTypes.append(values[i].name());
refineTypes.append(", ");
}
refineTypes.append("or ");
refineTypes.append(values[values.length - 1].name());
}
params.add(refineTypes.toString());
// optimization help explanation
params.add("Optimize the refined alignment if true.");
// seed help explanation
params.add("Random seed for the Monte Carlo optimization, "
+ "for reproducibility of results.");
// symmetry levels
params.add("Specify the maximum number of symmetry levels to explore "
+ "recursively. If equal to 1, only C and H symmetries can be "
+ "found. If equal to 2, D and two-level hierarchical C and H "
+ "can be found, etc. If equal to 0, the number of recursive "
+ "iterations is unbounded (until thresholds reached).");
// unrefined score threshold
params.add("Unrefined score threshold: TM-score values for the optimal"
+ " self-alignment, before refinement, below the "
+ "threshold will be considered asymmetric.");
// refined score threshold
params.add("Refined score threshold: TM-score values for the refined "
+ "multiple alignment of repeats below the "
+ "threshold will be considered asymmetric.");
// SSE threshold
params.add("SSE threshold: The minimum number of secondary structure "
+ "elements (strands or helices) in each symmetrical repeat. "
+ "If the repeats do not have enough SSE, the structure will "
+ "be considered asymmetric. 0 means no restriction.");
// min core repeat length
params.add("Minimum core length: the minimum number of non-gapped "
+ "residues in every symmetric repeat.");
// distance cutoff
params.add("Distance Cutoff: the maximum allowed distance (in A) "
+ "between two aligned residues.");
// gaps
params.add("Internal Gaps: allow up to 50% of repeats to have gaps in "
+ "the multiple alignment if true, "
+ "otherwise all repeats must be aligned at each position.");
// optimization steps
params.add("Optimization Steps: maximum number of optimization steps:"
+ " 0 means calculated automatically with the alignment length.");
return params;
}
@Override
public List getUserConfigParameters() {
List params = super.getUserConfigParameters();
params.add("MaxSymmOrder");
params.add("UserOrder");
params.add("SymmType");
params.add("OrderDetectorMethod");
params.add("RefineMethod");
params.add("Optimization");
params.add("RndSeed");
params.add("SymmLevels");
params.add("UnrefinedScoreThreshold");
params.add("RefinedScoreThreshold");
params.add("SSEThreshold");
params.add("MinCoreLength");
params.add("DistanceCutoff");
params.add("Gaps");
params.add("OptimizationSteps");
return params;
}
@Override
public List getUserConfigParameterNames() {
List params = super.getUserConfigParameterNames();
params.add("Maximum Order of Symmetry");
params.add("User Input Order");
params.add("Type of Symmetry");
params.add("Order Detection Method");
params.add("Refinement Method");
params.add("Optimization");
params.add("Random Seed");
params.add("Symmetry Levels");
params.add("Unrefined Score Threshold");
params.add("Refined Score Threshold");
params.add("SSE Threshold");
params.add("Minimum Core Length");
params.add("Distance Cutoff");
params.add("Internal Gaps");
params.add("Optimization Steps");
return params;
}
@Override
@SuppressWarnings("rawtypes")
public List getUserConfigTypes() {
List params = super.getUserConfigTypes();
params.add(Integer.class);
params.add(Integer.class);
params.add(SymmetryType.class);
params.add(OrderDetectorMethod.class);
params.add(RefineMethod.class);
params.add(Boolean.class);
params.add(Integer.class);
params.add(Integer.class);
params.add(Double.class);
params.add(Double.class);
params.add(Integer.class);
params.add(Integer.class);
params.add(Double.class);
params.add(Boolean.class);
params.add(Integer.class);
return params;
}
public RefineMethod getRefineMethod() {
return refineMethod;
}
public void setRefineMethod(RefineMethod refineMethod) {
this.refineMethod = refineMethod;
}
@Deprecated
public void setRefineResult(boolean doRefine) {
if (!doRefine) {
refineMethod = RefineMethod.NOT_REFINED;
} else {
refineMethod = RefineMethod.DEFAULT;
}
}
public OrderDetectorMethod getOrderDetectorMethod() {
return orderDetectorMethod;
}
public void setOrderDetectorMethod(OrderDetectorMethod orderDetectorMethod) {
this.orderDetectorMethod = orderDetectorMethod;
}
public void setUserOrder(Integer userOrder) {
this.userOrder = userOrder;
}
public int getUserOrder() {
return userOrder;
}
public void setMaxSymmOrder(Integer maxSymmOrder) {
this.maxSymmOrder = maxSymmOrder;
}
public int getMaxSymmOrder() {
return maxSymmOrder;
}
public SymmetryType getSymmType() {
return symmType;
}
public void setSymmType(SymmetryType type) {
this.symmType = type;
}
public boolean getOptimization() {
return optimization;
}
public void setOptimization(Boolean optimization) {
this.optimization = optimization;
}
public int getRndSeed() {
return rndSeed;
}
public void setRndSeed(Integer seed) {
this.rndSeed = seed;
}
public int getSymmLevels() {
return symmLevels;
}
public void setSymmLevels(Integer symmLevels) {
this.symmLevels = symmLevels;
}
public double getUnrefinedScoreThreshold() {
return unrefinedScoreThreshold;
}
public void setUnrefinedScoreThreshold(Double unrefinedScoreThreshold) {
this.unrefinedScoreThreshold = unrefinedScoreThreshold;
}
public double getRefinedScoreThreshold() {
return refinedScoreThreshold;
}
public void setRefinedScoreThreshold(Double refinedScoreThreshold) {
this.refinedScoreThreshold = refinedScoreThreshold;
}
public int getSSEThreshold() {
return sseThreshold;
}
public void setSSEThreshold(Integer sseThreshold) {
this.sseThreshold = sseThreshold;
}
public int getMinCoreLength() {
return minCoreLength;
}
public void setMinCoreLength(Integer minCoreLength) {
this.minCoreLength = minCoreLength;
}
public double getDistanceCutoff() {
return distanceCutoff;
}
public void setDistanceCutoff(Double distanceCutoff) {
this.distanceCutoff = distanceCutoff;
}
public boolean isGaps() {
return gaps;
}
public void setGaps(Boolean gaps) {
this.gaps = gaps;
}
public int getOptimizationSteps() {
return optimizationSteps;
}
public void setOptimizationSteps(Integer optimizationSteps) {
this.optimizationSteps = optimizationSteps;
}
@Override
public String toString() {
return "CESymmParameters [maxSymmOrder=" + maxSymmOrder
+ ", userOrder=" + userOrder + ", symmType=" + symmType
+ ", orderDetectorMethod=" + orderDetectorMethod
+ ", refineMethod=" + refineMethod + ", optimization="
+ optimization + ", rndSeed=" + rndSeed + ", symmLevels="
+ symmLevels + ", unrefinedScoreThreshold="
+ unrefinedScoreThreshold + ", refinedScoreThreshold="
+ refinedScoreThreshold + ", sseThreshold=" + sseThreshold
+ ", minCoreLength=" + minCoreLength + ", distanceCutoff="
+ distanceCutoff + ", gaps=" + gaps + ", optimizationSteps="
+ optimizationSteps + "]";
}
}