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 561 by mmeineke, Fri Jun 20 20:29:36 2003 UTC vs.
Revision 572 by mmeineke, Wed Jul 2 21:26:55 2003 UTC

# Line 137 | Line 137 | void Integrator::checkConstraints( void ){
137        constrainedA[i] = temp_con[i].get_a();
138        constrainedB[i] = temp_con[i].get_b();
139        constrainedDsqr[i] = temp_con[i].get_dsqr();
140 +
141      }
142  
143      
# Line 256 | Line 257 | void Integrator::integrate( void ){
257  
258    }
259  
260 <  dumpOut->writeFinal();
260 >  dumpOut->writeFinal(currTime);
261  
262    delete dumpOut;
263    delete statOut;
# Line 293 | Line 294 | void Integrator::moveA( void ){
294    double ji[3];
295    double angle;
296  
297 +
298 +
299    for( i=0; i<nAtoms; i++ ){
300      atomIndex = i * 3;
301      aMatIndex = i * 9;
302 <    
302 >
303      // velocity half step
304      for( j=atomIndex; j<(atomIndex+3); j++ )
305        vel[j] += ( dt2 * frc[j] / atoms[i]->getMass() ) * eConvert;
306  
307      // position whole step    
308 <    for( j=atomIndex; j<(atomIndex+3); j++ )
309 <      pos[j] += dt * vel[j];
307 <
308 <  
308 >    for( j=atomIndex; j<(atomIndex+3); j++ ) pos[j] += dt * vel[j];
309 >    
310      if( atoms[i]->isDirectional() ){
311  
312        dAtom = (DirectionalAtom *)atoms[i];
# Line 402 | Line 403 | void Integrator::preMove( void ){
403  
404    if( nConstrained ){
405  
405 – //    if( oldAtoms != nAtoms ){
406 –      
407 – //       // save oldAtoms to check for lode balanceing later on.
408 –      
409 – //       oldAtoms = nAtoms;
410 –      
411 – //       delete[] moving;
412 – //       delete[] moved;
413 – //       delete[] oldPos;
414 –      
415 – //       moving = new int[nAtoms];
416 – //       moved  = new int[nAtoms];
417 –      
418 – //       oldPos = new double[nAtoms*3];
419 – //     }
420 –  
406      for(i=0; i<(nAtoms*3); i++) oldPos[i] = pos[i];
407    }
408   }  
# Line 426 | Line 411 | void Integrator::constrainA(){
411  
412    int i,j,k;
413    int done;
414 <  double pxab, pyab, pzab;
415 <  double rxab, ryab, rzab;
416 <  int a, b;
414 >  double pab[3];
415 >  double rab[3];
416 >  int a, b, ax, ay, az, bx, by, bz;
417    double rma, rmb;
418    double dx, dy, dz;
419    double rpab;
# Line 444 | Line 429 | void Integrator::constrainA(){
429      moving[i] = 0;
430      moved[i]  = 1;
431    }
432 <  
448 <  
432 >
433    iteration = 0;
434    done = 0;
435    while( !done && (iteration < maxIteration )){
# Line 455 | Line 439 | void Integrator::constrainA(){
439  
440        a = constrainedA[i];
441        b = constrainedB[i];
442 <    
442 >      
443 >      ax = (a*3) + 0;
444 >      ay = (a*3) + 1;
445 >      az = (a*3) + 2;
446 >
447 >      bx = (b*3) + 0;
448 >      by = (b*3) + 1;
449 >      bz = (b*3) + 2;
450 >
451        if( moved[a] || moved[b] ){
452          
453 <        pxab = pos[3*a+0] - pos[3*b+0];
454 <        pyab = pos[3*a+1] - pos[3*b+1];
455 <        pzab = pos[3*a+2] - pos[3*b+2];
453 >        pab[0] = pos[ax] - pos[bx];
454 >        pab[1] = pos[ay] - pos[by];
455 >        pab[2] = pos[az] - pos[bz];
456  
457 <        //periodic boundary condition
458 <        pxab = pxab - info->box_x * copysign(1, pxab)
459 <          * int( fabs(pxab) / info->box_x + 0.5);
460 <        pyab = pyab - info->box_y * copysign(1, pyab)
461 <          * int( fabs(pyab) / info->box_y + 0.5);
462 <        pzab = pzab - info->box_z * copysign(1, pzab)
471 <          * int( fabs(pzab) / info->box_z + 0.5);
472 <      
473 <        pabsq = pxab * pxab + pyab * pyab + pzab * pzab;
457 >        //periodic boundary condition
458 >
459 >        info->wrapVector( pab );
460 >
461 >        pabsq = pab[0] * pab[0] + pab[1] * pab[1] + pab[2] * pab[2];
462 >
463          rabsq = constrainedDsqr[i];
464 <        diffsq = pabsq - rabsq;
464 >        diffsq = rabsq - pabsq;
465  
466          // the original rattle code from alan tidesley
467 <        if (fabs(diffsq) > tol*rabsq*2) {
468 <          rxab = oldPos[3*a+0] - oldPos[3*b+0];
469 <          ryab = oldPos[3*a+1] - oldPos[3*b+1];
470 <          rzab = oldPos[3*a+2] - oldPos[3*b+2];
482 <
483 <          rxab = rxab - info->box_x * copysign(1, rxab)
484 <            * int( fabs(rxab) / info->box_x + 0.5);
485 <          ryab = ryab - info->box_y * copysign(1, ryab)
486 <            * int( fabs(ryab) / info->box_y + 0.5);
487 <          rzab = rzab - info->box_z * copysign(1, rzab)
488 <            * int( fabs(rzab) / info->box_z + 0.5);
467 >        if (fabs(diffsq) > (tol*rabsq*2)) {
468 >          rab[0] = oldPos[ax] - oldPos[bx];
469 >          rab[1] = oldPos[ay] - oldPos[by];
470 >          rab[2] = oldPos[az] - oldPos[bz];
471  
472 <          rpab = rxab * pxab + ryab * pyab + rzab * pzab;
472 >          info->wrapVector( rab );
473 >
474 >          rpab = rab[0] * pab[0] + rab[1] * pab[1] + rab[2] * pab[2];
475 >
476            rpabsq = rpab * rpab;
477  
478  
479            if (rpabsq < (rabsq * -diffsq)){
480 +
481   #ifdef IS_MPI
482              a = atoms[a]->getGlobalIndex();
483              b = atoms[b]->getGlobalIndex();
484   #endif //is_mpi
485              sprintf( painCave.errMsg,
486 <                     "Constraint failure in constrainA at atom %d and %d\n.",
486 >                     "Constraint failure in constrainA at atom %d and %d.\n",
487                       a, b );
488              painCave.isFatal = 1;
489              simError();
# Line 505 | Line 491 | void Integrator::constrainA(){
491  
492            rma = 1.0 / atoms[a]->getMass();
493            rmb = 1.0 / atoms[b]->getMass();
494 <          
494 >
495            gab = diffsq / ( 2.0 * ( rma + rmb ) * rpab );
496 <          dx = rxab * gab;
497 <          dy = ryab * gab;
498 <          dz = rzab * gab;
496 >
497 >          dx = rab[0] * gab;
498 >          dy = rab[1] * gab;
499 >          dz = rab[2] * gab;
500  
501 <          pos[3*a+0] += rma * dx;
502 <          pos[3*a+1] += rma * dy;
503 <          pos[3*a+2] += rma * dz;
501 >          pos[ax] += rma * dx;
502 >          pos[ay] += rma * dy;
503 >          pos[az] += rma * dz;
504  
505 <          pos[3*b+0] -= rmb * dx;
506 <          pos[3*b+1] -= rmb * dy;
507 <          pos[3*b+2] -= rmb * dz;
505 >          pos[bx] -= rmb * dx;
506 >          pos[by] -= rmb * dy;
507 >          pos[bz] -= rmb * dz;
508  
509            dx = dx / dt;
510            dy = dy / dt;
511            dz = dz / dt;
512  
513 <          vel[3*a+0] += rma * dx;
514 <          vel[3*a+1] += rma * dy;
515 <          vel[3*a+2] += rma * dz;
513 >          vel[ax] += rma * dx;
514 >          vel[ay] += rma * dy;
515 >          vel[az] += rma * dz;
516  
517 <          vel[3*b+0] -= rmb * dx;
518 <          vel[3*b+1] -= rmb * dy;
519 <          vel[3*b+2] -= rmb * dz;
517 >          vel[bx] -= rmb * dx;
518 >          vel[by] -= rmb * dy;
519 >          vel[bz] -= rmb * dz;
520  
521            moving[a] = 1;
522            moving[b] = 1;
# Line 563 | Line 550 | void Integrator::constrainB( void ){
550    int i,j,k;
551    int done;
552    double vxab, vyab, vzab;
553 <  double rxab, ryab, rzab;
554 <  int a, b;
553 >  double rab[3];
554 >  int a, b, ax, ay, az, bx, by, bz;
555    double rma, rmb;
556    double dx, dy, dz;
557    double rabsq, pabsq, rvab;
# Line 581 | Line 568 | void Integrator::constrainB( void ){
568    iteration = 0;
569    while( !done && (iteration < maxIteration ) ){
570  
571 +    done = 1;
572 +
573      for(i=0; i<nConstrained; i++){
574        
575        a = constrainedA[i];
576        b = constrainedB[i];
577  
578 +      ax = (a*3) + 0;
579 +      ay = (a*3) + 1;
580 +      az = (a*3) + 2;
581 +
582 +      bx = (b*3) + 0;
583 +      by = (b*3) + 1;
584 +      bz = (b*3) + 2;
585 +
586        if( moved[a] || moved[b] ){
587          
588 <        vxab = vel[3*a+0] - vel[3*b+0];
589 <        vyab = vel[3*a+1] - vel[3*b+1];
590 <        vzab = vel[3*a+2] - vel[3*b+2];
588 >        vxab = vel[ax] - vel[bx];
589 >        vyab = vel[ay] - vel[by];
590 >        vzab = vel[az] - vel[bz];
591  
592 <        rxab = pos[3*a+0] - pos[3*b+0];
593 <        ryab = pos[3*a+1] - pos[3*b+1];
594 <        rzab = pos[3*a+2] - pos[3*b+2];
592 >        rab[0] = pos[ax] - pos[bx];
593 >        rab[1] = pos[ay] - pos[by];
594 >        rab[2] = pos[az] - pos[bz];
595          
596 <        rxab = rxab - info->box_x * copysign(1, rxab)
597 <          * int( fabs(rxab) / info->box_x + 0.5);
601 <        ryab = ryab - info->box_y * copysign(1, ryab)
602 <          * int( fabs(ryab) / info->box_y + 0.5);
603 <        rzab = rzab - info->box_z * copysign(1, rzab)
604 <          * int( fabs(rzab) / info->box_z + 0.5);
605 <
596 >        info->wrapVector( rab );
597 >        
598          rma = 1.0 / atoms[a]->getMass();
599          rmb = 1.0 / atoms[b]->getMass();
600  
601 <        rvab = rxab * vxab + ryab * vyab + rzab * vzab;
601 >        rvab = rab[0] * vxab + rab[1] * vyab + rab[2] * vzab;
602            
603          gab = -rvab / ( ( rma + rmb ) * constrainedDsqr[i] );
604  
605          if (fabs(gab) > tol) {
606            
607 <          dx = rxab * gab;
608 <          dy = ryab * gab;
609 <          dz = rzab * gab;
607 >          dx = rab[0] * gab;
608 >          dy = rab[1] * gab;
609 >          dz = rab[2] * gab;
610            
611 <          vel[3*a+0] += rma * dx;
612 <          vel[3*a+1] += rma * dy;
613 <          vel[3*a+2] += rma * dz;
611 >          vel[ax] += rma * dx;
612 >          vel[ay] += rma * dy;
613 >          vel[az] += rma * dz;
614  
615 <          vel[3*b+0] -= rmb * dx;
616 <          vel[3*b+1] -= rmb * dy;
617 <          vel[3*b+2] -= rmb * dz;
615 >          vel[bx] -= rmb * dx;
616 >          vel[by] -= rmb * dy;
617 >          vel[bz] -= rmb * dz;
618            
619            moving[a] = 1;
620            moving[b] = 1;

Diff Legend

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