src/primitives/RigidBody.hpp

/*
 * Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
 *
 * The University of Notre Dame grants you ("Licensee") a
 * non-exclusive, royalty free, license to use, modify and
 * redistribute this software in source and binary code form, provided
 * that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the
 *    distribution.
 *
 * This software is provided "AS IS," without a warranty of any
 * kind. All express or implied conditions, representations and
 * warranties, including any implied warranty of merchantability,
 * fitness for a particular purpose or non-infringement, are hereby
 * excluded.  The University of Notre Dame and its licensors shall not
 * be liable for any damages suffered by licensee as a result of
 * using, modifying or distributing the software or its
 * derivatives. In no event will the University of Notre Dame or its
 * licensors be liable for any lost revenue, profit or data, or for
 * direct, indirect, special, consequential, incidental or punitive
 * damages, however caused and regardless of the theory of liability,
 * arising out of the use of or inability to use software, even if the
 * University of Notre Dame has been advised of the possibility of
 * such damages.
 *
 * SUPPORT OPEN SCIENCE!  If you use OpenMD or its source code in your
 * research, please cite the appropriate papers when you publish your
 * work.  Good starting points are:
 *                                                                      
 * [1]  Meineke, et al., J. Comp. Chem. 26, 252-271 (2005).             
 * [2]  Fennell & Gezelter, J. Chem. Phys. 124, 234104 (2006).          
 * [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 24107 (2008).          
 * [4]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
 * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
 */
 
/**
 * @file RigidBody.hpp
 * @author    tlin
 * @date  10/23/2004
 * @version 1.0
 */ 

#ifndef PRIMITIVES_RIGIDBODY_HPP
#define PRIMITIVES_RIGIDBODY_HPP

#include <vector>

#include "primitives/StuntDouble.hpp"
#include "primitives/DirectionalAtom.hpp"
#include "types/AtomStamp.hpp"
namespace OpenMD{
  class RigidBody : public StuntDouble {
  public:

    typedef std::vector<Atom*>::iterator AtomIterator;        

    RigidBody();

    virtual std::string getType() { return name_;}
        
    /** Sets the name of this stuntRealType*/
    virtual void setType(const std::string& name) { name_ = name;}
    

    /**
     * Sets  the previous rotation matrix of this stuntdouble
     * @param a  new rotation matrix 
     */         
    virtual void setPrevA(const RotMat3x3d& a);
       
    /**
     * Sets  the current rotation matrix of this stuntdouble
     * @param a  new rotation matrix 
     * @note setA will not change the position and rotation matrix of Directional atoms belong to
     * this rigidbody. If you want to do that, use #updateAtoms
     */         
    virtual void setA(const RotMat3x3d& a);
    /**
     * Sets  the rotation matrix of this stuntdouble in specified snapshot
     * @param a rotation matrix to be set 
     * @param snapshotNo 
     * @see #getA
     */         
    virtual void setA(const RotMat3x3d& a, int snapshotNo);

    /**
     * Returns the inertia tensor of this stuntdouble
     * @return the inertia tensor of this stuntdouble
     */ 
    virtual Mat3x3d getI();

    /**
     * Returns the gradient of this stuntdouble
     * @return the inertia tensor of this stuntdouble
     * @see #setI
     */ 
    virtual std::vector<RealType> getGrad();

    virtual void accept(BaseVisitor* v);

    void addAtom(Atom* at, AtomStamp* ats);

    /** calculates the reference coordinates */
    void calcRefCoords();

    /** Converts Atomic forces and torques to total forces and torques */
    void calcForcesAndTorques();

    /** 
        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.
        */ 
    Mat3x3d calcForcesAndTorquesAndVirial();
    
    /** update the positions of atoms belong to this rigidbody */
    void updateAtoms();

    void updateAtoms(int frame);

    void updateAtomVel();

    void updateAtomVel(int frame);
        
    Atom* beginAtom(std::vector<Atom*>::iterator& i) {
      i = atoms_.begin();
      return i != atoms_.end() ? *i : NULL;
    }

    Atom* nextAtom(std::vector<Atom*>::iterator& i) {
      ++i;
      return i != atoms_.end() ? *i : NULL;
    }

    std::vector<Atom*>::iterator getBeginAtomIter() {
      return atoms_.begin();
    }
        
    std::vector<Atom*>::iterator getEndAtomIter() {
      return atoms_.end();
    }

    /** 
     * Returns the atoms of this rigid body
     * @return the atoms of this rigid body in a vector
     * @deprecate
     */           
    std::vector<Atom*> getAtoms() {
      return atoms_;
    }

    /** 
     * Returns the number of atoms in this rigid body
     * @return the number of atoms in this rigid body
     */
    int getNumAtoms() {
      return atoms_.size();
    }

    /**
     * Return the position of atom which belongs to this rigid body.
     * @return true if index is valid otherwise return false
     * @param pos the position of atom which will be set on return if index is valid
     * @param index the index of the atom in rigid body's private data member atoms_
     */
    bool getAtomPos(Vector3d& pos, unsigned int index);

    /**
     * Return the position of atom which belongs to this rigid body.
     * @return true if atom belongs to this rigid body,otherwise return false
     * @param pos position of atom which will be set on return if atom belongs to this rigid body
     * @param atom the pointer to an atom
     */            
    bool getAtomPos(Vector3d& pos, Atom* atom);

    /**
     * Return the velocity of atom which belongs to this rigid body.
     * @return true if index is valid otherwise return false
     * @param vel the velocity of atom which will be set on return if index is valid
     * @param index the index of the atom in rigid body's private data member atoms_
     */
    bool getAtomVel(Vector3d& vel, unsigned int index);

    /**
     * Return the velocity of atom which belongs to this rigid body.
     * @return true if atom belongs to this rigid body,otherwise return false
     * @param vel velocity of atom which will be set on return if atom belongs to this rigid body
     * @param atom the pointer to an atom
     */ 
    bool getAtomVel(Vector3d& vel, Atom*);

    /**
     * Return the reference coordinate of atom which belongs to this rigid body.
     * @return true if index is valid otherwise return false
     * @param coor the reference coordinate of atom which will be set on return if index is valid
     * @param index the index of the atom in rigid body's private data member atoms_
     */
    bool getAtomRefCoor(Vector3d& coor, unsigned int index);

    /**
     * Return the velocity of atom which belongs to this rigid body.
     * @return true if atom belongs to this rigid body,otherwise return false
     * @param coor velocity of atom which will be set on return if atom belongs to this rigid body
     * @param atom the pointer to an atom
     */ 
    bool getAtomRefCoor(Vector3d& coor, Atom* atom);

  private:
    std::string name_;        
    Mat3x3d inertiaTensor_;     
    RotMat3x3d sU_;               /**< body fixed standard unit vector */
        
    std::vector<Atom*> atoms_;
    std::vector<Vector3d> refCoords_;
    std::vector<RotMat3x3d> refOrients_;
  };

}//namespace OpenMD

#endif //PRIMITIVES_RIGIDBODY_HPP

Revision:	1794
Committed:	Thu Sep 6 19:44:06 2012 UTC (12 years, 8 months ago) by gezelter
File size:	8027 byte(s)
Log Message:	Merging some of the trunk changes back to the development branch, cleaning up a datastorage bug
#	User	Rev	Content
1	gezelter	507	/*
2	gezelter	246	* 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	gezelter	1390	* 1. Redistributions of source code must retain the above copyright
10	gezelter	246	* notice, this list of conditions and the following disclaimer.
11			*
12	gezelter	1390	* 2. Redistributions in binary form must reproduce the above copyright
13	gezelter	246	* 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	gezelter	1390	*
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	gezelter	1665	* [4] Kuang & Gezelter, J. Chem. Phys. 133, 164101 (2010).
40			* [5] Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41	gezelter	246	*/
42
43			/**
44			* @file RigidBody.hpp
45			* @author tlin
46			* @date 10/23/2004
47			* @version 1.0
48			*/
49	gezelter	2
50	gezelter	246	#ifndef PRIMITIVES_RIGIDBODY_HPP
51			#define PRIMITIVES_RIGIDBODY_HPP
52
53	gezelter	2	#include <vector>
54	gezelter	246
55	tim	3	#include "primitives/StuntDouble.hpp"
56	gezelter	246	#include "primitives/DirectionalAtom.hpp"
57			#include "types/AtomStamp.hpp"
58	gezelter	1390	namespace OpenMD{
59	gezelter	507	class RigidBody : public StuntDouble {
60			public:
61	tim	284
62	gezelter	507	typedef std::vector<Atom*>::iterator AtomIterator;
63	tim	284
64	gezelter	507	RigidBody();
65	gezelter	2
66	gezelter	507	virtual std::string getType() { return name_;}
67	gezelter	246
68	tim	963	/** Sets the name of this stuntRealType*/
69	gezelter	507	virtual void setType(const std::string& name) { name_ = name;}
70	gezelter	246
71	gezelter	2
72	gezelter	507	/**
73			* Sets the previous rotation matrix of this stuntdouble
74			* @param a new rotation matrix
75			*/
76			virtual void setPrevA(const RotMat3x3d& a);
77	gezelter	246
78	gezelter	507	/**
79			* Sets the current rotation matrix of this stuntdouble
80			* @param a new rotation matrix
81			* @note setA will not change the position and rotation matrix of Directional atoms belong to
82			* this rigidbody. If you want to do that, use #updateAtoms
83			*/
84			virtual void setA(const RotMat3x3d& a);
85			/**
86			* Sets the rotation matrix of this stuntdouble in specified snapshot
87			* @param a rotation matrix to be set
88			* @param snapshotNo
89			* @see #getA
90			*/
91			virtual void setA(const RotMat3x3d& a, int snapshotNo);
92	gezelter	2
93	gezelter	507	/**
94			* Returns the inertia tensor of this stuntdouble
95			* @return the inertia tensor of this stuntdouble
96			*/
97			virtual Mat3x3d getI();
98	gezelter	2
99	gezelter	507	/**
100			* Returns the gradient of this stuntdouble
101			* @return the inertia tensor of this stuntdouble
102			* @see #setI
103			*/
104	tim	963	virtual std::vector<RealType> getGrad();
105	gezelter	2
106	gezelter	507	virtual void accept(BaseVisitor* v);
107	gezelter	2
108	gezelter	507	void addAtom(Atom* at, AtomStamp* ats);
109	gezelter	2
110	gezelter	1126	/** calculates the reference coordinates */
111	gezelter	507	void calcRefCoords();
112	gezelter	2
113	gezelter	1126	/** Converts Atomic forces and torques to total forces and torques */
114	gezelter	507	void calcForcesAndTorques();
115	gezelter	2
116	gezelter	1794	/**
117			Converts Atomic forces and torques to total forces and torques
118			and computes the rigid body contribution to the virial.
119			Returns the rigid body contribution to the virial as a 3x3
120			matrix.
121			*/
122	gezelter	1126	Mat3x3d calcForcesAndTorquesAndVirial();
123	gezelter	1794
124	gezelter	507	/** update the positions of atoms belong to this rigidbody */
125			void updateAtoms();
126	gezelter	2
127	gezelter	507	void updateAtoms(int frame);
128	tim	318
129	gezelter	507	void updateAtomVel();
130	tim	318
131	gezelter	507	void updateAtomVel(int frame);
132	tim	318
133	gezelter	507	Atom* beginAtom(std::vector<Atom*>::iterator& i) {
134			i = atoms_.begin();
135			return i != atoms_.end() ? *i : NULL;
136			}
137	gezelter	2
138	gezelter	507	Atom* nextAtom(std::vector<Atom*>::iterator& i) {
139			++i;
140			return i != atoms_.end() ? *i : NULL;
141			}
142	gezelter	2
143	gezelter	507	std::vector<Atom*>::iterator getBeginAtomIter() {
144			return atoms_.begin();
145			}
146	gezelter	246
147	gezelter	507	std::vector<Atom*>::iterator getEndAtomIter() {
148			return atoms_.end();
149			}
150	gezelter	2
151	gezelter	507	/**
152			* Returns the atoms of this rigid body
153			* @return the atoms of this rigid body in a vector
154			* @deprecate
155			*/
156			std::vector<Atom*> getAtoms() {
157			return atoms_;
158			}
159	gezelter	2
160	gezelter	507	/**
161			* Returns the number of atoms in this rigid body
162			* @return the number of atoms in this rigid body
163			*/
164			int getNumAtoms() {
165			return atoms_.size();
166			}
167	gezelter	2
168	gezelter	507	/**
169			* Return the position of atom which belongs to this rigid body.
170			* @return true if index is valid otherwise return false
171			* @param pos the position of atom which will be set on return if index is valid
172			* @param index the index of the atom in rigid body's private data member atoms_
173			*/
174			bool getAtomPos(Vector3d& pos, unsigned int index);
175	gezelter	2
176	gezelter	507	/**
177			* Return the position of atom which belongs to this rigid body.
178			* @return true if atom belongs to this rigid body,otherwise return false
179			* @param pos position of atom which will be set on return if atom belongs to this rigid body
180			* @param atom the pointer to an atom
181			*/
182			bool getAtomPos(Vector3d& pos, Atom* atom);
183	gezelter	2
184	gezelter	507	/**
185			* Return the velocity of atom which belongs to this rigid body.
186			* @return true if index is valid otherwise return false
187			* @param vel the velocity of atom which will be set on return if index is valid
188			* @param index the index of the atom in rigid body's private data member atoms_
189			*/
190			bool getAtomVel(Vector3d& vel, unsigned int index);
191	gezelter	2
192	gezelter	507	/**
193			* Return the velocity of atom which belongs to this rigid body.
194			* @return true if atom belongs to this rigid body,otherwise return false
195			* @param vel velocity of atom which will be set on return if atom belongs to this rigid body
196			* @param atom the pointer to an atom
197			*/
198			bool getAtomVel(Vector3d& vel, Atom*);
199	gezelter	2
200	gezelter	507	/**
201			* Return the reference coordinate of atom which belongs to this rigid body.
202			* @return true if index is valid otherwise return false
203			* @param coor the reference coordinate of atom which will be set on return if index is valid
204			* @param index the index of the atom in rigid body's private data member atoms_
205			*/
206			bool getAtomRefCoor(Vector3d& coor, unsigned int index);
207	gezelter	2
208	gezelter	507	/**
209			* Return the velocity of atom which belongs to this rigid body.
210			* @return true if atom belongs to this rigid body,otherwise return false
211			* @param coor velocity of atom which will be set on return if atom belongs to this rigid body
212			* @param atom the pointer to an atom
213			*/
214			bool getAtomRefCoor(Vector3d& coor, Atom* atom);
215	gezelter	2
216	gezelter	507	private:
217			std::string name_;
218			Mat3x3d inertiaTensor_;
219			RotMat3x3d sU_; /*< body fixed standard unit vector /
220	gezelter	246
221	gezelter	507	std::vector<Atom*> atoms_;
222			std::vector<Vector3d> refCoords_;
223			std::vector<RotMat3x3d> refOrients_;
224			};
225	gezelter	2
226	gezelter	1390	}//namespace OpenMD
227	gezelter	2
228	gezelter	246	#endif //PRIMITIVES_RIGIDBODY_HPP
229	gezelter	2