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

Comparing:
branches/mmeineke/mdtools/interface_implementation/SimSetup.cpp (file contents), Revision 10 by mmeineke, Tue Jul 9 18:40:59 2002 UTC vs.
trunk/mdtools/interface_implementation/SimSetup.cpp (file contents), Revision 198 by mmeineke, Fri Dec 6 21:20:42 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 "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 19 | Line 30 | void SimSetup::parseFile( char* fileName ){
30  
31   void SimSetup::parseFile( char* fileName ){
32  
33 <  inFileName = fileName;
34 <  set_interface_stamps( stamps, globals );
35 <  yacc_BASS( fileName );
33 > #ifdef IS_MPI
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 >
44 >    yacc_BASS( fileName );
45 >
46 > #ifdef IS_MPI
47 >    throwMPIEvent(NULL);
48 >  }
49 >  else receiveParse();
50 > #endif
51 >
52   }
53  
54 + #ifdef IS_MPI
55 + void SimSetup::receiveParse(void){
56 +
57 +    set_interface_stamps( stamps, globals );
58 +    mpiEventInit();
59 +    MPIcheckPoint();
60 +    mpiEventLoop();
61 +
62 + }
63 +
64 +
65 + void SimSetup::testMe(void){
66 +  bassDiag* dumpMe = new bassDiag(globals,stamps);
67 +  dumpMe->dumpStamps();
68 +  delete dumpMe;
69 + }
70 + #endif
71 +
72   void SimSetup::createSim( void ){
73  
74    MakeStamps *the_stamps;
# Line 43 | Line 88 | void SimSetup::createSim( void ){
88    n_components = the_globals->getNComponents();
89    strcpy( force_field, the_globals->getForceField() );
90    strcpy( ensemble, the_globals->getEnsemble() );
91 <  
91 >
92    if( !strcmp( force_field, "TraPPE" ) ) the_ff = new TraPPEFF();
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];
111    comp_stamps = new MoleculeStamp*[n_components];
112 <  
112 >
113    if( !the_globals->haveNMol() ){
114 <    // we don't have the total number of molecules, so we assume it is
114 >    // we don't have the total number of molecules, so we assume it is
115      // given in each component
116  
117      tot_nmol = 0;
118      for( i=0; i<n_components; i++ ){
119 <      
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 77 | Line 131 | void SimSetup::createSim( void ){
131      }
132    }
133    else{
134 <    std::cerr << "NOT A SUPPORTED FEATURE\n";
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      
82 – //     tot_nmol = the_globals->getNMol();
143      
144 < //     //we have the total number of molecules, now we check for molfractions
145 < //     for( i=0; i<n_components; i++ ){
146 <      
147 < //       if( !the_components[i]->haveMolFraction() ){
148 <        
149 < //      if( !the_components[i]->haveNMol() ){
150 < //        //we have a problem
151 < //        std::cerr << "SimSetup error. Neither molFraction nor "
152 < //                  << " nMol was given in component
153 <
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 110 | Line 213 | void SimSetup::createSim( void ){
213    tot_bends = 0;
214    tot_torsions = 0;
215    for( i=0; i<n_components; i++ ){
216 <    
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 <  
222 >
223    tot_SRI = tot_bonds + tot_bends + tot_torsions;
224 <  
224 >
225    simnfo->n_atoms = tot_atoms;
226    simnfo->n_bonds = tot_bonds;
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  
128 –  // create the atom and short range interaction arrays
232    
233 <  the_atoms = new Atom*[tot_atoms];
234 <  //  the_molecules = new Molecule[tot_nmol];
233 > #ifdef IS_MPI
234 >
235 >  // divide the molecules among processors here.
236    
237 +  new mpiSimulation( simnfo );
238    
239 <  if( tot_SRI ){
240 <    the_sris = new SRI*[tot_SRI];
241 <    the_excludes = new ex_pair[tot_SRI];
239 >  simnfo->mpiSim->divideLabor( n_components, comp_stamps, components_nmol );
240 >
241 > #endif // is_mpi
242 >  
243 >
244 >  // create the atom and short range interaction arrays
245 >
246 >  Atom::createArrays(simnfo->n_atoms);
247 >  the_atoms = new Atom*[simnfo->n_atoms];
248 >  the_molecules = new Molecule[simnfo->n_mol];
249 >
250 >
251 >  if( simnfo->n_SRI ){
252 >    the_sris = new SRI*[simnfo->n_SRI];
253 >    the_excludes = new ex_pair[simnfo->n_SRI];
254    }
255  
256    // set the arrays into the SimInfo object
# Line 143 | Line 260 | void SimSetup::createSim( void ){
260    simnfo->n_exclude = tot_SRI;
261    simnfo->excludes = the_excludes;
262  
263 +
264    // initialize the arrays
265 <  
265 >
266    the_ff->setSimInfo( simnfo );
267 <    
267 >
268    makeAtoms();
269  
270    if( tot_bonds ){
# Line 161 | Line 279 | void SimSetup::createSim( void ){
279      makeTorsions();
280    }
281  
164 –  //  makeMolecules();
282  
283    // get some of the tricky things that may still be in the globals
284  
285    if( simnfo->n_dipoles ){
286  
287      if( !the_globals->haveRRF() ){
288 <      std::cerr << "SimSetup Error, system has dipoles, but no rRF was set.\n";
289 <      exit(8);
288 >      sprintf( painCave.errMsg,
289 >               "SimSetup Error, system has dipoles, but no rRF was set.\n");
290 >      painCave.isFatal = 1;
291 >      simError();
292      }
293      if( !the_globals->haveDielectric() ){
294 <      std::cerr << "SimSetup Error, system has dipoles, but no"
295 <                << " dielectric was set.\n";
296 <      exit(8);
294 >      sprintf( painCave.errMsg,
295 >               "SimSetup Error, system has dipoles, but no"
296 >               " dielectric was set.\n" );
297 >      painCave.isFatal = 1;
298 >      simError();
299      }
300  
301      simnfo->rRF        = the_globals->getRRF();
302      simnfo->dielectric = the_globals->getDielectric();
303    }
304  
305 + #ifdef IS_MPI
306 +  strcpy( checkPointMsg, "rRf and dielectric check out" );
307 +  MPIcheckPoint();
308 + #endif // is_mpi
309 +  
310    if( the_globals->haveBox() ){
311      simnfo->box_x = the_globals->getBox();
312      simnfo->box_y = the_globals->getBox();
313      simnfo->box_z = the_globals->getBox();
314    }
315    else if( the_globals->haveDensity() ){
316 <    
316 >
317      double vol;
318      vol = (double)tot_nmol / the_globals->getDensity();
319      simnfo->box_x = pow( vol, ( 1.0 / 3.0 ) );
# Line 196 | Line 322 | void SimSetup::createSim( void ){
322    }
323    else{
324      if( !the_globals->haveBoxX() ){
325 <      std::cerr << "SimSetup error, no periodic BoxX size given.\n";
326 <      exit(8);
325 >      sprintf( painCave.errMsg,
326 >               "SimSetup error, no periodic BoxX size given.\n" );
327 >      painCave.isFatal = 1;
328 >      simError();
329      }
330      simnfo->box_x = the_globals->getBoxX();
331  
332      if( !the_globals->haveBoxY() ){
333 <      std::cerr << "SimSetup error, no periodic BoxY size given.\n";
334 <      exit(8);
333 >      sprintf( painCave.errMsg,
334 >               "SimSetup error, no periodic BoxY size given.\n" );
335 >      painCave.isFatal = 1;
336 >      simError();
337      }
338      simnfo->box_y = the_globals->getBoxY();
339  
340      if( !the_globals->haveBoxZ() ){
341 <      std::cerr << "SimSetup error, no periodic BoxZ size given.\n";
342 <      exit(8);
341 >      sprintf( painCave.errMsg,
342 >               "SimSetup error, no periodic BoxZ size given.\n" );
343 >      painCave.isFatal = 1;
344 >      simError();
345      }
346      simnfo->box_z = the_globals->getBoxZ();
347    }
216 –    
217 –  if( the_globals->haveInitialConfig() ){
218 –    InitializeFromFile* fileInit;
219 –    fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
220 –    
221 –    fileInit->read_xyz( simnfo ); // default velocities on
348  
349 <    delete fileInit;    
350 <  }
351 <  else{
352 <    initFromBass();
227 <  }
349 > #ifdef IS_MPI
350 >  strcpy( checkPointMsg, "Box size set up" );
351 >  MPIcheckPoint();
352 > #endif // is_mpi
353  
354 <  if( the_globals->haveFinalConfig() ){
355 <    strcpy( simnfo->finalName, the_globals->getFinalConfig() );
356 <  }
357 <  else{
358 <    strcpy( simnfo->finalName, inFileName );
359 <    char* endTest;
360 <    int nameLength = strlen( simnfo->finalName );
361 <    endTest = &(simnfo->finalName[nameLength - 5]);
362 <    if( !strcmp( endTest, ".bass" ) ){
363 <      strcpy( endTest, ".eor" );
364 <    }
365 <    else if( !strcmp( endTest, ".BASS" ) ){
366 <      strcpy( endTest, ".eor" );
354 >
355 >
356 > //   if( the_globals->haveInitialConfig() ){
357 > //        InitializeFromFile* fileInit;
358 > //     fileInit = new InitializeFromFile( the_globals->getInitialConfig() );
359 >
360 > //     fileInit->read_xyz( simnfo ); // default velocities on
361 >
362 > //     delete fileInit;
363 > //   }
364 > //   else{
365 >
366 > #ifdef IS_MPI
367 >
368 >  // no init from bass
369 >  
370 >  sprintf( painCave.errMsg,
371 >           "Cannot intialize a parallel simulation without an initial configuration file.\n" );
372 >  painCave.isFatal;
373 >  simError();
374 >  
375 > #else
376 >
377 >  initFromBass();
378 >
379 > #endif // is_mpi
380 >
381 > #ifdef IS_MPI
382 >  strcpy( checkPointMsg, "Successfully read in the initial configuration" );
383 >  MPIcheckPoint();
384 > #endif // is_mpi
385 >
386 >
387 >  
388 >
389 >  
390 >  //   }
391 >  
392 > #ifdef IS_MPI
393 >  if( worldRank == 0 ){
394 > #endif // is_mpi
395 >    
396 >    if( the_globals->haveFinalConfig() ){
397 >      strcpy( simnfo->finalName, the_globals->getFinalConfig() );
398      }
399      else{
400 <      endTest = &(simnfo->finalName[nameLength - 4]);
401 <      if( !strcmp( endTest, ".bss" ) ){
400 >      strcpy( simnfo->finalName, inFileName );
401 >      char* endTest;
402 >      int nameLength = strlen( simnfo->finalName );
403 >      endTest = &(simnfo->finalName[nameLength - 5]);
404 >      if( !strcmp( endTest, ".bass" ) ){
405          strcpy( endTest, ".eor" );
406        }
407 <      else if( !strcmp( endTest, ".mdl" ) ){
407 >      else if( !strcmp( endTest, ".BASS" ) ){
408          strcpy( endTest, ".eor" );
409        }
410        else{
411 <        strcat( simnfo->finalName, ".eor" );
411 >        endTest = &(simnfo->finalName[nameLength - 4]);
412 >        if( !strcmp( endTest, ".bss" ) ){
413 >          strcpy( endTest, ".eor" );
414 >        }
415 >        else if( !strcmp( endTest, ".mdl" ) ){
416 >          strcpy( endTest, ".eor" );
417 >        }
418 >        else{
419 >          strcat( simnfo->finalName, ".eor" );
420 >        }
421        }
422      }
255 –  }
423      
424 <  // make the sample and status out names
425 <
426 <  strcpy( simnfo->sampleName, inFileName );
427 <  char* endTest;
428 <  int nameLength = strlen( simnfo->sampleName );
429 <  endTest = &(simnfo->sampleName[nameLength - 5]);
430 <  if( !strcmp( endTest, ".bass" ) ){
264 <    strcpy( endTest, ".dump" );
265 <  }
266 <  else if( !strcmp( endTest, ".BASS" ) ){
267 <    strcpy( endTest, ".dump" );
268 <  }
269 <  else{
270 <    endTest = &(simnfo->sampleName[nameLength - 4]);
271 <    if( !strcmp( endTest, ".bss" ) ){
424 >    // make the sample and status out names
425 >    
426 >    strcpy( simnfo->sampleName, inFileName );
427 >    char* endTest;
428 >    int nameLength = strlen( simnfo->sampleName );
429 >    endTest = &(simnfo->sampleName[nameLength - 5]);
430 >    if( !strcmp( endTest, ".bass" ) ){
431        strcpy( endTest, ".dump" );
432      }
433 <    else if( !strcmp( endTest, ".mdl" ) ){
433 >    else if( !strcmp( endTest, ".BASS" ) ){
434        strcpy( endTest, ".dump" );
435      }
436      else{
437 <      strcat( simnfo->sampleName, ".dump" );
437 >      endTest = &(simnfo->sampleName[nameLength - 4]);
438 >      if( !strcmp( endTest, ".bss" ) ){
439 >        strcpy( endTest, ".dump" );
440 >      }
441 >      else if( !strcmp( endTest, ".mdl" ) ){
442 >        strcpy( endTest, ".dump" );
443 >      }
444 >      else{
445 >        strcat( simnfo->sampleName, ".dump" );
446 >      }
447      }
448 <  }
449 <  
450 <  strcpy( simnfo->statusName, inFileName );
451 <  nameLength = strlen( simnfo->statusName );
452 <  endTest = &(simnfo->statusName[nameLength - 5]);
285 <  if( !strcmp( endTest, ".bass" ) ){
286 <    strcpy( endTest, ".stat" );
287 <  }
288 <  else if( !strcmp( endTest, ".BASS" ) ){
289 <    strcpy( endTest, ".stat" );
290 <  }
291 <  else{
292 <    endTest = &(simnfo->statusName[nameLength - 4]);
293 <    if( !strcmp( endTest, ".bss" ) ){
448 >    
449 >    strcpy( simnfo->statusName, inFileName );
450 >    nameLength = strlen( simnfo->statusName );
451 >    endTest = &(simnfo->statusName[nameLength - 5]);
452 >    if( !strcmp( endTest, ".bass" ) ){
453        strcpy( endTest, ".stat" );
454      }
455 <    else if( !strcmp( endTest, ".mdl" ) ){
455 >    else if( !strcmp( endTest, ".BASS" ) ){
456        strcpy( endTest, ".stat" );
457      }
458      else{
459 <      strcat( simnfo->statusName, ".stat" );
459 >      endTest = &(simnfo->statusName[nameLength - 4]);
460 >      if( !strcmp( endTest, ".bss" ) ){
461 >        strcpy( endTest, ".stat" );
462 >      }
463 >      else if( !strcmp( endTest, ".mdl" ) ){
464 >        strcpy( endTest, ".stat" );
465 >      }
466 >      else{
467 >        strcat( simnfo->statusName, ".stat" );
468 >      }
469      }
470 +    
471 + #ifdef IS_MPI
472    }
473 + #endif // is_mpi
474    
475    // set the status, sample, and themal kick times
476 <
476 >  
477    if( the_globals->haveSampleTime() ){
478 <    simnfo->sampleTime = the_globals->getSampleTime();
478 >    simnfo->sampleTime = the_globals->getSampleTime();
479      simnfo->statusTime = simnfo->sampleTime;
480      simnfo->thermalTime = simnfo->sampleTime;
481    }
482    else{
483 <    simnfo->sampleTime = the_globals->getRunTime();
483 >    simnfo->sampleTime = the_globals->getRunTime();
484      simnfo->statusTime = simnfo->sampleTime;
485      simnfo->thermalTime = simnfo->sampleTime;
486    }
# Line 325 | Line 496 | void SimSetup::createSim( void ){
496    // check for the temperature set flag
497  
498    if( the_globals->haveTempSet() ) simnfo->setTemp = the_globals->getTempSet();
499 <  
500 <    
499 >
500 >
501    // make the longe range forces and the integrator
502 <  
502 >
503    new AllLong( simnfo );
504 <      
504 >
505    if( !strcmp( force_field, "TraPPE" ) ) new Verlet( *simnfo );
506    if( !strcmp( force_field, "DipoleTest" ) ) new Symplectic( simnfo );
507    if( !strcmp( force_field, "TraPPE_Ex" ) ) new Symplectic( simnfo );
508   }
509  
510   void SimSetup::makeAtoms( void ){
511 <  
511 >
512    int i, j, k, index;
513    double ux, uy, uz, uSqr, u;
514    AtomStamp* current_atom;
515    DirectionalAtom* dAtom;
516 +  int molIndex, molStart, molEnd, nMemb;
517  
518 +
519 +  molIndex = 0;
520    index = 0;
521    for( i=0; i<n_components; i++ ){
522 <    
522 >
523      for( j=0; j<components_nmol[i]; j++ ){
524 <      
524 >
525 >      molStart = index;
526 >      nMemb = comp_stamps[i]->getNAtoms();
527        for( k=0; k<comp_stamps[i]->getNAtoms(); k++ ){
528 <        
528 >
529          current_atom = comp_stamps[i]->getAtom( k );
530 <        if( current_atom->haveOrientation() ){
530 >        if( current_atom->haveOrientation() ){
531  
532 <          dAtom = new DirectionalAtom;
532 >          dAtom = new DirectionalAtom(index);
533            simnfo->n_oriented++;
534            the_atoms[index] = dAtom;
535 <      
535 >
536            ux = current_atom->getOrntX();
537            uy = current_atom->getOrntY();
538            uz = current_atom->getOrntZ();
539 <          
539 >
540            uSqr = (ux * ux) + (uy * uy) + (uz * uz);
541 <          
541 >
542            u = sqrt( uSqr );
543            ux = ux / u;
544            uy = uy / u;
545            uz = uz / u;
546 <          
546 >
547            dAtom->setSUx( ux );
548            dAtom->setSUy( uy );
549            dAtom->setSUz( uz );
550          }
551          else{
552 <          the_atoms[index] = new GeneralAtom;
552 >          the_atoms[index] = new GeneralAtom(index);
553          }
554          the_atoms[index]->setType( current_atom->getType() );
555          the_atoms[index]->setIndex( index );
556 <        
556 >
557          // increment the index and repeat;
558          index++;
559        }
560 +
561 +      molEnd = index -1;
562 +      the_molecules[molIndex].setNMembers( nMemb );
563 +      the_molecules[molIndex].setStartAtom( molStart );
564 +      the_molecules[molIndex].setEndAtom( molEnd );
565 +      molIndex++;
566 +
567      }
568    }
569 <  
569 >
570    the_ff->initializeAtoms();
571   }
572  
# Line 397 | Line 580 | void SimSetup::makeBonds( void ){
580    index = 0;
581    offset = 0;
582    for( i=0; i<n_components; i++ ){
583 <    
583 >
584      for( j=0; j<components_nmol[i]; j++ ){
585 <      
585 >
586        for( k=0; k<comp_stamps[i]->getNBonds(); k++ ){
587 <        
587 >
588          current_bond = comp_stamps[i]->getBond( k );
589          the_bonds[index].a = current_bond->getA() + offset;
590          the_bonds[index].b = current_bond->getB() + offset;
# Line 415 | Line 598 | void SimSetup::makeBonds( void ){
598        offset += comp_stamps[i]->getNAtoms();
599      }
600    }
601 <  
601 >
602    the_ff->initializeBonds( the_bonds );
603   }
604  
# Line 429 | Line 612 | void SimSetup::makeBends( void ){
612    index = 0;
613    offset = 0;
614    for( i=0; i<n_components; i++ ){
615 <    
615 >
616      for( j=0; j<components_nmol[i]; j++ ){
617 <      
617 >
618        for( k=0; k<comp_stamps[i]->getNBends(); k++ ){
619 <        
619 >
620          current_bend = comp_stamps[i]->getBend( k );
621          the_bends[index].a = current_bend->getA() + offset;
622          the_bends[index].b = current_bend->getB() + offset;
# Line 448 | Line 631 | void SimSetup::makeBends( void ){
631        offset += comp_stamps[i]->getNAtoms();
632      }
633    }
634 <  
634 >
635    the_ff->initializeBends( the_bends );
636   }
637  
# Line 462 | Line 645 | void SimSetup::makeTorsions( void ){
645    index = 0;
646    offset = 0;
647    for( i=0; i<n_components; i++ ){
648 <    
648 >
649      for( j=0; j<components_nmol[i]; j++ ){
650 <      
650 >
651        for( k=0; k<comp_stamps[i]->getNTorsions(); k++ ){
652 <        
652 >
653          current_torsion = comp_stamps[i]->getTorsion( k );
654          the_torsions[index].a = current_torsion->getA() + offset;
655          the_torsions[index].b = current_torsion->getB() + offset;
# Line 482 | Line 665 | void SimSetup::makeTorsions( void ){
665        offset += comp_stamps[i]->getNAtoms();
666      }
667    }
668 <  
668 >
669    the_ff->initializeTorsions( the_torsions );
670   }
671  
489 – void SimSetup::makeMolecules( void ){
490 –
491 –  //empy for now
492 – }
493 –
672   void SimSetup::initFromBass( void ){
673  
674    int i, j, k;
# Line 518 | Line 696 | void SimSetup::initFromBass( void ){
696      n_per_extra = (int)ceil( temp1 );
697  
698      if( n_per_extra > 4){
699 <      std::cerr << "THere has been an error in constructing the non-complete lattice.\n";
700 <      exit(8);
699 >      sprintf( painCave.errMsg,
700 >               "SimSetup error. There has been an error in constructing"
701 >               " the non-complete lattice.\n" );
702 >      painCave.isFatal = 1;
703 >      simError();
704      }
705    }
706    else{
# Line 528 | Line 709 | void SimSetup::initFromBass( void ){
709      celly = simnfo->box_y / temp3;
710      cellz = simnfo->box_z / temp3;
711    }
712 <  
712 >
713    current_mol = 0;
714    current_comp_mol = 0;
715    current_comp = 0;
716    current_atom_ndx = 0;
717 <  
717 >
718    for( i=0; i < n_cells ; i++ ){
719      for( j=0; j < n_cells; j++ ){
720        for( k=0; k < n_cells; k++ ){
721 <        
721 >
722          makeElement( i * cellx,
723                       j * celly,
724                       k * cellz );
725 <        
725 >
726          makeElement( i * cellx + 0.5 * cellx,
727                       j * celly + 0.5 * celly,
728                       k * cellz );
729 <        
729 >
730          makeElement( i * cellx,
731                       j * celly + 0.5 * celly,
732                       k * cellz + 0.5 * cellz );
733 <        
733 >
734          makeElement( i * cellx + 0.5 * cellx,
735                       j * celly,
736                       k * cellz + 0.5 * cellz );
# Line 559 | Line 740 | void SimSetup::initFromBass( void ){
740  
741    if( have_extra ){
742      done = 0;
743 <    
743 >
744      int start_ndx;
745      for( i=0; i < (n_cells+1) && !done; i++ ){
746        for( j=0; j < (n_cells+1) && !done; j++ ){
747 <        
747 >
748          if( i < n_cells ){
749 <          
749 >
750            if( j < n_cells ){
751              start_ndx = n_cells;
752            }
753            else start_ndx = 0;
754          }
755          else start_ndx = 0;
756 <        
756 >
757          for( k=start_ndx; k < (n_cells+1) && !done; k++ ){
758 <          
758 >
759            makeElement( i * cellx,
760                         j * celly,
761                         k * cellz );
762            done = ( current_mol >= tot_nmol );
763 <          
763 >
764            if( !done && n_per_extra > 1 ){
765              makeElement( i * cellx + 0.5 * cellx,
766                           j * celly + 0.5 * celly,
767                           k * cellz );
768              done = ( current_mol >= tot_nmol );
769            }
770 <          
770 >
771            if( !done && n_per_extra > 2){
772              makeElement( i * cellx,
773                           j * celly + 0.5 * celly,
774                           k * cellz + 0.5 * cellz );
775              done = ( current_mol >= tot_nmol );
776            }
777 <          
777 >
778            if( !done && n_per_extra > 3){
779              makeElement( i * cellx + 0.5 * cellx,
780                           j * celly,
# Line 604 | Line 785 | void SimSetup::initFromBass( void ){
785        }
786      }
787    }
788 <  
789 <  
788 >
789 >
790    for( i=0; i<simnfo->n_atoms; i++ ){
791      simnfo->atoms[i]->set_vx( 0.0 );
792      simnfo->atoms[i]->set_vy( 0.0 );
# Line 621 | Line 802 | void SimSetup::makeElement( double x, double y, double
802    double rotMat[3][3];
803  
804    for( k=0; k<comp_stamps[current_comp]->getNAtoms(); k++ ){
805 <    
805 >
806      current_atom = comp_stamps[current_comp]->getAtom( k );
807      if( !current_atom->havePosition() ){
808 <      std::cerr << "Component " << comp_stamps[current_comp]->getID()
809 <                << ", atom " << current_atom->getType()
810 <                << " does not have a position specified.\n"
811 <                << "The initialization routine is unable to give a start"
812 <                << " position.\n";
813 <      exit(8);
808 >      sprintf( painCave.errMsg,
809 >               "SimSetup:initFromBass error.\n"
810 >               "\tComponent %s, atom %s does not have a position specified.\n"
811 >               "\tThe initialization routine is unable to give a start"
812 >               " position.\n",
813 >               comp_stamps[current_comp]->getID(),
814 >               current_atom->getType() );
815 >      painCave.isFatal = 1;
816 >      simError();
817      }
818 <    
818 >
819      the_atoms[current_atom_ndx]->setX( x + current_atom->getPosX() );
820      the_atoms[current_atom_ndx]->setY( y + current_atom->getPosY() );
821      the_atoms[current_atom_ndx]->setZ( z + current_atom->getPosZ() );
822 <    
822 >
823      if( the_atoms[current_atom_ndx]->isDirectional() ){
824 <      
824 >
825        dAtom = (DirectionalAtom *)the_atoms[current_atom_ndx];
826 <      
826 >
827        rotMat[0][0] = 1.0;
828        rotMat[0][1] = 0.0;
829        rotMat[0][2] = 0.0;
# Line 657 | Line 841 | void SimSetup::makeElement( double x, double y, double
841  
842      current_atom_ndx++;
843    }
844 <  
844 >
845    current_mol++;
846    current_comp_mol++;
847  
848    if( current_comp_mol >= components_nmol[current_comp] ){
849 <    
849 >
850      current_comp_mol = 0;
851      current_comp++;
852    }

Diff Legend

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