# | Line 1 | Line 1 | |
---|---|---|
1 | < | #include <iostream> |
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. Redistributions of source code must retain the above copyright |
10 | > | * notice, this list of conditions and the following disclaimer. |
11 | > | * |
12 | > | * 2. Redistributions in binary form must reproduce the above copyright |
13 | > | * notice, this list of conditions and the following disclaimer in the |
14 | > | * documentation and/or other materials provided with the |
15 | > | * distribution. |
16 | > | * |
17 | > | * This software is provided "AS IS," without a warranty of any |
18 | > | * kind. All express or implied conditions, representations and |
19 | > | * warranties, including any implied warranty of merchantability, |
20 | > | * fitness for a particular purpose or non-infringement, are hereby |
21 | > | * excluded. The University of Notre Dame and its licensors shall not |
22 | > | * be liable for any damages suffered by licensee as a result of |
23 | > | * using, modifying or distributing the software or its |
24 | > | * derivatives. In no event will the University of Notre Dame or its |
25 | > | * licensors be liable for any lost revenue, profit or data, or for |
26 | > | * direct, indirect, special, consequential, incidental or punitive |
27 | > | * damages, however caused and regardless of the theory of liability, |
28 | > | * arising out of the use of or inability to use software, even if the |
29 | > | * University of Notre Dame has been advised of the possibility of |
30 | > | * such damages. |
31 | > | * |
32 | > | * SUPPORT OPEN SCIENCE! If you use OpenMD or its source code in your |
33 | > | * research, please cite the appropriate papers when you publish your |
34 | > | * work. Good starting points are: |
35 | > | * |
36 | > | * [1] Meineke, et al., J. Comp. Chem. 26, 252-271 (2005). |
37 | > | * [2] Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006). |
38 | > | * [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008). |
39 | > | * [4] Vardeman & Gezelter, in progress (2009). |
40 | > | */ |
41 | ||
42 | < | using namespace std; |
43 | < | |
5 | < | #include "simError.h" |
6 | < | #include "Atom.hpp" |
7 | < | |
8 | < | Atom::Atom(int theIndex, SimState* theConfig) { |
9 | < | |
10 | < | objType = OT_ATOM; |
11 | < | myConfig = theConfig; |
12 | < | hasCoords = false; |
13 | < | |
14 | < | has_dipole = 0; |
15 | < | has_charge = 0; |
42 | > | #include "primitives/Atom.hpp" |
43 | > | namespace OpenMD { |
44 | ||
45 | < | index = theIndex; |
46 | < | offset = 0; |
47 | < | offsetX = offset; |
20 | < | offsetY = offset+1; |
21 | < | offsetZ = offset+2; |
22 | < | |
23 | < | Axx = 0; |
24 | < | Axy = Axx+1; |
25 | < | Axz = Axx+2; |
26 | < | |
27 | < | Ayx = Axx+3; |
28 | < | Ayy = Axx+4; |
29 | < | Ayz = Axx+5; |
30 | < | |
31 | < | Azx = Axx+6; |
32 | < | Azy = Axx+7; |
33 | < | Azz = Axx+8; |
34 | < | } |
35 | < | |
36 | < | void Atom::setIndex(int theIndex) { |
37 | < | index = theIndex; |
38 | < | } |
39 | < | |
40 | < | void Atom::setCoords(void){ |
41 | < | |
42 | < | if( myConfig->isAllocated() ){ |
43 | < | |
44 | < | myConfig->getAtomPointers( index, |
45 | < | &pos, |
46 | < | &vel, |
47 | < | &frc, |
48 | < | &trq, |
49 | < | &Amat, |
50 | < | &mu, |
51 | < | &ul); |
45 | > | Atom::Atom(AtomType* at) : StuntDouble(otAtom, &Snapshot::atomData), |
46 | > | atomType_(at) { |
47 | > | mass_ = at->getMass(); |
48 | } | |
53 | – | else{ |
54 | – | sprintf( painCave.errMsg, |
55 | – | "Attempted to set Atom %d coordinates with an unallocated " |
56 | – | "SimState object.\n", index ); |
57 | – | painCave.isFatal = 1; |
58 | – | simError(); |
59 | – | } |
60 | – | |
61 | – | hasCoords = true; |
62 | – | |
63 | – | } |
49 | ||
50 | < | void Atom::getPos( double theP[3] ){ |
50 | > | Mat3x3d Atom::getI() { |
51 | > | return Mat3x3d::identity(); |
52 | > | } |
53 | ||
54 | < | if( hasCoords ){ |
55 | < | theP[0] = pos[offsetX]; |
56 | < | theP[1] = pos[offsetY]; |
70 | < | theP[2] = pos[offsetZ]; |
71 | < | } |
72 | < | else{ |
73 | < | |
74 | < | sprintf( painCave.errMsg, |
75 | < | "Attempt to get Pos for atom %d before coords set.\n", |
76 | < | index ); |
77 | < | painCave.isFatal = 1; |
78 | < | simError(); |
79 | < | } |
80 | < | } |
81 | < | |
82 | < | void Atom::setPos( double theP[3] ){ |
83 | < | |
84 | < | if( hasCoords ){ |
85 | < | pos[offsetX] = theP[0]; |
86 | < | pos[offsetY] = theP[1]; |
87 | < | pos[offsetZ] = theP[2]; |
88 | < | } |
89 | < | else{ |
90 | < | |
91 | < | sprintf( painCave.errMsg, |
92 | < | "Attempt to set Pos for atom %d before coords set.\n", |
93 | < | index ); |
94 | < | painCave.isFatal = 1; |
95 | < | simError(); |
96 | < | } |
97 | < | } |
98 | < | |
99 | < | void Atom::getVel( double theV[3] ){ |
100 | < | |
101 | < | if( hasCoords ){ |
102 | < | theV[0] = vel[offsetX]; |
103 | < | theV[1] = vel[offsetY]; |
104 | < | theV[2] = vel[offsetZ]; |
105 | < | } |
106 | < | else{ |
54 | > | std::vector<RealType> Atom::getGrad() { |
55 | > | std::vector<RealType> grad(3); |
56 | > | Vector3d force= getFrc(); |
57 | ||
58 | < | sprintf( painCave.errMsg, |
59 | < | "Attempt to get vel for atom %d before coords set.\n", |
60 | < | index ); |
111 | < | painCave.isFatal = 1; |
112 | < | simError(); |
113 | < | } |
114 | < | |
115 | < | } |
116 | < | |
117 | < | void Atom::setVel( double theV[3] ){ |
118 | < | |
119 | < | if( hasCoords ){ |
120 | < | vel[offsetX] = theV[0]; |
121 | < | vel[offsetY] = theV[1]; |
122 | < | vel[offsetZ] = theV[2]; |
123 | < | } |
124 | < | else{ |
58 | > | grad[0] = -force[0]; |
59 | > | grad[1] = -force[1]; |
60 | > | grad[2] = -force[2]; |
61 | ||
62 | < | sprintf( painCave.errMsg, |
63 | < | "Attempt to set vel for atom %d before coords set.\n", |
128 | < | index ); |
129 | < | painCave.isFatal = 1; |
130 | < | simError(); |
131 | < | } |
132 | < | } |
133 | < | |
134 | < | void Atom::getFrc( double theF[3] ){ |
62 | > | return grad; |
63 | > | } |
64 | ||
65 | < | if( hasCoords ){ |
66 | < | theF[0] = frc[offsetX]; |
67 | < | theF[1] = frc[offsetY]; |
139 | < | theF[2] = frc[offsetZ]; |
140 | < | } |
141 | < | else{ |
142 | < | |
143 | < | sprintf( painCave.errMsg, |
144 | < | "Attempt to get frc for atom %d before coords set.\n", |
145 | < | index ); |
146 | < | painCave.isFatal = 1; |
147 | < | simError(); |
148 | < | } |
65 | > | void Atom::accept(BaseVisitor* v) { |
66 | > | v->visit(this); |
67 | > | } |
68 | } | |
150 | – | |
151 | – | void Atom::addFrc( double theF[3] ){ |
152 | – | |
153 | – | if( hasCoords ){ |
154 | – | frc[offsetX] += theF[0]; |
155 | – | frc[offsetY] += theF[1]; |
156 | – | frc[offsetZ] += theF[2]; |
157 | – | } |
158 | – | else{ |
159 | – | |
160 | – | sprintf( painCave.errMsg, |
161 | – | "Attempt to add frc for atom %d before coords set.\n", |
162 | – | index ); |
163 | – | painCave.isFatal = 1; |
164 | – | simError(); |
165 | – | } |
166 | – | } |
167 | – | |
168 | – | |
169 | – | void Atom::zeroForces( void ){ |
170 | – | |
171 | – | if( hasCoords ){ |
172 | – | frc[offsetX] = 0.0; |
173 | – | frc[offsetY] = 0.0; |
174 | – | frc[offsetZ] = 0.0; |
175 | – | } |
176 | – | else{ |
177 | – | |
178 | – | sprintf( painCave.errMsg, |
179 | – | "Attempt to zero frc for atom %d before coords set.\n", |
180 | – | index ); |
181 | – | painCave.isFatal = 1; |
182 | – | simError(); |
183 | – | } |
184 | – | } |
185 | – |
– | Removed lines |
+ | Added lines |
< | Changed lines |
> | Changed lines |