ring.h

Go to the documentation of this file.

/**********************************************************************
ring.h - Deal with rings, find smallest set of smallest rings (SSSR).

Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison

This file is part of the Open Babel project.
For more information, see <http://openbabel.org/>

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_RING_H
#define OB_RING_H

#include <deque>
#include <algorithm>

// TODO: Make this work as a free-standing header
// Currently only used in ring.cpp which imports mol.h beforehand
#include <openbabel/bitvec.h>
#include <openbabel/typer.h>

namespace OpenBabel
{

 class OBMol;
 class OBAtom;
 class OBBond;
 class vector3;

 // class introduction in ring.cpp
 class OBAPI OBRing
 {
 OBMol *_parent; 
 public:
 //public data members
 int ring_id; 
 std::vector<int> _path; 
 OBBitVec _pathset; 


 OBRing() {}
 OBRing(std::vector<int>& path, int size);
 OBRing(std::vector<int>& path, OBBitVec set) : _path(path), _pathset(set) {}
 OBRing(const OBRing &src);
 OBRing& operator=(const OBRing &src);

 //member functions

 size_t Size() const { return(_path.size()); }
 size_t PathSize() const { return(_path.size()); }

 bool IsAromatic();

 void SetType(char *type);
 void SetType(std::string &type);
 char *GetType();
 unsigned int GetRootAtom();

 bool IsMember(OBAtom *a);
 bool IsMember(OBBond *b);
 bool IsInRing(int i)
 {
 return(_pathset.BitIsSet(i));
 }

 void SetParent(OBMol *m) { _parent = m; }
 OBMol *GetParent() { return(_parent);}

 bool findCenterAndNormal(vector3 & center, vector3 &norm1, vector3 &norm2);
 private:
 char _type[30]; 
 };

 OBAPI bool CompareRingSize(const OBRing *,const OBRing *);


 class OBAPI OBRingSearch
 {
 std::vector<OBBond*> _bonds; 
 std::vector<OBRing*> _rlist; 
 public:
 OBRingSearch() {}
 ~OBRingSearch();

 void SortRings()
 {
 std::vector<OBRing*>::iterator j;
 int ring_id; // for each ring, assign a unique id to ensure a stable sort
 
 for (j = _rlist.begin(), ring_id = 0; j != _rlist.end(); ++j, ++ring_id)
 (*j)->ring_id = ring_id;
 std::sort(_rlist.begin(),_rlist.end(),CompareRingSize);
 }
 void RemoveRedundant(int);
 void AddRingFromClosure(OBMol &,OBBond *);

 bool SaveUniqueRing(std::deque<int>&,std::deque<int>&);

 void WriteRings();


 std::vector<OBRing*>::iterator BeginRings()
 {
 return(_rlist.begin());
 }
 std::vector<OBRing*>::iterator EndRings()
 {
 return(_rlist.end());
 }
 };

 class OBAPI OBRTree
 {
 OBAtom *_atom; 
 OBRTree *_prv; 
 public:
 OBRTree(OBAtom*,OBRTree*);
 ~OBRTree() {}

 int GetAtomIdx();
 void PathToRoot(std::vector<OBAtom*>&);
 };

} // end namespace OpenBabel

#endif // OB_RING_H