pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-03 21:44:30 +08:00
Code Issues Packages Projects Releases Wiki Activity

Fix/github1262 (#1265)

Browse Source 
* fix for calculation of prinicipal moments of inertia

* fix a typo
update expected values

* PMI and NPR tests working

* cleanup some of the other descriptors and tests

* Test against Moments.py descriptors

* add new tests from Brian

* remove some warnings
This commit is contained in:
Greg Landrum
2017-01-22 05:49:52 +01:00
parent 26f0b648d6
commit b9e8ab4a53
13 changed files with 1404 additions and 899 deletions
Download Patch File Download Diff File Expand all files Collapse all files

96
Code/GraphMol/Descriptors/PBF.cpp
View File

@@ -3,7 +3,7 @@
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
//modification, are permitted provided that the following conditions are
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
@@ -14,7 +14,8 @@
// with the distribution.
// * Neither the name of Institue of Cancer Research.
// nor the names of its contributors may be used to endorse or promote
// products derived from this software without specific prior written permission.
// products derived from this software without specific prior written
// permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
@@ -28,18 +29,23 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// For more information on the Plane of Best Fit please see http://pubs.acs.org/doi/abs/10.1021/ci300293f
// For more information on the Plane of Best Fit please see
// http://pubs.acs.org/doi/abs/10.1021/ci300293f
//
// If this code has been useful to you, please include the reference
// in any work which has made use of it:
// Plane of Best Fit: A Novel Method to Characterize the Three-Dimensionality of Molecules, Nicholas C. Firth, Nathan Brown, and Julian Blagg, Journal of Chemical Information and Modeling 2012 52 (10), 2516-2525
// Plane of Best Fit: A Novel Method to Characterize the Three-Dimensionality
// of Molecules, Nicholas C. Firth, Nathan Brown, and Julian Blagg, Journal of
// Chemical Information and Modeling 2012 52 (10), 2516-2525
//
//
// Created by Nicholas Firth, November 2011
// Modified by Greg Landrum for inclusion in the RDKit distribution November 2012
// Further modified by Greg Landrum for inclusion in the RDKit core September 2016
// Modified by Greg Landrum for inclusion in the RDKit distribution November
// 2012
// Further modified by Greg Landrum for inclusion in the RDKit core September
// 2016
//
#include <GraphMol/RDKitBase.h>
@@ -54,89 +60,93 @@
#include <Eigen/Dense>
namespace RDKit {
namespace Descriptors{
namespace Descriptors {
namespace {
double distanceFromAPlane(const RDGeom::Point3D &pt,const std::vector<double> &plane, double denom){
double numer=0.0;
numer = std::abs(pt.x*plane[0]+pt.y*plane[1]+pt.z*plane[2]+plane[3]);
double distanceFromAPlane(const RDGeom::Point3D &pt,
const std::vector<double> &plane, double denom) {
double numer = 0.0;
numer =
std::abs(pt.x * plane[0] + pt.y * plane[1] + pt.z * plane[2] + plane[3]);
return numer/denom;
return numer / denom;
}
bool getBestFitPlane(const Conformer &conf,
const std::vector<RDGeom::Point3D> &points,
const std::vector<RDGeom::Point3D> &points,
std::vector<double> &plane,
const std::vector<double> *weights) {
PRECONDITION((!weights || weights->size()>=points.size()),"bad weights vector");
PRECONDITION(plane.size()>=4,"bad plane");
RDGeom::Point3D origin(0,0,0);
double wSum=0.0;
PRECONDITION((!weights || weights->size() >= points.size()),
"bad weights vector");
PRECONDITION(plane.size() >= 4, "bad plane");
RDGeom::Point3D origin(0, 0, 0);
double wSum = 0.0;
for(unsigned int i=0;i<points.size();++i){
if(weights){
double w=(*weights)[i];
wSum+=w;
origin+=points[i]*w;
for (unsigned int i = 0; i < points.size(); ++i) {
if (weights) {
double w = (*weights)[i];
wSum += w;
origin += points[i] * w;
} else {
wSum+=1;
origin+=points[i];
wSum += 1;
origin += points[i];
}
}
origin /= wSum;
Eigen::Matrix3d evects;
Eigen::Vector3d evals;
MolTransforms::computePrincipalAxesAndMoments(conf,evects,evals,false,weights);
MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
conf, evects, evals, false, weights);
RDGeom::Point3D normal;
normal.x=evects(0,0);
normal.y=evects(1,0);
normal.z=evects(2,0);
normal.x = evects(0, 0);
normal.y = evects(1, 0);
normal.z = evects(2, 0);
plane[0] = normal.x;
plane[1] = normal.y;
plane[2] = normal.z;
plane[3] = -1*normal.dotProduct(origin);
plane[3] = -1 * normal.dotProduct(origin);
return true;
}
} //end of anonymous namespace
} // end of anonymous namespace
double PBF(const ROMol& mol,int confId){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers")
double PBF(const ROMol &mol, int confId) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers")
unsigned int numAtoms = mol.getNumAtoms();
if(numAtoms<4) return 0;
if (numAtoms < 4) return 0;
const Conformer &conf = mol.getConformer(confId);
if(!conf.is3D()) return 0 ;
if (!conf.is3D()) return 0;
std::vector<RDGeom::Point3D> points;
points.reserve(numAtoms);
for(unsigned int i=0; i<numAtoms; ++i){
for (unsigned int i = 0; i < numAtoms; ++i) {
points.push_back(conf.getAtomPos(i));
}
std::vector<double> plane(4);
if(!getBestFitPlane(conf,points,plane,NULL)){
if (!getBestFitPlane(conf, points, plane, NULL)) {
// the eigenvalue calculation failed, return 0
// FIX: throw an exception here?
return 0.0;
}
double denom=0.0;
for(unsigned int i=0; i<3; ++i){
denom += plane[i]*plane[i];
double denom = 0.0;
for (unsigned int i = 0; i < 3; ++i) {
denom += plane[i] * plane[i];
}
denom = sqrt(denom);
double res=0.0;
for(unsigned int i=0; i<numAtoms; ++i){
res+= distanceFromAPlane(points[i], plane, denom);
double res = 0.0;
for (unsigned int i = 0; i < numAtoms; ++i) {
res += distanceFromAPlane(points[i], plane, denom);
}
res /= numAtoms;
return res;
}
} // end of Descriptors namespace
} // end of RDKit namespace
} // end of Descriptors namespace
} // end of RDKit namespace

276
Code/GraphMol/Descriptors/PMI.cpp
View File

@@ -16,191 +16,217 @@
#include <Eigen/Dense>
namespace RDKit {
namespace Descriptors{
namespace Descriptors {
namespace {
bool getMoments(const ROMol& mol,int confId, bool useAtomicMasses,
double &pm1, double &pm2, double &pm3){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
const char *pn1 = useAtomicMasses ? "_PMI1_mass" : "_PMI1";
const char *pn2 = useAtomicMasses ? "_PMI2_mass" : "_PMI2";
const char *pn3 = useAtomicMasses ? "_PMI3_mass" : "_PMI3";
bool getMoments(const ROMol& mol, int confId, bool useAtomicMasses, double& pm1,
double& pm2, double& pm3) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
const char* pn1 = useAtomicMasses ? "_PMI1_mass" : "_PMI1";
const char* pn2 = useAtomicMasses ? "_PMI2_mass" : "_PMI2";
const char* pn3 = useAtomicMasses ? "_PMI3_mass" : "_PMI3";
if(mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3) ) {
mol.getProp(pn1,pm1);
mol.getProp(pn2,pm2);
mol.getProp(pn3,pm3);
if (mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3)) {
mol.getProp(pn1, pm1);
mol.getProp(pn2, pm2);
mol.getProp(pn3, pm3);
return true;
}
const Conformer &conf=mol.getConformer(confId);
const Conformer& conf = mol.getConformer(confId);
Eigen::Matrix3d axes;
Eigen::Vector3d moments;
bool res;
bool ignoreHs=false;
if(useAtomicMasses){
bool ignoreHs = false;
if (useAtomicMasses) {
std::vector<double> weights;
weights.resize(mol.getNumAtoms());
for(ROMol::ConstAtomIterator cai=mol.beginAtoms();
cai!=mol.endAtoms();++cai){
for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
++cai) {
weights[(*cai)->getIdx()] = (*cai)->getMass();
}
res = MolTransforms::computePrincipalAxesAndMoments(conf,axes,moments,ignoreHs,false,&weights);
res = MolTransforms::computePrincipalAxesAndMoments(
conf, axes, moments, ignoreHs, false, &weights);
} else {
res = MolTransforms::computePrincipalAxesAndMoments(conf,axes,moments,ignoreHs);
res = MolTransforms::computePrincipalAxesAndMoments(conf, axes, moments,
ignoreHs);
}
if(res){
if (res) {
pm1 = moments(0);
pm2 = moments(1);
pm3 = moments(2);
//std::cerr<<" moments: "<<pm1<<" "<<pm2<<" "<<pm3<<std::endl;
mol.setProp(pn1,pm1,true);
mol.setProp(pn2,pm2,true);
mol.setProp(pn3,pm3,true);
mol.setProp(pn1, pm1, true);
mol.setProp(pn2, pm2, true);
mol.setProp(pn3, pm3, true);
}
return res;
}
bool getMomentsFromGyration(const ROMol& mol, int confId, bool useAtomicMasses,
double& pm1, double& pm2, double& pm3) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
const char* pn1 = useAtomicMasses ? "_PMI1_mass_cov" : "_PMI1_cov";
const char* pn2 = useAtomicMasses ? "_PMI2_mass_cov" : "_PMI2_cov";
const char* pn3 = useAtomicMasses ? "_PMI3_mass_cov" : "_PMI3_cov";
if (mol.hasProp(pn1) && mol.hasProp(pn2) && mol.hasProp(pn3)) {
mol.getProp(pn1, pm1);
mol.getProp(pn2, pm2);
mol.getProp(pn3, pm3);
return true;
}
const Conformer& conf = mol.getConformer(confId);
Eigen::Matrix3d axes;
Eigen::Vector3d moments;
bool res;
bool ignoreHs = false;
if (useAtomicMasses) {
std::vector<double> weights;
weights.resize(mol.getNumAtoms());
for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
++cai) {
weights[(*cai)->getIdx()] = (*cai)->getMass();
}
res = MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
conf, axes, moments, ignoreHs, false, &weights);
} else {
res = MolTransforms::computePrincipalAxesAndMomentsFromGyrationMatrix(
conf, axes, moments, ignoreHs);
}
if (res) {
pm1 = moments(0);
pm2 = moments(1);
pm3 = moments(2);
mol.setProp(pn1, pm1, true);
mol.setProp(pn2, pm2, true);
mol.setProp(pn3, pm3, true);
}
return res;
}
} // end of anonymous namespace
} // end of anonymous namespace
double NPR1(const ROMol& mol, int confId, bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double NPR1(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
if(pm3<1e-8) return 0.0;
return pm1/pm3;
if (pm3 < 1e-8) return 0.0;
return pm1 / pm3;
}
double NPR2(const ROMol& mol, int confId, bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double NPR2(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
if(pm3<1e-8) return 0.0;
return pm2/pm3;
if (pm3 < 1e-8) return 0.0;
return pm2 / pm3;
}
double PMI1(const ROMol& mol, int confId, bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double PMI1(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
return pm1;
}
double PMI2(const ROMol& mol, int confId, bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double PMI2(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
return pm2;
}
double PMI3(const ROMol& mol, int confId, bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double PMI3(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
return pm3;
}
double radiusOfGyration(const ROMol& mol,int confId,
bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double radiusOfGyration(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
}
double denom;
if(useAtomicMasses){
denom = 0.0;
for(ROMol::ConstAtomIterator cai = mol.beginAtoms();
cai!=mol.endAtoms();++cai){
denom += (*cai)->getMass();
}
} else {
denom = mol.getNumAtoms();
}
if(denom<1e-8) return 0.0;
if(pm1<1e-4) {
// planar
return sqrt(sqrt(pm2*pm3)/denom);
} else {
return sqrt(2*M_PI*pow(pm1*pm2*pm3,1./3)/denom);
return 0.0; // FIX: throw an exception here?
}
return sqrt(pm1 + pm2 + pm3);
}
double inertialShapeFactor(const ROMol& mol,int confId,
bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double inertialShapeFactor(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
if(pm1<1e-4 || pm3<1e-4) {
if (pm1 < 1e-4 || pm3 < 1e-4) {
// planar or no coordinates
return 0.0;
} else {
return pm2 / (pm1*pm3);
return pm2 / (pm1 * pm3);
}
}
double eccentricity(const ROMol& mol,int confId,
bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
double eccentricity(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMoments(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
return 0.0; // FIX: throw an exception here?
}
if(pm3<1e-4) {
if (pm3 < 1e-4) {
// no coordinates
return 0.0;
} else {
return sqrt(pm3*pm3-pm1*pm1) / pm3;
}
}
double asphericity(const ROMol& mol,int confId,
bool useAtomicMasses){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
}
if(pm3<1e-4) {
// no coordinates
return 0.0;
} else {
return 0.5 * (pow(pm3-pm2,2) + pow(pm3-pm1,2) + pow(pm2-pm1,2))/
(pm1*pm1+pm2*pm2+pm3*pm3);
}
}
double spherocityIndex(const ROMol& mol,int confId){
PRECONDITION(mol.getNumConformers()>=1,"molecule has no conformers");
bool useAtomicMasses=false;
double pm1,pm2,pm3;
if(!getMoments(mol,confId,useAtomicMasses,pm1,pm2,pm3)){
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
}
if(pm3<1e-4) {
// no coordinates
return 0.0;
} else {
return 3. * pm1 / (pm1+pm2+pm3);
return sqrt(pm3 * pm3 - pm1 * pm1) / pm3;
}
}
double asphericity(const ROMol& mol, int confId, bool useAtomicMasses) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
double pm1, pm2, pm3;
if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
}
if (pm3 < 1e-4) {
// no coordinates
return 0.0;
} else {
double denom = pm1 + pm2 + pm3;
} // end of Descriptors namespace
} // end of RDKit namespace
return 0.5 * (pow(pm1 - pm2, 2) + pow(pm1 - pm3, 2) + pow(pm2 - pm3, 2)) /
(denom * denom);
}
}
double spherocityIndex(const ROMol& mol, int confId) {
PRECONDITION(mol.getNumConformers() >= 1, "molecule has no conformers");
bool useAtomicMasses = false;
double pm1, pm2, pm3;
if (!getMomentsFromGyration(mol, confId, useAtomicMasses, pm1, pm2, pm3)) {
// the eigenvector calculation failed
return 0.0; // FIX: throw an exception here?
}
if (pm3 < 1e-4) {
// no coordinates
return 0.0;
} else {
return 3. * pm1 / (pm1 + pm2 + pm3);
}
}
} // end of Descriptors namespace
} // end of RDKit namespace

161
Code/GraphMol/Descriptors/PMI.h
View File

@@ -13,90 +13,97 @@
#ifdef RDK_BUILD_DESCRIPTORS3D
namespace RDKit {
class ROMol;
namespace Descriptors {
//! Normalized principal moments ratio 1 (=I1/I3)
//! from Sauer and Schwarz JCIM 43:987-1003 (2003)
//! https://dx.doi.org/10.1021/ci025599w
double NPR1(const ROMol&, int confId=-1, bool useAtomicMasses=true);
const std::string NPR1Version = "1.0.0";
//! Normalized principal moments ratio 2 (=I2/I3)
//! from Sauer and Schwarz JCIM 43:987-1003 (2003)
//! https://dx.doi.org/10.1021/ci025599w
double NPR2(const ROMol&, int confId=-1, bool useAtomicMasses=true);
const std::string NPR2Version = "1.0.0";
class ROMol;
namespace Descriptors {
//! Normalized principal moments ratio 1 (=I1/I3)
//! from Sauer and Schwarz JCIM 43:987-1003 (2003)
//! https://dx.doi.org/10.1021/ci025599w
double NPR1(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string NPR1Version = "1.0.0";
//! Normalized principal moments ratio 2 (=I2/I3)
//! from Sauer and Schwarz JCIM 43:987-1003 (2003)
//! https://dx.doi.org/10.1021/ci025599w
double NPR2(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string NPR2Version = "1.0.0";
//! First (smallest) principal moment of inertia
double PMI1(const ROMol&, int confId=-1, bool useAtomicMasses=true);
const std::string PMI1Version = "1.0.0";
//! second principal moment of inertia
double PMI2(const ROMol&, int confId=-1, bool useAtomicMasses=true);
const std::string PMI2Version = "1.0.0";
//! Third (largest) principal moment of inertia
double PMI3(const ROMol&, int confId=-1, bool useAtomicMasses=true);
const std::string PMI3Version = "1.0.0";
//! First (smallest) principal moment of inertia
double PMI1(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string PMI1Version = "1.0.0";
//! second principal moment of inertia
double PMI2(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string PMI2Version = "1.0.0";
//! Third (largest) principal moment of inertia
double PMI3(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string PMI3Version = "1.0.0";
/*!
Radius of gyration
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
/*!
Radius of gyration
from G. A. Arteca "Molecular Shape Descriptors"
Reviews in Computational Chemistry vol 9
http://dx.doi.org/10.1002/9780470125861.ch5
Definition:
for planar molecules: sqrt( sqrt(pm3*pm2)/MW )
for nonplanar molecules: sqrt( 2*pi*pow(pm3*pm2*pm1,1/3)/MW )
*/
double radiusOfGyration(const ROMol&,int confId=-1,
bool useAtomicMasses=true);
const std::string radiusOfGyrationVersion = "1.0.0";
/*!
Inertial shape factor
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition (eq: A4):
sqrt(t_1 + t_2 + t_3) where t_i is the ith moment from the gyration matrix
*/
double radiusOfGyration(const ROMol&, int confId = -1,
bool useAtomicMasses = true);
const std::string radiusOfGyrationVersion = "1.0.0";
/*!
Inertial shape factor
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition:
pm2 / (pm1*pm3)
*/
double inertialShapeFactor(const ROMol&,int confId=-1,
bool useAtomicMasses=true);
const std::string inertialShapeFactorVersion = "1.0.0";
/*!
Molecular eccentricity
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition:
pm2 / (pm1*pm3)
*/
double inertialShapeFactor(const ROMol&, int confId = -1,
bool useAtomicMasses = true);
const std::string inertialShapeFactorVersion = "1.0.0";
/*!
Molecular eccentricity
from G. A. Arteca "Molecular Shape Descriptors"
Reviews in Computational Chemistry vol 9
http://dx.doi.org/10.1002/9780470125861.ch5
Definition:
sqrt(pm3**2 -pm1**2) / pm3**2
*/
double eccentricity(const ROMol&,int confId=-1,
bool useAtomicMasses=true);
const std::string eccentricityVersion = "1.0.0";
/*!
molecular asphericity
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition (eq 4):
sqrt(pm_3**2 -pm_1**2) / pm_3**2 where pm_i is the ith moment of inertia
*/
double eccentricity(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string eccentricityVersion = "1.0.0";
/*!
molecular asphericity
from A. Baumgaertner, "Shapes of flexible vesicles"
J. Chem. Phys. 98:7496 (1993)
http://dx.doi.org/10.1063/1.464689
Definition:
0.5 * ((pm3-pm2)**2 + (pm3-pm1)**2 + (pm2-pm1)**2)/(pm1**2+pm2**2+pm3**2)
*/
double asphericity(const ROMol&,int confId=-1,
bool useAtomicMasses=true);
const std::string asphericityVersion = "1.0.0";
/*!
Spherocity index
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition (eq 11):
0.5 * ((t_3-t_2)**2 + (t_3-t_1)**2 + (t_2-t_1)**2)/(t_1+t_2+t_3)**2
where t_i is the ith moment from the gyration matrix
Definition:
3 * pm1 / (pm1+pm2+pm3) where the moments are calculated without weights
*/
double spherocityIndex(const ROMol&,int confId=-1);
const std::string spherocityIndexVersion = "1.0.0";
}
Some explanation of that definition: the text of the paper mentions axes
of inertia, but then the defintion of the radius of gyration in eq.9 clearly
uses the moments of the gyration matrix. The text under equation 11 has the
appropriate inequalities and limits for the moments of gyration, but the
description of the geometry provided corresponds to the moments of inertia.
The definition here corresponds to what Dragon generates and seem logical
*/
double asphericity(const ROMol&, int confId = -1, bool useAtomicMasses = true);
const std::string asphericityVersion = "1.0.0";
/*!
Spherocity index
from Todeschini and Consoni "Descriptors from Molecular Geometry"
Handbook of Chemoinformatics
http://dx.doi.org/10.1002/9783527618279.ch37
Definition:
3 * t_1 / (t_1+t_2+t_3)
where the moments of the gyration matrix are calculated without weights
*/
double spherocityIndex(const ROMol&, int confId = -1);
const std::string spherocityIndexVersion = "1.0.0";
}
}
#endif
#endif

418
Code/GraphMol/Descriptors/test3D.cpp
View File

@@ -13,7 +13,6 @@
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <iostream>
#include <fstream>
@@ -38,148 +37,151 @@
using namespace RDKit;
using namespace RDKit::Descriptors;
bool compare(const std::string &inm,double ref,double val,double tol=1e-3){
if(fabs(ref-val)>.001){
std::cerr<<"value mismatch: "<<inm<<" "<<ref<<" "<<val<<std::endl;
bool compare(const std::string &inm, double ref, double val,
double tol = 1e-3) {
if (fabs(ref - val) > tol) {
std::cerr << "value mismatch: " << inm << " " << ref << " " << val
<< std::endl;
}
return fabs(ref-val)<tol;
return fabs(ref - val) < tol;
}
void testPMI1(){
void testPMI1() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Basic PMI tests." << std::endl;
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
RDKit::SDMolSupplier reader(sdfName,true,false);
std::string fName = pathName+"/Code/GraphMol/Descriptors/test_data/PMI_egfr.out";
RDKit::SDMolSupplier reader(sdfName, true, false);
std::string fName =
pathName + "/Code/GraphMol/Descriptors/test_data/PMI_egfr.out";
std::ifstream instrm(fName.c_str());
int nDone=0;
while(!reader.atEnd()){
RDKit::ROMol *m=reader.next();
int nDone = 0;
while (!reader.atEnd()) {
RDKit::ROMol *m = reader.next();
TEST_ASSERT(m);
RDKit::ROMol mcpy(*m);
std::string nm;
m->getProp("_Name",nm);
m->getProp("_Name", nm);
std::string inm;
instrm>>inm;
TEST_ASSERT(inm==nm);
instrm >> inm;
TEST_ASSERT(inm == nm);
double val;
double pmi1_m,pmi2_m,pmi3_m,pmi1_nom,pmi2_nom,pmi3_nom;
instrm>>pmi1_m;
instrm>>pmi2_m;
instrm>>pmi3_m;
instrm>>pmi1_nom;
instrm>>pmi2_nom;
instrm>>pmi3_nom;
double pmi1_m, pmi2_m, pmi3_m, pmi1_nom, pmi2_nom, pmi3_nom;
instrm >> pmi1_m;
instrm >> pmi2_m;
instrm >> pmi3_m;
instrm >> pmi1_nom;
instrm >> pmi2_nom;
instrm >> pmi3_nom;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(compare(inm,pmi1_m,val));
TEST_ASSERT(compare(inm, pmi1_m, val));
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(compare(inm,pmi2_m,val));
TEST_ASSERT(compare(inm, pmi2_m, val));
val = RDKit::Descriptors::PMI3(*m);
TEST_ASSERT(compare(inm,pmi3_m,val));
TEST_ASSERT(compare(inm, pmi3_m, val));
val = RDKit::Descriptors::PMI1(*m,-1,false);
TEST_ASSERT(compare(inm,pmi1_nom,val));
val = RDKit::Descriptors::PMI2(*m,-1,false);
TEST_ASSERT(compare(inm,pmi2_nom,val));
val = RDKit::Descriptors::PMI3(*m,-1,false);
TEST_ASSERT(compare(inm,pmi3_nom,val));
val = RDKit::Descriptors::PMI1(*m, -1, false);
TEST_ASSERT(compare(inm, pmi1_nom, val));
val = RDKit::Descriptors::PMI2(*m, -1, false);
TEST_ASSERT(compare(inm, pmi2_nom, val));
val = RDKit::Descriptors::PMI3(*m, -1, false);
TEST_ASSERT(compare(inm, pmi3_nom, val));
// now try doing it in the reverse order to make sure caching doesn't
// screw up.
val = RDKit::Descriptors::PMI1(mcpy,-1,false);
TEST_ASSERT(compare(inm,pmi1_nom,val));
val = RDKit::Descriptors::PMI2(mcpy,-1,false);
TEST_ASSERT(compare(inm,pmi2_nom,val));
val = RDKit::Descriptors::PMI3(mcpy,-1,false);
TEST_ASSERT(compare(inm,pmi3_nom,val));
val = RDKit::Descriptors::PMI1(mcpy, -1, false);
TEST_ASSERT(compare(inm, pmi1_nom, val));
val = RDKit::Descriptors::PMI2(mcpy, -1, false);
TEST_ASSERT(compare(inm, pmi2_nom, val));
val = RDKit::Descriptors::PMI3(mcpy, -1, false);
TEST_ASSERT(compare(inm, pmi3_nom, val));
val = RDKit::Descriptors::PMI1(mcpy);
TEST_ASSERT(compare(inm,pmi1_m,val));
TEST_ASSERT(compare(inm, pmi1_m, val));
val = RDKit::Descriptors::PMI2(mcpy);
TEST_ASSERT(compare(inm,pmi2_m,val));
TEST_ASSERT(compare(inm, pmi2_m, val));
val = RDKit::Descriptors::PMI3(mcpy);
TEST_ASSERT(compare(inm,pmi3_m,val));
TEST_ASSERT(compare(inm, pmi3_m, val));
delete m;
++nDone;
}
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void testPMIEdges(){
void testPMIEdges() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " PMI edge cases." << std::endl;
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/linear.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) >= 10);
val = RDKit::Descriptors::PMI3(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(val >= 10);
TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI2(*m) <
1e-2);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) >= 1);
val = RDKit::Descriptors::PMI3(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(val >= 1);
TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI2(*m) <
1e-2);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/planar.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(fabs(val)<1e-4);
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(val>=1e-4);
val = RDKit::Descriptors::PMI3(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(RDKit::Descriptors::PMI2(*m) - RDKit::Descriptors::PMI1(*m) <
1e-2);
TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI1(*m) >
10);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(fabs(val)<1e-4);
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(val>=1e-4);
val = RDKit::Descriptors::PMI3(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(RDKit::Descriptors::PMI2(*m) - RDKit::Descriptors::PMI1(*m) <
1e-2);
TEST_ASSERT(RDKit::Descriptors::PMI3(*m) - RDKit::Descriptors::PMI1(*m) >
1);
delete m;
}
@@ -193,46 +195,86 @@ void testPMIEdges(){
m.addAtom(new RDKit::Atom(6));
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val = RDKit::Descriptors::PMI1(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI2(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI3(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void testPMI2() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " More PMI/NPR tests." << std::endl;
void testNPR1(){
std::string pathName = getenv("RDBASE");
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/pmi.sdf";
RDKit::SDMolSupplier reader(sdfName, true, false);
while (!reader.atEnd()) {
RDKit::ROMol *mnoh = reader.next();
TEST_ASSERT(mnoh);
bool explicitOnly = false, addCoords = true;
RDKit::ROMol *m = MolOps::addHs(*mnoh, explicitOnly, addCoords);
delete mnoh;
double pmi1 = RDKit::Descriptors::PMI1(*m);
double pmi2 = RDKit::Descriptors::PMI2(*m);
double pmi3 = RDKit::Descriptors::PMI3(*m);
double npr1 = RDKit::Descriptors::NPR1(*m);
double npr2 = RDKit::Descriptors::NPR2(*m);
// tolerances are coarse because the reference values come from MOE
// and the placement of Hs is not identical
TEST_ASSERT(compare("pmi1", m->getProp<double>("pmi1"), pmi1, pmi1 / 100));
TEST_ASSERT(compare("pmi2", m->getProp<double>("pmi2"), pmi2, pmi2 / 100));
TEST_ASSERT(compare("pmi3", m->getProp<double>("pmi3"), pmi3, pmi3 / 100));
TEST_ASSERT(compare("npr1", m->getProp<double>("npr1"), npr1, npr1 / 100));
TEST_ASSERT(compare("npr2", m->getProp<double>("npr2"), npr2, npr2 / 100));
delete m;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void testNPR1() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Basic NPR tests." << std::endl;
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
RDKit::SDMolSupplier reader(sdfName,true,false);
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/PBF_egfr.sdf";
RDKit::SDMolSupplier reader(sdfName, true, false);
int nDone=0;
while(!reader.atEnd()){
RDKit::ROMol *m=reader.next();
int nDone = 0;
while (!reader.atEnd()) {
RDKit::ROMol *m = reader.next();
TEST_ASSERT(m);
RDKit::ROMol mcpy(*m);
std::string nm;
m->getProp("_Name",nm);
m->getProp("_Name", nm);
double val;
double pmi1_m,pmi2_m,pmi3_m,pmi1_nom,pmi2_nom,pmi3_nom;
double pmi1_m, pmi2_m, pmi3_m, pmi1_nom, pmi2_nom, pmi3_nom;
pmi1_m = RDKit::Descriptors::PMI1(*m);
pmi2_m = RDKit::Descriptors::PMI2(*m);
pmi3_m = RDKit::Descriptors::PMI3(*m);
pmi1_nom = RDKit::Descriptors::PMI1(*m,-1,false);
pmi2_nom = RDKit::Descriptors::PMI2(*m,-1,false);
pmi3_nom = RDKit::Descriptors::PMI3(*m,-1,false);
pmi1_nom = RDKit::Descriptors::PMI1(*m, -1, false);
pmi2_nom = RDKit::Descriptors::PMI2(*m, -1, false);
pmi3_nom = RDKit::Descriptors::PMI3(*m, -1, false);
val = RDKit::Descriptors::NPR1(*m);
compare(nm,pmi1_m/pmi3_m,val);
compare(nm, pmi1_m / pmi3_m, val);
val = RDKit::Descriptors::NPR2(*m);
compare(nm,pmi2_m/pmi3_m,val);
compare(nm, pmi2_m / pmi3_m, val);
val = RDKit::Descriptors::NPR1(*m, -1, false);
compare(nm, pmi1_nom / pmi3_nom, val);
val = RDKit::Descriptors::NPR2(*m, -1, false);
compare(nm, pmi2_nom / pmi3_nom, val);
delete m;
++nDone;
@@ -240,67 +282,71 @@ void testNPR1(){
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void testNPREdges(){
void testNPREdges() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " NPR edge cases." << std::endl;
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/linear.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val - 1) < 1e-4);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/linear_2atom.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val - 1) < 1e-4);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/planar.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/planar_3atom.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
TEST_ASSERT(val>=1e-4);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
delete m;
}
@@ -314,61 +360,81 @@ void testNPREdges(){
m.addAtom(new RDKit::Atom(6));
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val = RDKit::Descriptors::NPR1(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void test3DEdges(){
void test3DVals() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " 3D descriptors." << std::endl;
std::string rdbase = getenv("RDBASE");
{ // a disc (benzene)
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_1.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::radiusOfGyration(*m);
TEST_ASSERT(fabs(val - 1.511) < 1e-2);
val = RDKit::Descriptors::eccentricity(*m);
TEST_ASSERT(fabs(val - 0.866) < 1e-2);
val = RDKit::Descriptors::asphericity(*m);
TEST_ASSERT(fabs(val - 0.25) < 1e-2);
val = RDKit::Descriptors::spherocityIndex(*m);
TEST_ASSERT(fabs(val) < 1e-2);
delete m;
}
{ // a rod (dimethyl acetylene)
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_2.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::radiusOfGyration(*m);
TEST_ASSERT(fabs(val - 1.686) < 1e-2);
val = RDKit::Descriptors::eccentricity(*m);
TEST_ASSERT(fabs(val - 1.0) < 1e-2);
val = RDKit::Descriptors::asphericity(*m);
TEST_ASSERT(fabs(val - 0.875) < 1e-2);
val = RDKit::Descriptors::spherocityIndex(*m);
// nothing really precise to say here
TEST_ASSERT((0 < val) && (val < 0.25));
delete m;
}
{ // adamantane
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_3.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::radiusOfGyration(*m);
TEST_ASSERT(fabs(val - 1.827) < 1e-2);
val = RDKit::Descriptors::eccentricity(*m);
TEST_ASSERT(fabs(val) < 1e-2);
val = RDKit::Descriptors::asphericity(*m);
TEST_ASSERT(fabs(val) < 1e-2);
val = RDKit::Descriptors::spherocityIndex(*m);
TEST_ASSERT(fabs(val - 1) < 1e-2);
delete m;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void test3DEdges() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " 3D descriptor edge cases." << std::endl;
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/linear.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::radiusOfGyration(*m);
TEST_ASSERT(fabs(val)<1e-2);
val = RDKit::Descriptors::inertialShapeFactor(*m);
TEST_ASSERT(fabs(val)<1e-4);
val = RDKit::Descriptors::eccentricity(*m);
TEST_ASSERT(fabs(1.0-val)<1e-4);
val = RDKit::Descriptors::asphericity(*m);
TEST_ASSERT(fabs(1.0-val)<1e-4);
val = RDKit::Descriptors::spherocityIndex(*m);
TEST_ASSERT(fabs(val)<1e-4);
delete m;
}
{
std::string pathName = getenv("RDBASE");
std::string sdfName = pathName+"/Code/GraphMol/Descriptors/test_data/planar.mol";
RDKit::ROMol *m=MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::radiusOfGyration(*m);
TEST_ASSERT(fabs(val)>1e-2);
val = RDKit::Descriptors::inertialShapeFactor(*m);
TEST_ASSERT(fabs(val)<1e-4);
val = RDKit::Descriptors::eccentricity(*m);
TEST_ASSERT(fabs(1.0-val)<1e-4);
val = RDKit::Descriptors::asphericity(*m);
TEST_ASSERT(fabs(0.5-val)<1e-4);
val = RDKit::Descriptors::spherocityIndex(*m);
TEST_ASSERT(fabs(val)<1e-4);
delete m;
}
{ // octahedron
{ // octahedron
RDKit::RWMol m;
m.addAtom(new RDKit::Atom(1));
m.addAtom(new RDKit::Atom(1));
@@ -377,23 +443,21 @@ void test3DEdges(){
m.addAtom(new RDKit::Atom(1));
m.addAtom(new RDKit::Atom(1));
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
m.getConformer().setAtomPos(0,RDGeom::Point3D(1,0,0));
m.getConformer().setAtomPos(1,RDGeom::Point3D(-1,0,0));
m.getConformer().setAtomPos(2,RDGeom::Point3D(0,1,0));
m.getConformer().setAtomPos(3,RDGeom::Point3D(0,-1,0));
m.getConformer().setAtomPos(4,RDGeom::Point3D(0,0,1));
m.getConformer().setAtomPos(5,RDGeom::Point3D(0,0,-1));
m.getConformer().setAtomPos(0, RDGeom::Point3D(1, 0, 0));
m.getConformer().setAtomPos(1, RDGeom::Point3D(-1, 0, 0));
m.getConformer().setAtomPos(2, RDGeom::Point3D(0, 1, 0));
m.getConformer().setAtomPos(3, RDGeom::Point3D(0, -1, 0));
m.getConformer().setAtomPos(4, RDGeom::Point3D(0, 0, 1));
m.getConformer().setAtomPos(5, RDGeom::Point3D(0, 0, -1));
double val;
val = RDKit::Descriptors::radiusOfGyration(m);
TEST_ASSERT(fabs(val)>0.1);
val = RDKit::Descriptors::inertialShapeFactor(m);
TEST_ASSERT(fabs(val)>1);
TEST_ASSERT(fabs(val) > 0.1);
val = RDKit::Descriptors::eccentricity(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::asphericity(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::spherocityIndex(m);
TEST_ASSERT(fabs(1.-val)<1e-4);
TEST_ASSERT(fabs(1. - val) < 1e-4);
}
{
@@ -407,31 +471,33 @@ void test3DEdges(){
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val;
val = RDKit::Descriptors::radiusOfGyration(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::inertialShapeFactor(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::eccentricity(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::asphericity(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::spherocityIndex(m);
TEST_ASSERT(fabs(val)<1e-4);
TEST_ASSERT(fabs(val) < 1e-4);
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//
//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
int main() {
RDLog::InitLogs();
test3DEdges();
testPMI1();
testPMI2();
#if 1
testNPR1();
testPMIEdges();
testNPREdges();
testPMI1();
testNPR1();
test3DVals();
test3DEdges();
#endif
}

730
Code/GraphMol/Descriptors/test_data/PMI_egfr.out
View File

@@ -1,365 +1,365 @@
ZINC02640583 3.0801 29.7186 611.2271 0.2847 2.6912 9.5101
ZINC03815185 3.5346 27.0039 504.3305 0.2063 2.4595 10.6998
ZINC00020644 2.6425 26.9142 503.4538 0.3094 3.1402 11.4473
ZINC03815359 1.8104 25.1140 127.0568 0.2941 3.0868 11.3061
ZINC03815360 1.0117 22.1038 144.9868 0.2901 3.0698 11.3354
ZINC03815361 1.6029 25.6052 108.9653 0.3842 3.4720 12.5140
ZINC00007282 2.4846 27.5291 203.4813 0.3024 3.1157 11.3806
ZINC03815304 2.0897 26.3651 127.5708 0.3342 3.1706 12.1041
ZINC03815353 22.4564 31.4503 114.5407 1.5892 3.8362 6.5291
ZINC00118570 1.3943 18.6414 97.7103 0.2724 2.5262 10.8296
ZINC03815331 1.5327 19.4748 96.5107 0.2958 2.3868 11.1637
ZINC00151213 3.5669 25.5232 465.3378 0.3141 2.6207 10.9890
ZINC00151212 2.7213 20.9339 122.5810 0.2925 2.5390 10.8807
ZINC03815388 1.4185 25.7575 101.6433 0.2919 3.0555 11.2252
ZINC00104621 2.1731 20.0218 108.5350 0.3994 2.8232 12.3101
ZINC03815229 3.7147 25.0157 530.7980 0.3149 2.3985 10.8691
ZINC03815317 4.7456 27.7210 86.8434 1.0672 2.9782 9.0980
ZINC03815247 3.0364 25.4102 475.4405 0.2810 2.7007 10.2004
ZINC03815375 4.3305 25.9187 462.6263 0.3794 2.5321 10.4342
ZINC03815227 2.4708 27.4159 506.8760 0.1898 2.7792 10.9349
ZINC03815274 1.3270 19.2506 115.7583 0.2608 2.4849 12.7037
ZINC00151214 3.1339 23.2410 736.2225 0.3134 2.6437 11.0079
ZINC03815386 11.3526 21.0966 450.7802 1.0822 1.8197 11.0230
ZINC00118581 3.5709 24.8304 192.6177 0.3042 2.5827 10.9386
ZINC03815055 3.6817 22.4606 836.7797 0.3022 2.5782 12.9045
ZINC03815319 6.8681 21.5220 786.1869 1.1329 2.5498 10.1492
ZINC03815146 4.2130 24.4087 535.5866 0.3000 2.5448 12.1103
ZINC03815314 3.4217 57.8741 195.3103 0.8959 2.4918 10.6726
ZINC03815398 9.8121 19.1927 130.6622 1.1623 2.3410 10.5614
ZINC00104782 2.8524 20.2475 126.8371 0.4116 2.5932 14.0443
ZINC03815197 3.5442 33.3375 596.9038 0.3190 2.3997 10.9896
ZINC03815196 0.9500 31.5306 104.8934 0.2136 3.7684 12.1287
ZINC03815276 0.8812 28.6923 488.0190 0.1132 3.2365 10.4524
ZINC03815251 1.2764 31.0311 111.9996 0.3030 3.2794 13.0827
ZINC03815264 3.1097 80.2402 538.0409 0.1941 2.9195 10.2118
ZINC03815202 1.5646 29.5527 108.0422 0.3081 3.6911 11.4435
ZINC03815203 3.2105 80.9649 537.2133 0.1955 2.9232 10.9743
ZINC03815236 7.4008 32.6996 640.1130 0.2871 2.8416 10.2324
ZINC03815238 5.9469 19.6415 123.0272 1.2927 2.1975 12.8994
ZINC03815259 6.5526 19.6214 134.2680 1.0983 2.2664 12.1194
ZINC03815280 1.2901 20.9120 134.0537 0.3059 2.6942 14.3518
ZINC03815242 2.9597 42.3757 516.1766 0.1932 2.8317 10.9630
ZINC03813425 18.7624 24.8798 430.3084 1.2052 2.6203 10.7186
ZINC03815036 6.3566 26.1594 500.9108 0.4079 2.9438 11.1178
ZINC03815410 9.5123 34.3412 435.7890 1.3063 2.2656 10.6805
ZINC03815046 3.4430 27.7518 232.1838 0.2926 2.5460 12.8244
ZINC03815035 7.1132 31.7527 473.7552 1.0026 3.3258 8.9279
ZINC03815034 5.1396 26.0410 505.2368 0.3417 3.1100 11.4212
ZINC03815282 4.9038 26.9602 534.2950 0.2822 2.7599 10.2037
ZINC03815281 8.0616 23.6308 192.6667 1.1237 2.5178 10.1027
ZINC03813430 4.2604 16.9351 664.1676 1.1521 2.3330 10.7735
ZINC03813429 7.1823 23.3050 471.7129 1.1109 2.5517 10.1191
ZINC03815072 3.5378 28.6953 572.3357 0.3057 2.5823 12.8792
ZINC03815374 5.6247 25.1217 544.0283 0.3872 2.5267 10.5518
ZINC03815124 6.5917 25.7393 101.8343 1.2222 2.8406 10.6321
ZINC03815338 1.4839 50.9005 154.0863 0.2677 3.1516 11.2912
ZINC03815176 6.8769 21.2675 105.6047 1.1141 2.6949 11.6898
ZINC03815111 2.7953 20.3991 144.1591 0.2805 2.4905 12.7653
ZINC03815343 3.5817 27.6171 502.3218 0.3182 2.6709 12.0961
ZINC03815100 2.7732 35.8476 511.2191 0.2145 3.4303 10.4710
ZINC03815101 3.1339 33.8291 519.3260 0.2207 3.3136 10.7558
ZINC00020362 2.1102 27.7997 558.8167 0.2278 3.7932 12.7160
ZINC03815232 3.5758 35.1689 612.7364 0.3558 2.8298 14.2766
ZINC03815097 5.5374 22.8310 132.5972 1.2396 2.6567 14.3703
ZINC03815163 3.5541 36.5281 611.3909 0.3424 2.7223 14.0004
ZINC03815162 4.7922 23.3951 580.5819 0.3342 2.6870 15.2283
ZINC03815029 7.8113 25.9661 544.6238 0.4435 3.0929 13.3585
ZINC03815037 10.2974 39.3217 474.5641 1.0851 2.7762 12.9196
ZINC03815038 5.5841 25.5238 572.6742 0.3433 2.8106 12.2288
ZINC03815411 2.5146 31.1824 499.8055 0.2824 4.0495 10.0688
ZINC03815159 7.0094 26.0184 718.8113 0.3583 3.0882 11.6707
ZINC03815042 16.4190 29.2867 186.3169 1.3125 2.9108 11.2554
ZINC03815286 3.4618 29.1038 553.9148 0.3440 2.4411 14.7767
ZINC03815284 4.6689 22.7489 137.4907 0.9164 2.5940 13.2093
ZINC03815144 3.4415 42.5563 497.5603 0.2752 4.3367 10.1968
ZINC03815183 5.6638 26.5895 558.9469 0.3478 3.3013 13.3264
ZINC03813424 12.4792 42.1919 374.8405 1.2435 3.3846 10.0882
ZINC03815137 1.6807 27.5790 570.0587 0.2084 3.6576 12.5302
ZINC02391776 5.0387 25.2263 557.8216 0.2980 2.9663 12.9163
ZINC03815060 2.5896 30.7132 115.0409 0.7579 3.8403 12.3040
ZINC03815140 6.1703 26.1022 551.1329 0.3726 3.4001 13.2952
ZINC03815138 2.8040 30.2756 543.3491 0.2774 4.0754 10.2394
ZINC03815143 1.4857 34.7568 112.7672 0.3168 4.4257 12.9706
ZINC03815070 3.3029 41.3331 528.8407 0.2611 3.6458 12.6528
ZINC03815320 4.9713 24.7335 576.1407 0.3773 2.2603 14.9528
ZINC03815069 2.9482 43.3994 516.7938 0.2430 3.9372 12.2239
ZINC03815332 5.0034 23.5154 587.2414 0.3513 2.7293 14.5762
ZINC03815248 5.7710 23.7532 571.6996 0.3932 2.4591 15.2311
ZINC03815373 4.4864 27.7421 129.7568 1.0674 2.7498 12.2562
ZINC03815118 4.5082 26.3356 569.7949 0.3130 3.3222 13.0392
ZINC03815117 7.1946 26.3622 553.6425 0.4123 3.0062 13.3551
ZINC03815121 7.0742 26.7588 112.9301 1.1551 3.1477 12.6333
ZINC03815335 3.7328 33.6183 589.9957 0.3539 2.6613 12.4590
ZINC03815266 6.3488 28.1951 571.8773 0.4569 3.8583 12.9199
ZINC03815125 11.1157 40.7042 499.0718 1.1156 3.0374 13.1889
ZINC03815328 5.5587 23.9645 613.2192 0.3986 2.5157 16.8191
ZINC03815136 4.8401 25.2081 612.8020 0.3076 2.8507 15.0085
ZINC03815141 1.5488 39.2165 109.6781 0.3713 4.8364 12.4659
ZINC03815033 11.2350 37.9837 510.7523 1.3083 2.5817 13.9836
ZINC00116727 1.3089 30.5193 133.0445 0.3622 3.7455 13.8781
ZINC03815406 5.4578 24.0424 653.6700 0.3084 2.5772 13.0944
ZINC00020363 3.4623 46.7596 502.0294 0.3141 4.3844 11.9000
ZINC02391785 5.0105 25.3307 604.2828 0.3152 2.8201 15.3885
ZINC03815357 5.0139 22.5943 1049.6983 0.3083 2.5978 13.1133
ZINC03815080 2.6300 30.1491 577.3952 0.2791 3.9216 12.4809
ZINC03813428 6.5965 30.4845 139.8075 1.0080 2.8166 10.4313
ZINC03815079 1.8462 29.7959 581.5337 0.2676 4.2337 12.0581
ZINC00118594 6.0893 23.8840 178.3182 0.4557 2.8277 12.3621
ZINC03815027 8.0274 28.0719 565.2599 0.4964 3.5218 13.1176
ZINC03813434 14.4810 23.7280 520.9077 1.5172 3.3488 9.8543
ZINC03815393 4.6892 22.8388 288.7785 0.2980 2.5462 13.0388
ZINC03815187 5.0253 23.0719 625.5046 0.4233 2.5830 16.8409
ZINC03815190 5.3210 22.3494 647.8644 0.3506 2.5408 18.4990
ZINC00600292 6.4530 28.4804 625.4717 0.4100 3.8000 14.0629
ZINC03815041 11.8605 73.9987 322.5237 0.9413 5.2055 10.3637
ZINC03815212 8.8923 33.1139 747.5921 0.3780 3.2331 11.6714
ZINC03815031 5.1866 40.5240 627.7386 0.4369 3.7199 14.1492
ZINC03815045 10.1069 50.4763 569.8905 1.0494 2.8241 15.9884
ZINC03815292 5.7751 23.9366 645.6246 0.6013 2.6564 16.3881
ZINC00601499 3.4471 46.5413 690.0197 0.3127 2.5625 18.7055
ZINC03815206 17.7468 24.9949 232.9904 0.9076 3.3410 14.0250
ZINC01386818 3.1049 29.6024 167.4622 0.3824 3.7508 13.9432
ZINC00009851 1.2140 29.3054 169.1254 0.3507 3.6563 15.1321
ZINC03815362 6.8357 26.1451 177.2097 0.5087 3.0831 12.8835
ZINC03815129 5.8055 26.8880 198.6478 0.4353 2.8540 14.2617
ZINC03815235 5.1047 22.8230 707.2976 0.2965 2.5575 18.5659
ZINC03815075 6.0943 25.9850 1035.0296 0.4113 3.8149 14.0796
ZINC03813431 7.7723 21.4937 161.0004 1.2183 2.3987 10.3999
ZINC01386782 1.0718 24.6132 814.5218 0.3754 3.7305 14.2649
ZINC03815283 1.8783 68.5815 216.0656 0.2658 4.0103 13.4086
ZINC03815250 4.7524 50.9325 598.4512 0.3356 3.1403 13.0025
ZINC00116937 5.2109 29.9543 257.2815 0.3972 3.7772 14.0068
ZINC03815334 5.1741 42.2025 563.2728 0.8533 3.9754 8.9349
ZINC03815199 5.1639 49.0140 641.8840 0.3789 2.9752 14.9801
ZINC03815088 3.5546 42.4396 183.6829 0.6418 4.1454 12.4633
ZINC03815348 5.1727 48.2280 621.3441 0.3956 4.8418 13.3696
ZINC03815258 7.0133 31.7568 657.1921 0.3380 2.9732 15.4485
ZINC03815102 8.9388 63.4228 538.8212 1.1188 2.7663 13.7083
ZINC03815043 25.0952 50.2335 389.0591 1.7972 4.1328 10.0899
ZINC03815032 7.6033 95.9321 772.3180 0.4284 3.7990 14.4211
ZINC03815050 14.9990 20.7526 632.7411 1.2799 2.6671 12.5946
ZINC03815273 27.5889 39.7376 138.8623 1.6989 4.0846 9.0136
ZINC03815119 10.1368 58.0929 576.5039 0.9952 3.0750 17.2075
ZINC03815189 5.1577 42.6487 638.8627 0.2955 5.6578 13.0756
ZINC03815278 8.5414 268.3438 589.2431 0.4625 3.8724 14.2194
ZINC03815290 28.9735 40.0839 365.6048 1.7689 4.0755 9.0242
ZINC00016978 5.0420 39.1153 270.7927 0.4096 3.7759 14.0965
ZINC03815316 1.3327 28.0887 188.7900 0.3841 3.4433 18.7025
ZINC03815384 5.1845 51.2045 128.9776 1.0030 4.5295 10.3356
ZINC03815228 3.2494 90.6087 576.7578 0.4820 4.3946 20.6088
ZINC03815397 5.0651 49.9130 114.5828 0.9746 4.3531 11.9137
ZINC03815077 10.4934 65.3349 661.0210 1.0205 3.0973 19.9972
ZINC03815300 5.0890 46.7589 586.3476 1.0130 4.5230 10.5636
ZINC02572485 6.8628 33.4591 692.4366 0.4412 4.9258 16.5024
ZINC03815298 5.3244 51.4114 216.6748 1.0067 4.5250 10.4633
ZINC03815059 10.1878 32.0558 549.1714 1.1216 3.3850 11.1458
ZINC03815201 11.7720 48.0025 643.7280 1.3005 2.7187 15.3792
ZINC03815066 3.4766 30.9659 641.1929 0.6743 3.9489 13.4434
ZINC04617768 8.6760 67.9287 621.7433 1.0340 5.3267 13.1296
ZINC03815198 11.6066 67.4490 459.0621 1.4671 3.4840 13.8034
ZINC04617774 12.6494 61.1252 658.0457 1.1400 3.2862 19.2287
ZINC03815064 10.1283 79.2554 624.6928 1.0474 3.1725 17.0695
ZINC03815087 18.9520 72.0885 420.1266 1.5698 4.4108 15.5795
ZINC03815040 17.3314 32.5240 707.5437 1.5183 2.7986 16.1127
ZINC03815049 18.1326 59.2002 640.6690 1.1542 4.0374 14.8740
ZINC03815243 10.1384 46.9636 660.6019 1.2224 2.4310 21.7915
ZINC03815026 8.4057 32.9998 686.1989 0.4840 4.8661 16.4617
ZINC03815051 10.2879 80.4456 716.7764 1.0402 3.2461 20.1464
ZINC03815044 6.9659 28.9251 226.2914 0.5690 3.7689 15.8035
ZINC03815272 5.5967 39.9321 171.3677 0.8647 4.9454 16.4149
ZINC03815172 26.7937 40.6152 336.6267 2.1750 4.1399 8.2329
ZINC03815191 10.0633 48.2445 670.5817 1.3106 2.7416 17.9523
ZINC03815063 10.9189 39.6704 743.9648 1.3868 2.4263 17.7814
ZINC03815387 5.6889 50.9814 201.3199 0.9651 4.3649 14.5884
ZINC03815218 7.0820 35.9712 733.3688 0.3306 2.8309 18.3261
ZINC03815090 19.7839 77.6511 467.7188 1.6859 4.4004 18.4313
ZINC04617771 17.1171 48.4474 625.1706 1.6276 4.2819 12.2556
ZINC03815333 4.1446 32.7890 199.0960 0.7959 4.1617 18.4942
ZINC03815237 10.6361 33.4368 685.4242 1.5639 2.5381 19.1085
ZINC04617779 14.4174 62.2481 649.4801 1.1278 3.6075 18.2912
ZINC03815175 10.1310 68.7005 706.1378 0.9809 3.1832 26.9274
ZINC03815096 10.9179 98.1941 784.2749 1.0547 3.1537 19.5993
ZINC03815358 9.4563 51.2077 223.5663 1.0307 4.5086 10.5775
ZINC03815126 12.6741 46.6525 580.5334 1.3896 4.8042 11.1996
ZINC03815404 6.2636 48.5285 160.8552 1.0206 4.3249 12.1151
ZINC03815401 6.0202 49.0115 138.2635 1.2090 3.9598 15.6957
ZINC03815108 19.7928 89.4520 510.4963 1.6559 4.4956 22.1028
ZINC03815154 8.5515 50.9919 220.2240 1.4478 5.3911 23.8441
ZINC04617776 16.8569 73.4008 500.5637 1.5173 4.2482 17.6645
ZINC03815165 9.8842 80.4098 757.5846 1.1402 3.1925 30.8502
ZINC03815352 6.1882 37.5056 202.4066 1.0123 4.9215 17.9755
ZINC03815173 9.9671 84.1533 844.1115 1.1300 3.1735 35.6162
ZINC03815367 3.7204 20.8477 115.6583 0.8692 2.5065 11.7555
ZINC00109589 3.7365 20.3118 117.7157 0.8414 2.5224 11.6897
ZINC03815364 2.1082 25.2357 129.6789 0.7184 2.9211 13.3238
ZINC03815303 3.3197 30.2207 143.0733 0.7905 3.5294 14.0423
ZINC03815312 4.6663 26.2188 128.5059 0.9534 2.9945 12.6011
ZINC03815256 3.3196 40.1055 117.5422 0.7905 4.1353 12.5742
ZINC03815253 3.1300 39.9078 128.2590 0.7683 4.2580 11.2027
ZINC03815365 2.7586 33.1221 146.1594 0.6777 2.8993 15.6981
ZINC01386812 2.9878 38.1877 139.4571 0.7502 3.8600 14.2523
ZINC00020368 3.0025 38.8146 167.1622 0.7476 3.4624 18.1227
ZINC03815297 5.0136 38.7230 147.4924 1.0990 3.9138 15.2838
ZINC03815342 7.9308 34.9951 296.0252 0.5576 3.9477 14.9707
ZINC03815083 4.8329 30.8296 121.1423 0.8896 3.1801 12.6484
ZINC03815293 3.8447 26.2998 200.3378 0.3545 2.4555 10.5381
ZINC03815310 3.6734 22.8856 248.1496 0.3463 2.3153 12.6938
ZINC03815326 1.1329 32.6789 102.4499 0.3862 3.5898 11.7287
ZINC03815341 1.6202 31.8066 125.2812 0.4027 3.6021 12.3618
ZINC03815394 1.8097 35.1363 110.9254 0.4926 4.0723 12.8623
ZINC03815277 1.0882 31.5182 121.3087 0.3962 3.4607 14.8127
ZINC03815156 3.1987 41.4774 210.3355 0.2294 3.7454 11.7341
ZINC03815244 3.7273 40.3201 536.3376 0.4251 3.7097 11.8245
ZINC00020645 3.3757 41.4557 207.2809 0.4139 3.6656 11.7980
ZINC03815402 2.1971 30.1382 140.3313 0.4788 3.2836 15.9760
ZINC03815336 5.3912 29.9273 190.4203 0.5290 3.4361 14.0346
ZINC00023489 5.0716 26.6857 239.7284 0.3568 2.2470 12.6165
ZINC00007342 4.9491 26.1897 241.2471 0.3523 2.4375 12.3370
ZINC03815231 5.2649 29.1528 244.6185 0.4081 3.4741 12.8216
ZINC03815295 5.3535 32.9404 235.2480 0.4300 4.6180 11.7766
ZINC03815257 11.4317 65.1123 211.5339 0.9100 8.0938 10.5132
ZINC03815345 43.7078 55.8307 111.9607 1.2444 4.8666 13.3694
ZINC03815368 9.1237 56.8264 111.3380 1.9022 6.1794 11.3024
ZINC03815234 4.6754 37.1159 725.9089 0.2029 2.3887 13.7775
ZINC03815200 5.8322 24.3840 609.1183 0.3530 2.9162 13.2483
ZINC00006271 3.5197 39.3555 588.1213 0.2736 3.2072 13.3058
ZINC04617767 3.5211 40.6218 591.2611 0.2690 2.9648 13.3686
ZINC03815028 3.5631 39.7689 597.4111 0.2874 3.1899 12.7811
ZINC03815058 3.5631 41.2116 594.9623 0.2847 3.0907 12.6742
ZINC03815241 6.9353 29.2591 686.9333 0.2770 2.9295 13.1268
ZINC03815054 3.6324 40.5229 600.5043 0.2943 2.9800 12.9320
ZINC03815030 3.9729 44.3145 593.5970 0.3302 3.9805 12.7784
ZINC02391775 3.4971 40.5637 632.3835 0.2946 2.7359 16.0586
ZINC03815052 3.5312 45.7016 623.3138 0.3145 3.3649 15.6107
ZINC03815057 3.5137 41.2529 635.6484 0.3084 2.8509 15.5605
ZINC03815073 3.4769 39.5957 629.0278 0.2988 2.9828 15.7822
ZINC03815249 4.4642 37.4292 786.9165 0.3491 2.8892 16.8465
ZINC03815152 6.3754 50.1263 773.4424 0.4246 2.8779 17.6617
ZINC03815116 10.2732 57.1923 592.9763 0.9765 5.3867 12.6602
ZINC04617775 8.5118 45.8693 837.5017 0.7471 2.5394 22.1642
ZINC03815233 4.1159 43.5508 866.3574 0.6990 2.2832 26.6272
ZINC04617795 11.2368 44.3426 830.5891 0.7992 2.4988 21.7562
ZINC03815239 9.7538 38.9849 816.7974 0.9275 2.6764 23.2574
ZINC03815188 4.9047 41.3271 861.0376 0.5784 2.6374 21.9216
ZINC03815095 11.5909 72.9028 595.7968 1.0433 5.9156 14.3936
ZINC03815103 5.7037 41.2345 859.4428 0.6008 2.6113 22.3030
ZINC03815209 10.0250 39.0470 820.4473 0.9199 2.4281 23.8348
ZINC03815306 3.6654 73.6123 917.5873 0.6740 2.4860 25.1269
ZINC03815208 15.9182 38.0292 857.6401 1.1585 2.9640 24.5676
ZINC03815067 9.3763 94.3488 643.0497 0.9700 5.2165 14.5574
ZINC03815382 2.6787 27.9037 266.2927 0.1833 2.4184 15.9431
ZINC03815179 0.8838 25.7209 154.1975 0.1649 2.4712 18.1955
ZINC03815112 1.6196 26.7291 166.7907 0.2727 2.8606 20.0135
ZINC03815061 3.3094 26.2862 694.8298 0.1908 2.7148 18.3053
ZINC03815048 3.6935 36.4904 700.7639 0.2021 2.5644 18.3870
ZINC03815120 3.3962 42.0325 655.2896 0.2210 3.2213 16.3673
ZINC03815084 3.8778 39.7831 760.9846 0.1968 2.7747 18.3280
ZINC03815255 0.8447 26.5099 206.3294 0.1670 2.4985 18.4192
ZINC03815186 1.6331 26.8434 221.0006 0.2767 2.8771 20.2495
ZINC03815245 5.4097 31.7544 254.4987 0.3219 2.8574 20.0847
ZINC03815322 3.0956 25.9268 596.5974 0.2548 2.5420 13.8272
ZINC03815301 3.0173 29.8481 147.7305 0.7671 2.9174 16.5918
ZINC00327021 3.2051 26.8219 144.7914 0.7453 3.0347 15.2074
ZINC03815356 3.5888 31.5972 143.5607 0.8376 3.3426 15.6307
ZINC03815340 3.7911 28.6080 139.1194 0.8464 3.4364 14.3505
ZINC04617812 3.5889 31.5977 143.5603 0.8376 3.3427 15.6306
ZINC04617811 3.7911 28.6083 139.1179 0.8464 3.4364 14.3505
ZINC03815093 8.2533 28.1672 510.3932 0.4821 3.5697 10.7614
ZINC03815222 8.9358 28.0526 511.6620 0.5122 3.4185 10.3199
ZINC00006798 2.3677 42.4380 98.4375 0.5040 4.4545 11.6118
ZINC01609260 3.6979 37.2983 104.9882 0.8250 3.7575 11.9570
ZINC03815377 10.0965 33.9829 208.2650 0.8682 3.7776 12.0735
ZINC03815366 5.4417 47.6948 121.4649 1.0012 4.5269 13.2945
ZINC03815351 6.0836 43.7940 128.4898 1.0325 4.3437 14.3436
ZINC03815376 3.3655 39.0079 153.8446 0.7782 3.7324 16.0630
ZINC01609268 3.6361 37.4272 148.2598 0.8166 3.6287 15.8635
ZINC03815391 8.7545 57.4848 138.6225 1.2893 5.2439 15.3639
ZINC03815323 9.1271 53.6217 232.3228 1.2581 4.9640 25.0817
ZINC03815390 5.7245 68.0927 216.2764 1.0311 6.6152 20.2510
ZINC03815324 6.5756 55.0430 292.4884 1.0679 5.0585 30.5805
ZINC03815025 5.0519 24.5424 626.7561 0.2695 3.2551 14.6625
ZINC03815106 4.9734 24.9114 633.5179 0.2660 3.1458 14.1277
ZINC04617810 1.5505 22.6508 189.6155 0.3538 2.7794 18.7675
ZINC04617809 1.5505 22.6510 189.6149 0.3538 2.7794 18.7674
ZINC03815339 3.2586 46.1171 116.4939 0.7890 4.4371 12.3275
ZINC04617808 3.2586 46.1168 116.4952 0.7890 4.4370 12.3275
ZINC04617792 3.3520 50.1757 106.2983 0.8104 5.0634 10.8026
ZINC04617793 1.4793 27.0467 188.5370 0.3673 3.8175 18.2586
ZINC03815184 1.4793 27.0466 188.5374 0.3673 3.8176 18.2586
ZINC04617794 3.3518 50.1748 106.2984 0.8104 5.0633 10.8026
ZINC04617801 5.8187 60.0431 106.6008 0.8833 6.2218 11.2560
ZINC04617802 4.1840 31.3380 202.1591 0.4661 4.0692 20.2929
ZINC04617803 3.8951 29.7071 207.4835 0.4486 3.9601 20.6972
ZINC03815267 5.6345 59.8788 109.0295 0.8178 6.2333 11.5358
ZINC04617798 2.6103 119.2837 189.8692 0.6870 11.5918 20.3970
ZINC03815217 3.2799 81.7245 143.4065 0.8354 7.8151 15.4454
ZINC04617797 2.7339 119.0755 189.8598 0.7129 11.5563 20.3943
ZINC04617799 3.2391 83.1031 143.4294 0.8346 7.9380 15.4651
ZINC03815395 6.9197 38.3109 95.8169 1.2407 3.9492 10.3705
ZINC00021592 2.7796 53.6519 115.2296 0.6399 5.0887 12.6349
ZINC03815265 6.7971 49.3206 237.0175 0.4107 5.3109 12.7124
ZINC00839396 3.4467 96.5287 196.6345 0.4333 5.3576 13.6817
ZINC03815082 3.7124 96.7957 182.6650 0.4319 5.6627 13.0981
ZINC03815194 7.4802 47.3065 257.5270 0.8383 4.7412 15.0052
ZINC00839389 11.6245 130.5250 243.2178 0.7401 5.2186 12.7802
ZINC03815150 3.4259 92.4894 192.3062 0.4237 5.3993 14.4975
ZINC03815169 3.6455 107.5983 180.7663 0.4726 6.0368 15.2191
ZINC00839395 3.6481 100.4232 209.0234 0.5101 5.0866 17.0429
ZINC03815219 3.3799 103.5448 211.7705 0.4843 5.2754 19.2788
ZINC04617814 13.1493 28.3835 133.6191 1.9201 3.2195 13.4649
ZINC03815409 13.5755 30.5796 123.8069 1.9656 3.4826 12.4445
ZINC03815213 6.0207 56.4653 205.6988 0.6659 5.6790 8.8749
ZINC03815151 5.4596 55.1184 201.4901 0.7074 5.8068 9.2482
ZINC03815230 9.9460 63.2361 234.1895 0.7700 5.7939 9.4665
ZINC00018522 2.0154 30.3215 183.7180 0.4382 3.6631 17.7178
ZINC03815160 6.6947 92.8569 165.2870 0.8532 6.7135 10.7070
ZINC03815171 4.5315 82.2156 149.3579 0.6500 7.3843 9.7082
ZINC03815161 7.2725 133.7181 152.5670 0.9246 6.8015 13.7809
ZINC03815158 5.9549 34.9301 152.3612 0.8643 3.9073 14.9651
ZINC03815305 8.0959 32.6070 151.7302 1.1850 3.5828 15.5772
ZINC03815157 12.8152 77.7913 459.5002 1.0203 5.2320 14.8304
ZINC03815396 3.3511 33.3639 179.1872 0.4809 3.7066 18.4329
ZINC03815371 4.6782 30.9087 181.0884 0.8525 3.3901 18.4943
ZINC03815389 6.5712 27.1096 183.6598 0.8984 3.4133 18.2769
ZINC03815403 7.6623 72.5561 210.7696 0.9321 6.9741 10.3733
ZINC00006094 5.9610 61.2620 106.6019 0.9568 6.6245 8.4224
ZINC00600430 8.3447 94.4086 132.1459 0.9733 6.7531 8.4501
ZINC03815123 2.9271 47.2687 228.7693 0.5357 5.0319 22.3677
ZINC03815071 18.9385 44.7967 719.5770 1.4155 3.6451 18.8246
ZINC03815047 4.0388 106.0228 649.7154 0.4935 4.1382 22.1590
ZINC03815094 7.1777 24.1058 250.7409 1.2353 2.7552 22.5268
ZINC03815098 18.3582 31.6465 757.2868 1.7536 2.6809 20.0565
ZINC03815164 6.4608 42.4490 224.0467 1.2250 4.4794 19.7275
ZINC03815076 8.7615 107.0224 551.5783 1.0440 4.3586 20.1499
ZINC03815354 16.8236 50.5634 254.0749 0.9539 2.7235 20.4080
ZINC00838734 16.7798 50.4477 249.8347 0.9342 2.6776 21.6232
ZINC00601820 16.7591 50.1319 259.4784 0.9113 2.6728 20.6406
ZINC03815288 20.5854 49.2560 279.6875 0.9308 2.9412 21.9044
ZINC03815350 21.4028 49.2150 250.7529 0.9401 3.6780 19.2410
ZINC03815309 17.1705 47.1084 333.2633 0.9489 2.5209 27.4857
ZINC03815223 15.8971 48.2459 325.4408 1.0255 2.4926 27.0690
ZINC02047503 15.8941 47.8334 333.1977 1.0321 2.5650 26.1506
ZINC03815370 19.7193 47.8061 283.3839 0.9341 3.2187 23.2701
ZINC03815299 24.0559 50.4188 322.7077 1.0287 3.1086 22.6320
ZINC03815128 13.8663 34.2042 750.5695 2.0077 4.0781 14.0965
ZINC03815114 3.2940 47.2403 257.8616 0.8058 4.7282 25.3696
ZINC03815099 11.0196 47.8810 175.1004 1.6266 4.7353 17.3447
ZINC03815074 3.3493 117.0552 681.9084 0.5870 4.1006 24.6260
ZINC03815065 9.5815 27.9104 776.4001 1.4207 3.5161 15.6960
ZINC03815091 6.7289 89.3953 632.9107 1.2875 3.0235 24.8104
ZINC03815279 10.8090 86.0518 703.4090 0.9112 5.8357 19.9567
ZINC03815062 10.5038 73.4477 818.0296 1.1790 3.0173 26.2664
ZINC03815132 5.4393 29.9330 322.8260 1.1465 3.3684 27.8204
ZINC03815113 4.0973 141.3333 603.2610 0.5004 5.1999 22.4808
ZINC03815105 13.9205 21.1988 985.6640 1.4239 3.1610 22.3197
ZINC00837641 10.4046 116.9544 126.6226 1.3578 7.6826 8.9589
ZINC03815109 11.8128 51.9263 230.8542 1.5342 5.6293 20.9176
ZINC03815122 2.9388 151.9921 651.6918 0.4789 4.8530 26.8818
ZINC03815147 16.2280 77.1168 594.0964 1.3823 5.9681 12.7042
ZINC03815178 9.4212 40.2129 295.2748 1.4658 4.3415 27.0596
ZINC03815155 10.8708 38.5367 310.5692 1.6096 4.1665 31.8768
ZINC04617805 3.1017 116.5847 237.5021 0.7791 10.5000 22.5039
ZINC04617806 3.1135 116.6808 237.2937 0.7660 10.5196 22.4947
ZINC04617807 4.0078 77.6512 184.1165 0.9455 7.6422 16.2031
ZINC03815325 3.7298 78.0525 184.8368 0.9269 7.6830 16.2412
ZINC02640583 599.2117 4269.9056 4735.5939 74.3959 244.8702 305.0322
ZINC03815185 645.2668 3676.3702 4217.3488 66.6464 272.6532 328.9826
ZINC00020644 729.4222 4182.1244 4781.7255 110.3883 376.2160 466.7996
ZINC03815359 598.3646 2605.9182 3122.7862 108.1908 371.2085 460.5746
ZINC03815360 544.5062 2828.0298 3316.0472 107.5183 372.0158 460.9654
ZINC03815361 642.6296 2515.8289 3071.4550 134.9644 451.4352 559.5077
ZINC00007282 652.9996 3077.3227 3627.2404 109.3791 373.8566 463.8808
ZINC03815304 661.6421 2901.3626 3460.0760 115.6603 410.4643 504.0659
ZINC03815353 1182.4039 2249.8246 2507.4619 189.8890 284.1400 362.7856
ZINC00118570 401.5551 1960.3341 2300.0592 78.3622 310.8581 373.9643
ZINC03815331 410.4133 1961.2469 2303.6852 75.1139 320.8662 379.4129
ZINC00151213 641.7339 3724.9411 4204.8398 82.1730 316.4858 381.0697
ZINC00151212 472.8011 2371.1663 2739.7552 79.2821 312.8517 375.7514
ZINC03815388 554.2523 2156.0761 2642.5090 100.4242 345.5143 428.4218
ZINC00104621 483.1569 2353.2135 2734.5928 99.8997 393.9934 469.1312
ZINC03815229 635.3409 4028.2519 4501.9643 73.2623 301.9674 358.2246
ZINC03815317 757.6633 2145.1450 2633.9394 182.0420 457.4310 543.4283
ZINC03815247 630.5845 3750.7052 4247.3877 80.5072 282.9995 348.3319
ZINC03815375 647.9974 3705.2366 4155.3358 78.6088 291.9652 350.0888
ZINC03815227 683.0811 3818.6559 4396.1606 80.1609 300.3655 370.2789
ZINC03815274 432.7157 2420.5538 2790.3347 82.3720 388.9357 455.6575
ZINC00151214 690.4184 4513.7667 5033.4272 82.7966 316.9955 382.2436
ZINC03815386 694.5144 3763.4281 3869.4143 78.3496 326.8395 346.7519
ZINC00118581 542.7043 2776.1965 3186.8265 80.8327 314.7969 378.5958
ZINC03815055 704.4391 5418.7857 5926.9921 86.4118 396.2010 464.4795
ZINC03815319 899.0547 5265.9943 5714.6886 165.7192 507.6959 571.4552
ZINC03815146 652.1901 4538.4671 5012.5308 82.4989 359.8971 424.9964
ZINC03815314 1118.0348 2783.3939 3665.0044 152.4459 520.5835 592.3998
ZINC03815398 695.1849 3048.2686 3292.6407 157.6469 527.5658 580.6100
ZINC00104782 512.6858 2830.9130 3215.3339 96.1545 462.5886 532.3990
ZINC03815197 734.2960 4777.0904 5346.8638 73.4065 305.3312 361.5111
ZINC03815196 712.8576 2342.4097 3007.0677 123.4395 382.6102 492.8094
ZINC03815276 719.4543 3905.7322 4582.2251 100.4909 316.9702 410.6667
ZINC03815251 685.1776 2518.9137 3136.5729 114.6354 428.3421 523.5881
ZINC03815264 1171.2889 4277.3975 5316.3976 80.9539 270.5513 341.4139
ZINC03815202 677.4399 2394.8696 2995.3194 123.9730 364.2974 469.1704
ZINC03815203 1182.0537 4288.6670 5332.3110 84.2045 301.5825 375.2316
ZINC03815236 857.4506 4891.7786 5545.1056 84.4735 284.0255 352.9967
ZINC03815238 649.3294 3194.1211 3484.5723 167.5282 681.2232 724.6520
ZINC03815259 643.7840 3234.6020 3530.9356 154.7754 608.0127 661.7429
ZINC03815280 501.7138 2919.5687 3353.0010 96.0021 469.0438 545.4714
ZINC03815242 924.6527 4070.7094 4869.6115 81.6711 301.2161 372.4567
ZINC03813425 1074.1934 4334.3678 4404.3084 172.1473 536.5722 600.2514
ZINC03815036 757.0144 4200.7026 4689.0357 97.1995 334.2441 407.7854
ZINC03815410 1045.2156 4210.3534 4671.1698 160.7334 539.4059 582.5721
ZINC03815046 614.7461 3442.6399 3923.5964 85.1585 393.5115 461.1135
ZINC03815035 1058.5428 4079.4396 4742.5059 194.7790 446.8715 551.4181
ZINC03815034 749.9068 4216.5514 4749.3251 103.5506 352.8872 435.9354
ZINC03815282 744.7387 4322.4573 4891.9682 82.1383 283.1186 350.0170
ZINC03815281 761.0149 3270.4347 3638.3185 163.8651 505.1856 567.9198
ZINC03813430 642.8847 5500.6140 5834.5791 156.8264 536.6503 589.7915
ZINC03813429 836.6410 4302.4800 4729.3848 164.8192 505.3481 570.1859
ZINC03815072 734.5604 4656.0680 5225.6815 86.6383 395.5475 463.8444
ZINC03815374 663.9238 4570.4990 5003.6743 78.6763 295.3523 353.1194
ZINC03815124 802.1403 2687.8371 3116.4507 195.0167 569.0106 646.6922
ZINC03815338 896.9460 2618.3768 3440.5168 99.1588 335.2088 418.8413
ZINC03815176 717.7714 2814.5603 3163.9218 182.8347 614.5900 690.4679
ZINC03815111 493.9969 2911.8791 3295.5177 83.1309 391.3742 457.6747
ZINC03815343 699.6055 4256.6906 4783.7254 89.6725 372.4303 443.0092
ZINC03815100 890.5110 4009.4917 4777.4586 102.0532 299.1947 389.2357
ZINC03815101 867.9575 4075.7482 4809.0766 98.9597 307.3399 393.9419
ZINC00020362 816.1340 4773.4725 5489.7513 128.6704 414.2010 528.2930
ZINC03815232 888.4012 5272.9731 5985.7659 98.7534 453.6072 530.2984
ZINC03815097 767.4980 3644.7761 4056.6131 198.7126 796.1054 868.3784
ZINC03815163 892.1220 5273.4348 5991.5637 95.0057 444.6283 518.4049
ZINC03815162 693.2342 5333.1291 5809.9288 99.7003 513.5607 591.2054
ZINC03815029 845.6997 4891.1285 5405.4111 113.1644 441.6638 526.4423
ZINC03815037 1213.9508 4940.0546 5545.8840 185.3424 672.2239 753.3969
ZINC03815038 755.0907 5002.3876 5536.1136 94.6143 377.1621 451.1809
ZINC03815411 895.3505 4117.5501 4889.0041 138.6224 331.2388 451.7851
ZINC03815159 765.0108 5897.3178 6415.0329 103.3957 360.8715 442.7668
ZINC03815042 1053.4172 3685.8938 3989.9754 202.7220 603.2606 679.9792
ZINC03815286 730.0562 5037.7164 5591.2315 89.1219 483.8604 550.9679
ZINC03815284 714.3514 3519.5107 3960.2117 172.0082 692.1600 774.3631
ZINC03815144 1140.5581 4085.1190 5066.2775 142.9706 324.6336 450.5412
ZINC03815183 829.2113 4926.2872 5522.6428 116.7730 437.5768 532.0890
ZINC03813424 1430.4156 3869.4649 4586.3326 222.1473 543.9229 646.6940
ZINC03815137 786.6047 4813.3458 5520.3352 115.9813 382.1585 485.6349
ZINC02391776 753.5192 4929.8145 5469.4921 104.4578 422.8581 508.2408
ZINC03815060 903.6187 3093.6130 3820.3566 234.5108 666.1594 823.3607
ZINC03815140 838.5411 4906.7138 5482.7466 124.4981 451.0364 550.9418
ZINC03815138 882.4503 4499.9475 5255.5080 130.5844 315.5046 429.4465
ZINC03815143 857.3306 2689.9834 3467.5127 161.2460 451.7707 591.4737
ZINC03815070 1126.4073 4398.5330 5374.8589 121.1136 400.3316 505.2547
ZINC03815320 678.8194 5275.3298 5728.4017 81.7658 475.2336 533.6086
ZINC03815069 1157.9675 4293.8922 5315.0594 129.5864 386.4747 500.9949
ZINC03815332 693.8950 5347.9497 5819.0960 98.5770 477.6775 553.7732
ZINC03815248 697.4969 5278.6312 5710.0899 91.2755 499.9782 566.0882
ZINC03815373 818.5978 3313.2387 3845.2305 187.0432 652.8597 735.2932
ZINC03815118 797.4233 4967.3093 5577.6222 112.6914 413.9198 507.2021
ZINC03815117 831.1788 4918.2647 5455.7245 105.9735 426.7907 507.1999
ZINC03815121 949.0012 3346.4585 3875.9428 232.3505 744.5737 852.1774
ZINC03815335 816.1157 5474.2331 6091.9421 90.4543 384.3877 453.6095
ZINC03815266 972.5208 5249.0698 5935.9573 155.3471 481.5634 604.0155
ZINC03815125 1353.1588 5106.8896 5816.4490 195.1892 672.3089 762.6343
ZINC03815328 729.5569 5985.1796 6447.4932 102.0006 602.6177 676.7191
ZINC03815136 773.0487 5748.4152 6311.2700 107.3829 520.7477 607.2111
ZINC03815141 1026.4882 2770.8853 3706.1130 192.6841 474.9782 640.1857
ZINC03815033 1247.6116 5627.5238 6165.3894 198.3896 779.8866 844.8287
ZINC00116727 778.5041 3220.8281 3918.5144 147.8762 512.6522 634.4506
ZINC03815406 706.4418 6111.8795 6595.5799 86.5681 402.0841 470.1483
ZINC00020363 1366.0877 4360.2655 5554.3223 164.4482 427.4917 569.9541
ZINC02391785 780.3541 5722.5691 6280.1685 109.7357 549.6285 637.3026
ZINC03815357 759.7901 7319.8833 7835.2769 87.1840 402.6479 471.3314
ZINC03815080 935.7114 5097.7770 5904.7596 142.8243 433.8402 557.6867
ZINC03813428 945.7079 3480.5675 4070.1624 179.7562 537.6467 622.6483
ZINC03815079 928.7784 5085.7349 5917.0660 153.0428 419.0741 553.9222
ZINC00118594 694.2208 3774.3201 4225.5744 101.7845 397.3506 470.8813
ZINC03815027 979.5761 5238.2449 5865.4718 140.6375 476.4884 582.3801
ZINC03813434 1200.0378 5096.8258 5456.2743 248.1663 579.9472 673.3578
ZINC03815393 610.1467 4679.6740 5124.0327 85.3264 400.1023 467.5491
ZINC03815187 719.6801 6091.9435 6567.6211 108.2275 621.5128 699.2629
ZINC03815190 710.5713 6437.3042 6906.8938 104.0890 678.5856 757.4343
ZINC00600292 978.6710 6022.4719 6718.1490 151.5614 521.0231 643.0647
ZINC03815041 2407.3071 3735.1993 5541.6761 319.6307 587.8590 809.5964
ZINC03815212 1030.2272 6681.3500 7381.0360 108.3336 361.4838 447.1345
ZINC03815031 1153.5378 5924.5504 6811.0909 149.6473 525.1003 643.2892
ZINC03815045 1408.8051 6811.5608 7574.9077 201.4251 885.9691 978.2534
ZINC03815292 812.5981 6443.3569 6959.5641 123.7939 645.5991 723.6937
ZINC00601499 1106.0211 6776.0957 7702.1702 97.7563 646.6166 723.1123
ZINC03815206 968.3055 4455.0563 4787.4723 148.7034 522.6416 607.8110
ZINC01386818 831.5965 3880.4092 4566.3511 148.7953 515.7237 636.9856
ZINC00009851 783.7114 4023.9324 4727.9970 148.2586 572.8667 695.1707
ZINC03815362 796.5429 3997.4771 4505.1054 118.5279 441.9406 526.8953
ZINC03815129 776.5901 4400.4268 4932.6146 108.5448 485.0004 564.8179
ZINC03815235 748.1578 7148.8468 7680.7076 99.8912 660.1821 739.3191
ZINC03815075 1026.9274 7297.8694 8006.0301 152.1441 521.6747 644.2023
ZINC03813431 814.7652 3947.3293 4320.6380 173.6197 557.6737 614.3325
ZINC01386782 788.4832 7093.2033 7797.2619 147.8137 527.0520 647.8361
ZINC03815283 1319.3006 3491.9278 4713.4515 153.9364 492.2783 627.0800
ZINC03815250 1293.0910 5494.0405 6554.3050 111.2305 426.8193 516.5687
ZINC00116937 889.3997 4520.4190 5207.1494 150.2791 518.5449 640.2251
ZINC03815334 1274.9655 4773.9388 5741.1505 154.5192 313.2218 413.1281
ZINC03815199 1300.4516 6259.5225 7297.1173 114.0394 522.2039 610.4791
ZINC03815088 1308.5887 4583.8554 5693.0655 244.1472 668.3580 847.0463
ZINC03815348 1446.1786 5969.1540 7149.0197 199.0221 523.0792 692.0360
ZINC03815258 1070.9914 6511.6926 7294.9117 115.8915 552.5270 644.7618
ZINC03815102 1602.1209 6571.2465 7583.4812 194.2558 741.3535 823.7287
ZINC03815043 2159.7668 4820.8693 5498.9661 326.1499 653.7921 782.2456
ZINC03815032 1317.0718 8602.0918 9579.2671 152.1858 534.5824 655.9213
ZINC03815050 1111.3769 7049.5620 7296.2489 197.3504 693.7279 763.0850
ZINC03815273 1593.4183 3188.3477 3630.2401 225.5569 417.7876 510.8310
ZINC03815119 1608.3656 7271.2302 8212.4497 223.8582 1001.1495 1115.5362
ZINC03815189 1443.3818 6120.6978 7336.1435 214.3167 481.3585 674.3998
ZINC03815278 2183.6273 7346.3576 9023.6068 156.0588 528.5495 651.3048
ZINC03815290 1868.4338 4162.6193 4408.8522 227.9290 420.9284 510.8851
ZINC00016978 1004.6070 5182.5606 5978.9197 150.6799 522.2199 643.4062
ZINC03815316 794.3820 4849.1600 5550.9262 153.0967 763.4640 885.8336
ZINC03815384 1480.0091 3265.5519 4427.9764 210.2356 430.8671 564.8746
ZINC03815228 2420.6961 6635.5658 8855.3706 209.6925 906.9046 1075.1474
ZINC03815397 1466.0410 3190.5066 4342.9195 213.1070 515.5299 650.6697
ZINC03815077 1723.4853 8996.5658 10020.4646 230.5977 1176.9924 1293.2886
ZINC03815300 1559.9100 5509.4080 6719.4309 210.3661 439.9104 573.2908
ZINC02572485 1282.1047 7363.9140 8322.1905 225.4144 711.6321 899.9845
ZINC03815298 1516.1588 3924.9235 5110.7547 210.2040 435.8595 569.5542
ZINC03815059 1397.7182 5845.4563 6569.5739 238.8534 650.1719 770.1314
ZINC03815201 1491.2232 8154.4613 8840.2258 213.0198 884.0241 959.1871
ZINC03815066 1099.7506 6440.1444 7316.2087 184.9289 564.7086 695.6952
ZINC04617768 2255.1463 6950.0233 8635.6929 356.1950 793.1594 1033.5499
ZINC03815198 2103.1085 5875.3048 7183.4052 277.2612 855.1442 968.0935
ZINC04617774 1778.6197 8833.3563 9775.0301 247.8653 1140.6479 1260.8317
ZINC03815064 1937.9586 8412.5919 9682.9255 223.6557 960.1929 1072.8266
ZINC03815087 2496.1859 6089.5181 7370.2035 358.8322 1028.9562 1199.4152
ZINC03815040 1428.8879 8701.6857 9002.6269 241.7484 987.3376 1059.0357
ZINC03815049 1959.4599 8255.9305 9191.1051 275.1528 849.4918 1002.3000
ZINC03815243 1442.5753 9038.4406 9747.7195 219.2014 1380.8308 1453.3500
ZINC03815026 1305.3359 7356.3695 8275.8080 224.7042 711.7230 895.7674
ZINC03815051 1974.1645 10418.2972 11683.4894 240.0341 1186.4467 1309.9787
ZINC03815044 1022.4341 5701.8377 6381.6992 169.1748 638.5265 763.3230
ZINC03815272 1328.7418 4938.9850 5924.7240 255.6475 760.3052 939.8567
ZINC03815172 2295.3768 4569.8772 5022.6319 397.8382 655.6941 779.4858
ZINC03815191 1545.4804 8878.4629 9678.4371 239.0839 1136.5119 1220.9397
ZINC03815063 1425.4761 9339.3857 9955.0588 224.9700 1130.9193 1192.2520
ZINC03815387 1592.9796 4499.7173 5741.3170 223.8589 653.2445 796.0392
ZINC03815218 1184.0221 8020.5344 8889.9195 116.9763 690.2968 782.8107
ZINC03815090 2650.9172 7401.1302 8729.6922 383.4360 1267.3838 1438.3946
ZINC04617771 2036.8893 7409.9506 8320.0377 348.6565 819.1066 975.7115
ZINC03815333 1096.7494 5586.6842 6412.1463 218.1352 848.7623 996.8604
ZINC03815237 1351.0178 9087.6578 9614.6563 258.4213 1302.3590 1363.7349
ZINC04617779 1971.7632 8921.7415 9944.5322 279.3838 1145.7185 1292.0244
ZINC03815175 1899.6628 10821.1165 12011.1275 262.3389 1758.2257 1896.9670
ZINC03815096 2101.3609 10962.1992 12305.1416 231.4623 1135.9749 1251.4153
ZINC03815358 1647.3973 4422.2061 5608.4678 210.4903 441.1112 573.2712
ZINC03815126 2004.9643 6637.5648 7811.0623 365.4345 742.7602 944.2269
ZINC03815404 1549.9628 4417.0768 5578.2886 213.8193 525.4278 657.5979
ZINC03815401 1595.7911 4353.0835 5528.9373 237.7662 777.6202 904.1544
ZINC03815108 2858.6927 8949.1610 10446.8547 406.0037 1568.0757 1755.4958
ZINC03815154 2063.3667 7903.0072 9318.6852 471.8835 1745.1419 2017.2264
ZINC04617776 2481.6194 7931.9720 9252.1573 368.9908 1227.6308 1402.4132
ZINC03815165 2136.1045 12603.6386 13999.6279 285.9617 2111.3680 2246.8169
ZINC03815352 1407.3775 6167.2582 7155.9383 284.8204 911.4147 1099.0575
ZINC03815173 2214.5261 15032.4481 16476.2478 296.9456 2535.4891 2676.4889
ZINC03815367 522.3494 2488.3799 2827.1888 101.2720 378.7392 427.8600
ZINC00109589 519.7983 2530.5823 2866.8106 104.2778 388.4621 440.5754
ZINC03815364 685.6718 3256.6441 3797.8653 174.6964 674.0222 779.7551
ZINC03815303 792.5350 3334.8306 3940.5992 151.1956 519.1471 615.0071
ZINC03815312 811.2261 3379.4096 3908.4545 197.3950 677.7260 779.7789
ZINC03815256 981.0218 2846.7122 3640.9744 172.4021 467.7629 584.8308
ZINC03815253 1025.4089 3081.5306 3920.2291 180.9468 430.9561 556.5826
ZINC03815365 818.2972 3621.2197 4274.7469 128.7715 589.5310 669.5058
ZINC01386812 1029.8563 3631.1552 4471.0362 179.7955 585.0983 706.3801
ZINC00020368 1016.4434 4324.3307 5154.0291 155.7684 698.2015 798.6491
ZINC03815297 1161.1237 4109.6258 4946.0767 210.5401 688.0781 806.3010
ZINC03815342 1105.0819 5930.2406 6667.8264 171.2012 590.0743 718.8973
ZINC03815083 759.1204 2626.8748 3150.1878 138.3728 460.2930 538.1700
ZINC03815293 552.7144 2871.1946 3284.8416 75.8691 294.0994 350.8261
ZINC03815310 526.5219 3652.1384 4037.7495 77.1865 378.1629 435.2612
ZINC03815326 797.8964 2479.8667 3205.8939 143.1372 436.1352 551.4667
ZINC03815341 828.9971 3002.2933 3738.3177 148.1766 472.2864 590.6649
ZINC03815394 935.1974 2859.7962 3681.6562 178.0297 520.8411 660.4507
ZINC03815277 815.7581 3133.2696 3873.7774 150.4187 593.1438 712.6620
ZINC03815156 1001.8107 3392.5467 4268.5199 127.1920 382.8307 495.3438
ZINC03815244 1210.0705 4639.1712 5659.2736 148.8537 440.9840 559.2321
ZINC00020645 1054.1503 3431.7521 4336.5277 146.8614 439.6260 556.6884
ZINC03815402 842.9007 3674.6445 4387.8912 150.4994 658.1929 770.3851
ZINC03815336 970.0126 4726.3386 5436.6695 154.6404 567.9805 681.3552
ZINC00023489 617.1088 3707.3748 4140.2014 75.5108 376.2262 431.0429
ZINC00007342 618.6195 3724.9627 4161.5334 83.6931 380.6788 443.2357
ZINC03815231 778.1330 3992.3945 4562.8074 128.1122 436.5775 537.7576
ZINC03815295 965.7777 4012.7884 4758.9254 181.7280 439.4373 590.2066
ZINC03815257 2265.9283 4405.3944 6115.3517 378.1601 479.7767 781.4953
ZINC03815345 2117.3326 4496.5649 5244.6975 274.9958 657.6209 820.6184
ZINC03815368 2184.4165 3824.7129 5324.3414 412.1602 673.4364 891.5702
ZINC03815234 819.0017 6165.6870 6836.3773 69.9740 377.4699 436.4875
ZINC03815200 775.4229 5562.6933 6100.5747 101.3456 421.6421 501.1000
ZINC00006271 1042.9703 5160.3104 6031.7004 111.3853 434.5412 528.4172
ZINC04617767 1034.4350 5188.1826 6053.1198 100.2470 422.7669 506.3359
ZINC03815028 1021.9877 5240.9175 6089.8905 107.7942 405.1207 495.0989
ZINC03815058 1041.1607 5213.5352 6080.6991 104.6372 401.7261 488.7115
ZINC03815241 852.0685 6046.1471 6676.5769 96.1952 402.1148 481.6892
ZINC03815054 1015.0519 5285.0539 6122.4967 101.5034 410.0149 493.2707
ZINC03815030 1247.5880 5421.7922 6469.2031 146.5628 445.6923 569.8019
ZINC02391775 1056.9433 5955.4299 6833.7887 103.0365 556.0088 639.0159
ZINC03815052 1214.9109 5854.4436 6888.1241 125.1018 541.4561 645.1704
ZINC03815057 1067.4854 5979.1411 6864.4576 107.4165 539.5447 625.9877
ZINC03815073 1066.9754 5921.8944 6808.4031 114.8556 562.8351 656.7762
ZINC03815249 1122.6038 8366.4302 9246.3756 116.5809 619.0423 710.4855
ZINC03815152 1311.1383 8579.2585 9540.7424 122.1911 669.1919 759.9640
ZINC03815116 2115.2044 6185.9311 7697.6584 279.9823 600.0141 794.0621
ZINC04617775 1355.3489 10074.7638 10908.3914 141.3195 985.1882 1062.2561
ZINC03815233 1224.6465 10777.4141 11707.9501 137.1814 1257.0015 1329.8785
ZINC04617795 1385.1570 9968.5851 10704.7484 138.5176 947.3287 1018.7118
ZINC03815239 1344.6721 10033.2444 10724.0606 169.3843 1136.6923 1218.8890
ZINC03815188 1222.1093 10106.6716 11008.6790 135.0599 944.9987 1031.4767
ZINC03815095 2738.9227 6589.3899 8643.0539 320.1074 710.0957 934.2215
ZINC03815103 1221.5636 10223.0592 11088.9402 138.1199 984.8653 1071.3135
ZINC03815209 1330.2320 10083.8086 10764.9132 154.0069 1138.7139 1208.0901
ZINC03815306 1539.7322 11405.1619 12664.3877 145.3592 1186.8432 1270.1914
ZINC03815208 1557.8046 11266.2068 11735.5869 206.1240 1286.3053 1376.5801
ZINC03815067 2917.1017 7902.7022 10199.9081 284.5803 714.2618 909.6018
ZINC03815382 634.5575 4521.8402 5061.1362 78.0526 483.7924 550.8452
ZINC03815179 530.6965 3918.1707 4401.4296 86.9916 605.8932 682.0001
ZINC03815112 633.8664 4489.2874 5036.7691 112.8004 730.3048 823.4674
ZINC03815061 745.5530 6969.4444 7579.7954 95.8833 610.3710 693.6637
ZINC03815048 888.7740 6943.7874 7676.4849 91.2941 613.4386 691.3959
ZINC03815120 1060.0178 6335.3953 7235.5281 113.5978 547.4148 646.4248
ZINC03815084 1000.5670 7837.5616 8678.0063 98.0602 611.3186 696.3895
ZINC03815255 581.7238 5261.1196 5792.8276 87.9620 613.3458 690.2854
ZINC03815186 676.9534 5969.2924 6551.3942 113.5387 738.9446 832.5606
ZINC03815245 917.4197 6583.7548 7265.6496 114.4545 734.6373 825.9151
ZINC03815322 694.1064 5517.0227 6063.1357 86.7013 436.5423 507.4449
ZINC03815301 739.9651 3851.2905 4407.6841 125.2752 590.2026 663.3117
ZINC00327021 731.0917 3621.8216 4169.3280 132.2973 558.3430 638.4712
ZINC03815356 853.1424 3929.6238 4560.9640 154.6683 609.3245 702.0123
ZINC03815340 844.8657 3686.6089 4304.0862 162.7456 577.4828 675.9039
ZINC04617812 853.1462 3929.6202 4560.9605 154.6694 609.3228 702.0110
ZINC04617811 844.8718 3686.5732 4304.0562 162.7466 577.4799 675.9009
ZINC03815093 966.2357 4510.8305 5112.8311 129.6578 359.7938 458.5940
ZINC03815222 967.4324 4506.4222 5092.4989 121.8543 335.7958 425.8910
ZINC00006798 1101.3101 2597.5671 3560.7331 173.5477 424.0505 562.3200
ZINC01609260 1012.4102 2796.3070 3590.7528 164.9722 460.1536 565.7231
ZINC03815377 1128.6842 3947.3911 4648.1374 167.2477 465.8999 570.6366
ZINC03815366 1405.8716 3485.4851 4562.0404 221.1233 571.8279 712.8549
ZINC03815351 1333.8141 3715.1840 4689.0517 215.0466 615.0430 747.4934
ZINC03815376 1140.7680 4200.8222 5120.3364 180.4240 673.6458 791.8174
ZINC01609268 1106.8611 4126.6710 4995.1277 177.8114 667.2024 779.6878
ZINC03815391 1858.3644 4389.0950 5710.0130 287.4638 732.7443 906.7468
ZINC03815323 2029.4745 8044.7804 9449.5954 329.7701 1396.0077 1592.4235
ZINC03815390 2557.6327 7625.2110 9726.3125 412.9009 1149.2309 1450.7760
ZINC03815324 2162.9581 10715.5296 12364.1254 361.4593 1867.2574 2102.7005
ZINC03815025 819.7493 6005.9292 6605.9980 119.8331 507.6856 609.1960
ZINC03815106 812.0772 6006.3299 6608.2691 109.1765 460.5981 552.7520
ZINC04617810 647.3438 4967.3308 5517.7701 125.3294 764.8522 861.8763
ZINC04617809 647.3486 4967.3137 5517.7551 125.3300 764.8504 861.8749
ZINC03815339 1271.1895 3188.1339 4247.1772 209.0437 524.6594 670.5805
ZINC04617808 1271.1829 3188.1640 4247.2007 209.0425 524.6595 670.5796
ZINC04617792 1470.5562 3048.7269 4289.5300 252.5724 499.3591 682.2370
ZINC04617793 834.5258 5189.1823 5923.9971 179.9474 800.9124 949.2735
ZINC03815184 834.5254 5189.1854 5924.0015 179.9485 800.9115 949.2741
ZINC04617794 1470.5282 3048.7279 4289.5087 252.5693 499.3591 682.2337
ZINC04617801 1952.8471 3362.7665 4957.5935 319.7292 546.2678 786.5005
ZINC04617802 1077.2495 6103.0393 6945.1843 204.0851 934.1542 1096.2936
ZINC04617803 1025.0953 6239.8280 7048.2011 198.3935 951.5622 1109.5788
ZINC03815267 1941.5882 3426.6425 5028.9840 317.3015 555.9131 799.6085
ZINC04617798 4381.8011 7026.0660 11167.3841 749.0092 1286.1249 1951.3173
ZINC03815217 3024.4453 5357.2533 8082.5535 527.6787 993.1268 1418.8893
ZINC04617797 4378.3225 7031.1519 11158.2185 748.4180 1287.5371 1948.9873
ZINC04617799 3072.2657 5358.3049 8133.9490 535.1307 994.2817 1427.5873
ZINC03815395 1191.5322 2730.9516 3506.3177 207.5941 464.4465 572.7865
ZINC00021592 1447.4652 3159.3441 4433.6660 211.9591 491.1673 655.7756
ZINC03815265 1535.0089 4491.0166 5748.5453 211.7016 485.5552 666.8627
ZINC00839396 2243.5734 4320.5661 6381.8077 220.0567 536.3714 723.4945
ZINC03815082 2363.0883 3971.5580 6134.3260 231.5948 514.1402 712.9071
ZINC03815194 1569.6608 5257.7844 6451.6002 223.1834 633.7435 789.8595
ZINC00839389 2605.1984 4802.2110 6886.0283 220.4741 500.2512 665.9570
ZINC03815150 2243.5641 4265.4593 6327.2100 227.1002 581.9295 775.9782
ZINC03815169 2637.3674 4413.0489 6836.6849 266.8881 643.3600 871.4923
ZINC00839395 2337.2256 5123.5721 7250.8948 229.4649 719.6724 907.3115
ZINC03815219 2492.2460 5717.6241 8005.5520 259.1843 889.3394 1104.9366
ZINC04617814 1172.0824 4059.0174 4431.1820 221.0035 661.5554 717.4275
ZINC03815409 1246.4456 3797.5688 4221.2971 234.2715 619.6335 684.8656
ZINC03815213 1692.0905 3607.6023 5004.7699 228.4147 343.4680 523.9384
ZINC03815151 1690.1637 3567.4132 4968.2515 241.0269 368.3585 557.0361
ZINC03815230 2011.7428 4589.5104 6108.2819 242.8664 378.7503 564.6340
ZINC00018522 892.8053 4949.5698 5711.5798 164.0527 726.2419 855.2377
ZINC03815160 2825.2285 3308.1520 5777.6736 302.6697 462.4061 696.8197
ZINC03815171 2679.1569 3511.3288 5901.4414 353.5091 455.7621 752.0725
ZINC03815161 3192.7790 4445.2649 7218.9851 339.9455 647.0415 905.6244
ZINC03815158 1161.5651 4400.9158 5206.6336 195.6385 649.0085 773.7707
ZINC03815305 1153.0146 4506.3549 5168.6288 195.4802 687.2492 785.5623
ZINC03815157 2662.1100 6167.8392 8054.2148 381.3902 966.8927 1223.8033
ZINC03815396 1019.4916 5103.8916 5928.6361 163.3119 737.6357 863.4396
ZINC03815371 1001.9842 5254.2667 5957.9236 173.9486 793.2218 897.2615
ZINC03815389 961.4364 5300.2968 5872.1140 172.4718 767.0119 867.6079
ZINC03815403 2313.0423 4113.4697 6024.3631 316.2464 452.2160 693.8969
ZINC00006094 1922.4248 2974.9099 4536.2773 303.2505 375.1691 601.8759
ZINC00600430 2706.3233 3673.0270 5901.5743 309.0594 376.9369 608.1284
ZINC03815123 1518.9491 6831.8379 8157.3511 244.9720 1007.7510 1205.5823
ZINC03815071 1841.1395 10158.7136 10783.9303 293.5163 1173.9253 1303.2423
ZINC03815047 2526.4433 8507.7934 10777.7106 189.8983 928.7508 1078.1827
ZINC03815094 1053.9508 8245.1989 8781.5388 243.4173 1449.4858 1542.2017
ZINC03815098 1590.1020 10401.7846 10580.5846 279.3763 1374.0362 1432.4562
ZINC03815164 1626.8265 7341.7999 8485.2605 347.9652 1278.1018 1476.6211
ZINC03815076 2643.5565 8890.1709 10920.2370 313.3505 1229.2435 1421.4900
ZINC03815354 1215.8775 7511.1113 7602.6957 147.0958 854.4741 925.2604
ZINC00838734 1207.9505 7547.7466 7643.0942 148.0810 924.8524 996.3310
ZINC00601820 1196.3802 7640.9161 7730.9560 143.3624 862.0755 932.5358
ZINC03815288 1347.7658 8407.8037 8557.1530 162.6254 959.0768 1043.5159
ZINC03815350 1432.3454 7695.6801 7913.0219 198.5786 867.7884 985.5199
ZINC03815309 1260.8435 10290.7573 10348.7064 156.1402 1279.5594 1350.2979
ZINC03815223 1269.4634 10028.6638 10177.1707 158.3147 1264.2556 1330.2721
ZINC02047503 1263.6174 10117.1731 10258.4743 161.8682 1223.2223 1292.1997
ZINC03815370 1404.5085 8854.4857 9043.4709 186.8776 1089.1909 1191.9979
ZINC03815299 1625.8986 9840.2731 10247.8460 177.9049 1017.4096 1106.8447
ZINC03815128 1878.9426 9391.4909 10151.3168 395.5778 1046.7758 1181.3468
ZINC03815114 1639.5592 8170.1173 9549.2345 282.2360 1334.9434 1534.9886
ZINC03815099 2031.9397 6405.2072 7617.5631 432.6093 1290.0507 1501.4408
ZINC03815074 2774.4771 9824.7719 12353.5265 225.0069 1210.2275 1378.8779
ZINC03815065 1474.8598 9768.1985 10502.7516 320.8920 1112.5825 1248.7872
ZINC03815091 2340.4969 10443.2273 12193.4444 284.5231 1722.4581 1837.0335
ZINC03815279 2966.9397 9526.9921 11835.4511 350.8421 1085.1336 1341.2062
ZINC03815062 1953.4362 13331.6310 14488.0859 255.9770 1674.1725 1786.3109
ZINC03815132 1251.7332 10866.0548 11671.1508 288.9567 1853.8847 1996.0894
ZINC03815113 3334.2608 8766.8196 11837.6622 250.8122 1011.1737 1217.9525
ZINC03815105 1330.1636 13513.3935 13906.1115 279.6812 1448.3621 1554.3263
ZINC00837641 3449.2578 3799.1928 6606.4576 379.6953 433.2987 698.9403
ZINC03815109 2330.7692 8410.0905 9870.1007 508.6058 1594.0761 1884.8314
ZINC03815122 3433.6832 10648.4818 13870.1606 271.9293 1395.3952 1618.4759
ZINC03815147 3062.6491 7052.9531 9089.3071 360.1712 690.2386 914.9405
ZINC03815178 1832.4639 10620.8745 11718.0143 412.3168 2025.2997 2229.4758
ZINC03815155 1908.3681 12168.3329 13195.5006 438.9886 2544.9659 2739.2912
ZINC04617805 4460.0497 8970.3736 13132.9632 710.5831 1466.8299 2079.2445
ZINC04617806 4463.5519 8963.4441 13130.8215 710.9882 1465.4216 2079.8999
ZINC04617807 3111.8907 6855.0093 9591.1315 541.0203 1080.3561 1502.2490
ZINC03815325 3118.0557 6868.6956 9630.1130 542.4246 1081.5874 1507.2234

42
Code/GraphMol/Descriptors/test_data/pmi.py
View File

@@ -11,38 +11,30 @@
from rdkit import Chem
from rdkit.Chem import AllChem
import numpy as np
from numpy import linalg
def GetMoments(mol, includeWeights):
conf = mol.GetConformer()
if includeWeights:
weights = [x.GetMass() for x in mol.GetAtoms()]
masses = np.array([x.GetMass() for x in mol.GetAtoms()])
else:
weights = [1.0] * mol.GetNumAtoms()
masses = [1.0] * mol.GetNumAtoms()
pts = [conf.GetAtomPosition(i) for i in range(mol.GetNumAtoms())]
wSum = sum(weights)
origin = np.sum([pts[i] * weights[i] for i in range(mol.GetNumAtoms())], 0)
origin /= wSum
sumXX = 0
sumXY = 0
sumXZ = 0
sumYY = 0
sumYZ = 0
sumZZ = 0
sums = np.zeros((3, 3), np.double)
for j, pt in enumerate(pts):
dp = weights[j] * (pt - origin)
for i in range(3):
sums[i, i] += dp[i] * dp[i]
for j in range(i + 1, 3):
sums[i, j] += dp[i] * dp[j]
sums[j, i] += dp[i] * dp[j]
sums /= wSum
vals, vects = linalg.eigh(sums)
vals = sorted(vals)
return vals
ps = conf.GetPositions()
mps = [x*y for x,y in zip(ps,masses)]
centroid = np.sum(mps,axis=0)/sum(masses)
cps = ps - centroid
xx = xy = xz = yy = yz = zz = 0.0
for m,p in zip(masses,cps):
xx += m*(p[1]*p[1] + p[2]*p[2])
yy += m*(p[0]*p[0] + p[2]*p[2])
zz += m*(p[1]*p[1] + p[0]*p[0])
xy -= m*p[0]*p[1]
xz -= m*p[0]*p[2]
yz -= m*p[1]*p[2]
covm = np.array([[xx,xy,xz],[xy,yy,yz],[xz,yz,zz]])
res = np.linalg.eigvals(covm)
return sorted(res)
if __name__ == '__main__':

123
Code/GraphMol/Descriptors/test_data/pmi.sdf Normal file
View File

@@ -0,0 +1,123 @@
XX_0000000001_001_001_001
RDKit 3D
5 4 0 0 0 0 0 0 0 0999 V2000
-0.0372 1.5779 0.0423 C 0 0 0 0 0 0 0 0 0 0 0 0
-0.0107 0.0264 0.0242 C 0 0 0 0 0 0 0 0 0 0 0 0
0.6771 -0.4966 -1.1839 N 0 0 0 0 0 0 0 0 0 0 0 0
0.7202 -1.9805 -1.2328 C 0 0 0 0 0 0 0 0 0 0 0 0
1.4448 -2.4914 -2.5064 C 0 0 0 0 0 0 0 0 0 0 0 0
1 2 1 0
2 3 1 0
3 4 1 0
4 5 1 0
M CHG 1 3 1
M END
> <SMILES_USERINPUT>
CCNCC
> <STATUS>
OK
> <COMMENT>
correct SMILES 3D structure successfully generated (#structures: 1; Protonation Abundance: 99.95%; Tautomerisation Abundance: 100%)
> <npr2>
0.94636673
> <npr1>
0.11207375
> <pmi2>
251.33347
> <pmi1>
29.764236
> <pmi3>
265.57724
> <pmi>
273.33746
> <pmiY>
167.30069
> <pmiZ>
75.545876
> <pmiX>
30.490913
$$$$
XX_0000000002_001_001_001
RDKit 3D
12 12 0 0 0 0 0 0 0 0999 V2000
0.1906 1.4156 0.2263 C 0 0 0 0 0 0 0 0 0 0 0 0
-0.0330 -0.1087 0.0412 C 0 0 0 0 0 0 0 0 0 0 0 0
0.7670 -0.7169 -0.9973 O 0 0 0 0 0 0 0 0 0 0 0 0
2.1979 -0.6480 -0.8048 C 0 0 0 0 0 0 0 0 0 0 0 0
2.8054 0.6364 -1.4304 C 0 0 0 0 0 0 0 0 0 0 0 0
3.8673 0.1208 -2.4291 C 0 0 0 0 0 0 0 0 0 0 0 0
3.3100 -1.1675 -2.8908 N 0 0 0 0 0 0 0 0 0 0 0 0
2.8358 -1.7942 -1.6373 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.5059 -0.3843 -0.3459 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.7966 0.2344 -1.5223 F 0 0 0 0 0 0 0 0 0 0 0 0
-1.6904 -1.7245 -0.4953 F 0 0 0 0 0 0 0 0 0 0 0 0
-2.3503 0.0713 0.6196 F 0 0 0 0 0 0 0 0 0 0 0 0
1 2 1 0
2 3 1 0
2 9 1 0
3 4 1 0
4 8 1 0
4 5 1 0
5 6 1 0
6 7 1 0
7 8 1 0
9 10 1 0
9 11 1 0
9 12 1 0
M CHG 1 7 1
M END
> <SMILES_USERINPUT>
C1CNCC1OC(C(F)(F)F)C
> <STATUS>
OK
> <COMMENT>
correct SMILES 3D structure successfully generated (#structures: 4; Protonation Abundance: 99.88%; Tautomerisation Abundance: 100%)
> <npr2>
0.91831785
> <npr1>
0.22067128
> <pmi2>
1084.2975
> <pmi1>
260.55609
> <pmi3>
1180.7432
> <pmi>
1262.7983
> <pmiY>
167.13344
> <pmiZ>
209.69215
> <pmiX>
885.97278
$$$$

229
Code/GraphMol/MolTransforms/MolTransforms.cpp
View File

@@ -59,52 +59,51 @@ RDGeom::Point3D computeCentroid(const Conformer &conf, bool ignoreHs) {
}
namespace {
void computeCovarianceTerms(const Conformer &conf,
const RDGeom::Point3D &center,
double &xx, double &xy, double &xz, double &yy, double &yz, double &zz,
bool normalize, bool ignoreHs,
const std::vector<double> *weights ){
PRECONDITION(!weights || weights->size()>=conf.getNumAtoms(), "bad weights vector");
xx = xy = xz = yy = yz = zz = 0.0;
const ROMol &mol = conf.getOwningMol();
double wSum = 0.0;
for (ROMol::ConstAtomIterator cai = mol.beginAtoms();
cai != mol.endAtoms(); cai++) {
if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
continue;
}
RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
loc -= center;
if(weights) {
double w = (*weights)[(*cai)->getIdx()];
wSum += w;
loc *= w;
} else {
wSum+=1.0;
}
xx += loc.x * loc.x;
xy += loc.x * loc.y;
xz += loc.x * loc.z;
yy += loc.y * loc.y;
yz += loc.y * loc.z;
zz += loc.z * loc.z;
const RDGeom::Point3D &center, double &xx,
double &xy, double &xz, double &yy, double &yz,
double &zz, bool normalize, bool ignoreHs,
const std::vector<double> *weights) {
PRECONDITION(!weights || weights->size() >= conf.getNumAtoms(),
"bad weights vector");
xx = xy = xz = yy = yz = zz = 0.0;
const ROMol &mol = conf.getOwningMol();
double wSum = 0.0;
for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
cai++) {
if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
continue;
}
if (normalize) {
xx /= wSum;
xy /= wSum;
xz /= wSum;
yy /= wSum;
yz /= wSum;
zz /= wSum;
RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
loc -= center;
double w = 1.0;
if (weights) {
w = (*weights)[(*cai)->getIdx()];
}
wSum += w;
xx += w * loc.x * loc.x;
xy += w * loc.x * loc.y;
xz += w * loc.x * loc.z;
yy += w * loc.y * loc.y;
yz += w * loc.y * loc.z;
zz += w * loc.z * loc.z;
}
if (normalize) {
xx /= wSum;
xy /= wSum;
xz /= wSum;
yy /= wSum;
yz /= wSum;
zz /= wSum;
}
}
RDNumeric::DoubleSymmMatrix *computeCovarianceMatrix(
const Conformer &conf, const RDGeom::Point3D &center, bool normalize,
bool ignoreHs) {
double xx, xy, xz, yy, yz, zz;
computeCovarianceTerms(conf,center,xx,xy,xz,yy,yz,zz,normalize,ignoreHs,NULL);
computeCovarianceTerms(conf, center, xx, xy, xz, yy, yz, zz, normalize,
ignoreHs, NULL);
RDNumeric::DoubleSymmMatrix *res = new RDNumeric::DoubleSymmMatrix(3, 3);
res->setVal(0, 0, xx);
res->setVal(0, 1, xy);
@@ -114,69 +113,147 @@ RDNumeric::DoubleSymmMatrix *computeCovarianceMatrix(
res->setVal(2, 2, zz);
return res;
}
void computeInertiaTerms(const Conformer &conf, const RDGeom::Point3D &center,
double &xx, double &xy, double &xz, double &yy,
double &yz, double &zz, bool ignoreHs,
const std::vector<double> *weights) {
PRECONDITION(!weights || weights->size() >= conf.getNumAtoms(),
"bad weights vector");
xx = xy = xz = yy = yz = zz = 0.0;
const ROMol &mol = conf.getOwningMol();
for (ROMol::ConstAtomIterator cai = mol.beginAtoms(); cai != mol.endAtoms();
cai++) {
if (((*cai)->getAtomicNum() == 1) && (ignoreHs)) {
continue;
}
RDGeom::Point3D loc = conf.getAtomPos((*cai)->getIdx());
loc -= center;
double w = 1.0;
if (weights) {
w = (*weights)[(*cai)->getIdx()];
}
xx += w * (loc.y * loc.y + loc.z * loc.z);
yy += w * (loc.x * loc.x + loc.z * loc.z);
zz += w * (loc.y * loc.y + loc.x * loc.x);
xy -= w * loc.x * loc.y;
xz -= w * loc.x * loc.z;
yz -= w * loc.z * loc.y;
}
}
}
#ifdef RDK_HAS_EIGEN3
#include <Eigen/Dense>
bool computePrincipalAxesAndMoments(
const RDKit::Conformer &conf,
Eigen::Matrix3d &axes,
Eigen::Vector3d &moments,
bool ignoreHs,
bool force,
const std::vector<double> *weights){
PRECONDITION((!weights || weights->size()>=conf.getNumAtoms()),"bad weights vector");
bool computePrincipalAxesAndMoments(const RDKit::Conformer &conf,
Eigen::Matrix3d &axes,
Eigen::Vector3d &moments, bool ignoreHs,
bool force,
const std::vector<double> *weights) {
PRECONDITION((!weights || weights->size() >= conf.getNumAtoms()),
"bad weights vector");
const char *axesPropName = ignoreHs ? "_principalAxes_noH" : "_principalAxes";
const char *momentsPropName = ignoreHs ? "_principalMoments_noH" : "_principalMoments";
if(!weights && !force &&
conf.getOwningMol().hasProp(axesPropName) &&
conf.getOwningMol().hasProp(momentsPropName) ){
conf.getOwningMol().getProp(axesPropName,axes);
conf.getOwningMol().getProp(momentsPropName,moments);
const char *momentsPropName =
ignoreHs ? "_principalMoments_noH" : "_principalMoments";
if (!weights && !force && conf.getOwningMol().hasProp(axesPropName) &&
conf.getOwningMol().hasProp(momentsPropName)) {
conf.getOwningMol().getProp(axesPropName, axes);
conf.getOwningMol().getProp(momentsPropName, moments);
return true;
}
const ROMol &mol=conf.getOwningMol();
RDGeom::Point3D origin(0,0,0);
double wSum=0.0;
for(unsigned int i=0;i<conf.getNumAtoms();++i){
if(ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum()==1) continue;
double w=1.0;
if(weights){
w=(*weights)[i];
const ROMol &mol = conf.getOwningMol();
RDGeom::Point3D origin(0, 0, 0);
double wSum = 0.0;
for (unsigned int i = 0; i < conf.getNumAtoms(); ++i) {
if (ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum() == 1) continue;
double w = 1.0;
if (weights) {
w = (*weights)[i];
}
wSum+=w;
origin+=conf.getAtomPos(i)*w;
wSum += w;
origin += conf.getAtomPos(i) * w;
}
// std::cerr<<" origin: "<<origin<<" "<<wSum<<std::endl;
origin /= wSum;
double sumXX,sumXY,sumXZ,sumYY,sumYZ,sumZZ;
computeCovarianceTerms(conf,origin,sumXX,sumXY,sumXZ,sumYY,sumYZ,sumZZ,
true,ignoreHs,weights);
double sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ;
computeInertiaTerms(conf, origin, sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ,
ignoreHs, weights);
Eigen::Matrix3d mat;
mat << sumXX, sumXY, sumXZ,
sumXY, sumYY, sumYZ,
sumXZ, sumYZ, sumZZ;
mat << sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ;
// std::cerr<<" matrix: "<<mat<<std::endl;
Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(mat);
if(eigensolver.info()!=Eigen::Success){
BOOST_LOG(rdErrorLog)<<"eigenvalue calculation did not converge"<<std::endl;
if (eigensolver.info() != Eigen::Success) {
BOOST_LOG(rdErrorLog) << "eigenvalue calculation did not converge"
<< std::endl;
return false;
}
axes = eigensolver.eigenvectors();
moments = eigensolver.eigenvalues();
if(!weights) {
conf.getOwningMol().setProp(axesPropName,axes, true);
conf.getOwningMol().setProp(momentsPropName,moments, true);
if (!weights) {
conf.getOwningMol().setProp(axesPropName, axes, true);
conf.getOwningMol().setProp(momentsPropName, moments, true);
}
return true;
}
bool computePrincipalAxesAndMomentsFromGyrationMatrix(
const RDKit::Conformer &conf, Eigen::Matrix3d &axes,
Eigen::Vector3d &moments, bool ignoreHs, bool force,
const std::vector<double> *weights) {
PRECONDITION((!weights || weights->size() >= conf.getNumAtoms()),
"bad weights vector");
const char *axesPropName =
ignoreHs ? "_principalAxes_noH_cov" : "_principalAxes_cov";
const char *momentsPropName =
ignoreHs ? "_principalMoments_noH_cov" : "_principalMoments_cov";
if (!weights && !force && conf.getOwningMol().hasProp(axesPropName) &&
conf.getOwningMol().hasProp(momentsPropName)) {
conf.getOwningMol().getProp(axesPropName, axes);
conf.getOwningMol().getProp(momentsPropName, moments);
return true;
}
const ROMol &mol = conf.getOwningMol();
RDGeom::Point3D origin(0, 0, 0);
double wSum = 0.0;
for (unsigned int i = 0; i < conf.getNumAtoms(); ++i) {
if (ignoreHs && mol.getAtomWithIdx(i)->getAtomicNum() == 1) continue;
double w = 1.0;
if (weights) {
w = (*weights)[i];
}
wSum += w;
origin += conf.getAtomPos(i) * w;
}
// std::cerr<<" origin: "<<origin<<" "<<wSum<<std::endl;
origin /= wSum;
double sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ;
computeCovarianceTerms(conf, origin, sumXX, sumXY, sumXZ, sumYY, sumYZ, sumZZ,
true, ignoreHs, weights);
Eigen::Matrix3d mat;
mat << sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ;
// std::cerr<<" matrix: "<<mat<<std::endl;
Eigen::SelfAdjointEigenSolver<Eigen::Matrix3d> eigensolver(mat);
if (eigensolver.info() != Eigen::Success) {
BOOST_LOG(rdErrorLog) << "eigenvalue calculation did not converge"
<< std::endl;
return false;
}
axes = eigensolver.eigenvectors();
moments = eigensolver.eigenvalues();
if (!weights) {
conf.getOwningMol().setProp(axesPropName, axes, true);
conf.getOwningMol().setProp(momentsPropName, moments, true);
}
return true;
}
#endif
RDGeom::Transform3D *computeCanonicalTransform(const Conformer &conf,
const RDGeom::Point3D *center,
bool normalizeCovar,
@@ -356,8 +433,8 @@ void setBondLength(Conformer &conf, unsigned int iAtomId, unsigned int jAtomId,
}
}
double getAngleRad(const Conformer &conf, unsigned int iAtomId, unsigned int jAtomId,
unsigned int kAtomId) {
double getAngleRad(const Conformer &conf, unsigned int iAtomId,
unsigned int jAtomId, unsigned int kAtomId) {
const RDGeom::POINT3D_VECT &pos = conf.getPositions();
URANGE_CHECK(iAtomId, pos.size() - 1);
URANGE_CHECK(jAtomId, pos.size() - 1);

45
Code/GraphMol/MolTransforms/MolTransforms.h
View File

@@ -43,28 +43,53 @@ RDGeom::Point3D computeCentroid(const RDKit::Conformer &conf,
bool ignoreHs = true);
#ifdef RDK_HAS_EIGEN3
//! Compute principal axes and moments for a conformer
//! Compute principal axes and moments of inertia for a conformer
/*!
These values are calculated from the inertia tensor:
Iij = - sum_{s=1..N}(w_s * r_{si} * r_{sj}) i != j
Iii = sum_{s=1..N} sum_{j!=i} (w_s * r_{sj} * r_{sj})
where the coordinates are relative to the center of mass.
\param conf Conformer of interest
\param axes used to return the principal axes
\param moments used to return the principal moments
\param ignoreHs If true, ignore hydrogen atoms
\param force If true, the calculation will be carried out even if a cached value is present
\param force If true, the calculation will be carried out even if a
cached value is present
\param weights If present used to weight the atomic coordinates
\returns whether or not the calculation was successful
*/
bool computePrincipalAxesAndMoments(
const RDKit::Conformer &conf,
Eigen::Matrix3d &axes,
Eigen::Vector3d &moments,
bool ignoreHs = true,
bool force = false,
bool computePrincipalAxesAndMoments(const RDKit::Conformer &conf,
Eigen::Matrix3d &axes,
Eigen::Vector3d &moments,
bool ignoreHs = false, bool force = false,
const std::vector<double> *weights = NULL);
//! Compute principal axes and moments from the gyration matrix of a conformer
/*!
These values are calculated from the gyration matrix/tensor:
Iij = sum_{s=1..N}(w_s * r_{si} * r_{sj}) i != j
Iii = sum_{s=1..N} sum_{t!=s}(w_s * r_{si} * r_{ti})
where the coordinates are relative to the center of mass.
\param conf Conformer of interest
\param axes used to return the principal axes
\param moments used to return the principal moments
\param ignoreHs If true, ignore hydrogen atoms
\param force If true, the calculation will be carried out even if a
cached value is present
\param weights If present used to weight the atomic coordinates
\returns whether or not the calculation was successful
*/
bool computePrincipalAxesAndMomentsFromGyrationMatrix(
const RDKit::Conformer &conf, Eigen::Matrix3d &axes,
Eigen::Vector3d &moments, bool ignoreHs = false, bool force = false,
const std::vector<double> *weights = NULL);
#endif
//! Compute the transformation require to orient the conformation
//! along the principal axes about the center; i.e. center is made to coincide
// with the

71
Code/GraphMol/MolTransforms/test1.cpp
View File

@@ -1,6 +1,5 @@
// $Id$
//
// Copyright (C) 2003-2006 Rational Discovery LLC
// Copyright (C) 2003-2017 Greg Landrum and Rational Discovery LLC
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
@@ -202,6 +201,71 @@ void testGetSetDihedral() {
TEST_ASSERT(RDKit::feq(dihedral, -120.0));
}
#ifndef RDK_HAS_EIGEN3
void testGithub1262() {}
#else
void _calcAxesAndMoments(RWMol *m, Eigen::Matrix3d &axes,
Eigen::Vector3d &moments) {
TEST_ASSERT(m);
Conformer &conf = m->getConformer();
std::vector<double> weights;
weights.resize(m->getNumAtoms());
for (ROMol::AtomIterator cai = m->beginAtoms(); cai != m->endAtoms(); ++cai) {
weights[(*cai)->getIdx()] = (*cai)->getMass();
}
bool ignoreHs = false, force = true;
computePrincipalAxesAndMoments(conf, axes, moments, ignoreHs, force,
&weights);
}
void testGithub1262() {
std::string rdbase = getenv("RDBASE");
{ // a disc (benzene)
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_1.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
Eigen::Matrix3d axes;
Eigen::Vector3d moments;
_calcAxesAndMoments(m, axes, moments);
TEST_ASSERT((moments(2) - moments(0)) > 10.);
TEST_ASSERT((moments(2) - moments(1)) > 10.);
TEST_ASSERT((moments(1) - moments(0)) < 1e-2);
delete m;
}
{ // a rod
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_2.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
Eigen::Matrix3d axes;
Eigen::Vector3d moments;
_calcAxesAndMoments(m, axes, moments);
TEST_ASSERT((moments(2) - moments(0)) > 10.);
TEST_ASSERT((moments(2) - moments(1)) < 1e-2);
TEST_ASSERT((moments(1) - moments(0)) > 10);
delete m;
}
{ // adamantane
std::string fName =
rdbase + "/Code/GraphMol/MolTransforms/test_data/github1262_3.mol";
RWMol *m = MolFileToMol(fName, true, false);
TEST_ASSERT(m);
Eigen::Matrix3d axes;
Eigen::Vector3d moments;
_calcAxesAndMoments(m, axes, moments);
TEST_ASSERT((moments(2) - moments(0)) < 1e-2);
TEST_ASSERT((moments(2) - moments(1)) < 1e-2);
TEST_ASSERT((moments(1) - moments(0)) < 1e-2);
delete m;
}
}
#endif
int main() {
// test1();
std::cout << "***********************************************************\n";
@@ -219,6 +283,9 @@ int main() {
std::cout << "\t---------------------------------\n";
std::cout << "\t testGetSetDihedral \n\n";
testGetSetDihedral();
std::cout << "\t---------------------------------\n";
std::cout << "\t testGithub1262: PMI descriptors incorrect \n\n";
testGithub1262();
std::cout << "***********************************************************\n";
return (0);
}

29
Code/GraphMol/MolTransforms/test_data/github1262_1.mol Normal file
View File

@@ -0,0 +1,29 @@
benzene
RDKit 3D
12 12 0 0 0 0 0 0 0 0999 V2000
1.2930 0.5342 0.0022 C 0 0 0 0 0 0 0 0 0 0 0 0
0.1839 1.3868 -0.0124 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.1091 0.8526 -0.0146 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.2930 -0.5342 -0.0022 C 0 0 0 0 0 0 0 0 0 0 0 0
-0.1839 -1.3868 0.0124 C 0 0 0 0 0 0 0 0 0 0 0 0
1.1091 -0.8526 0.0146 C 0 0 0 0 0 0 0 0 0 0 0 0
2.2934 0.9475 0.0038 H 0 0 0 0 0 0 0 0 0 0 0 0
0.3262 2.4598 -0.0220 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.9672 1.5122 -0.0258 H 0 0 0 0 0 0 0 0 0 0 0 0
-2.2934 -0.9475 -0.0038 H 0 0 0 0 0 0 0 0 0 0 0 0
-0.3262 -2.4598 0.0220 H 0 0 0 0 0 0 0 0 0 0 0 0
1.9672 -1.5122 0.0258 H 0 0 0 0 0 0 0 0 0 0 0 0
1 2 2 0
2 3 1 0
3 4 2 0
4 5 1 0
5 6 2 0
6 1 1 0
1 7 1 0
2 8 1 0
3 9 1 0
4 10 1 0
5 11 1 0
6 12 1 0
M END

24
Code/GraphMol/MolTransforms/test_data/github1262_2.mol Normal file
View File

@@ -0,0 +1,24 @@
rod
RDKit 3D
10 9 0 0 0 0 0 0 0 0999 V2000
2.0570 0.0543 0.1822 C 0 0 0 0 0 0 0 0 0 0 0 0
0.6002 0.0158 0.0532 C 0 0 0 0 0 0 0 0 0 0 0 0
-0.6002 -0.0158 -0.0532 C 0 0 0 0 0 0 0 0 0 0 0 0
-2.0570 -0.0543 -0.1822 C 0 0 0 0 0 0 0 0 0 0 0 0
2.3299 0.4769 1.1710 H 0 0 0 0 0 0 0 0 0 0 0 0
2.4635 -0.9743 0.0949 H 0 0 0 0 0 0 0 0 0 0 0 0
2.4830 0.6895 -0.6215 H 0 0 0 0 0 0 0 0 0 0 0 0
-2.4976 0.8223 0.3359 H 0 0 0 0 0 0 0 0 0 0 0 0
-2.4445 -0.9876 0.2758 H 0 0 0 0 0 0 0 0 0 0 0 0
-2.3342 -0.0268 -1.2561 H 0 0 0 0 0 0 0 0 0 0 0 0
1 2 1 0
2 3 3 0
3 4 1 0
1 5 1 0
1 6 1 0
1 7 1 0
4 8 1 0
4 9 1 0
4 10 1 0
M END

59
Code/GraphMol/MolTransforms/test_data/github1262_3.mol Normal file
View File

@@ -0,0 +1,59 @@
adamantane
RDKit 3D
26 28 0 0 0 0 0 0 0 0999 V2000
0.9283 1.4942 -0.2956 C 0 0 0 0 0 0 0 0 0 0 0 0
0.4514 1.0012 1.0893 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.0903 0.8936 1.0930 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.5432 -0.1064 0.0051 C 0 0 0 0 0 0 0 0 0 0 0 0
-0.9283 -1.4942 0.2956 C 0 0 0 0 0 0 0 0 0 0 0 0
0.6136 -1.3898 0.2909 C 0 0 0 0 0 0 0 0 0 0 0 0
1.0903 -0.8936 -1.0930 C 0 0 0 0 0 0 0 0 0 0 0 0
0.4781 0.4950 -1.3853 C 0 0 0 0 0 0 0 0 0 0 0 0
-1.0636 0.3881 -1.3783 C 0 0 0 0 0 0 0 0 0 0 0 0
1.0636 -0.3881 1.3783 C 0 0 0 0 0 0 0 0 0 0 0 0
2.0363 1.5911 -0.3034 H 0 0 0 0 0 0 0 0 0 0 0 0
0.5063 2.5015 -0.5062 H 0 0 0 0 0 0 0 0 0 0 0 0
0.7758 1.7206 1.8722 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.5412 1.8922 0.9023 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.4450 0.5552 2.0913 H 0 0 0 0 0 0 0 0 0 0 0 0
-2.6522 -0.1829 0.0088 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.2807 -1.8667 1.2825 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.2618 -2.2258 -0.4729 H 0 0 0 0 0 0 0 0 0 0 0 0
1.0546 -2.3886 0.4999 H 0 0 0 0 0 0 0 0 0 0 0 0
2.2006 -0.8309 -1.1122 H 0 0 0 0 0 0 0 0 0 0 0 0
0.7856 -1.6166 -1.8813 H 0 0 0 0 0 0 0 0 0 0 0 0
0.8217 0.8508 -2.3808 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.5141 1.3796 -1.6044 H 0 0 0 0 0 0 0 0 0 0 0 0
-1.3991 -0.3165 -2.1708 H 0 0 0 0 0 0 0 0 0 0 0 0
2.1735 -0.3182 1.3944 H 0 0 0 0 0 0 0 0 0 0 0 0
0.7397 -0.7449 2.3807 H 0 0 0 0 0 0 0 0 0 0 0 0
1 2 1 0
2 3 1 0
3 4 1 0
4 5 1 0
5 6 1 0
6 7 1 0
7 8 1 0
8 9 1 0
6 10 1 0
8 1 1 0
9 4 1 0
10 2 1 0
1 11 1 0
1 12 1 0
2 13 1 0
3 14 1 0
3 15 1 0
4 16 1 0
5 17 1 0
5 18 1 0
6 19 1 0
7 20 1 0
7 21 1 0
8 22 1 0
9 23 1 0
9 24 1 0
10 25 1 0
10 26 1 0
M END