Import Geant4 10.0.0 source tree

examples/extended/parallel/MPI/source/include/G4MPIbatch.hh

@@ -28,8 +28,8 @@
 #ifndef G4MPI_BATCH_H
 #define G4MPI_BATCH_H
 
-#include "G4VMPIsession.hh"
 #include <fstream>
+#include "G4VMPIsession.hh"
 
 class G4MPIbatch : public G4VMPIsession {
 public:
@@ -39,9 +39,9 @@ public:
   virtual G4UIsession* SessionStart();
 
 protected:
-  std::ifstream batchStream;
-  G4bool isOpened;
-  G4bool isBatchMode;
+  std::ifstream batch_stream_;
+  G4bool is_opened_;
+  G4bool is_batch_mode_;
 
   // get a command from a batch script file
   G4String ReadCommand();

examples/extended/parallel/MPI/source/include/G4MPImanager.hh

@@ -29,9 +29,13 @@
 #define G4MPI_MANAGER_H
 
 #include "mpi.h"
-#include "globals.hh"
-#include <pthread.h>
 #include <fstream>
+#include <pthread.h>
+#include "globals.hh"
+
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
 
 class G4MPImessenger;
 class G4MPIsession;
@@ -41,13 +45,13 @@ class G4VMPIseedGenerator;
 class G4MPImanager {
 public:
   // MPI master rank
-  enum { RANK_MASTER = 0 };
-  
+  enum { kRANK_MASTER = 0 };
+
   enum { // MPI tag
-    TAG_G4COMMAND = 100,
-    TAG_G4STATUS = 200,
-    TAG_G4SEED = 300,
-    TAG_DATA = 1000
+    kTAG_G4COMMAND = 100,
+    kTAG_G4STATUS = 200,
+    kTAG_G4SEED = 300,
+    kTAG_DATA = 1000
   };
 
   G4MPImanager();
@@ -101,127 +105,129 @@ public:
   void ShowHelp() const;
 
 private:
-  static G4MPImanager* theManager;
-  G4MPImessenger* messenger;
-  G4MPIsession* session;
-
-  G4int verbose;
-  G4MPIstatus* status; // status for each node
-
-  // MPI rank
-  G4bool isMaster;
-  G4bool isSlave;
-  G4int rank;
-  G4int size;
-
-  // MPI communicator
-  MPI::Intracomm COMM_G4COMMAND;
-
-  // cout/cerr control
-  G4bool qfcout;
-  std::ofstream fscout;
-
-  // init/macro file
-  G4bool qinitmacro;
-  G4String initFileName;
-  G4bool qbatchmode;
-  G4String macroFileName;
+  DISALLOW_COPY_AND_ASSIGN(G4MPImanager);
 
   // internal use
   void Initialize();
   void ParseArguments(G4int argc, char** argv);
-  void Wait(G4int ausec) const;
   void UpdateStatus();
 
-  // for beamOn
-  pthread_t threadID;
+  static G4MPImanager* g4mpi_;
+  G4MPImessenger* messenger_;
+  G4MPIsession* session_;
 
   // seed generator
-  G4VMPIseedGenerator* seedGenerator;
+  G4VMPIseedGenerator* seed_generator_;
+
+  G4MPIstatus* status_; // status for each node
+
+  G4int verbose_;
+
+  // MPI rank
+  G4bool is_master_;
+  G4bool is_slave_;
+  G4int rank_;
+  G4int size_;
+
+  // MPI communicator
+  MPI::Intracomm COMM_G4COMMAND_;
+
+  // cout/cerr control
+  G4bool qfcout_;
+  std::ofstream fscout_;
+
+  // init/macro file
+  G4bool qinitmacro_;
+  G4String init_file_name_;
+  G4bool qbatchmode_;
+  G4String macro_file_name_;
+
+  // for beamOn
+  pthread_t thread_id_;
 
   // parallel parameters
-  G4double masterWeight;
+  G4double master_weight_;
 };
 
 // ====================================================================
 inline G4MPIsession* G4MPImanager::GetMPIsession() const
 {
-  return session;
+  return session_;
 }
 
 inline G4int G4MPImanager::GetVerbose() const
 {
-  return verbose;
+  return verbose_;
 }
 
 inline void G4MPImanager::SetVerbose(G4int iverbose)
 {
-  G4int lv=iverbose;
-  if(iverbose>1) lv=1;
-  if(iverbose<0) lv=0;
+  G4int lv = iverbose;
+  if( iverbose > 1 ) lv = 1;
+  if( iverbose < 0 ) lv = 0;
 
-  verbose= lv;
+  verbose_ = lv;
   return;
 }
 
 inline G4int G4MPImanager::GetRank() const
 {
-  return rank;
+  return rank_;
 }
 
 inline G4int G4MPImanager::GetSize() const
 {
-  return size;
+  return size_;
 }
 
 inline G4bool G4MPImanager::IsMaster() const
 {
-  return isMaster;
+  return is_master_;
 }
 
 inline G4bool G4MPImanager::IsSlave() const
 {
-  return isSlave;
+  return is_slave_;
 }
 
 inline G4bool G4MPImanager::IsInitMacro() const
 {
-  return qinitmacro;
+  return qinitmacro_;
 
 }
 
 inline const G4String& G4MPImanager::GetInitFileName() const
 {
-  return initFileName;
+  return init_file_name_;
 
 }
 
 inline G4bool G4MPImanager::IsBatchMode() const
 {
-  return qbatchmode;
+  return qbatchmode_;
 }
 
 inline const G4String& G4MPImanager::GetMacroFileName() const
 {
-  return macroFileName;
+  return macro_file_name_;
 }
 
 inline void G4MPImanager::SetMasterWeight(G4double aweight)
 {
-  masterWeight= aweight;
+  master_weight_ = aweight;
 
-  if(aweight<0.) masterWeight= 0.;
-  if(aweight>1.) masterWeight= 1.;
+  if( aweight < 0. ) master_weight_ = 0.;
+  if( aweight > 1. ) master_weight_ = 1.;
 }
 
 inline G4double G4MPImanager::GetMasterWeight() const
 {
-  return masterWeight;
+  return master_weight_;
 }
 
 inline G4VMPIseedGenerator* G4MPImanager::GetSeedGenerator() const
 {
-  return seedGenerator;
+  return seed_generator_;
 }
 
 #endif

examples/extended/parallel/MPI/source/include/G4MPImessenger.hh

@@ -30,6 +30,10 @@
 
 #include "G4UImessenger.hh"
 
+#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
+  TypeName(const TypeName&);               \
+  void operator=(const TypeName&)
+
 class G4MPImanager;
 class G4UIdirectory;
 class G4UIcmdWithoutParameter;
@@ -40,30 +44,40 @@ class G4UIcommand;
 
 class G4MPImessenger : public G4UImessenger {
 public:
-  G4MPImessenger(G4MPImanager* manager);
+  G4MPImessenger();
   ~G4MPImessenger();
 
   virtual void SetNewValue(G4UIcommand* command, G4String newValue);
   virtual G4String GetCurrentValue(G4UIcommand* command);
 
+  void SetTargetObject(G4MPImanager* mpi_manager);
+
 private:
-  G4MPImanager* g4MPI;
+  DISALLOW_COPY_AND_ASSIGN(G4MPImessenger);
+
+  G4MPImanager* g4mpi_;
 
   // /mpi
-  G4UIdirectory* dir;
+  G4UIdirectory* dir_;
 
-  G4UIcmdWithAnInteger* verbose;
-  G4UIcmdWithoutParameter* status;
+  G4UIcmdWithAnInteger* verbose_;
+  G4UIcmdWithoutParameter* status_;
 
-  G4UIcmdWithAString* execute;
+  G4UIcmdWithAString* execute_;
 
-  G4UIcommand* beamOn;
-  G4UIcommand* dotbeamOn;
-  G4UIcmdWithADouble* masterWeight;
+  G4UIcommand* beam_on_;
+  G4UIcommand* dot_beam_on_;
+  G4UIcmdWithADouble* master_weight_;
 
-  G4UIcmdWithoutParameter* showSeeds;
-  G4UIcmdWithAnInteger* setMasterSeed;
-  G4UIcommand* setSeed;
+  G4UIcmdWithoutParameter* show_seeds_;
+  G4UIcmdWithAnInteger* set_master_seed_;
+  G4UIcommand* set_seed_;
 };
 
+// ====================================================================
+inline void G4MPImessenger::SetTargetObject(G4MPImanager* mpi_manager)
+{
+  g4mpi_ = mpi_manager;
+}
+
 #endif

examples/extended/parallel/MPI/source/include/G4MPIsession.hh

@@ -40,8 +40,8 @@ public:
 
   virtual G4UIsession* SessionStart();
 
-protected:
-  G4VUIshell* shell;
+private:
+  G4VUIshell* shell_;
 
   // get command from user prompt of the master node
   G4String GetCommand(const char* msg = 0);

examples/extended/parallel/MPI/source/include/G4MPIstatus.hh

@@ -36,8 +36,6 @@ class G4Timer;
 
 class G4MPIstatus {
 public:
-  enum { NSIZE = 10 };
-
   G4MPIstatus();
   ~G4MPIstatus();
 
@@ -63,14 +61,16 @@ public:
 
   void Print() const;
 
+  enum { kNSIZE = 10 };
+
 private:
-  G4int rank;
-  G4int runID;
-  G4int nEventToBeProcessed;
-  G4int eventID;
-  G4double cputime;
-  G4ApplicationState g4state;
-  G4Timer* timer;
+  G4int rank_;
+  G4int run_id_;
+  G4int nevent_to_be_processed_;
+  G4int event_id_;
+  G4double cputime_;
+  G4ApplicationState g4state_;
+  G4Timer* timer_;
 
   G4String GetStateString(G4ApplicationState astate) const;
 };
@@ -78,47 +78,37 @@ private:
 // ====================================================================
 inline G4int G4MPIstatus::SizeOf() const
 {
-  return NSIZE;
+  return kNSIZE;
 }
 
 inline G4int G4MPIstatus::GetRank() const
 {
-  return rank;
+  return rank_;
 }
 
 inline G4int G4MPIstatus::GetRunID() const
 {
-  return runID;
+  return run_id_;
 }
 
 inline G4int G4MPIstatus::GetNEventToBeProcessed() const
 {
-  return nEventToBeProcessed;
+  return nevent_to_be_processed_;
 }
 
 inline G4int G4MPIstatus::GetEventID() const
 {
-  return eventID;
+  return event_id_;
 }
 
 inline G4double G4MPIstatus::GetCPUTime() const
 {
-  return cputime;
+  return cputime_;
 }
 
 inline G4ApplicationState G4MPIstatus::GetG4State() const
 {
-  return g4state;
-}
-
-inline void G4MPIstatus::StartTimer()
-{
-  timer-> Start();
-}
-
-inline void G4MPIstatus::StopTimer()
-{
-  timer-> Stop();
+  return g4state_;
 }
 
 #endif

examples/extended/parallel/MPI/source/include/G4VMPIseedGenerator.hh

@@ -43,22 +43,22 @@ public:
   const std::vector<G4long>& GetSeedList() const;
 
 protected:
-  G4long masterSeed;
-  std::vector<G4long> seedList;
+  G4long master_seed_;
+  std::vector<G4long> seed_list_;
 
   // generate seeds for MPI nodes
-  virtual void GenerateSeeds()=0;
+  virtual void GenerateSeeds() = 0;
 };
 
 // ====================================================================
 inline G4long G4VMPIseedGenerator::GetMasterSeed() const
 {
-  return masterSeed;
+  return master_seed_;
 }
 
-inline const std::vector<G4long>& G4VMPIseedGenerator::GetSeedList() const  
+inline const std::vector<G4long>& G4VMPIseedGenerator::GetSeedList() const
 {
-  return seedList;
+  return seed_list_;
 }
 
 #endif

examples/extended/parallel/MPI/source/include/G4VMPIsession.hh

@@ -30,7 +30,7 @@
 
 #include "G4VBasicShell.hh"
 
-typedef void* (*Func_t)(void *);  // for thead function
+typedef void* (*Func_t)(void *);  // for thread function
 
 class G4MPImanager;
 class G4VUIshell;
@@ -46,14 +46,14 @@ public:
   virtual G4int ReceiveG4cerr(const G4String& cerrString);
 
 protected:
-  G4MPImanager* g4MPI;
+  G4MPImanager* g4mpi_;
 
   // MPI node info (cache)
-  G4bool isMaster;
-  G4bool isSlave;
-  G4int rank;
+  G4bool is_master_;
+  G4bool is_slave_;
+  G4int rank_;
 
-  G4int ExecCommand(G4String acommand);
+  G4int ExecCommand(const G4String& acommand);
   G4String TruncateCommand(const G4String& command) const;
   G4String BypassCommand(const G4String& command) const;