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 605 by gezelter, Tue Jul 15 03:27:24 2003 UTC vs.
Revision 621 by gezelter, Wed Jul 16 02:11:02 2003 UTC

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

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines