public void TestMetheneFragmentSignatures()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("H");
molecule.AddAtom("H");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(0, 2);
MoleculeSignature signature = new MoleculeSignature(molecule);
var symmetryClasses = signature.GetSymmetryClasses();
Assert.AreEqual(2, symmetryClasses.Count);
foreach (var symmetryClass in symmetryClasses)
{
if (symmetryClass.GetSignatureString().StartsWith("[H"))
{
Assert.AreEqual(2, symmetryClass.Count);
}
else
{
Assert.AreEqual(1, symmetryClass.Count);
}
}
}
public void MinimalTest()
{
Molecule molecule = new Molecule();
molecule.AddAtom(0, "C");
molecule.AddAtom(1, "N");
molecule.AddAtom(2, "Cl");
molecule.AddAtom(3, "O");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(1, 2);
molecule.AddSingleBond(1, 3);
MoleculeSignature signature = new MoleculeSignature(molecule);
string moleculeSignature = signature.GetGraphSignature();
//Console.Out.WriteLine("molsig : " + moleculeSignature);
Molecule permutation = new Molecule();
permutation.AddAtom(0, "C");
permutation.AddAtom(1, "N");
permutation.AddAtom(2, "O");
permutation.AddAtom(3, "Cl");
permutation.AddSingleBond(0, 1);
permutation.AddSingleBond(1, 2);
permutation.AddSingleBond(1, 3);
MoleculeSignature permSignature = new MoleculeSignature(molecule);
string permSignatureString = permSignature.GetGraphSignature();
//Console.Out.WriteLine("molsig : " + permSignatureString);
Assert.AreEqual(moleculeSignature, permSignatureString);
}
public void MultipleBondedFragmentTest()
{
Molecule molA = new Molecule();
molA.AddAtom("C");
molA.AddAtom("C");
molA.AddAtom("C");
molA.AddAtom("H");
molA.AddBond(0, 1, Molecule.BondOrder.Double);
molA.AddSingleBond(0, 2);
molA.AddSingleBond(0, 3);
MoleculeSignature molSig = new MoleculeSignature(molA);
string signatureFor0A = molSig.SignatureStringForVertex(0);
Console.Out.WriteLine(signatureFor0A);
Molecule molB = new Molecule();
molB.AddAtom("C");
molB.AddAtom("C");
molB.AddAtom("C");
molB.AddAtom("H");
molB.AddSingleBond(0, 1);
molB.AddBond(0, 2, Molecule.BondOrder.Double);
molB.AddSingleBond(0, 3);
molSig = new MoleculeSignature(molB);
string signatureFor0B = molSig.SignatureStringForVertex(0);
Console.Out.WriteLine(signatureFor0B);
Assert.AreEqual(signatureFor0A, signatureFor0B);
}
public void TestCarbonChainUnique()
{
// single atom
Molecule a = new Molecule("C", 1);
this.CheckCanonicalIsUnique(a);
// pair of connected atoms
a.AddAtom("C");
a.AddSingleBond(0, 1);
this.CheckCanonicalIsUnique(a);
// chain of three atoms
a.AddAtom("C");
a.AddSingleBond(0, 2);
this.CheckCanonicalIsUnique(a);
// copies for new level
Molecule b = new Molecule(a);
Molecule c = new Molecule(a);
// 4-chain
a.AddAtom("C");
a.AddSingleBond(1, 3);
this.CheckCanonicalIsUnique(a);
// 3-star
b.AddAtom("C");
b.AddSingleBond(0, 3);
this.CheckCanonicalIsUnique(b);
// 3-cycle
c.AddSingleBond(1, 2);
this.CheckCanonicalIsUnique(c);
}
public void TestRoundtrip()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(0, 3);
molecule.AddSingleBond(1, 2);
molecule.AddSingleBond(2, 3);
AtomSignature atomSignature = new AtomSignature(molecule, 0);
string signatureString = atomSignature.ToCanonicalString();
ColoredTree tree = AtomSignature.Parse(signatureString);
MoleculeBuilder builder = new MoleculeBuilder();
Molecule builtMolecule = builder.FromTree(tree);
Assert.AreEqual(molecule.ToString(), builtMolecule.ToString());
// test that this can be done more than once
builtMolecule = builder.FromTree(tree);
Assert.AreEqual(molecule.ToString(), builtMolecule.ToString());
}
public void DichlorocyclopropaneTest()
{
Molecule mol = new Molecule();
mol.AddAtom("C");
mol.AddAtom("C");
mol.AddAtom("C");
mol.AddAtom("Cl");
mol.AddAtom("Cl");
mol.AddAtom("H");
mol.AddAtom("H");
mol.AddAtom("H");
mol.AddAtom("H");
mol.AddMultipleSingleBonds(0, 1, 2, 3, 5);
mol.AddMultipleSingleBonds(1, 2, 4, 6);
mol.AddMultipleSingleBonds(2, 7, 8);
// 5 symmetry classes - the non-chiral carbon, its hydrogens, the chiral
// carbons, their hydrogens, and the chlorines.
MoleculeSignature molSig = new MoleculeSignature(mol);
var symmetryClasses = molSig.GetSymmetryClasses();
// Console.Out.WriteLine(symmetryClasses);
Assert.AreEqual(5, symmetryClasses.Count);
// only two possible chiral centers
var tetraChiralCenters =
ChiralCenterFinder.FindTetrahedralChiralCenters(mol);
Assert.AreEqual(2, tetraChiralCenters.Count);
Assert.AreEqual(0, (int)tetraChiralCenters[0]);
Assert.AreEqual(1, (int)tetraChiralCenters[1]);
}
public void TestMetheneFragmentIsCanonicallyUnique()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("H");
molecule.AddAtom("H");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(0, 2);
this.CheckCanonicalIsUnique(molecule);
}
public void MinimalTest()
{
Molecule mol = new Molecule();
mol.AddAtom("C");
mol.AddAtom("O");
mol.AddAtom("N");
mol.AddSingleBond(0, 1);
mol.AddBond(0, 2, Molecule.BondOrder.Double);
// TODO : test this somehow...
// MoleculeWriter.WriteToStream(System.out, mol);
}
public void TestMethyneFragmentSignatures()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("H");
molecule.AddSingleBond(0, 1);
MoleculeSignature signature = new MoleculeSignature(molecule);
var symmetryClasses = signature.GetSymmetryClasses();
Assert.AreEqual(2, symmetryClasses.Count);
foreach (var symmetryClass in symmetryClasses)
{
Assert.AreEqual(1, symmetryClass.Count);
}
}
public Molecule MakeMinimalMultiRing(int ringCount, int ringSize)
{
var mol = new Molecule();
mol.AddAtom("C");
for (int i = 0; i < ringCount; i++)
{
AddRing(0, ringSize, mol);
}
return(mol);
}
public void DodecahedraneTest()
{
var mol = new Molecule();
for (int i = 0; i < 20; i++)
{
mol.AddAtom("C");
}
mol.AddSingleBond(0, 1);
mol.AddSingleBond(0, 4);
mol.AddSingleBond(1, 2);
mol.AddSingleBond(2, 7);
mol.AddSingleBond(3, 4);
mol.AddSingleBond(3, 8);
mol.AddSingleBond(5, 10);
mol.AddSingleBond(5, 11);
mol.AddSingleBond(6, 11);
mol.AddSingleBond(6, 12);
mol.AddSingleBond(7, 13);
mol.AddSingleBond(8, 14);
mol.AddSingleBond(9, 10);
mol.AddSingleBond(9, 14);
mol.AddSingleBond(12, 17);
mol.AddSingleBond(13, 18);
mol.AddSingleBond(15, 16);
mol.AddSingleBond(15, 19);
mol.AddSingleBond(16, 17);
mol.AddSingleBond(18, 19);
mol.AddBond(0, 5, Molecule.BondOrder.Double);
mol.AddBond(1, 6, Molecule.BondOrder.Double);
mol.AddBond(2, 3, Molecule.BondOrder.Double);
mol.AddBond(4, 9, Molecule.BondOrder.Double);
mol.AddBond(7, 12, Molecule.BondOrder.Double);
mol.AddBond(8, 13, Molecule.BondOrder.Double);
mol.AddBond(10, 15, Molecule.BondOrder.Double);
mol.AddBond(11, 16, Molecule.BondOrder.Double);
mol.AddBond(17, 18, Molecule.BondOrder.Double);
mol.AddBond(14, 19, Molecule.BondOrder.Double);
for (int i = 0; i < 20; i++)
{
Assert.AreEqual(4, mol.GetTotalOrder(i), "Atom " + i + " has wrong order");
}
var mqg = new MoleculeQuotientGraph(mol);
Console.Out.WriteLine(mqg);
Assert.AreEqual(5, mqg.GetVertexCount());
Assert.AreEqual(9, mqg.GetEdgeCount());
Assert.AreEqual(3, mqg.NumberOfLoopEdges());
}
public void TestCarbonHydrogenCanonicalChain()
{
Molecule a = new Molecule("C", 1);
this.CheckCanonicalIsUnique(a);
a.AddAtom("H");
a.AddSingleBond(0, 1);
this.CheckCanonicalIsUnique(a);
a.AddAtom("H");
a.AddSingleBond(0, 2);
this.CheckCanonicalIsUnique(a);
a.AddAtom("H");
a.AddSingleBond(0, 3);
this.CheckCanonicalIsUnique(a);
a.AddAtom("H");
a.AddSingleBond(0, 4);
this.CheckCanonicalIsUnique(a);
}
public void ChoTest()
{
Molecule mol = new Molecule();
mol.AddAtom("C");
mol.AddAtom("H");
mol.AddAtom("O");
mol.AddSingleBond(0, 1);
mol.AddSingleBond(0, 2);
MoleculeSignature firstSig = new MoleculeSignature(mol, InvariantType.Integer);
string firstSigString = firstSig.ToCanonicalString();
Console.Out.WriteLine(firstSigString);
AtomPermutor permutor = new AtomPermutor(mol);
foreach (Molecule pMol in permutor)
{
MoleculeSignature pSig = new MoleculeSignature(pMol, InvariantType.Integer);
string pSigString = pSig.ToCanonicalString();
Console.Out.WriteLine(pSigString);
}
}
public void AddRing(int atomToAttachTo, int ringSize, Molecule molecule)
{
var numberOfAtoms = molecule.GetAtomCount();
var previous = atomToAttachTo;
for (int i = 0; i < ringSize; i++)
{
molecule.AddAtom("C");
int current = numberOfAtoms + i;
molecule.AddSingleBond(previous, current);
previous = current;
}
molecule.AddSingleBond(numberOfAtoms, numberOfAtoms + (ringSize - 1));
}
public Molecule MakeTetrakisTriphenylPhosphoranylRhodium()
{
var ttpr = new Molecule();
ttpr.AddAtom("Rh");
int phosphateCount = 3;
for (int i = 1; i <= phosphateCount; i++)
{
ttpr.AddAtom("P");
ttpr.AddSingleBond(0, i);
}
int phenylCount = 3;
for (int j = 1; j <= phosphateCount; j++)
{
for (int k = 0; k < phenylCount; k++)
{
AddRing(j, 6, ttpr);
}
}
return(ttpr);
}
public Molecule MakeChain(int length)
{
var chain = new Molecule();
int previous = -1;
for (int i = 0; i < length; i++)
{
chain.AddAtom("C");
if (previous != -1)
{
chain.AddSingleBond(previous, i);
}
previous = i;
}
return(chain);
}
public void Cyclobut_2_ene()
{
Molecule mol = new Molecule();
for (int i = 0; i < 4; i++)
{
mol.AddAtom("C");
}
mol.AddSingleBond(0, 1);
mol.AddBond(0, 2, Molecule.BondOrder.Double);
mol.AddBond(1, 3, Molecule.BondOrder.Double);
mol.AddSingleBond(2, 3);
MoleculeSignature molSignature = new MoleculeSignature(mol);
Console.Out.WriteLine(molSignature.ToCanonicalString());
}
public void TestCanonicalIsUnique()
{
Molecule molecule = new Molecule();
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddAtom("C");
molecule.AddSingleBond(0, 1);
molecule.AddSingleBond(1, 2);
molecule.AddSingleBond(1, 3);
molecule.AddSingleBond(2, 4);
molecule.AddSingleBond(2, 5);
this.CheckCanonicalIsUnique(molecule);
}
private static Molecule MakeMolecule(List <string> block)
{
Molecule molecule = new Molecule();
// counts are on the fourth line
string countLine = block[3];
int atomCount = int.Parse(countLine.Substring(0, 3).Trim(), NumberFormatInfo.InvariantInfo);
int bondCount = int.Parse(countLine.Substring(3, 3).Trim(), NumberFormatInfo.InvariantInfo);
// atom block starts on the fifth line (4th index)
int atomLineStart = 4;
int atomLineEnd = atomCount + atomLineStart;
for (int i = atomLineStart; i < atomLineEnd; i++)
{
string symbol = block[i].Substring(30, 33).Trim();
int atomIndex = i - atomLineStart;
molecule.AddAtom(atomIndex, symbol);
}
if (atomCount > 1)
{
// bond block starts right after the atom block
int bondLineStart = atomLineEnd;
int bondLineEnd = bondLineStart + bondCount;
for (int i = bondLineStart; i < bondLineEnd; i++)
{
string bondLine = block[i];
int atomNumberA =
int.Parse(bondLine.Substring(0, 3).Trim(), NumberFormatInfo.InvariantInfo);
int atomNumberB =
int.Parse(bondLine.Substring(3, 3).Trim(), NumberFormatInfo.InvariantInfo);
int order = int.Parse(bondLine.Substring(7, 3).Trim(), NumberFormatInfo.InvariantInfo);
var o = ConvertIntToBondOrder(order);
molecule.AddBond(atomNumberA - 1, atomNumberB - 1, o);
}
}
return(molecule);
}
public void BenzeneTest()
{
Molecule mol = new Molecule();
for (int i = 0; i < 6; i++)
{
mol.AddAtom("C");
}
mol.AddSingleBond(0, 1);
mol.AddBond(1, 2, Molecule.BondOrder.Double);
mol.AddSingleBond(2, 3);
mol.AddBond(3, 4, Molecule.BondOrder.Double);
mol.AddSingleBond(4, 5);
mol.AddBond(5, 0, Molecule.BondOrder.Double);
MoleculeSignature molSig = new MoleculeSignature(mol);
string sigString0 = molSig.SignatureStringForVertex(0);
for (int i = 1; i < 6; i++)
{
string sigStringI = molSig.SignatureStringForVertex(i);
Assert.AreEqual(sigString0, sigStringI);
}
}
public void CocoTest()
{
Molecule moleculeA = new Molecule();
int chainLength = 6;
moleculeA.AddAtom("O");
moleculeA.AddAtom("C");
moleculeA.AddAtom("C");
moleculeA.AddAtom("O");
moleculeA.AddAtom("C");
moleculeA.AddAtom("O");
for (int i = 0; i < chainLength - 2; i++)
{
moleculeA.AddSingleBond(i, i + 1);
}
moleculeA.AddBond(chainLength - 2, chainLength - 1, Molecule.BondOrder.Double);
// moleculeA.AddBond(chainLength - 2, chainLength - 1, 1);
Molecule moleculeB = new Molecule();
moleculeB.AddAtom("O");
moleculeB.AddAtom("C");
moleculeB.AddAtom("C");
moleculeB.AddAtom("C");
moleculeB.AddAtom("O");
moleculeB.AddAtom("O");
moleculeB.AddSingleBond(0, 1);
moleculeB.AddSingleBond(1, 3);
moleculeB.AddSingleBond(2, 4);
moleculeB.AddBond(2, 5, Molecule.BondOrder.Double);
// moleculeB.AddBond(2, 5, 1);
moleculeB.AddSingleBond(3, 4);
MoleculeSignature molSigA = new MoleculeSignature(moleculeA);
string sigA = molSigA.SignatureStringForVertex(3);
Console.Out.WriteLine(sigA);
Console.Out.WriteLine("--------------------------------------");
MoleculeSignature molSigB = new MoleculeSignature(moleculeB);
string sigB = molSigB.SignatureStringForVertex(4);
Console.Out.WriteLine(sigB);
Assert.AreEqual(sigA, sigB);
}
public void SpiranTest()
{
Molecule mol = new Molecule();
mol.AddAtom("N");
mol.AddMultipleAtoms(12, "C");
mol.AddMultipleAtoms(24, "H");
mol.AddMultipleSingleBonds(0, 1, 4, 5, 8); // central N
mol.AddMultipleSingleBonds(1, 2, 33, 34); // ring 1 - CA
mol.AddMultipleSingleBonds(2, 3, 11, 15); // ring 1 - CB
mol.AddMultipleSingleBonds(3, 4, 12, 16); // ring 1 - CB
mol.AddMultipleSingleBonds(4, 35, 36); // ring 1 - CA
mol.AddMultipleSingleBonds(5, 6, 29, 30); // ring 2 - CA
mol.AddMultipleSingleBonds(6, 7, 9, 13); // ring 2 - CB
mol.AddMultipleSingleBonds(7, 8, 10, 14); // ring 2 - CB
mol.AddMultipleSingleBonds(8, 31, 32); // ring 2 - CA
mol.AddMultipleSingleBonds(9, 17, 18, 19); // CH3 A
mol.AddMultipleSingleBonds(10, 20, 21, 22); // CH3 B
mol.AddMultipleSingleBonds(11, 23, 24, 25); // CH3 C
mol.AddMultipleSingleBonds(12, 26, 27, 28); // CH3 D
// 7 symmetry classes - central N, CA, CB, CH3-C, HA, HB, CH3-H
MoleculeSignature molSig = new MoleculeSignature(mol);
var symmetryClasses = molSig.GetSymmetryClasses();
Assert.AreEqual(7, symmetryClasses.Count);
var tetraChiralCenters =
ChiralCenterFinder.FindTetrahedralChiralCenters(mol);
Assert.AreEqual(4, tetraChiralCenters.Count);
Assert.AreEqual(2, (int)tetraChiralCenters[0]);
Assert.AreEqual(3, (int)tetraChiralCenters[1]);
Assert.AreEqual(6, (int)tetraChiralCenters[2]);
Assert.AreEqual(7, (int)tetraChiralCenters[3]);
}
