std::string LogNeighbourhood( const ROMol &mol, unsigned int idx, const std::vector<Neighbourhood> &neighbour_array) { std::stringstream oss; // FIX ME turn into utility func? std::string name(""); mol.getPropIfPresent(common_properties::_Name, name); oss << "atom '" << name << "' idx=" << idx << " AA: "; const Atom &atm = *mol.getAtomWithIdx(idx); oss << atm.getSymbol(); if (atm.getFormalCharge()) oss << (atm.getFormalCharge() > 0 ? "+" : "") << atm.getFormalCharge(); if (atm.getNumRadicalElectrons()) oss << atm.getNumRadicalElectrons(); // these neighbors should be sorted properly? size_t numNbrs = neighbour_array[idx].Atoms.size(); // CHECK_INVARIANT(numNBrs == neighbour_array[idx].Bonds.size()); std::vector<NbrData> nbrs; for (size_t i = 0; i < numNbrs; ++i) { const Bond *bond = mol.getBondWithIdx(neighbour_array[idx].Bonds[i]); const Atom &nbr = *mol.getAtomWithIdx(neighbour_array[idx].Atoms[i]); nbrs.push_back(NbrData(nbr.getSymbol(), bond->getBondType(), nbr.getFormalCharge(), nbr.getNumRadicalElectrons())); } std::sort(nbrs.begin(), nbrs.end(), lessTuple); for (size_t i = 0; i < nbrs.size(); ++i) { NbrData &nbr = nbrs[i]; std::string bs = ""; switch (nbr.get<1>()) { case Bond::SINGLE: bs = "-"; break; case Bond::DOUBLE: bs = "="; break; case Bond::TRIPLE: bs = "#"; break; case Bond::AROMATIC: bs = "~"; break; } if (bs.size()) oss << "(" << bs << nbr.get<0>(); else oss << "(" << "?" << (int)nbr.get<1>() << "?" << nbr.get<0>(); if (nbr.get<2>()) oss << (nbr.get<2>() > 0 ? "+" : "") << nbr.get<2>(); if (nbr.get<3>()) oss << nbr.get<3>(); oss << ")"; } return oss.str(); }
void test5() { std::cout << " ----------------- Test 5" << std::endl; { std::string smiles = "*c1cc(*)cc(*)c1"; std::string nameBase = "test5_1"; ROMol *m = SmilesToMol(smiles); TEST_ASSERT(m); RDDepict::compute2DCoords(*m); WedgeMolBonds(*m, &(m->getConformer())); MolDrawOptions options; options.dummiesAreAttachments = true; options.atomLabels[0] = "R1"; #ifdef RDK_CAIRO_BUILD { MolDraw2DCairo drawer(300, 300); drawer.drawOptions() = options; drawer.drawMolecule(*m); drawer.finishDrawing(); drawer.writeDrawingText(nameBase + ".png"); } #endif { std::ofstream outs((nameBase + ".svg").c_str()); MolDraw2DSVG drawer(300, 300, outs); drawer.drawOptions() = options; drawer.drawMolecule(*m); drawer.finishDrawing(); outs.flush(); } delete m; } std::cout << " Done" << std::endl; }
void Seed::fillNewBonds(const ROMol& qmol) { std::vector<bool> excludedBonds = ExcludedBonds; for (unsigned srcAtomIdx = LastAddedAtomsBeginIdx; srcAtomIdx < getNumAtoms(); srcAtomIdx++) { // all atoms added on previous growing only const Atom* atom = MoleculeFragment.Atoms[srcAtomIdx]; ROMol::OEDGE_ITER beg, end; for (boost::tie(beg, end) = qmol.getAtomBonds(atom); beg != end; beg++) { // all bonds from MoleculeFragment.Atoms[srcAtomIdx] const Bond* bond = &*(qmol[*beg]); if (!excludedBonds[bond->getIdx()]) { // already in the seed or NewBonds list from another atom in a RING excludedBonds[bond->getIdx()] = true; unsigned ai = (atom == bond->getBeginAtom()) ? bond->getEndAtomIdx() : bond->getBeginAtomIdx(); const Atom* end_atom = qmol.getAtomWithIdx(ai); unsigned end_atom_idx = NotSet; for (unsigned i = 0; i < getNumAtoms(); i++) if (end_atom == MoleculeFragment.Atoms[i]) { // already exists in this seed end_atom_idx = i; break; } NewBonds.push_back(NewBond(srcAtomIdx, bond->getIdx(), ai, end_atom_idx, NotSet == end_atom_idx ? end_atom : 0)); } } } }
void calcCrippenDescriptors(const ROMol &mol,double &logp,double &mr,bool includeHs, bool force){ if(!force && mol.hasProp("_crippenLogP")){ mol.getProp("_crippenLogP",logp); mol.getProp("_crippenMR",mr); return; } // this isn't as bad as it looks, we aren't actually going // to harm the molecule in any way! ROMol *workMol=const_cast<ROMol *>(&mol); if(includeHs){ workMol = MolOps::addHs(mol,false,false); } std::vector<double> logpContribs(workMol->getNumAtoms()); std::vector<double> mrContribs(workMol->getNumAtoms()); getCrippenAtomContribs(*workMol,logpContribs,mrContribs,force); logp=0.0; for(std::vector<double>::const_iterator iter=logpContribs.begin(); iter!=logpContribs.end();++iter){ logp+= *iter; } mr=0.0; for(std::vector<double>::const_iterator iter=mrContribs.begin(); iter!=mrContribs.end();++iter){ mr+= *iter; } if(includeHs){ delete workMol; } mol.setProp("_crippenLogP",logp,true); mol.setProp("_crippenMR",mr,true); };
//************************************************************************************* // // Adds 2D coordinates to a molecule using the Depict.dll // // ARGUMENTS: // mol: the molecule to be altered // tempFilename: (OPTIONAL) the name of the temporary file // // RETURNS: // 1 on success, 0 otherwise // // Here's the process by which this works (it's kind of contorted): // 1) convert the mol to SMILES // 2) use the DLL to convert the SMILES to a mol file (on disk) // 3) parse the mol file into a temporary molecule // 4) do a substructure match from the old molecule to the // temp one (which may have a different atom numbering or additional // atoms added). // 5) Update the positions of the atoms on the old molecule. // 6) Free the temp molecule. // // NOTES: // - *FIX:* at the moment we're not doing anything to clear up the // temp file created in this process. It'll always have the same // name unless the user explicitly asks that we do something different. // - To use the DLL, it's essential that the COMBICHEM_ROOT and COMBICHEM_RELEASE // environment variables be set. If this isn't done, this whole process // will fail. // - See the notes above about failures when opening the DLL. // //************************************************************************************* int Add2DCoordsToMolDLL(ROMol &mol,std::string tempFilename){ std::string smi=MolToSmiles(mol,true); int tmp = SmilesToMolFileDLL(smi,tempFilename); int res = -1; if(tmp){ // build another mol from that mol file: RWMol *tmpMol = MolFileToMol(tempFilename,false); // match it up with the starting mol: // (We need to do this because the depict.dll conversion // to a mol file may have added Hs) MatchVectType matchVect; bool hasMatch=SubstructMatch(tmpMol,&mol,matchVect); if(hasMatch){ const Conformer &conf = tmpMol->getCoformer(0); Coformer *nconf = new Coformer(mol.getNumAtoms()); for(MatchVectType::const_iterator mvi=matchVect.begin(); mvi!=matchVect.end();mvi++){ nconf->setAtomPos(conf.getAtomPos(mvi->first)); } confId = (int)mol.addConformer(nconf, true); } delete tmpMol; } return res; }
INT_LIST getShortestPath(const ROMol &mol, int aid1, int aid2) { int nats = mol.getNumAtoms(); RANGE_CHECK(0,aid1,nats-1); RANGE_CHECK(0,aid2,nats-1); CHECK_INVARIANT(aid1 != aid2, ""); INT_VECT pred, doneAtms; //pred.reserve(nats); //doneAtms.reserve(nats); pred.resize(nats); doneAtms.resize(nats); int ai; for (ai = 0; ai < nats; ++ai) { doneAtms[ai] = 0; } std::deque<int> bfsQ; bfsQ.push_back(aid1); bool done = false; ROMol::ADJ_ITER nbrIdx,endNbrs; while ((!done) && (bfsQ.size() > 0)) { int curAid = bfsQ.front(); boost::tie(nbrIdx,endNbrs) = mol.getAtomNeighbors(mol.getAtomWithIdx(curAid)); while (nbrIdx != endNbrs) { if (doneAtms[*nbrIdx] == 0) { pred[*nbrIdx] = curAid; if (static_cast<int>(*nbrIdx) == aid2) { done = true; break; } bfsQ.push_back(*nbrIdx); } nbrIdx++; } doneAtms[curAid] = 1; bfsQ.pop_front(); } INT_LIST res; if(done){ done = false; int prev = aid2; res.push_back(aid2); while (!done) { prev = pred[prev]; if (prev != aid1) { res.push_front(prev); } else { done = true; } } res.push_front(aid1); } return res; }
void alignMolConformers(ROMol &mol, const std::vector<unsigned int> *atomIds, const std::vector<unsigned int> *confIds, const RDNumeric::DoubleVector *weights, bool reflect, unsigned int maxIters, std::vector<double> *RMSlist) { if (mol.getNumConformers() == 0) { // nothing to be done ; return; } RDGeom::Point3DConstPtrVect refPoints, prbPoints; int cid = -1; if ((confIds != 0) && (confIds->size() > 0)) { cid = confIds->front(); } const Conformer &refCnf = mol.getConformer(cid); _fillAtomPositions(refPoints, refCnf, atomIds); // now loop throught the remaininf conformations and transform them RDGeom::Transform3D trans; double ssd; if (confIds == 0) { unsigned int i = 0; ROMol::ConformerIterator cnfi; // Conformer *conf; for (cnfi = mol.beginConformers(); cnfi != mol.endConformers(); cnfi++) { // conf = (*cnfi); i += 1; if (i == 1) { continue; } _fillAtomPositions(prbPoints, *(*cnfi), atomIds); ssd = RDNumeric::Alignments::AlignPoints(refPoints, prbPoints, trans, weights, reflect, maxIters); if (RMSlist) { ssd /= (prbPoints.size()); RMSlist->push_back(sqrt(ssd)); } MolTransforms::transformConformer(*(*cnfi), trans); } } else { std::vector<unsigned int>::const_iterator cai; unsigned int i = 0; for (cai = confIds->begin(); cai != confIds->end(); cai++) { i += 1; if (i == 1) { continue; } Conformer &conf = mol.getConformer(*cai); _fillAtomPositions(prbPoints, conf, atomIds); ssd = RDNumeric::Alignments::AlignPoints(refPoints, prbPoints, trans, weights, reflect, maxIters); if (RMSlist) { ssd /= (prbPoints.size()); RMSlist->push_back(sqrt(ssd)); } MolTransforms::transformConformer(conf, trans); } } }
bool MCSAtomCompareIsotopes (const MCSAtomCompareParameters& p, const ROMol& mol1, unsigned int atom1, const ROMol& mol2, unsigned int atom2, void* ud) { // ignore everything except isotope information: //if( ! MCSAtomCompareElements (p, mol1, atom1, mol2, atom2, ud)) // return false; const Atom& a1 = *mol1.getAtomWithIdx(atom1); const Atom& a2 = *mol2.getAtomWithIdx(atom2); return a1.getIsotope() == a2.getIsotope(); }
bool classifyAtoms(ROMol &mol, std::vector<double> &radii, const SASAOpts &opts) { radii.clear(); const freesasa_classifier *classifier = nullptr; switch (opts.classifier) { case SASAOpts::Protor: classifier = &freesasa_protor_classifier; break; case SASAOpts::NACCESS: classifier = &freesasa_naccess_classifier; break; case SASAOpts::OONS: classifier = &freesasa_oons_classifier; break; default: throw ValueErrorException("unknown FreeSASA classifier specified"); return false; } bool success = true; for (ROMol::AtomIterator at = mol.beginAtoms(); at != mol.endAtoms(); ++at) { Atom *atom = *at; freesasa_atom_class cls = FREESASA_ATOM_UNKNOWN; std::string classification = "Unclassified"; double radius = 0.0; const AtomMonomerInfo *info = atom->getMonomerInfo(); if (info) { const char *atom_name = info->getName().c_str(); const char *res_name = nullptr; if (info->getMonomerType() == AtomMonomerInfo::PDBRESIDUE) { res_name = ((AtomPDBResidueInfo *)info)->getResidueName().c_str(); radius = freesasa_classifier_radius(classifier, res_name, atom_name); if (radius == 0.0) { BOOST_LOG(rdWarningLog) << "Atom " << atom->getIdx() << " has zero radius" << std::endl; } cls = freesasa_classifier_class(classifier, res_name, atom_name); if (cls == FREESASA_ATOM_UNKNOWN) { BOOST_LOG(rdWarningLog) << "Atom " << atom->getIdx() << " could not be classified" << std::endl; success = false; } else { classification = freesasa_classifier_class2str(cls); } } } radii.push_back(radius); atom->setProp<int>(common_properties::Atom::SASAClass, (int)cls); atom->setProp(common_properties::Atom::SASAClassName, classification); } return success; }
void test6() { BOOST_LOG(rdErrorLog) << "-------------------------------------" << std::endl; BOOST_LOG(rdErrorLog) << "Feature Location testing." << std::endl; ROMol *testMol; Conformer *conf; std::string inText; FeatSPtrList featSPtrs; boost::shared_ptr<MolChemicalFeature> featSPtr; MolChemicalFeatureFactory *factory; MolChemicalFeatureDef::CollectionType::value_type featDef; inText = "DefineFeature HDonor1 [N,O;!H0]\n" " Family HBondDonor\n" " Weights 1.0\n" "EndFeature\n" "DefineFeature Carboxyl1 C(=O)[O;H1,-]\n" " Family ZnBinder\n" " Weights 1.0,1.0,1.0\n" "EndFeature\n"; factory = buildFeatureFactory(inText); TEST_ASSERT(factory); TEST_ASSERT(factory->getNumFeatureDefs() == 2); testMol = SmilesToMol("C(=O)O"); TEST_ASSERT(testMol); conf = new Conformer(3); testMol->addConformer(conf); conf->setAtomPos(0, RDGeom::Point3D(0, 0, 0.0)); conf->setAtomPos(1, RDGeom::Point3D(1.2, 0, 0.0)); conf->setAtomPos(2, RDGeom::Point3D(0, 1.5, 0.0)); featSPtrs = factory->getFeaturesForMol(*testMol); TEST_ASSERT(featSPtrs.size() == 2); featSPtr = *featSPtrs.begin(); TEST_ASSERT(featSPtr->getFamily() == "HBondDonor"); TEST_ASSERT(featSPtr->getType() == "HDonor1"); TEST_ASSERT(feq(featSPtr->getPos().x, 0.0)); TEST_ASSERT(feq(featSPtr->getPos().y, 1.5)); TEST_ASSERT(feq(featSPtr->getPos().z, 0.0)); featSPtr = *(++featSPtrs.begin()); TEST_ASSERT(featSPtr->getFamily() == "ZnBinder"); TEST_ASSERT(featSPtr->getType() == "Carboxyl1"); TEST_ASSERT(feq(featSPtr->getPos().x, 0.4)); TEST_ASSERT(feq(featSPtr->getPos().y, 0.5)); TEST_ASSERT(feq(featSPtr->getPos().z, 0.0)); delete testMol; delete factory; BOOST_LOG(rdErrorLog) << " done" << std::endl; }
bool MCSAtomCompareElements (const MCSAtomCompareParameters& p, const ROMol& mol1, unsigned int atom1, const ROMol& mol2, unsigned int atom2, void* ) { const Atom& a1 = *mol1.getAtomWithIdx(atom1); const Atom& a2 = *mol2.getAtomWithIdx(atom2); if(a1.getAtomicNum() != a2.getAtomicNum()) return false; if(p.MatchValences && a1.getTotalValence() != a2.getTotalValence()) return false; return true; }
void testSDMemoryCorruption() { std::string rdbase = getenv("RDBASE"); std::string fname = rdbase + "/Data/NCI/first_200.props.sdf"; SDMolSupplier sdsup(fname,true); std::string ofile = rdbase + "/Code/GraphMol/FileParsers/test_data/outNCI_first_200.props.sdf"; std::ostream *os=new std::ofstream(ofile.c_str()); //std::ostream *os=new std::stringstream(); SDWriter *writer = new SDWriter(os,false); STR_VECT names; #if 1 ROMol *m1=sdsup.next(); MolOps::sanitizeMol(*(RWMol *)m1); #else ROMol *m1=SmilesToMol("C1CC1"); TEST_ASSERT(m1); #endif sdsup.reset(); int nDone=0; while (!sdsup.atEnd()) { //std::cerr<<nDone<<std::endl; ROMol *mol = sdsup.next(); //std::cerr<<"m:"<<mol<<std::endl; TEST_ASSERT(mol); std::string mname; mol->getProp("_Name", mname); names.push_back(mname); //std::cerr<<" w"<<std::endl; writer->write(*mol); //std::cerr<<" ok"<<std::endl; delete mol; nDone++; } CHECK_INVARIANT(nDone == 200, ""); writer->flush(); CHECK_INVARIANT(writer->numMols() == 200, ""); delete writer; #if 1 // now read in the file we just finished writing SDMolSupplier reader(ofile); int i = 0; while (!reader.atEnd()) { ROMol *mol = reader.next(); std::string mname; mol->getProp("_Name", mname); CHECK_INVARIANT(mname == names[i], ""); delete mol; i++; } #endif }
void ClearSingleBondDirFlags(ROMol &mol) { for (RWMol::BondIterator bondIt = mol.beginBonds(); bondIt != mol.endBonds(); ++bondIt) { if ((*bondIt)->getBondType() == Bond::SINGLE) { if ((*bondIt)->getBondDir() == Bond::UNKNOWN) (*bondIt)->setProp(common_properties::_UnknownStereo, 1); (*bondIt)->setBondDir(Bond::NONE); } } }
double tverskyIndex(const ROMol &mol1, const ROMol &mol2, double alpha, double beta, int confId1, int confId2, double gridSpacing, DiscreteValueVect::DiscreteValueType bitsPerPoint, double vdwScale, double stepSize, int maxLayers, bool ignoreHs) { const Conformer &conf1 = mol1.getConformer(confId1); const Conformer &conf2 = mol2.getConformer(confId2); return tverskyIndex(conf1, conf2, alpha, beta, gridSpacing, bitsPerPoint, vdwScale, stepSize, maxLayers, ignoreHs); }
double tanimotoDistance(const ROMol &mol1, const ROMol &mol2, int confId1, int confId2, double gridSpacing, DiscreteValueVect::DiscreteValueType bitsPerPoint, double vdwScale, double stepSize, int maxLayers, bool ignoreHs) { const Conformer &conf1 = mol1.getConformer(confId1); const Conformer &conf2 = mol2.getConformer(confId2); return tanimotoDistance(conf1, conf2, gridSpacing = 0.5, bitsPerPoint, vdwScale, stepSize, maxLayers, ignoreHs); }
EEM_arrays::EEM_arrays(const ROMol &mol, unsigned int sz) : n(sz) { /* Fill vector b i.e. -A */ Atomindex = new unsigned int[n]; EEMatomtype = new unsigned int[n]; for (unsigned int j = 0; j < n; j++) { EEMatomtype[j] = getAtomtype(mol, mol.getAtomWithIdx(j)); Atomindex[j] = mol.getAtomWithIdx(j)->getAtomicNum(); } }
void testSDWriterStrm() { std::string rdbase = getenv("RDBASE"); { std::string fname = rdbase + "/Code/GraphMol/FileParsers/test_data/NCI_aids_few.sdf"; SDMolSupplier sdsup(fname); std::string ofile = rdbase + "/Code/GraphMol/FileParsers/test_data/outNCI_few.sdf"; std::ofstream *oStream=new std::ofstream(ofile.c_str()); SDWriter *writer = new SDWriter(oStream); STR_VECT names; while (!sdsup.atEnd()) { ROMol *mol = sdsup.next(); std::string mname; mol->getProp("_Name", mname); names.push_back(mname); writer->write(*mol); delete mol; } writer->flush(); CHECK_INVARIANT(writer->numMols() == 16, ""); delete writer; // now read in the file we just finished writing SDMolSupplier reader(ofile); int i = 0; while (!reader.atEnd()) { ROMol *mol = reader.next(); std::string mname; mol->getProp("_Name", mname); CHECK_INVARIANT(mname == names[i], ""); delete mol; i++; } } { // now read in a file with aromatic information on the bonds std::string infile = rdbase + "/Code/GraphMol/FileParsers/test_data/outNCI_arom.sdf"; SDMolSupplier nreader(infile); unsigned int i = 0; while (!nreader.atEnd()) { ROMol *mol = nreader.next(); TEST_ASSERT(mol); ++i; delete mol; } TEST_ASSERT(i==16); } }
double calcTPSA(const ROMol &mol, bool force) { if (!force && mol.hasProp(common_properties::_tpsa)) { double res; mol.getProp(common_properties::_tpsa, res); return res; } std::vector<double> contribs; contribs.resize(mol.getNumAtoms()); double res; res = getTPSAAtomContribs(mol, contribs, force); return res; }
void testSmilesWriterStrm() { std::string rdbase = getenv("RDBASE"); std::string fname = rdbase + "/Code/GraphMol/FileParsers/test_data/fewSmi.csv"; SmilesMolSupplier *nSup = new SmilesMolSupplier(fname, ",", 1, 0, false); std::string oname = rdbase + "/Code/GraphMol/FileParsers/test_data/outSmiles.csv"; std::ofstream *oStream=new std::ofstream(oname.c_str()); STR_VECT propNames; propNames.push_back(std::string("Column_2")); SmilesWriter *writer = new SmilesWriter(oStream, " "); writer->setProps(propNames); STR_VECT names; STR_VECT props; ROMol *mol = nSup->next(); while (mol) { std::string mname, pval; mol->getProp("_Name", mname); mol->getProp("Column_2", pval); names.push_back(mname); props.push_back(pval); writer->write(*mol); delete mol; try { mol = nSup->next(); } catch (FileParseException &) { break; } } writer->flush(); delete writer; delete nSup; // now read the molecules back in a check if we have the same properties etc nSup = new SmilesMolSupplier(oname); int i = 0; mol = nSup->next(); while (mol){ std::string mname, pval; mol->getProp("_Name", mname); mol->getProp("Column_2", pval); CHECK_INVARIANT(mname == names[i], ""); CHECK_INVARIANT(pval == props[i], ""); i++; delete mol; try { mol = nSup->next(); } catch (FileParseException &) { break; } } }
array<Point3D, 4> calcRefPoints(const ROMol& mol, const vector<int>& heavyAtoms) { const auto num_points = heavyAtoms.size(); assert(num_points == mol.getNumHeavyAtoms()); const auto& conf = mol.getConformer(); array<Point3D, 4> refPoints; for (auto& ref : refPoints) { assert(ref[0] == 0); assert(ref[1] == 0); assert(ref[2] == 0); } auto& ctd = refPoints[0]; auto& cst = refPoints[1]; auto& fct = refPoints[2]; auto& ftf = refPoints[3]; for (const auto i : heavyAtoms) { const auto& a = conf.getAtomPos(i); ctd += a; } ctd /= num_points; double cst_dist = numeric_limits<double>::max(); double fct_dist = numeric_limits<double>::lowest(); double ftf_dist = numeric_limits<double>::lowest(); for (const auto i : heavyAtoms) { const auto& a = conf.getAtomPos(i); const auto this_dist = dist2(a, ctd); if (this_dist < cst_dist) { cst = a; cst_dist = this_dist; } if (this_dist > fct_dist) { fct = a; fct_dist = this_dist; } } for (const auto i : heavyAtoms) { const auto& a = conf.getAtomPos(i); const auto this_dist = dist2(a, fct); if (this_dist > ftf_dist) { ftf = a; ftf_dist = this_dist; } } return refPoints; }
double calcLabuteASA(const ROMol &mol, bool includeHs, bool force) { if (!force && mol.hasProp(common_properties::_labuteASA)) { double res; mol.getProp(common_properties::_labuteASA, res); return res; } std::vector<double> contribs; contribs.resize(mol.getNumAtoms()); double hContrib; double res; res = getLabuteAtomContribs(mol, contribs, hContrib, includeHs, force); return res; }
void setHybridization(ROMol &mol) { ROMol::AtomIterator ai; int norbs; for (ai = mol.beginAtoms(); ai != mol.endAtoms(); ai++) { if((*ai)->getAtomicNum()==0){ (*ai)->setHybridization(Atom::UNSPECIFIED); } else { norbs = numBondsPlusLonePairs(*ai); switch(norbs) { case 0: // This occurs for things like Na+ (*ai)->setHybridization(Atom::S); break; case 1: (*ai)->setHybridization(Atom::S); break; case 2: (*ai)->setHybridization(Atom::SP); break; case 3: (*ai)->setHybridization(Atom::SP2); break; case 4: // potentially SP3, but we'll set it down to SP2 // if we have a conjugated bond (like the second O // in O=CO) // we'll also avoid setting the hybridization down to // SP2 in the case of an atom with degree higher than 3 // (e.g. things like CP1(C)=CC=CN=C1C, where the P // has norbs = 4, and a conjugated bond, but clearly should // not be SP2) // This is Issue276 if((*ai)->getDegree()>3 || !MolOps::atomHasConjugatedBond(*ai)){ (*ai)->setHybridization(Atom::SP3); } else { (*ai)->setHybridization(Atom::SP2); } break; case 5: (*ai)->setHybridization(Atom::SP3D); break; case 6: (*ai)->setHybridization(Atom::SP3D2); break; default : (*ai)->setHybridization(Atom::UNSPECIFIED); } } } }
// ------------------------------------------------------------------------ // // // // ------------------------------------------------------------------------ void addAngleSpecialCases(const ROMol &mol, int confId, const AtomicParamVect ¶ms, ForceFields::ForceField *field){ PRECONDITION(mol.getNumAtoms()==params.size(),"bad parameters"); PRECONDITION(field,"bad forcefield"); unsigned int nAtoms=mol.getNumAtoms(); for(unsigned int i=0;i<nAtoms;i++){ const Atom *atom = mol.getAtomWithIdx(i); // trigonal bipyramidal: if( (atom->getHybridization()==Atom::SP3D && atom->getDegree()==5) ){ addTrigonalBipyramidAngles(atom,mol,confId, params,field); } } }
void fragmentOnSomeBonds( const ROMol &mol, const std::vector<unsigned int> &bondIndices, std::vector<ROMOL_SPTR> &resMols, unsigned int maxToCut, bool addDummies, const std::vector<std::pair<unsigned int, unsigned int>> *dummyLabels, const std::vector<Bond::BondType> *bondTypes, std::vector<std::vector<unsigned int>> *nCutsPerAtom) { PRECONDITION((!dummyLabels || dummyLabels->size() == bondIndices.size()), "bad dummyLabel vector"); PRECONDITION((!bondTypes || bondTypes->size() == bondIndices.size()), "bad bondType vector"); if (bondIndices.size() > 63) throw ValueErrorException("currently can only fragment on up to 63 bonds"); if (!maxToCut || !mol.getNumAtoms() || !bondIndices.size()) return; boost::uint64_t state = (0x1L << maxToCut) - 1; boost::uint64_t stop = 0x1L << bondIndices.size(); std::vector<unsigned int> fragmentHere(maxToCut); std::vector<std::pair<unsigned int, unsigned int>> *dummyLabelsHere = nullptr; if (dummyLabels) { dummyLabelsHere = new std::vector<std::pair<unsigned int, unsigned int>>(maxToCut); } std::vector<Bond::BondType> *bondTypesHere = nullptr; if (bondTypes) { bondTypesHere = new std::vector<Bond::BondType>(maxToCut); } while (state < stop) { unsigned int nSeen = 0; for (unsigned int i = 0; i < bondIndices.size() && nSeen < maxToCut; ++i) { if (state & (0x1L << i)) { fragmentHere[nSeen] = bondIndices[i]; if (dummyLabelsHere) (*dummyLabelsHere)[nSeen] = (*dummyLabels)[i]; if (bondTypesHere) (*bondTypesHere)[nSeen] = (*bondTypes)[i]; ++nSeen; } } std::vector<unsigned int> *lCutsPerAtom = nullptr; if (nCutsPerAtom) { nCutsPerAtom->push_back(std::vector<unsigned int>(mol.getNumAtoms())); lCutsPerAtom = &(nCutsPerAtom->back()); } ROMol *nm = fragmentOnBonds(mol, fragmentHere, addDummies, dummyLabelsHere, bondTypesHere, lCutsPerAtom); resMols.push_back(ROMOL_SPTR(nm)); state = nextBitCombo(state); } delete dummyLabelsHere; delete bondTypesHere; }
void WedgeMolBonds(ROMol &mol, const Conformer *conf) { PRECONDITION(conf, "no conformer"); INT_MAP_INT wedgeBonds = pickBondsToWedge(mol); for (ROMol::BondIterator bondIt = mol.beginBonds(); bondIt != mol.endBonds(); ++bondIt) { Bond *bond = *bondIt; if (bond->getBondType() == Bond::SINGLE) { Bond::BondDir dir = DetermineBondWedgeState(bond, wedgeBonds, conf); if (dir == Bond::BEGINWEDGE || dir == Bond::BEGINDASH) { bond->setBondDir(dir); } } } }
bool MCSBondCompareOrderExact (const MCSBondCompareParameters& p, const ROMol& mol1, unsigned int bond1, const ROMol& mol2, unsigned int bond2, void* ud) { static const BondMatchOrderMatrix match(false); // AROMATIC != SINGLE const Bond* b1 = mol1.getBondWithIdx(bond1); const Bond* b2 = mol2.getBondWithIdx(bond2); Bond::BondType t1 = b1->getBondType(); Bond::BondType t2 = b2->getBondType(); if(match.isEqual(t1,t2)) { if(p.RingMatchesRingOnly) return checkRingMatch(p, mol1, bond1, mol2, bond2, ud); else return true; } return false; }
// ------------------------------------------------------------------------ // // the two-bit matrix returned by this contains: // 0: if atoms i and j are directly connected // 1: if atoms i and j are connected via an atom // 3: otherwise // // NOTE: the caller is responsible for calling delete [] // on the result // // ------------------------------------------------------------------------ boost::shared_array<boost::uint8_t> buildNeighborMatrix(const ROMol &mol) { unsigned int nAtoms = mol.getNumAtoms(); unsigned nTwoBitCells = (nAtoms * nAtoms - 1) / 4 + 1; boost::shared_array<boost::uint8_t> res(new boost::uint8_t[nTwoBitCells]); for (unsigned int i = 0; i < nTwoBitCells; ++i) { res[i] = 0; } for (unsigned int i = 0; i < nAtoms; ++i) { unsigned int iTab = i * nAtoms; for (unsigned int j = i; j < nAtoms; ++j) { setTwoBitCell(res, iTab + j, RELATION_1_X); setTwoBitCell(res, i + j * nAtoms, RELATION_1_X); } } for (unsigned int i = 0; i < mol.getNumBonds(); ++i) { const Bond *bondi = mol.getBondWithIdx(i); setTwoBitCell(res, bondi->getBeginAtomIdx() * nAtoms + bondi->getEndAtomIdx(), RELATION_1_2); setTwoBitCell(res, bondi->getEndAtomIdx() * nAtoms + bondi->getBeginAtomIdx(), RELATION_1_2); for (unsigned int j = i + 1; j < mol.getNumBonds(); ++j) { const Bond *bondj = mol.getBondWithIdx(j); int idx1 = -1; int idx3 = -1; if (bondi->getBeginAtomIdx() == bondj->getBeginAtomIdx()) { idx1 = bondi->getEndAtomIdx(); idx3 = bondj->getEndAtomIdx(); } else if (bondi->getBeginAtomIdx() == bondj->getEndAtomIdx()) { idx1 = bondi->getEndAtomIdx(); idx3 = bondj->getBeginAtomIdx(); } else if (bondi->getEndAtomIdx() == bondj->getBeginAtomIdx()) { idx1 = bondi->getBeginAtomIdx(); idx3 = bondj->getEndAtomIdx(); } else if (bondi->getEndAtomIdx() == bondj->getEndAtomIdx()) { idx1 = bondi->getBeginAtomIdx(); idx3 = bondj->getBeginAtomIdx(); } if (idx1 > -1) { setTwoBitCell(res, idx1 * nAtoms + idx3, RELATION_1_3); setTwoBitCell(res, idx3 * nAtoms + idx1, RELATION_1_3); } } } return res; }
bool atomIsCandidateForRingStereochem(const ROMol &mol, const Atom *atom) { PRECONDITION(atom, "bad atom"); bool res = false; if (!atom->getPropIfPresent(common_properties::_ringStereochemCand, res)) { const RingInfo *ringInfo = mol.getRingInfo(); if (ringInfo->isInitialized() && ringInfo->numAtomRings(atom->getIdx())) { ROMol::OEDGE_ITER beg, end; boost::tie(beg, end) = mol.getAtomBonds(atom); std::vector<const Atom *> nonRingNbrs; std::vector<const Atom *> ringNbrs; while (beg != end) { const BOND_SPTR bond = mol[*beg]; if (!ringInfo->numBondRings(bond->getIdx())) { nonRingNbrs.push_back(bond->getOtherAtom(atom)); } else { ringNbrs.push_back(bond->getOtherAtom(atom)); } ++beg; } unsigned int rank1 = 0, rank2 = 0; switch (nonRingNbrs.size()) { case 0: // don't do spiro: res = false; break; case 1: if (ringNbrs.size() == 2) res = true; break; case 2: if (nonRingNbrs[0]->getPropIfPresent(common_properties::_CIPRank, rank1) && nonRingNbrs[1]->getPropIfPresent(common_properties::_CIPRank, rank2)) { if (rank1 == rank2) { res = false; } else { res = true; } } break; default: res = false; } } atom->setProp(common_properties::_ringStereochemCand, res, 1); } return res; }
std::string MolToSequence(const ROMol &mol) { std::string result; for (ROMol::ConstAtomIterator atomIt=mol.beginAtoms(); atomIt!=mol.endAtoms();++atomIt){ const Atom *atom = *atomIt; AtomPDBResidueInfo *info = (AtomPDBResidueInfo*)(atom->getMonomerInfo()); if (info && info->getMonomerType()==AtomMonomerInfo::PDBRESIDUE && info->getName() == " CA ") { result += getOneLetterCode(info); } } return result; }
void testCrippenO3AConstraintsAndLocalOnly() { std::string rdbase = getenv("RDBASE"); std::string sdf = rdbase + "/Code/GraphMol/MolAlign/test_data/ref_e2.sdf"; SDMolSupplier supplier(sdf, true, false); const int refNum = 23; const int prbNum = 32; ROMol *refMol = supplier[refNum]; ROMol *prbMol = supplier[prbNum]; MMFF::MMFFMolProperties refMP(*refMol); TEST_ASSERT(refMP.isValid()); MMFF::MMFFMolProperties prbMP(*prbMol); TEST_ASSERT(prbMP.isValid()); RWMol *patt = SmartsToMol("S"); MatchVectType matchVect; TEST_ASSERT(SubstructMatch(*refMol, (ROMol &)*patt, matchVect)); delete patt; unsigned int refSIdx = matchVect[0].second; matchVect.clear(); patt = SmartsToMol("O"); TEST_ASSERT(SubstructMatch(*prbMol, (ROMol &)*patt, matchVect)); delete patt; unsigned int prbOIdx = matchVect[0].second; std::vector<double> distOS(2); distOS[0] = 3.2; distOS[1] = 0.3; std::vector<double> weights(2); weights[0] = 10.0; weights[1] = 100.0; for (unsigned int i = 0; i < 2; ++i) { MatchVectType constraintMap; constraintMap.push_back(std::make_pair(prbOIdx, refSIdx)); RDNumeric::DoubleVector constraintWeights(1); constraintWeights[0] = weights[i]; MolAlign::O3A *o3a = new MolAlign::O3A(*prbMol, *refMol, &prbMP, &refMP, MolAlign::O3A::MMFF94, -1, -1, false, 50, 0, &constraintMap, &constraintWeights); TEST_ASSERT(o3a); o3a->align(); delete o3a; o3a = new MolAlign::O3A(*prbMol, *refMol, &prbMP, &refMP, MolAlign::O3A::MMFF94, -1, -1, false, 50, MolAlign::O3_LOCAL_ONLY); TEST_ASSERT(o3a); o3a->align(); delete o3a; double d = (prbMol->getConformer().getAtomPos(prbOIdx) - refMol->getConformer().getAtomPos(refSIdx)).length(); TEST_ASSERT(feq(d, distOS[i], 0.1)); } }