ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/OpenMD/branches/development/src/brains/SimInfo.cpp
(Generate patch)

Comparing trunk/src/brains/SimInfo.cpp (file contents):
Revision 716 by chrisfen, Thu Nov 3 23:12:27 2005 UTC vs.
Revision 1126 by gezelter, Fri Apr 6 21:53:43 2007 UTC

# Line 48 | Line 48
48  
49   #include <algorithm>
50   #include <set>
51 + #include <map>
52  
53   #include "brains/SimInfo.hpp"
54   #include "math/Vector3.hpp"
55   #include "primitives/Molecule.hpp"
56 + #include "primitives/StuntDouble.hpp"
57   #include "UseTheForce/fCutoffPolicy.h"
58   #include "UseTheForce/DarkSide/fElectrostaticSummationMethod.h"
59   #include "UseTheForce/DarkSide/fElectrostaticScreeningMethod.h"
60 + #include "UseTheForce/DarkSide/fSwitchingFunctionType.h"
61   #include "UseTheForce/doForces_interface.h"
62 + #include "UseTheForce/DarkSide/neighborLists_interface.h"
63   #include "UseTheForce/DarkSide/electrostatic_interface.h"
64 < #include "UseTheForce/notifyCutoffs_interface.h"
64 > #include "UseTheForce/DarkSide/switcheroo_interface.h"
65   #include "utils/MemoryUtils.hpp"
66   #include "utils/simError.h"
67   #include "selection/SelectionManager.hpp"
68 + #include "io/ForceFieldOptions.hpp"
69 + #include "UseTheForce/ForceField.hpp"
70  
71 +
72   #ifdef IS_MPI
73   #include "UseTheForce/mpiComponentPlan.h"
74   #include "UseTheForce/DarkSide/simParallel_interface.h"
75   #endif
76  
77   namespace oopse {
78 +  std::set<int> getRigidSet(int index, std::map<int, std::set<int> >& container) {
79 +    std::map<int, std::set<int> >::iterator i = container.find(index);
80 +    std::set<int> result;
81 +    if (i != container.end()) {
82 +        result = i->second;
83 +    }
84  
85 <  SimInfo::SimInfo(MakeStamps* stamps, std::vector<std::pair<MoleculeStamp*, int> >& molStampPairs,
86 <                   ForceField* ff, Globals* simParams) :
87 <    stamps_(stamps), forceField_(ff), simParams_(simParams),
88 <    ndf_(0), ndfRaw_(0), ndfTrans_(0), nZconstraint_(0),
85 >    return result;
86 >  }
87 >  
88 >  SimInfo::SimInfo(ForceField* ff, Globals* simParams) :
89 >    forceField_(ff), simParams_(simParams),
90 >    ndf_(0), fdf_local(0), ndfRaw_(0), ndfTrans_(0), nZconstraint_(0),
91      nGlobalMols_(0), nGlobalAtoms_(0), nGlobalCutoffGroups_(0),
92      nGlobalIntegrableObjects_(0), nGlobalRigidBodies_(0),
93      nAtoms_(0), nBonds_(0),  nBends_(0), nTorsions_(0), nRigidBodies_(0),
94      nIntegrableObjects_(0),  nCutoffGroups_(0), nConstraints_(0),
95 <    sman_(NULL), fortranInitialized_(false) {
95 >    sman_(NULL), fortranInitialized_(false), calcBoxDipole_(false),
96 >    useAtomicVirial_(true) {
97  
82 –            
83 –      std::vector<std::pair<MoleculeStamp*, int> >::iterator i;
98        MoleculeStamp* molStamp;
99        int nMolWithSameStamp;
100        int nCutoffAtoms = 0; // number of atoms belong to cutoff groups
# Line 88 | Line 102 | namespace oopse {
102        CutoffGroupStamp* cgStamp;    
103        RigidBodyStamp* rbStamp;
104        int nRigidAtoms = 0;
105 <    
106 <      for (i = molStampPairs.begin(); i !=molStampPairs.end(); ++i) {
107 <        molStamp = i->first;
108 <        nMolWithSameStamp = i->second;
105 >      std::vector<Component*> components = simParams->getComponents();
106 >      
107 >      for (std::vector<Component*>::iterator i = components.begin(); i !=components.end(); ++i) {
108 >        molStamp = (*i)->getMoleculeStamp();
109 >        nMolWithSameStamp = (*i)->getNMol();
110          
111          addMoleculeStamp(molStamp, nMolWithSameStamp);
112  
113          //calculate atoms in molecules
114          nGlobalAtoms_ += molStamp->getNAtoms() *nMolWithSameStamp;  
115  
101 –
116          //calculate atoms in cutoff groups
117          int nAtomsInGroups = 0;
118          int nCutoffGroupsInStamp = molStamp->getNCutoffGroups();
119          
120          for (int j=0; j < nCutoffGroupsInStamp; j++) {
121 <          cgStamp = molStamp->getCutoffGroup(j);
121 >          cgStamp = molStamp->getCutoffGroupStamp(j);
122            nAtomsInGroups += cgStamp->getNMembers();
123          }
124  
# Line 117 | Line 131 | namespace oopse {
131          int nRigidBodiesInStamp = molStamp->getNRigidBodies();
132          
133          for (int j=0; j < nRigidBodiesInStamp; j++) {
134 <          rbStamp = molStamp->getRigidBody(j);
134 >          rbStamp = molStamp->getRigidBodyStamp(j);
135            nAtomsInRigidBodies += rbStamp->getNMembers();
136          }
137  
# Line 156 | Line 170 | namespace oopse {
170      }
171      molecules_.clear();
172        
159 –    delete stamps_;
173      delete sman_;
174      delete simParams_;
175      delete forceField_;
# Line 263 | Line 276 | namespace oopse {
276            }
277          }
278              
279 <      }//end for (integrableObject)
280 <    }// end for (mol)
279 >      }
280 >    }
281      
282      // n_constraints is local, so subtract them on each processor
283      ndf_local -= nConstraints_;
# Line 281 | Line 294 | namespace oopse {
294  
295    }
296  
297 +  int SimInfo::getFdf() {
298 + #ifdef IS_MPI
299 +    MPI_Allreduce(&fdf_local,&fdf_,1,MPI_INT,MPI_SUM, MPI_COMM_WORLD);
300 + #else
301 +    fdf_ = fdf_local;
302 + #endif
303 +    return fdf_;
304 +  }
305 +    
306    void SimInfo::calcNdfRaw() {
307      int ndfRaw_local;
308  
# Line 343 | Line 365 | namespace oopse {
365      int b;
366      int c;
367      int d;
368 +
369 +    std::map<int, std::set<int> > atomGroups;
370 +
371 +    Molecule::RigidBodyIterator rbIter;
372 +    RigidBody* rb;
373 +    Molecule::IntegrableObjectIterator ii;
374 +    StuntDouble* integrableObject;
375 +    
376 +    for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
377 +           integrableObject = mol->nextIntegrableObject(ii)) {
378 +
379 +      if (integrableObject->isRigidBody()) {
380 +          rb = static_cast<RigidBody*>(integrableObject);
381 +          std::vector<Atom*> atoms = rb->getAtoms();
382 +          std::set<int> rigidAtoms;
383 +          for (int i = 0; i < atoms.size(); ++i) {
384 +            rigidAtoms.insert(atoms[i]->getGlobalIndex());
385 +          }
386 +          for (int i = 0; i < atoms.size(); ++i) {
387 +            atomGroups.insert(std::map<int, std::set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms));
388 +          }      
389 +      } else {
390 +        std::set<int> oneAtomSet;
391 +        oneAtomSet.insert(integrableObject->getGlobalIndex());
392 +        atomGroups.insert(std::map<int, std::set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
393 +      }
394 +    }  
395 +
396      
397 +    
398      for (bond= mol->beginBond(bondIter); bond != NULL; bond = mol->nextBond(bondIter)) {
399        a = bond->getAtomA()->getGlobalIndex();
400        b = bond->getAtomB()->getGlobalIndex();        
# Line 354 | Line 405 | namespace oopse {
405        a = bend->getAtomA()->getGlobalIndex();
406        b = bend->getAtomB()->getGlobalIndex();        
407        c = bend->getAtomC()->getGlobalIndex();
408 +      std::set<int> rigidSetA = getRigidSet(a, atomGroups);
409 +      std::set<int> rigidSetB = getRigidSet(b, atomGroups);
410 +      std::set<int> rigidSetC = getRigidSet(c, atomGroups);
411  
412 <      exclude_.addPair(a, b);
413 <      exclude_.addPair(a, c);
414 <      exclude_.addPair(b, c);        
412 >      exclude_.addPairs(rigidSetA, rigidSetB);
413 >      exclude_.addPairs(rigidSetA, rigidSetC);
414 >      exclude_.addPairs(rigidSetB, rigidSetC);
415 >      
416 >      //exclude_.addPair(a, b);
417 >      //exclude_.addPair(a, c);
418 >      //exclude_.addPair(b, c);        
419      }
420  
421      for (torsion= mol->beginTorsion(torsionIter); torsion != NULL; torsion = mol->nextTorsion(torsionIter)) {
# Line 365 | Line 423 | namespace oopse {
423        b = torsion->getAtomB()->getGlobalIndex();        
424        c = torsion->getAtomC()->getGlobalIndex();        
425        d = torsion->getAtomD()->getGlobalIndex();        
426 +      std::set<int> rigidSetA = getRigidSet(a, atomGroups);
427 +      std::set<int> rigidSetB = getRigidSet(b, atomGroups);
428 +      std::set<int> rigidSetC = getRigidSet(c, atomGroups);
429 +      std::set<int> rigidSetD = getRigidSet(d, atomGroups);
430  
431 +      exclude_.addPairs(rigidSetA, rigidSetB);
432 +      exclude_.addPairs(rigidSetA, rigidSetC);
433 +      exclude_.addPairs(rigidSetA, rigidSetD);
434 +      exclude_.addPairs(rigidSetB, rigidSetC);
435 +      exclude_.addPairs(rigidSetB, rigidSetD);
436 +      exclude_.addPairs(rigidSetC, rigidSetD);
437 +
438 +      /*
439 +      exclude_.addPairs(rigidSetA.begin(), rigidSetA.end(), rigidSetB.begin(), rigidSetB.end());
440 +      exclude_.addPairs(rigidSetA.begin(), rigidSetA.end(), rigidSetC.begin(), rigidSetC.end());
441 +      exclude_.addPairs(rigidSetA.begin(), rigidSetA.end(), rigidSetD.begin(), rigidSetD.end());
442 +      exclude_.addPairs(rigidSetB.begin(), rigidSetB.end(), rigidSetC.begin(), rigidSetC.end());
443 +      exclude_.addPairs(rigidSetB.begin(), rigidSetB.end(), rigidSetD.begin(), rigidSetD.end());
444 +      exclude_.addPairs(rigidSetC.begin(), rigidSetC.end(), rigidSetD.begin(), rigidSetD.end());
445 +        
446 +      
447        exclude_.addPair(a, b);
448        exclude_.addPair(a, c);
449        exclude_.addPair(a, d);
450        exclude_.addPair(b, c);
451        exclude_.addPair(b, d);
452        exclude_.addPair(c, d);        
453 +      */
454      }
455  
377 –    Molecule::RigidBodyIterator rbIter;
378 –    RigidBody* rb;
456      for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
457        std::vector<Atom*> atoms = rb->getAtoms();
458        for (int i = 0; i < atoms.size() -1 ; ++i) {
# Line 400 | Line 477 | namespace oopse {
477      int b;
478      int c;
479      int d;
480 +
481 +    std::map<int, std::set<int> > atomGroups;
482 +
483 +    Molecule::RigidBodyIterator rbIter;
484 +    RigidBody* rb;
485 +    Molecule::IntegrableObjectIterator ii;
486 +    StuntDouble* integrableObject;
487      
488 +    for (integrableObject = mol->beginIntegrableObject(ii); integrableObject != NULL;
489 +           integrableObject = mol->nextIntegrableObject(ii)) {
490 +
491 +      if (integrableObject->isRigidBody()) {
492 +          rb = static_cast<RigidBody*>(integrableObject);
493 +          std::vector<Atom*> atoms = rb->getAtoms();
494 +          std::set<int> rigidAtoms;
495 +          for (int i = 0; i < atoms.size(); ++i) {
496 +            rigidAtoms.insert(atoms[i]->getGlobalIndex());
497 +          }
498 +          for (int i = 0; i < atoms.size(); ++i) {
499 +            atomGroups.insert(std::map<int, std::set<int> >::value_type(atoms[i]->getGlobalIndex(), rigidAtoms));
500 +          }      
501 +      } else {
502 +        std::set<int> oneAtomSet;
503 +        oneAtomSet.insert(integrableObject->getGlobalIndex());
504 +        atomGroups.insert(std::map<int, std::set<int> >::value_type(integrableObject->getGlobalIndex(), oneAtomSet));        
505 +      }
506 +    }  
507 +
508 +    
509      for (bond= mol->beginBond(bondIter); bond != NULL; bond = mol->nextBond(bondIter)) {
510        a = bond->getAtomA()->getGlobalIndex();
511        b = bond->getAtomB()->getGlobalIndex();        
# Line 412 | Line 517 | namespace oopse {
517        b = bend->getAtomB()->getGlobalIndex();        
518        c = bend->getAtomC()->getGlobalIndex();
519  
520 <      exclude_.removePair(a, b);
521 <      exclude_.removePair(a, c);
522 <      exclude_.removePair(b, c);        
520 >      std::set<int> rigidSetA = getRigidSet(a, atomGroups);
521 >      std::set<int> rigidSetB = getRigidSet(b, atomGroups);
522 >      std::set<int> rigidSetC = getRigidSet(c, atomGroups);
523 >
524 >      exclude_.removePairs(rigidSetA, rigidSetB);
525 >      exclude_.removePairs(rigidSetA, rigidSetC);
526 >      exclude_.removePairs(rigidSetB, rigidSetC);
527 >      
528 >      //exclude_.removePair(a, b);
529 >      //exclude_.removePair(a, c);
530 >      //exclude_.removePair(b, c);        
531      }
532  
533      for (torsion= mol->beginTorsion(torsionIter); torsion != NULL; torsion = mol->nextTorsion(torsionIter)) {
# Line 423 | Line 536 | namespace oopse {
536        c = torsion->getAtomC()->getGlobalIndex();        
537        d = torsion->getAtomD()->getGlobalIndex();        
538  
539 +      std::set<int> rigidSetA = getRigidSet(a, atomGroups);
540 +      std::set<int> rigidSetB = getRigidSet(b, atomGroups);
541 +      std::set<int> rigidSetC = getRigidSet(c, atomGroups);
542 +      std::set<int> rigidSetD = getRigidSet(d, atomGroups);
543 +
544 +      exclude_.removePairs(rigidSetA, rigidSetB);
545 +      exclude_.removePairs(rigidSetA, rigidSetC);
546 +      exclude_.removePairs(rigidSetA, rigidSetD);
547 +      exclude_.removePairs(rigidSetB, rigidSetC);
548 +      exclude_.removePairs(rigidSetB, rigidSetD);
549 +      exclude_.removePairs(rigidSetC, rigidSetD);
550 +
551 +      /*
552 +      exclude_.removePairs(rigidSetA.begin(), rigidSetA.end(), rigidSetB.begin(), rigidSetB.end());
553 +      exclude_.removePairs(rigidSetA.begin(), rigidSetA.end(), rigidSetC.begin(), rigidSetC.end());
554 +      exclude_.removePairs(rigidSetA.begin(), rigidSetA.end(), rigidSetD.begin(), rigidSetD.end());
555 +      exclude_.removePairs(rigidSetB.begin(), rigidSetB.end(), rigidSetC.begin(), rigidSetC.end());
556 +      exclude_.removePairs(rigidSetB.begin(), rigidSetB.end(), rigidSetD.begin(), rigidSetD.end());
557 +      exclude_.removePairs(rigidSetC.begin(), rigidSetC.end(), rigidSetD.begin(), rigidSetD.end());
558 +
559 +      
560        exclude_.removePair(a, b);
561        exclude_.removePair(a, c);
562        exclude_.removePair(a, d);
563        exclude_.removePair(b, c);
564        exclude_.removePair(b, d);
565        exclude_.removePair(c, d);        
566 +      */
567      }
568  
434 –    Molecule::RigidBodyIterator rbIter;
435 –    RigidBody* rb;
569      for (rb = mol->beginRigidBody(rbIter); rb != NULL; rb = mol->nextRigidBody(rbIter)) {
570        std::vector<Atom*> atoms = rb->getAtoms();
571        for (int i = 0; i < atoms.size() -1 ; ++i) {
# Line 471 | Line 604 | namespace oopse {
604      /** @deprecate */    
605      int isError = 0;
606      
607 +    setupCutoff();
608 +    
609      setupElectrostaticSummationMethod( isError );
610 +    setupSwitchingFunction();
611 +    setupAccumulateBoxDipole();
612  
613      if(isError){
614        sprintf( painCave.errMsg,
# Line 479 | Line 616 | namespace oopse {
616        painCave.isFatal = 1;
617        simError();
618      }
482 –  
483 –    
484 –    setupCutoff();
619  
620      calcNdf();
621      calcNdfRaw();
# Line 516 | Line 650 | namespace oopse {
650      int useLennardJones = 0;
651      int useElectrostatic = 0;
652      int useEAM = 0;
653 +    int useSC = 0;
654      int useCharge = 0;
655      int useDirectional = 0;
656      int useDipole = 0;
# Line 529 | Line 664 | namespace oopse {
664      //usePBC and useRF are from simParams
665      int usePBC = simParams_->getUsePeriodicBoundaryConditions();
666      int useRF;
667 <    int useDW;
667 >    int useSF;
668 >    int useSP;
669 >    int useBoxDipole;
670 >
671      std::string myMethod;
672  
673      // set the useRF logical
674      useRF = 0;
675 <    useDW = 0;
675 >    useSF = 0;
676 >    useSP = 0;
677  
678  
679      if (simParams_->haveElectrostaticSummationMethod()) {
680        std::string myMethod = simParams_->getElectrostaticSummationMethod();
681        toUpper(myMethod);
682 <      if (myMethod == "REACTION_FIELD") {
683 <        useRF=1;
684 <      } else {
685 <        if (myMethod == "SHIFTED_POTENTIAL") {
686 <          useDW = 1;
687 <        }
682 >      if (myMethod == "REACTION_FIELD"){
683 >        useRF = 1;
684 >      } else if (myMethod == "SHIFTED_FORCE"){
685 >        useSF = 1;
686 >      } else if (myMethod == "SHIFTED_POTENTIAL"){
687 >        useSP = 1;
688        }
689      }
690 +    
691 +    if (simParams_->haveAccumulateBoxDipole())
692 +      if (simParams_->getAccumulateBoxDipole())
693 +        useBoxDipole = 1;
694  
695 +    useAtomicVirial_ = simParams_->getUseAtomicVirial();
696 +
697      //loop over all of the atom types
698      for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
699        useLennardJones |= (*i)->isLennardJones();
700        useElectrostatic |= (*i)->isElectrostatic();
701        useEAM |= (*i)->isEAM();
702 +      useSC |= (*i)->isSC();
703        useCharge |= (*i)->isCharge();
704        useDirectional |= (*i)->isDirectional();
705        useDipole |= (*i)->isDipole();
# Line 604 | Line 750 | namespace oopse {
750      temp = useEAM;
751      MPI_Allreduce(&temp, &useEAM, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
752  
753 +    temp = useSC;
754 +    MPI_Allreduce(&temp, &useSC, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
755 +    
756      temp = useShape;
757      MPI_Allreduce(&temp, &useShape, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);  
758  
# Line 613 | Line 762 | namespace oopse {
762      temp = useRF;
763      MPI_Allreduce(&temp, &useRF, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
764  
765 <    temp = useDW;
766 <    MPI_Allreduce(&temp, &useDW, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);    
765 >    temp = useSF;
766 >    MPI_Allreduce(&temp, &useSF, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);  
767  
768 +    temp = useSP;
769 +    MPI_Allreduce(&temp, &useSP, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
770 +
771 +    temp = useBoxDipole;
772 +    MPI_Allreduce(&temp, &useBoxDipole, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
773 +
774 +    temp = useAtomicVirial_;
775 +    MPI_Allreduce(&temp, &useAtomicVirial_, 1, MPI_INT, MPI_LOR, MPI_COMM_WORLD);
776 +
777   #endif
778  
779      fInfo_.SIM_uses_PBC = usePBC;    
# Line 628 | Line 786 | namespace oopse {
786      fInfo_.SIM_uses_StickyPower = useStickyPower;
787      fInfo_.SIM_uses_GayBerne = useGayBerne;
788      fInfo_.SIM_uses_EAM = useEAM;
789 +    fInfo_.SIM_uses_SC = useSC;
790      fInfo_.SIM_uses_Shapes = useShape;
791      fInfo_.SIM_uses_FLARB = useFLARB;
792      fInfo_.SIM_uses_RF = useRF;
793 <    fInfo_.SIM_uses_DampedWolf = useDW;
794 <
795 <    if( myMethod == "REACTION_FIELD") {
796 <      
638 <      if (simParams_->haveDielectric()) {
639 <        fInfo_.dielect = simParams_->getDielectric();
640 <      } else {
641 <        sprintf(painCave.errMsg,
642 <                "SimSetup Error: No Dielectric constant was set.\n"
643 <                "\tYou are trying to use Reaction Field without"
644 <                "\tsetting a dielectric constant!\n");
645 <        painCave.isFatal = 1;
646 <        simError();
647 <      }      
648 <    }
649 <
793 >    fInfo_.SIM_uses_SF = useSF;
794 >    fInfo_.SIM_uses_SP = useSP;
795 >    fInfo_.SIM_uses_BoxDipole = useBoxDipole;
796 >    fInfo_.SIM_uses_AtomicVirial = useAtomicVirial_;
797    }
798  
799    void SimInfo::setupFortranSim() {
# Line 663 | Line 810 | namespace oopse {
810      }
811  
812      //calculate mass ratio of cutoff group
813 <    std::vector<double> mfact;
813 >    std::vector<RealType> mfact;
814      SimInfo::MoleculeIterator mi;
815      Molecule* mol;
816      Molecule::CutoffGroupIterator ci;
817      CutoffGroup* cg;
818      Molecule::AtomIterator ai;
819      Atom* atom;
820 <    double totalMass;
820 >    RealType totalMass;
821  
822      //to avoid memory reallocation, reserve enough space for mfact
823      mfact.reserve(getNCutoffGroups());
# Line 731 | Line 878 | namespace oopse {
878               "succesfully sent the simulation information to fortran.\n");
879      MPIcheckPoint();
880   #endif // is_mpi
881 +
882 +    // Setup number of neighbors in neighbor list if present
883 +    if (simParams_->haveNeighborListNeighbors()) {
884 +      int nlistNeighbors = simParams_->getNeighborListNeighbors();
885 +      setNeighbors(&nlistNeighbors);
886 +    }
887 +  
888 +
889    }
890  
891  
# Line 793 | Line 948 | namespace oopse {
948  
949   #endif
950  
951 <  double SimInfo::calcMaxCutoffRadius() {
951 >  void SimInfo::setupCutoff() {          
952 >    
953 >    ForceFieldOptions& forceFieldOptions_ = forceField_->getForceFieldOptions();
954  
955 +    // Check the cutoff policy
956 +    int cp =  TRADITIONAL_CUTOFF_POLICY; // Set to traditional by default
957  
958 <    std::set<AtomType*> atomTypes;
959 <    std::set<AtomType*>::iterator i;
960 <    std::vector<double> cutoffRadius;
961 <
962 <    //get the unique atom types
804 <    atomTypes = getUniqueAtomTypes();
805 <
806 <    //query the max cutoff radius among these atom types
807 <    for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
808 <      cutoffRadius.push_back(forceField_->getRcutFromAtomType(*i));
958 >    std::string myPolicy;
959 >    if (forceFieldOptions_.haveCutoffPolicy()){
960 >      myPolicy = forceFieldOptions_.getCutoffPolicy();
961 >    }else if (simParams_->haveCutoffPolicy()) {
962 >      myPolicy = simParams_->getCutoffPolicy();
963      }
964  
965 <    double maxCutoffRadius = *(std::max_element(cutoffRadius.begin(), cutoffRadius.end()));
812 < #ifdef IS_MPI
813 <    //pick the max cutoff radius among the processors
814 < #endif
815 <
816 <    return maxCutoffRadius;
817 <  }
818 <
819 <  void SimInfo::getCutoff(double& rcut, double& rsw) {
820 <    
821 <    if (fInfo_.SIM_uses_Charges | fInfo_.SIM_uses_Dipoles | fInfo_.SIM_uses_RF) {
822 <        
823 <      if (!simParams_->haveCutoffRadius()){
824 <        sprintf(painCave.errMsg,
825 <                "SimCreator Warning: No value was set for the cutoffRadius.\n"
826 <                "\tOOPSE will use a default value of 15.0 angstroms"
827 <                "\tfor the cutoffRadius.\n");
828 <        painCave.isFatal = 0;
829 <        simError();
830 <        rcut = 15.0;
831 <      } else{
832 <        rcut = simParams_->getCutoffRadius();
833 <      }
834 <
835 <      if (!simParams_->haveSwitchingRadius()){
836 <        sprintf(painCave.errMsg,
837 <                "SimCreator Warning: No value was set for switchingRadius.\n"
838 <                "\tOOPSE will use a default value of\n"
839 <                "\t0.85 * cutoffRadius for the switchingRadius\n");
840 <        painCave.isFatal = 0;
841 <        simError();
842 <        rsw = 0.85 * rcut;
843 <      } else{
844 <        rsw = simParams_->getSwitchingRadius();
845 <      }
846 <
847 <    } else {
848 <      // if charge, dipole or reaction field is not used and the cutofff radius is not specified in
849 <      //meta-data file, the maximum cutoff radius calculated from forcefiled will be used
850 <        
851 <      if (simParams_->haveCutoffRadius()) {
852 <        rcut = simParams_->getCutoffRadius();
853 <      } else {
854 <        //set cutoff radius to the maximum cutoff radius based on atom types in the whole system
855 <        rcut = calcMaxCutoffRadius();
856 <      }
857 <
858 <      if (simParams_->haveSwitchingRadius()) {
859 <        rsw  = simParams_->getSwitchingRadius();
860 <      } else {
861 <        rsw = rcut;
862 <      }
863 <    
864 <    }
865 <  }
866 <
867 <  void SimInfo::setupCutoff() {    
868 <    getCutoff(rcut_, rsw_);    
869 <    double rnblist = rcut_ + 1; // skin of neighbor list
870 <
871 <    //Pass these cutoff radius etc. to fortran. This function should be called once and only once
872 <    
873 <    int cp =  TRADITIONAL_CUTOFF_POLICY;
874 <    if (simParams_->haveCutoffPolicy()) {
875 <      std::string myPolicy = simParams_->getCutoffPolicy();
965 >    if (!myPolicy.empty()){
966        toUpper(myPolicy);
967        if (myPolicy == "MIX") {
968          cp = MIX_CUTOFF_POLICY;
# Line 891 | Line 981 | namespace oopse {
981            }    
982          }          
983        }
984 <    }
984 >    }          
985 >    notifyFortranCutoffPolicy(&cp);
986  
987 <
987 >    // Check the Skin Thickness for neighborlists
988 >    RealType skin;
989      if (simParams_->haveSkinThickness()) {
990 <      double skinThickness = simParams_->getSkinThickness();
991 <    }
990 >      skin = simParams_->getSkinThickness();
991 >      notifyFortranSkinThickness(&skin);
992 >    }            
993 >        
994 >    // Check if the cutoff was set explicitly:
995 >    if (simParams_->haveCutoffRadius()) {
996 >      rcut_ = simParams_->getCutoffRadius();
997 >      if (simParams_->haveSwitchingRadius()) {
998 >        rsw_  = simParams_->getSwitchingRadius();
999 >      } else {
1000 >        if (fInfo_.SIM_uses_Charges |
1001 >            fInfo_.SIM_uses_Dipoles |
1002 >            fInfo_.SIM_uses_RF) {
1003 >          
1004 >          rsw_ = 0.85 * rcut_;
1005 >          sprintf(painCave.errMsg,
1006 >                  "SimCreator Warning: No value was set for the switchingRadius.\n"
1007 >                  "\tOOPSE will use a default value of 85 percent of the cutoffRadius.\n"
1008 >                  "\tswitchingRadius = %f. for this simulation\n", rsw_);
1009 >        painCave.isFatal = 0;
1010 >        simError();
1011 >        } else {
1012 >          rsw_ = rcut_;
1013 >          sprintf(painCave.errMsg,
1014 >                  "SimCreator Warning: No value was set for the switchingRadius.\n"
1015 >                  "\tOOPSE will use the same value as the cutoffRadius.\n"
1016 >                  "\tswitchingRadius = %f. for this simulation\n", rsw_);
1017 >          painCave.isFatal = 0;
1018 >          simError();
1019 >        }
1020 >      }
1021 >      
1022 >      notifyFortranCutoffs(&rcut_, &rsw_);
1023 >      
1024 >    } else {
1025 >      
1026 >      // For electrostatic atoms, we'll assume a large safe value:
1027 >      if (fInfo_.SIM_uses_Charges | fInfo_.SIM_uses_Dipoles | fInfo_.SIM_uses_RF) {
1028 >        sprintf(painCave.errMsg,
1029 >                "SimCreator Warning: No value was set for the cutoffRadius.\n"
1030 >                "\tOOPSE will use a default value of 15.0 angstroms"
1031 >                "\tfor the cutoffRadius.\n");
1032 >        painCave.isFatal = 0;
1033 >        simError();
1034 >        rcut_ = 15.0;
1035 >      
1036 >        if (simParams_->haveElectrostaticSummationMethod()) {
1037 >          std::string myMethod = simParams_->getElectrostaticSummationMethod();
1038 >          toUpper(myMethod);
1039 >          if (myMethod == "SHIFTED_POTENTIAL" || myMethod == "SHIFTED_FORCE") {
1040 >            if (simParams_->haveSwitchingRadius()){
1041 >              sprintf(painCave.errMsg,
1042 >                      "SimInfo Warning: A value was set for the switchingRadius\n"
1043 >                      "\teven though the electrostaticSummationMethod was\n"
1044 >                      "\tset to %s\n", myMethod.c_str());
1045 >              painCave.isFatal = 1;
1046 >              simError();            
1047 >            }
1048 >          }
1049 >        }
1050 >      
1051 >        if (simParams_->haveSwitchingRadius()){
1052 >          rsw_ = simParams_->getSwitchingRadius();
1053 >        } else {        
1054 >          sprintf(painCave.errMsg,
1055 >                  "SimCreator Warning: No value was set for switchingRadius.\n"
1056 >                  "\tOOPSE will use a default value of\n"
1057 >                  "\t0.85 * cutoffRadius for the switchingRadius\n");
1058 >          painCave.isFatal = 0;
1059 >          simError();
1060 >          rsw_ = 0.85 * rcut_;
1061 >        }
1062 >        notifyFortranCutoffs(&rcut_, &rsw_);
1063 >      } else {
1064 >        // We didn't set rcut explicitly, and we don't have electrostatic atoms, so
1065 >        // We'll punt and let fortran figure out the cutoffs later.
1066 >        
1067 >        notifyFortranYouAreOnYourOwn();
1068  
1069 <    notifyFortranCutoffs(&rcut_, &rsw_, &rnblist, &cp);
1070 <    // also send cutoff notification to electrostatics
903 <    setElectrostaticCutoffRadius(&rcut_, &rsw_);
1069 >      }
1070 >    }
1071    }
1072  
1073    void SimInfo::setupElectrostaticSummationMethod( int isError ) {    
# Line 908 | Line 1075 | namespace oopse {
1075      int errorOut;
1076      int esm =  NONE;
1077      int sm = UNDAMPED;
1078 <    double alphaVal;
1079 <    double dielectric;
1080 <
1078 >    RealType alphaVal;
1079 >    RealType dielectric;
1080 >    
1081      errorOut = isError;
915 –    alphaVal = simParams_->getDampingAlpha();
916 –    dielectric = simParams_->getDielectric();
1082  
1083      if (simParams_->haveElectrostaticSummationMethod()) {
1084        std::string myMethod = simParams_->getElectrostaticSummationMethod();
# Line 930 | Line 1095 | namespace oopse {
1095              if (myMethod == "SHIFTED_FORCE") {            
1096                esm = SHIFTED_FORCE;
1097              } else {
1098 <              if (myMethod == "REACTION_FIELD") {            
1098 >              if (myMethod == "REACTION_FIELD") {
1099                  esm = REACTION_FIELD;
1100 +                dielectric = simParams_->getDielectric();
1101 +                if (!simParams_->haveDielectric()) {
1102 +                  // throw warning
1103 +                  sprintf( painCave.errMsg,
1104 +                           "SimInfo warning: dielectric was not specified in the input file\n\tfor the reaction field correction method.\n"
1105 +                           "\tA default value of %f will be used for the dielectric.\n", dielectric);
1106 +                  painCave.isFatal = 0;
1107 +                  simError();
1108 +                }
1109                } else {
1110                  // throw error        
1111                  sprintf( painCave.errMsg,
1112 <                         "SimInfo error: Unknown electrostaticSummationMethod. (Input file specified %s .)\n\telectrostaticSummationMethod must be one of: \"none\", \"shifted_potential\", \"shifted_force\", or \"reaction_field\".", myMethod.c_str() );
1112 >                         "SimInfo error: Unknown electrostaticSummationMethod.\n"
1113 >                         "\t(Input file specified %s .)\n"
1114 >                         "\telectrostaticSummationMethod must be one of: \"none\",\n"
1115 >                         "\t\"shifted_potential\", \"shifted_force\", or \n"
1116 >                         "\t\"reaction_field\".\n", myMethod.c_str() );
1117                  painCave.isFatal = 1;
1118                  simError();
1119                }    
# Line 954 | Line 1132 | namespace oopse {
1132          if (myScreen == "DAMPED") {
1133            sm = DAMPED;
1134            if (!simParams_->haveDampingAlpha()) {
1135 <            //throw error
1135 >            // first set a cutoff dependent alpha value
1136 >            // we assume alpha depends linearly with rcut from 0 to 20.5 ang
1137 >            alphaVal = 0.5125 - rcut_* 0.025;
1138 >            // for values rcut > 20.5, alpha is zero
1139 >            if (alphaVal < 0) alphaVal = 0;
1140 >
1141 >            // throw warning
1142              sprintf( painCave.errMsg,
1143 <                     "SimInfo warning: dampingAlpha was not specified in the input file. A default value of %f (1/ang) will be used.", alphaVal);
1143 >                     "SimInfo warning: dampingAlpha was not specified in the input file.\n"
1144 >                     "\tA default value of %f (1/ang) will be used for the cutoff of\n\t%f (ang).\n", alphaVal, rcut_);
1145              painCave.isFatal = 0;
1146              simError();
1147 +          } else {
1148 +            alphaVal = simParams_->getDampingAlpha();
1149            }
1150 +          
1151          } else {
1152            // throw error        
1153            sprintf( painCave.errMsg,
1154 <                   "SimInfo error: Unknown electrostaticScreeningMethod. (Input file specified %s .)\n\telectrostaticScreeningMethod must be one of: \"undamped\" or \"damped\".", myScreen.c_str() );
1154 >                   "SimInfo error: Unknown electrostaticScreeningMethod.\n"
1155 >                   "\t(Input file specified %s .)\n"
1156 >                   "\telectrostaticScreeningMethod must be one of: \"undamped\"\n"
1157 >                   "or \"damped\".\n", myScreen.c_str() );
1158            painCave.isFatal = 1;
1159            simError();
1160          }
# Line 972 | Line 1163 | namespace oopse {
1163      
1164      // let's pass some summation method variables to fortran
1165      setElectrostaticSummationMethod( &esm );
1166 +    setFortranElectrostaticMethod( &esm );
1167      setScreeningMethod( &sm );
1168      setDampingAlpha( &alphaVal );
1169      setReactionFieldDielectric( &dielectric );
1170 <    initFortranFF( &esm, &errorOut );
1170 >    initFortranFF( &errorOut );
1171    }
1172  
1173 +  void SimInfo::setupSwitchingFunction() {    
1174 +    int ft = CUBIC;
1175 +
1176 +    if (simParams_->haveSwitchingFunctionType()) {
1177 +      std::string funcType = simParams_->getSwitchingFunctionType();
1178 +      toUpper(funcType);
1179 +      if (funcType == "CUBIC") {
1180 +        ft = CUBIC;
1181 +      } else {
1182 +        if (funcType == "FIFTH_ORDER_POLYNOMIAL") {
1183 +          ft = FIFTH_ORDER_POLY;
1184 +        } else {
1185 +          // throw error        
1186 +          sprintf( painCave.errMsg,
1187 +                   "SimInfo error: Unknown switchingFunctionType. (Input file specified %s .)\n\tswitchingFunctionType must be one of: \"cubic\" or \"fifth_order_polynomial\".", funcType.c_str() );
1188 +          painCave.isFatal = 1;
1189 +          simError();
1190 +        }          
1191 +      }
1192 +    }
1193 +
1194 +    // send switching function notification to switcheroo
1195 +    setFunctionType(&ft);
1196 +
1197 +  }
1198 +
1199 +  void SimInfo::setupAccumulateBoxDipole() {    
1200 +
1201 +    // we only call setAccumulateBoxDipole if the accumulateBoxDipole parameter is true
1202 +    if ( simParams_->haveAccumulateBoxDipole() )
1203 +      if ( simParams_->getAccumulateBoxDipole() ) {
1204 +        setAccumulateBoxDipole();
1205 +        calcBoxDipole_ = true;
1206 +      }
1207 +
1208 +  }
1209 +
1210    void SimInfo::addProperty(GenericData* genData) {
1211      properties_.addProperty(genData);  
1212    }
# Line 1034 | Line 1263 | namespace oopse {
1263      Molecule* mol;
1264  
1265      Vector3d comVel(0.0);
1266 <    double totalMass = 0.0;
1266 >    RealType totalMass = 0.0;
1267      
1268  
1269      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1270 <      double mass = mol->getMass();
1270 >      RealType mass = mol->getMass();
1271        totalMass += mass;
1272        comVel += mass * mol->getComVel();
1273      }  
1274  
1275   #ifdef IS_MPI
1276 <    double tmpMass = totalMass;
1276 >    RealType tmpMass = totalMass;
1277      Vector3d tmpComVel(comVel);    
1278 <    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1279 <    MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1278 >    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1279 >    MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1280   #endif
1281  
1282      comVel /= totalMass;
# Line 1060 | Line 1289 | namespace oopse {
1289      Molecule* mol;
1290  
1291      Vector3d com(0.0);
1292 <    double totalMass = 0.0;
1292 >    RealType totalMass = 0.0;
1293      
1294      for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1295 <      double mass = mol->getMass();
1295 >      RealType mass = mol->getMass();
1296        totalMass += mass;
1297        com += mass * mol->getCom();
1298      }  
1299  
1300   #ifdef IS_MPI
1301 <    double tmpMass = totalMass;
1301 >    RealType tmpMass = totalMass;
1302      Vector3d tmpCom(com);    
1303 <    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1304 <    MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1303 >    MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1304 >    MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1305   #endif
1306  
1307      com /= totalMass;
# Line 1096 | Line 1325 | namespace oopse {
1325        Molecule* mol;
1326        
1327      
1328 <      double totalMass = 0.0;
1328 >      RealType totalMass = 0.0;
1329      
1330  
1331        for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {
1332 <         double mass = mol->getMass();
1332 >         RealType mass = mol->getMass();
1333           totalMass += mass;
1334           com += mass * mol->getCom();
1335           comVel += mass * mol->getComVel();          
1336        }  
1337        
1338   #ifdef IS_MPI
1339 <      double tmpMass = totalMass;
1339 >      RealType tmpMass = totalMass;
1340        Vector3d tmpCom(com);  
1341        Vector3d tmpComVel(comVel);
1342 <      MPI_Allreduce(&tmpMass,&totalMass,1,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1343 <      MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1344 <      MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1342 >      MPI_Allreduce(&tmpMass,&totalMass,1,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1343 >      MPI_Allreduce(tmpCom.getArrayPointer(), com.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1344 >      MPI_Allreduce(tmpComVel.getArrayPointer(), comVel.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1345   #endif
1346        
1347        com /= totalMass;
# Line 1131 | Line 1360 | namespace oopse {
1360     void SimInfo::getInertiaTensor(Mat3x3d &inertiaTensor, Vector3d &angularMomentum){
1361        
1362  
1363 <      double xx = 0.0;
1364 <      double yy = 0.0;
1365 <      double zz = 0.0;
1366 <      double xy = 0.0;
1367 <      double xz = 0.0;
1368 <      double yz = 0.0;
1363 >      RealType xx = 0.0;
1364 >      RealType yy = 0.0;
1365 >      RealType zz = 0.0;
1366 >      RealType xy = 0.0;
1367 >      RealType xz = 0.0;
1368 >      RealType yz = 0.0;
1369        Vector3d com(0.0);
1370        Vector3d comVel(0.0);
1371        
# Line 1148 | Line 1377 | namespace oopse {
1377        Vector3d thisq(0.0);
1378        Vector3d thisv(0.0);
1379  
1380 <      double thisMass = 0.0;
1380 >      RealType thisMass = 0.0;
1381      
1382        
1383        
# Line 1186 | Line 1415 | namespace oopse {
1415   #ifdef IS_MPI
1416        Mat3x3d tmpI(inertiaTensor);
1417        Vector3d tmpAngMom;
1418 <      MPI_Allreduce(tmpI.getArrayPointer(), inertiaTensor.getArrayPointer(),9,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1419 <      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1418 >      MPI_Allreduce(tmpI.getArrayPointer(), inertiaTensor.getArrayPointer(),9,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1419 >      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1420   #endif
1421                
1422        return;
# Line 1208 | Line 1437 | namespace oopse {
1437        Vector3d thisr(0.0);
1438        Vector3d thisp(0.0);
1439        
1440 <      double thisMass;
1440 >      RealType thisMass;
1441        
1442        for (mol = beginMolecule(i); mol != NULL; mol = nextMolecule(i)) {        
1443          thisMass = mol->getMass();
# Line 1221 | Line 1450 | namespace oopse {
1450        
1451   #ifdef IS_MPI
1452        Vector3d tmpAngMom;
1453 <      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_DOUBLE,MPI_SUM, MPI_COMM_WORLD);
1453 >      MPI_Allreduce(tmpAngMom.getArrayPointer(), angularMomentum.getArrayPointer(),3,MPI_REALTYPE,MPI_SUM, MPI_COMM_WORLD);
1454   #endif
1455        
1456        return angularMomentum;
1457     }
1458    
1459 <  
1459 >  StuntDouble* SimInfo::getIOIndexToIntegrableObject(int index) {
1460 >    return IOIndexToIntegrableObject.at(index);
1461 >  }
1462 >  
1463 >  void SimInfo::setIOIndexToIntegrableObject(const std::vector<StuntDouble*>& v) {
1464 >    IOIndexToIntegrableObject= v;
1465 >  }
1466 >
1467 >  /* Returns the Volume of the simulation based on a ellipsoid with semi-axes
1468 >     based on the radius of gyration V=4/3*Pi*R_1*R_2*R_3
1469 >     where R_i are related to the principle inertia moments R_i = sqrt(C*I_i/N), this reduces to
1470 >     V = 4/3*Pi*(C/N)^3/2*sqrt(det(I)). See S.E. Baltazar et. al. Comp. Mat. Sci. 37 (2006) 526-536.
1471 >  */
1472 >  void SimInfo::getGyrationalVolume(RealType &volume){
1473 >    Mat3x3d intTensor;
1474 >    RealType det;
1475 >    Vector3d dummyAngMom;
1476 >    RealType sysconstants;
1477 >    RealType geomCnst;
1478 >
1479 >    geomCnst = 3.0/2.0;
1480 >    /* Get the inertial tensor and angular momentum for free*/
1481 >    getInertiaTensor(intTensor,dummyAngMom);
1482 >    
1483 >    det = intTensor.determinant();
1484 >    sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1485 >    volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(det);
1486 >    return;
1487 >  }
1488 >
1489 >  void SimInfo::getGyrationalVolume(RealType &volume, RealType &detI){
1490 >    Mat3x3d intTensor;
1491 >    Vector3d dummyAngMom;
1492 >    RealType sysconstants;
1493 >    RealType geomCnst;
1494 >
1495 >    geomCnst = 3.0/2.0;
1496 >    /* Get the inertial tensor and angular momentum for free*/
1497 >    getInertiaTensor(intTensor,dummyAngMom);
1498 >    
1499 >    detI = intTensor.determinant();
1500 >    sysconstants = geomCnst/(RealType)nGlobalIntegrableObjects_;
1501 >    volume = 4.0/3.0*NumericConstant::PI*pow(sysconstants,3.0/2.0)*sqrt(detI);
1502 >    return;
1503 >  }
1504 > /*
1505 >   void SimInfo::setStuntDoubleFromGlobalIndex(std::vector<StuntDouble*> v) {
1506 >      assert( v.size() == nAtoms_ + nRigidBodies_);
1507 >      sdByGlobalIndex_ = v;
1508 >    }
1509 >
1510 >    StuntDouble* SimInfo::getStuntDoubleFromGlobalIndex(int index) {
1511 >      //assert(index < nAtoms_ + nRigidBodies_);
1512 >      return sdByGlobalIndex_.at(index);
1513 >    }  
1514 > */  
1515   }//end namespace oopse
1516  

Diff Legend

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