OOPSE/libmdtools/RigidBody.hpp

#ifndef __RIGIDBODY_HPP__
#define __RIGIDBODY_HPP__

#include <vector>
//#include "Atom.hpp"
//#include "AtomStamp.hpp"
#include "RigidBodyStamp.hpp"
#include "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();
  
  virtual bool isLinear() {return is_linear;}
  virtual 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);
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:	1234
Committed:	Fri Jun 4 03:15:31 2004 UTC (20 years, 1 month ago) by tim
File size:	3158 byte(s)
Log Message:	new rattle algorithm is working
#	User	Rev	Content
1	gezelter	1100	#ifndef __RIGIDBODY_HPP__
2			#define __RIGIDBODY_HPP__
3
4			#include <vector>
5			//#include "Atom.hpp"
6			//#include "AtomStamp.hpp"
7			#include "RigidBodyStamp.hpp"
8			#include "StuntDouble.hpp"
9			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	tim	1234	//RigidBody(const RigidBody& rb);
30
31	gezelter	1100	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	tim	1118
45			virtual bool isLinear() {return is_linear;}
46			virtual int linearAxis() {return linear_axis;}
47	gezelter	1100
48			double getMass( void ) { return mass; }
49
50			void printAmatIndex( void );
51	tim	1113	void setEuler( double phi, double theta, double psi );
52	gezelter	1100	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	tim	1108	virtual void setType(char* type) {strcpy(rbName, type);}
62			virtual char* getType() { return rbName;}
63
64	gezelter	1100	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	chrisfen	1187	double getZangle( );
72			void setZangle( double zAng );
73			void addZangle( double zAng );
74
75	gezelter	1100	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	tim	1118
96			virtual void accept(BaseVisitor* v);
97
98			vector<Atom*> getAtoms() { return myAtoms;}
99	tim	1234	int getNumAtoms() {return myAtoms.size();}
100
101			void getAtomPos(double theP[3], int index);
102	gezelter	1100	protected:
103
104			double mass; // the total mass
105			double pos[3]; // the position array (center of mass)
106			double vel[3]; // the velocity array (center of mass)
107			double frc[3]; // the force array (center of mass)
108			double trq[3]; // the torque vector ( space fixed )
109			double ji[3]; // the angular momentum vector (body fixed)
110			double A[3][3]; // the rotation matrix
111			double I[3][3]; // the inertial tensor (body fixed)
112			double sU[3][3]; // the standard unit vectors (body fixed)
113	chrisfen	1187	double zAngle; // the rotation about the z-axis (body fixed)
114	gezelter	1100
115	tim	1118	bool is_linear;
116			int linear_axis;
117	gezelter	1174	double momIntTol;
118	tim	1118
119	gezelter	1100	vector<Atom*> myAtoms; // the vector of atoms
120			vector<vec3> refCoords;
121			vector<mat3x3> refOrients;
122
123	tim	1108	char rbName[100]; //it will eventually be converted into string
124	gezelter	1100	};
125
126			#endif