ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE-2.0/src/UseTheForce/DUFF.cpp
(Generate patch)

Comparing trunk/OOPSE-2.0/src/UseTheForce/DUFF.cpp (file contents):
Revision 1621 by gezelter, Wed Oct 20 21:52:20 2004 UTC vs.
Revision 1706 by gezelter, Thu Nov 4 16:20:28 2004 UTC

# Line 8 | Line 8 | using namespace std;
8   #include "UseTheForce/ForceFields.hpp"
9   #include "primitives/SRI.hpp"
10   #include "utils/simError.h"
11 + #include "types/DirectionalAtomType.hpp"
12 + #include "UseTheForce/DarkSide/lj_interface.h"
13 + #include "UseTheForce/DarkSide/dipole_interface.h"
14   #include "UseTheForce/DarkSide/sticky_interface.h"
12 – #include "UseTheForce/DarkSide/atype_interface.h"
15  
14 – //#include "UseTheForce/fortranWrappers.hpp"
15 –
16 –
16   #ifdef IS_MPI
17   #include "UseTheForce/mpiForceField.h"
18   #endif // is_mpi
# Line 455 | Line 454 | DUFF::DUFF(){
454  
455   DUFF::DUFF(){
456  
457 <  char fileName[200];
458 <  char* ffPath_env = "FORCE_PARAM_PATH";
460 <  char* ffPath;
461 <  char temp[200];
457 >  string fileName;
458 >  string tempString;
459  
460    headAtomType       = NULL;
461    currentAtomType    = NULL;
# Line 568 | Line 565 | DUFF::DUFF(){
565      
566      // generate the force file name
567      
568 <    strcpy( fileName, "DUFF.frc" );
568 >    fileName = "DUFF.frc";
569      //    fprintf( stderr,"Trying to open %s\n", fileName );
570      
571      // attempt to open the file in the current directory first.
572      
573 <    frcFile = fopen( fileName, "r" );
573 >    frcFile = fopen( fileName.c_str(), "r" );
574      
575      if( frcFile == NULL ){
576        
577        // next see if the force path enviorment variable is set
578 <      
579 <      ffPath = getenv( ffPath_env );
580 <      if( ffPath == NULL ) {
581 <        STR_DEFINE(ffPath, FRC_PATH );
582 <      }
578 >
579 >      tempString = ffPath + "/" + fileName;
580 >      fileName = tempString;
581 >            
582 >      frcFile = fopen( fileName.c_str(), "r" );
583        
587 –      
588 –      strcpy( temp, ffPath );
589 –      strcat( temp, "/" );
590 –      strcat( temp, fileName );
591 –      strcpy( fileName, temp );
592 –      
593 –      frcFile = fopen( fileName, "r" );
594 –      
584        if( frcFile == NULL ){
585          
586          sprintf( painCave.errMsg,
# Line 599 | Line 588 | DUFF::DUFF(){
588                   "\t%s\n"
589                   "\tHave you tried setting the FORCE_PARAM_PATH environment "
590                   "variable?\n",
591 <                 fileName );
591 >                 fileName.c_str() );
592          painCave.severity = OOPSE_ERROR;
593          painCave.isFatal = 1;
594          simError();
# Line 653 | Line 642 | void DUFF::initForceField( int ljMixRule ){
642   }
643  
644  
645 < void DUFF::initForceField( int ljMixRule ){
645 > void DUFF::initForceField(){
646    
647 <  initFortran( ljMixRule, entry_plug->useReactionField );
647 >  initFortran( entry_plug->useReactionField );
648   }
660 –
661 – double DUFF::getAtomTypeMass (char* atomType) {
649  
663 –  currentAtomType = headAtomType->find( atomType );
664 –  if( currentAtomType == NULL ){
665 –    sprintf( painCave.errMsg,
666 –            "AtomType error, %s not found in force file.\n",
667 –             atomType );
668 –    painCave.isFatal = 1;
669 –    simError();
670 –  }
650  
672 –  return currentAtomType->mass;
673 – }
674 –
651   void DUFF::readParams( void ){
652  
653 <  int identNum;
653 >  int identNum, isError;
654    
655    atomStruct atomInfo;
656    bondStruct bondInfo;
657    bendStruct bendInfo;
658    torsionStruct torsionInfo;
659 +
660 +  AtomType* at;
661    
662    bigSigma = 0.0;
663  
# Line 780 | Line 758 | void DUFF::readParams( void ){
758    }
759  
760   #endif // is_mpi
761 <
784 <
785 <
786 <  // call new A_types in fortran
787 <  
788 <  int isError;
789 <  
761 >
762    // dummy variables
763 <  
792 <  int isGB = 0;
793 <  int isLJ = 1;
794 <  int isEAM =0;
795 <  int isCharge = 0;
796 <  double charge=0.0;
797 <    
763 >      
764    currentAtomType = headAtomType->next;;
765 <  while( currentAtomType != NULL ){
766 <    
767 <    if(currentAtomType->isDipole) entry_plug->useDipoles = 1;
768 <    if(currentAtomType->isSSD) {
769 <      entry_plug->useSticky = 1;
770 <      makeStickyType( &(currentAtomType->w0), &(currentAtomType->v0),
771 <                      &(currentAtomType->v0p),
772 <                      &(currentAtomType->rl), &(currentAtomType->ru),
773 <                      &(currentAtomType->rlp), &(currentAtomType->rup));
765 >  while( currentAtomType != NULL ){    
766 >
767 >    if( currentAtomType->name[0] != '\0' ){
768 >      
769 >      if (currentAtomType->isSSD || currentAtomType->isDipole)
770 >        at = new DirectionalAtomType();
771 >      else
772 >        at = new AtomType();
773 >      
774 >      if (currentAtomType->isSSD) {
775 >        ((DirectionalAtomType*)at)->setSticky();
776 >      }
777 >      
778 >      if (currentAtomType->isDipole) {
779 >        ((DirectionalAtomType*)at)->setDipole();
780 >      }
781 >      
782 >      at->setIdent(currentAtomType->ident);
783 >      at->setName(currentAtomType->name);    
784 >      at->setLennardJones();
785 >      at->complete();
786      }
787 +    currentAtomType = currentAtomType->next;
788 +  }
789 +  
790 +  currentAtomType = headAtomType->next;;
791 +  while( currentAtomType != NULL ){    
792  
793      if( currentAtomType->name[0] != '\0' ){
794        isError = 0;
795 <      makeAtype( &(currentAtomType->ident),
796 <                 &isLJ,
814 <                 &(currentAtomType->isSSD),
815 <                 &(currentAtomType->isDipole),
816 <                 &isGB,
817 <                 &isEAM,
818 <                 &isCharge,
819 <                 &(currentAtomType->epslon),
820 <                 &(currentAtomType->sigma),
821 <                 &charge,
822 <                 &(currentAtomType->dipole),
823 <                 &isError );
795 >      newLJtype( &(currentAtomType->ident), &(currentAtomType->sigma),
796 >                 &(currentAtomType->epslon), &isError);
797        if( isError ){
798 <        sprintf( painCave.errMsg,
799 <                 "Error initializing the \"%s\" atom type in fortran\n",
800 <                 currentAtomType->name );
801 <        painCave.isFatal = 1;
802 <        simError();
798 >        sprintf( painCave.errMsg,
799 >                 "Error initializing the \"%s\" LJ type in fortran\n",
800 >                 currentAtomType->name );
801 >        painCave.isFatal = 1;
802 >        simError();
803 >      }
804 >          
805 >      if (currentAtomType->isDipole) {
806 >        newDipoleType(&(currentAtomType->ident), &(currentAtomType->dipole),
807 >                      &isError);
808 >        if( isError ){
809 >          sprintf( painCave.errMsg,
810 >                   "Error initializing the \"%s\" dipole type in fortran\n",
811 >                   currentAtomType->name );
812 >          painCave.isFatal = 1;
813 >          simError();
814 >        }
815 >      }
816 >      
817 >      if(currentAtomType->isSSD) {        
818 >        makeStickyType( &(currentAtomType->w0), &(currentAtomType->v0),
819 >                        &(currentAtomType->v0p),
820 >                        &(currentAtomType->rl), &(currentAtomType->ru),
821 >                        &(currentAtomType->rlp), &(currentAtomType->rup));
822        }
823 +      
824      }
825      currentAtomType = currentAtomType->next;
826    }
# Line 1090 | Line 1083 | void DUFF::readParams( void ){
1083    MPIcheckPoint();
1084  
1085   #endif // is_mpi
1093 –
1094 –  entry_plug->useLJ = 1;
1086   }
1087  
1088  
# Line 1151 | Line 1142 | void DUFF::initializeAtoms( int nAtoms, Atom** the_ato
1142      the_atoms[i]->setMass( currentAtomType->mass );
1143      the_atoms[i]->setIdent( currentAtomType->ident );
1144  
1145 +    if (currentAtomType->isSSD) entry_plug->useSticky = 1;      
1146 +    if (currentAtomType->isDipole) entry_plug->useDipoles = 1;
1147 +    // Fix this later.  We'll set it a bunch of times.
1148 +    entry_plug->useLennardJones = 1;
1149 +
1150 +
1151      if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;
1152  
1153      if( currentAtomType->isDipole ){

Diff Legend

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