public ProtonTotalPartialChargeDescriptor(IAtomContainer container)
{
clonedContainer = (IAtomContainer)container.Clone();
var peoe = new GasteigerMarsiliPartialCharges {
MaxGasteigerIterations = 6
};
peoe.AssignGasteigerMarsiliSigmaPartialCharges(this.clonedContainer, true);
this.container = container;
}
/// <param name="maxIterations">Number of maximum iterations</param>
public PartialSigmaChargeDescriptor(IAtomContainer container, int maxIterations = int.MaxValue)
{
clonedContainer = (IAtomContainer)container.Clone();
var peoe = new GasteigerMarsiliPartialCharges();
if (maxIterations != int.MaxValue)
{
peoe.MaxGasteigerIterations = maxIterations;
}
peoe.AssignGasteigerMarsiliSigmaPartialCharges(clonedContainer, true);
this.container = container;
}
/// <param name="maxIterations">Number of maximum iterations</param>
/// <param name="checkLonePairElectron">Checking lone pair electrons. Default <see langword="true"/></param>
/// <param name="maxResonanceStructures">Number of maximum resonance structures to be searched</param>
public PartialTChargePEOEDescriptor(IAtomContainer container,
int maxIterations = int.MaxValue,
bool checkLonePairElectron = true,
int maxResonanceStructures = int.MaxValue)
{
clonedContainer = (IAtomContainer)container.Clone();
AtomContainerManipulator.PercieveAtomTypesAndConfigureAtoms(clonedContainer);
var pepe = new GasteigerPEPEPartialCharges();
if (checkLonePairElectron)
{
CDK.LonePairElectronChecker.Saturate(clonedContainer);
}
if (maxIterations != int.MaxValue)
{
pepe.MaxGasteigerIterations = maxIterations;
}
if (maxResonanceStructures != int.MaxValue)
{
pepe.MaxResonanceStructures = maxResonanceStructures;
}
var peoe = new GasteigerMarsiliPartialCharges();
peoe.AssignGasteigerMarsiliSigmaPartialCharges(clonedContainer, true);
var peoeAtom = clonedContainer.Atoms.Select(n => n.Charge.Value).ToList();
foreach (var aatom in clonedContainer.Atoms)
{
aatom.Charge = 0;
}
pepe.AssignGasteigerPiPartialCharges(clonedContainer, true);
for (int i = 0; i < clonedContainer.Atoms.Count; i++)
{
var aatom = clonedContainer.Atoms[i];
aatom.Charge = aatom.Charge.Value + peoeAtom[i];
}
this.container = container;
}
private static double[] Listcharges(IAtomContainer container)
{
var natom = container.Atoms.Count;
var charges = new double[natom];
try
{
var mol = container.Builder.NewAtomContainer(((IAtomContainer)container.Clone()));
var peoe = new GasteigerMarsiliPartialCharges();
peoe.AssignGasteigerMarsiliSigmaPartialCharges(mol, true);
for (int i = 0; i < natom; i++)
{
var atom = mol.Atoms[i];
charges[i] = atom.Charge.Value;
}
}
catch (Exception ex1)
{
throw new CDKException($"Problems with assigning Gasteiger-Marsili partial charges due to {ex1.Message}", ex1);
}
return(charges);
}
/// <summary>
/// Evaluates the 29 CPSA descriptors using Gasteiger-Marsilli charges.
/// </summary>
/// <returns>An ArrayList containing 29 elements in the order described above</returns>
public Result Calculate(IAtomContainer container)
{
container = (IAtomContainer)container.Clone();
if (!GeometryUtil.Has3DCoordinates(container))
{
throw new ThreeDRequiredException("Molecule must have 3D coordinates");
}
var peoe = new GasteigerMarsiliPartialCharges();
peoe.AssignGasteigerMarsiliSigmaPartialCharges(container, true);
var surface = new NumericalSurface(container);
surface.CalculateSurface();
var atomSurfaces = surface.GetAllSurfaceAreas();
var totalSA = surface.GetTotalSurfaceArea();
double ppsa1 = 0.0;
double ppsa3 = 0.0;
double pnsa1 = 0.0;
double pnsa3 = 0.0;
double totpcharge = 0.0;
double totncharge = 0.0;
for (int i = 0; i < container.Atoms.Count; i++)
{
if (container.Atoms[i].Charge > 0)
{
ppsa1 += atomSurfaces[i];
ppsa3 += container.Atoms[i].Charge.Value * atomSurfaces[i];
totpcharge += container.Atoms[i].Charge.Value;
}
else
{
pnsa1 += atomSurfaces[i];
pnsa3 += container.Atoms[i].Charge.Value * atomSurfaces[i];
totncharge += container.Atoms[i].Charge.Value;
}
}
var ppsa2 = ppsa1 * totpcharge;
var pnsa2 = pnsa1 * totncharge;
// fractional +ve & -ve SA
var fpsa1 = ppsa1 / totalSA;
var fpsa2 = ppsa2 / totalSA;
var fpsa3 = ppsa3 / totalSA;
var fnsa1 = pnsa1 / totalSA;
var fnsa2 = pnsa2 / totalSA;
var fnsa3 = pnsa3 / totalSA;
// surface wtd +ve & -ve SA
var wpsa1 = ppsa1 * totalSA / 1000;
var wpsa2 = ppsa2 * totalSA / 1000;
var wpsa3 = ppsa3 * totalSA / 1000;
var wnsa1 = pnsa1 * totalSA / 1000;
var wnsa2 = pnsa2 * totalSA / 1000;
var wnsa3 = pnsa3 * totalSA / 1000;
// hydrophobic and poalr surface area
double phobic = 0.0;
double polar = 0.0;
for (int i = 0; i < container.Atoms.Count; i++)
{
if (Math.Abs(container.Atoms[i].Charge.Value) < 0.2)
{
phobic += atomSurfaces[i];
}
else
{
polar += atomSurfaces[i];
}
}
var thsa = phobic;
var tpsa = polar;
var rhsa = phobic / totalSA;
var rpsa = polar / totalSA;
// differential +ve & -ve SA
var dpsa1 = ppsa1 - pnsa1;
var dpsa2 = ppsa2 - pnsa2;
var dpsa3 = ppsa3 - pnsa3;
double maxpcharge = 0.0;
double maxncharge = 0.0;
int pidx = 0;
int nidx = 0;
for (int i = 0; i < container.Atoms.Count; i++)
{
var charge = container.Atoms[i].Charge.Value;
if (charge > maxpcharge)
{
maxpcharge = charge;
pidx = i;
}
if (charge < maxncharge)
{
maxncharge = charge;
nidx = i;
}
}
// relative descriptors
var rpcg = maxpcharge / totpcharge;
var rncg = maxncharge / totncharge;
var rpcs = atomSurfaces[pidx] * rpcg;
var rncs = atomSurfaces[nidx] * rncg;
return(new Result(new double[]
{
ppsa1,
ppsa2,
ppsa3,
pnsa1,
pnsa2,
pnsa3,
dpsa1,
dpsa2,
dpsa3,
fpsa1,
fpsa2,
fpsa3,
fnsa1,
fnsa2,
fnsa3,
wpsa1,
wpsa2,
wpsa3,
wnsa1,
wnsa2,
wnsa3,
rpcg,
rncg,
rpcs,
rncs,
thsa,
tpsa,
rhsa,
rpsa,
}));
}
private static Result CalculateMain(IAtomContainer container, int nhigh, int nlow)
{
var iso = CDK.IsotopeFactory;
int nheavy = 0;
// find number of heavy atoms
nheavy += container.Atoms.Count(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H));
if (nheavy == 0)
{
throw new CDKException("No heavy atoms in the container");
}
var diagvalue = new double[nheavy];
// get atomic mass weighted BCUT
try
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter] = iso.GetMajorIsotope(atom.AtomicNumber).ExactMass.Value;
counter++;
}
}
catch (Exception e)
{
throw new CDKException($"Could not calculate weight: {e.Message}", e);
}
double[] eval1, eval2, eval3;
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval1 = eigenDecomposition.Select(n => n.Real).ToArray();
}
try
{
// get charge weighted BCUT
CDK.LonePairElectronChecker.Saturate(container);
var charges = new double[container.Atoms.Count];
var peoe = new GasteigerMarsiliPartialCharges();
peoe.AssignGasteigerMarsiliSigmaPartialCharges(container, true);
for (int i = 0; i < container.Atoms.Count; i++)
{
charges[i] += container.Atoms[i].Charge.Value;
}
for (int i = 0; i < container.Atoms.Count; i++)
{
container.Atoms[i].Charge = charges[i];
}
}
catch (Exception e)
{
throw new CDKException("Could not calculate partial charges: " + e.Message, e);
}
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter++] = atom.Charge.Value;
}
}
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval2 = eigenDecomposition.Select(n => n.Real).ToArray();
}
var topoDistance = PathTools.ComputeFloydAPSP(AdjacencyMatrix.GetMatrix(container));
// get polarizability weighted BCUT
{
var counter = 0;
foreach (var atom in container.Atoms.Where(atom => !atom.AtomicNumber.Equals(AtomicNumbers.H)))
{
diagvalue[counter++] = Polarizability.CalculateGHEffectiveAtomPolarizability(container, atom, false, topoDistance);
}
}
{
var burdenMatrix = BurdenMatrix.EvalMatrix(container, diagvalue);
if (HasUndefined(burdenMatrix))
{
throw new CDKException("Burden matrix has undefined values");
}
var matrix = Matrix <double> .Build.DenseOfColumnArrays(burdenMatrix);
var eigenDecomposition = matrix.Evd().EigenValues;
eval3 = eigenDecomposition.Select(n => n.Real).ToArray();
}
// return only the n highest & lowest eigenvalues
int lnlow, lnhigh, enlow, enhigh;
if (nlow > nheavy)
{
lnlow = nheavy;
enlow = nlow - nheavy;
}
else
{
lnlow = nlow;
enlow = 0;
}
if (nhigh > nheavy)
{
lnhigh = nheavy;
enhigh = nhigh - nheavy;
}
else
{
lnhigh = nhigh;
enhigh = 0;
}
var retval = new List <double>((lnlow + enlow + lnhigh + enhigh) * 3);
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval1[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval1[eval1.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval2[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval2[eval2.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnlow; i++)
{
retval.Add(eval3[i]);
}
for (int i = 0; i < enlow; i++)
{
retval.Add(double.NaN);
}
for (int i = 0; i < lnhigh; i++)
{
retval.Add(eval3[eval3.Length - i - 1]);
}
for (int i = 0; i < enhigh; i++)
{
retval.Add(double.NaN);
}
return(new Result(retval, nhigh, nlow));
}
