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