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, 234107 (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 gradient of this stuntdouble
     */ 
    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
     * @deprecated
     */           
    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:	1850
Committed:	Wed Feb 20 15:39:39 2013 UTC (12 years, 2 months ago) by gezelter
File size:	8005 byte(s)
Log Message:	Fixed a widespread typo in the license
#	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	gezelter	1850	* [3] Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (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	gezelter	1808	* @return the gradient of this stuntdouble
102	gezelter	507	*/
103	tim	963	virtual std::vector<RealType> getGrad();
104	gezelter	2
105	gezelter	507	virtual void accept(BaseVisitor* v);
106	gezelter	2
107	gezelter	507	void addAtom(Atom* at, AtomStamp* ats);
108	gezelter	2
109	gezelter	1126	/** calculates the reference coordinates */
110	gezelter	507	void calcRefCoords();
111	gezelter	2
112	gezelter	1126	/** Converts Atomic forces and torques to total forces and torques */
113	gezelter	507	void calcForcesAndTorques();
114	gezelter	2
115	gezelter	1794	/**
116			Converts Atomic forces and torques to total forces and torques
117			and computes the rigid body contribution to the virial.
118			Returns the rigid body contribution to the virial as a 3x3
119			matrix.
120			*/
121	gezelter	1126	Mat3x3d calcForcesAndTorquesAndVirial();
122	gezelter	1794
123	gezelter	507	/** update the positions of atoms belong to this rigidbody */
124			void updateAtoms();
125	gezelter	2
126	gezelter	507	void updateAtoms(int frame);
127	tim	318
128	gezelter	507	void updateAtomVel();
129	tim	318
130	gezelter	507	void updateAtomVel(int frame);
131	tim	318
132	gezelter	507	Atom* beginAtom(std::vector<Atom*>::iterator& i) {
133			i = atoms_.begin();
134			return i != atoms_.end() ? *i : NULL;
135			}
136	gezelter	2
137	gezelter	507	Atom* nextAtom(std::vector<Atom*>::iterator& i) {
138			++i;
139			return i != atoms_.end() ? *i : NULL;
140			}
141	gezelter	2
142	gezelter	507	std::vector<Atom*>::iterator getBeginAtomIter() {
143			return atoms_.begin();
144			}
145	gezelter	246
146	gezelter	507	std::vector<Atom*>::iterator getEndAtomIter() {
147			return atoms_.end();
148			}
149	gezelter	2
150	gezelter	507	/**
151			* Returns the atoms of this rigid body
152			* @return the atoms of this rigid body in a vector
153	gezelter	1808	* @deprecated
154	gezelter	507	*/
155			std::vector<Atom*> getAtoms() {
156			return atoms_;
157			}
158	gezelter	2
159	gezelter	507	/**
160			* Returns the number of atoms in this rigid body
161			* @return the number of atoms in this rigid body
162			*/
163			int getNumAtoms() {
164			return atoms_.size();
165			}
166	gezelter	2
167	gezelter	507	/**
168			* Return the position of atom which belongs to this rigid body.
169			* @return true if index is valid otherwise return false
170			* @param pos the position of atom which will be set on return if index is valid
171			* @param index the index of the atom in rigid body's private data member atoms_
172			*/
173			bool getAtomPos(Vector3d& pos, unsigned int index);
174	gezelter	2
175	gezelter	507	/**
176			* Return the position of atom which belongs to this rigid body.
177			* @return true if atom belongs to this rigid body,otherwise return false
178			* @param pos position of atom which will be set on return if atom belongs to this rigid body
179			* @param atom the pointer to an atom
180			*/
181			bool getAtomPos(Vector3d& pos, Atom* atom);
182	gezelter	2
183	gezelter	507	/**
184			* Return the velocity of atom which belongs to this rigid body.
185			* @return true if index is valid otherwise return false
186			* @param vel the velocity of atom which will be set on return if index is valid
187			* @param index the index of the atom in rigid body's private data member atoms_
188			*/
189			bool getAtomVel(Vector3d& vel, unsigned int index);
190	gezelter	2
191	gezelter	507	/**
192			* Return the velocity of atom which belongs to this rigid body.
193			* @return true if atom belongs to this rigid body,otherwise return false
194			* @param vel velocity of atom which will be set on return if atom belongs to this rigid body
195			* @param atom the pointer to an atom
196			*/
197			bool getAtomVel(Vector3d& vel, Atom*);
198	gezelter	2
199	gezelter	507	/**
200			* Return the reference coordinate of atom which belongs to this rigid body.
201			* @return true if index is valid otherwise return false
202			* @param coor the reference coordinate of atom which will be set on return if index is valid
203			* @param index the index of the atom in rigid body's private data member atoms_
204			*/
205			bool getAtomRefCoor(Vector3d& coor, unsigned int index);
206	gezelter	2
207	gezelter	507	/**
208			* Return the velocity of atom which belongs to this rigid body.
209			* @return true if atom belongs to this rigid body,otherwise return false
210			* @param coor velocity of atom which will be set on return if atom belongs to this rigid body
211			* @param atom the pointer to an atom
212			*/
213			bool getAtomRefCoor(Vector3d& coor, Atom* atom);
214	gezelter	2
215	gezelter	507	private:
216			std::string name_;
217			Mat3x3d inertiaTensor_;
218			RotMat3x3d sU_; /*< body fixed standard unit vector /
219	gezelter	246
220	gezelter	507	std::vector<Atom*> atoms_;
221			std::vector<Vector3d> refCoords_;
222			std::vector<RotMat3x3d> refOrients_;
223			};
224	gezelter	2
225	gezelter	1390	}//namespace OpenMD
226	gezelter	2
227	gezelter	246	#endif //PRIMITIVES_RIGIDBODY_HPP
228	gezelter	2