ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/openbabel/fingerprint.cpp
(Generate patch)

Comparing trunk/src/openbabel/fingerprint.cpp (file contents):
Revision 751 by gezelter, Thu Nov 17 20:38:45 2005 UTC vs.
Revision 1081 by gezelter, Thu Oct 19 20:49:05 2006 UTC

# Line 41 | Line 41 | const unsigned int OBFingerprint::bitsperint = 8 * siz
41  
42   OBFingerprint* OBFingerprint::_pDefault; //static variable
43   const unsigned int OBFingerprint::bitsperint = 8 * sizeof(unsigned int);
44 + int OBFingerprint::rubbish = 666;
45  
46   void OBFingerprint::SetBit(vector<unsigned int>& vec, unsigned int n)
47   {
48 <        vec[n/bitsperint] |= (1 << (n % bitsperint));
48 >        vec[n/Getbitsperint()] |= (1 << (n % Getbitsperint()));
49   }
50  
51   ////////////////////////////////////////        
52   void OBFingerprint::Fold(vector<unsigned int>& vec, unsigned int nbits)
53   {
54 <        while(vec.size()*bitsperint/2 >= nbits)
54 >        while(vec.size()*Getbitsperint()/2 >= nbits)
55                  vec.erase(transform(vec.begin(),vec.begin()+vec.size()/2,
56                          vec.begin()+vec.size()/2, vec.begin(), bit_or()), vec.end());
57   }
# Line 119 | Line 120 | bool FastSearch::Find(OBBase* pOb, vector<unsigned int
120          ///The positions of the candidate matching molecules in the original datafile are returned.
121          
122          vector<unsigned int> vecwords;
123 <        _pFP->GetFingerprint(pOb,vecwords, _index.header.words * OBFingerprint::bitsperint);
123 >        _pFP->GetFingerprint(pOb,vecwords, _index.header.words * OBFingerprint::Getbitsperint());
124          
125          vector<unsigned int>candidates; //indices of matches from fingerprint screen
126          candidates.reserve(MaxCandidates);
# Line 160 | Line 161 | bool FastSearch::Find(OBBase* pOb, vector<unsigned int
161              strstream errorMsg;
162   #endif
163              errorMsg << "Stopped looking after " << i << " molecules." << endl;
164 <            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obInfo);
164 >            obErrorLog.ThrowError(__func__, errorMsg.str(), obWarning);
165            }
166  
167          vector<unsigned int>::iterator itr;
# Line 176 | Line 177 | bool FastSearch::FindSimilar(OBBase* pOb, multimap<dou
177                                                                                                                   double MinTani)
178   {
179          vector<unsigned int> targetfp;
180 <        _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::bitsperint);
180 >        _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::Getbitsperint());
181  
182          unsigned int words = _index.header.words;
183          unsigned int dataSize = _index.header.nEntries;
# Line 211 | Line 212 | bool FastSearch::FindSimilar(OBBase* pOb, multimap<dou
212                  return false;
213  
214          vector<unsigned int> targetfp;
215 <        _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::bitsperint);
215 >        _pFP->GetFingerprint(pOb,targetfp, _index.header.words * OBFingerprint::Getbitsperint());
216  
217          unsigned int words = _index.header.words;
218          unsigned int dataSize = _index.header.nEntries;
# Line 230 | Line 231 | bool FastSearch::FindSimilar(OBBase* pOb, multimap<dou
231                  }
232          }      
233          return true;
234 < }/////////////////////////////////////////////////////////
234 > }
235 >
236 > /////////////////////////////////////////////////////////
237   string FastSearch::ReadIndex(istream* pIndexstream)
238   {
239          //Reads fs index from istream into member variables
240 <        // but first checks whether it is already loaded
238 <        FptIndexHeader headercopy = _index.header;
239 <        pIndexstream->read((char*)&(_index.header), sizeof(FptIndexHeader));
240 >        _index.Read(pIndexstream);
241  
242 <        if(memcmp(&headercopy,&(_index.header),sizeof(FptIndexHeader)))
243 <        {
244 <                pIndexstream->seekg(_index.header.headerlength);//allows header length to be changed
242 >        _pFP = _index.CheckFP();        
243 >        if(!_pFP)
244 >                *(_index.header.datafilename) = '\0';
245  
246 <                unsigned int nwords = _index.header.nEntries * _index.header.words;
247 <                _index.fptdata.resize(nwords);
248 <                _index.seekdata.resize(_index.header.nEntries);
246 >        return _index.header.datafilename; //will be empty on error
247 > }
248 >
249 > //////////////////////////////////////////////////////////
250 > bool FptIndex::Read(istream* pIndexstream)
251 > {
252 >        pIndexstream->read((char*)&(header), sizeof(FptIndexHeader));
253 >        pIndexstream->seekg(header.headerlength);//allows header length to be changed
254 >        if(pIndexstream->fail() || header.headerlength != sizeof(FptIndexHeader))
255 >        {
256 >                *(header.datafilename) = '\0';
257 >                return false;
258 >        }
259  
260 <                pIndexstream->read((char*)&(_index.fptdata[0]), sizeof(unsigned int) * nwords);
261 <                pIndexstream->read((char*)&(_index.seekdata[0]), sizeof(unsigned int) * _index.header.nEntries);
262 <                
263 <                if(pIndexstream->fail())
264 <                        *(_index.header.datafilename) = '\0';
265 <                
266 <                string tempFP(_index.header.fpid);
267 <                _pFP = OBFingerprint::FindFingerprint(tempFP);
268 <                if(!_pFP)
269 <                {
270 < #ifdef HAVE_SSTREAM
271 <                  stringstream errorMsg;
272 < #else
273 <                  strstream errorMsg;
263 < #endif
264 <                  errorMsg << "Index has Fingerprints of type '" << _index.header.fpid
265 <                           << " which is not currently loaded." << endl;
266 <                  obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
267 <                  *(_index.header.datafilename) = '\0';
268 <                }
260 >        unsigned int nwords = header.nEntries * header.words;
261 >        fptdata.resize(nwords);
262 >        seekdata.resize(header.nEntries);
263 >
264 >        pIndexstream->read((char*)&(fptdata[0]), sizeof(unsigned int) * nwords);
265 >        pIndexstream->read((char*)&(seekdata[0]), sizeof(unsigned int) * header.nEntries);
266 >        
267 >        if(pIndexstream->fail())
268 >        {
269 >                *(header.datafilename) = '\0';
270 >                return false;
271 >        }
272 >        return true;
273 > }
274  
275 + //////////////////////////////////////////////////////////
276 + OBFingerprint* FptIndex::CheckFP()
277 + {
278 +        //check that fingerprint type is available
279 +        string tempFP(header.fpid);
280 +        OBFingerprint* pFP = OBFingerprint::FindFingerprint(tempFP);
281 +        if(!pFP)
282 +        {
283 +        #ifdef HAVE_SSTREAM
284 +                stringstream errorMsg;
285 +        #else
286 +                strstream errorMsg;
287 +        #endif
288 +                errorMsg << "Index has Fingerprints of type '" << header.fpid
289 +                         << " which is not currently loaded." << endl;
290 +                obErrorLog.ThrowError(__func__, errorMsg.str(), obError);
291          }
292 <        return _index.header.datafilename;
292 >        return pFP; //NULL if not available
293   }
294  
295   //*******************************************************
# Line 277 | Line 298 | FastSearchIndexer::FastSearchIndexer(string& datafilen
298   {
299          ///Starts indexing process
300          _indexstream = os;
280 –        _pFP = OBFingerprint::FindFingerprint(fpid);
281 –        if(!_pFP)
282 –          {
283 – #ifdef HAVE_SSTREAM
284 –            stringstream errorMsg;
285 – #else
286 –            strstream errorMsg;
287 – #endif
288 –            errorMsg << "Fingerprint type '" << fpid << "' not available" << endl;
289 –            obErrorLog.ThrowError(__FUNCTION__, errorMsg.str(), obWarning);
290 –          }
291 –
301          _nbits=FptBits;
302          _pindex= new FptIndex;
303          _pindex->header.headerlength = sizeof(FptIndexHeader);
304          strncpy(_pindex->header.fpid,fpid.c_str(),15);
305          strncpy(_pindex->header.datafilename, datafilename.c_str(), 255);
306 +
307 +        //check that fingerprint type is available
308 +        _pFP = _pindex->CheckFP();      
309 + }
310 +
311 + /////////////////////////////////////////////////////////////
312 + FastSearchIndexer::FastSearchIndexer(FptIndex* pindex, std::ostream* os)
313 + {
314 +        //Uses existing index
315 +        _indexstream = os;
316 +        _pindex = pindex;
317 +        _nbits  = _pindex->header.words * OBFingerprint::Getbitsperint();
318 +
319 +        //check that fingerprint type is available
320 +        _pFP = _pindex->CheckFP();      
321   }
322  
323   /////////////////////////////////////////////////////////////
# Line 305 | Line 329 | FastSearchIndexer::~FastSearchIndexer()
329          _indexstream->write((const char*)&_pindex->fptdata[0], _pindex->fptdata.size()*sizeof(unsigned int));
330          _indexstream->write((const char*)&_pindex->seekdata[0], _pindex->seekdata.size()*sizeof(unsigned int));
331          if(!_indexstream)
332 <          obErrorLog.ThrowError(__FUNCTION__,
332 >          obErrorLog.ThrowError(__func__,
333                                  "Difficulty writing index", obWarning);
334          delete _pindex;
335   }
# Line 326 | Line 350 | bool FastSearchIndexer::Add(OBBase* pOb, streampos see
350                  _pindex->seekdata.push_back(seekpos);
351                  return true;    
352          }
353 <        obErrorLog.ThrowError(__FUNCTION__, "Failed to make a fingerprint", obWarning);
353 >        obErrorLog.ThrowError(__func__, "Failed to make a fingerprint", obWarning);
354          return false;
331 –
355   }
356  
357   /*!

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines