ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/branches/development/src/primitives/RigidBody.hpp

Comparing:
trunk/src/primitives/RigidBody.hpp (file contents), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/RigidBody.hpp (file contents), Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

#	Line 1 | Line 1
1	<	#ifndef __RIGIDBODY_HPP__
2	<	#define __RIGIDBODY_HPP__
1	>	/*
2	>	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	>	*
4	>	* The University of Notre Dame grants you ("Licensee") a
5	>	* non-exclusive, royalty free, license to use, modify and
6	>	* redistribute this software in source and binary code form, provided
7	>	* that the following conditions are met:
8	>	*
9	>	* 1. Redistributions of source code must retain the above copyright
10	>	*    notice, this list of conditions and the following disclaimer.
11	>	*
12	>	* 2. Redistributions in binary form must reproduce the above copyright
13	>	*    notice, this list of conditions and the following disclaimer in the
14	>	*    documentation and/or other materials provided with the
15	>	*    distribution.
16	>	*
17	>	* This software is provided "AS IS," without a warranty of any
18	>	* kind. All express or implied conditions, representations and
19	>	* warranties, including any implied warranty of merchantability,
20	>	* fitness for a particular purpose or non-infringement, are hereby
21	>	* excluded.  The University of Notre Dame and its licensors shall not
22	>	* be liable for any damages suffered by licensee as a result of
23	>	* using, modifying or distributing the software or its
24	>	* derivatives. In no event will the University of Notre Dame or its
25	>	* licensors be liable for any lost revenue, profit or data, or for
26	>	* direct, indirect, special, consequential, incidental or punitive
27	>	* damages, however caused and regardless of the theory of liability,
28	>	* arising out of the use of or inability to use software, even if the
29	>	* University of Notre Dame has been advised of the possibility of
30	>	* such damages.
31	>	*
32	>	* SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
33	>	* research, please cite the appropriate papers when you publish your
34	>	* work.  Good starting points are:
35	>	*
36	>	* [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).
37	>	* [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).
39	>	* [4]  Vardeman & Gezelter, in progress (2009).
40	>	*/
41	>
42	>	/**
43	>	* @file RigidBody.hpp
44	>	* @author    tlin
45	>	* @date  10/23/2004
46	>	* @version 1.0
47	>	*/
48
49	+	#ifndef PRIMITIVES_RIGIDBODY_HPP
50	+	#define PRIMITIVES_RIGIDBODY_HPP
51	+
52		#include <vector>
5	–	//#include "Atom.hpp"
6	–	//#include "AtomStamp.hpp"
7	–	#include "RigidBodyStamp.hpp"
8	–	#include "StuntDouble.hpp"
9	–	using namespace std;
53
54	<	class Atom;
55	<	class AtomStamp;
54	>	#include "primitives/StuntDouble.hpp"
55	>	#include "primitives/DirectionalAtom.hpp"
56	>	#include "types/AtomStamp.hpp"
57	>	namespace OpenMD{
58	>	class RigidBody : public StuntDouble {
59	>	public:
60
61	<	typedef struct {
15	<	double vec[3];
16	<	double& operator[](int index) {return vec[index];}
17	<	} vec3;
61	>	typedef std::vector<Atom*>::iterator AtomIterator;
62
63	<	typedef struct {
20	<	double mat[3][3];
21	<	double* operator[](int index) {return mat[index];}
22	<	} mat3x3;
63	>	RigidBody();
64
65	<	class RigidBody : public StuntDouble {
65	>	virtual std::string getType() { return name_;}
66	>
67	>	/** Sets the name of this stuntRealType*/
68	>	virtual void setType(const std::string& name) { name_ = name;}
69	>
70
71	<	public:
72	<
73	<	RigidBody();
74	<	//RigidBody(const RigidBody& rb);
75	<
76	<	virtual ~RigidBody();
77	<
78	<	void addAtom(Atom* at, AtomStamp* ats);
71	>	/**
72	>	* Sets  the previous rotation matrix of this stuntdouble
73	>	* @param a  new rotation matrix
74	>	*/
75	>	virtual void setPrevA(const RotMat3x3d& a);
76	>
77	>	/**
78	>	* Sets  the current rotation matrix of this stuntdouble
79	>	* @param a  new rotation matrix
80	>	* @note setA will not change the position and rotation matrix of Directional atoms belong to
81	>	* this rigidbody. If you want to do that, use #updateAtoms
82	>	*/
83	>	virtual void setA(const RotMat3x3d& a);
84	>	/**
85	>	* Sets  the rotation matrix of this stuntdouble in specified snapshot
86	>	* @param a rotation matrix to be set
87	>	* @param snapshotNo
88	>	* @see #getA
89	>	*/
90	>	virtual void setA(const RotMat3x3d& a, int snapshotNo);
91
92	<	void getPos( double theP[3] );
93	<	void setPos( double theP[3] );
92	>	/**
93	>	* Returns the inertia tensor of this stuntdouble
94	>	* @return the inertia tensor of this stuntdouble
95	>	*/
96	>	virtual Mat3x3d getI();
97
38	–	void getVel( double theV[3] );
39	–	void setVel( double theV[3] );
98
99	<	void getFrc( double theF[3] );
100	<	void addFrc( double theF[3] );
101	<	void zeroForces();
102	<
103	<	virtual bool isLinear() {return is_linear;}
104	<	virtual int linearAxis() {return linear_axis;}
99	>	/** Sets the internal unit frame of this stuntdouble by three euler angles */
100	>	void setElectroFrameFromEuler(RealType phi, RealType theta, RealType psi);
101	>
102	>	/**
103	>	* Returns the gradient of this stuntdouble
104	>	* @return the inertia tensor of this stuntdouble
105	>	* @see #setI
106	>	*/
107	>	virtual std::vector<RealType> getGrad();
108
109	<	double getMass( void ) { return mass; }
109	>	virtual void accept(BaseVisitor* v);
110
111	<	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] );
111	>	void addAtom(Atom* at, AtomStamp* ats);
112
113	<	void getA( double the_A[3][3] ); // get the full rotation matrix
114	<	void setA( double the_A[3][3] );
113	>	/** calculates the reference coordinates */
114	>	void calcRefCoords();
115
116	<	void getJ( double theJ[3] );
117	<	void setJ( double theJ[3] );
116	>	/** Converts Atomic forces and torques to total forces and torques */
117	>	void calcForcesAndTorques();
118
119	<	virtual void setType(char* type) {strcpy(rbName, type);}
120	<	virtual char* getType() { return rbName;}
119	>	/** Converts Atomic forces and torques to total forces and torques and computes the rigid body contribution to the virial.  Returns the rigid body contribution to the virial as a 3x3 matrix. */
120	>	Mat3x3d calcForcesAndTorquesAndVirial();
121
122	<	void getTrq( double theT[3] );
123	<	void addTrq( double theT[3] );
122	>	/** update the positions of atoms belong to this rigidbody */
123	>	void updateAtoms();
124
125	<	void getI( double the_I[3][3] );
68	<	void lab2Body( double r[3] );
69	<	void body2Lab( double r[3] );
125	>	void updateAtoms(int frame);
126
127	<	double getZangle( );
72	<	void setZangle( double zAng );
73	<	void addZangle( double zAng );
127	>	void updateAtomVel();
128
129	<	void calcRefCoords( void );
130	<	void doEulerToRotMat(vec3 &euler, mat3x3 &myA );
131	<	void calcForcesAndTorques( void );
132	<	void updateAtoms( void );
129	>	void updateAtomVel(int frame);
130	>
131	>	Atom* beginAtom(std::vector<Atom*>::iterator& i) {
132	>	i = atoms_.begin();
133	>	return i != atoms_.end() ? *i : NULL;
134	>	}
135
136	<	//void yourAtomsHaveMoved( void );
136	>	Atom* nextAtom(std::vector<Atom*>::iterator& i) {
137	>	++i;
138	>	return i != atoms_.end() ? *i : NULL;
139	>	}
140
141	<	// Four functions added for derivatives with respect to Euler Angles:
142	<	// (Needed for minimization routines):
141	>	std::vector<Atom*>::iterator getBeginAtomIter() {
142	>	return atoms_.begin();
143	>	}
144	>
145	>	std::vector<Atom*>::iterator getEndAtomIter() {
146	>	return atoms_.end();
147	>	}
148
149	<	void getGrad(double gradient[6] );
150	<	void getEulerAngles( double myEuler[3] );
151	<
152	<	double max(double x, double y);
153	<	double min(double x, double y);
149	>	/**
150	>	* Returns the atoms of this rigid body
151	>	* @return the atoms of this rigid body in a vector
152	>	* @deprecate
153	>	*/
154	>	std::vector<Atom*> getAtoms() {
155	>	return atoms_;
156	>	}
157
158	+	/**
159	+	* Returns the number of atoms in this rigid body
160	+	* @return the number of atoms in this rigid body
161	+	*/
162	+	int getNumAtoms() {
163	+	return atoms_.size();
164	+	}
165
166	<	// utility routines
166	>	/**
167	>	* Return the position of atom which belongs to this rigid body.
168	>	* @return true if index is valid otherwise return false
169	>	* @param pos the position of atom which will be set on return if index is valid
170	>	* @param index the index of the atom in rigid body's private data member atoms_
171	>	*/
172	>	bool getAtomPos(Vector3d& pos, unsigned int index);
173
174	<	void findCOM( void );
174	>	/**
175	>	* Return the position of atom which belongs to this rigid body.
176	>	* @return true if atom belongs to this rigid body,otherwise return false
177	>	* @param pos position of atom which will be set on return if atom belongs to this rigid body
178	>	* @param atom the pointer to an atom
179	>	*/
180	>	bool getAtomPos(Vector3d& pos, Atom* atom);
181
182	<	virtual void accept(BaseVisitor* v);
182	>	/**
183	>	* Return the velocity of atom which belongs to this rigid body.
184	>	* @return true if index is valid otherwise return false
185	>	* @param vel the velocity of atom which will be set on return if index is valid
186	>	* @param index the index of the atom in rigid body's private data member atoms_
187	>	*/
188	>	bool getAtomVel(Vector3d& vel, unsigned int index);
189
190	<	vector<Atom*> getAtoms() { return myAtoms;}
191	<	int getNumAtoms() {return myAtoms.size();}
190	>	/**
191	>	* Return the velocity of atom which belongs to this rigid body.
192	>	* @return true if atom belongs to this rigid body,otherwise return false
193	>	* @param vel velocity of atom which will be set on return if atom belongs to this rigid body
194	>	* @param atom the pointer to an atom
195	>	*/
196	>	bool getAtomVel(Vector3d& vel, Atom*);
197
198	<	void getAtomPos(double theP[3], int index);
199	<	void getAtomVel(double theV[3], int index);
200	<	void getAtomRefCoor(double pos[3], int index);
201	<	protected:
198	>	/**
199	>	* Return the reference coordinate of atom which belongs to this rigid body.
200	>	* @return true if index is valid otherwise return false
201	>	* @param coor the reference coordinate of atom which will be set on return if index is valid
202	>	* @param index the index of the atom in rigid body's private data member atoms_
203	>	*/
204	>	bool getAtomRefCoor(Vector3d& coor, unsigned int index);
205
206	<	double mass;     // the total mass
207	<	double pos[3];   // the position array (center of mass)
208	<	double vel[3];   // the velocity array (center of mass)
209	<	double frc[3];   // the force array    (center of mass)
210	<	double trq[3];   // the torque vector  ( space fixed )
211	<	double ji[3];    // the angular momentum vector (body fixed)
212	<	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)
206	>	/**
207	>	* Return the velocity of atom which belongs to this rigid body.
208	>	* @return true if atom belongs to this rigid body,otherwise return false
209	>	* @param coor velocity of atom which will be set on return if atom belongs to this rigid body
210	>	* @param atom the pointer to an atom
211	>	*/
212	>	bool getAtomRefCoor(Vector3d& coor, Atom* atom);
213
214	<	bool is_linear;
215	<	int linear_axis;
216	<	double momIntTol;
214	>	private:
215	>	std::string name_;
216	>	Mat3x3d inertiaTensor_;
217	>	RotMat3x3d sU_;               /**< body fixed standard unit vector */
218	>
219	>	std::vector<Atom*> atoms_;
220	>	std::vector<Vector3d> refCoords_;
221	>	std::vector<RotMat3x3d> refOrients_;
222	>	};
223
224	<	vector<Atom*> myAtoms;  // the vector of atoms
122	<	vector<vec3> refCoords;
123	<	vector<mat3x3> refOrients;
224	>	}//namespace OpenMD
225
226	<	char rbName[100]; //it will eventually be converted into string
126	<	};
226	>	#endif //PRIMITIVES_RIGIDBODY_HPP
227
128	–	#endif

Comparing:
trunk/src/primitives/RigidBody.hpp (property svn:keywords), Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
branches/development/src/primitives/RigidBody.hpp (property svn:keywords), Revision 1465 by chuckv, Fri Jul 9 23:08:25 2010 UTC

#	Line 0 | Line 1
1	+	Author Id Revision Date

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines