ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/primitives/StuntDouble.hpp
(Generate patch)

Comparing trunk/src/primitives/StuntDouble.hpp (file contents):
Revision 507 by gezelter, Fri Apr 15 22:04:00 2005 UTC vs.
Revision 1024 by tim, Wed Aug 30 18:42:29 2006 UTC

# Line 65 | Line 65 | namespace oopse{
65    /**
66     * @class StuntDouble StuntDouble.hpp "Primitives/StuntDouble.hpp"
67     * @brief
68 +   *     "Don't move, or you're dead! Stand up! Captain, we've got them!"
69 +   *
70 +   *     "Spectacular stunt, my friends, but all for naught. Turn around
71 +   *      please. Ha. What a pity. What a pity. So, Princess, you thought
72 +   *      you could outwit the imperious forces of...."
73 +   *
74 +   *     "You idiots! These are not them. You've captured their stunt
75 +   *      doubles! Search the area. Find them! Find them!"
76 +   *
77     * StuntDouble is a very strange idea.  A StuntDouble stands in for
78     * some object that can be manipulated by the Integrators or
79     * Minimizers.  Some of the manipulable objects are Atoms, some are
80     * DirectionalAtoms, and some are RigidBodies.  StuntDouble
81     * provides an interface for the Integrators and Minimizers to use,
82     * and does some preliminary sanity checking so that the program
83 <   * doesn't try to do something stupid like torque an Atom
83 >   * doesn't try to do something stupid like torque an Atom (The
84 >   * quotes above are from Spaceballs...)
85 >   *
86     * @note the dynamic data of stuntdouble will be stored outside of the class
87     */
88    class StuntDouble{
# Line 86 | Line 97 | namespace oopse{
97      virtual ~StuntDouble();
98          
99      /**
100 <     * Returns the global index of this stuntdouble.
100 >     * Returns the global index of this stuntRealType.
101       * @return  the global index of this stuntdouble
102       */
103      int getGlobalIndex() {
# Line 94 | Line 105 | namespace oopse{
105      }
106  
107      /**
108 <     * Sets the global index of this stuntdouble.
108 >     * Sets the global index of this stuntRealType.
109       * @param new global index to be set
110       */
111      void setGlobalIndex(int index) {
# Line 117 | Line 128 | namespace oopse{
128        localIndex_ = index;
129      }
130  
131 +  int getGlobalIntegrableObjectIndex(){
132 +        return globalIntegrableObjectIndex_;
133 +  }
134 +  void setGlobalIntegrableObjectIndex(int index) {
135 +     globalIntegrableObjectIndex_ = index;
136 +  }
137 +
138      /**
139       * Sets the Snapshot Manager of this stuntdouble
140       */
# Line 154 | Line 172 | namespace oopse{
172       */
173      bool isDirectional(){
174        return isDirectionalAtom() || isRigidBody();
175 +    }
176 +
177 +    /**
178 +     * Freezes out all velocity, angular velocity, forces and torques
179 +     * on this StuntDouble.  Also computes the number of frozen degrees
180 +     * of freedom.
181 +     * @return the total number of frozen degrees of freedom
182 +     */  
183 +    int freeze() {
184 +      
185 +      int fdf = 3;
186 +
187 +      setVel(V3Zero);
188 +      setFrc(V3Zero);
189 +      if (isDirectional()){
190 +        setJ(V3Zero);
191 +        setTrq(V3Zero);
192 +        if (isLinear())
193 +          fdf +=2;
194 +        else
195 +          fdf +=3;        
196 +      }      
197 +      return fdf;
198      }
199  
200      /**
# Line 449 | Line 490 | namespace oopse{
490      }
491  
492      /**
493 <     * Sets  the previous euler angles of this stuntdouble.
493 >     * Sets  the previous euler angles of this stuntRealType.
494       * @param euler  new euler angles
495       * @see #getEuler
496       * @note actual storage data is rotation matrix        
# Line 676 | Line 717 | namespace oopse{
717       * Returns the previous z-angle of this stuntdouble
718       * @return the z-angle of this stuntdouble
719       */    
720 <    double getPrevZangle() {
720 >    RealType getPrevZangle() {
721        return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
722      }
723        
# Line 684 | Line 725 | namespace oopse{
725       * Returns the current z-angle of this stuntdouble
726       * @return the z-angle of this stuntdouble
727       */    
728 <    double getZangle() {
728 >    RealType getZangle() {
729        return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
730      }
731  
# Line 693 | Line 734 | namespace oopse{
734       * @return the z-angle of this stuntdouble
735       * @param snapshotNo
736       */    
737 <    double getZangle(int snapshotNo) {
737 >    RealType getZangle(int snapshotNo) {
738        return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_];
739      }
740  
# Line 702 | Line 743 | namespace oopse{
743       * @param angle  new z-angle
744       * @see #getZangle
745       */        
746 <    void setPrevZangle(double angle) {
746 >    void setPrevZangle(RealType angle) {
747        ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] = angle;
748      }
749        
# Line 710 | Line 751 | namespace oopse{
751       * Sets  the current z-angle of this stuntdouble
752       * @param angle  new z-angle
753       */        
754 <    void setZangle(double angle) {
754 >    void setZangle(RealType angle) {
755        ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] = angle;
756      }
757  
# Line 720 | Line 761 | namespace oopse{
761       * @param snapshotNo
762       * @see #getZangle
763       */        
764 <    void setZangle(double angle, int snapshotNo) {
764 >    void setZangle(RealType angle, int snapshotNo) {
765        ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] = angle;
766      }
767  
# Line 729 | Line 770 | namespace oopse{
770       * @param angle  new z-angle
771       * @see #getZangle
772       */        
773 <    void addPrevZangle(double angle) {
773 >    void addPrevZangle(RealType angle) {
774        ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] += angle;
775      }
776        
# Line 737 | Line 778 | namespace oopse{
778       * Adds z-angle into the current z-angle of this stuntdouble
779       * @param angle  new z-angle
780       */        
781 <    void addZangle(double angle) {
781 >    void addZangle(RealType angle) {
782        ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] += angle;
783      }
784  
# Line 747 | Line 788 | namespace oopse{
788       * @param snapshotNo
789       * @see #getZangle
790       */        
791 <    void addZangle(double angle, int snapshotNo) {
791 >    void addZangle(RealType angle, int snapshotNo) {
792        ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
793      }      
794  
# Line 763 | Line 804 | namespace oopse{
804       * Returns the gradient of this stuntdouble
805       * @return the gradient of this stuntdouble
806       */
807 <    virtual std::vector<double> getGrad() = 0;
807 >    virtual std::vector<RealType> getGrad() = 0;
808  
809      /**
810       * Tests the  if this stuntdouble is a  linear rigidbody
# Line 789 | Line 830 | namespace oopse{
830      }
831  
832      /** Returns the mass of this stuntdouble */
833 <    double getMass() {
833 >    RealType getMass() {
834        return mass_;
835      }
836  
# Line 797 | Line 838 | namespace oopse{
838       * Sets the mass of this stuntdoulbe
839       * @param mass the mass to be set
840       */        
841 <    void setMass(double mass) {
841 >    void setMass(RealType mass) {
842        mass_ = mass;
843      }
844  
845      /** Returns the name of this stuntdouble */
846      virtual std::string getType() = 0;
847          
848 <    /** Sets the name of this stuntdouble*/
848 >    /** Sets the name of this stuntRealType*/
849      virtual void setType(const std::string& name) {}
850  
851      /**
# Line 898 | Line 939 | namespace oopse{
939  
940          
941      int globalIndex_;
942 +    int globalIntegrableObjectIndex_;
943      int localIndex_;
944  
945  
946 <    double mass_;
946 >    RealType mass_;
947          
948    private:
949          

Diff Legend

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