public void TestGetAllAtomContainers_IRingSet()
{
IRingSet rs = builder.NewRingSet();
rs.Add(builder.NewRing());
rs.Add(builder.NewRing());
var list = RingSetManipulator.GetAllAtomContainers(rs);
Assert.AreEqual(2, list.Count());
}
public virtual void TestGetRings_IBond()
{
IRingSet ringset = (IRingSet)NewChemObject();
IAtom ring1Atom1 = ringset.Builder.NewAtom("C"); // rather artificial molecule
IAtom ring1Atom2 = ringset.Builder.NewAtom("C");
IAtom sharedAtom1 = ringset.Builder.NewAtom("C");
IAtom sharedAtom2 = ringset.Builder.NewAtom("C");
IAtom ring2Atom1 = ringset.Builder.NewAtom("C");
IAtom ring2Atom2 = ringset.Builder.NewAtom("C");
IBond ring1Bond1 = ringset.Builder.NewBond(ring1Atom1, ring1Atom2);
IBond ring1Bond2 = ringset.Builder.NewBond(sharedAtom1, ring1Atom1);
IBond ring1Bond3 = ringset.Builder.NewBond(sharedAtom2, ring1Atom2);
IBond sharedBond = ringset.Builder.NewBond(sharedAtom1, sharedAtom2);
IBond ring2Bond1 = ringset.Builder.NewBond(ring2Atom1, ring2Atom2);
IBond ring2Bond2 = ringset.Builder.NewBond(sharedAtom1, ring2Atom1);
IBond ring2Bond3 = ringset.Builder.NewBond(sharedAtom2, ring2Atom2);
IRing ring1 = ringset.Builder.NewRing();
ring1.Atoms.Add(ring1Atom1);
ring1.Atoms.Add(ring1Atom2);
ring1.Atoms.Add(sharedAtom1);
ring1.Atoms.Add(sharedAtom2);
ring1.Bonds.Add(ring1Bond1);
ring1.Bonds.Add(ring1Bond2);
ring1.Bonds.Add(ring1Bond3);
ring1.Bonds.Add(sharedBond);
IRing ring2 = ringset.Builder.NewRing();
ring2.Atoms.Add(ring2Atom1);
ring2.Atoms.Add(ring2Atom2);
ring2.Atoms.Add(sharedAtom1);
ring2.Atoms.Add(sharedAtom2);
ring2.Bonds.Add(ring2Bond1);
ring2.Bonds.Add(ring2Bond2);
ring2.Bonds.Add(ring2Bond3);
ring2.Bonds.Add(sharedBond);
ringset.Add(ring1);
ringset.Add(ring2);
Assert.AreEqual(1, ringset.GetRings(ring1Bond1).Count());
Assert.AreEqual(1, ringset.GetRings(ring1Bond2).Count());
Assert.AreEqual(1, ringset.GetRings(ring1Bond3).Count());
Assert.AreEqual(2, ringset.GetRings(sharedBond).Count());
Assert.AreEqual(1, ringset.GetRings(ring2Bond1).Count());
Assert.AreEqual(1, ringset.GetRings(ring2Bond2).Count());
Assert.AreEqual(1, ringset.GetRings(ring2Bond3).Count());
}
public virtual void TestContains_IAtom()
{
IRingSet ringset = (IRingSet)NewChemObject();
IAtom ring1Atom1 = ringset.Builder.NewAtom("C"); // rather artificial molecule
IAtom ring1Atom2 = ringset.Builder.NewAtom("C");
IAtom sharedAtom1 = ringset.Builder.NewAtom("C");
IAtom sharedAtom2 = ringset.Builder.NewAtom("C");
IAtom ring2Atom1 = ringset.Builder.NewAtom("C");
IAtom ring2Atom2 = ringset.Builder.NewAtom("C");
IBond ring1Bond1 = ringset.Builder.NewBond(ring1Atom1, ring1Atom2);
IBond ring1Bond2 = ringset.Builder.NewBond(sharedAtom1, ring1Atom1);
IBond ring1Bond3 = ringset.Builder.NewBond(sharedAtom2, ring1Atom2);
IBond sharedBond = ringset.Builder.NewBond(sharedAtom1, sharedAtom2);
IBond ring2Bond1 = ringset.Builder.NewBond(ring2Atom1, ring2Atom2);
IBond ring2Bond2 = ringset.Builder.NewBond(sharedAtom1, ring2Atom1);
IBond ring2Bond3 = ringset.Builder.NewBond(sharedAtom2, ring2Atom2);
IRing ring1 = ringset.Builder.NewRing();
ring1.Atoms.Add(ring1Atom1);
ring1.Atoms.Add(ring1Atom2);
ring1.Atoms.Add(sharedAtom1);
ring1.Atoms.Add(sharedAtom2);
ring1.Bonds.Add(ring1Bond1);
ring1.Bonds.Add(ring1Bond2);
ring1.Bonds.Add(ring1Bond3);
ring1.Bonds.Add(sharedBond);
IRing ring2 = ringset.Builder.NewRing();
ring2.Atoms.Add(ring2Atom1);
ring2.Atoms.Add(ring2Atom2);
ring2.Atoms.Add(sharedAtom1);
ring2.Atoms.Add(sharedAtom2);
ring2.Bonds.Add(ring2Bond1);
ring2.Bonds.Add(ring2Bond2);
ring2.Bonds.Add(ring2Bond3);
ring2.Bonds.Add(sharedBond);
ringset.Add(ring1);
ringset.Add(ring2);
Assert.IsTrue(ringset.Contains(ring1Atom1));
Assert.IsTrue(ringset.Contains(ring1Atom2));
Assert.IsTrue(ringset.Contains(sharedAtom1));
Assert.IsTrue(ringset.Contains(sharedAtom2));
Assert.IsTrue(ringset.Contains(ring2Atom1));
Assert.IsTrue(ringset.Contains(ring2Atom2));
}
public virtual void TestAdd_IRingSet()
{
IRingSet rs = (IRingSet)NewChemObject();
IRing r1 = rs.Builder.NewRing(5, "C");
IRing r2 = rs.Builder.NewRing(3, "C");
rs.Add(r1);
IRingSet rs2 = (IRingSet)NewChemObject();
rs2.Add(r2);
rs2.Add(rs);
Assert.AreEqual(1, rs.Count);
Assert.AreEqual(2, rs2.Count);
}
public void TestGetAtomCount_IRingSet()
{
IRingSet rs = builder.NewRingSet();
IRing ac1 = builder.NewRing();
ac1.Atoms.Add(builder.NewAtom("O"));
rs.Add(ac1);
IRing ac2 = builder.NewRing();
ac2.Atoms.Add(builder.NewAtom("C"));
ac2.Atoms.Add(builder.NewAtom("C"));
ac2.AddBond(ac2.Atoms[0], ac2.Atoms[1], BondOrder.Double);
rs.Add(ac2);
Assert.AreEqual(3, RingSetManipulator.GetAtomCount(rs));
Assert.AreEqual(1, RingSetManipulator.GetBondCount(rs));
}
/// <summary>
/// Returns Ring set based on Hanser Ring Finding method
/// <param name="molecule"></param>
/// </summary>
/// <returns>report collected the rings</returns>
/// <seealso cref="IRingFinder.GetRingSet(IAtomContainer)"/>
public IRingSet GetRingSet(IAtomContainer molecule)
{
var cycles = FindRings(molecule);
IRingSet ringSet = molecule.Builder.NewRingSet();
foreach (var ringAtoms in cycles)
{
IRing ring = molecule.Builder.NewRing();
foreach (var atom in ringAtoms)
{
atom.IsInRing = true;
ring.Atoms.Add(atom);
foreach (var atomNext in ringAtoms)
{
if (!atom.Equals(atomNext))
{
IBond bond = molecule.GetBond(atom, atomNext);
if (bond != null)
{
bond.IsInRing = true;
ring.Bonds.Add(bond);
}
}
}
}
ringSet.Add(ring);
}
return(ringSet);
}
/// <summary>
/// All basic rings and the all pairs of basic rings share at least one edge combined.
/// </summary>
/// <returns>subset of all rings</returns>
/// <exception cref="NoSuchAtomException">atom was not found in the molecule</exception>
/// <seealso cref="GetBasicRings"/>
public IRingSet GetAllRings()
{
IRingSet ringset = GetBasicRings();
IRing newring;
int nBasicRings = ringset.Count;
for (int i = 0; i < nBasicRings; i++)
{
GetBondsInRing(molecule, (IRing)ringset[i], cb[i]);
}
for (int i = 0; i < nBasicRings; i++)
{
for (int j = i + 1; j < nBasicRings; j++)
{
//Debug.WriteLine("combining rings "+(i+1)+","+(j+1));
newring = CombineRings(ringset, i, j);
//newring = CombineRings((Ring)ringset[i],(Ring)ringset[j]);
if (newring != null)
{
ringset.Add(newring);
}
}
}
return(ringset);
}
/// <summary>
/// Perform a walk in the given RingSet, starting at a given Ring and
/// recursively searching for other Rings connected to this ring. By doing
/// this it finds all rings in the RingSet connected to the start ring,
/// putting them in newRs, and removing them from rs.
/// </summary>
/// <param name="rs">The RingSet to be searched</param>
/// <param name="ring">The ring to start with</param>
/// <param name="newRs">The RingSet containing all Rings connected to ring</param>
/// <returns>newRs The RingSet containing all Rings connected to ring</returns>
private static IRingSet WalkRingSystem(IRingSet rs, IRing ring, IRingSet newRs)
{
IRing tempRing;
var tempRings = rs.GetConnectedRings(ring);
rs.Remove(ring);
foreach (var container in tempRings)
{
tempRing = (IRing)container;
if (!newRs.Contains(tempRing))
{
newRs.Add(tempRing);
newRs.Add(WalkRingSystem(rs, tempRing, newRs));
}
}
return(newRs);
}
public void TestRingAlreadyInSet_IRing_IRingSet()
{
IRing r1 = builder.NewRing(5, "C");
IRing r2 = builder.NewRing(3, "C");
IRingSet rs = builder.NewRingSet();
Assert.IsFalse(RingSetManipulator.RingAlreadyInSet(r1, rs));
Assert.IsFalse(RingSetManipulator.RingAlreadyInSet(r2, rs));
rs.Add(r1);
Assert.IsTrue(RingSetManipulator.RingAlreadyInSet(r1, rs));
Assert.IsFalse(RingSetManipulator.RingAlreadyInSet(r2, rs));
rs.Add(r2);
Assert.IsTrue(RingSetManipulator.RingAlreadyInSet(r1, rs));
Assert.IsTrue(RingSetManipulator.RingAlreadyInSet(r2, rs));
}
public override void TestIsEmpty()
{
IRingSet ringSet = (IRingSet)NewChemObject();
Assert.IsTrue(ringSet.IsEmpty(), "new ringset should be empty");
ringSet.Add(ringSet.Builder.NewRing()); // NCDK does not suppor to add AtomContainer object to RingSet object
Assert.IsFalse(ringSet.IsEmpty(), "ringset with an atom container should not be empty");
ringSet.Clear();
Assert.IsTrue(ringSet.IsEmpty(), "ringset with removed atom containers should be empty");
}
public override void TestClone()
{
IRingSet ringset = (IRingSet)NewChemObject();
IRing ring = ringset.Builder.NewRing();
ringset.Add(ring);
IRingSet clone = (IRingSet)ringset.Clone();
Assert.IsNotNull(clone);
Assert.IsTrue(clone is IRingSet);
Assert.AreEqual(1, clone.Count);
Assert.AreNotSame(ring, clone[0]);
}
/// <summary>
/// The basic rings of the spanning tree. Using the pruned edges, return any path
/// which connects the end points of the pruned edge in the tree. These paths form
/// cycles.
/// </summary>
/// <returns>basic rings</returns>
/// <exception cref="NoSuchAtomException">atoms not found in the molecule</exception>
public IRingSet GetBasicRings()
{
IRingSet ringset = molecule.Builder.NewRingSet();
IAtomContainer spt = GetSpanningTree();
for (int i = 0; i < totalEdgeCount; i++)
{
if (!bondsInTree[i])
{
ringset.Add(GetRing(spt, molecule.Bonds[i]));
}
}
return(ringset);
}
public virtual void TestStateChanged_EventPropagation_RingSet()
{
ChemObjectListenerImpl listener = new ChemObjectListenerImpl();
IChemModel chemObject = (IChemModel)NewChemObject();
chemObject.Listeners.Add(listener);
IRingSet ringSet = chemObject.Builder.NewRingSet();
chemObject.RingSet = ringSet;
Assert.IsTrue(listener.Changed);
// reset the listener
listener.Reset();
Assert.IsFalse(listener.Changed);
// changing the set should trigger a change event in the IChemModel
ringSet.Add(chemObject.Builder.NewRing());
Assert.IsTrue(listener.Changed);
}
public void TestIsEmpty_RingSet()
{
var model = (IChemModel)NewChemObject();
IChemObjectBuilder builder = model.Builder;
IRing container = builder.NewRing(); // NCDK does not allow to add Ring to RingSet
IRingSet ringset = builder.NewRingSet();
Assert.IsTrue(model.IsEmpty());
model.RingSet = ringset;
Assert.IsTrue(model.IsEmpty());
ringset.Add(container);
Assert.IsFalse(model.IsEmpty());
model.RingSet = null;
Assert.IsTrue(model.IsEmpty());
}
public virtual void TestStateChanged_ButNotAfterRemoval_RingSet()
{
ChemObjectListenerImpl listener = new ChemObjectListenerImpl();
IChemModel chemObject = (IChemModel)NewChemObject();
chemObject.Listeners.Add(listener);
IRingSet ringSet = chemObject.Builder.NewRingSet();
chemObject.RingSet = ringSet;
Assert.IsTrue(listener.Changed);
// remove the set from the IChemModel
chemObject.RingSet = null;
// reset the listener
listener.Reset();
Assert.IsFalse(listener.Changed);
// changing the set must *not* trigger a change event in the IChemModel
ringSet.Add(chemObject.Builder.NewRing());
Assert.IsFalse(listener.Changed);
}
/// <summary>
/// Returns all the rings in the RingSet that share one or more atoms with a given ring.
/// </summary>
/// <param name="ring">A ring with which all return rings must share one or more atoms</param>
/// <returns>All the rings that share one or more atoms with a given ring.</returns>
public IEnumerable <IRing> GetConnectedRings(IRing ring)
{
IRingSet connectedRings = ring.Builder.NewRingSet();
foreach (var atom in ring.Atoms)
{
foreach (var tempRing in this)
{
if (tempRing != ring &&
!connectedRings.Contains(tempRing) &&
tempRing.Contains(atom))
{
connectedRings.Add(tempRing);
}
}
}
return(connectedRings);
}
/// <summary>
/// Determine the ring set for this atom container.
/// </summary>
/// <param name="atomContainer">the atom container to find rings in.</param>
/// <returns>the rings of the molecule</returns>
protected virtual IRingSet GetRingSet(IAtomContainer atomContainer)
{
IRingSet ringSet = atomContainer.Builder.NewRingSet();
try
{
var molecules = ConnectivityChecker.PartitionIntoMolecules(atomContainer);
foreach (var mol in molecules)
{
ringSet.Add(Cycles.FindSSSR(mol).ToRingSet());
}
return(ringSet);
}
catch (Exception exception)
{
Trace.TraceWarning("Could not partition molecule: " + exception.Message);
Debug.WriteLine(exception);
return(ringSet);
}
}
public virtual void TestGetConnectedRingsBug1772613()
{
// Build a bridged and fused norbomane like ring system
// C1CCC2C(C1)C4CC2C3CCCCC34
IRingSet ringSet = (IRingSet)NewChemObject();
IRing leftCyclohexane = ringSet.Builder.NewRing(6, "C");
IRing rightCyclopentane = ringSet.Builder.NewRing(5, "C");
IRing leftCyclopentane = ringSet.Builder.NewRing();
IBond leftCyclohexane0RightCyclopentane4 = ringSet.Builder.NewBond(leftCyclohexane.Atoms[0], rightCyclopentane.Atoms[4]);
IBond leftCyclohexane1RightCyclopentane2 = ringSet.Builder.NewBond(leftCyclohexane.Atoms[1], rightCyclopentane.Atoms[2]);
leftCyclopentane.Atoms.Add(leftCyclohexane.Atoms[0]);
leftCyclopentane.Atoms.Add(leftCyclohexane.Atoms[1]);
leftCyclopentane.Atoms.Add(rightCyclopentane.Atoms[2]);
leftCyclopentane.Atoms.Add(rightCyclopentane.Atoms[3]);
leftCyclopentane.Atoms.Add(rightCyclopentane.Atoms[4]);
leftCyclopentane.Bonds.Add(leftCyclohexane.GetBond(leftCyclohexane.Atoms[0], leftCyclohexane.Atoms[1]));
leftCyclopentane.Bonds.Add(leftCyclohexane1RightCyclopentane2);
leftCyclopentane.Bonds.Add(rightCyclopentane.GetBond(rightCyclopentane.Atoms[2], rightCyclopentane.Atoms[3]));
leftCyclopentane.Bonds.Add(rightCyclopentane.GetBond(rightCyclopentane.Atoms[3], rightCyclopentane.Atoms[4]));
leftCyclopentane.Bonds.Add(leftCyclohexane0RightCyclopentane4);
IRing rightCyclohexane = ringSet.Builder.NewRing();
IAtom rightCyclohexaneAtom0 = ringSet.Builder.NewAtom("C");
IAtom rightCyclohexaneAtom1 = ringSet.Builder.NewAtom("C");
IAtom rightCyclohexaneAtom2 = ringSet.Builder.NewAtom("C");
IAtom rightCyclohexaneAtom5 = ringSet.Builder.NewAtom("C");
IBond rightCyclohexaneAtom0Atom1 = ringSet.Builder.NewBond(rightCyclohexaneAtom0,
rightCyclohexaneAtom1);
IBond rightCyclohexaneAtom1Atom2 = ringSet.Builder.NewBond(rightCyclohexaneAtom1,
rightCyclohexaneAtom2);
IBond rightCyclohexane2rightCyclopentane1 = ringSet.Builder.NewBond(rightCyclohexaneAtom2, rightCyclopentane.Atoms[1]);
IBond rightCyclohexane5rightCyclopentane0 = ringSet.Builder.NewBond(rightCyclohexaneAtom5, rightCyclopentane.Atoms[0]);
IBond rightCyclohexaneAtom0Atom5 = ringSet.Builder.NewBond(rightCyclohexaneAtom0,
rightCyclohexaneAtom5);
rightCyclohexane.Atoms.Add(rightCyclohexaneAtom0);
rightCyclohexane.Atoms.Add(rightCyclohexaneAtom1);
rightCyclohexane.Atoms.Add(rightCyclohexaneAtom2);
rightCyclohexane.Atoms.Add(rightCyclopentane.Atoms[1]);
rightCyclohexane.Atoms.Add(rightCyclopentane.Atoms[0]);
rightCyclohexane.Atoms.Add(rightCyclohexaneAtom5);
rightCyclohexane.Bonds.Add(rightCyclohexaneAtom0Atom1);
rightCyclohexane.Bonds.Add(rightCyclohexaneAtom1Atom2);
rightCyclohexane.Bonds.Add(rightCyclohexane2rightCyclopentane1);
rightCyclohexane.Bonds.Add(rightCyclopentane.GetBond(rightCyclopentane.Atoms[0], rightCyclopentane.Atoms[1]));
rightCyclohexane.Bonds.Add(rightCyclohexane5rightCyclopentane0);
rightCyclohexane.Bonds.Add(rightCyclohexaneAtom0Atom5);
ringSet.Add(leftCyclohexane);
ringSet.Add(leftCyclopentane);
ringSet.Add(rightCyclopentane);
ringSet.Add(rightCyclohexane);
// Get connected rings
var connectedRings = ringSet.GetConnectedRings(leftCyclohexane);
// Iterate over the connectedRings and fail if any duplicate is found
IList <IRing> foundRings = new List <IRing>();
foreach (var container in connectedRings)
{
IRing connectedRing = (IRing)container;
if (foundRings.Contains(connectedRing))
{
Assert.Fail("The list of connected rings contains duplicates.");
}
foundRings.Add(connectedRing);
}
}
public void SetUp()
{
builder = ChemObjectBuilder.Instance;
ringset = builder.NewRingSet();
ring1Atom1 = builder.NewAtom("C"); // rather artificial molecule
IAtom ring1Atom2 = builder.NewAtom("C");
ring1Atom3 = builder.NewAtom("C");
IAtom ring2Atom1 = builder.NewAtom("C");
IAtom ring2Atom2 = builder.NewAtom("C");
ring2Atom3 = builder.NewAtom("C");
IAtom ring3Atom3 = builder.NewAtom("C");
IAtom ring3Atom4 = builder.NewAtom("C");
IAtom ring4Atom1 = builder.NewAtom("C");
IAtom ring4Atom2 = builder.NewAtom("C");
IBond ring1Bond1 = builder.NewBond(ring1Atom1, ring1Atom2);
IBond ring1Bond2 = builder.NewBond(ring1Atom2, ring1Atom3);
IBond ring1Bond3 = builder.NewBond(ring1Atom3, ring1Atom1);
bondRing2Ring3 = builder.NewBond(ring2Atom1, ring2Atom2);
IBond ring2Bond2 = builder.NewBond(ring2Atom2, ring2Atom3);
IBond ring2Bond3 = builder.NewBond(ring2Atom3, ring2Atom1, BondOrder.Double);
IBond ring3Bond2 = builder.NewBond(ring2Atom2, ring3Atom3);
IBond bondRing3Ring4 = builder.NewBond(ring3Atom3, ring3Atom4);
IBond ring3Bond4 = builder.NewBond(ring3Atom4, ring2Atom1);
IBond ring4Bond1 = builder.NewBond(ring4Atom1, ring4Atom2);
IBond ring4Bond2 = builder.NewBond(ring4Atom2, ring3Atom3);
IBond ring4Bond3 = builder.NewBond(ring3Atom4, ring4Atom1);
IRing ring1 = builder.NewRing();
ring1.Atoms.Add(ring1Atom1);
ring1.Atoms.Add(ring1Atom2);
ring1.Atoms.Add(ring1Atom3);
ring1.Bonds.Add(ring1Bond1);
ring1.Bonds.Add(ring1Bond2);
ring1.Bonds.Add(ring1Bond3);
ring2 = builder.NewRing();
ring2.Atoms.Add(ring2Atom1);
ring2.Atoms.Add(ring2Atom2);
ring2.Atoms.Add(ring2Atom3);
ring2.Bonds.Add(bondRing2Ring3);
ring2.Bonds.Add(ring2Bond2);
ring2.Bonds.Add(ring2Bond3);
ring3 = builder.NewRing();
ring3.Atoms.Add(ring2Atom1);
ring3.Atoms.Add(ring2Atom2);
ring3.Atoms.Add(ring3Atom3);
ring3.Atoms.Add(ring3Atom4);
ring3.Bonds.Add(bondRing2Ring3);
ring3.Bonds.Add(ring3Bond2);
ring3.Bonds.Add(bondRing3Ring4);
ring3.Bonds.Add(ring3Bond4);
IRing ring4 = builder.NewRing();
ring4.Atoms.Add(ring4Atom1);
ring4.Atoms.Add(ring4Atom2);
ring4.Atoms.Add(ring3Atom3);
ring4.Atoms.Add(ring3Atom4);
ring4.Bonds.Add(bondRing3Ring4);
ring4.Bonds.Add(ring4Bond1);
ring4.Bonds.Add(ring4Bond2);
ring4.Bonds.Add(ring4Bond3);
ringset.Add(ring1);
ringset.Add(ring2);
ringset.Add(ring3);
ringset.Add(ring4);
}
