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

Comparing trunk/OOPSE-4/src/UseTheForce/DUFF.cpp (file contents):
Revision 1617 by chuckv, Wed Oct 20 20:46:20 2004 UTC vs.
Revision 1670 by gezelter, Thu Oct 28 16:56:20 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   }
649  
661 – double DUFF::getAtomTypeMass (char* atomType) {
650  
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 –  }
671 –
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 <      set_sticky_params( &(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 >        entry_plug->useSticky = 1;
777 >      }
778 >      
779 >      if (currentAtomType->isDipole) {
780 >        ((DirectionalAtomType*)at)->setDipole();
781 >        entry_plug->useDipoles = 1;              
782 >      }
783 >      
784 >      at->setIdent(currentAtomType->ident);
785 >      at->setName(currentAtomType->name);    
786 >      at->setLennardJones();
787 >      at->complete();
788      }
789 +    currentAtomType = currentAtomType->next;
790 +  }
791 +  
792 +  currentAtomType = headAtomType->next;;
793 +  while( currentAtomType != NULL ){    
794  
795      if( currentAtomType->name[0] != '\0' ){
796        isError = 0;
797 <      makeAtype( &(currentAtomType->ident),
798 <                 &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 );
797 >      newLJtype( &(currentAtomType->ident), &(currentAtomType->sigma),
798 >                 &(currentAtomType->epslon), &isError);
799        if( isError ){
800 <        sprintf( painCave.errMsg,
801 <                 "Error initializing the \"%s\" atom type in fortran\n",
802 <                 currentAtomType->name );
803 <        painCave.isFatal = 1;
804 <        simError();
800 >        sprintf( painCave.errMsg,
801 >                 "Error initializing the \"%s\" LJ type in fortran\n",
802 >                 currentAtomType->name );
803 >        painCave.isFatal = 1;
804 >        simError();
805        }
806 +          
807 +      if (currentAtomType->isDipole) {
808 +        newDipoleType(&(currentAtomType->ident), &(currentAtomType->dipole),
809 +                      &isError);
810 +        if( isError ){
811 +          sprintf( painCave.errMsg,
812 +                   "Error initializing the \"%s\" dipole type in fortran\n",
813 +                   currentAtomType->name );
814 +          painCave.isFatal = 1;
815 +          simError();
816 +        }
817 +      }
818 +      
819 +      if(currentAtomType->isSSD) {        
820 +        makeStickyType( &(currentAtomType->w0), &(currentAtomType->v0),
821 +                        &(currentAtomType->v0p),
822 +                        &(currentAtomType->rl), &(currentAtomType->ru),
823 +                        &(currentAtomType->rlp), &(currentAtomType->rup));
824 +      }
825 +      
826      }
827      currentAtomType = currentAtomType->next;
828    }
# Line 1091 | Line 1086 | void DUFF::readParams( void ){
1086  
1087   #endif // is_mpi
1088  
1089 <  entry_plug->useLJ = 1;
1089 >  entry_plug->useLennardJones = 1;
1090   }
1091  
1092  

Diff Legend

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