/**********************************************************************

fingerprint.cpp - Implementation of fingerpring base class and fastsearching

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.

***********************************************************************/

#include <openbabel/babelconfig.h>

#include <vector>

#include <algorithm>

#include <iosfwd>

#include <cstring>

#include <fstream>

#include <openbabel/fingerprint.h>

#include <openbabel/oberror.h>

using namespace std;

namespace OpenBabel

{

#if defined(__CYGWIN__) || defined(__MINGW32__)

  // macro to implement static OBPlugin::PluginMapType& Map()

  PLUGIN_CPP_FILE(OBFingerprint)

#endif

  const unsigned int OBFingerprint::bitsperint = 8 * sizeof(unsigned int);

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

  {

    vec[n/Getbitsperint()] |= (1 << (n % Getbitsperint()));

  }

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

  {

    unsigned int word =vec[n/Getbitsperint()];

    return (word &= (1 << (n % Getbitsperint())))!=0;

  }

  ////////////////////////////////////////

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

  {

    if(nbits<Getbitsperint())

    {

      stringstream ss;

      ss << "Can't fold to less than " << Getbitsperint() << "bits";

      obErrorLog.ThrowError(__FUNCTION__, ss.str(), obError);

      return;

    }

    // "folding" to a larger # of bits

    if (nbits > vec.size()*Getbitsperint()) {

      vec.resize(nbits/Getbitsperint(), 0);

    }

    else {

      // normal folding to smaller vector sizes

      while(vec.size()*Getbitsperint()/2 >= nbits)

        vec.erase(transform(vec.begin(),vec.begin()+vec.size()/2,

                            vec.begin()+vec.size()/2, vec.begin(), bit_or()), vec.end());

    }

  }

  ////////////////////////////////////////

/*  bool OBFingerprint::GetNextFPrt(std::string& id, OBFingerprint*& pFPrt)

  {

    Fptpos iter;

    if(id.empty())

      iter=FPtsMap().begin();

    else

      {

        iter=FPtsMap().find(id);

        if(iter!=FPtsMap().end())

          ++iter;

      }

    if(iter==FPtsMap().end())

      return false;

    id    = iter->first;

    pFPrt = iter->second;

    return true;

  }

  OBFingerprint* OBFingerprint::FindFingerprint(const string& ID)

  {

    if(ID.empty())

      return _pDefault;

    Fptpos iter = FPtsMap().find(ID);

    if(iter==FPtsMap().end())

      return NULL;

    else

      return iter->second;

  }

*/

  double OBFingerprint::Tanimoto(const vector<unsigned int>& vec1, const vector<unsigned int>& vec2)

  {

    //Independent of sizeof(unsigned int)

    if(vec1.size()!=vec2.size())

      return -1; //different number of bits

    int andbits=0, orbits=0;

    for (unsigned i=0;i<vec1.size();++i)

      {

        int andfp = vec1[i] & vec2[i];

        int orfp = vec1[i] | vec2[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

      }

    if(orbits==0)

      return 0.0;

    return((double)andbits/(double)orbits);

  }

  //*****************************************************************

  bool FastSearch::Find(OBBase* pOb, vector<unsigned long>& SeekPositions,

                        unsigned int MaxCandidates)

  {

    ///Finds chemical objects in datafilename (which must previously have been indexed)

    ///that have all the same bits set in their fingerprints as in the fingerprint of

    ///a pattern object. (Usually a substructure search in molecules.)

    ///The type of fingerprint and its degree of folding does not have to be specified

    ///here because the values in the index file are used.

    ///The positions of the candidate matching molecules in the original datafile are returned.

    vector<unsigned int> vecwords;

    _pFP->GetFingerprint(pOb,vecwords, _index.header.words * OBFingerprint::Getbitsperint());

    vector<unsigned int>candidates; //indices of matches from fingerprint screen

    candidates.reserve(MaxCandidates);

    unsigned int dataSize = _index.header.nEntries;

    //  GetFingerprint(mol, vecwords, _index.header.words, _index.header.fptype);

    unsigned int words = _index.header.words;

    unsigned int* nextp = &_index.fptdata[0];

    unsigned int* ppat0 = &vecwords[0];

    unsigned int* p;

    unsigned int* ppat;

    unsigned int i;

    for(i=0;i<dataSize; ++i) //speed critical section

      {

        p=nextp;

        nextp += words;

        ppat=ppat0;

        bool ppat_has_additional_bits = false;

        while(p<nextp)

          {

            if ((*ppat & *p) ^ *ppat) { // any bits in ppat that are not in p?

              ppat_has_additional_bits = true;

              break;

            }

            p++;

            ppat++;

          }

        if(!ppat_has_additional_bits)

          {

            candidates.push_back(i);

            if(candidates.size()>=MaxCandidates)

              break;

          }

      }

    if(i<_index.header.nEntries) //premature end to search

      {

        stringstream errorMsg;

        errorMsg << "Stopped looking after " << i << " molecules." << endl;

        obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);

      }

    vector<unsigned int>::iterator itr;

    for(itr=candidates.begin();itr!=candidates.end();++itr)

      {

        SeekPositions.push_back(_index.seekdata[*itr]);

      }

    return true;

  }

////////////////////////////////////////////////////////////

 bool FastSearch::FindMatch(OBBase* pOb, vector<unsigned long>& SeekPositions,

                            unsigned int MaxCandidates)

{

//Similar to FastSearch::Find() except that successful candidates have all bits the same as the target

  vector<unsigned int> vecwords;

  _pFP->GetFingerprint(pOb,vecwords, _index.header.words * OBFingerprint::Getbitsperint());

  vector<unsigned int>candidates; //indices of matches from fingerprint screen

  unsigned int dataSize = _index.header.nEntries;

  unsigned int words = _index.header.words;

  unsigned int* nextp = &_index.fptdata[0]; // start of next FP in index

  unsigned int* ppat0 = &vecwords[0];       // start of target FP

  unsigned int* p;                          // current position in index

  unsigned int* ppat;                       // current position in target FP

  unsigned int i; // need address of this, can't be register

  for(i=0;i<dataSize; ++i) //speed critical section

  {

    p=nextp;

    nextp += words;

    ppat=ppat0;

    while((*p++ == *ppat++ ) && (p<nextp));

    if(p==nextp)

    {

      candidates.push_back(i);

      if(candidates.size()>=MaxCandidates)

        break;

    }

  }

  vector<unsigned int>::iterator itr;

  for(itr=candidates.begin();itr!=candidates.end();++itr)

    {

      SeekPositions.push_back(_index.seekdata[*itr]);

    }

  return true;

}

  /////////////////////////////////////////////////////////

  bool FastSearch::FindSimilar(OBBase* pOb, multimap<double, unsigned long>& SeekposMap,

                               double MinTani, double MaxTani)

  {

    vector<unsigned int> targetfp;

    _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::Getbitsperint());

    unsigned int words = _index.header.words;

    unsigned int dataSize = _index.header.nEntries;

    unsigned int* nextp = &_index.fptdata[0];

    unsigned int* p;

    unsigned int i;

    for(i=0;i<dataSize; ++i) //speed critical section

      {

        p=nextp;

        nextp += words;

        double tani = OBFingerprint::Tanimoto(targetfp,p);

        if(tani>MinTani && tani < MaxTani)

          SeekposMap.insert(pair<const double, unsigned long>(tani,_index.seekdata[i]));

      }

    return true;

  }

  /////////////////////////////////////////////////////////

  bool FastSearch::FindSimilar(OBBase* pOb, multimap<double, unsigned long>& SeekposMap,

                               int nCandidates)

  {

    ///If nCandidates is zero or omitted the original size of the multimap is used

    if(nCandidates)

      {

        //initialise the multimap with nCandidate zero entries

        SeekposMap.clear();

        int i;

        for(i=0;i<nCandidates;++i)

          SeekposMap.insert(pair<const double, unsigned long>(0,0));

      }

    else if(SeekposMap.size()==0)

      return false;

    vector<unsigned int> targetfp;

    _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::Getbitsperint());

    unsigned int words = _index.header.words;

    unsigned int dataSize = _index.header.nEntries;

    unsigned int* nextp = &_index.fptdata[0];

    unsigned int* p;

    unsigned int i;

    for(i=0;i<dataSize; ++i) //speed critical section

      {

        p=nextp;

        nextp += words;

        double tani = OBFingerprint::Tanimoto(targetfp,p);

        if(tani>SeekposMap.begin()->first)

          {

            SeekposMap.insert(pair<const double, unsigned long>(tani,_index.seekdata[i]));

            SeekposMap.erase(SeekposMap.begin());

          }

      }

    return true;

  }

  /////////////////////////////////////////////////////////

  string FastSearch::ReadIndex(istream* pIndexstream)

  {

    //Reads fs index from istream into member variables

    _index.Read(pIndexstream);

    _pFP = _index.CheckFP();

    if(!_pFP)

      *(_index.header.datafilename) = '\0';

    return _index.header.datafilename; //will be empty on error

  }

  //////////////////////////////////////////////////////////

  string FastSearch::ReadIndexFile(string IndexFilename)

  {

    ifstream ifs(IndexFilename.c_str(),ios::binary);

    if(ifs)

      return ReadIndex(&ifs);

    else

    {

      string dum;

      return dum;

    }

  }

  //////////////////////////////////////////////////////////

  bool FptIndex::Read(istream* pIndexstream)

  {

//    pIndexstream->read((char*)&(header), sizeof(FptIndexHeader));

//    pIndexstream->seekg(header.headerlength);//allows header length to be changed

    if(!ReadHeader(pIndexstream))

      {

        *(header.datafilename) = '\0';

        return false;

      }

    unsigned long nwords = header.nEntries * header.words;

    fptdata.resize(nwords);

    seekdata.resize(header.nEntries);

    pIndexstream->read((char*)&(fptdata[0]), sizeof(unsigned int) * nwords);

    if(header.seek64) 

      {

      pIndexstream->read((char*)&(seekdata[0]), sizeof(unsigned long) * header.nEntries);

      }

    else 

      { //legacy format

   vector<unsigned int> tmp(header.nEntries);

         pIndexstream->read((char*)&(tmp[0]), sizeof(unsigned int) * header.nEntries);

   std::copy(tmp.begin(),tmp.end(),seekdata.begin());

      }

    if(pIndexstream->fail())

      {

        *(header.datafilename) = '\0';

        return false;

      }

    return true;

  }

  //////////////////////////////////////////////////////////

  bool FptIndex::ReadHeader(istream* pIndexstream)

  {

    pIndexstream->read( (char*)&header.headerlength, sizeof(unsigned) );

    pIndexstream->read( (char*)&header.nEntries,     sizeof(unsigned) );

    pIndexstream->read( (char*)&header.words,        sizeof(unsigned) );

    pIndexstream->read( (char*)&header.fpid,         sizeof(header.fpid) );

    pIndexstream->read( (char*)&header.seek64,       sizeof(header.seek64) );

    pIndexstream->read( (char*)&header.datafilename, sizeof(header.datafilename) );

    return !pIndexstream->fail();

 }

  //////////////////////////////////////////////////////////

  OBFingerprint* FptIndex::CheckFP()

  {

    //check that fingerprint type is available

    OBFingerprint* pFP = OBFingerprint::FindFingerprint(header.fpid);

    if(!pFP)

      {

        stringstream errorMsg;

        errorMsg << "Index has Fingerprints of type '" << header.fpid

                 << " which is not currently loaded." << endl;

        obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obError);

      }

    return pFP; //NULL if not available

  }

  //*******************************************************

  FastSearchIndexer::FastSearchIndexer(string& datafilename, ostream* os,

                                       std::string& fpid, int FptBits, int nmols)

  {

    ///Starts indexing process

    _indexstream = os;

    _nbits=FptBits;

    _pindex= new FptIndex;

    _pindex->header.headerlength = 3*sizeof(unsigned)+sizeof(_pindex->header.fpid)

                                    +sizeof(_pindex->header.datafilename);

    strncpy(_pindex->header.fpid,fpid.c_str(),15);

    _pindex->header.fpid[14]='\0'; //ensure fpid is terminated at 14 characters.

    _pindex->header.seek64 = 1;

    strncpy(_pindex->header.datafilename, datafilename.c_str(), 255);

    //just a hint to reserve size of vectors; definitive value set in destructor

    _pindex->header.nEntries = nmols;

    //check that fingerprint type is available

    _pFP = _pindex->CheckFP();

    if(fpid.empty()) // add id of default FP

      strcpy(_pindex->header.fpid, _pFP->GetID());

    //Save a small amount of time by not generating info (FP2 currently)

    _pFP->SetFlags(_pFP->Flags() | OBFingerprint::FPT_NOINFO);

  }

  /////////////////////////////////////////////////////////////

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

  {

    //nmols is new total number of molecules

    _indexstream = os;

    _pindex = pindex;

    _nbits  = _pindex->header.words * OBFingerprint::Getbitsperint();

    //just a hint to reserve size of vectors; definitive value set in destructor

    _pindex->header.nEntries = nmols;

    //check that fingerprint type is available

    _pFP = _pindex->CheckFP();

  }

  /////////////////////////////////////////////////////////////

  FastSearchIndexer::~FastSearchIndexer()

  {

    ///Saves index file

    FptIndexHeader& hdr = _pindex->header;

    hdr.nEntries = _pindex->seekdata.size();

    //Write header

    //_indexstream->write((const char*)&hdr, sizeof(FptIndexHeader));

    _indexstream->write( (const char*)&hdr.headerlength, sizeof(unsigned) );

    _indexstream->write( (const char*)&hdr.nEntries,     sizeof(unsigned) );

    _indexstream->write( (const char*)&hdr.words,        sizeof(unsigned) );

    _indexstream->write( (const char*)&hdr.fpid,         sizeof(hdr.fpid) );

    _indexstream->write( (const char*)&hdr.seek64,         sizeof(hdr.seek64) );

    _indexstream->write( (const char*)&hdr.datafilename, sizeof(hdr.datafilename) );

    _indexstream->write((const char*)&_pindex->fptdata[0], _pindex->fptdata.size()*sizeof(unsigned int));

    _indexstream->write((const char*)&_pindex->seekdata[0], _pindex->seekdata.size()*sizeof(unsigned long));

    if(!_indexstream)

      obErrorLog.ThrowError(__FUNCTION__,

                            "Difficulty writing index", obWarning);

    delete _pindex;

    _pFP->SetFlags(_pFP->Flags() & ~OBFingerprint::FPT_NOINFO); //Clear

  }

  ///////////////////////////////////////////////////////////////

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

  {

    ///Adds a fingerprint

    vector<unsigned int> vecwords;

    if(!_pFP)

      return false;

    if(_pFP->GetFingerprint(pOb, vecwords, _nbits))

      {

        _pindex->header.words = vecwords.size(); //Use size as returned from fingerprint

        if(_pindex->fptdata.empty() && _pindex->header.nEntries!=0)

        {

          //Reserve size of vectors at start to avoid multiple realloction and copying later.

          //Done here rather than in constructor because needs the size of the fingerprint.

          _pindex->fptdata.reserve(_pindex->header.nEntries * _pindex->header.words);

          _pindex->seekdata.reserve(_pindex->header.nEntries);

        }

        for(unsigned int i=0;i<_pindex->header.words;++i)

          _pindex->fptdata.push_back(vecwords[i]);

        _pindex->seekdata.push_back(seekpos);

        return true;

      }

    obErrorLog.ThrowError(__FUNCTION__, "Failed to make a fingerprint", obWarning);

    return false;

  }

  /*!

    \class OBFingerprint fingerprint.h <openbabel/fingerprint.h>

    These fingerprints are condensed representation of molecules (or other objects)

    as a list of boolean values (actually bits in a vector<unsigned>) with length

    of a power of 2. The main motivation is for fast searching of data sources

    containing large numbers of molecules (up to several million). Open Babel

    provides some routines which can search text files containing lists of molecules

    in any format. See the documentation on the class FastSearch.

    There are descriptions of molecular fingerprints at <br>

    http://www.daylight.com/dayhtml/doc/theory/theory.finger.html) and <br>

    http://www.mesaac.com/Fingerprint.htm <br>

    Many methods of preparing fingerprints have been described, but the type supported

    currently in OpenBabel has each bit representing a substructure (or other

    molecular property). If a substructure is present in the molecule, then a

    particular bit is set to 1. But because the hashing method may also map other

    substructures to the same bit, a match does not guarantee that a particular

    substructure is present; there may be false positives.  However, with proper design,

    a large fraction of irrelevant molecules in a data set can be eliminated in a

    fast search with boolean methods on the fingerprints.

    It then becomes feasible to make a definitive substructure search by

    conventional methods on this reduced list even if it is slow.

    OpenBabel provides a framework for applying new types of fingerprints without

    changing any existing code. They are derived from OBFingerprint and the

    source file is just compiled with the rest of OpenBabel. Alternatively,

    they can be separately compiled as a DLL or shared library and discovered

    when OpenBabel runs.

    For more on these specific implementations of fingerprints in Open

    Babel, please take a look at the developer's wiki:

    http://openbabel.org/wiki/Fingerprints

    Fingerprints derived from this abstract base class OBFingerprint can be for any

    object derived from OBBase (not just for OBMol).

    Each derived class provides an ID as a string and OBFingerprint keeps a map of

    these to provides a pointer to the class when requested in FindFingerprint.

    <h4>-- To define a fingerprint type --</h4>

    The classes derived form OBFingerprint are required to provide

    a GetFingerprint() routine and a Description() routine

    \code

    class MyFpType : OBFingerprint

    {

       MyFpType(const char* id) : OBFingerprint(id){};

       virtual bool GetFingerprint(OBBase* pOb, vector<unsigned int>& fp, int nbits)

       {

          //Convert pOb to the required type, usually OBMol

          OBMol* pmol = dynamic_cast<OBMol*>(pOb);

          fp.resize(required_number_of_words);

          ...

          use SetBit(fp,n); to set the nth bit

          if(nbits)

             Fold(fp, nbits);

       }

       virtual const char* Description(){ return "Some descriptive text";}

       ...

    };

    \endcode

    Declare a global instance with the ID you will use in -f options to specify

    its use.

    \code

    MyFpType theMyFpType("myfpID");

    \endcode

    <h4>-- To obtain a fingerprint --</h4>

    \code

    OBMol mol;

    ...

    vector<unsigned int> fp;

    OBFingerprint::GetDefault()->GetFingerprint(&mol, fp); //gets default size of fingerprint

    \endcode

    or

    \code

    vector<unsigned int> fp;

    OBFingerPrint* pFP = OBFingerprint::FindFingerprint("myfpID");

    ...and maybe...

    pFP->GetFingerprint(&mol,fp, 128); //fold down to 128bits if was originally larger

    \endcode

    <h4>-- To print a list of available fingerprint types --</h4>

    \code

    std::string id;

    OBFingerPrint* pFPrt=NULL;

    while(OBFingerprint::GetNextFPrt(id, pFPrt))

    {

       cout << id << " -- " << pFPrt->Description() << endl;

    }

    \endcode

    Fingerprints are handled as vector<unsigned int> so that the number of bits

    in this vector and their order will be platform and compiler

    dependent, because of size of int types and endian differences.

    Use fingerprints (and fastsearch indexes containing them) only

    for comparing with other fingerprints prepared on the same machine.

    The FingerprintFormat class is an output format which displays fingerprints

    as hexadecimal. When multiple molecules are supplied it will calculate the

    Tanimoto coefficient from the first molecule to each of the others. It also

    shows whether the first molecule is a possible substructure to all the others,

    i.e. whether all the bits set in the fingerprint for the first molecule are

    set in the fingerprint of the others. To display hexadecimal information when

    multiple molecules are provided it is necessay to use the -xh option.

    To see a list of available format types, type obabel -F on the command line.

    The -xF option of the FingerprintFormat class also provides this output, but due

    to a quirk in the way the program works, it is necessary to have a valid input

    molecule for this option to work.

  */

  /*! \class FastSearch fingerprint.h <openbabel/fingerprint.h>

    The FastSearch class searches an index to a datafile containing a list of molecules

    (or other objects) prepared by FastSearchIndexer.

    OpenBabel can also search files for molecules containing a substructure specified

    by a SMARTS string, using OBSmartsPattern or from the command line:

    \code

    obabel datafile.xxx -O outfile.yyy -sSMARTS

    \endcode

    But when the data file contains more than about 10,000 molecules this becomes

    rather too slow to be used interactively. To do it more quickly, an index

    of the molecules containing their fingerprints (see OBFingerprint) is prepared using

    FastSearchIndexer. The indexing process may take a long time but only has to

    be done once. The index can be searched very quickly with FastSearch. Because

    of the nature of fingerprints a match to a bit does not guarantee

    the presence of a particular substructure or other molecular property, so that

    a definitive answer may require a subsequent search of the (much reduced) list

    of candidates by another method (like OBSmartsPattern).

    Note that the index files are not portable. They need to be prepared on the

    computer that will access them.

    <h4>Using FastSearch and FastSearchIndexer in a program</h4>

    The index has two tables:

    - an array of fingerprints of the molecules

    - an array of the seek positions in the datasource file of all the molecules

    <h4>To prepare an fastsearch index file:</h4>

    - Open an ostream to the index file.

    - Make a FastSearchIndexer object on the heap or the stack, passing in as parameters:

    - the datafile name, the indexfile stream,

    - the id of the fingerprint type to be used,

    -  the number of bits the fingerprint is to be folded down to, If it is to be left

    unfolded, set fpid to 0 or do not specify it.

    .

    - For each molecule, call Add() with its pointer and its position in the datafile.<br>

    Currently the std::streampos value is implicitly cast to unsigned int so that

    for 32bit machines the datafile has to be no longer than about 2Gbyte.

    - The index file is written when the FastSearchIndexer object is deleted or goes out

    of scope.

    <h4>To search in a fastsearch index file</h4>

    - Open a std::istream to the indexfile (in binary mode on some systems)

    - Make a FastSearch object, read the index and open the datafile whose

    name it provides

    \code

    ifstream ifs(indexname,ios::binary);

    FastSearch fs;

    string datafilename = fs.ReadIndex(&ifs);

    if(datafilename.empty()

       return false;

    ifstream datastream(datafilename);

    if(!datastream)

       return false;

    \endcode

    <strong>To do a search for molecules which have all the substructure bits the

    OBMol object, patternMol</strong>

    \code

    vector<unsigned int>& SeekPositions;

    if(!fs.Find(patternMol, SeekPositions, MaxCandidates))

      for(itr=SeekPositions.begin();itr!=SeekPositions.end();++itr)

      {

         datastream.seekg(*itr);

         ... read the candidate molecule

         and subject to more rigorous test if necessary

      }

    \endcode

    <strong>To do a similarity search based on the Tanimoto coefficient</strong>

    This is defined as: <br>

    <em>Number of bits set in (patternFP & targetFP)/Number of bits in (patternFP | targetFP)</em><br>

    where the boolean operations between the fingerprints are bitwise<br>

    The Tanimoto coefficient has no absolute meaning and depends on

    the design of the fingerprint.

    \code

    multimap<double, unsigned int> SeekposMap;

    // to find n best molecules

    fs.FindSimilar(&patternMol, SeekposMap, n);

    ...or

    // to find molecules with Tanimoto coefficient > MinTani

    fs.FindSimilar(&patternMol, SeekposMap, MinTani);

    multimap<double, unsigned int>::reverse_iterator itr;

    for(itr=SeekposMap.rbegin();itr!=SeekposMap.rend();++itr)

    {

       datastream.seekg(itr->second);

       // ... read the candidate molecule

       double tani = itr->first;

    }

    \endcode

    The FastSearchFormat class facilitates the use of these routine from the

    command line or other front end program. For instance:

    <strong>Prepare an index:</strong>

    \code

    obabel datafile.xxx -O index.fs

    \endcode

    With options you can specify:

    - which type of fingerprint to be used, e.g. -xfFP2,

    - whether it is folded to a specified number of bits, e.g. -xn128

    (which should be a power of 2)

    - whether to pre-select the molecules which are indexed:

    - by structure e.g only ethers and esters, -sCOC

    - by excluding molecules with bezene rings, -vc1ccccc1

    - by position in the datafile e.g. only mols 10 to 90, -f10 -l90

    .

    <strong>Substructure search</strong> in a previously prepared index file

    \code

    obabel index.fs -O outfile.yyy -sSMILES

    \endcode

    The datafile can also be used as the input file, provided the input format is specified as fs

    \code

    obabel datafile.xxx -O outfile.yyy -sSMILES -ifs

    \endcode

    A "slow" search not using fingerprints would be done on the same data by omitting -ifs.

    A "slow" search can use SMARTS strings, but the fast search is restricted

    to the subset which is valid SMILES.

    With the -S option, the target can be specified as a molecule in a file of any format

    \code

    obabel datafile.xxx -O outfile.yyy -Spattern_mol.zzz -ifs

    \endcode

    These searches have two stages: a fingerprint search which produces

    a number of candidate molecules and a definitive search which selects

    from these using SMARTS pattern matching. The maximum number of candidates

    is 4000 by default but you can change this with an option

    e.g. -al 8000  (Note that you need the space between l and the number.)

    If the fingerprint search reaches the maximum number it will not

    look further and will tell you at what stage it stopped.

    <strong>Similarity search</strong> in a previously prepared index file<br>

    This rather done (rather than a substructure search) if the -at option is used,

    \code

    obabel datafile.xxx -O outfile.yyy -sSMILES -ifs -at0.7

    \endcode

    for instance

    - -at0.7 will recover all molecules with Tanimoto greater than 0.7

    - -at15 (no decimal point) will recover the 15 molecules with largest coefficients.

    - -aa will add the Tanimoto coefficient to the titles of the output molecules.

    All stages, the indexing, the interpretation of the SMILES string in the -s option,

    the file in the -S option and the final SMARTS filter convert to OBMol and apply

    ConvertDativeBonds(). This ensures thatforms such as[N+]([O-])=O  and N(=O)=O

    are recognized as chemically identical.

  */

}//Openbabel

//! \file fingerprint.cpp

//! \brief Definitions for OBFingerprint base class and fastsearch classes