1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
//
// Copyright (C) 2001-2024 Greg Landrum and other RDKit contributors
//
// @@ All Rights Reserved @@
// This file is part of the RDKit.
// The contents are covered by the terms of the BSD license
// which is included in the file license.txt, found at the root
// of the RDKit source tree.
//
#include <RDGeneral/export.h>
#ifndef _RD_CONFORMER_H
#define _RD_CONFORMER_H
#include <Geometry/point.h>
#include <RDGeneral/types.h>
#include <boost/smart_ptr.hpp>
#include <RDGeneral/RDProps.h>
#include <cmath>
#include <limits>
#include <utility>
namespace RDKit {
class ROMol;
//! used to indicate errors from incorrect conformer access
class RDKIT_GRAPHMOL_EXPORT ConformerException : public std::exception {
public:
//! construct with an error message
ConformerException(const char *msg) : _msg(msg) {}
//! construct with an error message
ConformerException(std::string msg) : _msg(std::move(msg)) {}
//! get the error message
const char *what() const noexcept override { return _msg.c_str(); }
~ConformerException() noexcept override = default;
private:
std::string _msg;
};
//! The class for representing 2D or 3D conformation of a molecule
/*!
This class contains
- a pointer to the owing molecule
- a vector of 3D points (positions of atoms)
*/
class RDKIT_GRAPHMOL_EXPORT Conformer : public RDProps {
public:
friend class ROMol;
//! Constructor
Conformer() = default;
//! Constructor with number of atoms specified ID specification
Conformer(unsigned int numAtoms)
: d_positions(numAtoms, RDGeom::Point3D(0.0, 0.0, 0.0)) {}
//! Copy Constructor: initialize from a second conformation.
Conformer(const Conformer &other) = default;
Conformer &operator=(const Conformer &other) = default;
Conformer(Conformer &&o) noexcept
: RDProps(o),
df_is3D(o.df_is3D),
d_id(o.d_id),
dp_mol(o.dp_mol),
d_positions(std::move(o.d_positions)) {}
Conformer &operator=(Conformer &&o) noexcept {
if (this == &o) {
return *this;
}
RDProps::operator=(std::move(o));
df_is3D = o.df_is3D;
d_id = o.d_id;
dp_mol = o.dp_mol;
d_positions = std::move(o.d_positions);
return *this;
}
//! Destructor
~Conformer() = default;
//! Resize the conformer so that more atoms location can be added.
//! Useful, for e.g., when adding hydrogens
void resize(unsigned int size) { d_positions.resize(size); }
//! Reserve more space for atom position
void reserve(unsigned int size) { d_positions.reserve(size); }
//! returns whether or not this instance belongs to a molecule
bool hasOwningMol() const { return dp_mol != nullptr; }
//! Get the molecule that owns this instance
ROMol &getOwningMol() const {
PRECONDITION(dp_mol, "no owner");
return *dp_mol;
}
//! Get a const reference to the vector of atom positions
const RDGeom::POINT3D_VECT &getPositions() const;
//! Get a reference to the atom positions
RDGeom::POINT3D_VECT &getPositions();
//! Get the position of the specified atom
const RDGeom::Point3D &getAtomPos(unsigned int atomId) const;
//! overload
template <class U>
const RDGeom::Point3D &getAtomPos(U atomId) const {
return getAtomPos(rdcast<unsigned int>(atomId));
}
//! Get the position of the specified atom
RDGeom::Point3D &getAtomPos(unsigned int atomId);
//! overload
template <class U>
RDGeom::Point3D &getAtomPos(U atomId) {
return getAtomPos(rdcast<unsigned int>(atomId));
}
//! Set the position of the specified atom
inline void setAtomPos(unsigned int atomId, const RDGeom::Point3D &position) {
if (atomId == std::numeric_limits<unsigned int>::max()) {
throw ValueErrorException("atom index overflow");
}
if (atomId >= d_positions.size()) {
d_positions.resize(atomId + 1, RDGeom::Point3D(0.0, 0.0, 0.0));
}
d_positions[atomId] = position;
}
//! overload
template <class U>
void setAtomPos(U atomId, const RDGeom::Point3D &position) {
return setAtomPos(rdcast<unsigned int>(atomId), position);
}
//! get the ID of this conformer
inline unsigned int getId() const { return d_id; }
//! set the ID of this conformer
inline void setId(unsigned int id) { d_id = id; }
//! Get the number of atoms
inline unsigned int getNumAtoms() const {
return rdcast<unsigned int>(d_positions.size());
}
inline bool is3D() const { return df_is3D; }
inline void set3D(bool v) { df_is3D = v; }
protected:
//! Set owning molecule
void setOwningMol(ROMol *mol);
//! Set owning molecule
void setOwningMol(ROMol &mol);
private:
bool df_is3D{true}; // is this a 3D conformation?
unsigned int d_id{0}; // id is the conformation
ROMol *dp_mol{nullptr}; // owning molecule
RDGeom::POINT3D_VECT d_positions; // positions of the atoms
};
typedef boost::shared_ptr<Conformer> CONFORMER_SPTR;
//! Returns true if any of the z coords are non zero, false otherwise
/*!
\param conf Conformer object to analyze
*/
inline bool hasNonZeroZCoords(const Conformer &conf) {
constexpr double zeroTol = 1e-3;
for (auto p : conf.getPositions()) {
if (std::abs(p.z) > zeroTol) {
return true;
}
}
return false;
}
} // namespace RDKit
#endif
|
