30 |
|
* @version 1.0 |
31 |
|
*/ |
32 |
|
|
33 |
– |
#include "primitives/Molecule.hpp" |
33 |
|
#include <algorithm> |
34 |
+ |
#include <set> |
35 |
|
|
36 |
+ |
#include "primitives/Molecule.hpp" |
37 |
+ |
#include "utils/MemoryUtils.hpp" |
38 |
+ |
|
39 |
|
namespace oopse { |
40 |
|
|
41 |
|
Molecule::~Molecule() { |
42 |
|
|
43 |
< |
deleteVectorOfPointer(atoms_); |
44 |
< |
deleteVectorOfPointer(bonds_); |
45 |
< |
deleteVectorOfPointer(bends_); |
46 |
< |
deleteVectorOfPointer(torsions_); |
47 |
< |
deleteVectorOfPointer(rigidbodies_); |
48 |
< |
deleteVectorOfPointer(cutoffGroups_); |
43 |
> |
MemoryUtils::deleteVectorOfPointer(atoms_); |
44 |
> |
MemoryUtils::deleteVectorOfPointer(bonds_); |
45 |
> |
MemoryUtils::deleteVectorOfPointer(bends_); |
46 |
> |
MemoryUtils::deleteVectorOfPointer(torsions_); |
47 |
> |
MemoryUtils::deleteVectorOfPointer(rigidBodies_); |
48 |
> |
MemoryUtils::deleteVectorOfPointer(cutoffGroups_); |
49 |
|
|
50 |
+ |
//integrableObjects_ don't own the objects |
51 |
|
integrableObjects_.clear(); |
52 |
|
|
53 |
|
} |
54 |
|
|
55 |
|
void Molecule::addAtom(Atom* atom) { |
56 |
< |
if (atoms_.find(atom) == atoms_.end()) { |
56 |
> |
if (std::find(atoms_.begin(), atoms_.end(), atom) == atoms_.end()) { |
57 |
|
atoms_.push_back(atom); |
58 |
|
} |
59 |
|
} |
60 |
|
|
61 |
|
void Molecule::addBond(Bond* bond) { |
62 |
< |
if (bonds_.find(bond) == bonds_.end()) { |
62 |
> |
if (std::find(bonds_.begin(), bonds_.end(), bond) == bonds_.end()) { |
63 |
|
bonds_.push_back(bond); |
64 |
|
} |
65 |
|
} |
66 |
|
|
67 |
|
void Molecule::addBend(Bend* bend) { |
68 |
< |
if (bends_.find(bend) == bends_.end()) { |
68 |
> |
if (std::find(bends_.begin(), bends_.end(), bend) == bends_.end()) { |
69 |
|
bends_.push_back(bend); |
70 |
|
} |
71 |
|
} |
72 |
|
|
73 |
|
void Molecule::addTorsion(Torsion* torsion) { |
74 |
< |
if (torsions_.find(torsion) == torsions_.end()) { |
74 |
> |
if (std::find(torsions_.begin(), torsions_.end(), torsion) == torsions_.end()) { |
75 |
|
torsions_.push_back(torsion); |
76 |
|
} |
77 |
|
} |
78 |
|
|
79 |
|
void Molecule::addRigidBody(RigidBody *rb) { |
80 |
< |
if (rigidBodies_.find(bond) == bonds_.end()) { |
80 |
> |
if (std::find(rigidBodies_.begin(), rigidBodies_.end(), rb) == rigidBodies_.end()) { |
81 |
|
rigidBodies_.push_back(rb); |
82 |
|
} |
83 |
|
} |
84 |
|
|
85 |
|
void Molecule::addCutoffGroup(CutoffGroup* cp) { |
86 |
< |
if (cutoffGroups_.find(bond) == bonds_.end()) { |
86 |
> |
if (std::find(cutoffGroups_.begin(), cutoffGroups_.end(), cp) == cutoffGroups_.end()) { |
87 |
|
cutoffGroups_.push_back(cp); |
88 |
|
} |
89 |
|
|
96 |
|
|
97 |
|
std::set<Atom*> rigidAtoms; |
98 |
|
RigidBody* rb; |
99 |
< |
std::vector<RigidBody*> rbIter; |
99 |
> |
std::vector<RigidBody*>::iterator rbIter; |
100 |
|
|
101 |
|
|
102 |
|
for (rb = beginRigidBody(rbIter); rb != NULL; rb = nextRigidBody(rbIter)) { |
103 |
< |
rigidAtoms.insert(rb->beginAtomIter(), rb->endAtomIter()); |
103 |
> |
rigidAtoms.insert(rb->getBeginAtomIter(), rb->getEndAtomIter()); |
104 |
|
} |
105 |
|
|
106 |
|
//find all free atoms (which do not belong to rigid bodies) |
194 |
|
Bond* bond; |
195 |
|
Bend* bend; |
196 |
|
Torsion* torsion; |
197 |
< |
std::vector<RigidBody*> rbIter; |
198 |
< |
std::vector<Bond*> bondIter;; |
199 |
< |
std::vector<Bend*> bendIter; |
200 |
< |
std::vector<Torsion*> torsionIter; |
197 |
> |
std::vector<RigidBody*>::iterator rbIter; |
198 |
> |
std::vector<Bond*>::iterator bondIter;; |
199 |
> |
std::vector<Bend*>::iterator bendIter; |
200 |
> |
std::vector<Torsion*>::iterator torsionIter; |
201 |
|
|
202 |
|
for (rb = beginRigidBody(rbIter); rb != NULL; rb = nextRigidBody(rbIter)) { |
203 |
|
rb->updateAtoms(); |
204 |
|
} |
205 |
|
|
206 |
|
for (bond = beginBond(bondIter); bond != NULL; bond = nextBond(bondIter)) { |
207 |
< |
bond->calcForce(); |
207 |
> |
bond->calc_forces(); |
208 |
|
} |
209 |
|
|
210 |
|
for (bend = beginBend(bendIter); bend != NULL; bend = nextBend(bendIter)) { |
211 |
< |
bend->calcForce(); |
211 |
> |
bend->calc_forces(); |
212 |
|
} |
213 |
|
|
214 |
|
for (torsion = beginTorsion(torsionIter); torsion != NULL; torsion = nextTorsion(torsionIter)) { |
215 |
< |
torsion->calcForce(); |
215 |
> |
torsion->calc_forces(); |
216 |
|
} |
217 |
|
|
218 |
|
} |
223 |
|
Bend* bend; |
224 |
|
Torsion* torsion; |
225 |
|
//std::vector<RigidBody*> rbIter; |
226 |
< |
std::vector<Bond*> bondIter;; |
227 |
< |
std::vector<Bend*> bendIter; |
228 |
< |
std::vector<Torsion*> torsionIter; |
226 |
> |
std::vector<Bond*>::iterator bondIter;; |
227 |
> |
std::vector<Bend*>::iterator bendIter; |
228 |
> |
std::vector<Torsion*>::iterator torsionIter; |
229 |
|
|
230 |
|
double potential = 0; |
231 |
|
|
234 |
|
//} |
235 |
|
|
236 |
|
for (bond = beginBond(bondIter); bond != NULL; bond = nextBond(bondIter)) { |
237 |
< |
potential += bond->getPotential(); |
237 |
> |
potential += bond->get_potential(); |
238 |
|
} |
239 |
|
|
240 |
|
for (bend = beginBend(bendIter); bend != NULL; bend = nextBend(bendIter)) { |
241 |
< |
potential += bend->getPotential(); |
241 |
> |
potential += bend->get_potential(); |
242 |
|
} |
243 |
|
|
244 |
|
for (torsion = beginTorsion(torsionIter); torsion != NULL; torsion = nextTorsion(torsionIter)) { |
245 |
< |
potential += torsion->getPotential(); |
245 |
> |
potential += torsion->get_potential(); |
246 |
|
} |
247 |
|
|
248 |
|
return potential; |
266 |
|
return com; |
267 |
|
} |
268 |
|
|
269 |
< |
void Molecule::moveCom(const Vetor3d& delta) { |
269 |
> |
void Molecule::moveCom(const Vector3d& delta) { |
270 |
|
StuntDouble* sd; |
271 |
|
std::vector<StuntDouble*>::iterator i; |
272 |
|
|
273 |
|
for (sd = beginIntegrableObject(i); sd != NULL; sd = nextIntegrableObject(i)){ |
274 |
< |
s->setPos(sd->getPos() + delta); |
274 |
> |
sd->setPos(sd->getPos() + delta); |
275 |
|
} |
276 |
|
|
277 |
|
} |
294 |
|
return velCom; |
295 |
|
} |
296 |
|
|
297 |
< |
std::ostream& operator <<(std::ostream& o, const Molecule& mol) { |
297 |
> |
std::ostream& operator <<(std::ostream& o, Molecule& mol) { |
298 |
|
o << std::endl; |
299 |
|
o << "Molecule " << mol.getGlobalIndex() << "has: " << std::endl; |
300 |
|
o << mol.getNAtoms() << " atoms" << std::endl; |