private bool preprocessMolecule(IAtomContainer original)
{
//prepare atom weights
var atomWeightCanBeCalculated = prepareAtomWeights(original);
// If the SDF contains an "R" or something, we don't know its mass, so this whole endevour is fruitless
// (since we won't be able to match the fragment masses to the peaks).
if (!atomWeightCanBeCalculated)
{
return false;
}
//mark all the bonds and atoms with numbers --> identify them later on
originalMolecule = markAllBonds(original);
//do ring detection with the original molecule
var allRingsFinder = new AllRingsFinder();
// Steve: Set a really large timeout, because we don't want to crash just because it took a long time.
// The size limit of 7 below should stop it looping forever.
allRingsFinder.setTimeout(int.MaxValue);
// TODO: Steve: The 7 is a max ring size - I added this to prevent it getting in to infinite loops (7 comes from MetFrag
// where it is used in some other random class). Don't know if we need to change this??
allRings = allRingsFinder.findAllRings(originalMolecule, Integer.valueOf(7));
aromaticBonds = new List<IBond>();
CDKHueckelAromaticityDetector.detectAromaticity(originalMolecule);
foreach (var bond in originalMolecule.bonds().ToWindowsEnumerable<IBond>())
{
//lets see if it is a ring and aromatic
var rings = allRings.getRings(bond);
//don't split up aromatic rings...see constructor for option
for (var i = 0; i < rings.getAtomContainerCount(); i++)
{
var aromatic = AromaticityCalculator.isAromatic((IRing)rings.getAtomContainer(i), originalMolecule);
if (aromatic)
{
aromaticBonds.Add(bond);
break;
}
}
}
return true;
}
public static IAtomContainer MoleculeNumbering(IAtomContainer mol)
{
var count = 0;
var countBond = 0;
var alreadyDone = new List<IAtom>();
foreach (var bond in mol.bonds().ToWindowsEnumerable<IBond>())
{
bond.setID(countBond.ToString(CultureInfo.InvariantCulture));
countBond++;
foreach (var atom in bond.atoms().ToWindowsEnumerable<IAtom>())
{
if (!alreadyDone.Contains(atom))
{
atom.setID(count.ToString(CultureInfo.InvariantCulture));
count++;
alreadyDone.Add(atom);
}
}
}
return mol;
}
private IDictionary<IAtom, IList<IBond>> GetAtomBondsDictionary(IAtomContainer atomContainer)
{
var dict = new Dictionary<IAtom, IList<IBond>>();
foreach (var bond in atomContainer.bonds().ToWindowsEnumerable<IBond>())
{
foreach (var atom in bond.atoms().ToWindowsEnumerable<IAtom>())
{
if (!dict.ContainsKey(atom))
{
dict[atom] = new List<IBond>();
}
dict[atom].Add(bond);
}
}
return dict;
}
private List<IBond> getSplitableBonds(IAtomContainer atomContainer, IDictionary<IAtom, IList<IBond>> atomBonds)
{
// find the splitable bonds
var splitableBonds = new List<IBond>();
foreach (var bond in atomContainer.bonds().ToWindowsEnumerable<IBond>())
{
var isTerminal = false;
// lets see if it is a terminal bond...we dont want to split up the hydrogen
foreach (var atom in bond.atoms().ToWindowsEnumerable<IAtom>())
{
//dont split up "terminal" H atoms
if (atomBonds[atom].Count == 1 && atom.getSymbol().StartsWith("H"))
{
//terminal hydrogen...ignore it
isTerminal = true;
break;
}
}
if (!isTerminal)
{
splitableBonds.Add(bond);
}
}
return splitableBonds;
}
/**
* Post process a fragment. --> find neutral possible neutral losses read in
* from the file
*
* @param original
* the original
*
* @return the i atom container set
*
* @throws CDKException
* the CDK exception
* @throws CloneNotSupportedException
* the clone not supported exception
*/
public List<IAtomContainer> PostProcess(IAtomContainer original, double neutralLossMass)
{
// Render.Draw(original, "Original Main");
var ret = new List<IAtomContainer>();
allRings = new RingSet();
if (allRingsOrig.getAtomContainerCount() > 0)
{
// get the rings which are not broken up yet
var bondMap = new Dictionary<IBond, int>();
var count = 0;
foreach (var bondOrig in original.bonds().ToWindowsEnumerable<IBond>())
{
bondMap[bondOrig] = count;
count++;
}
// check for rings which are not broken up!
IRingSet validRings = new RingSet();
for (var i = 0; i < allRingsOrig.getAtomContainerCount(); i++)
{
var bondcount = 0;
foreach (var bondRing in allRingsOrig.getAtomContainer(i).bonds().ToWindowsEnumerable<IBond>())
{
if (bondMap.ContainsKey(bondRing))
{
bondcount++;
}
}
if (bondcount == allRingsOrig.getAtomContainer(i).getBondCount())
{
validRings.addAtomContainer(allRingsOrig.getAtomContainer(i));
}
}
// rings which are not split up
allRings = validRings;
}
IAtomContainer temp = new AtomContainer();
var doneAtoms = new List<IAtom>();
var doneBonds = new List<IBond>();
// now find out the important atoms of the neutral loss
var atomToStart = neutralLoss[neutralLossMass].AtomToStart;
foreach (var bond in original.bonds().ToWindowsEnumerable<IBond>())
{
if (doneBonds.Contains(bond))
{
continue;
}
else
{
doneBonds.Add(bond);
}
// check if this was checked b4
foreach (var atom in bond.atoms().ToWindowsEnumerable<IAtom>())
{
if (doneAtoms.Contains(atom))
{
continue;
}
else
{
doneAtoms.Add(atom);
}
// a possible hit
if (atom.getSymbol().Equals(atomToStart) && !allRings.contains(atom))
{
// Render.Draw(original, "BEFORE");
// check if it is a terminal bond...and not in between!
var atomList = original.getConnectedAtomsList(atom);
var atomCount = 0;
foreach (var iAtom in atomList.ToWindowsEnumerable<IAtom>())
{
// dont check
if (iAtom.getSymbol().Equals("H"))
{
continue;
}
else
{
atomCount++;
}
}
// not a terminal atom...so skip it!
if (atomCount > 1)
{
continue;
}
temp = checkForCompleteNeutralLoss(original, atom,
neutralLossMass);
if (temp.getAtomCount() > 0)
{
if (ConnectivityChecker.isConnected(temp))
{
ret.Add(temp);
}
else
{
var set = ConnectivityChecker
.partitionIntoMolecules(temp);
foreach (var molecule in set.molecules().ToWindowsEnumerable<IMolecule>())
{
ret.Add(molecule);
}
}
// create a atom container
temp = new AtomContainer();
}
}
}
}
return ret;
}
