1 |
/* |
2 |
* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved. |
3 |
* |
4 |
* The University of Notre Dame grants you ("Licensee") a |
5 |
* non-exclusive, royalty free, license to use, modify and |
6 |
* redistribute this software in source and binary code form, provided |
7 |
* that the following conditions are met: |
8 |
* |
9 |
* 1. Acknowledgement of the program authors must be made in any |
10 |
* publication of scientific results based in part on use of the |
11 |
* program. An acceptable form of acknowledgement is citation of |
12 |
* the article in which the program was described (Matthew |
13 |
* A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher |
14 |
* J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented |
15 |
* Parallel Simulation Engine for Molecular Dynamics," |
16 |
* J. Comput. Chem. 26, pp. 252-271 (2005)) |
17 |
* |
18 |
* 2. Redistributions of source code must retain the above copyright |
19 |
* notice, this list of conditions and the following disclaimer. |
20 |
* |
21 |
* 3. Redistributions in binary form must reproduce the above copyright |
22 |
* notice, this list of conditions and the following disclaimer in the |
23 |
* documentation and/or other materials provided with the |
24 |
* distribution. |
25 |
* |
26 |
* This software is provided "AS IS," without a warranty of any |
27 |
* kind. All express or implied conditions, representations and |
28 |
* warranties, including any implied warranty of merchantability, |
29 |
* fitness for a particular purpose or non-infringement, are hereby |
30 |
* excluded. The University of Notre Dame and its licensors shall not |
31 |
* be liable for any damages suffered by licensee as a result of |
32 |
* using, modifying or distributing the software or its |
33 |
* derivatives. In no event will the University of Notre Dame or its |
34 |
* licensors be liable for any lost revenue, profit or data, or for |
35 |
* direct, indirect, special, consequential, incidental or punitive |
36 |
* damages, however caused and regardless of the theory of liability, |
37 |
* arising out of the use of or inability to use software, even if the |
38 |
* University of Notre Dame has been advised of the possibility of |
39 |
* such damages. |
40 |
*/ |
41 |
|
42 |
/** |
43 |
* @file MoleculeCreator.cpp |
44 |
* @author tlin |
45 |
* @date 11/04/2004 |
46 |
* @time 13:44am |
47 |
* @version 1.0 |
48 |
*/ |
49 |
|
50 |
#include <cassert> |
51 |
#include <typeinfo> |
52 |
#include <set> |
53 |
|
54 |
#include "brains/MoleculeCreator.hpp" |
55 |
#include "primitives/GhostBend.hpp" |
56 |
#include "primitives/GhostTorsion.hpp" |
57 |
#include "types/DirectionalAtomType.hpp" |
58 |
#include "types/FixedBondType.hpp" |
59 |
#include "utils/simError.h" |
60 |
#include "utils/StringUtils.hpp" |
61 |
|
62 |
namespace oopse { |
63 |
|
64 |
Molecule* MoleculeCreator::createMolecule(ForceField* ff, MoleculeStamp *molStamp, |
65 |
int stampId, int globalIndex, LocalIndexManager* localIndexMan) { |
66 |
|
67 |
Molecule* mol = new Molecule(stampId, globalIndex, molStamp->getName()); |
68 |
|
69 |
//create atoms |
70 |
Atom* atom; |
71 |
AtomStamp* currentAtomStamp; |
72 |
int nAtom = molStamp->getNAtoms(); |
73 |
for (int i = 0; i < nAtom; ++i) { |
74 |
currentAtomStamp = molStamp->getAtomStamp(i); |
75 |
atom = createAtom(ff, mol, currentAtomStamp, localIndexMan); |
76 |
mol->addAtom(atom); |
77 |
} |
78 |
|
79 |
//create rigidbodies |
80 |
RigidBody* rb; |
81 |
RigidBodyStamp * currentRigidBodyStamp; |
82 |
int nRigidbodies = molStamp->getNRigidBodies(); |
83 |
|
84 |
for (int i = 0; i < nRigidbodies; ++i) { |
85 |
currentRigidBodyStamp = molStamp->getRigidBodyStamp(i); |
86 |
rb = createRigidBody(molStamp, mol, currentRigidBodyStamp, localIndexMan); |
87 |
mol->addRigidBody(rb); |
88 |
} |
89 |
|
90 |
//create bonds |
91 |
Bond* bond; |
92 |
BondStamp* currentBondStamp; |
93 |
int nBonds = molStamp->getNBonds(); |
94 |
|
95 |
for (int i = 0; i < nBonds; ++i) { |
96 |
currentBondStamp = molStamp->getBondStamp(i); |
97 |
bond = createBond(ff, mol, currentBondStamp); |
98 |
mol->addBond(bond); |
99 |
} |
100 |
|
101 |
//create bends |
102 |
Bend* bend; |
103 |
BendStamp* currentBendStamp; |
104 |
int nBends = molStamp->getNBends(); |
105 |
for (int i = 0; i < nBends; ++i) { |
106 |
currentBendStamp = molStamp->getBendStamp(i); |
107 |
bend = createBend(ff, mol, currentBendStamp); |
108 |
mol->addBend(bend); |
109 |
} |
110 |
|
111 |
//create torsions |
112 |
Torsion* torsion; |
113 |
TorsionStamp* currentTorsionStamp; |
114 |
int nTorsions = molStamp->getNTorsions(); |
115 |
for (int i = 0; i < nTorsions; ++i) { |
116 |
currentTorsionStamp = molStamp->getTorsionStamp(i); |
117 |
torsion = createTorsion(ff, mol, currentTorsionStamp); |
118 |
mol->addTorsion(torsion); |
119 |
} |
120 |
|
121 |
//create cutoffGroups |
122 |
CutoffGroup* cutoffGroup; |
123 |
CutoffGroupStamp* currentCutoffGroupStamp; |
124 |
int nCutoffGroups = molStamp->getNCutoffGroups(); |
125 |
for (int i = 0; i < nCutoffGroups; ++i) { |
126 |
currentCutoffGroupStamp = molStamp->getCutoffGroupStamp(i); |
127 |
cutoffGroup = createCutoffGroup(mol, currentCutoffGroupStamp); |
128 |
mol->addCutoffGroup(cutoffGroup); |
129 |
} |
130 |
|
131 |
//every free atom is a cutoff group |
132 |
std::vector<Atom*> freeAtoms; |
133 |
std::vector<Atom*>::iterator ai; |
134 |
std::vector<Atom*>::iterator fai; |
135 |
|
136 |
//add all atoms into allAtoms set |
137 |
for(atom = mol->beginAtom(fai); atom != NULL; atom = mol->nextAtom(fai)) { |
138 |
freeAtoms.push_back(atom); |
139 |
} |
140 |
|
141 |
Molecule::CutoffGroupIterator ci; |
142 |
CutoffGroup* cg; |
143 |
|
144 |
for (cg = mol->beginCutoffGroup(ci); cg != NULL; cg = mol->nextCutoffGroup(ci)) { |
145 |
|
146 |
for(atom = cg->beginAtom(ai); atom != NULL; atom = cg->nextAtom(ai)) { |
147 |
//erase the atoms belong to cutoff groups from freeAtoms vector |
148 |
freeAtoms.erase(std::remove(freeAtoms.begin(), freeAtoms.end(), atom), freeAtoms.end()); |
149 |
} |
150 |
|
151 |
} |
152 |
|
153 |
//loop over the free atoms and then create one cutoff group for every single free atom |
154 |
|
155 |
for (fai = freeAtoms.begin(); fai != freeAtoms.end(); ++fai) { |
156 |
cutoffGroup = createCutoffGroup(mol, *fai); |
157 |
mol->addCutoffGroup(cutoffGroup); |
158 |
} |
159 |
//create constraints |
160 |
createConstraintPair(mol); |
161 |
createConstraintElem(mol); |
162 |
|
163 |
//the construction of this molecule is finished |
164 |
mol->complete(); |
165 |
|
166 |
return mol; |
167 |
} |
168 |
|
169 |
|
170 |
Atom* MoleculeCreator::createAtom(ForceField* ff, Molecule* mol, AtomStamp* stamp, |
171 |
LocalIndexManager* localIndexMan) { |
172 |
AtomType * atomType; |
173 |
Atom* atom; |
174 |
|
175 |
atomType = ff->getAtomType(stamp->getType()); |
176 |
|
177 |
if (atomType == NULL) { |
178 |
sprintf(painCave.errMsg, "Can not find Matching Atom Type for[%s]", |
179 |
stamp->getType().c_str()); |
180 |
|
181 |
painCave.isFatal = 1; |
182 |
simError(); |
183 |
} |
184 |
|
185 |
//below code still have some kind of hard-coding smell |
186 |
if (atomType->isDirectional()){ |
187 |
|
188 |
DirectionalAtomType* dAtomType = dynamic_cast<DirectionalAtomType*>(atomType); |
189 |
|
190 |
if (dAtomType == NULL) { |
191 |
sprintf(painCave.errMsg, "Can not cast AtomType to DirectionalAtomType"); |
192 |
|
193 |
painCave.isFatal = 1; |
194 |
simError(); |
195 |
} |
196 |
|
197 |
DirectionalAtom* dAtom; |
198 |
dAtom = new DirectionalAtom(dAtomType); |
199 |
atom = dAtom; |
200 |
} |
201 |
else{ |
202 |
atom = new Atom(atomType); |
203 |
} |
204 |
|
205 |
atom->setLocalIndex(localIndexMan->getNextAtomIndex()); |
206 |
|
207 |
return atom; |
208 |
} |
209 |
|
210 |
RigidBody* MoleculeCreator::createRigidBody(MoleculeStamp *molStamp, Molecule* mol, |
211 |
RigidBodyStamp* rbStamp, |
212 |
LocalIndexManager* localIndexMan) { |
213 |
Atom* atom; |
214 |
int nAtoms; |
215 |
Vector3d refCoor; |
216 |
AtomStamp* atomStamp; |
217 |
|
218 |
RigidBody* rb = new RigidBody(); |
219 |
nAtoms = rbStamp->getNMembers(); |
220 |
for (int i = 0; i < nAtoms; ++i) { |
221 |
//rbStamp->getMember(i) return the local index of current atom inside the molecule. |
222 |
//It is not the same as local index of atom which is the index of atom at DataStorage class |
223 |
atom = mol->getAtomAt(rbStamp->getMemberAt(i)); |
224 |
atomStamp= molStamp->getAtomStamp(rbStamp->getMemberAt(i)); |
225 |
rb->addAtom(atom, atomStamp); |
226 |
} |
227 |
|
228 |
//after all of the atoms are added, we need to calculate the reference coordinates |
229 |
rb->calcRefCoords(); |
230 |
|
231 |
//set the local index of this rigid body, global index will be set later |
232 |
rb->setLocalIndex(localIndexMan->getNextRigidBodyIndex()); |
233 |
|
234 |
//the rule for naming rigidbody MoleculeName_RB_Integer |
235 |
//The first part is the name of the molecule |
236 |
//The second part is alway fixed as "RB" |
237 |
//The third part is the index of the rigidbody defined in meta-data file |
238 |
//For example, Butane_RB_0 is a valid rigid body name of butane molecule |
239 |
/**@todo replace itoa by lexi_cast */ |
240 |
std::string s = OOPSE_itoa(mol->getNRigidBodies(), 10); |
241 |
rb->setType(mol->getType() + "_RB_" + s.c_str()); |
242 |
|
243 |
return rb; |
244 |
} |
245 |
|
246 |
Bond* MoleculeCreator::createBond(ForceField* ff, Molecule* mol, BondStamp* stamp) { |
247 |
BondType* bondType; |
248 |
Atom* atomA; |
249 |
Atom* atomB; |
250 |
|
251 |
atomA = mol->getAtomAt(stamp->getA()); |
252 |
atomB = mol->getAtomAt(stamp->getB()); |
253 |
|
254 |
assert( atomA && atomB); |
255 |
|
256 |
bondType = ff->getBondType(atomA->getType(), atomB->getType()); |
257 |
|
258 |
if (bondType == NULL) { |
259 |
sprintf(painCave.errMsg, "Can not find Matching Bond Type for[%s, %s]", |
260 |
atomA->getType().c_str(), |
261 |
atomB->getType().c_str()); |
262 |
|
263 |
painCave.isFatal = 1; |
264 |
simError(); |
265 |
} |
266 |
return new Bond(atomA, atomB, bondType); |
267 |
} |
268 |
|
269 |
Bend* MoleculeCreator::createBend(ForceField* ff, Molecule* mol, BendStamp* stamp) { |
270 |
Bend* bend = NULL; |
271 |
std::vector<int> bendAtoms = stamp->getMembers(); |
272 |
if (bendAtoms.size() == 3) { |
273 |
Atom* atomA = mol->getAtomAt(bendAtoms[0]); |
274 |
Atom* atomB = mol->getAtomAt(bendAtoms[1]); |
275 |
Atom* atomC = mol->getAtomAt(bendAtoms[2]); |
276 |
|
277 |
assert( atomA && atomB && atomC); |
278 |
|
279 |
BendType* bendType = ff->getBendType(atomA->getType().c_str(), atomB->getType().c_str(), atomC->getType().c_str()); |
280 |
|
281 |
if (bendType == NULL) { |
282 |
sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", |
283 |
atomA->getType().c_str(), |
284 |
atomB->getType().c_str(), |
285 |
atomC->getType().c_str()); |
286 |
|
287 |
painCave.isFatal = 1; |
288 |
simError(); |
289 |
} |
290 |
|
291 |
bend = new Bend(atomA, atomB, atomC, bendType); |
292 |
} else if ( bendAtoms.size() == 2 && stamp->haveGhostVectorSource()) { |
293 |
int ghostIndex = stamp->getGhostVectorSource(); |
294 |
int normalIndex = ghostIndex != bendAtoms[0] ? bendAtoms[0] : bendAtoms[1]; |
295 |
Atom* normalAtom = mol->getAtomAt(normalIndex) ; |
296 |
DirectionalAtom* ghostAtom = dynamic_cast<DirectionalAtom*>(mol->getAtomAt(ghostIndex)); |
297 |
if (ghostAtom == NULL) { |
298 |
sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); |
299 |
painCave.isFatal = 1; |
300 |
simError(); |
301 |
} |
302 |
|
303 |
BendType* bendType = ff->getBendType(normalAtom->getType(), ghostAtom->getType(), "GHOST"); |
304 |
|
305 |
if (bendType == NULL) { |
306 |
sprintf(painCave.errMsg, "Can not find Matching Bend Type for[%s, %s, %s]", |
307 |
normalAtom->getType().c_str(), |
308 |
ghostAtom->getType().c_str(), |
309 |
"GHOST"); |
310 |
|
311 |
painCave.isFatal = 1; |
312 |
simError(); |
313 |
} |
314 |
|
315 |
bend = new GhostBend(normalAtom, ghostAtom, bendType); |
316 |
|
317 |
} |
318 |
|
319 |
return bend; |
320 |
} |
321 |
|
322 |
Torsion* MoleculeCreator::createTorsion(ForceField* ff, Molecule* mol, TorsionStamp* stamp) { |
323 |
|
324 |
Torsion* torsion = NULL; |
325 |
std::vector<int> torsionAtoms = stamp->getMembers(); |
326 |
if (torsionAtoms.size() < 3) { |
327 |
return torsion; |
328 |
} |
329 |
|
330 |
Atom* atomA = mol->getAtomAt(torsionAtoms[0]); |
331 |
Atom* atomB = mol->getAtomAt(torsionAtoms[1]); |
332 |
Atom* atomC = mol->getAtomAt(torsionAtoms[2]); |
333 |
|
334 |
if (torsionAtoms.size() == 4) { |
335 |
Atom* atomD = mol->getAtomAt(torsionAtoms[3]); |
336 |
|
337 |
assert(atomA && atomB && atomC && atomD); |
338 |
|
339 |
TorsionType* torsionType = ff->getTorsionType(atomA->getType(), atomB->getType(), |
340 |
atomC->getType(), atomD->getType()); |
341 |
|
342 |
if (torsionType == NULL) { |
343 |
sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", |
344 |
atomA->getType().c_str(), |
345 |
atomB->getType().c_str(), |
346 |
atomC->getType().c_str(), |
347 |
atomD->getType().c_str()); |
348 |
|
349 |
painCave.isFatal = 1; |
350 |
simError(); |
351 |
} |
352 |
|
353 |
torsion = new Torsion(atomA, atomB, atomC, atomD, torsionType); |
354 |
} |
355 |
else { |
356 |
|
357 |
DirectionalAtom* dAtom = dynamic_cast<DirectionalAtom*>(mol->getAtomAt(stamp->getGhostVectorSource())); |
358 |
if (dAtom == NULL) { |
359 |
sprintf(painCave.errMsg, "Can not cast Atom to DirectionalAtom"); |
360 |
painCave.isFatal = 1; |
361 |
simError(); |
362 |
} |
363 |
|
364 |
TorsionType* torsionType = ff->getTorsionType(atomA->getType(), atomB->getType(), |
365 |
atomC->getType(), "GHOST"); |
366 |
|
367 |
if (torsionType == NULL) { |
368 |
sprintf(painCave.errMsg, "Can not find Matching Torsion Type for[%s, %s, %s, %s]", |
369 |
atomA->getType().c_str(), |
370 |
atomB->getType().c_str(), |
371 |
atomC->getType().c_str(), |
372 |
"GHOST"); |
373 |
|
374 |
painCave.isFatal = 1; |
375 |
simError(); |
376 |
} |
377 |
|
378 |
torsion = new GhostTorsion(atomA, atomB, dAtom, torsionType); |
379 |
} |
380 |
|
381 |
return torsion; |
382 |
} |
383 |
|
384 |
CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule* mol, CutoffGroupStamp* stamp) { |
385 |
int nAtoms; |
386 |
CutoffGroup* cg; |
387 |
Atom* atom; |
388 |
cg = new CutoffGroup(); |
389 |
|
390 |
nAtoms = stamp->getNMembers(); |
391 |
for (int i =0; i < nAtoms; ++i) { |
392 |
atom = mol->getAtomAt(stamp->getMemberAt(i)); |
393 |
assert(atom); |
394 |
cg->addAtom(atom); |
395 |
} |
396 |
|
397 |
return cg; |
398 |
} |
399 |
|
400 |
CutoffGroup* MoleculeCreator::createCutoffGroup(Molecule * mol, Atom* atom) { |
401 |
CutoffGroup* cg; |
402 |
cg = new CutoffGroup(); |
403 |
cg->addAtom(atom); |
404 |
return cg; |
405 |
} |
406 |
|
407 |
void MoleculeCreator::createConstraintPair(Molecule* mol) { |
408 |
|
409 |
//add bond constraints |
410 |
Molecule::BondIterator bi; |
411 |
Bond* bond; |
412 |
for (bond = mol->beginBond(bi); bond != NULL; bond = mol->nextBond(bi)) { |
413 |
|
414 |
BondType* bt = bond->getBondType(); |
415 |
|
416 |
//class Parent1 {}; |
417 |
//class Child1 : public Parent {}; |
418 |
//class Child2 : public Parent {}; |
419 |
//Child1* ch1 = new Child1(); |
420 |
//Child2* ch2 = dynamic_cast<Child2*>(ch1); |
421 |
//the dynamic_cast is succeed in above line. A compiler bug? |
422 |
|
423 |
if (typeid(FixedBondType) == typeid(*bt)) { |
424 |
FixedBondType* fbt = dynamic_cast<FixedBondType*>(bt); |
425 |
|
426 |
ConstraintElem* consElemA = new ConstraintElem(bond->getAtomA()); |
427 |
ConstraintElem* consElemB = new ConstraintElem(bond->getAtomB()); |
428 |
ConstraintPair* consPair = new ConstraintPair(consElemA, consElemB, fbt->getEquilibriumBondLength()); |
429 |
mol->addConstraintPair(consPair); |
430 |
} |
431 |
} |
432 |
|
433 |
//rigidbody -- rigidbody constraint is not support yet |
434 |
} |
435 |
|
436 |
void MoleculeCreator::createConstraintElem(Molecule* mol) { |
437 |
|
438 |
ConstraintPair* consPair; |
439 |
Molecule::ConstraintPairIterator cpi; |
440 |
std::set<StuntDouble*> sdSet; |
441 |
for (consPair = mol->beginConstraintPair(cpi); consPair != NULL; consPair = mol->nextConstraintPair(cpi)) { |
442 |
|
443 |
StuntDouble* sdA = consPair->getConsElem1()->getStuntDouble(); |
444 |
if (sdSet.find(sdA) == sdSet.end()){ |
445 |
sdSet.insert(sdA); |
446 |
mol->addConstraintElem(new ConstraintElem(sdA)); |
447 |
} |
448 |
|
449 |
StuntDouble* sdB = consPair->getConsElem2()->getStuntDouble(); |
450 |
if (sdSet.find(sdB) == sdSet.end()){ |
451 |
sdSet.insert(sdB); |
452 |
mol->addConstraintElem(new ConstraintElem(sdB)); |
453 |
} |
454 |
|
455 |
} |
456 |
|
457 |
} |
458 |
|
459 |
} |