fingerprint.h

Go to the documentation of this file.

/**********************************************************************
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.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_FINGERPRINT_H
#define OB_FINGERPRINT_H

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

#include <openbabel/plugin.h>

#ifndef OBFPRT
#define OBFPRT
#endif

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

class OBFPRT OBFingerprint : public OBPlugin
{
//see end of cpp file for detailed documentation

MAKE_PLUGIN(OBFingerprint)

const char* TypeID()
 {
 return "fingerprints";
 }

 //Rest of OBFingerprints declarations
public:

 virtual ~OBFingerprint(){}

 void SetBit(std::vector<unsigned int>& vec, const unsigned int n);

 bool GetBit(const std::vector<unsigned int>& vec, const unsigned int n);

 void Fold(std::vector<unsigned int>& vec, unsigned int nbits);

 virtual bool GetFingerprint(OBBase* pOb, std::vector<unsigned int>& fp, int nbits=0)=0;

 enum FptFlag{FPT_UNIQUEBITS=1, FPT_NOINFO=2};
 virtual unsigned int Flags() { return 0;};
 virtual void SetFlags(unsigned int){}

 virtual std::string DescribeBits(const std::vector<unsigned int> /* fp */,
 bool /* bSet */ =true)
 {
 std::string txt("");
 return txt;
 }

 static double Tanimoto(const std::vector<unsigned int>& vec1, const std::vector<unsigned int>& vec2);

 static double Tanimoto(const std::vector<unsigned int>& vec1, const unsigned int* p2)
 {
 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
 /* GCC 3.4 supports a "population count" builtin, which on many targets is
 implemented with a single instruction. There is a fallback definition
 in libgcc in case a target does not have one, which should be just as
 good as the static function below. */
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
 andbits += __builtin_popcount(andfp);
 orbits += __builtin_popcount(orfp);
#else
 for(;andfp;andfp=andfp<<1)
 if(andfp<0) ++andbits;
 for(;orfp;orfp=orfp<<1)
 if(orfp<0) ++orbits;
#endif
 }
 return((double)andbits/(double)orbits);
 };

 static unsigned int Getbitsperint(){ return bitsperint; }

private:
 struct bit_or
 {
 unsigned int operator()(const unsigned int a, const unsigned int b)
 {
 return a | b;
 }
 };


public:
static OBFingerprint* FindFingerprint(const char* ID){ return FindType(ID);}

private:
 static const unsigned int bitsperint;// = 8 * sizeof(unsigned int);
};

//Fast search routines
struct OBFPRT FptIndexHeader
{
 unsigned int headerlength;
 unsigned int nEntries; 
 unsigned int words; 
 char fpid[15]; 
 char seek64; //if true, seek data consists of 64bit long values (only zero in legacy indices)
 char datafilename[256]; 
};

struct OBFPRT FptIndex
{
 FptIndexHeader header;
 std::vector<unsigned int> fptdata;
 std::vector<unsigned long> seekdata;
 bool Read(std::istream* pIndexstream);
 bool ReadIndex(std::istream* pIndexstream);
 bool ReadHeader(std::istream* pIndexstream);

 OBFingerprint* CheckFP();
};

class OBFPRT FastSearch
{
//see end of cpp file for detailed documentation
public:
 std::string ReadIndexFile(std::string IndexFilename);
 std::string ReadIndex(std::istream* pIndexstream);

 virtual ~FastSearch(){};

 bool Find(OBBase* pOb, std::vector<unsigned long>& SeekPositions, unsigned int MaxCandidates);

 bool FindMatch(OBBase* pOb, std::vector<unsigned long>& SeekPositions,
 unsigned int MaxCandidates);

 bool FindSimilar(OBBase* pOb, std::multimap<double, unsigned long>& SeekposMap,
 double MinTani, double MaxTani = 1.1 );

 bool FindSimilar(OBBase* pOb, std::multimap<double, unsigned long>& SeekposMap,
 int nCandidates=0);

 OBFingerprint* GetFingerprint() const{ return _pFP;};

 const FptIndexHeader& GetIndexHeader() const{ return _index.header;};

private:
 FptIndex _index;
 OBFingerprint* _pFP;
};

class OBFPRT FastSearchIndexer
{
//see end of cpp file for detailed documentation
public:
 FastSearchIndexer(std::string& datafilename, std::ostream* os, std::string& fpid,
 int FptBits=0, int nmols=0);

 FastSearchIndexer(FptIndex* pindex, std::ostream* os, int nmols=0);

 ~FastSearchIndexer();

 bool Add(OBBase* pOb, std::streampos seekpos);

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

} //namespace OpenBabel
#endif