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

Comparing trunk/OOPSE/libmdtools/Rattle.cpp (file contents):
Revision 1232 by tim, Thu Jun 3 21:51:55 2004 UTC vs.
Revision 1254 by tim, Wed Jun 9 16:16:33 2004 UTC

# Line 1 | Line 1
1   #include "Rattle.hpp"
2   #include <cmath>
3   #include "SimInfo.hpp"
4 + #include "MatVec3.h"
5 + ////////////////////////////////////////////////////////////////////////////////
6 + //Implementation of DCShakeFunctor
7 + ////////////////////////////////////////////////////////////////////////////////
8 + int DCRattleAFunctor::operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2){
9 +  double posA[3];
10 +  double posB[3];
11 +  double oldPosA[3];
12 +  double oldPosB[3];
13 +  double velA[3];
14 +  double velB[3];
15 +  double pab[3];
16 +  double rab[3];
17 +  double rma, rmb;
18 +  double dx, dy, dz;
19 +  double rpab;
20 +  double rabsq, pabsq, rpabsq;
21 +  double diffsq;
22 +  double gab;
23 +  double dt;
24 +  
25 +  dt = info->dt;
26 +  
27 +  consAtom1->getPos(posA);
28 +  consAtom2->getPos(posB);
29  
30 +  
31 +  pab[0] = posA[0] - posB[0];
32 +  pab[1] = posA[1] - posB[1];
33 +  pab[2] = posA[2] - posB[2];
34 +
35 +  //periodic boundary condition
36 +
37 +  info->wrapVector(pab);
38 +
39 +  pabsq = pab[0] * pab[0] + pab[1] * pab[1] + pab[2] * pab[2];
40 +
41 +  rabsq = curPair->getBondLength2();
42 +  diffsq = rabsq - pabsq;
43 +
44 +  // the original rattle code from alan tidesley
45 +  if (fabs(diffsq) > (consTolerance * rabsq * 2)){
46 +    
47 +    consAtom1->getOldPos(oldPosA);
48 +    consAtom2->getOldPos(oldPosB);      
49 +    
50 +    rab[0] = oldPosA[0] - oldPosB[0];
51 +    rab[1] = oldPosA[1] - oldPosB[1];
52 +    rab[2] = oldPosA[2] - oldPosB[2];
53 +
54 +    info->wrapVector(rab);
55 +
56 +    rpab = rab[0] * pab[0] + rab[1] * pab[1] + rab[2] * pab[2];
57 +
58 +    rpabsq = rpab * rpab;
59 +
60 +
61 +    if (rpabsq < (rabsq * -diffsq)){
62 +      return consFail;
63 +    }
64 +
65 +    rma = 1.0 / consAtom1->getMass();
66 +    rmb = 1.0 / consAtom2->getMass();
67 +
68 +    gab = diffsq / (2.0 * (rma + rmb) * rpab);
69 +
70 +    dx = rab[0] * gab;
71 +    dy = rab[1] * gab;
72 +    dz = rab[2] * gab;
73 +
74 +    //set atom1's position
75 +    posA[0] += rma * dx;
76 +    posA[1] += rma * dy;
77 +    posA[2] += rma * dz;
78 +    consAtom1->setPos(posA);
79 +
80 +    //set atom2's position
81 +    posB[0] -= rmb * dx;
82 +    posB[1] -= rmb * dy;
83 +    posB[2] -= rmb * dz;
84 +    consAtom2->setPos(posB);
85 +
86 +    dx = dx / dt;
87 +    dy = dy / dt;
88 +    dz = dz / dt;
89 +
90 +    //set atom1's velocity
91 +    consAtom1->getVel(velA);
92 +    velA[0] += rma * dx;
93 +    velA[1] += rma * dy;
94 +    velA[2] += rma * dz;
95 +    consAtom1->setVel(velA);
96 +
97 +    //set atom2's velocity
98 +    consAtom2->getVel(velB);
99 +    velB[0] -= rmb * dx;
100 +    velB[1] -= rmb * dy;
101 +    velB[2] -= rmb * dz;
102 +    consAtom2->setVel(velB);
103 +
104 +    return consSuccess;
105 +  }
106 +  else
107 +    return consAlready;
108 +  
109 + }
110 +
111 +
112 + int DCRattleAFunctor::operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB){
113 +  return consElemHandlerFail;
114 + }
115 +
116 + int DCRattleAFunctor::operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2){
117 +  //calculate lamda
118 +
119 +  //integrate
120 +
121 +  //
122 +  return consElemHandlerFail;
123 + }
124   ////////////////////////////////////////////////////////////////////////////////
125 + //Implementation of JCShakeFunctor
126 + ////////////////////////////////////////////////////////////////////////////////
127 + int JCRattleAFunctor::operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2){
128 +  return consElemHandlerFail;
129 + }
130 +
131 + int JCRattleAFunctor::operator()(ConstraintAtom* consAtom,ConstraintRigidBody* consRB){
132 +  return consElemHandlerFail;
133 +
134 + }
135 +
136 + int JCRattleAFunctor::operator()(ConstraintRigidBody* consRB1, ConstraintRigidBody* consRB2){
137 +  //calculate lamda,
138 +  //integrate
139 +  //
140 +  return consElemHandlerFail;
141 + }
142 +
143 +
144 + ////////////////////////////////////////////////////////////////////////////////
145   //Implementation of DCRattleBFunctor
146   ////////////////////////////////////////////////////////////////////////////////
147   int DCRattleBFunctor::operator()(ConstraintAtom* consAtom1, ConstraintAtom* consAtom2){

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines