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

Comparing trunk/OOPSE/libmdtools/Integrator.hpp (file contents):
Revision 767 by tim, Tue Sep 16 20:02:11 2003 UTC vs.
Revision 790 by mmeineke, Mon Sep 29 21:16:11 2003 UTC

# Line 30 | Line 30 | template<typename T = BaseIntegrator> class Integrator
30    virtual double  getConservedQuantity(void);
31  
32   protected:
33 <  
33 >
34    virtual void integrateStep( int calcPot, int calcStress );
35    virtual void preMove( void );
36    virtual void moveA( void );
# Line 44 | Line 44 | template<typename T = BaseIntegrator> class Integrator
44    virtual void calcForce( int calcPot, int calcStress );  
45    virtual void thermalize();
46    
47 +  virtual void rotationPropagation( DirectionalAtom* dAtom, double ji[3] );
48 +
49    void checkConstraints( void );
50    void rotate( int axes1, int axes2, double angle, double j[3],
51           double A[3][3] );
# Line 135 | Line 137 | template<typename T> class NPTi : public T{
137  
138  
139  
140 < template<typename T> class NPTi : public T{
140 > template<typename T> class NPT : public T{
141  
142   public:
143  
144 <  NPTi ( SimInfo *theInfo, ForceFields* the_ff);
145 <  virtual ~NPTi();
144 >  NPT ( SimInfo *theInfo, ForceFields* the_ff);
145 >  virtual ~NPT();
146    
147    virtual void integrateStep( int calcPot, int calcStress ){
148      calcStress = 1;
149      T::integrateStep( calcPot, calcStress );
148 –    /* accIntegralOfChidt(); */
150    }
151  
152 <  virtual double getConservedQuantity(void);
152 >  virtual double getConservedQuantity(void) = 0;
153  
154    void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
155    void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
# Line 167 | Line 168 | template<typename T> class NPTi : public T{ (protected
168  
169    virtual void resetIntegrator( void );
170  
171 +  virtual void getVelScaleA( double sc[3], double vel[3] ) = 0;
172 +  virtual void getVelScaleB( double sc[3], int index ) = 0;
173 +  virtual void getPosScale(double pos[3], double COM[3],
174 +                           int index, double sc[3]) = 0;
175 +
176 +  virtual bool chiConverged( void );
177 +  virtual bool etaConverged( void ) = 0;
178 +  
179 +  virtual void evolveChiA( void );
180 +  virtual void evolveEtaA( void ) = 0;
181 +  virtual void evolveChiB( void );
182 +  virtual void evolveEtaB( void ) = 0;
183 +
184 +  virtual void scaleSimBox( void ) = 0;
185 +
186    void accIntegralOfChidt(void) { integralOfChidt += dt * chi;}
187  
188    // chi and eta are the propagated degrees of freedom
189  
190 +  double oldChi;
191 +  double prevChi;
192    double chi;
175 –  double eta;
193    double NkBT;
194    double fkBT;
195  
196 +  double tt2, tb2;
197 +  double instaTemp, instaPress, instaVol;
198 +  double press[3][3];
199 +
200    int Nparticles;
201  
202    double integralOfChidt;
# Line 204 | Line 225 | template<typename T> class NPTim : public T{
225  
226   };
227  
228 < template<typename T> class NPTim : public T{
229 <
228 > template<typename T> class NPTi : public T{
229 >  
230   public:
231 +  NPTi( SimInfo *theInfo, ForceFields* the_ff);
232 +  ~NPTi();
233  
211 –  NPTim ( SimInfo *theInfo, ForceFields* the_ff);
212 –  virtual ~NPTim() {}
213 –
214 –  virtual void integrateStep( int calcPot, int calcStress ){
215 –    calcStress = 1;
216 –    T::integrateStep( calcPot, calcStress );
217 –    accIntegralOfChidt();  
218 –  }
219 –
234    virtual double getConservedQuantity(void);
235 +  virtual void resetIntegrator(void);
236  
222 –  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
223 –  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
224 –  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
225 –  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
226 –  void setChiTolerance(double tol) {chiTolerance = tol;}
227 –  void setPosIterTolerance(double tol) {posIterTolerance = tol;}
228 –
237   protected:
238  
239 <  virtual void moveA( void );
232 <  virtual void moveB( void );
239 >
240  
241 <  virtual int readyCheck();
241 >  virtual void evolveEtaA(void);
242 >  virtual void evolveEtaB(void);
243  
244 <  virtual void resetIntegrator( void );
244 >  virtual bool etaConverged( void );
245  
246 <  void accIntegralOfChidt(void) { integralOfChidt += dt * chi;}
239 <  
240 <  Molecule* myMolecules;
241 <  Atom** myAtoms;
246 >  virtual void scaleSimBox( void );
247  
248 <  // chi and eta are the propagated degrees of freedom
249 <
250 <  double chi;
251 <  double eta;
247 <  double NkBT;
248 <  double integralOfChidt;
248 >  virtual void getVelScaleA( double sc[3], double vel[3] );
249 >  virtual void getVelScaleB( double sc[3], int index );
250 >  virtual void getPosScale(double pos[3], double COM[3],
251 >                           int index, double sc[3]);
252  
253 <  // targetTemp, targetPressure, and tauBarostat must be set.  
251 <  // One of qmass or tauThermostat must be set;
252 <
253 <  double targetTemp;
254 <  double targetPressure;
255 <  double tauThermostat;
256 <  double tauBarostat;
257 <
258 <  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
259 <  short int have_target_pressure;
260 <  double chiTolerance;
261 <  short int have_chi_tolerance;
262 <  double posIterTolerance;
263 <  short int have_pos_iter_tolerance;
264 <
253 >  double eta, oldEta, prevEta;
254   };
255  
256   template<typename T> class NPTzm : public T{
# Line 320 | Line 309 | template<typename T> class NPTf : public T{ (public)
309    NPTf ( SimInfo *theInfo, ForceFields* the_ff);
310    virtual ~NPTf();
311  
323 –  virtual void integrateStep( int calcPot, int calcStress ){
324 –    calcStress = 1;
325 –    T::integrateStep( calcPot, calcStress );
326 –  }
327 –  
312    virtual double getConservedQuantity(void);
313 +  virtual void resetIntegrator(void);
314  
330 –  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
331 –  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
332 –  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
333 –  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
334 –  void setChiTolerance(double tol) {chiTolerance = tol;}
335 –  void setPosIterTolerance(double tol) {posIterTolerance = tol;}
336 –
315   protected:
316  
317 <  virtual void  moveA( void );
318 <  virtual void moveB( void );
317 >  virtual void evolveEtaA(void);
318 >  virtual void evolveEtaB(void);
319  
320 <  virtual void resetIntegrator( void );
320 >  virtual bool etaConverged( void );
321  
322 <  virtual int readyCheck();
322 >  virtual void scaleSimBox( void );
323  
324 +  virtual void getVelScaleA( double sc[3], double vel[3] );
325 +  virtual void getVelScaleB( double sc[3], int index );
326 +  virtual void getPosScale(double pos[3], double COM[3],
327 +                           int index, double sc[3]);
328  
347 –  // chi and eta are the propagated degrees of freedom
348 –
349 –  double chi;
329    double eta[3][3];
330 <  double NkBT;
331 <  double fkBT;
353 <
354 <  int Nparticles;
355 <
356 <  double *oldPos;
357 <  double *oldVel;
358 <  double *oldJi;
359 <
360 <  double integralOfChidt;
361 <  
362 <  // targetTemp, targetPressure, and tauBarostat must be set.  
363 <  // One of qmass or tauThermostat must be set;
364 <
365 <  double targetTemp;
366 <  double targetPressure;
367 <  double tauThermostat;
368 <  double tauBarostat;
369 <
370 <  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
371 <  short int have_target_pressure;
372 <  double chiTolerance;
373 <  short int have_chi_tolerance;
374 <  double posIterTolerance;
375 <  short int have_pos_iter_tolerance;
376 <  double etaTolerance;
377 <  short int have_eta_tolerance;
330 >  double oldEta[3][3];
331 >  double prevEta[3][3];
332   };
333  
334   template<typename T> class NPTxym : public T{
# Line 427 | Line 381 | template<typename T> class NPTxym : public T{ (protect
381  
382   };
383  
430 –
431 – template<typename T> class NPTfm : public T{
432 –
433 – public:
434 –
435 –  NPTfm ( SimInfo *theInfo, ForceFields* the_ff);
436 –  virtual ~NPTfm() {};
437 –
438 –  virtual void integrateStep( int calcPot, int calcStress ){
439 –    calcStress = 1;
440 –    T::integrateStep( calcPot, calcStress );
441 –    accIntegralOfChidt();
442 –  }
443 –
444 –  virtual double getConservedQuantity(void);
445 –  
446 –  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
447 –  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
448 –  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
449 –  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
450 –  void setChiTolerance(double tol) {chiTolerance = tol;}
451 –  void setPosIterTolerance(double tol) {posIterTolerance = tol;}
452 –
453 – protected:
454 –
455 –  virtual void  moveA( void );
456 –  virtual void moveB( void );
457 –
458 –  virtual void resetIntegrator( void );
459 –
460 –  virtual int readyCheck();
461 –
462 –  void accIntegralOfChidt(void) { integralOfChidt += dt * chi;}
463 –
464 –  Molecule* myMolecules;
465 –  Atom** myAtoms;
466 –
467 –  // chi and eta are the propagated degrees of freedom
468 –
469 –  double chi;
470 –  double eta[3][3];
471 –  double NkBT;
472 –  double integralOfChidt;
473 –
474 –  // targetTemp, targetPressure, and tauBarostat must be set.  
475 –  // One of qmass or tauThermostat must be set;
476 –
477 –  double targetTemp;
478 –  double targetPressure;
479 –  double tauThermostat;
480 –  double tauBarostat;
481 –
482 –  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
483 –  short int have_target_pressure;
484 –  double chiTolerance;
485 –  short int have_chi_tolerance;
486 –  double posIterTolerance;
487 –  short int have_pos_iter_tolerance;
488 –
489 – };
490 –
491 –
492 – template<typename T> class NPTpr : public T{
493 –
494 – public:
495 –
496 –  NPTpr ( SimInfo *theInfo, ForceFields* the_ff);
497 –  virtual ~NPTpr() {};
498 –
499 –  virtual void integrateStep( int calcPot, int calcStress ){
500 –    calcStress = 1;
501 –    T::integrateStep( calcPot, calcStress );
502 –  }
503 –
504 –  void setTauThermostat(double tt) {tauThermostat = tt; have_tau_thermostat=1;}
505 –  void setTauBarostat(double tb) {tauBarostat = tb; have_tau_barostat=1;}
506 –  void setTargetTemp(double tt) {targetTemp = tt; have_target_temp = 1;}
507 –  void setTargetPressure(double tp) {targetPressure = tp; have_target_pressure = 1;}
508 –  void setChiTolerance(double tol) {chiTolerance = tol;}
509 –  void setPosIterTolerance(double tol) {posIterTolerance = tol;}
510 –
511 – protected:
512 –
513 –  virtual void  moveA( void );
514 –  virtual void moveB( void );
515 –
516 –  virtual int readyCheck();
517 –
518 –  virtual void resetIntegrator( void );
519 –
520 –  // chi and eta are the propagated degrees of freedom
521 –
522 –  double chi;
523 –  double eta[3][3];
524 –  double NkBT;
525 –
526 –  // targetTemp, targetPressure, and tauBarostat must be set.  
527 –  // One of qmass or tauThermostat must be set;
528 –
529 –  double targetTemp;
530 –  double targetPressure;
531 –  double tauThermostat;
532 –  double tauBarostat;
533 –
534 –  short int have_tau_thermostat, have_tau_barostat, have_target_temp;
535 –  short int have_target_pressure;
536 –  double chiTolerance;
537 –  short int have_chi_tolerance;
538 –  double posIterTolerance;
539 –  short int have_pos_iter_tolerance;
540 –
541 – };
542 –
543 –
384   template<typename T> class ZConstraint : public T {
385    
386    public:
# Line 555 | Line 395 | template<typename T> class ZConstraint : public T {
395        virtual double getHFOfUnconsMols(Atom* atom, double totalForce) = 0;
396      
397     protected:
398 <     ZConstraint<T>* zconsIntegrator;;
398 >     ZConstraint<T>* zconsIntegrator;
399    };
400  
401    class PolicyByNumber : public ForceSubtractionPolicy{
# Line 608 | Line 448 | template<typename T> class ZConstraint : public T {
448    virtual void update();                      //which is called to indicate the molecules' migration
449   #endif
450  
451 +  enum ZConsState {zcsMoving, zcsFixed};  
452 +
453 +  vector<Molecule*> zconsMols;              //z-constraint molecules array
454 +  vector<ZConsState> states;                 //state of z-constraint molecules
455 +
456 +
457 +
458 +  int totNumOfUnconsAtoms;              //total number of uncontraint atoms
459 +  double totalMassOfUncons;                //total mas of unconstraint molecules
460 +
461 +
462   protected:
463  
464 <  enum ZConsState {zcsMoving, zcsFixed};  
464 >
465  
466    virtual void calcForce( int calcPot, int calcStress );
467    virtual void thermalize(void);
# Line 633 | Line 484 | template<typename T> class ZConstraint : public T {
484    double zForceConst;                           //base force constant term
485                                                            //which is estimate by OOPSE
486    
487 <  vector<Molecule*> zconsMols;              //z-constraint molecules array
487 >
488    vector<double> massOfZConsMols;       //mass of z-constraint molecule
489    vector<double> kz;                              //force constant array
490 <  vector<ZConsState> states;                 //state of z-constraint molecules
490 >
491    vector<double> zPos;                          //
492    
493    
494    vector<Molecule*> unconsMols;           //unconstraint molecules array
495    vector<double> massOfUnconsMols;    //mass array of unconstraint molecules
645 –  double totalMassOfUncons;                //total mas of unconstraint molecules
496  
497 +
498    vector<ZConsParaItem>* parameters; //
499    
500    vector<int> indexOfAllZConsMols;     //index of All Z-Constraint Molecuels
# Line 652 | Line 503 | template<typename T> class ZConstraint : public T {
503    double* fz;
504    double* curZPos;
505    
655 –  int totNumOfUnconsAtoms;              //total number of uncontraint atoms
506  
507 +
508    int whichDirection;                           //constraint direction
509    
510   private:

Diff Legend

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