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 1245 by chuckv, Tue May 27 16:39:06 2008 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (file contents), Revision 1710 by gezelter, Fri May 18 21:44:02 2012 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]  Kuang & Gezelter,  J. Chem. Phys. 133, 164101 (2010).
40 + * [5]  Vardeman, Stocker & Gezelter, J. Chem. Theory Comput. 7, 834 (2011).
41   */
42  
43   /**
# Line 58 | Line 59
59   #include "utils/PropertyMap.hpp"
60   #include "brains/Snapshot.hpp"
61   #include "brains/SnapshotManager.hpp"
62 < namespace oopse{
62 > namespace OpenMD{
63  
64  
65    
# Line 760 | Line 761 | namespace oopse{
761       */        
762      void addTrq(const Vector3d& trq, int snapshotNo) {
763        ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).torque[localIndex_] += trq;
764 +    }      
765 +
766 +
767 +
768 +    /**
769 +     * Returns the previous particlePot of this stuntDouble
770 +     * @return the particlePot of this stuntDouble
771 +     */    
772 +    RealType getPrevParticlePot() {
773 +      return ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_];
774 +    }
775 +      
776 +    /**
777 +     * Returns the current particlePot of this stuntDouble
778 +     * @return the particlePot of this stuntDouble
779 +     */    
780 +    RealType getParticlePot() {
781 +      return ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_];
782 +    }
783 +
784 +    /**
785 +     * Returns the particlePot of this stuntDouble in specified snapshot
786 +     *
787 +     * @return the particlePot of this stuntDouble
788 +     * @param snapshotNo
789 +     */    
790 +    RealType getParticlePot(int snapshotNo) {
791 +      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_];
792 +    }
793 +
794 +    /**
795 +     * Sets  the previous particlePot of this stuntDouble
796 +     *
797 +     * @param particlePot  new particlePot
798 +     * @see #getParticlePot
799 +     */        
800 +    void setPrevParticlePot(const RealType& particlePot) {
801 +      ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
802 +    }
803 +      
804 +    /**
805 +     * Sets  the current particlePot of this stuntDouble
806 +     * @param particlePot  new particlePot
807 +     */        
808 +    void setParticlePot(const RealType& particlePot) {
809 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] = particlePot;
810 +    }
811 +
812 +    /**
813 +     * Sets  the particlePot of this stuntDouble in specified snapshot
814 +     *
815 +     * @param particlePot particlePot to be set
816 +     * @param snapshotNo
817 +     * @see #getParticlePot
818 +     */        
819 +    void setParticlePot(const RealType& particlePot, int snapshotNo) {
820 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] = particlePot;
821 +    }
822 +
823 +    /**
824 +     * Adds particlePot into the previous particlePot of this stuntDouble
825 +     *
826 +     * @param particlePot  new particlePot
827 +     * @see #getParticlePot
828 +     */        
829 +    void addPrevParticlePot(const RealType& particlePot) {
830 +      ((snapshotMan_->getPrevSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
831 +    }
832 +      
833 +    /**
834 +     * Adds particlePot into the current particlePot of this stuntDouble
835 +     * @param particlePot  new particlePot
836 +     */        
837 +    void addParticlePot(const RealType& particlePot) {
838 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).particlePot[localIndex_] += particlePot;
839 +    }
840 +
841 +    /**
842 +     * Adds particlePot into the particlePot of this stuntDouble in specified snapshot
843 +     *
844 +     * @param particlePot particlePot to be add
845 +     * @param snapshotNo
846 +     * @see #getParticlePot
847 +     */        
848 +    void addParticlePot(const RealType& particlePot, int snapshotNo) {
849 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] += particlePot;
850      }      
851  
852  
# Line 840 | Line 927 | namespace oopse{
927       */        
928      void addZangle(RealType angle, int snapshotNo) {
929        ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
930 +    }      
931 +
932 +
933 +    /**
934 +     * Returns the previous fluctuating charge of this stuntDouble
935 +     * @return the fluctuating charge of this stuntDouble
936 +     */    
937 +    RealType getPrevFlucQPos() {
938 +      return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_];
939 +    }
940 +      
941 +    /**
942 +     * Returns the current fluctuating charge of this stuntDouble
943 +     * @return the fluctuating charge of this stuntDouble
944 +     */    
945 +    RealType getFlucQPos() {
946 +      return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_];
947 +    }
948 +
949 +    /**
950 +     * Returns the fluctuating charge of this stuntDouble in specified snapshot
951 +     * @return the fluctuating charge of this stuntDouble
952 +     * @param snapshotNo
953 +     */    
954 +    RealType getFlucQPos(int snapshotNo) {
955 +      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_];
956 +    }
957 +
958 +    /**
959 +     * Sets  the previous fluctuating charge of this stuntDouble
960 +     * @param charge  new fluctuating charge
961 +     * @see #getflucQPos
962 +     */        
963 +    void setPrevFlucQPos(RealType charge) {
964 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_] = charge;
965 +    }
966 +      
967 +    /**
968 +     * Sets  the current fluctuating charge of this stuntDouble
969 +     * @param charge  new fluctuating charge
970 +     */        
971 +    void setFlucQPos(RealType charge) {
972 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_] = charge;
973 +    }
974 +
975 +    /**
976 +     * Sets  the fluctuating charge of this stuntDouble in specified snapshot
977 +     * @param charge fluctuating charge to be set
978 +     * @param snapshotNo
979 +     * @see #getflucQPos
980 +     */        
981 +    void setFlucQPos(RealType charge, int snapshotNo) {
982 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_] = charge;
983 +    }
984 +
985 +    /**
986 +     * Adds fluctuating charge into the previous fluctuating charge of this stuntDouble
987 +     * @param charge  new fluctuating charge
988 +     * @see #getflucQPos
989 +     */        
990 +    void addPrevFlucQPos(RealType charge) {
991 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_] += charge;
992 +    }
993 +      
994 +    /**
995 +     * Adds fluctuating charge into the current fluctuating charge of this stuntDouble
996 +     * @param charge  new fluctuating charge
997 +     */        
998 +    void addFlucQPos(RealType charge) {
999 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_] += charge;
1000 +    }
1001 +
1002 +    /**
1003 +     * Adds fluctuating charge into the fluctuating charge of this stuntDouble in specified snapshot
1004 +     * @param value fluctuating charge to be add
1005 +     * @param snapshotNo
1006 +     * @see #getflucQPos
1007 +     */        
1008 +    void addflucQPos(RealType charge, int snapshotNo) {
1009 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_] += charge;
1010 +    }      
1011 +
1012 +
1013 +    /**
1014 +     * Returns the previous charge velocity of this stuntDouble
1015 +     * @return the charge velocity of this stuntDouble
1016 +     */    
1017 +    RealType getPrevFlucQVel() {
1018 +      return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_];
1019 +    }
1020 +      
1021 +    /**
1022 +     * Returns the current charge velocity of this stuntDouble
1023 +     * @return the charge velocity of this stuntDouble
1024 +     */    
1025 +    RealType getFlucQVel() {
1026 +      return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_];
1027 +    }
1028 +
1029 +    /**
1030 +     * Returns the charge velocity of this stuntDouble in specified snapshot
1031 +     * @return the charge velocity of this stuntDouble
1032 +     * @param snapshotNo
1033 +     */    
1034 +    RealType getFlucQVel(int snapshotNo) {
1035 +      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_];
1036 +    }
1037 +
1038 +    /**
1039 +     * Sets  the previous charge velocity of this stuntDouble
1040 +     * @param cvel  new charge velocity
1041 +     * @see #getflucQVel
1042 +     */        
1043 +    void setPrevFlucQVel(RealType cvel) {
1044 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_] = cvel;
1045 +    }
1046 +      
1047 +    /**
1048 +     * Sets  the current charge velocity of this stuntDouble
1049 +     * @param cvel  new charge velocity
1050 +     */        
1051 +    void setFlucQVel(RealType cvel) {
1052 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_] = cvel;
1053 +    }
1054 +
1055 +    /**
1056 +     * Sets  the charge velocity of this stuntDouble in specified snapshot
1057 +     * @param cvel charge velocity to be set
1058 +     * @param snapshotNo
1059 +     * @see #getflucQVel
1060 +     */        
1061 +    void setFlucQVel(RealType cvel, int snapshotNo) {
1062 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_] = cvel;
1063 +    }
1064 +
1065 +    /**
1066 +     * Adds charge velocity into the previous charge velocity of this stuntDouble
1067 +     * @param cvel  new charge velocity
1068 +     * @see #getflucQVel
1069 +     */        
1070 +    void addPrevFlucQVel(RealType cvel) {
1071 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_] += cvel;
1072 +    }
1073 +      
1074 +    /**
1075 +     * Adds charge velocity into the current charge velocity of this stuntDouble
1076 +     * @param cvel  new charge velocity
1077 +     */        
1078 +    void addFlucQVel(RealType cvel) {
1079 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_] += cvel;
1080 +    }
1081 +
1082 +    /**
1083 +     * Adds charge velocity into the charge velocity of this stuntDouble in specified snapshot
1084 +     * @param value charge velocity to be add
1085 +     * @param snapshotNo
1086 +     * @see #getflucQVel
1087 +     */        
1088 +    void addflucQVel(RealType cvel, int snapshotNo) {
1089 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_] += cvel;
1090      }      
1091  
1092 +
1093 +    /**
1094 +     * Returns the previous charge force of this stuntDouble
1095 +     * @return the charge force of this stuntDouble
1096 +     */    
1097 +    RealType getPrevFlucQFrc() {
1098 +      return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_];
1099 +    }
1100 +      
1101 +    /**
1102 +     * Returns the current charge force of this stuntDouble
1103 +     * @return the charge force of this stuntDouble
1104 +     */    
1105 +    RealType getFlucQFrc() {
1106 +      return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_];
1107 +    }
1108 +
1109 +    /**
1110 +     * Returns the charge force of this stuntDouble in specified snapshot
1111 +     * @return the charge force of this stuntDouble
1112 +     * @param snapshotNo
1113 +     */    
1114 +    RealType getFlucQFrc(int snapshotNo) {
1115 +      return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_];
1116 +    }
1117 +
1118 +    /**
1119 +     * Sets  the previous charge force of this stuntDouble
1120 +     * @param cfrc  new charge force
1121 +     * @see #getflucQFrc
1122 +     */        
1123 +    void setPrevFlucQFrc(RealType cfrc) {
1124 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_] = cfrc;
1125 +    }
1126 +      
1127 +    /**
1128 +     * Sets  the current charge force of this stuntDouble
1129 +     * @param cfrc  new charge force
1130 +     */        
1131 +    void setFlucQFrc(RealType cfrc) {
1132 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_] = cfrc;
1133 +    }
1134 +
1135 +    /**
1136 +     * Sets  the charge force of this stuntDouble in specified snapshot
1137 +     * @param cfrc charge force to be set
1138 +     * @param snapshotNo
1139 +     * @see #getflucQFrc
1140 +     */        
1141 +    void setFlucQFrc(RealType cfrc, int snapshotNo) {
1142 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_] = cfrc;
1143 +    }
1144 +
1145 +    /**
1146 +     * Adds charge force into the previous charge force of this stuntDouble
1147 +     * @param cfrc  new charge force
1148 +     * @see #getflucQFrc
1149 +     */        
1150 +    void addPrevFlucQFrc(RealType cfrc) {
1151 +      ((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_] += cfrc;
1152 +    }
1153 +      
1154 +    /**
1155 +     * Adds charge force into the current charge force of this stuntDouble
1156 +     * @param cfrc  new charge force
1157 +     */        
1158 +    void addFlucQFrc(RealType cfrc) {
1159 +      ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_] += cfrc;
1160 +    }
1161 +
1162 +    /**
1163 +     * Adds charge force into the charge force of this stuntDouble in specified snapshot
1164 +     * @param value charge force to be add
1165 +     * @param snapshotNo
1166 +     * @see #getflucQFrc
1167 +     */        
1168 +    void addflucQFrc(RealType cfrc, int snapshotNo) {
1169 +      ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_] += cfrc;
1170 +    }      
1171 +
1172 +
1173 +
1174 +
1175      /** Set the force of this stuntDouble to zero */
1176      void zeroForcesAndTorques();
1177      /**
# Line 925 | Line 1255 | namespace oopse{
1255      }
1256  
1257      /**
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    /**
1258       * <p>
1259 <     * The purpose of the Visitor Pattern is to encapsulate an operation that you want to perform on
1260 <     * the elements of a data structure. In this way, you can change the operation being performed
1261 <     * on a structure without the need of changing the classes of the elements that you are operating
1262 <     * on. Using a Visitor pattern allows you to decouple the classes for the data structure and the
1263 <     * algorithms used upon them
1259 >     * The purpose of the Visitor Pattern is to encapsulate an
1260 >     * operation that you want to perform on the elements of a data
1261 >     * structure. In this way, you can change the operation being
1262 >     * performed on a structure without the need of changing the
1263 >     * classes of the elements that you are operating on. Using a
1264 >     * Visitor pattern allows you to decouple the classes for the data
1265 >     * structure and the algorithms used upon them
1266       * </p>
1267       * @param v visitor
1268       */      
# Line 1053 | Line 1333 | namespace oopse{
1333      PropertyMap properties_;
1334    };
1335  
1336 < }//end namespace oopse
1336 > }//end namespace OpenMD
1337   #endif //PRIMITIVES_STUNTDOUBLE_HPP

Comparing:
trunk/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1245 by chuckv, Tue May 27 16:39:06 2008 UTC vs.
branches/development/src/primitives/StuntDouble.hpp (property svn:keywords), Revision 1710 by gezelter, Fri May 18 21:44:02 2012 UTC

# Line 0 | Line 1
1 + Author Id Revision Date

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines