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 1097 by gezelter, Mon Apr 12 20:32:20 2004 UTC vs.
Revision 1174 by gezelter, Wed May 12 20:54:10 2004 UTC

# Line 147 | Line 147 | void SimSetup::createSim(void){
147    // make the output filenames
148  
149    makeOutNames();
150 –
151 –  if (globals->haveMinimizer())
152 –    // make minimizer
153 –    makeMinimizer();
154 –  else
155 –    // make the integrator
156 –    makeIntegrator();
150    
151   #ifdef IS_MPI
152    mpiSim->mpiRefresh();
# Line 162 | Line 155 | void SimSetup::createSim(void){
155    // initialize the Fortran
156  
157    initFortran();
158 +
159 +  if (globals->haveMinimizer())
160 +    // make minimizer
161 +    makeMinimizer();
162 +  else
163 +    // make the integrator
164 +    makeIntegrator();
165 +
166   }
167  
168  
169   void SimSetup::makeMolecules(void){
170    int i, j, k;
171 <  int exI, exJ, exK, exL, slI;
171 >  int exI, exJ, exK, exL, slI, slJ;
172    int tempI, tempJ, tempK, tempL;
173    int molI;
174    int stampID, atomOffset, rbOffset;
# Line 182 | Line 183 | void SimSetup::makeMolecules(void){
183    BendStamp* currentBend;
184    TorsionStamp* currentTorsion;
185    RigidBodyStamp* currentRigidBody;
186 +  CutoffGroupStamp* currentCutoffGroup;
187 +  CutoffGroup* myCutoffGroup;
188 +  int nCutoffGroups;// number of cutoff group of a molecule defined in mdl file
189 +  set<int> cutoffAtomSet; //atoms belong to  cutoffgroup defined at mdl file
190  
191    bond_pair* theBonds;
192    bend_set* theBends;
# Line 190 | Line 195 | void SimSetup::makeMolecules(void){
195    set<int> skipList;
196  
197    double phi, theta, psi;
198 +  char* molName;
199 +  char rbName[100];
200  
201    //init the forceField paramters
202  
# Line 206 | Line 213 | void SimSetup::makeMolecules(void){
213  
214      for (i = 0; i < info[k].n_mol; i++){
215        stampID = info[k].molecules[i].getStampID();
216 +      molName = comp_stamps[stampID]->getID();
217  
218        molInfo.nAtoms = comp_stamps[stampID]->getNAtoms();
219        molInfo.nBonds = comp_stamps[stampID]->getNBonds();
220        molInfo.nBends = comp_stamps[stampID]->getNBends();
221        molInfo.nTorsions = comp_stamps[stampID]->getNTorsions();
222        molInfo.nRigidBodies = comp_stamps[stampID]->getNRigidBodies();
223 +
224 +      nCutoffGroups = comp_stamps[stampID]->getNCutoffGroups();
225        
226        molInfo.myAtoms = &(info[k].atoms[atomOffset]);
227  
228        if (molInfo.nBonds > 0)
229 <        molInfo.myBonds = new (Bond *) [molInfo.nBonds];
229 >        molInfo.myBonds = new Bond*[molInfo.nBonds];
230        else
231          molInfo.myBonds = NULL;
232  
233        if (molInfo.nBends > 0)
234 <        molInfo.myBends = new (Bend *) [molInfo.nBends];
234 >        molInfo.myBends = new Bend*[molInfo.nBends];
235        else
236          molInfo.myBends = NULL;
237  
238        if (molInfo.nTorsions > 0)
239 <        molInfo.myTorsions = new (Torsion *) [molInfo.nTorsions];
239 >        molInfo.myTorsions = new Torsion *[molInfo.nTorsions];
240        else
241          molInfo.myTorsions = NULL;
242  
# Line 259 | Line 269 | void SimSetup::makeMolecules(void){
269          else{
270  
271            molInfo.myAtoms[j] = new Atom((j + atomOffset), info[k].getConfiguration());
272 +
273          }
274  
275          molInfo.myAtoms[j]->setType(currentAtom->getType());
265 –
276   #ifdef IS_MPI
277  
278 <        molInfo.myAtoms[j]->setGlobalIndex(globalIndex[j + atomOffset]);
278 >        molInfo.myAtoms[j]->setGlobalIndex(globalAtomIndex[j + atomOffset]);
279  
280   #endif // is_mpi
281        }
# Line 406 | Line 416 | void SimSetup::makeMolecules(void){
416          info[k].excludes->addPair(exK, exL);
417        }
418  
419 +      
420 +      molInfo.myRigidBodies.clear();
421 +      
422        for (j = 0; j < molInfo.nRigidBodies; j++){
423  
424          currentRigidBody = comp_stamps[stampID]->getRigidBody(j);
# Line 414 | Line 427 | void SimSetup::makeMolecules(void){
427          // Create the Rigid Body:
428  
429          myRB = new RigidBody();
430 +
431 +        sprintf(rbName,"%s_RB_%d", molName, j);
432 +        myRB->setType(rbName);
433          
434          for (rb1 = 0; rb1 < nMembers; rb1++) {
435  
# Line 454 | Line 470 | void SimSetup::makeMolecules(void){
470              // used for the exclude list:
471              
472   #ifdef IS_MPI
473 <            exI = info[k].atoms[tempI]->getGlobalIndex() + 1;
474 <            exJ = info[k].atoms[tempJ]->getGlobalIndex() + 1;
473 >            exI = molInfo.myAtoms[tempI]->getGlobalIndex() + 1;
474 >            exJ = molInfo.myAtoms[tempJ]->getGlobalIndex() + 1;
475   #else
476 <            exI = tempI + 1;
477 <            exJ = tempJ + 1;
476 >            exI = molInfo.myAtoms[tempI]->getIndex() + 1;
477 >            exJ = molInfo.myAtoms[tempJ]->getIndex() + 1;
478   #endif
479              
480              info[k].excludes->addPair(exI, exJ);
481              
482            }
483          }
484 +
485 +        molInfo.myRigidBodies.push_back(myRB);
486 +        info[k].rigidBodies.push_back(myRB);
487        }
488        
489 +
490 +      //create cutoff group for molecule
491 +
492 +      cutoffAtomSet.clear();
493 +      molInfo.myCutoffGroups.clear();
494 +      
495 +      for (j = 0; j < nCutoffGroups; j++){
496 +
497 +        currentCutoffGroup = comp_stamps[stampID]->getCutoffGroup(j);
498 +        nMembers = currentCutoffGroup->getNMembers();
499 +
500 +        myCutoffGroup = new CutoffGroup();
501 +        
502 +        for (int cg = 0; cg < nMembers; cg++) {
503 +
504 +          // molI is atom numbering inside this molecule
505 +          molI = currentCutoffGroup->getMember(cg);    
506 +
507 +          // tempI is atom numbering on local processor
508 +          tempI = molI + atomOffset;
509 +          
510 +          myCutoffGroup->addAtom(info[k].atoms[tempI]);          
511 +
512 +          cutoffAtomSet.insert(tempI);
513 +        }
514 +
515 +        molInfo.myCutoffGroups.push_back(myCutoffGroup);
516 +      }//end for (j = 0; j < molInfo.nCutoffGroups; j++)
517 +
518 +      //creat a cutoff group for every atom  in current molecule which does not belong to cutoffgroup defined at mdl file
519 +
520 +      for(j = 0; j < molInfo.nAtoms; j++){
521 +
522 +        if(cutoffAtomSet.find(molInfo.myAtoms[j]->getIndex()) == cutoffAtomSet.end()){
523 +          myCutoffGroup = new CutoffGroup();
524 +          myCutoffGroup->addAtom(molInfo.myAtoms[j]);
525 +          molInfo.myCutoffGroups.push_back(myCutoffGroup);
526 +        }
527 +          
528 +      }
529 +
530 +              
531 +
532 +
533 +      // After this is all set up, scan through the atoms to
534 +      // see if they can be added to the integrableObjects:
535 +
536 +      molInfo.myIntegrableObjects.clear();
537 +      
538 +
539 +      for (j = 0; j < molInfo.nAtoms; j++){
540 +
541 + #ifdef IS_MPI
542 +        slJ = molInfo.myAtoms[j]->getGlobalIndex();
543 + #else
544 +        slJ = j+atomOffset;
545 + #endif
546 +
547 +        // if they aren't on the skip list, then they can be integrated
548 +
549 +        if (skipList.find(slJ) == skipList.end()) {
550 +          mySD = (StuntDouble *) molInfo.myAtoms[j];
551 +          info[k].integrableObjects.push_back(mySD);
552 +          molInfo.myIntegrableObjects.push_back(mySD);
553 +        }
554 +      }
555 +
556 +      // all rigid bodies are integrated:
557 +
558 +      for (j = 0; j < molInfo.nRigidBodies; j++) {
559 +        mySD = (StuntDouble *) molInfo.myRigidBodies[j];
560 +        info[k].integrableObjects.push_back(mySD);      
561 +        molInfo.myIntegrableObjects.push_back(mySD);
562 +      }
563 +    
564 +      
565        // send the arrays off to the forceField for init.
566        
567        the_ff->initializeAtoms(molInfo.nAtoms, molInfo.myAtoms);
# Line 482 | Line 577 | void SimSetup::makeMolecules(void){
577        delete[] theBonds;
578        delete[] theBends;
579        delete[] theTorsions;
580 <    }
486 <
487 <    // build up the integrableObjects vector:
488 <
489 <    for (i = 0; i < info[k].n_atoms; i++) {
490 <      
491 < #ifdef IS_MPI
492 <      slI = info[k].atoms[i]->getGlobalIndex();
493 < #else
494 <      slI = i;
495 < #endif
496 <
497 <      if (skipList.find(slI) == skipList.end()) {
498 <        mySD = (StuntDouble *) info[k].atoms[i];
499 <        info[k].integrableObjects.push_back(mySD);
500 <      }
501 <    }
502 <    for (i = 0; i < info[k].rigidBodies.size(); i++) {
503 <      mySD = (StuntDouble *) info[k].rigidBodies[i];
504 <      info[k].integrableObjects.push_back(mySD);      
505 <    }
506 <    
580 >    }    
581    }
582  
583   #ifdef IS_MPI
584    sprintf(checkPointMsg, "all molecules initialized succesfully");
585    MPIcheckPoint();
586   #endif // is_mpi
513 –
514 –  // clean up the forcefield
515 –
516 –  if (!globals->haveLJrcut()){
517 –
518 –    the_ff->calcRcut();
519 –
520 –  } else {
521 –    
522 –    the_ff->setRcut( globals->getLJrcut() );
523 –  }
587  
525 –  the_ff->cleanMe();
588   }
589  
590   void SimSetup::initFromBass(void){
# Line 809 | Line 871 | void SimSetup::gatherInfo(void){
871    }
872  
873    //check whether sample time, status time, thermal time and reset time are divisble by dt
874 <  if (!isDivisible(globals->getSampleTime(), globals->getDt())){
874 >  if (globals->haveSampleTime() && !isDivisible(globals->getSampleTime(), globals->getDt())){
875      sprintf(painCave.errMsg,
876              "Sample time is not divisible by dt.\n"
877              "\tThis will result in samples that are not uniformly\n"
# Line 819 | Line 881 | void SimSetup::gatherInfo(void){
881      simError();    
882    }
883  
884 <  if (globals->haveStatusTime() && !isDivisible(globals->getSampleTime(), globals->getDt())){
884 >  if (globals->haveStatusTime() && !isDivisible(globals->getStatusTime(), globals->getDt())){
885      sprintf(painCave.errMsg,
886              "Status time is not divisible by dt.\n"
887              "\tThis will result in status reports that are not uniformly\n"
# Line 855 | Line 917 | void SimSetup::gatherInfo(void){
917      if (globals->haveSampleTime()){
918        info[i].sampleTime = globals->getSampleTime();
919        info[i].statusTime = info[i].sampleTime;
858 –      info[i].thermalTime = info[i].sampleTime;
920      }
921      else{
922        info[i].sampleTime = globals->getRunTime();
923        info[i].statusTime = info[i].sampleTime;
863 –      info[i].thermalTime = info[i].sampleTime;
924      }
925  
926      if (globals->haveStatusTime()){
# Line 869 | Line 929 | void SimSetup::gatherInfo(void){
929  
930      if (globals->haveThermalTime()){
931        info[i].thermalTime = globals->getThermalTime();
932 +    } else {
933 +      info[i].thermalTime = globals->getRunTime();
934      }
935  
936      info[i].resetIntegrator = 0;
# Line 939 | Line 1001 | void SimSetup::finalInfoCheck(void){
1001   void SimSetup::finalInfoCheck(void){
1002    int index;
1003    int usesDipoles;
1004 +  int usesCharges;
1005    int i;
1006  
1007    for (i = 0; i < nInfo; i++){
# Line 950 | Line 1013 | void SimSetup::finalInfoCheck(void){
1013        usesDipoles = (info[i].atoms[index])->hasDipole();
1014        index++;
1015      }
1016 <
1016 >    index = 0;
1017 >    usesCharges = 0;
1018 >    while ((index < info[i].n_atoms) && !usesCharges){
1019 >      usesCharges= (info[i].atoms[index])->hasCharge();
1020 >      index++;
1021 >    }
1022   #ifdef IS_MPI
1023      int myUse = usesDipoles;
1024      MPI_Allreduce(&myUse, &usesDipoles, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
1025   #endif //is_mpi
1026  
1027 <    double theEcr, theEst;
1027 >    double theRcut, theRsw;
1028  
1029 <    if (globals->getUseRF()){
1030 <      info[i].useReactionField = 1;
1029 >    if (globals->haveRcut()) {
1030 >      theRcut = globals->getRcut();
1031  
1032 <      if (!globals->haveECR()){
1033 <        sprintf(painCave.errMsg,
1034 <                "SimSetup Warning: No value was set for electrostaticCutoffRadius.\n"
1032 >      if (globals->haveRsw())
1033 >        theRsw = globals->getRsw();
1034 >      else
1035 >        theRsw = theRcut;
1036 >      
1037 >      info[i].setDefaultRcut(theRcut, theRsw);
1038 >
1039 >    } else {
1040 >      
1041 >      the_ff->calcRcut();
1042 >      theRcut = info[i].getRcut();
1043 >
1044 >      if (globals->haveRsw())
1045 >        theRsw = globals->getRsw();
1046 >      else
1047 >        theRsw = theRcut;
1048 >      
1049 >      info[i].setDefaultRcut(theRcut, theRsw);
1050 >    }
1051 >
1052 >    if (globals->getUseRF()){
1053 >      info[i].useReactionField = 1;
1054 >      
1055 >      if (!globals->haveRcut()){
1056 >        sprintf(painCave.errMsg,
1057 >                "SimSetup Warning: No value was set for the cutoffRadius.\n"
1058                  "\tOOPSE will use a default value of 15.0 angstroms"
1059 <                "\tfor the electrostaticCutoffRadius.\n");
1059 >                "\tfor the cutoffRadius.\n");
1060          painCave.isFatal = 0;
1061          simError();
1062 <        theEcr = 15.0;
1062 >        theRcut = 15.0;
1063        }
1064        else{
1065 <        theEcr = globals->getECR();
1065 >        theRcut = globals->getRcut();
1066        }
1067  
1068 <      if (!globals->haveEST()){
1068 >      if (!globals->haveRsw()){
1069          sprintf(painCave.errMsg,
1070 <                "SimSetup Warning: No value was set for electrostaticSkinThickness.\n"
1070 >                "SimSetup Warning: No value was set for switchingRadius.\n"
1071                  "\tOOPSE will use a default value of\n"
1072 <                "\t0.05 * electrostaticCutoffRadius\n"
982 <                "\tfor the electrostaticSkinThickness\n");
1072 >                "\t0.95 * cutoffRadius for the switchingRadius\n");
1073          painCave.isFatal = 0;
1074          simError();
1075 <        theEst = 0.05 * theEcr;
1075 >        theRsw = 0.95 * theRcut;
1076        }
1077        else{
1078 <        theEst = globals->getEST();
1078 >        theRsw = globals->getRsw();
1079        }
1080  
1081 <      info[i].setDefaultEcr(theEcr, theEst);
1081 >      info[i].setDefaultRcut(theRcut, theRsw);
1082  
1083        if (!globals->haveDielectric()){
1084          sprintf(painCave.errMsg,
# Line 1001 | Line 1091 | void SimSetup::finalInfoCheck(void){
1091        info[i].dielectric = globals->getDielectric();
1092      }
1093      else{
1094 <      if (usesDipoles){
1095 <        if (!globals->haveECR()){
1096 <          sprintf(painCave.errMsg,
1097 <                  "SimSetup Warning: No value was set for electrostaticCutoffRadius.\n"
1098 <                  "\tOOPSE will use a default value of 15.0 angstroms"
1099 <                  "\tfor the electrostaticCutoffRadius.\n");
1100 <          painCave.isFatal = 0;
1101 <          simError();
1102 <          theEcr = 15.0;
1103 <        }
1094 >      if (usesDipoles || usesCharges){
1095 >
1096 >        if (!globals->haveRcut()){
1097 >          sprintf(painCave.errMsg,
1098 >                  "SimSetup Warning: No value was set for the cutoffRadius.\n"
1099 >                  "\tOOPSE will use a default value of 15.0 angstroms"
1100 >                  "\tfor the cutoffRadius.\n");
1101 >          painCave.isFatal = 0;
1102 >          simError();
1103 >          theRcut = 15.0;
1104 >      }
1105          else{
1106 <          theEcr = globals->getECR();
1106 >          theRcut = globals->getRcut();
1107          }
1108 <        
1109 <        if (!globals->haveEST()){
1108 >        
1109 >        if (!globals->haveRsw()){
1110            sprintf(painCave.errMsg,
1111 <                  "SimSetup Warning: No value was set for electrostaticSkinThickness.\n"
1111 >                  "SimSetup Warning: No value was set for switchingRadius.\n"
1112                    "\tOOPSE will use a default value of\n"
1113 <                  "\t0.05 * electrostaticCutoffRadius\n"
1023 <                  "\tfor the electrostaticSkinThickness\n");
1113 >                  "\t0.95 * cutoffRadius for the switchingRadius\n");
1114            painCave.isFatal = 0;
1115            simError();
1116 <          theEst = 0.05 * theEcr;
1116 >          theRsw = 0.95 * theRcut;
1117          }
1118          else{
1119 <          theEst = globals->getEST();
1119 >          theRsw = globals->getRsw();
1120          }
1121 +        
1122 +        info[i].setDefaultRcut(theRcut, theRsw);
1123          
1032 –        info[i].setDefaultEcr(theEcr, theEst);
1124        }
1125      }
1126    }
# Line 1037 | Line 1128 | void SimSetup::finalInfoCheck(void){
1128    strcpy(checkPointMsg, "post processing checks out");
1129    MPIcheckPoint();
1130   #endif // is_mpi
1131 +
1132 +  // clean up the forcefield
1133 +  the_ff->cleanMe();
1134   }
1135    
1136   void SimSetup::initSystemCoords(void){
# Line 1251 | Line 1345 | void SimSetup::compList(void){
1345    LinkedMolStamp* headStamp = new LinkedMolStamp();
1346    LinkedMolStamp* currentStamp = NULL;
1347    comp_stamps = new MoleculeStamp * [n_components];
1348 +  bool haveCutoffGroups;
1349  
1350 +  haveCutoffGroups = false;
1351 +  
1352    // make an array of molecule stamps that match the components used.
1353    // also extract the used stamps out into a separate linked list
1354  
# Line 1286 | Line 1383 | void SimSetup::compList(void){
1383        headStamp->add(currentStamp);
1384        comp_stamps[i] = headStamp->match(id);
1385      }
1386 +
1387 +    if(comp_stamps[i]->getNCutoffGroups() > 0)
1388 +      haveCutoffGroups = true;    
1389    }
1390 +    
1391 +  for (i = 0; i < nInfo; i++)
1392 +    info[i].haveCutoffGroups = haveCutoffGroups;
1393  
1394   #ifdef IS_MPI
1395    strcpy(checkPointMsg, "Component stamps successfully extracted\n");
# Line 1334 | Line 1437 | void SimSetup::mpiMolDivide(void){
1437    int localMol, allMol;
1438    int local_atoms, local_bonds, local_bends, local_torsions, local_SRI;
1439    int local_rigid;
1440 +  vector<int> globalMolIndex;
1441  
1442    mpiSim = new mpiSimulation(info);
1443  
1444 <  globalIndex = mpiSim->divideLabor();
1444 >  mpiSim->divideLabor();
1445 >  globalAtomIndex = mpiSim->getGlobalAtomIndex();
1446 >  //globalMolIndex = mpiSim->getGlobalMolIndex();
1447  
1448    // set up the local variables
1449  
# Line 1351 | Line 1457 | void SimSetup::mpiMolDivide(void){
1457    local_bends = 0;
1458    local_torsions = 0;
1459    local_rigid = 0;
1460 <  globalAtomIndex = 0;
1460 >  globalAtomCounter = 0;
1461  
1462    for (i = 0; i < n_components; i++){
1463      for (j = 0; j < components_nmol[i]; j++){
# Line 1364 | Line 1470 | void SimSetup::mpiMolDivide(void){
1470          localMol++;
1471        }      
1472        for (k = 0; k < comp_stamps[i]->getNAtoms(); k++){
1473 <        info[0].molMembershipArray[globalAtomIndex] = allMol;
1474 <        globalAtomIndex++;
1473 >        info[0].molMembershipArray[globalAtomCounter] = allMol;
1474 >        globalAtomCounter++;
1475        }
1476  
1477        allMol++;
# Line 1433 | Line 1539 | void SimSetup::makeSysArrays(void){
1539   #else // is_mpi
1540  
1541      molIndex = 0;
1542 <    globalAtomIndex = 0;
1542 >    globalAtomCounter = 0;
1543      for (i = 0; i < n_components; i++){
1544        for (j = 0; j < components_nmol[i]; j++){
1545          the_molecules[molIndex].setStampID(i);
1546          the_molecules[molIndex].setMyIndex(molIndex);
1547          the_molecules[molIndex].setGlobalIndex(molIndex);
1548          for (k = 0; k < comp_stamps[i]->getNAtoms(); k++){
1549 <          info[l].molMembershipArray[globalAtomIndex] = molIndex;
1550 <          globalAtomIndex++;
1549 >          info[l].molMembershipArray[globalAtomCounter] = molIndex;
1550 >          globalAtomCounter++;
1551          }
1552          molIndex++;
1553        }
# Line 1458 | Line 1564 | void SimSetup::makeSysArrays(void){
1564      info[l].atoms = the_atoms;
1565      info[l].molecules = the_molecules;
1566      info[l].nGlobalExcludes = 0;
1567 <
1567 >    
1568      the_ff->setSimInfo(info);
1569    }
1570   }

Diff Legend

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