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