public static void Main()
{
{
IChemObjectSet <IAtomContainer> ms = null;
#region
AllRingsFinder arf = new AllRingsFinder();
foreach (var m in ms)
{
try
{
IRingSet rs = arf.FindAllRings(m);
}
catch (CDKException)
{
// molecule was too complex, handle error
}
}
#endregion
}
{
#region UsingThreshold
// using static NCDK.RingSearches.AllRingsFinder.Threshold;
AllRingsFinder arf = AllRingsFinder.UsingThreshold(Threshold.PubChem99);
#endregion
}
}
/// <summary>
/// Set the active center for this molecule.
/// The active center will be those which correspond to a ring
/// with pi electrons with resonance.
/// </summary>
/// FIXME REACT: It could be possible that a ring is a super ring of others small rings
/// <param name="reactant">The molecule to set the activity</param>
private static void SetActiveCenters(IAtomContainer reactant)
{
var arf = new AllRingsFinder();
var ringSet = arf.FindAllRings(reactant);
for (int ir = 0; ir < ringSet.Count; ir++)
{
var ring = ringSet[ir];
//only rings with even number of atoms
int nrAtoms = ring.Atoms.Count;
if (nrAtoms % 2 == 0)
{
int nrSingleBonds = 0;
foreach (var bond in ring.Bonds)
{
if (bond.Order == BondOrder.Single)
{
nrSingleBonds++;
}
}
//if exactly half (nrAtoms/2==nrSingleBonds)
if (nrSingleBonds != 0 && nrAtoms / 2 == nrSingleBonds)
{
foreach (var bond in ring.Bonds)
{
bond.IsReactiveCenter = true;
}
}
}
}
}
/// <summary>
/// Fixes Aromaticity of the molecule
/// i.e. need to find rings and aromaticity again since added H's
/// <param name="mol"></param>
/// </summary>
public static void Configure(IAtomContainer mol)
{
// need to find rings and aromaticity again since added H's
IRingSet ringSet = null;
try
{
var arf = new AllRingsFinder();
ringSet = arf.FindAllRings(mol);
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
try
{
// figure out which atoms are in aromatic rings:
var cdk = CDK.HydrogenAdder;
ExtAtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
cdk.AddImplicitHydrogens(mol);
Aromaticity.CDKLegacy.Apply(mol);
// figure out which rings are aromatic:
RingSetManipulator.MarkAromaticRings(ringSet);
// figure out which simple (non cycles) rings are aromatic:
// only atoms in 6 membered rings are aromatic
// determine largest ring that each atom is a part of
foreach (var atom in mol.Atoms)
{
atom.IsAromatic = false;
foreach (var ring in ringSet)
{
if (!ring.IsAromatic)
{
continue;
}
bool haveatom = ring.Contains(atom);
//Debug.WriteLine("haveatom="+haveatom);
if (haveatom && ring.Atoms.Count == 6)
{
atom.IsAromatic = true;
}
}
}
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
}
public void TestGetLargestRingSetListIRingSet()
{
var list = new List <IRingSet> {
ringset
};
var mol = TestMoleculeFactory.MakeBiphenyl();
var arf = new AllRingsFinder();
var ringSet = arf.FindAllRings(mol);
list.Add(ringSet);
Assert.AreEqual(2, RingSetManipulator.GetLargestRingSet(list).Count);
}
private static IRingSet GetRings(IAtomContainer mol)
{
try
{
var arf = new AllRingsFinder();
var rs = arf.FindAllRings(mol);
return(rs);
}
catch (Exception e)
{
Console.Out.WriteLine($"Could not find all rings: {e.Message}");
}
return(null);
}
public void TestGetBondCount()
{
IAtomContainer mol = TestMoleculeFactory.MakeAdenine();
AllRingsFinder arf = new AllRingsFinder();
IRingSet ringSet = arf.FindAllRings(mol);
Assert.AreEqual(3, ringSet.Count);
Assert.AreEqual(20, RingSetManipulator.GetBondCount(ringSet));
mol = TestMoleculeFactory.MakeBiphenyl();
ringSet = arf.FindAllRings(mol);
Assert.AreEqual(2, ringSet.Count);
Assert.AreEqual(12, RingSetManipulator.GetBondCount(ringSet));
}
IRingSet GetRings()
{
IRingSet rs = null;
try
{
AllRingsFinder arf = new AllRingsFinder();
rs = arf.FindAllRings(mol);
}
catch (Exception e)
{
Console.Out.WriteLine("Could not find all rings: " + e.Message);
}
return(rs);
}
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 void MarkAromatic()
{
IAtomContainer mol = TestMoleculeFactory.MakeBiphenyl();
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
Aromaticity.CDKLegacy.Apply(mol);
AllRingsFinder arf = new AllRingsFinder();
IRingSet ringSet = arf.FindAllRings(mol);
Assert.AreEqual(2, ringSet.Count);
RingSetManipulator.MarkAromaticRings(ringSet);
for (int i = 0; i < ringSet.Count; i++)
{
IRing ring = (IRing)ringSet[i];
Assert.IsTrue(ring.IsAromatic);
}
}
/// <summary>
/// Generates a fingerprint of the default size for the given AtomContainer.
/// </summary>
/// <param name="container">The AtomContainer for which a Fingerprint is generated</param>
/// <param name="ringFinder">An instance of <see cref="AllRingsFinder"/></param>
/// <exception cref="CDKException">if there is a timeout in ring or aromaticity perception</exception>
/// <returns>A <see cref="BitArray"/> representing the fingerprint</returns>
public IBitFingerprint GetBitFingerprint(IAtomContainer container, AllRingsFinder ringFinder)
{
Debug.WriteLine("Entering Fingerprinter");
Debug.WriteLine("Starting Aromaticity Detection");
var before = DateTime.Now.Ticks;
if (!HasPseudoAtom(container.Atoms))
{
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(container);
Aromaticity.CDKLegacy.Apply(container);
}
var after = DateTime.Now.Ticks;
Debug.WriteLine($"time for aromaticity calculation: {after - before} ticks");
Debug.WriteLine("Finished Aromaticity Detection");
BitArray bitSet = new BitArray(size);
EncodePaths(container, SearchDepth, bitSet, size);
return(new BitSetFingerprint(bitSet));
}
/// <summary> Retrieves the set of all rings and performs an aromaticity detection based
/// on Hueckels 4n + 2 rule. An AllRingsFinder with customized timeout may be
/// assigned to this method.
/// </summary>
/// <param name="removeAromatictyFlags"> When true, we leaves ChemObjects that
/// are already marked as aromatic as they are
/// </param>
/// <param name="atomContainer"> AtomContainer to be searched for
/// </param>
/// <param name="arf"> AllRingsFinder to be employed for the
/// ringsearch. Use this to customize the
/// AllRingsFinder timeout feature
/// rings
/// </param>
/// <returns> True, if molecule has aromatic features
/// </returns>
/// <exception cref="CDKException"> Thrown in case of errors or an
/// AllRingsFinder timeout
/// </exception>
public static bool detectAromaticity(IAtomContainer atomContainer, bool removeAromatictyFlags, AllRingsFinder arf)
{
//logger.debug("Entered Aromaticity Detection");
//logger.debug("Starting AllRingsFinder");
long before = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
if (arf == null)
{
arf = new AllRingsFinder();
arf.setTimeout(timeout);
}
ringSet = arf.findAllRings(atomContainer);
long after = (System.DateTime.Now.Ticks - 621355968000000000) / 10000;
//logger.debug("time for finding all rings: " + (after - before) + " milliseconds");
//logger.debug("Finished AllRingsFinder");
if (ringSet.AtomContainerCount > 0)
{
return(detectAromaticity(atomContainer, ringSet, removeAromatictyFlags));
}
return(false);
}
public static void FixAromaticityForXLogP(IAtomContainer m)
{
// need to find rings and aromaticity again since added H's
IRingSet rs = null;
try
{
AllRingsFinder arf = new AllRingsFinder();
rs = arf.FindAllRings(m);
// SSSRFinder s = new SSSRFinder(m);
// srs = s.FindEssentialRings();
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
try
{
// figure out which atoms are in aromatic rings:
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(m);
Aromaticity.CDKLegacy.Apply(m);
// figure out which rings are aromatic:
RingSetManipulator.MarkAromaticRings(rs);
// figure out which simple (non cycles) rings are aromatic:
// HueckelAromaticityDetector.DetectAromaticity(m, srs);
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
// only atoms in 6 membered rings are aromatic
// determine largest ring that each atom is a part of
for (int i = 0; i <= m.Atoms.Count - 1; i++)
{
m.Atoms[i].IsAromatic = false;
for (int j = 0; j <= rs.Count - 1; j++)
{
//Debug.WriteLine(i+"\t"+j);
IRing r = (IRing)rs[j];
if (!r.IsAromatic)
{
goto continue_jloop;
}
bool haveatom = r.Contains(m.Atoms[i]);
//Debug.WriteLine("haveatom="+haveatom);
if (haveatom && r.Atoms.Count == 6)
{
m.Atoms[i].IsAromatic = true;
}
continue_jloop:
;
}
}
}
internal IReactionSet Initiate(IChemObjectSet <IAtomContainer> reactants, IChemObjectSet <IAtomContainer> agents, int length, bool checkPrev, AtomCheck atomCheck)
{
CheckInitiateParams(reactants, agents);
IReactionSet setOfReactions = reactants.Builder.NewReactionSet();
IAtomContainer reactant = reactants[0];
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactant);
Aromaticity.CDKLegacy.Apply(reactant);
AllRingsFinder arf = new AllRingsFinder();
IRingSet ringSet = arf.FindAllRings(reactant);
for (int ir = 0; ir < ringSet.Count; ir++)
{
IRing ring = (IRing)ringSet[ir];
for (int jr = 0; jr < ring.Atoms.Count; jr++)
{
IAtom aring = ring.Atoms[jr];
aring.IsInRing = true;
}
}
// if the parameter hasActiveCenter is not fixed yet, set the active centers
IParameterReaction ipr = base.GetParameterClass(typeof(SetReactionCenter));
if (ipr != null && !ipr.IsSetParameter)
{
SetActiveCenters(reactant, length, checkPrev, atomCheck);
}
HOSECodeGenerator hcg = new HOSECodeGenerator();
foreach (var atomi in reactant.Atoms)
{
if (atomi.IsReactiveCenter && reactant.GetConnectedSingleElectrons(atomi).Count() == 1)
{
IEnumerable <IAtom> atom1s = null;
if (checkPrev)
{
hcg.GetSpheres(reactant, atomi, length - 1, true);
atom1s = hcg.GetNodesInSphere(length - 1);
}
hcg.GetSpheres(reactant, atomi, length, true);
foreach (var atoml in hcg.GetNodesInSphere(length))
{
if (atoml != null &&
atoml.IsReactiveCenter &&
!atoml.IsInRing &&
(atoml.FormalCharge ?? 0) == 0 &&
!atoml.AtomicNumber.Equals(AtomicNumbers.H) &&
reactant.GetMaximumBondOrder(atoml) == BondOrder.Single)
{
foreach (var atomR in reactant.GetConnectedAtoms(atoml))
{
if (atom1s != null && atom1s.Contains(atomR))
{
continue;
}
if (reactant.GetBond(atomR, atoml).IsReactiveCenter &&
atomR.IsReactiveCenter &&
atomCheck(atomR))
{
var atomList = new List <IAtom>
{
atomR,
atomi,
atoml
};
var bondList = new List <IBond>
{
reactant.GetBond(atomR, atoml)
};
var moleculeSet = reactant.Builder.NewChemObjectSet <IAtomContainer>();
moleculeSet.Add(reactant);
var reaction = Mechanism.Initiate(moleculeSet, atomList, bondList);
if (reaction == null)
{
continue;
}
else
{
setOfReactions.Add(reaction);
}
}
}
}
}
}
}
return(setOfReactions);
}
/// <summary>
/// Initiate process.
/// It is needed to call the addExplicitHydrogensToSatisfyValency
/// from the class tools.HydrogenAdder.
/// </summary>
/// <exception cref="CDKException"> Description of the Exception</exception>
/// <param name="reactants">reactants of the reaction.</param>
/// <param name="agents">agents of the reaction (Must be in this case null).</param>
public IReactionSet Initiate(IChemObjectSet <IAtomContainer> reactants, IChemObjectSet <IAtomContainer> agents)
{
CheckInitiateParams(reactants, agents);
var setOfReactions = reactants.Builder.NewReactionSet();
var reactant = reactants[0];
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactant);
// if the parameter hasActiveCenter is not fixed yet, set the active centers
var ipr = base.GetParameterClass(typeof(SetReactionCenter));
if (ipr != null && !ipr.IsSetParameter)
{
SetActiveCenters(reactant);
}
var arf = new AllRingsFinder();
var ringSet = arf.FindAllRings((IAtomContainer)reactant);
for (int ir = 0; ir < ringSet.Count; ir++)
{
var ring = ringSet[ir];
//only rings with even number of atoms
int nrAtoms = ring.Atoms.Count;
if (nrAtoms % 2 == 0)
{
int nrSingleBonds = 0;
foreach (var bond in ring.Bonds)
{
if (bond.Order == BondOrder.Single)
{
nrSingleBonds++;
}
}
//if exactly half (nrAtoms/2==nrSingleBonds)
if (nrSingleBonds != 0 && nrAtoms / 2 == nrSingleBonds)
{
bool ringCompletActive = false;
foreach (var bond in ring.Bonds)
{
if (bond.IsReactiveCenter)
{
ringCompletActive = true;
}
else
{
ringCompletActive = false;
break;
}
}
if (!ringCompletActive)
{
continue;
}
IReaction reaction = reactants.Builder.NewReaction();
reaction.Reactants.Add(reactant);
IAtomContainer reactantCloned;
reactantCloned = (IAtomContainer)reactant.Clone();
foreach (var bondi in ring.Bonds)
{
int bondiP = reactant.Bonds.IndexOf(bondi);
if (bondi.Order == BondOrder.Single)
{
BondManipulator.IncreaseBondOrder(reactantCloned.Bonds[bondiP]);
}
else
{
BondManipulator.DecreaseBondOrder(reactantCloned.Bonds[bondiP]);
}
}
reaction.Products.Add(reactantCloned);
setOfReactions.Add(reaction);
}
}
}
return(setOfReactions);
}
/// <summary>
/// Constructor for the DeduceBondSystemTool object.
/// </summary>
public DeduceBondSystemTool()
{
allRingsFinder = new AllRingsFinder();
}
/// <summary>
/// Constructor for the DeduceBondSystemTool object accepting a custom <see cref="AllRingsFinder"/>.
/// </summary>
/// <param name="ringFinder">a custom <see cref="AllRingsFinder"/>.</param>
public DeduceBondSystemTool(AllRingsFinder ringFinder)
{
allRingsFinder = ringFinder;
}
/// <summary>
/// This function finds rings and uses aromaticity detection code to
/// aromatize the molecule.
/// </summary>
/// <param name="mol">input molecule</param>
public static void AromatizeMolecule(IAtomContainer mol)
{
// need to find rings and aromaticity again since added H's
IRingSet ringSet = null;
try
{
AllRingsFinder arf = new AllRingsFinder();
ringSet = arf.FindAllRings(mol);
// SSSRFinder s = new SSSRFinder(atomContainer);
// srs = s.FindEssentialRings();
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
try
{
// figure out which atoms are in aromatic rings:
// PrintAtoms(atomContainer);
ExtAtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(mol);
// PrintAtoms(atomContainer);
Aromaticity.CDKLegacy.Apply(mol);
// PrintAtoms(atomContainer);
// figure out which rings are aromatic:
RingSetManipulator.MarkAromaticRings(ringSet);
// PrintAtoms(atomContainer);
// figure out which simple (non cycles) rings are aromatic:
// HueckelAromaticityDetector.DetectAromaticity(atomContainer, srs);
}
catch (Exception e)
{
Console.Out.WriteLine(e.StackTrace);
}
// only atoms in 6 membered rings are aromatic
// determine largest ring that each atom is atom part of
for (int i = 0; i <= mol.Atoms.Count - 1; i++)
{
mol.Atoms[i].IsAromatic = false;
foreach (var ring in ringSet)
{
if (!ring.IsAromatic)
{
continue;
}
bool haveatom = ring.Contains(mol.Atoms[i]);
//Debug.WriteLine("haveatom="+haveatom);
if (haveatom && ring.Atoms.Count == 6)
{
mol.Atoms[i].IsAromatic = true;
}
}
}
}
