ViewVC Help

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

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

Comparing trunk/src/integrators/NPT.cpp (file contents):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1879 by gezelter, Sun Jun 16 15:15:42 2013 UTC

#	Line 1 | Line 1
1	+	/*
2	+	* Copyright (c) 2005 The University of Notre Dame. All Rights Reserved.
3	+	*
4	+	* The University of Notre Dame grants you ("Licensee") a
5	+	* non-exclusive, royalty free, license to use, modify and
6	+	* redistribute this software in source and binary code form, provided
7	+	* that the following conditions are met:
8	+	*
9	+	* 1. Redistributions of source code must retain the above copyright
10	+	*    notice, this list of conditions and the following disclaimer.
11	+	*
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.
16	+	*
17	+	* This software is provided "AS IS," without a warranty of any
18	+	* kind. All express or implied conditions, representations and
19	+	* warranties, including any implied warranty of merchantability,
20	+	* fitness for a particular purpose or non-infringement, are hereby
21	+	* excluded.  The University of Notre Dame and its licensors shall not
22	+	* be liable for any damages suffered by licensee as a result of
23	+	* using, modifying or distributing the software or its
24	+	* derivatives. In no event will the University of Notre Dame or its
25	+	* licensors be liable for any lost revenue, profit or data, or for
26	+	* direct, indirect, special, consequential, incidental or punitive
27	+	* damages, however caused and regardless of the theory of liability,
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, 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		#include <math.h>
44
45	<	#include "Atom.hpp"
46	<	#include "SRI.hpp"
47	<	#include "AbstractClasses.hpp"
48	<	#include "SimInfo.hpp"
49	<	#include "ForceFields.hpp"
50	<	#include "Thermo.hpp"
51	<	#include "ReadWrite.hpp"
10	<	#include "Integrator.hpp"
11	<	#include "simError.h"
45	>	#include "brains/SimInfo.hpp"
46	>	#include "brains/Thermo.hpp"
47	>	#include "integrators/NPT.hpp"
48	>	#include "math/SquareMatrix3.hpp"
49	>	#include "primitives/Molecule.hpp"
50	>	#include "utils/PhysicalConstants.hpp"
51	>	#include "utils/simError.h"
52
13	–	#ifdef IS_MPI
14	–	#include "mpiSimulation.hpp"
15	–	#endif
16	–
17	–
53		// Basic isotropic thermostating and barostating via the Melchionna
54		// modification of the Hoover algorithm:
55		//
#	Line 25 | Line 60
60		//
61		//    Hoover, W. G., 1986, Phys. Rev. A, 34, 2499.
62
63	<	template<typename T> NPT<T>::NPT ( SimInfo *theInfo, ForceFields* the_ff):
29	<	T( theInfo, the_ff )
30	<	{
31	<	GenericData* data;
32	<	DoubleData * chiValue;
33	<	DoubleData * integralOfChidtValue;
63	>	namespace OpenMD {
64
65	<	chiValue = NULL;
66	<	integralOfChidtValue = NULL;
65	>	NPT::NPT(SimInfo* info) :
66	>	VelocityVerletIntegrator(info), chiTolerance(1e-6), etaTolerance(1e-6), maxIterNum_(4) {
67
68	<	chi = 0.0;
69	<	integralOfChidt = 0.0;
70	<	have_tau_thermostat = 0;
71	<	have_tau_barostat = 0;
72	<	have_target_temp = 0;
73	<	have_target_pressure = 0;
74	<	have_chi_tolerance = 0;
75	<	have_eta_tolerance = 0;
76	<	have_pos_iter_tolerance = 0;
68	>	Globals* simParams = info_->getSimParams();
69	>
70	>	if (!simParams->getUseIntialExtendedSystemState()) {
71	>	Snapshot* currSnapshot = info_->getSnapshotManager()->getCurrentSnapshot();
72	>	currSnapshot->setThermostat(make_pair(0.0, 0.0));
73	>	currSnapshot->setBarostat(Mat3x3d(0.0));
74	>	}
75	>
76	>	if (!simParams->haveTargetTemp()) {
77	>	sprintf(painCave.errMsg, "You can't use the NVT integrator without a targetTemp!\n");
78	>	painCave.isFatal = 1;
79	>	painCave.severity = OPENMD_ERROR;
80	>	simError();
81	>	} else {
82	>	targetTemp = simParams->getTargetTemp();
83	>	}
84
85	<	// retrieve chi and integralOfChidt from simInfo
86	<	data = info->getProperty(CHIVALUE_ID);
87	<	if(data){
88	<	chiValue = dynamic_cast<DoubleData*>(data);
52	<	}
85	>	// We must set tauThermostat
86	>	if (!simParams->haveTauThermostat()) {
87	>	sprintf(painCave.errMsg, "If you use the constant temperature\n"
88	>	"\tintegrator, you must set tauThermostat.\n");
89
90	<	data = info->getProperty(INTEGRALOFCHIDT_ID);
91	<	if(data){
92	<	integralOfChidtValue = dynamic_cast<DoubleData*>(data);
93	<	}
90	>	painCave.severity = OPENMD_ERROR;
91	>	painCave.isFatal = 1;
92	>	simError();
93	>	} else {
94	>	tauThermostat = simParams->getTauThermostat();
95	>	}
96
97	<	// chi and integralOfChidt should appear by pair
98	<	if(chiValue && integralOfChidtValue){
99	<	chi = chiValue->getData();
62	<	integralOfChidt = integralOfChidtValue->getData();
63	<	}
97	>	if (!simParams->haveTargetPressure()) {
98	>	sprintf(painCave.errMsg, "NPT error: You can't use the NPT integrator\n"
99	>	"   without a targetPressure!\n");
100
101	<	oldPos = new double[3*integrableObjects.size()];
102	<	oldVel = new double[3*integrableObjects.size()];
103	<	oldJi = new double[3*integrableObjects.size()];
101	>	painCave.isFatal = 1;
102	>	simError();
103	>	} else {
104	>	targetPressure = simParams->getTargetPressure();
105	>	}
106	>
107	>	if (!simParams->haveTauBarostat()) {
108	>	sprintf(painCave.errMsg,
109	>	"If you use the NPT integrator, you must set tauBarostat.\n");
110	>	painCave.severity = OPENMD_ERROR;
111	>	painCave.isFatal = 1;
112	>	simError();
113	>	} else {
114	>	tauBarostat = simParams->getTauBarostat();
115	>	}
116	>
117	>	tt2 = tauThermostat * tauThermostat;
118	>	tb2 = tauBarostat * tauBarostat;
119
120	<	}
120	>	updateSizes();
121	>	}
122
123	<	template<typename T> NPT<T>::~NPT() {
124	<	delete[] oldPos;
73	<	delete[] oldVel;
74	<	delete[] oldJi;
75	<	}
123	>	NPT::~NPT() {
124	>	}
125
126	<	template<typename T> void NPT<T>::moveA() {
126	>	void NPT::doUpdateSizes() {
127
128	<	//new version of NPT
129	<	int i, j, k;
130	<	double Tb[3], ji[3];
82	<	double mass;
83	<	double vel[3], pos[3], frc[3];
84	<	double sc[3];
85	<	double COM[3];
128	>	oldPos.resize(info_->getNIntegrableObjects());
129	>	oldVel.resize(info_->getNIntegrableObjects());
130	>	oldJi.resize(info_->getNIntegrableObjects());
131
132	<	instaTemp = tStats->getTemperature();
88	<	tStats->getPressureTensor( press );
89	<	instaPress = p_convert * (press[0][0] + press[1][1] + press[2][2]) / 3.0;
90	<	instaVol = tStats->getVolume();
132	>	}
133
134	<	tStats->getCOM(COM);
134	>	void NPT::moveA() {
135	>	SimInfo::MoleculeIterator i;
136	>	Molecule::IntegrableObjectIterator  j;
137	>	Molecule* mol;
138	>	StuntDouble* sd;
139	>	Vector3d Tb, ji;
140	>	RealType mass;
141	>	Vector3d vel;
142	>	Vector3d pos;
143	>	Vector3d frc;
144	>	Vector3d sc;
145	>	int index;
146
147	<	//evolve velocity half step
147	>	thermostat = snap->getThermostat();
148	>	loadEta();
149	>
150	>	instaTemp =thermo.getTemperature();
151	>	press = thermo.getPressureTensor();
152	>	instaPress = PhysicalConstants::pressureConvert* (press(0, 0) + press(1, 1) + press(2, 2)) / 3.0;
153	>	instaVol =thermo.getVolume();
154
155	<	calcVelScale();
97	<
98	<	for( i=0; i<integrableObjects.size(); i++ ){
155	>	Vector3d  COM = thermo.getCom();
156
157	<	integrableObjects[i]->getVel( vel );
101	<	integrableObjects[i]->getFrc( frc );
157	>	//evolve velocity half step
158
159	<	mass = integrableObjects[i]->getMass();
159	>	calcVelScale();
160
161	<	getVelScaleA( sc, vel );
161	>	for (mol = info_->beginMolecule(i); mol != NULL;
162	>	mol = info_->nextMolecule(i)) {
163
164	<	for (j=0; j < 3; j++) {
164	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
165	>	sd = mol->nextIntegrableObject(j)) {
166	>
167	>	vel = sd->getVel();
168	>	frc = sd->getFrc();
169
170	<	// velocity half step  (use chi from previous step here):
110	<	vel[j] += dt2 * ((frc[j] / mass ) * eConvert - sc[j]);
170	>	mass = sd->getMass();
171
172	<	}
172	>	getVelScaleA(sc, vel);
173
174	<	integrableObjects[i]->setVel( vel );
174	>	// velocity half step  (use chi from previous step here):
175
176	<	if( integrableObjects[i]->isDirectional() ){
176	>	vel += dt2*PhysicalConstants::energyConvert/mass* frc - dt2*sc;
177	>	sd->setVel(vel);
178
179	<	// get and convert the torque to body frame
179	>	if (sd->isDirectional()) {
180
181	<	integrableObjects[i]->getTrq( Tb );
121	<	integrableObjects[i]->lab2Body( Tb );
181	>	// get and convert the torque to body frame
182
183	<	// get the angular momentum, and propagate a half step
183	>	Tb = sd->lab2Body(sd->getTrq());
184
185	<	integrableObjects[i]->getJ( ji );
185	>	// get the angular momentum, and propagate a half step
186
187	<	for (j=0; j < 3; j++)
128	<	ji[j] += dt2 * (Tb[j] * eConvert - ji[j]*chi);
187	>	ji = sd->getJ();
188
189	<	this->rotationPropagation( integrableObjects[i], ji );
189	>	ji += dt2*PhysicalConstants::energyConvert * Tb
190	>	- dt2*thermostat.first* ji;
191	>
192	>	rotAlgo_->rotate(sd, ji, dt);
193
194	<	integrableObjects[i]->setJ( ji );
194	>	sd->setJ(ji);
195	>	}
196	>
197	>	}
198		}
199	<	}
199	>	// evolve chi and eta  half step
200
201	<	// evolve chi and eta  half step
201	>	thermostat.first += dt2 * (instaTemp / targetTemp - 1.0) / tt2;
202	>
203	>	evolveEtaA();
204
205	<	evolveChiA();
206	<	evolveEtaA();
205	>	//calculate the integral of chidt
206	>	thermostat.second += dt2 * thermostat.first;
207	>
208	>	flucQ_->moveA();
209
141	–	//calculate the integral of chidt
142	–	integralOfChidt += dt2*chi;
210
211	<	//save the old positions
212	<	for(i = 0; i < integrableObjects.size(); i++){
213	<	integrableObjects[i]->getPos(pos);
147	<	for(j = 0; j < 3; j++)
148	<	oldPos[i*3 + j] = pos[j];
149	<	}
211	>	index = 0;
212	>	for (mol = info_->beginMolecule(i); mol != NULL;
213	>	mol = info_->nextMolecule(i)) {
214
215	<	//the first estimation of r(t+dt) is equal to  r(t)
215	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
216	>	sd = mol->nextIntegrableObject(j)) {
217
218	<	for(k = 0; k < 5; k ++){
218	>	oldPos[index++] = sd->getPos();
219
220	<	for(i =0 ; i < integrableObjects.size(); i++){
220	>	}
221	>	}
222	>
223	>	//the first estimation of r(t+dt) is equal to  r(t)
224
225	<	integrableObjects[i]->getVel(vel);
226	<	integrableObjects[i]->getPos(pos);
225	>	for(int k = 0; k < maxIterNum_; k++) {
226	>	index = 0;
227	>	for (mol = info_->beginMolecule(i); mol != NULL;
228	>	mol = info_->nextMolecule(i)) {
229
230	<	this->getPosScale( pos, COM, i, sc );
230	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
231	>	sd = mol->nextIntegrableObject(j)) {
232
233	<	for(j = 0; j < 3; j++)
234	<	pos[j] = oldPos[i*3 + j] + dt*(vel[j] + sc[j]);
233	>	vel = sd->getVel();
234	>	pos = sd->getPos();
235
236	<	integrableObjects[i]->setPos( pos );
236	>	this->getPosScale(pos, COM, index, sc);
237	>
238	>	pos = oldPos[index] + dt * (vel + sc);
239	>	sd->setPos(pos);
240	>
241	>	++index;
242	>	}
243	>	}
244	>
245	>	rattle_->constraintA();
246		}
247	<
248	<	if(nConstrained)
169	<	constrainA();
170	<	}
247	>
248	>	// Scale the box after all the positions have been moved:
249
250	+	this->scaleSimBox();
251
252	<	// Scale the box after all the positions have been moved:
252	>	snap->setThermostat(thermostat);
253
254	<	this->scaleSimBox();
176	<	}
177	<
178	<	template<typename T> void NPT<T>::moveB( void ){
179	<
180	<	//new version of NPT
181	<	int i, j, k;
182	<	double Tb[3], ji[3], sc[3];
183	<	double vel[3], frc[3];
184	<	double mass;
185	<
186	<	// Set things up for the iteration:
187	<
188	<	for( i=0; i<integrableObjects.size(); i++ ){
189	<
190	<	integrableObjects[i]->getVel( vel );
191	<
192	<	for (j=0; j < 3; j++)
193	<	oldVel[3*i + j]  = vel[j];
194	<
195	<	if( integrableObjects[i]->isDirectional() ){
196	<
197	<	integrableObjects[i]->getJ( ji );
198	<
199	<	for (j=0; j < 3; j++)
200	<	oldJi[3*i + j] = ji[j];
201	<
202	<	}
254	>	saveEta();
255		}
256
257	<	// do the iteration:
257	>	void NPT::moveB(void) {
258	>	SimInfo::MoleculeIterator i;
259	>	Molecule::IntegrableObjectIterator  j;
260	>	Molecule* mol;
261	>	StuntDouble* sd;
262	>	int index;
263	>	Vector3d Tb;
264	>	Vector3d ji;
265	>	Vector3d sc;
266	>	Vector3d vel;
267	>	Vector3d frc;
268	>	RealType mass;
269
270	<	instaVol = tStats->getVolume();
270	>	thermostat = snap->getThermostat();
271	>	RealType oldChi  = thermostat.first;
272	>	RealType prevChi;
273
274	<	for (k=0; k < 4; k++) {
274	>	loadEta();
275	>
276	>	//save velocity and angular momentum
277	>	index = 0;
278	>	for (mol = info_->beginMolecule(i); mol != NULL;
279	>	mol = info_->nextMolecule(i)) {
280
281	<	instaTemp = tStats->getTemperature();
282	<	instaPress = tStats->getPressure();
281	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
282	>	sd = mol->nextIntegrableObject(j)) {
283	>
284	>	oldVel[index] = sd->getVel();
285
286	<	// evolve chi another half step using the temperature at t + dt/2
286	>	if (sd->isDirectional())
287	>	oldJi[index] = sd->getJ();
288
289	<	this->evolveChiB();
217	<	this->evolveEtaB();
218	<	this->calcVelScale();
219	<
220	<	for( i=0; i<integrableObjects.size(); i++ ){
221	<
222	<	integrableObjects[i]->getFrc( frc );
223	<	integrableObjects[i]->getVel(vel);
224	<
225	<	mass = integrableObjects[i]->getMass();
226	<
227	<	getVelScaleB( sc, i );
228	<
229	<	// velocity half step
230	<	for (j=0; j < 3; j++)
231	<	vel[j] = oldVel[3*i+j] + dt2 * ((frc[j] / mass ) * eConvert - sc[j]);
232	<
233	<	integrableObjects[i]->setVel( vel );
234	<
235	<	if( integrableObjects[i]->isDirectional() ){
236	<
237	<	// get and convert the torque to body frame
238	<
239	<	integrableObjects[i]->getTrq( Tb );
240	<	integrableObjects[i]->lab2Body( Tb );
241	<
242	<	for (j=0; j < 3; j++)
243	<	ji[j] = oldJi[3*i + j] + dt2 * (Tb[j] * eConvert - oldJi[3*i+j]*chi);
244	<
245	<	integrableObjects[i]->setJ( ji );
289	>	++index;
290		}
291		}
292
293	<	if(nConstrained)
294	<	constrainB();
293	>	// do the iteration:
294	>	instaVol =thermo.getVolume();
295
296	<	if ( this->chiConverged() && this->etaConverged() ) break;
297	<	}
296	>	for(int k = 0; k < maxIterNum_; k++) {
297	>	instaTemp =thermo.getTemperature();
298	>	instaPress =thermo.getPressure();
299
300	<	//calculate integral of chida
301	<	integralOfChidt += dt2*chi;
300	>	// evolve chi another half step using the temperature at t + dt/2
301	>	prevChi = thermostat.first;
302	>	thermostat.first = oldChi + dt2 * (instaTemp / targetTemp - 1.0) / tt2;
303
304	+	//evolve eta
305	+	this->evolveEtaB();
306	+	this->calcVelScale();
307
308	<	}
308	>	index = 0;
309	>	for (mol = info_->beginMolecule(i); mol != NULL;
310	>	mol = info_->nextMolecule(i)) {
311
312	<	template<typename T> void NPT<T>::resetIntegrator() {
313	<	chi = 0.0;
263	<	T::resetIntegrator();
264	<	}
312	>	for (sd = mol->beginIntegrableObject(j); sd != NULL;
313	>	sd = mol->nextIntegrableObject(j)) {
314
315	<	template<typename T> void NPT<T>::evolveChiA() {
316	<	chi += dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
268	<	oldChi = chi;
269	<	}
315	>	frc = sd->getFrc();
316	>	mass = sd->getMass();
317
318	<	template<typename T> void NPT<T>::evolveChiB() {
318	>	getVelScaleB(sc, index);
319
320	<	prevChi = chi;
321	<	chi = oldChi + dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
322	<	}
320	>	// velocity half step
321	>	vel = oldVel[index]
322	>	+ dt2*PhysicalConstants::energyConvert/mass* frc
323	>	- dt2*sc;
324
325	<	template<typename T> bool NPT<T>::chiConverged() {
325	>	sd->setVel(vel);
326
327	<	return ( fabs( prevChi - chi ) <= chiTolerance );
328	<	}
327	>	if (sd->isDirectional()) {
328	>	// get and convert the torque to body frame
329	>	Tb = sd->lab2Body(sd->getTrq());
330
331	<	template<typename T> int NPT<T>::readyCheck() {
331	>	ji = oldJi[index]
332	>	+ dt2*PhysicalConstants::energyConvert*Tb
333	>	- dt2*thermostat.first*oldJi[index];
334
335	<	//check parent's readyCheck() first
336	<	if (T::readyCheck() == -1)
286	<	return -1;
335	>	sd->setJ(ji);
336	>	}
337
338	<	// First check to see if we have a target temperature.
339	<	// Not having one is fatal.
338	>	++index;
339	>	}
340	>	}
341	>
342	>	rattle_->constraintB();
343
344	<	if (!have_target_temp) {
345	<	sprintf( painCave.errMsg,
346	<	"NPT error: You can't use the NPT integrator\n"
347	<	"   without a targetTemp!\n"
295	<	);
296	<	painCave.isFatal = 1;
297	<	simError();
298	<	return -1;
299	<	}
344	>	if ((fabs(prevChi - thermostat.first) <= chiTolerance) &&
345	>	this->etaConverged())
346	>	break;
347	>	}
348
349	<	if (!have_target_pressure) {
350	<	sprintf( painCave.errMsg,
303	<	"NPT error: You can't use the NPT integrator\n"
304	<	"   without a targetPressure!\n"
305	<	);
306	<	painCave.isFatal = 1;
307	<	simError();
308	<	return -1;
309	<	}
349	>	//calculate integral of chidt
350	>	thermostat.second += dt2 * thermostat.first;
351
352	<	// We must set tauThermostat.
352	>	snap->setThermostat(thermostat);
353
354	<	if (!have_tau_thermostat) {
355	<	sprintf( painCave.errMsg,
315	<	"NPT error: If you use the NPT\n"
316	<	"   integrator, you must set tauThermostat.\n");
317	<	painCave.isFatal = 1;
318	<	simError();
319	<	return -1;
354	>	flucQ_->moveB();
355	>	saveEta();
356		}
357
358	<	// We must set tauBarostat.
359	<
360	<	if (!have_tau_barostat) {
325	<	sprintf( painCave.errMsg,
326	<	"If you use the NPT integrator, you must set tauBarostat.\n");
327	<	painCave.severity = OOPSE_ERROR;
328	<	painCave.isFatal = 1;
329	<	simError();
330	<	return -1;
358	>	void NPT::resetIntegrator(){
359	>	snap->setThermostat(make_pair(0.0, 0.0));
360	>	resetEta();
361		}
362
363	<	if (!have_chi_tolerance) {
364	<	sprintf( painCave.errMsg,
365	<	"Setting chi tolerance to 1e-6 in NPT integrator\n");
336	<	chiTolerance = 1e-6;
337	<	have_chi_tolerance = 1;
338	<	painCave.severity = OOPSE_INFO;
339	<	painCave.isFatal = 0;
340	<	simError();
363	>	void NPT::resetEta() {
364	>	Mat3x3d etaMat(0.0);
365	>	snap->setBarostat(etaMat);
366		}
342	–
343	–	if (!have_eta_tolerance) {
344	–	sprintf( painCave.errMsg,
345	–	"Setting eta tolerance to 1e-6 in NPT integrator");
346	–	etaTolerance = 1e-6;
347	–	have_eta_tolerance = 1;
348	–	painCave.severity = OOPSE_INFO;
349	–	painCave.isFatal = 0;
350	–	simError();
351	–	}
352	–
353	–	// We need NkBT a lot, so just set it here: This is the RAW number
354	–	// of integrableObjects, so no subtraction or addition of constraints or
355	–	// orientational degrees of freedom:
356	–
357	–	NkBT = (double)(info->getTotIntegrableObjects()) * kB * targetTemp;
358	–
359	–	// fkBT is used because the thermostat operates on more degrees of freedom
360	–	// than the barostat (when there are particles with orientational degrees
361	–	// of freedom).
362	–
363	–	fkBT = (double)(info->getNDF()) * kB * targetTemp;
364	–
365	–	tt2 = tauThermostat * tauThermostat;
366	–	tb2 = tauBarostat * tauBarostat;
367	–
368	–	return 1;
367		}

Comparing trunk/src/integrators/NPT.cpp (property svn:keywords):
Revision 2 by gezelter, Fri Sep 24 04:16:43 2004 UTC vs.
Revision 1879 by gezelter, Sun Jun 16 15:15:42 2013 UTC

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

Diff Legend

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