int countAtomElec(const Atom *at) { PRECONDITION(at, "bad atom"); // default valence : int dv = PeriodicTable::getTable()->getDefaultValence(at->getAtomicNum()); if (dv <= 1) { // univalent elements can't be either aromatic or conjugated return -1; } // total atom degree: int degree = at->getDegree() + at->getTotalNumHs(); ROMol::OEDGE_ITER beg, end; boost::tie(beg, end) = at->getOwningMol().getAtomBonds(at); while (beg != end) { BOND_SPTR bond = at->getOwningMol()[*beg]; if (bond->getBondType() == Bond::UNSPECIFIED // query bonds should not // contribute; this was github // issue #443 || bond->getBondType() == Bond::ZERO) --degree; ++beg; } // if we are more than 3 coordinated we should not be aromatic if (degree > 3) { return -1; } // number of lone pair electrons = (outer shell elecs) - (default valence) int nlp; nlp = PeriodicTable::getTable()->getNouterElecs(at->getAtomicNum()) - dv; // subtract the charge to get the true number of lone pair electrons: nlp = std::max(nlp - at->getFormalCharge(), 0); int nRadicals = at->getNumRadicalElectrons(); // num electrons available for donation into the pi system: int res = (dv - degree) + nlp - nRadicals; if (res > 1) { // if we have an incident bond with order higher than 2, // (e.g. triple or higher), we only want to return 1 electron // we detect this using the total unsaturation, because we // know that there aren't multiple unsaturations (detected // above in isAtomCandForArom()) int nUnsaturations = at->getExplicitValence() - at->getDegree(); if (nUnsaturations > 1) { res = 1; } } return res; }
// find the neighbors for an atoms that are not connected by single bond that is // not refBond // if checkDir is true only neighbor atoms with bonds marked with a direction // will be returned void findAtomNeighborsHelper(const ROMol &mol, const Atom *atom, const Bond *refBond, UINT_VECT &neighbors, bool checkDir = false) { PRECONDITION(atom, "bad atom"); PRECONDITION(refBond, "bad bond"); neighbors.clear(); ROMol::OEDGE_ITER beg, end; boost::tie(beg, end) = mol.getAtomBonds(atom); while (beg != end) { const BOND_SPTR bond = mol[*beg]; Bond::BondDir dir = bond->getBondDir(); if (bond->getBondType() == Bond::SINGLE && bond->getIdx() != refBond->getIdx()) { if (checkDir) { if ((dir != Bond::ENDDOWNRIGHT) && (dir != Bond::ENDUPRIGHT)) { ++beg; continue; } } Atom *nbrAtom = bond->getOtherAtom(atom); neighbors.push_back(nbrAtom->getIdx()); } ++beg; } }
bool bondCompat(const BOND_SPTR &b1, const BOND_SPTR &b2, bool useQueryQueryMatches) { PRECONDITION(b1, "bad bond"); PRECONDITION(b2, "bad bond"); bool res; if (useQueryQueryMatches && b1->hasQuery() && b2->hasQuery()) { res = static_cast<QueryBond *>(b1.get())->QueryMatch( static_cast<QueryBond *>(b2.get())); } else { res = b1->Match(b2); } if (res && b1->getBondType() == Bond::DATIVE && b2->getBondType() == Bond::DATIVE) { // for dative bonds we need to make sure that the direction also matches: if (!b1->getBeginAtom()->Match(b1->getBeginAtom()) || !b1->getEndAtom()->Match(b2->getEndAtom())) { res = false; } } // std::cout << "\t\tbondCompat: "<< b1->getIdx() << "-" << b2->getIdx() << ": // " << res << std::endl; return res; }
// finds cycles void dfsFindCycles(ROMol &mol,int atomIdx,int inBondIdx, std::vector<AtomColors> &colors, const UINT_VECT &ranks, INT_VECT &atomOrders, VECT_INT_VECT &atomRingClosures, const boost::dynamic_bitset<> *bondsInPlay, const std::vector<std::string> *bondSymbols ){ Atom *atom = mol.getAtomWithIdx(atomIdx); atomOrders.push_back(atomIdx); colors[atomIdx] = GREY_NODE; // --------------------- // // Build the list of possible destinations from here // // --------------------- std::vector< PossibleType > possibles; possibles.resize(0); ROMol::OBOND_ITER_PAIR bondsPair = mol.getAtomBonds(atom); possibles.reserve(bondsPair.second-bondsPair.first); while(bondsPair.first != bondsPair.second){ BOND_SPTR theBond = mol[*(bondsPair.first)]; bondsPair.first++; if(bondsInPlay && !(*bondsInPlay)[theBond->getIdx()]) continue; if(inBondIdx<0 || theBond->getIdx() != static_cast<unsigned int>(inBondIdx)){ int otherIdx = theBond->getOtherAtomIdx(atomIdx); long rank=ranks[otherIdx]; // --------------------- // // things are a bit more complicated if we are sitting on a // ring atom. we would like to traverse first to the // ring-closure atoms, then to atoms outside the ring first, // then to atoms in the ring that haven't already been visited // (non-ring-closure atoms). // // Here's how the black magic works: // - non-ring atom neighbors have their original ranks // - ring atom neighbors have this added to their ranks: // (MAX_BONDTYPE - bondOrder)*MAX_NATOMS*MAX_NATOMS // - ring-closure neighbors lose a factor of: // (MAX_BONDTYPE+1)*MAX_NATOMS*MAX_NATOMS // // This tactic biases us to traverse to non-ring neighbors first, // original ordering if bond orders are all equal... crafty, neh? // // --------------------- if( colors[otherIdx] == GREY_NODE ) { rank -= static_cast<int>(MAX_BONDTYPE+1) * MAX_NATOMS*MAX_NATOMS; if(!bondSymbols){ rank += static_cast<int>(MAX_BONDTYPE - theBond->getBondType()) * MAX_NATOMS; } else { const std::string &symb=(*bondSymbols)[theBond->getIdx()]; boost::uint32_t hsh=gboost::hash_range(symb.begin(),symb.end()); rank += (hsh%MAX_NATOMS) * MAX_NATOMS; } } else if( theBond->getOwningMol().getRingInfo()->numBondRings(theBond->getIdx()) ){ if(!bondSymbols){ rank += static_cast<int>(MAX_BONDTYPE - theBond->getBondType()) * MAX_NATOMS*MAX_NATOMS; } else { const std::string &symb=(*bondSymbols)[theBond->getIdx()]; boost::uint32_t hsh=gboost::hash_range(symb.begin(),symb.end()); rank += (hsh%MAX_NATOMS)*MAX_NATOMS*MAX_NATOMS; } } //std::cerr<<"aIdx: "<< atomIdx <<" p: "<<otherIdx<<" Rank: "<<ranks[otherIdx] <<" "<<colors[otherIdx]<<" "<<theBond->getBondType()<<" "<<rank<<std::endl; possibles.push_back(PossibleType(rank,otherIdx,theBond.get())); } } // --------------------- // // Sort on ranks // // --------------------- std::sort(possibles.begin(),possibles.end(),_possibleCompare()); // --------------------- // // Now work the children // // --------------------- for(std::vector<PossibleType>::iterator possiblesIt=possibles.begin(); possiblesIt!=possibles.end(); possiblesIt++){ int possibleIdx = possiblesIt->get<1>(); Bond *bond = possiblesIt->get<2>(); Atom *otherAtom=mol.getAtomWithIdx(possibleIdx); switch(colors[possibleIdx]){ case WHITE_NODE: // ----- // we haven't seen this node at all before, traverse // ----- dfsFindCycles(mol,possibleIdx,bond->getIdx(),colors, ranks,atomOrders, atomRingClosures, bondsInPlay,bondSymbols); break; case GREY_NODE: // ----- // we've seen this, but haven't finished it (we're finishing a ring) // ----- atomRingClosures[possibleIdx].push_back(bond->getIdx()); atomRingClosures[atomIdx].push_back(bond->getIdx()); break; default: // ----- // this node has been finished. don't do anything. // ----- break; } } colors[atomIdx] = BLACK_NODE; }
RWMOL_SPTR initProduct(const ROMOL_SPTR prodTemplateSptr) { const ROMol *prodTemplate=prodTemplateSptr.get(); RWMol *res=new RWMol(); // --------- --------- --------- --------- --------- --------- // Initialize by making a copy of the product template as a normal molecule. // NOTE that we can't just use a normal copy because we do not want to end up // with query atoms or bonds in the product. // copy in the atoms: ROMol::ATOM_ITER_PAIR atItP = prodTemplate->getVertices(); while(atItP.first != atItP.second ) { Atom *oAtom=(*prodTemplate)[*(atItP.first++)].get(); Atom *newAtom=new Atom(*oAtom); res->addAtom(newAtom,false,true); int mapNum; if(newAtom->getPropIfPresent(common_properties::molAtomMapNumber, mapNum)) { // set bookmarks for the mapped atoms: res->setAtomBookmark(newAtom,mapNum); // now clear the molAtomMapNumber property so that it doesn't // end up in the products (this was bug 3140490): newAtom->clearProp(common_properties::molAtomMapNumber); } newAtom->setChiralTag(Atom::CHI_UNSPECIFIED); // if the product-template atom has the inversion flag set // to 4 (=SET), then bring its stereochem over, otherwise we'll // ignore it: int iFlag; if(oAtom->getPropIfPresent(common_properties::molInversionFlag, iFlag)) { if(iFlag==4) newAtom->setChiralTag(oAtom->getChiralTag()); } // check for properties we need to set: int val; if(newAtom->getPropIfPresent(common_properties::_QueryFormalCharge, val)) { newAtom->setFormalCharge(val); } if(newAtom->getPropIfPresent(common_properties::_QueryHCount, val)) { newAtom->setNumExplicitHs(val); } if(newAtom->getPropIfPresent(common_properties::_QueryMass, val)) { // FIX: technically should do something with this //newAtom->setMass(val); } if(newAtom->getPropIfPresent(common_properties::_QueryIsotope, val)) { newAtom->setIsotope(val); } } // and the bonds: ROMol::BOND_ITER_PAIR bondItP = prodTemplate->getEdges(); while(bondItP.first != bondItP.second ) { const BOND_SPTR oldB=(*prodTemplate)[*(bondItP.first++)]; unsigned int bondIdx; bondIdx=res->addBond(oldB->getBeginAtomIdx(),oldB->getEndAtomIdx(),oldB->getBondType())-1; // make sure we don't lose the bond dir information: Bond *newB=res->getBondWithIdx(bondIdx); newB->setBondDir(oldB->getBondDir()); // Special case/hack: // The product has been processed by the SMARTS parser. // The SMARTS parser tags unspecified bonds as single, but then adds // a query so that they match single or double // This caused Issue 1748846 // http://sourceforge.net/tracker/index.php?func=detail&aid=1748846&group_id=160139&atid=814650 // We need to fix that little problem now: if( oldB->hasQuery()) { // remember that the product has been processed by the SMARTS parser. std::string queryDescription=oldB->getQuery()->getDescription(); if(queryDescription=="BondOr" && oldB->getBondType()==Bond::SINGLE) { // We need to fix that little problem now: if(newB->getBeginAtom()->getIsAromatic() && newB->getEndAtom()->getIsAromatic()) { newB->setBondType(Bond::AROMATIC); newB->setIsAromatic(true); } else { newB->setBondType(Bond::SINGLE); newB->setIsAromatic(false); } } else if(queryDescription=="BondNull") { newB->setProp(common_properties::NullBond,1); } } } return RWMOL_SPTR(res); } // end of initProduct()
static void addResult(std::vector<std::pair<ROMOL_SPTR, ROMOL_SPTR> >& res, // const SignatureVector& resSignature, const ROMol& mol, const BondVector_t& bonds_selected, size_t maxCuts) { #ifdef _DEBUG std::cout << res.size() + 1 << ": "; #endif RWMol em(mol); // loop through the bonds to delete. == deleteBonds() unsigned isotope = 0; std::map<unsigned, unsigned> isotope_track; for (size_t i = 0; i < bonds_selected.size(); i++) { #ifdef _DEBUG { std::string symbol = em.getAtomWithIdx(bonds_selected[i].first)->getSymbol(); int label = 0; em.getAtomWithIdx(bonds_selected[i].first) ->getPropIfPresent(common_properties::molAtomMapNumber, label); char a1[32]; if (0 == label) sprintf(a1, "\'%s\'", symbol.c_str(), label); else sprintf(a1, "\'%s:%u\'", symbol.c_str(), label); symbol = em.getAtomWithIdx(bonds_selected[i].second)->getSymbol(); label = 0; em.getAtomWithIdx(bonds_selected[i].second) ->getPropIfPresent(common_properties::molAtomMapNumber, label); char a2[32]; if (0 == label) sprintf(a2, "\'%s\'", symbol.c_str(), label); else sprintf(a2, "\'%s:%u\'", symbol.c_str(), label); std::cout << "(" << bonds_selected[i].first << a1 << "," << bonds_selected[i].second << a2 << ") "; } #endif isotope += 1; // remove the bond em.removeBond(bonds_selected[i].first, bonds_selected[i].second); // now add attachement points and set attachment point lables Atom* a = new Atom(0); a->setProp(common_properties::molAtomMapNumber, (int)isotope); unsigned newAtomA = em.addAtom(a, true, true); em.addBond(bonds_selected[i].first, newAtomA, Bond::SINGLE); a = new Atom(0); a->setProp(common_properties::molAtomMapNumber, (int)isotope); unsigned newAtomB = em.addAtom(a, true, true); em.addBond(bonds_selected[i].second, newAtomB, Bond::SINGLE); // keep track of where to put isotopes isotope_track[newAtomA] = isotope; isotope_track[newAtomB] = isotope; } #ifdef _DEBUG std::cout << "\n"; #endif RWMOL_SPTR core, side_chains; // core & side_chains output molecules if (isotope == 1) { side_chains = RWMOL_SPTR(new RWMol(em)); // output = '%s,%s,,%s.%s' // DEBUG PRINT #ifdef _DEBUG // OK: std::cout<<res.size()+1<<" isotope="<< isotope <<","<< // MolToSmiles(*side_chains, true) <<"\n"; #endif } else if (isotope >= 2) { std::vector<std::vector<int> > frags; unsigned int nFrags = MolOps::getMolFrags(em, frags); //#check if its a valid triple or bigger cut. matchObj = re.search( //'\*.*\*.*\*', f) // check if exists a fragment with maxCut connection points (*.. *.. *) if (isotope >= 3) { bool valid = false; for (size_t i = 0; i < nFrags; i++) { unsigned nLabels = 0; for (size_t ai = 0; ai < frags[i].size(); ai++) { if (isotope_track.end() != isotope_track.find(frags[i][ai])) // new added atom ++nLabels; // found connection point } if (nLabels >= maxCuts) { // looks like it should be selected as core ! ?????? valid = true; break; } } if (!valid) { #ifdef _DEBUG std::cout << "isotope>=3: invalid fragments. fragment with maxCut " "connection points not found" << "\n"; #endif return; } } size_t iCore = std::numeric_limits<size_t>::max(); side_chains = RWMOL_SPTR(new RWMol); std::map<unsigned, unsigned> visitedBonds; // key is bond index in source molecule unsigned maxAttachments = 0; for (size_t i = 0; i < frags.size(); i++) { unsigned nAttachments = 0; for (size_t ai = 0; ai < frags[i].size(); ai++) { if (isotope_track.end() != isotope_track.find( frags[i][ai])) // == if(a->hasProp("molAtomMapNumber")) ++nAttachments; } if (maxAttachments < nAttachments) maxAttachments = nAttachments; if (1 == nAttachments) { // build side-chain set of molecules from // selected fragment std::map<unsigned, unsigned> newAtomMap; // key is atom index in source molecule for (size_t ai = 0; ai < frags[i].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[i][ai]); newAtomMap[frags[i][ai]] = side_chains->addAtom(a->copy(), true, true); } // add all bonds from this fragment for (size_t ai = 0; ai < frags[i].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[i][ai]); ROMol::OEDGE_ITER beg, end; for (boost::tie(beg, end) = em.getAtomBonds(a); beg != end; ++beg) { const BOND_SPTR bond = em[*beg]; if (newAtomMap.end() == newAtomMap.find(bond->getBeginAtomIdx()) || newAtomMap.end() == newAtomMap.find(bond->getEndAtomIdx()) || visitedBonds.end() != visitedBonds.find(bond->getIdx())) continue; unsigned ai1 = newAtomMap[bond->getBeginAtomIdx()]; unsigned ai2 = newAtomMap[bond->getEndAtomIdx()]; unsigned bi = side_chains->addBond(ai1, ai2, bond->getBondType()); visitedBonds[bond->getIdx()] = bi; } } } else { // select the core fragment // DEBUG PRINT #ifdef _DEBUG if (iCore != -1) std::cout << "Next CORE found. iCore=" << iCore << " New i=" << i << " nAttachments=" << nAttachments << "\n"; #endif if (nAttachments >= maxAttachments) // Choose a fragment with maximal // number of connection points as a // core iCore = i; } } // build core molecule from selected fragment if (iCore != std::numeric_limits<size_t>::max()) { core = RWMOL_SPTR(new RWMol); visitedBonds.clear(); std::map<unsigned, unsigned> newAtomMap; // key is atom index in source molecule for (size_t i = 0; i < frags[iCore].size(); i++) { unsigned ai = frags[iCore][i]; Atom* a = em.getAtomWithIdx(ai); newAtomMap[ai] = core->addAtom(a->copy(), true, true); } // add all bonds from this fragment for (size_t ai = 0; ai < frags[iCore].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[iCore][ai]); ROMol::OEDGE_ITER beg, end; for (boost::tie(beg, end) = em.getAtomBonds(a); beg != end; ++beg) { const BOND_SPTR bond = em[*beg]; if (newAtomMap.end() == newAtomMap.find(bond->getBeginAtomIdx()) || newAtomMap.end() == newAtomMap.find(bond->getEndAtomIdx()) || visitedBonds.end() != visitedBonds.find(bond->getIdx())) continue; unsigned ai1 = newAtomMap[bond->getBeginAtomIdx()]; unsigned ai2 = newAtomMap[bond->getEndAtomIdx()]; unsigned bi = core->addBond(ai1, ai2, bond->getBondType()); visitedBonds[bond->getIdx()] = bi; } } // DEBUG PRINT #ifdef _DEBUG // std::cout<<res.size()+1<<" isotope="<< isotope <<" "<< MolToSmiles(*core, // true)<<", "<<MolToSmiles(*side_chains, true)<<"\n"; #endif } // iCore != -1 } // check for duplicates: bool resFound = false; size_t ri = 0; for (ri = 0; ri < res.size(); ri++) { const std::pair<ROMOL_SPTR, ROMOL_SPTR>& r = res[ri]; if (side_chains->getNumAtoms() == r.second->getNumAtoms() && side_chains->getNumBonds() == r.second->getNumBonds() && ((NULL == core.get() && NULL == r.first.get()) || (NULL != core.get() && NULL != r.first.get() && core->getNumAtoms() == r.first->getNumAtoms() && core->getNumBonds() == r.first->getNumBonds()))) { // ToDo accurate check: // 1. compare hash code if (computeMorganCodeHash(*side_chains) == computeMorganCodeHash(*r.second) && (NULL == core || computeMorganCodeHash(*core) == computeMorganCodeHash(*r.first))) { // 2. final check to exclude hash collisions // We decided that it does not neccessary to implement resFound = true; break; } } } if (!resFound) { //std::cerr << "**********************" << std::endl; // From rfrag.py // now change the labels on sidechains and core // to get the new labels, cansmi the dot-disconnected side chains // the first fragment in the side chains has attachment label 1, 2nd: 2, 3rd: 3 // then change the labels accordingly in the core std::map<unsigned int, int> canonicalAtomMaps; if( side_chains.get() ) { RWMol tmp_side_chain(*(side_chains.get())); std::vector<int> oldMaps(tmp_side_chain.getNumAtoms(), 0); // clear atom labels (they are used in canonicalization) // and move them to dummy storage for (ROMol::AtomIterator at = tmp_side_chain.beginAtoms(); at != tmp_side_chain.endAtoms(); ++at) { int label = 0; if ((*at)->getPropIfPresent(common_properties::molAtomMapNumber, label) ) { (*at)->clearProp(common_properties::molAtomMapNumber); oldMaps[(*at)->getIdx()] = label; } } const bool doIsomericSmiles = true; // should this be false??? std::string smiles = MolToSmiles(tmp_side_chain, doIsomericSmiles); //std::cerr << "smiles: " << smiles << std::endl; // Get the canonical output order and use it to remap // the atom maps int the side chains // these will get reapplied to the core (if there is a core) const std::vector<unsigned int> &ranks = tmp_side_chain.getProp< std::vector<unsigned int> >( common_properties::_smilesAtomOutputOrder); std::vector<std::pair<unsigned int, int> > rankedAtoms; for(size_t idx=0;idx<ranks.size();++idx) { unsigned int atom_idx = ranks[idx]; if(oldMaps[atom_idx] >0) { const int label = oldMaps[atom_idx]; //std::cerr << "atom_idx: " << atom_idx << " rank: " << ranks[atom_idx] << // " molAtomMapNumber: " << label << std::endl; rankedAtoms.push_back(std::make_pair(idx, label)); } } std::sort(rankedAtoms.begin(), rankedAtoms.end()); int nextMap = 0; for(size_t i=0;i<rankedAtoms.size();++i) { if(canonicalAtomMaps.find(rankedAtoms[i].second) == canonicalAtomMaps.end()) { //std::cerr << "Remapping: " << rankedAtoms[i].second << " " << " to " << (i+1) << // std::endl; canonicalAtomMaps[rankedAtoms[i].second] = ++nextMap; } } } //std::cerr << "======== Remap core " << std::endl; if( core.get() ) { // remap core if it exists for (ROMol::AtomIterator at = core->beginAtoms(); at != core->endAtoms(); ++at) { int label = 0; if ((*at)->getPropIfPresent(common_properties::molAtomMapNumber, label) ) { //std::cerr << "remapping core: " << label << " :" << canonicalAtomMaps[label] << // std::endl; (*at)->setProp(common_properties::molAtomMapNumber, canonicalAtomMaps[label]); } } } //std::cerr << "======== Remap side-chain " << std::endl; for (ROMol::AtomIterator at = side_chains->beginAtoms(); at != side_chains->endAtoms(); ++at) { int label = 0; if ((*at)->getPropIfPresent(common_properties::molAtomMapNumber, label) ) { //std::cerr << "remapping side chain: " << label << " :" << // canonicalAtomMaps[label] << std::endl; (*at)->setProp(common_properties::molAtomMapNumber, canonicalAtomMaps[label]); } } res.push_back(std::pair<ROMOL_SPTR, ROMOL_SPTR>(core, side_chains)); // } #ifdef _DEBUG else std::cout << res.size() + 1 << " --- DUPLICATE Result FOUND --- ri=" << ri << "\n"; #endif }
static void addResult(std::vector<std::pair<ROMOL_SPTR, ROMOL_SPTR> >& res, // const SignatureVector& resSignature, const ROMol& mol, const BondVector_t& bonds_selected, size_t maxCuts) { #ifdef _DEBUG std::cout << res.size() + 1 << ": "; #endif RWMol em(mol); // loop through the bonds to delete. == deleteBonds() unsigned isotope = 0; std::map<unsigned, unsigned> isotope_track; for (size_t i = 0; i < bonds_selected.size(); i++) { #ifdef _DEBUG { std::string symbol = em.getAtomWithIdx(bonds_selected[i].first)->getSymbol(); int label = 0; em.getAtomWithIdx(bonds_selected[i].first) ->getPropIfPresent(common_properties::molAtomMapNumber, label); char a1[32]; if (0 == label) sprintf(a1, "\'%s\'", symbol.c_str(), label); else sprintf(a1, "\'%s:%u\'", symbol.c_str(), label); symbol = em.getAtomWithIdx(bonds_selected[i].second)->getSymbol(); label = 0; em.getAtomWithIdx(bonds_selected[i].second) ->getPropIfPresent(common_properties::molAtomMapNumber, label); char a2[32]; if (0 == label) sprintf(a2, "\'%s\'", symbol.c_str(), label); else sprintf(a2, "\'%s:%u\'", symbol.c_str(), label); std::cout << "(" << bonds_selected[i].first << a1 << "," << bonds_selected[i].second << a2 << ") "; } #endif isotope += 1; // remove the bond em.removeBond(bonds_selected[i].first, bonds_selected[i].second); // now add attachement points and set attachment point lables Atom* a = new Atom(0); a->setProp(common_properties::molAtomMapNumber, (int)isotope); unsigned newAtomA = em.addAtom(a, true, true); em.addBond(bonds_selected[i].first, newAtomA, Bond::SINGLE); a = new Atom(0); a->setProp(common_properties::molAtomMapNumber, (int)isotope); unsigned newAtomB = em.addAtom(a, true, true); em.addBond(bonds_selected[i].second, newAtomB, Bond::SINGLE); // keep track of where to put isotopes isotope_track[newAtomA] = isotope; isotope_track[newAtomB] = isotope; } #ifdef _DEBUG std::cout << "\n"; #endif RWMOL_SPTR core, side_chains; // core & side_chains output molecules if (isotope == 1) { side_chains = RWMOL_SPTR(new RWMol(em)); // output = '%s,%s,,%s.%s' // DEBUG PRINT #ifdef _DEBUG // OK: std::cout<<res.size()+1<<" isotope="<< isotope <<","<< // MolToSmiles(*side_chains, true) <<"\n"; #endif } else if (isotope >= 2) { std::vector<std::vector<int> > frags; unsigned int nFrags = MolOps::getMolFrags(em, frags); //#check if its a valid triple or bigger cut. matchObj = re.search( //'\*.*\*.*\*', f) // check if exists a fragment with maxCut connection points (*.. *.. *) if (isotope >= 3) { bool valid = false; for (size_t i = 0; i < nFrags; i++) { unsigned nLabels = 0; for (size_t ai = 0; ai < frags[i].size(); ai++) { if (isotope_track.end() != isotope_track.find(frags[i][ai])) // new added atom ++nLabels; // found connection point } if (nLabels >= maxCuts) { // looks like it should be selected as core ! ?????? valid = true; break; } } if (!valid) { #ifdef _DEBUG std::cout << "isotope>=3: invalid fragments. fragment with maxCut " "connection points not found" << "\n"; #endif return; } } size_t iCore = std::numeric_limits<size_t>::max(); side_chains = RWMOL_SPTR(new RWMol); std::map<unsigned, unsigned> visitedBonds; // key is bond index in source molecule unsigned maxAttachments = 0; for (size_t i = 0; i < frags.size(); i++) { unsigned nAttachments = 0; for (size_t ai = 0; ai < frags[i].size(); ai++) { if (isotope_track.end() != isotope_track.find( frags[i][ai])) // == if(a->hasProp("molAtomMapNumber")) ++nAttachments; } if (maxAttachments < nAttachments) maxAttachments = nAttachments; if (1 == nAttachments) { // build side-chain set of molecules from // selected fragment std::map<unsigned, unsigned> newAtomMap; // key is atom index in source molecule for (size_t ai = 0; ai < frags[i].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[i][ai]); newAtomMap[frags[i][ai]] = side_chains->addAtom(a->copy(), true, true); } // add all bonds from this fragment for (size_t ai = 0; ai < frags[i].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[i][ai]); ROMol::OEDGE_ITER beg, end; for (boost::tie(beg, end) = em.getAtomBonds(a); beg != end; ++beg) { const BOND_SPTR bond = em[*beg]; if (newAtomMap.end() == newAtomMap.find(bond->getBeginAtomIdx()) || newAtomMap.end() == newAtomMap.find(bond->getEndAtomIdx()) || visitedBonds.end() != visitedBonds.find(bond->getIdx())) continue; unsigned ai1 = newAtomMap[bond->getBeginAtomIdx()]; unsigned ai2 = newAtomMap[bond->getEndAtomIdx()]; unsigned bi = side_chains->addBond(ai1, ai2, bond->getBondType()); visitedBonds[bond->getIdx()] = bi; } } } else { // select the core fragment // DEBUG PRINT #ifdef _DEBUG if (iCore != -1) std::cout << "Next CORE found. iCore=" << iCore << " New i=" << i << " nAttachments=" << nAttachments << "\n"; #endif if (nAttachments >= maxAttachments) // Choose a fragment with maximal // number of connection points as a // core iCore = i; } } // build core molecule from selected fragment if (iCore != std::numeric_limits<size_t>::max()) { core = RWMOL_SPTR(new RWMol); visitedBonds.clear(); std::map<unsigned, unsigned> newAtomMap; // key is atom index in source molecule for (size_t i = 0; i < frags[iCore].size(); i++) { unsigned ai = frags[iCore][i]; Atom* a = em.getAtomWithIdx(ai); newAtomMap[ai] = core->addAtom(a->copy(), true, true); } // add all bonds from this fragment for (size_t ai = 0; ai < frags[iCore].size(); ai++) { Atom* a = em.getAtomWithIdx(frags[iCore][ai]); ROMol::OEDGE_ITER beg, end; for (boost::tie(beg, end) = em.getAtomBonds(a); beg != end; ++beg) { const BOND_SPTR bond = em[*beg]; if (newAtomMap.end() == newAtomMap.find(bond->getBeginAtomIdx()) || newAtomMap.end() == newAtomMap.find(bond->getEndAtomIdx()) || visitedBonds.end() != visitedBonds.find(bond->getIdx())) continue; unsigned ai1 = newAtomMap[bond->getBeginAtomIdx()]; unsigned ai2 = newAtomMap[bond->getEndAtomIdx()]; unsigned bi = core->addBond(ai1, ai2, bond->getBondType()); visitedBonds[bond->getIdx()] = bi; } } // DEBUG PRINT #ifdef _DEBUG // std::cout<<res.size()+1<<" isotope="<< isotope <<" "<< MolToSmiles(*core, // true)<<", "<<MolToSmiles(*side_chains, true)<<"\n"; #endif } // iCore != -1 } // check for dublicates: bool resFound = false; size_t ri = 0; for (ri = 0; ri < res.size(); ri++) { const std::pair<ROMOL_SPTR, ROMOL_SPTR>& r = res[ri]; if (side_chains->getNumAtoms() == r.second->getNumAtoms() && side_chains->getNumBonds() == r.second->getNumBonds() && ((NULL == core.get() && NULL == r.first.get()) || (NULL != core.get() && NULL != r.first.get() && core->getNumAtoms() == r.first->getNumAtoms() && core->getNumBonds() == r.first->getNumBonds()))) { // ToDo accurate check: // 1. compare hash code if (computeMorganCodeHash(*side_chains) == computeMorganCodeHash(*r.second) && (NULL == core || computeMorganCodeHash(*core) == computeMorganCodeHash(*r.first))) { // 2. final check to exclude hash collisions // We decided that it does not neccessary to implement resFound = true; break; } } } if (!resFound) res.push_back(std::pair<ROMOL_SPTR, ROMOL_SPTR>(core, side_chains)); // #ifdef _DEBUG else std::cout << res.size() + 1 << " --- DUPLICATE Result FOUND --- ri=" << ri << "\n"; #endif }
void canonicalDFSTraversal(ROMol &mol,int atomIdx,int inBondIdx, std::vector<AtomColors> &colors, VECT_INT_VECT &cycles, INT_VECT &ranks, INT_VECT &cyclesAvailable, MolStack &molStack, INT_VECT &atomOrders, INT_VECT &bondVisitOrders, VECT_INT_VECT &atomRingClosures, std::vector<INT_LIST> &atomTraversalBondOrder, const boost::dynamic_bitset<> *bondsInPlay, const std::vector<std::string> *bondSymbols ){ PRECONDITION(colors.size()>=mol.getNumAtoms(),"vector too small"); PRECONDITION(ranks.size()>=mol.getNumAtoms(),"vector too small"); PRECONDITION(atomOrders.size()>=mol.getNumAtoms(),"vector too small"); PRECONDITION(bondVisitOrders.size()>=mol.getNumBonds(),"vector too small"); PRECONDITION(atomRingClosures.size()>=mol.getNumAtoms(),"vector too small"); PRECONDITION(atomTraversalBondOrder.size()>=mol.getNumAtoms(),"vector too small"); PRECONDITION(!bondsInPlay || bondsInPlay->size()>=mol.getNumBonds(),"bondsInPlay too small"); PRECONDITION(!bondSymbols || bondSymbols->size()>=mol.getNumBonds(),"bondSymbols too small"); int nAttached=0; Atom *atom = mol.getAtomWithIdx(atomIdx); INT_LIST directTravList,cycleEndList; molStack.push_back(MolStackElem(atom)); atomOrders[atom->getIdx()] = molStack.size(); colors[atomIdx] = GREY_NODE; // --------------------- // // Build the list of possible destinations from here // // --------------------- std::vector< PossibleType > possibles; possibles.resize(0); ROMol::OBOND_ITER_PAIR bondsPair = mol.getAtomBonds(atom); possibles.reserve(bondsPair.second-bondsPair.first); while(bondsPair.first != bondsPair.second){ BOND_SPTR theBond = mol[*(bondsPair.first)]; bondsPair.first++; if(bondsInPlay && !(*bondsInPlay)[theBond->getIdx()]) continue; if(inBondIdx<0 || theBond->getIdx() != static_cast<unsigned int>(inBondIdx)){ int otherIdx = theBond->getOtherAtomIdx(atomIdx); long rank=ranks[otherIdx]; // --------------------- // // things are a bit more complicated if we are sitting on a // ring atom we would like to traverse first to the // ring-closure atoms, then to atoms outside the ring first, // then to atoms in the ring that haven't already been visited // (non-ring-closure atoms). // // Here's how the black magic works: // - non-ring atom neighbors have their original ranks // - ring atom neighbors have this added to their ranks: // (Bond::OTHER - bondOrder)*MAX_NATOMS*MAX_NATOMS // - ring-closure neighbors lose a factor of: // (Bond::OTHER+1)*MAX_NATOMS*MAX_NATOMS // // This tactic biases us to traverse to non-ring neighbors first, // original ordering if bond orders are all equal... crafty, neh? // // --------------------- if( colors[otherIdx] == GREY_NODE ) { rank -= static_cast<int>(Bond::OTHER+1) * MAX_NATOMS*MAX_NATOMS; if(!bondSymbols){ rank += static_cast<int>(Bond::OTHER - theBond->getBondType()) * MAX_NATOMS; } else { const std::string &symb=(*bondSymbols)[theBond->getIdx()]; boost::uint32_t hsh=gboost::hash_range(symb.begin(),symb.end()); rank += (hsh%MAX_NATOMS) * MAX_NATOMS; } } else if( theBond->getOwningMol().getRingInfo()->numBondRings(theBond->getIdx()) ){ if(!bondSymbols){ rank += static_cast<int>(Bond::OTHER - theBond->getBondType()) * MAX_NATOMS*MAX_NATOMS; } else { const std::string &symb=(*bondSymbols)[theBond->getIdx()]; boost::uint32_t hsh=gboost::hash_range(symb.begin(),symb.end()); rank += (hsh%MAX_NATOMS)*MAX_NATOMS*MAX_NATOMS; } } possibles.push_back(PossibleType(rank,otherIdx,theBond.get())); } } // --------------------- // // Sort on ranks // // --------------------- std::sort(possibles.begin(),possibles.end(),_possibleComp); // --------------------- // // Now work the children // // --------------------- std::vector<MolStack> subStacks; for(std::vector<PossibleType>::iterator possiblesIt=possibles.begin(); possiblesIt!=possibles.end(); possiblesIt++){ MolStack subStack; #if 0 int possibleIdx = possiblesIt->second.first; Bond *bond = possiblesIt->second.second; #endif int possibleIdx = possiblesIt->get<1>(); Bond *bond = possiblesIt->get<2>(); Atom *otherAtom=mol.getAtomWithIdx(possibleIdx); unsigned int lowestRingIdx; INT_VECT::const_iterator cAIt; switch(colors[possibleIdx]){ case WHITE_NODE: // ----- // we haven't seen this node at all before // ----- // it might have some residual data from earlier calls, clean that up: if(otherAtom->hasProp("_TraversalBondIndexOrder")){ otherAtom->clearProp("_TraversalBondIndexOrder"); } directTravList.push_back(bond->getIdx()); subStack.push_back(MolStackElem(bond,atomIdx)); canonicalDFSTraversal(mol,possibleIdx,bond->getIdx(),colors, cycles,ranks,cyclesAvailable,subStack, atomOrders,bondVisitOrders,atomRingClosures,atomTraversalBondOrder, bondsInPlay,bondSymbols); subStacks.push_back(subStack); nAttached += 1; break; case GREY_NODE: // ----- // we've seen this, but haven't finished it (we're finishing a ring) // ----- cycleEndList.push_back(bond->getIdx()); cAIt=std::find(cyclesAvailable.begin(), cyclesAvailable.end(),1); if(cAIt==cyclesAvailable.end()){ throw ValueErrorException("Too many rings open at once. SMILES cannot be generated."); } lowestRingIdx = cAIt-cyclesAvailable.begin(); cyclesAvailable[lowestRingIdx] = 0; cycles[possibleIdx].push_back(lowestRingIdx); ++lowestRingIdx; bond->setProp("_TraversalRingClosureBond",lowestRingIdx); molStack.push_back(MolStackElem(bond, atom->getIdx())); molStack.push_back(MolStackElem(lowestRingIdx)); // we need to add this bond (which closes the ring) to the traversal list for the // other atom as well: atomTraversalBondOrder[otherAtom->getIdx()].push_back(bond->getIdx()); atomRingClosures[otherAtom->getIdx()].push_back(bond->getIdx()); break; default: // ----- // this node has been finished. don't do anything. // ----- break; } } INT_VECT &ringClosures=atomRingClosures[atom->getIdx()]; CHECK_INVARIANT(ringClosures.size()==cycles[atomIdx].size(), "ring closure mismatch"); for(unsigned int i=0;i<ringClosures.size();i++){ int ringIdx=cycles[atomIdx][i]; ringIdx += 1; molStack.push_back(MolStackElem(ringIdx)); } cycles[atomIdx].resize(0); MolStack::const_iterator ciMS; for(int i=0;i<nAttached;i++){ if(i<nAttached-1){ int branchIdx=0; if(subStacks[i].begin()->type==MOL_STACK_ATOM){ branchIdx=subStacks[i].begin()->obj.atom->getIdx(); } else if(subStacks[i].begin()->type==MOL_STACK_BOND){ branchIdx=-1*subStacks[i].begin()->obj.bond->getIdx(); } else { ASSERT_INVARIANT(0,"branch started with something other than an atom or bond"); } molStack.push_back(MolStackElem("(",branchIdx)); for(ciMS=subStacks[i].begin();ciMS!=subStacks[i].end();ciMS++){ molStack.push_back(*ciMS); switch(ciMS->type){ case MOL_STACK_ATOM: atomOrders[ciMS->obj.atom->getIdx()] = molStack.size(); break; case MOL_STACK_BOND: bondVisitOrders[ciMS->obj.bond->getIdx()] = molStack.size(); break; default: break; } } molStack.push_back(MolStackElem(")",branchIdx)); } else { for(ciMS=subStacks[i].begin();ciMS!=subStacks[i].end();ciMS++){ molStack.push_back(*ciMS); switch(ciMS->type){ case MOL_STACK_ATOM: atomOrders[ciMS->obj.atom->getIdx()] = molStack.size(); break; case MOL_STACK_BOND: bondVisitOrders[ciMS->obj.bond->getIdx()] = molStack.size(); break; default: break; } } } } //std::cerr<<"*****>>>>>> Traversal results for atom: "<<atom->getIdx()<<"> "; INT_LIST travList; // first push on the incoming bond: if(inBondIdx >= 0){ //std::cerr<<" "<<inBondIdx; travList.push_back(inBondIdx); } // ... ring closures that end here: for(INT_LIST_CI ilci=cycleEndList.begin();ilci!=cycleEndList.end();++ilci){ //std::cerr<<" ["<<*ilci<<"]"; travList.push_back(*ilci); } // ... ring closures that start here: // if(atom->hasProp("_TraversalBondIndexOrder")){ // INT_LIST indirectTravList; // atom->getProp("_TraversalBondIndexOrder",indirectTravList); // for(INT_LIST_CI ilci=indirectTravList.begin();ilci!=indirectTravList.end();++ilci){ // //std::cerr<<" ("<<*ilci<<")"; // travList.push_back(*ilci); // } // } BOOST_FOREACH(int ili,atomTraversalBondOrder[atom->getIdx()]){ travList.push_back(ili); }