ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/primitives/DirectionalAtom.hpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/primitives/DirectionalAtom.hpp (file contents):
Revision 1490 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1930 by gezelter, Wed Jan 12 22:41:40 2005 UTC

# Line 1 | Line 1
1 < #ifndef _DIRECTIONALATOM_H_
2 < #define _DIRECTIONALATOM_H_
3 <
4 < #include <string.h>
5 < #include <stdlib.h>
6 < #include <iostream>
7 <
8 < #include "StuntDouble.hpp"
9 < #include "Atom.hpp"
10 <
11 < class DirectionalAtom : public Atom {
12 <  
13 < public:
14 <  DirectionalAtom(int theIndex, SimState* theConfig) : Atom(theIndex,
15 <                                                            theConfig)
16 <  {
17 <    objType = OT_DATOM;
18 <
19 <    for (int i=0; i < 3; i++)
20 <      for (int j=0; j < 3; j++)
21 <        sU[i][j] = 0.0;
22 <
23 <  }
24 <  virtual ~DirectionalAtom() {}
25 <
26 <  virtual void setCoords(void);
27 <
28 <  void printAmatIndex( void );
29 <  
30 <  void setUnitFrameFromEuler(double phi, double theta, double psi);
31 <  void setEuler( double phi, double theta, double psi );
32 <
33 <  void zeroForces();
34 <
35 <  void getA( double the_A[3][3] ); // get the full rotation matrix
36 <  void setA( double the_A[3][3] );
37 <  void rotateBy( double by_A[3][3] );  // rotate your frame using this matrix
38 <
39 <  void getU( double the_u[3] ); // get the unit vetor
40 <  void updateU( void );
41 <
42 <  void getQ( double the_q[4] ); // get the quanternions
43 <  void setQ( double the_q[4] );
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. Acknowledgement of the program authors must be made in any
10 > *    publication of scientific results based in part on use of the
11 > *    program.  An acceptable form of acknowledgement is citation of
12 > *    the article in which the program was described (Matthew
13 > *    A. Meineke, Charles F. Vardeman II, Teng Lin, Christopher
14 > *    J. Fennell and J. Daniel Gezelter, "OOPSE: An Object-Oriented
15 > *    Parallel Simulation Engine for Molecular Dynamics,"
16 > *    J. Comput. Chem. 26, pp. 252-271 (2005))
17 > *
18 > * 2. Redistributions of source code must retain the above copyright
19 > *    notice, this list of conditions and the following disclaimer.
20 > *
21 > * 3. Redistributions in binary form must reproduce the above copyright
22 > *    notice, this list of conditions and the following disclaimer in the
23 > *    documentation and/or other materials provided with the
24 > *    distribution.
25 > *
26 > * This software is provided "AS IS," without a warranty of any
27 > * kind. All express or implied conditions, representations and
28 > * warranties, including any implied warranty of merchantability,
29 > * fitness for a particular purpose or non-infringement, are hereby
30 > * excluded.  The University of Notre Dame and its licensors shall not
31 > * be liable for any damages suffered by licensee as a result of
32 > * using, modifying or distributing the software or its
33 > * derivatives. In no event will the University of Notre Dame or its
34 > * licensors be liable for any lost revenue, profit or data, or for
35 > * direct, indirect, special, consequential, incidental or punitive
36 > * damages, however caused and regardless of the theory of liability,
37 > * arising out of the use of or inability to use software, even if the
38 > * University of Notre Dame has been advised of the possibility of
39 > * such damages.
40 > */
41  
42 <  void getJ( double theJ[3] );
43 <  void setJ( double theJ[3] );
42 > /**
43 > * @file DirectionalAtom.hpp
44 > * @author    tlin
45 > * @date  10/23/2004
46 > * @version 1.0
47 > */
48  
49 <  void getTrq( double theT[3] );
50 <  void addTrq( double theT[3] );
49 > #ifndef PRIMITIVES_DIRECTIONALATOM_HPP
50 > #define PRIMITIVES_DIRECTIONALATOM_HPP
51  
52 <  void setI( double the_I[3][3] );
53 <  void getI( double the_I[3][3] );
54 <  
55 <  void lab2Body( double r[3] );
56 <  void body2Lab( double r[3] );
52 > #include "primitives/Atom.hpp"
53 > #include "types/DirectionalAtomType.hpp"
54 > namespace oopse{
55 >    class DirectionalAtom : public Atom {
56 >        public:
57 >            DirectionalAtom(DirectionalAtomType* dAtomType);
58 >            /**
59 >             * Returns the inertia tensor of this stuntdouble
60 >             * @return the inertia tensor of this stuntdouble
61 >             */
62 >            virtual Mat3x3d getI();            
63  
64 <  double getZangle( );
65 <  void setZangle( double zAng );
66 <  void addZangle( double zAng );
64 >           /**
65 >             * Sets  the previous rotation matrix of this stuntdouble
66 >             * @param a  new rotation matrix
67 >             */        
68 >           virtual void setPrevA(const RotMat3x3d& a);
69 >          
70 >           /**
71 >             * Sets  the current rotation matrix of this stuntdouble
72 >             * @param a  new rotation matrix
73 >             */        
74 >            virtual void setA(const RotMat3x3d& a);
75  
76 <  // Four functions added for derivatives with respect to Euler Angles:
77 <  // (Needed for minimization routines):
76 >           /**
77 >             * Sets  the rotation matrix of this stuntdouble in specified snapshot
78 >             * @param a rotation matrix to be set
79 >             * @param snapshotNo
80 >             * @see #getA
81 >             */        
82 >            virtual void setA(const RotMat3x3d& a, int snapshotNo);
83  
84 <  void getGrad(double gradient[6] );
85 <  void getEulerAngles( double myEuler[3] );
84 >            /**
85 >             * Left multiple rotation matrix by another rotation matrix
86 >             * @param m a rotation matrix
87 >             */
88 >            void rotateBy(const RotMat3x3d& m);
89 >            
90  
91 <  double max(double x, double y);
92 <  double min(double x, double y);
91 >            /**
92 >             * Returns the gradient of this stuntdouble
93 >             * @return the gradient of this stuntdouble
94 >             */
95 >            virtual std::vector<double> getGrad();
96  
97 <  virtual void accept(BaseVisitor* v) {v->visit(this);}
98 <  
99 < private:
100 <  int dIndex;
97 >            virtual void accept(BaseVisitor* v);
98 >                
99 >        protected:
100 >            Mat3x3d inertiaTensor_;                             /**< inertial tensor */    
101 >            RotMat3x3d electroBodyFrame_;               /**< body fixed standard eletrostatic frame */
102 >    };
103  
104 <  double sU[3][3];       // the standard unit vectors    ( body fixed )
76 <  
77 <  double jx, jy, jz;    // the angular momentum vector ( body fixed )
78 <  
79 <  double Ixx, Ixy, Ixz; // the inertial tensor matrix  ( body fixed )
80 <  double Iyx, Iyy, Iyz;
81 <  double Izx, Izy, Izz;
104 > }//namepace oopse
105  
106 < };
84 <
85 < #endif
106 > #endif //PRIMITIVES_DIRECTIONALATOM_HPP

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines