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

Comparing trunk/OOPSE/libmdtools/SimSetup.cpp (file contents):
Revision 845 by gezelter, Thu Oct 30 18:59:20 2003 UTC vs.
Revision 1104 by gezelter, Tue Apr 13 16:26:03 2004 UTC

# Line 9 | Line 9
9   #include "parse_me.h"
10   #include "Integrator.hpp"
11   #include "simError.h"
12 + #include "RigidBody.hpp"
13 + //#include "ConjugateMinimizer.hpp"
14 + #include "OOPSEMinimizer.hpp"
15  
16   #ifdef IS_MPI
17   #include "mpiBASS.h"
# Line 24 | Line 27
27   #define NPTxyz_ENS     4
28  
29  
30 < #define FF_DUFF 0
31 < #define FF_LJ   1
32 < #define FF_EAM  2
30 > #define FF_DUFF  0
31 > #define FF_LJ    1
32 > #define FF_EAM   2
33 > #define FF_H2O   3
34  
35   using namespace std;
36  
37 + /**
38 + * Check whether dividend is divisble by divisor or not
39 + */
40 + bool isDivisible(double dividend, double divisor){
41 +  double tolerance = 0.000001;
42 +  double quotient;
43 +  double diff;
44 +  int intQuotient;
45 +  
46 +  quotient = dividend / divisor;
47 +
48 +  if (quotient < 0)
49 +    quotient = -quotient;
50 +
51 +  intQuotient = int (quotient + tolerance);
52 +
53 +  diff = fabs(fabs(dividend) - intQuotient  * fabs(divisor));
54 +
55 +  if (diff <= tolerance)
56 +    return true;
57 +  else
58 +    return false;  
59 + }
60 +
61   SimSetup::SimSetup(){
62    
63    initSuspend = false;
# Line 103 | Line 131 | void SimSetup::createSim(void){
131  
132    sysObjectsCreation();
133  
134 +  // check on the post processing info
135 +
136 +  finalInfoCheck();
137 +
138    // initialize the system coordinates
139  
140    if ( !initSuspend ){
# Line 112 | Line 144 | void SimSetup::createSim(void){
144        info[0].currentTime = 0.0;
145    }  
146  
115 –  // check on the post processing info
116 –
117 –  finalInfoCheck();
118 –
147    // make the output filenames
148  
149    makeOutNames();
150  
151 <  // make the integrator
152 <
153 <  makeIntegrator();
154 <
151 >  if (globals->haveMinimizer())
152 >    // make minimizer
153 >    makeMinimizer();
154 >  else
155 >    // make the integrator
156 >    makeIntegrator();
157 >  
158   #ifdef IS_MPI
159    mpiSim->mpiRefresh();
160   #endif
# Line 135 | Line 166 | void SimSetup::makeMolecules(void){
166  
167  
168   void SimSetup::makeMolecules(void){
169 <  int k;
170 <  int i, j, exI, exJ, tempEx, stampID, atomOffset, excludeOffset;
169 >  int i, j, k;
170 >  int exI, exJ, exK, exL, slI, slJ;
171 >  int tempI, tempJ, tempK, tempL;
172 >  int molI;
173 >  int stampID, atomOffset, rbOffset;
174    molInit molInfo;
175    DirectionalAtom* dAtom;
176 +  RigidBody* myRB;
177 +  StuntDouble* mySD;
178    LinkedAssign* extras;
179    LinkedAssign* current_extra;
180    AtomStamp* currentAtom;
181    BondStamp* currentBond;
182    BendStamp* currentBend;
183    TorsionStamp* currentTorsion;
184 +  RigidBodyStamp* currentRigidBody;
185  
186    bond_pair* theBonds;
187    bend_set* theBends;
188    torsion_set* theTorsions;
189  
190 +  set<int> skipList;
191  
192 +  double phi, theta, psi;
193 +
194    //init the forceField paramters
195  
196    the_ff->readParams();
197  
158 –
198    // init the atoms
199  
200 <  double ux, uy, uz, u, uSqr;
200 >  int nMembers, nNew, rb1, rb2;
201  
202    for (k = 0; k < nInfo; k++){
203      the_ff->setSimInfo(&(info[k]));
204  
205      atomOffset = 0;
206 <    excludeOffset = 0;
206 >
207      for (i = 0; i < info[k].n_mol; i++){
208        stampID = info[k].molecules[i].getStampID();
209  
# Line 172 | Line 211 | void SimSetup::makeMolecules(void){
211        molInfo.nBonds = comp_stamps[stampID]->getNBonds();
212        molInfo.nBends = comp_stamps[stampID]->getNBends();
213        molInfo.nTorsions = comp_stamps[stampID]->getNTorsions();
214 <      molInfo.nExcludes = molInfo.nBonds + molInfo.nBends + molInfo.nTorsions;
215 <
214 >      molInfo.nRigidBodies = comp_stamps[stampID]->getNRigidBodies();
215 >      
216        molInfo.myAtoms = &(info[k].atoms[atomOffset]);
178 –      molInfo.myExcludes = &(info[k].excludes[excludeOffset]);
179 –      molInfo.myBonds = new Bond * [molInfo.nBonds];
180 –      molInfo.myBends = new Bend * [molInfo.nBends];
181 –      molInfo.myTorsions = new Torsion * [molInfo.nTorsions];
217  
218 +      if (molInfo.nBonds > 0)
219 +        molInfo.myBonds = new (Bond *) [molInfo.nBonds];
220 +      else
221 +        molInfo.myBonds = NULL;
222 +
223 +      if (molInfo.nBends > 0)
224 +        molInfo.myBends = new (Bend *) [molInfo.nBends];
225 +      else
226 +        molInfo.myBends = NULL;
227 +
228 +      if (molInfo.nTorsions > 0)
229 +        molInfo.myTorsions = new (Torsion *) [molInfo.nTorsions];
230 +      else
231 +        molInfo.myTorsions = NULL;
232 +
233        theBonds = new bond_pair[molInfo.nBonds];
234        theBends = new bend_set[molInfo.nBends];
235        theTorsions = new torsion_set[molInfo.nTorsions];
236 <
236 >      
237        // make the Atoms
238  
239        for (j = 0; j < molInfo.nAtoms; j++){
240          currentAtom = comp_stamps[stampID]->getAtom(j);
241 +
242          if (currentAtom->haveOrientation()){
243            dAtom = new DirectionalAtom((j + atomOffset),
244                                        info[k].getConfiguration());
245            info[k].n_oriented++;
246            molInfo.myAtoms[j] = dAtom;
247  
248 <          ux = currentAtom->getOrntX();
249 <          uy = currentAtom->getOrntY();
250 <          uz = currentAtom->getOrntZ();
248 >          // Directional Atoms have standard unit vectors which are oriented
249 >          // in space using the three Euler angles.  We assume the standard
250 >          // unit vector was originally along the z axis below.
251  
252 <          uSqr = (ux * ux) + (uy * uy) + (uz * uz);
252 >          phi = currentAtom->getEulerPhi() * M_PI / 180.0;
253 >          theta = currentAtom->getEulerTheta() * M_PI / 180.0;
254 >          psi = currentAtom->getEulerPsi()* M_PI / 180.0;
255  
256 <          u = sqrt(uSqr);
257 <          ux = ux / u;
205 <          uy = uy / u;
206 <          uz = uz / u;
207 <
208 <          dAtom->setSUx(ux);
209 <          dAtom->setSUy(uy);
210 <          dAtom->setSUz(uz);
256 >          dAtom->setUnitFrameFromEuler(phi, theta, psi);
257 >            
258          }
259          else{
260 <          molInfo.myAtoms[j] = new GeneralAtom((j + atomOffset),
261 <                                               info[k].getConfiguration());
260 >
261 >          molInfo.myAtoms[j] = new Atom((j + atomOffset), info[k].getConfiguration());
262          }
263 +
264          molInfo.myAtoms[j]->setType(currentAtom->getType());
265  
266   #ifdef IS_MPI
# Line 228 | Line 276 | void SimSetup::makeMolecules(void){
276          theBonds[j].a = currentBond->getA() + atomOffset;
277          theBonds[j].b = currentBond->getB() + atomOffset;
278  
279 <        exI = theBonds[j].a;
280 <        exJ = theBonds[j].b;
279 >        tempI = theBonds[j].a;
280 >        tempJ = theBonds[j].b;
281  
234 –        // exclude_I must always be the smaller of the pair
235 –        if (exI > exJ){
236 –          tempEx = exI;
237 –          exI = exJ;
238 –          exJ = tempEx;
239 –        }
282   #ifdef IS_MPI
283 <        tempEx = exI;
284 <        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
285 <        tempEx = exJ;
286 <        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
283 >        exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
284 >        exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
285 > #else
286 >        exI = tempI + 1;
287 >        exJ = tempJ + 1;
288 > #endif
289  
290 <        info[k].excludes[j + excludeOffset]->setPair(exI, exJ);
247 < #else  // isn't MPI
248 <
249 <        info[k].excludes[j + excludeOffset]->setPair((exI + 1), (exJ + 1));
250 < #endif  //is_mpi
290 >        info[k].excludes->addPair(exI, exJ);
291        }
252 –      excludeOffset += molInfo.nBonds;
292  
293        //make the bends
294        for (j = 0; j < molInfo.nBends; j++){
# Line 299 | Line 338 | void SimSetup::makeMolecules(void){
338            }
339          }
340  
341 <        if (!theBends[j].isGhost){
342 <          exI = theBends[j].a;
343 <          exJ = theBends[j].c;
344 <        }
345 <        else{
307 <          exI = theBends[j].a;
308 <          exJ = theBends[j].b;
309 <        }
310 <
311 <        // exclude_I must always be the smaller of the pair
312 <        if (exI > exJ){
313 <          tempEx = exI;
314 <          exI = exJ;
315 <          exJ = tempEx;
316 <        }
341 >        if (theBends[j].isGhost) {
342 >          
343 >          tempI = theBends[j].a;
344 >          tempJ = theBends[j].b;
345 >          
346   #ifdef IS_MPI
347 <        tempEx = exI;
348 <        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
349 <        tempEx = exJ;
350 <        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
347 >          exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
348 >          exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
349 > #else
350 >          exI = tempI + 1;
351 >          exJ = tempJ + 1;
352 > #endif          
353 >          info[k].excludes->addPair(exI, exJ);
354  
355 <        info[k].excludes[j + excludeOffset]->setPair(exI, exJ);
356 < #else  // isn't MPI
357 <        info[k].excludes[j + excludeOffset]->setPair((exI + 1), (exJ + 1));
358 < #endif  //is_mpi
355 >        } else {
356 >
357 >          tempI = theBends[j].a;
358 >          tempJ = theBends[j].b;
359 >          tempK = theBends[j].c;
360 >          
361 > #ifdef IS_MPI
362 >          exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
363 >          exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
364 >          exK = info[k].atoms[tempK]->getGlobalIndex() + 1;
365 > #else
366 >          exI = tempI + 1;
367 >          exJ = tempJ + 1;
368 >          exK = tempK + 1;
369 > #endif
370 >          
371 >          info[k].excludes->addPair(exI, exK);
372 >          info[k].excludes->addPair(exI, exJ);
373 >          info[k].excludes->addPair(exJ, exK);
374 >        }
375        }
328 –      excludeOffset += molInfo.nBends;
376  
377        for (j = 0; j < molInfo.nTorsions; j++){
378          currentTorsion = comp_stamps[stampID]->getTorsion(j);
# Line 334 | Line 381 | void SimSetup::makeMolecules(void){
381          theTorsions[j].c = currentTorsion->getC() + atomOffset;
382          theTorsions[j].d = currentTorsion->getD() + atomOffset;
383  
384 <        exI = theTorsions[j].a;
385 <        exJ = theTorsions[j].d;
384 >        tempI = theTorsions[j].a;      
385 >        tempJ = theTorsions[j].b;
386 >        tempK = theTorsions[j].c;
387 >        tempL = theTorsions[j].d;
388  
389 <        // exclude_I must always be the smaller of the pair
390 <        if (exI > exJ){
391 <          tempEx = exI;
392 <          exI = exJ;
393 <          exJ = tempEx;
389 > #ifdef IS_MPI
390 >        exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
391 >        exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
392 >        exK = info[k].atoms[tempK]->getGlobalIndex() + 1;
393 >        exL = info[k].atoms[tempL]->getGlobalIndex() + 1;
394 > #else
395 >        exI = tempI + 1;
396 >        exJ = tempJ + 1;
397 >        exK = tempK + 1;
398 >        exL = tempL + 1;
399 > #endif
400 >
401 >        info[k].excludes->addPair(exI, exJ);
402 >        info[k].excludes->addPair(exI, exK);
403 >        info[k].excludes->addPair(exI, exL);        
404 >        info[k].excludes->addPair(exJ, exK);
405 >        info[k].excludes->addPair(exJ, exL);
406 >        info[k].excludes->addPair(exK, exL);
407 >      }
408 >
409 >      for (j = 0; j < molInfo.nRigidBodies; j++){
410 >
411 >        currentRigidBody = comp_stamps[stampID]->getRigidBody(j);
412 >        nMembers = currentRigidBody->getNMembers();
413 >
414 >        // Create the Rigid Body:
415 >
416 >        myRB = new RigidBody();
417 >        
418 >        for (rb1 = 0; rb1 < nMembers; rb1++) {
419 >
420 >          // molI is atom numbering inside this molecule
421 >          molI = currentRigidBody->getMember(rb1);    
422 >
423 >          // tempI is atom numbering on local processor
424 >          tempI = molI + atomOffset;
425 >
426 >          // currentAtom is the AtomStamp (which we need for
427 >          // rigid body reference positions)
428 >          currentAtom = comp_stamps[stampID]->getAtom(molI);
429 >
430 >          // When we add to the rigid body, add the atom itself and
431 >          // the stamp info:
432 >
433 >          myRB->addAtom(info[k].atoms[tempI], currentAtom);
434 >          
435 >          // Add this atom to the Skip List for the integrators
436 > #ifdef IS_MPI
437 >          slI = info[k].atoms[tempI]->getGlobalIndex();
438 > #else
439 >          slI = tempI;
440 > #endif
441 >          skipList.insert(slI);
442 >          
443          }
444 +        
445 +        for(rb1 = 0; rb1 < nMembers - 1; rb1++) {
446 +          for(rb2 = rb1+1; rb2 < nMembers; rb2++) {
447 +            
448 +            tempI = currentRigidBody->getMember(rb1);
449 +            tempJ = currentRigidBody->getMember(rb2);
450 +            
451 +            // Some explanation is required here.
452 +            // Fortran indexing starts at 1, while c indexing starts at 0
453 +            // Also, in parallel computations, the GlobalIndex is
454 +            // used for the exclude list:
455 +            
456   #ifdef IS_MPI
457 <        tempEx = exI;
458 <        exI = info[k].atoms[tempEx]->getGlobalIndex() + 1;
459 <        tempEx = exJ;
460 <        exJ = info[k].atoms[tempEx]->getGlobalIndex() + 1;
457 >            exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
458 >            exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
459 > #else
460 >            exI = tempI + 1;
461 >            exJ = tempJ + 1;
462 > #endif
463 >            
464 >            info[k].excludes->addPair(exI, exJ);
465 >            
466 >          }
467 >        }
468  
469 <        info[k].excludes[j + excludeOffset]->setPair(exI, exJ);
470 < #else  // isn't MPI
354 <        info[k].excludes[j + excludeOffset]->setPair((exI + 1), (exJ + 1));
355 < #endif  //is_mpi
469 >        molInfo.myRigidBodies.push_back(myRB);
470 >        info[k].rigidBodies.push_back(myRB);
471        }
472 <      excludeOffset += molInfo.nTorsions;
472 >      
473  
474 +      // After this is all set up, scan through the atoms to
475 +      // see if they can be added to the integrableObjects:
476  
477 <      // send the arrays off to the forceField for init.
477 >      for (j = 0; j < molInfo.nAtoms; j++){
478  
479 + #ifdef IS_MPI
480 +        slJ = molInfo.myAtoms[j]->getGlobalIndex();
481 + #else
482 +        slJ = j+atomOffset;
483 + #endif
484 +
485 +        // if they aren't on the skip list, then they can be integrated
486 +
487 +        if (skipList.find(slJ) == skipList.end()) {
488 +          mySD = (StuntDouble *) molInfo.myAtoms[j];
489 +          info[k].integrableObjects.push_back(mySD);
490 +          molInfo.myIntegrableObjects.push_back(mySD);
491 +        }
492 +      }
493 +
494 +      // all rigid bodies are integrated:
495 +
496 +      for (j = 0; j < molInfo.nRigidBodies; j++) {
497 +        mySD = (StuntDouble *) molInfo.myRigidBodies[j];
498 +        info[k].integrableObjects.push_back(mySD);      
499 +        molInfo.myIntegrableObjects.push_back(mySD);
500 +      }
501 +    
502 +      
503 +      // send the arrays off to the forceField for init.
504 +      
505        the_ff->initializeAtoms(molInfo.nAtoms, molInfo.myAtoms);
506        the_ff->initializeBonds(molInfo.nBonds, molInfo.myBonds, theBonds);
507        the_ff->initializeBends(molInfo.nBends, molInfo.myBends, theBends);
508        the_ff->initializeTorsions(molInfo.nTorsions, molInfo.myTorsions,
509                                   theTorsions);
510  
368 –
511        info[k].molecules[i].initialize(molInfo);
512  
513  
# Line 373 | Line 515 | void SimSetup::makeMolecules(void){
515        delete[] theBonds;
516        delete[] theBends;
517        delete[] theTorsions;
518 <    }
518 >    }    
519    }
520  
521   #ifdef IS_MPI
# Line 383 | Line 525 | void SimSetup::makeMolecules(void){
525  
526    // clean up the forcefield
527  
528 <  the_ff->calcRcut();
528 >  if (!globals->haveLJrcut()){
529 >
530 >    the_ff->calcRcut();
531 >
532 >  } else {
533 >    
534 >    the_ff->setRcut( globals->getLJrcut() );
535 >  }
536 >
537    the_ff->cleanMe();
538   }
539  
# Line 585 | Line 735 | void SimSetup::gatherInfo(void){
735    else if (!strcasecmp(force_field, "EAM")){
736      ffCase = FF_EAM;
737    }
738 +  else if (!strcasecmp(force_field, "WATER")){
739 +    ffCase = FF_H2O;
740 +  }
741    else{
742      sprintf(painCave.errMsg, "SimSetup Error. Unrecognized force field -> %s\n",
743              force_field);
# Line 613 | Line 766 | void SimSetup::gatherInfo(void){
766    }
767    else{
768      sprintf(painCave.errMsg,
769 <            "SimSetup Warning. Unrecognized Ensemble -> %s, "
770 <            "reverting to NVE for this simulation.\n",
769 >            "SimSetup Warning. Unrecognized Ensemble -> %s \n"
770 >            "\treverting to NVE for this simulation.\n",
771              ensemble);
772           painCave.isFatal = 0;
773           simError();
# Line 646 | Line 799 | void SimSetup::gatherInfo(void){
799        if (!the_components[i]->haveNMol()){
800          // we have a problem
801          sprintf(painCave.errMsg,
802 <                "SimSetup Error. No global NMol or component NMol"
803 <                " given. Cannot calculate the number of atoms.\n");
802 >                "SimSetup Error. No global NMol or component NMol given.\n"
803 >                "\tCannot calculate the number of atoms.\n");
804          painCave.isFatal = 1;
805          simError();
806        }
# Line 667 | Line 820 | void SimSetup::gatherInfo(void){
820      simError();
821    }
822  
823 +  //check whether sample time, status time, thermal time and reset time are divisble by dt
824 +  if (!isDivisible(globals->getSampleTime(), globals->getDt())){
825 +    sprintf(painCave.errMsg,
826 +            "Sample time is not divisible by dt.\n"
827 +            "\tThis will result in samples that are not uniformly\n"
828 +            "\tdistributed in time.  If this is a problem, change\n"
829 +            "\tyour sampleTime variable.\n");
830 +    painCave.isFatal = 0;
831 +    simError();    
832 +  }
833 +
834 +  if (globals->haveStatusTime() && !isDivisible(globals->getSampleTime(), globals->getDt())){
835 +    sprintf(painCave.errMsg,
836 +            "Status time is not divisible by dt.\n"
837 +            "\tThis will result in status reports that are not uniformly\n"
838 +            "\tdistributed in time.  If this is a problem, change \n"
839 +            "\tyour statusTime variable.\n");
840 +    painCave.isFatal = 0;
841 +    simError();    
842 +  }
843 +
844 +  if (globals->haveThermalTime() && !isDivisible(globals->getThermalTime(), globals->getDt())){
845 +    sprintf(painCave.errMsg,
846 +            "Thermal time is not divisible by dt.\n"
847 +            "\tThis will result in thermalizations that are not uniformly\n"
848 +            "\tdistributed in time.  If this is a problem, change \n"
849 +            "\tyour thermalTime variable.\n");
850 +    painCave.isFatal = 0;
851 +    simError();    
852 +  }  
853 +
854 +  if (globals->haveResetTime() && !isDivisible(globals->getResetTime(), globals->getDt())){
855 +    sprintf(painCave.errMsg,
856 +            "Reset time is not divisible by dt.\n"
857 +            "\tThis will result in integrator resets that are not uniformly\n"
858 +            "\tdistributed in time.  If this is a problem, change\n"
859 +            "\tyour resetTime variable.\n");
860 +    painCave.isFatal = 0;
861 +    simError();    
862 +  }
863 +
864    // set the status, sample, and thermal kick times
865  
866    for (i = 0; i < nInfo; i++){
# Line 699 | Line 893 | void SimSetup::gatherInfo(void){
893      
894      if (globals->haveTempSet())
895        info[i].setTemp = globals->getTempSet();
896 +
897 +    // check for the extended State init
898 +
899 +    info[i].useInitXSstate = globals->getUseInitXSstate();
900 +    info[i].orthoTolerance = globals->getOrthoBoxTolerance();
901      
902    }
903    
# Line 741 | Line 940 | void SimSetup::gatherInfo(void){
940    for (int i = 0; i < nInfo; i++){
941      info[i].setSeed(seedValue);
942    }
943 <
943 >  
944   #ifdef IS_MPI
945 <  strcpy(checkPointMsg, "Succesfully gathered all information from Bass\n");
945 >  strcpy(checkPointMsg, "Successfully gathered all information from Bass\n");
946    MPIcheckPoint();
947   #endif // is_mpi
948   }
# Line 776 | Line 975 | void SimSetup::finalInfoCheck(void){
975  
976        if (!globals->haveECR()){
977          sprintf(painCave.errMsg,
978 <                "SimSetup Warning: using default value of 1/2 the smallest "
979 <                "box length for the electrostaticCutoffRadius.\n"
980 <                "I hope you have a very fast processor!\n");
978 >                "SimSetup Warning: No value was set for electrostaticCutoffRadius.\n"
979 >                "\tOOPSE will use a default value of 15.0 angstroms"
980 >                "\tfor the electrostaticCutoffRadius.\n");
981          painCave.isFatal = 0;
982          simError();
983 <        double smallest;
785 <        smallest = info[i].boxL[0];
786 <        if (info[i].boxL[1] <= smallest)
787 <          smallest = info[i].boxL[1];
788 <        if (info[i].boxL[2] <= smallest)
789 <          smallest = info[i].boxL[2];
790 <        theEcr = 0.5 * smallest;
983 >        theEcr = 15.0;
984        }
985        else{
986          theEcr = globals->getECR();
# Line 795 | Line 988 | void SimSetup::finalInfoCheck(void){
988  
989        if (!globals->haveEST()){
990          sprintf(painCave.errMsg,
991 <                "SimSetup Warning: using default value of 0.05 * the "
992 <                "electrostaticCutoffRadius for the electrostaticSkinThickness\n");
991 >                "SimSetup Warning: No value was set for electrostaticSkinThickness.\n"
992 >                "\tOOPSE will use a default value of\n"
993 >                "\t0.05 * electrostaticCutoffRadius\n"
994 >                "\tfor the electrostaticSkinThickness\n");
995          painCave.isFatal = 0;
996          simError();
997          theEst = 0.05 * theEcr;
# Line 809 | Line 1004 | void SimSetup::finalInfoCheck(void){
1004  
1005        if (!globals->haveDielectric()){
1006          sprintf(painCave.errMsg,
1007 <                "SimSetup Error: You are trying to use Reaction Field without"
1008 <                "setting a dielectric constant!\n");
1007 >                "SimSetup Error: No Dielectric constant was set.\n"
1008 >                "\tYou are trying to use Reaction Field without"
1009 >                "\tsetting a dielectric constant!\n");
1010          painCave.isFatal = 1;
1011          simError();
1012        }
# Line 820 | Line 1016 | void SimSetup::finalInfoCheck(void){
1016        if (usesDipoles){
1017          if (!globals->haveECR()){
1018            sprintf(painCave.errMsg,
1019 <                  "SimSetup Warning: using default value of 1/2 the smallest "
1020 <                  "box length for the electrostaticCutoffRadius.\n"
1021 <                  "I hope you have a very fast processor!\n");
1022 <          painCave.isFatal = 0;
1023 <          simError();
1024 <          double smallest;
829 <          smallest = info[i].boxL[0];
830 <          if (info[i].boxL[1] <= smallest)
831 <            smallest = info[i].boxL[1];
832 <          if (info[i].boxL[2] <= smallest)
833 <            smallest = info[i].boxL[2];
834 <          theEcr = 0.5 * smallest;
1019 >                  "SimSetup Warning: No value was set for electrostaticCutoffRadius.\n"
1020 >                  "\tOOPSE will use a default value of 15.0 angstroms"
1021 >                  "\tfor the electrostaticCutoffRadius.\n");
1022 >          painCave.isFatal = 0;
1023 >          simError();
1024 >          theEcr = 15.0;
1025          }
1026          else{
1027            theEcr = globals->getECR();
1028          }
1029 <
1029 >        
1030          if (!globals->haveEST()){
1031            sprintf(painCave.errMsg,
1032 <                  "SimSetup Warning: using default value of 0.05 * the "
1033 <                  "electrostaticCutoffRadius for the "
1034 <                  "electrostaticSkinThickness\n");
1032 >                  "SimSetup Warning: No value was set for electrostaticSkinThickness.\n"
1033 >                  "\tOOPSE will use a default value of\n"
1034 >                  "\t0.05 * electrostaticCutoffRadius\n"
1035 >                  "\tfor the electrostaticSkinThickness\n");
1036            painCave.isFatal = 0;
1037            simError();
1038            theEst = 0.05 * theEcr;
# Line 849 | Line 1040 | void SimSetup::finalInfoCheck(void){
1040          else{
1041            theEst = globals->getEST();
1042          }
1043 <
1043 >        
1044          info[i].setDefaultEcr(theEcr, theEst);
1045        }
1046      }
856 –    info[i].checkCutOffs();
1047    }
858 –
1048   #ifdef IS_MPI
1049    strcpy(checkPointMsg, "post processing checks out");
1050    MPIcheckPoint();
1051   #endif // is_mpi
1052   }
1053 <
1053 >  
1054   void SimSetup::initSystemCoords(void){
1055    int i;
1056  
# Line 889 | Line 1078 | void SimSetup::initSystemCoords(void){
1078      delete fileInit;
1079    }
1080    else{
1081 < #ifdef IS_MPI
893 <
1081 >    
1082      // no init from bass
1083 <
1083 >    
1084      sprintf(painCave.errMsg,
1085 <            "Cannot intialize a parallel simulation without an initial configuration file.\n");
1085 >            "Cannot intialize a simulation without an initial configuration file.\n");
1086      painCave.isFatal = 1;;
1087      simError();
1088 <
901 < #else
902 <
903 <    initFromBass();
904 <
905 <
906 < #endif
1088 >    
1089    }
1090  
1091   #ifdef IS_MPI
# Line 1057 | Line 1239 | void SimSetup::createFF(void){
1239        the_ff = new EAM_FF();
1240        break;
1241  
1242 +    case FF_H2O:
1243 +      the_ff = new WATER();
1244 +      break;
1245 +
1246      default:
1247        sprintf(painCave.errMsg,
1248                "SimSetup Error. Unrecognized force field in case statement.\n");
# Line 1129 | Line 1315 | void SimSetup::calcSysValues(void){
1315    tot_bonds = 0;
1316    tot_bends = 0;
1317    tot_torsions = 0;
1318 +  tot_rigid = 0;
1319    for (i = 0; i < n_components; i++){
1320      tot_atoms += components_nmol[i] * comp_stamps[i]->getNAtoms();
1321      tot_bonds += components_nmol[i] * comp_stamps[i]->getNBonds();
1322      tot_bends += components_nmol[i] * comp_stamps[i]->getNBends();
1323      tot_torsions += components_nmol[i] * comp_stamps[i]->getNTorsions();
1324 +    tot_rigid += components_nmol[i] * comp_stamps[i]->getNRigidBodies();
1325    }
1326 <
1326 >  
1327    tot_SRI = tot_bonds + tot_bends + tot_torsions;
1328    molMembershipArray = new int[tot_atoms];
1329  
# Line 1157 | Line 1345 | void SimSetup::mpiMolDivide(void){
1345    int i, j, k;
1346    int localMol, allMol;
1347    int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
1348 +  int local_rigid;
1349  
1350    mpiSim = new mpiSimulation(info);
1351  
# Line 1173 | Line 1362 | void SimSetup::mpiMolDivide(void){
1362    local_bonds = 0;
1363    local_bends = 0;
1364    local_torsions = 0;
1365 +  local_rigid = 0;
1366    globalAtomIndex = 0;
1367  
1178 –
1368    for (i = 0; i < n_components; i++){
1369      for (j = 0; j < components_nmol[i]; j++){
1370        if (mol2proc[allMol] == worldRank){
# Line 1183 | Line 1372 | void SimSetup::mpiMolDivide(void){
1372          local_bonds += comp_stamps[i]->getNBonds();
1373          local_bends += comp_stamps[i]->getNBends();
1374          local_torsions += comp_stamps[i]->getNTorsions();
1375 +        local_rigid += comp_stamps[i]->getNRigidBodies();
1376          localMol++;
1377        }      
1378        for (k = 0; k < comp_stamps[i]->getNAtoms(); k++){
# Line 1196 | Line 1386 | void SimSetup::mpiMolDivide(void){
1386    local_SRI = local_bonds + local_bends + local_torsions;
1387  
1388    info[0].n_atoms = mpiSim->getMyNlocal();  
1389 +  
1390  
1391    if (local_atoms != info[0].n_atoms){
1392      sprintf(painCave.errMsg,
1393 <            "SimSetup error: mpiSim's localAtom (%d) and SimSetup's"
1394 <            " localAtom (%d) are not equal.\n",
1393 >            "SimSetup error: mpiSim's localAtom (%d) and SimSetup's\n"
1394 >            "\tlocalAtom (%d) are not equal.\n",
1395              info[0].n_atoms, local_atoms);
1396      painCave.isFatal = 1;
1397      simError();
# Line 1228 | Line 1419 | void SimSetup::makeSysArrays(void){
1419  
1420    Atom** the_atoms;
1421    Molecule* the_molecules;
1231 –  Exclude** the_excludes;
1422  
1233 –
1423    for (l = 0; l < nInfo; l++){
1424      // create the atom and short range interaction arrays
1425  
# Line 1273 | Line 1462 | void SimSetup::makeSysArrays(void){
1462  
1463   #endif // is_mpi
1464  
1465 <
1466 <    if (info[l].n_SRI){
1467 <      Exclude::createArray(info[l].n_SRI);
1279 <      the_excludes = new Exclude * [info[l].n_SRI];
1280 <      for (int ex = 0; ex < info[l].n_SRI; ex++){
1281 <        the_excludes[ex] = new Exclude(ex);
1282 <      }
1283 <      info[l].globalExcludes = new int;
1284 <      info[l].n_exclude = info[l].n_SRI;
1285 <    }
1286 <    else{
1287 <      Exclude::createArray(1);
1288 <      the_excludes = new Exclude * ;
1289 <      the_excludes[0] = new Exclude(0);
1290 <      the_excludes[0]->setPair(0, 0);
1291 <      info[l].globalExcludes = new int;
1292 <      info[l].globalExcludes[0] = 0;
1293 <      info[l].n_exclude = 0;
1294 <    }
1295 <
1465 >    info[l].globalExcludes = new int;
1466 >    info[l].globalExcludes[0] = 0;
1467 >    
1468      // set the arrays into the SimInfo object
1469  
1470      info[l].atoms = the_atoms;
1471      info[l].molecules = the_molecules;
1472      info[l].nGlobalExcludes = 0;
1301 –    info[l].excludes = the_excludes;
1473  
1474      the_ff->setSimInfo(info);
1475    }
# Line 1342 | Line 1513 | void SimSetup::makeIntegrator(void){
1513          else{
1514            sprintf(painCave.errMsg,
1515                    "SimSetup error: If you use the NVT\n"
1516 <                  "    ensemble, you must set tauThermostat.\n");
1516 >                  "\tensemble, you must set tauThermostat.\n");
1517            painCave.isFatal = 1;
1518            simError();
1519          }
# Line 1365 | Line 1536 | void SimSetup::makeIntegrator(void){
1536          else{
1537            sprintf(painCave.errMsg,
1538                    "SimSetup error: If you use a constant pressure\n"
1539 <                  "    ensemble, you must set targetPressure in the BASS file.\n");
1539 >                  "\tensemble, you must set targetPressure in the BASS file.\n");
1540            painCave.isFatal = 1;
1541            simError();
1542          }
# Line 1375 | Line 1546 | void SimSetup::makeIntegrator(void){
1546          else{
1547            sprintf(painCave.errMsg,
1548                    "SimSetup error: If you use an NPT\n"
1549 <                  "    ensemble, you must set tauThermostat.\n");
1549 >                  "\tensemble, you must set tauThermostat.\n");
1550            painCave.isFatal = 1;
1551            simError();
1552          }
# Line 1385 | Line 1556 | void SimSetup::makeIntegrator(void){
1556          else{
1557            sprintf(painCave.errMsg,
1558                    "SimSetup error: If you use an NPT\n"
1559 <                  "    ensemble, you must set tauBarostat.\n");
1559 >                  "\tensemble, you must set tauBarostat.\n");
1560            painCave.isFatal = 1;
1561            simError();
1562          }
# Line 1408 | Line 1579 | void SimSetup::makeIntegrator(void){
1579          else{
1580            sprintf(painCave.errMsg,
1581                    "SimSetup error: If you use a constant pressure\n"
1582 <                  "    ensemble, you must set targetPressure in the BASS file.\n");
1582 >                  "\tensemble, you must set targetPressure in the BASS file.\n");
1583            painCave.isFatal = 1;
1584            simError();
1585          }    
# Line 1419 | Line 1590 | void SimSetup::makeIntegrator(void){
1590          else{
1591            sprintf(painCave.errMsg,
1592                    "SimSetup error: If you use an NPT\n"
1593 <                  "    ensemble, you must set tauThermostat.\n");
1593 >                  "\tensemble, you must set tauThermostat.\n");
1594            painCave.isFatal = 1;
1595            simError();
1596          }
# Line 1430 | Line 1601 | void SimSetup::makeIntegrator(void){
1601          else{
1602            sprintf(painCave.errMsg,
1603                    "SimSetup error: If you use an NPT\n"
1604 <                  "    ensemble, you must set tauBarostat.\n");
1604 >                  "\tensemble, you must set tauBarostat.\n");
1605            painCave.isFatal = 1;
1606            simError();
1607          }
# Line 1453 | Line 1624 | void SimSetup::makeIntegrator(void){
1624          else{
1625            sprintf(painCave.errMsg,
1626                    "SimSetup error: If you use a constant pressure\n"
1627 <                  "    ensemble, you must set targetPressure in the BASS file.\n");
1627 >                  "\tensemble, you must set targetPressure in the BASS file.\n");
1628            painCave.isFatal = 1;
1629            simError();
1630          }    
# Line 1463 | Line 1634 | void SimSetup::makeIntegrator(void){
1634          else{
1635            sprintf(painCave.errMsg,
1636                    "SimSetup error: If you use an NPT\n"
1637 <                  "    ensemble, you must set tauThermostat.\n");
1637 >                  "\tensemble, you must set tauThermostat.\n");
1638            painCave.isFatal = 1;
1639            simError();
1640          }
# Line 1473 | Line 1644 | void SimSetup::makeIntegrator(void){
1644          else{
1645            sprintf(painCave.errMsg,
1646                    "SimSetup error: If you use an NPT\n"
1647 <                  "    ensemble, you must set tauBarostat.\n");
1647 >                  "\tensemble, you must set tauBarostat.\n");
1648            painCave.isFatal = 1;
1649            simError();
1650          }
# Line 1526 | Line 1697 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1697    }
1698    else{
1699      sprintf(painCave.errMsg,
1700 <            "ZConstraint error: If you use an ZConstraint\n"
1701 <            " , you must set sample time.\n");
1700 >            "ZConstraint error: If you use a ZConstraint,\n"
1701 >            "\tyou must set zconsTime.\n");
1702      painCave.isFatal = 1;
1703      simError();
1704    }
# Line 1542 | Line 1713 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1713    else{
1714      double defaultZConsTol = 0.01;
1715      sprintf(painCave.errMsg,
1716 <            "ZConstraint Waring: Tolerance for z-constraint methodl is not specified\n"
1717 <            " , default value %f is used.\n",
1716 >            "ZConstraint Warning: Tolerance for z-constraint method is not specified.\n"
1717 >            "\tOOPSE will use a default value of %f.\n"
1718 >            "\tTo set the tolerance, use the zconsTol variable.\n",
1719              defaultZConsTol);
1720      painCave.isFatal = 0;
1721      simError();      
# Line 1561 | Line 1733 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1733    }
1734    else{
1735      sprintf(painCave.errMsg,
1736 <            "ZConstraint Warning: User does not set force Subtraction policy, "
1737 <            "PolicyByMass is used\n");
1736 >            "ZConstraint Warning: No force subtraction policy was set.\n"
1737 >            "\tOOPSE will use PolicyByMass.\n"
1738 >            "\tTo set the policy, use the zconsForcePolicy variable.\n");
1739      painCave.isFatal = 0;
1740      simError();
1741      zconsForcePolicy->setData("BYMASS");
# Line 1570 | Line 1743 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1743  
1744    theInfo.addProperty(zconsForcePolicy);
1745  
1746 +  //set zcons gap
1747 +  DoubleData* zconsGap = new DoubleData();
1748 +  zconsGap->setID(ZCONSGAP_ID);
1749 +
1750 +  if (globals->haveZConsGap()){
1751 +    zconsGap->setData(globals->getZconsGap());
1752 +    theInfo.addProperty(zconsGap);  
1753 +  }
1754 +
1755 +  //set zcons fixtime
1756 +  DoubleData* zconsFixtime = new DoubleData();
1757 +  zconsFixtime->setID(ZCONSFIXTIME_ID);
1758 +
1759 +  if (globals->haveZConsFixTime()){
1760 +    zconsFixtime->setData(globals->getZconsFixtime());
1761 +    theInfo.addProperty(zconsFixtime);  
1762 +  }
1763 +
1764 +  //set zconsUsingSMD
1765 +  IntData* zconsUsingSMD = new IntData();
1766 +  zconsUsingSMD->setID(ZCONSUSINGSMD_ID);
1767 +
1768 +  if (globals->haveZConsUsingSMD()){
1769 +    zconsUsingSMD->setData(globals->getZconsUsingSMD());
1770 +    theInfo.addProperty(zconsUsingSMD);  
1771 +  }
1772 +
1773    //Determine the name of ouput file and add it into SimInfo's property list
1774    //Be careful, do not use inFileName, since it is a pointer which
1775    //point to a string at master node, and slave nodes do not contain that string
# Line 1599 | Line 1799 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1799      tempParaItem.zPos = zconStamp[i]->getZpos();
1800      tempParaItem.zconsIndex = zconStamp[i]->getMolIndex();
1801      tempParaItem.kRatio = zconStamp[i]->getKratio();
1802 <
1802 >    tempParaItem.havingCantVel = zconStamp[i]->haveCantVel();
1803 >    tempParaItem.cantVel = zconStamp[i]->getCantVel();    
1804      zconsParaData->addItem(tempParaItem);
1805    }
1806  
1807    //check the uniqueness of index  
1808    if(!zconsParaData->isIndexUnique()){
1809      sprintf(painCave.errMsg,
1810 <            "ZConstraint Error: molIndex is not unique\n");
1810 >            "ZConstraint Error: molIndex is not unique!\n");
1811      painCave.isFatal = 1;
1812      simError();
1813    }
# Line 1617 | Line 1818 | void SimSetup::setupZConstraint(SimInfo& theInfo){
1818    //push data into siminfo, therefore, we can retrieve later
1819    theInfo.addProperty(zconsParaData);
1820   }
1821 +
1822 + void SimSetup::makeMinimizer(){
1823 +
1824 +  OOPSEMinimizer* myOOPSEMinimizer;
1825 +  MinimizerParameterSet* param;
1826 +  char minimizerName[100];
1827 +  
1828 +  for (int i = 0; i < nInfo; i++){
1829 +    
1830 +    //prepare parameter set for minimizer
1831 +    param = new MinimizerParameterSet();
1832 +    param->setDefaultParameter();
1833 +
1834 +    if (globals->haveMinimizer()){
1835 +      param->setFTol(globals->getMinFTol());
1836 +    }
1837 +
1838 +    if (globals->haveMinGTol()){
1839 +      param->setGTol(globals->getMinGTol());
1840 +    }
1841 +
1842 +    if (globals->haveMinMaxIter()){
1843 +      param->setMaxIteration(globals->getMinMaxIter());
1844 +    }
1845 +
1846 +    if (globals->haveMinWriteFrq()){
1847 +      param->setMaxIteration(globals->getMinMaxIter());
1848 +    }
1849 +
1850 +    if (globals->haveMinWriteFrq()){
1851 +      param->setWriteFrq(globals->getMinWriteFrq());
1852 +    }
1853 +    
1854 +    if (globals->haveMinStepSize()){
1855 +      param->setStepSize(globals->getMinStepSize());
1856 +    }
1857 +
1858 +    if (globals->haveMinLSMaxIter()){
1859 +      param->setLineSearchMaxIteration(globals->getMinLSMaxIter());
1860 +    }    
1861 +
1862 +    if (globals->haveMinLSTol()){
1863 +      param->setLineSearchTol(globals->getMinLSTol());
1864 +    }    
1865 +
1866 +    strcpy(minimizerName, globals->getMinimizer());
1867 +
1868 +    if (!strcasecmp(minimizerName, "CG")){
1869 +      myOOPSEMinimizer = new PRCGMinimizer(&(info[i]), the_ff, param);
1870 +    }
1871 +    else if (!strcasecmp(minimizerName, "SD")){
1872 +    //myOOPSEMinimizer = MinimizerFactory.creatMinimizer("", &(info[i]), the_ff, param);
1873 +      myOOPSEMinimizer = new SDMinimizer(&(info[i]), the_ff, param);
1874 +    }
1875 +    else{
1876 +          sprintf(painCave.errMsg,
1877 +                  "SimSetup error: Unrecognized Minimizer, use Conjugate Gradient \n");
1878 +          painCave.isFatal = 0;
1879 +          simError();
1880 +
1881 +      myOOPSEMinimizer = new PRCGMinimizer(&(info[i]), the_ff, param);          
1882 +    }
1883 +     info[i].the_integrator = myOOPSEMinimizer;
1884 +
1885 +     //store the minimizer into simInfo
1886 +     info[i].the_minimizer = myOOPSEMinimizer;
1887 +     info[i].has_minimizer = true;
1888 +  }
1889 +
1890 + }

Diff Legend

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