# | Line 56 | Line 56 | namespace oopse { | |
---|---|---|
56 | namespace oopse { | |
57 | Molecule::Molecule(int stampId, int globalIndex, const std::string& molName) | |
58 | : stampId_(stampId), globalIndex_(globalIndex), moleculeName_(molName) { | |
59 | < | |
60 | < | } |
61 | < | |
59 | > | } |
60 | > | |
61 | Molecule::~Molecule() { | |
62 | < | |
62 | > | |
63 | MemoryUtils::deletePointers(atoms_); | |
64 | MemoryUtils::deletePointers(bonds_); | |
65 | MemoryUtils::deletePointers(bends_); | |
# | Line 69 | Line 68 | namespace oopse { | |
68 | MemoryUtils::deletePointers(cutoffGroups_); | |
69 | MemoryUtils::deletePointers(constraintPairs_); | |
70 | MemoryUtils::deletePointers(constraintElems_); | |
71 | < | //integrableObjects_ don't own the objects |
71 | > | // integrableObjects_ don't own the objects |
72 | integrableObjects_.clear(); | |
73 | ||
74 | } | |
75 | < | |
75 | > | |
76 | void Molecule::addAtom(Atom* atom) { | |
77 | if (std::find(atoms_.begin(), atoms_.end(), atom) == atoms_.end()) { | |
78 | atoms_.push_back(atom); | |
79 | } | |
80 | } | |
81 | < | |
81 | > | |
82 | void Molecule::addBond(Bond* bond) { | |
83 | if (std::find(bonds_.begin(), bonds_.end(), bond) == bonds_.end()) { | |
84 | bonds_.push_back(bond); | |
85 | } | |
86 | } | |
87 | < | |
87 | > | |
88 | void Molecule::addBend(Bend* bend) { | |
89 | if (std::find(bends_.begin(), bends_.end(), bend) == bends_.end()) { | |
90 | bends_.push_back(bend); | |
91 | } | |
92 | } | |
93 | < | |
93 | > | |
94 | void Molecule::addTorsion(Torsion* torsion) { | |
95 | < | if (std::find(torsions_.begin(), torsions_.end(), torsion) == torsions_.end()) { |
95 | > | if (std::find(torsions_.begin(), torsions_.end(), torsion) == |
96 | > | torsions_.end()) { |
97 | torsions_.push_back(torsion); | |
98 | } | |
99 | } | |
100 | < | |
100 | > | |
101 | void Molecule::addRigidBody(RigidBody *rb) { | |
102 | < | if (std::find(rigidBodies_.begin(), rigidBodies_.end(), rb) == rigidBodies_.end()) { |
102 | > | if (std::find(rigidBodies_.begin(), rigidBodies_.end(), rb) == |
103 | > | rigidBodies_.end()) { |
104 | rigidBodies_.push_back(rb); | |
105 | } | |
106 | } | |
107 | < | |
107 | > | |
108 | void Molecule::addCutoffGroup(CutoffGroup* cp) { | |
109 | < | if (std::find(cutoffGroups_.begin(), cutoffGroups_.end(), cp) == cutoffGroups_.end()) { |
109 | > | if (std::find(cutoffGroups_.begin(), cutoffGroups_.end(), cp) == |
110 | > | cutoffGroups_.end()) { |
111 | cutoffGroups_.push_back(cp); | |
112 | < | } |
111 | < | |
112 | > | } |
113 | } | |
114 | < | |
114 | > | |
115 | void Molecule::addConstraintPair(ConstraintPair* cp) { | |
116 | < | if (std::find(constraintPairs_.begin(), constraintPairs_.end(), cp) == constraintPairs_.end()) { |
116 | > | if (std::find(constraintPairs_.begin(), constraintPairs_.end(), cp) == |
117 | > | constraintPairs_.end()) { |
118 | constraintPairs_.push_back(cp); | |
119 | < | } |
118 | < | |
119 | > | } |
120 | } | |
121 | < | |
121 | > | |
122 | void Molecule::addConstraintElem(ConstraintElem* cp) { | |
123 | < | if (std::find(constraintElems_.begin(), constraintElems_.end(), cp) == constraintElems_.end()) { |
123 | > | if (std::find(constraintElems_.begin(), constraintElems_.end(), cp) == |
124 | > | constraintElems_.end()) { |
125 | constraintElems_.push_back(cp); | |
126 | } | |
125 | – | |
127 | } | |
128 | < | |
128 | > | |
129 | void Molecule::complete() { | |
130 | ||
131 | std::set<Atom*> rigidAtoms; | |
# | Line 135 | Line 136 | namespace oopse { | |
136 | for (rb = beginRigidBody(rbIter); rb != NULL; rb = nextRigidBody(rbIter)) { | |
137 | rigidAtoms.insert(rb->getBeginAtomIter(), rb->getEndAtomIter()); | |
138 | } | |
139 | < | |
139 | > | |
140 | Atom* atom; | |
141 | AtomIterator ai; | |
142 | for (atom = beginAtom(ai); atom != NULL; atom = nextAtom(ai)) { | |
143 | < | |
143 | > | |
144 | if (rigidAtoms.find(*ai) == rigidAtoms.end()) { | |
145 | < | //if an atom does not belong to a rigid body, it is an integrable object |
145 | > | |
146 | > | // If an atom does not belong to a rigid body, it is an |
147 | > | // integrable object |
148 | > | |
149 | integrableObjects_.push_back(*ai); | |
150 | } | |
151 | } | |
152 | < | |
152 | > | |
153 | //find all free atoms (which do not belong to rigid bodies) | |
154 | < | //performs the "difference" operation from set theory, the output range contains a copy of every |
155 | < | //element that is contained in [allAtoms.begin(), allAtoms.end()) and not contained in |
156 | < | //[rigidAtoms.begin(), rigidAtoms.end()). |
154 | > | // performs the "difference" operation from set theory, the output |
155 | > | // range contains a copy of every element that is contained in |
156 | > | // [allAtoms.begin(), allAtoms.end()) and not contained in |
157 | > | // [rigidAtoms.begin(), rigidAtoms.end()). |
158 | //std::set_difference(allAtoms.begin(), allAtoms.end(), rigidAtoms.begin(), rigidAtoms.end(), | |
159 | // std::back_inserter(integrableObjects_)); | |
160 | ||
# | Line 170 | Line 175 | namespace oopse { | |
175 | StuntDouble* sd; | |
176 | std::vector<StuntDouble*>::iterator i; | |
177 | RealType mass = 0.0; | |
178 | < | |
179 | < | for (sd = beginIntegrableObject(i); sd != NULL; sd = nextIntegrableObject(i)){ |
178 | > | |
179 | > | for (sd = beginIntegrableObject(i); sd != NULL; sd = |
180 | > | nextIntegrableObject(i)){ |
181 | mass += sd->getMass(); | |
182 | } | |
183 | < | |
184 | < | return mass; |
179 | < | |
183 | > | |
184 | > | return mass; |
185 | } | |
186 | ||
187 | Vector3d Molecule::getCom() { | |
# | Line 186 | Line 191 | namespace oopse { | |
191 | RealType totalMass = 0; | |
192 | RealType mass; | |
193 | ||
194 | < | for (sd = beginIntegrableObject(i); sd != NULL; sd = nextIntegrableObject(i)){ |
194 | > | for (sd = beginIntegrableObject(i); sd != NULL; sd = |
195 | > | nextIntegrableObject(i)){ |
196 | mass = sd->getMass(); | |
197 | totalMass += mass; | |
198 | com += sd->getPos() * mass; | |
199 | } | |
200 | < | |
200 | > | |
201 | com /= totalMass; | |
202 | ||
203 | return com; | |
# | Line 201 | Line 207 | namespace oopse { | |
207 | StuntDouble* sd; | |
208 | std::vector<StuntDouble*>::iterator i; | |
209 | ||
210 | < | for (sd = beginIntegrableObject(i); sd != NULL; sd = nextIntegrableObject(i)){ |
210 | > | for (sd = beginIntegrableObject(i); sd != NULL; sd = |
211 | > | nextIntegrableObject(i)){ |
212 | sd->setPos(sd->getPos() + delta); | |
213 | < | } |
207 | < | |
213 | > | } |
214 | } | |
215 | ||
216 | Vector3d Molecule::getComVel() { | |
# | Line 214 | Line 220 | namespace oopse { | |
220 | RealType totalMass = 0; | |
221 | RealType mass; | |
222 | ||
223 | < | for (sd = beginIntegrableObject(i); sd != NULL; sd = nextIntegrableObject(i)){ |
223 | > | for (sd = beginIntegrableObject(i); sd != NULL; sd = |
224 | > | nextIntegrableObject(i)){ |
225 | mass = sd->getMass(); | |
226 | totalMass += mass; | |
227 | velCom += sd->getVel() * mass; | |
228 | } | |
229 | < | |
229 | > | |
230 | velCom /= totalMass; | |
231 | < | |
231 | > | |
232 | return velCom; | |
233 | } | |
234 | ||
# | Line 244 | Line 251 | namespace oopse { | |
251 | potential += bend->getPotential(); | |
252 | } | |
253 | ||
254 | < | for (torsion = beginTorsion(torsionIter); torsion != NULL; torsion = nextTorsion(torsionIter)) { |
254 | > | for (torsion = beginTorsion(torsionIter); torsion != NULL; torsion = |
255 | > | nextTorsion(torsionIter)) { |
256 | potential += torsion->getPotential(); | |
257 | } | |
258 | < | |
258 | > | |
259 | return potential; | |
260 | < | |
260 | > | |
261 | } | |
262 | < | |
262 | > | |
263 | std::ostream& operator <<(std::ostream& o, Molecule& mol) { | |
264 | o << std::endl; | |
265 | o << "Molecule " << mol.getGlobalIndex() << "has: " << std::endl; | |
# | Line 265 | Line 273 | namespace oopse { | |
273 | o << mol.getNConstraintPairs() << "constraint pairs" << std::endl; | |
274 | return o; | |
275 | } | |
276 | < | |
276 | > | |
277 | }//end namespace oopse |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |