src/openbabel/fingerprint.hpp

/**********************************************************************
fingerprint.h - Base class for fingerprints and fast searching 
 
Copyright (C) 2005 by Chris Morley
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
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_FINGERPRINT_H
#define OB_FINGERPRINT_H

#include <list>
#include <map>
#include <set>
#include <vector>
#include <string>

namespace OpenBabel
{
        class OBBase; //Forward declaration; used only as pointer.

/// \brief The base class for fingerprints
class OBAPI OBFingerprint
{
//see end of cpp file for detailed documentation
public:
        /// Sets the nth bit
        void SetBit(std::vector<unsigned int>& vec, unsigned int n);    

        /// Repeatedly ORs the top half with the bottom half until no smaller than nbits 
        void Fold(std::vector<unsigned int>& vec, unsigned int nbits); 

        /// Returns fingerprint in vector, which may be resized, folded to nbits (if nbits!=0)
        virtual bool GetFingerprint(OBBase* pOb, std::vector<unsigned int>& fp, int nbits=0)=0;

        /// Required short description of the fingerprint type.
        virtual std::string Description()=0;

        /// Optional flags
        enum FptFlag{FPT_UNIQUEBITS=1};
        virtual unsigned int Flags() { return 0;}; 

        /// Obtain info on available fingerprints
        static bool GetNextFPrt(std::string& id, OBFingerprint*& pFPrt);

        /// Returns a pointer to a fingerprint (the default if ID is empty), or NULL if not available
        static OBFingerprint* FindFingerprint(std::string& ID);

        /// Returns the Tanimoto coefficient between two vectors (vector<unsigned int>& SeekPositions)
        static double Tanimoto(const std::vector<unsigned int>& vec1, const std::vector<unsigned int>& vec2);
        
        /// Inline version of Tanimoto() taking a pointer for the second vector
        static double Tanimoto(const std::vector<unsigned int>& vec1, const unsigned int* p2) 
        {
                ///If used for two vectors, vec1 and vec2, call as Tanimoto(vec1, &vec2[0]);
                int andbits=0, orbits=0;
                unsigned int i;
                for (i=0;i<vec1.size();++i)
                {
                        int andfp = vec1[i] & p2[i];
                        int orfp = vec1[i] | p2[i];
                        //Count bits
                        for(;andfp;andfp=andfp<<1)
                                if(andfp<0) ++andbits;
                        for(;orfp;orfp=orfp<<1)
                                if(orfp<0) ++orbits;
                }
                        return((double)andbits/(double)orbits);
        };
        
        static const unsigned int bitsperint;// = 8 * sizeof(unsigned int);

private:
        ///Function object to set bits
        struct bit_or
        {
                unsigned int operator()(const unsigned int a, const unsigned int b)
                {
                        return a | b;   
                }
        };
        
        typedef std::map<std::string, OBFingerprint*> FPMapType;
        typedef FPMapType::iterator Fptpos;

protected:
        ///This static function returns a reference to the FPtsMap
        ///which, because it is a static local variable is constructed only once.
        ///This fiddle is to avoid the "static initialization order fiasco"
        ///See Marshall Cline's C++ FAQ Lite document, www.parashift.com/c++-faq-lite/". 
        static FPMapType& FPtsMap()
        {
                static FPMapType* fptm = new FPMapType;
                return *fptm;
        };

        OBFingerprint(std::string ID, bool IsDefault=false)
        {
                FPtsMap()[ID] = this; //registers the derived fingerprint class
                if(IsDefault || FPtsMap().empty())
                        _pDefault=this;
        };
        
private:
        static OBFingerprint* _pDefault;
};


//*************************************************************
//Fast search routines
///Header for fastsearch index file
struct OBAPI FptIndexHeader
{
        unsigned int headerlength;///<offset to data: sizeof(FptIndexHeader)
        unsigned int nEntries;    ///<number of fingerprints
        unsigned int words;                             ///<number 32bit words per fingerprint
        char fpid[16];            ///<ID of the fingerprint type
        char datafilename[256];   ///<the data that this is an index to
};
/// Structure of fastsearch index files
struct OBAPI FptIndex
{
        FptIndexHeader header;
        std::vector<unsigned int> fptdata;
        std::vector<unsigned int> seekdata;
};

/// \brief Class to search fingerprint index files
class OBAPI FastSearch
{
//see end of cpp file for detailed documentation
public:
  std::string ReadIndex(std::istream* pIndexstream);
        virtual ~FastSearch(){};

        /// \brief Does substructure search and returns vector of the file positions of matches 
        bool    Find(OBBase* pOb, std::vector<unsigned int>& SeekPositions, unsigned int MaxCandidates);

        /// \brief Returns multimap containing objects whose Tanimoto coefficients with the target
        ///     is greater than the value specified.
        bool    FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
                double MinTani);

        /// \brief Returns multimap containing the nCandidates objects with largest Tanimoto
        ///  coefficients with the target.
        bool    FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
                int nCandidates=0);

        /// \brief Returns a pointer to the fingerprint type used to constuct the index
        OBFingerprint* GetFingerprint() const{ return _pFP;};

private:
        FptIndex   _index;
        OBFingerprint* _pFP;
};

//**********************************************
/// \brief Class to prepare fingerprint index files See FastSearch class for details
class OBAPI FastSearchIndexer
{
//see end of cpp file for detailed documentation
public:
        FastSearchIndexer(std::string& datafilename, std::ostream* os, std::string& fpid,
                        int FptBits=0);
        ~FastSearchIndexer();

        ///\brief Called for each object
        bool Add(OBBase* pOb, std::streampos seekpos);

private:
        std::ostream* _indexstream;
        FptIndex*               _pindex;
        OBFingerprint* _pFP;
        int _nbits;
};

} //namespace OpenBabel
#endif

//! \file fingerprint.h
//! \brief Declaration of OBFingerprint base class and fastsearch classes
Revision:	2445
Committed:	Wed Nov 16 21:22:51 2005 UTC (18 years, 8 months ago) by tim
File size:	6071 byte(s)
Log Message:	adding more readers/writers
#	Content
1	/**********************************************************************
2	fingerprint.h - Base class for fingerprints and fast searching
3
4	Copyright (C) 2005 by Chris Morley
5
6	This file is part of the Open Babel project.
7	For more information, see <http://openbabel.sourceforge.net/>
8
9	This program is free software; you can redistribute it and/or modify
10	it under the terms of the GNU General Public License as published by
11	the Free Software Foundation version 2 of the License.
12
13	This program is distributed in the hope that it will be useful,
14	but WITHOUT ANY WARRANTY; without even the implied warranty of
15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	GNU General Public License for more details.
17	***********************************************************************/
18
19	#ifndef OB_FINGERPRINT_H
20	#define OB_FINGERPRINT_H
21
22	#include <list>
23	#include <map>
24	#include <set>
25	#include <vector>
26	#include <string>
27
28	namespace OpenBabel
29	{
30	class OBBase; //Forward declaration; used only as pointer.
31
32	/// \brief The base class for fingerprints
33	class OBAPI OBFingerprint
34	{
35	//see end of cpp file for detailed documentation
36	public:
37	/// Sets the nth bit
38	void SetBit(std::vector<unsigned int>& vec, unsigned int n);
39
40	/// Repeatedly ORs the top half with the bottom half until no smaller than nbits
41	void Fold(std::vector<unsigned int>& vec, unsigned int nbits);
42
43	/// Returns fingerprint in vector, which may be resized, folded to nbits (if nbits!=0)
44	virtual bool GetFingerprint(OBBase* pOb, std::vector<unsigned int>& fp, int nbits=0)=0;
45
46	/// Required short description of the fingerprint type.
47	virtual std::string Description()=0;
48
49	/// Optional flags
50	enum FptFlag{FPT_UNIQUEBITS=1};
51	virtual unsigned int Flags() { return 0;};
52
53	/// Obtain info on available fingerprints
54	static bool GetNextFPrt(std::string& id, OBFingerprint*& pFPrt);
55
56	/// Returns a pointer to a fingerprint (the default if ID is empty), or NULL if not available
57	static OBFingerprint* FindFingerprint(std::string& ID);
58
59	/// Returns the Tanimoto coefficient between two vectors (vector<unsigned int>& SeekPositions)
60	static double Tanimoto(const std::vector<unsigned int>& vec1, const std::vector<unsigned int>& vec2);
61
62	/// Inline version of Tanimoto() taking a pointer for the second vector
63	static double Tanimoto(const std::vector<unsigned int>& vec1, const unsigned int* p2)
64	{
65	///If used for two vectors, vec1 and vec2, call as Tanimoto(vec1, &vec2[0]);
66	int andbits=0, orbits=0;
67	unsigned int i;
68	for (i=0;i<vec1.size();++i)
69	{
70	int andfp = vec1[i] & p2[i];
71	int orfp = vec1[i] \| p2[i];
72	//Count bits
73	for(;andfp;andfp=andfp<<1)
74	if(andfp<0) ++andbits;
75	for(;orfp;orfp=orfp<<1)
76	if(orfp<0) ++orbits;
77	}
78	return((double)andbits/(double)orbits);
79	};
80
81	static const unsigned int bitsperint;// = 8 * sizeof(unsigned int);
82
83	private:
84	///Function object to set bits
85	struct bit_or
86	{
87	unsigned int operator()(const unsigned int a, const unsigned int b)
88	{
89	return a \| b;
90	}
91	};
92
93	typedef std::map<std::string, OBFingerprint*> FPMapType;
94	typedef FPMapType::iterator Fptpos;
95
96	protected:
97	///This static function returns a reference to the FPtsMap
98	///which, because it is a static local variable is constructed only once.
99	///This fiddle is to avoid the "static initialization order fiasco"
100	///See Marshall Cline's C++ FAQ Lite document, www.parashift.com/c++-faq-lite/".
101	static FPMapType& FPtsMap()
102	{
103	static FPMapType* fptm = new FPMapType;
104	return *fptm;
105	};
106
107	OBFingerprint(std::string ID, bool IsDefault=false)
108	{
109	FPtsMap()[ID] = this; //registers the derived fingerprint class
110	if(IsDefault \|\| FPtsMap().empty())
111	_pDefault=this;
112	};
113
114	private:
115	static OBFingerprint* _pDefault;
116	};
117
118
119
120
121	//*************************************************************
122	//Fast search routines
123	///Header for fastsearch index file
124	struct OBAPI FptIndexHeader
125	{
126	unsigned int headerlength;///<offset to data: sizeof(FptIndexHeader)
127	unsigned int nEntries; ///<number of fingerprints
128	unsigned int words; ///<number 32bit words per fingerprint
129	char fpid[16]; ///<ID of the fingerprint type
130	char datafilename[256]; ///<the data that this is an index to
131	};
132	/// Structure of fastsearch index files
133	struct OBAPI FptIndex
134	{
135	FptIndexHeader header;
136	std::vector<unsigned int> fptdata;
137	std::vector<unsigned int> seekdata;
138	};
139
140	/// \brief Class to search fingerprint index files
141	class OBAPI FastSearch
142	{
143	//see end of cpp file for detailed documentation
144	public:
145	std::string ReadIndex(std::istream* pIndexstream);
146	virtual ~FastSearch(){};
147
148	/// \brief Does substructure search and returns vector of the file positions of matches
149	bool Find(OBBase* pOb, std::vector<unsigned int>& SeekPositions, unsigned int MaxCandidates);
150
151	/// \brief Returns multimap containing objects whose Tanimoto coefficients with the target
152	/// is greater than the value specified.
153	bool FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
154	double MinTani);
155
156	/// \brief Returns multimap containing the nCandidates objects with largest Tanimoto
157	/// coefficients with the target.
158	bool FindSimilar(OBBase* pOb, std::multimap<double, unsigned int>& SeekposMap,
159	int nCandidates=0);
160
161	/// \brief Returns a pointer to the fingerprint type used to constuct the index
162	OBFingerprint* GetFingerprint() const{ return _pFP;};
163
164	private:
165	FptIndex _index;
166	OBFingerprint* _pFP;
167	};
168
169	//**********************************************
170	/// \brief Class to prepare fingerprint index files See FastSearch class for details
171	class OBAPI FastSearchIndexer
172	{
173	//see end of cpp file for detailed documentation
174	public:
175	FastSearchIndexer(std::string& datafilename, std::ostream* os, std::string& fpid,
176	int FptBits=0);
177	~FastSearchIndexer();
178
179	///\brief Called for each object
180	bool Add(OBBase* pOb, std::streampos seekpos);
181
182	private:
183	std::ostream* _indexstream;
184	FptIndex* _pindex;
185	OBFingerprint* _pFP;
186	int _nbits;
187	};
188
189	} //namespace OpenBabel
190	#endif
191
192	//! \file fingerprint.h
193	//! \brief Declaration of OBFingerprint base class and fastsearch classes