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>
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 {
26typedef 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
132typedef std::map<unsigned int, EmbeddedAtom> INT_EATOM_MAP;
133typedef INT_EATOM_MAP::iterator INT_EATOM_MAP_I;
134typedef 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 */
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
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
int nbr2
the second neighbor of atom that from the 'angle'
Definition: EmbeddedFrag.h:94
RDGeom::Point2D loc
Definition: EmbeddedFrag.h:111
EmbeddedAtom & operator=(const EmbeddedAtom &other)
Definition: EmbeddedFrag.h:50
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.
std::vector< PAIR_I_I > findCollisions(const double *dmat, bool includeBonds=1)
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)
const RDKit::ROMol * getMol() const
Get the molecule that this embedded fragment belongs to.
Definition: EmbeddedFrag.h:258
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
void openAngles(const double *dmat, unsigned int aid1, unsigned int aid2)
const INT_EATOM_MAP & GetEmbeddedAtoms() const
Definition: EmbeddedFrag.h:286
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:19
std::list< int > INT_LIST
Definition: types.h:284
std::vector< int > INT_VECT
Definition: types.h:278
std::vector< INT_VECT > VECT_INT_VECT
Definition: types.h:292