pub_soft/rdkit
3
0
Fork 0
mirror of https://github.com/rdkit/rdkit.git synced 2026-06-04 21:54:27 +08:00
Code Issues Packages Projects Releases Wiki Activity
Files
3ce201603979cc5bd4897249152d884b90b701cc
rdkit/Code/GraphMol/Descriptors/test3D.cpp
Ric a6b26253ff Fix (most of) mem problems (#2123) 
* do not use new on loggers

* del pointers in testDistGeom

* Update Dict hasNonPOD status on bulk update

* delete new Dicts in memtest1.cpp

* fixes in MolSuppliers and testFMCS

* PeriodicTable singleton as unique_ptr

* fix EEM_arrays leak

* fix leaks in testPBF

* fix ParamCollection leak in test UFF

* fix leaks in MMFF

* clear prop dict before read in in pickler

* fix leaks in testFreeSASA

* fix leaks in test3D

* modernize Dict.h & SmilesParse.cpp

* fix leaks in testQuery

* fix leaks in testCrystalFF

* fix leaks in cxsmilesTest

* fix leaks in Catalog & mol cat test

* fix leaks in ShapeUtils & tests

* fix leaks in testSubgraphs1

* fix leaks testFingerprintGenerators

* fix leaks in Catalog/FilterCatalog

* fix leaks in graphmolqueryTest

* these changes reduce bison parse leaks

* fixed leaks in testChirality.cpp

* fix leaks + 2 tests in testMolWriter

* fix 4m leaks in substructLibraryTest

* small improvements to molTautomerTest; still leaks

* fix leaks in testRGroupDecomp

* fix leaks in test; parser still leaks

* fix leaks in itertest

* fix 4m leaks in testDepictor

* fixes in smatest; still leaking due to parser

* fixes in testSLNParse; still leaking due to parser

* flex/bison: always add atoms with ownership; smarts error cleanup

* fix leaks in testReaction

* fix leaks in testSubstructMatch

* fix leaks in resMolSupplierTest

* fix leaks in testChemTransforms + bug in ChemTransforms

* fix leaks in testPickler

* fix leaks in testMolTransform

* fix leaks in testFragCatalog

* fix leak in testSLNParse. Still leaks due to Smiles

* fixed most leaks in testMolSupplier

* pre bison fix

* fix some atom & bond parse problems; others still fail

* bison smiles & smarts, atoms & bonds more or less fixed

* fix leaks in molopstest.cpp

* fix leaks in testFingerprints, MACCS.cpp & AtomPairs.cpp

* fix leaks in moldraw2Dtest1

* fix leaks in testDescriptors

* fix leaks in testInchi

* fix leaks in testUFFForceFieldHelpers

* fix leaks in hanoiTest & new_canon.h

* fix leaks in testMMFFForceField

* fix leaks in graphmolTest1

* fix leaks in testMMFFForceFieldHelpers

* fix leaks in testDistGeomHelpers

* fix leaks in testMolAlign

* initialize occupancy & temp facto with default values

* fix leak in TautomerTransform

* updated suppressions

* fix testStructChecker

* fix logging & py tests

* fix TautomerTransform class/struct issue

* remove misplaced delete in testSLNParse

* deinit in testAvalonLib1

* fix Avalon-triggered(?) bug in StructChecker/Pattern.cpp

* fix random testMolWriter/Supplier fails

- diversify output file names to avoid clashing.
- unify Writers close/destruct behavior.
- flushing/closing in tests.

* use reset in FFs Params.cpp

* comments on testMMFFForceField

* unrequired 'if's added to mol suppliers

* correct cast in FilterCatalog.h

* use unique_ptr in MACCS Patterns

* remove unrequred if in new_canon

* update & move suppressions
2018-10-29 14:33:26 +00:00

533 lines
17 KiB
C++
Raw Blame History

//
// Copyright (C) 2016 Greg Landrum
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#ifdef _MSC_VER
// disable warnings about getenv in visual C++
#define _CRT_SECURE_NO_WARNINGS
#endif
#include <RDGeneral/test.h>
#include <iostream>
#include <fstream>
#include <RDGeneral/BoostStartInclude.h>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/lexical_cast.hpp>
#include <RDGeneral/BoostEndInclude.h>
#include <RDGeneral/Invariant.h>
#include <RDGeneral/RDLog.h>
#include <RDGeneral/utils.h>
#include <RDGeneral/StreamOps.h>
#include <GraphMol/RDKitBase.h>
#include <GraphMol/SmilesParse/SmilesParse.h>
#include <GraphMol/FileParsers/FileParsers.h>
#include <GraphMol/FileParsers/MolSupplier.h>
#include <GraphMol/Descriptors/MolDescriptors3D.h>
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) > tol) {
std::cerr << "value mismatch: " << inm << " " << ref << " " << val
<< std::endl;
}
return fabs(ref - val) < tol;
}
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";
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();
TEST_ASSERT(m);
RDKit::ROMol mcpy(*m);
std::string nm;
m->getProp("_Name", nm);
std::string inm;
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;
val = RDKit::Descriptors::PMI1(*m);
TEST_ASSERT(compare(inm, pmi1_m, val));
val = RDKit::Descriptors::PMI2(*m);
TEST_ASSERT(compare(inm, pmi2_m, val));
val = RDKit::Descriptors::PMI3(*m);
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));
// 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);
TEST_ASSERT(compare(inm, pmi1_m, val));
val = RDKit::Descriptors::PMI2(mcpy);
TEST_ASSERT(compare(inm, pmi2_m, val));
val = RDKit::Descriptors::PMI3(mcpy);
TEST_ASSERT(compare(inm, pmi3_m, val));
delete m;
++nDone;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
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";
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(fabs(val) >= 10);
val = RDKit::Descriptors::PMI3(*m);
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";
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(fabs(val) >= 1);
val = RDKit::Descriptors::PMI3(*m);
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
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;
}
{
RDKit::RWMol m;
bool updateLabel = true;
bool takeOwnership = true;
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val = RDKit::Descriptors::PMI1(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI2(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::PMI3(m);
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;
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);
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);
double val;
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);
val = RDKit::Descriptors::NPR1(*m);
compare(nm, pmi1_m / pmi3_m, val);
val = RDKit::Descriptors::NPR2(*m);
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;
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
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";
RDKit::ROMol *m = MolFileToMol(sdfName);
TEST_ASSERT(m);
double val;
val = RDKit::Descriptors::NPR1(*m);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
val = RDKit::Descriptors::NPR2(*m);
TEST_ASSERT(fabs(val - 0.5) < 1e-4);
delete m;
}
{
RDKit::RWMol m;
bool updateLabel = true;
bool takeOwnership = true;
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val = RDKit::Descriptors::NPR1(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::NPR2(m);
TEST_ASSERT(fabs(val) < 1e-4);
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
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;
{ // octahedron
RDKit::RWMol m;
bool updateLabel = true;
bool takeOwnership = true;
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(1), updateLabel, takeOwnership);
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));
double val;
val = RDKit::Descriptors::radiusOfGyration(m);
TEST_ASSERT(fabs(val) > 0.1);
val = RDKit::Descriptors::eccentricity(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::asphericity(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::spherocityIndex(m);
TEST_ASSERT(fabs(1. - val) < 1e-4);
}
{
RDKit::RWMol m;
bool updateLabel = true;
bool takeOwnership = true;
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addAtom(new RDKit::Atom(6), updateLabel, takeOwnership);
m.addConformer(new RDKit::Conformer(m.getNumAtoms()));
double val;
val = RDKit::Descriptors::radiusOfGyration(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::inertialShapeFactor(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::eccentricity(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::asphericity(m);
TEST_ASSERT(fabs(val) < 1e-4);
val = RDKit::Descriptors::spherocityIndex(m);
TEST_ASSERT(fabs(val) < 1e-4);
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
void testInertialShapeFactor() {
BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl;
BOOST_LOG(rdErrorLog) << " Inertial shape factor." << std::endl;
{
std::string pathName = getenv("RDBASE");
std::string sdfName =
pathName + "/Code/GraphMol/Descriptors/test_data/doravirine.mol";
bool sanitize = true, removeHs = false;
std::unique_ptr<RDKit::ROMol> m(MolFileToMol(sdfName, sanitize, removeHs));
TEST_ASSERT(m);
auto pmi1 = RDKit::Descriptors::PMI1(*m);
auto pmi2 = RDKit::Descriptors::PMI2(*m);
auto pmi3 = RDKit::Descriptors::PMI3(*m);
auto isf = RDKit::Descriptors::inertialShapeFactor(*m);
TEST_ASSERT(feq(isf, pmi2 / (pmi1 * pmi3)));
}
BOOST_LOG(rdErrorLog) << " done" << std::endl;
}
//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//
//-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
int main() {
RDLog::InitLogs();
#if 1
testPMI1();
testPMI2();
testNPR1();
testPMIEdges();
testNPREdges();
test3DVals();
test3DEdges();
#endif
testInertialShapeFactor();
}
Reference in New Issue View Git Blame Copy Permalink