RDKit: EmbeddedFrag.h Source File

| RDKit Open-source cheminformatics and machine learning.

Loading...
Searching...
No Matches
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
20namespace RDKit {
21class ROMol;
22class Bond;
23} // namespace RDKit
24
25namespace 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
29 class RDKIT_DEPICTOR_EXPORT EmbeddedAtom {
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
50 EmbeddedAtom &operator=(const EmbeddedAtom &other) {
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
116 RDGeom::Point2D normal;
117
118 //! and these are the atom IDs of the neighbors that still need to be embedded
119 RDKit::INT_VECT neighs;
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*/
146 class RDKIT_DEPICTOR_EXPORT EmbeddedFrag {
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
153 EmbeddedFrag() {
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 */
177 EmbeddedFrag(const RDKit::ROMol *mol,
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 \param useRingTemplates whether to use ring system templates for generating
186 initial coordinates
187 */
188 EmbeddedFrag(const RDKit::ROMol *mol, const RDKit::VECT_INT_VECT &fusedRings,
189 bool useRingTemplates);
190
191 //! Initializer for a cis/trans system using the double bond
192 /*!
193 ARGUMENTS:
194 \param dblBond the double bond that is involved in the cis/trans
195 configuration
196 */
197 explicit EmbeddedFrag(const RDKit::Bond *dblBond);
198
199 //! Expand this embedded system by adding neighboring atoms or other embedded
200 /// systems
201 /*!
202
203 Note that both nratms and efrags are modified in this function
204 as we start merging them with the current fragment
205
206 */
207 void expandEfrag(RDKit::INT_LIST &nratms, std::list<EmbeddedFrag> &efrags);
208
209 //! Add a new non-ring atom to this object
210 /*
211 ARGUMENTS:
212 \param aid ID of the atom to be added
213 \param toAid ID of the atom that is already in this object to which this
214 atom is added
215 */
216 void addNonRingAtom(unsigned int aid, unsigned int toAid);
217
218 //! Merge this embedded object with another embedded fragment
219 /*!
220
221 The transformation (rotation + translation required to attached
222 the passed in object will be computed and applied. The
223 coordinates of the atoms in this object will remain fixed We
224 will assume that there are no common atoms between the two
225 fragments to start with
226
227 ARGUMENTS:
228 \param embObj another EmbeddedFrag object to be merged with this object
229 \param toAid the atom in this embedded fragment to which the new object
230 will be attached
231 \param nbrAid the atom in the other fragment to attach to
232 */
233 void mergeNoCommon(EmbeddedFrag &embObj, unsigned int toAid,
234 unsigned int nbrAid);
235
236 //! Merge this embedded object with another embedded fragment
237 /*!
238
239 The transformation (rotation + translation required to attached
240 the passed in object will be computed and applied. The
241 coordinates of the atoms in this object will remain fixed This
242 already know there are a atoms in common and we will use them to
243 merge things
244
245 ARGUMENTS:
246 \param embObj another EmbeddedFrag object to be merged with this object
247 \param commAtms a vector of ids of the common atoms
248
249 */
250 void mergeWithCommon(EmbeddedFrag &embObj, RDKit::INT_VECT &commAtms);
251
252 void mergeFragsWithComm(std::list<EmbeddedFrag> &efrags);
253
254 //! Mark this fragment to be done for final embedding
255 void markDone() { d_done = true; }
256
257 //! If this fragment done for the final embedding
258 bool isDone() { return d_done; }
259
260 //! Get the molecule that this embedded fragment belongs to
261 const RDKit::ROMol *getMol() const { return dp_mol; }
262
263 //! Find the common atom ids between this fragment and a second one
264 RDKit::INT_VECT findCommonAtoms(const EmbeddedFrag &efrag2);
265
266 //! Find a neighbor to a non-ring atom among the already embedded atoms
267 /*!
268 ARGUMENTS:
269 \param aid the atom id of interest
270
271 RETURNS:
272 \return the id of the atom if we found a neighbor
273 -1 otherwise
274
275 NOTE: by definition we can have only one neighbor in the embedded system.
276 */
277 int findNeighbor(unsigned int aid);
278
279 //! Transform this object to a new coordinates system
280 /*!
281 ARGUMENTS:
282 \param trans : the transformation that need to be applied to the atoms in
283 this object
284 */
285 void Transform(const RDGeom::Transform2D &trans);
286
287 void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2);
288
289 const INT_EATOM_MAP &GetEmbeddedAtoms() const { return d_eatoms; }
290
291 void Translate(const RDGeom::Point2D &shift) {
292 INT_EATOM_MAP_I eari;
293 for (eari = d_eatoms.begin(); eari != d_eatoms.end(); eari++) {
294 eari->second.loc += shift;
295 }
296 }
297
298 EmbeddedAtom GetEmbeddedAtom(unsigned int aid) const {
299 INT_EATOM_MAP_CI posi = d_eatoms.find(aid);
300 if (posi == d_eatoms.end()) {
301 PRECONDITION(0, "Embedded atom does not contain embedded atom specified");
302 }
303 return posi->second;
304 }
305
306 //! the number of atoms in the embedded system
307 int Size() const { return d_eatoms.size(); }
308
309 //! \brief compute a box that encloses the fragment
310 void computeBox();
311
312 //! \brief Flip atoms on one side of a bond - used in removing collisions
313 /*!
314 ARGUMENTS:
315 \param bondId - the bond used as the mirror to flip
316 \param flipEnd - flip the atoms at the end of the bond
317
318 */
319 void flipAboutBond(unsigned int bondId, bool flipEnd = true);
320
321 void openAngles(const double *dmat, unsigned int aid1, unsigned int aid2);
322
323 std::vector<PAIR_I_I> findCollisions(const double *dmat,
324 bool includeBonds = 1);
325
326 void computeDistMat(DOUBLE_SMART_PTR &dmat);
327
328 double mimicDistMatAndDensityCostFunc(const DOUBLE_SMART_PTR *dmat,
329 double mimicDmatWt);
330
331 void permuteBonds(unsigned int aid, unsigned int aid1, unsigned int aid2);
332
333 void randomSampleFlipsAndPermutations(unsigned int nBondsPerSample = 3,
334 unsigned int nSamples = 100,
335 int seed = 100,
336 const DOUBLE_SMART_PTR *dmat = nullptr,
337 double mimicDmatWt = 0.0,
338 bool permuteDeg4Nodes = false);
339
340 //! Remove collisions in a structure by flipping rotatable bonds
341 //! along the shortest path between two colliding atoms
342 void removeCollisionsBondFlip();
343
344 //! Remove collision by opening angles at the offending atoms
345 void removeCollisionsOpenAngles();
346
347 //! Remove collisions by shortening bonds along the shortest path between the
348 /// atoms
349 void removeCollisionsShortenBonds();
350
351 //! helpers functions to
352
353 //! \brief make list of neighbors for each atom in the embedded system that
354 //! still need to be embedded
355 void setupNewNeighs();
356
357 //! update the unembedded neighbor atom list for a specified atom
358 void updateNewNeighs(unsigned int aid);
359
360 //! \brief Find all atoms in this embedded system that are
361 //! within a specified distant of a point
362 int findNumNeigh(const RDGeom::Point2D &pt, double radius);
363
364 inline double getBoxPx() { return d_px; }
365 inline double getBoxNx() { return d_nx; }
366 inline double getBoxPy() { return d_py; }
367 inline double getBoxNy() { return d_ny; }
368
369 void canonicalizeOrientation();
370
371 private:
372 double totalDensity();
373
374 // returns true if fused rings found a template
375 bool matchToTemplate(const RDKit::INT_VECT &ringSystemAtoms,
376 unsigned int ring_count);
377
378 void embedFusedRings(const RDKit::VECT_INT_VECT &fusedRings,
379 bool useRingTemplates);
380
381 void setupAttachmentPoints();
382
383 //! \brief Find a transform to join a ring to the current embedded frag when
384 /// we
385 //! have only on common atom
386 /*!
387 So this is the state of affairs assumed here:
388 - we already have some rings in the fused system embedded and the
389 coordinates for the atoms
390 - the coordinates for the atoms in the new ring (with the center
391 of rings at the origin) are available nringCors. we want to
392 translate and rotate this ring to join with the already
393 embeded rings.
394 - only one atom is common between this new ring and the atoms
395 that are already embedded
396 - so we need to compute a transform that includes a translation
397 so that the common atom overlaps and the rotation to minimize
398 overlap with other atoms.
399
400 Here's what is done:
401 - we bisect the remaining sweep angle at the common atom and
402 attach the new ring such that the center of the new ring falls
403 on this bisecting line
404
405 NOTE: It is assumed here that the original coordinates for the
406 new ring are such that the center is at the origin (this is the
407 way rings come out of embedRing)
408 */
409 RDGeom::Transform2D computeOneAtomTrans(unsigned int commAid,
410 const EmbeddedFrag &other);
411
412 RDGeom::Transform2D computeTwoAtomTrans(
413 unsigned int aid1, unsigned int aid2,
414 const RDGeom::INT_POINT2D_MAP &nringCor);
415
416 //! Merge a ring with already embedded atoms
417 /*!
418 It is assumed that the new rings has already been oriented
419 correctly etc. This function just update all the relevant data,
420 like the neighbor information and the sweep angle
421 */
422 void mergeRing(const EmbeddedFrag &embRing, unsigned int nCommon,
423 const RDKit::INT_VECT &pinAtoms);
424
425 //! Reflect a fragment if necessary through a line connecting two atoms
426 /*!
427
428 We want add the new fragment such that, most of its atoms fall
429 on the side opposite to where the atoms already embedded are aid1
430 and aid2 give the atoms that were used to align the new ring to
431 the embedded atoms and we will assume that that process has
432 already taken place (i.e. transformRing has been called)
433
434 */
435 void reflectIfNecessaryDensity(EmbeddedFrag &embFrag, unsigned int aid1,
436 unsigned int aid2);
437
438 //! Reflect a fragment if necessary based on the cis/trans specification
439 /*!
440
441 we want to add the new fragment such that the cis/trans
442 specification on bond between aid1 and aid2 is not violated. We
443 will assume that aid1 and aid2 from this fragments as well as
444 embFrag are already aligned to each other.
445
446 \param embFrag the fragment that will be reflected if necessary
447 \param ctCase which fragment if the cis/trans dbl bond
448 - 1 means embFrag is the cis/trans fragment
449 - 2 mean "this" is the cis/trans fragment
450 \param aid1 first atom that forms the plane (line) of reflection
451 \param aid2 second atom that forms the plane of reflection
452 */
453 void reflectIfNecessaryCisTrans(EmbeddedFrag &embFrag, unsigned int ctCase,
454 unsigned int aid1, unsigned int aid2);
455
456 //! Reflect a fragment if necessary based on a third common point
457 /*!
458
459 we want add the new fragment such that the third point falls on
460 the same side of aid1 and aid2. We will assume that aid1 and
461 aid2 from this fragments as well as embFrag are already aligned
462 to each other.
463
464 */
465 void reflectIfNecessaryThirdPt(EmbeddedFrag &embFrag, unsigned int aid1,
466 unsigned int aid2, unsigned int aid3);
467
468 //! \brief Initialize this fragment from a ring and coordinates for its atoms
469 /*!
470 ARGUMENTS:
471 /param ring a vector of atom ids in the ring; it is assumed that there
472 in
473 clockwise or anti-clockwise order
474 /param nringMap a map of atomId to coordinate map for the atoms in the ring
475 */
476 void initFromRingCoords(const RDKit::INT_VECT &ring,
477 const RDGeom::INT_POINT2D_MAP &nringMap);
478
479 //! Helper function to addNonRingAtom to a specified atoms in the fragment
480 /*
481 Add an atom to this embedded fragment when the fragment already
482 has at least two neighbors previously added to 'toAid'. In this
483 case we have to choose where the new neighbor goes based on
484 the angle that is already taken around the atom.
485
486 ARGUMENTS:
487 \param aid ID of the atom to be added
488 \param toAid ID of the atom that is already in this object to which this
489 atom is added
490 */
491 void addAtomToAtomWithAng(unsigned int aid, unsigned int toAid);
492
493 //! Helper function to addNonRingAtom to a specified atoms in the fragment
494 /*!
495
496 Add an atom (aid) to an atom (toAid) in this embedded fragment
497 when 'toAid' has one or no neighbors previously added. In this
498 case where the new atom should fall is determined by the degree
499 of 'toAid' and the congestion around it.
500
501 ARGUMENTS:
502 \param aid ID of the atom to be added
503 \param toAid ID of the atom that is already in this object to which this
504 atom is added
505 \param mol the molecule we are dealing with
506 */
507 void addAtomToAtomWithNoAng(
508 unsigned int aid,
509 unsigned int toAid); //, const RDKit::ROMol *mol);
510
511 //! Helper function to constructor that takes predefined coordinates
512 /*!
513
514 Given an atom with more than 2 neighbors all embedded in this
515 fragment this function tries to determine
516
517 - how much of an angle if left for any new neighbors yet to be
518 added
519 - which atom should we rotate when we add a new neighbor and in
520 which direction (clockwise or anticlockwise
521
522 This is how it works
523 - find the pair of nbrs that have the largest angle
524 - this will most likely be the angle that is available - unless
525 we have fused rings and we found on of the ring angle !!!! -
526 in this case we find the next best
527 - find the smallest angle that contains one of these nbrs -
528 this determined which
529 - way we want to rotate
530
531 ARGUMENTS:
532 \param aid the atom id where we are centered right now
533 \param doneNbrs list of neighbors that are already embedded around aid
534 */
535 void computeNbrsAndAng(unsigned int aid, const RDKit::INT_VECT &doneNbrs);
536 // const RDKit::ROMol *mol);
537
538 //! are we embedded with the final (molecule) coordinates
539 bool d_done = false;
540 double d_px = 0.0, d_nx = 0.0, d_py = 0.0, d_ny = 0.0;
541
542 //! a map that takes one from the atom id to the embeddedatom object for that
543 /// atom.
544 INT_EATOM_MAP d_eatoms;
545
546 // RDKit::INT_DEQUE d_attachPts;
547 RDKit::INT_LIST d_attachPts;
548
549 // pointer to the owning molecule
550 const RDKit::ROMol *dp_mol = nullptr;
551};
552} // namespace RDDepict
553
554#endif
DepictUtils.h
PRECONDITION
#define PRECONDITION(expr, mess)
Definition Invariant.h:108
Transform2D.h
RDDepict::EmbeddedAtom
Class that contains the data for an atoms that has already been embedded.
Definition EmbeddedFrag.h:29
RDDepict::EmbeddedAtom::EmbeddedAtom
EmbeddedAtom(const EmbeddedAtom &other)=default
RDDepict::EmbeddedAtom::df_fixed
bool df_fixed
Definition EmbeddedFrag.h:129
RDDepict::EmbeddedAtom::CisTransNbr
int CisTransNbr
Definition EmbeddedFrag.h:98
RDDepict::EmbeddedAtom::aid
unsigned int aid
Definition EmbeddedFrag.h:84
RDDepict::EmbeddedAtom::EmbeddedAtom
EmbeddedAtom()
Definition EmbeddedFrag.h:33
RDDepict::EmbeddedAtom::d_density
double d_density
Definition EmbeddedFrag.h:125
RDDepict::EmbeddedAtom::nbr1
int nbr1
the first neighbor of this atom that form the 'angle'
Definition EmbeddedFrag.h:91
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:119
RDDepict::EmbeddedAtom::rotDir
int rotDir
Definition EmbeddedFrag.h:109
RDDepict::EmbeddedAtom::normal
RDGeom::Point2D normal
Definition EmbeddedFrag.h:116
RDDepict::EmbeddedAtom::nbr2
int nbr2
the second neighbor of atom that from the 'angle'
Definition EmbeddedFrag.h:94
RDDepict::EmbeddedAtom::ccw
bool ccw
Definition EmbeddedFrag.h:103
RDDepict::EmbeddedAtom::loc
RDGeom::Point2D loc
Definition EmbeddedFrag.h:111
RDDepict::EmbeddedAtom::CISTRANS
@ CISTRANS
Definition EmbeddedFrag.h:31
RDDepict::EmbeddedAtom::UNSPECIFIED
@ UNSPECIFIED
Definition EmbeddedFrag.h:31
RDDepict::EmbeddedAtom::RING
@ RING
Definition EmbeddedFrag.h:31
RDDepict::EmbeddedAtom::operator=
EmbeddedAtom & operator=(const EmbeddedAtom &other)
Definition EmbeddedFrag.h:50
RDDepict::EmbeddedAtom::EmbeddedAtom
EmbeddedAtom(unsigned int aid, const RDGeom::Point2D &pos)
Definition EmbeddedFrag.h:37
RDDepict::EmbeddedAtom::angle
double angle
Definition EmbeddedFrag.h:88
RDDepict::EmbeddedAtom::Transform
void Transform(const RDGeom::Transform2D &trans)
Definition EmbeddedFrag.h:69
RDDepict::EmbeddedAtom::Reflect
void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
Definition EmbeddedFrag.h:76
RDDepict::EmbeddedFrag::getBoxPx
double getBoxPx()
Definition EmbeddedFrag.h:364
RDDepict::EmbeddedFrag::GetEmbeddedAtom
EmbeddedAtom GetEmbeddedAtom(unsigned int aid) const
Definition EmbeddedFrag.h:298
RDDepict::EmbeddedFrag::Transform
void Transform(const RDGeom::Transform2D &trans)
Transform this object to a new coordinates system.
RDDepict::EmbeddedFrag::removeCollisionsBondFlip
void removeCollisionsBondFlip()
RDDepict::EmbeddedFrag::updateNewNeighs
void updateNewNeighs(unsigned int aid)
update the unembedded neighbor atom list for a specified atom
RDDepict::EmbeddedFrag::markDone
void markDone()
Mark this fragment to be done for final embedding.
Definition EmbeddedFrag.h:255
RDDepict::EmbeddedFrag::EmbeddedFrag
EmbeddedFrag(const RDKit::ROMol *mol, const RDKit::VECT_INT_VECT &fusedRings, bool useRingTemplates)
Initializer from a set of fused rings.
RDDepict::EmbeddedFrag::flipAboutBond
void flipAboutBond(unsigned int bondId, bool flipEnd=true)
Flip atoms on one side of a bond - used in removing collisions.
RDDepict::EmbeddedFrag::findCollisions
std::vector< PAIR_I_I > findCollisions(const double *dmat, bool includeBonds=1)
RDDepict::EmbeddedFrag::Size
int Size() const
the number of atoms in the embedded system
Definition EmbeddedFrag.h:307
RDDepict::EmbeddedFrag::mergeNoCommon
void mergeNoCommon(EmbeddedFrag &embObj, unsigned int toAid, unsigned int nbrAid)
Merge this embedded object with another embedded fragment.
RDDepict::EmbeddedFrag::EmbeddedFrag
EmbeddedFrag(const RDKit::ROMol *mol, const RDGeom::INT_POINT2D_MAP &coordMap)
Constructor when the coordinates have been specified for a set of atoms.
RDDepict::EmbeddedFrag::getBoxNx
double getBoxNx()
Definition EmbeddedFrag.h:365
RDDepict::EmbeddedFrag::EmbeddedFrag
EmbeddedFrag()
Default constructor.
Definition EmbeddedFrag.h:153
RDDepict::EmbeddedFrag::EmbeddedFrag
EmbeddedFrag(const RDKit::Bond *dblBond)
Initializer for a cis/trans system using the double bond.
RDDepict::EmbeddedFrag::findCommonAtoms
RDKit::INT_VECT findCommonAtoms(const EmbeddedFrag &efrag2)
Find the common atom ids between this fragment and a second one.
RDDepict::EmbeddedFrag::expandEfrag
void expandEfrag(RDKit::INT_LIST &nratms, std::list< EmbeddedFrag > &efrags)
RDDepict::EmbeddedFrag::findNumNeigh
int findNumNeigh(const RDGeom::Point2D &pt, double radius)
Find all atoms in this embedded system that are within a specified distant of a point.
RDDepict::EmbeddedFrag::removeCollisionsOpenAngles
void removeCollisionsOpenAngles()
Remove collision by opening angles at the offending atoms.
RDDepict::EmbeddedFrag::EmbeddedFrag
EmbeddedFrag(unsigned int aid, const RDKit::ROMol *mol)
Initializer from a single atom id.
RDDepict::EmbeddedFrag::mimicDistMatAndDensityCostFunc
double mimicDistMatAndDensityCostFunc(const DOUBLE_SMART_PTR *dmat, double mimicDmatWt)
RDDepict::EmbeddedFrag::Translate
void Translate(const RDGeom::Point2D &shift)
Definition EmbeddedFrag.h:291
RDDepict::EmbeddedFrag::canonicalizeOrientation
void canonicalizeOrientation()
RDDepict::EmbeddedFrag::getBoxPy
double getBoxPy()
Definition EmbeddedFrag.h:366
RDDepict::EmbeddedFrag::addNonRingAtom
void addNonRingAtom(unsigned int aid, unsigned int toAid)
Add a new non-ring atom to this object.
RDDepict::EmbeddedFrag::permuteBonds
void permuteBonds(unsigned int aid, unsigned int aid1, unsigned int aid2)
RDDepict::EmbeddedFrag::getBoxNy
double getBoxNy()
Definition EmbeddedFrag.h:367
RDDepict::EmbeddedFrag::getMol
const RDKit::ROMol * getMol() const
Get the molecule that this embedded fragment belongs to.
Definition EmbeddedFrag.h:261
RDDepict::EmbeddedFrag::removeCollisionsShortenBonds
void removeCollisionsShortenBonds()
RDDepict::EmbeddedFrag::setupNewNeighs
void setupNewNeighs()
helpers functions to
RDDepict::EmbeddedFrag::Reflect
void Reflect(const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
RDDepict::EmbeddedFrag::computeBox
void computeBox()
compute a box that encloses the fragment
RDDepict::EmbeddedFrag::openAngles
void openAngles(const double *dmat, unsigned int aid1, unsigned int aid2)
RDDepict::EmbeddedFrag::GetEmbeddedAtoms
const INT_EATOM_MAP & GetEmbeddedAtoms() const
Definition EmbeddedFrag.h:289
RDDepict::EmbeddedFrag::mergeWithCommon
void mergeWithCommon(EmbeddedFrag &embObj, RDKit::INT_VECT &commAtms)
Merge this embedded object with another embedded fragment.
RDDepict::EmbeddedFrag::randomSampleFlipsAndPermutations
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)
RDDepict::EmbeddedFrag::isDone
bool isDone()
If this fragment done for the final embedding.
Definition EmbeddedFrag.h:258
RDDepict::EmbeddedFrag::mergeFragsWithComm
void mergeFragsWithComm(std::list< EmbeddedFrag > &efrags)
RDDepict::EmbeddedFrag::findNeighbor
int findNeighbor(unsigned int aid)
Find a neighbor to a non-ring atom among the already embedded atoms.
RDDepict::EmbeddedFrag::computeDistMat
void computeDistMat(DOUBLE_SMART_PTR &dmat)
RDGeom::Point2D
Definition point.h:284
RDGeom::Transform2D
Definition Transform2D.h:22
RDGeom::Transform2D::TransformPoint
void TransformPoint(Point2D &pt) const
RDKit::Bond
class for representing a bond
Definition Bond.h:46
RDKit::ROMol
Definition ROMol.h:199
export.h
RDKIT_DEPICTOR_EXPORT
#define RDKIT_DEPICTOR_EXPORT
Definition export.h:97
RDDepict
Definition Reaction.h:477
RDDepict::DOUBLE_SMART_PTR
boost::shared_array< double > DOUBLE_SMART_PTR
Definition EmbeddedFrag.h:26
RDDepict::INT_EATOM_MAP_I
INT_EATOM_MAP::iterator INT_EATOM_MAP_I
Definition EmbeddedFrag.h:133
RDDepict::reflectPoint
RDKIT_DEPICTOR_EXPORT RDGeom::Point2D reflectPoint(const RDGeom::Point2D &point, const RDGeom::Point2D &loc1, const RDGeom::Point2D &loc2)
RDDepict::INT_EATOM_MAP
std::map< unsigned int, EmbeddedAtom > INT_EATOM_MAP
Definition EmbeddedFrag.h:132
RDDepict::INT_EATOM_MAP_CI
INT_EATOM_MAP::const_iterator INT_EATOM_MAP_CI
Definition EmbeddedFrag.h:134
RDGeom::INT_POINT2D_MAP
std::map< int, Point2D > INT_POINT2D_MAP
Definition point.h:556
RDKit
Std stuff.
Definition Abbreviations.h:19
RDKit::INT_LIST
std::list< int > INT_LIST
Definition types.h:309
RDKit::INT_VECT
std::vector< int > INT_VECT
Definition types.h:303
RDKit::VECT_INT_VECT
std::vector< INT_VECT > VECT_INT_VECT
Definition types.h:317
point.h
types.h