/**
* Internal - makes a map of the highlights for reaction mapping.
*
* @param reactants reaction reactants
* @param products reaction products
* @return the highlight map
*/
private Map<IChemObject, Color> makeHighlightAtomMap(
List<IAtomContainer> reactants, List<IAtomContainer> products) {
Map<IChemObject, Color> colorMap = new HashMap<>();
Map<Integer, Color> mapToColor = new HashMap<>();
int colorIdx = -1;
for (IAtomContainer mol : reactants) {
int prevPalletIdx = colorIdx;
for (IAtom atom : mol.atoms()) {
int mapidx = accessAtomMap(atom);
if (mapidx > 0) {
if (prevPalletIdx == colorIdx) {
colorIdx++; // select next color
if (colorIdx >= atomMapColors.length)
throw new IllegalArgumentException(
"Not enough colors to highlight atom mapping, please provide mode");
}
Color color = atomMapColors[colorIdx];
colorMap.put(atom, color);
mapToColor.put(mapidx, color);
}
}
if (colorIdx > prevPalletIdx) {
for (IBond bond : mol.bonds()) {
IAtom a1 = bond.getAtom(0);
IAtom a2 = bond.getAtom(1);
Color c1 = colorMap.get(a1);
Color c2 = colorMap.get(a2);
if (c1 != null && c1 == c2) colorMap.put(bond, c1);
}
}
}
for (IAtomContainer mol : products) {
for (IAtom atom : mol.atoms()) {
int mapidx = accessAtomMap(atom);
if (mapidx > 0) {
colorMap.put(atom, mapToColor.get(mapidx));
}
}
for (IBond bond : mol.bonds()) {
IAtom a1 = bond.getAtom(0);
IAtom a2 = bond.getAtom(1);
Color c1 = colorMap.get(a1);
Color c2 = colorMap.get(a2);
if (c1 != null && c1 == c2) colorMap.put(bond, c1);
}
}
return colorMap;
}
private IRenderingElement generate(IAtomContainer molecule, RendererModel model, int atomNum)
throws CDKException {
// tag the atom and bond ids
String molId = molecule.getProperty(MarkedElement.ID_KEY);
if (molId != null) {
int atomId = 0, bondid = 0;
for (IAtom atom : molecule.atoms())
setIfMissing(atom, MarkedElement.ID_KEY, molId + "atm" + ++atomId);
for (IBond bond : molecule.bonds())
setIfMissing(bond, MarkedElement.ID_KEY, molId + "bnd" + ++bondid);
}
if (annotateAtomNum) {
for (IAtom atom : molecule.atoms()) {
if (atom.getProperty(StandardGenerator.ANNOTATION_LABEL) != null)
throw new UnsupportedOperationException("Multiple annotation labels are not supported.");
atom.setProperty(StandardGenerator.ANNOTATION_LABEL, Integer.toString(atomNum++));
}
} else if (annotateAtomVal) {
for (IAtom atom : molecule.atoms()) {
if (atom.getProperty(StandardGenerator.ANNOTATION_LABEL) != null)
throw new UnsupportedOperationException("Multiple annotation labels are not supported.");
atom.setProperty(
StandardGenerator.ANNOTATION_LABEL, atom.getProperty(CDKConstants.COMMENT));
}
} else if (annotateAtomMap) {
for (IAtom atom : molecule.atoms()) {
if (atom.getProperty(StandardGenerator.ANNOTATION_LABEL) != null)
throw new UnsupportedOperationException("Multiple annotation labels are not supported.");
int mapidx = accessAtomMap(atom);
if (mapidx > 0) {
atom.setProperty(StandardGenerator.ANNOTATION_LABEL, Integer.toString(mapidx));
}
}
}
ElementGroup grp = new ElementGroup();
for (IGenerator<IAtomContainer> gen : gens) grp.add(gen.generate(molecule, model));
// cleanup
if (annotateAtomNum || annotateAtomMap) {
for (IAtom atom : molecule.atoms()) {
atom.removeProperty(StandardGenerator.ANNOTATION_LABEL);
}
}
return grp;
}
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;
}
/**
* Modules for cleaning a molecule
*
* @param molecule
* @return cleaned AtomContainer
*/
@TestMethod("testCheckAndCleanMolecule")
public static IAtomContainer checkAndCleanMolecule(IAtomContainer molecule) {
boolean isMarkush = false;
for (IAtom atom : molecule.atoms()) {
if (atom.getSymbol().equals("R")) {
isMarkush = true;
break;
}
}
if (isMarkush) {
System.err.println("Skipping Markush structure for sanity check");
}
// Check for salts and such
if (!ConnectivityChecker.isConnected(molecule)) {
// lets see if we have just two parts if so, we assume its a salt and just work
// on the larger part. Ideally we should have a check to ensure that the smaller
// part is a metal/halogen etc.
IMoleculeSet fragments = ConnectivityChecker.partitionIntoMolecules(molecule);
if (fragments.getMoleculeCount() > 2) {
System.err.println("More than 2 components. Skipped");
} else {
IMolecule frag1 = fragments.getMolecule(0);
IMolecule frag2 = fragments.getMolecule(1);
if (frag1.getAtomCount() > frag2.getAtomCount()) {
molecule = frag1;
} else {
molecule = frag2;
}
}
}
configure(molecule);
return molecule;
}
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();
}
/** 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;
}
/**
* 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);
}
@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());
}
private boolean checkForNullAtoms(IAtomContainer mol) {
for (IAtom a : mol.atoms()) {
if (a == null) {
return true;
}
}
return false;
}
private boolean isChemicallyValid(IAtomContainer union) throws CDKException {
for (IAtom atom : union.atoms()) {
if ((union.getConnectedBondsCount(atom) + atom.getFormalCharge())
> atom.getFormalNeighbourCount()) {
return false;
}
}
return true;
}
/**
* Test to recognize if a IAtomContainer matcher correctly identifies the CDKAtomTypes.
*
* @param molecule The IAtomContainer to analyze
* @throws CDKException
*/
private void makeSureAtomTypesAreRecognized(IAtomContainer molecule) throws CDKException {
Iterator<IAtom> atoms = molecule.atoms().iterator();
CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.getInstance(molecule.getBuilder());
while (atoms.hasNext()) {
IAtom nextAtom = atoms.next();
Assert.assertNotNull(
"Missing atom type for: " + nextAtom, matcher.findMatchingAtomType(molecule, nextAtom));
}
}
private boolean checkForGenericAtoms(IAtomContainer mol) {
for (IAtom atom : mol.atoms()) {
if (atom instanceof PseudoAtom) return true;
String className = atom.getClass().getName();
if (className.equalsIgnoreCase("org.openscience.cdk.PseudoAtom")) {
return true;
}
}
return false;
}
/**
* Place all hydrogens connected to atoms which have already been laid out.
*
* @param container atom container
* @param bondLength bond length to user
*/
@TestMethod("testBug933572,testH2")
public void placeHydrogens2D(final IAtomContainer container, final double bondLength) {
logger.debug("placing hydrogens on all atoms");
for (IAtom atom : container.atoms()) {
// only place hydrogens for atoms which have coordinates
if (atom.getPoint2d() != null) {
placeHydrogens2D(container, atom, bondLength);
}
}
logger.debug("hydrogen placement complete");
}
/**
* Reset the coordinates to their position before rendering.
*
* @param mols molecules
* @param scales how molecules were scaled
*/
private static void resetCoords(Iterable<IAtomContainer> mols, List<Double> scales) {
Iterator<Double> it = scales.iterator();
for (IAtomContainer mol : mols) {
final double factor = it.next();
if (!Double.isNaN(factor)) {
GeometryUtil.scaleMolecule(mol, 1 / factor);
} else {
for (IAtom atom : mol.atoms()) atom.setPoint2d(null);
}
}
}
/**
* @param atomContainer
* @param getNoneAssesments
* @return
*/
@Override
public Map<IAtom, IStereoAndConformation> getTetrahedralChiralities(
IAtomContainer atomContainer, boolean getNoneAssesments) {
Map<IAtom, IStereoAndConformation> chiralities = new HashMap<>();
WedgeStereoLifter lifter = new WedgeStereoLifter();
for (IAtom atom : atomContainer.atoms()) {
IStereoAndConformation chirality = getChirality2D(lifter, atom, atomContainer);
if (getNoneAssesments || chirality != NONE) {
chiralities.put(atom, chirality);
}
}
return chiralities;
}
/**
* Returns common mapped fragment in the target molecule.
*
* @return common mapped fragment in the target molecule
* @throws CloneNotSupportedException
*/
public synchronized IAtomContainer getCommonFragmentInTarget() throws CloneNotSupportedException {
IAtomContainer ac = (IAtomContainer) target.clone();
List<IAtom> uniqueAtoms = Collections.synchronizedList(new ArrayList<IAtom>());
for (IAtom atom : target.atoms()) {
if (!mapping.containsValue(atom)) {
uniqueAtoms.add(ac.getAtom(getTargetIndex(atom)));
}
}
for (IAtom atom : uniqueAtoms) {
ac.removeAtomAndConnectedElectronContainers(atom);
}
return ac;
}
/**
* Clean up chemical model ,removing duplicates empty molecules etc
*
* @param chemModel
* @param avoidOverlap
* @throws CDKException
*/
public static void cleanUpChemModel(final IChemModel chemModel,
final boolean avoidOverlap, final AbstractJChemPaintPanel panel)
throws CDKException {
JChemPaint.setReactionIDs(chemModel);
JChemPaint.replaceReferencesWithClones(chemModel);
// check the model is not completely empty
if (ChemModelManipulator.getBondCount(chemModel) == 0
&& ChemModelManipulator.getAtomCount(chemModel) == 0) {
throw new CDKException(
"Structure does not have bonds or atoms. Cannot depict structure.");
}
JChemPaint.removeDuplicateAtomContainers(chemModel);
JChemPaint.checkCoordinates(chemModel);
JChemPaint.removeEmptyAtomContainers(chemModel);
if (avoidOverlap) {
try {
ControllerHub.avoidOverlap(chemModel);
} catch (final Exception e) {
JOptionPane.showMessageDialog(panel,
GT._("Structure could not be generated"));
throw new CDKException("Cannot depict structure");
}
}
// We update implicit Hs in any case
final CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher
.getInstance(chemModel.getBuilder());
for (final IAtomContainer container : ChemModelManipulator
.getAllAtomContainers(chemModel)) {
for (final IAtom atom : container.atoms()) {
if (!(atom instanceof IPseudoAtom)) {
try {
final IAtomType type = matcher.findMatchingAtomType(
container, atom);
if (type != null
&& type.getFormalNeighbourCount() != null) {
final int connectedAtomCount = container
.getConnectedAtomsCount(atom);
atom.setImplicitHydrogenCount(type
.getFormalNeighbourCount()
- connectedAtomCount);
}
} catch (final CDKException e) {
e.printStackTrace();
}
}
}
}
}
@Test
public void testRingFlags1() throws Exception {
SmilesParser sp = new SmilesParser(DefaultChemObjectBuilder.getInstance());
IAtomContainer molecule = sp.parseSmiles("c1ccccc1");
new SSSRFinder(molecule).findSSSR();
int count = 0;
Iterator atoms = molecule.atoms().iterator();
while (atoms.hasNext()) {
IAtom atom = (IAtom) atoms.next();
if (atom.getFlag(CDKConstants.ISINRING)) count++;
}
Assert.assertEquals("All atoms in benzene were not marked as being in a ring", 6, count);
}
/**
* Method that actually does the work of convert the atomContainer to IMolecularFormula given a
* IMolecularFormula.
*
* <p>The hydrogens must be implicit.
*
* @param atomContainer IAtomContainer object
* @param formula IMolecularFormula molecularFormula to put the new Isotopes
* @return the filled AtomContainer
* @see #getMolecularFormula(IAtomContainer)
*/
public static IMolecularFormula getMolecularFormula(
IAtomContainer atomContainer, IMolecularFormula formula) {
int charge = 0;
IAtom hAtom = null;
for (IAtom iAtom : atomContainer.atoms()) {
formula.addIsotope(iAtom);
if (iAtom.getFormalCharge() != null) charge += iAtom.getFormalCharge();
if (iAtom.getImplicitHydrogenCount() != null && (iAtom.getImplicitHydrogenCount() > 0)) {
if (hAtom == null) hAtom = atomContainer.getBuilder().newInstance(IAtom.class, "H");
formula.addIsotope(hAtom, iAtom.getImplicitHydrogenCount());
}
}
formula.setCharge(charge);
return formula;
}
/**
* The method returns partial charges assigned to an heavy atom through MMFF94 method. It is
* needed to call the addExplicitHydrogensToSatisfyValency method from the class
* tools.HydrogenAdder.
*
* @param atom The IAtom for which the DescriptorValue is requested
* @param org AtomContainer
* @return partial charge of parameter atom
*/
@Override
public DescriptorValue calculate(IAtom atom, IAtomContainer org) {
if (atom.getProperty(CHARGE_CACHE) == null) {
IAtomContainer copy;
try {
copy = org.clone();
} catch (CloneNotSupportedException e) {
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
new DoubleResult(Double.NaN),
NAMES);
}
for (IAtom a : org.atoms()) {
if (a.getImplicitHydrogenCount() == null || a.getImplicitHydrogenCount() != 0) {
logger.error("Hydrogens must be explict for MMFF charge calculation");
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
new DoubleResult(Double.NaN),
NAMES);
}
}
if (!mmff.assignAtomTypes(copy))
logger.warn("One or more atoms could not be assigned an MMFF atom type");
mmff.partialCharges(copy);
mmff.clearProps(copy);
// cache charges
for (int i = 0; i < org.getAtomCount(); i++) {
org.getAtom(i).setProperty(CHARGE_CACHE, copy.getAtom(i).getCharge());
}
}
return new DescriptorValue(
getSpecification(),
getParameterNames(),
getParameters(),
new DoubleResult(atom.getProperty(CHARGE_CACHE, Double.class)),
NAMES);
}
/** Tests if the electron count matches the Hückel 4n+2 rule. */
private static boolean isHueckelValid(IAtomContainer singleRing) throws CDKException {
int electronCount = 0;
for (IAtom ringAtom : singleRing.atoms()) {
if (ringAtom.getHybridization() != CDKConstants.UNSET
&& (ringAtom.getHybridization() == Hybridization.SP2)
|| ringAtom.getHybridization() == Hybridization.PLANAR3) {
// for example, a carbon
// note: the double bond is in the ring, that has been tested earlier
// FIXME: this does assume bond orders to be resolved too, when detecting
// sprouting double bonds
if ("N.planar3".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("N.minus.planar3".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("N.amide".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("S.2".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("S.planar3".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("C.minus.planar".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("O.planar3".equals(ringAtom.getAtomTypeName())) {
electronCount += 2;
} else if ("N.sp2.3".equals(ringAtom.getAtomTypeName())) {
electronCount += 1;
} else {
if (factory == null) {
factory =
AtomTypeFactory.getInstance(
"org/openscience/cdk/dict/data/cdk-atom-types.owl", ringAtom.getBuilder());
}
IAtomType type = factory.getAtomType(ringAtom.getAtomTypeName());
Object property = type.getProperty(CDKConstants.PI_BOND_COUNT);
if (property != null && property instanceof Integer) {
electronCount += ((Integer) property).intValue();
}
}
} else if (ringAtom.getHybridization() != null
&& ringAtom.getHybridization() == Hybridization.SP3
&& getLonePairCount(ringAtom) > 0) {
// for example, a nitrogen or oxygen
electronCount += 2;
}
}
return (electronCount % 4 == 2) && (electronCount > 2);
}
private synchronized IQuery build(IAtomContainer queryMolecule) {
VFQueryBuilder result = new VFQueryBuilder();
for (IAtom atom : queryMolecule.atoms()) {
AtomMatcher matcher = createAtomMatcher(queryMolecule, atom);
if (matcher != null) {
result.addNode(matcher, atom);
}
}
for (int i = 0; i < queryMolecule.getBondCount(); i++) {
IBond bond = queryMolecule.getBond(i);
IAtom atomI = bond.getAtom(0);
IAtom atomJ = bond.getAtom(1);
result.connect(
result.getNode(atomI), result.getNode(atomJ), createBondMatcher(queryMolecule, bond));
}
return result;
}
/**
* 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);
}
}
}
}
}
}
}
}
}
/**
* Determines if the isolatedRingSystem has attached double bonds, which are not part of the ring
* system itself, and not part of any other ring system. Exceptions: a N.sp2.3 nitrogen with a
* double ring to an oxygen outwards.
*/
private static boolean isRingSystemSproutedWithNonRingDoubleBonds(
IAtomContainer fullContainer, IAtomContainer isolatedRingSystem) {
Iterator<IAtom> atoms = isolatedRingSystem.atoms().iterator();
while (atoms.hasNext()) {
IAtom atom = atoms.next();
Iterator<IBond> neighborBonds = fullContainer.getConnectedBondsList(atom).iterator();
while (neighborBonds.hasNext()) {
IBond neighborBond = neighborBonds.next();
if (!neighborBond.getFlag(CDKConstants.ISINRING)
&& neighborBond.getOrder() == CDKConstants.BONDORDER_DOUBLE
|| neighborBond.getOrder() == CDKConstants.BONDORDER_TRIPLE) {
if (!("N.sp2.3".equals(atom.getAtomTypeName())
&& "O.sp2".equals(neighborBond.getConnectedAtom(atom).getAtomTypeName())))
return true;
}
}
}
return false;
}
/** @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);
}
}
public String perceiveSybylAtomTypes(IMolecule mol)
throws InvocationTargetException {
ICDKMolecule cdkmol;
try {
cdkmol = cdk.asCDKMolecule(mol);
}
catch (BioclipseException e) {
System.out.println("Error converting cdk10 to cdk");
e.printStackTrace();
throw new InvocationTargetException(e);
}
IAtomContainer ac = cdkmol.getAtomContainer();
CDKAtomTypeMatcher cdkMatcher
= CDKAtomTypeMatcher.getInstance(ac.getBuilder());
AtomTypeMapper mapper
= AtomTypeMapper.getInstance(
"org/openscience/cdk/dict/data/cdk-sybyl-mappings.owl" );
IAtomType[] sybylTypes = new IAtomType[ac.getAtomCount()];
int atomCounter = 0;
int a=0;
for (IAtom atom : ac.atoms()) {
IAtomType type;
try {
type = cdkMatcher.findMatchingAtomType(ac, atom);
}
catch (CDKException e) {
type = null;
}
if (type==null) {
// logger.debug("AT null for atom: " + atom);
type = atom.getBuilder().newAtomType(atom.getSymbol());
type.setAtomTypeName("X");
}
AtomTypeManipulator.configure(atom, type);
a++;
}
try {
CDKHueckelAromaticityDetector.detectAromaticity(ac);
// System.out.println("Arom: "
// + CDKHueckelAromaticityDetector.detectAromaticity(ac) );
}
catch (CDKException e) {
logger.debug("Failed to perceive aromaticity: " + e.getMessage());
}
for (IAtom atom : ac.atoms()) {
String mappedType = mapper.mapAtomType(atom.getAtomTypeName());
if ("C.2".equals(mappedType)
&& atom.getFlag(CDKConstants.ISAROMATIC)) {
mappedType = "C.ar";
}
else if ("N.pl3".equals(mappedType)
&& atom.getFlag(CDKConstants.ISAROMATIC)) {
mappedType = "N.ar";
}
try {
sybylTypes[atomCounter] = factory.getAtomType(mappedType);
}
catch (NoSuchAtomTypeException e) {
// yes, setting null's here is important
sybylTypes[atomCounter] = null;
}
atomCounter++;
}
StringBuffer result = new StringBuffer();
// now that full perception is finished, we can set atom type names:
for (int i = 0; i < sybylTypes.length; i++) {
if (sybylTypes[i] != null) {
ac.getAtom(i).setAtomTypeName(sybylTypes[i].getAtomTypeName());
}
else {
ac.getAtom(i).setAtomTypeName("X");
}
result.append(i).append(':').append(ac.getAtom(i).getAtomTypeName())
/*.append("\n")*/;
}
return result.toString();
}
/**
* @return
* @throws Exception
*/
public int process() throws Exception {
if (file == null) throw new Exception("File not assigned! Use -f command line option.");
if (!file.exists()) throw new FileNotFoundException(file.getAbsolutePath());
int records_read = 0;
int records_processed = 0;
int records_error = 0;
InputStream in = new FileInputStream(file);
/**
* cdk-io module http://ambit.uni-plovdiv.bg:8083/nexus/index.html#nexus-
* search;classname~IteratingMDLReader
*/
IteratingSDFReader reader = null;
SDFWriter writer = new SDFWriter(new OutputStreamWriter(System.out));
try {
reader = new IteratingSDFReader(in, DefaultChemObjectBuilder.getInstance());
LOGGER.log(Level.INFO, String.format("Reading %s", file.getAbsoluteFile()));
while (reader.hasNext()) {
/** Note recent versions allow IAtomContainer molecule = reader.next(); */
Object object = reader.next();
IAtomContainer molecule = null;
if (object instanceof IAtomContainer) molecule = (IAtomContainer) object;
else break;
records_read++;
try {
/** cdk-standard module */
AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(molecule);
// CDKHueckelAromaticityDetector.detectAromaticity(molecule);
for (IAtom atom : molecule.atoms())
if (atom.getImplicitHydrogenCount() == null) {
LOGGER.fine(
atom.getSymbol()
+ "\t"
+ atom.getAtomTypeName()
+ "\t"
+ atom.getImplicitHydrogenCount());
atom.setImplicitHydrogenCount(0);
}
molecule = AtomContainerManipulator.copyAndSuppressedHydrogens(molecule);
/** Generate SMILES and assign as properties */
assignSMILES(molecule);
molecule.setProperty("REACTION", "REACTANT");
molecule.setProperty("SMIRKS", "");
/** Apply reactions */
writer.write(molecule);
for (int r = 0; r < smirks.length; r++) {
if (reactions[r] == null) {
reactions[r] = smrkMan.parse(smirks[r][1]);
}
IAtomContainer reactant = molecule.clone();
if (smrkMan.applyTransformation(reactant, reactions[r])) {
AtomContainerManipulator.percieveAtomTypesAndConfigureAtoms(reactant);
reactant.setProperty("REACTION", "PRODUCT OF " + smirks[r][0]);
reactant.setProperty("SMIRKS", smirks[r][1]);
try {
assignSMILES(reactant);
} catch (Exception x) {
LOGGER.log(Level.WARNING, x.getMessage());
}
writer.write(reactant);
}
}
records_processed++;
;
} catch (Exception x) {
System.err.println("*");
records_error++;
LOGGER.log(
Level.SEVERE,
String.format("[Record %d] Error %s\n", records_read, file.getAbsoluteFile()),
x);
}
}
} catch (Exception x) {
LOGGER.log(
Level.SEVERE,
String.format("[Record %d] Error %s\n", records_read, file.getAbsoluteFile()),
x);
} finally {
try {
reader.close();
} catch (Exception x) {
}
try {
writer.close();
} catch (Exception x) {
}
}
LOGGER.log(
Level.INFO,
String.format(
"[Records read/processed/error %d/%d/%d] %s",
records_read, records_processed, records_error, file.getAbsoluteFile()));
return records_read;
}
/**
* Process spectra in the following way: Fragment each hit in KEGG starting with the lowest
* collision energy If hits were found they are used for the next measurement as input and the
* original molecule is not used.
*
* @param folder the folder
* @param file the file
*/
private void processSpectra(String folder, String file, int treeDepth) {
this.scoreMap = new HashMap<Integer, ArrayList<String>>();
if (blackList.contains(file)) {
completeLog += "Blacklisted Molecule: " + file;
histogramReal += "\n" + file + "\tBLACKLIST\t";
histogram += "\n" + file + "\tBLACKLIST\t";
histogramCompare += "\n" + file + "\tBLACKLIST\t";
return;
}
double exactMass = spectra.get(0).getExactMass();
// timing
long timeStart = System.currentTimeMillis();
HashMap<Double, Vector<String>> realScoreMap = new HashMap<Double, Vector<String>>();
int mode = spectra.get(0).getMode();
// instantiate and read in CID-KEGG.txt
String keggIdentifier = spectra.get(0).getKEGG();
completeLog +=
"\n\n============================================================================";
completeLog +=
"\nFile: " + spectra.get(0).getTrivialName() + " (KEGG Entry: " + keggIdentifier + ")";
// get candidates from kegg webservice...with with a given mzppm and mzabs
Vector<String> candidates =
KeggWebservice.KEGGbyMass(exactMass, (mzabs + PPMTool.getPPMDeviation(exactMass, mzppm)));
try {
GetKEGGIdentifier keggID = new GetKEGGIdentifier(folder + "CID-KEGG/CID-KEGG.txt");
// now find the corresponding KEGG entry
if (keggID.existInKEGG(spectra.get(0).getCID()))
keggIdentifier = keggID.getKEGGID(spectra.get(0).getCID());
} catch (IOException e) {
System.out.println(e.getMessage());
completeLog += "Error! Message: " + e.getMessage();
}
// comparison histogram
if (keggIdentifier.equals("none"))
histogramCompare += "\n" + file + "\t" + keggIdentifier + "\t\t" + exactMass;
else
histogramCompare +=
"\n" + file + "\t" + keggIdentifier + "\t" + candidates.size() + "\t" + exactMass;
// list of peaks which are contained in the real molecule
Vector<Peak> listOfPeaksCorresponding = new Vector<Peak>();
// list of peaks which are not contained in the real molecule
Vector<Peak> listOfPeaks = new Vector<Peak>();
// loop over all hits
for (int c = 0; c < candidates.size(); c++) {
this.foundHits = new Vector<IAtomContainer>();
// get mol file from kegg....remove "cpd:"
String candidate = KeggWebservice.KEGGgetMol(candidates.get(c).substring(4), this.keggPath);
IAtomContainer molecule = null;
try {
// write string to disk
new File(folder + file + "_Mol").mkdir();
File outFile = new File(folder + file + "_Mol/" + candidates.get(c).substring(4) + ".mol");
FileWriter out = new FileWriter(outFile);
out.write(candidate);
out.close();
// now fragment the retrieved molecule
molecule = Molfile.Read(folder + file + "_Mol/" + candidates.get(c).substring(4) + ".mol");
// now create a new folder to write the .mol files into
new File(folder + file).mkdir();
boolean status = new File(folder + file + "/" + candidates.get(c).substring(4)).mkdir();
} catch (IOException e) {
completeLog += "Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
} catch (CDKException e) {
completeLog += "Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
}
try {
// add hydrogens
CDKAtomTypeMatcher matcher = CDKAtomTypeMatcher.getInstance(molecule.getBuilder());
for (IAtom atom : molecule.atoms()) {
IAtomType type = matcher.findMatchingAtomType(molecule, atom);
AtomTypeManipulator.configure(atom, type);
}
CDKHydrogenAdder hAdder = CDKHydrogenAdder.getInstance(molecule.getBuilder());
hAdder.addImplicitHydrogens(molecule);
AtomContainerManipulator.convertImplicitToExplicitHydrogens(molecule);
}
// there is a bug in cdk?? error happens when there is a S or Ti in the molecule
catch (IllegalArgumentException e) {
completeLog += "Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
// skip it
continue;
} catch (CDKException e) {
completeLog += "Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
// skip it
continue;
}
// get peak list....it is reset if this is not the first run
Vector<Peak> peakList = spectra.get(0).getPeakList();
// create a new instance
Fragmenter fragmenter =
new Fragmenter(
(Vector<Peak>) peakList.clone(),
mzabs,
mzppm,
mode,
breakAromaticRings,
quickRedundancy,
false,
false);
double combinedScore = 0;
int combinedHits = 0;
int combinedPeakCount = 0;
String peaks = "";
combinedPeakCount = peakList.size();
int count = 0;
boolean first = true;
// loop over the different collision energies
for (WrapperSpectrum spectrum : spectra) {
List<IAtomContainer> l = null;
long start = System.currentTimeMillis();
try {
if (first) {
try {
l = fragmenter.generateFragmentsInMemory(molecule, true, treeDepth);
count++;
} catch (OutOfMemoryError e) {
System.out.println("OUT OF MEMORY ERROR! " + candidates.get(c).substring(4));
completeLog +=
"Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
continue;
}
first = false;
} else {
peakList = spectrum.getPeakList();
combinedPeakCount += peakList.size();
// set the current peak list...
fragmenter.setPeakList((Vector<Peak>) peakList.clone());
try {
// l = fragmenter.generateFragmentsHierarchical(foundHits, true);
System.err.println("REMOVED....no improvement!");
System.exit(1);
count++;
} catch (OutOfMemoryError e) {
System.out.println("OUT OF MEMORY ERROR! " + candidates.get(c).substring(4));
completeLog +=
"Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
continue;
}
}
long time = System.currentTimeMillis() - start;
System.out.println("Benötigte Zeit: " + time);
System.out.println("Got " + l.size() + " fragments");
System.out.println("Needed " + fragmenter.getNround() + " calls to generateFragments()");
new File(
folder
+ file
+ "/"
+ candidates.get(c).substring(4)
+ "/"
+ spectrum.getCollisionEnergy())
.mkdir();
for (int i = 0; i < l.size(); i++) {
try {
// write fragments to disk
FileWriter w =
new FileWriter(
new File(
folder
+ file
+ "/"
+ candidates.get(c).substring(4)
+ "/"
+ spectrum.getCollisionEnergy()
+ "/frag_"
+ i
+ ".mol"));
MDLWriter mw = new MDLWriter(w);
mw.write(new Molecule(l.get(i)));
mw.close();
} catch (IOException e) {
System.out.println("IOException: " + e.toString());
completeLog +=
"Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
} catch (Exception e) {
System.out.println(e.toString());
completeLog +=
"Error: " + candidates.get(c).substring(4) + " Message: " + e.getMessage();
}
}
// Draw molecule and its fragments
if (showDiagrams) Render.Draw(molecule, l, "Original Molecule");
if (pdf) {
// Create PDF Output
l.add(0, molecule);
DisplayStructure ds1 = null;
// create pdf subfolder
new File(folder + file + "/" + candidates.get(c) + "pdf/").mkdir();
ds1 =
new WritePDFTable(
true,
300,
300,
0.9,
2,
false,
false,
folder + file + "/" + candidates.get(c) + "pdf/");
for (int i = 0; i < l.size(); i++) {
// ds = new displayStructure(false, 300, 300, 0.9, false, "PDF",
// "/home/basti/WorkspaceJava/TandemMSLookup/fragmenter/Test");
assert ds1 != null;
ds1.drawStructure(l.get(i), i);
}
if (ds1 != null) ds1.close();
}
// now read the saved mol files
List<IAtomContainer> fragments =
Molfile.Readfolder(
folder
+ file
+ "/"
+ candidates.get(c).substring(4)
+ "/"
+ spectrum.getCollisionEnergy());
List<IAtomContainer> fragmentsList = new ArrayList<IAtomContainer>();
for (int i = 0; i < fragments.size(); i++) {
fragmentsList.add(fragments.get(i));
}
// get the original peak list again
// spectrum = new SpectrumWrapper(folder + file + ".txt");
peakList = (Vector<Peak>) spectrum.getPeakList().clone();
// clean up peak list
CleanUpPeakList cList = new CleanUpPeakList(peakList);
Vector<Peak> cleanedPeakList = cList.getCleanedPeakList(spectrum.getExactMass());
// now find corresponding fragments to the mass
AssignFragmentPeak afp = new AssignFragmentPeak();
afp.setHydrogenTest(hydrogenTest);
afp.assignFragmentPeak(
fragments, cleanedPeakList, mzabs, mzppm, spectrum.getMode(), false);
Vector<PeakMolPair> hits = afp.getHits();
Vector<PeakMolPair> hitsAll = afp.getAllHits();
// add them to the list of already found fragments....they were found in the previous run
// with a smaller collission energy
for (PeakMolPair peakMolPair : hitsAll) {
foundHits.add(peakMolPair.getFragment());
}
combinedHits += ((combinedHits + hits.size()) - combinedHits);
// Render.Draw(molecule, foundHits, "Found Hits");
// now "real" scoring
Scoring score = new Scoring(cleanedPeakList);
double currentScore = score.computeScoring(afp.getHitsMZ());
combinedScore += currentScore;
// check for last run and create the data for the log file
if (count == spectra.size()) {
// save score in hashmap...if there are several hits with the same score --> vector of
// strings
if (realScoreMap.containsKey(combinedScore)) {
Vector<String> tempList = realScoreMap.get(combinedScore);
tempList.add(candidates.get(c).substring(4));
realScoreMap.put(combinedScore, tempList);
} else {
Vector<String> temp = new Vector<String>();
temp.add(candidates.get(c).substring(4));
realScoreMap.put(combinedScore, temp);
}
// save score in hashmap...if there are several hits with the same
// amount of identified peaks --> ArrayList
if (scoreMap.containsKey(combinedHits)) {
ArrayList<String> tempList = scoreMap.get(combinedHits);
tempList.add(candidates.get(c).substring(4));
scoreMap.put(combinedHits, tempList);
} else {
ArrayList<String> temp = new ArrayList<String>();
temp.add(candidates.get(c).substring(4));
scoreMap.put(combinedHits, temp);
}
}
// get all the identified peaks
for (int i = 0; i < hits.size(); i++) {
peaks += hits.get(i).getPeak().getMass() + " ";
listOfPeaks.add(hits.get(i).getPeak());
if (keggIdentifier.equals(candidates.get(c).substring(4)))
listOfPeaksCorresponding.add(hits.get(i).getPeak());
}
List<IAtomContainer> hitsListTest = new ArrayList<IAtomContainer>();
for (int i = 0; i < hits.size(); i++) {
List<IAtomContainer> hitsList = new ArrayList<IAtomContainer>();
hitsList.add(AtomContainerManipulator.removeHydrogens(hits.get(i).getFragment()));
hitsListTest.add(hits.get(i).getFragment());
// Render.Highlight(AtomContainerManipulator.removeHydrogens(molecule), hitsList ,
// Double.toString(hits.get(i).getPeak()));
}
if (showDiagrams)
Render.Draw(molecule, hitsListTest, "Fragmente von: " + candidates.get(c));
} catch (CDKException e) {
System.out.println("CDK error!" + e.getMessage());
completeLog += "CDK Error! " + e.getMessage() + "File: " + candidates.get(c).substring(4);
} catch (FileNotFoundException e) {
System.out.println("File not found" + e.getMessage());
completeLog +=
"File not found error! " + e.getMessage() + "File: " + candidates.get(c).substring(4);
} catch (IOException e) {
System.out.println("IO error: " + e.getMessage());
completeLog += "IO Error! " + e.getMessage() + "File: " + candidates.get(c).substring(4);
} catch (Exception e) {
System.out.println("Error" + e.getMessage());
completeLog += "Error! " + e.getMessage() + "File: " + candidates.get(c).substring(4);
} catch (OutOfMemoryError e) {
System.out.println("Out of memory: " + e.getMessage() + "\n" + e.getStackTrace());
System.gc();
completeLog +=
"Out of memory! " + e.getMessage() + "File: " + candidates.get(c).substring(4);
}
}
// write things to log file
foundPeaks += combinedHits;
allPeaks += combinedPeakCount;
completeLog +=
"\nFile: "
+ candidates.get(c).substring(4)
+ "\t #Peaks: "
+ combinedPeakCount
+ "\t #Found: "
+ combinedHits;
completeLog += "\tPeaks: " + peaks;
}
// easy scoring
Integer[] keylist = new Integer[scoreMap.keySet().size()];
Object[] keys = scoreMap.keySet().toArray();
for (int i = 0; i < keys.length; i++) {
keylist[i] = Integer.parseInt(keys[i].toString());
}
Arrays.sort(keylist);
String scoreList = "";
int rank = 0;
for (int i = keylist.length - 1; i >= 0; i--) {
boolean check = false;
for (int j = 0; j < scoreMap.get(keylist[i]).size(); j++) {
scoreList += "\n" + keylist[i] + " - " + scoreMap.get(keylist[i]).get(j);
if (keggIdentifier.equals(scoreMap.get(keylist[i]).get(j))) {
check = true;
}
// worst case: count all which are better or have a equal position
rank++;
}
if (check) {
histogram += "\n" + file + "\t" + keggIdentifier + "\t" + rank + "\t" + exactMass;
}
}
if (keggIdentifier.equals("none")) {
histogram += "\n" + file + "\t" + keggIdentifier + "\t\t" + exactMass;
}
completeLog += "\n\n*****************Scoring*****************************";
completeLog += "Supposed to be: " + keggIdentifier;
completeLog += scoreList;
completeLog += "\n*****************************************************\n\n";
// easy scoring end
// real scoring
Double[] keysScore = new Double[realScoreMap.keySet().size()];
keysScore = realScoreMap.keySet().toArray(keysScore);
Arrays.sort(keysScore);
String scoreListReal = "";
rank = 0;
for (int i = keysScore.length - 1; i >= 0; i--) {
boolean check = false;
for (int j = 0; j < realScoreMap.get(keysScore[i]).size(); j++) {
scoreListReal += "\n" + keysScore[i] + " - " + realScoreMap.get(keysScore[i]).get(j);
if (keggIdentifier.compareTo(realScoreMap.get(keysScore[i]).get(j)) == 0) {
check = true;
}
// worst case: count all which are better or have a equal position
rank++;
}
if (check) {
histogramReal += "\n" + file + "\t" + keggIdentifier + "\t" + rank + "\t" + exactMass;
}
}
if (keggIdentifier.equals("none")) {
histogramReal += "\n" + file + "\t" + keggIdentifier + "\t\t" + exactMass;
}
// timing
long timeEnd = System.currentTimeMillis() - timeStart;
sumTime += timeEnd;
completeLog += "\n\n*****************Scoring(Real)*****************************";
completeLog += "Supposed to be: " + keggIdentifier;
completeLog += "\nTime: " + timeEnd;
completeLog += scoreListReal;
completeLog += "\n*****************************************************\n\n";
// write the data for peak histogram to log file
for (int i = 0; i < listOfPeaks.size(); i++) {
histogramPeaksAll += listOfPeaks.get(i) + "\n";
}
// filter the peaks which are contained in the all peaks list. (exclusive)
for (int i = 0; i < listOfPeaksCorresponding.size(); i++) {
for (int j = 0; j < listOfPeaks.size(); j++) {
Double valueA = listOfPeaks.get(j).getMass();
Double valueB = listOfPeaksCorresponding.get(i).getMass();
if (valueA.compareTo(valueB) == 0) {
listOfPeaks.remove(j);
}
}
}
for (int i = 0; i < listOfPeaks.size(); i++) {
histogramPeaks += listOfPeaks.get(i) + " ";
}
for (int i = 0; i < listOfPeaksCorresponding.size(); i++) {
histogramPeaksReal += listOfPeaksCorresponding.get(i) + " ";
}
}
/**
* Get all paths of lengths 0 to the specified length.
*
* <p>This method will find all paths upto length N starting from each atom in the molecule and
* return the unique set of such paths.
*
* @param container The molecule to search
* @return A map of path strings, keyed on themselves
*/
private Integer[] findPaths(IAtomContainer container) {
ShortestPathWalker walker = new ShortestPathWalker(container);
// convert paths to hashes
List<Integer> paths = new ArrayList<Integer>();
int patternIndex = 0;
for (String s : walker.paths()) {
int toHashCode = s.hashCode();
paths.add(patternIndex, toHashCode);
patternIndex++;
}
/*
* Add ring information
*/
IRingSet sssr = Cycles.essential(container).toRingSet();
RingSetManipulator.sort(sssr);
for (Iterator<IAtomContainer> it = sssr.atomContainers().iterator(); it.hasNext(); ) {
IAtomContainer ring = it.next();
int toHashCode = String.valueOf(ring.getAtomCount()).hashCode();
paths.add(patternIndex, toHashCode);
patternIndex++;
}
/*
* Check for the charges
*/
List<String> l = new ArrayList<String>();
for (Iterator<IAtom> it = container.atoms().iterator(); it.hasNext(); ) {
IAtom atom = it.next();
int charge = atom.getFormalCharge() == null ? 0 : atom.getFormalCharge();
if (charge != 0) {
l.add(atom.getSymbol().concat(String.valueOf(charge)));
}
}
Collections.sort(l);
int toHashCode = l.hashCode();
paths.add(patternIndex, toHashCode);
patternIndex++;
l = new ArrayList<String>();
/*
* atom stereo parity
*/
for (Iterator<IAtom> it = container.atoms().iterator(); it.hasNext(); ) {
IAtom atom = it.next();
int st = atom.getStereoParity() == null ? 0 : atom.getStereoParity();
if (st != 0) {
l.add(atom.getSymbol().concat(String.valueOf(st)));
}
}
Collections.sort(l);
toHashCode = l.hashCode();
paths.add(patternIndex, toHashCode);
patternIndex++;
if (container.getSingleElectronCount() > 0) {
StringBuilder radicalInformation = new StringBuilder();
radicalInformation.append("RAD: ").append(String.valueOf(container.getSingleElectronCount()));
paths.add(patternIndex, radicalInformation.toString().hashCode());
patternIndex++;
}
if (container.getLonePairCount() > 0) {
StringBuilder lpInformation = new StringBuilder();
lpInformation.append("LP: ").append(String.valueOf(container.getLonePairCount()));
paths.add(patternIndex, lpInformation.toString().hashCode());
patternIndex++;
}
return paths.toArray(new Integer[paths.size()]);
}