/**
* set the active center for this molecule. The active center will be those which correspond with
* [A*]-B=C .
*
* <pre>
* A: Atom with single electron
* -: Single bond
* B: Atom
* =: Double bond
* C: Atom
* </pre>
*
* @param reactant The molecule to set the activity
* @throws CDKException
*/
private void setActiveCenters(IAtomContainer reactant) throws CDKException {
if (AtomContainerManipulator.getTotalNegativeFormalCharge(reactant)
!= 0 /*|| AtomContainerManipulator.getTotalPositiveFormalCharge(reactant) != 0*/) return;
Iterator<IAtom> atoms = reactant.atoms().iterator();
while (atoms.hasNext()) {
IAtom atomi = atoms.next();
if (reactant.getConnectedSingleElectronsCount(atomi) == 1) {
Iterator<IBond> bondis = reactant.getConnectedBondsList(atomi).iterator();
while (bondis.hasNext()) {
IBond bondi = bondis.next();
if (bondi.getOrder() == IBond.Order.SINGLE) {
IAtom atomj = bondi.getConnectedAtom(atomi);
if ((atomj.getFormalCharge() == CDKConstants.UNSET ? 0 : atomj.getFormalCharge()) == 0
&& reactant.getConnectedSingleElectronsCount(atomj) == 0) {
Iterator<IBond> bondjs = reactant.getConnectedBondsList(atomj).iterator();
while (bondjs.hasNext()) {
IBond bondj = bondjs.next();
if (bondj.equals(bondi)) continue;
if (bondj.getOrder() == IBond.Order.DOUBLE) {
IAtom atomk = bondj.getConnectedAtom(atomj);
if ((atomk.getFormalCharge() == CDKConstants.UNSET ? 0 : atomk.getFormalCharge())
== 0
&& reactant.getConnectedSingleElectronsCount(atomk) == 0) {
atomi.setFlag(CDKConstants.REACTIVE_CENTER, true);
atomj.setFlag(CDKConstants.REACTIVE_CENTER, true);
atomk.setFlag(CDKConstants.REACTIVE_CENTER, true);
bondi.setFlag(CDKConstants.REACTIVE_CENTER, true);
bondj.setFlag(CDKConstants.REACTIVE_CENTER, true);
}
}
}
}
}
}
}
}
}
/**
* set the active center for this molecule. The active center will be those which correspond with
* A-B-[C*].
*
* <pre>
* A: Atom
* -: bond
* B: Atom
* -: bond
* C: Atom with single electron
* </pre>
*
* @param reactant The molecule to set the activity
* @throws CDKException
*/
private void setActiveCenters(IMolecule reactant) throws CDKException {
Iterator<IAtom> atoms = reactant.atoms().iterator();
while (atoms.hasNext()) {
IAtom atomi = atoms.next();
if (reactant.getConnectedSingleElectronsCount(atomi) == 1 && atomi.getFormalCharge() == 1) {
Iterator<IBond> bondis = reactant.getConnectedBondsList(atomi).iterator();
while (bondis.hasNext()) {
IBond bondi = bondis.next();
if (bondi.getOrder() == IBond.Order.SINGLE) {
IAtom atomj = bondi.getConnectedAtom(atomi);
if (atomj.getFormalCharge() == 0) {
Iterator<IBond> bondjs = reactant.getConnectedBondsList(atomj).iterator();
while (bondjs.hasNext()) {
IBond bondj = bondjs.next();
if (bondj.equals(bondi)) continue;
if (bondj.getOrder() == IBond.Order.SINGLE) {
IAtom atomk = bondj.getConnectedAtom(atomj);
if (atomk.getSymbol().equals("C") && atomk.getFormalCharge() == 0) {
atomi.setFlag(CDKConstants.REACTIVE_CENTER, true);
atomj.setFlag(CDKConstants.REACTIVE_CENTER, true);
atomk.setFlag(CDKConstants.REACTIVE_CENTER, true);
bondi.setFlag(CDKConstants.REACTIVE_CENTER, true);
bondj.setFlag(CDKConstants.REACTIVE_CENTER, true);
}
}
}
}
}
}
}
}
}
@SuppressWarnings("unchecked")
@Test
public void aromaticBond() throws Exception {
IAtom u = mock(IAtom.class);
IAtom v = mock(IAtom.class);
IBond b = new Bond(u, v);
b.setFlag(CDKConstants.ISAROMATIC, true);
Map<IAtom, Integer> mock = mock(Map.class);
when(mock.get(u)).thenReturn(0);
when(mock.get(v)).thenReturn(1);
CDKToBeam c2g = new CDKToBeam();
assertThat(c2g.toBeamEdge(b, mock), is(uk.ac.ebi.beam.Bond.AROMATIC.edge(0, 1)));
}
/** A unit test for JUnit with Benzene */
@Test
public void testPartialTotalChargeDescriptor_Benzene()
throws ClassNotFoundException, CDKException, java.lang.Exception {
double[] testResult = {
-0.15, -0.15, -0.15, -0.15, -0.15, -0.15, 0.15, 0.15, 0.15, 0.15, 0.15, 0.15
}; /* from Merck Molecular Force Field. II. Thomas A. Halgren*/
IAtomicDescriptor descriptor = new PartialTChargeMMFF94Descriptor();
// IMolecule mol = sp.parseSmiles("c1ccccc1");
IMolecule mol = builder.newInstance(IMolecule.class);
for (int i = 0; i < 6; i++) {
IAtom carbon = builder.newInstance(IAtom.class, Elements.CARBON);
carbon.setFlag(CDKConstants.ISAROMATIC, true);
// making sure the order matches the test results
mol.addAtom(carbon);
}
IBond ringBond =
builder.newInstance(
IBond.class, mol.getAtom(0), mol.getAtom(1), CDKConstants.BONDORDER_DOUBLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
ringBond =
builder.newInstance(
IBond.class, mol.getAtom(1), mol.getAtom(2), CDKConstants.BONDORDER_SINGLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
ringBond =
builder.newInstance(
IBond.class, mol.getAtom(2), mol.getAtom(3), CDKConstants.BONDORDER_DOUBLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
ringBond =
builder.newInstance(
IBond.class, mol.getAtom(3), mol.getAtom(4), CDKConstants.BONDORDER_SINGLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
ringBond =
builder.newInstance(
IBond.class, mol.getAtom(4), mol.getAtom(5), CDKConstants.BONDORDER_DOUBLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
ringBond =
builder.newInstance(
IBond.class, mol.getAtom(5), mol.getAtom(0), CDKConstants.BONDORDER_SINGLE);
ringBond.setFlag(CDKConstants.ISAROMATIC, true);
mol.addBond(ringBond);
addExplicitHydrogens(mol);
for (int i = 0; i < 12; i++) {
double result =
((DoubleResult) descriptor.calculate(mol.getAtom(i), mol).getValue()).doubleValue();
Assert.assertEquals(testResult[i], result, METHOD_ERROR);
}
}
/**
* set the active center for this molecule. The active center will be those which correspond with
* A-B. If the bond is simple, it will be broken forming two fragments
*
* <pre>
* A: Atom
* #/=/-: bond
* B: Atom
* </pre>
*
* @param reactant The molecule to set the activity
* @throws CDKException
*/
private void setActiveCenters(IMolecule reactant) throws CDKException {
Iterator<IBond> bonds = reactant.bonds().iterator();
while (bonds.hasNext()) {
IBond bond = bonds.next();
IAtom atom1 = bond.getAtom(0);
IAtom atom2 = bond.getAtom(1);
if (bond.getOrder() != IBond.Order.SINGLE
&& (atom1.getFormalCharge() == CDKConstants.UNSET ? 0 : atom1.getFormalCharge()) == 0
&& (atom2.getFormalCharge() == CDKConstants.UNSET ? 0 : atom2.getFormalCharge()) == 0
&& reactant.getConnectedSingleElectronsCount(atom1) == 0
&& reactant.getConnectedSingleElectronsCount(atom2) == 0) {
atom1.setFlag(CDKConstants.REACTIVE_CENTER, true);
atom2.setFlag(CDKConstants.REACTIVE_CENTER, true);
bond.setFlag(CDKConstants.REACTIVE_CENTER, true);
}
}
}
@Test
public void getAromaticEdgeLabelTest() {
IAtomContainer benzeneRing = builder.newInstance(IAtomContainer.class);
for (int i = 0; i < 6; i++) {
benzeneRing.addAtom(builder.newInstance(IAtom.class, "C"));
}
for (int i = 0; i < 6; i++) {
IAtom a = benzeneRing.getAtom(i);
IAtom b = benzeneRing.getAtom((i + 1) % 6);
IBond bond = builder.newInstance(IBond.class, a, b);
benzeneRing.addBond(bond);
bond.setFlag(CDKConstants.ISAROMATIC, true);
}
MoleculeSignature molSignature = new MoleculeSignature(benzeneRing);
System.out.println("" + molSignature.toFullString());
List<AbstractVertexSignature> signatures = molSignature.getVertexSignatures();
for (AbstractVertexSignature signature : signatures) {
for (int i = 0; i < 6; i++) {
Assert.assertEquals(
"Failed for " + i, "p", ((AtomSignature) signature).getEdgeLabel(i, (i + 1) % 6));
}
}
}
/** @throws BioclipseException */
private void calculateInchi() throws BioclipseException {
try {
IAtomContainer clone = (IAtomContainer) getAtomContainer().clone();
// remove aromaticity flags
for (IAtom atom : clone.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, false);
for (IBond bond : clone.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, false);
if (factory == null) {
factory = InChIGeneratorFactory.getInstance();
}
InChIGenerator gen = factory.getInChIGenerator(clone);
INCHI_RET status = gen.getReturnStatus();
if (status == INCHI_RET.OKAY || status == INCHI_RET.WARNING) {
InChI inchi = new InChI();
inchi.setValue(gen.getInchi());
inchi.setKey(gen.getInchiKey());
cachedInchi = inchi;
} else {
throw new InvalidParameterException(
"Error while generating InChI (" + status + "): " + gen.getMessage());
}
} catch (Exception e) {
throw new BioclipseException("Could not create InChI: " + e.getMessage(), e);
}
}
/**
* Prepare the target molecule for analysis.
*
* <p>We perform ring perception and aromaticity detection and set up the appropriate properties.
* Right now, this function is called each time we need to do a query and this is inefficient.
*
* @throws CDKException if there is a problem in ring perception or aromaticity detection, which
* is usually related to a timeout in the ring finding code.
*/
private void initializeMolecule() throws CDKException {
// Code copied from
// org.openscience.cdk.qsar.descriptors.atomic.AtomValenceDescriptor;
Map<String, Integer> valencesTable = new HashMap<String, Integer>();
valencesTable.put("H", 1);
valencesTable.put("Li", 1);
valencesTable.put("Be", 2);
valencesTable.put("B", 3);
valencesTable.put("C", 4);
valencesTable.put("N", 5);
valencesTable.put("O", 6);
valencesTable.put("F", 7);
valencesTable.put("Na", 1);
valencesTable.put("Mg", 2);
valencesTable.put("Al", 3);
valencesTable.put("Si", 4);
valencesTable.put("P", 5);
valencesTable.put("S", 6);
valencesTable.put("Cl", 7);
valencesTable.put("K", 1);
valencesTable.put("Ca", 2);
valencesTable.put("Ga", 3);
valencesTable.put("Ge", 4);
valencesTable.put("As", 5);
valencesTable.put("Se", 6);
valencesTable.put("Br", 7);
valencesTable.put("Rb", 1);
valencesTable.put("Sr", 2);
valencesTable.put("In", 3);
valencesTable.put("Sn", 4);
valencesTable.put("Sb", 5);
valencesTable.put("Te", 6);
valencesTable.put("I", 7);
valencesTable.put("Cs", 1);
valencesTable.put("Ba", 2);
valencesTable.put("Tl", 3);
valencesTable.put("Pb", 4);
valencesTable.put("Bi", 5);
valencesTable.put("Po", 6);
valencesTable.put("At", 7);
valencesTable.put("Fr", 1);
valencesTable.put("Ra", 2);
valencesTable.put("Cu", 2);
valencesTable.put("Mn", 2);
valencesTable.put("Co", 2);
// do all ring perception
AllRingsFinder arf = new AllRingsFinder();
IRingSet allRings;
try {
allRings = arf.findAllRings(atomContainer);
} catch (CDKException e) {
logger.debug(e.toString());
throw new CDKException(e.toString(), e);
}
// sets SSSR information
SSSRFinder finder = new SSSRFinder(atomContainer);
IRingSet sssr = finder.findEssentialRings();
for (IAtom atom : atomContainer.atoms()) {
// add a property to each ring atom that will be an array of
// Integers, indicating what size ring the given atom belongs to
// Add SSSR ring counts
if (allRings.contains(atom)) { // it's in a ring
atom.setFlag(CDKConstants.ISINRING, true);
// lets find which ring sets it is a part of
List<Integer> ringsizes = new ArrayList<Integer>();
IRingSet currentRings = allRings.getRings(atom);
int min = 0;
for (int i = 0; i < currentRings.getAtomContainerCount(); i++) {
int size = currentRings.getAtomContainer(i).getAtomCount();
if (min > size) min = size;
ringsizes.add(size);
}
atom.setProperty(CDKConstants.RING_SIZES, ringsizes);
atom.setProperty(CDKConstants.SMALLEST_RINGS, sssr.getRings(atom));
} else {
atom.setFlag(CDKConstants.ISINRING, false);
}
// determine how many rings bonds each atom is a part of
int hCount;
if (atom.getImplicitHydrogenCount() == CDKConstants.UNSET) hCount = 0;
else hCount = atom.getImplicitHydrogenCount();
List<IAtom> connectedAtoms = atomContainer.getConnectedAtomsList(atom);
int total = hCount + connectedAtoms.size();
for (IAtom connectedAtom : connectedAtoms) {
if (connectedAtom.getSymbol().equals("H")) {
hCount++;
}
}
atom.setProperty(CDKConstants.TOTAL_CONNECTIONS, total);
atom.setProperty(CDKConstants.TOTAL_H_COUNT, hCount);
if (valencesTable.get(atom.getSymbol()) != null) {
int formalCharge =
atom.getFormalCharge() == CDKConstants.UNSET ? 0 : atom.getFormalCharge();
atom.setValency(valencesTable.get(atom.getSymbol()) - formalCharge);
}
}
for (IBond bond : atomContainer.bonds()) {
if (allRings.getRings(bond).getAtomContainerCount() > 0) {
bond.setFlag(CDKConstants.ISINRING, true);
}
}
for (IAtom atom : atomContainer.atoms()) {
List<IAtom> connectedAtoms = atomContainer.getConnectedAtomsList(atom);
int counter = 0;
IAtom any;
for (IAtom connectedAtom : connectedAtoms) {
any = connectedAtom;
if (any.getFlag(CDKConstants.ISINRING)) {
counter++;
}
}
atom.setProperty(CDKConstants.RING_CONNECTIONS, counter);
}
// check for atomaticity
try {
AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(atomContainer);
CDKHueckelAromaticityDetector.detectAromaticity(atomContainer);
} catch (CDKException e) {
logger.debug(e.toString());
throw new CDKException(e.toString(), e);
}
}
@TestMethod(value = "testCalculate_IAtomContainer")
public DescriptorValue calculate(
IAtom atom, IAtomContainer atomContainer, IRingSet precalculatedringset) {
IAtomContainer varAtomContainer;
try {
varAtomContainer = (IAtomContainer) atomContainer.clone();
} catch (CloneNotSupportedException e) {
return getDummyDescriptorValue(e);
}
int atomPosition = atomContainer.getAtomNumber(atom);
IAtom clonedAtom = varAtomContainer.getAtom(atomPosition);
DoubleArrayResult rdfProtonCalculatedValues = new DoubleArrayResult(gsr_desc_length);
if (!atom.getSymbol().equals("H")) {
return getDummyDescriptorValue(new CDKException("Invalid atom specified"));
}
///////////////////////// FIRST SECTION OF MAIN METHOD: DEFINITION OF MAIN VARIABLES
///////////////////////// AND AROMATICITY AND PI-SYSTEM AND RINGS DETECTION
Molecule mol = new Molecule(varAtomContainer);
if (varAtomContainer != acold) {
acold = varAtomContainer;
// DETECTION OF pi SYSTEMS
varAtomContainerSet = ConjugatedPiSystemsDetector.detect(mol);
if (precalculatedringset == null)
try {
varRingSet = (new AllRingsFinder()).findAllRings(varAtomContainer);
} catch (CDKException e) {
return getDummyDescriptorValue(e);
}
else varRingSet = precalculatedringset;
try {
GasteigerMarsiliPartialCharges peoe = new GasteigerMarsiliPartialCharges();
peoe.assignGasteigerMarsiliSigmaPartialCharges(mol, true);
} catch (Exception ex1) {
return getDummyDescriptorValue(ex1);
}
}
if (checkAromaticity) {
try {
AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(varAtomContainer);
CDKHueckelAromaticityDetector.detectAromaticity(varAtomContainer);
} catch (CDKException e) {
return getDummyDescriptorValue(e);
}
}
IRingSet rsAtom;
Ring ring;
IRingSet ringsWithThisBond;
// SET ISINRING FLAGS FOR BONDS
Iterator<IBond> bondsInContainer = varAtomContainer.bonds().iterator();
while (bondsInContainer.hasNext()) {
IBond bond = bondsInContainer.next();
ringsWithThisBond = varRingSet.getRings(bond);
if (ringsWithThisBond.getAtomContainerCount() > 0) {
bond.setFlag(CDKConstants.ISINRING, true);
}
}
// SET ISINRING FLAGS FOR ATOMS
IRingSet ringsWithThisAtom;
for (int w = 0; w < varAtomContainer.getAtomCount(); w++) {
ringsWithThisAtom = varRingSet.getRings(varAtomContainer.getAtom(w));
if (ringsWithThisAtom.getAtomContainerCount() > 0) {
varAtomContainer.getAtom(w).setFlag(CDKConstants.ISINRING, true);
}
}
IAtomContainer detected = varAtomContainerSet.getAtomContainer(0);
// neighboors[0] is the atom joined to the target proton:
List<IAtom> neighboors = mol.getConnectedAtomsList(clonedAtom);
IAtom neighbour0 = neighboors.get(0);
// 2', 3', 4', 5', 6', and 7' atoms up to the target are detected:
List<IAtom> atomsInSecondSphere = mol.getConnectedAtomsList(neighbour0);
List<IAtom> atomsInThirdSphere;
List<IAtom> atomsInFourthSphere;
List<IAtom> atomsInFifthSphere;
List<IAtom> atomsInSixthSphere;
List<IAtom> atomsInSeventhSphere;
// SOME LISTS ARE CREATED FOR STORING OF INTERESTING ATOMS AND BONDS DURING DETECTION
ArrayList<Integer> singles = new ArrayList<Integer>(); // list of any bond not rotatable
ArrayList<Integer> doubles = new ArrayList<Integer>(); // list with only double bonds
ArrayList<Integer> atoms = new ArrayList<Integer>(); // list with all the atoms in spheres
// atoms.add( Integer.valueOf( mol.getAtomNumber(neighboors[0]) ) );
ArrayList<Integer> bondsInCycloex =
new ArrayList<Integer>(); // list for bonds in cycloexane-like rings
// 2', 3', 4', 5', 6', and 7' bonds up to the target are detected:
IBond secondBond; // (remember that first bond is proton bond)
IBond thirdBond; //
IBond fourthBond; //
IBond fifthBond; //
IBond sixthBond; //
IBond seventhBond; //
// definition of some variables used in the main FOR loop for detection of interesting atoms and
// bonds:
boolean theBondIsInA6MemberedRing; // this is like a flag for bonds which are in cycloexane-like
// rings (rings with more than 4 at.)
IBond.Order bondOrder;
int bondNumber;
int sphere;
// THIS MAIN FOR LOOP DETECT RIGID BONDS IN 7 SPHERES:
for (IAtom curAtomSecond : atomsInSecondSphere) {
secondBond = mol.getBond(neighbour0, curAtomSecond);
if (mol.getAtomNumber(curAtomSecond) != atomPosition
&& getIfBondIsNotRotatable(mol, secondBond, detected)) {
sphere = 2;
bondOrder = secondBond.getOrder();
bondNumber = mol.getBondNumber(secondBond);
theBondIsInA6MemberedRing = false;
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomSecond),
atoms,
sphere,
theBondIsInA6MemberedRing);
atomsInThirdSphere = mol.getConnectedAtomsList(curAtomSecond);
if (atomsInThirdSphere.size() > 0) {
for (IAtom curAtomThird : atomsInThirdSphere) {
thirdBond = mol.getBond(curAtomThird, curAtomSecond);
// IF THE ATOMS IS IN THE THIRD SPHERE AND IN A CYCLOEXANE-LIKE RING, IT IS STORED IN
// THE PROPER LIST:
if (mol.getAtomNumber(curAtomThird) != atomPosition
&& getIfBondIsNotRotatable(mol, thirdBond, detected)) {
sphere = 3;
bondOrder = thirdBond.getOrder();
bondNumber = mol.getBondNumber(thirdBond);
theBondIsInA6MemberedRing = false;
// if the bond is in a cyclohexane-like ring (a ring with 5 or more atoms, not
// aromatic)
// the boolean "theBondIsInA6MemberedRing" is set to true
if (!thirdBond.getFlag(CDKConstants.ISAROMATIC)) {
if (!curAtomThird.equals(neighbour0)) {
rsAtom = varRingSet.getRings(thirdBond);
for (int f = 0; f < rsAtom.getAtomContainerCount(); f++) {
ring = (Ring) rsAtom.getAtomContainer(f);
if (ring.getRingSize() > 4 && ring.contains(thirdBond)) {
theBondIsInA6MemberedRing = true;
}
}
}
}
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomThird),
atoms,
sphere,
theBondIsInA6MemberedRing);
theBondIsInA6MemberedRing = false;
atomsInFourthSphere = mol.getConnectedAtomsList(curAtomThird);
if (atomsInFourthSphere.size() > 0) {
for (IAtom curAtomFourth : atomsInFourthSphere) {
fourthBond = mol.getBond(curAtomThird, curAtomFourth);
if (mol.getAtomNumber(curAtomFourth) != atomPosition
&& getIfBondIsNotRotatable(mol, fourthBond, detected)) {
sphere = 4;
bondOrder = fourthBond.getOrder();
bondNumber = mol.getBondNumber(fourthBond);
theBondIsInA6MemberedRing = false;
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomFourth),
atoms,
sphere,
theBondIsInA6MemberedRing);
atomsInFifthSphere = mol.getConnectedAtomsList(curAtomFourth);
if (atomsInFifthSphere.size() > 0) {
for (IAtom curAtomFifth : atomsInFifthSphere) {
fifthBond = mol.getBond(curAtomFifth, curAtomFourth);
if (mol.getAtomNumber(curAtomFifth) != atomPosition
&& getIfBondIsNotRotatable(mol, fifthBond, detected)) {
sphere = 5;
bondOrder = fifthBond.getOrder();
bondNumber = mol.getBondNumber(fifthBond);
theBondIsInA6MemberedRing = false;
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomFifth),
atoms,
sphere,
theBondIsInA6MemberedRing);
atomsInSixthSphere = mol.getConnectedAtomsList(curAtomFifth);
if (atomsInSixthSphere.size() > 0) {
for (IAtom curAtomSixth : atomsInSixthSphere) {
sixthBond = mol.getBond(curAtomFifth, curAtomSixth);
if (mol.getAtomNumber(curAtomSixth) != atomPosition
&& getIfBondIsNotRotatable(mol, sixthBond, detected)) {
sphere = 6;
bondOrder = sixthBond.getOrder();
bondNumber = mol.getBondNumber(sixthBond);
theBondIsInA6MemberedRing = false;
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomSixth),
atoms,
sphere,
theBondIsInA6MemberedRing);
atomsInSeventhSphere = mol.getConnectedAtomsList(curAtomSixth);
if (atomsInSeventhSphere.size() > 0) {
for (IAtom curAtomSeventh : atomsInSeventhSphere) {
seventhBond = mol.getBond(curAtomSeventh, curAtomSixth);
if (mol.getAtomNumber(curAtomSeventh) != atomPosition
&& getIfBondIsNotRotatable(mol, seventhBond, detected)) {
sphere = 7;
bondOrder = seventhBond.getOrder();
bondNumber = mol.getBondNumber(seventhBond);
theBondIsInA6MemberedRing = false;
checkAndStore(
bondNumber,
bondOrder,
singles,
doubles,
bondsInCycloex,
mol.getAtomNumber(curAtomSeventh),
atoms,
sphere,
theBondIsInA6MemberedRing);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
// Variables
double[] values; // for storage of results of other methods
double distance;
double sum;
double smooth = -20;
double partial;
int position;
double limitInf;
double limitSup;
double step;
//////////////////////// THE FOUTH DESCRIPTOR IS gS(r), WHICH TAKES INTO ACCOUNT SINGLE BONDS IN
// RIGID SYSTEMS
Vector3d a_a = new Vector3d();
Vector3d a_b = new Vector3d();
Vector3d b_a = new Vector3d();
Vector3d b_b = new Vector3d();
Point3d middlePoint = new Point3d();
double angle = 0;
if (singles.size() > 0) {
double dist0;
double dist1;
IAtom singleBondAtom0;
IAtom singleBondAtom1;
distance = 0;
position = 0;
IBond theSingleBond = null;
limitInf = 0;
limitSup = Math.PI / 2;
step = (limitSup - limitInf) / 7;
smooth = -1.15;
int counter = 0;
for (double ghs = 0; ghs < limitSup; ghs = ghs + step) {
sum = 0;
for (int sing = 0; sing < singles.size(); sing++) {
angle = 0;
partial = 0;
Integer thisSingleBond = singles.get(sing);
position = thisSingleBond;
theSingleBond = mol.getBond(position);
middlePoint = theSingleBond.get3DCenter();
singleBondAtom0 = theSingleBond.getAtom(0);
singleBondAtom1 = theSingleBond.getAtom(1);
dist0 = calculateDistanceBetweenTwoAtoms(singleBondAtom0, atom);
dist1 = calculateDistanceBetweenTwoAtoms(singleBondAtom1, atom);
a_a.set(middlePoint.x, middlePoint.y, middlePoint.z);
if (dist1 > dist0)
a_b.set(
singleBondAtom0.getPoint3d().x,
singleBondAtom0.getPoint3d().y,
singleBondAtom0.getPoint3d().z);
else
a_b.set(
singleBondAtom1.getPoint3d().x,
singleBondAtom1.getPoint3d().y,
singleBondAtom1.getPoint3d().z);
b_a.set(middlePoint.x, middlePoint.y, middlePoint.z);
b_b.set(atom.getPoint3d().x, atom.getPoint3d().y, atom.getPoint3d().z);
values = calculateDistanceBetweenAtomAndBond(atom, theSingleBond);
angle = calculateAngleBetweenTwoLines(a_a, a_b, b_a, b_b);
// System.out.println("ANGLe: "+angle+ " "+ mol.getAtomNumber(atomsInSingleBond[0]) +" "
// +mol.getAtomNumber(atomsInSingleBond[1]));
partial =
(1 / (Math.pow(values[0], 2))) * Math.exp(smooth * (Math.pow((ghs - angle), 2)));
sum += partial;
}
// gSr_function.add(new Double(sum));
rdfProtonCalculatedValues.add(sum);
logger.debug("RDF gSr prob.: " + sum + " at distance " + ghs);
counter++;
}
} else {
return getDummyDescriptorValue(new CDKException("Some error occurred. Please report"));
}
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
rdfProtonCalculatedValues,
getDescriptorNames());
}
/**
* Search if the setOfAtomContainer contains the atomContainer
*
* @param set ISetOfAtomContainer object where to search
* @param atomContainer IAtomContainer to search
* @return True, if the atomContainer is contained
*/
private boolean existAC(IAtomContainerSet set, IAtomContainer atomContainer) {
IAtomContainer acClone = null;
try {
acClone = (IMolecule) atomContainer.clone();
if (!lookingSymmetry) {
/*remove all aromatic flags*/
for (IAtom atom : acClone.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, false);
for (IBond bond : acClone.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, false);
}
} catch (CloneNotSupportedException e1) {
e1.printStackTrace();
}
for (int i = 0; i < acClone.getAtomCount(); i++)
// if(acClone.getAtom(i).getID() == null)
acClone.getAtom(i).setID("" + acClone.getAtomNumber(acClone.getAtom(i)));
if (lookingSymmetry) {
try {
CDKHueckelAromaticityDetector.detectAromaticity(acClone);
} catch (CDKException e) {
e.printStackTrace();
}
} else {
if (!lookingSymmetry) {
/*remove all aromatic flags*/
for (IAtom atom : acClone.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, false);
for (IBond bond : acClone.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, false);
}
}
for (int i = 0; i < set.getAtomContainerCount(); i++) {
IAtomContainer ss = set.getAtomContainer(i);
for (int j = 0; j < ss.getAtomCount(); j++)
// if(ss.getAtom(j).getID() == null)
ss.getAtom(j).setID("" + ss.getAtomNumber(ss.getAtom(j)));
try {
if (!lookingSymmetry) {
QueryAtomContainer qAC =
QueryAtomContainerCreator.createSymbolChargeIDQueryContainer(acClone);
if (UniversalIsomorphismTester.isIsomorph(ss, qAC)) {
QueryAtomContainer qAC2 =
QueryAtomContainerCreator.createSymbolAndBondOrderQueryContainer(acClone);
if (UniversalIsomorphismTester.isIsomorph(ss, qAC2)) return true;
}
} else {
QueryAtomContainer qAC =
QueryAtomContainerCreator.createSymbolAndChargeQueryContainer(acClone);
CDKHueckelAromaticityDetector.detectAromaticity(ss);
if (UniversalIsomorphismTester.isIsomorph(ss, qAC)) return true;
}
} catch (CDKException e1) {
System.err.println(e1);
logger.error(e1.getMessage());
logger.debug(e1);
}
}
return false;
}
/**
* Read an IAtomContainer from a file in MDL sd format
*
* @return The Molecule that was read from the MDL file.
*/
private IAtomContainer readAtomContainer(IAtomContainer molecule) throws CDKException {
logger.debug("Reading new molecule");
IAtomContainer outputContainer = null;
int linecount = 0;
int atoms = 0;
int bonds = 0;
int atom1 = 0;
int atom2 = 0;
int order = 0;
IBond.Stereo stereo = (IBond.Stereo) CDKConstants.UNSET;
int RGroupCounter = 1;
int Rnumber = 0;
String[] rGroup = null;
double x = 0.0;
double y = 0.0;
double z = 0.0;
double totalX = 0.0;
double totalY = 0.0;
double totalZ = 0.0;
String title = null;
String remark = null;
// int[][] conMat = new int[0][0];
// String help;
IAtom atom;
String line = "";
// A map to keep track of R# atoms so that RGP line can be parsed
Map<Integer, IPseudoAtom> rAtoms = new HashMap<Integer, IPseudoAtom>();
try {
IsotopeFactory isotopeFactory = Isotopes.getInstance();
logger.info("Reading header");
line = input.readLine();
linecount++;
if (line == null) {
return null;
}
logger.debug("Line " + linecount + ": " + line);
if (line.startsWith("$$$$")) {
logger.debug("File is empty, returning empty molecule");
return molecule;
}
if (line.length() > 0) {
title = line;
}
line = input.readLine();
linecount++;
logger.debug("Line " + linecount + ": " + line);
line = input.readLine();
linecount++;
logger.debug("Line " + linecount + ": " + line);
if (line.length() > 0) {
remark = line;
}
logger.info("Reading rest of file");
line = input.readLine();
linecount++;
logger.debug("Line " + linecount + ": " + line);
// if the line is empty we hav a problem - either a malformed
// molecule entry or just extra new lines at the end of the file
if (line.length() == 0) {
// read till the next $$$$ or EOF
while (true) {
line = input.readLine();
linecount++;
if (line == null) {
return null;
}
if (line.startsWith("$$$$")) {
return molecule; // an empty molecule
}
}
}
// check the CT block version
if (line.contains("V3000") || line.contains("v3000")) {
handleError("This file must be read with the MDLV3000Reader.");
} else if (!line.contains("V2000") && !line.contains("v2000")) {
handleError("This file must be read with the MDLReader.");
}
atoms = Integer.parseInt(line.substring(0, 3).trim());
List<IAtom> atomList = new ArrayList<IAtom>();
logger.debug("Atomcount: " + atoms);
bonds = Integer.parseInt(line.substring(3, 6).trim());
logger.debug("Bondcount: " + bonds);
List<IBond> bondList = new ArrayList<IBond>();
// used for applying the MDL valence model
int[] explicitValence = new int[atoms];
// read ATOM block
logger.info("Reading atom block");
atomsByLinePosition = new ArrayList<IAtom>();
atomsByLinePosition.add(null); // 0 is not a valid position
int atomBlockLineNumber = 0;
for (int f = 0; f < atoms; f++) {
line = input.readLine();
linecount++;
atomBlockLineNumber++;
Matcher trailingSpaceMatcher = TRAILING_SPACE.matcher(line);
if (trailingSpaceMatcher.find()) {
handleError(
"Trailing space found",
linecount,
trailingSpaceMatcher.start(),
trailingSpaceMatcher.end());
line = trailingSpaceMatcher.replaceAll("");
}
x = Double.parseDouble(line.substring(0, 10).trim());
y = Double.parseDouble(line.substring(10, 20).trim());
z = Double.parseDouble(line.substring(20, 30).trim());
// *all* values should be zero, not just the sum
totalX += Math.abs(x);
totalY += Math.abs(y);
totalZ += Math.abs(z);
logger.debug("Coordinates: " + x + "; " + y + "; " + z);
String element = line.substring(31, Math.min(line.length(), 34)).trim();
if (line.length() < 34) {
handleError(
"Element atom type does not follow V2000 format type should of length three"
+ " and padded with space if required",
linecount,
31,
34);
}
logger.debug("Atom type: ", element);
if (isotopeFactory.isElement(element)) {
atom = isotopeFactory.configure(molecule.getBuilder().newInstance(IAtom.class, element));
} else if ("A".equals(element)) {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} else if ("Q".equals(element)) {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} else if ("*".equals(element)) {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} else if ("LP".equals(element)) {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} else if ("L".equals(element)) {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} else if (element.equals("R") || (element.length() > 0 && element.charAt(0) == 'R')) {
logger.debug("Atom ", element, " is not an regular element. Creating a PseudoAtom.");
// check if the element is R
rGroup = element.split("^R");
atom = null;
if (rGroup.length > 1) {
try {
Rnumber = Integer.valueOf(rGroup[(rGroup.length - 1)]);
RGroupCounter = Rnumber;
element = "R" + Rnumber;
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
} catch (Exception ex) {
// This happens for atoms labeled "R#".
// The Rnumber may be set later on, using RGP line
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, "R");
rAtoms.put(atomBlockLineNumber, (IPseudoAtom) atom);
}
} else {
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
}
} else {
handleError(
"Invalid element type. Must be an existing " + "element, or one in: A, Q, L, LP, *.",
linecount,
32,
35);
atom = molecule.getBuilder().newInstance(IPseudoAtom.class, element);
atom.setSymbol(element);
}
// store as 3D for now, convert to 2D (if totalZ == 0.0) later
atom.setPoint3d(new Point3d(x, y, z));
// parse further fields
if (line.length() >= 36) {
String massDiffString = line.substring(34, 36).trim();
logger.debug("Mass difference: ", massDiffString);
if (!(atom instanceof IPseudoAtom)) {
try {
int massDiff = Integer.parseInt(massDiffString);
if (massDiff != 0) {
IIsotope major = Isotopes.getInstance().getMajorIsotope(element);
atom.setMassNumber(major.getMassNumber() + massDiff);
}
} catch (Exception exception) {
handleError("Could not parse mass difference field.", linecount, 35, 37, exception);
}
} else {
logger.error("Cannot set mass difference for a non-element!");
}
} else {
handleError("Mass difference is missing", linecount, 34, 36);
}
// set the stereo partiy
Integer parity = line.length() > 41 ? Character.digit(line.charAt(41), 10) : 0;
atom.setStereoParity(parity);
if (line.length() >= 51) {
String valenceString = removeNonDigits(line.substring(48, 51));
logger.debug("Valence: ", valenceString);
if (!(atom instanceof IPseudoAtom)) {
try {
int valence = Integer.parseInt(valenceString);
if (valence != 0) {
// 15 is defined as 0 in mol files
if (valence == 15) atom.setValency(0);
else atom.setValency(valence);
}
} catch (Exception exception) {
handleError(
"Could not parse valence information field", linecount, 49, 52, exception);
}
} else {
logger.error("Cannot set valence information for a non-element!");
}
}
if (line.length() >= 39) {
String chargeCodeString = line.substring(36, 39).trim();
logger.debug("Atom charge code: ", chargeCodeString);
int chargeCode = Integer.parseInt(chargeCodeString);
if (chargeCode == 0) {
// uncharged species
} else if (chargeCode == 1) {
atom.setFormalCharge(+3);
} else if (chargeCode == 2) {
atom.setFormalCharge(+2);
} else if (chargeCode == 3) {
atom.setFormalCharge(+1);
} else if (chargeCode == 4) {
} else if (chargeCode == 5) {
atom.setFormalCharge(-1);
} else if (chargeCode == 6) {
atom.setFormalCharge(-2);
} else if (chargeCode == 7) {
atom.setFormalCharge(-3);
}
} else {
handleError("Atom charge is missing", linecount, 36, 39);
}
try {
// read the mmm field as position 61-63
String reactionAtomIDString = line.substring(60, 63).trim();
logger.debug("Parsing mapping id: ", reactionAtomIDString);
try {
int reactionAtomID = Integer.parseInt(reactionAtomIDString);
if (reactionAtomID != 0) {
atom.setProperty(CDKConstants.ATOM_ATOM_MAPPING, reactionAtomID);
}
} catch (Exception exception) {
logger.error("Mapping number ", reactionAtomIDString, " is not an integer.");
logger.debug(exception);
}
} catch (Exception exception) {
// older mol files don't have all these fields...
logger.warn("A few fields are missing. Older MDL MOL file?");
}
// shk3: This reads shifts from after the molecule. I don't think this is an official
// format, but I saw it frequently 80=>78 for alk
if (line.length() >= 78) {
double shift = Double.parseDouble(line.substring(69, 80).trim());
atom.setProperty("first shift", shift);
}
if (line.length() >= 87) {
double shift = Double.parseDouble(line.substring(79, 87).trim());
atom.setProperty("second shift", shift);
}
atomList.add(atom);
atomsByLinePosition.add(atom);
}
// convert to 2D, if totalZ == 0
if (totalX == 0.0 && totalY == 0.0 && totalZ == 0.0) {
logger.info("All coordinates are 0.0");
if (atomList.size() == 1) {
atomList.get(0).setPoint2d(new Point2d(x, y));
} else {
for (IAtom atomToUpdate : atomList) {
atomToUpdate.setPoint3d(null);
}
}
} else if (totalZ == 0.0 && !forceReadAs3DCoords.isSet()) {
logger.info("Total 3D Z is 0.0, interpreting it as a 2D structure");
for (IAtom atomToUpdate : atomList) {
Point3d p3d = atomToUpdate.getPoint3d();
if (p3d != null) {
atomToUpdate.setPoint2d(new Point2d(p3d.x, p3d.y));
atomToUpdate.setPoint3d(null);
}
}
}
// read BOND block
logger.info("Reading bond block");
int queryBondCount = 0;
for (int f = 0; f < bonds; f++) {
line = input.readLine();
linecount++;
atom1 = Integer.parseInt(line.substring(0, 3).trim());
atom2 = Integer.parseInt(line.substring(3, 6).trim());
order = Integer.parseInt(line.substring(6, 9).trim());
if (line.length() >= 12) {
int mdlStereo =
line.length() > 12
? Integer.parseInt(line.substring(9, 12).trim())
: Integer.parseInt(line.substring(9).trim());
if (mdlStereo == 1) {
// MDL up bond
stereo = IBond.Stereo.UP;
} else if (mdlStereo == 6) {
// MDL down bond
stereo = IBond.Stereo.DOWN;
} else if (mdlStereo == 0) {
if (order == 2) {
// double bond stereo defined by coordinates
stereo = IBond.Stereo.E_Z_BY_COORDINATES;
} else {
// bond has no stereochemistry
stereo = IBond.Stereo.NONE;
}
} else if (mdlStereo == 3 && order == 2) {
// unknown E/Z stereochemistry
stereo = IBond.Stereo.E_OR_Z;
} else if (mdlStereo == 4) {
// MDL bond undefined
stereo = IBond.Stereo.UP_OR_DOWN;
}
} else {
handleError("Missing expected stereo field at line: ", linecount, 10, 12);
}
if (logger.isDebugEnabled()) {
logger.debug("Bond: " + atom1 + " - " + atom2 + "; order " + order);
}
// interpret CTfile's special bond orders
IAtom a1 = atomList.get(atom1 - 1);
IAtom a2 = atomList.get(atom2 - 1);
IBond newBond = null;
if (order >= 1 && order <= 3) {
IBond.Order cdkOrder = IBond.Order.SINGLE;
if (order == 2) cdkOrder = IBond.Order.DOUBLE;
if (order == 3) cdkOrder = IBond.Order.TRIPLE;
if (stereo != null) {
newBond = molecule.getBuilder().newInstance(IBond.class, a1, a2, cdkOrder, stereo);
} else {
newBond = molecule.getBuilder().newInstance(IBond.class, a1, a2, cdkOrder);
}
} else if (order == 4) {
// aromatic bond
if (stereo != null) {
newBond =
molecule.getBuilder().newInstance(IBond.class, a1, a2, IBond.Order.UNSET, stereo);
} else {
newBond = molecule.getBuilder().newInstance(IBond.class, a1, a2, IBond.Order.UNSET);
}
// mark both atoms and the bond as aromatic and raise the SINGLE_OR_DOUBLE-flag
newBond.setFlag(CDKConstants.SINGLE_OR_DOUBLE, true);
newBond.setFlag(CDKConstants.ISAROMATIC, true);
a1.setFlag(CDKConstants.ISAROMATIC, true);
a2.setFlag(CDKConstants.ISAROMATIC, true);
} else {
queryBondCount++;
newBond = new CTFileQueryBond(molecule.getBuilder());
IAtom[] bondAtoms = {a1, a2};
newBond.setAtoms(bondAtoms);
newBond.setOrder(null);
CTFileQueryBond.Type queryBondType = null;
switch (order) {
case 5:
queryBondType = CTFileQueryBond.Type.SINGLE_OR_DOUBLE;
break;
case 6:
queryBondType = CTFileQueryBond.Type.SINGLE_OR_AROMATIC;
break;
case 7:
queryBondType = CTFileQueryBond.Type.DOUBLE_OR_AROMATIC;
break;
case 8:
queryBondType = CTFileQueryBond.Type.ANY;
break;
}
((CTFileQueryBond) newBond).setType(queryBondType);
newBond.setStereo(stereo);
}
bondList.add((newBond));
// add the bond order to the explicit valence for each atom
if (newBond.getOrder() != null && newBond.getOrder() != IBond.Order.UNSET) {
explicitValence[atom1 - 1] += newBond.getOrder().numeric();
explicitValence[atom2 - 1] += newBond.getOrder().numeric();
} else {
explicitValence[atom1 - 1] = Integer.MIN_VALUE;
explicitValence[atom2 - 1] = Integer.MIN_VALUE;
}
}
if (queryBondCount == 0) outputContainer = molecule;
else {
outputContainer = new QueryAtomContainer(molecule.getBuilder());
}
outputContainer.setProperty(CDKConstants.TITLE, title);
outputContainer.setProperty(CDKConstants.REMARK, remark);
for (IAtom at : atomList) {
outputContainer.addAtom(at);
}
for (IBond bnd : bondList) {
outputContainer.addBond(bnd);
}
// read PROPERTY block
logger.info("Reading property block");
while (true) {
line = input.readLine();
linecount++;
if (line == null) {
handleError("The expected property block is missing!", linecount, 0, 0);
}
if (line.startsWith("M END")) break;
boolean lineRead = false;
if (line.startsWith("M CHG")) {
// FIXME: if this is encountered for the first time, all
// atom charges should be set to zero first!
int infoCount = Integer.parseInt(line.substring(6, 9).trim());
StringTokenizer st = new StringTokenizer(line.substring(9));
for (int i = 1; i <= infoCount; i++) {
String token = st.nextToken();
int atomNumber = Integer.parseInt(token.trim());
token = st.nextToken();
int charge = Integer.parseInt(token.trim());
outputContainer.getAtom(atomNumber - 1).setFormalCharge(charge);
}
} else if (line.matches("A\\s{1,4}\\d+")) {
// Reads the pseudo atom property from the mol file
// The atom number of the to replaced atom
int aliasAtomNumber =
Integer.parseInt(line.replaceFirst("A\\s{1,4}", "")) - RGroupCounter;
line = input.readLine();
linecount++;
String[] aliasArray = line.split("\\\\");
// name of the alias atom like R1 or R2 etc.
String alias = "";
for (int i = 0; i < aliasArray.length; i++) {
alias += aliasArray[i];
}
IAtom aliasAtom = outputContainer.getAtom(aliasAtomNumber);
// skip if already a pseudoatom
if (aliasAtom instanceof IPseudoAtom) {
((IPseudoAtom) aliasAtom).setLabel(alias);
continue;
}
IAtom newPseudoAtom = molecule.getBuilder().newInstance(IPseudoAtom.class, alias);
if (aliasAtom.getPoint2d() != null) {
newPseudoAtom.setPoint2d(aliasAtom.getPoint2d());
}
if (aliasAtom.getPoint3d() != null) {
newPseudoAtom.setPoint3d(aliasAtom.getPoint3d());
}
outputContainer.addAtom(newPseudoAtom);
List<IBond> bondsOfAliasAtom = outputContainer.getConnectedBondsList(aliasAtom);
for (int i = 0; i < bondsOfAliasAtom.size(); i++) {
IBond bondOfAliasAtom = bondsOfAliasAtom.get(i);
IAtom connectedToAliasAtom = bondOfAliasAtom.getConnectedAtom(aliasAtom);
IBond newBond = bondOfAliasAtom.getBuilder().newInstance(IBond.class);
newBond.setAtoms(new IAtom[] {connectedToAliasAtom, newPseudoAtom});
newBond.setOrder(bondOfAliasAtom.getOrder());
outputContainer.addBond(newBond);
outputContainer.removeBond(aliasAtom, connectedToAliasAtom);
}
outputContainer.removeAtom(aliasAtom);
RGroupCounter++;
} else if (line.startsWith("M ISO")) {
try {
String countString = line.substring(6, 10).trim();
int infoCount = Integer.parseInt(countString);
StringTokenizer st = new StringTokenizer(line.substring(10));
for (int i = 1; i <= infoCount; i++) {
int atomNumber = Integer.parseInt(st.nextToken().trim());
int absMass = Integer.parseInt(st.nextToken().trim());
if (absMass != 0) {
IAtom isotope = outputContainer.getAtom(atomNumber - 1);
isotope.setMassNumber(absMass);
}
}
} catch (NumberFormatException exception) {
String error =
"Error ("
+ exception.getMessage()
+ ") while parsing line "
+ linecount
+ ": "
+ line
+ " in property block.";
logger.error(error);
handleError(
"NumberFormatException in isotope information.", linecount, 7, 11, exception);
}
} else if (line.startsWith("M RAD")) {
try {
String countString = line.substring(6, 9).trim();
int infoCount = Integer.parseInt(countString);
StringTokenizer st = new StringTokenizer(line.substring(9));
for (int i = 1; i <= infoCount; i++) {
int atomNumber = Integer.parseInt(st.nextToken().trim());
int spinMultiplicity = Integer.parseInt(st.nextToken().trim());
MDLV2000Writer.SPIN_MULTIPLICITY spin = MDLV2000Writer.SPIN_MULTIPLICITY.NONE;
if (spinMultiplicity > 0) {
IAtom radical = outputContainer.getAtom(atomNumber - 1);
switch (spinMultiplicity) {
case 1:
spin = MDLV2000Writer.SPIN_MULTIPLICITY.DOUBLET;
break;
case 2:
spin = MDLV2000Writer.SPIN_MULTIPLICITY.SINGLET;
break;
case 3:
spin = MDLV2000Writer.SPIN_MULTIPLICITY.TRIPLET;
break;
default:
logger.debug("Invalid spin multiplicity found: " + spinMultiplicity);
break;
}
for (int j = 0; j < spin.getSingleElectrons(); j++) {
outputContainer.addSingleElectron(
molecule.getBuilder().newInstance(ISingleElectron.class, radical));
}
}
}
} catch (NumberFormatException exception) {
String error =
"Error ("
+ exception.getMessage()
+ ") while parsing line "
+ linecount
+ ": "
+ line
+ " in property block.";
logger.error(error);
handleError(
"NumberFormatException in radical information", linecount, 7, 10, exception);
}
} else if (line.startsWith("G ")) {
try {
String atomNumberString = line.substring(3, 6).trim();
int atomNumber = Integer.parseInt(atomNumberString);
// String whatIsThisString = line.substring(6,9).trim();
String atomName = input.readLine();
// convert Atom into a PseudoAtom
IAtom prevAtom = outputContainer.getAtom(atomNumber - 1);
IPseudoAtom pseudoAtom = molecule.getBuilder().newInstance(IPseudoAtom.class, atomName);
if (prevAtom.getPoint2d() != null) {
pseudoAtom.setPoint2d(prevAtom.getPoint2d());
}
if (prevAtom.getPoint3d() != null) {
pseudoAtom.setPoint3d(prevAtom.getPoint3d());
}
AtomContainerManipulator.replaceAtomByAtom(molecule, prevAtom, pseudoAtom);
} catch (NumberFormatException exception) {
String error =
"Error ("
+ exception.toString()
+ ") while parsing line "
+ linecount
+ ": "
+ line
+ " in property block.";
logger.error(error);
handleError("NumberFormatException in group information", linecount, 4, 7, exception);
}
} else if (line.startsWith("M RGP")) {
StringTokenizer st = new StringTokenizer(line);
// Ignore first 3 tokens (overhead).
st.nextToken();
st.nextToken();
st.nextToken();
// Process the R group numbers as defined in RGP line.
while (st.hasMoreTokens()) {
Integer position = new Integer(st.nextToken());
Rnumber = new Integer(st.nextToken());
IPseudoAtom pseudoAtom = rAtoms.get(position);
if (pseudoAtom != null) {
pseudoAtom.setLabel("R" + Rnumber);
}
}
}
if (line.startsWith("V ")) {
Integer atomNumber = new Integer(line.substring(3, 6).trim());
IAtom atomWithComment = outputContainer.getAtom(atomNumber - 1);
atomWithComment.setProperty(CDKConstants.COMMENT, line.substring(7));
}
if (!lineRead) {
logger.warn("Skipping line in property block: ", line);
}
}
if (interpretHydrogenIsotopes.isSet()) {
fixHydrogenIsotopes(molecule, isotopeFactory);
}
// note: apply the valence model last so that all fixes (i.e. hydrogen
// isotopes) are in place
for (int i = 0; i < atoms; i++) {
applyMDLValenceModel(outputContainer.getAtom(i), explicitValence[i]);
}
} catch (CDKException exception) {
String error =
"Error while parsing line " + linecount + ": " + line + " -> " + exception.getMessage();
logger.error(error);
logger.debug(exception);
throw exception;
} catch (Exception exception) {
exception.printStackTrace();
String error =
"Error while parsing line " + linecount + ": " + line + " -> " + exception.getMessage();
logger.error(error);
logger.debug(exception);
handleError("Error while parsing line: " + line, linecount, 0, 0, exception);
}
return outputContainer;
}
private static void markRingAtomsAndBondsAromatic(IAtomContainer container) {
for (IAtom atom : container.atoms()) atom.setFlag(CDKConstants.ISAROMATIC, true);
for (IBond bond : container.bonds()) bond.setFlag(CDKConstants.ISAROMATIC, true);
}
