int main(int argc,char **argv) { // Create a test molecule OpenBabel::OBMol mol; OpenBabel::OBAtom* a[5]; a[0] = mol.NewAtom(); a[0]->SetAtomicNum(6); a[0]->SetVector(-0.013, 1.086, 0.008); a[1] = mol.NewAtom(); a[1]->SetAtomicNum(1); a[1]->SetVector( 0.002, -0.004, 0.002); a[2] = mol.NewAtom(); a[2]->SetAtomicNum(9); a[2]->SetVector( 1.300, 1.570, -0.002); a[3] = mol.NewAtom(); a[3]->SetAtomicNum(35); a[3]->SetVector(-0.964, 1.737, -1.585); a[4] = mol.NewAtom(); a[4]->SetAtomicNum(17); a[4]->SetVector(-0.857, 1.667, 1.491); OpenBabel::OBBond* b; for (int i(1); i < 5; ++i) { b = mol.NewBond(); b->SetBegin(a[0]); b->SetEnd(a[i]); b->SetBondOrder(1); } // Run the tests test01(&mol); test02(&mol); test03(&mol); test04(&mol); test05(&mol); test06(&mol); test07(&mol); test08(&mol); test09(&mol); // End return 0; }
Coordinate _hDonCalcNormal(OpenBabel::OBAtom* a) { int nbrBonds(0); Coordinate normal; std::vector<OpenBabel::OBBond*>::iterator bi; for (OpenBabel::OBBond* b = a->BeginBond(bi); b; b = a->NextBond(bi)) { OpenBabel::OBAtom* aa = b->GetNbrAtom(a); if (aa->GetAtomicNum() == 1) { continue; } ++nbrBonds; normal.x += (aa->x() - a->x()); normal.y += (aa->y() - a->y()); normal.z += (aa->z() - a->z()); } double length(sqrt(normal.x*normal.x + normal.y*normal.y + normal.z*normal.z)); normal.x /= length; normal.y /= length; normal.z /= length; normal.x = -normal.x; normal.y = -normal.y; normal.z = -normal.z; normal.x += a->x(); normal.y += a->y(); normal.z += a->z(); return normal; }
int spectrophoretest(int argc, char* argv[]) { int defaultchoice = 1; int choice = defaultchoice; if (argc > 1) { if(sscanf(argv[1], "%d", &choice) != 1) { printf("Couldn't parse that input as a number\n"); return -1; } } // Create a test molecule OpenBabel::OBMol mol; OpenBabel::OBAtom* a[5]; a[0] = mol.NewAtom(); a[0]->SetAtomicNum(6); a[0]->SetVector(-0.013, 1.086, 0.008); a[1] = mol.NewAtom(); a[1]->SetAtomicNum(1); a[1]->SetVector( 0.002, -0.004, 0.002); a[2] = mol.NewAtom(); a[2]->SetAtomicNum(9); a[2]->SetVector( 1.300, 1.570, -0.002); a[3] = mol.NewAtom(); a[3]->SetAtomicNum(35); a[3]->SetVector(-0.964, 1.737, -1.585); a[4] = mol.NewAtom(); a[4]->SetAtomicNum(17); a[4]->SetVector(-0.857, 1.667, 1.491); OpenBabel::OBBond* b; for (int i(1); i < 5; ++i) { b = mol.NewBond(); b->SetBegin(a[0]); b->SetEnd(a[i]); b->SetBondOrder(1); } switch(choice) { case 1: test01(&mol); test02(&mol); break; case 2: test03(&mol); test04(&mol); break; case 3: test05(&mol); test06(&mol); break; case 4: test07(&mol); test08(&mol); break; case 5: test09(&mol); break; default: std::cout << "Test number " << choice << " does not exist!\n"; return -1; } return 0; }
void StereoCenterItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) { Molecule *mol = molecule(); painter->save(); painter->setPen(Qt::green); if (!mol) { // not connected: default behaviour (draw connectable box) MolInputItem::paint(painter, option, widget); painter->restore(); return; } const QList<Atom*> &atoms = mol->atoms(); OpenBabel::OBMol *obmol = mol->OBMol(); QPointF offset(-5.0, 5.0); #ifdef OPENBABEL2_TRUNK // need to calculate symmetry first std::vector<unsigned int> symmetry_classes; OpenBabel::OBGraphSym graphsym(obmol); graphsym.GetSymmetry(symmetry_classes); //std::vector<unsigned long> atomIds = FindTetrahedralAtoms(obmol, symmetry_classes); std::vector<OpenBabel::StereogenicUnit> units = FindStereogenicUnits(obmol, symmetry_classes); for (unsigned int i = 0; i < units.size(); ++i) { if (units.at(i).type == OpenBabel::OBStereo::Tetrahedral) { OpenBabel::OBAtom *obatom = obmol->GetAtomById(units.at(i).id); painter->drawEllipse(mapFromItem(mol, atoms[obatom->GetIndex()]->pos()), 10, 10); } else if (units.at(i).type == OpenBabel::OBStereo::CisTrans) { OpenBabel::OBBond *obbond = obmol->GetBondById(units.at(i).id); OpenBabel::OBAtom *obatom1 = obbond->GetBeginAtom(); OpenBabel::OBAtom *obatom2 = obbond->GetEndAtom(); painter->drawEllipse(mapFromItem(mol, atoms[obatom1->GetIndex()]->pos()), 10, 10); painter->drawEllipse(mapFromItem(mol, atoms[obatom2->GetIndex()]->pos()), 10, 10); } } #else using OpenBabel::OBMolAtomIter; FOR_ATOMS_OF_MOL(atom, obmol) if (atom->IsChiral()) painter->drawEllipse(mapFromItem(mol, atoms[atom->GetIdx()-1]->pos()), 10, 10); #endif // default behavious (draw the label()) MolInputItem::paint(painter, option, widget); painter->restore(); }
void Fingerprint::_getFragments(std::vector<int> levels, std::vector<int>curfrag, int level, OpenBabel::OBAtom* patom, OpenBabel::OBBond* pbond) { const int MaxFragSize = 7; int bo(0); if (pbond) bo = pbond->IsAromatic() ? 5 : pbond->GetBondOrder(); curfrag.push_back(bo); curfrag.push_back(patom->GetAtomicNum()); levels[patom->GetIdx()] = level; std::vector<OpenBabel::OBBond*>::iterator i; OpenBabel::OBBond* pnewbond; for (pnewbond = patom->BeginBond(i); pnewbond; pnewbond = patom->NextBond(i)) { if (pnewbond == pbond) { continue; } OpenBabel::OBAtom* pnxtat = pnewbond->GetNbrAtom(patom); int atlevel = levels[pnxtat->GetIdx()]; if (atlevel) { if (atlevel == 1) { curfrag[0] = bo; _ringset.insert(curfrag); } } else { if (level < MaxFragSize) { _getFragments(levels, curfrag, level + 1, pnxtat, pnewbond); } } } if ((curfrag[0] == 0) && ((level > 1) || (patom->GetAtomicNum() > 8) || (patom->GetAtomicNum() < 6))) { _fragset.insert(curfrag); } }
//-- // [rad] generate path and ident for bond void RelationBond::GetPathAndIdentBond(const std::string& refMoleculeId, std::string& refPath, std::string& refIdent) { refPath = m_vecSatisfiedClasses.front()->GetPrefix() + ":" + m_vecSatisfiedClasses.front()->GetName(); std::stringstream ssConv; OpenBabel::OBBond* pBond = m_pBond; OpenBabel::OBAtom* pAtomStart = pBond->GetBeginAtom(); OpenBabel::OBAtom* pAtomEnd = pBond->GetEndAtom(); ssConv << m_vecSatisfiedClasses.front()->GetName() << "_" << refMoleculeId << "_" << pAtomStart->GetIdx() << "_" << pAtomEnd->GetIdx(); refIdent = ""; ssConv >> refIdent; }
unsigned int Schuffenhauer::CalculateAcyclicBonds(OpenBabel::OBMol& mol) { unsigned int nbonds(0); OpenBabel::OBAtom* nbratom[2]; OpenBabel::OBBond* bond; std::vector<OpenBabel::OBBond*>::iterator bvi; for (bond = mol.BeginBond(bvi); bond; bond = mol.NextBond(bvi)) { nbratom[0] = bond->GetBeginAtom(); nbratom[1] = bond->GetEndAtom(); if (nbratom[0] && nbratom[1]) { if (!bond->IsInRing() && (nbratom[0]->GetValence() > 1) && (nbratom[1]->GetValence() > 1)) { ++nbonds; } } } return nbonds; }
bool Schuffenhauer::HasLinkerToHeteroAtom(OpenBabel::OBMol& mol, OpenBabel::OBRing* ring) { std::vector<OpenBabel::OBBond*>::iterator bvi; OpenBabel::OBBond* bond; OpenBabel::OBAtom* nbrAtom[2]; for (bond = mol.BeginBond(bvi); bond; bond = mol.NextBond(bvi)) { nbrAtom[0] = bond->GetBeginAtom(); nbrAtom[1] = bond->GetEndAtom(); if ( // Neighbours are real nbrAtom[0] && nbrAtom[1] && // Bond should be acyclic !bond->IsInRing() && // Both atoms have to be ring atoms nbrAtom[0]->IsInRing() && nbrAtom[1]->IsInRing() && // At least one of the atoms should be hetero (nbrAtom[0]->IsHeteroatom() || nbrAtom[1]->IsHeteroatom()) && // One of the atoms, but not both, should be part of this ring ((ring->IsMember(nbrAtom[0]) && !ring->IsMember(nbrAtom[1])) || (ring->IsMember(nbrAtom[1]) && !ring->IsMember(nbrAtom[0]))) ) { return true; } } return false; }
bool Oprea_1::CalculateScaffold(const OpenBabel::OBMol& mol, Options* o) { OpenBabel::OBMol m(mol); OpenBabel::OBAtom* atom; OpenBabel::OBAtom* nbrAtom[2]; OpenBabel::OBBondIterator bi; std::vector<OpenBabel::OBAtom*>::iterator avi; OpenBabel::OBBond* bond; std::vector<OpenBabel::OBBond*>::iterator bvi; bool removed(true); while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if (IsEndStanding(atom, false, false)) { m.DeleteAtom(atom); removed = true; break; } } } // Make all atoms as neutral C and all bond orders equal to 1 m.BeginModify(); for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { atom->SetAtomicNum(6); atom->SetFormalCharge(0); } for (bond = m.BeginBond(bvi); bond; bond = m.NextBond(bvi)) { bond->SetBondOrder(1); } m.EndModify(); // Transform all neighbouring linker atoms into a single bond removed = true; while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if (!atom->IsInRing() && (atom->GetValence() == 2)) { nbrAtom[0] = atom->BeginNbrAtom(bi); nbrAtom[1] = atom->NextNbrAtom(bi); if (nbrAtom[0] && nbrAtom[1]) { m.BeginModify(); m.AddBond(nbrAtom[0]->GetIdx(), nbrAtom[1]->GetIdx(), 1); m.DeleteAtom(atom); m.EndModify(); removed = true; break; } } } } // Shrink all rings to their minimum size removed = true; while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if ((atom->MemberOfRingSize() > 3) && (atom->GetValence() == 2)) { nbrAtom[0] = atom->BeginNbrAtom(bi); nbrAtom[1] = atom->NextNbrAtom(bi); if (nbrAtom[0] && nbrAtom[1]) { m.BeginModify(); m.AddBond(nbrAtom[0]->GetIdx(), nbrAtom[1]->GetIdx(), 1); m.DeleteAtom(atom); m.EndModify(); removed = true; break; } } } } if (!m.Empty()) { _smiles = _mol2can.WriteString(&m, true); } else { _smiles = "-"; return false; } return true; }
bool Oprea_2::CalculateScaffold(const OpenBabel::OBMol& mol, Options* o) { OpenBabel::OBMol m(mol); // Tag all HBD std::vector<bool> hbd(m.NumAtoms() + 1); for (OpenBabel::OBMolAtomIter atom(m); atom; ++atom) { if (atom->MatchesSMARTS("[NH,NH2,NH3,OH,nH]")) { hbd[atom->GetIdx()] = true; } else { hbd[atom->GetIdx()] = false; } } // Tag all HBA std::vector<bool> hba(m.NumAtoms() + 1); for (OpenBabel::OBMolAtomIter atom(m); atom; ++atom) { if (!atom->IsAmideNitrogen() && // No amide nitrogen !atom->IsAromatic() && // Not aromatic (atom->GetFormalCharge() <= 0) && // No + charge atom->MatchesSMARTS("[NH0]")) // No hydrogens { hba[atom->GetIdx()] = true; } else if (atom->IsNitrogen() && // Nitrogen atom->IsAromatic() && // Aromatic atom->MatchesSMARTS("[nH0]") && // No hydrogens (atom->GetHvyValence() <= 2) && // Maximal two non-H atoms connected (atom->GetFormalCharge() <= 0)) // No + charge { hba[atom->GetIdx()] = true; } else if (atom->IsOxygen() && // Oxygen (atom->GetFormalCharge() <= 0)) // No + charge { hba[atom->GetIdx()] = true; } else { hba[atom->GetIdx()] = false; } } // Mark the C(=O) or S(=O) also as HBA for (OpenBabel::OBMolAtomIter atom(m); atom; ++atom) { if (atom->MatchesSMARTS("C=O")) { hba[atom->GetIdx()] = true; } else if (atom->MatchesSMARTS("S=O")) { hba[atom->GetIdx()] = true; } } // Make all atoms as neutral C, N (HBD), or O (HBA) m.BeginModify(); std::vector<OpenBabel::OBAtom*>::iterator avi; OpenBabel::OBAtom* atom; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if (hba[atom->GetIdx()]) { atom->SetAtomicNum(8); } else if (hbd[atom->GetIdx()]) { atom->SetAtomicNum(7); } else { atom->SetAtomicNum(6); } atom->SetFormalCharge(0); } m.EndModify(); // Remove all endstanding atoms OpenBabel::OBBondIterator bi; OpenBabel::OBBond* bond; std::vector<OpenBabel::OBBond*>::iterator bvi; bool removed(true); while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if (IsEndStanding(atom, false, false)) { m.DeleteAtom(atom); removed = true; break; } } } // Set all bond orders equal to 1 m.BeginModify(); for (bond = m.BeginBond(bvi); bond; bond = m.NextBond(bvi)) { bond->SetBondOrder(1); } m.EndModify(); // Transform all neighbouring linker atoms into a single bond removed = true; OpenBabel::OBAtom* nbrAtom[2]; while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if (!atom->IsInRing() && (atom->GetValence() == 2)) { m.BeginModify(); nbrAtom[0] = atom->BeginNbrAtom(bi); nbrAtom[1] = atom->NextNbrAtom(bi); if (nbrAtom[0] && nbrAtom[1]) { m.AddBond(nbrAtom[0]->GetIdx(), nbrAtom[1]->GetIdx(), 1); m.DeleteAtom(atom); m.EndModify(); removed = true; break; } } } } // Shrink all rings to their minimum size removed = true; while (removed) { removed = false; for (atom = m.BeginAtom(avi); atom; atom = m.NextAtom(avi)) { if ((atom->MemberOfRingSize() > 3) && (atom->GetValence() == 2)) { nbrAtom[0] = atom->BeginNbrAtom(bi); nbrAtom[1] = atom->NextNbrAtom(bi); if (nbrAtom[0] && nbrAtom[1]) { if (nbrAtom[0]->GetAtomicNum() == atom->GetAtomicNum()) { m.BeginModify(); m.AddBond(nbrAtom[0]->GetIdx(), nbrAtom[1]->GetIdx(), 1); m.DeleteAtom(atom); m.EndModify(); removed = true; break; } else if (nbrAtom[1]->GetAtomicNum() == atom->GetAtomicNum()) { m.BeginModify(); m.AddBond(nbrAtom[0]->GetIdx(), nbrAtom[1]->GetIdx(), 1); m.DeleteAtom(atom); m.EndModify(); removed = true; break; } } } } } if (!m.Empty()) { _smiles = _mol2can.WriteString(&m, true); } else { _smiles = "-"; return false; } return true; }
OpenBabel::OBMol Schuffenhauer::RemoveRing(OpenBabel::OBMol& oldMol, std::vector<OpenBabel::OBRing*>& rings, unsigned int ringIdx) { OpenBabel::OBMol newMol(oldMol); // Make list of the ring bonds std::set<OpenBabel::OBBond*> ringBonds; OpenBabel::OBBond* bond; std::vector<OpenBabel::OBBond*>::iterator bvi; for (bond = newMol.BeginBond(bvi); bond; bond = newMol.NextBond(bvi)) { if (rings[ringIdx]->IsMember(bond)) { ringBonds.insert(bond); } } // Make list of delocalizable bonds (aromatic, single and flanked by two double bonds) std::set<OpenBabel::OBBond*> delocalizableBonds; std::set<OpenBabel::OBBond*>::iterator bli; OpenBabel::OBBondIterator bi; OpenBabel::OBAtom* atom; OpenBabel::OBBond* nbrBond; unsigned int n; for (bli = ringBonds.begin(); bli != ringBonds.end(); ++bli) { bond = *bli; if ((bond->GetBondOrder() == 1) && bond->IsAromatic()) { n = 0; atom = bond->GetBeginAtom(); for (nbrBond = atom->BeginBond(bi); nbrBond; nbrBond = atom->NextBond(bi)) { if ((nbrBond != bond) && ringBonds.count(nbrBond) && (nbrBond->GetBondOrder() == 2)) { ++n; } } atom = bond->GetEndAtom(); for (nbrBond = atom->BeginBond(bi); nbrBond; nbrBond = atom->NextBond(bi)) { if ((nbrBond != bond) && ringBonds.count(nbrBond) && (nbrBond->GetBondOrder() == 2)) { ++n; } } } if (n == 2) { delocalizableBonds.insert(bond); } } // Make list of bonds which form the fusion with other rings std::set<OpenBabel::OBBond*> fusionBonds; for (bli = ringBonds.begin(); bli != ringBonds.end(); ++bli) { bond = *bli; for (unsigned int i(0); i < rings.size(); ++i) { if (i != ringIdx) { if (rings[i]->IsMember(bond)) { fusionBonds.insert(bond); } } } } // Make list of bonds which are the fusion between aromatic and non-aromatic std::set<OpenBabel::OBBond*> aromaticNonaromaticFusionBonds; if (rings[ringIdx]->IsAromatic()) { for (bli = fusionBonds.begin(); bli != fusionBonds.end(); ++bli) { bond = *bli; for (unsigned int i(0); i < rings.size(); ++i) { if (i != ringIdx) { if (rings[i]->IsMember(bond) && !rings[i]->IsAromatic()) { aromaticNonaromaticFusionBonds.insert(bond); } } } } } // Make list of bonds which are the fusion between aromatic and aromatic std::set<OpenBabel::OBBond*> aromaticAromaticFusionBonds; if (rings[ringIdx]->IsAromatic()) { for (bli = fusionBonds.begin(); bli != fusionBonds.end(); ++bli) { bond = *bli; for (unsigned int i(0); i < rings.size(); ++i) { if (i != ringIdx) { if (rings[i]->IsMember(bond) && rings[i]->IsAromatic()) { aromaticAromaticFusionBonds.insert(bond); } } } } } // Remove ring std::set<OpenBabel::OBBond*> bondsToBeDeleted; std::set<OpenBabel::OBAtom*> atomsToBeDeleted; OpenBabel::OBAtom* nbrAtom[2]; for (bli = ringBonds.begin(); bli != ringBonds.end(); ++bli) { bond = *bli; if (fusionBonds.count(bond)) { continue; } else { bondsToBeDeleted.insert(bond); nbrAtom[0] = bond->GetBeginAtom(); nbrAtom[1] = bond->GetEndAtom(); if (nbrAtom[0] && nbrAtom[1]) { if (nbrAtom[0]->MemberOfRingCount() == 1) { atomsToBeDeleted.insert(nbrAtom[0]); } if (nbrAtom[1]->MemberOfRingCount() == 1) { atomsToBeDeleted.insert(nbrAtom[1]); } } } } newMol.BeginModify(); for (bli = bondsToBeDeleted.begin(); bli != bondsToBeDeleted.end(); ++bli) { newMol.DeleteBond(*bli); } newMol.EndModify(); newMol.BeginModify(); std::set<OpenBabel::OBAtom*>::iterator ali; for (ali = atomsToBeDeleted.begin(); ali != atomsToBeDeleted.end(); ++ali) { newMol.DeleteAtom(*ali); } newMol.EndModify(); // Correct the bond orders of the ex-fusion bond(s) newMol.BeginModify(); for (bond = newMol.BeginBond(bvi); bond; bond = newMol.NextBond(bvi)) { if (aromaticNonaromaticFusionBonds.count(bond)) { bond->SetBondOrder(2); } else if (aromaticAromaticFusionBonds.count(bond) && delocalizableBonds.count(bond)) { bond->SetBondOrder(2); } } newMol.EndModify(); // Remove single atoms that originate from exocyclic bonds at ring (void) RemoveSidechains(&newMol); // Check if there are atoms with valences that are not allowed std::vector<OpenBabel::OBAtom*>::iterator avi; for (atom = newMol.BeginAtom(avi); atom; atom = newMol.NextAtom(avi)) { if (atom->IsCarbon() && (atom->BOSum() > 4)) { newMol.Clear(); break; } else if (atom->IsNitrogen() && (atom->BOSum() > 3)) { newMol.Clear(); break; } else if (atom->IsOxygen() && (atom->BOSum() > 2)) { newMol.Clear(); break; } } // Check if there are no discontinuous fragments if (newMol.Separate().size() > 1) { newMol.Clear(); } return newMol; }
OpenBabel::OBMol Schuffenhauer::Rule_7(OpenBabel::OBMol& oldMol) { std::vector<OpenBabel::OBRing*> allrings(oldMol.GetSSSR()); if (allrings.size() <= _ringsToBeRetained) { return oldMol; } // Are all atoms and bonds aromatic? std::vector<OpenBabel::OBAtom*>::iterator avi; OpenBabel::OBAtom* atom; for (atom = oldMol.BeginAtom(avi); atom; atom = oldMol.NextAtom(avi)) { if (!atom->IsAromatic()) { return oldMol; } } std::vector<OpenBabel::OBBond*>::iterator bvi; OpenBabel::OBBond* bond; for (bond = oldMol.BeginBond(bvi); bond; bond = oldMol.NextBond(bvi)) { if (!bond->IsAromatic()) { return oldMol; } } std::vector<OpenBabel::OBMol> mols; for (unsigned int i(0); i < allrings.size(); ++i) { mols.push_back(oldMol); } std::vector<OpenBabel::OBMol> validMols; for (unsigned int i(0); i < mols.size(); ++i) { mols[i] = RemoveRing(mols[i], allrings, i); if (!mols[i].Empty()) { // Has aromaticity been broken? bool broken(false); for (atom = mols[i].BeginAtom(avi); atom; atom = mols[i].NextAtom(avi)) { if (atom->IsInRing() && !atom->IsAromatic()) { broken = true; break; } } if (!broken) { validMols.push_back(mols[i]); } } } if (validMols.size() == 1) { return validMols[0]; } return oldMol; }
void FilterRingsystems::Calculate(OpenBabel::OBMol* mol) { // Are there rings? bool rings(false); OpenBabel::OBAtom* atom; std::vector<OpenBabel::OBAtom*>::iterator i; for (atom = mol->BeginAtom(i); atom; atom = mol->NextAtom(i)) { if (atom->IsInRing()) { rings = true; break; } } if (rings) { // Make workcopy of original mol OpenBabel::OBMol m = *mol; m.DeleteHydrogens(); // Remove all atoms that are not part of ring std::vector<OpenBabel::OBAtom*> nonRingAtoms; nonRingAtoms.clear(); for (atom = m.BeginAtom(i); atom; atom = m.NextAtom(i)) { if (!atom->IsInRing()) nonRingAtoms.push_back(atom); } for (unsigned int i(0); i < nonRingAtoms.size(); ++i) { m.DeleteAtom(nonRingAtoms[i]); } // Remove all bonds that are not part of a ring std::vector<OpenBabel::OBBond*> nonRingBonds; nonRingBonds.clear(); OpenBabel::OBBond* bond; std::vector<OpenBabel::OBBond*>::iterator j; for (bond = m.BeginBond(j); bond; bond = m.NextBond(j)) { if (!bond->IsInRing()) nonRingBonds.push_back(bond); } for (unsigned int i(0); i < nonRingBonds.size(); ++i) { m.DeleteBond(nonRingBonds[i]); } // Count ringsystems std::vector<std::vector< int > > ringsystems; m.ContigFragList(ringsystems); _result = ringsystems.size(); } else { _result = 0; } if ((_minLimit && (_result < _min)) || (_maxLimit && (_result > _max))) { _passed = false; } else { _passed = true; } }