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

Comparing branches/development/src/brains/SimInfo.cpp (file contents):
Revision 1534 by gezelter, Wed Dec 29 21:53:28 2010 UTC vs.
Revision 1536 by gezelter, Wed Jan 5 14:49:05 2011 UTC

# Line 54 | Line 54
54   #include "math/Vector3.hpp"
55   #include "primitives/Molecule.hpp"
56   #include "primitives/StuntDouble.hpp"
57 – #include "UseTheForce/doForces_interface.h"
57   #include "UseTheForce/DarkSide/neighborLists_interface.h"
58 + #include "UseTheForce/doForces_interface.h"
59   #include "utils/MemoryUtils.hpp"
60   #include "utils/simError.h"
61   #include "selection/SelectionManager.hpp"
# Line 656 | Line 656 | namespace OpenMD {
656    /**
657     * update
658     *
659 <   *  Performs the global checks and variable settings after the objects have been
660 <   *  created.
659 >   *  Performs the global checks and variable settings after the
660 >   *  objects have been created.
661     *
662     */
663 <  void SimInfo::update() {
664 <    
663 >  void SimInfo::update() {  
664      setupSimVariables();
666 –    setupCutoffs();
667 –    setupSwitching();
668 –    setupElectrostatics();
669 –    setupNeighborlists();
670 –
671 – #ifdef IS_MPI
672 –    setupFortranParallel();
673 – #endif
674 –    setupFortranSim();
675 –    fortranInitialized_ = true;
676 –
665      calcNdf();
666      calcNdfRaw();
667      calcNdfTrans();
668    }
669    
670 +  /**
671 +   * getSimulatedAtomTypes
672 +   *
673 +   * Returns an STL set of AtomType* that are actually present in this
674 +   * simulation.  Must query all processors to assemble this information.
675 +   *
676 +   */
677    set<AtomType*> SimInfo::getSimulatedAtomTypes() {
678      SimInfo::MoleculeIterator mi;
679      Molecule* mol;
# Line 691 | Line 686 | namespace OpenMD {
686          atomTypes.insert(atom->getAtomType());
687        }      
688      }    
694 –    return atomTypes;        
695 –  }
689  
690 <  /**
698 <   * setupCutoffs
699 <   *
700 <   * Sets the values of cutoffRadius and cutoffMethod
701 <   *
702 <   * cutoffRadius : realType
703 <   *  If the cutoffRadius was explicitly set, use that value.
704 <   *  If the cutoffRadius was not explicitly set:
705 <   *      Are there electrostatic atoms?  Use 12.0 Angstroms.
706 <   *      No electrostatic atoms?  Poll the atom types present in the
707 <   *      simulation for suggested cutoff values (e.g. 2.5 * sigma).
708 <   *      Use the maximum suggested value that was found.
709 <   *
710 <   * cutoffMethod : (one of HARD, SWITCHED, SHIFTED_FORCE, SHIFTED_POTENTIAL)
711 <   *      If cutoffMethod was explicitly set, use that choice.
712 <   *      If cutoffMethod was not explicitly set, use SHIFTED_FORCE
713 <   */
714 <  void SimInfo::setupCutoffs() {
715 <    
716 <    if (simParams_->haveCutoffRadius()) {
717 <      cutoffRadius_ = simParams_->getCutoffRadius();
718 <    } else {      
719 <      if (usesElectrostaticAtoms_) {
720 <        sprintf(painCave.errMsg,
721 <                "SimInfo: No value was set for the cutoffRadius.\n"
722 <                "\tOpenMD will use a default value of 12.0 angstroms"
723 <                "\tfor the cutoffRadius.\n");
724 <        painCave.isFatal = 0;
725 <        painCave.severity = OPENMD_INFO;
726 <        simError();
727 <        cutoffRadius_ = 12.0;
728 <      } else {
729 <        RealType thisCut;
730 <        set<AtomType*>::iterator i;
731 <        set<AtomType*> atomTypes;
732 <        atomTypes = getSimulatedAtomTypes();        
733 <        for (i = atomTypes.begin(); i != atomTypes.end(); ++i) {
734 <          thisCut = InteractionManager::Instance()->getSuggestedCutoffRadius((*i));
735 <          cutoffRadius_ = max(thisCut, cutoffRadius_);
736 <        }
737 <        sprintf(painCave.errMsg,
738 <                "SimInfo: No value was set for the cutoffRadius.\n"
739 <                "\tOpenMD will use %lf angstroms.\n",
740 <                cutoffRadius_);
741 <        painCave.isFatal = 0;
742 <        painCave.severity = OPENMD_INFO;
743 <        simError();
744 <      }            
745 <    }
690 > #ifdef IS_MPI
691  
692 <    map<string, CutoffMethod> stringToCutoffMethod;
693 <    stringToCutoffMethod["HARD"] = HARD;
694 <    stringToCutoffMethod["SWITCHING_FUNCTION"] = SWITCHING_FUNCTION;
695 <    stringToCutoffMethod["SHIFTED_POTENTIAL"] = SHIFTED_POTENTIAL;    
696 <    stringToCutoffMethod["SHIFTED_FORCE"] = SHIFTED_FORCE;
697 <  
698 <    if (simParams_->haveCutoffMethod()) {
699 <      string cutMeth = toUpperCopy(simParams_->getCutoffMethod());
700 <      map<string, CutoffMethod>::iterator i;
701 <      i = stringToCutoffMethod.find(cutMeth);
702 <      if (i == stringToCutoffMethod.end()) {
703 <        sprintf(painCave.errMsg,
704 <                "SimInfo: Could not find chosen cutoffMethod %s\n"
705 <                "\tShould be one of: "
706 <                "HARD, SWITCHING_FUNCTION, SHIFTED_POTENTIAL, or SHIFTED_FORCE\n",
707 <                cutMeth.c_str());
708 <        painCave.isFatal = 1;
709 <        painCave.severity = OPENMD_ERROR;
710 <        simError();
711 <      } else {
712 <        cutoffMethod_ = i->second;
713 <      }
714 <    } else {
715 <      sprintf(painCave.errMsg,
716 <              "SimInfo: No value was set for the cutoffMethod.\n"
717 <              "\tOpenMD will use SHIFTED_FORCE.\n");
718 <        painCave.isFatal = 0;
774 <        painCave.severity = OPENMD_INFO;
775 <        simError();
776 <        cutoffMethod_ = SHIFTED_FORCE;        
777 <    }
778 <  }
779 <  
780 <  /**
781 <   * setupSwitching
782 <   *
783 <   * Sets the values of switchingRadius and
784 <   *  If the switchingRadius was explicitly set, use that value (but check it)
785 <   *  If the switchingRadius was not explicitly set: use 0.85 * cutoffRadius_
786 <   */
787 <  void SimInfo::setupSwitching() {
692 >    // loop over the found atom types on this processor, and add their
693 >    // numerical idents to a vector:
694 >
695 >    vector<int> foundTypes;
696 >    set<AtomType*>::iterator i;
697 >    for (i = atomTypes.begin(); i != atomTypes.end(); ++i)
698 >      foundTypes.push_back( (*i)->getIdent() );
699 >
700 >    // count_local holds the number of found types on this processor
701 >    int count_local = foundTypes.size();
702 >
703 >    // count holds the total number of found types on all processors
704 >    // (some will be redundant with the ones found locally):
705 >    int count;
706 >    MPI::COMM_WORLD.Allreduce(&count_local, &count, 1, MPI::INT, MPI::SUM);
707 >
708 >    // create a vector to hold the globally found types, and resize it:
709 >    vector<int> ftGlobal;
710 >    ftGlobal.resize(count);
711 >    vector<int> counts;
712 >
713 >    int nproc = MPI::COMM_WORLD.Get_size();
714 >    counts.resize(nproc);
715 >    vector<int> disps;
716 >    disps.resize(nproc);
717 >
718 >    // now spray out the foundTypes to all the other processors:
719      
720 <    if (simParams_->haveSwitchingRadius()) {
721 <      switchingRadius_ = simParams_->getSwitchingRadius();
791 <      if (switchingRadius_ > cutoffRadius_) {        
792 <        sprintf(painCave.errMsg,
793 <                "SimInfo: switchingRadius (%f) is larger than cutoffRadius(%f)\n",
794 <                switchingRadius_, cutoffRadius_);
795 <        painCave.isFatal = 1;
796 <        painCave.severity = OPENMD_ERROR;
797 <        simError();
798 <      }
799 <    } else {      
800 <      switchingRadius_ = 0.85 * cutoffRadius_;
801 <      sprintf(painCave.errMsg,
802 <              "SimInfo: No value was set for the switchingRadius.\n"
803 <              "\tOpenMD will use a default value of 85 percent of the cutoffRadius.\n"
804 <              "\tswitchingRadius = %f. for this simulation\n", switchingRadius_);
805 <      painCave.isFatal = 0;
806 <      painCave.severity = OPENMD_WARNING;
807 <      simError();
808 <    }          
809 <    
810 <    if (simParams_->haveSwitchingFunctionType()) {
811 <      string funcType = simParams_->getSwitchingFunctionType();
812 <      toUpper(funcType);
813 <      if (funcType == "CUBIC") {
814 <        sft_ = cubic;
815 <      } else {
816 <        if (funcType == "FIFTH_ORDER_POLYNOMIAL") {
817 <          sft_ = fifth_order_poly;
818 <        } else {
819 <          // throw error        
820 <          sprintf( painCave.errMsg,
821 <                   "SimInfo : Unknown switchingFunctionType. (Input file specified %s .)\n"
822 <                   "\tswitchingFunctionType must be one of: "
823 <                   "\"cubic\" or \"fifth_order_polynomial\".",
824 <                   funcType.c_str() );
825 <          painCave.isFatal = 1;
826 <          painCave.severity = OPENMD_ERROR;
827 <          simError();
828 <        }          
829 <      }
830 <    }
831 <  }
720 >    MPI::COMM_WORLD.Allgatherv(&foundTypes[0], count_local, MPI::INT,
721 >                               &ftGlobal[0], &counts[0], &disps[0], MPI::INT);
722  
723 <  /**
724 <   * setupNeighborlists
725 <   *
726 <   *  If the skinThickness was explicitly set, use that value (but check it)
727 <   *  If the skinThickness was not explicitly set: use 1.0 angstroms
728 <   */
729 <  void SimInfo::setupNeighborlists() {    
730 <    if (simParams_->haveSkinThickness()) {
731 <      skinThickness_ = simParams_->getSkinThickness();
732 <    } else {      
733 <      skinThickness_ = 1.0;
734 <      sprintf(painCave.errMsg,
735 <              "SimInfo: No value was set for the skinThickness.\n"
736 <              "\tOpenMD will use a default value of %f Angstroms\n"
737 <              "\tfor this simulation\n", skinThickness_);
738 <      painCave.severity = OPENMD_INFO;
849 <      painCave.isFatal = 0;
850 <      simError();
851 <    }            
723 >    // foundIdents is a stl set, so inserting an already found ident
724 >    // will have no effect.
725 >    set<int> foundIdents;
726 >    vector<int>::iterator j;
727 >    for (j = ftGlobal.begin(); j != ftGlobal.end(); ++j)
728 >      foundIdents.insert((*j));
729 >    
730 >    // now iterate over the foundIdents and get the actual atom types
731 >    // that correspond to these:
732 >    set<int>::iterator it;
733 >    for (it = foundIdents.begin(); it != foundIdents.end(); ++it)
734 >      atomTypes.insert( forceField_->getAtomType((*it)) );
735 >
736 > #endif
737 >    
738 >    return atomTypes;        
739    }
740  
741    void SimInfo::setupSimVariables() {
# Line 892 | Line 779 | namespace OpenMD {
779      fInfo_.SIM_uses_AtomicVirial = usesAtomicVirial_;
780    }
781  
782 <  void SimInfo::setupFortranSim() {
782 >  void SimInfo::setupFortran() {
783      int isError;
784      int nExclude, nOneTwo, nOneThree, nOneFour;
785      vector<int> fortranGlobalGroupMembership;
786      
900 –    notifyFortranSkinThickness(&skinThickness_);
901 –
902 –    int ljsp = cutoffMethod_ == SHIFTED_POTENTIAL ? 1 : 0;
903 –    int ljsf = cutoffMethod_ == SHIFTED_FORCE ? 1 : 0;
904 –    notifyFortranCutoffs(&cutoffRadius_, &switchingRadius_, &ljsp, &ljsf);
905 –
787      isError = 0;
788  
789      //globalGroupMembership_ is filled by SimCreator    
# Line 937 | Line 818 | namespace OpenMD {
818        }      
819      }
820  
821 <    //fill ident array of local atoms (it is actually ident of AtomType, it is so confusing !!!)
821 >    //fill ident array of local atoms (it is actually ident of
822 >    //AtomType, it is so confusing !!!)
823      vector<int> identArray;
824  
825      //to avoid memory reallocation, reserve enough space identArray
# Line 997 | Line 879 | namespace OpenMD {
879        setNeighbors(&nlistNeighbors);
880      }
881    
1000 –
1001 –  }
1002 –
1003 –
1004 –  void SimInfo::setupFortranParallel() {
882   #ifdef IS_MPI    
883 <    //SimInfo is responsible for creating localToGlobalAtomIndex and localToGlobalGroupIndex
883 >    //SimInfo is responsible for creating localToGlobalAtomIndex and
884 >    //localToGlobalGroupIndex
885      vector<int> localToGlobalAtomIndex(getNAtoms(), 0);
886      vector<int> localToGlobalCutoffGroupIndex;
1009 –    SimInfo::MoleculeIterator mi;
1010 –    Molecule::AtomIterator ai;
1011 –    Molecule::CutoffGroupIterator ci;
1012 –    Molecule* mol;
1013 –    Atom* atom;
1014 –    CutoffGroup* cg;
887      mpiSimData parallelData;
1016 –    int isError;
888  
889      for (mol = beginMolecule(mi); mol != NULL; mol  = nextMolecule(mi)) {
890  
# Line 1053 | Line 924 | namespace OpenMD {
924  
925      sprintf(checkPointMsg, " mpiRefresh successful.\n");
926      errorCheckPoint();
1056 –
927   #endif
1058 –  }
928  
929 <
930 <  void SimInfo::setupAccumulateBoxDipole() {    
931 <
932 <
929 >    initFortranFF(&isError);
930 >    if (isError) {
931 >      sprintf(painCave.errMsg,
932 >              "initFortranFF errror: fortran didn't like something we gave it.\n");
933 >      painCave.isFatal = 1;
934 >      simError();
935 >    }
936 >    fortranInitialized_ = true;
937    }
938  
939    void SimInfo::addProperty(GenericData* genData) {

Diff Legend

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