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 131 by chuckv, Wed Oct 9 22:29:40 2002 UTC vs.
Revision 206 by chuckv, Thu Dec 12 21:21:59 2002 UTC

# Line 6 | Line 6
6   #include "parse_me.h"
7   #include "LRI.hpp"
8   #include "Integrator.hpp"
9 + #include "simError.h"
10 +
11   #ifdef IS_MPI
12 < #include "mpiInterface.h"
12 > #include "mpiBASS.h"
13   #include "bassDiag.hpp"
14   #endif
15  
16   SimSetup::SimSetup(){
17    stamps = new MakeStamps();
18    globals = new Globals();
19 +  
20 + #ifdef IS_MPI
21 +  strcpy( checkPointMsg, "SimSetup creation successful" );
22 +  MPIcheckPoint();
23 + #endif // IS_MPI
24   }
25  
26   SimSetup::~SimSetup(){
# Line 23 | Line 30 | void SimSetup::parseFile( char* fileName ){
30  
31   void SimSetup::parseFile( char* fileName ){
32  
26 –  inFileName = fileName;
27 –  set_interface_stamps( stamps, globals );
33   #ifdef IS_MPI
34 <  mpiEventInit();
34 >  if( worldRank == 0 ){
35 > #endif // is_mpi
36 >    
37 >    inFileName = fileName;
38 >    set_interface_stamps( stamps, globals );
39 >    
40 > #ifdef IS_MPI
41 >    mpiEventInit();
42   #endif
43 <  yacc_BASS( fileName );
43 >
44 >    yacc_BASS( fileName );
45 >
46   #ifdef IS_MPI
47 <  throwMPIEvent(NULL);
47 >    throwMPIEvent(NULL);
48 >  }
49 >  else receiveParse();
50   #endif
51  
52   }
# Line 40 | Line 56 | void SimSetup::receiveParse(void){
56  
57      set_interface_stamps( stamps, globals );
58      mpiEventInit();
59 +    MPIcheckPoint();
60      mpiEventLoop();
61  
62   }
# Line 51 | Line 68 | void SimSetup::testMe(void){
68    delete dumpMe;
69   }
70   #endif
71 +
72   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 75 | Line 93 | void SimSetup::createSim( void ){
93    else if( !strcmp( force_field, "DipoleTest" ) ) the_ff = new DipoleTestFF();
94    else if( !strcmp( force_field, "TraPPE_Ex" ) ) the_ff = new TraPPE_ExFF();
95    else{
96 <    std::cerr<< "SimSetup Error. Unrecognized force field -> "
97 <             << force_field << "\n";
98 <    exit(8);
96 >    sprintf( painCave.errMsg,
97 >             "SimSetup Error. Unrecognized force field -> %s\n",
98 >             force_field );
99 >    painCave.isFatal = 1;
100 >    simError();
101    }
102  
103 + #ifdef IS_MPI
104 +  strcpy( checkPointMsg, "ForceField creation successful" );
105 +  MPIcheckPoint();
106 + #endif // is_mpi
107 +
108    // get the components and calculate the tot_nMol and indvidual n_mol
109    the_components = the_globals->getComponents();
110    components_nmol = new int[n_components];
# Line 94 | 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 104 | 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 137 | 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 151 | 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 <  the_atoms = new Atom*[tot_atoms];
299 <  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 189 | Line 331 | void SimSetup::createSim( void ){
331      makeTorsions();
332    }
333  
192 –  //  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 224 | 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  
246 – //   if( the_globals->haveInitialConfig() ){
247 – //        InitializeFromFile* fileInit;
248 – //     fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
406  
250 – //     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 < //   if( the_globals->haveFinalConfig() ){
262 < //     strcpy( simnfo->finalName, the_globals->getFinalConfig() );
263 < //   }
264 < //   else{
265 < //     strcpy( simnfo->finalName, inFileName );
266 < //     char* endTest;
267 < //     int nameLength = strlen( simnfo->finalName );
268 < //     endTest = &(simnfo->finalName[nameLength - 5]);
269 < //     if( !strcmp( endTest, ".bass" ) ){
270 < //       strcpy( endTest, ".eor" );
271 < //     }
272 < //     else if( !strcmp( endTest, ".BASS" ) ){
273 < //       strcpy( endTest, ".eor" );
274 < //     }
275 < //     else{
276 < //       endTest = &(simnfo->finalName[nameLength - 4]);
277 < //       if( !strcmp( endTest, ".bss" ) ){
278 < //      strcpy( endTest, ".eor" );
279 < //       }
280 < //       else if( !strcmp( endTest, ".mdl" ) ){
281 < //      strcpy( endTest, ".eor" );
282 < //       }
283 < //       else{
284 < //      strcat( simnfo->finalName, ".eor" );
285 < //       }
286 < //     }
287 < //   }
435 >  initFromBass();
436  
289 – //   // make the sample and status out names
437  
438 < //   strcpy( simnfo->sampleName, inFileName );
439 < //   char* endTest;
293 < //   int nameLength = strlen( simnfo->sampleName );
294 < //   endTest = &(simnfo->sampleName[nameLength - 5]);
295 < //   if( !strcmp( endTest, ".bass" ) ){
296 < //     strcpy( endTest, ".dump" );
297 < //   }
298 < //   else if( !strcmp( endTest, ".BASS" ) ){
299 < //     strcpy( endTest, ".dump" );
300 < //   }
301 < //   else{
302 < //     endTest = &(simnfo->sampleName[nameLength - 4]);
303 < //     if( !strcmp( endTest, ".bss" ) ){
304 < //       strcpy( endTest, ".dump" );
305 < //     }
306 < //     else if( !strcmp( endTest, ".mdl" ) ){
307 < //       strcpy( endTest, ".dump" );
308 < //     }
309 < //     else{
310 < //       strcat( simnfo->sampleName, ".dump" );
311 < //     }
312 < //   }
438 > #endif
439 > }
440  
441 < //   strcpy( simnfo->statusName, inFileName );
442 < //   nameLength = strlen( simnfo->statusName );
443 < //   endTest = &(simnfo->statusName[nameLength - 5]);
444 < //   if( !strcmp( endTest, ".bass" ) ){
318 < //     strcpy( endTest, ".stat" );
319 < //   }
320 < //   else if( !strcmp( endTest, ".BASS" ) ){
321 < //     strcpy( endTest, ".stat" );
322 < //   }
323 < //   else{
324 < //     endTest = &(simnfo->statusName[nameLength - 4]);
325 < //     if( !strcmp( endTest, ".bss" ) ){
326 < //       strcpy( endTest, ".stat" );
327 < //     }
328 < //     else if( !strcmp( endTest, ".mdl" ) ){
329 < //       strcpy( endTest, ".stat" );
330 < //     }
331 < //     else{
332 < //       strcat( simnfo->statusName, ".stat" );
333 < //     }
334 < //   }
441 > #ifdef IS_MPI
442 >  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
443 >  MPIcheckPoint();
444 > #endif // is_mpi
445  
446  
447 <  // set the status, sample, and themal kick times
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 +        endTest = &(simnfo->finalName[nameLength - 4]);
472 +        if( !strcmp( endTest, ".bss" ) ){
473 +          strcpy( endTest, ".eor" );
474 +        }
475 +        else if( !strcmp( endTest, ".mdl" ) ){
476 +          strcpy( endTest, ".eor" );
477 +        }
478 +        else{
479 +          strcat( simnfo->finalName, ".eor" );
480 +        }
481 +      }
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, ".mdl" ) ){
502 +        strcpy( endTest, ".dump" );
503 +      }
504 +      else{
505 +        strcat( simnfo->sampleName, ".dump" );
506 +      }
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, ".mdl" ) ){
524 +        strcpy( endTest, ".stat" );
525 +      }
526 +      else{
527 +        strcat( simnfo->statusName, ".stat" );
528 +      }
529 +    }
530 +    
531 + #ifdef IS_MPI
532 +  }
533 + #endif // is_mpi
534 +  
535 +  // set the status, sample, and themal kick times
536 +  
537    if( the_globals->haveSampleTime() ){
538      simnfo->sampleTime = the_globals->getSampleTime();
539      simnfo->statusTime = simnfo->sampleTime;
# Line 375 | 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;
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;
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++;
428 –
638      }
639    }
640  
# Line 434 | 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 466 | 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 499 | 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 525 | 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 558 | 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 664 | 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