コード例 #1
0
        public void AvoidWedgingRingBond()
        {
            var smi    = "CC(C)[C@@H]1CCCCO1";
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles(smi);
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            int wedgeCount = 0;

            foreach (var bond in mol.Bonds)
            {
                switch (bond.Stereo)
                {
                case BondStereo.Up:
                case BondStereo.Down:
                case BondStereo.UpInverted:
                case BondStereo.DownInverted:
                    Assert.IsFalse(bond.IsInRing);
                    ++wedgeCount;
                    break;
                }
            }
            Assert.AreEqual(1, wedgeCount);
        }
コード例 #2
0
        public void AtropisomerWedgeBonds()
        {
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles("OC1=CC=C2C=CC=CC2=C1C1=C(O)C=CC2=C1C=CC=C2");

            var focus    = mol.GetBond(mol.Atoms[10], mol.Atoms[11]);
            var carriers = new List <IAtom>();

            carriers.AddRange(mol.GetConnectedAtoms(focus.Begin));
            carriers.AddRange(mol.GetConnectedAtoms(focus.End));
            carriers.Remove(focus.Begin);
            carriers.Remove(focus.End);

            mol.StereoElements.Add(new Atropisomeric(focus, carriers, StereoConfigurations.Left));

            var sdg = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);

            var bond1 = mol.GetBond(focus.Begin, carriers[1]);
            var bond2 = mol.GetBond(focus.End, carriers[3]);

            Assert.AreEqual(BondOrder.Single, bond1.Order);
            Assert.AreEqual(BondOrder.Single, bond2.Order);

            Assert.IsTrue(bond1.Stereo == BondStereo.Down || bond2.Stereo == BondStereo.Down, "One of the single bonds should have been wedged");
        }
コード例 #3
0
        private bool ShowIt(IAtomContainer molecule, string name)
        {
            StructureDiagramGenerator sdg = new StructureDiagramGenerator {
                Molecule = (IAtomContainer)molecule.Clone()
            };

            sdg.GenerateCoordinates(new Vector2(0, 1));
            return(true);
        }
コード例 #4
0
 /// <summary>
 /// Automatically generate coordinates if a user has provided a molecule without them.
 /// </summary>
 /// <param name="container">a molecule</param>
 /// <returns>if coordinates needed to be generated</returns>
 /// <exception cref="CDKException">coordinates could not be generated</exception>
 private static bool Ensure2DLayout(IAtomContainer container)
 {
     if (!GeometryUtil.Has2DCoordinates(container))
     {
         var sdg = new StructureDiagramGenerator();
         sdg.GenerateCoordinates(container);
         return(true);
     }
     return(false);
 }
コード例 #5
0
 /// <summary>
 /// Automatically generate coordinates if a user has provided reaction without them.
 /// </summary>
 /// <param name="rxn">reaction</param>
 /// <exception cref="CDKException">coordinates could not be generated</exception>
 private void Ensure2DLayout(IReaction rxn)
 {
     if (!GeometryUtil.Has2DCoordinates(rxn))
     {
         var sdg = new StructureDiagramGenerator {
             AlignMappedReaction = alignMappedReactions
         };
         sdg.GenerateCoordinates(rxn);
     }
 }
コード例 #6
0
        /// <summary>
        /// Generate coordinates for a molecule
        /// </summary>
        /// <param name="mol"></param>
        /// <returns></returns>
        public IAtomContainer GenerateCoordinates(
            IAtomContainer mol)
        {
            StructureDiagramGenerator sdg = new StructureDiagramGenerator();

            sdg.Molecule = mol;
            sdg.GenerateCoordinates();
            IAtomContainer mol2 = sdg.Molecule;

            return(mol2);
        }
コード例 #7
0
        void Main()
        {
            IAtomContainer someMolecule = null;

            #region
            StructureDiagramGenerator sdg = new StructureDiagramGenerator();
            sdg.Molecule = someMolecule;
            sdg.GenerateCoordinates();
            IAtomContainer layedOutMol = sdg.Molecule;
            #endregion
        }
コード例 #8
0
 private bool EverythingOk(IEnumerable <IAtomContainer> structures)
 {
     Debug.WriteLine($"number of structures in vector: {structures.Count()}");
     foreach (var mol in structures)
     {
         var sdg = new StructureDiagramGenerator {
             Molecule = mol
         };
         sdg.GenerateCoordinates(new Vector2(0, 1));
     }
     return(true);
 }
コード例 #9
0
        public void NoWavyBondForCisTransNv5()
        {
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles("CN(C)(C)=CC");
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            foreach (IBond bond in mol.Bonds)
            {
                Assert.AreNotEqual(BondStereo.UpOrDown, bond.Stereo);
                Assert.AreNotEqual(BondStereo.UpOrDownInverted, bond.Stereo);
            }
        }
コード例 #10
0
        private bool everythingOk(IEnumerable <IAtomContainer> structures)
        {
            StructureDiagramGenerator sdg;

            if (debug)
            {
                Console.Out.WriteLine("number of structures in vector: " + structures.Count());
            }
            foreach (var mol in structures)
            {
                sdg = new StructureDiagramGenerator {
                    Molecule = mol
                };
                sdg.GenerateCoordinates(new Vector2(0, 1));
            }
            return(true);
        }
コード例 #11
0
 public void InconsistentStereoState()
 {
     try
     {
         var smi    = "O[C@]([H])(C)CCC";
         var smipar = CDK.SmilesParser;
         var mol    = smipar.ParseSmiles(smi);
         mol.Remove(mol.Bonds[1]);
         mol.Atoms.RemoveAt(2); // unsafe-removes
         var sdg = new StructureDiagramGenerator();
         sdg.GenerateCoordinates(mol);
         Assert.Fail();
     }
     catch (ArgumentException)
     {
     }
 }
コード例 #12
0
        public void Testosterone()
        {
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles("O=C4C=C2[C@]([C@@]1([H])CC[C@@]3([C@@]([H])(O)CC[C@@]3([H])[C@]1([H])CC2)C)(C)CC4");
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            int wedgeCount = 0;

            foreach (IBond bond in mol.Bonds)
            {
                if (bond.Stereo == BondStereo.Up || bond.Stereo == BondStereo.Down)
                {
                    wedgeCount++;
                }
            }
            Assert.AreEqual(7, wedgeCount);
        }
コード例 #13
0
        public void MinWedges()
        {
            var smi    = "[C@](([C@@H](C)Cl)([C@H](C)Cl)[C@H](O)[C@](([C@@H](C)Cl)[C@H](C)Cl)[H])[H]";
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles(smi);
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            int wedgeCount = 0;

            foreach (var bond in mol.Bonds)
            {
                switch (bond.Stereo)
                {
                case BondStereo.Up:
                case BondStereo.Down:
                case BondStereo.UpInverted:
                case BondStereo.DownInverted:
                    ++wedgeCount;
                    break;
                }
            }
            Assert.AreEqual(7, wedgeCount);
        }
コード例 #14
0
        public void WedgeExtendedTetrahedral()
        {
            var smi    = "C(=C=C=[C@@]=C=C=CC)C";
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles(smi);
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            int wedgeCount = 0;

            foreach (var bond in mol.Bonds)
            {
                switch (bond.Stereo)
                {
                case BondStereo.Up:
                case BondStereo.Down:
                case BondStereo.UpInverted:
                case BondStereo.DownInverted:
                    ++wedgeCount;
                    break;
                }
            }
            Assert.AreEqual(2, wedgeCount);
        }
コード例 #15
0
        public void AvoidBondsToOtherStereoCentres()
        {
            var smi    = "[H][C@@]([C@H](C)N)([C@@H](C)O)[C@@H](C)OC";
            var smipar = CDK.SmilesParser;
            var mol    = smipar.ParseSmiles(smi);
            var sdg    = new StructureDiagramGenerator();

            sdg.GenerateCoordinates(mol);
            int wedgeCount = 0;

            foreach (var bond in mol.Bonds)
            {
                switch (bond.Stereo)
                {
                case BondStereo.Up:
                case BondStereo.Down:
                case BondStereo.UpInverted:
                case BondStereo.DownInverted:
                    wedgeCount++;
                    break;
                }
            }
            Assert.AreEqual(4, wedgeCount);
        }
コード例 #16
0
        public void TestModel3D_bug_1610997()
        {
            //bool notCalculatedResults = false;
            var inputList = new List <IAtomContainer>();

            ////////////////////////////////////////////////////////////////////////////////////////////
            //generate the input molecules. This are molecules without x, y, z coordinates

            string[] smiles = new string[] { "CC", "OCC", "O(C)CCC", "c1ccccc1", "C(=C)=C", "OCC=CCc1ccccc1(C=C)",
                                             "O(CC=C)CCN", "CCCCCCCCCCCCCCC", "OCC=CCO", "NCCCCN" };
            var sp = CDK.SmilesParser;

            IAtomContainer[] atomContainer = new IAtomContainer[smiles.Length];
            for (int i = 0; i < smiles.Length; i++)
            {
                atomContainer[i] = sp.ParseSmiles(smiles[i]);

                inputList.Add(atomContainer[i]);
            }
            ///////////////////////////////////////////////////////////////////////////////////////////
            // Generate 2D coordinates for the input molecules with the Structure Diagram Generator

            StructureDiagramGenerator str;
            List <IAtomContainer>     resultList = new List <IAtomContainer>();

            foreach (var molecule in inputList)
            {
                str = new StructureDiagramGenerator()
                {
                    Molecule = molecule
                };
                str.GenerateCoordinates();
                resultList.Add(str.Molecule);
            }
            inputList = resultList;

            /////////////////////////////////////////////////////////////////////////////////////////////
            // Delete x and y coordinates

            foreach (var molecule in inputList)
            {
                foreach (var atom in molecule.Atoms)
                {
                    atom.Point2D = null;
                }
            }

            ////////////////////////////////////////////////////////////////////////////////////////////////////
            // Test for the method Model3DBuildersWithMM2ForceField
            var builder = CDK.Builder;

            ModelBuilder3D mb3d = ModelBuilder3D.GetInstance();

            for (var i = 0; i < inputList.Count; i++)
            {
                var input = inputList[i];
                {
                    // shallow copy
                    IAtomContainer mol = builder.NewAtomContainer(input);
                    try
                    {
                        mol = mb3d.Generate3DCoordinates(mol, false);
                        foreach (var a in mol.Atoms)
                        {
                            Assert.IsNotNull(a.Point3D, $"{smiles[0]} has unplaced atom");
                        }
                        CheckAverageBondLength(mol);
                    }
                    catch (Exception e)
                    {
                        if (e is CDKException || e is IOException)
                        {
                            Assert.Fail($"3D coordinated could not be generator for {smiles[i]}: {e.StackTrace}");
                        }
                        else
                        {
                            throw;
                        }
                    }
                }
            }
        }
コード例 #17
0
 static TemplateHandlerTest()
 {
     sdg = new StructureDiagramGenerator();
     sp  = CDK.SmilesParser;
 }