mdtools/libmdCode/TraPPE_ExFF.cpp

#include <cstdlib>
#include <cstdio>
#include <cstring>

#include <iostream>
using namespace std;

#include "ForceFields.hpp"
#include "SRI.hpp"
#include "simError.h"

#include <fortranWrappers.hpp>

#ifdef IS_MPI
#include "mpiForceField.h"
#endif // is_mpi

namespace TPE {  // restrict the access of the folowing to this file only.


  // Declare the structures that will be passed by MPI
  
  typedef struct{
    char name[15];
    double mass;
    double epslon;
    double sigma;
    double dipole;
    double w0;
    double v0;
    int isSSD;
    int isDipole;
    int ident;
    int last;      //  0  -> default
                   //  1  -> tells nodes to stop listening
  } atomStruct;
  
  
  typedef struct{
    char nameA[15];
    char nameB[15];
    char type[30];
    double d0;
    int last;      //  0  -> default
                   //  1  -> tells nodes to stop listening
  } bondStruct;
  
  
  typedef struct{
    char nameA[15];
    char nameB[15];
    char nameC[15];
    char type[30];
    double k1, k2, k3, t0;
    int last;      //  0  -> default
                   //  1  -> tells nodes to stop listening
  } bendStruct;
  

  typedef struct{
    char nameA[15];
    char nameB[15];
    char nameC[15];
    char nameD[15];
    char type[30];
    double k1, k2, k3, k4;
    int last;      //  0  -> default
                   //  1  -> tells nodes to stop listening
  } torsionStruct;
  
  
  int parseAtom(    char *lineBuffer, int lineNum, atomStruct     &info );
  int parseBond(    char *lineBuffer, int lineNum, bondStruct     &info );
  int parseBend(    char *lineBuffer, int lineNum, bendStruct     &info );
  int parseTorsion( char *lineBuffer, int lineNum, torsionStruct  &info );
  
  
#ifdef IS_MPI

  MPI_Datatype mpiAtomStructType;
  MPI_Datatype mpiBondStructType;
  MPI_Datatype mpiBendStructType;
  MPI_Datatype mpiTorsionStructType;

#endif

} // namespace

using namespace TPE;


//****************************************************************
// begins the actual forcefield stuff.  
//****************************************************************


TraPPE_ExFF::TraPPE_ExFF(){

  char fileName[200];
  char* ffPath_env = "FORCE_PARAM_PATH";
  char* ffPath;
  char temp[200];
  char errMsg[1000];

  // do the funtion wrapping
  wrapMeFF( this );


#ifdef IS_MPI
  int i;
  
  // **********************************************************************
  // Init the atomStruct mpi type

  atomStruct atomProto; // mpiPrototype
  int atomBC[3] = {15,6,4};  // block counts
  MPI_Aint atomDspls[3];           // displacements
  MPI_Datatype atomMbrTypes[3];    // member mpi types

  MPI_Address(&atomProto.name, &atomDspls[0]);
  MPI_Address(&atomProto.mass, &atomDspls[1]);
  MPI_Address(&atomProto.isSSD, &atomDspls[2]);
  
  atomMbrTypes[0] = MPI_CHAR;
  atomMbrTypes[1] = MPI_DOUBLE;
  atomMbrTypes[2] = MPI_INT;
  
  for (i=2; i >= 0; i--) atomDspls[i] -= atomDspls[0];
  
  MPI_Type_struct(3, atomBC, atomDspls, atomMbrTypes, &mpiAtomStructType);
  MPI_Type_commit(&mpiAtomStructType);


  // **********************************************************************
  // Init the bondStruct mpi type
  
  bondStruct bondProto; // mpiPrototype
  int bondBC[3] = {60,1,1};  // block counts
  MPI_Aint bondDspls[3];           // displacements
  MPI_Datatype bondMbrTypes[3];    // member mpi types
  
  MPI_Address(&bondProto.nameA, &bondDspls[0]);
  MPI_Address(&bondProto.d0,    &bondDspls[1]);
  MPI_Address(&bondProto.last,  &bondDspls[2]);
  
  bondMbrTypes[0] = MPI_CHAR;
  bondMbrTypes[1] = MPI_DOUBLE;
  bondMbrTypes[2] = MPI_INT;
  
  for (i=2; i >= 0; i--) bondDspls[i] -= bondDspls[0];
  
  MPI_Type_struct(3, bondBC, bondDspls, bondMbrTypes, &mpiBondStructType);
  MPI_Type_commit(&mpiBondStructType);


  // **********************************************************************
  // Init the bendStruct mpi type
  
  bendStruct bendProto; // mpiPrototype
  int bendBC[3] = {75,4,1};  // block counts
  MPI_Aint bendDspls[3];           // displacements
  MPI_Datatype bendMbrTypes[3];    // member mpi types
  
  MPI_Address(&bendProto.nameA, &bendDspls[0]);
  MPI_Address(&bendProto.k1,    &bendDspls[1]);
  MPI_Address(&bendProto.last,  &bendDspls[2]);
  
  bendMbrTypes[0] = MPI_CHAR;
  bendMbrTypes[1] = MPI_DOUBLE;
  bendMbrTypes[2] = MPI_INT;
  
  for (i=2; i >= 0; i--) bendDspls[i] -= bendDspls[0];
  
  MPI_Type_struct(3, bendBC, bendDspls, bendMbrTypes, &mpiBendStructType);
  MPI_Type_commit(&mpiBendStructType);


  // **********************************************************************
  // Init the torsionStruct mpi type
  
  torsionStruct torsionProto; // mpiPrototype
  int torsionBC[3] = {90,4,1};  // block counts
  MPI_Aint torsionDspls[3];           // displacements
  MPI_Datatype torsionMbrTypes[3];    // member mpi types
  
  MPI_Address(&torsionProto.nameA, &torsionDspls[0]);
  MPI_Address(&torsionProto.k1,    &torsionDspls[1]);
  MPI_Address(&torsionProto.last,  &torsionDspls[2]);
  
  torsionMbrTypes[0] = MPI_CHAR;
  torsionMbrTypes[1] = MPI_DOUBLE;
  torsionMbrTypes[2] = MPI_INT;
  
  for (i=2; i >= 0; i--) torsionDspls[i] -= torsionDspls[0];
  
  MPI_Type_struct(3, torsionBC, torsionDspls, torsionMbrTypes, 
                  &mpiTorsionStructType);
  MPI_Type_commit(&mpiTorsionStructType);

  // ***********************************************************************
  
  if( worldRank == 0 ){
#endif
    
    // generate the force file name
    
    strcpy( fileName, "TraPPE_Ex.frc" ); 
    //    fprintf( stderr,"Trying to open %s\n", fileName );
    
    // attempt to open the file in the current directory first.
    
    frcFile = fopen( fileName, "r" );
    
    if( frcFile == NULL ){
      
      // next see if the force path enviorment variable is set
      
      ffPath = getenv( ffPath_env );
      if( ffPath == NULL ) {
        STR_DEFINE(ffPath, FRC_PATH );
      }
      
      
      strcpy( temp, ffPath );
      strcat( temp, "/" );
      strcat( temp, fileName );
      strcpy( fileName, temp );
      
      frcFile = fopen( fileName, "r" );
      
      if( frcFile == NULL ){
        
        sprintf( painCave.errMsg,
                 "Error opening the force field parameter file: %s\n"
                 "Have you tried setting the FORCE_PARAM_PATH environment "
                 "vairable?\n",
                 fileName );
        painCave.isFatal = 1;
        simError();
      }
    }
    
#ifdef IS_MPI
  }
  
  sprintf( checkPointMsg, "TraPPE_ExFF file opened sucessfully." );
  MPIcheckPoint();
  
#endif // is_mpi
}


TraPPE_ExFF::~TraPPE_ExFF(){

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif // is_mpi
    
    fclose( frcFile );
    
#ifdef IS_MPI
  }
#endif // is_mpi
}

void TraPPE_ExFF::doForces( int calcPot ){

  int i, isError;
  double* frc;
  double* pos;
  double* tau;
  short int passedCalcPot = (short int)calcPot;

  // forces are zeroed here, before any are acumulated.
  // NOTE: do not rezero the forces in Fortran.

  for(i=0; i<entry_plug->n_atoms; i++){
    entry_plug->atoms[i]->zeroForces();
  }

  frc = Atom::getFrcArray();
  pos = Atom::getPosArray();
  tau = entry_plug->tau;

  isError = 0;
  fortranForceLoop( pos, frc, &(entry_plug->lrPot), tau, 
                    &passedCalcPot, &isError );


  if( isError ){
    sprintf( painCave.errMsg,
             "Error returned from the fortran force calculation.\n" );
    painCave.isFatal = 1;
    simError();
  }

#ifdef IS_MPI
  sprintf( checkPointMsg,
           "successfully returned from the force calculation.\n" );
  MPIcheckPoint();
#endif // is_mpi

}


void TraPPE_ExFF::initializeAtoms( void ){
  
  class LinkedType {
  public:
    LinkedType(){ 
      next = NULL;
      name[0] = '\0';
    }
    ~LinkedType(){ if( next != NULL ) delete next; }

    LinkedType* find(char* key){ 
      if( !strcmp(name, key) ) return this;
      if( next != NULL ) return next->find(key);
      return NULL;
    }
    
    void add( atomStruct &info ){

      // check for duplicates
      
      if( !strcmp( info.name, name ) ){
        sprintf( painCave.errMsg,
                 "Duplicate TraPPE_Ex atom type \"%s\" found in "
                 "the TraPPE_ExFF param file./n",
                 name );
        painCave.isFatal = 1;
        simError();
      }

      if( next != NULL ) next->add(info);
      else{
        next = new LinkedType();
        strcpy(next->name, info.name);
        next->isDipole = info.isDipole;
        next->isSSD    = info.isSSD;
        next->mass     = info.mass;
        next->epslon   = info.epslon;
        next->sigma    = info.sigma;
        next->dipole   = info.dipole;
        next->w0       = info.w0;
        next->v0       = info.v0;
        next->ident    = info.ident;
      }
    }

#ifdef IS_MPI
    
    void duplicate( atomStruct &info ){
      strcpy(info.name, name);
      info.isDipole = isDipole;
      info.isSSD    = isSSD;
      info.mass     = mass;
      info.epslon   = epslon;
      info.sigma    = sigma;
      info.dipole   = dipole;
      info.w0       = w0;
      info.v0       = v0;
      info.last     = 0;
    }


#endif

    char name[15];
    int isDipole;
    int isSSD;
    double mass;
    double epslon;
    double sigma;
    double dipole;
    double w0;
    double v0;
    int ident;
    LinkedType* next;
  };
  
  LinkedType* headAtomType; 
  LinkedType* currentAtomType;
  atomStruct info;
  info.last = 1; // initialize last to have the last set. 
                 // if things go well, last will be set to 0

  
  int i;
  int identNum;
  
  Atom** the_atoms;
  int nAtoms;
  the_atoms = entry_plug->atoms;
  nAtoms = entry_plug->n_atoms;
  
  
  //////////////////////////////////////////////////
  // a quick water fix 

  double waterI[3][3]; 
  waterI[0][0] = 1.76958347772500;
  waterI[0][1] = 0.0;
  waterI[0][2] = 0.0;

  waterI[1][0] = 0.0;
  waterI[1][1] = 0.614537057924513;
  waterI[1][2] = 0.0;

  waterI[2][0] = 0.0;
  waterI[2][1] = 0.0;
  waterI[2][2] = 1.15504641980049;


  double headI[3][3]; 
  headI[0][0] = 1125;
  headI[0][1] = 0.0;
  headI[0][2] = 0.0;

  headI[1][0] = 0.0;
  headI[1][1] = 1125;
  headI[1][2] = 0.0;

  headI[2][0] = 0.0;
  headI[2][1] = 0.0;
  headI[2][2] = 250;

  
  //////////////////////////////////////////////////


#ifdef IS_MPI
  if( worldRank == 0 ){
#endif
    
    // read in the atom types.

    headAtomType = new LinkedType;
    
    fastForward( "AtomTypes", "initializeAtoms" );

    // we are now at the AtomTypes section.
    
    eof_test = fgets( readLine, sizeof(readLine), frcFile );
    lineNum++;
    
    
    // read a line, and start parseing out the atom types 

    if( eof_test == NULL ){
      sprintf( painCave.errMsg, 
               "Error in reading Atoms from force file at line %d.\n",
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    identNum = 1;
    // stop reading at end of file, or at next section
    while( readLine[0] != '#' && eof_test != NULL ){

      // toss comment lines
      if( readLine[0] != '!' ){
        
        // the parser returns 0 if the line was blank
        if( parseAtom( readLine, lineNum, info ) ){
          info.ident = identNum;
          headAtomType->add( info );;
          identNum++;
        }
      }
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }

#ifdef IS_MPI
    
    // send out the linked list to all the other processes

    sprintf( checkPointMsg,
             "TraPPE_ExFF atom structures read successfully." );
    MPIcheckPoint();

    currentAtomType = headAtomType->next; //skip the first element who is a place holder.
    while( currentAtomType != NULL ){
      currentAtomType->duplicate( info );

 
      sendFrcStruct( &info, mpiAtomStructType );

      sprintf( checkPointMsg,
               "successfully sent TraPPE_Ex force type: \"%s\"\n",
               info.name );
      MPIcheckPoint();

      currentAtomType = currentAtomType->next;
    }
    info.last = 1;
    sendFrcStruct( &info, mpiAtomStructType );
    
  }

  else{
    
    // listen for node 0 to send out the force params
    
    MPIcheckPoint();

    headAtomType = new LinkedType;
    recieveFrcStruct( &info, mpiAtomStructType );
    
    while( !info.last ){


      headAtomType->add( info );
      
      MPIcheckPoint();

      recieveFrcStruct( &info, mpiAtomStructType );
    }
  }
#endif // is_mpi

  // call new A_types in fortran
  
  int isError;
  
  // dummy variables
  
  int isGB = 0;
  int isLJ = 1;
  
  
  currentAtomType = headAtomType;
  while( currentAtomType != NULL ){
    
    if( currentAtomType->name[0] != '\0' ){
      isError = 0;
          newTPEtype( &(currentAtomType->ident),
                      &(currentAtomType->mass),
                      &(currentAtomType->epslon),
                      &(currentAtomType->sigma),
                      &isLJ,
                      &(currentAtomType->isSSD),
                      &(currentAtomType->isDipole),
                      &isGB,
                      &(currentAtomType->w0),
                      &(currentAtomType->v0),
                      &(currentAtomType->dipole),
                      &isError );
      if( isError ){
        sprintf( painCave.errMsg,
                 "Error initializing the \"%s\" atom type in fortran\n",
                 currentAtomType->name );
        painCave.isFatal = 1;
        simError();
      }
    }
    currentAtomType = currentAtomType->next;
  }
      
#ifdef IS_MPI
  sprintf( checkPointMsg,
           "TraPPE_ExFF atom structures successfully sent to fortran\n" );
  MPIcheckPoint();
#endif // is_mpi

  
  // initialize the atoms
  
  double bigSigma = 0.0;
  DirectionalAtom* dAtom;

  for( i=0; i<nAtoms; i++ ){
    
    currentAtomType = headAtomType->find( the_atoms[i]->getType() );
    if( currentAtomType == NULL ){
      sprintf( painCave.errMsg, 
               "AtomType error, %s not found in force file.\n",
               the_atoms[i]->getType() );
      painCave.isFatal = 1;
      simError();
    }
    
    the_atoms[i]->setMass( currentAtomType->mass );
    the_atoms[i]->setEpslon( currentAtomType->epslon );
    the_atoms[i]->setSigma( currentAtomType->sigma );
    the_atoms[i]->setLJ();

    if( bigSigma < currentAtomType->sigma ) bigSigma = currentAtomType->sigma;

    if( currentAtomType->isDipole ){
      if( the_atoms[i]->isDirectional() ){
        
        dAtom = (DirectionalAtom *) the_atoms[i];
        dAtom->setMu( currentAtomType->dipole );
        dAtom->setHasDipole( 1 );
        dAtom->setJx( 0.0 );
        dAtom->setJy( 0.0 );
        dAtom->setJz( 0.0 );
        
        if(!strcmp("SSD",the_atoms[i]->getType())){
          dAtom->setI( waterI );
          dAtom->setSSD( 1 );
        }
        else if(!strcmp("HEAD",the_atoms[i]->getType())){
          dAtom->setI( headI );
          dAtom->setSSD( 0 );
        }
        else{
          sprintf(painCave.errMsg,
                  "AtmType error, %s does not have a moment of inertia set.\n",
                  the_atoms[i]->getType() );
          painCave.isFatal = 1;
          simError();
        }
        entry_plug->n_dipoles++;
      }
      else{
        
        sprintf( painCave.errMsg,
                "TraPPE_ExFF error: Atom \"%s\" is a dipole, yet no standard"
                 " orientation was specifed in the BASS file.\n",
                 currentAtomType->name );
        painCave.isFatal = 1;
        simError();
      }
    }
    else{
      if( the_atoms[i]->isDirectional() ){
        sprintf( painCave.errMsg,
                 "TraPPE_ExFF error: Atom \"%s\" was given a standard"
                 "orientation in the BASS file, yet it is not a dipole.\n",
                 currentAtomType->name);
        painCave.isFatal = 1;
        simError();
      }
    }
  }

#ifdef IS_MPI
  double tempBig = bigSigma;
  MPI::COMM_WORLD.Allreduce( &tempBig, &bigSigma, 1, MPI_DOUBLE, MPI_MAX );
#endif  //is_mpi

  //calc rCut and rList

  entry_plug->rCut = 2.5 * bigSigma;
  
  if(entry_plug->rCut > (entry_plug->box_x / 2.0)) 
    entry_plug->rCut = entry_plug->box_x / 2.0;
  
  if(entry_plug->rCut > (entry_plug->box_y / 2.0)) 
    entry_plug->rCut = entry_plug->box_y / 2.0;
  
  if(entry_plug->rCut > (entry_plug->box_z / 2.0)) 
    entry_plug->rCut = entry_plug->box_z / 2.0;

  entry_plug->rList = entry_plug->rCut + 1.0;


  // clean up the memory
  
  delete headAtomType;

#ifdef IS_MPI
  sprintf( checkPointMsg, "TraPPE_Ex atoms initialized succesfully" );
  MPIcheckPoint();
#endif // is_mpi

  initFortran();
  entry_plug->refreshSim();

}

void TraPPE_ExFF::initializeBonds( bond_pair* the_bonds ){
  
  class LinkedType {
  public:
    LinkedType(){ 
      next = NULL;
      nameA[0] = '\0';
      nameB[0] = '\0';
      type[0] = '\0';
    }
    ~LinkedType(){ if( next != NULL ) delete next; }

    LinkedType* find(char* key1, char* key2){ 
      if( !strcmp(nameA, key1 ) && !strcmp( nameB, key2 ) ) return this;
      if( !strcmp(nameA, key2 ) && !strcmp( nameB, key1 ) ) return this;
      if( next != NULL ) return next->find(key1, key2);
      return NULL;
    }
    

    void add( bondStruct &info ){
      
      // check for duplicates
      int dup = 0;

      if( !strcmp(nameA, info.nameA ) && !strcmp( nameB, info.nameB ) ) dup = 1;
      if( !strcmp(nameA, info.nameB ) && !strcmp( nameB, info.nameA ) ) dup = 1;
      
      if(dup){
        sprintf( painCave.errMsg,
                 "Duplicate TraPPE_Ex bond type \"%s - %s\" found in "
                 "the TraPPE_ExFF param file./n",
                 nameA, nameB );
        painCave.isFatal = 1;
        simError();
      }

        
      if( next != NULL ) next->add(info);
      else{
        next = new LinkedType();
        strcpy(next->nameA, info.nameA);
        strcpy(next->nameB, info.nameB);
        strcpy(next->type,  info.type);
        next->d0 = info.d0;
      }
    }
    
#ifdef IS_MPI
    void duplicate( bondStruct &info ){
      strcpy(info.nameA, nameA);
      strcpy(info.nameB, nameB);
      strcpy(info.type,  type);
      info.d0   = d0;
      info.last = 0;
    }


#endif

    char nameA[15];
    char nameB[15];
    char type[30];
    double d0;

    LinkedType* next;
  };


  LinkedType* headBondType; 
  LinkedType* currentBondType;
  bondStruct info;
  info.last = 1; // initialize last to have the last set. 
                 // if things go well, last will be set to 0

  SRI **the_sris;
  Atom** the_atoms;
  int nBonds;
  the_sris = entry_plug->sr_interactions;
  the_atoms = entry_plug->atoms;
  nBonds = entry_plug->n_bonds;

  int i, a, b;
  char* atomA;
  char* atomB;
  
#ifdef IS_MPI
  if( worldRank == 0 ){
#endif
    
    // read in the bond types.
    
    headBondType = new LinkedType;
    
    fastForward( "BondTypes", "initializeBonds" );

    // we are now at the bondTypes section

    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
    lineNum++;
    
    
    // read a line, and start parseing out the atom types 

    if( eof_test == NULL ){
      sprintf( painCave.errMsg, 
               "Error in reading bonds from force file at line %d.\n",
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    // stop reading at end of file, or at next section
    while( readLine[0] != '#' && eof_test != NULL ){

      // toss comment lines
      if( readLine[0] != '!' ){
        
        // the parser returns 0 if the line was blank
        if( parseBond( readLine, lineNum, info ) ){
          headBondType->add( info );
        }
      }
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }
        
#ifdef IS_MPI
    
    // send out the linked list to all the other processes
    
    sprintf( checkPointMsg,
             "TraPPE_Ex bond structures read successfully." );
    MPIcheckPoint();
    
    currentBondType = headBondType;
    while( currentBondType != NULL ){
      currentBondType->duplicate( info );
      sendFrcStruct( &info, mpiBondStructType );
      currentBondType = currentBondType->next;
    }
    info.last = 1;
    sendFrcStruct( &info, mpiBondStructType );
    
  }

  else{
    
    // listen for node 0 to send out the force params
    
    MPIcheckPoint();

    headBondType = new LinkedType;
    recieveFrcStruct( &info, mpiBondStructType );
    while( !info.last ){

      headBondType->add( info );
      recieveFrcStruct( &info, mpiBondStructType );
    }
  }
#endif // is_mpi
  
  
  // initialize the Bonds
  

  for( i=0; i<nBonds; i++ ){
    
    a = the_bonds[i].a;
    b = the_bonds[i].b;

    atomA = the_atoms[a]->getType();
    atomB = the_atoms[b]->getType();
    currentBondType = headBondType->find( atomA, atomB );
    if( currentBondType == NULL ){
      sprintf( painCave.errMsg,
               "BondType error, %s - %s not found in force file.\n",
               atomA, atomB );
      painCave.isFatal = 1;
      simError();
    }
    
    if( !strcmp( currentBondType->type, "fixed" ) ){
      
      the_sris[i] = new ConstrainedBond( *the_atoms[a], 
                                         *the_atoms[b],
                                         currentBondType->d0 );
      entry_plug->n_constraints++;
    }
  }


  // clean up the memory
  
  delete headBondType;

#ifdef IS_MPI
  sprintf( checkPointMsg, "TraPPE_Ex bonds initialized succesfully" );
  MPIcheckPoint();
#endif // is_mpi

}

void TraPPE_ExFF::initializeBends( bend_set* the_bends ){
  
  class LinkedType {
  public:
    LinkedType(){ 
      next = NULL;
      nameA[0] = '\0';
      nameB[0] = '\0';
      nameC[0] = '\0';
      type[0] = '\0';
    }
    ~LinkedType(){ if( next != NULL ) delete next; }

    LinkedType* find( char* key1, char* key2, char* key3 ){ 
      if( !strcmp( nameA, key1 ) && !strcmp( nameB, key2 ) 
          && !strcmp( nameC, key3 ) ) return this;
      if( !strcmp( nameA, key3 ) && !strcmp( nameB, key2 ) 
          && !strcmp( nameC, key1 ) ) return this;
      if( next != NULL ) return next->find(key1, key2, key3);
      return NULL;
    }
    
    void add( bendStruct &info ){

      // check for duplicates
      int dup = 0;
      
      if( !strcmp( nameA, info.nameA ) && !strcmp( nameB, info.nameB ) 
          && !strcmp( nameC, info.nameC ) ) dup = 1;
      if( !strcmp( nameA, info.nameC ) && !strcmp( nameB, info.nameB ) 
          && !strcmp( nameC, info.nameA ) ) dup = 1;

      if(dup){
        sprintf( painCave.errMsg,
                 "Duplicate TraPPE_Ex bend type \"%s - %s - %s\" found in "
                 "the TraPPE_ExFF param file./n",
                 nameA, nameB, nameC );
        painCave.isFatal = 1;
        simError();
      }

      if( next != NULL ) next->add(info);
      else{
        next = new LinkedType();
        strcpy(next->nameA, info.nameA);
        strcpy(next->nameB, info.nameB);
        strcpy(next->nameC, info.nameC);
        strcpy(next->type,  info.type);
        next->k1 = info.k1;
        next->k2 = info.k2;
        next->k3 = info.k3;
        next->t0 = info.t0;
      }
    }

#ifdef IS_MPI    

    void duplicate( bendStruct &info ){
      strcpy(info.nameA, nameA);
      strcpy(info.nameB, nameB);
      strcpy(info.nameC, nameC);
      strcpy(info.type,  type);
      info.k1   = k1;
      info.k2   = k2;
      info.k3   = k3;
      info.t0   = t0;
      info.last = 0;
    }

#endif // is_mpi

    char nameA[15];
    char nameB[15];
    char nameC[15];
    char type[30];
    double k1, k2, k3, t0;

    LinkedType* next;
  };
  
  LinkedType* headBendType; 
  LinkedType* currentBendType;
  bendStruct info;
  info.last = 1; // initialize last to have the last set. 
                 // if things go well, last will be set to 0

  QuadraticBend* qBend;
  GhostBend* gBend;
  SRI **the_sris;
  Atom** the_atoms;
  int nBends;
  the_sris = entry_plug->sr_interactions;
  the_atoms = entry_plug->atoms;
  nBends = entry_plug->n_bends;

  int i, a, b, c;
  char* atomA;
  char* atomB;
  char* atomC;


#ifdef IS_MPI
  if( worldRank == 0 ){
#endif

    // read in the bend types.

    headBendType = new LinkedType;
    
    fastForward( "BendTypes", "initializeBends" );

    // we are now at the bendTypes section

    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
    lineNum++;
        
    // read a line, and start parseing out the bend types 

    if( eof_test == NULL ){
      sprintf( painCave.errMsg, 
               "Error in reading bends from force file at line %d.\n",
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    // stop reading at end of file, or at next section
    while( readLine[0] != '#' && eof_test != NULL ){
      
      // toss comment lines
      if( readLine[0] != '!' ){
        
        // the parser returns 0 if the line was blank
        if( parseBend( readLine, lineNum, info ) ){
          headBendType->add( info );
        }
      }
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }
    
#ifdef IS_MPI
    
    // send out the linked list to all the other processes

    sprintf( checkPointMsg,
             "TraPPE_Ex bend structures read successfully." );
    MPIcheckPoint();

    currentBendType = headBendType;
    while( currentBendType != NULL ){
      currentBendType->duplicate( info );
      sendFrcStruct( &info, mpiBendStructType );
      currentBendType = currentBendType->next;
    }
    info.last = 1;
    sendFrcStruct( &info, mpiBendStructType );
    
  }

  else{
    
    // listen for node 0 to send out the force params
    
    MPIcheckPoint();

    headBendType = new LinkedType;
    recieveFrcStruct( &info, mpiBendStructType );
    while( !info.last ){

      headBendType->add( info );
      recieveFrcStruct( &info, mpiBendStructType );
    }
  }
#endif // is_mpi
  
  // initialize the Bends
  
  int index;

  for( i=0; i<nBends; i++ ){
    
    a = the_bends[i].a;
    b = the_bends[i].b;
    c = the_bends[i].c;

    atomA = the_atoms[a]->getType();
    atomB = the_atoms[b]->getType();

    if( the_bends[i].isGhost ) atomC = "GHOST";
    else atomC = the_atoms[c]->getType();

    currentBendType = headBendType->find( atomA, atomB, atomC );
    if( currentBendType == NULL ){
      sprintf( painCave.errMsg, "BendType error, %s - %s - %s not found"
               " in force file.\n",
               atomA, atomB, atomC );
      painCave.isFatal = 1;
      simError();
    }
    
    if( !strcmp( currentBendType->type, "quadratic" ) ){
      
      index = i + entry_plug->n_bonds;
      
      if( the_bends[i].isGhost){
        
        if( the_bends[i].ghost == b ){
          // do nothing
        }
        else if( the_bends[i].ghost == a ){
          c = a;
          a = b;
          b = a;
        }
        else{ 
          sprintf( painCave.errMsg, 
                   "BendType error, %s - %s - %s,\n"
                   "  --> central atom is not "
                   "correctly identified with the "
                   "\"ghostVectorSource = \" tag.\n",
                   atomA, atomB, atomC );
          painCave.isFatal = 1;
          simError();
        }
        
        gBend = new GhostBend( *the_atoms[a], 
                               *the_atoms[b] );                        
        gBend->setConstants( currentBendType->k1,
                             currentBendType->k2,
                             currentBendType->k3,
                             currentBendType->t0 );
        the_sris[index] = gBend;
      }
      else{
        qBend = new QuadraticBend( *the_atoms[a], 
                                   *the_atoms[b],
                                   *the_atoms[c] );
        qBend->setConstants( currentBendType->k1,
                             currentBendType->k2,
                             currentBendType->k3,
                             currentBendType->t0 );
        the_sris[index] = qBend;
      }
    }
  }


  // clean up the memory
  
  delete headBendType;

#ifdef IS_MPI
  sprintf( checkPointMsg, "TraPPE_Ex bends initialized succesfully" );
  MPIcheckPoint();
#endif // is_mpi

}

void TraPPE_ExFF::initializeTorsions( torsion_set* the_torsions ){

  class LinkedType {
  public:
    LinkedType(){ 
      next = NULL;
      nameA[0] = '\0';
      nameB[0] = '\0';
      nameC[0] = '\0';
      type[0] = '\0';
    }
    ~LinkedType(){ if( next != NULL ) delete next; }

    LinkedType* find( char* key1, char* key2, char* key3, char* key4 ){ 
      if( !strcmp( nameA, key1 ) && !strcmp( nameB, key2 ) &&
          !strcmp( nameC, key3 ) && !strcmp( nameD, key4 ) ) return this;

      if( !strcmp( nameA, key4 ) && !strcmp( nameB, key3 ) &&
          !strcmp( nameC, key2 ) && !strcmp( nameD, key1 ) ) return this;

      if( next != NULL ) return next->find(key1, key2, key3, key4);
      return NULL;
    }

    void add( torsionStruct &info ){

      // check for duplicates
      int dup = 0;

      if( !strcmp( nameA, info.nameA ) && !strcmp( nameB, info.nameB ) &&
          !strcmp( nameC, info.nameC ) && !strcmp( nameD, info.nameD ) ) dup = 1;
      
      if( !strcmp( nameA, info.nameD ) && !strcmp( nameB, info.nameC ) &&
          !strcmp( nameC, info.nameB ) && !strcmp( nameD, info.nameA ) ) dup = 1;
      
      if(dup){
        sprintf( painCave.errMsg,
                 "Duplicate TraPPE_Ex torsion type \"%s - %s - %s - %s\" found in "
                 "the TraPPE_ExFF param file./n", nameA, nameB, nameC, nameD );
        painCave.isFatal = 1;
        simError();
      }

      if( next != NULL ) next->add(info);
      else{
        next = new LinkedType();
        strcpy(next->nameA, info.nameA);
        strcpy(next->nameB, info.nameB);
        strcpy(next->nameC, info.nameC);
        strcpy(next->type,  info.type);
        next->k1 = info.k1;
        next->k2 = info.k2;
        next->k3 = info.k3;
        next->k4 = info.k4;
      }
    }

#ifdef IS_MPI
    
    void duplicate( torsionStruct &info ){
      strcpy(info.nameA, nameA);
      strcpy(info.nameB, nameB);
      strcpy(info.nameC, nameC);
      strcpy(info.nameD, nameD);
      strcpy(info.type,  type);
      info.k1   = k1;
      info.k2   = k2;
      info.k3   = k3;
      info.k4   = k4;
      info.last = 0;
    }

#endif

    char nameA[15];
    char nameB[15];
    char nameC[15];
    char nameD[15];
    char type[30];
    double k1, k2, k3, k4;

    LinkedType* next;
  };
  
  LinkedType* headTorsionType; 
  LinkedType* currentTorsionType;
  torsionStruct info;
  info.last = 1; // initialize last to have the last set. 
                 // if things go well, last will be set to 0

  int i, a, b, c, d, index;
  char* atomA;
  char* atomB;
  char* atomC;
  char* atomD;
  CubicTorsion* cTors;

  SRI **the_sris;
  Atom** the_atoms;
  int nTorsions;
  the_sris = entry_plug->sr_interactions;
  the_atoms = entry_plug->atoms;
  nTorsions = entry_plug->n_torsions;

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif

    // read in the torsion types.

    headTorsionType = new LinkedType;
    
    fastForward( "TorsionTypes", "initializeTorsions" );

    // we are now at the torsionTypes section

    eof_test =  fgets( readLine, sizeof(readLine), frcFile );
    lineNum++;
    
    
    // read a line, and start parseing out the atom types 

    if( eof_test == NULL ){
      sprintf( painCave.errMsg, 
               "Error in reading torsions from force file at line %d.\n",
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    // stop reading at end of file, or at next section
    while( readLine[0] != '#' && eof_test != NULL ){

      // toss comment lines
      if( readLine[0] != '!' ){
        
        // the parser returns 0 if the line was blank
        if( parseTorsion( readLine, lineNum, info ) ){
          headTorsionType->add( info );
        }
      }
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }

#ifdef IS_MPI
    
    // send out the linked list to all the other processes
    
    sprintf( checkPointMsg,
             "TraPPE_Ex torsion structures read successfully." );
    MPIcheckPoint();
    
    currentTorsionType = headTorsionType;
    while( currentTorsionType != NULL ){
      currentTorsionType->duplicate( info );
      sendFrcStruct( &info, mpiTorsionStructType );
      currentTorsionType = currentTorsionType->next;
    }
    info.last = 1;
    sendFrcStruct( &info, mpiTorsionStructType );
    
  }

  else{
    
    // listen for node 0 to send out the force params
    
    MPIcheckPoint();

    headTorsionType = new LinkedType;
    recieveFrcStruct( &info, mpiTorsionStructType );
    while( !info.last ){

      headTorsionType->add( info );
      recieveFrcStruct( &info, mpiTorsionStructType );
    }
  }
#endif // is_mpi
  
  // initialize the Torsions

  for( i=0; i<nTorsions; i++ ){
    
    a = the_torsions[i].a;
    b = the_torsions[i].b;
    c = the_torsions[i].c;
    d = the_torsions[i].d;

    atomA = the_atoms[a]->getType();
    atomB = the_atoms[b]->getType();
    atomC = the_atoms[c]->getType();
    atomD = the_atoms[d]->getType();
    currentTorsionType = headTorsionType->find( atomA, atomB, atomC, atomD );
    if( currentTorsionType == NULL ){
      sprintf( painCave.errMsg,
               "TorsionType error, %s - %s - %s - %s not found"
               " in force file.\n",
               atomA, atomB, atomC, atomD );
      painCave.isFatal = 1;
      simError();
    }
    
    if( !strcmp( currentTorsionType->type, "cubic" ) ){
      index = i + entry_plug->n_bonds + entry_plug->n_bends;
      
      cTors = new CubicTorsion( *the_atoms[a], *the_atoms[b],
                                *the_atoms[c], *the_atoms[d] );
      cTors->setConstants( currentTorsionType->k1, currentTorsionType->k2,
                           currentTorsionType->k3, currentTorsionType->k4 );
      the_sris[index] = cTors;
    }
  }


  // clean up the memory
  
  delete headTorsionType;

#ifdef IS_MPI
  sprintf( checkPointMsg, "TraPPE_Ex torsions initialized succesfully" );
  MPIcheckPoint();
#endif // is_mpi

}

void TraPPE_ExFF::fastForward( char* stopText, char* searchOwner ){

  int foundText = 0;
  char* the_token;

  rewind( frcFile );
  lineNum = 0;

  eof_test = fgets( readLine, sizeof(readLine), frcFile );
  lineNum++;
  if( eof_test == NULL ){
    sprintf( painCave.errMsg, "Error fast forwarding force file for %s: "
             " file is empty.\n",
             searchOwner );
    painCave.isFatal = 1;
    simError();
  }
  
  
  while( !foundText ){
    while( eof_test != NULL && readLine[0] != '#' ){
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
    }
    if( eof_test == NULL ){
      sprintf( painCave.errMsg,
               "Error fast forwarding force file for %s at "
               "line %d: file ended unexpectedly.\n",
               searchOwner,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    the_token = strtok( readLine, " ,;\t#\n" );
    foundText = !strcmp( stopText, the_token );
    
    if( !foundText ){
      eof_test = fgets( readLine, sizeof(readLine), frcFile );
      lineNum++;
      
      if( eof_test == NULL ){
        sprintf( painCave.errMsg, 
                 "Error fast forwarding force file for %s at "
                 "line %d: file ended unexpectedly.\n",
                 searchOwner,
                 lineNum );
        painCave.isFatal = 1;
        simError();
      } 
    }
  }  
}


int parseAtom( char *lineBuffer, int lineNum, atomStruct &info ){
 
  char* the_token;
  
  the_token = strtok( lineBuffer, " \n\t,;" );
  if( the_token != NULL ){
    
    strcpy( info.name, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    info.isDipole = atoi( the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }

    info.isSSD = atoi( the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    info.mass = atof( the_token );
    
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
        
    info.epslon = atof( the_token );
          
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing AtomTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
        
    info.sigma = atof( the_token );

    if( info.isDipole ){
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg, 
                 "Error parseing AtomTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.dipole = atof( the_token );
    }
    else info.dipole = 0.0;

    if( info.isSSD ){

      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg, 
                 "Error parseing AtomTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.w0 = atof( the_token );

      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg, 
                 "Error parseing AtomTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.v0 = atof( the_token );
    }
    else info.v0 = info.w0 = 0.0;

    return 1;
  }
  else return 0;
}

int parseBond( char *lineBuffer, int lineNum, bondStruct &info ){
 
  char* the_token;
  
  the_token = strtok( lineBuffer, " \n\t,;" );
  if( the_token != NULL ){
    
    strcpy( info.nameA, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing BondTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameB, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing BondTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.type, the_token );
    
    if( !strcmp( info.type, "fixed" ) ){
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing BondTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.d0 = atof( the_token );
    }
    else{
      sprintf( painCave.errMsg, 
               "Unknown TraPPE_Ex bond type \"%s\" at line %d\n",
               info.type,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }             
    
    return 1;
  }
  else return 0;
}


int parseBend( char *lineBuffer, int lineNum, bendStruct &info ){

  char* the_token;
  
  the_token = strtok( lineBuffer, " \n\t,;" );
  if( the_token != NULL ){
    
    strcpy( info.nameA, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing BondTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameB, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing BondTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameC, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg, 
               "Error parseing BondTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.type, the_token );

    if( !strcmp( info.type, "quadratic" ) ){
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing BendTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
        
      info.k1 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing BendTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.k2 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing BendTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
        
      info.k3 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing BendTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.t0 = atof( the_token );
    }
    
    else{
      sprintf( painCave.errMsg, 
               "Unknown TraPPE_Ex bend type \"%s\" at line %d\n",
               info.type,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }             
        
    return 1;
  }
  else return 0;
}

int parseTorsion( char *lineBuffer, int lineNum, torsionStruct &info ){
  
  char*  the_token;

  the_token = strtok( lineBuffer, " \n\t,;" );
  if( the_token != NULL ){
    
    strcpy( info.nameA, the_token );
        
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg,
               "Error parseing TorsionTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameB, the_token );

    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg,
               "Error parseing TorsionTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameC, the_token );
    
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg,
               "Error parseing TorsionTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.nameD, the_token );
    
    if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
      sprintf( painCave.errMsg,
               "Error parseing TorsionTypes: line %d\n", lineNum );
      painCave.isFatal = 1;
      simError();
    }
    
    strcpy( info.type, the_token );
    
    if( !strcmp( info.type, "cubic" ) ){
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing TorsionTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.k1 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing TorsionTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.k2 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing TorsionTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.k3 = atof( the_token );
      
      if( ( the_token = strtok( NULL, " \n\t,;" ) ) == NULL ){
        sprintf( painCave.errMsg,
                 "Error parseing TorsionTypes: line %d\n", lineNum );
        painCave.isFatal = 1;
        simError();
      }
      
      info.k4 = atof( the_token );
    
    }
    
    else{
      sprintf( painCave.errMsg, 
               "Unknown TraPPE_Ex torsion type \"%s\" at line %d\n",
               info.type,
               lineNum );
      painCave.isFatal = 1;
      simError();
    }             
    
    return 1;
  }
  
  else return 0;
}
Revision:	359
Committed:	Mon Mar 17 21:38:57 2003 UTC (21 years, 3 months ago) by mmeineke
File size:	41455 byte(s)
Log Message:	adding more to the interface