Import Geant4 11.0.0 source tree

examples/basic/B1/include/ActionInitialization.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1ActionInitialization.hh
-/// \brief Definition of the B1ActionInitialization class
+/// \file ActionInitialization.hh
+/// \brief Definition of the B1::ActionInitialization class
 
 #ifndef B1ActionInitialization_h
 #define B1ActionInitialization_h 1
@@ -34,18 +34,21 @@
 
 /// Action initialization class.
 
-class B1ActionInitialization : public G4VUserActionInitialization
+namespace B1
+{
+
+class ActionInitialization : public G4VUserActionInitialization
 {
   public:
-    B1ActionInitialization();
-    virtual ~B1ActionInitialization();
+    ActionInitialization();
+    ~ActionInitialization() override;
 
-    virtual void BuildForMaster() const;
-    virtual void Build() const;
+    void BuildForMaster() const override;
+    void Build() const override;
 };
 
+}
+
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif
-
-

examples/basic/B1/include/DetectorConstruction.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1DetectorConstruction.hh
-/// \brief Definition of the B1DetectorConstruction class
+/// \file DetectorConstruction.hh
+/// \brief Definition of the B1::DetectorConstruction class
 
 #ifndef B1DetectorConstruction_h
 #define B1DetectorConstruction_h 1
@@ -38,21 +38,25 @@ class G4LogicalVolume;
 
 /// Detector construction class to define materials and geometry.
 
-class B1DetectorConstruction : public G4VUserDetectorConstruction
+namespace B1
+{
+
+class DetectorConstruction : public G4VUserDetectorConstruction
 {
   public:
-    B1DetectorConstruction();
-    virtual ~B1DetectorConstruction();
+    DetectorConstruction();
+    ~DetectorConstruction() override;
 
-    virtual G4VPhysicalVolume* Construct();
+    G4VPhysicalVolume* Construct() override;
 
     G4LogicalVolume* GetScoringVolume() const { return fScoringVolume; }
 
   protected:
-    G4LogicalVolume*  fScoringVolume;
+    G4LogicalVolume* fScoringVolume = nullptr;
 };
 
+}
+
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif
-

examples/basic/B1/include/EventAction.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1EventAction.hh
-/// \brief Definition of the B1EventAction class
+/// \file EventAction.hh
+/// \brief Definition of the B1::EventAction class
 
 #ifndef B1EventAction_h
 #define B1EventAction_h 1
@@ -33,27 +33,32 @@
 #include "G4UserEventAction.hh"
 #include "globals.hh"
 
-class B1RunAction;
-
 /// Event action class
 ///
 
-class B1EventAction : public G4UserEventAction
+namespace B1
+{
+
+class RunAction;
+
+class EventAction : public G4UserEventAction
 {
   public:
-    B1EventAction(B1RunAction* runAction);
-    virtual ~B1EventAction();
+    EventAction(RunAction* runAction);
+    ~EventAction() override;
 
-    virtual void BeginOfEventAction(const G4Event* event);
-    virtual void EndOfEventAction(const G4Event* event);
+    void BeginOfEventAction(const G4Event* event) override;
+    void EndOfEventAction(const G4Event* event) override;
 
     void AddEdep(G4double edep) { fEdep += edep; }
 
   private:
-    B1RunAction* fRunAction;
-    G4double     fEdep;
+    RunAction* fRunAction = nullptr;
+    G4double   fEdep = 0.;
 };
 
+}
+
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif

examples/basic/B1/include/PrimaryGeneratorAction.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1PrimaryGeneratorAction.hh
-/// \brief Definition of the B1PrimaryGeneratorAction class
+/// \file PrimaryGeneratorAction.hh
+/// \brief Definition of the B1::PrimaryGeneratorAction class
 
 #ifndef B1PrimaryGeneratorAction_h
 #define B1PrimaryGeneratorAction_h 1
@@ -43,23 +43,28 @@ class G4Box;
 /// The default kinematic is a 6 MeV gamma, randomly distribued
 /// in front of the phantom across 80% of the (X,Y) phantom size.
 
-class B1PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction
+namespace B1
+{
+
+class PrimaryGeneratorAction : public G4VUserPrimaryGeneratorAction
 {
   public:
-    B1PrimaryGeneratorAction();
-    virtual ~B1PrimaryGeneratorAction();
+    PrimaryGeneratorAction();
+    ~PrimaryGeneratorAction() override;
 
     // method from the base class
-    virtual void GeneratePrimaries(G4Event*);
+    void GeneratePrimaries(G4Event*) override;
 
     // method to access particle gun
     const G4ParticleGun* GetParticleGun() const { return fParticleGun; }
 
   private:
-    G4ParticleGun*  fParticleGun; // pointer a to G4 gun class
-    G4Box* fEnvelopeBox;
+    G4ParticleGun* fParticleGun = nullptr; // pointer a to G4 gun class
+    G4Box* fEnvelopeBox = nullptr;
 };
 
+}
+
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif

examples/basic/B1/include/RunAction.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1RunAction.hh
-/// \brief Definition of the B1RunAction class
+/// \file RunAction.hh
+/// \brief Definition of the B1::RunAction class
 
 #ifndef B1RunAction_h
 #define B1RunAction_h 1
@@ -42,22 +42,26 @@ class G4Run;
 /// from the energy deposit accumulated via stepping and event actions.
 /// The computed dose is then printed on the screen.
 
-class B1RunAction : public G4UserRunAction
+namespace B1
+{
+
+class RunAction : public G4UserRunAction
 {
   public:
-    B1RunAction();
-    virtual ~B1RunAction();
+    RunAction();
+    ~RunAction() override;
 
-    // virtual G4Run* GenerateRun();
-    virtual void BeginOfRunAction(const G4Run*);
-    virtual void   EndOfRunAction(const G4Run*);
+    void BeginOfRunAction(const G4Run*) override;
+    void   EndOfRunAction(const G4Run*) override;
 
     void AddEdep (G4double edep);
 
   private:
-    G4Accumulable<G4double> fEdep;
-    G4Accumulable<G4double> fEdep2;
+    G4Accumulable<G4double> fEdep = 0.;
+    G4Accumulable<G4double> fEdep2 = 0.;
 };
 
+}
+
 #endif
 

examples/basic/B1/include/SteppingAction.hh

@@ -24,8 +24,8 @@
 // ********************************************************************
 //
 //
-/// \file B1SteppingAction.hh
-/// \brief Definition of the B1SteppingAction class
+/// \file SteppingAction.hh
+/// \brief Definition of the B1::SteppingAction class
 
 #ifndef B1SteppingAction_h
 #define B1SteppingAction_h 1
@@ -33,27 +33,32 @@
 #include "G4UserSteppingAction.hh"
 #include "globals.hh"
 
-class B1EventAction;
-
 class G4LogicalVolume;
 
 /// Stepping action class
 ///
 
-class B1SteppingAction : public G4UserSteppingAction
+namespace B1
+{
+
+class EventAction;
+
+class SteppingAction : public G4UserSteppingAction
 {
   public:
-    B1SteppingAction(B1EventAction* eventAction);
-    virtual ~B1SteppingAction();
+    SteppingAction(EventAction* eventAction);
+    ~SteppingAction() override;
 
     // method from the base class
-    virtual void UserSteppingAction(const G4Step*);
+    void UserSteppingAction(const G4Step*) override;
 
   private:
-    B1EventAction*  fEventAction;
-    G4LogicalVolume* fScoringVolume;
+    EventAction* fEventAction = nullptr;
+    G4LogicalVolume* fScoringVolume = nullptr;
 };
 
+}
+
 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
 
 #endif