RDKit: SubstructLibrary.h Source File

| RDKit Open-source cheminformatics and machine learning.

- Main Page
- Namespaces
- Classes
- Files

- File List
- File Members

SubstructLibrary.h
Go to the documentation of this file.
1 // Copyright (c) 2017, Novartis Institutes for BioMedical Research Inc.
2 // All rights reserved.
3 //
4 // Redistribution and use in source and binary forms, with or without
5 // modification, are permitted provided that the following conditions are
6 // met:
7 //
8 // * Redistributions of source code must retain the above copyright
9 // notice, this list of conditions and the following disclaimer.
10 // * Redistributions in binary form must reproduce the above
11 // copyright notice, this list of conditions and the following
12 // disclaimer in the documentation and/or other materials provided
13 // with the distribution.
14 // * Neither the name of Novartis Institutes for BioMedical Research Inc.
15 // nor the names of its contributors may be used to endorse or promote
16 // products derived from this software without specific prior written
17 // permission.
18 //
19 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 //
31 #ifndef RDKIT_SUBSTRUCT_LIBRARY
32 #define RDKIT_SUBSTRUCT_LIBRARY
33
34 #include <GraphMol/RDKitBase.h>
35 #include <GraphMol/MolPickler.h>
36 #include <GraphMol/SmilesParse/SmilesParse.h>
37 #include <GraphMol/SmilesParse/SmilesWrite.h>
38 #include <GraphMol/Fingerprints/Fingerprints.h>
39 #include <DataStructs/ExplicitBitVect.h>
40 #include <DataStructs/BitOps.h>
41
42 namespace RDKit {
43
44 //! Base class API for holding molecules so substructure search.
45 /*!
46 This is an API that hides the implementation details used for
47 indexing molecules for substructure searching. It simply
48 provides an API for adding and getting molecules from a set.
49 */
50 class MolHolderBase {
51 public:
52 virtual ~MolHolderBase() {}
53
54 //! Add a new molecule to the substructure search library
55 //! Returns the molecules index in the library
56 virtual unsigned int addMol( const ROMol &m ) = 0;
57
58 // implementations should throw IndexError on out of range
59 virtual boost::shared_ptr<ROMol> getMol(unsigned int) const = 0;
60
61 //! Get the current library size
62 virtual unsigned int size() const = 0;
63 };
64
65 //! Concrete class that holds molecules in memory
66 /*!
67 This is currently one of the faster implementations.
68 However it is very memory intensive.
69 */
70 class MolHolder : public MolHolderBase {
71 std::vector<boost::shared_ptr<ROMol> > mols;
72
73 public:
74 MolHolder() : MolHolderBase(), mols() {}
75
76 virtual unsigned int addMol(const ROMol &m) {
77 mols.push_back(boost::make_shared<ROMol>(m));
78 return size() - 1;
79 }
80
81 virtual boost::shared_ptr<ROMol> getMol(unsigned int idx) const {
82 if(idx >= mols.size())
83 throw IndexErrorException(idx);
84 return mols[idx];
85 }
86
87 virtual unsigned int size() const {
88 return rdcast<unsigned int>(mols.size());
89 }
90 };
91
92 //! Concrete class that holds binary cached molecules in memory
93 /*!
94 This implementation uses quite a bit less memory than the
95 non cached implementation. However, due to the reduced speed
96 it should be used in conjunction with a pattern fingerprinter.
97
98 See RDKit::FPHolder
99 */
100 class CachedMolHolder : public MolHolderBase {
101 std::vector<std::string> mols;
102
103 public:
104 CachedMolHolder() : MolHolderBase(), mols() {}
105
106 virtual unsigned int addMol(const ROMol &m) {
107 mols.push_back(std::string());
108 MolPickler::pickleMol(m, mols.back());
109 return size() - 1;
110 }
111
112 //! Adds a pickled binary molecule, no validity checking of the input
113 //! is done.
114 unsigned int addBinary(const std::string &pickle) {
115 mols.push_back( pickle );
116 return size()-1;
117 }
118
119 virtual boost::shared_ptr<ROMol> getMol(unsigned int idx) const {
120 if(idx >= mols.size())
121 throw IndexErrorException(idx);
122 boost::shared_ptr<ROMol> mol(new ROMol);
123 MolPickler::molFromPickle(mols[idx], mol.get());
124 return mol;
125 }
126
127 virtual unsigned int size() const {
128 return rdcast<unsigned int>(mols.size());
129 }
130 };
131
132 //! Concrete class that holds smiles strings in memory
133 /*!
134 This implementation uses quite a bit less memory than the
135 cached binary or uncached implementation. However, due to the
136 reduced speed it should be used in conjunction with a pattern
137 fingerprinter.
138
139 See RDKit::FPHolder
140 */
141 class CachedSmilesMolHolder : public MolHolderBase {
142 std::vector<std::string> mols;
143
144 public:
145 CachedSmilesMolHolder() : MolHolderBase(), mols() {}
146
147 virtual unsigned int addMol(const ROMol &m) {
148 bool doIsomericSmiles = true;
149 mols.push_back(MolToSmiles(m, doIsomericSmiles));
150 return size() - 1;
151 }
152
153 //! Add a smiles to the dataset, no validation is done
154 //! to the inputs.
155 unsigned int addSmiles( const std::string &smiles ) {
156 mols.push_back(smiles);
157 return size() - 1;
158 }
159
160 virtual boost::shared_ptr<ROMol> getMol(unsigned int idx) const {
161 if(idx >= mols.size())
162 throw IndexErrorException(idx);
163
164 boost::shared_ptr<ROMol> mol(SmilesToMol(mols[idx]));
165 return mol;
166 }
167
168 virtual unsigned int size() const {
169 return rdcast<unsigned int>(mols.size());
170 }
171 };
172
173 //! Concrete class that holds trusted smiles strings in memory
174 /*!
175 A trusted smiles is essentially a smiles string that
176 RDKit has generated. This indicates that fewer
177 sanitization steps are required. See
178 http://rdkit.blogspot.com/2016/09/avoiding-unnecessary-work-and.html
179
180 This implementation uses quite a bit less memory than the
181 cached binary or uncached implementation. However, due to the
182 reduced speed it should be used in conjunction with a pattern
183 fingerprinter.
184
185 See RDKit::FPHolder
186 */
187 class CachedTrustedSmilesMolHolder : public MolHolderBase {
188 std::vector<std::string> mols;
189
190 public:
191 CachedTrustedSmilesMolHolder() : MolHolderBase(), mols() {}
192
193 virtual unsigned int addMol(const ROMol &m) {
194 bool doIsomericSmiles = true;
195 mols.push_back(MolToSmiles(m, doIsomericSmiles));
196 return size() - 1;
197 }
198
199 //! Add a smiles to the dataset, no validation is done
200 //! to the inputs.
201 unsigned int addSmiles( const std::string &smiles ) {
202 mols.push_back(smiles);
203 return size() - 1;
204 }
205
206 virtual boost::shared_ptr<ROMol> getMol(unsigned int idx) const {
207 if(idx >= mols.size())
208 throw IndexErrorException(idx);
209
210 RWMol *m = SmilesToMol(mols[idx], 0, false);
211 m->updatePropertyCache();
212 return boost::shared_ptr<ROMol>(m);
213 }
214
215 virtual unsigned int size() const {
216 return rdcast<unsigned int>(mols.size());
217 }
218 };
219
220 //! Base FPI for the fingerprinter used to rule out impossible matches
221 class FPHolderBase {
222 std::vector<ExplicitBitVect *> fps;
223
224 public:
225 virtual ~FPHolderBase() {
226 for (size_t i = 0; i < fps.size(); ++i) delete fps[i];
227
228 }
229
230 //! Adds a molecule to the fingerprinter
231 unsigned int addMol( const ROMol &m) {
232 fps.push_back(makeFingerprint(m));
233 return rdcast<unsigned int>(fps.size() - 1);
234 }
235
236 //! Adds a raw bit vector to the fingerprinter
237 unsigned int addFingerprint( const ExplicitBitVect &v ) {
238 fps.push_back( new ExplicitBitVect(v) );
239 return rdcast<unsigned int>(fps.size() - 1);
240 }
241
242 //! Return false if a substructure search can never match the molecule
243 bool passesFilter(unsigned int idx, const ExplicitBitVect &query) const {
244 if(idx >= fps.size())
245 throw IndexErrorException(idx);
246
247 return AllProbeBitsMatch(query, *fps[idx]);
248 }
249
250 //! Get the bit vector at the specified index (throws IndexError if out of range)
251 const ExplicitBitVect &getFingerprint(unsigned int idx) const {
252 if(idx >= fps.size())
253 throw IndexErrorException(idx);
254 return *fps[idx];
255 }
256
257 //! make the query vector
258 //! Caller owns the vector!
259 virtual ExplicitBitVect *makeFingerprint(const ROMol &m) const = 0;
260 };
261
262 //! Uses the pattern fingerprinter to rule out matches
263 class PatternHolder : public FPHolderBase {
264 public:
265 //! Caller owns the vector!
266 virtual ExplicitBitVect *makeFingerprint(const ROMol &m) const {
267 return PatternFingerprintMol(m, 2048);
268 }
269 };
270
271 //! Substtructure Search a library of molecules
272 /*! This class allows for multithreaded substructure searches os
273 large datasets.
274
275 The implementations can use fingerprints to speed up searches
276 and have molecules cached as binary forms to reduce memory
277 usage.
278 */
279 class SubstructLibrary {
280 boost::shared_ptr<MolHolderBase> molholder;
281 boost::shared_ptr<FPHolderBase> fpholder;
282 MolHolderBase *mols; // used for a small optimization
283 FPHolderBase *fps;
284
285 public:
286 SubstructLibrary()
287 : molholder(new MolHolder),
288 fpholder(),
289 mols(molholder.get()),
290 fps(NULL) {}
291
292 SubstructLibrary(boost::shared_ptr<MolHolderBase> molecules)
293 : molholder(molecules), fpholder(), mols(molholder.get()), fps(0) {}
294
295 SubstructLibrary(boost::shared_ptr<MolHolderBase> molecules,
296 boost::shared_ptr<FPHolderBase> fingerprints)
297 : molholder(molecules),
298 fpholder(fingerprints),
299 mols(molholder.get()),
300 fps(fpholder.get()) {}
301
302 //!Get the underlying molecule holder implementation
303 MolHolderBase & getMolHolder() {
304 PRECONDITION(mols, "Molecule holder NULL in SubstructLibrary");
305 return *mols;
306 }
307
308 const MolHolderBase & getMolecules() const {
309 PRECONDITION(mols, "Molecule holder NULL in SubstructLibrary");
310 return *mols;
311 }
312
313 //!Get the underlying fingerprint implementation.
314 /*! Throws a value error if no fingerprints have been set */
315 FPHolderBase & getFingerprints() {
316 if (!fps)
317 throw ValueErrorException("Substruct Library does not have fingerprints");
318 return *fps;
319 }
320
321 const FPHolderBase & getFingerprints() const {
322 if (!fps)
323 throw ValueErrorException("Substruct Library does not have fingerprints");
324 return *fps;
325 }
326
327 //! Add a molecule to the library
328 /*!
329 \param mol Molecule to add
330
331 returns index for the molecule in the library
332 */
333 unsigned int addMol(const ROMol &mol);
334
335 //! Get the matching indices for the query
336 /*!
337 \param query Query to match against molecules
338 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
339 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
340 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
341 will be used as part of the matching
342 \param numThreads If -1 use all available processors [default -1]
343 \param maxResults Maximum results to return, -1 means return all [default
344 -1]
345 */
346 std::vector<unsigned int> getMatches(const ROMol &query,
347 bool recursionPossible=true,
348 bool useChirality=true,
349 bool useQueryQueryMatches=false,
350 int numThreads=-1,
351 int maxResults=-1);
352 //!Get the matching indices for the query between the given indices
353 /*!
354 \param query Query to match against molecules
355 \param startIdx Start index of the search
356 \param endIdx Ending idx (non-inclusive) of the search.
357 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
358 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
359 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
360 will be used as part of the matching
361 \param numThreads If -1 use all available processors [default -1]
362 \param maxResults Maximum results to return, -1 means return all [default
363 -1]
364 */
365 std::vector<unsigned int> getMatches(const ROMol &query,
366 unsigned int startIdx, unsigned int endIdx,
367 bool recursionPossible=true,
368 bool useChirality=true,
369 bool useQueryQueryMatches=false,
370 int numThreads=-1,
371 int maxResults=-1);
372
373 //! Return the number of matches for the query
374 /*!
375 \param query Query to match against molecules
376 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
377 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
378 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
379 will be used as part of the matching
380 \param numThreads If -1 use all available processors [default -1]
381 */
382 unsigned int countMatches(const ROMol &query,
383 bool recursionPossible=true,
384 bool useChirality=true,
385 bool useQueryQueryMatches=false,
386 int numThreads=-1);
387 //!Return the number of matches for the query between the given indices
388 /*!
389 \param query Query to match against molecules
390 \param startIdx Start index of the search
391 \param endIdx Ending idx (non-inclusive) of the search.
392 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
393 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
394 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
395 will be used as part of the matching
396 \param numThreads If -1 use all available processors [default -1]
397 */
398 unsigned int countMatches(const ROMol &query,
399 unsigned int startIdx, unsigned int endIdx,
400 bool recursionPossible=true,
401 bool useChirality=true,
402 bool useQueryQueryMatches=false,
403 int numThreads=-1);
404
405 //! Returns true if any match exists for the query
406 /*!
407 \param query Query to match against molecules
408 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
409 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
410 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
411 will be used as part of the matching
412 \param numThreads If -1 use all available processors [default -1]
413 */
414 bool hasMatch(const ROMol &query,
415 bool recursionPossible=true,
416 bool useChirality=true,
417 bool useQueryQueryMatches=false,
418 int numThreads=-1);
419 //! Returns true if any match exists for the query between the specified indices
420 /*!
421 \param query Query to match against molecules
422 \param startIdx Start index of the search
423 \param endIdx Ending idx (inclusive) of the search.
424 \param recursionPossible flags whether or not recursive matches are allowed [ default true ]
425 \param useChirality use atomic CIP codes as part of the comparison [ default true ]
426 \param useQueryQueryMatches if set, the contents of atom and bond queries [ default false ]
427 will be used as part of the matching
428 \param numThreads If -1 use all available processors [default -1]
429 */
430 bool hasMatch(const ROMol &query,
431 unsigned int startIdx, unsigned int endIdx,
432 bool recursionPossible=true,
433 bool useChirality=true,
434 bool useQueryQueryMatches=false,
435 int numThreads=-1);
436
437 //! Returns the molecule at the given index
438 /*!
439 \param idx Index of the molecule in the library
440 */
441 boost::shared_ptr<ROMol> getMol(unsigned int idx) const {
442 // expects implementation to throw IndexError if out of range
443 PRECONDITION(mols, "molholder is null in SubstructLibrary");
444 return mols->getMol(idx);
445 }
446
447 //! Returns the molecule at the given index
448 /*!
449 \param idx Index of the molecule in the library
450 */
451 boost::shared_ptr<ROMol> operator[] (unsigned int idx) {
452 // expects implementation to throw IndexError if out of range
453 PRECONDITION(mols, "molholder is null in SubstructLibrary");
454 return mols->getMol(idx);
455 }
456
457 //! return the number of molecules in the library
458 unsigned int size() const {
459 PRECONDITION(mols, "molholder is null in SubstructLibrary");
460 return rdcast<unsigned int>(molholder->size());
461 }
462 };
463 }
464
465 #endif
RDKit::MolHolder::getMol
virtual boost::shared_ptr< ROMol > getMol(unsigned int idx) const
Definition: SubstructLibrary.h:81
RDKit::SubstructLibrary::SubstructLibrary
SubstructLibrary(boost::shared_ptr< MolHolderBase > molecules, boost::shared_ptr< FPHolderBase > fingerprints)
Definition: SubstructLibrary.h:295
RDKit::CachedTrustedSmilesMolHolder::size
virtual unsigned int size() const
Get the current library size.
Definition: SubstructLibrary.h:215
RDKit::MolPickler::pickleMol
static void pickleMol(const ROMol *mol, std::ostream &ss)
pickles a molecule and sends the results to stream ss
RDKit::FPHolderBase::passesFilter
bool passesFilter(unsigned int idx, const ExplicitBitVect &query) const
Return false if a substructure search can never match the molecule.
Definition: SubstructLibrary.h:243
RDKit::SubstructLibrary::getMolHolder
MolHolderBase & getMolHolder()
Get the underlying molecule holder implementation.
Definition: SubstructLibrary.h:303
RDKit::RWMol
RWMol is a molecule class that is intended to be edited.
Definition: RWMol.h:30
RDKit::MolToSmiles
std::string MolToSmiles(const ROMol &mol, bool doIsomericSmiles=false, bool doKekule=false, int rootedAtAtom=-1, bool canonical=true, bool allBondsExplicit=false, bool allHsExplicit=false)
returns canonical SMILES for a molecule
SmilesWrite.h
SmilesParse.h
RDKit::MolHolder
Concrete class that holds molecules in memory.
Definition: SubstructLibrary.h:70
RDKit::CachedMolHolder::addMol
virtual unsigned int addMol(const ROMol &m)
Definition: SubstructLibrary.h:106
RDKit::CachedTrustedSmilesMolHolder
Concrete class that holds trusted smiles strings in memory.
Definition: SubstructLibrary.h:187
RDKitBase.h
pulls in the core RDKit functionality
RDKit::ROMol
ROMol is a molecule class that is intended to have a fixed topology.
Definition: ROMol.h:103
ExplicitBitVect.h
RDKit::CachedTrustedSmilesMolHolder::getMol
virtual boost::shared_ptr< ROMol > getMol(unsigned int idx) const
Definition: SubstructLibrary.h:206
RDKit::SubstructLibrary::getFingerprints
const FPHolderBase & getFingerprints() const
Definition: SubstructLibrary.h:321
RDKit::CachedSmilesMolHolder::addMol
virtual unsigned int addMol(const ROMol &m)
Definition: SubstructLibrary.h:147
RDKit::FPHolderBase::addMol
unsigned int addMol(const ROMol &m)
Adds a molecule to the fingerprinter.
Definition: SubstructLibrary.h:231
RDKit::FPHolderBase
Base FPI for the fingerprinter used to rule out impossible matches.
Definition: SubstructLibrary.h:221
RDKit::PatternHolder::makeFingerprint
virtual ExplicitBitVect * makeFingerprint(const ROMol &m) const
Caller owns the vector!
Definition: SubstructLibrary.h:266
RDKit::MolHolderBase::getMol
virtual boost::shared_ptr< ROMol > getMol(unsigned int) const =0
RDKit::CachedTrustedSmilesMolHolder::addMol
virtual unsigned int addMol(const ROMol &m)
Definition: SubstructLibrary.h:193
RDKit::CachedMolHolder::CachedMolHolder
CachedMolHolder()
Definition: SubstructLibrary.h:104
RDKit::ROMol::updatePropertyCache
void updatePropertyCache(bool strict=true)
calculates any of our lazy properties
RDKit::SmilesToMol
RWMol * SmilesToMol(const std::string &smi, const SmilesParserParams &params)
RDKit::PatternFingerprintMol
ExplicitBitVect * PatternFingerprintMol(const ROMol &mol, unsigned int fpSize=2048, std::vector< unsigned int > *atomCounts=0, ExplicitBitVect *setOnlyBits=0)
Generates a topological fingerprint for a molecule using a series of pre-defined structural patterns...
RDKit
Std stuff.
Definition: Atom.h:29
RDKit::SubstructLibrary::SubstructLibrary
SubstructLibrary(boost::shared_ptr< MolHolderBase > molecules)
Definition: SubstructLibrary.h:292
RDKit::CachedSmilesMolHolder::CachedSmilesMolHolder
CachedSmilesMolHolder()
Definition: SubstructLibrary.h:145
IndexErrorException
Class to allow us to throw an IndexError from C++ and have it make it back to Python.
Definition: Exceptions.h:18
Fingerprints.h
RDKit::MolHolder::MolHolder
MolHolder()
Definition: SubstructLibrary.h:74
RDKit::MolHolderBase
Base class API for holding molecules so substructure search.
Definition: SubstructLibrary.h:50
MolPickler.h
RDKit::SubstructLibrary::getMol
boost::shared_ptr< ROMol > getMol(unsigned int idx) const
Returns the molecule at the given index.
Definition: SubstructLibrary.h:441
RDKit::CachedMolHolder::size
virtual unsigned int size() const
Get the current library size.
Definition: SubstructLibrary.h:127
RDKit::MolHolderBase::addMol
virtual unsigned int addMol(const ROMol &m)=0
RDKit::SubstructLibrary::size
unsigned int size() const
return the number of molecules in the library
Definition: SubstructLibrary.h:458
RDKit::CachedTrustedSmilesMolHolder::CachedTrustedSmilesMolHolder
CachedTrustedSmilesMolHolder()
Definition: SubstructLibrary.h:191
RDKit::CachedSmilesMolHolder::addSmiles
unsigned int addSmiles(const std::string &smiles)
Definition: SubstructLibrary.h:155
RDKit::CachedSmilesMolHolder::getMol
virtual boost::shared_ptr< ROMol > getMol(unsigned int idx) const
Definition: SubstructLibrary.h:160
BitOps.h
Contains general bit-comparison and similarity operations.
RDKit::SubstructLibrary::SubstructLibrary
SubstructLibrary()
Definition: SubstructLibrary.h:286
RDKit::CachedTrustedSmilesMolHolder::addSmiles
unsigned int addSmiles(const std::string &smiles)
Definition: SubstructLibrary.h:201
RDKit::CachedSmilesMolHolder::size
virtual unsigned int size() const
Get the current library size.
Definition: SubstructLibrary.h:168
RDKit::MolPickler::molFromPickle
static void molFromPickle(const std::string &pickle, ROMol *mol)
constructs a molecule from a pickle stored in a string
RDKit::CachedMolHolder::addBinary
unsigned int addBinary(const std::string &pickle)
Definition: SubstructLibrary.h:114
RDKit::CachedMolHolder
Concrete class that holds binary cached molecules in memory.
Definition: SubstructLibrary.h:100
RDKit::FPHolderBase::getFingerprint
const ExplicitBitVect & getFingerprint(unsigned int idx) const
Get the bit vector at the specified index (throws IndexError if out of range)
Definition: SubstructLibrary.h:251
PRECONDITION
#define PRECONDITION(expr, mess)
Definition: Invariant.h:107
RDKit::SubstructLibrary::getMolecules
const MolHolderBase & getMolecules() const
Definition: SubstructLibrary.h:308
RDKit::PatternHolder
Uses the pattern fingerprinter to rule out matches.
Definition: SubstructLibrary.h:263
RDKit::MolHolder::addMol
virtual unsigned int addMol(const ROMol &m)
Definition: SubstructLibrary.h:76
RDKit::FPHolderBase::addFingerprint
unsigned int addFingerprint(const ExplicitBitVect &v)
Adds a raw bit vector to the fingerprinter.
Definition: SubstructLibrary.h:237
AllProbeBitsMatch
bool AllProbeBitsMatch(const char *probe, const char *ref)
ValueErrorException
Class to allow us to throw a ValueError from C++ and have it make it back to Python.
Definition: Exceptions.h:32
RDKit::CachedMolHolder::getMol
virtual boost::shared_ptr< ROMol > getMol(unsigned int idx) const
Definition: SubstructLibrary.h:119
RDKit::FPHolderBase::~FPHolderBase
virtual ~FPHolderBase()
Definition: SubstructLibrary.h:225
ExplicitBitVect
a class for bit vectors that are densely occupied
Definition: ExplicitBitVect.h:28
RDKit::MolHolderBase::size
virtual unsigned int size() const =0
Get the current library size.
RDKit::SubstructLibrary::getFingerprints
FPHolderBase & getFingerprints()
Get the underlying fingerprint implementation.
Definition: SubstructLibrary.h:315
RDKit::MolHolder::size
virtual unsigned int size() const
Get the current library size.
Definition: SubstructLibrary.h:87
RDKit::CachedSmilesMolHolder
Concrete class that holds smiles strings in memory.
Definition: SubstructLibrary.h:141
RDKit::MolHolderBase::~MolHolderBase
virtual ~MolHolderBase()
Definition: SubstructLibrary.h:52
RDKit::SubstructLibrary
Substtructure Search a library of molecules.
Definition: SubstructLibrary.h:279
RDKit::EnumerationStrategyPickler::pickle
void pickle(const boost::shared_ptr< EnumerationStrategyBase > &enumerator, std::ostream &ss)
pickles a EnumerationStrategy and adds the results to a stream ss