bool OBRingSearch::SaveUniqueRing(deque<int> &d1,deque<int> &d2) { vector<int> path; OBBitVec bv; deque<int>::iterator i; for (i = d1.begin();i != d1.end();++i) { bv.SetBitOn(*i); path.push_back(*i); } for (i = d2.begin();i != d2.end();++i) { bv.SetBitOn(*i); path.push_back(*i); } vector<OBRing*>::iterator j; for (j = _rlist.begin();j != _rlist.end();++j) if (bv == (*j)->_pathset) return(false); OBRing *ring = new OBRing(path, bv); _rlist.push_back(ring); return(true); }
/** * This function finds the LSSR containing all relevant cycles. A cycle is * relevant if it belongs to at least one minimum cycle basis. Another * description is more useful though: * * A cycle (C) is relevant if: * - no smaller cycles C_i, ..., C_k exist such that C = C_1 + ... + C_k * - both bonds & atoms are checked * * This is based on lemma 1 from: * * P. Vismara, Union of all the minimum cycle bases of a graph, The electronic * journal of combinatorics, Vol. 4, 1997 * http://www.emis.de/journals/EJC/Volume_4/PostScriptfiles/v4i1r9.ps */ void visitRing(OBMol *mol, OBRing *ring, std::vector<OBRing*> &rlist, std::vector<OBRing*> &rignored) { const std::vector<int> &atoms = ring->_path; OBBitVec mask; // Make sure mask is the same size as the maximum ring atom/bond index. mask.SetBitOn(mol->NumAtoms()); mask.SetBitOn(mol->NumBonds()); // // Remove larger rings that cover the same atoms as smaller rings. // mask.Clear(); for (unsigned int j = 0; j < rlist.size(); ++j) // Here we select only smaller rings. if (rlist[j]->_path.size() < ring->_path.size()) mask |= rlist[j]->_pathset; mask = mask & ring->_pathset; bool containsSmallerAtomRing = (mask == ring->_pathset) ? true : false; // Translate ring atom indexes to ring bond indexes. std::vector<unsigned int> bonds = atomRingToBondRing(mol, ring->_path); OBBitVec bondset; for (unsigned int i = 0; i < bonds.size(); ++i) bondset.SetBitOn(bonds[i]); // // Remove larger rings that cover the same bonds as smaller rings. // mask.Clear(); for (unsigned int j = 0; j < rlist.size(); ++j) { std::vector<unsigned int> otherBonds = atomRingToBondRing(mol, rlist[j]->_path); OBBitVec bs; for (unsigned int i = 0; i < otherBonds.size(); ++i) bs.SetBitOn(otherBonds[i]); // Here we select only smaller rings. if (otherBonds.size() < bonds.size()) mask |= bs; } mask = mask & bondset; bool containsSmallerBondRing = (mask == bondset) ? true : false; // The ring is part of the LSSR if all it's atoms and bonds are not // found in smaller rings. if (!containsSmallerAtomRing || !containsSmallerBondRing) { rlist.push_back(ring); } else { rignored.push_back(ring); } }
void testIsomorphismMask() { // read file: 3 6-rings // // /\ /\ /\ // | | | | // \/ \/ \/ // OBMol mol; OBConversion conv; conv.SetInFormat("cml"); std::ifstream ifs(OBTestUtil::GetFilename("isomorphism1.cml").c_str()); OB_REQUIRE( ifs ); conv.Read(&mol, &ifs); OBQuery *query = CompileSmilesQuery("C1CCCCC1"); OBIsomorphismMapper *mapper = OBIsomorphismMapper::GetInstance(query); // no mask OBIsomorphismMapper::Mappings maps; mapper->MapUnique(&mol, maps); cout << maps.size() << endl; OB_ASSERT( maps.size() == 3 ); // mask first ring OBBitVec mask; for (int i = 0; i < 6; ++i) mask.SetBitOn(i+1); mapper->MapUnique(&mol, maps, mask); cout << maps.size() << endl; OB_ASSERT( maps.size() == 1 ); // mask second ring also for (int i = 6; i < 10; ++i) mask.SetBitOn(i+1); mapper->MapUnique(&mol, maps, mask); cout << maps.size() << endl; OB_ASSERT( maps.size() == 2 ); // just mask last ring (atomIds 7-8, 10-13) mask.Clear(); for (int i = 10; i < 14; ++i) mask.SetBitOn(i+1); mask.SetBitOn(7 + 1); mask.SetBitOn(8 + 1); mapper->MapUnique(&mol, maps, mask); cout << maps.size() << endl; OB_ASSERT( maps.size() == 1 ); // Should be same result as masking just the first ring delete query; delete mapper; }
vector<OBBond*> OBResidue::GetBonds(bool exterior) const { OBAtom *atom; vector<OBBond*> bonds; OBBitVec idxs; unsigned int sz; sz = (unsigned int) _atoms.size(); for ( unsigned int i = 0 ; i < sz ; ++i ) { atom = _atoms[i]; OBBond *bond; vector<OBBond*>::iterator b; for (bond = atom->BeginBond(b) ; bond ; bond = atom->NextBond(b)) { if (!idxs.BitIsOn(bond->GetIdx())) { if (!exterior) { if (bond->GetNbrAtom(atom)->GetResidue() == this) bonds.push_back(&(*bond)); } else bonds.push_back(&(*bond)); idxs.SetBitOn(bond->GetIdx()); } } } return bonds; }
static void FindRings(OBMol &mol,vector<int> &path,OBBitVec &avisit, OBBitVec &bvisit, int natom,int depth ) { OBAtom *atom; OBBond *bond; vector<OBBond*>::iterator k; // don't return if all atoms are visited // (For example, some atoms are in multiple rings!) -GRH if (avisit[natom]) { int j = depth-1; bond=mol.GetBond(path[j--]); bond->SetInRing(); while( j >= 0 ) { bond=mol.GetBond(path[j--]); bond->SetInRing(); (bond->GetBeginAtom())->SetInRing(); (bond->GetEndAtom())->SetInRing(); if(bond->GetBeginAtomIdx()==static_cast<unsigned int>(natom) || bond-> GetEndAtomIdx()==static_cast<unsigned int>(natom)) break; } } else { avisit.SetBitOn(natom); atom = mol.GetAtom(natom); for(bond = atom->BeginBond(k);bond;bond=atom->NextBond(k)) if( !bvisit[bond->GetIdx()]) { path[depth] = bond->GetIdx(); bvisit.SetBitOn(bond->GetIdx()); FindRings(mol,path,avisit,bvisit,bond->GetNbrAtomIdx(atom), depth+1); } } }
void testOBRotorListFixedBonds() { // 1 2 3 4 5 6 7 8 // C-C-C-C-C-C-C-C // 0 1 2 3 4 5 6 OBMolPtr mol = OBTestUtil::ReadFile("octane.cml"); // test with no bonds fixed OBRotorList rlist1; rlist1.Setup(*mol); OB_ASSERT(rlist1.Size() == 5); // test with bond 3 fixed OBBitVec fixedBonds; fixedBonds.SetBitOn(3); rlist1.SetFixedBonds(fixedBonds); rlist1.Setup(*mol); OB_ASSERT(rlist1.Size() == 4); // test with bond 1, 3, 5 fixed fixedBonds.SetBitOn(1); fixedBonds.SetBitOn(5); rlist1.SetFixedBonds(fixedBonds); rlist1.Setup(*mol); OB_ASSERT(rlist1.Size() == 2); // test with bond 1, 2, 3, 5 fixed fixedBonds.SetBitOn(2); rlist1.SetFixedBonds(fixedBonds); rlist1.Setup(*mol); OB_ASSERT(rlist1.Size() == 1); }
bool OBDepict::DrawMolecule(OBMol *mol) { if (!d->painter) return false; d->mol = mol; double width=0.0, height=0.0; OBAtom *atom; OBBondIterator j; OBAtomIterator i; if(mol->NumAtoms()>0) { // scale bond lengths double bondLengthSum = 0.0; for (OBBond *bond = mol->BeginBond(j); bond; bond = mol->NextBond(j)) bondLengthSum += bond->GetLength(); const double averageBondLength = bondLengthSum / mol->NumBonds(); const double f = mol->NumBonds() ? d->bondLength / averageBondLength : 1.0; for (atom = mol->BeginAtom(i); atom; atom = mol->NextAtom(i)) atom->SetVector(atom->GetX() * f, atom->GetY() * f, 0.0); // find min/max values double min_x, max_x; double min_y, max_y; atom = mol->BeginAtom(i); min_x = max_x = atom->GetX(); min_y = max_y = atom->GetY(); for (atom = mol->NextAtom(i); atom; atom = mol->NextAtom(i)) { min_x = std::min(min_x, atom->GetX()); max_x = std::max(max_x, atom->GetX()); min_y = std::min(min_y, atom->GetY()); max_y = std::max(max_y, atom->GetY()); } const double margin = 40.0; // translate all atoms so the bottom-left atom is at margin,margin for (atom = mol->BeginAtom(i); atom; atom = mol->NextAtom(i)) atom->SetVector(atom->GetX() - min_x + margin, atom->GetY() - min_y + margin, 0.0); width = max_x - min_x + 2*margin; height = max_y - min_y + 2*margin; //d->painter->SetPenWidth(d->penWidth); //d->painter->SetPenColor(d->pen)); //d->painter->SetFillColor(OBColor("black")); } d->painter->NewCanvas(width, height); // draw bonds if(d->options & genWedgeHash) d->SetWedgeAndHash(mol); for (OBBond *bond = mol->BeginBond(j); bond; bond = mol->NextBond(j)) { OBAtom *begin = bond->GetBeginAtom(); OBAtom *end = bond->GetEndAtom(); if((d->options & internalColor) && bond->HasData("color")) d->painter->SetPenColor(OBColor(bond->GetData("color")->GetValue())); else d->painter->SetPenColor(d->bondColor); if (bond->IsWedge()) { d->DrawWedge(begin, end); } else if (bond->IsHash()) { d->DrawHash(begin, end); } else if (!bond->IsInRing()) { d->DrawSimpleBond(begin, end, bond->GetBO()); } } // draw ring bonds std::vector<OBRing*> rings(mol->GetSSSR()); OBBitVec drawnBonds; for (std::vector<OBRing*>::iterator k = rings.begin(); k != rings.end(); ++k) { OBRing *ring = *k; std::vector<int> indexes = ring->_path; vector3 center(VZero); for (std::vector<int>::iterator l = indexes.begin(); l != indexes.end(); ++l) { center += mol->GetAtom(*l)->GetVector(); } center /= indexes.size(); for (unsigned int l = 0; l < indexes.size(); ++l) { OBAtom *begin = mol->GetAtom(indexes[l]); OBAtom *end; if (l+1 < indexes.size()) end = mol->GetAtom(indexes[l+1]); else end = mol->GetAtom(indexes[0]); OBBond *ringBond = mol->GetBond(begin, end); if (drawnBonds.BitIsSet(ringBond->GetId())) continue; if((d->options & internalColor) && ringBond->HasData("color")) d->painter->SetPenColor(OBColor(ringBond->GetData("color")->GetValue())); else d->painter->SetPenColor(d->bondColor); d->DrawRingBond(begin, end, center, ringBond->GetBO()); drawnBonds.SetBitOn(ringBond->GetId()); } } // draw atom labels for (atom = mol->BeginAtom(i); atom; atom = mol->NextAtom(i)) { double x = atom->GetX(); double y = atom->GetY(); int alignment = GetLabelAlignment(atom); bool rightAligned = false; switch (alignment) { case TopRight: case CenterRight: case BottomRight: rightAligned = true; default: break; } if((d->options & internalColor) && atom->HasData("color")) d->painter->SetPenColor(OBColor(atom->GetData("color")->GetValue())); else if(d->options & bwAtoms) d->painter->SetPenColor(d->bondColor); else d->painter->SetPenColor(OBColor(etab.GetRGB(atom->GetAtomicNum()))); //charge and radical int charge = atom->GetFormalCharge(); int spin = atom->GetSpinMultiplicity(); if(charge || spin) { OBFontMetrics metrics = d->painter->GetFontMetrics("N"); double yoffset = d->HasLabel(atom) ? 0.4 * metrics.height : 0.0; switch (GetLabelAlignment(atom)) { case TopCenter: case TopRight: case TopLeft: case CenterLeft: case CenterRight: yoffset = - 1.2 * metrics.height; } stringstream ss; if(charge) { if(abs(charge)!=1) ss << abs(charge); ss << (charge>0 ? "+" : "-") ; } if(spin) { ss << (spin==2 ? "." : ".."); yoffset += 0.5 * metrics.height; } if(spin || charge<0) d->painter->SetFontSize(2 * metrics.fontSize); d->painter->DrawText(x-0.4*metrics.width, y-yoffset, ss.str()); d->painter->SetFontSize(metrics.fontSize);//restore } if (atom->IsCarbon()) { if(!(d->options & drawAllC)) { if (atom->GetValence() > 1) continue; if ((atom->GetValence() == 1) && !(d->options & drawTermC))//!d->drawTerminalC) continue; } } stringstream ss; AliasData* ad = NULL; if(d->aliasMode && atom->HasData(AliasDataType)) ad = static_cast<AliasData*>(atom->GetData(AliasDataType)); //For unexpanded aliases use appropriate form of alias instead of element symbol, Hs, etc if(ad && !ad->IsExpanded()) { ss <<ad->GetAlias(rightAligned); OBColor aliasColor = !ad->GetColor().empty() ? ad->GetColor() : d->bondColor; d->painter->SetPenColor(aliasColor); } else { const char* atomSymbol; if(atom->IsHydrogen() && atom->GetIsotope()>1) atomSymbol = atom->GetIsotope()==2 ? "D" : "T"; else atomSymbol = etab.GetSymbol(atom->GetAtomicNum()); unsigned int hCount = atom->ImplicitHydrogenCount(); // rightAligned: // false CH3 // true H3C if (hCount && rightAligned) ss << "H"; if ((hCount > 1) && rightAligned) ss << hCount; ss << atomSymbol; if (hCount && !rightAligned) ss << "H"; if ((hCount > 1) && !rightAligned) ss << hCount; } d->DrawAtomLabel(ss.str(), alignment, vector3(x, y, 0.0)); } return true; }