/// <summary> Checks the pathes if a ring has been found
///
/// </summary>
/// <param name="pathes"> The pathes to check for rings
/// </param>
/// <param name="ringSet"> The ringset to add the detected rings to
/// </param>
/// <param name="ac"> The AtomContainer with the original structure
/// </param>
private void detectRings(System.Collections.ArrayList pathes, IRingSet ringSet, IAtomContainer ac)
{
Path path = null;
IRing ring = null;
IBond bond = null;
for (int f = 0; f < pathes.Count; f++)
{
path = (Path)pathes[f];
if (path.Count > 3 && path[path.Count - 1] == path[0])
{
if (debug)
{
System.Console.Out.WriteLine("Removing path " + path.toString(originalAc) + " which is a ring.");
}
path.RemoveAt(0);
ring = ac.Builder.newRing();
for (int g = 0; g < path.Count; g++)
{
ring.addAtom((IAtom)path[g]);
}
IBond[] bonds = ac.Bonds;
for (int g = 0; g < bonds.Length; g++)
{
bond = bonds[g];
if (ring.contains(bond.getAtomAt(0)) && ring.contains(bond.getAtomAt(1)))
{
ring.addBond(bond);
}
}
ringSet.addAtomContainer(ring);
}
}
}
/// <summary> Checks if <code>atom1</code> and <code>atom2</code> share membership in the same ring or ring system.
/// Membership in the same ring is checked if the RingSet contains the SSSR of a molecule; membership in
/// the same ring or same ring system is checked if the RingSet contains all rings of a molecule.<BR><BR>
///
/// <p><B>Important:</B> This method only returns meaningful results if <code>atom1</code> and
/// <code>atom2</code> are members of the same molecule for which the RingSet was calculated!
///
/// </summary>
/// <param name="atom1"> The first atom
/// </param>
/// <param name="atom2"> The second atom
/// </param>
/// <returns> boolean true if <code>atom1</code> and <code>atom2</code> share membership of at least one ring or ring system, false otherwise
/// </returns>
public static bool isSameRing(IRingSet ringSet, IAtom atom1, IAtom atom2)
{
IAtomContainer[] rings = ringSet.AtomContainers;
for (int i = 0; i < rings.Length; i++)
{
IRing ring = (IRing)rings[i];
if (ring.contains(atom1))
{
if (ring.contains(atom2))
{
return(true);
}
}
}
return(false);
}
/// <summary> Tests the <code>ring</code> in the <code>molecule</code> for aromaticity. Uses the
/// Hückle rule (4n + 2) pie electrons. sp<sup>2</sup> hybridized C contibute 1 electron non
/// sp<sup>2</sup> hybridized heteroatoms contribute 2 electrons (N and O should never be sp in
/// or anything else in a ring and d electron elements get to complicated)
/// sp<sup>2</sup> hybridized heteroatoms contribute 1 electron hybridization is worked out by
/// counting the number of bonds with order 2. Therefore sp<sup>2</sup> hybridization is assumed
/// if there is one bond of order 2. Otherwise sp<sup>3</sup> hybridization is assumed.
///
/// </summary>
/// <param name="ring"> the ring to test
/// </param>
/// <param name="atomContainer"> the AtomContainer the ring is in
/// </param>
/// <returns> true if the ring is aromatic false otherwise.
/// </returns>
protected internal static bool isAromatic(IRing ring, IAtomContainer atomContainer)
{
IAtom[] ringAtoms = ring.Atoms;
int eCount = 0;
IBond[] conectedBonds;
int numDoubleBond = 0;
bool allConnectedBondsSingle;
for (int i = 0; i < ringAtoms.Length; i++)
{
IAtom atom = ringAtoms[i];
numDoubleBond = 0;
allConnectedBondsSingle = true;
conectedBonds = atomContainer.getConnectedBonds(atom);
for (int j = 0; j < conectedBonds.Length; j++)
{
IBond bond = conectedBonds[j];
if (bond.Order == 2 && ring.contains(bond))
{
numDoubleBond++;
}
// Count the Electron if bond order = 1.5
else if (bond.Order == 1.5 && ring.contains(bond))
{
numDoubleBond = 1;
}
if (bond.Order != 1)
{
allConnectedBondsSingle = false;
}
}
if (numDoubleBond == 1)
{
//C or heteroatoms both contibute 1 electron in sp2 hybridized form
eCount++;
}
else if (!atom.Symbol.Equals("C"))
{
//Heteroatom probably in sp3 hybrid therefore 2 electrons contributed.
eCount = eCount + 2;
}
else if (atom.getFlag(CDKConstants.ISAROMATIC))
{
eCount++;
}
else if (allConnectedBondsSingle && atom.Symbol.Equals("C") && atom.getFormalCharge() == 1.0)
{
// This is for tropylium and kinds.
// Dependence on hybridisation would be better:
// empty p-orbital is needed
continue;
}
else
{
return(false);
}
}
if (eCount - 2 != 0 && (eCount - 2) % 4 == 0)
{
return(true);
}
return(false);
}
/// <summary> Tests the <code>ring</code> in the <code>molecule</code> for aromaticity. Uses the
/// Hückle rule (4n + 2) pie electrons. sp<sup>2</sup> hybridized C contibute 1 electron non
/// sp<sup>2</sup> hybridized heteroatoms contribute 2 electrons (N and O should never be sp in
/// or anything else in a ring and d electron elements get to complicated)
/// sp<sup>2</sup> hybridized heteroatoms contribute 1 electron hybridization is worked out by
/// counting the number of bonds with order 2. Therefore sp<sup>2</sup> hybridization is assumed
/// if there is one bond of order 2. Otherwise sp<sup>3</sup> hybridization is assumed.
///
/// </summary>
/// <param name="ring"> the ring to test
/// </param>
/// <param name="atomContainer"> the AtomContainer the ring is in
/// </param>
/// <returns> true if the ring is aromatic false otherwise.
/// </returns>
protected internal static bool isAromatic(IRing ring, IAtomContainer atomContainer)
{
IAtom[] ringAtoms = ring.Atoms;
int eCount = 0;
IBond[] conectedBonds;
int numDoubleBond = 0;
bool allConnectedBondsSingle;
for (int i = 0; i < ringAtoms.Length; i++)
{
IAtom atom = ringAtoms[i];
numDoubleBond = 0;
allConnectedBondsSingle = true;
conectedBonds = atomContainer.getConnectedBonds(atom);
for (int j = 0; j < conectedBonds.Length; j++)
{
IBond bond = conectedBonds[j];
if (bond.Order == 2 && ring.contains(bond))
{
numDoubleBond++;
}
// Count the Electron if bond order = 1.5
else if (bond.Order == 1.5 && ring.contains(bond))
{
numDoubleBond = 1;
}
if (bond.Order != 1)
{
allConnectedBondsSingle = false;
}
}
if (numDoubleBond == 1)
{
//C or heteroatoms both contibute 1 electron in sp2 hybridized form
eCount++;
}
else if (!atom.Symbol.Equals("C"))
{
//Heteroatom probably in sp3 hybrid therefore 2 electrons contributed.
eCount = eCount + 2;
}
else if (atom.getFlag(CDKConstants.ISAROMATIC))
{
eCount++;
}
else if (allConnectedBondsSingle && atom.Symbol.Equals("C") && atom.getFormalCharge() == 1.0)
{
// This is for tropylium and kinds.
// Dependence on hybridisation would be better:
// empty p-orbital is needed
continue;
}
else
{
return false;
}
}
if (eCount - 2 != 0 && (eCount - 2) % 4 == 0)
{
return true;
}
return false;
}