void FragCatalogEntry::setDescription(const FragCatParams *params) {
PRECONDITION(params, "");
INT_INT_VECT_MAP::const_iterator fMapIt;
for (fMapIt = d_aToFmap.begin(); fMapIt != d_aToFmap.end(); fMapIt++) {
int atIdx = fMapIt->first;
INT_VECT fGroups = fMapIt->second;
std::string label = "", temp;
INT_VECT::const_iterator fGroupIdx = fGroups.begin();
const ROMol *fGroup;
for (unsigned int i = 0; i < fGroups.size() - 1; i++) {
fGroup = params->getFuncGroup(*fGroupIdx);
fGroup->getProp(common_properties::_Name, temp);
label += "(<" + temp + ">)";
fGroupIdx++;
}
fGroup = params->getFuncGroup(*fGroupIdx);
fGroup->getProp(common_properties::_Name, temp);
label += "<" + temp + ">";
dp_mol->getAtomWithIdx(atIdx)
->setProp(common_properties::_supplementalSmilesLabel, label);
}
std::string smi = MolToSmiles(*dp_mol);
// std::cerr << "----" << smi << "----" << std::endl;
d_descrip = smi;
};
//*************************************************************************************
//
// 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;
}
std::vector<std::vector<std::string> > EnumerateLibraryBase::nextSmiles() {
std::vector<std::vector<std::string> > result;
std::vector<MOL_SPTR_VECT> mols = next();
const bool doisomeric = true;
result.resize(mols.size());
for (size_t i = 0; i < mols.size(); ++i) {
result[i].resize(mols[i].size());
for (size_t j = 0; j < mols[i].size(); ++j) {
if (mols[i][j].get()) result[i][j] = MolToSmiles(*mols[i][j], doisomeric);
}
}
return result;
}
ROMol *LargestFragmentChooser::choose(const ROMol &mol) {
BOOST_LOG(rdInfoLog) << "Running LargestFragmentChooser\n";
std::vector<boost::shared_ptr<ROMol>> frags = MolOps::getMolFrags(mol);
LargestFragmentChooser::Largest l;
for (const auto &frag : frags) {
std::string smiles = MolToSmiles(*frag);
BOOST_LOG(rdInfoLog) << "Fragment: " << smiles << "\n";
bool organic = isOrganic(*frag);
if (this->PREFER_ORGANIC) {
// Skip this fragment if not organic and we already have an organic
// fragment as the largest so far
if (l.Fragment != nullptr && l.Organic && !organic) continue;
// Reset largest if it wasn't organic and this fragment is organic
// if largest and organic and not largest['organic']:
if (l.Fragment != nullptr && organic && !l.Organic) {
l.Fragment = nullptr;
}
}
unsigned int numatoms = 0;
for (const auto at : frag->atoms()) {
numatoms += 1 + at->getTotalNumHs();
}
// Skip this fragment if fewer atoms than the largest
if (l.Fragment != nullptr && (numatoms < l.NumAtoms)) continue;
// Skip this fragment if equal number of atoms but weight is lower
double weight = Descriptors::calcExactMW(*frag);
if (l.Fragment != nullptr && (numatoms == l.NumAtoms) &&
(weight < l.Weight))
continue;
// Skip this fragment if equal number of atoms and equal weight but smiles
// comes last alphabetically
if (l.Fragment != nullptr && (numatoms == l.NumAtoms) &&
(weight == l.Weight) && (smiles > l.Smiles))
continue;
BOOST_LOG(rdInfoLog) << "New largest fragment: " << smiles << " (" <<
numatoms << ")\n";
// Otherwise this is the largest so far
l.Smiles = smiles;
l.Fragment = frag;
l.NumAtoms = numatoms;
l.Weight = weight;
l.Organic = organic;
}
return new ROMol(*(l.Fragment));
}
python::list GetRGroupsAsRows(bool asSmiles=false) {
const RGroupRows &groups = decomp->getRGroupsAsRows();
python::list result;
for (RGroupRows::const_iterator it = groups.begin(); it != groups.end();
++it) {
python::dict dict;
const RGroupRow &side_chains = *(it);
for (RGroupRow::const_iterator sit = side_chains.begin();
sit != side_chains.end(); ++sit) {
if (asSmiles) {
dict[sit->first] = MolToSmiles(*sit->second, true);
} else {
dict[sit->first] = sit->second;
}
}
result.append(dict);
}
return result;
}
python::dict GetRGroupsAsColumn(bool asSmiles=false) {
python::dict result;
RGroupColumns groups = decomp->getRGroupsAsColumns();
for (RGroupColumns::const_iterator it = groups.begin(); it != groups.end();
++it) {
python::list col;
for (RGroupColumn::const_iterator cit = it->second.begin();
cit != it->second.end(); ++cit) {
if (asSmiles) {
col.append(MolToSmiles(**cit,true));
} else {
col.append(*cit);
}
}
result[it->first] = col;
}
return result;
}
void TDTWriter::write(const ROMol &mol, int confId) {
CHECK_INVARIANT(dp_ostream,"no output stream");
//start by writing a "|" line unless this is the first line
if (d_molid > 0) {
(*dp_ostream) << "|\n";
}
// write the molecule
(*dp_ostream) << "$SMI<" << MolToSmiles(mol) << ">\n";
if(df_writeNames && mol.hasProp("_Name")){
std::string name;
mol.getProp("_Name",name);
(*dp_ostream) << "NAME<" << name << ">\n";
}
// do we need to write coordinates?
if(mol.getNumConformers()){
// get the ordering of the atoms in the output SMILES:
std::vector<unsigned int> atomOrdering;
mol.getProp("_smilesAtomOutputOrder",atomOrdering);
const Conformer &conf = mol.getConformer(confId);
if(df_write2D){
(*dp_ostream) << "2D<";
} else {
(*dp_ostream) << "3D<";
}
const RDGeom::POINT3D_VECT &coords=conf.getPositions();
int nAts=atomOrdering.size();
for(int i=0;i<nAts;i++){
(*dp_ostream) << std::setprecision(d_numDigits) << coords[atomOrdering[i]].x << ",";
(*dp_ostream) << std::setprecision(d_numDigits) << coords[atomOrdering[i]].y;
if(!df_write2D){
(*dp_ostream) << "," << std::setprecision(d_numDigits) << coords[atomOrdering[i]].z;
}
if(i!=nAts-1) (*dp_ostream) << ",";
}
(*dp_ostream) << ";>\n";
}
// now write the properties
STR_VECT_CI pi;
if (d_props.size() > 0) {
// check if we have any properties the user specified to write out
// in which loop over them and write them out
for (pi = d_props.begin(); pi != d_props.end(); pi++) {
if (mol.hasProp(*pi)) {
writeProperty(mol, (*pi));
}
}
}
else {
// if use did not specify any properties, write all non computed properties
// out to the file
STR_VECT properties = mol.getPropList();
STR_VECT compLst;
if (mol.hasProp(detail::computedPropName)) {
mol.getProp(detail::computedPropName, compLst);
}
STR_VECT_CI pi;
for (pi = properties.begin(); pi != properties.end(); pi++) {
// ignore any of the following properties
if ( ((*pi) == detail::computedPropName) ||
((*pi) == "_Name") ||
((*pi) == "_MolFileInfo") ||
((*pi) == "_MolFileComments") ||
((*pi) == "_MolFileChiralFlag")) {
continue;
}
// check if this property is not computed
if (std::find(compLst.begin(), compLst.end(), (*pi)) == compLst.end()) {
writeProperty(mol, (*pi));
}
}
}
d_molid++;
}
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
}
