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

Comparing trunk/src/primitives/StuntDouble.hpp (file contents):
Revision 1245 by chuckv, Tue May 27 16:39:06 2008 UTC vs.
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC

# Line 6 | Line 6
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
9 > * 1. Redistributions of source code must retain the above copyright
10   *    notice, this list of conditions and the following disclaimer.
11   *
12 < * 3. Redistributions in binary form must reproduce the above copyright
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.
# Line 37 | Line 28
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   /**
# Line 58 | Line 58
58   #include "utils/PropertyMap.hpp"
59   #include "brains/Snapshot.hpp"
60   #include "brains/SnapshotManager.hpp"
61 < namespace oopse{
61 > namespace OpenMD{
62  
63  
64    
# Line 760 | Line 760 | namespace oopse{
760       */        
761      void addTrq(const Vector3d& trq, int snapshotNo) {
762        ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] += trq;
763 +    }      
764 +
765 +
766 +
767 +    /**
768 +     * Returns the previous particlePot of this stuntDouble
769 +     * @return the particlePot of this stuntDouble
770 +     */    
771 +    RealType getPrevParticlePot() {
772 +      return ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_];
773 +    }
774 +      
775 +    /**
776 +     * Returns the current particlePot of this stuntDouble
777 +     * @return the particlePot of this stuntDouble
778 +     */    
779 +    RealType getParticlePot() {
780 +      return ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_];
781 +    }
782 +
783 +    /**
784 +     * Returns the particlePot of this stuntDouble in specified snapshot
785 +     *
786 +     * @return the particlePot of this stuntDouble
787 +     * @param snapshotNo
788 +     */    
789 +    RealType getParticlePot(int snapshotNo) {
790 +      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_];
791 +    }
792 +
793 +    /**
794 +     * Sets  the previous particlePot of this stuntDouble
795 +     *
796 +     * @param particlePot  new particlePot
797 +     * @see #getParticlePot
798 +     */        
799 +    void setPrevParticlePot(const RealType& particlePot) {
800 +      ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
801 +    }
802 +      
803 +    /**
804 +     * Sets  the current particlePot of this stuntDouble
805 +     * @param particlePot  new particlePot
806 +     */        
807 +    void setParticlePot(const RealType& particlePot) {
808 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
809 +    }
810 +
811 +    /**
812 +     * Sets  the particlePot of this stuntDouble in specified snapshot
813 +     *
814 +     * @param particlePot particlePot to be set
815 +     * @param snapshotNo
816 +     * @see #getParticlePot
817 +     */        
818 +    void setParticlePot(const RealType& particlePot, int snapshotNo) {
819 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] = particlePot;
820 +    }
821 +
822 +    /**
823 +     * Adds particlePot into the previous particlePot of this stuntDouble
824 +     *
825 +     * @param particlePot  new particlePot
826 +     * @see #getParticlePot
827 +     */        
828 +    void addPrevParticlePot(const RealType& particlePot) {
829 +      ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
830 +    }
831 +      
832 +    /**
833 +     * Adds particlePot into the current particlePot of this stuntDouble
834 +     * @param particlePot  new particlePot
835 +     */        
836 +    void addParticlePot(const RealType& particlePot) {
837 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
838 +    }
839 +
840 +    /**
841 +     * Adds particlePot into the particlePot of this stuntDouble in specified snapshot
842 +     *
843 +     * @param particlePot particlePot to be add
844 +     * @param snapshotNo
845 +     * @see #getParticlePot
846 +     */        
847 +    void addParticlePot(const RealType& particlePot, int snapshotNo) {
848 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] += particlePot;
849      }      
850  
851  
# Line 925 | Line 1011 | namespace oopse{
1011      }
1012  
1013      /**
928 –     * Returns the previous particle potential of this stuntDouble
929 –     * @return the particle potential of this stuntDouble
930 –     */    
931 –    RealType getPrevParticlePot() {
932 –      return ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_];
933 –    }
934 –      
935 –    /**
936 –     * Returns the current particle potential of this stuntDouble
937 –     * @return the particle potential of this stuntDouble
938 –     */    
939 –    RealType getParticlePot() {
940 –      return ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_];
941 –    }
942 –
943 –    /**
944 –     * Returns the particle potential of this stuntDouble in specified snapshot
945 –     * @return the particle potential of this stuntDouble
946 –     * @param snapshotNo
947 –     */    
948 –    RealType getParticlePot(int snapshotNo) {
949 –      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_];
950 –    }
951 –
952 –    /**
953 –     * Sets  the previous particle potential of this stuntDouble
954 –     * @param po tnew particle potential
955 –     * @see #getParticlePot
956 –     */        
957 –    void setPrevParticlePot(RealType pot) {
958 –      ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] = pot;
959 –    }
960 –      
961 –    /**
962 –     * Sets  the current velocity of this stuntDouble
963 –     * @param vel  new velocity
964 –     */        
965 –    void setParticlePot(RealType pot) {
966 –      ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] = pot;
967 –    }
968 –
969 –    /**
970 –     * Sets  the particle potential of this stuntDouble in specified snapshot
971 –     * @param pot potential to be set
972 –     * @param snapshotNo
973 –     * @see #getVel
974 –     */        
975 –    void setParticlePot(RealType pot, int snapshotNo) {
976 –      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] = pot;
977 –    }
978 –
979 –    /**
1014       * <p>
1015 <     * The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
1016 <     * the elements of a data structure. In this way, you can change the operation being performed
1017 <     * on a structure without the need of changing the classes of the elements that you are operating
1018 <     * on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
1019 <     * algorithms used upon them
1015 >     * The purpose of the Visitor Pattern is to encapsulate an
1016 >     * operation that you want to perform on the elements of a data
1017 >     * structure. In this way, you can change the operation being
1018 >     * performed on a structure without the need of changing the
1019 >     * classes of the elements that you are operating on. Using a
1020 >     * Visitor pattern allows you to decouple the classes for the data
1021 >     * structure and the algorithms used upon them
1022       * </p>
1023       * @param v visitor
1024       */      
# Line 1053 | Line 1089 | namespace oopse{
1089      PropertyMap properties_;
1090    };
1091  
1092 < }//end namespace oopse
1092 > }//end namespace OpenMD
1093   #endif //PRIMITIVES_STUNTDOUBLE_HPP

Diff Legend

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