mdtools/libmdCode/SimSetup.cpp

#include <cstdlib>
#include <iostream>
#include <cmath>

#include "SimSetup.hpp"
#include "parse_me.h"
#include "Integrator.hpp"
#include "simError.h"

#ifdef IS_MPI
#include "mpiBASS.h"
#include "mpiSimulation.hpp"
#endif

SimSetup::SimSetup(){
  stamps = new MakeStamps();
  globals = new Globals();
  
#ifdef IS_MPI
  strcpy( checkPointMsg, "SimSetup creation successful" );
  MPIcheckPoint();
#endif // IS_MPI
}

SimSetup::~SimSetup(){
  delete stamps;
  delete globals;
}

void SimSetup::parseFile( char* fileName ){

#ifdef IS_MPI
  if( worldRank == 0 ){
#endif // is_mpi
    
    inFileName = fileName;
    set_interface_stamps( stamps, globals );
    
#ifdef IS_MPI
    mpiEventInit();
#endif

    yacc_BASS( fileName );

#ifdef IS_MPI
    throwMPIEvent(NULL);
  }
  else receiveParse();
#endif

}

#ifdef IS_MPI
void SimSetup::receiveParse(void){

    set_interface_stamps( stamps, globals );
    mpiEventInit();
    MPIcheckPoint();
    mpiEventLoop();

}

#endif // is_mpi

void SimSetup::createSim( void ){

  MakeStamps *the_stamps;
  Globals* the_globals;
  int i, j;

  // get the stamps and globals;
  the_stamps = stamps;
  the_globals = globals;

  // set the easy ones first
  simnfo->target_temp = the_globals->getTargetTemp();
  simnfo->dt = the_globals->getDt();
  simnfo->run_time = the_globals->getRunTime();

  // get the ones we know are there, yet still may need some work.
  n_components = the_globals->getNComponents();
  strcpy( force_field, the_globals->getForceField() );
  strcpy( ensemble, the_globals->getEnsemble() );
  strcpy( simnfo->ensemble, ensemble );

  strcpy( simnfo->mixingRule, the_globals->getMixingRule() );
  simnfo->usePBC = the_globals->getPBC();
          

  if( !strcmp( force_field, "TraPPE" ) ) the_ff = new TraPPEFF();
  else if( !strcmp( force_field, "DipoleTest" ) ) the_ff = new DipoleTestFF();
  else if( !strcmp( force_field, "TraPPE_Ex" ) ) the_ff = new TraPPE_ExFF();
  else if( !strcmp( force_field, "LJ" ) ) the_ff = new LJ_FF();
  else{
    sprintf( painCave.errMsg,
             "SimSetup Error. Unrecognized force field -> %s\n",
             force_field );
    painCave.isFatal = 1;
    simError();
  }

#ifdef IS_MPI
  strcpy( checkPointMsg, "ForceField creation successful" );
  MPIcheckPoint();
#endif // is_mpi

  
  // get the components and calculate the tot_nMol and indvidual n_mol
  the_components = the_globals->getComponents();
  components_nmol = new int[n_components];
  comp_stamps = new MoleculeStamp*[n_components];

  if( !the_globals->haveNMol() ){
    // we don't have the total number of molecules, so we assume it is
    // given in each component

    tot_nmol = 0;
    for( i=0; i<n_components; i++ ){

      if( !the_components[i]->haveNMol() ){
        // we have a problem
        sprintf( painCave.errMsg,
                 "SimSetup Error. No global NMol or component NMol"
                 " given. Cannot calculate the number of atoms.\n" );
        painCave.isFatal = 1;
        simError();
      }

      tot_nmol += the_components[i]->getNMol();
      components_nmol[i] = the_components[i]->getNMol();
    }
  }
  else{
    sprintf( painCave.errMsg,
             "SimSetup error.\n"
             "\tSorry, the ability to specify total"
             " nMols and then give molfractions in the components\n"
             "\tis not currently supported."
             " Please give nMol in the components.\n" );
    painCave.isFatal = 1;
    simError();
    
    
    //     tot_nmol = the_globals->getNMol();
    
    //   //we have the total number of molecules, now we check for molfractions
    //     for( i=0; i<n_components; i++ ){
    
    //       if( !the_components[i]->haveMolFraction() ){
    
    //  if( !the_components[i]->haveNMol() ){
    //    //we have a problem
    //    std::cerr << "SimSetup error. Neither molFraction nor "
    //              << " nMol was given in component
    
  }

#ifdef IS_MPI
  strcpy( checkPointMsg, "Have the number of components" );
  MPIcheckPoint();
#endif // is_mpi

  // make an array of molecule stamps that match the components used.
  // also extract the used stamps out into a separate linked list

  simnfo->nComponents = n_components;
  simnfo->componentsNmol = components_nmol;
  simnfo->compStamps = comp_stamps;
  simnfo->headStamp = new LinkedMolStamp();
  
  char* id;
  LinkedMolStamp* headStamp = simnfo->headStamp;
  LinkedMolStamp* currentStamp = NULL;
  for( i=0; i<n_components; i++ ){

    id = the_components[i]->getType();
    comp_stamps[i] = NULL;
    
    // check to make sure the component isn't already in the list

    comp_stamps[i] = headStamp->match( id );
    if( comp_stamps[i] == NULL ){
      
      // extract the component from the list;
      
      currentStamp = the_stamps->extractMolStamp( id );
      if( currentStamp == NULL ){
        sprintf( painCave.errMsg,
                 "SimSetup error: Component \"%s\" was not found in the "
                 "list of declared molecules\n",
                 id );
        painCave.isFatal = 1;
        simError();
      }
      
      headStamp->add( currentStamp );
      comp_stamps[i] = headStamp->match( id );
    }
  }

#ifdef IS_MPI
  strcpy( checkPointMsg, "Component stamps successfully extracted\n" );
  MPIcheckPoint();
#endif // is_mpi
  

  // caclulate the number of atoms, bonds, bends and torsions

  tot_atoms = 0;
  tot_bonds = 0;
  tot_bends = 0;
  tot_torsions = 0;
  for( i=0; i<n_components; i++ ){
    
    tot_atoms +=    components_nmol[i] * comp_stamps[i]->getNAtoms();
    tot_bonds +=    components_nmol[i] * comp_stamps[i]->getNBonds();
    tot_bends +=    components_nmol[i] * comp_stamps[i]->getNBends();
    tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
  }

  tot_SRI = tot_bonds + tot_bends + tot_torsions;

  simnfo->n_atoms = tot_atoms;
  simnfo->n_bonds = tot_bonds;
  simnfo->n_bends = tot_bends;
  simnfo->n_torsions = tot_torsions;
  simnfo->n_SRI = tot_SRI;
  simnfo->n_mol = tot_nmol;

  
#ifdef IS_MPI

  // divide the molecules among processors here.
  
  mpiSim = new mpiSimulation( simnfo );
  
  
  globalIndex = mpiSim->divideLabor();


  // set up the local variables 
  
  int localMol, allMol;
  int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
  
  allMol = 0;
  localMol = 0;
  local_atoms = 0;
  local_bonds = 0;
  local_bends = 0;
  local_torsions = 0;
  for( i=0; i<n_components; i++ ){

    for( j=0; j<components_nmol[i]; j++ ){
      
      if( mpiSim->getMyMolStart() <= allMol &&
          allMol <= mpiSim->getMyMolEnd() ){
        
        local_atoms +=    comp_stamps[i]->getNAtoms();
        local_bonds +=    comp_stamps[i]->getNBonds();
        local_bends +=    comp_stamps[i]->getNBends();
        local_torsions += comp_stamps[i]->getNTorsions();
        localMol++;
      }      
      allMol++;
    }
  }
  local_SRI = local_bonds + local_bends + local_torsions;
  

  simnfo->n_atoms = mpiSim->getMyNlocal();  
  
  if( local_atoms != simnfo->n_atoms ){
    sprintf( painCave.errMsg,
             "SimSetup error: mpiSim's localAtom (%d) and SimSetup's"
             " localAtom (%d) are note equal.\n",
             simnfo->n_atoms,
             local_atoms );
    painCave.isFatal = 1;
    simError();
  }

  simnfo->n_bonds = local_bonds;
  simnfo->n_bends = local_bends;
  simnfo->n_torsions = local_torsions;
  simnfo->n_SRI = local_SRI;
  simnfo->n_mol = localMol;

  strcpy( checkPointMsg, "Passed nlocal consistency check." );
  MPIcheckPoint();
  
  
#endif // is_mpi
  

  // create the atom and short range interaction arrays

  Atom::createArrays(simnfo->n_atoms);
  the_atoms = new Atom*[simnfo->n_atoms];
  the_molecules = new Molecule[simnfo->n_mol];


  if( simnfo->n_SRI ){
    the_sris = new SRI*[simnfo->n_SRI];
    the_excludes = new int[2 * simnfo->n_SRI];
    simnfo->globalExcludes = new int;
  }
  else{
    the_excludes = new int;
    simnfo->globalExcludes = new int;
  }

  // set the arrays into the SimInfo object

  simnfo->atoms = the_atoms;
  simnfo->sr_interactions = the_sris;
  simnfo->n_exclude = tot_SRI;
  simnfo->nGlobalExcludes = 0;
  simnfo->excludes = the_excludes;


  // get some of the tricky things that may still be in the globals

  if( simnfo->n_dipoles ){

    if( !the_globals->haveRRF() ){
      sprintf( painCave.errMsg,
               "SimSetup Error, system has dipoles, but no rRF was set.\n");
      painCave.isFatal = 1;
      simError();
    }
    if( !the_globals->haveDielectric() ){
      sprintf( painCave.errMsg,
               "SimSetup Error, system has dipoles, but no"
               " dielectric was set.\n" );
      painCave.isFatal = 1;
      simError();
    }

    simnfo->rRF        = the_globals->getRRF();
    simnfo->dielectric = the_globals->getDielectric();
  }

#ifdef IS_MPI
  strcpy( checkPointMsg, "rRf and dielectric check out" );
  MPIcheckPoint();
#endif // is_mpi
  
  if( the_globals->haveBox() ){
    simnfo->box_x = the_globals->getBox();
    simnfo->box_y = the_globals->getBox();
    simnfo->box_z = the_globals->getBox();
  }
  else if( the_globals->haveDensity() ){

    double vol;
    vol = (double)tot_nmol / the_globals->getDensity();
    simnfo->box_x = pow( vol, ( 1.0 / 3.0 ) );
    simnfo->box_y = simnfo->box_x;
    simnfo->box_z = simnfo->box_x;
  }
  else{
    if( !the_globals->haveBoxX() ){
      sprintf( painCave.errMsg,
               "SimSetup error, no periodic BoxX size given.\n" );
      painCave.isFatal = 1;
      simError();
    }
    simnfo->box_x = the_globals->getBoxX();

    if( !the_globals->haveBoxY() ){
      sprintf( painCave.errMsg,
               "SimSetup error, no periodic BoxY size given.\n" );
      painCave.isFatal = 1;
      simError();
    }
    simnfo->box_y = the_globals->getBoxY();

    if( !the_globals->haveBoxZ() ){
      sprintf( painCave.errMsg,
               "SimSetup error, no periodic BoxZ size given.\n" );
      painCave.isFatal = 1;
      simError();
    }
    simnfo->box_z = the_globals->getBoxZ();
  }

#ifdef IS_MPI
  strcpy( checkPointMsg, "Box size set up" );
  MPIcheckPoint();
#endif // is_mpi


  // initialize the arrays

  the_ff->setSimInfo( simnfo );

  makeAtoms();
  simnfo->identArray = new int[simnfo->n_atoms];
  for(i=0; i<simnfo->n_atoms; i++){
    simnfo->identArray[i] = the_atoms[i]->getIdent();
  }
  
  if( tot_bonds ){
    makeBonds();
  }

  if( tot_bends ){
    makeBends();
  }

  if( tot_torsions ){
    makeTorsions();
  }


 if( the_globals->haveInitialConfig() ){
 
     InitializeFromFile* fileInit;
#ifdef IS_MPI // is_mpi
     if( worldRank == 0 ){
#endif //is_mpi
   fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
#ifdef IS_MPI
     }else fileInit = new InitializeFromFile( NULL );
#endif
   fileInit->read_xyz( simnfo ); // default velocities on

   delete fileInit;
 }
 else{

#ifdef IS_MPI 

  // no init from bass
  
  sprintf( painCave.errMsg,
           "Cannot intialize a parallel simulation without an initial configuration file.\n" );
  painCave.isFatal;
  simError();
  
#else

  initFromBass();


#endif
 }

#ifdef IS_MPI
  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
  MPIcheckPoint();
#endif // is_mpi


#ifdef IS_MPI
  if( worldRank == 0 ){
#endif // is_mpi
    
    if( the_globals->haveFinalConfig() ){
      strcpy( simnfo->finalName, the_globals->getFinalConfig() );
    }
    else{
      strcpy( simnfo->finalName, inFileName );
      char* endTest;
      int nameLength = strlen( simnfo->finalName );
      endTest = &(simnfo->finalName[nameLength - 5]);
      if( !strcmp( endTest, ".bass" ) ){
        strcpy( endTest, ".eor" );
      }
      else if( !strcmp( endTest, ".BASS" ) ){
        strcpy( endTest, ".eor" );
      }
      else{
        endTest = &(simnfo->finalName[nameLength - 4]);
        if( !strcmp( endTest, ".bss" ) ){
          strcpy( endTest, ".eor" );
        }
        else if( !strcmp( endTest, ".mdl" ) ){
          strcpy( endTest, ".eor" );
        }
        else{
          strcat( simnfo->finalName, ".eor" );
        }
      }
    }
    
    // make the sample and status out names
    
    strcpy( simnfo->sampleName, inFileName );
    char* endTest;
    int nameLength = strlen( simnfo->sampleName );
    endTest = &(simnfo->sampleName[nameLength - 5]);
    if( !strcmp( endTest, ".bass" ) ){
      strcpy( endTest, ".dump" );
    }
    else if( !strcmp( endTest, ".BASS" ) ){
      strcpy( endTest, ".dump" );
    }
    else{
      endTest = &(simnfo->sampleName[nameLength - 4]);
      if( !strcmp( endTest, ".bss" ) ){
        strcpy( endTest, ".dump" );
      }
      else if( !strcmp( endTest, ".mdl" ) ){
        strcpy( endTest, ".dump" );
      }
      else{
        strcat( simnfo->sampleName, ".dump" );
      }
    }
    
    strcpy( simnfo->statusName, inFileName );
    nameLength = strlen( simnfo->statusName );
    endTest = &(simnfo->statusName[nameLength - 5]);
    if( !strcmp( endTest, ".bass" ) ){
      strcpy( endTest, ".stat" );
    }
    else if( !strcmp( endTest, ".BASS" ) ){
      strcpy( endTest, ".stat" );
    }
    else{
      endTest = &(simnfo->statusName[nameLength - 4]);
      if( !strcmp( endTest, ".bss" ) ){
        strcpy( endTest, ".stat" );
      }
      else if( !strcmp( endTest, ".mdl" ) ){
        strcpy( endTest, ".stat" );
      }
      else{
        strcat( simnfo->statusName, ".stat" );
      }
    }
    
#ifdef IS_MPI
  }
#endif // is_mpi
  
  // set the status, sample, and themal kick times
  
  if( the_globals->haveSampleTime() ){
    simnfo->sampleTime = the_globals->getSampleTime();
    simnfo->statusTime = simnfo->sampleTime;
    simnfo->thermalTime = simnfo->sampleTime;
  }
  else{
    simnfo->sampleTime = the_globals->getRunTime();
    simnfo->statusTime = simnfo->sampleTime;
    simnfo->thermalTime = simnfo->sampleTime;
  }

  if( the_globals->haveStatusTime() ){
    simnfo->statusTime = the_globals->getStatusTime();
  }

  if( the_globals->haveThermalTime() ){
    simnfo->thermalTime = the_globals->getThermalTime();
  }

  // check for the temperature set flag

  if( the_globals->haveTempSet() ) simnfo->setTemp = the_globals->getTempSet();


//   // make the longe range forces and the integrator

//   new AllLong( simnfo );

  if( !strcmp( force_field, "TraPPE" ) ) new Verlet( *simnfo, the_ff );
  if( !strcmp( force_field, "DipoleTest" ) ) new Symplectic( simnfo, the_ff );
  if( !strcmp( force_field, "TraPPE_Ex" ) ) new Symplectic( simnfo, the_ff );
  if( !strcmp( force_field, "LJ" ) ) new Verlet( *simnfo, the_ff );


  // initialize the Fortran
  
  simnfo->refreshSim();
  
  if( !stcmp( simnfo->mixingRule, "standard") ){
    the_ff->initForceField( LB_MIXING_RULE );
  }
  else if( !stcmp( simnfo->mixingRule, "explicit") ){
    the_ff->initForceField( EXPLICIT_MIXING_RULE );
  }
  else{
    sprintf( painCave.errMsg,
             "SimSetup Error: unknown mixing rule -> \"%s\"\n",
             simnfo->mixingRule );
    painCave.isFatal = 1;
    simError();
  }


#ifdef IS_MPI
  strcpy( checkPointMsg, 
          "Successfully intialized the mixingRule for Fortran." );
  MPIcheckPoint();
#endif // is_mpi
}

void SimSetup::makeAtoms( void ){

  int i, j, k, index;
  double ux, uy, uz, uSqr, u;
  AtomStamp* current_atom;

  DirectionalAtom* dAtom;
  int molIndex, molStart, molEnd, nMemb, lMolIndex;

  lMolIndex = 0;
  molIndex = 0;
  index = 0;
  for( i=0; i<n_components; i++ ){

    for( j=0; j<components_nmol[i]; j++ ){

#ifdef IS_MPI
      if( mpiSim->getMyMolStart() <= molIndex &&
          molIndex <= mpiSim->getMyMolEnd() ){
#endif // is_mpi        

        molStart = index;
        nMemb = comp_stamps[i]->getNAtoms();
        for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
          
          current_atom = comp_stamps[i]->getAtom( k );
          if( current_atom->haveOrientation() ){
            
            dAtom = new DirectionalAtom(index);
            simnfo->n_oriented++;
            the_atoms[index] = dAtom;
            
            ux = current_atom->getOrntX();
            uy = current_atom->getOrntY();
            uz = current_atom->getOrntZ();
            
            uSqr = (ux * ux) + (uy * uy) + (uz * uz);
            
            u = sqrt( uSqr );
            ux = ux / u;
            uy = uy / u;
            uz = uz / u;
            
            dAtom->setSUx( ux );
            dAtom->setSUy( uy );
            dAtom->setSUz( uz );
          }
          else{
            the_atoms[index] = new GeneralAtom(index);
          }
          the_atoms[index]->setType( current_atom->getType() );
          the_atoms[index]->setIndex( index );
          
          // increment the index and repeat;
          index++;
        }
        
        molEnd = index -1;
        the_molecules[lMolIndex].setNMembers( nMemb );
        the_molecules[lMolIndex].setStartAtom( molStart );
        the_molecules[lMolIndex].setEndAtom( molEnd );
        the_molecules[lMolIndex].setStampID( i );
        lMolIndex++;

#ifdef IS_MPI
      }
#endif //is_mpi
      
      molIndex++;
    }
  }

#ifdef IS_MPI
    for( i=0; i<mpiSim->getMyNlocal(); i++ ) the_atoms[i]->setGlobalIndex( globalIndex[i] );
    
    delete[] globalIndex;

    mpiSim->mpiRefresh();
#endif //IS_MPI
          
  the_ff->initializeAtoms();
}

void SimSetup::makeBonds( void ){

  int i, j, k, index, offset, molIndex;
  bond_pair* the_bonds;
  BondStamp* current_bond;

  the_bonds = new bond_pair[tot_bonds];
  index = 0;
  offset = 0;
  molIndex = 0;

  for( i=0; i<n_components; i++ ){

    for( j=0; j<components_nmol[i]; j++ ){

#ifdef IS_MPI
      if( mpiSim->getMyMolStart() <= molIndex &&
          molIndex <= mpiSim->getMyMolEnd() ){
#endif // is_mpi        
        
        for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
          
          current_bond = comp_stamps[i]->getBond( k );
          the_bonds[index].a = current_bond->getA() + offset;
          the_bonds[index].b = current_bond->getB() + offset;

          exI = the_bonds[index].a;
          exJ = the_bonds[index].b;

          // exclude_I must always be the smaller of the pair
          if( exI > exJ ){
            tempEx = exI;
            exI = exJ;
            exJ = tempEx;
          }

          
#ifdef IS_MPI

          the_excludes[index*2] =     
            the_atoms[exI]->getGlobalIndex() + 1;
          the_excludes[index*2 + 1] = 
            the_atoms[exJ]->getGlobalIndex() + 1;

#else  // isn't MPI
          
          the_excludes[index*2] =     exI + 1; 
          the_excludes[index*2 + 1] = exJ + 1;
          // fortran index from 1 (hence the +1 in the indexing)
#endif  //is_mpi
          
          // increment the index and repeat;
          index++;
        }
        offset += comp_stamps[i]->getNAtoms();
        
#ifdef IS_MPI
      }
#endif //is_mpi
      
      molIndex++;
    }      
  }

  the_ff->initializeBonds( the_bonds );
}

void SimSetup::makeBends( void ){

  int i, j, k, index, offset, molIndex, exI, exJ;
  bend_set* the_bends;
  BendStamp* current_bend;
  LinkedAssign* extras;
  LinkedAssign* current_extra;
  

  the_bends = new bend_set[tot_bends];
  index = 0;
  offset = 0;
  molIndex = 0;
  for( i=0; i<n_components; i++ ){

    for( j=0; j<components_nmol[i]; j++ ){

#ifdef IS_MPI
      if( mpiSim->getMyMolStart() <= molIndex &&
          molIndex <= mpiSim->getMyMolEnd() ){
#endif // is_mpi        

        for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
          
          current_bend = comp_stamps[i]->getBend( k );
          the_bends[index].a = current_bend->getA() + offset;
          the_bends[index].b = current_bend->getB() + offset;
          the_bends[index].c = current_bend->getC() + offset;
          
          if( current_bend->haveExtras() ){
            
            extras = current_bend->getExtras();
            current_extra = extras;
            
            while( current_extra != NULL ){
              if( !strcmp( current_extra->getlhs(), "ghostVectorSource" )){
                
                switch( current_extra->getType() ){
                  
                case 0:
                  the_bends[index].ghost =
                    current_extra->getInt() + offset;
                  the_bends[index].isGhost = 1;
                  break;
                  
                case 1:
                  the_bends[index].ghost = 
                    (int)current_extra->getDouble() + offset;
                  the_bends[index].isGhost = 1;
                  break;
                  
                default:
                  sprintf( painCave.errMsg,
                           "SimSetup Error: ghostVectorSource was neiter a "
                           "double nor an int.\n"
                           "-->Bend[%d] in %s\n",
                           k, comp_stamps[i]->getID() );
                  painCave.isFatal = 1;
                  simError();
                }
              }
              
              else{
                
                sprintf( painCave.errMsg,
                         "SimSetup Error: unhandled bend assignment:\n"
                         "    -->%s in Bend[%d] in %s\n",
                         current_extra->getlhs(),
                         k, comp_stamps[i]->getID() );
                painCave.isFatal = 1;
                simError();
              }
              
              current_extra = current_extra->getNext();
            }
          }
          
          if( !the_bends[index].isGhost ){
            
            exI = the_bends[index].a;
            exJ = the_bends[index].c;
          }
          else{
            
            exI = the_bends[index].a;
            exJ = the_bends[index].b;
          }
          
          // exclude_I must always be the smaller of the pair
          if( exI > exJ ){
            tempEx = exI;
            exI = exJ;
            exJ = tempEx;
          }


#ifdef IS_MPI

          the_excludes[(index + tot_bonds)*2] =     
            the_atoms[exI]->getGlobalIndex() + 1;
          the_excludes[(index + tot_bonds)*2 + 1] = 
            the_atoms[exJ]->getGlobalIndex() + 1;
          
#else  // isn't MPI
          
          the_excludes[(index + tot_bonds)*2] =     exI + 1; 
          the_excludes[(index + tot_bonds)*2 + 1] = exJ + 1;
          // fortran index from 1 (hence the +1 in the indexing)
#endif  //is_mpi
          
          
          // increment the index and repeat;
          index++;
        }
        offset += comp_stamps[i]->getNAtoms();
        
#ifdef IS_MPI
      }
#endif //is_mpi

      molIndex++;
    }
  }

#ifdef IS_MPI
  sprintf( checkPointMsg,
           "Successfully created the bends list.\n" );
  MPIcheckPoint();
#endif // is_mpi
  

  the_ff->initializeBends( the_bends );
}

void SimSetup::makeTorsions( void ){

  int i, j, k, index, offset, molIndex, exI, exJ, tempEx;
  torsion_set* the_torsions;
  TorsionStamp* current_torsion;

  the_torsions = new torsion_set[tot_torsions];
  index = 0;
  offset = 0;
  molIndex = 0;
  for( i=0; i<n_components; i++ ){

    for( j=0; j<components_nmol[i]; j++ ){

#ifdef IS_MPI
      if( mpiSim->getMyMolStart() <= molIndex &&
          molIndex <= mpiSim->getMyMolEnd() ){
#endif // is_mpi        

      for( k=0; k<comp_stamps[i]->getNTorsions(); k++ ){

        current_torsion = comp_stamps[i]->getTorsion( k );
        the_torsions[index].a = current_torsion->getA() + offset;
        the_torsions[index].b = current_torsion->getB() + offset;
        the_torsions[index].c = current_torsion->getC() + offset;
        the_torsions[index].d = current_torsion->getD() + offset;

        exI = the_torsions[index].a;
        exJ = the_torsions[index].d;

        
        // exclude_I must always be the smaller of the pair
        if( exI > exJ ){
          tempEx = exI;
          exI = exJ;
          exJ = tempEx;
        }


#ifdef IS_MPI
        
        the_excludes[(index + tot_bonds + tot_bends)*2] =     
          the_atoms[exI]->getGlobalIndex() + 1;
        the_excludes[(index + tot_bonds + tot_bends)*2 + 1] = 
          the_atoms[exJ]->getGlobalIndex() + 1;
        
#else  // isn't MPI
        
        the_excludes[(index + tot_bonds + tot_bends)*2] =     exI + 1; 
        the_excludes[(index + tot_bonds + tot_bends)*2 + 1] = exJ + 1;
        // fortran indexes from 1 (hence the +1 in the indexing)
#endif  //is_mpi
        

        // increment the index and repeat;
        index++;
      }
      offset += comp_stamps[i]->getNAtoms();

#ifdef IS_MPI
      }
#endif //is_mpi      

      molIndex++;
    }
  }

  the_ff->initializeTorsions( the_torsions );
}

void SimSetup::initFromBass( void ){

  int i, j, k;
  int n_cells;
  double cellx, celly, cellz;
  double temp1, temp2, temp3;
  int n_per_extra;
  int n_extra;
  int have_extra, done;

  temp1 = (double)tot_nmol / 4.0;
  temp2 = pow( temp1, ( 1.0 / 3.0 ) );
  temp3 = ceil( temp2 );

  have_extra =0;
  if( temp2 < temp3 ){ // we have a non-complete lattice
    have_extra =1;

    n_cells = (int)temp3 - 1;
    cellx = simnfo->box_x / temp3;
    celly = simnfo->box_y / temp3;
    cellz = simnfo->box_z / temp3;
    n_extra = tot_nmol - ( 4 * n_cells * n_cells * n_cells );
    temp1 = ((double)n_extra) / ( pow( temp3, 3.0 ) - pow( n_cells, 3.0 ) );
    n_per_extra = (int)ceil( temp1 );

    if( n_per_extra > 4){
      sprintf( painCave.errMsg,
               "SimSetup error. There has been an error in constructing"
               " the non-complete lattice.\n" );
      painCave.isFatal = 1;
      simError();
    }
  }
  else{
    n_cells = (int)temp3;
    cellx = simnfo->box_x / temp3;
    celly = simnfo->box_y / temp3;
    cellz = simnfo->box_z / temp3;
  }

  current_mol = 0;
  current_comp_mol = 0;
  current_comp = 0;
  current_atom_ndx = 0;

  for( i=0; i < n_cells ; i++ ){
    for( j=0; j < n_cells; j++ ){
      for( k=0; k < n_cells; k++ ){

        makeElement( i * cellx,
                     j * celly,
                     k * cellz );

        makeElement( i * cellx + 0.5 * cellx,
                     j * celly + 0.5 * celly,
                     k * cellz );

        makeElement( i * cellx,
                     j * celly + 0.5 * celly,
                     k * cellz + 0.5 * cellz );

        makeElement( i * cellx + 0.5 * cellx,
                     j * celly,
                     k * cellz + 0.5 * cellz );
      }
    }
  }

  if( have_extra ){
    done = 0;

    int start_ndx;
    for( i=0; i < (n_cells+1) && !done; i++ ){
      for( j=0; j < (n_cells+1) && !done; j++ ){

        if( i < n_cells ){

          if( j < n_cells ){
            start_ndx = n_cells;
          }
          else start_ndx = 0;
        }
        else start_ndx = 0;

        for( k=start_ndx; k < (n_cells+1) && !done; k++ ){

          makeElement( i * cellx,
                       j * celly,
                       k * cellz );
          done = ( current_mol >= tot_nmol );

          if( !done && n_per_extra > 1 ){
            makeElement( i * cellx + 0.5 * cellx,
                         j * celly + 0.5 * celly,
                         k * cellz );
            done = ( current_mol >= tot_nmol );
          }

          if( !done && n_per_extra > 2){
            makeElement( i * cellx,
                         j * celly + 0.5 * celly,
                         k * cellz + 0.5 * cellz );
            done = ( current_mol >= tot_nmol );
          }

          if( !done && n_per_extra > 3){
            makeElement( i * cellx + 0.5 * cellx,
                         j * celly,
                         k * cellz + 0.5 * cellz );
            done = ( current_mol >= tot_nmol );
          }
        }
      }
    }
  }


  for( i=0; i<simnfo->n_atoms; i++ ){
    simnfo->atoms[i]->set_vx( 0.0 );
    simnfo->atoms[i]->set_vy( 0.0 );
    simnfo->atoms[i]->set_vz( 0.0 );
  }
}

void SimSetup::makeElement( double x, double y, double z ){

  int k;
  AtomStamp* current_atom;
  DirectionalAtom* dAtom;
  double rotMat[3][3];

  for( k=0; k<comp_stamps[current_comp]->getNAtoms(); k++ ){

    current_atom = comp_stamps[current_comp]->getAtom( k );
    if( !current_atom->havePosition() ){
      sprintf( painCave.errMsg,
               "SimSetup:initFromBass error.\n"
               "\tComponent %s, atom %s does not have a position specified.\n"
               "\tThe initialization routine is unable to give a start"
               " position.\n",
               comp_stamps[current_comp]->getID(),
               current_atom->getType() );
      painCave.isFatal = 1;
      simError();
    }

    the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );
    the_atoms[current_atom_ndx]->setY( y + current_atom->getPosY() );
    the_atoms[current_atom_ndx]->setZ( z + current_atom->getPosZ() );

    if( the_atoms[current_atom_ndx]->isDirectional() ){

      dAtom = (DirectionalAtom *)the_atoms[current_atom_ndx];

      rotMat[0][0] = 1.0;
      rotMat[0][1] = 0.0;
      rotMat[0][2] = 0.0;

      rotMat[1][0] = 0.0;
      rotMat[1][1] = 1.0;
      rotMat[1][2] = 0.0;

      rotMat[2][0] = 0.0;
      rotMat[2][1] = 0.0;
      rotMat[2][2] = 1.0;

      dAtom->setA( rotMat );
    }

    current_atom_ndx++;
  }

  current_mol++;
  current_comp_mol++;

  if( current_comp_mol >= components_nmol[current_comp] ){

    current_comp_mol = 0;
    current_comp++;
  }
}
Revision:	363
Committed:	Tue Mar 18 21:27:53 2003 UTC (21 years, 5 months ago) by mmeineke
File size:	26720 byte(s)
Log Message:	last little changes before compiling and debuging