BALL::RingPerceptionProcessor Class Reference

#include <BALL/QSAR/ringPerceptionProcessor.h>

Inheritance diagram for BALL::RingPerceptionProcessor:


Classes
struct	Default
	default options for the ring perception More...
struct	Option
	Option names. More...
struct	PathMessage_
struct	TNode_
Public Member Functions
const vector< vector< Atom * > > &	getAllSmallRings () const
Size	findAllBCC (std::vector< MolecularGraph * > &bcc, MolecularGraph &graph)
void	setDefaultOptions ()
Constrcutors and Destructors
	RingPerceptionProcessor ()
	RingPerceptionProcessor (const RingPerceptionProcessor &rp)
virtual	~RingPerceptionProcessor ()
Assignment
RingPerceptionProcessor &	operator= (const RingPerceptionProcessor &rp)
Accessors
Size	calculateSSSR (vector< vector< Atom * > > &sssr, AtomContainer &ac)
Processor-related methods
Processor::Result	operator() (AtomContainer &ac)
Public Attributes
Options	options
HashSet< NodeItem< Index, Index > * >	visited_
HashSet< EdgeItem< Index, Index > * >	visited_bonds_
HashMap< NodeItem< Index, Index > *, Size >	P_
HashMap< NodeItem< Index, Index > , NodeItem< Index, Index > >	parents_
std::stack< EdgeItem< Index, Index > * >	BCC_
static HashMap< TNode_ , NodeItem< Index, Index > >	tnode_to_atom_
	mapping for internal TNode structure and the nodes of the molecular graph
static HashMap< NodeItem < Index, Index > , TNode_ >	atom_to_tnode_
static HashMap< EdgeItem < Index, Index > *, Size >	bond_to_index_
	mapping for the path representation as bitvectors
static HashMap< Size, EdgeItem < Index, Index > * >	index_to_bond_
static std::vector< BitVector >	rings_
	the SSSR detected by the algorithm
static std::vector< BitVector >	matrix_
	the matrix for the independency tests
static std::vector< BitVector >	forwarded_rings_
	the rings of the ith phase, which are to be forwarded to the ring selector
static std::vector< BitVector >	tested_beers_
	rings (beer) which have already been tested
static std::vector < std::vector< Atom * > >	all_small_rings_
	contains all 3 to 6 membered rings after the procedure of the Balducci-Pearlman algorithm
static std::vector< BitVector >	all_small_beers_
	contains all 3 to 6 membered rings as beers
Size	FiguerasAlgorithm_ (vector< vector< Atom * > > &sssr, AtomContainer &ac)
Size	getRing_ (Atom n, HashSet< Atom > &ring_set)
void	checkEdges_ (HashSet< Atom * > &ring_set, AtomContainer &ac)
Size	findAllBCC_ (std::vector< MolecularGraph * > &bcc, MolecularGraph &graph)
void	DFSBCC_ (std::vector< MolecularGraph * > &bccs, Size dfbi, HashMap< NodeItem< Index, Index > , Size > DFBIndex, NodeItem< Index, Index > v)
Size	BalducciPearlmanAlgorithm_ (std::vector< std::vector< Atom * > > &sssr, MolecularGraph &graph)
static void	BalducciPearlmanRingSelector_ (BitVector bit_vector)

Detailed Description

Processor, which marks all atoms and bonds in a ring structure with the Composite Property "InRing". calculateSSSR() can also compute the number of rings found.

The processor is an implementation of Figueras algorithm, described in: J. Figueras, J. Chem. Inf. Comput. Sci., 1996, 36(5), 986-991

and the Balducci Pearlman algorithm described in: Renzo Balducci, Robert S. Pearlman, J. Chem. Inf. Comput. Sci., 34:822-831, 1994

Constructor & Destructor Documentation

BALL::RingPerceptionProcessor::RingPerceptionProcessor ( )

Default constructor

BALL::RingPerceptionProcessor::RingPerceptionProcessor ( const RingPerceptionProcessor & rp )

Copy constructor

virtual BALL::RingPerceptionProcessor::~RingPerceptionProcessor ( ) [virtual]

Destructor

Member Function Documentation

Size BALL::RingPerceptionProcessor::BalducciPearlmanAlgorithm_	(	std::vector< std::vector< Atom * > > &	sssr,
		MolecularGraph &	graph
	)			`[protected]`

static void BALL::RingPerceptionProcessor::BalducciPearlmanRingSelector_ ( BitVector bit_vector ) [static, protected]

Size BALL::RingPerceptionProcessor::calculateSSSR	(	vector< vector< Atom * > > &	sssr,
		AtomContainer &	ac
	)

Method to get a smallest set of smallest rings (SSSR) from a molecule.

Parameters:

	SSSR,vector	of rings, where the rings are stored in vector<Atom*>
	AtomContiner,from	which AtomContainer the rings are to be percepted

void BALL::RingPerceptionProcessor::checkEdges_	(	HashSet< Atom * > &	ring_set,
		AtomContainer &	ac
	)			`[protected]`

void BALL::RingPerceptionProcessor::DFSBCC_	(	std::vector< MolecularGraph * > &	bccs,
		Size	dfbi,
		HashMap< NodeItem< Index, Index > *, Size >	DFBIndex,
		NodeItem< Index, Index > *	v
	)			`[protected]`

Size BALL::RingPerceptionProcessor::FiguerasAlgorithm_	(	vector< vector< Atom * > > &	sssr,
		AtomContainer &	ac
	)			`[protected]`

Size BALL::RingPerceptionProcessor::findAllBCC	(	std::vector< MolecularGraph * > &	bcc,
		MolecularGraph &	graph
	)

Method that finds all biconnected components, the algorithm is freely adapted from a standard bcc (binary connected components) algorithm. Returns the number of bccs found.

Size BALL::RingPerceptionProcessor::findAllBCC_	(	std::vector< MolecularGraph * > &	bcc,
		MolecularGraph &	graph
	)			`[protected]`

const vector<vector<Atom*> >& BALL::RingPerceptionProcessor::getAllSmallRings ( ) const

Getter which returns all the 3 - 6 membered rings, calculateSSSR with the Balducci-Pearlman Algorithm (defalt) is needed prior this call.

Size BALL::RingPerceptionProcessor::getRing_	(	Atom *	n,
		HashSet< Atom * > &	ring_set
	)			`[protected]`

Processor::Result BALL::RingPerceptionProcessor::operator() ( AtomContainer & ) [virtual]

operator ()

Reimplemented from BALL::UnaryProcessor< AtomContainer >.

RingPerceptionProcessor& BALL::RingPerceptionProcessor::operator= ( const RingPerceptionProcessor & rp )

Assignment operator

void BALL::RingPerceptionProcessor::setDefaultOptions ( )

sets the default options of this processor

Member Data Documentation

std::vector<BitVector> BALL::RingPerceptionProcessor::all_small_beers_ [static, protected]

contains all 3 to 6 membered rings as beers

std::vector<std::vector<Atom*> > BALL::RingPerceptionProcessor::all_small_rings_ [static, protected]

contains all 3 to 6 membered rings after the procedure of the Balducci-Pearlman algorithm

HashMap<NodeItem<Index, Index>* , TNode_*> BALL::RingPerceptionProcessor::atom_to_tnode_ [static, protected]

std::stack<EdgeItem<Index, Index>* > BALL::RingPerceptionProcessor::BCC_ [protected]

HashMap<EdgeItem<Index, Index>*, Size> BALL::RingPerceptionProcessor::bond_to_index_ [static, protected]

mapping for the path representation as bitvectors

std::vector<BitVector> BALL::RingPerceptionProcessor::forwarded_rings_ [static, protected]

the rings of the ith phase, which are to be forwarded to the ring selector

HashMap<Size, EdgeItem<Index, Index>*> BALL::RingPerceptionProcessor::index_to_bond_ [static, protected]

std::vector<BitVector> BALL::RingPerceptionProcessor::matrix_ [static, protected]

the matrix for the independency tests

Options BALL::RingPerceptionProcessor::options

HashMap<NodeItem<Index, Index>* , Size> BALL::RingPerceptionProcessor::P_ [protected]

HashMap<NodeItem<Index, Index>*, NodeItem<Index, Index>* > BALL::RingPerceptionProcessor::parents_ [protected]

std::vector<BitVector> BALL::RingPerceptionProcessor::rings_ [static, protected]

the SSSR detected by the algorithm

std::vector<BitVector> BALL::RingPerceptionProcessor::tested_beers_ [static, protected]

rings (beer) which have already been tested

HashMap<TNode_*, NodeItem<Index, Index>* > BALL::RingPerceptionProcessor::tnode_to_atom_ [static, protected]

mapping for internal TNode structure and the nodes of the molecular graph

HashSet<NodeItem<Index, Index>* > BALL::RingPerceptionProcessor::visited_ [protected]

HashSet<EdgeItem<Index, Index>* > BALL::RingPerceptionProcessor::visited_bonds_ [protected]

BALL::RingPerceptionProcessor Class Reference

Classes

Public Member Functions

Public Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation