RDKit
Open-source cheminformatics and machine learning.
QueryOps.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2003-2010 Greg Landrum and Rational Discovery LLC
3 //
4 // @@ All Rights Reserved @@
5 // This file is part of the RDKit.
6 // The contents are covered by the terms of the BSD license
7 // which is included in the file license.txt, found at the root
8 // of the RDKit source tree.
9 //
10 
11 //! \file QueryOps.h
12 /*!
13  \brief Includes a bunch of functionality for handling Atom and Bond queries.
14 */
15 #ifndef _RD_QUERY_OPS_H
16 #define _RD_QUERY_OPS_H
17 
18 #include <GraphMol/RDKitBase.h>
19 #include <Query/QueryObjects.h>
20 #include <Query/Query.h>
21 
22 #ifdef RDK_THREADSAFE_SSS
23 #include <boost/thread/mutex.hpp>
24 #endif
25 
26 namespace RDKit{
29 
32 
35 
38 
41 
44 
47 
50 
53 
56 
59 
62 
63  // -------------------------------------------------
64  // common atom queries
65 
66  static int queryAtomAromatic(Atom const * at) { return at->getIsAromatic(); };
67  static int queryAtomAliphatic(Atom const * at) { return !(at->getIsAromatic()); };
68  static int queryAtomExplicitDegree(Atom const * at) { return at->getDegree(); };
69  static int queryAtomTotalDegree(Atom const * at) { return at->getTotalDegree(); };
70  static int queryAtomHeavyAtomDegree(Atom const * at) { return at->getTotalDegree()-at->getTotalNumHs(true); };
71  static int queryAtomHCount(Atom const * at) { return at->getTotalNumHs(true); };
72  static int queryAtomImplicitHCount(Atom const * at) { return at->getTotalNumHs(false); };
73  static int queryAtomHasImplicitH(Atom const * at) { return int(at->getTotalNumHs(false)>0); };
74  static int queryAtomImplicitValence(Atom const * at) { return at->getImplicitValence(); };
75  static int queryAtomExplicitValence(Atom const * at) { return at->getExplicitValence() - at->getNumExplicitHs(); };
76  static int queryAtomTotalValence(Atom const * at) { return at->getExplicitValence()+at->getImplicitValence(); };
77  static int queryAtomUnsaturated(Atom const * at) { return static_cast<int>(at->getDegree())<at->getExplicitValence(); };
78  static int queryAtomNum(Atom const * at) { return at->getAtomicNum(); };
79  static int massIntegerConversionFactor=1000;
80  static int queryAtomMass(Atom const * at) {
81  return static_cast<int>(round(massIntegerConversionFactor*at->getMass()));
82  };
83  static int queryAtomIsotope(Atom const * at) {
84  return static_cast<int>(at->getIsotope());
85  };
86  static int queryAtomFormalCharge(Atom const * at) {
87  return static_cast<int>(at->getFormalCharge());
88  };
89  static int queryAtomHybridization(Atom const * at) { return at->getHybridization(); };
90  unsigned int queryAtomBondProduct(Atom const * at);
91  unsigned int queryAtomAllBondProduct(Atom const * at);
92 
93 
94  // -------------------------------------------------
95  // common bond queries
96 
97  static int queryBondOrder(Bond const * bond) { return static_cast<int>(bond->getBondType()); };
98  static int queryBondDir(Bond const * bond) { return static_cast<int>(bond->getBondDir()); };
99  static int queryIsBondInNRings(Bond const * at) {
100  return at->getOwningMol().getRingInfo()->numBondRings(at->getIdx());
101  };
102 
103  // -------------------------------------------------
104  // ring queries
105 
106  static int queryIsAtomInNRings(Atom const * at) {
107  return at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx());
108  };
109  static int queryIsAtomInRing(Atom const * at) {
110  return at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx())!=0;
111  };
112  static int queryAtomHasRingBond(Atom const * at) {
113  ROMol::OBOND_ITER_PAIR atomBonds=at->getOwningMol().getAtomBonds(at);
114  while(atomBonds.first != atomBonds.second){
115  unsigned int bondIdx=at->getOwningMol().getTopology()[*atomBonds.first]->getIdx();
116  if(at->getOwningMol().getRingInfo()->numBondRings(bondIdx)) {
117  return 1;
118  }
119  ++atomBonds.first;
120  }
121  return 0;
122  };
123  static int queryIsBondInRing(Bond const * bond) {
124  return bond->getOwningMol().getRingInfo()->numBondRings(bond->getIdx())!=0;
125  };
126  static int queryAtomMinRingSize(Atom const *at){
127  return at->getOwningMol().getRingInfo()->minAtomRingSize(at->getIdx());
128  };
129  static int queryBondMinRingSize(Bond const *bond){
130  return bond->getOwningMol().getRingInfo()->minBondRingSize(bond->getIdx());
131  };
132 
133  static int queryAtomRingBondCount(Atom const *at) {
134  // EFF: cache this result
135  int res=0;
136  ROMol::OBOND_ITER_PAIR atomBonds=at->getOwningMol().getAtomBonds(at);
137  while(atomBonds.first != atomBonds.second){
138  unsigned int bondIdx=at->getOwningMol().getTopology()[*atomBonds.first]->getIdx();
139  if(at->getOwningMol().getRingInfo()->numBondRings(bondIdx)) {
140  res++;
141  }
142  ++atomBonds.first;
143  }
144  return res;
145  }
146 
147  template <int tgt>
148  int queryAtomIsInRingOfSize(Atom const *at) {
149  if(at->getOwningMol().getRingInfo()->isAtomInRingOfSize(at->getIdx(),tgt)){
150  return tgt;
151  } else {
152  return 0;
153  }
154  };
155  template <int tgt>
156  int queryBondIsInRingOfSize(Bond const *bond) {
157  if(bond->getOwningMol().getRingInfo()->isBondInRingOfSize(bond->getIdx(),tgt)){
158  return tgt;
159  } else {
160  return 0;
161  }
162  };
163 
164 
165  template <class T>
166  T *makeAtomSimpleQuery(int what,int func(Atom const *),const std::string &description="Atom Simple"){
167  T *res = new T;
168  res->setVal(what);
169  res->setDataFunc(func);
170  res->setDescription(description);
171  return res;
172  }
173 
174 
175  //! returns a Query for matching atomic number
176  template <class T>
177  T *makeAtomNumQuery(int what,const std::string &descr){
178  return makeAtomSimpleQuery<T>(what,queryAtomNum,descr);
179  }
180  //! \overload
181  ATOM_EQUALS_QUERY *makeAtomNumQuery(int what);
182 
183  //! returns a Query for matching implicit valence
184  template <class T>
185  T *makeAtomImplicitValenceQuery(int what,const std::string &descr){
186  return makeAtomSimpleQuery<T>(what,queryAtomImplicitValence,descr);
187  }
188  //! \overload
189  ATOM_EQUALS_QUERY *makeAtomImplicitValenceQuery(int what);
190 
191  //! returns a Query for matching explicit valence
192  template <class T>
193  T *makeAtomExplicitValenceQuery(int what,const std::string &descr){
194  return makeAtomSimpleQuery<T>(what,queryAtomExplicitValence,descr);
195  }
196  //! \overload
197  ATOM_EQUALS_QUERY *makeAtomExplicitValenceQuery(int what);
198 
199  //! returns a Query for matching total valence
200  template <class T>
201  T *makeAtomTotalValenceQuery(int what,const std::string &descr){
202  return makeAtomSimpleQuery<T>(what,queryAtomTotalValence,descr);
203  }
204  //! \overload
205  ATOM_EQUALS_QUERY *makeAtomTotalValenceQuery(int what);
206 
207  //! returns a Query for matching explicit degree
208  template <class T>
209  T *makeAtomExplicitDegreeQuery(int what,const std::string &descr){
210  return makeAtomSimpleQuery<T>(what,queryAtomExplicitDegree,descr);
211  }
212  //! \overload
213  ATOM_EQUALS_QUERY *makeAtomExplicitDegreeQuery(int what);
214 
215  //! returns a Query for matching atomic degree
216  template <class T>
217  T *makeAtomTotalDegreeQuery(int what,const std::string &descr){
218  return makeAtomSimpleQuery<T>(what,queryAtomTotalDegree,descr);
219  }
220  //! \overload
221  ATOM_EQUALS_QUERY *makeAtomTotalDegreeQuery(int what);
222 
223  //! returns a Query for matching hydrogen count
224  template <class T>
225  T *makeAtomHCountQuery(int what,const std::string &descr){
226  return makeAtomSimpleQuery<T>(what,queryAtomHCount,descr);
227  }
228  //! \overload
229  ATOM_EQUALS_QUERY *makeAtomHCountQuery(int what);
230 
231  //! returns a Query for matching ring atoms
232  template <class T>
233  T *makeAtomHasImplicitHQuery(const std::string &descr){
234  return makeAtomSimpleQuery<T>(true,queryAtomHasImplicitH,descr);
235  }
236  //! \overload
237  ATOM_EQUALS_QUERY *makeAtomHasImplicitHQuery();
238 
239 
240  //! returns a Query for matching implicit hydrogen count
241  template <class T>
242  T *makeAtomImplicitHCountQuery(int what,const std::string &descr){
243  return makeAtomSimpleQuery<T>(what,queryAtomImplicitHCount,descr);
244  }
245  //! \overload
246  ATOM_EQUALS_QUERY *makeAtomImplicitHCountQuery(int what);
247 
248  //! returns a Query for matching the \c isAromatic flag
249  template <class T>
250  T *makeAtomAromaticQuery(const std::string &descr){
251  return makeAtomSimpleQuery<T>(true,queryAtomAromatic,descr);
252  }
253  //! \overload
254  ATOM_EQUALS_QUERY *makeAtomAromaticQuery();
255 
256  //! returns a Query for matching aliphatic atoms
257  template <class T>
258  T *makeAtomAliphaticQuery(const std::string &descr){
259  return makeAtomSimpleQuery<T>(true,queryAtomAliphatic,descr);
260  }
261  //! \overload
262  ATOM_EQUALS_QUERY *makeAtomAliphaticQuery();
263 
264  //! returns a Query for matching atoms with a particular mass
265  template <class T>
266  T *makeAtomMassQuery(int what,const std::string &descr){
267  return makeAtomSimpleQuery<T>(massIntegerConversionFactor*what,queryAtomMass,descr);
268  }
269  //! \overload
270  ATOM_EQUALS_QUERY *makeAtomMassQuery(int what);
271 
272  //! returns a Query for matching atoms with a particular isotope
273  template <class T>
274  T *makeAtomIsotopeQuery(int what,const std::string &descr){
275  return makeAtomSimpleQuery<T>(what,queryAtomIsotope,descr);
276  }
277  //! \overload
278  ATOM_EQUALS_QUERY *makeAtomIsotopeQuery(int what);
279 
280  //! returns a Query for matching formal charge
281  template <class T>
282  T *makeAtomFormalChargeQuery(int what,const std::string &descr){
283  return makeAtomSimpleQuery<T>(what,queryAtomFormalCharge,descr);
284  }
285  //! \overload
286  ATOM_EQUALS_QUERY *makeAtomFormalChargeQuery(int what);
287 
288  //! returns a Query for matching hybridization
289  template <class T>
290  T *makeAtomHybridizationQuery(int what,const std::string &descr){
291  return makeAtomSimpleQuery<T>(what,queryAtomHybridization,descr);
292  }
293  //! \overload
294  ATOM_EQUALS_QUERY *makeAtomHybridizationQuery(int what);
295 
296  //! returns a Query for matching atoms with unsaturation:
297  template <class T>
298  T *makeAtomUnsaturatedQuery(const std::string &descr){
299  return makeAtomSimpleQuery<T>(true,queryAtomUnsaturated,descr);
300  }
301  //! \overload
302  ATOM_EQUALS_QUERY *makeAtomUnsaturatedQuery();
303 
304 
305  //! returns a Query for matching ring atoms
306  template <class T>
307  T *makeAtomInRingQuery(const std::string &descr){
308  return makeAtomSimpleQuery<T>(true,queryIsAtomInRing,descr);
309  }
310  //! \overload
311  ATOM_EQUALS_QUERY *makeAtomInRingQuery();
312 
313  //! returns a Query for matching atoms in a particular number of rings
314  template <class T>
315  T *makeAtomInNRingsQuery(int what,const std::string &descr){
316  return makeAtomSimpleQuery<T>(what,queryIsAtomInNRings,descr);
317  }
318  //! \overload
319  ATOM_EQUALS_QUERY *makeAtomInNRingsQuery(int what);
320 
321  //! returns a Query for matching atoms in rings of a particular size
322  ATOM_EQUALS_QUERY *makeAtomInRingOfSizeQuery(int tgt);
323 
324  //! returns a Query for matching an atom's minimum ring size
325  template <class T>
326  T *makeAtomMinRingSizeQuery(int tgt,const std::string &descr){
327  return makeAtomSimpleQuery<T>(tgt,queryAtomMinRingSize,descr);
328  }
329  //! \overload
330  ATOM_EQUALS_QUERY *makeAtomMinRingSizeQuery(int tgt);
331 
332  //! returns a Query for matching atoms with a particular number of ring bonds
333  template <class T>
334  T *makeAtomRingBondCountQuery(int what,const std::string &descr){
335  return makeAtomSimpleQuery<T>(what,queryAtomRingBondCount,descr);
336  }
337  //! \overload
338  ATOM_EQUALS_QUERY *makeAtomRingBondCountQuery(int what);
339 
340  //! returns a Query for matching atoms with a particular number of ring bonds
341  template <class T>
342  T *makeAtomHasRingBondQuery(const std::string &descr){
343  return makeAtomSimpleQuery<T>(1,queryAtomHasRingBond,descr);
344  }
345  //! \overload
346  ATOM_EQUALS_QUERY *makeAtomHasRingBondQuery();
347 
348  //! returns a Query for matching bond orders
349  BOND_EQUALS_QUERY *makeBondOrderEqualsQuery(Bond::BondType what);
350  //! returns a Query for matching bond directions
351  BOND_EQUALS_QUERY *makeBondDirEqualsQuery(Bond::BondDir what);
352  //! returns a Query for matching ring bonds
353  BOND_EQUALS_QUERY *makeBondIsInRingQuery();
354  //! returns a Query for matching bonds in rings of a particular size
355  BOND_EQUALS_QUERY *makeBondInRingOfSizeQuery(int what);
356  //! returns a Query for matching a bond's minimum ring size
357  BOND_EQUALS_QUERY *makeBondMinRingSizeQuery(int what);
358  //! returns a Query for matching bonds in a particular number of rings
359  BOND_EQUALS_QUERY *makeBondInNRingsQuery(int tgt);
360 
361  //! returns a Query for matching any bond
362  BOND_NULL_QUERY *makeBondNullQuery();
363  //! returns a Query for matching any atom
364  ATOM_NULL_QUERY *makeAtomNullQuery();
365 
366  static int queryAtomRingMembership(Atom const *at) {
367  return static_cast<int>(at->getOwningMol().getRingInfo()->numAtomRings(at->getIdx()));
368  }
369  // I'm pretty sure that this typedef shouldn't be necessary,
370  // but VC++ generates a warning about const Atom const * in
371  // the definition of Match, then complains about an override
372  // that differs only by const/volatile (c4301), then generates
373  // incorrect code if we don't do this... so let's do it.
374  typedef Atom const *ConstAtomPtr;
375 
376  class AtomRingQuery : public Queries::EqualityQuery<int, ConstAtomPtr,true> {
377  public:
378  AtomRingQuery() : Queries::EqualityQuery<int,ConstAtomPtr,true>(-1) {
379  // default is to just do a number of rings query:
380  this->setDescription("AtomInNRings");
382  };
383  explicit AtomRingQuery(int v) : Queries::EqualityQuery<int,ConstAtomPtr,true>(v) {
384  // default is to just do a number of rings query:
385  this->setDescription("AtomInNRings");
387  };
388 
389  virtual bool Match(const ConstAtomPtr what) const {
390  int v = this->TypeConvert(what,Queries::Int2Type<true>());
391  bool res;
392  if(this->d_val<0){
393  res = v!=0;
394  } else {
395  res=!Queries::queryCmp(v,this->d_val,this->d_tol);
396  }
397  if(this->getNegation()){
398  res=!res;
399  }
400  return res;
401  }
402 
403  //! returns a copy of this query
405  copy() const {
406  AtomRingQuery *res = new AtomRingQuery(this->d_val);
407  res->setNegation(getNegation());
408  res->setTol(this->getTol());
409  res->d_description = this->d_description;
410  res->d_dataFunc = this->d_dataFunc;
411  return res;
412  }
413  };
414 
415  //! allows use of recursive structure queries (e.g. recursive SMARTS)
416  class RecursiveStructureQuery : public Queries::SetQuery<int,Atom const *,true> {
417  public:
419  Queries::SetQuery<int,Atom const *,true>(),
420  d_serialNumber(0)
421  {
422  setDataFunc(getAtIdx);
423  setDescription("RecursiveStructure");
424  };
425  //! initialize from an ROMol pointer
426  /*!
427  <b>Notes</b>
428  - this takes over ownership of the pointer
429  */
430  RecursiveStructureQuery(ROMol const *query,unsigned int serialNumber=0) :
431  Queries::SetQuery<int,Atom const *,true>(),
432  d_serialNumber(serialNumber)
433  {
434  setQueryMol(query);
435  setDataFunc(getAtIdx);
436  setDescription("RecursiveStructure");
437  };
438  //! returns the index of an atom
439  static int getAtIdx(Atom const *at) {
440  PRECONDITION(at,"bad atom argument");
441  return at->getIdx();
442  };
443 
444  //! sets the molecule we'll use recursively
445  /*!
446  <b>Notes</b>
447  - this takes over ownership of the pointer
448  */
449  void setQueryMol(ROMol const *query) {
450  dp_queryMol.reset(query);
451  }
452  //! returns a pointer to our query molecule
453  ROMol const * getQueryMol() const { return dp_queryMol.get(); };
454 
455  //! returns a copy of this query
457  copy() const {
460  res->dp_queryMol.reset(new ROMol(*dp_queryMol,true));
461 
462  std::set<int>::const_iterator i;
463  for(i=d_set.begin();i!=d_set.end();i++){
464  res->insert(*i);
465  }
466  res->setNegation(getNegation());
468  res->d_serialNumber=d_serialNumber;
469  return res;
470  }
471  unsigned int getSerialNumber() const { return d_serialNumber; };
472 
473 #ifdef RDK_THREADSAFE_SSS
474  boost::mutex d_mutex;
475 #endif
476  private:
477  boost::shared_ptr<const ROMol>dp_queryMol;
478  unsigned int d_serialNumber;
479  };
480 
481  template <typename T>
482  int nullDataFun(T arg) { return 1; }
483  template <typename T>
484  bool nullQueryFun(T arg) { return true; }
485 
486  typedef Bond const *ConstBondPtr;
487 
488  // ! Query whether an atom has a property
489  template<class TargetPtr>
491  int, TargetPtr, true> {
492 
493  std::string propname;
494  public:
496  Queries::EqualityQuery<int,TargetPtr,true>(),
497  propname() {
498  // default is to just do a number of rings query:
499  this->setDescription("AtomHasProp");
500  this->setDataFunc(0);
501  };
502  explicit HasPropQuery(const std::string & v) :
503  Queries::EqualityQuery<int,TargetPtr,true>(),
504  propname(v) {
505  // default is to just do a number of rings query:
506  this->setDescription("AtomHasProp");
507  this->setDataFunc(0);
508  };
509 
510  virtual bool Match(const TargetPtr what) const {
511  bool res = what->hasProp(propname);
512  if(this->getNegation()){
513  res=!res;
514  }
515  return res;
516  }
517 
518  //! returns a copy of this query
520  copy() const {
521  HasPropQuery *res = new HasPropQuery(this->propname);
522  res->setNegation(this->getNegation());
523  res->d_description = this->d_description;
524  return res;
525  }
526  };
527 
528  typedef Queries::EqualityQuery<
529  int,Atom const *,true> ATOM_PROP_QUERY;
530  typedef Queries::EqualityQuery<
531  int,Bond const *,true> BOND_PROP_QUERY;
532 
533  //! returns a Query for matching atoms that have a particular property
534  template<class Target>
536  const std::string &property)
537  {
538  return new HasPropQuery<const Target *>(property);
539  }
540 
541  // ! Query whether an atom has a property with a value
542  template<class TargetPtr, class T>
544  int, TargetPtr, true> {
545  std::string propname;
546  T val;
547  T tolerance;
548  public:
550  Queries::EqualityQuery<int,TargetPtr,true>(),
551  propname(), val() {
552  // default is to just do a number of rings query:
553  this->setDescription("HasPropWithValue");
554  this->setDataFunc(0);
555  };
556  explicit HasPropWithValueQuery(const std::string & prop, const T&v,
557  const T&tol=0.0) :
558  Queries::EqualityQuery<int,TargetPtr,true>(),
559  propname(prop),
560  val(v),
561  tolerance(tol) {
562  // default is to just do a number of rings query:
563  this->setDescription("HasPropWithValue");
564  this->setDataFunc(0);
565  };
566 
567  virtual bool Match(const TargetPtr what) const {
568  bool res = what->hasProp(propname);
569  if (res)
570  {
571  try {
572  T atom_val = what->template getProp<T>(propname);
573  res = Queries::queryCmp(atom_val, this->val, this->tolerance) == 0;
574  }
575  catch (KeyErrorException e) {
576  res = false;
577  }
578  catch (boost::bad_any_cast)
579  {
580  res = false;
581  }
582 
583  }
584  if(this->getNegation()){
585  res=!res;
586  }
587  return res;
588  }
589 
590  //! returns a copy of this query
592  copy() const {
594  this->propname, this->val, this->tolerance);
595  res->setNegation(this->getNegation());
596  res->d_description = this->d_description;
597  return res;
598  }
599  };
600 
601  template<class TargetPtr>
602  class HasPropWithValueQuery<TargetPtr, std::string> :
603  public Queries::EqualityQuery<int, TargetPtr, true> {
604  std::string propname;
605  std::string val;
606  public:
608  Queries::EqualityQuery<int,TargetPtr,true>(),
609  propname(), val() {
610  // default is to just do a number of rings query:
611  this->setDescription("HasPropWithValue");
612  this->setDataFunc(0);
613  };
614  explicit HasPropWithValueQuery(const std::string & prop,
615  const std::string &v,
616  const std::string &tol="") :
617  Queries::EqualityQuery<int,TargetPtr,true>(),
618  propname(prop),
619  val(v) {
620  // default is to just do a number of rings query:
621  this->setDescription("HasPropWithValue");
622  this->setDataFunc(0);
623  };
624 
625  virtual bool Match(const TargetPtr what) const {
626  bool res = what->hasProp(propname);
627  if (res)
628  {
629  try {
630  std::string atom_val = what->template getProp<std::string>(propname);
631  res = atom_val == this->val;
632  }
633  catch (KeyErrorException) {
634  res = false;
635  }
636  catch (boost::bad_any_cast)
637  {
638  res = false;
639  }
640  }
641  if(this->getNegation()){
642  res=!res;
643  }
644  return res;
645  }
646 
647  //! returns a copy of this query
649  copy() const {
652  this->propname, this->val);
653  res->setNegation(this->getNegation());
654  res->d_description = this->d_description;
655  return res;
656  }
657  };
658 
659 
660  template<class Target, class T>
662  const std::string &propname,
663  const T&val,
664  const T&tolerance=T())
665  {
667  propname, val, tolerance);
668  }
669 };
670 
671 
672 #endif
ROMol & getOwningMol() const
returns a reference to the ROMol that owns this Atom
Definition: Atom.h:121
HasPropQuery(const std::string &v)
Definition: QueryOps.h:502
bool getNegation() const
returns whether or not we are negated
Definition: Query.h:60
T * makeAtomTotalValenceQuery(int what, const std::string &descr)
returns a Query for matching total valence
Definition: QueryOps.h:201
T * makeAtomInRingQuery(const std::string &descr)
returns a Query for matching ring atoms
Definition: QueryOps.h:307
Queries::SetQuery< int, Bond const *, true > BOND_SET_QUERY
Definition: QueryOps.h:58
static int queryAtomTotalDegree(Atom const *at)
Definition: QueryOps.h:69
int queryCmp(const T1 v1, const T2 v2, const T1 tol)
Definition: Query.h:161
T * makeAtomHybridizationQuery(int what, const std::string &descr)
returns a Query for matching hybridization
Definition: QueryOps.h:290
static int queryAtomHybridization(Atom const *at)
Definition: QueryOps.h:89
T * makeAtomMassQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular mass
Definition: QueryOps.h:266
double round(double v)
rounds a value to the closest int
Queries::Query< int, Atom const *, true > ATOM_NULL_QUERY
Definition: QueryOps.h:61
Queries::Query< bool, Atom const *, true > ATOM_BOOL_QUERY
Definition: QueryOps.h:27
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:592
bool isBondInRingOfSize(unsigned int idx, unsigned int size) const
returns whether or not the bond with index idx is in a size - ring.
Queries::LessEqualQuery< int, Atom const *, true > ATOM_LESSEQUAL_QUERY
Definition: QueryOps.h:51
Queries::EqualityQuery< int, Bond const *, true > BOND_EQUALS_QUERY
Definition: QueryOps.h:40
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:520
void setNegation(bool what)
sets whether or not we are negated
Definition: Query.h:58
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:625
ATOM_NULL_QUERY * makeAtomNullQuery()
returns a Query for matching any atom
ROMol const * getQueryMol() const
returns a pointer to our query molecule
Definition: QueryOps.h:453
a Query implementing AND: requires all children to be true
Definition: AndQuery.h:20
T * makeAtomImplicitValenceQuery(int what, const std::string &descr)
returns a Query for matching implicit valence
Definition: QueryOps.h:185
Queries::LessEqualQuery< int, Bond const *, true > BOND_LESSEQUAL_QUERY
Definition: QueryOps.h:52
Queries::Query< int, Bond const *, true > BOND_NULL_QUERY
Definition: QueryOps.h:60
void setTol(MatchFuncArgType what)
sets our tolerance
Definition: EqualityQuery.h:47
Atom const * ConstAtomPtr
Definition: QueryOps.h:374
BOND_EQUALS_QUERY * makeBondOrderEqualsQuery(Bond::BondType what)
returns a Query for matching bond orders
unsigned int getTotalNumHs(bool includeNeighbors=false) const
returns the total number of Hs (implicit and explicit) that this Atom is bound to ...
a Query implementing AND: requires any child to be true
Definition: OrQuery.h:19
unsigned int getIsotope() const
returns our isotope number
Definition: Atom.h:218
BondDir getBondDir() const
returns our direction
Definition: Bond.h:269
double getMass() const
returns our mass
unsigned int queryAtomAllBondProduct(Atom const *at)
T * makeAtomMinRingSizeQuery(int tgt, const std::string &descr)
returns a Query for matching an atom&#39;s minimum ring size
Definition: QueryOps.h:326
STL namespace.
Queries::GreaterEqualQuery< int, Bond const *, true > BOND_GREATEREQUAL_QUERY
Definition: QueryOps.h:46
static int massIntegerConversionFactor
Definition: QueryOps.h:79
Queries::EqualityQuery< int, Atom const *, true > ATOM_PROP_QUERY
Definition: QueryOps.h:529
static int queryAtomExplicitDegree(Atom const *at)
Definition: QueryOps.h:68
static int queryBondOrder(Bond const *bond)
Definition: QueryOps.h:97
Queries::LessQuery< int, Bond const *, true > BOND_LESS_QUERY
Definition: QueryOps.h:49
int TypeConvert(intwhat, Int2Type< false >) const
calls our dataFunc (if it&#39;s set) on what and returns the result, otherwise returns what ...
Definition: Query.h:134
static int queryAtomImplicitHCount(Atom const *at)
Definition: QueryOps.h:72
unsigned int getIdx() const
returns our index within the ROMol
Definition: Atom.h:124
static int getAtIdx(Atom const *at)
returns the index of an atom
Definition: QueryOps.h:439
T * makeAtomImplicitHCountQuery(int what, const std::string &descr)
returns a Query for matching implicit hydrogen count
Definition: QueryOps.h:242
static int queryAtomMass(Atom const *at)
Definition: QueryOps.h:80
Queries::EqualityQuery< int, const Target *, true > * makePropQuery(const std::string &propname, const T &val, const T &tolerance=T())
Definition: QueryOps.h:661
BondType
the type of Bond
Definition: Bond.h:55
pulls in the core RDKit functionality
static int queryIsBondInRing(Bond const *bond)
Definition: QueryOps.h:123
ROMol is a molecule class that is intended to have a fixed topology.
Definition: ROMol.h:105
unsigned int minAtomRingSize(unsigned int idx) const
returns the size of the smallest ring atom idx is involved in
virtual bool Match(const ConstAtomPtr what) const
Definition: QueryOps.h:389
unsigned int getDegree() const
Queries::EqualityQuery< int, Bond const *, true > BOND_PROP_QUERY
Definition: QueryOps.h:531
Queries::LessQuery< int, Atom const *, true > ATOM_LESS_QUERY
Definition: QueryOps.h:48
T * makeAtomExplicitDegreeQuery(int what, const std::string &descr)
returns a Query for matching explicit degree
Definition: QueryOps.h:209
static int queryBondDir(Bond const *bond)
Definition: QueryOps.h:98
static int queryAtomUnsaturated(Atom const *at)
Definition: QueryOps.h:77
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:567
virtual bool Match(const TargetPtr what) const
returns whether or not we match the argument
Definition: QueryOps.h:510
a Query implementing a range: arguments must fall in a particular range of values.
Definition: RangeQuery.h:26
unsigned int getTotalDegree() const
int queryAtomIsInRingOfSize(Atom const *at)
Definition: QueryOps.h:148
Queries::EqualityQuery< int, const Target *, true > * makeHasPropQuery(const std::string &property)
returns a Query for matching atoms that have a particular property
Definition: QueryOps.h:535
Queries::RangeQuery< int, Bond const *, true > BOND_RANGE_QUERY
Definition: QueryOps.h:55
T * makeAtomIsotopeQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular isotope
Definition: QueryOps.h:274
T * makeAtomAliphaticQuery(const std::string &descr)
returns a Query for matching aliphatic atoms
Definition: QueryOps.h:258
BOND_EQUALS_QUERY * makeBondInNRingsQuery(int tgt)
returns a Query for matching bonds in a particular number of rings
Queries::GreaterQuery< int, Bond const *, true > BOND_GREATER_QUERY
Definition: QueryOps.h:43
Queries::GreaterEqualQuery< int, Atom const *, true > ATOM_GREATEREQUAL_QUERY
Definition: QueryOps.h:45
int getAtomicNum() const
returns our atomic number
Definition: Atom.h:113
T * makeAtomUnsaturatedQuery(const std::string &descr)
returns a Query for matching atoms with unsaturation:
Definition: QueryOps.h:298
unsigned int numAtomRings(unsigned int idx) const
returns the number of rings atom idx is involved in
Queries::Query< int, ConstAtomPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:405
class to allow integer values to pick templates
Definition: Query.h:26
static int queryAtomIsotope(Atom const *at)
Definition: QueryOps.h:83
int getExplicitValence() const
returns the explicit valence (including Hs) of this atom
MolGraph const & getTopology() const
brief returns a pointer to our underlying BGL object
Definition: ROMol.h:434
BOND_NULL_QUERY * makeBondNullQuery()
returns a Query for matching any bond
allows use of recursive structure queries (e.g. recursive SMARTS)
Definition: QueryOps.h:416
Bond const * ConstBondPtr
Definition: QueryOps.h:486
static int queryAtomExplicitValence(Atom const *at)
Definition: QueryOps.h:75
static int queryIsAtomInRing(Atom const *at)
Definition: QueryOps.h:109
a Query implementing <= using a particular value (and an optional tolerance)
HasPropWithValueQuery(const std::string &prop, const std::string &v, const std::string &tol="")
Definition: QueryOps.h:614
static int queryAtomAromatic(Atom const *at)
Definition: QueryOps.h:66
unsigned int getNumExplicitHs() const
returns our number of explict Hs
Definition: Atom.h:205
Includes a bunch of functionality for handling Atom and Bond queries.
Definition: Atom.h:28
static int queryBondMinRingSize(Bond const *bond)
Definition: QueryOps.h:129
static int queryAtomNum(Atom const *at)
Definition: QueryOps.h:78
MatchFuncArgType(* d_dataFunc)(DataFuncArgType)
Definition: Query.h:130
Queries::RangeQuery< int, Atom const *, true > ATOM_RANGE_QUERY
Definition: QueryOps.h:54
T * makeAtomRingBondCountQuery(int what, const std::string &descr)
returns a Query for matching atoms with a particular number of ring bonds
Definition: QueryOps.h:334
T * makeAtomAromaticQuery(const std::string &descr)
returns a Query for matching the isAromatic flag
Definition: QueryOps.h:250
static int queryAtomFormalCharge(Atom const *at)
Definition: QueryOps.h:86
a Query implementing < using a particular value (and an optional tolerance)
Definition: LessQuery.h:20
a Query implementing ==: arguments must match a particular value (within an optional tolerance) ...
Definition: EqualityQuery.h:22
T * makeAtomNumQuery(int what, const std::string &descr)
returns a Query for matching atomic number
Definition: QueryOps.h:177
T * makeAtomFormalChargeQuery(int what, const std::string &descr)
returns a Query for matching formal charge
Definition: QueryOps.h:282
class for representing a bond
Definition: Bond.h:46
static int queryAtomHeavyAtomDegree(Atom const *at)
Definition: QueryOps.h:70
bool nullQueryFun(T arg)
Definition: QueryOps.h:484
T * makeAtomExplicitValenceQuery(int what, const std::string &descr)
returns a Query for matching explicit valence
Definition: QueryOps.h:193
int nullDataFun(T arg)
Definition: QueryOps.h:482
int getImplicitValence() const
returns the implicit valence for this Atom
RingInfo * getRingInfo() const
Definition: ROMol.h:327
void insert(const MatchFuncArgType what)
insert an entry into our set
Definition: SetQuery.h:33
void setDataFunc(int(*what)(ConstAtomPtr))
sets our data function
Definition: Query.h:81
bool isAtomInRingOfSize(unsigned int idx, unsigned int size) const
returns whether or not the atom with index idx is in a size - ring.
BondDir
the bond&#39;s direction (for chirality)
Definition: Bond.h:81
Queries::SetQuery< int, Atom const *, true > ATOM_SET_QUERY
Definition: QueryOps.h:57
static int queryIsAtomInNRings(Atom const *at)
Definition: QueryOps.h:106
void setQueryMol(ROMol const *query)
sets the molecule we&#39;ll use recursively
Definition: QueryOps.h:449
unsigned int getSerialNumber() const
Definition: QueryOps.h:471
Queries::AndQuery< int, Bond const *, true > BOND_AND_QUERY
Definition: QueryOps.h:31
Queries::GreaterQuery< int, Atom const *, true > ATOM_GREATER_QUERY
Definition: QueryOps.h:42
RecursiveStructureQuery(ROMol const *query, unsigned int serialNumber=0)
initialize from an ROMol pointer
Definition: QueryOps.h:430
static int queryAtomHasImplicitH(Atom const *at)
Definition: QueryOps.h:73
#define PRECONDITION(expr, mess)
Definition: Invariant.h:119
static int queryAtomMinRingSize(Atom const *at)
Definition: QueryOps.h:126
Queries::AndQuery< int, Atom const *, true > ATOM_AND_QUERY
Definition: QueryOps.h:30
unsigned int numBondRings(unsigned int idx) const
returns the number of rings bond idx is involved in
HybridizationType getHybridization() const
returns our hybridization
Definition: Atom.h:230
T * makeAtomHasRingBondQuery(const std::string &descr)
returns a Query for matching atoms with a particular number of ring bonds
Definition: QueryOps.h:342
std::string d_description
Definition: Query.h:123
Queries::OrQuery< int, Bond const *, true > BOND_OR_QUERY
Definition: QueryOps.h:34
T * makeAtomHasImplicitHQuery(const std::string &descr)
returns a Query for matching ring atoms
Definition: QueryOps.h:233
Queries::OrQuery< int, Atom const *, true > ATOM_OR_QUERY
Definition: QueryOps.h:33
T * makeAtomInNRingsQuery(int what, const std::string &descr)
returns a Query for matching atoms in a particular number of rings
Definition: QueryOps.h:315
static int queryAtomAliphatic(Atom const *at)
Definition: QueryOps.h:67
HasPropWithValueQuery(const std::string &prop, const T &v, const T &tol=0.0)
Definition: QueryOps.h:556
a Query implementing > using a particular value (and an optional tolerance)
Definition: GreaterQuery.h:20
BOND_EQUALS_QUERY * makeBondMinRingSizeQuery(int what)
returns a Query for matching a bond&#39;s minimum ring size
ATOM_EQUALS_QUERY * makeAtomInRingOfSizeQuery(int tgt)
returns a Query for matching atoms in rings of a particular size
static int queryAtomRingBondCount(Atom const *at)
Definition: QueryOps.h:133
a Query implementing >= using a particular value (and an optional tolerance)
Pulls in all the query types.
BOND_EQUALS_QUERY * makeBondDirEqualsQuery(Bond::BondDir what)
returns a Query for matching bond directions
Queries::Query< int, Atom const *, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:457
T * makeAtomSimpleQuery(int what, int func(Atom const *), const std::string &description="Atom Simple")
Definition: QueryOps.h:166
int getFormalCharge() const
returns the formal charge of this atom
Definition: Atom.h:192
int queryBondIsInRingOfSize(Bond const *bond)
Definition: QueryOps.h:156
unsigned int getIdx() const
returns our index within the ROMol
Definition: Bond.h:156
Queries::Query< int, TargetPtr, true > * copy() const
returns a copy of this query
Definition: QueryOps.h:649
static int queryAtomHasRingBond(Atom const *at)
Definition: QueryOps.h:112
BOND_EQUALS_QUERY * makeBondInRingOfSizeQuery(int what)
returns a Query for matching bonds in rings of a particular size
OBOND_ITER_PAIR getAtomBonds(Atom const *at) const
provides access to all Bond objects connected to an Atom
ROMol & getOwningMol() const
returns a reference to the ROMol that owns this Bond
Definition: Bond.h:144
Queries::Query< bool, Bond const *, true > BOND_BOOL_QUERY
Definition: QueryOps.h:28
static int queryAtomRingMembership(Atom const *at)
Definition: QueryOps.h:366
Base class for all queries.
Definition: Query.h:46
static int queryAtomHCount(Atom const *at)
Definition: QueryOps.h:71
unsigned int queryAtomBondProduct(Atom const *at)
static int queryAtomTotalValence(Atom const *at)
Definition: QueryOps.h:76
BOND_EQUALS_QUERY * makeBondIsInRingQuery()
returns a Query for matching ring bonds
unsigned int minBondRingSize(unsigned int idx) const
returns the size of the smallest ring bond idx is involved in
The class for representing atoms.
Definition: Atom.h:67
Queries::XOrQuery< int, Bond const *, true > BOND_XOR_QUERY
Definition: QueryOps.h:37
BondType getBondType() const
returns our bondType
Definition: Bond.h:117
a Query implementing XOR: requires exactly one child to be true
Definition: XOrQuery.h:20
Queries::EqualityQuery< int, Atom const *, true > ATOM_EQUALS_QUERY
Definition: QueryOps.h:39
void setDescription(const std::string &descr)
sets our text description
Definition: Query.h:63
bool getIsAromatic() const
returns our isAromatic flag
Definition: Atom.h:210
static int queryAtomImplicitValence(Atom const *at)
Definition: QueryOps.h:74
Class to allow us to throw a KeyError from C++ and have it make it back to Python.
Definition: Exceptions.h:46
Queries::XOrQuery< int, Atom const *, true > ATOM_XOR_QUERY
Definition: QueryOps.h:36
T * makeAtomHCountQuery(int what, const std::string &descr)
returns a Query for matching hydrogen count
Definition: QueryOps.h:225
T * makeAtomTotalDegreeQuery(int what, const std::string &descr)
returns a Query for matching atomic degree
Definition: QueryOps.h:217
const int getTol() const
returns out tolerance
Definition: EqualityQuery.h:49
static int queryIsBondInNRings(Bond const *at)
Definition: QueryOps.h:99