public void TestMapping()
        {
            var type           = new ElectronImpactPDBReaction();
            var setOfReactants = GetExampleReactants();
            var molecule       = setOfReactants[0];

            /* automatic search of the center active */
            var paramList = new List <IParameterReaction>();
            var param     = new SetReactionCenter
            {
                IsSetParameter = false
            };

            paramList.Add(param);
            type.ParameterList = paramList;

            /* initiate */
            var setOfReactions = type.Initiate(setOfReactants, null);

            var product = setOfReactions[0].Products[0];

            Assert.AreEqual(9, setOfReactions[0].Mappings.Count);
            var mappedProductA1 = (IAtom)ReactionManipulator.GetMappedChemObject(setOfReactions[0], molecule.Atoms[0]);

            Assert.AreEqual(mappedProductA1, product.Atoms[0]);
            var mappedProductA2 = (IAtom)ReactionManipulator.GetMappedChemObject(setOfReactions[0], molecule.Atoms[1]);

            Assert.AreEqual(mappedProductA2, product.Atoms[1]);
        }
        public void TestAutomatic_Set_Active_Bond()
        {
            /* ionize all possible double bonds */
            IAtomContainer reactant = builder.NewAtomContainer();//Miles("C=CC")

            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.AddBond(reactant.Atoms[0], reactant.Atoms[1], BondOrder.Double);
            reactant.AddBond(reactant.Atoms[1], reactant.Atoms[2], BondOrder.Single);
            AddExplicitHydrogens(reactant);

            var setOfReactants = ChemObjectBuilder.Instance.NewAtomContainerSet();

            setOfReactants.Add(reactant);

            /* initiate */
            AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactant);
            MakeSureAtomTypesAreRecognized(reactant);

            IReactionProcess type = new ElectronImpactPDBReaction();
            var setOfReactions    = type.Initiate(setOfReactants, null);

            Assert.AreEqual(2, setOfReactions.Count);

            IAtomContainer molecule = setOfReactions[0].Products[0];

            Assert.AreEqual(1, molecule.Atoms[0].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[1]).Count());

            molecule = setOfReactions[1].Products[0];
            Assert.AreEqual(1, molecule.Atoms[1].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[0]).Count());
        }
        public void TestAutomatic_Set_Active_Bond2()
        {
            /* ionize >C=C< , set the reactive center */
            IAtomContainer reactant = builder.NewAtomContainer();//CreateFromSmiles("C=CCC(=O)CC")

            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("O"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.AddBond(reactant.Atoms[0], reactant.Atoms[1], BondOrder.Double);
            reactant.AddBond(reactant.Atoms[1], reactant.Atoms[2], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[2], reactant.Atoms[3], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[3], reactant.Atoms[4], BondOrder.Double);
            reactant.AddBond(reactant.Atoms[3], reactant.Atoms[5], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[5], reactant.Atoms[6], BondOrder.Single);
            AddExplicitHydrogens(reactant);

            var setOfReactants = ChemObjectBuilder.Instance.NewAtomContainerSet();

            setOfReactants.Add(reactant);

            /* initiate */
            AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactant);
            MakeSureAtomTypesAreRecognized(reactant);

            var type      = new ElectronImpactPDBReaction();
            var paramList = new List <IParameterReaction>();
            var param     = new SetReactionCenter
            {
                IsSetParameter = false
            };

            paramList.Add(param);
            type.ParameterList = paramList;
            var setOfReactions = type.Initiate(setOfReactants, null);

            Assert.AreEqual(3, setOfReactions.Count);

            IAtomContainer molecule = setOfReactions[0].Products[0];

            Assert.AreEqual(1, molecule.Atoms[0].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[1]).Count());

            molecule = setOfReactions[1].Products[0];
            Assert.AreEqual(1, molecule.Atoms[1].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[0]).Count());

            Assert.AreEqual(17, setOfReactions[0].Mappings.Count);
        }
        public void TestCDKConstants_REACTIVE_CENTER()
        {
            IReactionProcess type         = new ElectronImpactPDBReaction();
            var            setOfReactants = GetExampleReactants();
            IAtomContainer molecule       = setOfReactants[0];

            /* manually put the reactive center */
            molecule.Atoms[0].IsReactiveCenter = true;
            molecule.Atoms[1].IsReactiveCenter = true;
            molecule.Bonds[0].IsReactiveCenter = true;

            var paramList = new List <IParameterReaction>();
            var param     = new SetReactionCenter
            {
                IsSetParameter = true
            };

            paramList.Add(param);
            type.ParameterList = paramList;

            /* initiate */
            MakeSureAtomTypesAreRecognized(molecule);

            var setOfReactions = type.Initiate(setOfReactants, null);

            Assert.AreEqual(2, setOfReactions.Count);
            Assert.AreEqual(1, setOfReactions[0].Products.Count);

            IAtomContainer reactant = setOfReactions[0].Reactants[0];

            Assert.IsTrue(molecule.Atoms[0].IsReactiveCenter);
            Assert.IsTrue(reactant.Atoms[0].IsReactiveCenter);
            Assert.IsTrue(molecule.Atoms[1].IsReactiveCenter);
            Assert.IsTrue(reactant.Atoms[1].IsReactiveCenter);
            Assert.IsTrue(molecule.Bonds[0].IsReactiveCenter);
            Assert.IsTrue(reactant.Bonds[0].IsReactiveCenter);
        }
        public void TestElectronImpactPDBReaction()
        {
            IReactionProcess type = new ElectronImpactPDBReaction();

            Assert.IsNotNull(type);
        }
        public override void TestInitiate_IAtomContainerSet_IAtomContainerSet()
        {
            /* ionize >C=C< , set the reactive center */
            var reactant = builder.NewAtomContainer();//CreateFromSmiles("C=CCC(=O)CC")

            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("O"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.Atoms.Add(builder.NewAtom("C"));
            reactant.AddBond(reactant.Atoms[0], reactant.Atoms[1], BondOrder.Double);
            reactant.AddBond(reactant.Atoms[1], reactant.Atoms[2], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[2], reactant.Atoms[3], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[3], reactant.Atoms[4], BondOrder.Double);
            reactant.AddBond(reactant.Atoms[3], reactant.Atoms[5], BondOrder.Single);
            reactant.AddBond(reactant.Atoms[5], reactant.Atoms[6], BondOrder.Single);
            AddExplicitHydrogens(reactant);

            foreach (var bond in reactant.Bonds)
            {
                var atom1 = bond.Atoms[0];
                var atom2 = bond.Atoms[1];
                if (bond.Order == BondOrder.Double && atom1.Symbol.Equals("C") && atom2.Symbol.Equals("C"))
                {
                    bond.IsReactiveCenter  = true;
                    atom1.IsReactiveCenter = true;
                    atom2.IsReactiveCenter = true;
                }
            }

            var setOfReactants = CDK.Builder.NewAtomContainerSet();

            setOfReactants.Add(reactant);

            /* initiate */
            AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(reactant);
            MakeSureAtomTypesAreRecognized(reactant);

            var type      = new ElectronImpactPDBReaction();
            var paramList = new List <IParameterReaction>();
            var param     = new SetReactionCenter
            {
                IsSetParameter = true
            };

            paramList.Add(param);
            type.ParameterList = paramList;
            var setOfReactions = type.Initiate(setOfReactants, null);

            Assert.AreEqual(2, setOfReactions.Count);

            var molecule = setOfReactions[0].Products[0];

            Assert.AreEqual(1, molecule.Atoms[0].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[1]).Count());
            Assert.AreEqual(1, molecule.SingleElectrons.Count);

            molecule = setOfReactions[1].Products[0];
            Assert.AreEqual(1, molecule.Atoms[1].FormalCharge.Value);
            Assert.AreEqual(1, molecule.GetConnectedSingleElectrons(molecule.Atoms[0]).Count());
            Assert.AreEqual(1, molecule.SingleElectrons.Count);

            Assert.AreEqual(17, setOfReactions[0].Mappings.Count);
        }