ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/primitives/RigidBody.hpp
(Generate patch)

Comparing trunk/src/primitives/RigidBody.hpp (file contents):
Revision 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 1 | Line 1
1 < #ifndef __RIGIDBODY_HPP__
2 < #define __RIGIDBODY_HPP__
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 > /**
43 > * @file RigidBody.hpp
44 > * @author    tlin
45 > * @date  10/23/2004
46 > * @version 1.0
47 > */
48  
49 + #ifndef PRIMITIVES_RIGIDBODY_HPP
50 + #define PRIMITIVES_RIGIDBODY_HPP
51 +
52   #include <vector>
53 < //#include "primitives/Atom.hpp"
6 < //#include "types/AtomStamp.hpp"
7 < #include "types/RigidBodyStamp.hpp"
53 >
54   #include "primitives/StuntDouble.hpp"
55 < using namespace std;
55 > #include "primitives/DirectionalAtom.hpp"
56 > #include "types/AtomStamp.hpp"
57 > namespace OpenMD{
58 >  class RigidBody : public StuntDouble {
59 >  public:
60  
61 < class Atom;
12 < class AtomStamp;
61 >    typedef std::vector<Atom*>::iterator AtomIterator;        
62  
63 < typedef struct {
15 <  double vec[3];
16 <  double& operator[](int index) {return vec[index];}  
17 < } vec3;
63 >    RigidBody();
64  
65 < typedef struct {
66 <  double mat[3][3];
67 <  double* operator[](int index) {return mat[index];}  
68 < } mat3x3;
65 >    virtual std::string getType() { return name_;}
66 >        
67 >    /** Sets the name of this stuntRealType*/
68 >    virtual void setType(const std::string& name) { name_ = name;}
69 >    
70  
71 < class RigidBody : public StuntDouble {
71 >    /**
72 >     * Sets  the previous rotation matrix of this stuntdouble
73 >     * @param a  new rotation matrix
74 >     */        
75 >    virtual void setPrevA(const RotMat3x3d& a);
76 >      
77 >    /**
78 >     * Sets  the current rotation matrix of this stuntdouble
79 >     * @param a  new rotation matrix
80 >     * @note setA will not change the position and rotation matrix of Directional atoms belong to
81 >     * this rigidbody. If you want to do that, use #updateAtoms
82 >     */        
83 >    virtual void setA(const RotMat3x3d& a);
84 >    /**
85 >     * Sets  the rotation matrix of this stuntdouble in specified snapshot
86 >     * @param a rotation matrix to be set
87 >     * @param snapshotNo
88 >     * @see #getA
89 >     */        
90 >    virtual void setA(const RotMat3x3d& a, int snapshotNo);
91  
92 < public:
93 <  
94 <  RigidBody();
95 <  //RigidBody(const RigidBody& rb);
96 <  
31 <  virtual ~RigidBody();
32 <
33 <  void addAtom(Atom* at, AtomStamp* ats);
92 >    /**
93 >     * Returns the inertia tensor of this stuntdouble
94 >     * @return the inertia tensor of this stuntdouble
95 >     */
96 >    virtual Mat3x3d getI();
97  
35 –  void getPos( double theP[3] );
36 –  void setPos( double theP[3] );
98  
99 <  void getVel( double theV[3] );
100 <  void setVel( double theV[3] );
99 >    /** Sets the internal unit frame of this stuntdouble by three euler angles */
100 >    void setElectroFrameFromEuler(RealType phi, RealType theta, RealType psi);
101 >        
102 >    /**
103 >     * Returns the gradient of this stuntdouble
104 >     * @return the inertia tensor of this stuntdouble
105 >     * @see #setI
106 >     */
107 >    virtual std::vector<RealType> getGrad();
108  
109 <  void getFrc( double theF[3] );
42 <  void addFrc( double theF[3] );
43 <  void zeroForces();
44 <  
45 <  virtual bool isLinear() {return is_linear;}
46 <  virtual int linearAxis() {return linear_axis;}
109 >    virtual void accept(BaseVisitor* v);
110  
111 <  double getMass( void ) { return mass; }
111 >    void addAtom(Atom* at, AtomStamp* ats);
112  
113 <  void printAmatIndex( void );
114 <  void setEuler( double phi, double theta, double psi );
52 <  void getQ( double the_q[4] ); // get the quanternions
53 <  void setQ( double the_q[4] );
113 >    /** calculates the reference coordinates */
114 >    void calcRefCoords();
115  
116 <  void getA( double the_A[3][3] ); // get the full rotation matrix
117 <  void setA( double the_A[3][3] );
116 >    /** Converts Atomic forces and torques to total forces and torques */
117 >    void calcForcesAndTorques();
118  
119 <  void getJ( double theJ[3] );
120 <  void setJ( double theJ[3] );
119 >    /** Converts Atomic forces and torques to total forces and torques and computes the rigid body contribution to the virial.  Returns the rigid body contribution to the virial as a 3x3 matrix. */
120 >    Mat3x3d calcForcesAndTorquesAndVirial();
121  
122 <  virtual void setType(char* type) {strcpy(rbName, type);}
123 <  virtual char* getType() { return rbName;}
122 >    /** update the positions of atoms belong to this rigidbody */
123 >    void updateAtoms();
124  
125 <  void getTrq( double theT[3] );
65 <  void addTrq( double theT[3] );
125 >    void updateAtoms(int frame);
126  
127 <  void getI( double the_I[3][3] );
68 <  void lab2Body( double r[3] );
69 <  void body2Lab( double r[3] );
127 >    void updateAtomVel();
128  
129 <  double getZangle( );
130 <  void setZangle( double zAng );
131 <  void addZangle( double zAng );
129 >    void updateAtomVel(int frame);
130 >        
131 >    Atom* beginAtom(std::vector<Atom*>::iterator& i) {
132 >      i = atoms_.begin();
133 >      return i != atoms_.end() ? *i : NULL;
134 >    }
135  
136 <  void calcRefCoords( void );
137 <  void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
138 <  void calcForcesAndTorques( void );
139 <  void updateAtoms( void );
136 >    Atom* nextAtom(std::vector<Atom*>::iterator& i) {
137 >      ++i;
138 >      return i != atoms_.end() ? *i : NULL;
139 >    }
140  
141 <  //void yourAtomsHaveMoved( void );
141 >    std::vector<Atom*>::iterator getBeginAtomIter() {
142 >      return atoms_.begin();
143 >    }
144 >        
145 >    std::vector<Atom*>::iterator getEndAtomIter() {
146 >      return atoms_.end();
147 >    }
148  
149 <  // Four functions added for derivatives with respect to Euler Angles:
150 <  // (Needed for minimization routines):
149 >    /**
150 >     * Returns the atoms of this rigid body
151 >     * @return the atoms of this rigid body in a vector
152 >     * @deprecate
153 >     */          
154 >    std::vector<Atom*> getAtoms() {
155 >      return atoms_;
156 >    }
157  
158 <  void getGrad(double gradient[6] );
159 <  void getEulerAngles( double myEuler[3] );
160 <
161 <  double max(double x, double y);
162 <  double min(double x, double y);
158 >    /**
159 >     * Returns the number of atoms in this rigid body
160 >     * @return the number of atoms in this rigid body
161 >     */
162 >    int getNumAtoms() {
163 >      return atoms_.size();
164 >    }
165  
166 +    /**
167 +     * Return the position of atom which belongs to this rigid body.
168 +     * @return true if index is valid otherwise return false
169 +     * @param pos the position of atom which will be set on return if index is valid
170 +     * @param index the index of the atom in rigid body's private data member atoms_
171 +     */
172 +    bool getAtomPos(Vector3d& pos, unsigned int index);
173  
174 <  // utility routines
174 >    /**
175 >     * Return the position of atom which belongs to this rigid body.
176 >     * @return true if atom belongs to this rigid body,otherwise return false
177 >     * @param pos position of atom which will be set on return if atom belongs to this rigid body
178 >     * @param atom the pointer to an atom
179 >     */            
180 >    bool getAtomPos(Vector3d& pos, Atom* atom);
181  
182 <  void findCOM( void );
182 >    /**
183 >     * Return the velocity of atom which belongs to this rigid body.
184 >     * @return true if index is valid otherwise return false
185 >     * @param vel the velocity of atom which will be set on return if index is valid
186 >     * @param index the index of the atom in rigid body's private data member atoms_
187 >     */
188 >    bool getAtomVel(Vector3d& vel, unsigned int index);
189  
190 <  virtual void accept(BaseVisitor* v);
190 >    /**
191 >     * Return the velocity of atom which belongs to this rigid body.
192 >     * @return true if atom belongs to this rigid body,otherwise return false
193 >     * @param vel velocity of atom which will be set on return if atom belongs to this rigid body
194 >     * @param atom the pointer to an atom
195 >     */
196 >    bool getAtomVel(Vector3d& vel, Atom*);
197  
198 <  vector<Atom*> getAtoms() { return myAtoms;}
199 <  int getNumAtoms() {return myAtoms.size();}
198 >    /**
199 >     * Return the reference coordinate of atom which belongs to this rigid body.
200 >     * @return true if index is valid otherwise return false
201 >     * @param coor the reference coordinate of atom which will be set on return if index is valid
202 >     * @param index the index of the atom in rigid body's private data member atoms_
203 >     */
204 >    bool getAtomRefCoor(Vector3d& coor, unsigned int index);
205  
206 <  void getAtomPos(double theP[3], int index);
207 <  void getAtomVel(double theV[3], int index);
208 <  void getAtomRefCoor(double pos[3], int index);
209 < protected:
206 >    /**
207 >     * Return the velocity of atom which belongs to this rigid body.
208 >     * @return true if atom belongs to this rigid body,otherwise return false
209 >     * @param coor velocity of atom which will be set on return if atom belongs to this rigid body
210 >     * @param atom the pointer to an atom
211 >     */
212 >    bool getAtomRefCoor(Vector3d& coor, Atom* atom);
213  
214 <  double mass;     // the total mass
215 <  double pos[3];   // the position array (center of mass)
216 <  double vel[3];   // the velocity array (center of mass)
217 <  double frc[3];   // the force array    (center of mass)
218 <  double trq[3];   // the torque vector  ( space fixed )
219 <  double ji[3];    // the angular momentum vector (body fixed)
220 <  double A[3][3];  // the rotation matrix
221 <  double I[3][3];  // the inertial tensor (body fixed)
222 <  double sU[3][3]; // the standard unit vectors (body fixed)
115 <  double zAngle;   // the rotation about the z-axis (body fixed)
214 >  private:
215 >    std::string name_;        
216 >    Mat3x3d inertiaTensor_;    
217 >    RotMat3x3d sU_;               /**< body fixed standard unit vector */
218 >        
219 >    std::vector<Atom*> atoms_;
220 >    std::vector<Vector3d> refCoords_;
221 >    std::vector<RotMat3x3d> refOrients_;
222 >  };
223  
224 <  bool is_linear;
118 <  int linear_axis;
119 <  double momIntTol;
224 > }//namespace OpenMD
225  
226 <  vector<Atom*> myAtoms;  // the vector of atoms
122 <  vector<vec3> refCoords;
123 <  vector<mat3x3> refOrients;
226 > #endif //PRIMITIVES_RIGIDBODY_HPP
227  
125 –  char rbName[100]; //it will eventually be converted into string
126 – };
127 –
128 – #endif

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines