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 branches/new_design/OOPSE-4/src/primitives/RigidBody.hpp (file contents):
Revision 1683, Thu Oct 28 22:34:02 2004 UTC vs.
Revision 1692 by tim, Mon Nov 1 20:15:58 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 > 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);}
95 <  virtual char* getType() { return rbName;}
94 >            /**
95 >             * Returns the atoms of this rigid body
96 >             * @return the atoms of this rigid body in a vector
97 >             */          
98 >            std::vector<Atom*> getAtoms() {
99 >                return atoms_;
100 >            }
101  
102 <  void getTrq( double theT[3] );
103 <  void addTrq( double theT[3] );
102 >            /**
103 >             * Returns the number of atoms in this rigid body
104 >             * @return the number of atoms in this rigid body
105 >             */
106 >            int getNumAtoms() {
107 >                return atoms_.size();
108 >            }
109  
110 <  void getI( double the_I[3][3] );
111 <  void lab2Body( double r[3] );
112 <  void body2Lab( double r[3] );
110 >            /**
111 >             * Return the position of atom which belongs to this rigid body.
112 >             * @return true if index is valid otherwise return false
113 >             * @param pos the position of atom which will be set on return if index is valid
114 >             * @param index the index of the atom in rigid body's private data member atoms_
115 >             */
116 >            bool getAtomPos(Vector3d& pos, unsigned int index);
117  
118 <  double getZangle( );
119 <  void setZangle( double zAng );
120 <  void addZangle( double zAng );
118 >            /**
119 >             * Return the position of atom which belongs to this rigid body.
120 >             * @return true if atom belongs to this rigid body,otherwise return false
121 >             * @param pos position of atom which will be set on return if atom belongs to this rigid body
122 >             * @param atom the pointer to an atom
123 >             */            
124 >            bool getAtomPos(Vector3d& pos, Atom* atom);
125  
126 <  void calcRefCoords( void );
127 <  void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
128 <  void calcForcesAndTorques( void );
129 <  void updateAtoms( void );
126 >            /**
127 >             * Return the velocity of atom which belongs to this rigid body.
128 >             * @return true if index is valid otherwise return false
129 >             * @param vel the velocity 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 getAtomVel(Vector3d& vel, unsigned int index);
133  
134 <  //void yourAtomsHaveMoved( void );
134 >            /**
135 >             * Return the velocity of atom which belongs to this rigid body.
136 >             * @return true if atom belongs to this rigid body,otherwise return false
137 >             * @param vel velocity 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 getAtomVel(Vector3d& vel, Atom*);
141  
142 <  // Four functions added for derivatives with respect to Euler Angles:
143 <  // (Needed for minimization routines):
142 >            /**
143 >             * Return the reference coordinate of atom which belongs to this rigid body.
144 >             * @return true if index is valid otherwise return false
145 >             * @param coor the reference coordinate 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 getAtomRefCoor(Vector3d& coor, unsigned int index);
149  
150 <  void getGrad(double gradient[6] );
151 <  void getEulerAngles( double myEuler[3] );
152 <
153 <  double max(double x, double y);
154 <  double min(double x, double y);
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 coor 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 getAtomRefCoor(Vector3d& coor, Atom* atom);
157  
158 +        private:
159 +            
160 +            Mat3x3d inertiaTensor_;    
161 +            RotMat3x3d sU_;               /**< body fixed standard unit vector */
162 +            
163 +            std::vector<Atom*> atoms_;
164 +            std::vector<Vector3d> refCoords_;
165 +    };
166  
167 <  // utility routines
167 > }//namepace oopse
168  
169 <  void findCOM( void );
169 > #endif //PRIMITIVES_RIGIDBODY_HPP
170  
96 –  virtual void accept(BaseVisitor* v);
97 –
98 –  vector<Atom*> getAtoms() { return myAtoms;}
99 –  int getNumAtoms() {return myAtoms.size();}
100 –
101 –  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:
105 –
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