mdtools/interface_implementation/SimSetup.cpp

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

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

#ifdef IS_MPI
#include "mpiBASS.h"
#include "bassDiag.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();

}


void SimSetup::testMe(void){
  bassDiag* dumpMe = new bassDiag(globals,stamps);
  dumpMe->dumpStamps();
  delete dumpMe;
}
#endif

void SimSetup::createSim( void ){

  MakeStamps *the_stamps;
  Globals* the_globals;
  int i;

  // 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() );

  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{
    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
        std::cerr << "SimSetup Error. No global NMol or component NMol"
                  << " given. Cannot calculate the number of atoms.\n";
        exit( 8 );
      }

      tot_nmol += the_components[i]->getNMol();
      components_nmol[i] = the_components[i]->getNMol();
    }
  }
  else{
    std::cerr << "NOT A SUPPORTED FEATURE\n";

//     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

  }

  // make an array of molecule stamps that match the components used.

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

    comp_stamps[i] =
      the_stamps->getMolecule( the_components[i]->getType() );
  }


  // 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;

  // create the atom and short range interaction arrays

  Atom::createArrays(tot_atoms);
  the_atoms = new Atom*[tot_atoms];
  the_molecules = new Molecule[tot_nmol];


  if( tot_SRI ){
    the_sris = new SRI*[tot_SRI];
    the_excludes = new ex_pair[tot_SRI];
  }

  // set the arrays into the SimInfo object

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


  // initialize the arrays

  the_ff->setSimInfo( simnfo );

  makeAtoms();

  if( tot_bonds ){
    makeBonds();
  }

  if( tot_bends ){
    makeBends();
  }

  if( tot_torsions ){
    makeTorsions();
  }

  //  makeMolecules();

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

  if( simnfo->n_dipoles ){

    if( !the_globals->haveRRF() ){
      std::cerr << "SimSetup Error, system has dipoles, but no rRF was set.\n";
      exit(8);
    }
    if( !the_globals->haveDielectric() ){
      std::cerr << "SimSetup Error, system has dipoles, but no"
                << " dielectric was set.\n";
      exit(8);
    }

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

  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() ){
      std::cerr << "SimSetup error, no periodic BoxX size given.\n";
      exit(8);
    }
    simnfo->box_x = the_globals->getBoxX();

    if( !the_globals->haveBoxY() ){
      std::cerr << "SimSetup error, no periodic BoxY size given.\n";
      exit(8);
    }
    simnfo->box_y = the_globals->getBoxY();

    if( !the_globals->haveBoxZ() ){
      std::cerr << "SimSetup error, no periodic BoxZ size given.\n";
      exit(8);
    }
    simnfo->box_z = the_globals->getBoxZ();
  }


//   if( the_globals->haveInitialConfig() ){
//        InitializeFromFile* fileInit;
//     fileInit = new InitializeFromFile( the_globals->getInitialConfig() );

//     fileInit->read_xyz( simnfo ); // default velocities on

//     delete fileInit;
//   }
//   else{

    initFromBass();


//   }

#ifdef IS_MPI
    if( worldRank == TESTWRITE ){
#endif // is_mpi
      
      fprintf( stderr, 
               "infile name is \"%s\"\n",
               inFileName );
      
      inFileName = "./butane.bass";
        
      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 );
  if( !strcmp( force_field, "DipoleTest" ) ) new Symplectic( simnfo );
  if( !strcmp( force_field, "TraPPE_Ex" ) ) new Symplectic( simnfo );
}

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;


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

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

      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[molIndex].setNMembers( nMemb );
      the_molecules[molIndex].setStartAtom( molStart );
      the_molecules[molIndex].setEndAtom( molEnd );
      molIndex++;

    }
  }

  the_ff->initializeAtoms();
}

void SimSetup::makeBonds( void ){

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

  the_bonds = new bond_pair[tot_bonds];
  index = 0;
  offset = 0;
  for( i=0; i<n_components; i++ ){

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

      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;

        the_excludes[index].i = the_bonds[index].a;
        the_excludes[index].j = the_bonds[index].b;

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

  the_ff->initializeBonds( the_bonds );
}

void SimSetup::makeBends( void ){

  int i, j, k, index, offset;
  bend_set* the_bends;
  BendStamp* current_bend;

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

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

      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;

        the_excludes[index + tot_bonds].i = the_bends[index].a;
        the_excludes[index + tot_bonds].j = the_bends[index].c;

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

  the_ff->initializeBends( the_bends );
}

void SimSetup::makeTorsions( void ){

  int i, j, k, index, offset;
  torsion_set* the_torsions;
  TorsionStamp* current_torsion;

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

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

      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;

        the_excludes[index + tot_bonds + tot_bends].i = the_torsions[index].a;
        the_excludes[index + tot_bonds + tot_bends].j = the_torsions[index].d;

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

  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){
      std::cerr << "THere has been an error in constructing the non-complete lattice.\n";
      exit(8);
    }
  }
  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() ){
      std::cerr << "Component " << comp_stamps[current_comp]->getID()
                << ", atom " << current_atom->getType()
                << " does not have a position specified.\n"
                << "The initialization routine is unable to give a start"
                << " position.\n";
      exit(8);
    }

    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:	184
Committed:	Thu Nov 21 20:33:06 2002 UTC (21 years, 7 months ago) by mmeineke
File size:	17610 byte(s)
Log Message:	* empty log message *
#	User	Rev	Content
1	mmeineke	10	#include <cstdlib>
2			#include <iostream>
3			#include <cmath>
4
5			#include "SimSetup.hpp"
6			#include "parse_me.h"
7			#include "LRI.hpp"
8			#include "Integrator.hpp"
9	mmeineke	176	#include "simError.h"
10	mmeineke	144
11	chuckv	131	#ifdef IS_MPI
12	chuckv	139	#include "mpiBASS.h"
13	chuckv	131	#include "bassDiag.hpp"
14			#endif
15	mmeineke	10
16			SimSetup::SimSetup(){
17			stamps = new MakeStamps();
18			globals = new Globals();
19	mmeineke	164
20			#ifdef IS_MPI
21			strcpy( checkPointMsg, "SimSetup creation successful" );
22			MPIcheckPoint();
23	mmeineke	176	#endif // IS_MPI
24	mmeineke	10	}
25
26			SimSetup::~SimSetup(){
27			delete stamps;
28			delete globals;
29			}
30
31			void SimSetup::parseFile( char* fileName ){
32
33	chuckv	131	#ifdef IS_MPI
34	mmeineke	164	if( worldRank == 0 ){
35			#endif // is_mpi
36
37			inFileName = fileName;
38			set_interface_stamps( stamps, globals );
39
40			#ifdef IS_MPI
41			mpiEventInit();
42	chuckv	124	#endif
43	mmeineke	164
44			yacc_BASS( fileName );
45
46	chuckv	131	#ifdef IS_MPI
47	mmeineke	164	throwMPIEvent(NULL);
48			}
49	mmeineke	176	else receiveParse();
50	chuckv	124	#endif
51
52	mmeineke	10	}
53
54	chuckv	131	#ifdef IS_MPI
55	chuckv	124	void SimSetup::receiveParse(void){
56
57			set_interface_stamps( stamps, globals );
58			mpiEventInit();
59	mmeineke	164	MPIcheckPoint();
60	chuckv	124	mpiEventLoop();
61
62			}
63
64	chuckv	131
65	chuckv	128	void SimSetup::testMe(void){
66			bassDiag* dumpMe = new bassDiag(globals,stamps);
67			dumpMe->dumpStamps();
68			delete dumpMe;
69			}
70	chuckv	131	#endif
71	mmeineke	176
72	mmeineke	10	void SimSetup::createSim( void ){
73
74			MakeStamps *the_stamps;
75			Globals* the_globals;
76			int i;
77
78			// get the stamps and globals;
79			the_stamps = stamps;
80			the_globals = globals;
81
82			// set the easy ones first
83			simnfo->target_temp = the_globals->getTargetTemp();
84			simnfo->dt = the_globals->getDt();
85			simnfo->run_time = the_globals->getRunTime();
86
87			// get the ones we know are there, yet still may need some work.
88			n_components = the_globals->getNComponents();
89			strcpy( force_field, the_globals->getForceField() );
90			strcpy( ensemble, the_globals->getEnsemble() );
91	chuckv	124
92	mmeineke	10	if( !strcmp( force_field, "TraPPE" ) ) the_ff = new TraPPEFF();
93			else if( !strcmp( force_field, "DipoleTest" ) ) the_ff = new DipoleTestFF();
94			else if( !strcmp( force_field, "TraPPE_Ex" ) ) the_ff = new TraPPE_ExFF();
95			else{
96	mmeineke	176	sprintf( painCave.errMsg,
97			"SimSetup Error. Unrecognized force field -> %s\n",
98			force_field );
99			painCave.isFatal = 1;
100			simError();
101	mmeineke	10	}
102
103	mmeineke	176	#ifdef IS_MPI
104			strcpy( checkPointMsg, "ForceField creation successful" );
105			MPIcheckPoint();
106			#endif // is_mpi
107
108	mmeineke	10	// get the components and calculate the tot_nMol and indvidual n_mol
109			the_components = the_globals->getComponents();
110			components_nmol = new int[n_components];
111			comp_stamps = new MoleculeStamp*[n_components];
112	chuckv	124
113	mmeineke	10	if( !the_globals->haveNMol() ){
114	chuckv	124	// we don't have the total number of molecules, so we assume it is
115	mmeineke	10	// given in each component
116
117			tot_nmol = 0;
118			for( i=0; i<n_components; i++ ){
119	chuckv	124
120	mmeineke	10	if( !the_components[i]->haveNMol() ){
121			// we have a problem
122			std::cerr << "SimSetup Error. No global NMol or component NMol"
123			<< " given. Cannot calculate the number of atoms.\n";
124			exit( 8 );
125			}
126
127			tot_nmol += the_components[i]->getNMol();
128			components_nmol[i] = the_components[i]->getNMol();
129			}
130			}
131			else{
132			std::cerr << "NOT A SUPPORTED FEATURE\n";
133	chuckv	124
134	mmeineke	10	// tot_nmol = the_globals->getNMol();
135	chuckv	124
136	mmeineke	10	// //we have the total number of molecules, now we check for molfractions
137			// for( i=0; i<n_components; i++ ){
138	chuckv	124
139	mmeineke	10	// if( !the_components[i]->haveMolFraction() ){
140	chuckv	124
141	mmeineke	10	// if( !the_components[i]->haveNMol() ){
142			// //we have a problem
143			// std::cerr << "SimSetup error. Neither molFraction nor "
144			// << " nMol was given in component
145
146			}
147
148			// make an array of molecule stamps that match the components used.
149
150			for( i=0; i<n_components; i++ ){
151
152	chuckv	124	comp_stamps[i] =
153	mmeineke	10	the_stamps->getMolecule( the_components[i]->getType() );
154			}
155
156
157	chuckv	124
158	mmeineke	10	// caclulate the number of atoms, bonds, bends and torsions
159
160			tot_atoms = 0;
161			tot_bonds = 0;
162			tot_bends = 0;
163			tot_torsions = 0;
164			for( i=0; i<n_components; i++ ){
165	chuckv	124
166	mmeineke	10	tot_atoms += components_nmol[i] * comp_stamps[i]->getNAtoms();
167			tot_bonds += components_nmol[i] * comp_stamps[i]->getNBonds();
168			tot_bends += components_nmol[i] * comp_stamps[i]->getNBends();
169			tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
170			}
171	chuckv	124
172	mmeineke	10	tot_SRI = tot_bonds + tot_bends + tot_torsions;
173	chuckv	124
174	mmeineke	10	simnfo->n_atoms = tot_atoms;
175			simnfo->n_bonds = tot_bonds;
176			simnfo->n_bends = tot_bends;
177			simnfo->n_torsions = tot_torsions;
178			simnfo->n_SRI = tot_SRI;
179
180			// create the atom and short range interaction arrays
181	chuckv	124
182	mmeineke	184	Atom::createArrays(tot_atoms);
183	mmeineke	10	the_atoms = new Atom*[tot_atoms];
184	mmeineke	113	the_molecules = new Molecule[tot_nmol];
185	chuckv	124
186
187	mmeineke	10	if( tot_SRI ){
188			the_sris = new SRI*[tot_SRI];
189			the_excludes = new ex_pair[tot_SRI];
190			}
191
192			// set the arrays into the SimInfo object
193
194			simnfo->atoms = the_atoms;
195			simnfo->sr_interactions = the_sris;
196			simnfo->n_exclude = tot_SRI;
197			simnfo->excludes = the_excludes;
198
199	chuckv	124
200	mmeineke	10	// initialize the arrays
201	chuckv	124
202	mmeineke	10	the_ff->setSimInfo( simnfo );
203	chuckv	124
204	mmeineke	10	makeAtoms();
205
206			if( tot_bonds ){
207			makeBonds();
208			}
209
210			if( tot_bends ){
211			makeBends();
212			}
213
214			if( tot_torsions ){
215			makeTorsions();
216			}
217
218			// makeMolecules();
219
220			// get some of the tricky things that may still be in the globals
221
222			if( simnfo->n_dipoles ){
223
224			if( !the_globals->haveRRF() ){
225			std::cerr << "SimSetup Error, system has dipoles, but no rRF was set.\n";
226			exit(8);
227			}
228			if( !the_globals->haveDielectric() ){
229			std::cerr << "SimSetup Error, system has dipoles, but no"
230			<< " dielectric was set.\n";
231			exit(8);
232			}
233
234			simnfo->rRF = the_globals->getRRF();
235			simnfo->dielectric = the_globals->getDielectric();
236			}
237
238			if( the_globals->haveBox() ){
239			simnfo->box_x = the_globals->getBox();
240			simnfo->box_y = the_globals->getBox();
241			simnfo->box_z = the_globals->getBox();
242			}
243			else if( the_globals->haveDensity() ){
244	chuckv	124
245	mmeineke	10	double vol;
246			vol = (double)tot_nmol / the_globals->getDensity();
247			simnfo->box_x = pow( vol, ( 1.0 / 3.0 ) );
248			simnfo->box_y = simnfo->box_x;
249			simnfo->box_z = simnfo->box_x;
250			}
251			else{
252			if( !the_globals->haveBoxX() ){
253			std::cerr << "SimSetup error, no periodic BoxX size given.\n";
254			exit(8);
255			}
256			simnfo->box_x = the_globals->getBoxX();
257
258			if( !the_globals->haveBoxY() ){
259			std::cerr << "SimSetup error, no periodic BoxY size given.\n";
260			exit(8);
261			}
262			simnfo->box_y = the_globals->getBoxY();
263
264			if( !the_globals->haveBoxZ() ){
265			std::cerr << "SimSetup error, no periodic BoxZ size given.\n";
266			exit(8);
267			}
268			simnfo->box_z = the_globals->getBoxZ();
269			}
270
271	chuckv	124
272			// if( the_globals->haveInitialConfig() ){
273			// InitializeFromFile* fileInit;
274			// fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
275
276			// fileInit->read_xyz( simnfo ); // default velocities on
277
278			// delete fileInit;
279			// }
280			// else{
281
282	mmeineke	10	initFromBass();
283
284
285	chuckv	124	// }
286
287	mmeineke	184	#ifdef IS_MPI
288			if( worldRank == TESTWRITE ){
289			#endif // is_mpi
290
291			fprintf( stderr,
292			"infile name is \"%s\"\n",
293			inFileName );
294
295			inFileName = "./butane.bass";
296
297			if( the_globals->haveFinalConfig() ){
298			strcpy( simnfo->finalName, the_globals->getFinalConfig() );
299			}
300			else{
301			strcpy( simnfo->finalName, inFileName );
302			char* endTest;
303			int nameLength = strlen( simnfo->finalName );
304			endTest = &(simnfo->finalName[nameLength - 5]);
305			if( !strcmp( endTest, ".bass" ) ){
306			strcpy( endTest, ".eor" );
307			}
308			else if( !strcmp( endTest, ".BASS" ) ){
309			strcpy( endTest, ".eor" );
310			}
311			else{
312			endTest = &(simnfo->finalName[nameLength - 4]);
313			if( !strcmp( endTest, ".bss" ) ){
314			strcpy( endTest, ".eor" );
315			}
316			else if( !strcmp( endTest, ".mdl" ) ){
317			strcpy( endTest, ".eor" );
318			}
319			else{
320			strcat( simnfo->finalName, ".eor" );
321			}
322			}
323			}
324
325			// make the sample and status out names
326
327			strcpy( simnfo->sampleName, inFileName );
328			char* endTest;
329			int nameLength = strlen( simnfo->sampleName );
330			endTest = &(simnfo->sampleName[nameLength - 5]);
331			if( !strcmp( endTest, ".bass" ) ){
332			strcpy( endTest, ".dump" );
333			}
334			else if( !strcmp( endTest, ".BASS" ) ){
335			strcpy( endTest, ".dump" );
336			}
337			else{
338			endTest = &(simnfo->sampleName[nameLength - 4]);
339			if( !strcmp( endTest, ".bss" ) ){
340			strcpy( endTest, ".dump" );
341			}
342			else if( !strcmp( endTest, ".mdl" ) ){
343			strcpy( endTest, ".dump" );
344			}
345			else{
346			strcat( simnfo->sampleName, ".dump" );
347			}
348			}
349
350			strcpy( simnfo->statusName, inFileName );
351			nameLength = strlen( simnfo->statusName );
352			endTest = &(simnfo->statusName[nameLength - 5]);
353			if( !strcmp( endTest, ".bass" ) ){
354			strcpy( endTest, ".stat" );
355			}
356			else if( !strcmp( endTest, ".BASS" ) ){
357			strcpy( endTest, ".stat" );
358			}
359			else{
360			endTest = &(simnfo->statusName[nameLength - 4]);
361			if( !strcmp( endTest, ".bss" ) ){
362			strcpy( endTest, ".stat" );
363			}
364			else if( !strcmp( endTest, ".mdl" ) ){
365			strcpy( endTest, ".stat" );
366			}
367			else{
368			strcat( simnfo->statusName, ".stat" );
369			}
370			}
371
372			#ifdef IS_MPI
373			}
374			#endif // is_mpi
375	chuckv	124
376	mmeineke	10	// set the status, sample, and themal kick times
377
378			if( the_globals->haveSampleTime() ){
379	chuckv	124	simnfo->sampleTime = the_globals->getSampleTime();
380	mmeineke	10	simnfo->statusTime = simnfo->sampleTime;
381			simnfo->thermalTime = simnfo->sampleTime;
382			}
383			else{
384	chuckv	124	simnfo->sampleTime = the_globals->getRunTime();
385	mmeineke	10	simnfo->statusTime = simnfo->sampleTime;
386			simnfo->thermalTime = simnfo->sampleTime;
387			}
388
389			if( the_globals->haveStatusTime() ){
390			simnfo->statusTime = the_globals->getStatusTime();
391			}
392
393			if( the_globals->haveThermalTime() ){
394			simnfo->thermalTime = the_globals->getThermalTime();
395			}
396
397			// check for the temperature set flag
398
399			if( the_globals->haveTempSet() ) simnfo->setTemp = the_globals->getTempSet();
400	chuckv	124
401
402	mmeineke	10	// make the longe range forces and the integrator
403	chuckv	124
404	mmeineke	10	new AllLong( simnfo );
405	chuckv	124
406	mmeineke	10	if( !strcmp( force_field, "TraPPE" ) ) new Verlet( *simnfo );
407			if( !strcmp( force_field, "DipoleTest" ) ) new Symplectic( simnfo );
408			if( !strcmp( force_field, "TraPPE_Ex" ) ) new Symplectic( simnfo );
409			}
410
411			void SimSetup::makeAtoms( void ){
412	chuckv	124
413	mmeineke	10	int i, j, k, index;
414			double ux, uy, uz, uSqr, u;
415			AtomStamp* current_atom;
416			DirectionalAtom* dAtom;
417	mmeineke	117	int molIndex, molStart, molEnd, nMemb;
418	mmeineke	10
419	chuckv	124
420	mmeineke	117	molIndex = 0;
421	mmeineke	10	index = 0;
422			for( i=0; i<n_components; i++ ){
423	chuckv	124
424	mmeineke	10	for( j=0; j<components_nmol[i]; j++ ){
425	chuckv	124
426	mmeineke	117	molStart = index;
427			nMemb = comp_stamps[i]->getNAtoms();
428	mmeineke	10	for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
429	chuckv	124
430	mmeineke	10	current_atom = comp_stamps[i]->getAtom( k );
431	chuckv	124	if( current_atom->haveOrientation() ){
432	mmeineke	10
433	mmeineke	145	dAtom = new DirectionalAtom(index);
434	mmeineke	10	simnfo->n_oriented++;
435			the_atoms[index] = dAtom;
436	chuckv	124
437	mmeineke	10	ux = current_atom->getOrntX();
438			uy = current_atom->getOrntY();
439			uz = current_atom->getOrntZ();
440	chuckv	124
441	mmeineke	10	uSqr = (ux * ux) + (uy * uy) + (uz * uz);
442	chuckv	124
443	mmeineke	10	u = sqrt( uSqr );
444			ux = ux / u;
445			uy = uy / u;
446			uz = uz / u;
447	chuckv	124
448	mmeineke	10	dAtom->setSUx( ux );
449			dAtom->setSUy( uy );
450			dAtom->setSUz( uz );
451			}
452			else{
453	mmeineke	145	the_atoms[index] = new GeneralAtom(index);
454	mmeineke	10	}
455			the_atoms[index]->setType( current_atom->getType() );
456			the_atoms[index]->setIndex( index );
457	chuckv	124
458	mmeineke	10	// increment the index and repeat;
459			index++;
460			}
461	chuckv	124
462	mmeineke	117	molEnd = index -1;
463			the_molecules[molIndex].setNMembers( nMemb );
464			the_molecules[molIndex].setStartAtom( molStart );
465			the_molecules[molIndex].setEndAtom( molEnd );
466			molIndex++;
467
468	mmeineke	10	}
469			}
470	chuckv	124
471	mmeineke	10	the_ff->initializeAtoms();
472			}
473
474			void SimSetup::makeBonds( void ){
475
476			int i, j, k, index, offset;
477			bond_pair* the_bonds;
478			BondStamp* current_bond;
479
480			the_bonds = new bond_pair[tot_bonds];
481			index = 0;
482			offset = 0;
483			for( i=0; i<n_components; i++ ){
484	chuckv	124
485	mmeineke	10	for( j=0; j<components_nmol[i]; j++ ){
486	chuckv	124
487	mmeineke	10	for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
488	chuckv	124
489	mmeineke	10	current_bond = comp_stamps[i]->getBond( k );
490			the_bonds[index].a = current_bond->getA() + offset;
491			the_bonds[index].b = current_bond->getB() + offset;
492
493			the_excludes[index].i = the_bonds[index].a;
494			the_excludes[index].j = the_bonds[index].b;
495
496			// increment the index and repeat;
497			index++;
498			}
499			offset += comp_stamps[i]->getNAtoms();
500			}
501			}
502	chuckv	124
503	mmeineke	10	the_ff->initializeBonds( the_bonds );
504			}
505
506			void SimSetup::makeBends( void ){
507
508			int i, j, k, index, offset;
509			bend_set* the_bends;
510			BendStamp* current_bend;
511
512			the_bends = new bend_set[tot_bends];
513			index = 0;
514			offset = 0;
515			for( i=0; i<n_components; i++ ){
516	chuckv	124
517	mmeineke	10	for( j=0; j<components_nmol[i]; j++ ){
518	chuckv	124
519	mmeineke	10	for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
520	chuckv	124
521	mmeineke	10	current_bend = comp_stamps[i]->getBend( k );
522			the_bends[index].a = current_bend->getA() + offset;
523			the_bends[index].b = current_bend->getB() + offset;
524			the_bends[index].c = current_bend->getC() + offset;
525
526			the_excludes[index + tot_bonds].i = the_bends[index].a;
527			the_excludes[index + tot_bonds].j = the_bends[index].c;
528
529			// increment the index and repeat;
530			index++;
531			}
532			offset += comp_stamps[i]->getNAtoms();
533			}
534			}
535	chuckv	124
536	mmeineke	10	the_ff->initializeBends( the_bends );
537			}
538
539			void SimSetup::makeTorsions( void ){
540
541			int i, j, k, index, offset;
542			torsion_set* the_torsions;
543			TorsionStamp* current_torsion;
544
545			the_torsions = new torsion_set[tot_torsions];
546			index = 0;
547			offset = 0;
548			for( i=0; i<n_components; i++ ){
549	chuckv	124
550	mmeineke	10	for( j=0; j<components_nmol[i]; j++ ){
551	chuckv	124
552	mmeineke	10	for( k=0; k<comp_stamps[i]->getNTorsions(); k++ ){
553	chuckv	124
554	mmeineke	10	current_torsion = comp_stamps[i]->getTorsion( k );
555			the_torsions[index].a = current_torsion->getA() + offset;
556			the_torsions[index].b = current_torsion->getB() + offset;
557			the_torsions[index].c = current_torsion->getC() + offset;
558			the_torsions[index].d = current_torsion->getD() + offset;
559
560			the_excludes[index + tot_bonds + tot_bends].i = the_torsions[index].a;
561			the_excludes[index + tot_bonds + tot_bends].j = the_torsions[index].d;
562
563			// increment the index and repeat;
564			index++;
565			}
566			offset += comp_stamps[i]->getNAtoms();
567			}
568			}
569	chuckv	124
570	mmeineke	10	the_ff->initializeTorsions( the_torsions );
571			}
572
573			void SimSetup::initFromBass( void ){
574
575			int i, j, k;
576			int n_cells;
577			double cellx, celly, cellz;
578			double temp1, temp2, temp3;
579			int n_per_extra;
580			int n_extra;
581			int have_extra, done;
582
583			temp1 = (double)tot_nmol / 4.0;
584			temp2 = pow( temp1, ( 1.0 / 3.0 ) );
585			temp3 = ceil( temp2 );
586
587			have_extra =0;
588			if( temp2 < temp3 ){ // we have a non-complete lattice
589			have_extra =1;
590
591			n_cells = (int)temp3 - 1;
592			cellx = simnfo->box_x / temp3;
593			celly = simnfo->box_y / temp3;
594			cellz = simnfo->box_z / temp3;
595			n_extra = tot_nmol - ( 4 * n_cells * n_cells * n_cells );
596			temp1 = ((double)n_extra) / ( pow( temp3, 3.0 ) - pow( n_cells, 3.0 ) );
597			n_per_extra = (int)ceil( temp1 );
598
599			if( n_per_extra > 4){
600			std::cerr << "THere has been an error in constructing the non-complete lattice.\n";
601			exit(8);
602			}
603			}
604			else{
605			n_cells = (int)temp3;
606			cellx = simnfo->box_x / temp3;
607			celly = simnfo->box_y / temp3;
608			cellz = simnfo->box_z / temp3;
609			}
610	chuckv	124
611	mmeineke	10	current_mol = 0;
612			current_comp_mol = 0;
613			current_comp = 0;
614			current_atom_ndx = 0;
615	chuckv	124
616	mmeineke	10	for( i=0; i < n_cells ; i++ ){
617			for( j=0; j < n_cells; j++ ){
618			for( k=0; k < n_cells; k++ ){
619	chuckv	124
620	mmeineke	10	makeElement( i * cellx,
621			j * celly,
622			k * cellz );
623	chuckv	124
624	mmeineke	10	makeElement( i * cellx + 0.5 * cellx,
625			j * celly + 0.5 * celly,
626			k * cellz );
627	chuckv	124
628	mmeineke	10	makeElement( i * cellx,
629			j * celly + 0.5 * celly,
630			k * cellz + 0.5 * cellz );
631	chuckv	124
632	mmeineke	10	makeElement( i * cellx + 0.5 * cellx,
633			j * celly,
634			k * cellz + 0.5 * cellz );
635			}
636			}
637			}
638
639			if( have_extra ){
640			done = 0;
641	chuckv	124
642	mmeineke	10	int start_ndx;
643			for( i=0; i < (n_cells+1) && !done; i++ ){
644			for( j=0; j < (n_cells+1) && !done; j++ ){
645	chuckv	124
646	mmeineke	10	if( i < n_cells ){
647	chuckv	124
648	mmeineke	10	if( j < n_cells ){
649			start_ndx = n_cells;
650			}
651			else start_ndx = 0;
652			}
653			else start_ndx = 0;
654	chuckv	124
655	mmeineke	10	for( k=start_ndx; k < (n_cells+1) && !done; k++ ){
656	chuckv	124
657	mmeineke	10	makeElement( i * cellx,
658			j * celly,
659			k * cellz );
660			done = ( current_mol >= tot_nmol );
661	chuckv	124
662	mmeineke	10	if( !done && n_per_extra > 1 ){
663			makeElement( i * cellx + 0.5 * cellx,
664			j * celly + 0.5 * celly,
665			k * cellz );
666			done = ( current_mol >= tot_nmol );
667			}
668	chuckv	124
669	mmeineke	10	if( !done && n_per_extra > 2){
670			makeElement( i * cellx,
671			j * celly + 0.5 * celly,
672			k * cellz + 0.5 * cellz );
673			done = ( current_mol >= tot_nmol );
674			}
675	chuckv	124
676	mmeineke	10	if( !done && n_per_extra > 3){
677			makeElement( i * cellx + 0.5 * cellx,
678			j * celly,
679			k * cellz + 0.5 * cellz );
680			done = ( current_mol >= tot_nmol );
681			}
682			}
683			}
684			}
685			}
686	chuckv	124
687
688	mmeineke	10	for( i=0; i<simnfo->n_atoms; i++ ){
689			simnfo->atoms[i]->set_vx( 0.0 );
690			simnfo->atoms[i]->set_vy( 0.0 );
691			simnfo->atoms[i]->set_vz( 0.0 );
692			}
693			}
694
695			void SimSetup::makeElement( double x, double y, double z ){
696
697			int k;
698			AtomStamp* current_atom;
699			DirectionalAtom* dAtom;
700			double rotMat[3][3];
701
702			for( k=0; k<comp_stamps[current_comp]->getNAtoms(); k++ ){
703	chuckv	124
704	mmeineke	10	current_atom = comp_stamps[current_comp]->getAtom( k );
705			if( !current_atom->havePosition() ){
706			std::cerr << "Component " << comp_stamps[current_comp]->getID()
707			<< ", atom " << current_atom->getType()
708			<< " does not have a position specified.\n"
709			<< "The initialization routine is unable to give a start"
710			<< " position.\n";
711			exit(8);
712			}
713	chuckv	124
714	mmeineke	10	the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );
715			the_atoms[current_atom_ndx]->setY( y + current_atom->getPosY() );
716			the_atoms[current_atom_ndx]->setZ( z + current_atom->getPosZ() );
717	chuckv	124
718	mmeineke	10	if( the_atoms[current_atom_ndx]->isDirectional() ){
719	chuckv	124
720	mmeineke	10	dAtom = (DirectionalAtom *)the_atoms[current_atom_ndx];
721	chuckv	124
722	mmeineke	10	rotMat[0][0] = 1.0;
723			rotMat[0][1] = 0.0;
724			rotMat[0][2] = 0.0;
725
726			rotMat[1][0] = 0.0;
727			rotMat[1][1] = 1.0;
728			rotMat[1][2] = 0.0;
729
730			rotMat[2][0] = 0.0;
731			rotMat[2][1] = 0.0;
732			rotMat[2][2] = 1.0;
733
734			dAtom->setA( rotMat );
735			}
736
737			current_atom_ndx++;
738			}
739	chuckv	124
740	mmeineke	10	current_mol++;
741			current_comp_mol++;
742
743			if( current_comp_mol >= components_nmol[current_comp] ){
744	chuckv	124
745	mmeineke	10	current_comp_mol = 0;
746			current_comp++;
747			}
748			}