ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/OpenMD/trunk/src/primitives/StuntDouble.hpp

Comparing trunk/src/primitives/StuntDouble.hpp (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1908 by gezelter, Fri Jul 19 21:25:45 2013 UTC

#	Line 35 | Line 35
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).
38	>	* [3]  Sun, Lin & Gezelter, J. Chem. Phys. 128, 234107 (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 106 | Line 107 | namespace OpenMD{
107
108		/**
109		* Sets the global index of this stuntDouble.
110	<	* @param new global index to be set
110	>	* @param index new global index to be set
111		*/
112		void setGlobalIndex(int index) {
113		globalIndex_ = index;
#	Line 567 | Line 568 | namespace OpenMD{
568		void setEuler(const Vector3d& euler, int snapshotNo) {
569		((snapshotMan_->getSnapshot(snapshotNo))->*storage_).aMat[localIndex_] = euler;
570		}
571	<
571	>
572		/**
573	<	* Returns the previous unit vectors of this stuntDouble
574	<	* @return the unit vectors of this stuntDouble
573	>	* Returns the previous dipole vector of this stuntDouble
574	>	* @return the dipole vector of this stuntDouble
575		*/
576	<	RotMat3x3d getPrevElectroFrame() {
577	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).electroFrame[localIndex_];
578	<	}
579	<
576	>	Vector3d getPrevDipole() {
577	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).dipole[localIndex_];
578	>	}
579	>
580		/**
581	<	* Returns the current unit vectors of this stuntDouble
582	<	* @return the unit vectors of this stuntDouble
581	>	* Returns the current dipole vector of this stuntDouble
582	>	* @return the dipole vector of this stuntDouble
583		*/
584	<	RotMat3x3d getElectroFrame() {
585	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).electroFrame[localIndex_];
584	>	Vector3d getDipole() {
585	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).dipole[localIndex_];
586		}
587	<
587	>
588		/**
589	<	* Returns the unit vectors of this stuntDouble in specified snapshot
589	>	* Returns the dipole vector of this stuntDouble in specified snapshot
590		*
591	<	* @return the unit vectors of this stuntDouble
591	>	* @return the dipole vector of this stuntDouble
592		* @param snapshotNo
593		*/
594	<	RotMat3x3d getElectroFrame(int snapshotNo) {
595	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electroFrame[localIndex_];
594	>	Vector3d getDipole(int snapshotNo) {
595	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).dipole[localIndex_];
596		}
597
598	+
599	+	/**
600	+	* Returns the previous quadrupole tensor of this stuntDouble
601	+	* @return the quadrupole tensor of this stuntDouble
602	+	*/
603	+	Mat3x3d getPrevQuadrupole() {
604	+	return ((snapshotMan_->getPrevSnapshot())->*storage_).quadrupole[localIndex_];
605	+	}
606	+
607	+	/**
608	+	* Returns the current quadrupole tensor of this stuntDouble
609	+	* @return the quadrupole tensor of this stuntDouble
610	+	*/
611	+	Mat3x3d getQuadrupole() {
612	+	return ((snapshotMan_->getCurrentSnapshot())->*storage_).quadrupole[localIndex_];
613	+	}
614	+
615	+	/**
616	+	* Returns the quadrupole tensor of this stuntDouble in specified snapshot
617	+	*
618	+	* @return the quadrupole tensor of this stuntDouble
619	+	* @param snapshotNo
620	+	*/
621	+	Mat3x3d getQuadrupole(int snapshotNo) {
622	+	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).quadrupole[localIndex_];
623	+	}
624	+
625		/**
626		* Returns the previous force of this stuntDouble
627		* @return the force of this stuntDouble
#	Line 848 | Line 876 | namespace OpenMD{
876		((snapshotMan_->getSnapshot(snapshotNo))->*storage_).particlePot[localIndex_] += particlePot;
877		}
878
851	–
879		/**
880	<	* Returns the previous z-angle of this stuntDouble
881	<	* @return the z-angle of this stuntDouble
880	>	* Returns the previous fluctuating charge of this stuntDouble
881	>	* @return the fluctuating charge of this stuntDouble
882		*/
883	<	RealType getPrevZangle() {
884	<	return ((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_];
883	>	RealType getPrevFlucQPos() {
884	>	return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_];
885		}
886
887		/**
888	<	* Returns the current z-angle of this stuntDouble
889	<	* @return the z-angle of this stuntDouble
888	>	* Returns the current fluctuating charge of this stuntDouble
889	>	* @return the fluctuating charge of this stuntDouble
890		*/
891	<	RealType getZangle() {
892	<	return ((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_];
891	>	RealType getFlucQPos() {
892	>	return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_];
893		}
894
895		/**
896	<	* Returns the z-angle of this stuntDouble in specified snapshot
897	<	* @return the z-angle of this stuntDouble
896	>	* Returns the fluctuating charge of this stuntDouble in specified snapshot
897	>	* @return the fluctuating charge of this stuntDouble
898		* @param snapshotNo
899		*/
900	<	RealType getZangle(int snapshotNo) {
901	<	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_];
900	>	RealType getFlucQPos(int snapshotNo) {
901	>	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_];
902		}
903
904		/**
905	<	* Sets  the previous z-angle of this stuntDouble
906	<	* @param angle  new z-angle
907	<	* @see #getZangle
905	>	* Sets  the previous fluctuating charge of this stuntDouble
906	>	* @param charge  new fluctuating charge
907	>	* @see #getFlucQPos
908		*/
909	<	void setPrevZangle(RealType angle) {
910	<	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] = angle;
909	>	void setPrevFlucQPos(RealType charge) {
910	>	((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_] = charge;
911		}
912
913		/**
914	<	* Sets  the current z-angle of this stuntDouble
915	<	* @param angle  new z-angle
914	>	* Sets  the current fluctuating charge of this stuntDouble
915	>	* @param charge  new fluctuating charge
916		*/
917	<	void setZangle(RealType angle) {
918	<	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] = angle;
917	>	void setFlucQPos(RealType charge) {
918	>	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_] = charge;
919		}
920
921		/**
922	<	* Sets  the z-angle of this stuntDouble in specified snapshot
923	<	* @param angle z-angle to be set
922	>	* Sets  the fluctuating charge of this stuntDouble in specified snapshot
923	>	* @param charge fluctuating charge to be set
924		* @param snapshotNo
925	<	* @see #getZangle
925	>	* @see #getFlucQPos
926		*/
927	<	void setZangle(RealType angle, int snapshotNo) {
928	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] = angle;
927	>	void setFlucQPos(RealType charge, int snapshotNo) {
928	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_] = charge;
929		}
930
931		/**
932	<	* Adds z-angle into the previous z-angle of this stuntDouble
933	<	* @param angle  new z-angle
934	<	* @see #getZangle
932	>	* Adds fluctuating charge into the previous fluctuating charge of this stuntDouble
933	>	* @param charge  new fluctuating charge
934	>	* @see #getFlucQPos
935		*/
936	<	void addPrevZangle(RealType angle) {
937	<	((snapshotMan_->getPrevSnapshot())->*storage_).zAngle[localIndex_] += angle;
936	>	void addPrevFlucQPos(RealType charge) {
937	>	((snapshotMan_->getPrevSnapshot())->*storage_).flucQPos[localIndex_] += charge;
938		}
939
940		/**
941	<	* Adds z-angle into the current z-angle of this stuntDouble
942	<	* @param angle  new z-angle
941	>	* Adds fluctuating charge into the current fluctuating charge of this stuntDouble
942	>	* @param charge  new fluctuating charge
943		*/
944	<	void addZangle(RealType angle) {
945	<	((snapshotMan_->getCurrentSnapshot())->*storage_).zAngle[localIndex_] += angle;
944	>	void addFlucQPos(RealType charge) {
945	>	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQPos[localIndex_] += charge;
946		}
947
948		/**
949	<	* Adds z-angle into the z-angle of this stuntDouble in specified snapshot
950	<	* @param angle z-angle to be add
949	>	* Adds fluctuating charge into the fluctuating charge of this stuntDouble in specified snapshot
950	>	* @param charge fluctuating charge to be add
951		* @param snapshotNo
952	<	* @see #getZangle
952	>	* @see #getFlucQPos
953		*/
954	<	void addZangle(RealType angle, int snapshotNo) {
955	<	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).zAngle[localIndex_] += angle;
954	>	void addFlucQPos(RealType charge, int snapshotNo) {
955	>	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQPos[localIndex_] += charge;
956		}
957
958	+
959	+	/**
960	+	* Returns the previous charge velocity of this stuntDouble
961	+	* @return the charge velocity of this stuntDouble
962	+	*/
963	+	RealType getPrevFlucQVel() {
964	+	return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_];
965	+	}
966	+
967	+	/**
968	+	* Returns the current charge velocity of this stuntDouble
969	+	* @return the charge velocity of this stuntDouble
970	+	*/
971	+	RealType getFlucQVel() {
972	+	return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_];
973	+	}
974	+
975	+	/**
976	+	* Returns the charge velocity of this stuntDouble in specified snapshot
977	+	* @return the charge velocity of this stuntDouble
978	+	* @param snapshotNo
979	+	*/
980	+	RealType getFlucQVel(int snapshotNo) {
981	+	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_];
982	+	}
983	+
984	+	/**
985	+	* Sets  the previous charge velocity of this stuntDouble
986	+	* @param cvel  new charge velocity
987	+	* @see #getFlucQVel
988	+	*/
989	+	void setPrevFlucQVel(RealType cvel) {
990	+	((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_] = cvel;
991	+	}
992	+
993	+	/**
994	+	* Sets  the current charge velocity of this stuntDouble
995	+	* @param cvel  new charge velocity
996	+	*/
997	+	void setFlucQVel(RealType cvel) {
998	+	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_] = cvel;
999	+	}
1000	+
1001	+	/**
1002	+	* Sets  the charge velocity of this stuntDouble in specified snapshot
1003	+	* @param cvel charge velocity to be set
1004	+	* @param snapshotNo
1005	+	* @see #getFlucQVel
1006	+	*/
1007	+	void setFlucQVel(RealType cvel, int snapshotNo) {
1008	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_] = cvel;
1009	+	}
1010	+
1011	+	/**
1012	+	* Adds charge velocity into the previous charge velocity of this stuntDouble
1013	+	* @param cvel  new charge velocity
1014	+	* @see #getFlucQVel
1015	+	*/
1016	+	void addPrevFlucQVel(RealType cvel) {
1017	+	((snapshotMan_->getPrevSnapshot())->*storage_).flucQVel[localIndex_] += cvel;
1018	+	}
1019	+
1020	+	/**
1021	+	* Adds charge velocity into the current charge velocity of this stuntDouble
1022	+	* @param cvel  new charge velocity
1023	+	*/
1024	+	void addFlucQVel(RealType cvel) {
1025	+	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQVel[localIndex_] += cvel;
1026	+	}
1027	+
1028	+	/**
1029	+	* Adds charge velocity into the charge velocity of this stuntDouble in specified snapshot
1030	+	* @param cvel charge velocity to be add
1031	+	* @param snapshotNo
1032	+	* @see #getFlucQVel
1033	+	*/
1034	+	void addFlucQVel(RealType cvel, int snapshotNo) {
1035	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQVel[localIndex_] += cvel;
1036	+	}
1037	+
1038	+
1039	+	/**
1040	+	* Returns the previous charge force of this stuntDouble
1041	+	* @return the charge force of this stuntDouble
1042	+	*/
1043	+	RealType getPrevFlucQFrc() {
1044	+	return ((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_];
1045	+	}
1046	+
1047	+	/**
1048	+	* Returns the current charge force of this stuntDouble
1049	+	* @return the charge force of this stuntDouble
1050	+	*/
1051	+	RealType getFlucQFrc() {
1052	+	return ((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_];
1053	+	}
1054	+
1055	+	/**
1056	+	* Returns the charge force of this stuntDouble in specified snapshot
1057	+	* @return the charge force of this stuntDouble
1058	+	* @param snapshotNo
1059	+	*/
1060	+	RealType getFlucQFrc(int snapshotNo) {
1061	+	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_];
1062	+	}
1063	+
1064	+	/**
1065	+	* Sets  the previous charge force of this stuntDouble
1066	+	* @param cfrc  new charge force
1067	+	* @see #getFlucQFrc
1068	+	*/
1069	+	void setPrevFlucQFrc(RealType cfrc) {
1070	+	((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_] = cfrc;
1071	+	}
1072	+
1073	+	/**
1074	+	* Sets  the current charge force of this stuntDouble
1075	+	* @param cfrc  new charge force
1076	+	*/
1077	+	void setFlucQFrc(RealType cfrc) {
1078	+	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_] = cfrc;
1079	+	}
1080	+
1081	+	/**
1082	+	* Sets  the charge force of this stuntDouble in specified snapshot
1083	+	* @param cfrc charge force to be set
1084	+	* @param snapshotNo
1085	+	* @see #getFlucQFrc
1086	+	*/
1087	+	void setFlucQFrc(RealType cfrc, int snapshotNo) {
1088	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_] = cfrc;
1089	+	}
1090	+
1091	+	/**
1092	+	* Adds charge force into the previous charge force of this stuntDouble
1093	+	* @param cfrc   charge force to be added
1094	+	* @see #getFlucQFrc
1095	+	*/
1096	+	void addPrevFlucQFrc(RealType cfrc) {
1097	+	((snapshotMan_->getPrevSnapshot())->*storage_).flucQFrc[localIndex_] += cfrc;
1098	+	}
1099	+
1100	+	/**
1101	+	* Adds charge force into the current charge force of this stuntDouble
1102	+	* @param cfrc   charge force to be added
1103	+	*/
1104	+	void addFlucQFrc(RealType cfrc) {
1105	+	((snapshotMan_->getCurrentSnapshot())->*storage_).flucQFrc[localIndex_] += cfrc;
1106	+	}
1107	+
1108	+	/**
1109	+	* Adds charge force into the charge force of this stuntDouble in specified snapshot
1110	+	* @param cfrc charge force to be added
1111	+	* @param snapshotNo
1112	+	* @see #getFlucQFrc
1113	+	*/
1114	+	void addFlucQFrc(RealType cfrc, int snapshotNo) {
1115	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).flucQFrc[localIndex_] += cfrc;
1116	+	}
1117	+
1118	+
1119	+	/**
1120	+	* Returns the previous electric field of this stuntDouble
1121	+	* @return the electric field of this stuntDouble
1122	+	*/
1123	+	Vector3d getPrevElectricField() {
1124	+	return ((snapshotMan_->getPrevSnapshot())->*storage_).electricField[localIndex_];
1125	+	}
1126	+
1127	+	/**
1128	+	* Returns the current electric field of this stuntDouble
1129	+	* @return the electric field of this stuntDouble
1130	+	*/
1131	+	Vector3d getElectricField() {
1132	+	return ((snapshotMan_->getCurrentSnapshot())->*storage_).electricField[localIndex_];
1133	+	}
1134	+
1135	+	/**
1136	+	* Returns the electric field of this stuntDouble in specified snapshot
1137	+	* @return the electric field of this stuntDouble
1138	+	* @param snapshotNo
1139	+	*/
1140	+	Vector3d getElectricField(int snapshotNo) {
1141	+	return ((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electricField[localIndex_];
1142	+	}
1143	+
1144	+	/**
1145	+	* Sets the previous electric field of this stuntDouble
1146	+	* @param eField  new electric field
1147	+	* @see #getElectricField
1148	+	*/
1149	+	void setPrevElectricField(const Vector3d& eField) {
1150	+	((snapshotMan_->getPrevSnapshot())->*storage_).electricField[localIndex_] = eField;
1151	+	}
1152	+
1153	+	/**
1154	+	* Sets the current electric field of this stuntDouble
1155	+	* @param eField  new electric field
1156	+	*/
1157	+	void setElectricField(const Vector3d& eField) {
1158	+	((snapshotMan_->getCurrentSnapshot())->*storage_).electricField[localIndex_] = eField;
1159	+	}
1160	+
1161	+	/**
1162	+	* Sets the electric field of this stuntDouble in specified snapshot
1163	+	* @param eField electric field to be set
1164	+	* @param snapshotNo
1165	+	* @see #getElectricField
1166	+	*/
1167	+	void setElectricField(const Vector3d& eField, int snapshotNo) {
1168	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electricField[localIndex_] = eField;
1169	+	}
1170	+
1171	+	/**
1172	+	* Adds electric field into the previous electric field of this
1173	+	* stuntDouble
1174	+	*
1175	+	* @param eField new electric field
1176	+	* @see #getElectricField
1177	+	*/
1178	+	void addPrevEelectricField(const Vector3d& eField) {
1179	+	((snapshotMan_->getPrevSnapshot())->*storage_).electricField[localIndex_] += eField;
1180	+	}
1181	+
1182	+	/**
1183	+	* Adds electric field into the current electric field of this stuntDouble
1184	+	* @param eField  new electric field
1185	+	*/
1186	+	void addElectricField(const Vector3d& eField) {
1187	+	((snapshotMan_->getCurrentSnapshot())->*storage_).electricField[localIndex_] += eField;
1188	+	}
1189	+
1190	+	/**
1191	+	* Adds electric field into the electric field of this stuntDouble in specified snapshot
1192	+	*
1193	+	* @param eField electric field to be added
1194	+	* @param snapshotNo
1195	+	* @see #getElectricField
1196	+	*/
1197	+	void addElectricField(const Vector3d& eField, int snapshotNo) {
1198	+	((snapshotMan_->getSnapshot(snapshotNo))->*storage_).electricField[localIndex_] += eField;
1199	+	}
1200	+
1201	+
1202		/** Set the force of this stuntDouble to zero */
1203		void zeroForcesAndTorques();
1204		/**

Comparing trunk/src/primitives/StuntDouble.hpp (property svn:keywords):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1908 by gezelter, Fri Jul 19 21:25:45 2013 UTC

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

Diff Legend

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