ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/group/trunk/OOPSE/libmdtools/SimSetup.cpp
(Generate patch)

Comparing trunk/OOPSE/libmdtools/SimSetup.cpp (file contents):
Revision 572 by mmeineke, Wed Jul 2 21:26:55 2003 UTC vs.
Revision 690 by mmeineke, Tue Aug 12 21:44:06 2003 UTC

# Line 1 | Line 1
1 + #include <algorithm>
2   #include <cstdlib>
3   #include <iostream>
4   #include <cmath>
5 + #include <string>
6  
7   #include "SimSetup.hpp"
8 + #include "ReadWrite.hpp"
9   #include "parse_me.h"
10   #include "Integrator.hpp"
11   #include "simError.h"
# Line 14 | Line 17
17  
18   // some defines for ensemble and Forcefield  cases
19  
20 < #define NVE_ENS 0
21 < #define NVT_ENS 1
22 < #define NPT_ENS 2
20 > #define NVE_ENS        0
21 > #define NVT_ENS        1
22 > #define NPTi_ENS       2
23 > #define NPTf_ENS       3
24 > #define NPTim_ENS      4
25 > #define NPTfm_ENS      5
26  
27   #define FF_DUFF 0
28   #define FF_LJ   1
29 + #define FF_EAM  2
30  
31 + using namespace std;
32  
33   SimSetup::SimSetup(){
34 +  
35 +  isInfoArray = 0;
36 +  nInfo = 1;
37 +  
38    stamps = new MakeStamps();
39    globals = new Globals();
40    
41 +  
42   #ifdef IS_MPI
43    strcpy( checkPointMsg, "SimSetup creation successful" );
44    MPIcheckPoint();
# Line 37 | Line 50 | void SimSetup::parseFile( char* fileName ){
50    delete globals;
51   }
52  
53 + void SimSetup::setSimInfo( SimInfo* the_info, int theNinfo ) {
54 +    info = the_info;
55 +    nInfo = theNinfo;
56 +    isInfoArray = 1;
57 + }
58 +
59 +
60   void SimSetup::parseFile( char* fileName ){
61  
62   #ifdef IS_MPI
# Line 72 | Line 92 | void SimSetup::createSim( void ){
92  
93   #endif // is_mpi
94  
95 < void SimSetup::createSim( void ){
95 > void SimSetup::createSim(void){
96  
77  MakeStamps *the_stamps;
78  Globals* the_globals;
97    int i, j, k, globalAtomIndex;
98    
99 <  int ensembleCase;
100 <  int ffCase;
99 >  // gather all of the information from the Bass file
100 >
101 >  gatherInfo();
102 >
103 >  // creation of complex system objects
104 >
105 >  sysObjectsCreation();
106 >
107 >  // check on the post processing info
108 >
109 >  finalInfoCheck();
110 >
111 >  // initialize the system coordinates
112 >
113 >  if( !isInfoArray ) initSystemCoords();  
114 >
115 >  // make the output filenames
116 >
117 >  makeOutNames();
118 >  
119 >  // make the integrator
120    
121 <  ensembleCase = -1;
122 <  ffCase = -1;
121 >  makeIntegrator();
122 >  
123 > #ifdef IS_MPI
124 >  mpiSim->mpiRefresh();
125 > #endif
126  
127 <  // get the stamps and globals;
88 <  the_stamps = stamps;
89 <  the_globals = globals;
127 >  // initialize the Fortran
128  
129 <  // set the easy ones first
92 <  simnfo->target_temp = the_globals->getTargetTemp();
93 <  simnfo->dt = the_globals->getDt();
94 <  simnfo->run_time = the_globals->getRunTime();
129 >  initFortran();
130  
96  // get the ones we know are there, yet still may need some work.
97  n_components = the_globals->getNComponents();
98  strcpy( force_field, the_globals->getForceField() );
131  
132 +
133 + }
134 +
135 +
136 + void SimSetup::makeMolecules( void ){
137 +
138 +  int k,l;
139 +  int i, j, exI, exJ, tempEx, stampID, atomOffset, excludeOffset;
140 +  molInit molInfo;
141 +  DirectionalAtom* dAtom;
142 +  LinkedAssign* extras;
143 +  LinkedAssign* current_extra;
144 +  AtomStamp* currentAtom;
145 +  BondStamp* currentBond;
146 +  BendStamp* currentBend;
147 +  TorsionStamp* currentTorsion;
148 +
149 +  bond_pair* theBonds;
150 +  bend_set* theBends;
151 +  torsion_set* theTorsions;
152 +
153 +  
154 +  //init the forceField paramters
155 +
156 +  the_ff->readParams();
157 +
158 +  
159 +  // init the atoms
160 +
161 +  double ux, uy, uz, u, uSqr;
162 +  
163 +  for(k=0; k<nInfo; k++){
164 +    
165 +    the_ff->setSimInfo( &(info[k]) );
166 +
167 +    atomOffset = 0;
168 +    excludeOffset = 0;
169 +    for(i=0; i<info[k].n_mol; i++){
170 +    
171 +      stampID = info[k].molecules[i].getStampID();
172 +
173 +      molInfo.nAtoms    = comp_stamps[stampID]->getNAtoms();
174 +      molInfo.nBonds    = comp_stamps[stampID]->getNBonds();
175 +      molInfo.nBends    = comp_stamps[stampID]->getNBends();
176 +      molInfo.nTorsions = comp_stamps[stampID]->getNTorsions();
177 +      molInfo.nExcludes = molInfo.nBonds + molInfo.nBends + molInfo.nTorsions;
178 +      
179 +      molInfo.myAtoms = &(info[k].atoms[atomOffset]);
180 +      molInfo.myExcludes = &(info[k].excludes[excludeOffset]);
181 +      molInfo.myBonds = new Bond*[molInfo.nBonds];
182 +      molInfo.myBends = new Bend*[molInfo.nBends];
183 +      molInfo.myTorsions = new Torsion*[molInfo.nTorsions];
184 +
185 +      theBonds = new bond_pair[molInfo.nBonds];
186 +      theBends = new bend_set[molInfo.nBends];
187 +      theTorsions = new torsion_set[molInfo.nTorsions];
188 +    
189 +      // make the Atoms
190 +    
191 +      for(j=0; j<molInfo.nAtoms; j++){
192 +        
193 +        currentAtom = comp_stamps[stampID]->getAtom( j );
194 +        if( currentAtom->haveOrientation() ){
195 +          
196 +          dAtom = new DirectionalAtom( (j + atomOffset),
197 +                                       info[k].getConfiguration() );
198 +          info[k].n_oriented++;
199 +          molInfo.myAtoms[j] = dAtom;
200 +          
201 +          ux = currentAtom->getOrntX();
202 +          uy = currentAtom->getOrntY();
203 +          uz = currentAtom->getOrntZ();
204 +          
205 +          uSqr = (ux * ux) + (uy * uy) + (uz * uz);
206 +          
207 +          u = sqrt( uSqr );
208 +          ux = ux / u;
209 +          uy = uy / u;
210 +          uz = uz / u;
211 +          
212 +          dAtom->setSUx( ux );
213 +          dAtom->setSUy( uy );
214 +          dAtom->setSUz( uz );
215 +        }
216 +        else{
217 +          molInfo.myAtoms[j] = new GeneralAtom( (j + atomOffset),
218 +                                                info[k].getConfiguration() );
219 +        }
220 +        molInfo.myAtoms[j]->setType( currentAtom->getType() );
221 +    
222 + #ifdef IS_MPI
223 +      
224 +        molInfo.myAtoms[j]->setGlobalIndex( globalIndex[j+atomOffset] );
225 +      
226 + #endif // is_mpi
227 +      }
228 +    
229 +    // make the bonds
230 +      for(j=0; j<molInfo.nBonds; j++){
231 +      
232 +        currentBond = comp_stamps[stampID]->getBond( j );
233 +        theBonds[j].a = currentBond->getA() + atomOffset;
234 +        theBonds[j].b = currentBond->getB() + atomOffset;
235 +        
236 +        exI = theBonds[j].a;
237 +        exJ = theBonds[j].b;
238 +        
239 +        // exclude_I must always be the smaller of the pair
240 +        if( exI > exJ ){
241 +          tempEx = exI;
242 +          exI = exJ;
243 +          exJ = tempEx;
244 +        }
245 + #ifdef IS_MPI
246 +        tempEx = exI;
247 +        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
248 +        tempEx = exJ;
249 +        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
250 +        
251 +        info[k].excludes[j+excludeOffset]->setPair( exI, exJ );
252 + #else  // isn't MPI
253 +        
254 +        info[k].excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
255 + #endif  //is_mpi
256 +      }
257 +      excludeOffset += molInfo.nBonds;
258 +      
259 +      //make the bends
260 +      for(j=0; j<molInfo.nBends; j++){
261 +        
262 +        currentBend = comp_stamps[stampID]->getBend( j );
263 +        theBends[j].a = currentBend->getA() + atomOffset;
264 +        theBends[j].b = currentBend->getB() + atomOffset;
265 +        theBends[j].c = currentBend->getC() + atomOffset;
266 +        
267 +        if( currentBend->haveExtras() ){
268 +          
269 +          extras = currentBend->getExtras();
270 +          current_extra = extras;
271 +          
272 +          while( current_extra != NULL ){
273 +            if( !strcmp( current_extra->getlhs(), "ghostVectorSource" )){
274 +              
275 +              switch( current_extra->getType() ){
276 +                
277 +              case 0:
278 +                theBends[j].ghost =
279 +                  current_extra->getInt() + atomOffset;
280 +                theBends[j].isGhost = 1;
281 +                break;
282 +                
283 +              case 1:
284 +                theBends[j].ghost =
285 +                  (int)current_extra->getDouble() + atomOffset;
286 +                theBends[j].isGhost = 1;
287 +                break;
288 +                
289 +              default:
290 +                sprintf( painCave.errMsg,
291 +                         "SimSetup Error: ghostVectorSource was neither a "
292 +                         "double nor an int.\n"
293 +                         "-->Bend[%d] in %s\n",
294 +                         j, comp_stamps[stampID]->getID() );
295 +                painCave.isFatal = 1;
296 +                simError();
297 +              }
298 +            }
299 +            
300 +            else{
301 +              
302 +              sprintf( painCave.errMsg,
303 +                       "SimSetup Error: unhandled bend assignment:\n"
304 +                       "    -->%s in Bend[%d] in %s\n",
305 +                       current_extra->getlhs(),
306 +                       j, comp_stamps[stampID]->getID() );
307 +              painCave.isFatal = 1;
308 +              simError();
309 +            }
310 +            
311 +            current_extra = current_extra->getNext();
312 +          }
313 +        }
314 +        
315 +        if( !theBends[j].isGhost ){
316 +          
317 +          exI = theBends[j].a;
318 +          exJ = theBends[j].c;
319 +        }
320 +        else{
321 +          
322 +          exI = theBends[j].a;
323 +          exJ = theBends[j].b;
324 +        }
325 +        
326 +        // exclude_I must always be the smaller of the pair
327 +        if( exI > exJ ){
328 +          tempEx = exI;
329 +          exI = exJ;
330 +          exJ = tempEx;
331 +        }
332 + #ifdef IS_MPI
333 +        tempEx = exI;
334 +        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
335 +        tempEx = exJ;
336 +        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
337 +      
338 +        info[k].excludes[j+excludeOffset]->setPair( exI, exJ );
339 + #else  // isn't MPI
340 +        info[k].excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
341 + #endif  //is_mpi
342 +      }
343 +      excludeOffset += molInfo.nBends;
344 +      
345 +      for(j=0; j<molInfo.nTorsions; j++){
346 +        
347 +        currentTorsion = comp_stamps[stampID]->getTorsion( j );
348 +        theTorsions[j].a = currentTorsion->getA() + atomOffset;
349 +        theTorsions[j].b = currentTorsion->getB() + atomOffset;
350 +        theTorsions[j].c = currentTorsion->getC() + atomOffset;
351 +        theTorsions[j].d = currentTorsion->getD() + atomOffset;
352 +        
353 +        exI = theTorsions[j].a;
354 +        exJ = theTorsions[j].d;
355 +        
356 +        // exclude_I must always be the smaller of the pair
357 +        if( exI > exJ ){
358 +          tempEx = exI;
359 +          exI = exJ;
360 +          exJ = tempEx;
361 +        }
362 + #ifdef IS_MPI
363 +        tempEx = exI;
364 +        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
365 +        tempEx = exJ;
366 +        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
367 +        
368 +        info[k].excludes[j+excludeOffset]->setPair( exI, exJ );
369 + #else  // isn't MPI
370 +        info[k].excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
371 + #endif  //is_mpi
372 +      }
373 +      excludeOffset += molInfo.nTorsions;
374 +      
375 +      
376 +      // send the arrays off to the forceField for init.
377 +      
378 +      the_ff->initializeAtoms( molInfo.nAtoms, molInfo.myAtoms );
379 +      the_ff->initializeBonds( molInfo.nBonds, molInfo.myBonds, theBonds );
380 +      the_ff->initializeBends( molInfo.nBends, molInfo.myBends, theBends );
381 +      the_ff->initializeTorsions( molInfo.nTorsions, molInfo.myTorsions, theTorsions );
382 +      
383 +      
384 +      info[k].molecules[i].initialize( molInfo );
385 +
386 +      
387 +      atomOffset += molInfo.nAtoms;
388 +      delete[] theBonds;
389 +      delete[] theBends;
390 +      delete[] theTorsions;
391 +    }
392 +  }
393 +  
394 + #ifdef IS_MPI
395 +  sprintf( checkPointMsg, "all molecules initialized succesfully" );
396 +  MPIcheckPoint();
397 + #endif // is_mpi
398 +  
399 +  // clean up the forcefield
400 +
401 +  the_ff->calcRcut();
402 +  the_ff->cleanMe();
403 +  
404 + }
405 +
406 + void SimSetup::initFromBass( void ){
407 +
408 +  int i, j, k;
409 +  int n_cells;
410 +  double cellx, celly, cellz;
411 +  double temp1, temp2, temp3;
412 +  int n_per_extra;
413 +  int n_extra;
414 +  int have_extra, done;
415 +
416 +  double vel[3];
417 +  vel[0] = 0.0;
418 +  vel[1] = 0.0;
419 +  vel[2] = 0.0;
420 +
421 +  temp1 = (double)tot_nmol / 4.0;
422 +  temp2 = pow( temp1, ( 1.0 / 3.0 ) );
423 +  temp3 = ceil( temp2 );
424 +
425 +  have_extra =0;
426 +  if( temp2 < temp3 ){ // we have a non-complete lattice
427 +    have_extra =1;
428 +
429 +    n_cells = (int)temp3 - 1;
430 +    cellx = info[0].boxL[0] / temp3;
431 +    celly = info[0].boxL[1] / temp3;
432 +    cellz = info[0].boxL[2] / temp3;
433 +    n_extra = tot_nmol - ( 4 * n_cells * n_cells * n_cells );
434 +    temp1 = ((double)n_extra) / ( pow( temp3, 3.0 ) - pow( n_cells, 3.0 ) );
435 +    n_per_extra = (int)ceil( temp1 );
436 +
437 +    if( n_per_extra > 4){
438 +      sprintf( painCave.errMsg,
439 +               "SimSetup error. There has been an error in constructing"
440 +               " the non-complete lattice.\n" );
441 +      painCave.isFatal = 1;
442 +      simError();
443 +    }
444 +  }
445 +  else{
446 +    n_cells = (int)temp3;
447 +    cellx = info[0].boxL[0] / temp3;
448 +    celly = info[0].boxL[1] / temp3;
449 +    cellz = info[0].boxL[2] / temp3;
450 +  }
451 +
452 +  current_mol = 0;
453 +  current_comp_mol = 0;
454 +  current_comp = 0;
455 +  current_atom_ndx = 0;
456 +
457 +  for( i=0; i < n_cells ; i++ ){
458 +    for( j=0; j < n_cells; j++ ){
459 +      for( k=0; k < n_cells; k++ ){
460 +
461 +        makeElement( i * cellx,
462 +                     j * celly,
463 +                     k * cellz );
464 +
465 +        makeElement( i * cellx + 0.5 * cellx,
466 +                     j * celly + 0.5 * celly,
467 +                     k * cellz );
468 +
469 +        makeElement( i * cellx,
470 +                     j * celly + 0.5 * celly,
471 +                     k * cellz + 0.5 * cellz );
472 +
473 +        makeElement( i * cellx + 0.5 * cellx,
474 +                     j * celly,
475 +                     k * cellz + 0.5 * cellz );
476 +      }
477 +    }
478 +  }
479 +
480 +  if( have_extra ){
481 +    done = 0;
482 +
483 +    int start_ndx;
484 +    for( i=0; i < (n_cells+1) && !done; i++ ){
485 +      for( j=0; j < (n_cells+1) && !done; j++ ){
486 +
487 +        if( i < n_cells ){
488 +
489 +          if( j < n_cells ){
490 +            start_ndx = n_cells;
491 +          }
492 +          else start_ndx = 0;
493 +        }
494 +        else start_ndx = 0;
495 +
496 +        for( k=start_ndx; k < (n_cells+1) && !done; k++ ){
497 +
498 +          makeElement( i * cellx,
499 +                       j * celly,
500 +                       k * cellz );
501 +          done = ( current_mol >= tot_nmol );
502 +
503 +          if( !done && n_per_extra > 1 ){
504 +            makeElement( i * cellx + 0.5 * cellx,
505 +                         j * celly + 0.5 * celly,
506 +                         k * cellz );
507 +            done = ( current_mol >= tot_nmol );
508 +          }
509 +
510 +          if( !done && n_per_extra > 2){
511 +            makeElement( i * cellx,
512 +                         j * celly + 0.5 * celly,
513 +                         k * cellz + 0.5 * cellz );
514 +            done = ( current_mol >= tot_nmol );
515 +          }
516 +
517 +          if( !done && n_per_extra > 3){
518 +            makeElement( i * cellx + 0.5 * cellx,
519 +                         j * celly,
520 +                         k * cellz + 0.5 * cellz );
521 +            done = ( current_mol >= tot_nmol );
522 +          }
523 +        }
524 +      }
525 +    }
526 +  }
527 +
528 +  for( i=0; i<info[0].n_atoms; i++ ){
529 +    info[0].atoms[i]->setVel( vel );
530 +  }
531 + }
532 +
533 + void SimSetup::makeElement( double x, double y, double z ){
534 +
535 +  int k;
536 +  AtomStamp* current_atom;
537 +  DirectionalAtom* dAtom;
538 +  double rotMat[3][3];
539 +  double pos[3];
540 +
541 +  for( k=0; k<comp_stamps[current_comp]->getNAtoms(); k++ ){
542 +
543 +    current_atom = comp_stamps[current_comp]->getAtom( k );
544 +    if( !current_atom->havePosition() ){
545 +      sprintf( painCave.errMsg,
546 +               "SimSetup:initFromBass error.\n"
547 +               "\tComponent %s, atom %s does not have a position specified.\n"
548 +               "\tThe initialization routine is unable to give a start"
549 +               " position.\n",
550 +               comp_stamps[current_comp]->getID(),
551 +               current_atom->getType() );
552 +      painCave.isFatal = 1;
553 +      simError();
554 +    }
555 +    
556 +    pos[0] = x + current_atom->getPosX();
557 +    pos[1] = y + current_atom->getPosY();
558 +    pos[2] = z + current_atom->getPosZ();
559 +    
560 +    info[0].atoms[current_atom_ndx]->setPos( pos );
561 +
562 +    if( info[0].atoms[current_atom_ndx]->isDirectional() ){
563 +
564 +      dAtom = (DirectionalAtom *)info[0].atoms[current_atom_ndx];
565 +
566 +      rotMat[0][0] = 1.0;
567 +      rotMat[0][1] = 0.0;
568 +      rotMat[0][2] = 0.0;
569 +
570 +      rotMat[1][0] = 0.0;
571 +      rotMat[1][1] = 1.0;
572 +      rotMat[1][2] = 0.0;
573 +
574 +      rotMat[2][0] = 0.0;
575 +      rotMat[2][1] = 0.0;
576 +      rotMat[2][2] = 1.0;
577 +
578 +      dAtom->setA( rotMat );
579 +    }
580 +
581 +    current_atom_ndx++;
582 +  }
583 +
584 +  current_mol++;
585 +  current_comp_mol++;
586 +
587 +  if( current_comp_mol >= components_nmol[current_comp] ){
588 +
589 +    current_comp_mol = 0;
590 +    current_comp++;
591 +  }
592 + }
593 +
594 +
595 + void SimSetup::gatherInfo( void ){
596 +  int i,j,k;
597 +
598 +  ensembleCase = -1;
599 +  ffCase = -1;
600 +
601 +  // set the easy ones first
602 +
603 +  for( i=0; i<nInfo; i++){
604 +    info[i].target_temp = globals->getTargetTemp();
605 +    info[i].dt = globals->getDt();
606 +    info[i].run_time = globals->getRunTime();
607 +  }
608 +  n_components = globals->getNComponents();
609 +
610 +
611 +  // get the forceField
612 +
613 +  strcpy( force_field, globals->getForceField() );
614 +
615    if( !strcasecmp( force_field, "DUFF" )) ffCase = FF_DUFF;
616    else if( !strcasecmp( force_field, "LJ" )) ffCase = FF_LJ;
617 +  else if( !strcasecmp( force_field, "EAM" )) ffCase = FF_EAM;
618    else{
619      sprintf( painCave.errMsg,
620               "SimSetup Error. Unrecognized force field -> %s\n",
# Line 107 | Line 623 | void SimSetup::createSim( void ){
623      simError();
624    }
625  
626 <  // get the ensemble:
111 <  strcpy( ensemble, the_globals->getEnsemble() );
626 >  // get the ensemble
627  
628 +  strcpy( ensemble, globals->getEnsemble() );
629 +
630    if( !strcasecmp( ensemble, "NVE" ))      ensembleCase = NVE_ENS;
631    else if( !strcasecmp( ensemble, "NVT" )) ensembleCase = NVT_ENS;
632 <  else if( !strcasecmp( ensemble, "NPT" )) ensembleCase = NPT_ENS;
632 >  else if( !strcasecmp( ensemble, "NPTi" ) || !strcasecmp( ensemble, "NPT") )
633 >    ensembleCase = NPTi_ENS;
634 >  else if( !strcasecmp( ensemble, "NPTf" )) ensembleCase = NPTf_ENS;
635 >  else if( !strcasecmp( ensemble, "NPTim" )) ensembleCase = NPTim_ENS;
636 >  else if( !strcasecmp( ensemble, "NPTfm" )) ensembleCase = NPTfm_ENS;
637    else{
638      sprintf( painCave.errMsg,
639               "SimSetup Warning. Unrecognized Ensemble -> %s, "
# Line 123 | Line 644 | void SimSetup::createSim( void ){
644      strcpy( ensemble, "NVE" );
645      ensembleCase = NVE_ENS;
646    }  
647 <  strcpy( simnfo->ensemble, ensemble );
647 >  
648 >  for(i=0; i<nInfo; i++){
649 >    
650 >    strcpy( info[i].ensemble, ensemble );
651  
652 +    // get the mixing rule
653  
654 < //   if( !strcasecmp( ensemble, "NPT" ) ) {
655 < //     the_extendedsystem = new ExtendedSystem( simnfo );
131 < //     the_extendedsystem->setTargetTemp(the_globals->getTargetTemp());
132 < //     if (the_globals->haveTargetPressure())
133 < //       the_extendedsystem->setTargetPressure(the_globals->getTargetPressure());
134 < //     else {
135 < //       sprintf( painCave.errMsg,
136 < //                "SimSetup error: If you use the constant pressure\n"
137 < //                "    ensemble, you must set targetPressure.\n"
138 < //                "    This was found in the BASS file.\n");
139 < //       painCave.isFatal = 1;
140 < //       simError();
141 < //     }
142 <
143 < //     if (the_globals->haveTauThermostat())
144 < //       the_extendedsystem->setTauThermostat(the_globals->getTauThermostat());
145 < //     else if (the_globals->haveQmass())
146 < //       the_extendedsystem->setQmass(the_globals->getQmass());
147 < //     else {
148 < //       sprintf( painCave.errMsg,
149 < //                "SimSetup error: If you use one of the constant temperature\n"
150 < //                "    ensembles, you must set either tauThermostat or qMass.\n"
151 < //                "    Neither of these was found in the BASS file.\n");
152 < //       painCave.isFatal = 1;
153 < //       simError();
154 < //     }
155 <
156 < //     if (the_globals->haveTauBarostat())
157 < //       the_extendedsystem->setTauBarostat(the_globals->getTauBarostat());
158 < //     else {
159 < //       sprintf( painCave.errMsg,
160 < //                "SimSetup error: If you use the constant pressure\n"
161 < //                "    ensemble, you must set tauBarostat.\n"
162 < //                "    This was found in the BASS file.\n");
163 < //       painCave.isFatal = 1;
164 < //       simError();
165 < //     }
166 <
167 < //   } else if ( !strcasecmp( ensemble, "NVT") ) {
168 < //     the_extendedsystem = new ExtendedSystem( simnfo );
169 < //     the_extendedsystem->setTargetTemp(the_globals->getTargetTemp());
170 <
171 < //     if (the_globals->haveTauThermostat())
172 < //       the_extendedsystem->setTauThermostat(the_globals->getTauThermostat());
173 < //     else if (the_globals->haveQmass())
174 < //       the_extendedsystem->setQmass(the_globals->getQmass());
175 < //     else {
176 < //       sprintf( painCave.errMsg,
177 < //                "SimSetup error: If you use one of the constant temperature\n"
178 < //                "    ensembles, you must set either tauThermostat or qMass.\n"
179 < //                "    Neither of these was found in the BASS file.\n");
180 < //       painCave.isFatal = 1;
181 < //       simError();
182 < //     }
183 <
184 <  strcpy( simnfo->mixingRule, the_globals->getMixingRule() );
185 <  simnfo->usePBC = the_globals->getPBC();
186 <          
187 <  int usesDipoles = 0;
188 <  switch( ffCase ){
189 <
190 <  case FF_DUFF:
191 <    the_ff = new DUFF();
192 <    usesDipoles = 1;
193 <    break;
194 <
195 <  case FF_LJ:
196 <    the_ff = new LJFF();
197 <    break;
198 <
199 <  default:
200 <    sprintf( painCave.errMsg,
201 <             "SimSetup Error. Unrecognized force field in case statement.\n");
202 <    painCave.isFatal = 1;
203 <    simError();
654 >    strcpy( info[i].mixingRule, globals->getMixingRule() );
655 >    info[i].usePBC = globals->getPBC();
656    }
657 <
206 < #ifdef IS_MPI
207 <  strcpy( checkPointMsg, "ForceField creation successful" );
208 <  MPIcheckPoint();
209 < #endif // is_mpi
210 <
657 >  
658    // get the components and calculate the tot_nMol and indvidual n_mol
659 <  the_components = the_globals->getComponents();
659 >
660 >  the_components = globals->getComponents();
661    components_nmol = new int[n_components];
214  comp_stamps = new MoleculeStamp*[n_components];
662  
663 <  if( !the_globals->haveNMol() ){
663 >
664 >  if( !globals->haveNMol() ){
665      // we don't have the total number of molecules, so we assume it is
666      // given in each component
667  
# Line 242 | Line 690 | void SimSetup::createSim( void ){
690               " Please give nMol in the components.\n" );
691      painCave.isFatal = 1;
692      simError();
245    
246    
247    //     tot_nmol = the_globals->getNMol();
248    
249    //   //we have the total number of molecules, now we check for molfractions
250    //     for( i=0; i<n_components; i++ ){
251    
252    //       if( !the_components[i]->haveMolFraction() ){
253    
254    //  if( !the_components[i]->haveNMol() ){
255    //    //we have a problem
256    //    std::cerr << "SimSetup error. Neither molFraction nor "
257    //              << " nMol was given in component
258    
259  }
260
261 #ifdef IS_MPI
262  strcpy( checkPointMsg, "Have the number of components" );
263  MPIcheckPoint();
264 #endif // is_mpi
265
266  // make an array of molecule stamps that match the components used.
267  // also extract the used stamps out into a separate linked list
268
269  simnfo->nComponents = n_components;
270  simnfo->componentsNmol = components_nmol;
271  simnfo->compStamps = comp_stamps;
272  simnfo->headStamp = new LinkedMolStamp();
273  
274  char* id;
275  LinkedMolStamp* headStamp = simnfo->headStamp;
276  LinkedMolStamp* currentStamp = NULL;
277  for( i=0; i<n_components; i++ ){
278
279    id = the_components[i]->getType();
280    comp_stamps[i] = NULL;
281    
282    // check to make sure the component isn't already in the list
283
284    comp_stamps[i] = headStamp->match( id );
285    if( comp_stamps[i] == NULL ){
286      
287      // extract the component from the list;
288      
289      currentStamp = the_stamps->extractMolStamp( id );
290      if( currentStamp == NULL ){
291        sprintf( painCave.errMsg,
292                 "SimSetup error: Component \"%s\" was not found in the "
293                 "list of declared molecules\n",
294                 id );
295        painCave.isFatal = 1;
296        simError();
297      }
298      
299      headStamp->add( currentStamp );
300      comp_stamps[i] = headStamp->match( id );
301    }
302  }
303
304 #ifdef IS_MPI
305  strcpy( checkPointMsg, "Component stamps successfully extracted\n" );
306  MPIcheckPoint();
307 #endif // is_mpi
308  
309
310
311
312  // caclulate the number of atoms, bonds, bends and torsions
313
314  tot_atoms = 0;
315  tot_bonds = 0;
316  tot_bends = 0;
317  tot_torsions = 0;
318  for( i=0; i<n_components; i++ ){
319    
320    tot_atoms +=    components_nmol[i] * comp_stamps[i]->getNAtoms();
321    tot_bonds +=    components_nmol[i] * comp_stamps[i]->getNBonds();
322    tot_bends +=    components_nmol[i] * comp_stamps[i]->getNBends();
323    tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
324  }
325
326  tot_SRI = tot_bonds + tot_bends + tot_torsions;
327
328  simnfo->n_atoms = tot_atoms;
329  simnfo->n_bonds = tot_bonds;
330  simnfo->n_bends = tot_bends;
331  simnfo->n_torsions = tot_torsions;
332  simnfo->n_SRI = tot_SRI;
333  simnfo->n_mol = tot_nmol;
334  
335  simnfo->molMembershipArray = new int[tot_atoms];
336
337 #ifdef IS_MPI
338
339  // divide the molecules among processors here.
340  
341  mpiSim = new mpiSimulation( simnfo );
342  
343  globalIndex = mpiSim->divideLabor();
344
345  // set up the local variables
346  
347  int localMol, allMol;
348  int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
349
350  int* mol2proc = mpiSim->getMolToProcMap();
351  int* molCompType = mpiSim->getMolComponentType();
352  
353  allMol = 0;
354  localMol = 0;
355  local_atoms = 0;
356  local_bonds = 0;
357  local_bends = 0;
358  local_torsions = 0;
359  globalAtomIndex = 0;
360
361
362  for( i=0; i<n_components; i++ ){
363
364    for( j=0; j<components_nmol[i]; j++ ){
365      
366      if( mol2proc[allMol] == worldRank ){
367        
368        local_atoms +=    comp_stamps[i]->getNAtoms();
369        local_bonds +=    comp_stamps[i]->getNBonds();
370        local_bends +=    comp_stamps[i]->getNBends();
371        local_torsions += comp_stamps[i]->getNTorsions();
372        localMol++;
373      }      
374      for (k = 0; k < comp_stamps[i]->getNAtoms(); k++) {
375        simnfo->molMembershipArray[globalAtomIndex] = allMol;
376        globalAtomIndex++;
377      }
378
379      allMol++;      
380    }
381  }
382  local_SRI = local_bonds + local_bends + local_torsions;
383  
384  simnfo->n_atoms = mpiSim->getMyNlocal();  
385  
386  if( local_atoms != simnfo->n_atoms ){
387    sprintf( painCave.errMsg,
388             "SimSetup error: mpiSim's localAtom (%d) and SimSetup's"
389             " localAtom (%d) are not equal.\n",
390             simnfo->n_atoms,
391             local_atoms );
392    painCave.isFatal = 1;
393    simError();
394  }
395
396  simnfo->n_bonds = local_bonds;
397  simnfo->n_bends = local_bends;
398  simnfo->n_torsions = local_torsions;
399  simnfo->n_SRI = local_SRI;
400  simnfo->n_mol = localMol;
401
402  strcpy( checkPointMsg, "Passed nlocal consistency check." );
403  MPIcheckPoint();
404  
405  
406 #endif // is_mpi
407  
408
409  // create the atom and short range interaction arrays
410
411  Atom::createArrays(simnfo->n_atoms);
412  the_atoms = new Atom*[simnfo->n_atoms];
413  the_molecules = new Molecule[simnfo->n_mol];
414  int molIndex;
415
416  // initialize the molecule's stampID's
417
418 #ifdef IS_MPI
419  
420
421  molIndex = 0;
422  for(i=0; i<mpiSim->getTotNmol(); i++){
423    
424    if(mol2proc[i] == worldRank ){
425      the_molecules[molIndex].setStampID( molCompType[i] );
426      the_molecules[molIndex].setMyIndex( molIndex );
427      the_molecules[molIndex].setGlobalIndex( i );
428      molIndex++;
429    }
693    }
694  
695 < #else // is_mpi
695 >  // set the status, sample, and thermal kick times
696    
697 <  molIndex = 0;
435 <  globalAtomIndex = 0;
436 <  for(i=0; i<n_components; i++){
437 <    for(j=0; j<components_nmol[i]; j++ ){
438 <      the_molecules[molIndex].setStampID( i );
439 <      the_molecules[molIndex].setMyIndex( molIndex );
440 <      the_molecules[molIndex].setGlobalIndex( molIndex );
441 <      for (k = 0; k < comp_stamps[i]->getNAtoms(); k++) {
442 <        simnfo->molMembershipArray[globalAtomIndex] = molIndex;
443 <        globalAtomIndex++;
444 <      }
445 <      molIndex++;
446 <    }
447 <  }
448 <    
697 >  for(i=0; i<nInfo; i++){
698  
699 < #endif // is_mpi
700 <
701 <
702 <  if( simnfo->n_SRI ){
454 <    
455 <    Exclude::createArray(simnfo->n_SRI);
456 <    the_excludes = new Exclude*[simnfo->n_SRI];
457 <    for( int ex=0; ex<simnfo->n_SRI; ex++) the_excludes[ex] = new Exclude(ex);
458 <    simnfo->globalExcludes = new int;
459 <    simnfo->n_exclude = simnfo->n_SRI;
460 <  }
461 <  else{
462 <    
463 <    Exclude::createArray( 1 );
464 <    the_excludes = new Exclude*;
465 <    the_excludes[0] = new Exclude(0);
466 <    the_excludes[0]->setPair( 0,0 );
467 <    simnfo->globalExcludes = new int;
468 <    simnfo->globalExcludes[0] = 0;
469 <    simnfo->n_exclude = 0;
470 <  }
471 <
472 <  // set the arrays into the SimInfo object
473 <
474 <  simnfo->atoms = the_atoms;
475 <  simnfo->molecules = the_molecules;
476 <  simnfo->nGlobalExcludes = 0;
477 <  simnfo->excludes = the_excludes;
478 <
479 <
480 <  // get some of the tricky things that may still be in the globals
481 <
482 <  double boxVector[3];
483 <  if( the_globals->haveBox() ){
484 <    boxVector[0] = the_globals->getBox();
485 <    boxVector[1] = the_globals->getBox();
486 <    boxVector[2] = the_globals->getBox();
487 <    
488 <    simnfo->setBox( boxVector );
489 <  }
490 <  else if( the_globals->haveDensity() ){
491 <
492 <    double vol;
493 <    vol = (double)tot_nmol / the_globals->getDensity();
494 <     boxVector[0] = pow( vol, ( 1.0 / 3.0 ) );
495 <     boxVector[1] = boxVector[0];
496 <     boxVector[2] = boxVector[0];
497 <
498 <    simnfo->setBox( boxVector );
499 <  }
500 <  else{
501 <    if( !the_globals->haveBoxX() ){
502 <      sprintf( painCave.errMsg,
503 <               "SimSetup error, no periodic BoxX size given.\n" );
504 <      painCave.isFatal = 1;
505 <      simError();
699 >    if( globals->haveSampleTime() ){
700 >      info[i].sampleTime = globals->getSampleTime();
701 >      info[i].statusTime = info[i].sampleTime;
702 >      info[i].thermalTime = info[i].sampleTime;
703      }
507    boxVector[0] = the_globals->getBoxX();
508
509    if( !the_globals->haveBoxY() ){
510      sprintf( painCave.errMsg,
511               "SimSetup error, no periodic BoxY size given.\n" );
512      painCave.isFatal = 1;
513      simError();
514    }
515    boxVector[1] = the_globals->getBoxY();
516
517    if( !the_globals->haveBoxZ() ){
518      sprintf( painCave.errMsg,
519               "SimSetup error, no periodic BoxZ size given.\n" );
520      painCave.isFatal = 1;
521      simError();
522    }
523    boxVector[2] = the_globals->getBoxZ();
524
525    simnfo->setBox( boxVector );
526  }
527
528 #ifdef IS_MPI
529  strcpy( checkPointMsg, "Box size set up" );
530  MPIcheckPoint();
531 #endif // is_mpi
532
533
534  // initialize the arrays
535
536  the_ff->setSimInfo( simnfo );
537
538  makeMolecules();
539  simnfo->identArray = new int[simnfo->n_atoms];
540  for(i=0; i<simnfo->n_atoms; i++){
541    simnfo->identArray[i] = the_atoms[i]->getIdent();
542  }
543  
544  if (the_globals->getUseRF() ) {
545    simnfo->useReactionField = 1;
546  
547    if( !the_globals->haveECR() ){
548      sprintf( painCave.errMsg,
549               "SimSetup Warning: using default value of 1/2 the smallest "
550               "box length for the electrostaticCutoffRadius.\n"
551               "I hope you have a very fast processor!\n");
552      painCave.isFatal = 0;
553      simError();
554      double smallest;
555      smallest = simnfo->boxLx;
556      if (simnfo->boxLy <= smallest) smallest = simnfo->boxLy;
557      if (simnfo->boxLz <= smallest) smallest = simnfo->boxLz;
558      simnfo->ecr = 0.5 * smallest;
559    } else {
560      simnfo->ecr        = the_globals->getECR();
561    }
562
563    if( !the_globals->haveEST() ){
564      sprintf( painCave.errMsg,
565               "SimSetup Warning: using default value of 0.05 * the "
566               "electrostaticCutoffRadius for the electrostaticSkinThickness\n"
567               );
568      painCave.isFatal = 0;
569      simError();
570      simnfo->est = 0.05 * simnfo->ecr;
571    } else {
572      simnfo->est        = the_globals->getEST();
573    }
574    
575    if(!the_globals->haveDielectric() ){
576      sprintf( painCave.errMsg,
577               "SimSetup Error: You are trying to use Reaction Field without"
578               "setting a dielectric constant!\n"
579               );
580      painCave.isFatal = 1;
581      simError();
582    }
583    simnfo->dielectric = the_globals->getDielectric();  
584  } else {
585    if (usesDipoles) {
586      
587      if( !the_globals->haveECR() ){
588        sprintf( painCave.errMsg,
589                 "SimSetup Warning: using default value of 1/2 the smallest "
590                 "box length for the electrostaticCutoffRadius.\n"
591                 "I hope you have a very fast processor!\n");
592        painCave.isFatal = 0;
593        simError();
594        double smallest;
595        smallest = simnfo->boxLx;
596        if (simnfo->boxLy <= smallest) smallest = simnfo->boxLy;
597        if (simnfo->boxLz <= smallest) smallest = simnfo->boxLz;
598        simnfo->ecr = 0.5 * smallest;
599      } else {
600        simnfo->ecr        = the_globals->getECR();
601      }
602      
603      if( !the_globals->haveEST() ){
604        sprintf( painCave.errMsg,
605                 "SimSetup Warning: using default value of 5%% of the "
606                 "electrostaticCutoffRadius for the "
607                 "electrostaticSkinThickness\n"
608                 );
609        painCave.isFatal = 0;
610        simError();
611        simnfo->est = 0.05 * simnfo->ecr;
612      } else {
613        simnfo->est        = the_globals->getEST();
614      }
615    }
616  }  
617
618 #ifdef IS_MPI
619  strcpy( checkPointMsg, "electrostatic parameters check out" );
620  MPIcheckPoint();
621 #endif // is_mpi
622
623 if( the_globals->haveInitialConfig() ){
624
625     InitializeFromFile* fileInit;
626 #ifdef IS_MPI // is_mpi
627     if( worldRank == 0 ){
628 #endif //is_mpi
629   fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
630 #ifdef IS_MPI
631     }else fileInit = new InitializeFromFile( NULL );
632 #endif
633   fileInit->read_xyz( simnfo ); // default velocities on
634
635   delete fileInit;
636 }
637 else{
638
639 #ifdef IS_MPI
640
641  // no init from bass
642  
643  sprintf( painCave.errMsg,
644           "Cannot intialize a parallel simulation without an initial configuration file.\n" );
645  painCave.isFatal;
646  simError();
647  
648 #else
649
650  initFromBass();
651
652
653 #endif
654 }
655
656 #ifdef IS_MPI
657  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
658  MPIcheckPoint();
659 #endif // is_mpi
660
661
662  
663
664  
665
666  
667 #ifdef IS_MPI
668  if( worldRank == 0 ){
669 #endif // is_mpi
670    
671    if( the_globals->haveFinalConfig() ){
672      strcpy( simnfo->finalName, the_globals->getFinalConfig() );
673    }
704      else{
705 <      strcpy( simnfo->finalName, inFileName );
706 <      char* endTest;
707 <      int nameLength = strlen( simnfo->finalName );
678 <      endTest = &(simnfo->finalName[nameLength - 5]);
679 <      if( !strcmp( endTest, ".bass" ) ){
680 <        strcpy( endTest, ".eor" );
681 <      }
682 <      else if( !strcmp( endTest, ".BASS" ) ){
683 <        strcpy( endTest, ".eor" );
684 <      }
685 <      else{
686 <        endTest = &(simnfo->finalName[nameLength - 4]);
687 <        if( !strcmp( endTest, ".bss" ) ){
688 <          strcpy( endTest, ".eor" );
689 <        }
690 <        else if( !strcmp( endTest, ".mdl" ) ){
691 <          strcpy( endTest, ".eor" );
692 <        }
693 <        else{
694 <          strcat( simnfo->finalName, ".eor" );
695 <        }
696 <      }
705 >      info[i].sampleTime = globals->getRunTime();
706 >      info[i].statusTime = info[i].sampleTime;
707 >      info[i].thermalTime = info[i].sampleTime;
708      }
709      
710 <    // make the sample and status out names
710 >    if( globals->haveStatusTime() ){
711 >      info[i].statusTime = globals->getStatusTime();
712 >    }
713      
714 <    strcpy( simnfo->sampleName, inFileName );
715 <    char* endTest;
703 <    int nameLength = strlen( simnfo->sampleName );
704 <    endTest = &(simnfo->sampleName[nameLength - 5]);
705 <    if( !strcmp( endTest, ".bass" ) ){
706 <      strcpy( endTest, ".dump" );
714 >    if( globals->haveThermalTime() ){
715 >      info[i].thermalTime = globals->getThermalTime();
716      }
717 <    else if( !strcmp( endTest, ".BASS" ) ){
718 <      strcpy( endTest, ".dump" );
717 >
718 >    // check for the temperature set flag
719 >
720 >    if( globals->haveTempSet() ) info[i].setTemp = globals->getTempSet();
721 >    
722 >    // get some of the tricky things that may still be in the globals
723 >    
724 >    double boxVector[3];
725 >    if( globals->haveBox() ){
726 >      boxVector[0] = globals->getBox();
727 >      boxVector[1] = globals->getBox();
728 >      boxVector[2] = globals->getBox();
729 >      
730 >      info[i].setBox( boxVector );
731      }
732 +    else if( globals->haveDensity() ){
733 +      
734 +      double vol;
735 +      vol = (double)tot_nmol / globals->getDensity();
736 +      boxVector[0] = pow( vol, ( 1.0 / 3.0 ) );
737 +      boxVector[1] = boxVector[0];
738 +      boxVector[2] = boxVector[0];
739 +      
740 +      info[i].setBox( boxVector );
741 +  }
742      else{
743 <      endTest = &(simnfo->sampleName[nameLength - 4]);
744 <      if( !strcmp( endTest, ".bss" ) ){
745 <        strcpy( endTest, ".dump" );
743 >      if( !globals->haveBoxX() ){
744 >        sprintf( painCave.errMsg,
745 >                 "SimSetup error, no periodic BoxX size given.\n" );
746 >        painCave.isFatal = 1;
747 >        simError();
748        }
749 <      else if( !strcmp( endTest, ".mdl" ) ){
750 <        strcpy( endTest, ".dump" );
749 >      boxVector[0] = globals->getBoxX();
750 >      
751 >      if( !globals->haveBoxY() ){
752 >        sprintf( painCave.errMsg,
753 >                 "SimSetup error, no periodic BoxY size given.\n" );
754 >        painCave.isFatal = 1;
755 >        simError();
756        }
757 <      else{
758 <        strcat( simnfo->sampleName, ".dump" );
757 >      boxVector[1] = globals->getBoxY();
758 >      
759 >      if( !globals->haveBoxZ() ){
760 >        sprintf( painCave.errMsg,
761 >                 "SimSetup error, no periodic BoxZ size given.\n" );
762 >        painCave.isFatal = 1;
763 >        simError();
764        }
765 +      boxVector[2] = globals->getBoxZ();
766 +      
767 +      info[i].setBox( boxVector );
768      }
769 +
770 +  }
771      
772 <    strcpy( simnfo->statusName, inFileName );
773 <    nameLength = strlen( simnfo->statusName );
774 <    endTest = &(simnfo->statusName[nameLength - 5]);
775 <    if( !strcmp( endTest, ".bass" ) ){
776 <      strcpy( endTest, ".stat" );
772 > #ifdef IS_MPI
773 >  strcpy( checkPointMsg, "Succesfully gathered all information from Bass\n" );
774 >  MPIcheckPoint();
775 > #endif // is_mpi
776 >
777 > }
778 >
779 >
780 > void SimSetup::finalInfoCheck( void ){
781 >  int index;
782 >  int usesDipoles;
783 >  int i;
784 >
785 >  for(i=0; i<nInfo; i++){
786 >    // check electrostatic parameters
787 >    
788 >    index = 0;
789 >    usesDipoles = 0;
790 >    while( (index < info[i].n_atoms) && !usesDipoles ){
791 >      usesDipoles = (info[i].atoms[index])->hasDipole();
792 >      index++;
793      }
794 <    else if( !strcmp( endTest, ".BASS" ) ){
795 <      strcpy( endTest, ".stat" );
796 <    }
797 <    else{
798 <      endTest = &(simnfo->statusName[nameLength - 4]);
799 <      if( !strcmp( endTest, ".bss" ) ){
800 <        strcpy( endTest, ".stat" );
794 >    
795 > #ifdef IS_MPI
796 >    int myUse = usesDipoles;
797 >    MPI_Allreduce( &myUse, &usesDipoles, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD );
798 > #endif //is_mpi
799 >    
800 >    double theEcr, theEst;
801 >  
802 >    if (globals->getUseRF() ) {
803 >      info[i].useReactionField = 1;
804 >      
805 >      if( !globals->haveECR() ){
806 >        sprintf( painCave.errMsg,
807 >                 "SimSetup Warning: using default value of 1/2 the smallest "
808 >                 "box length for the electrostaticCutoffRadius.\n"
809 >                 "I hope you have a very fast processor!\n");
810 >        painCave.isFatal = 0;
811 >        simError();
812 >        double smallest;
813 >        smallest = info[i].boxL[0];
814 >        if (info[i].boxL[1] <= smallest) smallest = info[i].boxL[1];
815 >        if (info[i].boxL[2] <= smallest) smallest = info[i].boxL[2];
816 >        theEcr = 0.5 * smallest;
817 >      } else {
818 >        theEcr = globals->getECR();
819        }
820 <      else if( !strcmp( endTest, ".mdl" ) ){
821 <        strcpy( endTest, ".stat" );
820 >      
821 >      if( !globals->haveEST() ){
822 >        sprintf( painCave.errMsg,
823 >                 "SimSetup Warning: using default value of 0.05 * the "
824 >                 "electrostaticCutoffRadius for the electrostaticSkinThickness\n"
825 >                 );
826 >        painCave.isFatal = 0;
827 >        simError();
828 >        theEst = 0.05 * theEcr;
829 >      } else {
830 >        theEst= globals->getEST();
831        }
832 <      else{
833 <        strcat( simnfo->statusName, ".stat" );
832 >      
833 >      info[i].setEcr( theEcr, theEst );
834 >      
835 >      if(!globals->haveDielectric() ){
836 >        sprintf( painCave.errMsg,
837 >                 "SimSetup Error: You are trying to use Reaction Field without"
838 >                 "setting a dielectric constant!\n"
839 >                 );
840 >        painCave.isFatal = 1;
841 >        simError();
842        }
843 <    }
844 <    
845 < #ifdef IS_MPI
843 >      info[i].dielectric = globals->getDielectric();  
844 >    }
845 >    else {
846 >      if (usesDipoles) {
847 >        
848 >        if( !globals->haveECR() ){
849 >          sprintf( painCave.errMsg,
850 >                   "SimSetup Warning: using default value of 1/2 the smallest "
851 >                   "box length for the electrostaticCutoffRadius.\n"
852 >                   "I hope you have a very fast processor!\n");
853 >          painCave.isFatal = 0;
854 >          simError();
855 >          double smallest;
856 >          smallest = info[i].boxL[0];
857 >          if (info[i].boxL[1] <= smallest) smallest = info[i].boxL[1];
858 >          if (info[i].boxL[2] <= smallest) smallest = info[i].boxL[2];
859 >          theEcr = 0.5 * smallest;
860 >        } else {
861 >          theEcr = globals->getECR();
862 >        }
863 >        
864 >        if( !globals->haveEST() ){
865 >          sprintf( painCave.errMsg,
866 >                   "SimSetup Warning: using default value of 0.05 * the "
867 >                   "electrostaticCutoffRadius for the "
868 >                   "electrostaticSkinThickness\n"
869 >                   );
870 >          painCave.isFatal = 0;
871 >          simError();
872 >          theEst = 0.05 * theEcr;
873 >        } else {
874 >          theEst= globals->getEST();
875 >        }
876 >        
877 >        info[i].setEcr( theEcr, theEst );
878 >      }
879 >    }  
880    }
881 +
882 + #ifdef IS_MPI
883 +  strcpy( checkPointMsg, "post processing checks out" );
884 +  MPIcheckPoint();
885   #endif // is_mpi
886 +
887 + }
888 +
889 + void SimSetup::initSystemCoords( void ){
890 +  int i;
891    
892 <  // set the status, sample, and themal kick times
892 >  char* inName;
893 >
894 >
895 >  (info[0].getConfiguration())->createArrays( info[0].n_atoms );
896    
897 <  if( the_globals->haveSampleTime() ){
898 <    simnfo->sampleTime = the_globals->getSampleTime();
899 <    simnfo->statusTime = simnfo->sampleTime;
900 <    simnfo->thermalTime = simnfo->sampleTime;
897 >  for(i=0; i<info[0].n_atoms; i++) info[0].atoms[i]->setCoords();
898 >  
899 >  if( globals->haveInitialConfig() ){
900 >    
901 >    InitializeFromFile* fileInit;
902 > #ifdef IS_MPI // is_mpi
903 >    if( worldRank == 0 ){
904 > #endif //is_mpi
905 >      inName = globals->getInitialConfig();
906 >      fileInit = new InitializeFromFile( inName );
907 > #ifdef IS_MPI
908 >    }else fileInit = new InitializeFromFile( NULL );
909 > #endif
910 >    fileInit->readInit( info ); // default velocities on
911 >    
912 >    delete fileInit;
913    }
914    else{
915 <    simnfo->sampleTime = the_globals->getRunTime();
916 <    simnfo->statusTime = simnfo->sampleTime;
917 <    simnfo->thermalTime = simnfo->sampleTime;
915 >    
916 > #ifdef IS_MPI
917 >    
918 >    // no init from bass
919 >    
920 >    sprintf( painCave.errMsg,
921 >             "Cannot intialize a parallel simulation without an initial configuration file.\n" );
922 >    painCave.isFatal;
923 >    simError();
924 >    
925 > #else
926 >    
927 >    initFromBass();
928 >    
929 >    
930 > #endif
931    }
932 +  
933 + #ifdef IS_MPI
934 +  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
935 +  MPIcheckPoint();
936 + #endif // is_mpi
937 +  
938 + }
939  
763  if( the_globals->haveStatusTime() ){
764    simnfo->statusTime = the_globals->getStatusTime();
765  }
940  
941 <  if( the_globals->haveThermalTime() ){
942 <    simnfo->thermalTime = the_globals->getThermalTime();
943 <  }
941 > void SimSetup::makeOutNames( void ){
942 >  
943 >  int k;
944  
945 <  // check for the temperature set flag
945 >  
946 >  for(k=0; k<nInfo; k++){
947  
948 <  if( the_globals->haveTempSet() ) simnfo->setTemp = the_globals->getTempSet();
948 > #ifdef IS_MPI
949 >    if( worldRank == 0 ){
950 > #endif // is_mpi
951 >      
952 >      if( globals->haveFinalConfig() ){
953 >        strcpy( info[k].finalName, globals->getFinalConfig() );
954 >      }
955 >      else{
956 >        strcpy( info[k].finalName, inFileName );
957 >        char* endTest;
958 >        int nameLength = strlen( info[k].finalName );
959 >        endTest = &(info[k].finalName[nameLength - 5]);
960 >        if( !strcmp( endTest, ".bass" ) ){
961 >          strcpy( endTest, ".eor" );
962 >        }
963 >        else if( !strcmp( endTest, ".BASS" ) ){
964 >          strcpy( endTest, ".eor" );
965 >        }
966 >        else{
967 >          endTest = &(info[k].finalName[nameLength - 4]);
968 >          if( !strcmp( endTest, ".bss" ) ){
969 >            strcpy( endTest, ".eor" );
970 >          }
971 >          else if( !strcmp( endTest, ".mdl" ) ){
972 >            strcpy( endTest, ".eor" );
973 >          }
974 >          else{
975 >            strcat( info[k].finalName, ".eor" );
976 >          }
977 >        }
978 >      }
979 >      
980 >      // make the sample and status out names
981 >      
982 >      strcpy( info[k].sampleName, inFileName );
983 >      char* endTest;
984 >      int nameLength = strlen( info[k].sampleName );
985 >      endTest = &(info[k].sampleName[nameLength - 5]);
986 >      if( !strcmp( endTest, ".bass" ) ){
987 >        strcpy( endTest, ".dump" );
988 >      }
989 >      else if( !strcmp( endTest, ".BASS" ) ){
990 >        strcpy( endTest, ".dump" );
991 >      }
992 >      else{
993 >        endTest = &(info[k].sampleName[nameLength - 4]);
994 >        if( !strcmp( endTest, ".bss" ) ){
995 >          strcpy( endTest, ".dump" );
996 >        }
997 >        else if( !strcmp( endTest, ".mdl" ) ){
998 >          strcpy( endTest, ".dump" );
999 >        }
1000 >        else{
1001 >          strcat( info[k].sampleName, ".dump" );
1002 >        }
1003 >      }
1004 >      
1005 >      strcpy( info[k].statusName, inFileName );
1006 >      nameLength = strlen( info[k].statusName );
1007 >      endTest = &(info[k].statusName[nameLength - 5]);
1008 >      if( !strcmp( endTest, ".bass" ) ){
1009 >        strcpy( endTest, ".stat" );
1010 >      }
1011 >      else if( !strcmp( endTest, ".BASS" ) ){
1012 >        strcpy( endTest, ".stat" );
1013 >      }
1014 >      else{
1015 >        endTest = &(info[k].statusName[nameLength - 4]);
1016 >        if( !strcmp( endTest, ".bss" ) ){
1017 >          strcpy( endTest, ".stat" );
1018 >        }
1019 >        else if( !strcmp( endTest, ".mdl" ) ){
1020 >          strcpy( endTest, ".stat" );
1021 >        }
1022 >        else{
1023 >          strcat( info[k].statusName, ".stat" );
1024 >        }
1025 >      }
1026 >      
1027 > #ifdef IS_MPI
1028 >    }
1029 > #endif // is_mpi
1030 >  }
1031 > }
1032  
1033  
1034 <  // make the integrator
1034 > void SimSetup::sysObjectsCreation( void ){
1035    
1036 +  int i,k;
1037    
1038 <  NVT* myNVT = NULL;
780 <  switch( ensembleCase ){
1038 >  // create the forceField
1039  
1040 <  case NVE_ENS:
783 <    new NVE( simnfo, the_ff );
784 <    break;
1040 >  createFF();
1041  
1042 <  case NVT_ENS:
787 <    myNVT = new NVT( simnfo, the_ff );
788 <    myNVT->setTargetTemp(the_globals->getTargetTemp());
1042 >  // extract componentList
1043  
1044 <    if (the_globals->haveTauThermostat())
1045 <      myNVT->setTauThermostat(the_globals->getTauThermostat());
1046 < //     else if (the_globals->haveQmass())
1047 < //       myNVT->setQmass(the_globals->getQmass());
1048 <    else {
1049 <      sprintf( painCave.errMsg,
1050 <               "SimSetup error: If you use the NVT\n"
1051 <               "    ensemble, you must set either tauThermostat or qMass.\n"
1052 <               "    Neither of these was found in the BASS file.\n");
1053 <      painCave.isFatal = 1;
1054 <      simError();
1044 >  compList();
1045 >
1046 >  // calc the number of atoms, bond, bends, and torsions
1047 >
1048 >  calcSysValues();
1049 >
1050 > #ifdef IS_MPI
1051 >  // divide the molecules among the processors
1052 >  
1053 >  mpiMolDivide();
1054 > #endif //is_mpi
1055 >  
1056 >  // create the atom and SRI arrays. Also initialize Molecule Stamp ID's
1057 >
1058 >  makeSysArrays();
1059 >
1060 >  // make and initialize the molecules (all but atomic coordinates)
1061 >
1062 >  makeMolecules();
1063 >  
1064 >  for(k=0; k<nInfo; k++){
1065 >    info[k].identArray = new int[info[k].n_atoms];
1066 >    for(i=0; i<info[k].n_atoms; i++){
1067 >      info[k].identArray[i] = info[k].atoms[i]->getIdent();
1068      }
1069 +  }
1070 + }
1071 +
1072 +
1073 + void SimSetup::createFF( void ){
1074 +
1075 +  switch( ffCase ){
1076 +
1077 +  case FF_DUFF:
1078 +    the_ff = new DUFF();
1079      break;
1080  
1081 +  case FF_LJ:
1082 +    the_ff = new LJFF();
1083 +    break;
1084 +
1085 +  case FF_EAM:
1086 +    the_ff = new EAM_FF();
1087 +    break;
1088 +
1089    default:
1090      sprintf( painCave.errMsg,
1091 <             "SimSetup Error. Unrecognized ensemble in case statement.\n");
1091 >             "SimSetup Error. Unrecognized force field in case statement.\n");
1092      painCave.isFatal = 1;
1093      simError();
1094    }
1095  
811
1096   #ifdef IS_MPI
1097 <  mpiSim->mpiRefresh();
1098 < #endif
1097 >  strcpy( checkPointMsg, "ForceField creation successful" );
1098 >  MPIcheckPoint();
1099 > #endif // is_mpi
1100  
1101 <  // initialize the Fortran
1101 > }
1102  
1103  
1104 <  simnfo->refreshSim();
1104 > void SimSetup::compList( void ){
1105 >
1106 >  int i;
1107 >  char* id;
1108 >  LinkedMolStamp* headStamp = new LinkedMolStamp();
1109 >  LinkedMolStamp* currentStamp = NULL;
1110 >  comp_stamps = new MoleculeStamp*[n_components];
1111    
1112 <  if( !strcmp( simnfo->mixingRule, "standard") ){
1113 <    the_ff->initForceField( LB_MIXING_RULE );
1112 >  // make an array of molecule stamps that match the components used.
1113 >  // also extract the used stamps out into a separate linked list
1114 >  
1115 >  for(i=0; i<nInfo; i++){
1116 >    info[i].nComponents = n_components;
1117 >    info[i].componentsNmol = components_nmol;
1118 >    info[i].compStamps = comp_stamps;
1119 >    info[i].headStamp = headStamp;
1120    }
1121 <  else if( !strcmp( simnfo->mixingRule, "explicit") ){
825 <    the_ff->initForceField( EXPLICIT_MIXING_RULE );
826 <  }
827 <  else{
828 <    sprintf( painCave.errMsg,
829 <             "SimSetup Error: unknown mixing rule -> \"%s\"\n",
830 <             simnfo->mixingRule );
831 <    painCave.isFatal = 1;
832 <    simError();
833 <  }
1121 >  
1122  
1123 +  for( i=0; i<n_components; i++ ){
1124  
1125 +    id = the_components[i]->getType();
1126 +    comp_stamps[i] = NULL;
1127 +    
1128 +    // check to make sure the component isn't already in the list
1129 +
1130 +    comp_stamps[i] = headStamp->match( id );
1131 +    if( comp_stamps[i] == NULL ){
1132 +      
1133 +      // extract the component from the list;
1134 +      
1135 +      currentStamp = stamps->extractMolStamp( id );
1136 +      if( currentStamp == NULL ){
1137 +        sprintf( painCave.errMsg,
1138 +                 "SimSetup error: Component \"%s\" was not found in the "
1139 +                 "list of declared molecules\n",
1140 +                 id );
1141 +        painCave.isFatal = 1;
1142 +        simError();
1143 +      }
1144 +      
1145 +      headStamp->add( currentStamp );
1146 +      comp_stamps[i] = headStamp->match( id );
1147 +    }
1148 +  }
1149 +
1150   #ifdef IS_MPI
1151 <  strcpy( checkPointMsg,
838 <          "Successfully intialized the mixingRule for Fortran." );
1151 >  strcpy( checkPointMsg, "Component stamps successfully extracted\n" );
1152    MPIcheckPoint();
1153   #endif // is_mpi
841 }
1154  
1155  
1156 < void SimSetup::makeMolecules( void ){
1156 > }
1157  
1158 <  int i, j, exI, exJ, tempEx, stampID, atomOffset, excludeOffset;
1159 <  molInit info;
1160 <  DirectionalAtom* dAtom;
1161 <  LinkedAssign* extras;
1162 <  LinkedAssign* current_extra;
1163 <  AtomStamp* currentAtom;
1164 <  BondStamp* currentBond;
1165 <  BendStamp* currentBend;
1166 <  TorsionStamp* currentTorsion;
1158 > void SimSetup::calcSysValues( void ){
1159 >  int i, j, k;
1160 >  
1161 >  int *molMembershipArray;
1162 >  
1163 >  tot_atoms = 0;
1164 >  tot_bonds = 0;
1165 >  tot_bends = 0;
1166 >  tot_torsions = 0;
1167 >  for( i=0; i<n_components; i++ ){
1168 >    
1169 >    tot_atoms +=    components_nmol[i] * comp_stamps[i]->getNAtoms();
1170 >    tot_bonds +=    components_nmol[i] * comp_stamps[i]->getNBonds();
1171 >    tot_bends +=    components_nmol[i] * comp_stamps[i]->getNBends();
1172 >    tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
1173 >  }
1174 >  
1175 >  tot_SRI = tot_bonds + tot_bends + tot_torsions;
1176 >  molMembershipArray = new int[tot_atoms];
1177 >  
1178 >  for(i=0; i<nInfo; i++){
1179 >    info[i].n_atoms = tot_atoms;
1180 >    info[i].n_bonds = tot_bonds;
1181 >    info[i].n_bends = tot_bends;
1182 >    info[i].n_torsions = tot_torsions;
1183 >    info[i].n_SRI = tot_SRI;
1184 >    info[i].n_mol = tot_nmol;
1185 >    
1186 >    info[i].molMembershipArray = molMembershipArray;
1187 >  }
1188 > }
1189  
1190 <  bond_pair* theBonds;
857 <  bend_set* theBends;
858 <  torsion_set* theTorsions;
1190 > #ifdef IS_MPI
1191  
1192 + void SimSetup::mpiMolDivide( void ){
1193    
1194 <  //init the forceField paramters
1194 >  int i, j, k;
1195 >  int localMol, allMol;
1196 >  int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
1197  
1198 <  the_ff->readParams();
864 <
1198 >  mpiSim = new mpiSimulation( info );
1199    
1200 <  // init the atoms
1200 >  globalIndex = mpiSim->divideLabor();
1201  
1202 <  double ux, uy, uz, u, uSqr;
1202 >  // set up the local variables
1203    
1204 <  atomOffset = 0;
1205 <  excludeOffset = 0;
1206 <  for(i=0; i<simnfo->n_mol; i++){
1207 <    
1208 <    stampID = the_molecules[i].getStampID();
1204 >  mol2proc = mpiSim->getMolToProcMap();
1205 >  molCompType = mpiSim->getMolComponentType();
1206 >  
1207 >  allMol = 0;
1208 >  localMol = 0;
1209 >  local_atoms = 0;
1210 >  local_bonds = 0;
1211 >  local_bends = 0;
1212 >  local_torsions = 0;
1213 >  globalAtomIndex = 0;
1214  
876    info.nAtoms    = comp_stamps[stampID]->getNAtoms();
877    info.nBonds    = comp_stamps[stampID]->getNBonds();
878    info.nBends    = comp_stamps[stampID]->getNBends();
879    info.nTorsions = comp_stamps[stampID]->getNTorsions();
880    info.nExcludes = info.nBonds + info.nBends + info.nTorsions;
1215  
1216 <    info.myAtoms = &the_atoms[atomOffset];
883 <    info.myExcludes = &the_excludes[excludeOffset];
884 <    info.myBonds = new Bond*[info.nBonds];
885 <    info.myBends = new Bend*[info.nBends];
886 <    info.myTorsions = new Torsion*[info.nTorsions];
1216 >  for( i=0; i<n_components; i++ ){
1217  
1218 <    theBonds = new bond_pair[info.nBonds];
889 <    theBends = new bend_set[info.nBends];
890 <    theTorsions = new torsion_set[info.nTorsions];
891 <    
892 <    // make the Atoms
893 <    
894 <    for(j=0; j<info.nAtoms; j++){
1218 >    for( j=0; j<components_nmol[i]; j++ ){
1219        
1220 <      currentAtom = comp_stamps[stampID]->getAtom( j );
897 <      if( currentAtom->haveOrientation() ){
1220 >      if( mol2proc[allMol] == worldRank ){
1221          
1222 <        dAtom = new DirectionalAtom(j + atomOffset);
1223 <        simnfo->n_oriented++;
1224 <        info.myAtoms[j] = dAtom;
1225 <        
1226 <        ux = currentAtom->getOrntX();
1227 <        uy = currentAtom->getOrntY();
1228 <        uz = currentAtom->getOrntZ();
1229 <        
1230 <        uSqr = (ux * ux) + (uy * uy) + (uz * uz);
908 <        
909 <        u = sqrt( uSqr );
910 <        ux = ux / u;
911 <        uy = uy / u;
912 <        uz = uz / u;
913 <        
914 <        dAtom->setSUx( ux );
915 <        dAtom->setSUy( uy );
916 <        dAtom->setSUz( uz );
1222 >        local_atoms +=    comp_stamps[i]->getNAtoms();
1223 >        local_bonds +=    comp_stamps[i]->getNBonds();
1224 >        local_bends +=    comp_stamps[i]->getNBends();
1225 >        local_torsions += comp_stamps[i]->getNTorsions();
1226 >        localMol++;
1227 >      }      
1228 >      for (k = 0; k < comp_stamps[i]->getNAtoms(); k++) {
1229 >        info[0].molMembershipArray[globalAtomIndex] = allMol;
1230 >        globalAtomIndex++;
1231        }
1232 <      else{
1233 <        info.myAtoms[j] = new GeneralAtom(j + atomOffset);
1234 <      }
1235 <      info.myAtoms[j]->setType( currentAtom->getType() );
1236 <    
1237 < #ifdef IS_MPI
1238 <      
1239 <      info.myAtoms[j]->setGlobalIndex( globalIndex[j+atomOffset] );
1240 <      
1232 >
1233 >      allMol++;      
1234 >    }
1235 >  }
1236 >  local_SRI = local_bonds + local_bends + local_torsions;
1237 >  
1238 >  info[0].n_atoms = mpiSim->getMyNlocal();  
1239 >  
1240 >  if( local_atoms != info[0].n_atoms ){
1241 >    sprintf( painCave.errMsg,
1242 >             "SimSetup error: mpiSim's localAtom (%d) and SimSetup's"
1243 >             " localAtom (%d) are not equal.\n",
1244 >             info[0].n_atoms,
1245 >             local_atoms );
1246 >    painCave.isFatal = 1;
1247 >    simError();
1248 >  }
1249 >
1250 >  info[0].n_bonds = local_bonds;
1251 >  info[0].n_bends = local_bends;
1252 >  info[0].n_torsions = local_torsions;
1253 >  info[0].n_SRI = local_SRI;
1254 >  info[0].n_mol = localMol;
1255 >
1256 >  strcpy( checkPointMsg, "Passed nlocal consistency check." );
1257 >  MPIcheckPoint();
1258 > }
1259 >
1260   #endif // is_mpi
928    }
929    
930    // make the bonds
931    for(j=0; j<info.nBonds; j++){
932      
933      currentBond = comp_stamps[stampID]->getBond( j );
934      theBonds[j].a = currentBond->getA() + atomOffset;
935      theBonds[j].b = currentBond->getB() + atomOffset;
1261  
937      exI = theBonds[j].a;
938      exJ = theBonds[j].b;
1262  
1263 <      // exclude_I must always be the smaller of the pair
1264 <      if( exI > exJ ){
942 <        tempEx = exI;
943 <        exI = exJ;
944 <        exJ = tempEx;
945 <      }
946 < #ifdef IS_MPI
947 <      tempEx = exI;
948 <      exI = the_atoms[tempEx]->getGlobalIndex() + 1;
949 <      tempEx = exJ;
950 <      exJ = the_atoms[tempEx]->getGlobalIndex() + 1;
951 <      
952 <      the_excludes[j+excludeOffset]->setPair( exI, exJ );
953 < #else  // isn't MPI
1263 > void SimSetup::makeSysArrays( void ){
1264 >  int i, j, k, l;
1265  
1266 <      the_excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
1267 < #endif  //is_mpi
1268 <    }
958 <    excludeOffset += info.nBonds;
1266 >  Atom** the_atoms;
1267 >  Molecule* the_molecules;
1268 >  Exclude** the_excludes;
1269  
1270 <    //make the bends
1271 <    for(j=0; j<info.nBends; j++){
1272 <      
1273 <      currentBend = comp_stamps[stampID]->getBend( j );
1274 <      theBends[j].a = currentBend->getA() + atomOffset;
1275 <      theBends[j].b = currentBend->getB() + atomOffset;
1276 <      theBends[j].c = currentBend->getC() + atomOffset;
1277 <          
1278 <      if( currentBend->haveExtras() ){
1279 <            
1280 <        extras = currentBend->getExtras();
1281 <        current_extra = extras;
1282 <            
1283 <        while( current_extra != NULL ){
1284 <          if( !strcmp( current_extra->getlhs(), "ghostVectorSource" )){
1285 <                
1286 <            switch( current_extra->getType() ){
1287 <              
1288 <            case 0:
1289 <              theBends[j].ghost =
1290 <                current_extra->getInt() + atomOffset;
1291 <              theBends[j].isGhost = 1;
1292 <              break;
1293 <                  
1294 <            case 1:
1295 <              theBends[j].ghost =
1296 <                (int)current_extra->getDouble() + atomOffset;
1297 <              theBends[j].isGhost = 1;
1298 <              break;
1299 <              
1300 <            default:
1301 <              sprintf( painCave.errMsg,
1302 <                       "SimSetup Error: ghostVectorSource was neither a "
1303 <                       "double nor an int.\n"
1304 <                       "-->Bend[%d] in %s\n",
1305 <                       j, comp_stamps[stampID]->getID() );
1306 <              painCave.isFatal = 1;
997 <              simError();
998 <            }
999 <          }
1000 <          
1001 <          else{
1002 <            
1003 <            sprintf( painCave.errMsg,
1004 <                     "SimSetup Error: unhandled bend assignment:\n"
1005 <                     "    -->%s in Bend[%d] in %s\n",
1006 <                     current_extra->getlhs(),
1007 <                     j, comp_stamps[stampID]->getID() );
1008 <            painCave.isFatal = 1;
1009 <            simError();
1010 <          }
1011 <          
1012 <          current_extra = current_extra->getNext();
1270 >  
1271 >  for(l=0; l<nInfo; l++){
1272 >    
1273 >    // create the atom and short range interaction arrays
1274 >    
1275 >    the_atoms = new Atom*[info[l].n_atoms];
1276 >    the_molecules = new Molecule[info[l].n_mol];
1277 >    int molIndex;
1278 >
1279 >    // initialize the molecule's stampID's
1280 >    
1281 > #ifdef IS_MPI
1282 >    
1283 >    
1284 >    molIndex = 0;
1285 >    for(i=0; i<mpiSim->getTotNmol(); i++){
1286 >    
1287 >      if(mol2proc[i] == worldRank ){
1288 >        the_molecules[molIndex].setStampID( molCompType[i] );
1289 >        the_molecules[molIndex].setMyIndex( molIndex );
1290 >        the_molecules[molIndex].setGlobalIndex( i );
1291 >        molIndex++;
1292 >      }
1293 >    }
1294 >    
1295 > #else // is_mpi
1296 >    
1297 >    molIndex = 0;
1298 >    globalAtomIndex = 0;
1299 >    for(i=0; i<n_components; i++){
1300 >      for(j=0; j<components_nmol[i]; j++ ){
1301 >        the_molecules[molIndex].setStampID( i );
1302 >        the_molecules[molIndex].setMyIndex( molIndex );
1303 >        the_molecules[molIndex].setGlobalIndex( molIndex );
1304 >        for (k = 0; k < comp_stamps[i]->getNAtoms(); k++) {
1305 >          info[l].molMembershipArray[globalAtomIndex] = molIndex;
1306 >          globalAtomIndex++;
1307          }
1308 +        molIndex++;
1309        }
1015          
1016      if( !theBends[j].isGhost ){
1017            
1018        exI = theBends[j].a;
1019        exJ = theBends[j].c;
1020      }
1021      else{
1022        
1023        exI = theBends[j].a;
1024        exJ = theBends[j].b;
1025      }
1026      
1027      // exclude_I must always be the smaller of the pair
1028      if( exI > exJ ){
1029        tempEx = exI;
1030        exI = exJ;
1031        exJ = tempEx;
1032      }
1033 #ifdef IS_MPI
1034      tempEx = exI;
1035      exI = the_atoms[tempEx]->getGlobalIndex() + 1;
1036      tempEx = exJ;
1037      exJ = the_atoms[tempEx]->getGlobalIndex() + 1;
1038      
1039      the_excludes[j+excludeOffset]->setPair( exI, exJ );
1040 #else  // isn't MPI
1041      the_excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
1042 #endif  //is_mpi
1310      }
1311 <    excludeOffset += info.nBends;
1311 >    
1312 >    
1313 > #endif // is_mpi
1314  
1046    for(j=0; j<info.nTorsions; j++){
1047      
1048      currentTorsion = comp_stamps[stampID]->getTorsion( j );
1049      theTorsions[j].a = currentTorsion->getA() + atomOffset;
1050      theTorsions[j].b = currentTorsion->getB() + atomOffset;
1051      theTorsions[j].c = currentTorsion->getC() + atomOffset;
1052      theTorsions[j].d = currentTorsion->getD() + atomOffset;
1053      
1054      exI = theTorsions[j].a;
1055      exJ = theTorsions[j].d;
1315  
1316 <      // exclude_I must always be the smaller of the pair
1317 <      if( exI > exJ ){
1318 <        tempEx = exI;
1319 <        exI = exJ;
1320 <        exJ = tempEx;
1316 >    if( info[l].n_SRI ){
1317 >    
1318 >      Exclude::createArray(info[l].n_SRI);
1319 >      the_excludes = new Exclude*[info[l].n_SRI];
1320 >      for( int ex=0; ex<info[l].n_SRI; ex++){
1321 >        the_excludes[ex] = new Exclude(ex);
1322        }
1323 < #ifdef IS_MPI
1324 <      tempEx = exI;
1065 <      exI = the_atoms[tempEx]->getGlobalIndex() + 1;
1066 <      tempEx = exJ;
1067 <      exJ = the_atoms[tempEx]->getGlobalIndex() + 1;
1068 <      
1069 <      the_excludes[j+excludeOffset]->setPair( exI, exJ );
1070 < #else  // isn't MPI
1071 <      the_excludes[j+excludeOffset]->setPair( (exI+1), (exJ+1) );
1072 < #endif  //is_mpi
1323 >      info[l].globalExcludes = new int;
1324 >      info[l].n_exclude = info[l].n_SRI;
1325      }
1326 <    excludeOffset += info.nTorsions;
1075 <
1326 >    else{
1327      
1328 <    // send the arrays off to the forceField for init.
1328 >      Exclude::createArray( 1 );
1329 >      the_excludes = new Exclude*;
1330 >      the_excludes[0] = new Exclude(0);
1331 >      the_excludes[0]->setPair( 0,0 );
1332 >      info[l].globalExcludes = new int;
1333 >      info[l].globalExcludes[0] = 0;
1334 >      info[l].n_exclude = 0;
1335 >    }
1336  
1337 <    the_ff->initializeAtoms( info.nAtoms, info.myAtoms );
1080 <    the_ff->initializeBonds( info.nBonds, info.myBonds, theBonds );
1081 <    the_ff->initializeBends( info.nBends, info.myBends, theBends );
1082 <    the_ff->initializeTorsions( info.nTorsions, info.myTorsions, theTorsions );
1337 >    // set the arrays into the SimInfo object
1338  
1339 +    info[l].atoms = the_atoms;
1340 +    info[l].molecules = the_molecules;
1341 +    info[l].nGlobalExcludes = 0;
1342 +    info[l].excludes = the_excludes;
1343  
1344 <    the_molecules[i].initialize( info );
1345 <
1087 <
1088 <    atomOffset += info.nAtoms;
1089 <    delete[] theBonds;
1090 <    delete[] theBends;
1091 <    delete[] theTorsions;
1344 >    the_ff->setSimInfo( info );
1345 >    
1346    }
1093
1094 #ifdef IS_MPI
1095  sprintf( checkPointMsg, "all molecules initialized succesfully" );
1096  MPIcheckPoint();
1097 #endif // is_mpi
1098
1099  // clean up the forcefield
1100  the_ff->calcRcut();
1101  the_ff->cleanMe();
1102
1347   }
1348  
1349 < void SimSetup::initFromBass( void ){
1349 > void SimSetup::makeIntegrator( void ){
1350  
1351 <  int i, j, k;
1108 <  int n_cells;
1109 <  double cellx, celly, cellz;
1110 <  double temp1, temp2, temp3;
1111 <  int n_per_extra;
1112 <  int n_extra;
1113 <  int have_extra, done;
1351 >  int k;
1352  
1353 <  temp1 = (double)tot_nmol / 4.0;
1354 <  temp2 = pow( temp1, ( 1.0 / 3.0 ) );
1355 <  temp3 = ceil( temp2 );
1353 >  NVT<RealIntegrator>*  myNVT = NULL;
1354 >  NPTi<RealIntegrator>* myNPTi = NULL;
1355 >  NPTf<RealIntegrator>* myNPTf = NULL;
1356 >  NPTim<RealIntegrator>* myNPTim = NULL;
1357 >  NPTfm<RealIntegrator>* myNPTfm = NULL;
1358 >        
1359 >  for(k=0; k<nInfo; k++){
1360 >    
1361 >    switch( ensembleCase ){
1362 >      
1363 >    case NVE_ENS:
1364 >        if (globals->haveZconstraints()){
1365 >         setupZConstraint(info[k]);
1366 >           new ZConstraint<NVE<RealIntegrator> >( &(info[k]), the_ff );
1367 >        }
1368  
1369 <  have_extra =0;
1370 <  if( temp2 < temp3 ){ // we have a non-complete lattice
1371 <    have_extra =1;
1369 >        else
1370 >        new NVE<RealIntegrator>( &(info[k]), the_ff );
1371 >      break;
1372 >      
1373 >    case NVT_ENS:
1374 >        if (globals->haveZconstraints()){
1375 >         setupZConstraint(info[k]);
1376 >           myNVT = new ZConstraint<NVT<RealIntegrator> >( &(info[k]), the_ff );
1377 >        }
1378 >        else
1379 >        myNVT = new NVT<RealIntegrator>( &(info[k]), the_ff );
1380  
1381 <    n_cells = (int)temp3 - 1;
1382 <    cellx = simnfo->boxLx / temp3;
1383 <    celly = simnfo->boxLy / temp3;
1384 <    cellz = simnfo->boxLz / temp3;
1385 <    n_extra = tot_nmol - ( 4 * n_cells * n_cells * n_cells );
1386 <    temp1 = ((double)n_extra) / ( pow( temp3, 3.0 ) - pow( n_cells, 3.0 ) );
1387 <    n_per_extra = (int)ceil( temp1 );
1381 >      myNVT->setTargetTemp(globals->getTargetTemp());
1382 >      
1383 >      if (globals->haveTauThermostat())
1384 >        myNVT->setTauThermostat(globals->getTauThermostat());
1385 >      
1386 >      else {
1387 >        sprintf( painCave.errMsg,
1388 >                 "SimSetup error: If you use the NVT\n"
1389 >                 "    ensemble, you must set tauThermostat.\n");
1390 >        painCave.isFatal = 1;
1391 >        simError();
1392 >      }
1393 >      break;
1394 >      
1395 >    case NPTi_ENS:
1396 >        if (globals->haveZconstraints()){
1397 >         setupZConstraint(info[k]);
1398 >           myNPTi = new ZConstraint<NPTi<RealIntegrator> >( &(info[k]), the_ff );
1399 >        }
1400 >        else
1401 >        myNPTi = new NPTi<RealIntegrator>( &(info[k]), the_ff );
1402  
1403 <    if( n_per_extra > 4){
1403 >        myNPTi->setTargetTemp( globals->getTargetTemp() );
1404 >      
1405 >      if (globals->haveTargetPressure())
1406 >        myNPTi->setTargetPressure(globals->getTargetPressure());
1407 >      else {
1408 >        sprintf( painCave.errMsg,
1409 >                 "SimSetup error: If you use a constant pressure\n"
1410 >                 "    ensemble, you must set targetPressure in the BASS file.\n");
1411 >        painCave.isFatal = 1;
1412 >        simError();
1413 >      }
1414 >      
1415 >      if( globals->haveTauThermostat() )
1416 >        myNPTi->setTauThermostat( globals->getTauThermostat() );
1417 >      else{
1418 >        sprintf( painCave.errMsg,
1419 >                 "SimSetup error: If you use an NPT\n"
1420 >                 "    ensemble, you must set tauThermostat.\n");
1421 >        painCave.isFatal = 1;
1422 >        simError();
1423 >      }
1424 >      
1425 >      if( globals->haveTauBarostat() )
1426 >        myNPTi->setTauBarostat( globals->getTauBarostat() );
1427 >      else{
1428 >        sprintf( painCave.errMsg,
1429 >                 "SimSetup error: If you use an NPT\n"
1430 >                 "    ensemble, you must set tauBarostat.\n");
1431 >        painCave.isFatal = 1;
1432 >        simError();
1433 >      }
1434 >      break;
1435 >      
1436 >    case NPTf_ENS:
1437 >        if (globals->haveZconstraints()){
1438 >         setupZConstraint(info[k]);
1439 >           myNPTf = new ZConstraint<NPTf<RealIntegrator> >( &(info[k]), the_ff );
1440 >        }
1441 >        else
1442 >        myNPTf = new NPTf<RealIntegrator>( &(info[k]), the_ff );
1443 >
1444 >      myNPTf->setTargetTemp( globals->getTargetTemp());
1445 >      
1446 >      if (globals->haveTargetPressure())
1447 >        myNPTf->setTargetPressure(globals->getTargetPressure());
1448 >      else {
1449 >        sprintf( painCave.errMsg,
1450 >                 "SimSetup error: If you use a constant pressure\n"
1451 >                 "    ensemble, you must set targetPressure in the BASS file.\n");
1452 >        painCave.isFatal = 1;
1453 >        simError();
1454 >      }    
1455 >      
1456 >      if( globals->haveTauThermostat() )
1457 >        myNPTf->setTauThermostat( globals->getTauThermostat() );
1458 >      else{
1459 >        sprintf( painCave.errMsg,
1460 >                 "SimSetup error: If you use an NPT\n"
1461 >               "    ensemble, you must set tauThermostat.\n");
1462 >        painCave.isFatal = 1;
1463 >        simError();
1464 >      }
1465 >      
1466 >      if( globals->haveTauBarostat() )
1467 >        myNPTf->setTauBarostat( globals->getTauBarostat() );
1468 >      else{
1469 >        sprintf( painCave.errMsg,
1470 >                 "SimSetup error: If you use an NPT\n"
1471 >                 "    ensemble, you must set tauBarostat.\n");
1472 >        painCave.isFatal = 1;
1473 >        simError();
1474 >      }
1475 >      break;
1476 >      
1477 >    case NPTim_ENS:
1478 >        if (globals->haveZconstraints()){
1479 >         setupZConstraint(info[k]);
1480 >           myNPTim = new ZConstraint<NPTim<RealIntegrator> >( &(info[k]), the_ff );
1481 >        }
1482 >        else
1483 >        myNPTim = new NPTim<RealIntegrator>( &(info[k]), the_ff );
1484 >
1485 >        myNPTim->setTargetTemp( globals->getTargetTemp());
1486 >      
1487 >      if (globals->haveTargetPressure())
1488 >        myNPTim->setTargetPressure(globals->getTargetPressure());
1489 >      else {
1490 >        sprintf( painCave.errMsg,
1491 >                 "SimSetup error: If you use a constant pressure\n"
1492 >                 "    ensemble, you must set targetPressure in the BASS file.\n");
1493 >        painCave.isFatal = 1;
1494 >        simError();
1495 >      }
1496 >      
1497 >      if( globals->haveTauThermostat() )
1498 >        myNPTim->setTauThermostat( globals->getTauThermostat() );
1499 >      else{
1500 >        sprintf( painCave.errMsg,
1501 >                 "SimSetup error: If you use an NPT\n"
1502 >                 "    ensemble, you must set tauThermostat.\n");
1503 >        painCave.isFatal = 1;
1504 >        simError();
1505 >      }
1506 >      
1507 >      if( globals->haveTauBarostat() )
1508 >        myNPTim->setTauBarostat( globals->getTauBarostat() );
1509 >      else{
1510        sprintf( painCave.errMsg,
1511 <               "SimSetup error. There has been an error in constructing"
1512 <               " the non-complete lattice.\n" );
1511 >               "SimSetup error: If you use an NPT\n"
1512 >               "    ensemble, you must set tauBarostat.\n");
1513        painCave.isFatal = 1;
1514        simError();
1137    }
1138  }
1139  else{
1140    n_cells = (int)temp3;
1141    cellx = simnfo->boxLx / temp3;
1142    celly = simnfo->boxLy / temp3;
1143    cellz = simnfo->boxLz / temp3;
1144  }
1145
1146  current_mol = 0;
1147  current_comp_mol = 0;
1148  current_comp = 0;
1149  current_atom_ndx = 0;
1150
1151  for( i=0; i < n_cells ; i++ ){
1152    for( j=0; j < n_cells; j++ ){
1153      for( k=0; k < n_cells; k++ ){
1154
1155        makeElement( i * cellx,
1156                     j * celly,
1157                     k * cellz );
1158
1159        makeElement( i * cellx + 0.5 * cellx,
1160                     j * celly + 0.5 * celly,
1161                     k * cellz );
1162
1163        makeElement( i * cellx,
1164                     j * celly + 0.5 * celly,
1165                     k * cellz + 0.5 * cellz );
1166
1167        makeElement( i * cellx + 0.5 * cellx,
1168                     j * celly,
1169                     k * cellz + 0.5 * cellz );
1515        }
1516 <    }
1517 <  }
1518 <
1519 <  if( have_extra ){
1520 <    done = 0;
1521 <
1177 <    int start_ndx;
1178 <    for( i=0; i < (n_cells+1) && !done; i++ ){
1179 <      for( j=0; j < (n_cells+1) && !done; j++ ){
1180 <
1181 <        if( i < n_cells ){
1182 <
1183 <          if( j < n_cells ){
1184 <            start_ndx = n_cells;
1185 <          }
1186 <          else start_ndx = 0;
1516 >      break;
1517 >      
1518 >    case NPTfm_ENS:
1519 >        if (globals->haveZconstraints()){
1520 >         setupZConstraint(info[k]);
1521 >           myNPTfm = new ZConstraint<NPTfm<RealIntegrator> >( &(info[k]), the_ff );
1522          }
1523 <        else start_ndx = 0;
1523 >        else
1524 >        myNPTfm = new NPTfm<RealIntegrator>( &(info[k]), the_ff );
1525  
1526 <        for( k=start_ndx; k < (n_cells+1) && !done; k++ ){
1527 <
1528 <          makeElement( i * cellx,
1529 <                       j * celly,
1530 <                       k * cellz );
1531 <          done = ( current_mol >= tot_nmol );
1532 <
1533 <          if( !done && n_per_extra > 1 ){
1534 <            makeElement( i * cellx + 0.5 * cellx,
1535 <                         j * celly + 0.5 * celly,
1200 <                         k * cellz );
1201 <            done = ( current_mol >= tot_nmol );
1202 <          }
1203 <
1204 <          if( !done && n_per_extra > 2){
1205 <            makeElement( i * cellx,
1206 <                         j * celly + 0.5 * celly,
1207 <                         k * cellz + 0.5 * cellz );
1208 <            done = ( current_mol >= tot_nmol );
1209 <          }
1210 <
1211 <          if( !done && n_per_extra > 3){
1212 <            makeElement( i * cellx + 0.5 * cellx,
1213 <                         j * celly,
1214 <                         k * cellz + 0.5 * cellz );
1215 <            done = ( current_mol >= tot_nmol );
1216 <          }
1217 <        }
1526 >        myNPTfm->setTargetTemp( globals->getTargetTemp());
1527 >      
1528 >      if (globals->haveTargetPressure())
1529 >        myNPTfm->setTargetPressure(globals->getTargetPressure());
1530 >      else {
1531 >        sprintf( painCave.errMsg,
1532 >                 "SimSetup error: If you use a constant pressure\n"
1533 >                 "    ensemble, you must set targetPressure in the BASS file.\n");
1534 >        painCave.isFatal = 1;
1535 >        simError();
1536        }
1537 +      
1538 +      if( globals->haveTauThermostat() )
1539 +        myNPTfm->setTauThermostat( globals->getTauThermostat() );
1540 +      else{
1541 +        sprintf( painCave.errMsg,
1542 +                 "SimSetup error: If you use an NPT\n"
1543 +                 "    ensemble, you must set tauThermostat.\n");
1544 +        painCave.isFatal = 1;
1545 +        simError();
1546 +      }
1547 +      
1548 +      if( globals->haveTauBarostat() )
1549 +        myNPTfm->setTauBarostat( globals->getTauBarostat() );
1550 +      else{
1551 +        sprintf( painCave.errMsg,
1552 +                 "SimSetup error: If you use an NPT\n"
1553 +                 "    ensemble, you must set tauBarostat.\n");
1554 +        painCave.isFatal = 1;
1555 +        simError();
1556 +      }
1557 +      break;
1558 +      
1559 +    default:
1560 +      sprintf( painCave.errMsg,
1561 +               "SimSetup Error. Unrecognized ensemble in case statement.\n");
1562 +      painCave.isFatal = 1;
1563 +      simError();
1564      }
1565    }
1566 + }
1567  
1568 + void SimSetup::initFortran( void ){
1569  
1570 <  for( i=0; i<simnfo->n_atoms; i++ ){
1571 <    simnfo->atoms[i]->set_vx( 0.0 );
1572 <    simnfo->atoms[i]->set_vy( 0.0 );
1573 <    simnfo->atoms[i]->set_vz( 0.0 );
1570 >  info[0].refreshSim();
1571 >  
1572 >  if( !strcmp( info[0].mixingRule, "standard") ){
1573 >    the_ff->initForceField( LB_MIXING_RULE );
1574    }
1575 < }
1575 >  else if( !strcmp( info[0].mixingRule, "explicit") ){
1576 >    the_ff->initForceField( EXPLICIT_MIXING_RULE );
1577 >  }
1578 >  else{
1579 >    sprintf( painCave.errMsg,
1580 >             "SimSetup Error: unknown mixing rule -> \"%s\"\n",
1581 >             info[0].mixingRule );
1582 >    painCave.isFatal = 1;
1583 >    simError();
1584 >  }
1585  
1230 void SimSetup::makeElement( double x, double y, double z ){
1586  
1587 <  int k;
1588 <  AtomStamp* current_atom;
1589 <  DirectionalAtom* dAtom;
1590 <  double rotMat[3][3];
1587 > #ifdef IS_MPI
1588 >  strcpy( checkPointMsg,
1589 >          "Successfully intialized the mixingRule for Fortran." );
1590 >  MPIcheckPoint();
1591 > #endif // is_mpi
1592  
1593 <  for( k=0; k<comp_stamps[current_comp]->getNAtoms(); k++ ){
1593 > }
1594  
1595 <    current_atom = comp_stamps[current_comp]->getAtom( k );
1596 <    if( !current_atom->havePosition() ){
1595 > void SimSetup::setupZConstraint(SimInfo& theInfo)
1596 > {
1597 >    int nZConstraints;
1598 >    ZconStamp** zconStamp;
1599 >        
1600 >    if(globals->haveZconstraintTime()){  
1601 >      
1602 >      //add sample time of z-constraint  into SimInfo's property list                    
1603 >      DoubleData* zconsTimeProp = new DoubleData();
1604 >      zconsTimeProp->setID(ZCONSTIME_ID);
1605 >      zconsTimeProp->setData(globals->getZconsTime());
1606 >      theInfo.addProperty(zconsTimeProp);
1607 >    }
1608 >    else{
1609        sprintf( painCave.errMsg,
1610 <               "SimSetup:initFromBass error.\n"
1611 <               "\tComponent %s, atom %s does not have a position specified.\n"
1244 <               "\tThe initialization routine is unable to give a start"
1245 <               " position.\n",
1246 <               comp_stamps[current_comp]->getID(),
1247 <               current_atom->getType() );
1610 >               "ZConstraint error: If you use an ZConstraint\n"
1611 >               " , you must set sample time.\n");
1612        painCave.isFatal = 1;
1613 <      simError();
1613 >      simError();      
1614      }
1615  
1616 <    the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );
1617 <    the_atoms[current_atom_ndx]->setY( y + current_atom->getPosY() );
1618 <    the_atoms[current_atom_ndx]->setZ( z + current_atom->getPosZ() );
1616 >    //
1617 >    nZConstraints = globals->getNzConstraints();
1618 >    zconStamp = globals->getZconStamp();
1619 >    ZConsParaItem tempParaItem;
1620  
1621 <    if( the_atoms[current_atom_ndx]->isDirectional() ){
1621 >    ZConsParaData* zconsParaData = new ZConsParaData();
1622 >    zconsParaData->setID(ZCONSPARADATA_ID);
1623 >  
1624 >    for(int i = 0; i < nZConstraints; i++){
1625 >    tempParaItem.havingZPos = zconStamp[i]->haveZpos();
1626 >    tempParaItem.zPos = zconStamp[i]->getZpos();
1627 >    tempParaItem.zconsIndex = zconStamp[i]->getMolIndex();
1628 >    tempParaItem.kRatio = zconStamp[i]->getKratio();
1629  
1630 <      dAtom = (DirectionalAtom *)the_atoms[current_atom_ndx];
1630 >    zconsParaData->addItem(tempParaItem);
1631 >    }
1632  
1633 <      rotMat[0][0] = 1.0;
1634 <      rotMat[0][1] = 0.0;
1635 <      rotMat[0][2] = 0.0;
1633 >    //sort the parameters by index of molecules
1634 >    zconsParaData->sortByIndex();
1635 >        
1636 >    //push data into siminfo, therefore, we can retrieve later
1637 >    theInfo.addProperty(zconsParaData);
1638  
1639 <      rotMat[1][0] = 0.0;
1640 <      rotMat[1][1] = 1.0;
1641 <      rotMat[1][2] = 0.0;
1642 <
1643 <      rotMat[2][0] = 0.0;
1644 <      rotMat[2][1] = 0.0;
1270 <      rotMat[2][2] = 1.0;
1271 <
1272 <      dAtom->setA( rotMat );
1639 >    //push zconsTol into siminfo, if user does not specify
1640 >    //value for zconsTol, a default value will be used
1641 >    DoubleData* zconsTol = new DoubleData();
1642 >    zconsTol->setID(ZCONSTOL_ID);
1643 >    if(globals->haveZconsTol()){
1644 >      zconsTol->setData(globals->getZconsTol());
1645      }
1646 +         else{
1647 +                double defaultZConsTol = 1E-6;
1648 +      sprintf( painCave.errMsg,
1649 +               "ZConstraint Waring: Tolerance for z-constraint methodl is not specified\n"
1650 +               " , default value %f is used.\n", defaultZConsTol);
1651 +      painCave.isFatal = 0;
1652 +      simError();      
1653  
1654 <    current_atom_ndx++;
1655 <  }
1656 <
1657 <  current_mol++;
1658 <  current_comp_mol++;
1659 <
1660 <  if( current_comp_mol >= components_nmol[current_comp] ){
1661 <
1662 <    current_comp_mol = 0;
1663 <    current_comp++;
1664 <  }
1654 >      zconsTol->setData(defaultZConsTol);
1655 >         }
1656 >    theInfo.addProperty(zconsTol);
1657 >        
1658 >    //Determine the name of ouput file and add it into SimInfo's property list
1659 >    //Be careful, do not use inFileName, since it is a pointer which
1660 >    //point to a string at master node, and slave nodes do not contain that string
1661 >    
1662 >    string zconsOutput(theInfo.finalName);
1663 >    
1664 >    zconsOutput = zconsOutput.substr(0, zconsOutput.rfind(".")) + ".fz";
1665 >    
1666 >    StringData* zconsFilename = new StringData();
1667 >    zconsFilename->setID(ZCONSFILENAME_ID);
1668 >    zconsFilename->setData(zconsOutput);
1669 >    
1670 >    theInfo.addProperty(zconsFilename);      
1671   }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines