ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/branches/new_design/OOPSE-3.0/src/primitives/RigidBody.hpp
(Generate patch)

Comparing:
trunk/OOPSE-3.0/src/primitives/RigidBody.hpp (file contents), Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/new_design/OOPSE-3.0/src/primitives/RigidBody.hpp (file contents), Revision 1695 by tim, Mon Nov 1 22:52:57 2004 UTC

# Line 1 | Line 1
1 < #ifndef __RIGIDBODY_HPP__
2 < #define __RIGIDBODY_HPP__
1 > /*
2 > * Copyright (C) 2000-2004  Object Oriented Parallel Simulation Engine (OOPSE) project
3 > *
4 > * Contact: oopse@oopse.org
5 > *
6 > * This program is free software; you can redistribute it and/or
7 > * modify it under the terms of the GNU Lesser General Public License
8 > * as published by the Free Software Foundation; either version 2.1
9 > * of the License, or (at your option) any later version.
10 > * All we ask is that proper credit is given for our work, which includes
11 > * - but is not limited to - adding the above copyright notice to the beginning
12 > * of your source code files, and to any copyright notice that you may distribute
13 > * with programs based on this work.
14 > *
15 > * This program is distributed in the hope that it will be useful,
16 > * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 > * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18 > * GNU Lesser General Public License for more details.
19 > *
20 > * You should have received a copy of the GNU Lesser General Public License
21 > * along with this program; if not, write to the Free Software
22 > * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
23 > *
24 > */
25  
26 < #include <vector>
27 < //#include "Atom.hpp"
28 < //#include "AtomStamp.hpp"
29 < #include "RigidBodyStamp.hpp"
30 < #include "StuntDouble.hpp"
31 < using namespace std;
26 > /**
27 > * @file RigidBody.hpp
28 > * @author    tlin
29 > * @date  10/23/2004
30 > * @version 1.0
31 > */
32  
33 < class Atom;
34 < class AtomStamp;
33 > #ifndef PRIMITIVES_RIGIDBODY_HPP
34 > #define PRIMITIVES_RIGIDBODY_HPP
35  
36 < typedef struct {
15 <  double vec[3];
16 <  double& operator[](int index) {return vec[index];}  
17 < } vec3;
36 > #include <vector>
37  
38 < typedef struct {
39 <  double mat[3][3];
40 <  double* operator[](int index) {return mat[index];}  
41 < } mat3x3;
38 > #include "primitives/StuntDouble.hpp"
39 > #include "primitives/DirectionalAtom.hpp"
40 > namespace oopse{
41 >    class RigidBody : public StuntDouble {
42 >        public:
43 >            RigidBody();
44  
45 < class RigidBody : public StuntDouble {
45 >           /**
46 >             * Sets  the previous rotation matrix of this stuntdouble
47 >             * @param a  new rotation matrix
48 >             */        
49 >           virtual void setPrevA(const RotMat3x3d& a);
50 >          
51 >           /**
52 >             * Sets  the current rotation matrix of this stuntdouble
53 >             * @param a  new rotation matrix
54 >             */        
55 >            virtual void setA(const RotMat3x3d& a);
56 >           /**
57 >             * Sets  the rotation matrix of this stuntdouble in specified snapshot
58 >             * @param a rotation matrix to be set
59 >             * @param snapshotNo
60 >             * @see #getA
61 >             */        
62 >            virtual void setA(const RotMat3x3d& a, int snapshotNo);
63  
64 < public:
65 <  
66 <  RigidBody();
67 <  //RigidBody(const RigidBody& rb);
68 <  
31 <  virtual ~RigidBody();
32 <
33 <  void addAtom(Atom* at, AtomStamp* ats);
64 >            /**
65 >             * Returns the inertia tensor of this stuntdouble
66 >             * @return the inertia tensor of this stuntdouble
67 >             */
68 >            virtual Mat3x3d getI();
69  
35 –  void getPos( double theP[3] );
36 –  void setPos( double theP[3] );
70  
71 <  void getVel( double theV[3] );
72 <  void setVel( double theV[3] );
71 >            /** Sets the internal unit frame of this stuntdouble by three euler angles */
72 >            void setUnitFrameFromEuler(double phi, double theta, double psi);
73 >            
74 >            /**
75 >             * Returns the gradient of this stuntdouble
76 >             * @return the inertia tensor of this stuntdouble
77 >             * @see #setI
78 >             */
79 >            virtual std::vector<double> getGrad();
80  
81 <  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;}
81 >            virtual void accept(BaseVisitor* v);
82  
83 <  double getMass( void ) { return mass; }
83 >            void addAtom(Atom* atom);
84  
85 <  void printAmatIndex( void );
86 <  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] );
85 >            /** calculate the reference coordinates */
86 >            void calcRefCoords();
87  
88 <  void getA( double the_A[3][3] ); // get the full rotation matrix
89 <  void setA( double the_A[3][3] );
88 >            /** Convert Atomic forces and torques to total forces and torques */
89 >            void calcForcesAndTorques();
90  
91 <  void getJ( double theJ[3] );
92 <  void setJ( double theJ[3] );
91 >            /** update the positions of atoms belong to this rigidbody */
92 >            void updateAtoms();
93  
94 <  virtual void setType(char* type) {strcpy(rbName, type);}
62 <  virtual char* getType() { return rbName;}
94 >            Atom* beginAtom(std::vector<Atom*>::iterator& i);
95  
96 <  void getTrq( double theT[3] );
65 <  void addTrq( double theT[3] );
96 >            Atom* nextAtom(std::vector<Atom*>::iterator& i);
97  
98 <  void getI( double the_I[3][3] );
99 <  void lab2Body( double r[3] );
100 <  void body2Lab( double r[3] );
98 >            std::vector<Atom*>::iterator getBeginAtomIter() {
99 >                return atoms_.begin();
100 >            }
101 >            
102 >            std::vector<Atom*>::iterator getEndAtomIter() {
103 >                return atoms_.end();
104 >            }
105  
106 <  double getZangle( );
107 <  void setZangle( double zAng );
108 <  void addZangle( double zAng );
106 >            /**
107 >             * Returns the atoms of this rigid body
108 >             * @return the atoms of this rigid body in a vector
109 >             * @deprecate
110 >             */          
111 >            std::vector<Atom*> getAtoms() {
112 >                return atoms_;
113 >            }
114  
115 <  void calcRefCoords( void );
116 <  void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
117 <  void calcForcesAndTorques( void );
118 <  void updateAtoms( void );
115 >            /**
116 >             * Returns the number of atoms in this rigid body
117 >             * @return the number of atoms in this rigid body
118 >             */
119 >            int getNumAtoms() {
120 >                return atoms_.size();
121 >            }
122  
123 <  //void yourAtomsHaveMoved( void );
123 >            /**
124 >             * Return the position of atom which belongs to this rigid body.
125 >             * @return true if index is valid otherwise return false
126 >             * @param pos the position of atom which will be set on return if index is valid
127 >             * @param index the index of the atom in rigid body's private data member atoms_
128 >             */
129 >            bool getAtomPos(Vector3d& pos, unsigned int index);
130  
131 <  // Four functions added for derivatives with respect to Euler Angles:
132 <  // (Needed for minimization routines):
131 >            /**
132 >             * Return the position of atom which belongs to this rigid body.
133 >             * @return true if atom belongs to this rigid body,otherwise return false
134 >             * @param pos position of atom which will be set on return if atom belongs to this rigid body
135 >             * @param atom the pointer to an atom
136 >             */            
137 >            bool getAtomPos(Vector3d& pos, Atom* atom);
138  
139 <  void getGrad(double gradient[6] );
140 <  void getEulerAngles( double myEuler[3] );
141 <
142 <  double max(double x, double y);
143 <  double min(double x, double y);
139 >            /**
140 >             * Return the velocity of atom which belongs to this rigid body.
141 >             * @return true if index is valid otherwise return false
142 >             * @param vel the velocity of atom which will be set on return if index is valid
143 >             * @param index the index of the atom in rigid body's private data member atoms_
144 >             */
145 >            bool getAtomVel(Vector3d& vel, unsigned int index);
146  
147 +            /**
148 +             * Return the velocity of atom which belongs to this rigid body.
149 +             * @return true if atom belongs to this rigid body,otherwise return false
150 +             * @param vel velocity of atom which will be set on return if atom belongs to this rigid body
151 +             * @param atom the pointer to an atom
152 +             */
153 +            bool getAtomVel(Vector3d& vel, Atom*);
154  
155 <  // utility routines
155 >            /**
156 >             * Return the reference coordinate of atom which belongs to this rigid body.
157 >             * @return true if index is valid otherwise return false
158 >             * @param coor the reference coordinate of atom which will be set on return if index is valid
159 >             * @param index the index of the atom in rigid body's private data member atoms_
160 >             */
161 >            bool getAtomRefCoor(Vector3d& coor, unsigned int index);
162  
163 <  void findCOM( void );
163 >            /**
164 >             * Return the velocity of atom which belongs to this rigid body.
165 >             * @return true if atom belongs to this rigid body,otherwise return false
166 >             * @param coor velocity of atom which will be set on return if atom belongs to this rigid body
167 >             * @param atom the pointer to an atom
168 >             */
169 >            bool getAtomRefCoor(Vector3d& coor, Atom* atom);
170  
171 <  virtual void accept(BaseVisitor* v);
171 >        private:
172 >            
173 >            Mat3x3d inertiaTensor_;    
174 >            RotMat3x3d sU_;               /**< body fixed standard unit vector */
175 >            
176 >            std::vector<Atom*> atoms_;
177 >            std::vector<Vector3d> refCoords_;
178 >    };
179  
180 <  vector<Atom*> getAtoms() { return myAtoms;}
99 <  int getNumAtoms() {return myAtoms.size();}
180 > }//namepace oopse
181  
182 <  void getAtomPos(double theP[3], int index);
102 <  void getAtomVel(double theV[3], int index);
103 <  void getAtomRefCoor(double pos[3], int index);
104 < protected:
182 > #endif //PRIMITIVES_RIGIDBODY_HPP
183  
106 –  double mass;     // the total mass
107 –  double pos[3];   // the position array (center of mass)
108 –  double vel[3];   // the velocity array (center of mass)
109 –  double frc[3];   // the force array    (center of mass)
110 –  double trq[3];   // the torque vector  ( space fixed )
111 –  double ji[3];    // the angular momentum vector (body fixed)
112 –  double A[3][3];  // the rotation matrix
113 –  double I[3][3];  // the inertial tensor (body fixed)
114 –  double sU[3][3]; // the standard unit vectors (body fixed)
115 –  double zAngle;   // the rotation about the z-axis (body fixed)
116 –
117 –  bool is_linear;
118 –  int linear_axis;
119 –  double momIntTol;
120 –
121 –  vector<Atom*> myAtoms;  // the vector of atoms
122 –  vector<vec3> refCoords;
123 –  vector<mat3x3> refOrients;
124 –
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