void Main()
        {
            IAtomContainer molecule = null;

            #region 1
            StructureResonanceGenerator     sRG   = new StructureResonanceGenerator();
            IChemObjectSet <IAtomContainer> setOf = sRG.GetContainers(molecule);
            #endregion

            #region 2
            molecule.Atoms[0].IsReactiveCenter = true;
            #endregion
        }
Пример #2
0
        /// <summary>
        /// Main method which assigns Gasteiger partial pi charges.
        /// </summary>
        /// <param name="ac">AtomContainer</param>
        /// <param name="setCharge">currently unused</param>
        /// <returns>AtomContainer with partial charges</returns>
        public IAtomContainer AssignGasteigerPiPartialCharges(IAtomContainer ac, bool setCharge)
        {
            // we save the aromaticity flags for the input molecule so that
            // we can add them back before we return
            var oldBondAromaticity = new bool[ac.Bonds.Count];
            var oldAtomAromaticity = new bool[ac.Atoms.Count];

            for (int i = 0; i < ac.Atoms.Count; i++)
            {
                oldAtomAromaticity[i] = ac.Atoms[i].IsAromatic;
            }
            for (int i = 0; i < ac.Bonds.Count; i++)
            {
                oldBondAromaticity[i] = ac.Bonds[i].IsAromatic;
            }

            /* 0: remove charge, and possible flag ac */
            for (int j = 0; j < ac.Atoms.Count; j++)
            {
                ac.Atoms[j].Charge   = 0.0;
                ac.Atoms[j].IsPlaced = false;
            }
            for (int j = 0; j < ac.Bonds.Count; j++)
            {
                ac.Bonds[j].IsPlaced = false;
            }

            /* 1: detect resonance structure */
            var gR1           = new StructureResonanceGenerator(); // according G. should be integrated the breaking bonding
            var reactionList1 = gR1.Reactions.ToList();
            var paramList1    = new List <IParameterReaction>();
            var param         = new SetReactionCenter {
                IsSetParameter = true
            };

            paramList1.Add(param);
            var reactionHCPB = new HeterolyticCleavagePBReaction {
                ParameterList = paramList1
            };

            reactionList1.Add(new SharingAnionReaction());
            foreach (var reaction in reactionList1)
            {
                reaction.ParameterList = paramList1;
            }
            gR1.Reactions = reactionList1;

            // according G. should be integrated the breaking bonding
            var gR2 = new StructureResonanceGenerator {
                MaximalStructures = MaxResonanceStructures
            };
            var reactionList2 = gR2.Reactions.ToList();
            var paramList     = new List <IParameterReaction>();
            var paramA        = new SetReactionCenter {
                IsSetParameter = true
            };

            paramList.Add(paramA);
            reactionList2.Add(new HeterolyticCleavagePBReaction());
            reactionList2.Add(new SharingAnionReaction());
            foreach (var reaction in reactionList2)
            {
                reaction.ParameterList = paramList;
            }
            gR2.Reactions = reactionList2;

            /* find resonance containers, which eliminates the repetitions */
            StructureResonanceGenerator gRN = new StructureResonanceGenerator(); // according G. should be integrated the breaking bonding
            var acSet = gRN.GetContainers(RemovingFlagsAromaticity(ac));

            var iSet = ac.Builder.NewAtomContainerSet();

            iSet.Add(ac);

            if (acSet != null)
            {
                foreach (var container in acSet)
                {
                    ac = SetFlags(container, ac, true);

                    // Aromatic don't break its double bond homolytically
                    if (Aromaticity.CDKLegacy.Apply(ac))
                    {
                        reactionList1.Remove(reactionHCPB);
                    }
                    else
                    {
                        reactionList1.Add(reactionHCPB);
                    }

                    var a = gR1.GetStructures(RemovingFlagsAromaticity(ac));
                    if (a.Count > 1)
                    {
                        for (int j = 1; j < a.Count; j++)
                        { // the first is already added
                            iSet.Add(a[j]);
                        }
                    }
                    ac = SetFlags(container, ac, false);

                    /* processing for bonds which are not in resonance */
                    for (int number = 0; number < ac.Bonds.Count; number++)
                    {
                        IAtomContainer aa = SetAntiFlags(container, ac, number, true);
                        if (aa != null)
                        {
                            var ab = gR2.GetStructures(aa);
                            if (ab.Count > 1)
                            {
                                for (int j = 1; j < ab.Count; j++)
                                { // the first is already added
                                    iSet.Add(ab[j]);
                                }
                            }
                            ac = SetAntiFlags(container, aa, number, false);
                        }
                    }
                }
            }

            /* detect hyperconjugation interactions */
            var setHI = GetHyperconjugationInteractions(ac, iSet);

            if (setHI != null)
            {
                if (setHI.Count != 0)
                {
                    iSet.AddRange(setHI);
                }
                Debug.WriteLine($"setHI: {iSet.Count}");
            }
            if (iSet.Count < 2)
            {
                for (int i = 0; i < ac.Atoms.Count; i++)
                {
                    ac.Atoms[i].IsAromatic = oldAtomAromaticity[i];
                }
                for (int i = 0; i < ac.Bonds.Count; i++)
                {
                    ac.Bonds[i].IsAromatic = oldBondAromaticity[i];
                }
                return(ac);
            }

            /* 2: search whose atoms which don't keep their formal charge and set flags */
            var sumCharges = Arrays.CreateJagged <double>(iSet.Count, ac.Atoms.Count);

            for (int i = 1; i < iSet.Count; i++)
            {
                var iac = iSet[i];
                for (int j = 0; j < iac.Atoms.Count; j++)
                {
                    sumCharges[i][j] = iac.Atoms[j].FormalCharge.Value;
                }
            }

            for (int i = 1; i < iSet.Count; i++)
            {
                var iac   = iSet[i];
                int count = 0;
                for (int j = 0; j < ac.Atoms.Count; j++)
                {
                    if (count < 2)
                    {
                        if (sumCharges[i][j] != ac.Atoms[j].FormalCharge)
                        {
                            ac.Atoms[j].IsPlaced  = true;
                            iac.Atoms[j].IsPlaced = true;
                            count++; /* TODO- error */
                        }
                    }
                }
            }

            /* 3: set sigma charge (PEOE). Initial start point */
            var peoe = new GasteigerMarsiliPartialCharges();;

            peoe.MaxGasteigerIterations = 6;
            IAtomContainer acCloned;

            var gasteigerFactors = AssignPiFactors(iSet);//a,b,c,deoc,chi,q

            /* 4: calculate topological weight factors Wt=fQ*fB*fA */
            var Wt = new double[iSet.Count - 1];

            for (int i = 1; i < iSet.Count; i++)
            {
                Wt[i - 1] = GetTopologicalFactors(iSet[i], ac);
                Debug.WriteLine($", W:{Wt[i - 1]}");
                acCloned = (IAtomContainer)iSet[i].Clone();

                acCloned = peoe.AssignGasteigerMarsiliSigmaPartialCharges(acCloned, true);
                for (int j = 0; j < acCloned.Atoms.Count; j++)
                {
                    if (iSet[i].Atoms[j].IsPlaced)
                    {
                        gasteigerFactors[i][StepSize * j + j + 5] = acCloned.Atoms[j].Charge.Value;
                    }
                }
            }

            // calculate electronegativity for changed atoms and make the difference
            // between whose atoms which change their formal charge
            for (int iter = 0; iter < MaxGasteigerIterations; iter++)
            {
                for (int k = 1; k < iSet.Count; k++)
                {
                    IAtomContainer iac = iSet[k];
                    double[]       electronegativity = new double[2];
                    int            count             = 0;
                    int            atom1             = 0;
                    int            atom2             = 0;
                    for (int j = 0; j < iac.Atoms.Count; j++)
                    {
                        if (count == 2) // The change of sign is product of only two atoms, is not true
                        {
                            break;
                        }
                        if (iac.Atoms[j].IsPlaced)
                        {
                            Debug.WriteLine("Atom: " + j + ", S:" + iac.Atoms[j].Symbol + ", C:"
                                            + iac.Atoms[j].FormalCharge);
                            if (count == 0)
                            {
                                atom1 = j;
                            }
                            else
                            {
                                atom2 = j;
                            }

                            double q1 = gasteigerFactors[k][StepSize * j + j + 5];
                            electronegativity[count] =
                                gasteigerFactors[k][StepSize * j + j + 2] * q1 * q1
                                + gasteigerFactors[k][StepSize * j + j + 1] * q1
                                + gasteigerFactors[k][StepSize * j + j];
                            Debug.WriteLine("e:" + electronegativity[count] + ",q1: " + q1 + ", c:"
                                            + gasteigerFactors[k][StepSize * j + j + 2] + ", b:"
                                            + gasteigerFactors[k][StepSize * j + j + 1] + ", a:"
                                            + gasteigerFactors[k][StepSize * j + j]);
                            count++;
                        }
                    }
                    Debug.WriteLine("Atom1:" + atom1 + ",Atom2:" + atom2);
                    /* difference of electronegativity 1 lower */
                    var    max1 = Math.Max(electronegativity[0], electronegativity[1]);
                    var    min1 = Math.Min(electronegativity[0], electronegativity[1]);
                    double DX   = 1.0;
                    if (electronegativity[0] < electronegativity[1])
                    {
                        DX = gasteigerFactors[k][StepSize * atom1 + atom1 + 3];
                    }
                    else
                    {
                        DX = gasteigerFactors[k][StepSize * atom2 + atom2 + 3];
                    }

                    var Dq = (max1 - min1) / DX;
                    Debug.WriteLine("Dq : " + Dq + " = (" + max1 + "-" + min1 + ")/" + DX);
                    var epN1  = GetElectrostaticPotentialN(iac, atom1, gasteigerFactors[k]);
                    var epN2  = GetElectrostaticPotentialN(iac, atom2, gasteigerFactors[k]);
                    var SumQN = Math.Abs(epN1 - epN2);
                    Debug.WriteLine("sum(" + SumQN + ") = (" + epN1 + ") - (" + epN2 + ")");

                    /* electronic weight */
                    var WE = Dq + fE * SumQN;
                    Debug.WriteLine("WE : " + WE + " = Dq(" + Dq + ")+FE(" + fE + ")*SumQN(" + SumQN);
                    var iTE = iter + 1;

                    /* total topological */
                    var W = WE * Wt[k - 1] * fS / (iTE);
                    Debug.WriteLine("W : " + W + " = WE(" + WE + ")*Wt(" + Wt[k - 1] + ")*FS(" + fS + ")/iter(" + iTE
                                    + "), atoms: " + atom1 + ", " + atom2);

                    /* iac == new structure, ac == old structure */
                    /* atom1 */
                    if (iac.Atoms[atom1].FormalCharge == 0)
                    {
                        if (ac.Atoms[atom1].FormalCharge < 0)
                        {
                            gasteigerFactors[k][StepSize * atom1 + atom1 + 5] = -1 * W;
                        }
                        else
                        {
                            gasteigerFactors[k][StepSize * atom1 + atom1 + 5] = W;
                        }
                    }
                    else if (iac.Atoms[atom1].FormalCharge > 0)
                    {
                        gasteigerFactors[k][StepSize * atom1 + atom1 + 5] = W;
                    }
                    else
                    {
                        gasteigerFactors[k][StepSize * atom1 + atom1 + 5] = -1 * W;
                    }
                    /* atom2 */
                    if (iac.Atoms[atom2].FormalCharge == 0)
                    {
                        if (ac.Atoms[atom2].FormalCharge < 0)
                        {
                            gasteigerFactors[k][StepSize * atom2 + atom2 + 5] = -1 * W;
                        }
                        else
                        {
                            gasteigerFactors[k][StepSize * atom2 + atom2 + 5] = W;
                        }
                    }
                    else if (iac.Atoms[atom2].FormalCharge > 0)
                    {
                        gasteigerFactors[k][StepSize * atom2 + atom2 + 5] = W;
                    }
                    else
                    {
                        gasteigerFactors[k][StepSize * atom2 + atom2 + 5] = -1 * W;
                    }
                }
                for (int k = 1; k < iSet.Count; k++)
                {
                    for (int i = 0; i < ac.Atoms.Count; i++)
                    {
                        if (iSet[k].Atoms[i].IsPlaced)
                        {
                            var    charge  = ac.Atoms[i].Charge.Value;
                            double chargeT = 0.0;
                            chargeT = charge + gasteigerFactors[k][StepSize * i + i + 5];
                            Debug.WriteLine("i<|" + ac.Atoms[i].Symbol + ", " + chargeT + "=c:" + charge + "+g: "
                                            + gasteigerFactors[k][StepSize * i + i + 5]);
                            ac.Atoms[i].Charge = chargeT;
                        }
                    }
                }
            }// iterations
            Debug.WriteLine("final");

            // before getting back we should set back the aromatic flags
            for (int i = 0; i < ac.Atoms.Count; i++)
            {
                ac.Atoms[i].IsAromatic = oldAtomAromaticity[i];
            }
            for (int i = 0; i < ac.Bonds.Count; i++)
            {
                ac.Bonds[i].IsAromatic = oldBondAromaticity[i];
            }

            return(ac);
        }
Пример #3
0
        /// <summary>
        /// calculate the stabilization of orbitals when they contain deficiency of charge.
        /// </summary>
        /// <param name="atomContainer">the molecule to be considered</param>
        /// <param name="atom">IAtom for which effective atom StabilizationCharges factor should be calculated</param>
        /// <returns>stabilizationValue</returns>
        public static double CalculatePositive(IAtomContainer atomContainer, IAtom atom)
        {
            /* restrictions */
            //        if(atomContainer.GetConnectedSingleElectronsCount(atom) > 0 || atom.FormalCharge != 1){
            if (atom.FormalCharge != 1)
            {
                return(0.0);
            }

            // only must be generated all structures which stabilize the atom in question.
            StructureResonanceGenerator gRI = new StructureResonanceGenerator();
            var reactionList = gRI.Reactions.ToList();

            reactionList.Add(new HyperconjugationReaction());
            gRI.Reactions = reactionList;
            var resonanceS = gRI.GetStructures(atomContainer);
            var containerS = gRI.GetContainers(atomContainer);

            if (resonanceS.Count < 2) // meaning it was not find any resonance structure
            {
                return(0.0);
            }

            int positionStart = atomContainer.Atoms.IndexOf(atom);

            var result1   = new List <double>();
            var distance1 = new List <int>();

            resonanceS.RemoveAt(0);// the first is the initial structure
            foreach (var resonance in resonanceS)
            {
                if (resonance.Atoms.Count < 2) // resonance with only one atom donnot have resonance
                {
                    continue;
                }

                ShortestPaths shortestPaths = new ShortestPaths(resonance, resonance.Atoms[positionStart]);

                /* search positive charge */

                PiElectronegativity electronegativity = new PiElectronegativity();

                foreach (var atomP in resonance.Atoms)
                {
                    IAtom atomR = atomContainer.Atoms[resonance.Atoms.IndexOf(atomP)];
                    if (containerS[0].Contains(atomR))
                    {
                        electronegativity.MaxIterations = 6;
                        double result = electronegativity.CalculatePiElectronegativity(resonance, atomP);
                        result1.Add(result);

                        int dis = shortestPaths.GetDistanceTo(atomP);
                        distance1.Add(dis);
                    }
                }
            }
            /* logarithm */
            double value = 0.0;
            double sum   = 0.0;

            var itDist = distance1.GetEnumerator();

            foreach (var ee in result1)
            {
                double suM = ee;
                if (suM < 0)
                {
                    suM = -1 * suM;
                }
                itDist.MoveNext();
                sum += suM * Math.Pow(0.67, itDist.Current);
            }
            value = sum;

            return(value);
        }