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

Comparing trunk/mdtools/interface_implementation/SimSetup.cpp (file contents):
Revision 184 by mmeineke, Thu Nov 21 20:33:06 2002 UTC vs.
Revision 206 by chuckv, Thu Dec 12 21:21:59 2002 UTC

# Line 73 | Line 73 | void SimSetup::createSim( void ){
73  
74    MakeStamps *the_stamps;
75    Globals* the_globals;
76 <  int i;
76 >  int i, j;
77  
78    // get the stamps and globals;
79    the_stamps = stamps;
# Line 119 | Line 119 | void SimSetup::createSim( void ){
119  
120        if( !the_components[i]->haveNMol() ){
121          // we have a problem
122 <        std::cerr << "SimSetup Error. No global NMol or component NMol"
123 <                  << " given. Cannot calculate the number of atoms.\n";
124 <        exit( 8 );
122 >        sprintf( painCave.errMsg,
123 >                 "SimSetup Error. No global NMol or component NMol"
124 >                 " given. Cannot calculate the number of atoms.\n" );
125 >        painCave.isFatal = 1;
126 >        simError();
127        }
128  
129        tot_nmol += the_components[i]->getNMol();
# Line 129 | Line 131 | void SimSetup::createSim( void ){
131      }
132    }
133    else{
134 <    std::cerr << "NOT A SUPPORTED FEATURE\n";
135 <
136 < //     tot_nmol = the_globals->getNMol();
137 <
138 < //     //we have the total number of molecules, now we check for molfractions
139 < //     for( i=0; i<n_components; i++ ){
140 <
141 < //       if( !the_components[i]->haveMolFraction() ){
142 <
143 < //      if( !the_components[i]->haveNMol() ){
144 < //        //we have a problem
145 < //        std::cerr << "SimSetup error. Neither molFraction nor "
146 < //                  << " nMol was given in component
147 <
134 >    sprintf( painCave.errMsg,
135 >             "SimSetup error.\n"
136 >             "\tSorry, the ability to specify total"
137 >             " nMols and then give molfractions in the components\n"
138 >             "\tis not currently supported."
139 >             " Please give nMol in the components.\n" );
140 >    painCave.isFatal = 1;
141 >    simError();
142 >    
143 >    
144 >    //     tot_nmol = the_globals->getNMol();
145 >    
146 >    //   //we have the total number of molecules, now we check for molfractions
147 >    //     for( i=0; i<n_components; i++ ){
148 >    
149 >    //       if( !the_components[i]->haveMolFraction() ){
150 >    
151 >    //  if( !the_components[i]->haveNMol() ){
152 >    //    //we have a problem
153 >    //    std::cerr << "SimSetup error. Neither molFraction nor "
154 >    //              << " nMol was given in component
155 >    
156    }
157  
158 + #ifdef IS_MPI
159 +  strcpy( checkPointMsg, "Have the number of components" );
160 +  MPIcheckPoint();
161 + #endif // is_mpi
162 +
163    // make an array of molecule stamps that match the components used.
164 +  // also extract the used stamps out into a separate linked list
165  
166 +  simnfo->nComponents = n_components;
167 +  simnfo->componentsNmol = components_nmol;
168 +  simnfo->compStamps = comp_stamps;
169 +  simnfo->headStamp = new LinkedMolStamp();
170 +  
171 +  char* id;
172 +  LinkedMolStamp* headStamp = simnfo->headStamp;
173 +  LinkedMolStamp* currentStamp = NULL;
174    for( i=0; i<n_components; i++ ){
175  
176 <    comp_stamps[i] =
177 <      the_stamps->getMolecule( the_components[i]->getType() );
176 >    id = the_components[i]->getType();
177 >    comp_stamps[i] = NULL;
178 >    
179 >    // check to make sure the component isn't already in the list
180 >
181 >    comp_stamps[i] = headStamp->match( id );
182 >    if( comp_stamps[i] == NULL ){
183 >      
184 >      // extract the component from the list;
185 >      
186 >      currentStamp = the_stamps->extractMolStamp( id );
187 >      if( currentStamp == NULL ){
188 >        sprintf( painCave.errMsg,
189 >                 "SimSetup error: Component \"%s\" was not found in the "
190 >                 "list of declared molecules\n"
191 >                 id );
192 >        painCave.isFatal = 1;
193 >        simError();
194 >      }
195 >      
196 >      headStamp->add( currentStamp );
197 >      comp_stamps[i] = headStamp->match( id );
198 >    }
199    }
200  
201 + #ifdef IS_MPI
202 +  strcpy( checkPointMsg, "Component stamps successfully extracted\n" );
203 +  MPIcheckPoint();
204 + #endif // is_mpi
205 +  
206  
207  
208 +
209    // caclulate the number of atoms, bonds, bends and torsions
210  
211    tot_atoms = 0;
# Line 162 | Line 213 | void SimSetup::createSim( void ){
213    tot_bends = 0;
214    tot_torsions = 0;
215    for( i=0; i<n_components; i++ ){
216 <
217 <    tot_atoms += components_nmol[i] * comp_stamps[i]->getNAtoms();
218 <    tot_bonds += components_nmol[i] * comp_stamps[i]->getNBonds();
219 <    tot_bends += components_nmol[i] * comp_stamps[i]->getNBends();
216 >    
217 >    tot_atoms +=    components_nmol[i] * comp_stamps[i]->getNAtoms();
218 >    tot_bonds +=    components_nmol[i] * comp_stamps[i]->getNBonds();
219 >    tot_bends +=    components_nmol[i] * comp_stamps[i]->getNBends();
220      tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
221    }
222  
# Line 176 | Line 227 | void SimSetup::createSim( void ){
227    simnfo->n_bends = tot_bends;
228    simnfo->n_torsions = tot_torsions;
229    simnfo->n_SRI = tot_SRI;
230 +  simnfo->n_mol = tot_nmol;
231 +
232 +  
233 + #ifdef IS_MPI
234 +
235 +  // divide the molecules among processors here.
236 +  
237 +  mpiSimulation* mpiSim = new mpiSimulation( simnfo );
238 +  
239 +  mpiSim->divideLabor();
240 +
241 +  // set up the local variables
242 +  
243 +  int localMol, allMol;
244 +  int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
245 +  
246 +  allMol = 0;
247 +  localMol = 0;
248 +  local_atoms = 0;
249 +  local_bonds = 0;
250 +  local_bends = 0;
251 +  local_torsions = 0;
252 +  for( i=0; i<n_components; i++ ){
253 +
254 +    for( j=0; j<components_nmol[i]; j++ ){
255 +      
256 +      if( mpiSim->getMyMolStart() <= allMol &&
257 +          allMol <= mpiSim->getMyMolEnd() ){
258 +        
259 +        local_atoms +=    comp_stamps[i]->getNAtoms();
260 +        local_bonds +=    comp_stamps[i]->getNBonds();
261 +        local_bends +=    comp_stamps[i]->getNBends();
262 +        local_torsions += comp_stamps[i]->getNTorsions();
263 +        localMol++;
264 +      }      
265 +      allMol++;
266 +    }
267 +  }
268 +  local_SRI = local_bonds + local_bends + local_torsions;
269 +  
270 +
271 +  simnfo->n_atoms = mpiSim->getMyNlocal();  
272 +  
273 +  if( local_atoms != simnfo->n_atoms ){
274 +    sprintf( painCave.errMsg,
275 +             "SimSetup error: mpiSim's localAtom (%d) and SimSetup's"
276 +             " localAtom (%d) are note equal.\n",
277 +             simnfo->n_atoms,
278 +             local_atoms );
279 +    painCave.isFatal = 1;
280 +    simError();
281 +  }
282 +
283 +  simnfo->n_bonds = local_bonds;
284 +  simnfo->n_bends = local_bends;
285 +  simnfo->n_torsions = local_torsions;
286 +  simnfo->n_SRI = local_SRI;
287 +  simnfo->n_mol = localMol;
288 +
289 +  strcpy( checkPointMsg, "Passed nlocal consistency check." );
290 +  MPIcheckPoint();
291 +  
292 +  
293 + #endif // is_mpi
294 +  
295  
296    // create the atom and short range interaction arrays
297  
298 <  Atom::createArrays(tot_atoms);
299 <  the_atoms = new Atom*[tot_atoms];
300 <  the_molecules = new Molecule[tot_nmol];
298 >  Atom::createArrays(simnfo->n_atoms);
299 >  the_atoms = new Atom*[simnfo->n_atoms];
300 >  the_molecules = new Molecule[simnfo->n_mol];
301  
302  
303 <  if( tot_SRI ){
304 <    the_sris = new SRI*[tot_SRI];
305 <    the_excludes = new ex_pair[tot_SRI];
303 >  if( simnfo->n_SRI ){
304 >    the_sris = new SRI*[simnfo->n_SRI];
305 >    the_excludes = new ex_pair[simnfo->n_SRI];
306    }
307  
308    // set the arrays into the SimInfo object
# Line 215 | Line 331 | void SimSetup::createSim( void ){
331      makeTorsions();
332    }
333  
218 –  //  makeMolecules();
334  
335    // get some of the tricky things that may still be in the globals
336  
337    if( simnfo->n_dipoles ){
338  
339      if( !the_globals->haveRRF() ){
340 <      std::cerr << "SimSetup Error, system has dipoles, but no rRF was set.\n";
341 <      exit(8);
340 >      sprintf( painCave.errMsg,
341 >               "SimSetup Error, system has dipoles, but no rRF was set.\n");
342 >      painCave.isFatal = 1;
343 >      simError();
344      }
345      if( !the_globals->haveDielectric() ){
346 <      std::cerr << "SimSetup Error, system has dipoles, but no"
347 <                << " dielectric was set.\n";
348 <      exit(8);
346 >      sprintf( painCave.errMsg,
347 >               "SimSetup Error, system has dipoles, but no"
348 >               " dielectric was set.\n" );
349 >      painCave.isFatal = 1;
350 >      simError();
351      }
352  
353      simnfo->rRF        = the_globals->getRRF();
354      simnfo->dielectric = the_globals->getDielectric();
355    }
356  
357 + #ifdef IS_MPI
358 +  strcpy( checkPointMsg, "rRf and dielectric check out" );
359 +  MPIcheckPoint();
360 + #endif // is_mpi
361 +  
362    if( the_globals->haveBox() ){
363      simnfo->box_x = the_globals->getBox();
364      simnfo->box_y = the_globals->getBox();
# Line 250 | Line 374 | void SimSetup::createSim( void ){
374    }
375    else{
376      if( !the_globals->haveBoxX() ){
377 <      std::cerr << "SimSetup error, no periodic BoxX size given.\n";
378 <      exit(8);
377 >      sprintf( painCave.errMsg,
378 >               "SimSetup error, no periodic BoxX size given.\n" );
379 >      painCave.isFatal = 1;
380 >      simError();
381      }
382      simnfo->box_x = the_globals->getBoxX();
383  
384      if( !the_globals->haveBoxY() ){
385 <      std::cerr << "SimSetup error, no periodic BoxY size given.\n";
386 <      exit(8);
385 >      sprintf( painCave.errMsg,
386 >               "SimSetup error, no periodic BoxY size given.\n" );
387 >      painCave.isFatal = 1;
388 >      simError();
389      }
390      simnfo->box_y = the_globals->getBoxY();
391  
392      if( !the_globals->haveBoxZ() ){
393 <      std::cerr << "SimSetup error, no periodic BoxZ size given.\n";
394 <      exit(8);
393 >      sprintf( painCave.errMsg,
394 >               "SimSetup error, no periodic BoxZ size given.\n" );
395 >      painCave.isFatal = 1;
396 >      simError();
397      }
398      simnfo->box_z = the_globals->getBoxZ();
399    }
400  
401 + #ifdef IS_MPI
402 +  strcpy( checkPointMsg, "Box size set up" );
403 +  MPIcheckPoint();
404 + #endif // is_mpi
405  
272 – //   if( the_globals->haveInitialConfig() ){
273 – //        InitializeFromFile* fileInit;
274 – //     fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
406  
276 – //     fileInit->read_xyz( simnfo ); // default velocities on
407  
408 < //     delete fileInit;
409 < //   }
410 < //   else{
408 > if( the_globals->haveInitialConfig() ){
409 >
410 >     InitializeFromFile* fileInit;
411 > #ifdef IS_MPI // is_mpi
412 >     if( worldRank == 0 ){
413 > #endif //is_mpi
414 >   fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
415 > #ifdef IS_MPI
416 >     }else fileInit = new InitializeFromFile( NULL );
417 > #endif
418 >   fileInit->read_xyz( simnfo ); // default velocities on
419  
420 <    initFromBass();
420 >   delete fileInit;
421 > }
422 > else{
423  
424 + #ifdef IS_MPI
425  
426 < //   }
426 >  // no init from bass
427 >  
428 >  sprintf( painCave.errMsg,
429 >           "Cannot intialize a parallel simulation without an initial configuration file.\n" );
430 >  painCave.isFatal;
431 >  simError();
432 >  
433 > #else
434  
435 +  initFromBass();
436 +
437 +
438 + #endif
439 + }
440 +
441   #ifdef IS_MPI
442 <    if( worldRank == TESTWRITE ){
442 >  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
443 >  MPIcheckPoint();
444   #endif // is_mpi
445 <      
446 <      fprintf( stderr,
447 <               "infile name is \"%s\"\n",
448 <               inFileName );
449 <      
450 <      inFileName = "./butane.bass";
451 <        
452 <      if( the_globals->haveFinalConfig() ){
453 <        strcpy( simnfo->finalName, the_globals->getFinalConfig() );
445 >
446 >
447 >  
448 >
449 >  
450 >
451 >  
452 > #ifdef IS_MPI
453 >  if( worldRank == 0 ){
454 > #endif // is_mpi
455 >    
456 >    if( the_globals->haveFinalConfig() ){
457 >      strcpy( simnfo->finalName, the_globals->getFinalConfig() );
458 >    }
459 >    else{
460 >      strcpy( simnfo->finalName, inFileName );
461 >      char* endTest;
462 >      int nameLength = strlen( simnfo->finalName );
463 >      endTest = &(simnfo->finalName[nameLength - 5]);
464 >      if( !strcmp( endTest, ".bass" ) ){
465 >        strcpy( endTest, ".eor" );
466        }
467 +      else if( !strcmp( endTest, ".BASS" ) ){
468 +        strcpy( endTest, ".eor" );
469 +      }
470        else{
471 <        strcpy( simnfo->finalName, inFileName );
472 <        char* endTest;
303 <        int nameLength = strlen( simnfo->finalName );
304 <        endTest = &(simnfo->finalName[nameLength - 5]);
305 <        if( !strcmp( endTest, ".bass" ) ){
471 >        endTest = &(simnfo->finalName[nameLength - 4]);
472 >        if( !strcmp( endTest, ".bss" ) ){
473            strcpy( endTest, ".eor" );
474          }
475 <        else if( !strcmp( endTest, ".BASS" ) ){
475 >        else if( !strcmp( endTest, ".mdl" ) ){
476            strcpy( endTest, ".eor" );
477          }
478          else{
479 <          endTest = &(simnfo->finalName[nameLength - 4]);
313 <          if( !strcmp( endTest, ".bss" ) ){
314 <            strcpy( endTest, ".eor" );
315 <          }
316 <          else if( !strcmp( endTest, ".mdl" ) ){
317 <            strcpy( endTest, ".eor" );
318 <          }
319 <          else{
320 <            strcat( simnfo->finalName, ".eor" );
321 <          }
479 >          strcat( simnfo->finalName, ".eor" );
480          }
481        }
482 <      
483 <      // make the sample and status out names
484 <      
485 <      strcpy( simnfo->sampleName, inFileName );
486 <      char* endTest;
487 <      int nameLength = strlen( simnfo->sampleName );
488 <      endTest = &(simnfo->sampleName[nameLength - 5]);
489 <      if( !strcmp( endTest, ".bass" ) ){
482 >    }
483 >    
484 >    // make the sample and status out names
485 >    
486 >    strcpy( simnfo->sampleName, inFileName );
487 >    char* endTest;
488 >    int nameLength = strlen( simnfo->sampleName );
489 >    endTest = &(simnfo->sampleName[nameLength - 5]);
490 >    if( !strcmp( endTest, ".bass" ) ){
491 >      strcpy( endTest, ".dump" );
492 >    }
493 >    else if( !strcmp( endTest, ".BASS" ) ){
494 >      strcpy( endTest, ".dump" );
495 >    }
496 >    else{
497 >      endTest = &(simnfo->sampleName[nameLength - 4]);
498 >      if( !strcmp( endTest, ".bss" ) ){
499          strcpy( endTest, ".dump" );
500        }
501 <      else if( !strcmp( endTest, ".BASS" ) ){
501 >      else if( !strcmp( endTest, ".mdl" ) ){
502          strcpy( endTest, ".dump" );
503        }
504        else{
505 <        endTest = &(simnfo->sampleName[nameLength - 4]);
339 <        if( !strcmp( endTest, ".bss" ) ){
340 <          strcpy( endTest, ".dump" );
341 <        }
342 <        else if( !strcmp( endTest, ".mdl" ) ){
343 <          strcpy( endTest, ".dump" );
344 <        }
345 <        else{
346 <          strcat( simnfo->sampleName, ".dump" );
347 <        }
505 >        strcat( simnfo->sampleName, ".dump" );
506        }
507 <      
508 <      strcpy( simnfo->statusName, inFileName );
509 <      nameLength = strlen( simnfo->statusName );
510 <      endTest = &(simnfo->statusName[nameLength - 5]);
511 <      if( !strcmp( endTest, ".bass" ) ){
507 >    }
508 >    
509 >    strcpy( simnfo->statusName, inFileName );
510 >    nameLength = strlen( simnfo->statusName );
511 >    endTest = &(simnfo->statusName[nameLength - 5]);
512 >    if( !strcmp( endTest, ".bass" ) ){
513 >      strcpy( endTest, ".stat" );
514 >    }
515 >    else if( !strcmp( endTest, ".BASS" ) ){
516 >      strcpy( endTest, ".stat" );
517 >    }
518 >    else{
519 >      endTest = &(simnfo->statusName[nameLength - 4]);
520 >      if( !strcmp( endTest, ".bss" ) ){
521          strcpy( endTest, ".stat" );
522        }
523 <      else if( !strcmp( endTest, ".BASS" ) ){
523 >      else if( !strcmp( endTest, ".mdl" ) ){
524          strcpy( endTest, ".stat" );
525        }
526        else{
527 <        endTest = &(simnfo->statusName[nameLength - 4]);
361 <        if( !strcmp( endTest, ".bss" ) ){
362 <          strcpy( endTest, ".stat" );
363 <        }
364 <        else if( !strcmp( endTest, ".mdl" ) ){
365 <          strcpy( endTest, ".stat" );
366 <        }
367 <        else{
368 <          strcat( simnfo->statusName, ".stat" );
369 <        }
527 >        strcat( simnfo->statusName, ".stat" );
528        }
371 –      
372 – #ifdef IS_MPI
529      }
530 +    
531 + #ifdef IS_MPI
532 +  }
533   #endif // is_mpi
534 <
534 >  
535    // set the status, sample, and themal kick times
536 <
536 >  
537    if( the_globals->haveSampleTime() ){
538      simnfo->sampleTime = the_globals->getSampleTime();
539      simnfo->statusTime = simnfo->sampleTime;
# Line 414 | Line 573 | void SimSetup::makeAtoms( void ){
573    double ux, uy, uz, uSqr, u;
574    AtomStamp* current_atom;
575    DirectionalAtom* dAtom;
576 <  int molIndex, molStart, molEnd, nMemb;
576 >  int molIndex, molStart, molEnd, nMemb, lMolIndex;
577  
578 <
578 >  lMolIndex = 0;
579    molIndex = 0;
580    index = 0;
581    for( i=0; i<n_components; i++ ){
582  
583      for( j=0; j<components_nmol[i]; j++ ){
584  
585 <      molStart = index;
586 <      nMemb = comp_stamps[i]->getNAtoms();
587 <      for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
585 > #ifdef IS_MPI
586 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
587 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
588 > #endif // is_mpi        
589  
590 <        current_atom = comp_stamps[i]->getAtom( k );
591 <        if( current_atom->haveOrientation() ){
592 <
593 <          dAtom = new DirectionalAtom(index);
594 <          simnfo->n_oriented++;
595 <          the_atoms[index] = dAtom;
596 <
597 <          ux = current_atom->getOrntX();
598 <          uy = current_atom->getOrntY();
599 <          uz = current_atom->getOrntZ();
600 <
601 <          uSqr = (ux * ux) + (uy * uy) + (uz * uz);
602 <
603 <          u = sqrt( uSqr );
604 <          ux = ux / u;
605 <          uy = uy / u;
606 <          uz = uz / u;
607 <
608 <          dAtom->setSUx( ux );
609 <          dAtom->setSUy( uy );
610 <          dAtom->setSUz( uz );
611 <        }
612 <        else{
613 <          the_atoms[index] = new GeneralAtom(index);
614 <        }
615 <        the_atoms[index]->setType( current_atom->getType() );
616 <        the_atoms[index]->setIndex( index );
617 <
618 <        // increment the index and repeat;
619 <        index++;
620 <      }
590 >        molStart = index;
591 >        nMemb = comp_stamps[i]->getNAtoms();
592 >        for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
593 >          
594 >          current_atom = comp_stamps[i]->getAtom( k );
595 >          if( current_atom->haveOrientation() ){
596 >            
597 >            dAtom = new DirectionalAtom(index);
598 >            simnfo->n_oriented++;
599 >            the_atoms[index] = dAtom;
600 >            
601 >            ux = current_atom->getOrntX();
602 >            uy = current_atom->getOrntY();
603 >            uz = current_atom->getOrntZ();
604 >            
605 >            uSqr = (ux * ux) + (uy * uy) + (uz * uz);
606 >            
607 >            u = sqrt( uSqr );
608 >            ux = ux / u;
609 >            uy = uy / u;
610 >            uz = uz / u;
611 >            
612 >            dAtom->setSUx( ux );
613 >            dAtom->setSUy( uy );
614 >            dAtom->setSUz( uz );
615 >          }
616 >          else{
617 >            the_atoms[index] = new GeneralAtom(index);
618 >          }
619 >          the_atoms[index]->setType( current_atom->getType() );
620 >          the_atoms[index]->setIndex( index );
621 >          
622 >          // increment the index and repeat;
623 >          index++;
624 >        }
625 >        
626 >        molEnd = index -1;
627 >        the_molecules[lMolIndex].setNMembers( nMemb );
628 >        the_molecules[lMolIndex].setStartAtom( molStart );
629 >        the_molecules[lMolIndex].setEndAtom( molEnd );
630 >        the_molecules[lMolIndex].setStampID( i );
631 >        lMolIndex++;
632  
633 <      molEnd = index -1;
634 <      the_molecules[molIndex].setNMembers( nMemb );
635 <      the_molecules[molIndex].setStartAtom( molStart );
636 <      the_molecules[molIndex].setEndAtom( molEnd );
633 > #ifdef IS_MPI
634 >      }
635 > #endif //is_mpi
636 >      
637        molIndex++;
467 –
638      }
639    }
640  
# Line 473 | Line 643 | void SimSetup::makeBonds( void ){
643  
644   void SimSetup::makeBonds( void ){
645  
646 <  int i, j, k, index, offset;
646 >  int i, j, k, index, offset, molIndex;
647    bond_pair* the_bonds;
648    BondStamp* current_bond;
649  
650    the_bonds = new bond_pair[tot_bonds];
651    index = 0;
652    offset = 0;
653 +  molIndex = 0;
654    for( i=0; i<n_components; i++ ){
655  
656      for( j=0; j<components_nmol[i]; j++ ){
657  
658 <      for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
659 <
660 <        current_bond = comp_stamps[i]->getBond( k );
661 <        the_bonds[index].a = current_bond->getA() + offset;
662 <        the_bonds[index].b = current_bond->getB() + offset;
663 <
664 <        the_excludes[index].i = the_bonds[index].a;
665 <        the_excludes[index].j = the_bonds[index].b;
666 <
667 <        // increment the index and repeat;
668 <        index++;
658 > #ifdef IS_MPI
659 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
660 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
661 > #endif // is_mpi        
662 >        
663 >        for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
664 >          
665 >          current_bond = comp_stamps[i]->getBond( k );
666 >          the_bonds[index].a = current_bond->getA() + offset;
667 >          the_bonds[index].b = current_bond->getB() + offset;
668 >          
669 >          the_excludes[index].i = the_bonds[index].a;
670 >          the_excludes[index].j = the_bonds[index].b;
671 >          
672 >          // increment the index and repeat;
673 >          index++;
674 >        }
675 >        offset += comp_stamps[i]->getNAtoms();
676 >        
677 > #ifdef IS_MPI
678        }
679 <      offset += comp_stamps[i]->getNAtoms();
680 <    }
679 > #endif is_mpi
680 >      
681 >      molIndex++;
682 >    }      
683    }
684  
685    the_ff->initializeBonds( the_bonds );
# Line 505 | Line 687 | void SimSetup::makeBends( void ){
687  
688   void SimSetup::makeBends( void ){
689  
690 <  int i, j, k, index, offset;
690 >  int i, j, k, index, offset, molIndex;
691    bend_set* the_bends;
692    BendStamp* current_bend;
693  
694    the_bends = new bend_set[tot_bends];
695    index = 0;
696    offset = 0;
697 +  molIndex = 0;
698    for( i=0; i<n_components; i++ ){
699  
700      for( j=0; j<components_nmol[i]; j++ ){
701  
702 <      for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
702 > #ifdef IS_MPI
703 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
704 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
705 > #endif // is_mpi        
706  
707 <        current_bend = comp_stamps[i]->getBend( k );
708 <        the_bends[index].a = current_bend->getA() + offset;
709 <        the_bends[index].b = current_bend->getB() + offset;
710 <        the_bends[index].c = current_bend->getC() + offset;
711 <
712 <        the_excludes[index + tot_bonds].i = the_bends[index].a;
713 <        the_excludes[index + tot_bonds].j = the_bends[index].c;
714 <
715 <        // increment the index and repeat;
716 <        index++;
707 >        for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
708 >          
709 >          current_bend = comp_stamps[i]->getBend( k );
710 >          the_bends[index].a = current_bend->getA() + offset;
711 >          the_bends[index].b = current_bend->getB() + offset;
712 >          the_bends[index].c = current_bend->getC() + offset;
713 >          
714 >          the_excludes[index + tot_bonds].i = the_bends[index].a;
715 >          the_excludes[index + tot_bonds].j = the_bends[index].c;
716 >          
717 >          // increment the index and repeat;
718 >          index++;
719 >        }
720 >        offset += comp_stamps[i]->getNAtoms();
721 >        
722 > #ifdef IS_MPI
723        }
724 <      offset += comp_stamps[i]->getNAtoms();
724 > #endif //is_mpi
725 >
726 >      molIndex++;
727      }
728    }
729  
# Line 538 | Line 732 | void SimSetup::makeTorsions( void ){
732  
733   void SimSetup::makeTorsions( void ){
734  
735 <  int i, j, k, index, offset;
735 >  int i, j, k, index, offset, molIndex;
736    torsion_set* the_torsions;
737    TorsionStamp* current_torsion;
738  
739    the_torsions = new torsion_set[tot_torsions];
740    index = 0;
741    offset = 0;
742 +  molIndex = 0;
743    for( i=0; i<n_components; i++ ){
744  
745      for( j=0; j<components_nmol[i]; j++ ){
746  
747 + #ifdef IS_MPI
748 +      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
749 +          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
750 + #endif // is_mpi        
751 +
752        for( k=0; k<comp_stamps[i]->getNTorsions(); k++ ){
753  
754          current_torsion = comp_stamps[i]->getTorsion( k );
# Line 564 | Line 764 | void SimSetup::makeTorsions( void ){
764          index++;
765        }
766        offset += comp_stamps[i]->getNAtoms();
767 +
768 + #ifdef IS_MPI
769 +      }
770 + #endif //is_mpi      
771 +
772 +      molIndex++;
773      }
774    }
775  
# Line 597 | Line 803 | void SimSetup::initFromBass( void ){
803      n_per_extra = (int)ceil( temp1 );
804  
805      if( n_per_extra > 4){
806 <      std::cerr << "THere has been an error in constructing the non-complete lattice.\n";
807 <      exit(8);
806 >      sprintf( painCave.errMsg,
807 >               "SimSetup error. There has been an error in constructing"
808 >               " the non-complete lattice.\n" );
809 >      painCave.isFatal = 1;
810 >      simError();
811      }
812    }
813    else{
# Line 703 | Line 912 | void SimSetup::makeElement( double x, double y, double
912  
913      current_atom = comp_stamps[current_comp]->getAtom( k );
914      if( !current_atom->havePosition() ){
915 <      std::cerr << "Component " << comp_stamps[current_comp]->getID()
916 <                << ", atom " << current_atom->getType()
917 <                << " does not have a position specified.\n"
918 <                << "The initialization routine is unable to give a start"
919 <                << " position.\n";
920 <      exit(8);
915 >      sprintf( painCave.errMsg,
916 >               "SimSetup:initFromBass error.\n"
917 >               "\tComponent %s, atom %s does not have a position specified.\n"
918 >               "\tThe initialization routine is unable to give a start"
919 >               " position.\n",
920 >               comp_stamps[current_comp]->getID(),
921 >               current_atom->getType() );
922 >      painCave.isFatal = 1;
923 >      simError();
924      }
925  
926      the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines