fixed rare issue non-thread-safe default InventorTemplate list

Author: thsa

src/main/java/com/actelion/research/chem/coords/InventorDefaultTemplateList.java

@@ -35,6 +35,7 @@
 package com.actelion.research.chem.coords;
 
 import com.actelion.research.chem.IDCodeParserWithoutCoordinateInvention;
+import com.actelion.research.chem.Molecule;
 import com.actelion.research.chem.SSSearcherWithIndex;
 import com.actelion.research.chem.StereoMolecule;
 
@@ -48,23 +49,24 @@ public class InventorDefaultTemplateList extends ArrayList<InventorTemplate> {
 	private static final String[] DEFAULT_TEMPLATE = {
 			// fullerene
 			"gkvt@@@@LddTTTrbTRTRTRRRRRRRRRRRRRrVRrIh\\IAaQxlY@gRHdJCJcRXlv_CfJx|A\\hRHejiLaQjTje^kSjtFcIhvXmVKMjt{lN{Kavy\\^wGjjjjjjjjjjjjjjjjjjjjjjjjjjjjjjh@@vo@HBC@PhLN@bPhtFKCcpDbILaRhtzCIbsX\\nOO`JDbqDjSKdJeJmQjtz}Ahr[LVkMnpz\\nwGj{PBhBdBlBBBjBfBnBaBiBeBmBcBkBgBoB`bhbdblbbbjbfbnbabibebmbcbkbgbob`RhRdRlRbRjRfRnRaRiReRmRcRkRgRoR`rhrdrlrbrjrfrnrarirermrcrkrgror`JhJdJlJbJjJfJnJaJiJeJmJcJkJgJoJ`jhjdjljbjjjfjnjajijej` !BnkjyVwsVr|iQn|Q|goTZWPIJwbudnRkVYBez]siZymNJZUqNFBqZWxS~iCXVU]SeRjwrtSPAjkvXLpBAZauDPzq]PfMlecrMnkv|@\\SFD`m|mWiEoCXp`SIe_J[l|[XCbloTV`[Gc@FJGopyyoOlFQfUy^w\\Bgz|",
-			"gcrt@@@@LdbbbbTRbRbRbRRRRRRRRRRRRVRrVQIA`HtRGAaIxZAHfShTjCIbqylQGKgqdBaXeQJeruBiPitZmFoPZLFSYbvZlVGMnsZ]vWSmr{]UUUUUUUUUUUUUUUUUUUUUUUUUUUUUT@@[G`DAA`HTFG@QHTZCEaqxBQDfPiTZ]AdqYlNWGgpEBQXbUIerEReVhuZ]^`tYMfKUfwX]NW[jkPBhBdBlBbBjBfBnBaBiBeBmBcBkBgBoB`bhbdblbbbjbfbnbabibebmbcbkbgbob`RhRdRlRbRjRfRnRaRiReRmRcRkRgRoR`rhrdrlrbrjrfrnrarirermrcrkrgror`JhJdJlJbJjJfJnJaJiJeJmJcJkJgJoJ`jhjdjljbjjjfjnjajij` !B^cR]`]Fm]QkfljE\\p\u007FUVfgOmFXsQe_gXPyXis_wF|vUUX_XbxpzU]HUFgYViwFo~@uemc@}~T\u007FIEPioYVwr]JnM~[ZEC\\g}~o_pUfdo~irsklTLiyVJshnw^iVAsZ`_~}PYkckURH{FYMImFaRaccUlCZSHMfP",
+			"gcrt@@@@LdbbbbTRbRbRbRRRRRRRRRRRRVRrVQIA`HtRGAaIxZAHfShTjCIbqylQGKgqdBaXeQJeruBiPitZmFoPZLFSYbvZlVGMnsZ]vWSmr{]UUUUUUUUUUUUUUUUUUUUUUUUUUUUUT@@[G`DAA`HTFG@QHTZCEaqxBQDfPiTZ]AdqYlNWGgpEBQXbUIerEReVhuZ]^`tYMfKUfwX]NW[jkPBhBdBlBbBjBfBnBaBiBeBmBcBkBgBoB`bhbdblbbbjbfbnbabibebmbcbkbgbob`RhRdRlRbRjRfRnRaRiReRmRcRkRgRoR`rhrdrlrbrjrfrnrarirermrcrkrgror`JhJdJlJbJjJfJnJaJiJeJmJcJkJgJoJ`jhjdjljbjjjfjnjajij` !B^cR]`]Fm]QkfljE\\p?UVfgOmFXsQe_gXPyXis_wF|vUUX_XbxpzU]HUFgYViwFo~@uemc@}~T?IEPioYVwr]JnM~[ZEC\\g}~o_pUfdo~irsklTLiyVJshnw^iVAsZ`_~}PYkckURH{FYMImFaRaccUlCZSHMfP",
 
 			// adamantane
 			"dml@@Dje^VGiyZjjjh@vtHSBinFU@ !BPTCTy[skMzUPF`AJbBixEZHS[Il",
 			"dml@@DjYVvGiyZjjjh@vtHSBinFU@ !BwLo~BJ~UquhXBinZ\\ykA@F_eMrT",
-			"dml@@LdfbbQX^fUZjjj`C[PaLJfxYT !BzxIHVc{OiJVRpprePho~]}y\u007FwLl",
-			"deL@@DjUYkfEijjjj@MeBDpj[ad !B\u007FaA\u007FMVr[AvkKzm_jKvVbD{sk",
+			"dml@@LdfbbQX^fUZjjj`C[PaLJfxYT !BzxIHVc{OiJVRpprePho~]}y?wLl",
+			"deL@@DjUYkfEijjjj@MeBDpj[ad !B?aA?MVr[AvkKzm_jKvVbD{sk",
 
 			// cubane
-			"dil@@LddTQRl[NX^Fjjjj@MiBDpj[a@ !BPfL@\u007Fox@M~T@\u007Fox@\u007F`C~@@",
+			"dil@@LddTQRl[NX^Fjjjj@MiBDpj[a@ !BPfL@?ox@M~T@?ox@?`C~@@",
 			"daL@@DjYtKJqjynjjjj@MaBDpj[` !B`bL@_gx@@Gy~@Gx@_`@",
 	};
 
 	public InventorDefaultTemplateList() {
 		SSSearcherWithIndex searcher = new SSSearcherWithIndex();
 		for (String idcode:DEFAULT_TEMPLATE) {
 			StereoMolecule fragment = new IDCodeParserWithoutCoordinateInvention().getCompactMolecule(idcode);
+			fragment.ensureHelperArrays(Molecule.cHelperCIP);
 			long[] ffp = searcher.createLongIndex(fragment);
 			InventorTemplate template = new InventorTemplate(fragment, ffp, false);
 			template.normalizeCoordinates();

src/main/java/com/actelion/research/chem/coords/InventorTemplate.java

@@ -3,10 +3,10 @@
 import com.actelion.research.chem.StereoMolecule;
 
 public class InventorTemplate {
-	private StereoMolecule mFragment;
-	private long[] mFFP;
+	private final StereoMolecule mFragment;
+	private final long[] mFFP;
 	private double mAVBL;
-	private boolean mKeepAbsoluteOrientation;
+	private final boolean mKeepAbsoluteOrientation;
 
 	public InventorTemplate(StereoMolecule fragment, long[] ffp, boolean keepAbsoluteOrientation) {
 		mFragment = fragment;

src/main/java/org/openmolecules/chem/conf/gen/BaseConformer.java

@@ -37,13 +37,13 @@ public class BaseConformer extends Conformer {
 	private static final int ESCAPE_STEPS = 4;	// how often we apply this rotation trying to solve the collision
 	private static final double MIN_ESCAPE_GAIN_PER_STEP = 0.05;
 
-	private short[][] mTorsion;
-	private short[][] mFrequency;
-	private double[][] mLikelyhood; // considering directly connected rigid fragments (frequency and collision strain)
-	private int[] mBestTorsionIndex;
-	private RotatableBond[] mRotatableBond;
-	private ArrayList<TorsionSetEliminationRule> mEliminationRuleList;
-	private Random mRandom;
+	private final short[][] mTorsion;
+	private final short[][] mFrequency;
+	private final double[][] mLikelyhood; // considering directly connected rigid fragments (frequency and collision strain)
+	private final int[] mBestTorsionIndex;
+	private final RotatableBond[] mRotatableBond;
+	private final ArrayList<TorsionSetEliminationRule> mEliminationRuleList;
+	private final Random mRandom;
 	private int mConformerCount;
 
 	public BaseConformer(StereoMolecule mol, RigidFragment[] rigidFragment, RotatableBond[] rotatableBond, int[] fragmentPermutation, Random random) {
@@ -116,9 +116,9 @@ public ArrayList<TorsionSetEliminationRule> getEliminationRules() {
 	}
 
 	/**
-	 * Calculates a random torsion index giving torsions with higher likelyhoods
+	 * Calculates a random torsion index giving torsions with higher likelihoods
 	 * (i.e. frequencies and collision strains) a higher chance to be selected.
-	 * With a progress value of 0.0 selection likelyhoods are proportional to
+	 * With a progress value of 0.0 selection likelihoods are proportional to
 	 * the torsion frequencies. With increasing progress value the higher frequent
 	 * torsions are less and less preferred until 1.0 without any preference.
 	 * @param random

src/main/java/org/openmolecules/chem/conf/gen/RigidFragment.java

@@ -77,6 +77,21 @@ public double getConformerLikelihood(int i) {
 		return mConformerLikelihood[i];
 	}
 
+	/**
+	 * Returns the conformer index with the lowest strain.
+	 */
+	public int getMostLikelyConformerIndex() {
+		double highestLikelihood = 0;
+		int highestIndex = -1;
+		for (int t=0; t<mConformerLikelihood.length; t++) {
+			if (highestLikelihood < mConformerLikelihood[t]) {
+				highestLikelihood = mConformerLikelihood[t];
+				highestIndex = t;
+			}
+		}
+		return highestIndex;
+	}
+
 	/**
 	 * Calculates a random conformer index giving conformers with lower strains
 	 * a higher chance to be selected. With a progress value of 0.0 selection

src/main/java/org/openmolecules/chem/conf/gen/RotatableBond.java

@@ -37,7 +37,7 @@
 /**
  * A RotatableBond knows the two rigid fragments within a molecule
  * that are connected by this bond. It also knows about possible torsion
- * states with associated likelyhoods, which are taken from COD statistics
+ * states with associated likelihoods, which are taken from COD statistics
  * and modified to account for collisions due to bulky groups in the molecule.
  * It knows the smaller half of the molecule and rotate the smaller half to
  * a given torsion angle.
@@ -47,15 +47,17 @@ public class RotatableBond {
 	private static final short[] SIXTY_DEGREE_FREQUENCY = { 17, 17, 17, 17, 17, 17};
 	private static final short[][] SIXTY_DEGREE_RANGE = { {-20,20},{40,80},{100,140},{160,200},{220,260},{280,320}};
 
-	private RigidFragment mFragment1,mFragment2;
+	private final RigidFragment mFragment1,mFragment2;
 	private String mTorsionID;
-	private int mRotationCenter,mBond,mFragmentNo1,mFragmentNo2;
-	private boolean mBondAtomsInFragmentOrder;
+	private int mRotationCenter;
+	private final int mBond,mFragmentNo1,mFragmentNo2;
+	private final boolean mBondAtomsInFragmentOrder;
 	private float mBondRelevance;
 	private short[] mDefaultTorsion;
 	private short[] mDefaultFrequency;
 	private short[][] mDefaultTorsionRange;
-	private int[] mTorsionAtom,mRearAtom,mSmallerSideAtomList;
+	private final int[] mTorsionAtom,mRearAtom;
+	private int[] mSmallerSideAtomList;
 
 	public RotatableBond(StereoMolecule mol, int bond, int[] fragmentNo, int[] disconnectedFragmentNo,
 	                     int disconnectedFragmentSize, RigidFragment[] fragment) {
@@ -64,8 +66,6 @@ public RotatableBond(StereoMolecule mol, int bond, int[] fragmentNo, int[] disco
 
 	public RotatableBond(StereoMolecule mol, int bond, int[] fragmentNo, int[] disconnectedFragmentNo,
 	                     int disconnectedFragmentSize, RigidFragment[] fragment, boolean use60degreeSteps) {
-if (TorsionDB.getTorsionFrequencies("gGP`@dfyjidNcGI[WQCP`<")[0]==-1)
-	System.out.println("ERROR");
 		mBond = bond;
 		mTorsionAtom = new int[4];
 		mRearAtom = new int[2];
@@ -85,10 +85,6 @@ public RotatableBond(StereoMolecule mol, int bond, int[] fragmentNo, int[] disco
 
 		mBondAtomsInFragmentOrder = (fragmentNo[mol.getBondAtom(0, bond)] == mFragmentNo1);
 
-if (TorsionDB.getTorsionFrequencies("gGP`@dfyjidNcGI[WQCP`<")[0]==-1)
-	System.out.println("ERROR");
-
-
 		if (use60degreeSteps) {
 			mDefaultTorsion = SIXTY_DEGREE_TORSION;
 			mDefaultFrequency = SIXTY_DEGREE_FREQUENCY;
@@ -150,7 +146,7 @@ private void predictAtomSequence(StereoMolecule mol) {
         	}
 
     	// A TorsionPrediction does not distinguish hetero atoms from carbons a positions 0 and 3.
-        // Therefore we can treat two sp2 neighbors as equivalent when predicting torsions.
+        // Therefore, we can treat two sp2 neighbors as equivalent when predicting torsions.
         if (mol.getAtomPi(mTorsionAtom[1]) == 0 && mol.getConnAtoms(mTorsionAtom[1]) == 3) {
 			mTorsionAtom[0] = -1;
         	}
@@ -266,13 +262,6 @@ public short[][] getDefaultTorsionRanges() {
 		return mDefaultTorsionRange;
 	}
 
-	/**
-	 * @return the likelyhood of torsion i among all torsions of this bond
-	 **
-	public double getTorsionLikelyhood(int t) {
-		return mLikelyhood[t];
-		}   */
-
 	/**
 	 * @return atoms of the smaller half of the molecule excluding anchor atom
 	 */

src/main/java/org/openmolecules/chem/conf/gen/TorsionSetStrategy.java

@@ -74,20 +74,23 @@ public abstract class TorsionSetStrategy {
 	protected ConformerGenerator mConformerGenerator;
 	protected RotatableBond[] mRotatableBond;
 	protected RigidFragment[] mRigidFragment;
-	private TorsionSetEncoder mTorsionSetEncoder;
-	private int mFragmentCount,mCollisionCount,mMaxTotalCount,mPermutationCount,mSuccessCount;
+	private final TorsionSetEncoder mTorsionSetEncoder;
+	private int mCollisionCount;
+	private int mMaxTotalCount;
+	private int mPermutationCount;
+	private int mSuccessCount;
 	private boolean mUsingSecondChoices;
-	private int[][][] mBondsBetweenFragments;
-	private int[][] mConnFragmentNo;
-	private int[][] mConnRotatableBondNo;
-	private int[] mGraphFragment;
-	private int[] mGraphBond;
-	private int[] mGraphParent;
-	private boolean[] mGraphFragmentHandled;
+	private final int[][][] mBondsBetweenFragments;
+	private final int[][] mConnFragmentNo;
+	private final int[][] mConnRotatableBondNo;
+	private final int[] mGraphFragment;
+	private final int[] mGraphBond;
+	private final int[] mGraphParent;
+	private final boolean[] mGraphFragmentHandled;
 	private double mLowestCollisionStrain;
-	private UniqueList<TorsionSet> mTorsionSetList;
-	private SortedList<TorsionSet> mSecondChoiceList;
-	private SortedList<TorsionSetWithEliminationRuleStrain> mStrainedTorsionSetCache;
+	private final UniqueList<TorsionSet> mTorsionSetList;
+	private final SortedList<TorsionSet> mSecondChoiceList;
+	private final SortedList<TorsionSetWithEliminationRuleStrain> mStrainedTorsionSetCache;
 	private TorsionSet mBestUnacceptableTorsionSet;
 
 	public TorsionSetStrategy(ConformerGenerator conformerGenerator) {
@@ -97,10 +100,10 @@ public TorsionSetStrategy(ConformerGenerator conformerGenerator) {
 		mTorsionSetEncoder = new TorsionSetEncoder(mRigidFragment, mRotatableBond);
 
 		// create arrays of neighbor fragment no's
-		mFragmentCount = 0;
+		int fragmentCount = 0;
 		for (RotatableBond rb:mRotatableBond)
-			mFragmentCount = Math.max(mFragmentCount, Math.max(1+rb.getFragmentNo(0), 1+rb.getFragmentNo(1)));
-		int[] count = new int[mFragmentCount];
+			fragmentCount = Math.max(fragmentCount, Math.max(1+rb.getFragmentNo(0), 1+rb.getFragmentNo(1)));
+		int[] count = new int[fragmentCount];
 		for (RotatableBond rb:mRotatableBond) {
 			count[rb.getFragmentNo(0)]++;
 			count[rb.getFragmentNo(1)]++;
@@ -123,14 +126,14 @@ public TorsionSetStrategy(ConformerGenerator conformerGenerator) {
 			count[f2]++;
 			}
 
-		mGraphFragment = new int[mFragmentCount];
-		mGraphBond = new int[mFragmentCount];
-		mGraphParent = new int[mFragmentCount];
-		mGraphFragmentHandled = new boolean[mFragmentCount];
+		mGraphFragment = new int[fragmentCount];
+		mGraphBond = new int[fragmentCount];
+		mGraphParent = new int[fragmentCount];
+		mGraphFragmentHandled = new boolean[fragmentCount];
 
 		// initialize array for rotatable bond sequences from fragment pairs
-		mBondsBetweenFragments = new int[mFragmentCount][][];
-		for (int f1=1; f1<mFragmentCount; f1++) {
+		mBondsBetweenFragments = new int[fragmentCount][][];
+		for (int f1 = 1; f1<fragmentCount; f1++) {
 			mBondsBetweenFragments[f1] = new int[f1][];
 			for (int f2=0; f2<f1; f2++)
 				mBondsBetweenFragments[f1][f2] = getRotatableBondsBetween(f1, f2);
@@ -484,9 +487,9 @@ protected double[] getBondAndFragmentCollisionIntensities(TorsionSet collidingTo
 
 
 	/**
-	 * With best current knowledge about colliding torsion combinations
+	 * With the best current knowledge about colliding torsion combinations
 	 * and based on the individual frequencies of currently active torsions
-	 * this method returns the conformers's overall contribution to the
+	 * this method returns the conformer's overall contribution to the
 	 * total set of non colliding conformers.
 	 * @return this conformer's contribution to all conformers
 	 */

src/main/java/org/openmolecules/chem/conf/gen/TorsionSetStrategyAdaptiveRandom.java

@@ -32,14 +32,14 @@
 
 public class TorsionSetStrategyAdaptiveRandom extends TorsionSetStrategyRandom {
 	private static final int MAX_TRIES_FOR_NEW = 64;
-	private boolean mStartWithMostProbable;
+	private final boolean mStartWithMostProbable;
 
 	/**
 	 * This torsion set strategy produces random sets of torsion indices until a torsion set
 	 * collides. Then it updates individual torsion indices of those rotatable bonds
 	 * that connect colliding fragments.
 	 * Torsion indices are picked either by pure random or with a twisted likelyhood
-	 * towards towards those angles, that show higher frequencies in the CSD.
+	 * towards those angles, that show higher frequencies in the COD/CSD.
 	 * @param conformerGenerator
 	 * @param preferLikelyTorsions if set then more frequent torsions are picked with higher probability
 	 * @param startWithMostProbable if true then the first torsion set returned contains for every bond the most frequent torsion
@@ -53,12 +53,8 @@ public TorsionSetStrategyAdaptiveRandom(ConformerGenerator conformerGenerator, b
 
 	@Override
 	public TorsionSet createTorsionSet(TorsionSet previousTorsionSet) {
-		if (previousTorsionSet == null) {
-			if (mStartWithMostProbable)
-				return createTorsionSet(new int[mRotatableBond.length], new int[mRigidFragment.length]);
-			else
-				return super.createTorsionSet(null);
-			}
+		if (previousTorsionSet == null)
+			return super.createTorsionSet(mStartWithMostProbable);
 
 		if (previousTorsionSet.getCollisionStrainSum() == 0.0)
 			return super.createTorsionSet(previousTorsionSet);

src/main/java/org/openmolecules/chem/conf/gen/TorsionSetStrategyLikelySystematic.java

@@ -36,7 +36,8 @@
  * @author Thomas Sander
  */
 public class TorsionSetStrategyLikelySystematic extends TorsionSetStrategy {
-	private int[]			mCurrentMaxTorsionIndex,mCurrentMaxConformerIndex;
+	private final int[]		mCurrentMaxTorsionIndex;
+	private final int[]		mCurrentMaxConformerIndex;
 	private TorsionSet[]	mAvailableTorsionSet;
 	private int				mAvailableTorsionSetIndex;
 

src/main/java/org/openmolecules/chem/conf/gen/TorsionSetStrategyRandom.java

@@ -32,8 +32,8 @@
 
 public class TorsionSetStrategyRandom extends TorsionSetStrategy {
 	private static final int MAX_TRIES_FOR_NEW = 64;
-	private Random mRandom;
-	private boolean mPreferLikelyTorsions;
+	private final Random mRandom;
+	private final boolean mPreferLikelyTorsions;
 
 	/**
 	 * This simple TorsionSetStrategy produces random sets of torsion indexes in a loop.
@@ -64,6 +64,14 @@ public Random getRandom() {
 	 */
 	@Override
 	public TorsionSet createTorsionSet(TorsionSet previousTorsionSet) {
+		return createTorsionSet(mPreferLikelyTorsions);
+	}
+
+	/**
+	 * Build a new set of torsion angles by pure or biased random picking.
+	 * @return a random and new torsion index set.
+	 */
+	public TorsionSet createTorsionSet(boolean startWithMostProbable) {
 		if (getTorsionSetCount() == getPermutationCount())
 			return null;	// if we have found all permutations
 
@@ -76,7 +84,14 @@ public TorsionSet createTorsionSet(TorsionSet previousTorsionSet) {
 			if (count++ == MAX_TRIES_FOR_NEW)
 				return null;
 
-			if (mPreferLikelyTorsions) {
+			if (startWithMostProbable && getTorsionSetCount() == 0) {
+				for (int rf=0; rf<mRigidFragment.length; rf++)
+					conformerIndex[rf] = mRigidFragment[rf].getMostLikelyConformerIndex();
+				BaseConformer baseConformer = mConformerGenerator.getBaseConformer(conformerIndex);
+				for (int rb=0; rb<mRotatableBond.length; rb++)
+					torsionIndex[rb] = baseConformer.getMostLikelyTorsionIndexes()[rb];
+				}
+			else if (mPreferLikelyTorsions) {
 				double progress = (double)count/(double)MAX_TRIES_FOR_NEW;
 				for (int rf=0; rf<mRigidFragment.length; rf++)
 					conformerIndex[rf] = mRigidFragment[rf].getLikelyRandomConformerIndex(mRandom.nextDouble(), progress);