public void TestCalculateNumberOfImplicitHydrogens() { IChemObjectBuilder builder = ChemObjectBuilder.Instance; IAtomContainer proton = builder.NewAtomContainer(); IAtom hplus = builder.NewAtom("H"); hplus.FormalCharge = 1; proton.Atoms.Add(hplus); Assert.AreEqual(0, satcheck.CalculateNumberOfImplicitHydrogens(hplus, proton)); IAtomContainer hydrogenRadical = builder.NewAtomContainer(); IAtom hradical = builder.NewAtom("H"); hydrogenRadical.Atoms.Add(hradical); hydrogenRadical.SingleElectrons.Add(builder.NewSingleElectron(hradical)); Assert.AreEqual(0, satcheck.CalculateNumberOfImplicitHydrogens(hradical, hydrogenRadical)); IAtomContainer hydrogen = builder.NewAtomContainer(); IAtom h = builder.NewAtom("H"); hydrogen.Atoms.Add(h); Assert.AreEqual(1, satcheck.CalculateNumberOfImplicitHydrogens(h, hydrogen)); IAtomContainer coRad = builder.NewAtomContainer(); IAtom c = builder.NewAtom("C"); IAtom o = builder.NewAtom("O"); IBond bond = builder.NewBond(c, o, BondOrder.Double); coRad.Atoms.Add(c); coRad.Atoms.Add(o); coRad.Bonds.Add(bond); coRad.SingleElectrons.Add(builder.NewSingleElectron(c)); Assert.AreEqual(1, satcheck.CalculateNumberOfImplicitHydrogens(c, coRad)); }
public void TestGetInChIFromMethylRadical() { var ac = builder.NewAtomContainer(); var a = builder.NewAtom("C"); a.ImplicitHydrogenCount = 3; ac.Atoms.Add(a); ac.SingleElectrons.Add(builder.NewSingleElectron(a)); var gen = factory.GetInChIGenerator(ac, "FixedH"); Assert.AreEqual(gen.ReturnStatus, InChIReturnCode.Ok); Assert.AreEqual("InChI=1/CH3/h1H3", gen.InChI); }
public void TestNewSingleElectron_IAtom() { IChemObjectBuilder builder = RootObject.Builder; ISingleElectron electron = builder.NewSingleElectron(builder.NewAtom()); Assert.IsNotNull(electron); }
public void TestDontDeleteSingleElectrons() { var atomCon = builder.NewAtomContainer(); // make two molecules; one with an LonePair, the other with a SingleElectron var mol1 = builder.NewAtomContainer(); var atom1 = builder.NewAtom("C"); mol1.Atoms.Add(atom1); var lp1 = builder.NewLonePair(atom1); mol1.LonePairs.Add(lp1); // mol2 var mol2 = builder.NewAtomContainer(); var atom2 = builder.NewAtom("C"); mol2.Atoms.Add(atom2); var se2 = builder.NewSingleElectron(atom2); mol2.SingleElectrons.Add(se2); atomCon.Add(mol1); atomCon.Add(mol2); // now partition var moleculeSet = ConnectivityChecker.PartitionIntoMolecules(atomCon).ToReadOnlyList(); Assert.IsNotNull(moleculeSet); Assert.AreEqual(2, moleculeSet.Count); Assert.IsTrue(ConnectivityChecker.IsConnected(moleculeSet[0])); Assert.IsTrue(ConnectivityChecker.IsConnected(moleculeSet[1])); // make sure Assert.AreEqual(1, moleculeSet[0].Atoms.Count); Assert.AreEqual(1, moleculeSet[0].GetElectronContainers().Count()); Assert.AreEqual(1, moleculeSet[1].Atoms.Count); Assert.AreEqual(1, moleculeSet[1].GetElectronContainers().Count()); // we don't know which partition contains the LP and which the electron Assert.IsTrue(moleculeSet[0].GetConnectedSingleElectrons( moleculeSet[0].Atoms[0]).Count() == 0 || moleculeSet[1].GetConnectedSingleElectrons( moleculeSet[1].Atoms[0]).Count() == 0); Assert.IsTrue(moleculeSet[0].GetConnectedLonePairs( moleculeSet[0].Atoms[0]).Count() == 0 || moleculeSet[1].GetConnectedLonePairs( moleculeSet[1].Atoms[0]).Count() == 0); }
public void WriteMoreThan8Radicals() { IAtomContainer mol = builder.NewAtomContainer(); for (int i = 0; i < 20; i++) { IAtom atom = builder.NewAtom(); atom.Symbol = "C"; mol.Atoms.Add(atom); mol.SingleElectrons.Add(builder.NewSingleElectron(atom)); } StringWriter sw = new StringWriter(); using (MDLV2000Writer mdlw = new MDLV2000Writer(sw)) { mdlw.Write(mol); } Assert.IsTrue(sw.ToString(). Contains("M RAD 8 9 2 10 2 11 2 12 2 13 2 14 2 15 2 16 2")); }
/// <summary> /// Transfers the CXSMILES state onto the CDK atom/molecule data-structures. /// </summary> /// <param name="bldr">chem-object builder</param> /// <param name="atoms">atoms parsed from the molecule or reaction. Reaction molecules are list left to right.</param> /// <param name="atomToMol">look-up of atoms to molecules when connectivity/sgroups need modification</param> /// <param name="cxstate">the CXSMILES state to read from</param> private void AssignCxSmilesInfo(IChemObjectBuilder bldr, IChemObject chemObj, List <IAtom> atoms, Dictionary <IAtom, IAtomContainer> atomToMol, CxSmilesState cxstate) { // atom-labels - must be done first as we replace atoms if (cxstate.atomLabels != null) { foreach (var e in cxstate.atomLabels) { // bounds check if (e.Key >= atoms.Count) { continue; } var old = atoms[e.Key]; var pseudo = bldr.NewPseudoAtom(); var val = e.Value; // specialised label handling if (val.EndsWith("_p", StringComparison.Ordinal)) // pseudo label { val = val.Substring(0, val.Length - 2); } else if (val.StartsWith("_AP", StringComparison.Ordinal)) // attachment point { pseudo.AttachPointNum = ParseIntSafe(val.Substring(3)); } pseudo.Label = val; pseudo.AtomicNumber = 0; pseudo.ImplicitHydrogenCount = 0; var mol = atomToMol[old]; AtomContainerManipulator.ReplaceAtomByAtom(mol, old, pseudo); atomToMol.Add(pseudo, mol); atoms[e.Key] = pseudo; } } // atom-values - set as comment, mirrors Molfile reading behavior if (cxstate.atomValues != null) { foreach (var e in cxstate.atomValues) { atoms[e.Key].SetProperty(CDKPropertyName.Comment, e.Value); } } // atom-coordinates if (cxstate.atomCoords != null) { var numAtoms = atoms.Count; var numCoords = cxstate.atomCoords.Count; var lim = Math.Min(numAtoms, numCoords); if (cxstate.coordFlag) { for (int i = 0; i < lim; i++) { atoms[i].Point3D = new Vector3( cxstate.atomCoords[i][0], cxstate.atomCoords[i][1], cxstate.atomCoords[i][2]); } } else { for (int i = 0; i < lim; i++) { atoms[i].Point2D = new Vector2( cxstate.atomCoords[i][0], cxstate.atomCoords[i][1]); } } } // atom radicals if (cxstate.atomRads != null) { foreach (var e in cxstate.atomRads) { // bounds check if (e.Key >= atoms.Count) { continue; } int count = 0; var aa = e.Value; switch (e.Value) { case CxSmilesState.Radical.Monovalent: count = 1; break; // no distinction in CDK between singled/triplet case CxSmilesState.Radical.Divalent: case CxSmilesState.Radical.DivalentSinglet: case CxSmilesState.Radical.DivalentTriplet: count = 2; break; // no distinction in CDK between doublet/quartet case CxSmilesState.Radical.Trivalent: case CxSmilesState.Radical.TrivalentDoublet: case CxSmilesState.Radical.TrivalentQuartet: count = 3; break; } var atom = atoms[e.Key]; var mol = atomToMol[atom]; while (count-- > 0) { mol.SingleElectrons.Add(bldr.NewSingleElectron(atom)); } } } var sgroupMap = new MultiDictionary <IAtomContainer, Sgroup>(); // positional-variation if (cxstate.positionVar != null) { foreach (var e in cxstate.positionVar) { var sgroup = new Sgroup { Type = SgroupType.ExtMulticenter }; var beg = atoms[e.Key]; var mol = atomToMol[beg]; var bonds = mol.GetConnectedBonds(beg); if (bonds.Count() == 0) { continue; // bad } sgroup.Add(beg); sgroup.Add(bonds.First()); foreach (var endpt in e.Value) { sgroup.Add(atoms[endpt]); } sgroupMap.Add(mol, sgroup); } } // data sgroups if (cxstate.dataSgroups != null) { foreach (var dsgroup in cxstate.dataSgroups) { if (dsgroup.Field != null && dsgroup.Field.StartsWith("cdk:", StringComparison.Ordinal)) { chemObj.SetProperty(dsgroup.Field, dsgroup.Value); } } } // polymer Sgroups if (cxstate.sgroups != null) { foreach (var psgroup in cxstate.sgroups) { var sgroup = new Sgroup(); var atomset = new HashSet <IAtom>(); IAtomContainer mol = null; foreach (var idx in psgroup.AtomSet) { if (idx >= atoms.Count) { continue; } var atom = atoms[idx]; var amol = atomToMol[atom]; if (mol == null) { mol = amol; } else if (amol != mol) { goto C_PolySgroup; } atomset.Add(atom); } if (mol == null) { continue; } foreach (var atom in atomset) { foreach (var bond in mol.GetConnectedBonds(atom)) { if (!atomset.Contains(bond.GetOther(atom))) { sgroup.Add(bond); } } sgroup.Add(atom); } sgroup.Subscript = psgroup.Subscript; sgroup.PutValue(SgroupKey.CtabConnectivity, psgroup.Supscript); switch (psgroup.Type) { case "n": sgroup.Type = SgroupType.CtabStructureRepeatUnit; break; case "mon": sgroup.Type = SgroupType.CtabMonomer; break; case "mer": sgroup.Type = SgroupType.CtabMer; break; case "co": sgroup.Type = SgroupType.CtabCopolymer; break; case "xl": sgroup.Type = SgroupType.CtabCrossLink; break; case "mod": sgroup.Type = SgroupType.CtabModified; break; case "mix": sgroup.Type = SgroupType.CtabMixture; break; case "f": sgroup.Type = SgroupType.CtabFormulation; break; case "any": sgroup.Type = SgroupType.CtabAnyPolymer; break; case "gen": sgroup.Type = SgroupType.CtabGeneric; break; case "c": sgroup.Type = SgroupType.CtabComponent; break; case "grf": sgroup.Type = SgroupType.CtabGraft; break; case "alt": sgroup.Type = SgroupType.CtabCopolymer; sgroup.PutValue(SgroupKey.CtabSubType, "ALT"); break; case "ran": sgroup.Type = SgroupType.CtabCopolymer; sgroup.PutValue(SgroupKey.CtabSubType, "RAN"); break; case "blk": sgroup.Type = SgroupType.CtabCopolymer; sgroup.PutValue(SgroupKey.CtabSubType, "BLO"); break; } sgroupMap.Add(mol, sgroup); C_PolySgroup: ; } } // assign Sgroups foreach (var e in sgroupMap) { e.Key.SetCtabSgroups(new List <Sgroup>(e.Value)); } }
public void TestNsp3SingleB() { //CreateFromSmiles("CN") var molecule = builder.NewAtomContainer(); molecule.Atoms.Add(builder.NewAtom("C")); molecule.Atoms.Add(builder.NewAtom("N")); molecule.AddBond(molecule.Atoms[0], molecule.Atoms[1], BondOrder.Single); molecule.Atoms.Add(builder.NewAtom("H")); molecule.Atoms.Add(builder.NewAtom("H")); molecule.Atoms.Add(builder.NewAtom("H")); molecule.Atoms.Add(builder.NewAtom("H")); molecule.Atoms.Add(builder.NewAtom("H")); molecule.AddBond(molecule.Atoms[0], molecule.Atoms[2], BondOrder.Single); molecule.AddBond(molecule.Atoms[0], molecule.Atoms[3], BondOrder.Single); molecule.AddBond(molecule.Atoms[0], molecule.Atoms[4], BondOrder.Single); molecule.AddBond(molecule.Atoms[1], molecule.Atoms[5], BondOrder.Single); molecule.AddBond(molecule.Atoms[1], molecule.Atoms[6], BondOrder.Single); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(molecule); CDK.LonePairElectronChecker.Saturate(molecule); molecule.Atoms[1].IsReactiveCenter = true; var setOfReactants = CDK.Builder.NewAtomContainerSet(); setOfReactants.Add(molecule); var type = new ElectronImpactNBEReaction(); var paramList = new List <IParameterReaction>(); var param = new SetReactionCenter { IsSetParameter = true }; paramList.Add(param); type.ParameterList = paramList; /* initiate */ var setOfReactions = type.Initiate(setOfReactants, null); Assert.AreEqual(1, setOfReactions.Count); // expected products //CreateFromSmiles("C[N*+]") var expected1 = builder.NewAtomContainer(); expected1.Atoms.Add(builder.NewAtom("C")); expected1.Atoms.Add(builder.NewAtom("N")); expected1.Atoms[1].FormalCharge = +1; expected1.SingleElectrons.Add(builder.NewSingleElectron(expected1.Atoms[1])); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[1], BondOrder.Single); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[2], BondOrder.Single); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[3], BondOrder.Single); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[4], BondOrder.Single); expected1.AddBond(expected1.Atoms[1], expected1.Atoms[5], BondOrder.Single); expected1.AddBond(expected1.Atoms[1], expected1.Atoms[6], BondOrder.Single); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(expected1); CDK.LonePairElectronChecker.Saturate(expected1); var product1 = setOfReactions[0].Products[0]; var queryAtom = QueryAtomContainerCreator.CreateSymbolAndChargeQueryContainer(expected1); Assert.IsTrue(new UniversalIsomorphismTester().IsIsomorph(product1, queryAtom)); }
public void TestM5() { //CreateFromSmiles("C=[C*]") IAtomContainer expected1 = builder.NewAtomContainer(); expected1.Atoms.Add(builder.NewAtom("C")); expected1.Atoms.Add(builder.NewAtom("C")); expected1.SingleElectrons.Add(builder.NewSingleElectron(expected1.Atoms[1])); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[1], BondOrder.Double); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.Atoms.Add(builder.NewAtom("H")); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[2], BondOrder.Single); expected1.AddBond(expected1.Atoms[0], expected1.Atoms[3], BondOrder.Single); expected1.AddBond(expected1.Atoms[1], expected1.Atoms[4], BondOrder.Single); string[] expectedTypes = { "C.sp2", "C.radical.sp2", "H", "H", "H" }; Assert.AreEqual(expectedTypes.Length, expected1.Atoms.Count); for (int i = 0; i < expectedTypes.Length; i++) { IAtom nextAtom = expected1.Atoms[i]; IAtomType perceivedType = matcher.FindMatchingAtomType(expected1, nextAtom); Assert.IsNotNull(perceivedType, "Missing atom type for: " + nextAtom + " " + i + " expected: " + expectedTypes[i]); Assert.AreEqual(expectedTypes[i], perceivedType.AtomTypeName, "Incorrect atom type perceived for: " + nextAtom); } }