RDKit
Open-source cheminformatics and machine learning.
EmbeddedFrag.h
Go to the documentation of this file.
1 //
2 // Copyright (C) 2003-2022 Greg Landrum and other RDKit contributors
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 #include <RDGeneral/export.h>
11 #ifndef RD_EMBEDDED_FRAG_H
12 #define RD_EMBEDDED_FRAG_H
13 
14 #include <RDGeneral/types.h>
15 #include <Geometry/Transform2D.h>
16 #include <Geometry/point.h>
17 #include "DepictUtils.h"
18 #include <boost/smart_ptr.hpp>
19 
20 namespace RDKit {
21 class ROMol;
22 class Bond;
23 } // namespace RDKit
24 
25 namespace RDDepict {
26 typedef boost::shared_array<double> DOUBLE_SMART_PTR;
27 
28 //! Class that contains the data for an atoms that has already been embedded
30  public:
31  typedef enum { UNSPECIFIED = 0, CISTRANS, RING } EAtomType;
32 
33  EmbeddedAtom() { neighs.clear(); }
34 
35  EmbeddedAtom(const EmbeddedAtom &other) = default;
36 
37  EmbeddedAtom(unsigned int aid, const RDGeom::Point2D &pos)
38  : aid(aid),
39  angle(-1.0),
40  nbr1(-1),
41  nbr2(-1),
42  CisTransNbr(-1),
43  ccw(true),
44  rotDir(0),
45  d_density(-1.0),
46  df_fixed(false) {
47  loc = pos;
48  }
49 
51  if (this == &other) {
52  return *this;
53  }
54 
55  loc = other.loc;
56  angle = other.angle;
57  nbr1 = other.nbr1;
58  nbr2 = other.nbr2;
59  CisTransNbr = other.CisTransNbr;
60  rotDir = other.rotDir;
61  normal = other.normal;
62  ccw = other.ccw;
63  neighs = other.neighs;
64  d_density = other.d_density;
65  df_fixed = other.df_fixed;
66  return *this;
67  }
68 
69  void Transform(const RDGeom::Transform2D &trans) {
70  RDGeom::Point2D temp = loc + normal;
71  trans.TransformPoint(loc);
72  trans.TransformPoint(temp);
73  normal = temp - loc;
74  }
75 
76  void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2) {
77  RDGeom::Point2D temp = loc + normal;
78  loc = reflectPoint(loc, loc1, loc2);
79  temp = reflectPoint(temp, loc1, loc2);
80  normal = temp - loc;
81  ccw = (!ccw);
82  }
83 
84  unsigned int aid{0}; // the id of the atom
85 
86  //! the angle that is already takes at this atom, so any new atom attaching to
87  /// this atom with have to fall in the available part
88  double angle{-1.0};
89 
90  //! the first neighbor of this atom that form the 'angle'
91  int nbr1{-1};
92 
93  //! the second neighbor of atom that from the 'angle'
94  int nbr2{-1};
95 
96  //! is this is a cis/trans atom the neighbor of this atom that is involved in
97  /// the cis/trans system - defaults to -1
98  int CisTransNbr{-1};
99 
100  //! which direction do we rotate this normal to add the next bond
101  //! if ccw is true we rotate counter clockwise, otherwise rotate clock wise,
102  /// by an angle that is <= PI/2
103  bool ccw{true};
104 
105  //! rotation direction around this atom when adding new atoms,
106  /// we determine this for the first neighbor and stick to this direction
107  /// after that
108  //! useful only on atoms that are degree >= 4
109  int rotDir{0};
110 
111  RDGeom::Point2D loc; // the current location of this atom
112  //! this is a normal vector to one of the bonds that added this atom
113  //! it provides the side on which we want to add a new bond to this atom
114  //! this is only relevant when we are dealing with non ring atoms. We would
115  /// like to draw chains in a zig-zag manner
117 
118  //! and these are the atom IDs of the neighbors that still need to be embedded
120 
121  // density of the atoms around this atoms
122  // - this is sum of inverse of the square of distances to other atoms from
123  // this atom. Used in the collision removal code
124  // - initialized to -1.0
125  double d_density{-1.0};
126 
127  //! if set this atom is fixed: further operations on the fragment may not
128  //! move it.
129  bool df_fixed{false};
130 };
131 
132 typedef std::map<unsigned int, EmbeddedAtom> INT_EATOM_MAP;
133 typedef INT_EATOM_MAP::iterator INT_EATOM_MAP_I;
134 typedef INT_EATOM_MAP::const_iterator INT_EATOM_MAP_CI;
135 
136 //! Class containing a fragment of a molecule that has already been embedded
137 /*
138  Here is how this class is designed to be used
139  - find a set of fused rings and compute the coordinates for the atoms in those
140  ring
141  - them grow this system either by adding non ring neighbors
142  - or by adding other embedded fragment
143  - so at the end of the process the whole molecule end up being one these
144  embedded frag objects
145 */
147  // REVIEW: think about moving member functions up to global level and just
148  // using
149  // this class as a container
150 
151  public:
152  //! Default constructor
154  d_eatoms.clear();
155  d_attachPts.clear();
156  }
157 
158  //! Initializer from a single atom id
159  /*!
160  A single Embedded Atom with this atom ID is added and placed at the origin
161  */
162  EmbeddedFrag(unsigned int aid, const RDKit::ROMol *mol);
163 
164  //! Constructor when the coordinates have been specified for a set of atoms
165  /*!
166  This simply initialized a set of EmbeddedAtom to have the same coordinates
167  as the one's specified. No testing is done to verify any kind of
168  correctness. Also this fragment is less ready (to expand and add new
169  neighbors) than when using other constructors. This is because:
170  - the user may have specified coords for only a part of the atoms in a
171  fused ring systems in which case we need to find these atoms and merge
172  these ring systems to this fragment
173  - The atoms are not yet aware of their neighbor (what is left to add etc.)
174  this again depends on atoms properly so that new neighbors can be added
175  to them
176  */
178  const RDGeom::INT_POINT2D_MAP &coordMap);
179 
180  //! Initializer from a set of fused rings
181  /*!
182  ARGUMENTS:
183  \param mol the molecule of interest
184  \param fusedRings a vector of rings, each ring is a list of atom ids
185  */
186  EmbeddedFrag(const RDKit::ROMol *mol, const RDKit::VECT_INT_VECT &fusedRings);
187 
188  //! Initializer for a cis/trans system using the double bond
189  /*!
190  ARGUMENTS:
191  \param dblBond the double bond that is involved in the cis/trans
192  configuration
193  */
194  explicit EmbeddedFrag(const RDKit::Bond *dblBond);
195 
196  //! Expand this embedded system by adding neighboring atoms or other embedded
197  /// systems
198  /*!
199 
200  Note that both nratms and efrags are modified in this function
201  as we start merging them with the current fragment
202 
203  */
204  void expandEfrag(RDKit::INT_LIST &nratms, std::list<EmbeddedFrag> &efrags);
205 
206  //! Add a new non-ring atom to this object
207  /*
208  ARGUMENTS:
209  \param aid ID of the atom to be added
210  \param toAid ID of the atom that is already in this object to which this
211  atom is added
212  */
213  void addNonRingAtom(unsigned int aid, unsigned int toAid);
214 
215  //! Merge this embedded object with another embedded fragment
216  /*!
217 
218  The transformation (rotation + translation required to attached
219  the passed in object will be computed and applied. The
220  coordinates of the atoms in this object will remain fixed We
221  will assume that there are no common atoms between the two
222  fragments to start with
223 
224  ARGUMENTS:
225  \param embObj another EmbeddedFrag object to be merged with this object
226  \param toAid the atom in this embedded fragment to which the new object
227  will be attached
228  \param nbrAid the atom in the other fragment to attach to
229  */
230  void mergeNoCommon(EmbeddedFrag &embObj, unsigned int toAid,
231  unsigned int nbrAid);
232 
233  //! Merge this embedded object with another embedded fragment
234  /*!
235 
236  The transformation (rotation + translation required to attached
237  the passed in object will be computed and applied. The
238  coordinates of the atoms in this object will remain fixed This
239  already know there are a atoms in common and we will use them to
240  merge things
241 
242  ARGUMENTS:
243  \param embObj another EmbeddedFrag object to be merged with this object
244  \param commAtms a vector of ids of the common atoms
245 
246  */
247  void mergeWithCommon(EmbeddedFrag &embObj, RDKit::INT_VECT &commAtms);
248 
249  void mergeFragsWithComm(std::list<EmbeddedFrag> &efrags);
250 
251  //! Mark this fragment to be done for final embedding
252  void markDone() { d_done = true; }
253 
254  //! If this fragment done for the final embedding
255  bool isDone() { return d_done; }
256 
257  //! Get the molecule that this embedded fragment belongs to
258  const RDKit::ROMol *getMol() const { return dp_mol; }
259 
260  //! Find the common atom ids between this fragment and a second one
262 
263  //! Find a neighbor to a non-ring atom among the already embedded atoms
264  /*!
265  ARGUMENTS:
266  \param aid the atom id of interest
267 
268  RETURNS:
269  \return the id of the atom if we found a neighbor
270  -1 otherwise
271 
272  NOTE: by definition we can have only one neighbor in the embedded system.
273  */
274  int findNeighbor(unsigned int aid);
275 
276  //! Transform this object to a new coordinates system
277  /*!
278  ARGUMENTS:
279  \param trans : the transformation that need to be applied to the atoms in
280  this object
281  */
282  void Transform(const RDGeom::Transform2D &trans);
283 
284  void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2);
285 
286  const INT_EATOM_MAP &GetEmbeddedAtoms() const { return d_eatoms; }
287 
288  void Translate(const RDGeom::Point2D &shift) {
289  INT_EATOM_MAP_I eari;
290  for (eari = d_eatoms.begin(); eari != d_eatoms.end(); eari++) {
291  eari->second.loc += shift;
292  }
293  }
294 
295  EmbeddedAtom GetEmbeddedAtom(unsigned int aid) const {
296  INT_EATOM_MAP_CI posi = d_eatoms.find(aid);
297  if (posi == d_eatoms.end()) {
298  PRECONDITION(0, "Embedded atom does not contain embedded atom specified");
299  }
300  return posi->second;
301  }
302 
303  //! the number of atoms in the embedded system
304  int Size() const { return d_eatoms.size(); }
305 
306  //! \brief compute a box that encloses the fragment
307  void computeBox();
308 
309  //! \brief Flip atoms on one side of a bond - used in removing collisions
310  /*!
311  ARGUMENTS:
312  \param bondId - the bond used as the mirror to flip
313  \param flipEnd - flip the atoms at the end of the bond
314 
315  */
316  void flipAboutBond(unsigned int bondId, bool flipEnd = true);
317 
318  void openAngles(const double *dmat, unsigned int aid1, unsigned int aid2);
319 
320  std::vector<PAIR_I_I> findCollisions(const double *dmat,
321  bool includeBonds = 1);
322 
324 
326  double mimicDmatWt);
327 
328  void permuteBonds(unsigned int aid, unsigned int aid1, unsigned int aid2);
329 
330  void randomSampleFlipsAndPermutations(unsigned int nBondsPerSample = 3,
331  unsigned int nSamples = 100,
332  int seed = 100,
333  const DOUBLE_SMART_PTR *dmat = nullptr,
334  double mimicDmatWt = 0.0,
335  bool permuteDeg4Nodes = false);
336 
337  //! Remove collisions in a structure by flipping rotatable bonds
338  //! along the shortest path between two colliding atoms
340 
341  //! Remove collision by opening angles at the offending atoms
343 
344  //! Remove collisions by shortening bonds along the shortest path between the
345  /// atoms
347 
348  //! helpers functions to
349 
350  //! \brief make list of neighbors for each atom in the embedded system that
351  //! still need to be embedded
353 
354  //! update the unembedded neighbor atom list for a specified atom
355  void updateNewNeighs(unsigned int aid);
356 
357  //! \brief Find all atoms in this embedded system that are
358  //! within a specified distant of a point
359  int findNumNeigh(const RDGeom::Point2D &pt, double radius);
360 
361  inline double getBoxPx() { return d_px; }
362  inline double getBoxNx() { return d_nx; }
363  inline double getBoxPy() { return d_py; }
364  inline double getBoxNy() { return d_ny; }
365 
367 
368  private:
369  double totalDensity();
370 
371  void embedFusedRings(const RDKit::VECT_INT_VECT &fusedRings);
372 
373  //! \brief Find a transform to join a ring to the current embedded frag when
374  /// we
375  //! have only on common atom
376  /*!
377  So this is the state of affairs assumed here:
378  - we already have some rings in the fused system embedded and the
379  coordinates for the atoms
380  - the coordinates for the atoms in the new ring (with the center
381  of rings at the origin) are available nringCors. we want to
382  translate and rotate this ring to join with the already
383  embeded rings.
384  - only one atom is common between this new ring and the atoms
385  that are already embedded
386  - so we need to compute a transform that includes a translation
387  so that the common atom overlaps and the rotation to minimize
388  overlap with other atoms.
389 
390  Here's what is done:
391  - we bisect the remaining sweep angle at the common atom and
392  attach the new ring such that the center of the new ring falls
393  on this bisecting line
394 
395  NOTE: It is assumed here that the original coordinates for the
396  new ring are such that the center is at the origin (this is the
397  way rings come out of embedRing)
398  */
399  RDGeom::Transform2D computeOneAtomTrans(unsigned int commAid,
400  const EmbeddedFrag &other);
401 
402  RDGeom::Transform2D computeTwoAtomTrans(
403  unsigned int aid1, unsigned int aid2,
404  const RDGeom::INT_POINT2D_MAP &nringCor);
405 
406  //! Merge a ring with already embedded atoms
407  /*!
408  It is assumed that the new rings has already been oriented
409  correctly etc. This function just update all the relevant data,
410  like the neighbor information and the sweep angle
411  */
412  void mergeRing(const EmbeddedFrag &embRing, unsigned int nCommon,
413  const RDKit::INT_VECT &pinAtoms);
414 
415  //! Reflect a fragment if necessary through a line connecting two atoms
416  /*!
417 
418  We want add the new fragment such that, most of its atoms fall
419  on the side opposite to where the atoms already embedded are aid1
420  and aid2 give the atoms that were used to align the new ring to
421  the embedded atoms and we will assume that that process has
422  already taken place (i.e. transformRing has been called)
423 
424  */
425  void reflectIfNecessaryDensity(EmbeddedFrag &embFrag, unsigned int aid1,
426  unsigned int aid2);
427 
428  //! Reflect a fragment if necessary based on the cis/trans specification
429  /*!
430 
431  we want to add the new fragment such that the cis/trans
432  specification on bond between aid1 and aid2 is not violated. We
433  will assume that aid1 and aid2 from this fragments as well as
434  embFrag are already aligned to each other.
435 
436  \param embFrag the fragment that will be reflected if necessary
437  \param ctCase which fragment if the cis/trans dbl bond
438  - 1 means embFrag is the cis/trans fragment
439  - 2 mean "this" is the cis/trans fragment
440  \param aid1 first atom that forms the plane (line) of reflection
441  \param aid2 second atom that forms the plane of reflection
442  */
443  void reflectIfNecessaryCisTrans(EmbeddedFrag &embFrag, unsigned int ctCase,
444  unsigned int aid1, unsigned int aid2);
445 
446  //! Reflect a fragment if necessary based on a third common point
447  /*!
448 
449  we want add the new fragment such that the third point falls on
450  the same side of aid1 and aid2. We will assume that aid1 and
451  aid2 from this fragments as well as embFrag are already aligned
452  to each other.
453 
454  */
455  void reflectIfNecessaryThirdPt(EmbeddedFrag &embFrag, unsigned int aid1,
456  unsigned int aid2, unsigned int aid3);
457 
458  //! \brief Initialize this fragment from a ring and coordinates for its atoms
459  /*!
460  ARGUMENTS:
461  /param ring a vector of atom ids in the ring; it is assumed that there
462  in
463  clockwise or anti-clockwise order
464  /param nringMap a map of atomId to coordinate map for the atoms in the ring
465  */
466  void initFromRingCoords(const RDKit::INT_VECT &ring,
467  const RDGeom::INT_POINT2D_MAP &nringMap);
468 
469  //! Helper function to addNonRingAtom to a specified atoms in the fragment
470  /*
471  Add an atom to this embedded fragment when the fragment already
472  has at least two neighbors previously added to 'toAid'. In this
473  case we have to choose where the new neighbor goes based on
474  the angle that is already taken around the atom.
475 
476  ARGUMENTS:
477  \param aid ID of the atom to be added
478  \param toAid ID of the atom that is already in this object to which this
479  atom is added
480  */
481  void addAtomToAtomWithAng(unsigned int aid, unsigned int toAid);
482 
483  //! Helper function to addNonRingAtom to a specified atoms in the fragment
484  /*!
485 
486  Add an atom (aid) to an atom (toAid) in this embedded fragment
487  when 'toAid' has one or no neighbors previously added. In this
488  case where the new atom should fall is determined by the degree
489  of 'toAid' and the congestion around it.
490 
491  ARGUMENTS:
492  \param aid ID of the atom to be added
493  \param toAid ID of the atom that is already in this object to which this
494  atom is added
495  \param mol the molecule we are dealing with
496  */
497  void addAtomToAtomWithNoAng(
498  unsigned int aid,
499  unsigned int toAid); //, const RDKit::ROMol *mol);
500 
501  //! Helper function to constructor that takes predefined coordinates
502  /*!
503 
504  Given an atom with more than 2 neighbors all embedded in this
505  fragment this function tries to determine
506 
507  - how much of an angle if left for any new neighbors yet to be
508  added
509  - which atom should we rotate when we add a new neighbor and in
510  which direction (clockwise or anticlockwise
511 
512  This is how it works
513  - find the pair of nbrs that have the largest angle
514  - this will most likely be the angle that is available - unless
515  we have fused rings and we found on of the ring angle !!!! -
516  in this case we find the next best
517  - find the smallest angle that contains one of these nbrs -
518  this determined which
519  - way we want to rotate
520 
521  ARGUMENTS:
522  \param aid the atom id where we are centered right now
523  \param doneNbrs list of neighbors that are already embedded around aid
524  */
525  void computeNbrsAndAng(unsigned int aid, const RDKit::INT_VECT &doneNbrs);
526  // const RDKit::ROMol *mol);
527 
528  //! are we embedded with the final (molecule) coordinates
529  bool d_done = false;
530  double d_px = 0.0, d_nx = 0.0, d_py = 0.0, d_ny = 0.0;
531 
532  //! a map that takes one from the atom id to the embeddedatom object for that
533  /// atom.
534  INT_EATOM_MAP d_eatoms;
535 
536  // RDKit::INT_DEQUE d_attachPts;
537  RDKit::INT_LIST d_attachPts;
538 
539  // pointer to the owning molecule
540  const RDKit::ROMol *dp_mol = nullptr;
541 };
542 } // namespace RDDepict
543 
544 #endif
#define PRECONDITION(expr, mess)
Definition: Invariant.h:109
Class that contains the data for an atoms that has already been embedded.
Definition: EmbeddedFrag.h:29
EmbeddedAtom(const EmbeddedAtom &other)=default
int nbr1
the first neighbor of this atom that form the 'angle'
Definition: EmbeddedFrag.h:91
RDKit::INT_VECT neighs
and these are the atom IDs of the neighbors that still need to be embedded
Definition: EmbeddedFrag.h:119
RDGeom::Point2D normal
Definition: EmbeddedFrag.h:116
EmbeddedAtom & operator=(const EmbeddedAtom &other)
Definition: EmbeddedFrag.h:50
int nbr2
the second neighbor of atom that from the 'angle'
Definition: EmbeddedFrag.h:94
RDGeom::Point2D loc
Definition: EmbeddedFrag.h:111
EmbeddedAtom(unsigned int aid, const RDGeom::Point2D &pos)
Definition: EmbeddedFrag.h:37
void Transform(const RDGeom::Transform2D &trans)
Definition: EmbeddedFrag.h:69
void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
Definition: EmbeddedFrag.h:76
Class containing a fragment of a molecule that has already been embedded.
Definition: EmbeddedFrag.h:146
EmbeddedAtom GetEmbeddedAtom(unsigned int aid) const
Definition: EmbeddedFrag.h:295
void Transform(const RDGeom::Transform2D &trans)
Transform this object to a new coordinates system.
void updateNewNeighs(unsigned int aid)
update the unembedded neighbor atom list for a specified atom
void markDone()
Mark this fragment to be done for final embedding.
Definition: EmbeddedFrag.h:252
void flipAboutBond(unsigned int bondId, bool flipEnd=true)
Flip atoms on one side of a bond - used in removing collisions.
int Size() const
the number of atoms in the embedded system
Definition: EmbeddedFrag.h:304
void mergeNoCommon(EmbeddedFrag &embObj, unsigned int toAid, unsigned int nbrAid)
Merge this embedded object with another embedded fragment.
EmbeddedFrag(const RDKit::ROMol *mol, const RDGeom::INT_POINT2D_MAP &coordMap)
Constructor when the coordinates have been specified for a set of atoms.
EmbeddedFrag()
Default constructor.
Definition: EmbeddedFrag.h:153
EmbeddedFrag(const RDKit::Bond *dblBond)
Initializer for a cis/trans system using the double bond.
RDKit::INT_VECT findCommonAtoms(const EmbeddedFrag &efrag2)
Find the common atom ids between this fragment and a second one.
void expandEfrag(RDKit::INT_LIST &nratms, std::list< EmbeddedFrag > &efrags)
int findNumNeigh(const RDGeom::Point2D &pt, double radius)
Find all atoms in this embedded system that are within a specified distant of a point.
void removeCollisionsOpenAngles()
Remove collision by opening angles at the offending atoms.
EmbeddedFrag(unsigned int aid, const RDKit::ROMol *mol)
Initializer from a single atom id.
double mimicDistMatAndDensityCostFunc(const DOUBLE_SMART_PTR *dmat, double mimicDmatWt)
void Translate(const RDGeom::Point2D &shift)
Definition: EmbeddedFrag.h:288
void addNonRingAtom(unsigned int aid, unsigned int toAid)
Add a new non-ring atom to this object.
void permuteBonds(unsigned int aid, unsigned int aid1, unsigned int aid2)
EmbeddedFrag(const RDKit::ROMol *mol, const RDKit::VECT_INT_VECT &fusedRings)
Initializer from a set of fused rings.
void removeCollisionsShortenBonds()
void setupNewNeighs()
helpers functions to
void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
void computeBox()
compute a box that encloses the fragment
std::vector< PAIR_I_I > findCollisions(const double *dmat, bool includeBonds=1)
void openAngles(const double *dmat, unsigned int aid1, unsigned int aid2)
const INT_EATOM_MAP & GetEmbeddedAtoms() const
Definition: EmbeddedFrag.h:286
const RDKit::ROMol * getMol() const
Get the molecule that this embedded fragment belongs to.
Definition: EmbeddedFrag.h:258
void mergeWithCommon(EmbeddedFrag &embObj, RDKit::INT_VECT &commAtms)
Merge this embedded object with another embedded fragment.
void randomSampleFlipsAndPermutations(unsigned int nBondsPerSample=3, unsigned int nSamples=100, int seed=100, const DOUBLE_SMART_PTR *dmat=nullptr, double mimicDmatWt=0.0, bool permuteDeg4Nodes=false)
bool isDone()
If this fragment done for the final embedding.
Definition: EmbeddedFrag.h:255
void mergeFragsWithComm(std::list< EmbeddedFrag > &efrags)
int findNeighbor(unsigned int aid)
Find a neighbor to a non-ring atom among the already embedded atoms.
void computeDistMat(DOUBLE_SMART_PTR &dmat)
void TransformPoint(Point2D &pt) const
class for representing a bond
Definition: Bond.h:47
#define RDKIT_DEPICTOR_EXPORT
Definition: export.h:89
boost::shared_array< double > DOUBLE_SMART_PTR
Definition: EmbeddedFrag.h:26
INT_EATOM_MAP::iterator INT_EATOM_MAP_I
Definition: EmbeddedFrag.h:133
RDKIT_DEPICTOR_EXPORT RDGeom::Point2D reflectPoint(const RDGeom::Point2D &point, const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
std::map< unsigned int, EmbeddedAtom > INT_EATOM_MAP
Definition: EmbeddedFrag.h:132
INT_EATOM_MAP::const_iterator INT_EATOM_MAP_CI
Definition: EmbeddedFrag.h:134
std::map< int, Point2D > INT_POINT2D_MAP
Definition: point.h:550
const uint32_t seed
Definition: MHFP.h:29
Std stuff.
Definition: Abbreviations.h:18
std::list< int > INT_LIST
Definition: types.h:283
std::vector< int > INT_VECT
Definition: types.h:277
std::vector< INT_VECT > VECT_INT_VECT
Definition: types.h:291