ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/Integrator.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/Integrator.cpp (file contents):
Revision 746 by mmeineke, Thu Sep 4 21:48:35 2003 UTC vs.
Revision 843 by mmeineke, Wed Oct 29 20:41:39 2003 UTC

# Line 1 | Line 1
1   #include <iostream>
2 < #include <cstdlib>
3 < #include <cmath>
2 > #include <stdlib.h>
3 > #include <math.h>
4  
5   #ifdef IS_MPI
6   #include "mpiSimulation.hpp"
# Line 25 | Line 25 | template<typename T> Integrator<T>::Integrator(SimInfo
25    if (info->the_integrator != NULL){
26      delete info->the_integrator;
27    }
28 –  info->the_integrator = this;
28  
29    nAtoms = info->n_atoms;
30  
# Line 147 | Line 146 | template<typename T> void Integrator<T>::integrate(voi
146  
147  
148   template<typename T> void Integrator<T>::integrate(void){
150 –  int i, j;                         // loop counters
149  
150    double runTime = info->run_time;
151    double sampleTime = info->sampleTime;
# Line 160 | Line 158 | template<typename T> void Integrator<T>::integrate(voi
158    double currThermal;
159    double currStatus;
160    double currReset;
161 <  
161 >
162    int calcPot, calcStress;
165 –  int isError;
163  
164    tStats = new Thermo(info);
165    statOut = new StatWriter(info);
166    dumpOut = new DumpWriter(info);
167  
168    atoms = info->atoms;
172 –  DirectionalAtom* dAtom;
169  
170    dt = info->dt;
171    dt2 = 0.5 * dt;
172  
173 +  readyCheck();
174 +
175    // initialize the forces before the first step
176  
177    calcForce(1, 1);
178 +
179 +  if (nConstrained){
180 +    preMove();
181 +    constrainA();
182 +    calcForce(1, 1);
183 +    constrainB();
184 +  }
185    
186    if (info->setTemp){
187      thermalize();
# Line 192 | Line 197 | template<typename T> void Integrator<T>::integrate(voi
197    dumpOut->writeDump(info->getTime());
198    statOut->writeStat(info->getTime());
199  
195 –  readyCheck();
200  
201   #ifdef IS_MPI
202    strcpy(checkPointMsg, "The integrator is ready to go.");
# Line 222 | Line 226 | template<typename T> void Integrator<T>::integrate(voi
226      }
227  
228      if (info->getTime() >= currStatus){
229 <      statOut->writeStat(info->getTime());
230 <      calcPot = 0;
229 >      statOut->writeStat(info->getTime());
230 >      calcPot = 0;
231        calcStress = 0;
232        currStatus += statusTime;
233 <    }
233 >    }
234  
235      if (info->resetIntegrator){
236        if (info->getTime() >= currReset){
# Line 241 | Line 245 | template<typename T> void Integrator<T>::integrate(voi
245   #endif // is_mpi
246    }
247  
244 –  dumpOut->writeFinal(info->getTime());
248  
249 +  // write the last frame
250 +  dumpOut->writeDump(info->getTime());
251 +
252    delete dumpOut;
253    delete statOut;
254   }
# Line 254 | Line 260 | template<typename T> void Integrator<T>::integrateStep
260  
261    moveA();
262  
263 <  if (nConstrained){
258 <    constrainA();
259 <  }
263 >
264  
265  
266   #ifdef IS_MPI
# Line 279 | Line 283 | template<typename T> void Integrator<T>::integrateStep
283  
284    moveB();
285  
282 –  if (nConstrained){
283 –    constrainB();
284 –  }
286  
287 +
288   #ifdef IS_MPI
289    strcpy(checkPointMsg, "Succesful moveB\n");
290    MPIcheckPoint();
# Line 294 | Line 296 | template<typename T> void Integrator<T>::moveA(void){
296    int i, j;
297    DirectionalAtom* dAtom;
298    double Tb[3], ji[3];
297 –  double A[3][3], I[3][3];
298 –  double angle;
299    double vel[3], pos[3], frc[3];
300    double mass;
301  
# Line 331 | Line 331 | template<typename T> void Integrator<T>::moveA(void){
331        for (j = 0; j < 3; j++)
332          ji[j] += (dt2 * Tb[j]) * eConvert;
333  
334 <      // use the angular velocities to propagate the rotation matrix a
335 <      // full time step
334 >      this->rotationPropagation( dAtom, ji );
335  
337 –      dAtom->getA(A);
338 –      dAtom->getI(I);
339 –
340 –      // rotate about the x-axis      
341 –      angle = dt2 * ji[0] / I[0][0];
342 –      this->rotate(1, 2, angle, ji, A);
343 –
344 –      // rotate about the y-axis
345 –      angle = dt2 * ji[1] / I[1][1];
346 –      this->rotate(2, 0, angle, ji, A);
347 –
348 –      // rotate about the z-axis
349 –      angle = dt * ji[2] / I[2][2];
350 –      this->rotate(0, 1, angle, ji, A);
351 –
352 –      // rotate about the y-axis
353 –      angle = dt2 * ji[1] / I[1][1];
354 –      this->rotate(2, 0, angle, ji, A);
355 –
356 –      // rotate about the x-axis
357 –      angle = dt2 * ji[0] / I[0][0];
358 –      this->rotate(1, 2, angle, ji, A);
359 –
360 –
336        dAtom->setJ(ji);
362 –      dAtom->setA(A);
337      }
338    }
339 +
340 +  if (nConstrained){
341 +    constrainA();
342 +  }
343   }
344  
345  
# Line 387 | Line 365 | template<typename T> void Integrator<T>::moveB(void){
365      if (atoms[i]->isDirectional()){
366        dAtom = (DirectionalAtom *) atoms[i];
367  
368 <      // get and convert the torque to body frame      
368 >      // get and convert the torque to body frame
369  
370        dAtom->getTrq(Tb);
371        dAtom->lab2Body(Tb);
# Line 403 | Line 381 | template<typename T> void Integrator<T>::moveB(void){
381        dAtom->setJ(ji);
382      }
383    }
384 +
385 +  if (nConstrained){
386 +    constrainB();
387 +  }
388   }
389  
390   template<typename T> void Integrator<T>::preMove(void){
# Line 421 | Line 403 | template<typename T> void Integrator<T>::constrainA(){
403   }
404  
405   template<typename T> void Integrator<T>::constrainA(){
406 <  int i, j, k;
406 >  int i, j;
407    int done;
408    double posA[3], posB[3];
409    double velA[3], velB[3];
# Line 561 | Line 543 | template<typename T> void Integrator<T>::constrainA(){
543      painCave.isFatal = 1;
544      simError();
545    }
546 +
547   }
548  
549   template<typename T> void Integrator<T>::constrainB(void){
550 <  int i, j, k;
550 >  int i, j;
551    int done;
552    double posA[3], posB[3];
553    double velA[3], velB[3];
# Line 573 | Line 556 | template<typename T> void Integrator<T>::constrainB(vo
556    int a, b, ax, ay, az, bx, by, bz;
557    double rma, rmb;
558    double dx, dy, dz;
559 <  double rabsq, pabsq, rvab;
577 <  double diffsq;
559 >  double rvab;
560    double gab;
561    int iteration;
562  
# Line 664 | Line 646 | template<typename T> void Integrator<T>::constrainB(vo
646    }
647   }
648  
649 + template<typename T> void Integrator<T>::rotationPropagation
650 + ( DirectionalAtom* dAtom, double ji[3] ){
651 +
652 +  double angle;
653 +  double A[3][3], I[3][3];
654 +
655 +  // use the angular velocities to propagate the rotation matrix a
656 +  // full time step
657 +
658 +  dAtom->getA(A);
659 +  dAtom->getI(I);
660 +
661 +  // rotate about the x-axis
662 +  angle = dt2 * ji[0] / I[0][0];
663 +  this->rotate( 1, 2, angle, ji, A );
664 +
665 +  // rotate about the y-axis
666 +  angle = dt2 * ji[1] / I[1][1];
667 +  this->rotate( 2, 0, angle, ji, A );
668 +
669 +  // rotate about the z-axis
670 +  angle = dt * ji[2] / I[2][2];
671 +  this->rotate( 0, 1, angle, ji, A);
672 +
673 +  // rotate about the y-axis
674 +  angle = dt2 * ji[1] / I[1][1];
675 +  this->rotate( 2, 0, angle, ji, A );
676 +
677 +  // rotate about the x-axis
678 +  angle = dt2 * ji[0] / I[0][0];
679 +  this->rotate( 1, 2, angle, ji, A );
680 +
681 +  dAtom->setA( A  );
682 + }
683 +
684   template<typename T> void Integrator<T>::rotate(int axes1, int axes2,
685                                                  double angle, double ji[3],
686                                                  double A[3][3]){
# Line 729 | Line 746 | template<typename T> void Integrator<T>::rotate(int ax
746      }
747    }
748  
749 <  // rotate the Rotation matrix acording to:
749 >  // rotate the Rotation matrix acording to:
750    //            A[][] = A[][] * transpose(rot[][])
751  
752  
# Line 754 | Line 771 | template<typename T> void Integrator<T>::thermalize(){
771   template<typename T> void Integrator<T>::thermalize(){
772    tStats->velocitize();
773   }
774 +
775 + template<typename T> double Integrator<T>::getConservedQuantity(void){
776 +  return tStats->getTotalE();
777 + }
778 + template<typename T> string Integrator<T>::getAdditionalParameters(void){
779 +  //By default, return a null string
780 +  //The reason we use string instead of char* is that if we use char*, we will
781 +  //return a pointer point to local variable which might cause problem
782 +  return string();
783 + }

Diff Legend

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