OOPSE/libmdtools/NPTi.cpp

#include <cmath>
#include "Atom.hpp"
#include "SRI.hpp"
#include "AbstractClasses.hpp"
#include "SimInfo.hpp"
#include "ForceFields.hpp"
#include "Thermo.hpp"
#include "ReadWrite.hpp"
#include "Integrator.hpp"
#include "simError.h" 


// Basic isotropic thermostating and barostating via the Melchionna
// modification of the Hoover algorithm:
//
//    Melchionna, S., Ciccotti, G., and Holian, B. L., 1993,
//       Molec. Phys., 78, 533. 
//
//           and
// 
//    Hoover, W. G., 1986, Phys. Rev. A, 34, 2499.

NPTi::NPTi ( SimInfo *theInfo, ForceFields* the_ff):
  Integrator( theInfo, the_ff )
{
  chi = 0.0;
  eta = 0.0;
  have_tau_thermostat = 0;
  have_tau_barostat = 0;
  have_target_temp = 0;
  have_target_pressure = 0;
}

void NPTi::moveA() {
  
  int i, j;
  DirectionalAtom* dAtom;
  double Tb[3], ji[3];
  double A[3][3], I[3][3];
  double angle, mass;
  double vel[3], pos[3], frc[3];

  double rj[3];
  double instaTemp, instaPress, instaVol;
  double tt2, tb2, scaleFactor;

  tt2 = tauThermostat * tauThermostat;
  tb2 = tauBarostat * tauBarostat;

  instaTemp = tStats->getTemperature();
  instaPress = tStats->getPressure();
  instaVol = tStats->getVolume();
   
   // first evolve chi a half step
  
  chi += dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
  eta += dt2 * ( instaVol * (instaPress - targetPressure) / 
                 (p_convert*NkBT*tb2));

  for( i=0; i<nAtoms; i++ ){
    atoms[i]->getVel( vel );
    atoms[i]->getPos( pos );
    atoms[i]->getFrc( frc );

    mass = atoms[i]->getMass();

    for (j=0; j < 3; j++) {
      vel[j] += dt2 * ((frc[j] / mass ) * eConvert - vel[j]*(chi+eta));
      rj[j] = pos[j];
    }

    atoms[i]->setVel( vel );

    info->wrapVector(rj);

    for (j = 0; j < 3; j++) 
      pos[j] += dt * (vel[j] + eta*rj[j]);


    atoms[i]->setPos( pos );


    if( atoms[i]->isDirectional() ){

      dAtom = (DirectionalAtom *)atoms[i];
          
      // get and convert the torque to body frame
      
      dAtom->getTrq( Tb );
      dAtom->lab2Body( Tb );
      
      // get the angular momentum, and propagate a half step

      dAtom->getJ( ji );

      for (j=0; j < 3; j++) 
        ji[j] += dt2 * (Tb[j] * eConvert - ji[j]*chi);
      
      // use the angular velocities to propagate the rotation matrix a
      // full time step

      dAtom->getA(A);
      dAtom->getI(I);
    
      // rotate about the x-axis      
      angle = dt2 * ji[0] / I[0][0];
      this->rotate( 1, 2, angle, ji, A ); 

      // rotate about the y-axis
      angle = dt2 * ji[1] / I[1][1];
      this->rotate( 2, 0, angle, ji, A );
      
      // rotate about the z-axis
      angle = dt * ji[2] / I[2][2];
      this->rotate( 0, 1, angle, ji, A);
      
      // rotate about the y-axis
      angle = dt2 * ji[1] / I[1][1];
      this->rotate( 2, 0, angle, ji, A );
      
       // rotate about the x-axis
      angle = dt2 * ji[0] / I[0][0];
      this->rotate( 1, 2, angle, ji, A );
      
      dAtom->setJ( ji );
      dAtom->setA( A  );    
    }                

  }

  // Scale the box after all the positions have been moved:
  
  scaleFactor = exp(dt*eta);

  if ((scaleFactor > 1.1) || (scaleFactor < 0.9)) {
    sprintf( painCave.errMsg,
             "NPTi error: Attempting a Box scaling of more than 10 percent"
             " check your tauBarostat, as it is probably too small!\n"
             " eta = %lf, scaleFactor = %lf\n", eta, scaleFactor
             );
    painCave.isFatal = 1;
    simError();
  } else {         
    info->scaleBox(exp(dt*eta));      
  }

}

void NPTi::moveB( void ){

  int i, j;
  DirectionalAtom* dAtom;
  double Tb[3], ji[3];
  double vel[3], frc[3];
  double mass;

  double instaTemp, instaPress, instaVol;
  double tt2, tb2;
  
  tt2 = tauThermostat * tauThermostat;
  tb2 = tauBarostat * tauBarostat;

  instaTemp = tStats->getTemperature();
  instaPress = tStats->getPressure();
  instaVol = tStats->getVolume();

  chi += dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
  eta += dt2 * ( instaVol * (instaPress - targetPressure) / 
                 (p_convert*NkBT*tb2));
  
  for( i=0; i<nAtoms; i++ ){

    atoms[i]->getVel( vel );
    atoms[i]->getFrc( frc );

    mass = atoms[i]->getMass();

    // velocity half step
    for (j=0; j < 3; j++) 
      vel[j] += dt2 * ((frc[j] / mass ) * eConvert - vel[j]*(chi+eta));
    
    atoms[i]->setVel( vel );

    if( atoms[i]->isDirectional() ){

      dAtom = (DirectionalAtom *)atoms[i];

      // get and convert the torque to body frame      

      dAtom->getTrq( Tb );
      dAtom->lab2Body( Tb );

      // get the angular momentum, and propagate a half step

      dAtom->getJ( ji );

      for (j=0; j < 3; j++) 
        ji[j] += dt2 * (Tb[j] * eConvert - ji[j]*chi);     

      dAtom->setJ( ji );
    }
  }
}

int NPTi::readyCheck() {
 
  // First check to see if we have a target temperature. 
  // Not having one is fatal. 
  
  if (!have_target_temp) {
    sprintf( painCave.errMsg,
             "NPTi error: You can't use the NPTi integrator\n"
             "   without a targetTemp!\n"
             );
    painCave.isFatal = 1;
    simError();
    return -1;
  }

  if (!have_target_pressure) {
    sprintf( painCave.errMsg,
             "NPTi error: You can't use the NPTi integrator\n"
             "   without a targetPressure!\n"
             );
    painCave.isFatal = 1;
    simError();
    return -1;
  }
  
  // We must set tauThermostat.
   
  if (!have_tau_thermostat) {
    sprintf( painCave.errMsg,
             "NPTi error: If you use the NPTi\n"
             "   integrator, you must set tauThermostat.\n");
    painCave.isFatal = 1;
    simError();
    return -1;
  }    

  // We must set tauBarostat.
   
  if (!have_tau_barostat) {
    sprintf( painCave.errMsg,
             "NPTi error: If you use the NPTi\n"
             "   integrator, you must set tauBarostat.\n");
    painCave.isFatal = 1;
    simError();
    return -1;
  }    

  // We need NkBT a lot, so just set it here:

  NkBT = (double)info->ndf * kB * targetTemp;

  return 1;
}
Revision:	614
Committed:	Tue Jul 15 17:57:04 2003 UTC (22 years, 3 months ago) by mmeineke
File size:	6002 byte(s)
Log Message:	fixed some bugs, Changed entry_plug to info where appropriate
#	User	Rev	Content
1	gezelter	578	#include <cmath>
2	gezelter	574	#include "Atom.hpp"
3			#include "SRI.hpp"
4			#include "AbstractClasses.hpp"
5			#include "SimInfo.hpp"
6			#include "ForceFields.hpp"
7			#include "Thermo.hpp"
8			#include "ReadWrite.hpp"
9			#include "Integrator.hpp"
10			#include "simError.h"
11
12
13			// Basic isotropic thermostating and barostating via the Melchionna
14			// modification of the Hoover algorithm:
15			//
16			// Melchionna, S., Ciccotti, G., and Holian, B. L., 1993,
17			// Molec. Phys., 78, 533.
18			//
19			// and
20			//
21			// Hoover, W. G., 1986, Phys. Rev. A, 34, 2499.
22
23			NPTi::NPTi ( SimInfo theInfo, ForceFields the_ff):
24			Integrator( theInfo, the_ff )
25			{
26			chi = 0.0;
27			eta = 0.0;
28			have_tau_thermostat = 0;
29			have_tau_barostat = 0;
30			have_target_temp = 0;
31			have_target_pressure = 0;
32			}
33
34			void NPTi::moveA() {
35
36	gezelter	600	int i, j;
37	gezelter	574	DirectionalAtom* dAtom;
38	gezelter	600	double Tb[3], ji[3];
39			double A[3][3], I[3][3];
40			double angle, mass;
41			double vel[3], pos[3], frc[3];
42
43	gezelter	574	double rj[3];
44			double instaTemp, instaPress, instaVol;
45	gezelter	611	double tt2, tb2, scaleFactor;
46	gezelter	574
47			tt2 = tauThermostat * tauThermostat;
48			tb2 = tauBarostat * tauBarostat;
49
50			instaTemp = tStats->getTemperature();
51			instaPress = tStats->getPressure();
52			instaVol = tStats->getVolume();
53
54	mmeineke	586	// first evolve chi a half step
55	gezelter	574
56			chi += dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
57	mmeineke	586	eta += dt2 * ( instaVol * (instaPress - targetPressure) /
58			(p_convertNkBTtb2));
59	gezelter	574
60			for( i=0; i<nAtoms; i++ ){
61	gezelter	600	atoms[i]->getVel( vel );
62			atoms[i]->getPos( pos );
63			atoms[i]->getFrc( frc );
64	gezelter	574
65	gezelter	600	mass = atoms[i]->getMass();
66	gezelter	574
67	gezelter	600	for (j=0; j < 3; j++) {
68			vel[j] += dt2 * ((frc[j] / mass ) * eConvert - vel[j]*(chi+eta));
69			rj[j] = pos[j];
70			}
71
72			atoms[i]->setVel( vel );
73
74	gezelter	577	info->wrapVector(rj);
75	gezelter	574
76	gezelter	600	for (j = 0; j < 3; j++)
77			pos[j] += dt * (vel[j] + eta*rj[j]);
78
79
80			atoms[i]->setPos( pos );
81
82
83	gezelter	574	if( atoms[i]->isDirectional() ){
84
85			dAtom = (DirectionalAtom *)atoms[i];
86
87			// get and convert the torque to body frame
88
89	gezelter	600	dAtom->getTrq( Tb );
90	gezelter	574	dAtom->lab2Body( Tb );
91
92			// get the angular momentum, and propagate a half step
93
94	gezelter	600	dAtom->getJ( ji );
95
96			for (j=0; j < 3; j++)
97			ji[j] += dt2 * (Tb[j] * eConvert - ji[j]*chi);
98	gezelter	574
99			// use the angular velocities to propagate the rotation matrix a
100			// full time step
101	gezelter	600
102			dAtom->getA(A);
103			dAtom->getI(I);
104
105	gezelter	574	// rotate about the x-axis
106	gezelter	600	angle = dt2 * ji[0] / I[0][0];
107			this->rotate( 1, 2, angle, ji, A );
108
109	gezelter	574	// rotate about the y-axis
110	gezelter	600	angle = dt2 * ji[1] / I[1][1];
111			this->rotate( 2, 0, angle, ji, A );
112	gezelter	574
113			// rotate about the z-axis
114	gezelter	600	angle = dt * ji[2] / I[2][2];
115			this->rotate( 0, 1, angle, ji, A);
116	gezelter	574
117			// rotate about the y-axis
118	gezelter	600	angle = dt2 * ji[1] / I[1][1];
119			this->rotate( 2, 0, angle, ji, A );
120	gezelter	574
121			// rotate about the x-axis
122	gezelter	600	angle = dt2 * ji[0] / I[0][0];
123			this->rotate( 1, 2, angle, ji, A );
124	gezelter	574
125	gezelter	600	dAtom->setJ( ji );
126			dAtom->setA( A );
127			}
128
129	gezelter	574	}
130	gezelter	611
131	gezelter	577	// Scale the box after all the positions have been moved:
132	gezelter	600
133	gezelter	611	scaleFactor = exp(dt*eta);
134
135	mmeineke	614	if ((scaleFactor > 1.1) \|\| (scaleFactor < 0.9)) {
136	gezelter	611	sprintf( painCave.errMsg,
137			"NPTi error: Attempting a Box scaling of more than 10 percent"
138			" check your tauBarostat, as it is probably too small!\n"
139			" eta = %lf, scaleFactor = %lf\n", eta, scaleFactor
140			);
141			painCave.isFatal = 1;
142			simError();
143			} else {
144			info->scaleBox(exp(dt*eta));
145			}
146	mmeineke	614
147	gezelter	574	}
148
149			void NPTi::moveB( void ){
150	gezelter	600
151			int i, j;
152	gezelter	574	DirectionalAtom* dAtom;
153	gezelter	600	double Tb[3], ji[3];
154			double vel[3], frc[3];
155			double mass;
156
157	gezelter	574	double instaTemp, instaPress, instaVol;
158			double tt2, tb2;
159
160			tt2 = tauThermostat * tauThermostat;
161			tb2 = tauBarostat * tauBarostat;
162
163			instaTemp = tStats->getTemperature();
164			instaPress = tStats->getPressure();
165			instaVol = tStats->getVolume();
166
167			chi += dt2 * ( instaTemp / targetTemp - 1.0) / tt2;
168	mmeineke	586	eta += dt2 * ( instaVol * (instaPress - targetPressure) /
169			(p_convertNkBTtb2));
170	gezelter	574
171			for( i=0; i<nAtoms; i++ ){
172	gezelter	600
173			atoms[i]->getVel( vel );
174			atoms[i]->getFrc( frc );
175
176			mass = atoms[i]->getMass();
177
178	gezelter	574	// velocity half step
179	gezelter	600	for (j=0; j < 3; j++)
180			vel[j] += dt2 * ((frc[j] / mass ) * eConvert - vel[j]*(chi+eta));
181	gezelter	574
182	gezelter	600	atoms[i]->setVel( vel );
183
184	gezelter	574	if( atoms[i]->isDirectional() ){
185	gezelter	600
186	gezelter	574	dAtom = (DirectionalAtom *)atoms[i];
187	gezelter	600
188			// get and convert the torque to body frame
189
190			dAtom->getTrq( Tb );
191	gezelter	574	dAtom->lab2Body( Tb );
192	gezelter	600
193			// get the angular momentum, and propagate a half step
194
195			dAtom->getJ( ji );
196
197			for (j=0; j < 3; j++)
198			ji[j] += dt2 * (Tb[j] * eConvert - ji[j]*chi);
199
200			dAtom->setJ( ji );
201	gezelter	574	}
202			}
203			}
204
205			int NPTi::readyCheck() {
206
207			// First check to see if we have a target temperature.
208			// Not having one is fatal.
209
210			if (!have_target_temp) {
211			sprintf( painCave.errMsg,
212			"NPTi error: You can't use the NPTi integrator\n"
213			" without a targetTemp!\n"
214			);
215			painCave.isFatal = 1;
216			simError();
217			return -1;
218			}
219
220			if (!have_target_pressure) {
221			sprintf( painCave.errMsg,
222			"NPTi error: You can't use the NPTi integrator\n"
223			" without a targetPressure!\n"
224			);
225			painCave.isFatal = 1;
226			simError();
227			return -1;
228			}
229
230			// We must set tauThermostat.
231
232			if (!have_tau_thermostat) {
233			sprintf( painCave.errMsg,
234			"NPTi error: If you use the NPTi\n"
235			" integrator, you must set tauThermostat.\n");
236			painCave.isFatal = 1;
237			simError();
238			return -1;
239			}
240
241			// We must set tauBarostat.
242
243			if (!have_tau_barostat) {
244			sprintf( painCave.errMsg,
245			"NPTi error: If you use the NPTi\n"
246			" integrator, you must set tauBarostat.\n");
247			painCave.isFatal = 1;
248			simError();
249			return -1;
250			}
251
252			// We need NkBT a lot, so just set it here:
253
254			NkBT = (double)info->ndf * kB * targetTemp;
255
256			return 1;
257			}