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 1161 by tim, Tue May 11 21:44:05 2004 UTC vs.
Revision 1452 by tim, Mon Aug 23 15:11:36 2004 UTC

# Line 13 | Line 13
13   #include "Thermo.hpp"
14   #include "ReadWrite.hpp"
15   #include "ZConsWriter.hpp"
16 + #include "Restraints.hpp"
17 + #include "Quaternion.hpp"
18 + #include "Mat4x4d.hpp"
19  
20   using namespace std;
21   const double kB = 8.31451e-7;// boltzmann constant amu*Ang^2*fs^-2/K
# Line 21 | Line 24 | const double tol = 1.0e-6;
24   const int maxIteration = 300;
25   const double tol = 1.0e-6;
26  
27 + class VelVerletConsFramework;
28   template<typename T = BaseIntegrator> class Integrator : public T {
29  
30   public:
# Line 33 | Line 37 | template<typename T = BaseIntegrator> class Integrator
37   protected:
38  
39    virtual void integrateStep( int calcPot, int calcStress );
40 <  virtual void preMove( void );
40 >  //virtual void preMove( void );
41    virtual void moveA( void );
42    virtual void moveB( void );
43 <  virtual void constrainA( void );
44 <  virtual void constrainB( void );
43 >  //virtual void constrainA( void );
44 >  //virtual void constrainB( void );
45    virtual int  readyCheck( void ) { return 1; }
46  
47    virtual void resetIntegrator( void ) { }
# Line 49 | Line 53 | template<typename T = BaseIntegrator> class Integrator
53  
54    virtual void rotationPropagation( StuntDouble* sd, double ji[3] );
55  
56 <  void checkConstraints( void );
56 >  //void checkConstraints( void );
57    void rotate( int axes1, int axes2, double angle, double j[3],
58           double A[3][3] );
59  
60 +  void printQuaternion(StuntDouble* sd);
61 +  Mat4x4d getS(const Quaternion& q);
62 +
63    ForceFields* myFF;
64  
65    SimInfo *info; // all the info we'll ever need
# Line 63 | Line 70 | template<typename T = BaseIntegrator> class Integrator
70    Molecule* molecules;
71    int nMols;
72  
73 <  int isConstrained; // boolean to know whether the systems contains
67 <         // constraints.
68 <  int nConstrained;  // counter for number of constraints
69 <  int *constrainedA; // the i of a constraint pair
70 <  int *constrainedB; // the j of a constraint pair
71 <  double *constrainedDsqr; // the square of the constraint distance
73 >  VelVerletConsFramework* consFramework;
74  
75 <  int* moving; // tells whether we are moving atom i
76 <  int* moved;  // tells whether we have moved atom i
77 <  double* oldPos; // pre constrained positions
75 >  //int isConstrained; // boolean to know whether the systems contains constraints.
76 >  //int nConstrained;  // counter for number of constraints
77 >  //int *constrainedA; // the i of a constraint pair
78 >  //int *constrainedB; // the j of a constraint pair
79 >  //double *constrainedDsqr; // the square of the constraint distance
80  
81 +  //int* moving; // tells whether we are moving atom i
82 +  //int* moved;  // tells whether we have moved atom i
83 +  //double* oldPos; // pre constrained positions
84 +
85    short isFirst; /*boolean for the first time integrate is called */
86  
87    double dt;
# Line 88 | Line 96 | typedef Integrator<BaseIntegrator> RealIntegrator;
96   typedef Integrator<BaseIntegrator> RealIntegrator;
97  
98   // ansi instantiation
99 < template class Integrator<BaseIntegrator>;
99 > // template class Integrator<BaseIntegrator>;
100  
101 +
102   template<typename T> class NVE : public T {
103  
104   public:
# Line 488 | Line 497 | template<typename T> class ZConstraint : public T { (p
497    friend class ForceSubtractionPolicy;
498  
499   };
491 –
492 – /*
493 – template<typename T> class SingleZConstrain : public T{
500  
501  
502 < };
503 < */
504 <
505 < template<typename T> class NonEquMD : public T {
502 > //Sympletic quaternion Scheme Integrator
503 > //Reference:
504 > // T.F. Miller, M. Eleftheriou, P. Pattnaik, A. Ndirango, D. Newns and G.J. Martyna
505 > //Symplectic quaternion Scheme for biophysical molecular dynamics
506 > //116(20), 8649, J. Chem. Phys. (2002)
507 > template<typename T> class SQSIntegrator : public T{
508    public:
509 <    
510 <
511 <
504 < };
505 <
506 <
507 < //
508 < template<typename T> class SingleZConstraint : public T{
509 <  public:
510 <    SingleZConstraint(SimInfo *theInfo, ForceFields* the_ff);
511 <    ~SingleZConstraint();
512 <    
513 <    bool stopIntegrator();
514 <    
509 >    SQSIntegrator( SimInfo *theInfo, ForceFields* the_ff );
510 >    virtual void moveA();
511 >    virtual void moveB();
512    protected:
513 <    
514 < };
518 <
519 < //Steered Molecular Dynamics, curret implement only support one steered molecule
520 < template<typename T> class SMD : public T{
521 <  public:
522 <    SMD( SimInfo *theInfo, ForceFields* the_ff);
523 <    ~SMD();
524 <  
525 <    virtual void integrate();
526 <    virtual void calcForce( int calcPot, int calcStress );  
527 <    bool stopIntegrator();
513 >    void freeRotor(double dt, Quaternion& q, Vector4d& qdot, Vector3d& I);
514 >    void rotate(int k, double dt,  Quaternion& q,  Vector4d& qdot, double Ik);
515    private:
516 <    
517 < };
516 >    Quaternion getPk(int i, const Vector4d& q);
517 >    Mat4x4d getS(const Quaternion& q);
518 >    vector<Quaternion> q;
519 >    vector<Vector4d> p_qua;
520 >    vector<double> I0;
521  
522 < //By using state pattern, Coordinate Drive is responsible for switching back and forth between
523 < //Driven Molecular Dynamics and ZConstraint Method.
534 < template<typename T> class CoordinateDriver : public T {
535 <  public:
536 <    typedef T ParentIntegrator;
537 <
538 <    CoordinateDriver(SimInfo*, ForceFields*, BaseIntegrator*, BaseIntegrator*);
539 <    ~CoordinateDriver();
540 <    
541 <    virtual void integrate();
542 <
543 <  private:    
544 <    BaseIntegrator* zconsIntegrator;
545 <    BaseIntegrator* drivenIntegrator;
546 <    
522 >                Vector4d p2j(const Vector4d& p, Mat4x4d& m);    
523 >                Vector4d j2p(const Vector4d& j, Mat4x4d& m);
524   };
548 –
525   #endif

Diff Legend

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