提交: 9e4d7cb3f74676c6ba6269b79e91e54651221827 - MolDS (git)

Commit MetaInfo

• 修訂: 9e4d7cb3f74676c6ba6269b79e91e54651221827 (tree)
• 時間: 2013-08-01 09:43:11
• 作者: Mikiya Fujii <mikiya.fujii@gmai...>
• Commiter: Mikiya Fujii

Log Message

Synchronize phase space point between all MPI-processes in MC, MD, RPMD, and opt is added. #31814

git-svn-id: https://svn.sourceforge.jp/svnroot/molds/trunk@1450 1136aad2-a195-0410-b898-f5ea1d11b9d8

Change Summary

• modified: src/base/Molecule.cpp
• modified: src/base/Molecule.h
• modified: src/mc/MC.cpp
• modified: src/md/MD.cpp
• modified: src/optimization/BFGS.cpp
• modified: src/optimization/Optimizer.cpp
• modified: src/optimization/SteepestDescent.cpp
• modified: src/rpmd/RPMD.cpp
• modified: src/rpmd/RPMD.h

差異

--- a/src/base/Molecule.cpp
+++ b/src/base/Molecule.cpp
@@ -711,6 +711,88 @@ void Molecule::SynchronizePhaseSpacePointTo(const Molecule& ref){
    this->CalcBasicsConfiguration();
 }
 
+void Molecule::BroadcastConfigurationToAllProcesses(int root) const{
+   int numTransported = this->GetNumberAtoms()*CartesianType_end;
+   double* tmp=NULL;
+   try{
+      MolDS_base::MallocerFreer::GetInstance()->Malloc<double>(&tmp, numTransported);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            tmp[a*CartesianType_end+i] = atom.GetXyz()[i];
+         }
+      }
+      MolDS_mpi::MpiProcess::GetInstance()->Broadcast(tmp, numTransported, root);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            atom.GetXyz()[i] = tmp[a*CartesianType_end+i];
+         }
+      }
+   }
+   catch(MolDS_base::MolDSException ex){
+      MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+      throw ex;
+   }
+   MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+}
+
+void Molecule::BroadcastMomentaToAllProcesses(int root) const{
+   int numTransported = this->GetNumberAtoms()*CartesianType_end;
+   double* tmp=NULL;
+   try{
+      MolDS_base::MallocerFreer::GetInstance()->Malloc<double>(&tmp, numTransported);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            tmp[a*CartesianType_end+i] = atom.GetPxyz()[i];
+         }
+      }
+      MolDS_mpi::MpiProcess::GetInstance()->Broadcast(tmp, numTransported, root);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            atom.GetPxyz()[i] = tmp[a*CartesianType_end+i];
+         }
+      }
+   }
+   catch(MolDS_base::MolDSException ex){
+      MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+      throw ex;
+   }
+   MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+}
+
+void Molecule::BroadcastPhaseSpacePointToAllProcesses(int root) const{
+   int numTransported = 2*this->GetNumberAtoms()*CartesianType_end;
+   double* tmp=NULL;
+   try{
+      MolDS_base::MallocerFreer::GetInstance()->Malloc<double>(&tmp, numTransported);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            int k = a*CartesianType_end+i;
+            tmp[2*k  ] = atom.GetXyz() [i];
+            tmp[2*k+1] = atom.GetPxyz()[i];
+         }
+      }
+      MolDS_mpi::MpiProcess::GetInstance()->Broadcast(tmp, numTransported, root);
+      for(int a=0; a<this->GetNumberAtoms(); a++){
+         Atom& atom = *this->GetAtom(a);
+         for(int i=0; i<CartesianType_end; i++){
+            int k = a*CartesianType_end+i;
+            atom.GetXyz() [i] = tmp[2*k  ];
+            atom.GetPxyz()[i] = tmp[2*k+1];
+         }
+      }
+   }
+   catch(MolDS_base::MolDSException ex){
+      MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+      throw ex;
+   }
+   MolDS_base::MallocerFreer::GetInstance()->Free<double>(&tmp, numTransported);
+}
+
 }
 
 

--- a/src/base/Molecule.h
+++ b/src/base/Molecule.h
@@ -60,6 +60,9 @@ public:
    void SynchronizeConfigurationTo  (const Molecule& ref);
    void SynchronizeMomentaTo        (const Molecule& ref);
    void SynchronizePhaseSpacePointTo(const Molecule& ref);
+   void BroadcastConfigurationToAllProcesses(int root) const;
+   void BroadcastMomentaToAllProcesses(int root) const;
+   void BroadcastPhaseSpacePointToAllProcesses(int root) const;
 private:
    std::vector<MolDS_base_atoms::Atom*>* atomVect;
    double*  xyzCOM; // x, y, z coordinates of Center of Mass;

--- a/src/mc/MC.cpp
+++ b/src/mc/MC.cpp
@@ -137,6 +137,11 @@ void MC::DoMC(int totalSteps, int elecState, double temperature, double stepWidt
       else{
          trialMolecule.SynchronizeConfigurationTo(*this->molecule);
       }
+
+      // Broadcast to all processes
+      int root=0;
+      this->molecule->BroadcastConfigurationToAllProcesses(root);
+      trialMolecule.BroadcastConfigurationToAllProcesses(root);
       
       // output molecular states
       this->OutputMolecule(*currentES, *this->molecule, elecState);

--- a/src/md/MD.cpp
+++ b/src/md/MD.cpp
@@ -115,6 +115,10 @@ void MD::DoMD(){
       // update momenta
       this->UpdateMomenta(*this->molecule, matrixForce, dt);
 
+      // Broadcast to all processes
+      int root=0;
+      this->molecule->BroadcastPhaseSpacePointToAllProcesses(root);
+
       // output results
       this->OutputEnergies(electronicStructure, initialEnergy);
       this->molecule->OutputConfiguration();

--- a/src/optimization/BFGS.cpp
+++ b/src/optimization/BFGS.cpp
@@ -188,6 +188,11 @@ void BFGS::SearchMinimum(boost::shared_ptr<ElectronicStructure> electronicStruct
          }
          else{
             this->UpdateMolecularCoordinates(molecule, matrixStep);
+
+            // Broadcast to all processes
+            int root=0;
+            molecule.BroadcastConfigurationToAllProcesses(root);
+
             this->UpdateElectronicStructure(electronicStructure, molecule, requireGuess, tempCanOutputLogs);
             lineSearchCurrentEnergy = electronicStructure->GetElectronicEnergy(elecState);
          }

--- a/src/optimization/Optimizer.cpp
+++ b/src/optimization/Optimizer.cpp
@@ -158,9 +158,9 @@ void Optimizer::UpdateMolecularCoordinates(Molecule& molecule, double const* con
 }
 
 void Optimizer::UpdateElectronicStructure(boost::shared_ptr<ElectronicStructure> electronicStructure, 
-                                                Molecule& molecule,
-                                                bool requireGuess, 
-                                                bool canOutputLogs) const{
+                                          Molecule& molecule,
+                                          bool requireGuess, 
+                                          bool canOutputLogs) const{
    electronicStructure->SetCanOutputLogs(canOutputLogs);
    molecule.SetCanOutputLogs(canOutputLogs);
    electronicStructure->DoSCF(requireGuess);
@@ -170,8 +170,8 @@ void Optimizer::UpdateElectronicStructure(boost::shared_ptr<ElectronicStructure>
 }
 
 void Optimizer::OutputMoleculeElectronicStructure(boost::shared_ptr<ElectronicStructure> electronicStructure, 
-                                                        Molecule& molecule,
-                                                        bool canOutputLogs) const{
+                                                  Molecule& molecule,
+                                                  bool canOutputLogs) const{
    // output molecular configuration
    molecule.SetCanOutputLogs(canOutputLogs);
    molecule.OutputConfiguration();
@@ -196,9 +196,10 @@ void Optimizer::LineSearch(boost::shared_ptr<ElectronicStructure> electronicStru
    int lineSearchSteps = 0;
    double lineSearchOldEnergy = lineSearchCurrentEnergy;
 
+   bool requireGuess = false;
    while(lineSearchCurrentEnergy <= lineSearchOldEnergy){
       this->UpdateMolecularCoordinates(molecule, matrixForce, dt);
-      this->UpdateElectronicStructure(electronicStructure, molecule, false, tempCanOutputLogs);
+      this->UpdateElectronicStructure(electronicStructure, molecule, requireGuess, tempCanOutputLogs);
       lineSearchOldEnergy = lineSearchCurrentEnergy;
       lineSearchCurrentEnergy = electronicStructure->GetElectronicEnergy(elecState);
       lineSearchSteps++;
@@ -207,7 +208,13 @@ void Optimizer::LineSearch(boost::shared_ptr<ElectronicStructure> electronicStru
    // final state of line search
    this->OutputLog(boost::format("%s%d\n\n") % this->messageLineSearchSteps.c_str() % lineSearchSteps);
    this->UpdateMolecularCoordinates(molecule, matrixForce, -0.5*dt);
-   this->UpdateElectronicStructure(electronicStructure, molecule, false, tempCanOutputLogs);
+
+   // Broadcast to all processes
+   int root=0;
+   molecule.BroadcastConfigurationToAllProcesses(root);
+
+   // update and output electronic structure
+   this->UpdateElectronicStructure(electronicStructure, molecule, requireGuess, tempCanOutputLogs);
    this->OutputMoleculeElectronicStructure(electronicStructure, molecule, this->CanOutputLogs());
 
    lineSearchCurrentEnergy = electronicStructure->GetElectronicEnergy(elecState);

--- a/src/optimization/SteepestDescent.cpp
+++ b/src/optimization/SteepestDescent.cpp
@@ -89,6 +89,8 @@ void SteepestDescent::SearchMinimum(boost::shared_ptr<ElectronicStructure> elect
 
       // do line search
       this->LineSearch(electronicStructure, molecule, lineSearchCurrentEnergy, matrixForce, elecState, dt);
+
+      // update force
       matrixForce = electronicStructure->GetForce(elecState);
 
       // check convergence

--- a/src/rpmd/RPMD.cpp
+++ b/src/rpmd/RPMD.cpp
@@ -129,6 +129,13 @@ void RPMD::UpdateCoordinates(const vector<boost::shared_ptr<Molecule> >& molecul
    }
 }
 
+void RPMD::BroadcastPhaseSpacepointsToAllProcesses(std::vector<boost::shared_ptr<MolDS_base::Molecule> >& molecularBeads, int root) const{
+   int numBeads = molecularBeads.size();
+   for(int b=0; b<numBeads; b++){
+      molecularBeads[b]->BroadcastPhaseSpacePointToAllProcesses(root);
+   }
+}
+
 void RPMD::FluctuateBeads(const vector<boost::shared_ptr<Molecule> >& molecularBeads,
                           int elecState,
                           double temperature,
@@ -194,6 +201,10 @@ void RPMD::DoRPMD(const Molecule& refferenceMolecule){
       // update momenta
       this->UpdateMomenta(molecularBeads, electronicStructureBeads, elecState, dt, temperature);
 
+      // Broadcast coordinates and momenta of beads to all processes
+      int root=0;
+      this->BroadcastPhaseSpacepointsToAllProcesses(molecularBeads, root);
+
       // output energy
       this->OutputEnergies(molecularBeads, 
                            electronicStructureBeads,

--- a/src/rpmd/RPMD.h
+++ b/src/rpmd/RPMD.h
@@ -65,6 +65,7 @@ private:
    void UpdateCoordinates(const std::vector<boost::shared_ptr<MolDS_base::Molecule> >& molecularBeads,
                           double dt);
    void UpdateElectronicStructure(const std::vector<boost::shared_ptr<MolDS_base::ElectronicStructure> >& electronicStructureBeads);
+   void BroadcastPhaseSpacepointsToAllProcesses(std::vector<boost::shared_ptr<MolDS_base::Molecule> >& molecularBeads, int root) const;
    void FluctuateBeads(const std::vector<boost::shared_ptr<MolDS_base::Molecule> >& molecularBeads,
                        int elecState,
                        double temperature,