ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/trunk/src/UseTheForce/WATER.cpp
(Generate patch)

Comparing trunk/src/UseTheForce/WATER.cpp (file contents):
Revision 3 by tim, Fri Sep 24 16:27:58 2004 UTC vs.
Revision 143 by chrisfen, Fri Oct 22 22:54:01 2004 UTC

# Line 12 | Line 12 | using namespace std;
12   #include "UseTheForce/ForceFields.hpp"
13   #include "primitives/SRI.hpp"
14   #include "utils/simError.h"
15 <
16 < #include "UseTheForce/fortranWrappers.hpp"
15 > #include "types/DirectionalAtomType.hpp"
16 > #include "UseTheForce/DarkSide/lj_interface.h"
17 > #include "UseTheForce/DarkSide/charge_interface.h"
18 > #include "UseTheForce/DarkSide/dipole_interface.h"
19 > #include "UseTheForce/DarkSide/sticky_interface.h"
20  
21   #ifdef IS_MPI
22   #include "UseTheForce/mpiForceField.h"
# Line 253 | Line 256 | WATER::WATER(){
256    headDirectionalType = NULL;
257    currentDirectionalType = NULL;
258  
256 –  // do the funtion wrapping
257 –  wrapMeFF( this );
258 –
259   #ifdef IS_MPI
260    int i;
261    
# Line 392 | Line 392 | void WATER::cleanMe( void ){
392   }
393  
394  
395 < void WATER::initForceField( int ljMixRule ){
395 > void WATER::initForceField(){
396    
397 <  initFortran( ljMixRule, entry_plug->useReactionField );
397 >  initFortran(entry_plug->useReactionField );
398   }
399  
400  
401   void WATER::readParams( void ){
402  
403 <  int identNum;
403 >  int identNum, isError;
404    int tempDirect0, tempDirect1;
405  
406    atomStruct atomInfo;
407    directionalStruct directionalInfo;
408    fpos_t *atomPos;
409  
410 +  AtomType* at;
411 +
412    atomInfo.last = 1;         // initialize last to have the last set.
413    directionalInfo.last = 1;  // if things go well, last will be set to 0
414    
# Line 545 | Line 547 | void WATER::readParams( void ){
547  
548   #endif // is_mpi
549    
548 –  // call new A_types in fortran
549 –  
550 –  int isError;
551 –
550    // dummy variables
553 –  int isGB = 0;
554 –  int isEAM = 0;
555 –  int notDipole = 0;
556 –  int notSSD = 0;
557 –  double noDipMoment = 0.0;
551  
559 –
552    currentAtomType = headAtomType->next;
553    currentDirectionalType = headDirectionalType->next;
554  
555    while( currentAtomType != NULL ){
556 <
557 <    if( currentAtomType->isLJ ) entry_plug->useLJ = 1;
558 <    if( currentAtomType->isCharge ) entry_plug->useCharges = 1;
559 <    if( currentAtomType->isDirectional ){
560 <      // only directional atoms can have dipoles or be sticky
561 <      if ( currentDirectionalType->isDipole ) entry_plug->useDipoles = 1;
562 <      if ( currentDirectionalType->isSticky ) {
563 <        entry_plug->useSticky = 1;
572 <        set_sticky_params( &(currentDirectionalType->w0),
573 <                           &(currentDirectionalType->v0),
574 <                           &(currentDirectionalType->v0p),
575 <                           &(currentDirectionalType->rl),
576 <                           &(currentDirectionalType->ru),
577 <                           &(currentDirectionalType->rlp),
578 <                           &(currentDirectionalType->rup));
556 >    if( currentAtomType->name[0] != '\0' ){
557 >      if (currentAtomType->isDirectional)
558 >        DirectionalAtomType* at = new DirectionalAtomType();
559 >      else
560 >        AtomType* at = new AtomType();
561 >
562 >      if (currentAtomType->isLJ) {
563 >        at->setLennardJones();
564        }
565 <      if( currentAtomType->name[0] != '\0' ){
566 <        isError = 0;
567 <        makeAtype( &(currentAtomType->ident),
568 <                   &(currentAtomType->isLJ),
569 <                   &(currentDirectionalType->isSticky),
570 <                   &(currentDirectionalType->isDipole),
571 <                   &isGB,
572 <                   &isEAM,
573 <                   &(currentAtomType->isCharge),
589 <                   &(currentAtomType->epslon),
590 <                   &(currentAtomType->sigma),
591 <                   &(currentAtomType->charge),
592 <                   &(currentDirectionalType->dipole),
593 <                   &isError );
594 <        if( isError ){
595 <          sprintf( painCave.errMsg,
596 <                   "Error initializing the \"%s\" atom type in fortran\n",
597 <                   currentAtomType->name );
598 <          painCave.isFatal = 1;
599 <          simError();
565 >
566 >      if (currentAtomType->isCharge) {
567 >        at->setCharge();
568 >      }
569 >
570 >      if (currentAtomType->isDirectional) {
571 >        if (currentDirectionalType->isSticky) {
572 >          ((DirectionalAtomType*)at)->setDipole();
573 >          entry_plug->useDipoles = 1;
574          }
575 +      
576 +        if (currentDirectionalType->isSticky) {
577 +          ((DirectionalAtomType*)at)->setSticky();
578 +          entry_plug->useSticky = 1;
579 +        }
580        }
581 <      currentDirectionalType->next;
581 >      
582 >      at->setIdent(currentAtomType->ident);
583 >      at->setName(currentAtomType->name);    
584 >      at->complete();
585      }
586 +    currentAtomType = currentAtomType->next;
587 +  }
588  
589 <    else {
590 <      // use all dummy variables if this is not a directional atom
591 <      if( currentAtomType->name[0] != '\0' ){
592 <        isError = 0;
593 <        makeAtype( &(currentAtomType->ident),
594 <                   &(currentAtomType->isLJ),
595 <                   &notSSD,
596 <                   &notDipole,
597 <                   &isGB,
598 <                   &isEAM,
599 <                   &(currentAtomType->isCharge),
600 <                   &(currentAtomType->epslon),
601 <                   &(currentAtomType->sigma),
602 <                   &(currentAtomType->charge),
603 <                   &noDipMoment,
604 <                   &isError );
589 >  currentAtomType = headAtomType->next;
590 >  currentDirectionalType = headDirectionalType->next;
591 >
592 >  while( currentAtomType != NULL ){    
593 >
594 >    if( currentAtomType->isLJ ){
595 >      isError = 0;
596 >      newLJtype( &(currentAtomType->ident), &(currentAtomType->sigma),
597 >                 &(currentAtomType->epslon), &isError);
598 >      if( isError ){
599 >        sprintf( painCave.errMsg,
600 >                 "Error initializing the \"%s\" LJ type in fortran\n",
601 >                 currentAtomType->name );
602 >        painCave.isFatal = 1;
603 >        simError();
604 >      }
605 >    }
606 >
607 >    if (currentAtomType->isCharge) {
608 >      newChargeType(&(currentAtomType->ident), &(currentAtomType->charge),
609 >                    &isError);
610 >      if( isError ){
611 >        sprintf( painCave.errMsg,
612 >                 "Error initializing the \"%s\" charge type in fortran\n",
613 >                 currentAtomType->name );
614 >        painCave.isFatal = 1;
615 >        simError();
616 >      }
617 >    }
618 >
619 >    if (currentAtomType->isDirectional){
620 >      if (currentDirectionalType->isDipole) {
621 >        newDipoleType(&(currentAtomType->ident),
622 >                      &(currentDirectionalType->dipole),
623 >                      &isError);
624          if( isError ){
625            sprintf( painCave.errMsg,
626 <                   "Error initializing the \"%s\" atom type in fortran\n",
627 <                   currentAtomType->name );
626 >                   "Error initializing the \"%s\" dipole type in fortran\n",
627 >                   currentDirectionalType->name );
628            painCave.isFatal = 1;
629            simError();
630          }
631        }
632 +      
633 +      if(currentDirectionalType->isSticky) {        
634 +        makeStickyType( &(currentDirectionalType->w0),
635 +                        &(currentDirectionalType->v0),
636 +                        &(currentDirectionalType->v0p),
637 +                        &(currentDirectionalType->rl),
638 +                        &(currentDirectionalType->ru),
639 +                        &(currentDirectionalType->rlp),
640 +                        &(currentDirectionalType->rup));
641 +      }
642      }
643      currentAtomType = currentAtomType->next;
644    }
645 <
645 >  
646   #ifdef IS_MPI
647    sprintf( checkPointMsg,
648             "WATER atom and directional structures successfully"
649             "sent to fortran\n" );
650    MPIcheckPoint();
651   #endif // is_mpi
652 <
652 >  
653   }
654  
655  

Diff Legend

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