src/primitives/RigidBody.hpp

#ifndef __RIGIDBODY_HPP__
#define __RIGIDBODY_HPP__

#include <vector>
//#include "primitives/Atom.hpp"
//#include "types/AtomStamp.hpp"
#include "types/RigidBodyStamp.hpp"
#include "primitives/StuntDouble.hpp"
using namespace std;

class Atom;
class AtomStamp;

typedef struct {
  double vec[3];
  double& operator[](int index) {return vec[index];}  
} vec3;

typedef struct {
  double mat[3][3];
  double* operator[](int index) {return mat[index];}  
} mat3x3;

class RigidBody : public StuntDouble {

public:
  
  RigidBody();
  //RigidBody(const RigidBody& rb);
  
  virtual ~RigidBody();
 
  void addAtom(Atom* at, AtomStamp* ats);

  void getPos( double theP[3] );
  void setPos( double theP[3] );

  void getVel( double theV[3] );
  void setVel( double theV[3] );

  void getFrc( double theF[3] );
  void addFrc( double theF[3] );
  void zeroForces();
  
  bool isLinear() {return is_linear;}
  int linearAxis() {return linear_axis;}

  double getMass( void ) { return mass; }

  void printAmatIndex( void );
  void setEuler( double phi, double theta, double psi );
  void getQ( double the_q[4] ); // get the quanternions
  void setQ( double the_q[4] );

  void getA( double the_A[3][3] ); // get the full rotation matrix
  void setA( double the_A[3][3] );

  void getJ( double theJ[3] );
  void setJ( double theJ[3] );

  virtual void setType(char* type) {strcpy(rbName, type);}
  virtual char* getType() { return rbName;}

  void getTrq( double theT[3] );
  void addTrq( double theT[3] );

  void getI( double the_I[3][3] );
  void lab2Body( double r[3] );
  void body2Lab( double r[3] );

  double getZangle( );
  void setZangle( double zAng );
  void addZangle( double zAng );

  void calcRefCoords( void );
  void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
  void calcForcesAndTorques( void );
  void updateAtoms( void );

  //void yourAtomsHaveMoved( void );

  // Four functions added for derivatives with respect to Euler Angles:
  // (Needed for minimization routines):

  void getGrad(double gradient[6] );
  void getEulerAngles( double myEuler[3] ); 
 
  double max(double x, double y);
  double min(double x, double y);


  // utility routines

  void findCOM( void );

  virtual void accept(BaseVisitor* v);

  vector<Atom*> getAtoms() { return myAtoms;}
  int getNumAtoms() {return myAtoms.size();}

  void getAtomPos(double theP[3], int index);
  void getAtomVel(double theV[3], int index);
  void getAtomRefCoor(double pos[3], int index);
protected:

  double mass;     // the total mass
  double pos[3];   // the position array (center of mass)
  double vel[3];   // the velocity array (center of mass)
  double frc[3];   // the force array    (center of mass)
  double trq[3];   // the torque vector  ( space fixed )
  double ji[3];    // the angular momentum vector (body fixed)
  double A[3][3];  // the rotation matrix 
  double I[3][3];  // the inertial tensor (body fixed)
  double sU[3][3]; // the standard unit vectors (body fixed)
  double zAngle;   // the rotation about the z-axis (body fixed)

  bool is_linear;
  int linear_axis;
  double momIntTol;

  vector<Atom*> myAtoms;  // the vector of atoms
  vector<vec3> refCoords;
  vector<mat3x3> refOrients;

  char rbName[100]; //it will eventually be converted into string
};

#endif
Revision:	205
Committed:	Thu Nov 4 16:22:03 2004 UTC (21 years ago) by gezelter
File size:	3271 byte(s)
Log Message:	isLinear and linearAxis are virtual in StuntDouble, but are implemented by DirectionalAtom and RigidBody In StuntDouble, they should return false and "-1" but there should be logic to figure them out in the other two classes
#	User	Rev	Content
1	gezelter	2	#ifndef __RIGIDBODY_HPP__
2			#define __RIGIDBODY_HPP__
3
4			#include <vector>
5	tim	3	//#include "primitives/Atom.hpp"
6			//#include "types/AtomStamp.hpp"
7			#include "types/RigidBodyStamp.hpp"
8			#include "primitives/StuntDouble.hpp"
9	gezelter	2	using namespace std;
10
11			class Atom;
12			class AtomStamp;
13
14			typedef struct {
15			double vec[3];
16			double& operator[](int index) {return vec[index];}
17			} vec3;
18
19			typedef struct {
20			double mat[3][3];
21			double* operator[](int index) {return mat[index];}
22			} mat3x3;
23
24			class RigidBody : public StuntDouble {
25
26			public:
27
28			RigidBody();
29			//RigidBody(const RigidBody& rb);
30
31			virtual ~RigidBody();
32
33			void addAtom(Atom* at, AtomStamp* ats);
34
35			void getPos( double theP[3] );
36			void setPos( double theP[3] );
37
38			void getVel( double theV[3] );
39			void setVel( double theV[3] );
40
41			void getFrc( double theF[3] );
42			void addFrc( double theF[3] );
43			void zeroForces();
44
45	gezelter	205	bool isLinear() {return is_linear;}
46			int linearAxis() {return linear_axis;}
47	gezelter	2
48			double getMass( void ) { return mass; }
49
50			void printAmatIndex( void );
51			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] );
54
55			void getA( double the_A[3][3] ); // get the full rotation matrix
56			void setA( double the_A[3][3] );
57
58			void getJ( double theJ[3] );
59			void setJ( double theJ[3] );
60
61			virtual void setType(char* type) {strcpy(rbName, type);}
62			virtual char* getType() { return rbName;}
63
64			void getTrq( double theT[3] );
65			void addTrq( double theT[3] );
66
67			void getI( double the_I[3][3] );
68			void lab2Body( double r[3] );
69			void body2Lab( double r[3] );
70
71			double getZangle( );
72			void setZangle( double zAng );
73			void addZangle( double zAng );
74
75			void calcRefCoords( void );
76			void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
77			void calcForcesAndTorques( void );
78			void updateAtoms( void );
79
80			//void yourAtomsHaveMoved( void );
81
82			// Four functions added for derivatives with respect to Euler Angles:
83			// (Needed for minimization routines):
84
85			void getGrad(double gradient[6] );
86			void getEulerAngles( double myEuler[3] );
87
88			double max(double x, double y);
89			double min(double x, double y);
90
91
92			// utility routines
93
94			void findCOM( void );
95
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