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 205 by mmeineke, Wed Dec 11 20:39:41 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  
406 +
407 +
408   //   if( the_globals->haveInitialConfig() ){
409   //        InitializeFromFile* fileInit;
410   //     fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
# Line 279 | Line 415 | void SimSetup::createSim( void ){
415   //   }
416   //   else{
417  
418 <    initFromBass();
418 > #ifdef IS_MPI
419  
420 +  // no init from bass
421 +  
422 +  sprintf( painCave.errMsg,
423 +           "Cannot intialize a parallel simulation without an initial configuration file.\n" );
424 +  painCave.isFatal;
425 +  simError();
426 +  
427 + #else
428  
429 < //   }
429 >  initFromBass();
430  
431 + #endif // is_mpi
432 +
433   #ifdef IS_MPI
434 <    if( worldRank == TESTWRITE ){
434 >  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
435 >  MPIcheckPoint();
436   #endif // is_mpi
437 <      
438 <      fprintf( stderr,
439 <               "infile name is \"%s\"\n",
440 <               inFileName );
441 <      
442 <      inFileName = "./butane.bass";
443 <        
444 <      if( the_globals->haveFinalConfig() ){
445 <        strcpy( simnfo->finalName, the_globals->getFinalConfig() );
437 >
438 >
439 >  
440 >
441 >  
442 >  //   }
443 >  
444 > #ifdef IS_MPI
445 >  if( worldRank == 0 ){
446 > #endif // is_mpi
447 >    
448 >    if( the_globals->haveFinalConfig() ){
449 >      strcpy( simnfo->finalName, the_globals->getFinalConfig() );
450 >    }
451 >    else{
452 >      strcpy( simnfo->finalName, inFileName );
453 >      char* endTest;
454 >      int nameLength = strlen( simnfo->finalName );
455 >      endTest = &(simnfo->finalName[nameLength - 5]);
456 >      if( !strcmp( endTest, ".bass" ) ){
457 >        strcpy( endTest, ".eor" );
458        }
459 +      else if( !strcmp( endTest, ".BASS" ) ){
460 +        strcpy( endTest, ".eor" );
461 +      }
462        else{
463 <        strcpy( simnfo->finalName, inFileName );
464 <        char* endTest;
303 <        int nameLength = strlen( simnfo->finalName );
304 <        endTest = &(simnfo->finalName[nameLength - 5]);
305 <        if( !strcmp( endTest, ".bass" ) ){
463 >        endTest = &(simnfo->finalName[nameLength - 4]);
464 >        if( !strcmp( endTest, ".bss" ) ){
465            strcpy( endTest, ".eor" );
466          }
467 <        else if( !strcmp( endTest, ".BASS" ) ){
467 >        else if( !strcmp( endTest, ".mdl" ) ){
468            strcpy( endTest, ".eor" );
469          }
470          else{
471 <          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 <          }
471 >          strcat( simnfo->finalName, ".eor" );
472          }
473        }
474 <      
475 <      // make the sample and status out names
476 <      
477 <      strcpy( simnfo->sampleName, inFileName );
478 <      char* endTest;
479 <      int nameLength = strlen( simnfo->sampleName );
480 <      endTest = &(simnfo->sampleName[nameLength - 5]);
481 <      if( !strcmp( endTest, ".bass" ) ){
474 >    }
475 >    
476 >    // make the sample and status out names
477 >    
478 >    strcpy( simnfo->sampleName, inFileName );
479 >    char* endTest;
480 >    int nameLength = strlen( simnfo->sampleName );
481 >    endTest = &(simnfo->sampleName[nameLength - 5]);
482 >    if( !strcmp( endTest, ".bass" ) ){
483 >      strcpy( endTest, ".dump" );
484 >    }
485 >    else if( !strcmp( endTest, ".BASS" ) ){
486 >      strcpy( endTest, ".dump" );
487 >    }
488 >    else{
489 >      endTest = &(simnfo->sampleName[nameLength - 4]);
490 >      if( !strcmp( endTest, ".bss" ) ){
491          strcpy( endTest, ".dump" );
492        }
493 <      else if( !strcmp( endTest, ".BASS" ) ){
493 >      else if( !strcmp( endTest, ".mdl" ) ){
494          strcpy( endTest, ".dump" );
495        }
496        else{
497 <        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 <        }
497 >        strcat( simnfo->sampleName, ".dump" );
498        }
499 <      
500 <      strcpy( simnfo->statusName, inFileName );
501 <      nameLength = strlen( simnfo->statusName );
502 <      endTest = &(simnfo->statusName[nameLength - 5]);
503 <      if( !strcmp( endTest, ".bass" ) ){
499 >    }
500 >    
501 >    strcpy( simnfo->statusName, inFileName );
502 >    nameLength = strlen( simnfo->statusName );
503 >    endTest = &(simnfo->statusName[nameLength - 5]);
504 >    if( !strcmp( endTest, ".bass" ) ){
505 >      strcpy( endTest, ".stat" );
506 >    }
507 >    else if( !strcmp( endTest, ".BASS" ) ){
508 >      strcpy( endTest, ".stat" );
509 >    }
510 >    else{
511 >      endTest = &(simnfo->statusName[nameLength - 4]);
512 >      if( !strcmp( endTest, ".bss" ) ){
513          strcpy( endTest, ".stat" );
514        }
515 <      else if( !strcmp( endTest, ".BASS" ) ){
515 >      else if( !strcmp( endTest, ".mdl" ) ){
516          strcpy( endTest, ".stat" );
517        }
518        else{
519 <        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 <        }
519 >        strcat( simnfo->statusName, ".stat" );
520        }
371 –      
372 – #ifdef IS_MPI
521      }
522 +    
523 + #ifdef IS_MPI
524 +  }
525   #endif // is_mpi
526 <
526 >  
527    // set the status, sample, and themal kick times
528 <
528 >  
529    if( the_globals->haveSampleTime() ){
530      simnfo->sampleTime = the_globals->getSampleTime();
531      simnfo->statusTime = simnfo->sampleTime;
# Line 414 | Line 565 | void SimSetup::makeAtoms( void ){
565    double ux, uy, uz, uSqr, u;
566    AtomStamp* current_atom;
567    DirectionalAtom* dAtom;
568 <  int molIndex, molStart, molEnd, nMemb;
568 >  int molIndex, molStart, molEnd, nMemb, lMolIndex;
569  
570 <
570 >  lMolIndex = 0;
571    molIndex = 0;
572    index = 0;
573    for( i=0; i<n_components; i++ ){
574  
575      for( j=0; j<components_nmol[i]; j++ ){
576  
577 <      molStart = index;
578 <      nMemb = comp_stamps[i]->getNAtoms();
579 <      for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
577 > #ifdef IS_MPI
578 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
579 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
580 > #endif // is_mpi        
581  
582 <        current_atom = comp_stamps[i]->getAtom( k );
583 <        if( current_atom->haveOrientation() ){
584 <
585 <          dAtom = new DirectionalAtom(index);
586 <          simnfo->n_oriented++;
587 <          the_atoms[index] = dAtom;
588 <
589 <          ux = current_atom->getOrntX();
590 <          uy = current_atom->getOrntY();
591 <          uz = current_atom->getOrntZ();
592 <
593 <          uSqr = (ux * ux) + (uy * uy) + (uz * uz);
594 <
595 <          u = sqrt( uSqr );
596 <          ux = ux / u;
597 <          uy = uy / u;
598 <          uz = uz / u;
599 <
600 <          dAtom->setSUx( ux );
601 <          dAtom->setSUy( uy );
602 <          dAtom->setSUz( uz );
582 >        molStart = index;
583 >        nMemb = comp_stamps[i]->getNAtoms();
584 >        for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
585 >          
586 >          current_atom = comp_stamps[i]->getAtom( k );
587 >          if( current_atom->haveOrientation() ){
588 >            
589 >            dAtom = new DirectionalAtom(index);
590 >            simnfo->n_oriented++;
591 >            the_atoms[index] = dAtom;
592 >            
593 >            ux = current_atom->getOrntX();
594 >            uy = current_atom->getOrntY();
595 >            uz = current_atom->getOrntZ();
596 >            
597 >            uSqr = (ux * ux) + (uy * uy) + (uz * uz);
598 >            
599 >            u = sqrt( uSqr );
600 >            ux = ux / u;
601 >            uy = uy / u;
602 >            uz = uz / u;
603 >            
604 >            dAtom->setSUx( ux );
605 >            dAtom->setSUy( uy );
606 >            dAtom->setSUz( uz );
607 >          }
608 >          else{
609 >            the_atoms[index] = new GeneralAtom(index);
610 >          }
611 >          the_atoms[index]->setType( current_atom->getType() );
612 >          the_atoms[index]->setIndex( index );
613 >          
614 >          // increment the index and repeat;
615 >          index++;
616          }
617 <        else{
618 <          the_atoms[index] = new GeneralAtom(index);
619 <        }
620 <        the_atoms[index]->setType( current_atom->getType() );
621 <        the_atoms[index]->setIndex( index );
617 >        
618 >        molEnd = index -1;
619 >        the_molecules[lMolIndex].setNMembers( nMemb );
620 >        the_molecules[lMolIndex].setStartAtom( molStart );
621 >        the_molecules[lMolIndex].setEndAtom( molEnd );
622 >        the_molecules[lMolIndex].setStampID( i );
623 >        lMolIndex++;
624  
625 <        // increment the index and repeat;
459 <        index++;
625 > #ifdef IS_MPI
626        }
627 <
628 <      molEnd = index -1;
463 <      the_molecules[molIndex].setNMembers( nMemb );
464 <      the_molecules[molIndex].setStartAtom( molStart );
465 <      the_molecules[molIndex].setEndAtom( molEnd );
627 > #endif //is_mpi
628 >      
629        molIndex++;
467 –
630      }
631    }
632  
# Line 473 | Line 635 | void SimSetup::makeBonds( void ){
635  
636   void SimSetup::makeBonds( void ){
637  
638 <  int i, j, k, index, offset;
638 >  int i, j, k, index, offset, molIndex;
639    bond_pair* the_bonds;
640    BondStamp* current_bond;
641  
642    the_bonds = new bond_pair[tot_bonds];
643    index = 0;
644    offset = 0;
645 +  molIndex = 0;
646    for( i=0; i<n_components; i++ ){
647  
648      for( j=0; j<components_nmol[i]; j++ ){
649  
650 <      for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
651 <
652 <        current_bond = comp_stamps[i]->getBond( k );
653 <        the_bonds[index].a = current_bond->getA() + offset;
654 <        the_bonds[index].b = current_bond->getB() + offset;
655 <
656 <        the_excludes[index].i = the_bonds[index].a;
657 <        the_excludes[index].j = the_bonds[index].b;
658 <
659 <        // increment the index and repeat;
660 <        index++;
650 > #ifdef IS_MPI
651 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
652 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
653 > #endif // is_mpi        
654 >        
655 >        for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
656 >          
657 >          current_bond = comp_stamps[i]->getBond( k );
658 >          the_bonds[index].a = current_bond->getA() + offset;
659 >          the_bonds[index].b = current_bond->getB() + offset;
660 >          
661 >          the_excludes[index].i = the_bonds[index].a;
662 >          the_excludes[index].j = the_bonds[index].b;
663 >          
664 >          // increment the index and repeat;
665 >          index++;
666 >        }
667 >        offset += comp_stamps[i]->getNAtoms();
668 >        
669 > #ifdef IS_MPI
670        }
671 <      offset += comp_stamps[i]->getNAtoms();
672 <    }
671 > #endif is_mpi
672 >      
673 >      molIndex++;
674 >    }      
675    }
676  
677    the_ff->initializeBonds( the_bonds );
# Line 505 | Line 679 | void SimSetup::makeBends( void ){
679  
680   void SimSetup::makeBends( void ){
681  
682 <  int i, j, k, index, offset;
682 >  int i, j, k, index, offset, molIndex;
683    bend_set* the_bends;
684    BendStamp* current_bend;
685  
686    the_bends = new bend_set[tot_bends];
687    index = 0;
688    offset = 0;
689 +  molIndex = 0;
690    for( i=0; i<n_components; i++ ){
691  
692      for( j=0; j<components_nmol[i]; j++ ){
693  
694 <      for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
695 <
696 <        current_bend = comp_stamps[i]->getBend( k );
697 <        the_bends[index].a = current_bend->getA() + offset;
523 <        the_bends[index].b = current_bend->getB() + offset;
524 <        the_bends[index].c = current_bend->getC() + offset;
694 > #ifdef IS_MPI
695 >      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
696 >          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
697 > #endif // is_mpi        
698  
699 <        the_excludes[index + tot_bonds].i = the_bends[index].a;
700 <        the_excludes[index + tot_bonds].j = the_bends[index].c;
701 <
702 <        // increment the index and repeat;
703 <        index++;
699 >        for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
700 >          
701 >          current_bend = comp_stamps[i]->getBend( k );
702 >          the_bends[index].a = current_bend->getA() + offset;
703 >          the_bends[index].b = current_bend->getB() + offset;
704 >          the_bends[index].c = current_bend->getC() + offset;
705 >          
706 >          the_excludes[index + tot_bonds].i = the_bends[index].a;
707 >          the_excludes[index + tot_bonds].j = the_bends[index].c;
708 >          
709 >          // increment the index and repeat;
710 >          index++;
711 >        }
712 >        offset += comp_stamps[i]->getNAtoms();
713 >        
714 > #ifdef IS_MPI
715        }
716 <      offset += comp_stamps[i]->getNAtoms();
716 > #endif //is_mpi
717 >
718 >      molIndex++;
719      }
720    }
721  
# Line 538 | Line 724 | void SimSetup::makeTorsions( void ){
724  
725   void SimSetup::makeTorsions( void ){
726  
727 <  int i, j, k, index, offset;
727 >  int i, j, k, index, offset, molIndex;
728    torsion_set* the_torsions;
729    TorsionStamp* current_torsion;
730  
731    the_torsions = new torsion_set[tot_torsions];
732    index = 0;
733    offset = 0;
734 +  molIndex = 0;
735    for( i=0; i<n_components; i++ ){
736  
737      for( j=0; j<components_nmol[i]; j++ ){
738  
739 + #ifdef IS_MPI
740 +      if( simnfo->mpiSim->getMyMolStart() <= molIndex &&
741 +          molIndex <= simnfo->mpiSim->getMyMolEnd() ){
742 + #endif // is_mpi        
743 +
744        for( k=0; k<comp_stamps[i]->getNTorsions(); k++ ){
745  
746          current_torsion = comp_stamps[i]->getTorsion( k );
# Line 564 | Line 756 | void SimSetup::makeTorsions( void ){
756          index++;
757        }
758        offset += comp_stamps[i]->getNAtoms();
759 +
760 + #ifdef IS_MPI
761 +      }
762 + #endif //is_mpi      
763 +
764 +      molIndex++;
765      }
766    }
767  
# Line 597 | Line 795 | void SimSetup::initFromBass( void ){
795      n_per_extra = (int)ceil( temp1 );
796  
797      if( n_per_extra > 4){
798 <      std::cerr << "THere has been an error in constructing the non-complete lattice.\n";
799 <      exit(8);
798 >      sprintf( painCave.errMsg,
799 >               "SimSetup error. There has been an error in constructing"
800 >               " the non-complete lattice.\n" );
801 >      painCave.isFatal = 1;
802 >      simError();
803      }
804    }
805    else{
# Line 703 | Line 904 | void SimSetup::makeElement( double x, double y, double
904  
905      current_atom = comp_stamps[current_comp]->getAtom( k );
906      if( !current_atom->havePosition() ){
907 <      std::cerr << "Component " << comp_stamps[current_comp]->getID()
908 <                << ", atom " << current_atom->getType()
909 <                << " does not have a position specified.\n"
910 <                << "The initialization routine is unable to give a start"
911 <                << " position.\n";
912 <      exit(8);
907 >      sprintf( painCave.errMsg,
908 >               "SimSetup:initFromBass error.\n"
909 >               "\tComponent %s, atom %s does not have a position specified.\n"
910 >               "\tThe initialization routine is unable to give a start"
911 >               " position.\n",
912 >               comp_stamps[current_comp]->getID(),
913 >               current_atom->getType() );
914 >      painCave.isFatal = 1;
915 >      simError();
916      }
917  
918      the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );

Diff Legend

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