void testGithub186(){ BOOST_LOG(rdInfoLog) << "testing github issue 186: chiral S not written to ctab" << std::endl; std::string rdbase = getenv("RDBASE"); rdbase += "/Code/GraphMol/FileParsers/test_data/"; { std::string fName = rdbase + "github186.mol"; RWMol *m = MolFileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==11); TEST_ASSERT(m->getNumBonds()==10); TEST_ASSERT(m->getAtomWithIdx(6)->getChiralTag()!=Atom::CHI_UNSPECIFIED && m->getAtomWithIdx(6)->getChiralTag()!=Atom::CHI_OTHER ); std::string mb=MolToMolBlock(*m); delete m; m = MolBlockToMol(mb); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==11); TEST_ASSERT(m->getNumBonds()==10); TEST_ASSERT(m->getAtomWithIdx(6)->getChiralTag()!=Atom::CHI_UNSPECIFIED && m->getAtomWithIdx(6)->getChiralTag()!=Atom::CHI_OTHER ); delete m; } }
void testGithub187(){ BOOST_LOG(rdInfoLog) << "testing github issue 187: A not written to mol block" << std::endl; std::string rdbase = getenv("RDBASE"); rdbase += "/Code/GraphMol/FileParsers/test_data/"; { std::string fName = rdbase + "github187.mol"; RWMol *m = MolFileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==1); TEST_ASSERT(m->getNumBonds()==0); TEST_ASSERT(m->getAtomWithIdx(0)->hasQuery()); std::string mb=MolToMolBlock(*m); TEST_ASSERT(mb.find(" A 0")!=std::string::npos); // try the v3000 version: mb=MolToMolBlock(*m,true,-1,true,true); TEST_ASSERT(mb.find("V30 1 A 0")!=std::string::npos); delete m; } { std::string fName = rdbase + "github187.v3k.mol"; RWMol *m = MolFileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==1); TEST_ASSERT(m->getNumBonds()==0); TEST_ASSERT(m->getAtomWithIdx(0)->hasQuery()); std::string mb=MolToMolBlock(*m); TEST_ASSERT(mb.find(" A 0")!=std::string::npos); // try the v3000 version: mb=MolToMolBlock(*m,true,-1,true,true); TEST_ASSERT(mb.find("V30 1 A 0")!=std::string::npos); delete m; } { std::string fName = rdbase + "github187.2.mol"; RWMol *m = MolFileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==1); TEST_ASSERT(m->getNumBonds()==0); TEST_ASSERT(m->getAtomWithIdx(0)->hasQuery()); std::string mb=MolToMolBlock(*m); TEST_ASSERT(mb.find(" Q 0")!=std::string::npos); // try the v3000 version: mb=MolToMolBlock(*m,true,-1,true,true); TEST_ASSERT(mb.find("V30 1 \"NOT [C,H]\" 0")!=std::string::npos); delete m; } BOOST_LOG(rdInfoLog) << "done" << std::endl; }
void testV3000WriterDetails(){ BOOST_LOG(rdInfoLog) << "testing details of v3000 writing" << std::endl; std::string rdbase = getenv("RDBASE"); rdbase += "/Code/GraphMol/FileParsers/test_data/"; { std::string fName = rdbase + "chebi_57262.v3k.mol"; RWMol *m = MolFileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==22); TEST_ASSERT(m->getNumBonds()==21); TEST_ASSERT(m->getAtomWithIdx(18)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(18)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(18)->getIsotope()==1); TEST_ASSERT(m->getAtomWithIdx(21)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(21)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(21)->getIsotope()==2); std::string mb=MolToMolBlock(*m,true,-1,true,true); TEST_ASSERT(mb.find("MASS=1")!=std::string::npos); TEST_ASSERT(mb.find("MASS=2")!=std::string::npos); delete m; m = MolBlockToMol(mb); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==22); TEST_ASSERT(m->getNumBonds()==21); TEST_ASSERT(m->getAtomWithIdx(18)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(18)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(18)->getIsotope()==1); TEST_ASSERT(m->getAtomWithIdx(21)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(21)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(21)->getIsotope()==2); // repeat that one more time to make sure we're really solid: mb=MolToMolBlock(*m,true,-1,true,true); TEST_ASSERT(mb.find("MASS=1")!=std::string::npos); TEST_ASSERT(mb.find("MASS=2")!=std::string::npos); delete m; m = MolBlockToMol(mb); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==22); TEST_ASSERT(m->getNumBonds()==21); TEST_ASSERT(m->getAtomWithIdx(18)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(18)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(18)->getIsotope()==1); TEST_ASSERT(m->getAtomWithIdx(21)->getAtomicNum()==0); TEST_ASSERT(!m->getAtomWithIdx(21)->hasQuery()); TEST_ASSERT(m->getAtomWithIdx(21)->getIsotope()==2); delete m; } BOOST_LOG(rdInfoLog) << "done" << std::endl; }
void testGithubIssue429() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing github issue 429: fragmentOnSomeBonds() should update implicit H count on aromatic heteroatoms when addDummies is False"<< std::endl; { std::string smi = "c1cccn1CC1CC1"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()); unsigned int indices[]={4,5}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); std::vector<ROMOL_SPTR> frags; MolFragmenter::fragmentOnSomeBonds(*mol,bindices,frags,1,false); TEST_ASSERT(frags.size()==2); std::vector<std::vector<int> > fragMap; BOOST_FOREACH(ROMOL_SPTR romol,frags){ RWMol *rwmol=(RWMol *)(romol.get()); MolOps::sanitizeMol(*rwmol); } // we actually changed fragmentOnBonds(), check that too: RWMol *nmol=(RWMol *)MolFragmenter::fragmentOnBonds(*mol,bindices,false); MolOps::sanitizeMol(*nmol); delete nmol; delete mol; }
const std::string GetMolFileQueryInfo(const RWMol &mol){ std::stringstream ss; boost::dynamic_bitset<> listQs(mol.getNumAtoms()); for(ROMol::ConstAtomIterator atomIt=mol.beginAtoms(); atomIt!=mol.endAtoms();++atomIt){ if(hasListQuery(*atomIt)) listQs.set((*atomIt)->getIdx()); } for(ROMol::ConstAtomIterator atomIt=mol.beginAtoms(); atomIt!=mol.endAtoms();++atomIt){ if(!listQs[(*atomIt)->getIdx()] && hasComplexQuery(*atomIt)){ std::string sma=SmartsWrite::GetAtomSmarts(static_cast<const QueryAtom *>(*atomIt)); ss<< "V "<<std::setw(3)<<(*atomIt)->getIdx()+1<<" "<<sma<<std::endl; } } for(ROMol::ConstAtomIterator atomIt=mol.beginAtoms(); atomIt!=mol.endAtoms();++atomIt){ if(listQs[(*atomIt)->getIdx()]){ INT_VECT vals; getListQueryVals((*atomIt)->getQuery(),vals); ss<<"M ALS "<<std::setw(3)<<(*atomIt)->getIdx()+1<<" "; ss<<std::setw(2)<<vals.size(); if((*atomIt)->getQuery()->getNegation()){ ss<<" T"; } else { ss<<" F"; } BOOST_FOREACH(int val,vals){ ss<<" "<<std::setw(3)<<std::left<<(PeriodicTable::getTable()->getElementSymbol(val)); } ss<<"\n"; } }
void test3CubeFiles () { std::string path = getenv ("RDBASE"); path += "/Code/GraphMol/MIF/test_data/"; RWMol mol = *MolFileToMol(path + "HCl.mol", true, false); RealValueVect *data = new RealValueVect (0.0, 125); UniformRealValueGrid3D grd (5.0, 5.0, 5.0, 1.0, new Point3D (0.0, 0.0, 0.0), data); for (unsigned int i = 0; i < grd.getSize (); i++) { grd.setVal (i, double (i / 10.0)); } writeToCubeFile (grd, mol, path + "test3.cube"); UniformRealValueGrid3D grd2; RWMol mol2 = *readFromCubeFile (grd2, path + "test3.cube"); CHECK_INVARIANT(grd.getSize() == grd2.getSize(), "I/O: grid sizes are not the same."); for (unsigned int i = 0; i < grd2.getSize (); i++) { CHECK_INVARIANT(feq(grd2.getVal(i), double(i / 10.0)), "I/O: values in grid are not correct."); } CHECK_INVARIANT(grd.getNumX() == grd2.getNumX(), "I/O: grids are not the same."); CHECK_INVARIANT(grd.getNumY() == grd2.getNumY(), "I/O: grids are not the same."); CHECK_INVARIANT(grd.getNumZ() == grd2.getNumZ(), "I/O: grids are not the same."); CHECK_INVARIANT(feq(grd.getOffset().x, grd2.getOffset().x), "I/O: grids are not the same."); CHECK_INVARIANT(feq(grd.getSpacing(), grd2.getSpacing()), "I/O: grids are not the same."); CHECK_INVARIANT(grd.compareVectors(grd2), "I/O: grids are not the same."); CHECK_INVARIANT(grd.compareParams(grd2), "I/O: grids are not the same."); CHECK_INVARIANT(grd.compareGrids(grd2), "I/O: grids are not the same."); CHECK_INVARIANT(mol.getNumAtoms() == mol2.getNumAtoms(), "I/O: number of atoms are not the same."); for (unsigned int i = 0; i < mol.getNumAtoms (); i++) { CHECK_INVARIANT(mol.getAtomWithIdx (i)->getAtomicNum () == mol2.getAtomWithIdx (i)->getAtomicNum (), "I/O: atoms are not the same"); CHECK_INVARIANT(feq (mol.getConformer ().getAtomPos (i).x, mol2.getConformer ().getAtomPos (i).x), "I/O: atom positions are not the same"); CHECK_INVARIANT(feq (mol.getConformer ().getAtomPos (i).y, mol2.getConformer ().getAtomPos (i).y), "I/O: atom positions are not the same"); CHECK_INVARIANT(feq (mol.getConformer ().getAtomPos (i).z, mol2.getConformer ().getAtomPos (i).z), "I/O: atom positions are not the same"); } }
void test4Coulomb () { std::string path = getenv("RDBASE"); path += "/Code/GraphMol/MIF/test_data/"; RWMol mol = *MolFileToMol(path + "HCl.mol", true, false); computeGasteigerCharges(mol); std::vector<double> charges; std::vector<Point3D> pos; Conformer conf = mol.getConformer(0); for (int i = 0; i < mol.getNumAtoms(); ++i) { charges.push_back(mol.getAtomWithIdx (i)->getProp<double> ("_GasteigerCharge")); pos.push_back(conf.getAtomPos(i)); } UniformRealValueGrid3D grd = *constructGrid(mol); UniformRealValueGrid3D grd2 = *constructGrid(mol); Coulomb coul(mol); calculateDescriptors<Coulomb>(grd, coul); calculateDescriptors<Coulomb>(grd2, Coulomb (charges, pos)); CHECK_INVARIANT(grd.compareGrids(grd2), "Coulomb: Different constructors do not yield the same descriptor."); CHECK_INVARIANT(feq (coul(0.0,0.0,0.0, 1000), 0.0), "Coulomb: Potential between atoms wrong.(should be 0)"); CHECK_INVARIANT(coul(2.0,0.0,0.0, 1000) < 0, "Coulomb: Potential between positive charges not positive."); CHECK_INVARIANT(coul(-2.0,0.0,0.0, 1000) > 0, "Coulomb: Potential between positive and negative charges not negative."); CHECK_INVARIANT(feq(coul(0.0,0.0,0.0, 0.1), 0.0), "Coulomb: Small threshold dist does not give 0."); calculateDescriptors<Coulomb>(grd, Coulomb(mol, 0, 1.0, true)); for (unsigned int i = 0; i < grd.getSize(); i++) { CHECK_INVARIANT(grd.getVal (i) <= 0.0, "Coulomb: Absolute value field not negative"); } Coulomb coul1(mol, 0, -1.0, false, "_GasteigerCharge", 0.0, 0.01); CHECK_INVARIANT(coul1(-2.0, 0.0, 0.0, 1000) < 0, "Coulomb: Potential between negative charges not positive."); CHECK_INVARIANT(coul1(2.0, 0.0, 0.0, 1000) > 0, "Coulomb: Potential between positive and negative charges not negative."); Coulomb coul2 = Coulomb(mol, 0, -.5, false, "_GasteigerCharge", 0.0, 0.01); CHECK_INVARIANT(coul1(-2.0, 0.0, 0.0, 1000) < coul2 (-2.0, 0.0, 0.0, 1000), "Coulomb: Higher probecharge does not result in stronger forces."); Coulomb coul3(mol, 0, 1.0, false, "_GasteigerCharge", 0.01, 1.0); CHECK_INVARIANT(coul3(0.0, 0.0, 0.0, 1000) > coul3(0.1, 0.0, 0.0, 1000), "Coulomb: Softcore interaction wrong."); CHECK_INVARIANT(coul3(0.66, 0.0, 0.0, 1000) > coul3(0.68, 0.0, 0.0, 1000), "Coulomb: Softcore interaction wrong."); CHECK_INVARIANT(coul3(0.70, 0.0, 0.0, 1000) > coul3(0.68, 0.0, 0.0, 1000), "Coulomb: Softcore interaction wrong."); CHECK_INVARIANT(feq(coul3(0.0,0.0,0.0, 0.1), 0.0), "Coulomb: Small threshold dist does not give 0."); }
void test2() { #ifdef SUPPORT_COMPRESSED_IO BOOST_LOG(rdInfoLog) << "testing writing to, then reading from compressed streams" << std::endl; std::string smiles = "C1CCCC1"; std::string buff, molBlock; RWMol *m; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(5)); m->setProp(common_properties::_Name, "monkey"); io::filtering_ostream outStrm; outStrm.push(io::gzip_compressor()); outStrm.push(io::back_inserter(buff)); TEST_ASSERT(outStrm.is_complete()); molBlock = MolToMolBlock(*m); outStrm << molBlock; outStrm.reset(); delete m; io::filtering_istream inStrm; inStrm.push(io::gzip_decompressor()); inStrm.push(boost::make_iterator_range(buff)); TEST_ASSERT(inStrm.is_complete()); unsigned int lineNo = 0; m = MolDataStreamToMol(inStrm, lineNo); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(5)); BOOST_LOG(rdInfoLog) << "done" << std::endl; #else BOOST_LOG(rdInfoLog) << "Compressed IO disabled; test skipped" << std::endl; #endif }
void kekulizeFused(RWMol &mol, const VECT_INT_VECT ås, unsigned int maxBackTracks) { // get all the atoms in the ring system INT_VECT allAtms; Union(arings, allAtms); // get all the atoms that are candidates to receive a double bond // also mark atoms in the fused system that are not aromatic to begin with // as done. Mark all the bonds that are part of the aromatic system // to be single bonds INT_VECT done; INT_VECT questions; unsigned int nats = mol.getNumAtoms(); unsigned int nbnds = mol.getNumBonds(); boost::dynamic_bitset<> dBndCands(nats); boost::dynamic_bitset<> dBndAdds(nbnds); markDbondCands(mol, allAtms, dBndCands, questions, done); #if 0 std::cerr << "candidates: "; for(int i=0;i<nats;++i) std::cerr << dBndCands[i]; std::cerr << std::endl; #endif bool kekulized; kekulized = kekulizeWorker(mol, allAtms, dBndCands, dBndAdds, done, maxBackTracks); if (!kekulized && questions.size()) { // we failed, but there are some dummy atoms we can try permuting. kekulized = permuteDummiesAndKekulize(mol, allAtms, dBndCands, questions, maxBackTracks); } if (!kekulized) { // we exhausted all option (or crossed the allowed // number of backTracks) and we still need to backtrack // can't kekulize this thing std::ostringstream errout; errout << "Can't kekulize mol."; errout << " Unkekulized atoms:"; for (unsigned int i = 0; i < nats; ++i) { if (dBndCands[i]) errout << " " << i; } errout << std::endl; std::string msg = errout.str(); BOOST_LOG(rdErrorLog) << msg << std::endl; throw MolSanitizeException(msg); } }
void test504() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing FMCS test504" << std::endl; std::cout << "\ntest504()\n"; std::vector<ROMOL_SPTR> mols; const char* smi[] = { // TEST 504 "C(CCNC(C1CC1[c:1]1[c:2]c(Cl)c(Cl)c[c:3]1)=O)CCN1CCC(NC(Nc2ccc(Cl)cc2)=O)" "C1 CHEMBL545864", // - QUERY "FC(F)(F)c1cc(NC(N2CCCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)CC2)=O)ccc1Cl " "CHEMBL528228", "FC(F)(F)c1cc(NC(NC2CCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)C2)=O)ccc1Cl " "CHEMBL525875", "Fc1ccc(NC(N2CCCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)CC2)=O)cc1C(F)(F)F " "CHEMBL527277", "FC(F)(F)c1cc(NC(NC2CCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)CC2)=O)ccc1Cl " "CHEMBL537333", "Fc1ccc(NC(NC2CCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)C2)=O)cc1C(F)(F)F " "CHEMBL588077", "FC(F)(F)c1ccc(NC(NC2CCN(CCCCCNC(C3CC3c3cc(Cl)c(Cl)cc3)=O)C2)=O)cc1 " "CHEMBL525307", "Fc1ccc(NC(NC2CCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)CC2)=O)cc1C(F)(F)F " "CHEMBL581847", "FC(F)(F)c1ccc(NC(NC2CCN(CCCCCNC(C3CC3c3cc(Cl)c(Cl)cc3)=O)CC2)=O)cc1 " "CHEMBL579547", "N#Cc1cccc(NC(NC2CCN(CCCCCNC(C3CC3c3ccc(Cl)c(Cl)c3)=O)CC2)=O)c1 " "CHEMBL529994", }; RWMol* qm = SmilesToMol(getSmilesOnly(smi[0])); unsigned nq = qm->getNumAtoms(); for (size_t ai = 0; ai < nq; ai++) { Atom* atom = qm->getAtomWithIdx(ai); atom->setProp("molAtomMapNumber", (int)ai); } std::cout << "Query +MAP " << MolToSmiles(*qm) << "\n"; mols.push_back(ROMOL_SPTR(qm)); // with RING INFO for (size_t i = 1; i < sizeof(smi) / sizeof(smi[0]); i++) mols.push_back( ROMOL_SPTR(SmilesToMol(getSmilesOnly(smi[i])))); // with RING INFO t0 = nanoClock(); MCSResult res = findMCS(mols); std::cout << "MCS: " << res.SmartsString << " " << res.NumAtoms << " atoms, " << res.NumBonds << " bonds\n"; printTime(); TEST_ASSERT(res.NumAtoms == 34 && res.NumBonds == 36); BOOST_LOG(rdInfoLog) << "\tdone" << std::endl; }
void testSFIssue1653802(){ BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdErrorLog) << " Testing SFIssue1653802." << std::endl; RWMol *mol; int needMore; ForceFields::ForceField *field; std::string pathName=getenv("RDBASE"); pathName += "/Code/GraphMol/ForceFieldHelpers/UFF/test_data"; mol = MolFileToMol(pathName+"/cyclobutadiene.mol",false); TEST_ASSERT(mol); MolOps::sanitizeMol(*mol); UFF::AtomicParamVect types; bool foundAll; boost::shared_array<boost::uint8_t> nbrMat; boost::tie(types,foundAll)=UFF::getAtomTypes(*mol); TEST_ASSERT(foundAll); TEST_ASSERT(types.size()==mol->getNumAtoms()); field=new ForceFields::ForceField(); UFF::Tools::addBonds(*mol,types,field); TEST_ASSERT(field->contribs().size()==8); nbrMat = UFF::Tools::buildNeighborMatrix(*mol); UFF::Tools::addAngles(*mol,types,field); TEST_ASSERT(field->contribs().size()==20); UFF::Tools::addTorsions(*mol,types,field); //std::cout << field->contribs().size() << std::endl; TEST_ASSERT(field->contribs().size()==36); UFF::Tools::addNonbonded(*mol,0,types,field,nbrMat); delete field; field = UFF::constructForceField(*mol); field->initialize(); needMore = field->minimize(200,1e-6,1e-3); TEST_ASSERT(!needMore); delete mol; delete field; BOOST_LOG(rdErrorLog) << " done" << std::endl; }
bool permuteDummiesAndKekulize(RWMol &mol, const INT_VECT &allAtms, boost::dynamic_bitset<> dBndCands, INT_VECT &questions, unsigned int maxBackTracks) { boost::dynamic_bitset<> atomsInPlay(mol.getNumAtoms()); for (int allAtm : allAtms) { atomsInPlay[allAtm] = 1; } bool kekulized = false; QuestionEnumerator qEnum(questions); while (!kekulized && questions.size()) { boost::dynamic_bitset<> dBndAdds(mol.getNumBonds()); INT_VECT done; #if 1 // reset the state: all aromatic bonds are remarked to single: for (RWMol::BondIterator bi = mol.beginBonds(); bi != mol.endBonds(); ++bi) { if ((*bi)->getIsAromatic() && (*bi)->getBondType() != Bond::SINGLE && atomsInPlay[(*bi)->getBeginAtomIdx()] && atomsInPlay[(*bi)->getEndAtomIdx()]) { (*bi)->setBondType(Bond::SINGLE); } } #endif // pick a new permutation of the questionable atoms: const INT_VECT &switchOff = qEnum.next(); if (!switchOff.size()) break; boost::dynamic_bitset<> tCands = dBndCands; for (int it : switchOff) { tCands[it] = 0; } #if 0 std::cerr<<"permute: "; for (boost::dynamic_bitset<>::size_type i = 0; i < tCands.size(); ++i){ std::cerr << tCands[i]; } std::cerr<<std::endl; #endif // try kekulizing again: kekulized = kekulizeWorker(mol, allAtms, tCands, dBndAdds, done, maxBackTracks); } return kekulized; }
void test1(){ #ifdef SUPPORT_COMPRESSED_IO BOOST_LOG(rdInfoLog) << "testing basic reading from compressed streams" << std::endl; std::string rdbase = getenv("RDBASE"); std::string fname2 = rdbase + "/Code/Demos/RDKit/BinaryIO/test_data/triazine.mol.gz"; RWMol *m; io::filtering_istream inStrm; inStrm.push(io::gzip_decompressor()); inStrm.push(io::file_source(fname2)); TEST_ASSERT(inStrm.is_complete()); unsigned int lineNo=0; m = MolDataStreamToMol(inStrm,lineNo); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(6)); BOOST_LOG(rdInfoLog) << "done" << std::endl; #else BOOST_LOG(rdInfoLog) << "Compressed IO disabled; test skipped" << std::endl; #endif }
void test18() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing FMCS test18" << std::endl; std::cout << "\ntest18()\n"; std::vector<ROMOL_SPTR> mols; const char* smi[] = { // TEST 18 "Cc1nc(CN(C(C)c2ncccc2)CCCCN)ccc1 CHEMBL1682991", //-- QUERY "Cc1ccc(CN(C(C)c2ccccn2)CCCCN)nc1 CHEMBL1682990", "Cc1cccnc1CN(C(C)c1ccccn1)CCCCN CHEMBL1682998", "CC(N(CCCCN)Cc1c(N)cccn1)c1ccccn1 CHEMBL1682987", "Cc1cc(C)c(CN(C(C)c2ccccn2)CCCCN)nc1 CHEMBL1682992", "Cc1cc(C(C)N(CCCCN)Cc2c(C)cccn2)ncc1 CHEMBL1682993", "Cc1nc(C(C)N(CCCCN)Cc2nc3c([nH]2)cccc3)ccc1 CHEMBL1682878", "CC(c1ncccc1)N(CCCCN)Cc1nc2c([nH]1)cccc2 CHEMBL1682867", "CC(N(CCCCN)Cc1c(C(C)(C)C)cccn1)c1ccccn1 CHEMBL1682989", "CC(N(CCCCN)Cc1c(C(F)(F)F)cccn1)c1ccccn1 CHEMBL1682988", //# 18 . 20 20 0.04 sec. Python MCS: CC(c1ccccn1)N(CCCCN)Ccnccc }; RWMol* qm = SmilesToMol(getSmilesOnly(smi[0])); unsigned nq = qm->getNumAtoms(); for (size_t ai = 0; ai < nq; ai++) { Atom* atom = qm->getAtomWithIdx(ai); atom->setProp("molAtomMapNumber", (int)ai); } std::cout << "Query +MAP " << MolToSmiles(*qm) << "\n"; mols.push_back(ROMOL_SPTR(qm)); // with RING INFO for (size_t i = 1; i < sizeof(smi) / sizeof(smi[0]); i++) mols.push_back( ROMOL_SPTR(SmilesToMol(getSmilesOnly(smi[i])))); // with RING INFO t0 = nanoClock(); MCSResult res = findMCS(mols); std::cout << "MCS: " << res.SmartsString << " " << res.NumAtoms << " atoms, " << res.NumBonds << " bonds\n"; printTime(); TEST_ASSERT(res.NumAtoms == 21 && res.NumBonds == 21); BOOST_LOG(rdInfoLog) << "\tdone" << std::endl; }
void testGeneral(std::string rdbase){ BOOST_LOG(rdInfoLog) << "---------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "-- testing general mol2 file parsing --" << std::endl; BOOST_LOG(rdInfoLog) << "---------------------------------------" << std::endl; { bool ok=false; std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/nonExistFile.mol2"; try{ RWMol *m = Mol2FileToMol(fName); delete m; } catch(const BadFileException &e){ ok=true; } TEST_ASSERT(ok); } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/pyrazole_pyridine.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==5); // this was sf.net issue 2727976: TEST_ASSERT(m->getNumConformers()==1); TEST_ASSERT(m->getConformer().is3D()); TEST_ASSERT(feq(m->getConformer().getAtomPos(0).x,1.5019)); TEST_ASSERT(feq(m->getConformer().getAtomPos(0).y,1.0435)); TEST_ASSERT(feq(m->getConformer().getAtomPos(0).z,0.0000)); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/benzene.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==6); delete m; } { bool ok=false; std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/mol_noatoms.mol2"; try { RWMol *m = Mol2FileToMol(fName); delete m; } catch(const FileParseException &e){ ok=true; } TEST_ASSERT(ok); } { bool ok=false; std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/mol_nomol.mol2"; try { RWMol *m = Mol2FileToMol(fName); delete m; } catch(const FileParseException &e){ ok=true; } TEST_ASSERT(ok); } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/lonePairMol.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms()==5 && m->getNumBonds()==4); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/symmetricGuanidine.mol2"; RWMol *m = Mol2FileToMol(fName,false); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(1)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/highlySymmetricGuanidine.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(4)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(12)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(20)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/Noxide.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(9)->getFormalCharge()==-1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/Noxide.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(9)->getFormalCharge()==-1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/fusedRing.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(0)->getFormalCharge()==0); TEST_ASSERT(m->getAtomWithIdx(5)->getFormalCharge()==0); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==0); TEST_ASSERT(m->getAtomWithIdx(13)->getFormalCharge()==0); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/pyridiniumPhenyl.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(5)->getFormalCharge()==1); TEST_ASSERT(m->getAtomWithIdx(6)->getFormalCharge()==0); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/sulfonAmide.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(1)->getFormalCharge()==0); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/chargedAmidineRWH.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(6)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/chargedAmidineEC.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(3)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/chargedAmidine.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(9)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/dbtranslateCharged.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==1); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/dbtranslateUncharged.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(8)->getFormalCharge()==0); delete m; } { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/dbtranslateUnchargedRing.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); TEST_ASSERT(m->getAtomWithIdx(2)->getFormalCharge()==0); delete m; } #if 0 { std::string fName = rdbase + "/Code/GraphMol/FileParsers/test_data/Sulfonate.mol2"; RWMol *m = Mol2FileToMol(fName); TEST_ASSERT(m); BOOST_LOG(rdInfoLog) <<MolToSmiles(*m)<<std::endl; delete m; } #endif BOOST_LOG(rdInfoLog) << "------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "-- DONE general mol2 file parsing --" << std::endl; BOOST_LOG(rdInfoLog) << "------------------------------------" << std::endl; }
void test5(){ #ifdef SUPPORT_COMPRESSED_IO BOOST_LOG(rdInfoLog) << "testing writing compressed pickles to a single file then reading them back" << std::endl; std::string rdbase = getenv("RDBASE"); std::string fname2 = rdbase + "/Code/Demos/RDKit/BinaryIO/test_data/tmp.rdz"; std::string smiles,buff; RWMol *m; std::vector<unsigned int> filePs; io::filtering_ostream outStrm; outStrm.push(io::file_sink(fname2,std::ios_base::out|std::ios_base::binary)); TEST_ASSERT(outStrm.is_complete()); smiles="C1CCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(4)); io::filtering_ostream *tmpStrm; tmpStrm=new io::filtering_ostream(); tmpStrm->push(io::gzip_compressor()); tmpStrm->push(io::back_inserter(buff)); filePs.push_back(0); MolPickler::pickleMol(*m,*tmpStrm); delete m; tmpStrm->reset(); outStrm<<buff.size(); outStrm<<buff; std::cerr<<"sz: " <<buff.size()<<" "<<outStrm.tellp() <<std::endl; buff=""; tmpStrm->push(io::gzip_compressor()); tmpStrm->push(io::back_inserter(buff)); smiles="C1CCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(4)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,*tmpStrm); delete m; tmpStrm->reset(); outStrm<<buff.size(); outStrm<<buff; std::cerr<<"sz: " <<buff.size()<<" "<<outStrm.tellp() <<std::endl; buff=""; tmpStrm->push(io::gzip_compressor()); tmpStrm->push(io::back_inserter(buff)); smiles="C1CCCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(5)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,*tmpStrm); delete m; tmpStrm->reset(); outStrm<<buff.size(); outStrm<<buff; std::cerr<<"sz: " <<buff.size()<<" "<<outStrm.tellp() <<std::endl; buff=""; tmpStrm->push(io::gzip_compressor()); tmpStrm->push(io::back_inserter(buff)); smiles="c1ccccc1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(6)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,*tmpStrm); delete m; tmpStrm->reset(); outStrm<<buff.size(); outStrm<<buff; std::cerr<<"sz: " <<buff.size()<<" "<<outStrm.tellp() <<std::endl; buff=""; tmpStrm->push(io::gzip_compressor()); tmpStrm->push(io::back_inserter(buff)); smiles="c1ccccc1CC(=O)O"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(9)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,*tmpStrm); delete m; tmpStrm->reset(); outStrm<<buff.size(); outStrm<<buff; std::cerr<<"sz: " <<buff.size()<<" "<<outStrm.tellp() <<std::endl; delete tmpStrm; io::flush(outStrm); outStrm.pop(); io::filtering_istream tmpIStrm; io::filtering_istream inStrm; unsigned int sz; char *charArr; inStrm.push(io::file_source(fname2,std::ios_base::in|std::ios_base::binary)); TEST_ASSERT(inStrm.is_complete()); inStrm>>sz; charArr = new char[sz]; inStrm.read(charArr,sz); buff = ""; buff.append(charArr,sz); tmpIStrm.push(io::gzip_decompressor()); tmpIStrm.push(boost::make_iterator_range(buff)); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(tmpIStrm,*m); TEST_ASSERT(m->getNumAtoms(4)); delete m; inStrm>>sz; delete [] charArr; charArr = new char[sz]; inStrm.read(charArr,sz); buff = ""; buff.append(charArr,sz); tmpIStrm.reset(); tmpIStrm.push(io::gzip_decompressor()); tmpIStrm.push(boost::make_iterator_range(buff)); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(tmpIStrm,*m); TEST_ASSERT(m->getNumAtoms(4)); delete m; inStrm>>sz; delete [] charArr; charArr = new char[sz]; inStrm.read(charArr,sz); buff = ""; buff.append(charArr,sz); tmpIStrm.reset(); tmpIStrm.push(io::gzip_decompressor()); tmpIStrm.push(boost::make_iterator_range(buff)); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(tmpIStrm,*m); TEST_ASSERT(m->getNumAtoms(5)); delete m; inStrm>>sz; delete [] charArr; charArr = new char[sz]; inStrm.read(charArr,sz); buff = ""; buff.append(charArr,sz); tmpIStrm.reset(); tmpIStrm.push(io::gzip_decompressor()); tmpIStrm.push(boost::make_iterator_range(buff)); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(tmpIStrm,*m); TEST_ASSERT(m->getNumAtoms(6)); delete m; inStrm>>sz; delete [] charArr; charArr = new char[sz]; inStrm.read(charArr,sz); buff = ""; buff.append(charArr,sz); tmpIStrm.reset(); tmpIStrm.push(io::gzip_decompressor()); tmpIStrm.push(boost::make_iterator_range(buff)); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(tmpIStrm,*m); TEST_ASSERT(m->getNumAtoms(9)); delete m; BOOST_LOG(rdInfoLog) << "done" << std::endl; #else BOOST_LOG(rdInfoLog) << "Compressed IO disabled; test skipped" << std::endl; #endif }
void testFragmentOnSomeBonds() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing fragmentOnSomeBonds"<< std::endl; { std::string smi = "OCCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()); unsigned int indices[]={0,2,4}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); std::vector<ROMOL_SPTR> frags; MolFragmenter::fragmentOnSomeBonds(*mol,bindices,frags,2); TEST_ASSERT(frags.size()==3); std::vector<std::vector<int> > fragMap; TEST_ASSERT(MolOps::getMolFrags(*frags[0],fragMap)==3); TEST_ASSERT(fragMap.size()==3); TEST_ASSERT(fragMap[0].size()==2); TEST_ASSERT(fragMap[1].size()==4); TEST_ASSERT(fragMap[2].size()==4); TEST_ASSERT(MolOps::getMolFrags(*frags[1],fragMap)==3); TEST_ASSERT(fragMap.size()==3); TEST_ASSERT(fragMap[0].size()==2); TEST_ASSERT(fragMap[1].size()==6); TEST_ASSERT(fragMap[2].size()==2); TEST_ASSERT(MolOps::getMolFrags(*frags[2],fragMap)==3); TEST_ASSERT(fragMap.size()==3); TEST_ASSERT(fragMap[0].size()==4); TEST_ASSERT(fragMap[1].size()==4); TEST_ASSERT(fragMap[2].size()==2); delete mol; } { std::string smi = "OCCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()); unsigned int indices[]={0,2,4}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); std::vector<ROMOL_SPTR> frags; std::vector<std::vector<unsigned int> > cpa; MolFragmenter::fragmentOnSomeBonds(*mol,bindices,frags,2,false,NULL,NULL,&cpa); TEST_ASSERT(frags.size()==3); TEST_ASSERT(cpa.size()==3); TEST_ASSERT(cpa[0].size()==mol->getNumAtoms()); TEST_ASSERT(cpa[1].size()==mol->getNumAtoms()); TEST_ASSERT(cpa[2].size()==mol->getNumAtoms()); delete mol; } BOOST_LOG(rdInfoLog) << "\tdone" << std::endl; }
void testFragmentOnBRICSBonds() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing fragmentOnBRICSBonds"<< std::endl; { std::string smi = "c1ccccc1OC"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==8); TEST_ASSERT(mol->getBondBetweenAtoms(5,6)); TEST_ASSERT(mol->getBondBetweenAtoms(6,7)); std::vector<MolFragmenter::FragmenterBondType> fbts; MolFragmenter::constructBRICSBondTypes(fbts); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,fbts); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==10); TEST_ASSERT(!nmol->getBondBetweenAtoms(5,6)); TEST_ASSERT(nmol->getBondBetweenAtoms(6,7)); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[3*]OC.[16*]c1ccccc1"); TEST_ASSERT(nmol->getAtomWithIdx(8)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(8)->getIsotope()==3); TEST_ASSERT(nmol->getBondBetweenAtoms(6,8)); TEST_ASSERT(nmol->getAtomWithIdx(9)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(9)->getIsotope()==16); TEST_ASSERT(nmol->getBondBetweenAtoms(5,9)); delete mol; delete nmol; } { std::string smi = "c1ccccc1"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==6); std::vector<MolFragmenter::FragmenterBondType> fbts; MolFragmenter::constructBRICSBondTypes(fbts); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,fbts); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==6); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="c1ccccc1"); delete mol; delete nmol; } { std::string smi = "OC(C)=CC"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); std::vector<MolFragmenter::FragmenterBondType> fbts; MolFragmenter::constructBRICSBondTypes(fbts); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,fbts); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==7); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[7*]=CC.[7*]=C(C)O"); delete mol; delete nmol; } { std::string smi = "c1ccccc1OC"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==8); ROMol *nmol=MolFragmenter::fragmentOnBRICSBonds(*mol); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==10); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[3*]OC.[16*]c1ccccc1"); delete mol; delete nmol; } { std::string smi = "OC(C)=CC"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); ROMol *nmol=MolFragmenter::fragmentOnBRICSBonds(*mol); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==7); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[7*]=CC.[7*]=C(C)O"); delete mol; delete nmol; } { std::string smi = "CCCOCCC(=O)c1ccccc1"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==14); ROMol *nmol=MolFragmenter::fragmentOnBRICSBonds(*mol); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==20); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[3*]O[3*].[4*]CCC.[4*]CCC([6*])=O.[16*]c1ccccc1"); MolOps::sanitizeMol(static_cast<RWMol &>(*nmol)); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="[3*]O[3*].[4*]CCC.[4*]CCC([6*])=O.[16*]c1ccccc1"); delete mol; delete nmol; } { std::string smi = "Cl.CC(=O)O[C@]1(c2ccccc2)CCN(C)[C@H]2CCCC[C@@H]21"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==22); ROMol *nmol=MolFragmenter::fragmentOnBRICSBonds(*mol); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==28); smi = MolToSmiles(*nmol,true); //std::cerr<<smi<<std::endl; TEST_ASSERT(smi=="Cl.[1*]C(C)=O.[3*]O[3*].[15*]C1([15*])CCN(C)[C@H]2CCCC[C@@H]21.[16*]c1ccccc1"); MolOps::sanitizeMol(static_cast<RWMol &>(*nmol)); smi = MolToSmiles(*nmol,true); TEST_ASSERT(smi=="Cl.[1*]C(C)=O.[3*]O[3*].[15*]C1([15*])CCN(C)[C@H]2CCCC[C@@H]21.[16*]c1ccccc1"); delete mol; delete nmol; } BOOST_LOG(rdInfoLog) << "\tdone" << std::endl; }
void testFragmentOnBonds() { BOOST_LOG(rdInfoLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdInfoLog) << "Testing fragmentOnBonds"<< std::endl; { std::string smi = "OCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); unsigned int indices[]={0,3}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,bindices,false); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==5); delete mol; delete nmol; } { std::string smi = "OCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); unsigned int indices[]={0,1}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); std::vector<unsigned int> cutsPerAtom(mol->getNumAtoms()); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,bindices,false,0,0,&cutsPerAtom); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==5); TEST_ASSERT(cutsPerAtom[0]==1); TEST_ASSERT(cutsPerAtom[1]==2); TEST_ASSERT(cutsPerAtom[2]==1); TEST_ASSERT(cutsPerAtom[3]==0); delete mol; delete nmol; } { std::string smi = "OCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); TEST_ASSERT(mol->getBondBetweenAtoms(0,1)); TEST_ASSERT(mol->getBondBetweenAtoms(3,4)); unsigned int indices[]={0,3}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,bindices); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==9); TEST_ASSERT(!nmol->getBondBetweenAtoms(0,1)); TEST_ASSERT(!nmol->getBondBetweenAtoms(3,4)); TEST_ASSERT(nmol->getAtomWithIdx(5)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(5)->getIsotope()==0); TEST_ASSERT(nmol->getBondBetweenAtoms(1,5)); TEST_ASSERT(nmol->getAtomWithIdx(6)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(6)->getIsotope()==1); TEST_ASSERT(nmol->getBondBetweenAtoms(0,6)); TEST_ASSERT(nmol->getAtomWithIdx(7)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(7)->getIsotope()==3); TEST_ASSERT(nmol->getBondBetweenAtoms(4,7)); TEST_ASSERT(nmol->getAtomWithIdx(8)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(8)->getIsotope()==4); TEST_ASSERT(nmol->getBondBetweenAtoms(3,8)); delete mol; delete nmol; } { std::string smi = "OCCCN"; RWMol *mol = SmilesToMol(smi); TEST_ASSERT(mol); TEST_ASSERT(mol->getNumAtoms()==5); TEST_ASSERT(mol->getBondBetweenAtoms(0,1)); TEST_ASSERT(mol->getBondBetweenAtoms(3,4)); unsigned int indices[]={0,3}; std::vector<unsigned int> bindices(indices,indices+(sizeof(indices)/sizeof(indices[0]))); std::vector< std::pair<unsigned int,unsigned int> > dummyLabels(2); dummyLabels[0] =std::make_pair(10,11); dummyLabels[1] =std::make_pair(100,110); ROMol *nmol=MolFragmenter::fragmentOnBonds(*mol,bindices,true,&dummyLabels); TEST_ASSERT(nmol); TEST_ASSERT(nmol->getNumAtoms()==9); TEST_ASSERT(!nmol->getBondBetweenAtoms(0,1)); TEST_ASSERT(!nmol->getBondBetweenAtoms(3,4)); TEST_ASSERT(nmol->getAtomWithIdx(5)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(5)->getIsotope()==10); TEST_ASSERT(nmol->getBondBetweenAtoms(1,5)); TEST_ASSERT(nmol->getAtomWithIdx(6)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(6)->getIsotope()==11); TEST_ASSERT(nmol->getBondBetweenAtoms(0,6)); TEST_ASSERT(nmol->getAtomWithIdx(7)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(7)->getIsotope()==100); TEST_ASSERT(nmol->getBondBetweenAtoms(4,7)); TEST_ASSERT(nmol->getAtomWithIdx(8)->getAtomicNum()==0); TEST_ASSERT(nmol->getAtomWithIdx(8)->getIsotope()==110); TEST_ASSERT(nmol->getBondBetweenAtoms(3,8)); delete mol; delete nmol; } BOOST_LOG(rdInfoLog) << "\tdone" << std::endl; }
int setAromaticity(RWMol &mol) { // FIX: we will assume for now that if the input molecule came // with aromaticity information it is correct and we will not // touch it. Loop through the atoms and check if any atom has // arom stuff set. We may want check this more carefully later // and start from scratch if necessary ROMol::AtomIterator ai; for (ai = mol.beginAtoms(); ai != mol.endAtoms(); ai++) { if ((*ai)->getIsAromatic()) { // found aromatic info return -1; } } // first find the all the simple rings in the molecule VECT_INT_VECT srings; if (mol.getRingInfo()->isInitialized()) { srings = mol.getRingInfo()->atomRings(); } else { MolOps::symmetrizeSSSR(mol, srings); } int narom = 0; // loop over all the atoms in the rings that can be candidates // for aromaticity // Atoms are candidates if // - it is part of ring // - has one or more electron to donate or has empty p-orbitals int natoms = mol.getNumAtoms(); boost::dynamic_bitset<> acands(natoms); boost::dynamic_bitset<> aseen(natoms); VECT_EDON_TYPE edon(natoms); VECT_INT_VECT cRings; // holder for rings that are candidates for aromaticity for (VECT_INT_VECT_I vivi = srings.begin(); vivi != srings.end(); ++vivi) { bool allAromatic = true; for (INT_VECT_I ivi = (*vivi).begin(); ivi != (*vivi).end(); ++ivi) { if (aseen[*ivi]) { if (!acands[*ivi]) allAromatic = false; continue; } aseen[*ivi] = 1; Atom *at = mol.getAtomWithIdx(*ivi); // now that the atom is part of ring check if it can donate // electron or has empty orbitals. Record the donor type // information in 'edon' - we will need it when we get to // the Huckel rule later edon[*ivi] = getAtomDonorTypeArom(at); acands[*ivi] = isAtomCandForArom(at, edon[*ivi]); if (!acands[*ivi]) allAromatic = false; } if (allAromatic) { cRings.push_back((*vivi)); } } // first convert all rings to bonds ids VECT_INT_VECT brings; RingUtils::convertToBonds(cRings, brings, mol); // make the neighbor map for the rings // i.e. a ring is a neighbor a another candidate ring if // shares at least one bond // useful to figure out fused systems INT_INT_VECT_MAP neighMap; RingUtils::makeRingNeighborMap(brings, neighMap, maxFusedAromaticRingSize); // now loop over all the candidate rings and check the // huckel rule - of course paying attention to fused systems. INT_VECT doneRs; int curr = 0; int cnrs = rdcast<int>(cRings.size()); boost::dynamic_bitset<> fusDone(cnrs); INT_VECT fused; while (curr < cnrs) { fused.resize(0); RingUtils::pickFusedRings(curr, neighMap, fused, fusDone); applyHuckelToFused(mol, cRings, brings, fused, edon, neighMap, narom, 6); int rix; for (rix = 0; rix < cnrs; rix++) { if (!fusDone[rix]) { curr = rix; break; } } if (rix == cnrs) { break; } } mol.setProp(common_properties::numArom, narom, true); return narom; }
void testGithub336() { BOOST_LOG(rdInfoLog) << "testing github issue 336: bad canonical smiles for " "conjugated double bonds" << std::endl; // some tests around dealing with bad mol blocks { std::string pathName = getenv("RDBASE"); pathName += "/External/AvalonTools/test_data/"; std::ifstream ins((pathName + "EZ_test.2.sdf").c_str()); std::string mb((std::istreambuf_iterator<char>(ins)), std::istreambuf_iterator<char>()); ROMol *m = MolBlockToMol(mb); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms() == 17); std::string smi1 = AvalonTools::getCanonSmiles(mb, false); std::string smi2 = AvalonTools::getCanonSmiles(*m); std::cerr << "smi1: " << smi1 << std::endl; std::cerr << "smi2: " << smi2 << std::endl; TEST_ASSERT(smi1 == smi2); delete m; } { std::string pathName = getenv("RDBASE"); pathName += "/External/AvalonTools/test_data/"; std::ifstream ins((pathName + "heterocycle.mol").c_str()); std::string mb((std::istreambuf_iterator<char>(ins)), std::istreambuf_iterator<char>()); RWMol *m = MolBlockToMol(mb, false); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms() == 6); m->updatePropertyCache(); MolOps::cleanUp(*m); MolOps::setAromaticity(*m); std::string smi1 = AvalonTools::getCanonSmiles(mb, false); std::string smi2 = AvalonTools::getCanonSmiles(*m); std::cerr << "smi1: " << smi1 << std::endl; std::cerr << "smi2: " << smi2 << std::endl; TEST_ASSERT(smi1 == smi2); TEST_ASSERT(smi1 == "CC1C=NNC=1"); delete m; } { std::string pathName = getenv("RDBASE"); pathName += "/External/AvalonTools/test_data/"; std::ifstream ins((pathName + "heterocycle2.mol").c_str()); std::string mb((std::istreambuf_iterator<char>(ins)), std::istreambuf_iterator<char>()); RWMol *m = MolBlockToMol(mb, false); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms() == 11); m->updatePropertyCache(); MolOps::cleanUp(*m); MolOps::setAromaticity(*m); std::string smi1 = AvalonTools::getCanonSmiles(mb, false); std::string smi2 = AvalonTools::getCanonSmiles(*m); std::cerr << "smi1: " << smi1 << std::endl; std::cerr << "smi2: " << smi2 << std::endl; TEST_ASSERT(smi1 == smi2); TEST_ASSERT(smi1 == "CN2C=CC1=CC(=O)NC=C12"); delete m; } BOOST_LOG(rdInfoLog) << "done" << std::endl; }
void test3(){ #ifdef SUPPORT_COMPRESSED_IO BOOST_LOG(rdInfoLog) << "testing writing pickles to a file then reading them back" << std::endl; std::string rdbase = getenv("RDBASE"); std::string fname2 = rdbase + "/Code/Demos/RDKit/BinaryIO/test_data/mols.rdb"; std::string smiles,buff; RWMol *m; std::vector<unsigned int> filePs; io::filtering_ostream outStrm; outStrm.push(io::file_sink(fname2,std::ios_base::out|std::ios_base::binary)); TEST_ASSERT(outStrm.is_complete()); smiles="C1CCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(4)); MolPickler::pickleMol(*m,outStrm); delete m; smiles="C1CCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(4)); RDDepict::compute2DCoords(*m); filePs.push_back(0); MolPickler::pickleMol(*m,outStrm); delete m; smiles="C1CCCC1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(5)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,outStrm); delete m; smiles="c1ccccc1"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(6)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,outStrm); delete m; smiles="c1ccccc1CC(=O)O"; m = SmilesToMol(smiles); TEST_ASSERT(m); TEST_ASSERT(m->getNumAtoms(9)); RDDepict::compute2DCoords(*m); filePs.push_back(outStrm.tellp()); MolPickler::pickleMol(*m,outStrm); delete m; outStrm.flush(); outStrm.reset(); io::filtering_istream inStrm; inStrm.push(io::file_source(fname2,std::ios_base::in|std::ios_base::binary)); TEST_ASSERT(inStrm.is_complete()); m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(inStrm,*m); TEST_ASSERT(m->getNumAtoms(4)); delete m; m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(inStrm,*m); TEST_ASSERT(m->getNumAtoms(4)); delete m; m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(inStrm,*m); TEST_ASSERT(m->getNumAtoms(5)); delete m; m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(inStrm,*m); TEST_ASSERT(m->getNumAtoms(6)); delete m; m = new RWMol(); TEST_ASSERT(m); MolPickler::molFromPickle(inStrm,*m); TEST_ASSERT(m->getNumAtoms(9)); delete m; BOOST_LOG(rdInfoLog) << "done" << std::endl; #else BOOST_LOG(rdInfoLog) << "Compressed IO disabled; test skipped" << std::endl; #endif }