public static void MakeCanonicalSmileFromRingSystems(string dataFileIn, string dataFileOut) { Console.Out.WriteLine("Start make SMILES..."); var data = new List <string>(); var smiles = new SmilesGenerator(); try { Console.Out.WriteLine("Start..."); using (var imdl = new EnumerableSDFReader(new StreamReader(dataFileIn), builder)) { Console.Out.WriteLine("Read File in.."); foreach (var m in imdl) { try { data.Add((string)smiles.Create(builder.NewAtomContainer(m))); } catch (Exception exc1) { if (!(exc1 is CDKException || exc1 is IOException)) { throw; } Console.Out.WriteLine("Could not create smile due to: " + exc1.Message); } } } } catch (Exception exc) { Console.Out.WriteLine("Could not read Molecules from file " + dataFileIn + " due to: " + exc.Message); } Console.Out.Write("...ready\nWrite data..."); try { using (var fout = new StreamWriter(dataFileOut)) { for (int i = 0; i < data.Count; i++) { try { fout.Write(((string)data[i])); fout.WriteLine(); } catch (Exception) { } } Console.Out.WriteLine($"number of smiles: {data.Count}"); } } catch (Exception exc3) { Console.Out.WriteLine($"Could not write smile in file {dataFileOut} due to: {exc3.Message}"); } Console.Out.WriteLine("...ready"); }
// private IAtomContainer CreateBenzaldehyde() { // Molecule result = new DefaultMolecule(); // Atom c1 = result.Atoms.Add("C"); // Atom c2 = result.Atoms.Add("C"); // Atom c3 = result.Atoms.Add("C"); // Atom c4 = result.Atoms.Add("C"); // Atom c5 = result.Atoms.Add("C"); // Atom c6 = result.Atoms.Add("C"); // Atom c7 = result.Atoms.Add("C"); // Atom o8 = result.Atoms.Add("O"); // // result.Connect(c1, c2, 1); // result.Connect(c2, c3, 2); // result.Connect(c3, c4, 1); // result.Connect(c4, c5, 2); // result.Connect(c5, c6, 1); // result.Connect(c6, c1, 2); // result.Connect(c7, c1, 1); // result.Connect(c7, o8, 2); // // return result; // } // // private IAtomContainer CreateBenzoicAcid() { // Molecule result = CreateBenzaldehyde(); // // result.Connect(result.Atoms[6], result.Atoms.Add("O"), 1); // // return result; // } // // private IAtomContainer CreateBlockedBenzaldehyde() { // Molecule result = CreateBenzaldehyde(); // // result.Connect(result.Atoms[6], result.Atoms.Add("H"), 1); // // return result; // } // private Molecule Create4Toluene() { // Molecule result = new DefaultMolecule(); // Atom c1 = result.Atoms.Add("C"); // Atom c2 = result.Atoms.Add("C"); // Atom c3 = result.Atoms.Add("C"); // Atom c4 = result.Atoms.Add("C"); // Atom c5 = result.Atoms.Add("C"); // Atom c6 = result.Atoms.Add("C"); // Atom c7 = result.Atoms.Add("C"); // // result.Connect(c1, c2, 1); // result.Connect(c2, c3, 2); // result.Connect(c3, c4, 1); // result.Connect(c4, c5, 2); // result.Connect(c5, c6, 1); // result.Connect(c6, c1, 2); // result.Connect(c7, c4, 1); // // return result; // } public static IAtomContainer CreateSimpleImine() { IAtomContainer result = builder.NewAtomContainer(); IAtom c1 = builder.NewAtom("C"); IAtom c2 = builder.NewAtom("N"); result.Atoms.Add(c1); result.Atoms.Add(c2); IBond bond = builder.NewBond(c1, c2, BondOrder.Double); result.Bonds.Add(bond); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(result); var adder = CDK.HydrogenAdder; adder.AddImplicitHydrogens(result); Aromaticity.CDKLegacy.Apply(result); SmilesGenerator sg = new SmilesGenerator(); string oldSmiles = sg.Create(result); Console.Out.WriteLine("SimpleImine " + oldSmiles); return(result); }
public void TestSplit() { var mol = smilesParser.ParseSmiles("C1CC1C2CCC2"); SpanningTree st = new SpanningTree(mol); IRingSet rings = st.GetAllRings(); IBond splitBond = null; for (int i = 0; i < mol.Bonds.Count; i++) { if (rings.GetRings(mol.Bonds[i]).Count() == 0) { splitBond = mol.Bonds[i]; break; } } var frags = FragmentUtils.SplitMolecule(mol, splitBond); SmilesGenerator sg = new SmilesGenerator(); var uniqueFrags = new HashSet <string>(); foreach (var frag in frags) { uniqueFrags.Add(sg.Create(frag)); } Assert.AreEqual(2, uniqueFrags.Count); // You can put the fragments back together with a ring closure and dot // [CH]12CC1.[CH]12CCC1 Assert.IsTrue(uniqueFrags.IsSupersetOf(new[] { "[CH]1CC1", "[CH]1CCC1" })); }
public void TestTermination() { int ringSize = 7; var ring = builder.NewAtomContainer(); for (int i = 0; i < ringSize; i++) { ring.Atoms.Add(builder.NewAtom("C")); } for (int j = 0; j < ringSize - 1; j++) { ring.AddBond(ring.Atoms[j], ring.Atoms[j + 1], BondOrder.Single); } ring.AddBond(ring.Atoms[ringSize - 1], ring.Atoms[0], BondOrder.Single); ring.Atoms.Add(builder.NewAtom("Cl")); ring.Atoms.Add(builder.NewAtom("F")); ring.AddBond(ring.Atoms[0], ring.Atoms[ringSize], BondOrder.Single); ring.AddBond(ring.Atoms[0], ring.Atoms[ringSize + 1], BondOrder.Single); ring.Atoms.Add(builder.NewAtom("O")); ring.AddBond(ring.Atoms[1], ring.Atoms[ringSize + 2], BondOrder.Single); var atoms = new IAtom[] { ring.Atoms[ringSize], ring.Atoms[ringSize + 1], ring.Atoms[ringSize - 1], ring.Atoms[1] }; var stereoCenter = new TetrahedralChirality(ring.Atoms[0], atoms, TetrahedralStereo.AntiClockwise); ring.StereoElements.Add(stereoCenter); SmilesGenerator generator = new SmilesGenerator(); CIPTool.GetCIPChirality(ring, stereoCenter); }
/// <summary> /// Writes the content from molecule to output. /// </summary> /// <param name="molecule">Molecule of which the data is given as output.</param> public void WriteAtomContainer(IAtomContainer molecule) { SmilesGenerator sg = new SmilesGenerator(); if (useAromaticityFlag.IsSet) { sg = sg.Aromatic(); } string smiles = ""; try { smiles = sg.Create(molecule); Debug.WriteLine($"Generated SMILES: {smiles}"); writer.Write(smiles); writer.Write('\n'); writer.Flush(); Debug.WriteLine("file flushed..."); } catch (Exception exc) { if (exc is CDKException | exc is IOException) { Trace.TraceError($"Error while writing Molecule: {exc.Message}"); Debug.WriteLine(exc); } else { throw; } } }
/// <summary> /// Method assigns certain properties to an atom. Necessary for the atom type matching /// Properties: /// <list type="bullet"> /// <item>aromaticity</item> /// <item>ChemicalGroup (CDKChemicalRingGroupConstant)</item> /// <item> /// <item>SSSR</item> /// <item>Ring/Group, ringSize, aromaticity</item> /// <item>SphericalMatcher (HoSe Code)</item> /// </item> /// </list> /// </summary> /// <param name="molecule"></param> /// <param name="aromaticity"><see langword="true"/> if aromaticity should be calculated</param> /// <returns>sssrf ring set of the molecule</returns> public static IRingSet AssignAtomTypePropertiesToAtom(IAtomContainer molecule, bool aromaticity) { var sg = new SmilesGenerator(); Debug.WriteLine("assignAtomTypePropertiesToAtom Start ..."); string hoseCode = ""; var ringSetMolecule = Cycles.FindSSSR(molecule).ToRingSet(); Debug.WriteLine(ringSetMolecule); if (aromaticity) { try { Aromaticity.CDKLegacy.Apply(molecule); } catch (Exception cdk1) { Trace.TraceError($"AROMATICITYError: Cannot determine aromaticity due to: {cdk1.ToString()}"); } } for (int i = 0; i < molecule.Atoms.Count; i++) { // FIXME: remove casting var atom2 = molecule.Atoms[i]; //Atom aromatic is set by HueckelAromaticityDetector //Atom in ring? if (ringSetMolecule.Contains(atom2)) { var ringSetA = ringSetMolecule.Builder.NewRingSet(); ringSetA.AddRange(ringSetMolecule.GetRings(atom2)); RingSetManipulator.Sort(ringSetA); var sring = ringSetA.Last(); atom2.SetProperty(CDKPropertyName.PartOfRingOfSize, sring.RingSize); atom2.SetProperty( CDKPropertyName.ChemicalGroupConstant, RingSystemClassifier(sring, GetSubgraphSmiles(sring, molecule))); atom2.IsInRing = true; atom2.IsAliphatic = false; } else { atom2.SetProperty(CDKPropertyName.ChemicalGroupConstant, NotInRing); atom2.IsInRing = false; atom2.IsAliphatic = true; } try { hoseCode = hcg.GetHOSECode(molecule, atom2, 3); hoseCode = RemoveAromaticityFlagsFromHoseCode(hoseCode); atom2.SetProperty(CDKPropertyName.SphericalMatcher, hoseCode); } catch (CDKException ex1) { throw new CDKException($"Could not build HOSECode from atom {i} due to {ex1.ToString()}", ex1); } } return(ringSetMolecule); }
public void InliningReactionsWithRadicals() { IChemObjectBuilder bldr = ChemObjectBuilder.Instance; SmilesParser smipar = new SmilesParser(bldr); IReaction reaction = smipar.ParseReactionSmiles("[CH2]CO.CC(=O)O>[H+]>CCOC(=O)C.O |^1:0| ethyl esterification"); SmilesGenerator smigen = new SmilesGenerator(SmiFlavors.CxSmiles); // convert to molecule IAtomContainer mol = ReactionManipulator.ToMolecule(reaction); Assert.AreEqual("[CH2]CO.CC(=O)O.[H+].CCOC(=O)C.O |^1:0|", smigen.Create(mol)); Assert.AreEqual("[CH2]CO.CC(=O)O>[H+]>CCOC(=O)C.O |^1:0|", smigen.CreateReactionSMILES(ReactionManipulator.ToReaction(mol))); }
/// <summary> /// Generate Smiles /// </summary> /// <param name="mol"></param> /// <param name="flags"></param> /// <returns></returns> public static String AtomContainerToSmiles( IAtomContainer mol, SmilesGeneratorType flags) { ApplyAromaticity(mol); SmilesGenerator sg = null; if ((flags & SmilesGeneratorType.Generic) != 0) { sg = SmilesGenerator.generic(); } else if ((flags & SmilesGeneratorType.Isomeric) != 0) { sg = SmilesGenerator.isomeric(); } else if ((flags & SmilesGeneratorType.Unique) != 0) { sg = SmilesGenerator.unique(); } else if ((flags & SmilesGeneratorType.Absolute) != 0) { sg = SmilesGenerator.unique(); } else { throw new Exception("Canonical/Stereo/Isotop types not defined"); } if ((flags & SmilesGeneratorType.NotAromatic) != 0) { } // not aromatic else { sg = sg.aromatic(); // aromatic by default even if not specified } if ((flags & SmilesGeneratorType.WithAtomClasses) != 0) { sg = sg.withAtomClasses(); } string smiles = sg.create(mol); return(smiles); }
/// <summary> /// Instantiate Murcko fragmenter. /// </summary> /// <param name="singleFrameworkOnly">if <see langword="true"/>, only the true Murcko framework is generated.</param> /// <param name="minimumFragmentSize">the smallest size of fragment to consider</param> /// <param name="generator">An instance of a <see cref="IMoleculeHashGenerator"/> to be used to check for duplicate fragments</param> public MurckoFragmenter(bool singleFrameworkOnly, int minimumFragmentSize, IMoleculeHashGenerator generator) { this.singleFrameworkOnly = singleFrameworkOnly; this.minimumFragmentSize = minimumFragmentSize; if (generator == null) { this.generator = new HashGeneratorMaker().Depth(8).Elemental().Isotopic().Charged().Orbital().Molecular(); } else { this.generator = generator; } smigen = SmilesGenerator.Unique.Aromatic(); }
public void TestIndoleAgainstItself() { IAtomContainer indole = TestMoleculeFactory.MakeIndole(); AddImplicitHydrogens(indole); AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(indole); Aromaticity.CDKLegacy.Apply(indole); SmilesGenerator generator = new SmilesGenerator().Aromatic(); string indoleSmiles = generator.Create(indole); var smilesParser = CDK.SmilesParser; indole = smilesParser.ParseSmiles(indoleSmiles); SMARTSQueryTool querytool = new SMARTSQueryTool(indoleSmiles, ChemObjectBuilder.Instance); Assert.IsTrue(querytool.Matches(indole)); }
/// <summary> Writes the content from molecule to output. /// /// </summary> /// <param name="molecule"> Molecule of which the data is outputted. /// </param> public virtual void writeMolecule(IMolecule molecule) { SmilesGenerator sg = new SmilesGenerator(molecule.Builder); System.String smiles = ""; try { smiles = sg.createSMILES(molecule); //logger.debug("Generated SMILES: " + smiles); writer.Write(smiles); //UPGRADE_TODO: Method 'java.io.BufferedWriter.newLine' was converted to 'System.IO.TextWriter.WriteLine' which has a different behavior. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1073'" writer.WriteLine(); writer.Flush(); //logger.debug("file flushed..."); } catch (System.Exception exc) { //UPGRADE_TODO: The equivalent in .NET for method 'java.lang.Throwable.getMessage' may return a different value. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1043'" //logger.error("Error while writing Molecule: ", exc.Message); //logger.debug(exc); } }
public static void ExtractUniqueRingSystemsFromFile(string dataFile) { Console.Out.WriteLine("****** EXTRACT UNIQUE RING SYSTEMS ******"); Console.Out.WriteLine($"From file: {dataFile}"); Dictionary <string, string> hashRingSystems = new Dictionary <string, string>(); SmilesGenerator smilesGenerator = new SmilesGenerator(); int counterRings = 0; int counterMolecules = 0; int counterUniqueRings = 0; IRingSet ringSet = null; string key = ""; IAtomContainer ac = null; string molfile = dataFile + "_UniqueRings"; try { using (var fout = new FileStream(molfile, FileMode.Create)) using (var mdlw = new MDLV2000Writer(fout)) { try { Console.Out.WriteLine("Start..."); using (var fin = new StreamReader(dataFile)) using (var imdl = new EnumerableSDFReader(fin, builder)) { Console.Out.WriteLine("Read File in.."); foreach (var m in imdl) { counterMolecules = counterMolecules + 1; IRingSet ringSetM = Cycles.FindSSSR(m).ToRingSet(); if (counterMolecules % 1000 == 0) { Console.Out.WriteLine("Molecules:" + counterMolecules); } if (ringSetM.Count > 0) { var ringSystems = RingPartitioner.PartitionRings(ringSetM); for (int i = 0; i < ringSystems.Count; i++) { ringSet = (IRingSet)ringSystems[i]; ac = builder.NewAtomContainer(); var containers = RingSetManipulator.GetAllAtomContainers(ringSet); foreach (var container in containers) { ac.Add(container); } counterRings = counterRings + 1; // Only connection is important for (int j = 0; j < ac.Atoms.Count; j++) { (ac.Atoms[j]).Symbol = "C"; } try { key = smilesGenerator.Create(builder.NewAtomContainer(ac)); } catch (CDKException e) { Trace.TraceError(e.Message); return; } if (hashRingSystems.ContainsKey(key)) { } else { counterUniqueRings = counterUniqueRings + 1; hashRingSystems[key] = "1"; try { mdlw.Write(builder.NewAtomContainer(ac)); } catch (Exception emdl) { if (!(emdl is ArgumentException || emdl is CDKException)) { throw; } } } } } } } } catch (Exception exc) { Console.Out.WriteLine($"Could not read Molecules from file {dataFile} due to: {exc.Message}"); } } } catch (Exception ex2) { Console.Out.WriteLine($"IOError:cannot write file due to: {ex2.ToString()}"); } Console.Out.WriteLine($"READY Molecules:{counterMolecules} RingSystems:{counterRings} UniqueRingsSystem:{counterUniqueRings}"); Console.Out.WriteLine($"HashtableKeys:{hashRingSystems.Count}"); }
/// <summary> /// Instantiate fragmenter with user specified minimum fragment size. /// </summary> /// <param name="minFragSize">the minimum fragment size desired</param> public ExhaustiveFragmenter(int minFragSize) { this.MinimumFragmentSize = minFragSize; fragMap = new Dictionary <string, IAtomContainer>(); smilesGenerator = SmilesGenerator.Unique.Aromatic(); }
public static string MolToSmiles(IAtomContainer mol) { var gen = new SmilesGenerator(); return(gen.Create(mol)); }