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

Comparing:
trunk/OOPSE-4/src/primitives/RigidBody.hpp (file contents), Revision 1492 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
branches/new_design/OOPSE-4/src/primitives/RigidBody.hpp (file contents), Revision 1813 by tim, Wed Dec 1 17:38:32 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 "primitives/Atom.hpp"
28 < //#include "types/AtomStamp.hpp"
29 < #include "types/RigidBodyStamp.hpp"
30 < #include "primitives/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 > #include "types/AtomStamp.hpp"
41 > namespace oopse{
42 >    class RigidBody : public StuntDouble {
43 >        public:
44 >            RigidBody();
45  
46 < class RigidBody : public StuntDouble {
46 >           /**
47 >             * Sets  the previous rotation matrix of this stuntdouble
48 >             * @param a  new rotation matrix
49 >             */        
50 >           virtual void setPrevA(const RotMat3x3d& a);
51 >          
52 >           /**
53 >             * Sets  the current rotation matrix of this stuntdouble
54 >             * @param a  new rotation matrix
55 >             * @note setA will not change the position and rotation matrix of Directional atoms belong to
56 >             * this rigidbody. If you want to do that, use #updateAtoms
57 >             */        
58 >            virtual void setA(const RotMat3x3d& a);
59 >           /**
60 >             * Sets  the rotation matrix of this stuntdouble in specified snapshot
61 >             * @param a rotation matrix to be set
62 >             * @param snapshotNo
63 >             * @see #getA
64 >             */        
65 >            virtual void setA(const RotMat3x3d& a, int snapshotNo);
66  
67 < public:
68 <  
69 <  RigidBody();
70 <  //RigidBody(const RigidBody& rb);
71 <  
31 <  virtual ~RigidBody();
32 <
33 <  void addAtom(Atom* at, AtomStamp* ats);
67 >            /**
68 >             * Returns the inertia tensor of this stuntdouble
69 >             * @return the inertia tensor of this stuntdouble
70 >             */
71 >            virtual Mat3x3d getI();
72  
35 –  void getPos( double theP[3] );
36 –  void setPos( double theP[3] );
73  
74 <  void getVel( double theV[3] );
75 <  void setVel( double theV[3] );
74 >            /** Sets the internal unit frame of this stuntdouble by three euler angles */
75 >            void setElectroFrameFromEuler(double phi, double theta, double psi);
76 >            
77 >            /**
78 >             * Returns the gradient of this stuntdouble
79 >             * @return the inertia tensor of this stuntdouble
80 >             * @see #setI
81 >             */
82 >            virtual std::vector<double> getGrad();
83  
84 <  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;}
84 >            virtual void accept(BaseVisitor* v);
85  
86 <  double getMass( void ) { return mass; }
86 >            void addAtom(Atom* at, AtomStamp* ats);
87  
88 <  void printAmatIndex( void );
89 <  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] );
88 >            /** calculate the reference coordinates */
89 >            void calcRefCoords();
90  
91 <  void getA( double the_A[3][3] ); // get the full rotation matrix
92 <  void setA( double the_A[3][3] );
91 >            /** Convert Atomic forces and torques to total forces and torques */
92 >            void calcForcesAndTorques();
93  
94 <  void getJ( double theJ[3] );
95 <  void setJ( double theJ[3] );
94 >            /** update the positions of atoms belong to this rigidbody */
95 >            void updateAtoms();
96  
97 <  virtual void setType(char* type) {strcpy(rbName, type);}
62 <  virtual char* getType() { return rbName;}
97 >            Atom* beginAtom(std::vector<Atom*>::iterator& i);
98  
99 <  void getTrq( double theT[3] );
65 <  void addTrq( double theT[3] );
99 >            Atom* nextAtom(std::vector<Atom*>::iterator& i);
100  
101 <  void getI( double the_I[3][3] );
102 <  void lab2Body( double r[3] );
103 <  void body2Lab( double r[3] );
101 >            std::vector<Atom*>::iterator getBeginAtomIter() {
102 >                return atoms_.begin();
103 >            }
104 >            
105 >            std::vector<Atom*>::iterator getEndAtomIter() {
106 >                return atoms_.end();
107 >            }
108  
109 <  double getZangle( );
110 <  void setZangle( double zAng );
111 <  void addZangle( double zAng );
109 >            /**
110 >             * Returns the atoms of this rigid body
111 >             * @return the atoms of this rigid body in a vector
112 >             * @deprecate
113 >             */          
114 >            std::vector<Atom*> getAtoms() {
115 >                return atoms_;
116 >            }
117  
118 <  void calcRefCoords( void );
119 <  void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
120 <  void calcForcesAndTorques( void );
121 <  void updateAtoms( void );
118 >            /**
119 >             * Returns the number of atoms in this rigid body
120 >             * @return the number of atoms in this rigid body
121 >             */
122 >            int getNumAtoms() {
123 >                return atoms_.size();
124 >            }
125  
126 <  //void yourAtomsHaveMoved( void );
126 >            /**
127 >             * Return the position of atom which belongs to this rigid body.
128 >             * @return true if index is valid otherwise return false
129 >             * @param pos the position of atom which will be set on return if index is valid
130 >             * @param index the index of the atom in rigid body's private data member atoms_
131 >             */
132 >            bool getAtomPos(Vector3d& pos, unsigned int index);
133  
134 <  // Four functions added for derivatives with respect to Euler Angles:
135 <  // (Needed for minimization routines):
134 >            /**
135 >             * Return the position of atom which belongs to this rigid body.
136 >             * @return true if atom belongs to this rigid body,otherwise return false
137 >             * @param pos position of atom which will be set on return if atom belongs to this rigid body
138 >             * @param atom the pointer to an atom
139 >             */            
140 >            bool getAtomPos(Vector3d& pos, Atom* atom);
141  
142 <  void getGrad(double gradient[6] );
143 <  void getEulerAngles( double myEuler[3] );
144 <
145 <  double max(double x, double y);
146 <  double min(double x, double y);
142 >            /**
143 >             * Return the velocity of atom which belongs to this rigid body.
144 >             * @return true if index is valid otherwise return false
145 >             * @param vel the velocity of atom which will be set on return if index is valid
146 >             * @param index the index of the atom in rigid body's private data member atoms_
147 >             */
148 >            bool getAtomVel(Vector3d& vel, unsigned int index);
149  
150 +            /**
151 +             * Return the velocity of atom which belongs to this rigid body.
152 +             * @return true if atom belongs to this rigid body,otherwise return false
153 +             * @param vel velocity of atom which will be set on return if atom belongs to this rigid body
154 +             * @param atom the pointer to an atom
155 +             */
156 +            bool getAtomVel(Vector3d& vel, Atom*);
157  
158 <  // utility routines
158 >            /**
159 >             * Return the reference coordinate of atom which belongs to this rigid body.
160 >             * @return true if index is valid otherwise return false
161 >             * @param coor the reference coordinate of atom which will be set on return if index is valid
162 >             * @param index the index of the atom in rigid body's private data member atoms_
163 >             */
164 >            bool getAtomRefCoor(Vector3d& coor, unsigned int index);
165  
166 <  void findCOM( void );
166 >            /**
167 >             * Return the velocity of atom which belongs to this rigid body.
168 >             * @return true if atom belongs to this rigid body,otherwise return false
169 >             * @param coor velocity of atom which will be set on return if atom belongs to this rigid body
170 >             * @param atom the pointer to an atom
171 >             */
172 >            bool getAtomRefCoor(Vector3d& coor, Atom* atom);
173  
174 <  virtual void accept(BaseVisitor* v);
174 >        private:
175 >            
176 >            Mat3x3d inertiaTensor_;    
177 >            RotMat3x3d sU_;               /**< body fixed standard unit vector */
178 >            
179 >            std::vector<Atom*> atoms_;
180 >            std::vector<Vector3d> refCoords_;
181 >            std::vector<RotMat3x3d> refOrients_;
182 >    };
183  
184 <  vector<Atom*> getAtoms() { return myAtoms;}
99 <  int getNumAtoms() {return myAtoms.size();}
184 > }//namepace oopse
185  
186 <  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:
186 > #endif //PRIMITIVES_RIGIDBODY_HPP
187  
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