/**
* Constructs an AtomContainer with a copy of the atoms and electronContainers of another
* AtomContainer (A shallow copy, i.e., with the same objects as in the original AtomContainer).
*
* @param container An AtomContainer to copy the atoms and electronContainers from
*/
public AtomContainer(IAtomContainer container) {
this.atomCount = container.getAtomCount();
this.bondCount = container.getBondCount();
this.lonePairCount = container.getLonePairCount();
this.singleElectronCount = container.getSingleElectronCount();
this.atoms = new IAtom[this.atomCount];
this.bonds = new IBond[this.bondCount];
this.lonePairs = new ILonePair[this.lonePairCount];
this.singleElectrons = new ISingleElectron[this.singleElectronCount];
stereoElements = new HashSet<IStereoElement>(atomCount / 2);
for (IStereoElement element : container.stereoElements()) {
addStereoElement(element);
}
for (int f = 0; f < container.getAtomCount(); f++) {
atoms[f] = container.getAtom(f);
container.getAtom(f).addListener(this);
}
for (int f = 0; f < this.bondCount; f++) {
bonds[f] = container.getBond(f);
container.getBond(f).addListener(this);
}
for (int f = 0; f < this.lonePairCount; f++) {
lonePairs[f] = container.getLonePair(f);
container.getLonePair(f).addListener(this);
}
for (int f = 0; f < this.singleElectronCount; f++) {
singleElectrons[f] = container.getSingleElectron(f);
container.getSingleElectron(f).addListener(this);
}
}
/** Checks if the ringSet (created by SSSR) contains rings with exactly the same atoms. */
static boolean checkForDuplicateRingsInSet(IRingSet ringset) {
// Make a list of rings
List<IAtomContainer> ringList = new ArrayList<IAtomContainer>();
for (IAtomContainer atCont : ringset.atomContainers()) {
ringList.add(atCont);
}
// Outer loop over rings
for (IAtomContainer ring : ringList) {
// Inner loop over rings
for (IAtomContainer otherRing : ringList) {
if (otherRing.hashCode() != ring.hashCode()
&& otherRing.getAtomCount() == ring.getAtomCount()) {
// check if the two rings have all the same atoms in them -
// this should not happen (="duplicate" rings)
boolean sameAtoms = true;
DUP_LOOP:
for (IAtom at : ring.atoms()) {
if (!otherRing.contains(at)) {
sameAtoms = false;
break DUP_LOOP;
}
}
if (sameAtoms) {
return true;
}
}
}
}
return false;
}
/**
* 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);
}
}
}
/**
* Generates a compatibility graph between two molecules
*
* @param source
* @param target
* @param shouldMatchBonds
* @param shouldMatchRings
* @param matchAtomType
* @throws java.io.IOException
*/
public GenerateCompatibilityGraph(
IAtomContainer source,
IAtomContainer target,
boolean shouldMatchBonds,
boolean shouldMatchRings,
boolean matchAtomType)
throws IOException {
this.shouldMatchRings = shouldMatchRings;
this.shouldMatchBonds = shouldMatchBonds;
this.matchAtomType = matchAtomType;
this.source = source;
this.target = target;
compGraphNodes = new ArrayList<>();
compGraphNodesCZero = new ArrayList<>();
cEdges = Collections.synchronizedList(new ArrayList<Integer>());
dEdges = Collections.synchronizedList(new ArrayList<Integer>());
/*
Generate all possible graphs when no ring match or atom type is required
*/
/*
Modification for AAM only
*/
if ((!shouldMatchBonds || !matchAtomType)
&& source.getAtomCount() > 30
&& target.getAtomCount() > 30) {
compatibilityGraphNodesIfCEdgeIsZero();
compatibilityGraphCEdgeZero();
clearCompGraphNodesCZero();
} else {
// System.out.println("compatibilityGraphNodes ");
compatibilityGraphNodes();
// System.out.println("compatibilityGraph ");
compatibilityGraph();
// System.out.println("c-edges " + getCEgdes().size());
// System.out.println("d-edges " + getDEgdes().size());
if (getCEdgesSize() == 0) {
clearCompGraphNodes();
clearCEgdes();
clearDEgdes();
resetCEdgesSize();
resetDEdgesSize();
compatibilityGraphNodesIfCEdgeIsZero();
compatibilityGraphCEdgeZero();
clearCompGraphNodesCZero();
}
}
}
/**
* Place hydrogens connected to the provided atom <i>atom</i> using the specified
* <i>bondLength</i>.
*
* @param container atom container
* @param bondLength bond length to user
* @throws IllegalArgumentException thrown if the <i>atom</i> or <i>container</i> was null or the
* atom has connected atoms which have not been placed.
*/
@TestMethod("testNoConnections,testNullContainer,unplacedNonHydrogen")
public void placeHydrogens2D(IAtomContainer container, IAtom atom, double bondLength) {
if (container == null)
throw new IllegalArgumentException("cannot place hydrogens, no container provided");
if (atom.getPoint2d() == null)
throw new IllegalArgumentException("cannot place hydrogens on atom without coordinates");
logger.debug(
"placing hydrogens connected to atom ", atom.getSymbol(),
": ", atom.getPoint2d());
logger.debug("bond length", bondLength);
AtomPlacer atomPlacer = new AtomPlacer();
atomPlacer.setMolecule(container);
List<IAtom> connected = container.getConnectedAtomsList(atom);
IAtomContainer placed = container.getBuilder().newInstance(IAtomContainer.class);
IAtomContainer unplaced = container.getBuilder().newInstance(IAtomContainer.class);
// divide connected atoms into those which are have and haven't been placed
for (final IAtom conAtom : connected) {
if (conAtom.getPoint2d() == null) {
if (conAtom.getSymbol().equals("H")) {
unplaced.addAtom(conAtom);
} else {
throw new IllegalArgumentException(
"cannot place hydrogens, atom has connected" + " non-hydrogens without coordinates");
}
} else {
placed.addAtom(conAtom);
}
}
logger.debug("Atom placement before procedure:");
logger.debug("Centre atom ", atom.getSymbol(), ": ", atom.getPoint2d());
for (int i = 0; i < unplaced.getAtomCount(); i++) {
logger.debug("H-" + i, ": ", unplaced.getAtom(i).getPoint2d());
}
Point2d centerPlacedAtoms = GeometryTools.get2DCenter(placed);
atomPlacer.distributePartners(atom, placed, centerPlacedAtoms, unplaced, bondLength);
logger.debug("Atom placement after procedure:");
logger.debug("Centre atom ", atom.getSymbol(), ": ", atom.getPoint2d());
for (int i = 0; i < unplaced.getAtomCount(); i++) {
logger.debug("H-" + i, ": ", unplaced.getAtom(i).getPoint2d());
}
}
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);
}
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());
}
}
/**
* 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;
}
@Test
public void testMakeAtomContainer() {
IChemObjectBuilder builder = SilentChemObjectBuilder.getInstance();
IAtom atom = builder.newInstance(IAtom.class, "C");
IAtom exclude = builder.newInstance(IAtom.class, "C");
IAtom a1 = builder.newInstance(IAtom.class, "C");
IAtom a2 = builder.newInstance(IAtom.class, "C");
IBond[] bonds =
new IBond[] {
builder.newInstance(IBond.class, atom, exclude),
builder.newInstance(IBond.class, a1, a2),
builder.newInstance(IBond.class, a1, atom),
builder.newInstance(IBond.class, a2, exclude)
};
IAtomContainer part = FragmentUtils.makeAtomContainer(atom, Arrays.asList(bonds), exclude);
assertThat(part.getAtomCount(), is(3));
assertThat(part.getBondCount(), is(2));
Assert.assertTrue(part.contains(atom));
Assert.assertTrue(part.contains(a1));
Assert.assertTrue(part.contains(a2));
Assert.assertFalse(part.contains(exclude));
Assert.assertTrue(part.contains(bonds[1]));
Assert.assertTrue(part.contains(bonds[2]));
}
/**
* 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);
}
/**
* Adds all atoms and electronContainers of a given atomcontainer to this container.
*
* @param atomContainer The atomcontainer to be added
*/
public void add(IAtomContainer atomContainer) {
for (int f = 0; f < atomContainer.getAtomCount(); f++) {
if (!contains(atomContainer.getAtom(f))) {
addAtom(atomContainer.getAtom(f));
}
}
for (int f = 0; f < atomContainer.getBondCount(); f++) {
if (!contains(atomContainer.getBond(f))) {
addBond(atomContainer.getBond(f));
}
}
for (int f = 0; f < atomContainer.getLonePairCount(); f++) {
if (!contains(atomContainer.getLonePair(f))) {
addLonePair(atomContainer.getLonePair(f));
}
}
for (int f = 0; f < atomContainer.getSingleElectronCount(); f++) {
if (!contains(atomContainer.getSingleElectron(f))) {
addSingleElectron(atomContainer.getSingleElectron(f));
}
}
for (IStereoElement se : atomContainer.stereoElements()) stereoElements.add(se);
notifyChanged();
}
/**
* 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);
}
/**
* 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);
}
@Test
public void napthaleneSkeletonHeightTest() {
IAtomContainer napthalene = builder.newInstance(IAtomContainer.class);
for (int i = 0; i < 10; i++) {
napthalene.addAtom(builder.newInstance(IAtom.class, "C"));
}
napthalene.addBond(0, 1, IBond.Order.SINGLE);
napthalene.addBond(0, 5, IBond.Order.SINGLE);
napthalene.addBond(1, 2, IBond.Order.SINGLE);
napthalene.addBond(1, 6, IBond.Order.SINGLE);
napthalene.addBond(2, 3, IBond.Order.SINGLE);
napthalene.addBond(2, 9, IBond.Order.SINGLE);
napthalene.addBond(3, 4, IBond.Order.SINGLE);
napthalene.addBond(4, 5, IBond.Order.SINGLE);
napthalene.addBond(6, 7, IBond.Order.SINGLE);
napthalene.addBond(7, 8, IBond.Order.SINGLE);
napthalene.addBond(8, 9, IBond.Order.SINGLE);
MoleculeSignature molSig = new MoleculeSignature(napthalene);
int height = 2;
Map<String, Orbit> orbits = new HashMap<String, Orbit>();
for (int i = 0; i < napthalene.getAtomCount(); i++) {
String signatureString = molSig.signatureStringForVertex(i, height);
Orbit orbit;
if (orbits.containsKey(signatureString)) {
orbit = orbits.get(signatureString);
} else {
orbit = new Orbit(signatureString, height);
orbits.put(signatureString, orbit);
}
orbit.addAtom(i);
}
Assert.assertEquals(3, orbits.size());
}
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;
}
/**
* 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;
}
/**
* compGraphNodesCZero is used to build up of the edges of the compatibility graph
*
* @return
* @throws IOException
*/
private Integer compatibilityGraphNodesIfCEdgeIsZero() throws IOException {
int count_nodes = 1;
List<String> list = new ArrayList<>();
compGraphNodesCZero = new ArrayList<>(); // Initialize the compGraphNodesCZero List
LabelContainer labelContainer = LabelContainer.getInstance();
compGraphNodes.clear();
for (int i = 0; i < source.getAtomCount(); i++) {
for (int j = 0; j < target.getAtomCount(); j++) {
IAtom atom1 = source.getAtom(i);
IAtom atom2 = target.getAtom(j);
// You can also check object equal or charge, hydrogen count etc
if ((atom1 instanceof IQueryAtom)
&& ((IQueryAtom) atom1).matches(atom2)
&& !list.contains(i + "_" + j)) {
compGraphNodesCZero.add(i);
compGraphNodesCZero.add(j);
compGraphNodesCZero.add(labelContainer.getLabelID(atom2.getSymbol())); // i.e C is label 1
compGraphNodesCZero.add(count_nodes);
compGraphNodes.add(i);
compGraphNodes.add(j);
compGraphNodes.add(count_nodes);
count_nodes += 1;
list.add(i + "_" + j);
} else if (atom1.getSymbol().equalsIgnoreCase(atom2.getSymbol())
&& !list.contains(i + "_" + j)) {
compGraphNodesCZero.add(i);
compGraphNodesCZero.add(j);
compGraphNodesCZero.add(labelContainer.getLabelID(atom1.getSymbol())); // i.e C is label 1
compGraphNodesCZero.add(count_nodes);
compGraphNodes.add(i);
compGraphNodes.add(j);
compGraphNodes.add(count_nodes);
count_nodes += 1;
list.add(i + "_" + j);
}
}
}
list.clear();
return count_nodes;
}
/**
* Validates that the SSSR has found the expected number of rings of a particular size.
*
* @param ringSet constructed by SSSR.
* @param ringSizeForCounting particular ring size to count
* @param expectedNumOfRings the expected number of rings
*/
private void ringCount(IRingSet ringSet, int ringSizeForCounting, int expectedNumOfRings) {
int ringCount = 0;
for (IAtomContainer ring : ringSet.atomContainers()) {
if (ring.getAtomCount() == ringSizeForCounting) {
ringCount++;
}
}
Assert.assertTrue(
"Counting rings of size " + ringSizeForCounting, expectedNumOfRings == ringCount);
}
/**
* Creates a bucky ball molecule.
*
* @return bucky ball molecule
*/
private IAtomContainer createBuckyBall() throws CDKException {
IAtomContainer molecule = null;
String filename = "data/mdl/buckyball.mol";
InputStream ins = this.getClass().getClassLoader().getResourceAsStream(filename);
MDLV2000Reader reader = new MDLV2000Reader(ins, Mode.STRICT);
molecule = (IAtomContainer) reader.read(new AtomContainer());
Assert.assertTrue("Atom count is 60 ", molecule.getAtomCount() == 60);
Assert.assertTrue("Bond count is 90 ", molecule.getBondCount() == 90);
return molecule;
}
public InChIMoleculeCheckerResult checkMolecule(IAtomContainer mol) {
InChIMoleculeCheckerResult res = new InChIMoleculeCheckerResult();
res.emptyMol = (mol.getAtomCount() == 0);
res.bondNull = checkForNullBonds(mol);
res.atomNull = checkForNullAtoms(mol);
res.genericAtom = checkForGenericAtoms(mol);
return res;
}
private List<Bounds> generate(List<IAtomContainer> mols, RendererModel model, int atomNum)
throws CDKException {
List<Bounds> elems = new ArrayList<>();
int num = 0;
for (IAtomContainer mol : mols) {
elems.add(new Bounds(generate(mol, model, atomNum)));
atomNum += mol.getAtomCount();
}
return elems;
}
public String toSMILES() {
if ("".equals(smiles) && atomContainer instanceof IMolecule) {
if (atomContainer.getAtomCount() < 100) {
SmilesGenerator sg = new SmilesGenerator();
smiles = sg.createSMILES((IMolecule) atomContainer);
} else {
logger.warn("Not generating SMILES. " + "DBMolecule " + name + " has too many atoms.");
}
}
return smiles;
}
boolean singleAtomIsomorphism() {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
isomorphismFound = false;
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) {
isomorphismFound = true;
break;
}
}
return (isomorphismFound);
}
public List<Integer> getIsomorphismPositions(IAtomContainer container) {
target = container;
FlagStoreIsomorphismNode = false;
isomorphismNodes.clear();
List<Integer> v = new ArrayList<Integer>();
if (query.getAtomCount() == 1) {
SMARTSAtom qa = (SMARTSAtom) query.getAtom(0);
for (int i = 0; i < target.getAtomCount(); i++) {
if (qa.matches(target.getAtom(i))) v.add(new Integer(i));
}
return (v);
}
TopLayer.setAtomTopLayers(target, TopLayer.TLProp);
for (int i = 0; i < target.getAtomCount(); i++) {
executeSequenceAtPos(i);
if (isomorphismFound) v.add(new Integer(i));
}
return (v);
}
/**
* Positions the aliphatic substituents of a ring system
*
* @param rs The RingSystem for which the substituents are to be laid out
* @return A list of atoms that where laid out
*/
public IAtomContainer placeRingSubstituents(IRingSet rs, double bondLength) {
logger.debug("RingPlacer.placeRingSubstituents() start");
IRing ring = null;
IAtom atom = null;
IRingSet rings = null;
IAtomContainer unplacedPartners = rs.getBuilder().newInstance(IAtomContainer.class);
IAtomContainer sharedAtoms = rs.getBuilder().newInstance(IAtomContainer.class);
IAtomContainer primaryAtoms = rs.getBuilder().newInstance(IAtomContainer.class);
IAtomContainer treatedAtoms = rs.getBuilder().newInstance(IAtomContainer.class);
Point2d centerOfRingGravity = null;
for (int j = 0; j < rs.getAtomContainerCount(); j++) {
ring = (IRing) rs.getAtomContainer(j); /* Get the j-th Ring in RingSet rs */
for (int k = 0; k < ring.getAtomCount(); k++) {
unplacedPartners.removeAllElements();
sharedAtoms.removeAllElements();
primaryAtoms.removeAllElements();
atom = ring.getAtom(k);
rings = rs.getRings(atom);
centerOfRingGravity = GeometryTools.get2DCenter(rings);
atomPlacer.partitionPartners(atom, unplacedPartners, sharedAtoms);
atomPlacer.markNotPlaced(unplacedPartners);
try {
for (int f = 0; f < unplacedPartners.getAtomCount(); f++) {
logger.debug(
"placeRingSubstituents->unplacedPartners: "
+ (molecule.getAtomNumber(unplacedPartners.getAtom(f)) + 1));
}
} catch (Exception exc) {
}
treatedAtoms.add(unplacedPartners);
if (unplacedPartners.getAtomCount() > 0) {
atomPlacer.distributePartners(
atom, sharedAtoms, centerOfRingGravity, unplacedPartners, bondLength);
}
}
}
logger.debug("RingPlacer.placeRingSubstituents() end");
return treatedAtoms;
}
/**
* Returns the bridge atoms, that is the outermost atoms in the chain of more than two atoms which
* are shared by two rings
*
* @param sharedAtoms The atoms (n > 2) which are shared by two rings
* @return The bridge atoms, i.e. the outermost atoms in the chain of more than two atoms which
* are shared by two rings
*/
private IAtom[] getBridgeAtoms(IAtomContainer sharedAtoms) {
IAtom[] bridgeAtoms = new IAtom[2];
IAtom atom;
int counter = 0;
for (int f = 0; f < sharedAtoms.getAtomCount(); f++) {
atom = sharedAtoms.getAtom(f);
if (sharedAtoms.getConnectedAtomsList(atom).size() == 1) {
bridgeAtoms[counter] = atom;
counter++;
}
}
return bridgeAtoms;
}
/**
* compatibilityGraphCEdgeZero is used to build up of the edges of the compatibility graph BIS
*
* @return
* @throws IOException
*/
private int compatibilityGraphCEdgeZero() throws IOException {
int compGraphNodesCZeroListSize = compGraphNodesCZero.size();
for (int a = 0; a < compGraphNodesCZeroListSize; a += 4) {
int index_a = compGraphNodesCZero.get(a);
int index_aPlus1 = compGraphNodesCZero.get(a + 1);
for (int b = a + 4; b < compGraphNodesCZeroListSize; b += 4) {
int index_b = compGraphNodesCZero.get(b);
int index_bPlus1 = compGraphNodesCZero.get(b + 1);
// if element atomCont !=jIndex and atoms on the adjacent sides of the bonds are not equal
if ((a != b) && (index_a != index_b) && (index_aPlus1 != index_bPlus1)) {
IBond reactantBond;
IBond productBond;
reactantBond = source.getBond(source.getAtom(index_a), source.getAtom(index_b));
productBond = target.getBond(target.getAtom(index_aPlus1), target.getAtom(index_bPlus1));
if (reactantBond != null && productBond != null) {
addZeroEdges(reactantBond, productBond, a, b);
} else if (reactantBond == null
&& productBond == null
&& source.getAtomCount() < 50
&& target.getAtomCount() < 50) {
// 50 unique condition to speed up the AAM
dEdges.add((a / 4) + 1);
dEdges.add((b / 4) + 1);
}
}
}
}
// Size of C and D edges of the compatibility graph
cEdgesSize = cEdges.size();
dEdgesSize = dEdges.size();
return 0;
}
private Map<IAtom, List<String>> labelAtomsBySymbol(IAtomContainer atomCont) {
Map<IAtom, List<String>> label_list = new HashMap<>();
for (int i = 0; i < atomCont.getAtomCount(); i++) {
List<String> label = new ArrayList<>(7);
for (int a = 0; a < 7; a++) {
label.add(a, "Z9");
}
IAtom refAtom = atomCont.getAtom(i);
/*
* Important Step: Discriminate between source atom types
*/
String referenceAtom;
if (refAtom instanceof IQueryAtom) {
referenceAtom =
((IQueryAtom) refAtom).getSymbol() == null ? "*" : ((IQueryAtom) refAtom).getSymbol();
// System.out.println("referenceAtom " + referenceAtom);
} else if (!(refAtom instanceof IQueryAtom) && this.matchAtomType) {
referenceAtom =
refAtom.getAtomTypeName() == null ? refAtom.getSymbol() : refAtom.getAtomTypeName();
} else {
referenceAtom = refAtom.getSymbol();
}
label.set(0, referenceAtom);
List<IAtom> connAtoms = atomCont.getConnectedAtomsList(refAtom);
int counter = 1;
for (IAtom negAtom : connAtoms) {
String neighbouringAtom;
if (refAtom instanceof IQueryAtom) {
neighbouringAtom =
((IQueryAtom) negAtom).getSymbol() == null ? "*" : ((IQueryAtom) negAtom).getSymbol();
// System.out.println("neighbouringAtom " + neighbouringAtom);
} else if (!(negAtom instanceof IQueryAtom) && this.matchAtomType) {
neighbouringAtom =
negAtom.getAtomTypeName() == null ? negAtom.getSymbol() : negAtom.getAtomTypeName();
} else {
neighbouringAtom = negAtom.getSymbol();
}
label.set(counter, neighbouringAtom);
counter += 1;
}
// System.out.println("label " + label);
bubbleSort(label);
label_list.put(refAtom, label);
}
return label_list;
}
/**
* Removes all atoms and electronContainers of a given atomcontainer from this container.
*
* @param atomContainer The atomcontainer to be removed
*/
public void remove(IAtomContainer atomContainer) {
for (int f = 0; f < atomContainer.getAtomCount(); f++) {
removeAtom(atomContainer.getAtom(f));
}
for (int f = 0; f < atomContainer.getBondCount(); f++) {
removeBond(atomContainer.getBond(f));
}
for (int f = 0; f < atomContainer.getLonePairCount(); f++) {
removeLonePair(atomContainer.getLonePair(f));
}
for (int f = 0; f < atomContainer.getSingleElectronCount(); f++) {
removeSingleElectron(atomContainer.getSingleElectron(f));
}
}
/**
* Generated coordinates for a given ring. Multiplexes to special handlers for the different
* possible situations (spiro-, fusion-, bridged attachement)
*
* @param ring The ring to be placed
* @param sharedAtoms The atoms of this ring, also members of another ring, which are already
* placed
* @param sharedAtomsCenter The geometric center of these atoms
* @param ringCenterVector A vector pointing the the center of the new ring
* @param bondLength The standard bondlength
*/
public void placeRing(
IRing ring,
IAtomContainer sharedAtoms,
Point2d sharedAtomsCenter,
Vector2d ringCenterVector,
double bondLength) {
int sharedAtomCount = sharedAtoms.getAtomCount();
logger.debug("placeRing -> sharedAtomCount: " + sharedAtomCount);
if (sharedAtomCount > 2) {
placeBridgedRing(ring, sharedAtoms, sharedAtomsCenter, ringCenterVector, bondLength);
} else if (sharedAtomCount == 2) {
placeFusedRing(ring, sharedAtoms, sharedAtomsCenter, ringCenterVector, bondLength);
} else if (sharedAtomCount == 1) {
placeSpiroRing(ring, sharedAtoms, sharedAtomsCenter, ringCenterVector, bondLength);
}
}