void expandNode(Node node) {
// System.out.println(node.toString(target));
QuerySequenceElement el = sequence.get(node.sequenceElNum);
if (el.center == null) // This node describers a bond that closes a ring
{
// Checking whether this bond is present in the target
IAtom tAt0 = node.atoms[query.getAtomNumber(el.atoms[0])];
IAtom tAt1 = node.atoms[query.getAtomNumber(el.atoms[1])];
IBond tBo = target.getBond(tAt0, tAt1);
if (tBo != null)
if (el.bonds[0].matches(tBo)) {
node.sequenceElNum++;
// stack.push(node);
if (node.sequenceElNum == sequence.size()) {
// The node is not added in the stack if the end of the sequence is reached
isomorphismFound = true;
if (FlagStoreIsomorphismNode) isomorphismNodes.add(node);
} else stack.push(node);
}
} else {
targetAt.clear();
IAtom tAt = node.atoms[el.centerNum];
List<IAtom> conAt = target.getConnectedAtomsList(tAt);
for (int i = 0; i < conAt.size(); i++) {
if (!containsAtom(node.atoms, conAt.get(i))) targetAt.add(conAt.get(i));
}
if (el.atoms.length <= targetAt.size()) generateNodes(node);
}
}
void executeSequence(boolean stopAtFirstMapping) {
isomorphismFound = false;
stack.clear();
// Initial nodes
QuerySequenceElement el = sequence.get(0);
for (int k = 0; k < target.getAtomCount(); k++) {
IAtom at = target.getAtom(k);
if (el.center.matches(at)) {
Node node = new Node();
node.sequenceElNum = 0;
node.nullifyAtoms(query.getAtomCount());
node.atoms[el.centerNum] = at;
stack.push(node);
}
}
// Expanding the tree of all possible mappings
if (stopAtFirstMapping) {
while (!stack.isEmpty()) {
expandNode(stack.pop());
if (isomorphismFound) break;
}
} else {
while (!stack.isEmpty()) expandNode(stack.pop());
}
}
/** A unit test for JUnit */
@Test
public void testPartitioning() {
String smiles = "";
IAtomContainer molecule = new AtomContainer();
SmilesGenerator sg = new SmilesGenerator();
Atom sodium = new Atom("Na");
sodium.setFormalCharge(+1);
Atom hydroxyl = new Atom("O");
hydroxyl.setImplicitHydrogenCount(1);
hydroxyl.setFormalCharge(-1);
molecule.addAtom(sodium);
molecule.addAtom(hydroxyl);
try {
smiles = sg.createSMILES(molecule);
} catch (Exception exc) {
System.out.println(exc);
if (!standAlone) {
Assert.fail();
}
}
if (standAlone) {
System.err.println("SMILES: " + smiles);
}
Assert.assertTrue(smiles.indexOf(".") != -1);
}
/**
* If no isomorphism is found the result is empty vector
*
* @param container
* @return
*/
public List<List<IAtom>> getAllIsomorphismMappings(IAtomContainer container) {
if (query == null) return null;
target = container;
FlagStoreIsomorphismNode = true;
isomorphismNodes.clear();
List<List<IAtom>> result = new ArrayList<List<IAtom>>();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
List<IAtom> v = new ArrayList<IAtom>();
v.add(target.getAtom(i));
result.add(v);
}
}
return result;
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequence(false);
if (isomorphismFound) {
// Getting the data from the all stored Nodes
for (int k = 0; k < isomorphismNodes.size(); k++) {
Node node = isomorphismNodes.get(k);
List<IAtom> v = new ArrayList<IAtom>();
for (int i = 0; i < node.atoms.length; i++) v.add(node.atoms[i]);
result.add(v);
}
}
return result;
}
/**
* Performs the pharmacophore matching.
*
* @param atomContainer The target molecule. Must have 3D coordinates
* @param initializeTarget If <i>true</i>, the target molecule specified in the first argument
* will be analyzed to identify matching pharmacophore groups. If <i>false</i> this is not
* performed. The latter case is only useful when dealing with conformers since for a given
* molecule, all conformers will have the same pharmacophore groups and only the constraints
* will change from one conformer to another.
* @return true is the target molecule contains the query pharmacophore
* @throws org.openscience.cdk.exception.CDKException if the query pharmacophore was not set or
* the query is invalid or if the molecule does not have 3D coordinates
*/
public boolean matches(IAtomContainer atomContainer, boolean initializeTarget)
throws CDKException {
if (!GeometryUtil.has3DCoordinates(atomContainer))
throw new CDKException("Molecule must have 3D coordinates");
if (pharmacophoreQuery == null)
throw new CDKException("Must set the query pharmacophore before matching");
if (!checkQuery(pharmacophoreQuery))
throw new CDKException(
"A problem in the query. Make sure all pharmacophore groups of the same symbol have the same same SMARTS");
String title = (String) atomContainer.getProperty(CDKConstants.TITLE);
if (initializeTarget) pharmacophoreMolecule = getPharmacophoreMolecule(atomContainer);
else {
// even though the atoms comprising the pcore groups are
// constant, their coords will differ, so we need to make
// sure we get the latest set of effective coordinates
for (IAtom iAtom : pharmacophoreMolecule.atoms()) {
PharmacophoreAtom patom = (PharmacophoreAtom) iAtom;
List<Integer> tmpList = new ArrayList<Integer>();
for (int idx : patom.getMatchingAtoms()) tmpList.add(idx);
Point3d coords = getEffectiveCoordinates(atomContainer, tmpList);
patom.setPoint3d(coords);
}
}
if (pharmacophoreMolecule.getAtomCount() < pharmacophoreQuery.getAtomCount()) {
logger.debug("Target [" + title + "] did not match the query SMARTS. Skipping constraints");
return false;
}
mappings = Pattern.findSubstructure(pharmacophoreQuery).matchAll(pharmacophoreMolecule);
// XXX: doing one search then discarding
return mappings.atLeast(1);
}
public String perceiveCDKAtomTypes(IMolecule mol)
throws InvocationTargetException {
ICDKMolecule cdkmol;
try {
cdkmol = cdk.asCDKMolecule(mol);
}
catch ( BioclipseException e ) {
e.printStackTrace();
throw new InvocationTargetException(
e, "Error while creating a ICDKMolecule" );
}
IAtomContainer ac = cdkmol.getAtomContainer();
CDKAtomTypeMatcher cdkMatcher
= CDKAtomTypeMatcher.getInstance(ac.getBuilder());
StringBuffer result = new StringBuffer();
int i = 1;
for (IAtom atom : ac.atoms()) {
IAtomType type = null;
try {
type = cdkMatcher.findMatchingAtomType(ac, atom);
}
catch ( CDKException e ) {}
result.append(i).append(':').append(
type != null ? type.getAtomTypeName() : "null"
).append('\n'); // FIXME: should use NEWLINE here
i++;
}
return result.toString();
}
public void addHydrogens(IAtomContainer mol, IAtom atom, int n) {
for (int i = 0; i < n; i++) {
IAtom h = builder.newInstance(IAtom.class, "H");
mol.addAtom(h);
mol.addBond(builder.newInstance(IBond.class, atom, h));
}
}
/**
* Performs a breadthFirstSearch in an AtomContainer starting with a particular sphere, which
* usually consists of one start atom, and searches for a pi system.
*
* @param container The AtomContainer to be searched
* @param sphere A sphere of atoms to start the search with
* @param path A ArrayList which stores the atoms belonging to the pi system
* @throws org.openscience.cdk.exception.CDKException Description of the Exception
*/
private void breadthFirstSearch(IAtomContainer container, List<IAtom> sphere, List<IAtom> path)
throws CDKException {
IAtom atom;
IAtom nextAtom;
List<IAtom> newSphere = new ArrayList<IAtom>();
// logger.debug("Start of breadthFirstSearch");
for (int i = 0; i < sphere.size(); i++) {
atom = sphere.get(i);
// logger.debug("BreadthFirstSearch around atom " + (atomNr + 1));
List<IBond> bonds = container.getConnectedBondsList(atom);
for (IBond bond : bonds) {
nextAtom = bond.getConnectedAtom(atom);
if ((!nextAtom.getFlag(CDKConstants.ISAROMATIC) && !nextAtom.getFlag(CDKConstants.ISINRING))
& !nextAtom.getFlag(CDKConstants.VISITED)) {
// logger.debug("BDS> AtomNr:"+container.getAtomNumber(nextAtom)+"
// maxBondOrder:"+container.getMaximumBondOrder(nextAtom)+"
// Aromatic:"+nextAtom.getFlag(CDKConstants.ISAROMATIC)+"
// FormalCharge:"+nextAtom.getFormalCharge()+" Charge:"+nextAtom.getCharge()+"
// Flag:"+nextAtom.getFlag(CDKConstants.VISITED));
path.add(nextAtom);
// logger.debug("BreadthFirstSearch is meeting new atom " + (nextAtomNr + 1));
nextAtom.setFlag(CDKConstants.VISITED, true);
if (container.getConnectedBondsCount(nextAtom) > 1) {
newSphere.add(nextAtom);
}
} else {
nextAtom.setFlag(CDKConstants.VISITED, true);
}
}
}
if (newSphere.size() > 0) {
breadthFirstSearch(container, newSphere, path);
}
}
@Test
public void methyleneCyclopropeneTest() {
IAtomContainer mol = builder.newInstance(IAtomContainer.class);
AbstractSignatureTest.addCarbons(mol, 4);
AbstractSignatureTest.addHydrogens(mol, 1, 2);
AbstractSignatureTest.addHydrogens(mol, 2, 1);
AbstractSignatureTest.addHydrogens(mol, 3, 1);
mol.addBond(0, 1, IBond.Order.DOUBLE);
mol.addBond(0, 2, IBond.Order.SINGLE);
mol.addBond(0, 3, IBond.Order.SINGLE);
mol.addBond(2, 3, IBond.Order.DOUBLE);
MoleculeSignature molSig = new MoleculeSignature(mol);
String sigFor2Height1 = molSig.signatureStringForVertex(2, 1);
String sigFor3Height1 = molSig.signatureStringForVertex(3, 1);
Assert.assertTrue(
"Height 1 signatures for atoms 2 and 3" + " should be the same",
sigFor2Height1.equals(sigFor3Height1));
String sigFor2Height2 = molSig.signatureStringForVertex(2, 1);
String sigFor3Height2 = molSig.signatureStringForVertex(3, 1);
Assert.assertTrue(
"Height 2 signatures for atoms 2 and 3" + " should be the same",
sigFor2Height2.equals(sigFor3Height2));
}
public static IAtomContainer getMcsAsNewContainer(IAtomContainer mol1, IAtomContainer mol2)
throws CDKException, CloneNotSupportedException {
Isomorphism mcs = new Isomorphism(org.openscience.cdk.smsd.interfaces.Algorithm.DEFAULT, true);
mcs.init(mol1, mol2, true, true);
mcs.setChemFilters(true, true, true);
mol1 = mcs.getReactantMolecule();
mol2 = mcs.getProductMolecule();
IAtomContainer mcsmolecule =
DefaultChemObjectBuilder.getInstance().newInstance(IAtomContainer.class, mol1);
List<IAtom> atomsToBeRemoved = new ArrayList<IAtom>();
for (IAtom atom : mcsmolecule.atoms()) {
int index = mcsmolecule.getAtomNumber(atom);
if (!mcs.getFirstMapping().containsKey(index)) {
atomsToBeRemoved.add(atom);
}
}
for (IAtom atom : atomsToBeRemoved) {
mcsmolecule.removeAtomAndConnectedElectronContainers(atom);
}
return mcsmolecule;
}
public void timeFile(File dir, String filename) throws CDKException, IOException {
IAtomContainer atomContainer = readFile(new File(dir, filename));
long start;
start = System.currentTimeMillis();
EquivalentClassPartitioner it = new EquivalentClassPartitioner(atomContainer);
int equivalentClass[] = it.getTopoEquivClassbyHuXu(atomContainer);
Partition huXuPartition = ArrayToPartition.convert(equivalentClass, 1);
long elapsedHuXu = System.currentTimeMillis() - start;
start = System.currentTimeMillis();
AtomDiscretePartitionRefiner refiner = new AtomDiscretePartitionRefiner();
refiner.refine(atomContainer);
Partition refinedPartition = refiner.getAutomorphismPartition();
long elapsedRef = System.currentTimeMillis() - start;
long order = refiner.getAutomorphismGroup().order();
boolean partitionsEqual = refinedPartition.equals(huXuPartition);
System.out.println(
filename
+ "\t"
+ atomContainer.getAtomCount()
+ "\t"
+ elapsedRef
+ "\t"
+ elapsedHuXu
+ "\t"
+ order
+ "\t"
+ refinedPartition.size()
+ "\t"
+ partitionsEqual);
}
/**
* Procedure required by the CDOInterface. This function is only supposed to be called by the JCFL
* library
*/
public void endObject(String objectType) {
logger.debug("END: " + objectType);
if (objectType.equals("Molecule")) {
eventReader.fireFrameRead();
clearData();
} else if (objectType.equals("Atom")) {
currentMolecule.addAtom(currentAtom);
} else if (objectType.equals("Bond")) {
logger.debug("Bond(" + bond_id + "): " + bond_a1 + ", " + bond_a2 + ", " + bond_order);
if (bond_a1 > currentMolecule.getAtomCount() || bond_a2 > currentMolecule.getAtomCount()) {
logger.error(
"Cannot add bond between at least one non-existant atom: "
+ bond_a1
+ " and "
+ bond_a2);
} else {
IAtom a1 = currentMolecule.getAtom(bond_a1);
IAtom a2 = currentMolecule.getAtom(bond_a2);
IBond b = builder.newBond(a1, a2, bond_order);
if (bond_id != null) b.setID(bond_id);
if (bond_stereo != -99) {
b.setStereo(bond_stereo);
}
currentMolecule.addBond(b);
}
}
}
/**
* This function returns null if no isomorphism is found
*
* @param container
* @return
*/
public List<IAtom> getIsomorphismMapping(IAtomContainer container) {
if (query == null) return null;
target = container;
FlagStoreIsomorphismNode = true;
isomorphismNodes.clear();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
List<IAtom> v = new ArrayList<IAtom>();
v.add(target.getAtom(i));
return (v);
}
}
return null;
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
executeSequence(true);
if (isomorphismFound) {
// Getting the data from the Node
Node node = isomorphismNodes.get(0);
List<IAtom> v = new ArrayList<IAtom>();
for (int i = 0; i < node.atoms.length; i++) v.add(node.atoms[i]);
return (v);
} else return (null);
}
/**
* Calculates the eccentric connectivity
*
* @param container Parameter is the atom container.
* @return An IntegerResult value representing the eccentric connectivity index
*/
@TestMethod("testCalculate_IAtomContainer")
public DescriptorValue calculate(IAtomContainer container) {
IAtomContainer local = AtomContainerManipulator.removeHydrogens(container);
int natom = local.getAtomCount();
int[][] admat = AdjacencyMatrix.getMatrix(local);
int[][] distmat = PathTools.computeFloydAPSP(admat);
int eccenindex = 0;
for (int i = 0; i < natom; i++) {
int max = -1;
for (int j = 0; j < natom; j++) {
if (distmat[i][j] > max) max = distmat[i][j];
}
int degree = local.getConnectedBondsCount(i);
eccenindex += max * degree;
}
IntegerResult retval = new IntegerResult(eccenindex);
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
retval,
getDescriptorNames(),
null);
}
@Test
public void testGetChiralAtom() {
TetrahedralChirality chirality =
new TetrahedralChirality(molecule.getAtom(1), ligands, Stereo.CLOCKWISE);
Assert.assertNotNull(chirality);
Assert.assertEquals(molecule.getAtom(1), chirality.getChiralAtom());
}
private static void replaceReferencesWithClones(final IChemModel chemModel)
throws CDKException {
// we make references in products/reactants clones, since same compounds
// in different reactions need separate layout (different positions etc)
if (chemModel.getReactionSet() != null) {
for (final IReaction reaction : chemModel.getReactionSet()
.reactions()) {
int i = 0;
final IAtomContainerSet products = reaction.getProducts();
for (final IAtomContainer product : products.atomContainers()) {
try {
products.replaceAtomContainer(i, product.clone());
} catch (final CloneNotSupportedException e) {
}
i++;
}
i = 0;
final IAtomContainerSet reactants = reaction.getReactants();
for (final IAtomContainer reactant : reactants.atomContainers()) {
try {
reactants.replaceAtomContainer(i, reactant.clone());
} catch (final CloneNotSupportedException e) {
}
i++;
}
}
}
}
public IAtomContainer cyclopentylcyclopentane() {
IAtom[] atoms =
new IAtom[] {
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
new Atom("C"),
};
IBond[] bonds =
new IBond[] {
new Bond(atoms[0], atoms[1], SINGLE),
new Bond(atoms[0], atoms[4], SINGLE),
new Bond(atoms[1], atoms[2], SINGLE),
new Bond(atoms[2], atoms[3], SINGLE),
new Bond(atoms[3], atoms[4], SINGLE),
new Bond(atoms[5], atoms[6], SINGLE),
new Bond(atoms[5], atoms[9], SINGLE),
new Bond(atoms[6], atoms[7], SINGLE),
new Bond(atoms[7], atoms[8], SINGLE),
new Bond(atoms[8], atoms[9], SINGLE),
new Bond(atoms[8], atoms[0], SINGLE),
};
IAtomContainer mol = new AtomContainer(0, 0, 0, 0);
mol.setAtoms(atoms);
mol.setBonds(bonds);
return mol;
}
/**
* Returns a CIP-expanded array of side chains of a ligand. If the ligand atom is only connected
* to the chiral atom, the method will return an empty list. The expansion involves the CIP rules,
* so that a double bonded oxygen will be represented twice in the list.
*
* @param ligand the {@link ILigand} for which to return the ILigands
* @return a {@link ILigand} array with the side chains of the ligand atom
*/
@TestMethod("testGetLigandLigands")
public static ILigand[] getLigandLigands(ILigand ligand) {
if (ligand instanceof TerminalLigand) return new ILigand[0];
IAtomContainer container = ligand.getAtomContainer();
IAtom ligandAtom = ligand.getLigandAtom();
IAtom centralAtom = ligand.getCentralAtom();
VisitedAtoms visitedAtoms = ligand.getVisitedAtoms();
List<IBond> bonds = container.getConnectedBondsList(ligandAtom);
// duplicate ligands according to bond order, following the CIP rules
List<ILigand> ligands = new ArrayList<ILigand>();
for (IBond bond : bonds) {
if (bond.contains(centralAtom)) {
if (Order.SINGLE == bond.getOrder()) continue;
int duplication = getDuplication(bond.getOrder()) - 1;
if (duplication > 0) {
for (int i = 1; i <= duplication; i++) {
ligands.add(new TerminalLigand(container, visitedAtoms, ligandAtom, centralAtom));
}
}
} else {
int duplication = getDuplication(bond.getOrder());
IAtom connectedAtom = bond.getConnectedAtom(ligandAtom);
if (visitedAtoms.isVisited(connectedAtom)) {
ligands.add(new TerminalLigand(container, visitedAtoms, ligandAtom, connectedAtom));
} else {
ligands.add(new Ligand(container, visitedAtoms, ligandAtom, connectedAtom));
}
for (int i = 2; i <= duplication; i++) {
ligands.add(new TerminalLigand(container, visitedAtoms, ligandAtom, connectedAtom));
}
}
}
return ligands.toArray(new ILigand[0]);
}
/**
* Generate Compatibility Graph Nodes
*
* @return
* @throws IOException
*/
private int compatibilityGraphNodes() throws IOException {
compGraphNodes.clear();
Set<Edge> edges = new HashSet<>();
int nodeCount = 1;
Map<IAtom, List<String>> labelAtomsBySymbolA = labelAtomsBySymbol(source);
Map<IAtom, List<String>> labelAtomsBySymbolB = labelAtomsBySymbol(target);
for (Map.Entry<IAtom, List<String>> labelA : labelAtomsBySymbolA.entrySet()) {
// System.err.println("labelA.getValue() " + labelA.getValue());
for (Map.Entry<IAtom, List<String>> labelB : labelAtomsBySymbolB.entrySet()) {
IAtom atom = labelA.getKey();
if (((atom instanceof IQueryAtom) && ((IQueryAtom) atom).matches(labelB.getKey()))
|| (!(atom instanceof IQueryAtom)
&& atom.getSymbol().equals(labelB.getKey().getSymbol()))) {
// System.err.println("labelB.getValue() " + labelB.getValue());
int atomNumberI = source.getAtomNumber(labelA.getKey());
int atomNumberJ = target.getAtomNumber(labelB.getKey());
Edge e = new Edge(atomNumberI, atomNumberJ);
if (!edges.contains(e)) {
edges.add(e);
compGraphNodes.add(atomNumberI);
compGraphNodes.add(atomNumberJ);
compGraphNodes.add(nodeCount);
nodeCount += 1;
}
}
}
}
return 0;
}
/**
* Selects an optimum edge for elimination in structures without N2 nodes.
*
* <p>This might be severely broken! Would have helped if there was an explanation of how this
* algorithm worked.
*
* @param ring
* @param molecule
*/
private IBond checkEdges(IRing ring, IAtomContainer molecule) {
IRing r1, r2;
IRingSet ringSet = ring.getBuilder().newInstance(IRingSet.class);
IBond bond;
int minMaxSize = Integer.MAX_VALUE;
int minMax = 0;
logger.debug("Molecule: " + molecule);
Iterator<IBond> bonds = ring.bonds().iterator();
while (bonds.hasNext()) {
bond = (IBond) bonds.next();
molecule.removeElectronContainer(bond);
r1 = getRing(bond.getAtom(0), molecule);
r2 = getRing(bond.getAtom(1), molecule);
logger.debug("checkEdges: " + bond);
if (r1.getAtomCount() > r2.getAtomCount()) {
ringSet.addAtomContainer(r1);
} else {
ringSet.addAtomContainer(r2);
}
molecule.addBond(bond);
}
for (int i = 0; i < ringSet.getAtomContainerCount(); i++) {
if (((IRing) ringSet.getAtomContainer(i)).getBondCount() < minMaxSize) {
minMaxSize = ((IRing) ringSet.getAtomContainer(i)).getBondCount();
minMax = i;
}
}
return (IBond) ring.getElectronContainer(minMax);
}
/**
* removes all bonds connected to the given atom leaving it with degree zero.
*
* @param atom The atom to be disconnecred
* @param molecule The molecule containing the atom
*/
private void trim(IAtom atom, IAtomContainer molecule) {
List<IBond> bonds = molecule.getConnectedBondsList(atom);
for (int i = 0; i < bonds.size(); i++) {
molecule.removeElectronContainer((IBond) bonds.get(i));
}
// you are erased! Har, har, har..... >8-)
}
/**
* Returns the ring that is formed by the atoms in the given vector.
*
* @param vec The vector that contains the atoms of the ring
* @param mol The molecule this ring is a substructure of
* @return The ring formed by the given atoms
*/
private IRing prepareRing(List vec, IAtomContainer mol) {
// add the atoms in vec to the new ring
int atomCount = vec.size();
IRing ring = mol.getBuilder().newInstance(IRing.class, atomCount);
IAtom[] atoms = new IAtom[atomCount];
vec.toArray(atoms);
ring.setAtoms(atoms);
// add the bonds in mol to the new ring
try {
IBond b;
for (int i = 0; i < atomCount - 1; i++) {
b = mol.getBond(atoms[i], atoms[i + 1]);
if (b != null) {
ring.addBond(b);
} else {
logger.error("This should not happen.");
}
}
b = mol.getBond(atoms[0], atoms[atomCount - 1]);
if (b != null) {
ring.addBond(b);
} else {
logger.error("This should not happen either.");
}
} catch (Exception exc) {
logger.debug(exc);
}
logger.debug("found Ring ", ring);
return ring;
}
/**
* @param list
* @param source
* @param target
*/
protected synchronized void identifySingleAtomsMatchedParts(
List<CDKRMap> list, IAtomContainer source, IAtomContainer target) {
// List<IAtom> array1 = new ArrayList<>();
// List<IAtom> array2 = new ArrayList<>();
/* We have serial numbers of the bonds/Atoms to delete
* Now we will collect the actual bond/Atoms rather than
* serial number for deletion. RonP flag check whether reactant is
* mapped on product or Vise Versa
*/
TreeMap<Integer, Integer> atomNumbersFromContainer = new TreeMap<>();
for (CDKRMap rmap : list) {
// System.err.print("Map " + o.getClass());
IAtom sAtom = source.getAtom(rmap.getId1());
IAtom tAtom = target.getAtom(rmap.getId2());
// array1.add(sAtom);
// array2.add(tAtom);
int indexI = source.getAtomNumber(sAtom);
int indexJ = target.getAtomNumber(tAtom);
atomNumbersFromContainer.put(indexI, indexJ);
/*Added the Mapping Numbers to the FinalMapping*
*/
getMappings().add(atomNumbersFromContainer);
}
}
@TestMethod("testCalculate_IAtomContainer")
public DescriptorValue calculate(IAtomContainer container) {
// removeHydrogens does a deep copy, so no need to clone
IAtomContainer localAtomContainer = AtomContainerManipulator.removeHydrogens(container);
CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.getInstance(container.getBuilder());
Iterator<IAtom> atoms = localAtomContainer.atoms().iterator();
while (atoms.hasNext()) {
IAtom atom = atoms.next();
IAtomType type;
try {
type = matcher.findMatchingAtomType(localAtomContainer, atom);
AtomTypeManipulator.configure(atom, type);
} catch (Exception e) {
return getDummyDescriptorValue(new CDKException("Error in atom typing: " + e.getMessage()));
}
}
CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(container.getBuilder());
try {
hAdder.addImplicitHydrogens(localAtomContainer);
} catch (CDKException e) {
return getDummyDescriptorValue(
new CDKException("Error in hydrogen addition: " + e.getMessage()));
}
List subgraph3 = order3(localAtomContainer);
List subgraph4 = order4(localAtomContainer);
List subgraph5 = order5(localAtomContainer);
List subgraph6 = order6(localAtomContainer);
double order3s = ChiIndexUtils.evalSimpleIndex(localAtomContainer, subgraph3);
double order4s = ChiIndexUtils.evalSimpleIndex(localAtomContainer, subgraph4);
double order5s = ChiIndexUtils.evalSimpleIndex(localAtomContainer, subgraph5);
double order6s = ChiIndexUtils.evalSimpleIndex(localAtomContainer, subgraph6);
double order3v, order4v, order5v, order6v;
try {
order3v = ChiIndexUtils.evalValenceIndex(localAtomContainer, subgraph3);
order4v = ChiIndexUtils.evalValenceIndex(localAtomContainer, subgraph4);
order5v = ChiIndexUtils.evalValenceIndex(localAtomContainer, subgraph5);
order6v = ChiIndexUtils.evalValenceIndex(localAtomContainer, subgraph6);
} catch (CDKException e) {
return getDummyDescriptorValue(
new CDKException("Error in substructure search: " + e.getMessage()));
}
DoubleArrayResult retval = new DoubleArrayResult();
retval.add(order3s);
retval.add(order4s);
retval.add(order5s);
retval.add(order6s);
retval.add(order3v);
retval.add(order4v);
retval.add(order5v);
retval.add(order6v);
return new DescriptorValue(
getSpecification(), getParameterNames(), getParameters(), retval, getDescriptorNames());
}
/**
* Helper method, used to help construct a configuration.
*
* @param atom
* @param container
* @return the array position of atom in container
*/
private int getAtomPosition(IAtom atom, IAtomContainer container) {
for (int i = 0; i < container.getAtomCount(); i++) {
if (atom.equals(container.getAtom(i))) {
return i;
}
}
return -1;
}
/**
* Helper method, used to help construct a configuration.
*
* @param bond
* @param container
* @return the array position of the bond in the container
*/
private int getBondPosition(IBond bond, IAtomContainer container) {
for (int i = 0; i < container.getBondCount(); i++) {
if (bond.equals(container.getBond(i))) {
return i;
}
}
return -1;
}
public static IAtomContainer makeFragment4() {
IAtomContainer mol = DefaultChemObjectBuilder.getInstance().newInstance(IAtomContainer.class);
mol.addAtom(new Atom("C")); // 0
mol.addAtom(new Atom("C")); // 1
mol.addBond(0, 1, IBond.Order.SINGLE); // 1
return mol;
}
public int findFirstAtomIndexForSymbol(IAtomContainer container, String symbol) {
for (int i = 0; i < container.getAtomCount(); i++) {
if (container.getAtom(i).getSymbol().equals(symbol)) {
return i;
}
}
return -1;
}
private double caclModelScale(Collection<IAtomContainer> mols) {
List<IBond> bonds = new ArrayList<>();
for (IAtomContainer mol : mols) {
for (IBond bond : mol.bonds()) {
bonds.add(bond);
}
}
return calcModelScaleForBondLength(medianBondLength(bonds));
}
/**
* Creates a ligand attached to a single chiral atom, where the involved atoms are identified by
* there index in the {@link IAtomContainer}. For ligand atom, {@link #HYDROGEN} can be passed as
* index, which will indicate the presence of an implicit hydrogen, not explicitly present in the
* chemical graph of the given <code>container</code>.
*
* @param container {@link IAtomContainer} for which the returned {@link ILigand}s are defined
* @param visitedAtoms a list of atoms already visited in the analysis
* @param chiralAtom an integer pointing to the {@link IAtom} index of the chiral atom
* @param ligandAtom an integer pointing to the {@link IAtom} index of the {@link ILigand}
* @return the created {@link ILigand}
*/
public static ILigand defineLigand(
IAtomContainer container, VisitedAtoms visitedAtoms, int chiralAtom, int ligandAtom) {
if (ligandAtom == HYDROGEN) {
return new ImplicitHydrogenLigand(container, visitedAtoms, container.getAtom(chiralAtom));
} else {
return new Ligand(
container, visitedAtoms, container.getAtom(chiralAtom), container.getAtom(ligandAtom));
}
}
