ViewVC Help

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

root/OpenMD/trunk/src/integrators/VelocityVerletIntegrator.cpp

Comparing trunk/src/integrators/VelocityVerletIntegrator.cpp (file contents):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1915 by gezelter, Mon Jul 29 17:55:17 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		/**
44		* @file VelocityVerletIntegrator.cpp
45		* @author tlin
46		* @date 11/09/2004
46	–	* @time 16:16am
47		* @version 1.0
48		*/
49
50		#include "integrators/VelocityVerletIntegrator.hpp"
51		#include "integrators/DLM.hpp"
52		#include "utils/StringUtils.hpp"
53	+	#include "utils/ProgressBar.hpp"
54
55		namespace OpenMD {
56	<	VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info), rotAlgo(NULL) {
56	>	VelocityVerletIntegrator::VelocityVerletIntegrator(SimInfo *info) : Integrator(info) {
57		dt2 = 0.5 * dt;
57	–	rotAlgo = new DLM();
58	–	rattle = new Rattle(info);
58		}
59
60		VelocityVerletIntegrator::~VelocityVerletIntegrator() {
62	–	delete rotAlgo;
63	–	delete rattle;
61		}
62
63		void VelocityVerletIntegrator::initialize(){
64
65	<	forceMan_->init();
65	>	forceMan_->initialize();
66
67		// remove center of mass drift velocity (in case we passed in a
68		// configuration that was drifting)
69		velocitizer_->removeComDrift();
70	+
71	+	// find the initial fluctuating charges.
72	+	flucQ_->initialize();
73
74		// initialize the forces before the first step
75	<	calcForce(true, true);
75	>	calcForce();
76
77		// execute the constraint algorithm to make sure that the system is
78		// constrained at the very beginning
79		if (info_->getNGlobalConstraints() > 0) {
80	<	rattle->constraintA();
81	<	calcForce(true, true);
82	<	rattle->constraintB();
80	>	rattle_->constraintA();
81	>	calcForce();
82	>	rattle_->constraintB();
83		//copy the current snapshot to previous snapshot
84		info_->getSnapshotManager()->advance();
85		}
#	Line 88 | Line 88 | namespace OpenMD {
88		velocitizer_->velocitize(targetScalingTemp);
89		}
90
91	<	dumpWriter = createDumpWriter();
92	<
93	<	statWriter = createStatWriter();
94	<
91	>	dumpWriter = createDumpWriter();
92	>	statWriter = createStatWriter();
93		dumpWriter->writeDumpAndEor();
94
95	+	progressBar = new ProgressBar();
96	+
97		//save statistics, before writeStat,  we must save statistics
98	–	thermo.saveStat();
98		saveConservedQuantity();
99	<	if (simParams->getUseRNEMD())
99	>	stats->collectStats();
100	>
101	>	if (simParams->getRNEMDParameters()->getUseRNEMD())
102		rnemd_->getStarted();
103
104	<	statWriter->writeStat(currentSnapshot_->statData);
104	>	statWriter->writeStat();
105
106	<	currSample = sampleTime + currentSnapshot_->getTime();
107	<	currStatus =  statusTime + currentSnapshot_->getTime();
108	<	currThermal = thermalTime + currentSnapshot_->getTime();
106	>	currSample = sampleTime + snap->getTime();
107	>	currStatus =  statusTime + snap->getTime();
108	>	currThermal = thermalTime + snap->getTime();
109		if (needReset) {
110	<	currReset = resetTime + currentSnapshot_->getTime();
110	>	currReset = resetTime + snap->getTime();
111		}
112	<	if (simParams->getUseRNEMD()){
113	<	currRNEMD = RNEMD_exchangeTime + currentSnapshot_->getTime();
112	>	if (simParams->getRNEMDParameters()->getUseRNEMD()){
113	>	currRNEMD = RNEMD_exchangeTime + snap->getTime();
114		}
115		needPotential = false;
116		needStress = false;
117
118		}
119	<
119	>
120		void VelocityVerletIntegrator::doIntegrate() {
121
121	–
122		initialize();
123
124	<	while (currentSnapshot_->getTime() < runTime) {
125	<
126	<	preStep();
127	<
128	<	integrateStep();
129	<
130	<	postStep();
131	<
132	<	}
133	<
124	>	while (snap->getTime() < runTime) {
125	>	preStep();
126	>	integrateStep();
127	>	postStep();
128	>	}
129		finalize();
135	–
130		}
131
132
133		void VelocityVerletIntegrator::preStep() {
134	<	RealType difference = currentSnapshot_->getTime() + dt - currStatus;
134	>	RealType difference = snap->getTime() + dt - currStatus;
135
136		if (difference > 0 || fabs(difference) < OpenMD::epsilon) {
137		needPotential = true;
#	Line 147 | Line 141 | namespace OpenMD {
141
142		void VelocityVerletIntegrator::postStep() {
143
150	–	//save snapshot
151	–	info_->getSnapshotManager()->advance();
152	–
153	–	//increase time
154	–	currentSnapshot_->increaseTime(dt);
144
145		if (needVelocityScaling) {
146	<	if (currentSnapshot_->getTime() >= currThermal) {
146	>	if (snap->getTime() >= currThermal) {
147		velocitizer_->velocitize(targetScalingTemp);
148		currThermal += thermalTime;
149		}
150		}
151		if (useRNEMD) {
152	<	rnemd_->collectData();
164	<	if (currentSnapshot_->getTime() >= currRNEMD) {
152	>	if (snap->getTime() >= currRNEMD) {
153		rnemd_->doRNEMD();
154		currRNEMD += RNEMD_exchangeTime;
155		}
156	+	rnemd_->collectData();
157		}
158
159	<	if (currentSnapshot_->getTime() >= currSample) {
159	>	if (snap->getTime() >= currSample) {
160		dumpWriter->writeDumpAndEor();
161
162		currSample += sampleTime;
163		}
164
165	<	if (currentSnapshot_->getTime() >= currStatus) {
165	>	if (snap->getTime() >= currStatus) {
166		//save statistics, before writeStat,  we must save statistics
178	–	thermo.saveStat();
167		saveConservedQuantity();
168	+	stats->collectStats();
169
170	<	if (simParams->getUseRNEMD()) {
171	<	rnemd_->getStatus();
170	>	if (simParams->getRNEMDParameters()->getUseRNEMD()) {
171	>	rnemd_->writeOutputFile();
172		}
173
174	<	statWriter->writeStat(currentSnapshot_->statData);
175	<
174	>	statWriter->writeStat();
175	>
176	>	progressBar->setStatus(snap->getTime(), runTime);
177	>	progressBar->update();
178	>
179		needPotential = false;
180		needStress = false;
181		currStatus += statusTime;
182		}
183
184	<	if (needReset && currentSnapshot_->getTime() >= currReset) {
184	>	if (needReset && snap->getTime() >= currReset) {
185		resetIntegrator();
186		currReset += resetTime;
187		}
188	+	//save snapshot
189	+	info_->getSnapshotManager()->advance();
190	+
191	+	//increase time
192	+	snap->increaseTime(dt);
193	+
194		}
195
196
197		void VelocityVerletIntegrator::finalize() {
198		dumpWriter->writeEor();
199	<
199	>	if (simParams->getRNEMDParameters()->getUseRNEMD()) {
200	>	rnemd_->writeOutputFile();
201	>	}
202	>
203		delete dumpWriter;
204		delete statWriter;
205
206		dumpWriter = NULL;
207		statWriter = NULL;
207	–
208		}
209
210		void VelocityVerletIntegrator::integrateStep() {
211
212		moveA();
213	<	calcForce(needPotential, needStress);
213	>	calcForce();
214		moveB();
215		}
216
217
218	<	void VelocityVerletIntegrator::calcForce(bool needPotential,
219	<	bool needStress) {
220	<	forceMan_->calcForces(needPotential, needStress);
218	>	void VelocityVerletIntegrator::calcForce() {
219	>	forceMan_->calcForces();
220	>	flucQ_->applyConstraints();
221		}
222
223		DumpWriter* VelocityVerletIntegrator::createDumpWriter() {
#	Line 225 | Line 225 | namespace OpenMD {
225		}
226
227		StatWriter* VelocityVerletIntegrator::createStatWriter() {
228	–
229	–	std::string statFileFormatString = simParams->getStatFileFormat();
230	–	StatsBitSet mask = parseStatFileFormat(statFileFormatString);
231	–
232	–	// if we're doing a thermodynamic integration, we'll want the raw
233	–	// potential as well as the full potential:
234	–
235	–
236	–	if (simParams->getUseThermodynamicIntegration())
237	–	mask.set(Stats::VRAW);
238	–
239	–	// if we've got restraints turned on, we'll also want a report of the
240	–	// total harmonic restraints
241	–	if (simParams->getUseRestraints()){
242	–	mask.set(Stats::VHARM);
243	–	}
244	–
245	–	if (simParams->havePrintPressureTensor() &&
246	–	simParams->getPrintPressureTensor()){
247	–	mask.set(Stats::PRESSURE_TENSOR_XX);
248	–	mask.set(Stats::PRESSURE_TENSOR_XY);
249	–	mask.set(Stats::PRESSURE_TENSOR_XZ);
250	–	mask.set(Stats::PRESSURE_TENSOR_YX);
251	–	mask.set(Stats::PRESSURE_TENSOR_YY);
252	–	mask.set(Stats::PRESSURE_TENSOR_YZ);
253	–	mask.set(Stats::PRESSURE_TENSOR_ZX);
254	–	mask.set(Stats::PRESSURE_TENSOR_ZY);
255	–	mask.set(Stats::PRESSURE_TENSOR_ZZ);
256	–	}
228
229	<	if (simParams->getAccumulateBoxDipole()) {
230	<	mask.set(Stats::BOX_DIPOLE_X);
260	<	mask.set(Stats::BOX_DIPOLE_Y);
261	<	mask.set(Stats::BOX_DIPOLE_Z);
262	<	}
263	<
264	<	if (simParams->haveTaggedAtomPair() && simParams->havePrintTaggedPairDistance()) {
265	<	if (simParams->getPrintTaggedPairDistance()) {
266	<	mask.set(Stats::TAGGED_PAIR_DISTANCE);
267	<	}
268	<	}
269	<
270	<	if (simParams->getUseRNEMD()) {
271	<	mask.set(Stats::RNEMD_EXCHANGE_TOTAL);
272	<	}
229	>	stats = new Stats(info_);
230	>	statWriter = new StatWriter(info_->getStatFileName(), stats);
231
232	<
275	<	return new StatWriter(info_->getStatFileName(), mask);
232	>	return statWriter;
233		}
234
278	–
235		} //end namespace OpenMD

Comparing trunk/src/integrators/VelocityVerletIntegrator.cpp (property svn:keywords):
Revision 1390 by gezelter, Wed Nov 25 20:02:06 2009 UTC vs.
Revision 1915 by gezelter, Mon Jul 29 17:55:17 2013 UTC

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

Diff Legend

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