Import Geant4 11.3.0 source tree

source/processes/hadronic/models/particle_hp/History

@@ -6,6 +6,54 @@ It must **not** be used as a substitute for writing good git commit messages!
 
 -------------------------------------------------------------------------------
 
+## 2024-10-28 Vladimir Ivanchenko (hadr-hpp-V11-02-16)
+- G4ParticleHPElasticData, G4ParticleHPInelasticData, G4ParticleHPCaptureData,
+  G4ParticleHPFissionData, G4ParticleHPThermalScatteringData,
+  G4ParticleHPThermalScattering - use const pointer of G4ElementTable, remove
+  unnecessary thread local variables, dead code and commented code
+
+## 2024-10-22 Alberto Ribon (hadr-hpp-V11-02-15)
+- G4ParticleHPElasticURR : added boolean argument to the constructor to know
+  whether thermal scattering is activated (false by default).
+
+## 2024-09-26 Alberto Ribon (hadr-hpp-V11-02-14)
+- G4ParticleHPManager, G4ParticleHPProbabilityTablesStore,
+  G4ParticleHPInelasticDataPT, G4ParticleHPInelasticURR : update to use the
+  class G4HadronicParameters to select the type of PT table for the URR 
+  treatment.
+  Thanks to Marek Zmeskal for these changes.
+
+## 2024-09-18 Vladimir Ivanchenko (hadr-hpp-V11-02-13)
+- G4CrossSectionXP - fixed cross section computation with Doppler broading
+    effect due to media temperature.
+
+## 2024-08-26 Gabriele Cosmo (hadr-hpp-V11-02-12)
+- More fixes for reported Coverity defects on use of std::move() and
+  const G4String&.
+
+## 2024-08-21 Gabriele Cosmo (hadr-hpp-V11-02-11)
+- Fixed reported Coverity defects for use of std::move() and const G4String&.
+- Use const qualifier for methods where possible.
+
+## 2024-08-02 Alberto Ribon (hadr-hpp-V11-02-10)
+- G4ParticleHPMessenger : removed ther recently introduced UI command for
+  selecting the type of PT table (choice between  "calendf"  and  "njoy" )
+  for the URR treatment.
+  ( Note: this has been replaced with a C++ interface in G4HadronicParameters
+          that allows the selection to be made at initialization time. )
+
+## 2024-07-18 Alberto Ribon (hadr-hpp-V11-02-09)
+- G4ParticleHPInelastic : fixed missed call to
+  `G4ParticleHPManager::RegisterInelasticFinalStates` in the method
+  `G4ParticleHPInelastic::BuildPhysicsTable`.
+  Thanks to Marek Zmeskal for finding this issue.
+
+## 2024-07-04 Alberto Ribon (hadr-hpp-V11-02-08)
+- G4ParticleHPProbabilityTablesStore, G4ParticleHPIsoProbabilityTable_NJOY,
+  G4ParticleHPIsoProbabilityTable_CALENDF : fixed mistakes in the access to
+  the compressed dataset G4URRPTDATA.
+  Thanks to Marek Zmeskal for reporting this issue.
+
 ## 2024-06-17 Gabriele Cosmo (hadr-hpp-V11-02-07)
 - Fixed compilation warnings for implicit type conversions on macOS/XCode.
 

source/processes/hadronic/models/particle_hp/include/G4CrossSectionHP.hh

@@ -91,8 +91,6 @@ class G4CrossSectionHP : public G4VCrossSectionDataSet
 
     void Initialise(const G4int Z);
 
-    void InitialiseOnFly(const G4int Z);
-
     void PrepareCache(const G4Material*);
 
     G4double IsoCrossSection(const G4double kinE, const G4double loge,

source/processes/hadronic/models/particle_hp/include/G4ENDFTapeRead.hh

@@ -57,7 +57,7 @@ class G4ENDFTapeRead
      *
      *  - Notes: The data will be read in immediately upon construction.
      */
-    G4ENDFTapeRead(G4String FileLocation, G4String FileName,
+    G4ENDFTapeRead(const G4String& FileLocation, const G4String& FileName,
                    G4FFGEnumerations::YieldType WhichYield,
                    G4FFGEnumerations::FissionCause WhichCause);
     /** Overloaded constructor
@@ -70,7 +70,7 @@ class G4ENDFTapeRead
      *
      *  - Notes: The data will be read in immediately upon construction.
      */
-    G4ENDFTapeRead(G4String FileLocation, G4String FileName,
+    G4ENDFTapeRead(const G4String& FileLocation, const G4String& FileName,
                    G4FFGEnumerations::YieldType WhichYield,
                    G4FFGEnumerations::FissionCause WhichCause, G4int Verbosity);
     /** Overloaded constructor
@@ -87,7 +87,7 @@ class G4ENDFTapeRead
 
   protected:
     /** Initialize is a common function called by all constructors. */
-    void Initialize(G4String dataFile);
+    void Initialize(const G4String& dataFile);
     /** Initialize is a common function calles by all constructors */
     void Initialize(std::istringstream& dataStream);
 
@@ -98,21 +98,21 @@ class G4ENDFTapeRead
      *
      *  - Notes:
      */
-    G4double* G4GetEnergyGroupValues();
+    G4double* G4GetEnergyGroupValues() const;
     /** Returns the number of energy yield groups that were extracted from the
      *  ENDF tape file
      *  - Usage: No arguments required
      *
      *  - Notes:
      */
-    G4int G4GetNumberOfEnergyGroups();
+    G4int G4GetNumberOfEnergyGroups() const;
     /** Returns the number of fission products that were extracted from the
      *  ENDF tape file
      *  - Usage: No arguments required
      *
      *  - Notes:
      */
-    G4int G4GetNumberOfFissionProducts();
+    G4int G4GetNumberOfFissionProducts() const;
     /** Returns the data for the requested fission product
      *  - Usage:
      *      - \p WhichYield: 0-based index of the fission product for which to
@@ -122,7 +122,7 @@ class G4ENDFTapeRead
      *      - This will return a pointer to the next G4FissionYieldContainer.
      *        NULL will be returned if no more fission containers exist.
      */
-    G4ENDFYieldDataContainer* G4GetYield(G4int WhichYield);
+    G4ENDFYieldDataContainer* G4GetYield(G4int WhichYield) const;
     /** Sets the verbosity levels
      *  - Usage:
      *      - \p WhichVerbosity: Combination of  levels

source/processes/hadronic/models/particle_hp/include/G4NeutronHPCaptureFS.hh

@@ -43,11 +43,12 @@
 class G4NeutronHPCaptureFS : public G4ParticleHPFinalState
 {
   public:
+
     G4NeutronHPCaptureFS();
     ~G4NeutronHPCaptureFS() override = default;
 
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName,
-              G4String& aFSType, G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
@@ -56,10 +57,10 @@ class G4NeutronHPCaptureFS : public G4ParticleHPFinalState
     }
 
     G4NeutronHPCaptureFS(G4NeutronHPCaptureFS&) = delete;
-    G4NeutronHPCaptureFS& operator=
-    (const G4NeutronHPCaptureFS &right) = delete;
+    G4NeutronHPCaptureFS& operator=(const G4NeutronHPCaptureFS &right) = delete;
 
   private:
+
     G4double targetMass;
     G4bool hasExactMF6;
 

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2AInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHP2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2AInelasticFS();
     ~G4ParticleHP2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2N2AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP2N2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2N2AInelasticFS();
     ~G4ParticleHP2N2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2N2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2NAInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP2NAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2NAInelasticFS();
     ~G4ParticleHP2NAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2NAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2NDInelasticFS.hh

@@ -41,17 +41,17 @@
 class G4ParticleHP2NDInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2NDInelasticFS();
     ~G4ParticleHP2NDInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2NDInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2NInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP2NInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2NInelasticFS();
     ~G4ParticleHP2NInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2NInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2NPInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP2NPInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2NPInelasticFS();
     ~G4ParticleHP2NPInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2NPInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP2PInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP2PInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP2PInelasticFS();
     ~G4ParticleHP2PInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP2PInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP3AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHP3AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP3AInelasticFS();
     ~G4ParticleHP3AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP3AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP3NAInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHP3NAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP3NAInelasticFS();
     ~G4ParticleHP3NAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP3NAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP3NInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHP3NInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP3NInelasticFS();
     ~G4ParticleHP3NInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP3NInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP3NPInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHP3NPInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP3NPInelasticFS();
     ~G4ParticleHP3NPInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP3NPInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHP4NInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHP4NInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHP4NInelasticFS();
     ~G4ParticleHP4NInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHP4NInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPAInelasticFS.hh

@@ -42,17 +42,18 @@
 class G4ParticleHPAInelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPAInelasticFS();
     ~G4ParticleHPAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPChannel.hh

@@ -55,28 +55,29 @@ class G4ParticleDefinition;
 
 class G4ParticleHPChannel
 {
-public:
+ public:
+
   G4ParticleHPChannel(G4ParticleDefinition* projectile = nullptr);
 
   ~G4ParticleHPChannel();
 
-  G4double GetXsec(G4double energy);
+  G4double GetXsec(G4double energy) const;
 
-  G4double GetWeightedXsec(G4double energy, G4int isoNumber);
+  G4double GetWeightedXsec(G4double energy, G4int isoNumber) const;
 
-  G4double GetFSCrossSection(G4double energy, G4int isoNumber);
+  G4double GetFSCrossSection(G4double energy, G4int isoNumber) const;
 
   G4bool IsActive(G4int isoNumber) const
   {
     return active[isoNumber];
   }
 
-  G4bool HasFSData(G4int isoNumber)
+  G4bool HasFSData(G4int isoNumber) const
   { 
     return theFinalStates[isoNumber]->HasFSData();
   }
 
-  G4bool HasAnyData(G4int isoNumber)
+  G4bool HasAnyData(G4int isoNumber) const
   {
     return theFinalStates[isoNumber]->HasAnyData();
   }
@@ -109,7 +110,7 @@ public:
   G4double GetZ(G4int i) const { return theFinalStates[i]->GetZ(); }
   G4double GetM(G4int i) const { return theFinalStates[i]->GetM(); }
 
-  G4bool HasDataInAnyFinalState()
+  G4bool HasDataInAnyFinalState() const
   {
     G4bool result = false;
     for (G4int i = 0; i < niso; ++i) {
@@ -121,23 +122,24 @@ public:
     return result;
   }
 
-  void DumpInfo();
+  void DumpInfo() const;
 
-  G4String& GetFSType() { return theFSType; }
+  const G4String& GetFSType() { return theFSType; }
 
   G4ParticleHPFinalState** GetFinalStates() const { return theFinalStates; }
 
   // method added by M.Zmeskal 02/2024 - to be used in G4ParticleHPFissionURR
-  G4WendtFissionFragmentGenerator* GetWendtFissionGenerator();
+  G4WendtFissionFragmentGenerator* GetWendtFissionGenerator() const;
 
   G4ParticleHPChannel(G4ParticleHPChannel &) = delete;
-  G4ParticleHPChannel & operator=
-  (const G4ParticleHPChannel &right) = delete;
+  G4ParticleHPChannel & operator=(const G4ParticleHPChannel &right) = delete;
+
+ protected:
 
-protected:
   G4ParticleHPManager* fManager;
 
-private:
+ private:
+
   G4ParticleDefinition* theProjectile;
 
   G4ParticleHPVector* theChannelData;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPD2AInelasticFS.hh

@@ -37,17 +37,18 @@
 class G4ParticleHPD2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPD2AInelasticFS();
     ~G4ParticleHPD2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPD2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPDAInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPDAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPDAInelasticFS();
     ~G4ParticleHPDAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPDAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPDInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPDInelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPDInelasticFS();
     ~G4ParticleHPDInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPDInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPDataUsed.hh

@@ -45,12 +45,12 @@ public:
   void SetM(G4int aM) { theM = aM; }
   void SetName(const G4String& aName) { theName = aName; }
 
-  G4int GetZ() { return theZ; }
-  G4int GetA() { return theA; }
-  G4int GetM() { return theM; }
-  G4String& GetName() { return theName; }
+  G4int GetZ() const { return theZ; }
+  G4int GetA() const { return theA; }
+  G4int GetM() const { return theM; }
+  const G4String& GetName() const { return theName; }
 
-  G4bool IsThisNaturalAbundance() { return nat; };
+  G4bool IsThisNaturalAbundance() const { return nat; };
   void SetNaturalAbundanceFlag() { nat = TRUE; };
 
 private:

source/processes/hadronic/models/particle_hp/include/G4ParticleHPElasticFS.hh

@@ -48,14 +48,15 @@
 class G4ParticleHPElasticFS : public G4ParticleHPFinalState
 {
   public:
+
     G4ParticleHPElasticFS();
     ~G4ParticleHPElasticFS() override
     {
       delete theCoefficients;
       delete theProbArray;
     }
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
@@ -67,6 +68,7 @@ class G4ParticleHPElasticFS : public G4ParticleHPFinalState
     void RegisterCrossSection(G4ParticleHPVector* vec) { xsForDBRC = vec; }
 
   private:
+
     // The following two methods and six data members are needed for the DBRC algorithm
     void InitializeScatteringKernelParameters();
     G4ReactionProduct GetBiasedThermalNucleus(const G4double aMass, G4ThreeVector aVelocity,

source/processes/hadronic/models/particle_hp/include/G4ParticleHPElasticURR.hh

@@ -60,7 +60,7 @@ class G4ParticleHPElastic;
 
 class G4ParticleHPElasticURR : public G4HadronicInteraction {
   public:
-    G4ParticleHPElasticURR();
+    G4ParticleHPElasticURR( G4bool isThermalScatteringOn = false );
     ~G4ParticleHPElasticURR();
 
     G4HadFinalState* ApplyYourself( const G4HadProjectile& aTrack, G4Nucleus& aTargetNucleus );

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFCFissionFS.hh

@@ -37,10 +37,12 @@
 class G4ParticleHPFCFissionFS : public G4ParticleHPFissionBaseFS
 {
   public:
+
     G4ParticleHPFCFissionFS() { hasXsec = false; }
     ~G4ParticleHPFCFissionFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition* projectile) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition* projectile) override;
     G4DynamicParticleVector* ApplyYourself(G4int nNeutrons);
     G4ParticleHPFinalState* New() override
     {
@@ -49,6 +51,7 @@ class G4ParticleHPFCFissionFS : public G4ParticleHPFissionBaseFS
     }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 };
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFFFissionFS.hh

@@ -37,11 +37,12 @@
 class G4ParticleHPFFFissionFS : public G4ParticleHPFissionBaseFS
 {
   public:
+
     G4ParticleHPFFFissionFS() { hasXsec = false; }
     ~G4ParticleHPFFFissionFS() override;
 
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
 
     G4DynamicParticleVector* ApplyYourself(G4int nNeutrons);
 
@@ -55,6 +56,7 @@ class G4ParticleHPFFFissionFS : public G4ParticleHPFissionBaseFS
     void GetAFissionFragment(G4double, G4int&, G4int&, G4int&);
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 
     //        MT              Energy            FPS    Yield

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFSFissionFS.hh

@@ -52,11 +52,12 @@ class G4ParticleHPFSFissionFS : public G4ParticleHPFinalState
     };
 
   public:
+
     G4ParticleHPFSFissionFS() { hasXsec = true; }
     ~G4ParticleHPFSFissionFS() override = default;
 
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
 
     G4DynamicParticleVector* ApplyYourself(G4int Prompt, G4int delayed, G4double* decayconst);
 
@@ -66,7 +67,7 @@ class G4ParticleHPFSFissionFS : public G4ParticleHPFinalState
       return theNew;
     }
 
-    inline G4double GetMass() { return theFinalStateNeutrons.GetTargetMass(); }
+    inline G4double GetMass() const { return theFinalStateNeutrons.GetTargetMass(); }
 
     void SampleNeutronMult(G4int& all, G4int& Prompt, G4int& delayed, G4double energy, G4int off);
 
@@ -87,6 +88,7 @@ class G4ParticleHPFSFissionFS : public G4ParticleHPFinalState
     inline G4ParticleHPFissionERelease* GetEnergyRelease() { return &theEnergyRelease; }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 
     G4ParticleHPParticleYield theFinalStateNeutrons;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFinalState.hh

@@ -49,17 +49,18 @@ class G4ParticleDefinition;
 class G4ParticleHPFinalState
 {
   public:
+
     G4ParticleHPFinalState();
     virtual ~G4ParticleHPFinalState();
 
-    void Init(G4double A, G4double Z, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition* p)
+    inline void Init(G4double A, G4double Z, const G4String& dirName,
+                     const G4String& aFSType, G4ParticleDefinition* p)
     {
       theProjectile = p;
       Init(A, Z, 0, dirName, aFSType, p);
     }
-    virtual void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-                      G4ParticleDefinition*) = 0;
+    virtual void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                      const G4String& aFSType, G4ParticleDefinition*) = 0;
 
     virtual G4HadFinalState* ApplyYourself(const G4HadProjectile&)
     {
@@ -73,12 +74,12 @@ class G4ParticleHPFinalState
     //
     virtual G4ParticleHPFinalState* New() = 0;
 
-    G4bool HasXsec() { return hasXsec; }
-    G4bool HasFSData() { return hasFSData; }
-    G4bool HasAnyData() { return hasAnyData; }
+    inline G4bool HasXsec() const { return hasXsec; }
+    inline G4bool HasFSData() const { return hasFSData; }
+    inline G4bool HasAnyData() const { return hasAnyData; }
 
-    virtual G4double GetXsec(G4double) { return 0; }
-    virtual G4ParticleHPVector* GetXsec() { return nullptr; }
+    virtual G4double GetXsec(G4double) const { return 0.; }
+    virtual G4ParticleHPVector* GetXsec() const { return nullptr; }
 
     void SetA_Z(G4double anA, G4double aZ, G4int aM = 0)
     {
@@ -86,19 +87,19 @@ class G4ParticleHPFinalState
       theBaseZ = G4lrint(aZ);
       theBaseM = aM;
     }
-    G4double GetZ() { return theBaseZ; }
-    G4double GetN() { return theBaseA; }
-    G4double GetA() { return theBaseA; }
-    G4int GetM() { return theBaseM; }
+    G4double GetZ() const { return theBaseZ; }
+    G4double GetN() const { return theBaseA; }
+    G4double GetA() const { return theBaseA; }
+    G4int GetM() const { return theBaseM; }
 
-    void SetAZMs(G4ParticleHPDataUsed used)
+    inline void SetAZMs(const G4ParticleHPDataUsed& used)
     {
       theNDLDataA = G4lrint(used.GetA());
       theNDLDataZ = G4lrint(used.GetZ());
       theNDLDataM = used.GetM();
     }
 
-    void SetAZMs(G4double anA, G4double aZ, G4int aM, G4ParticleHPDataUsed used)
+    inline void SetAZMs(G4double anA, G4double aZ, G4int aM, const G4ParticleHPDataUsed& used)
     {
       theBaseA = G4lrint(anA);
       theBaseZ = G4lrint(aZ);
@@ -108,13 +109,16 @@ class G4ParticleHPFinalState
       theNDLDataM = used.GetM();
     }
 
-    void SetProjectile(G4ParticleDefinition* projectile) { theProjectile = projectile; }
+    inline void SetProjectile(G4ParticleDefinition* projectile)
+    {
+      theProjectile = projectile;
+    }
 
-    G4ParticleHPFinalState& operator=
-    (const G4ParticleHPFinalState& right) = delete;
+    G4ParticleHPFinalState& operator=(const G4ParticleHPFinalState& right) = delete;
     G4ParticleHPFinalState(const G4ParticleHPFinalState&) = delete;
 
   protected:
+
     void adjust_final_state(G4LorentzVector);
 
     G4ParticleDefinition* theProjectile{nullptr};
@@ -139,4 +143,5 @@ class G4ParticleHPFinalState
     G4Cache<G4HadFinalState*> theResult;
 
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFissionBaseFS.hh

@@ -49,6 +49,7 @@ class G4ParticleHPFissionBaseFS : public G4ParticleHPFinalState
     };
 
   public:
+
     G4ParticleHPFissionBaseFS()
     {
       hasXsec = true;
@@ -57,17 +58,17 @@ class G4ParticleHPFissionBaseFS : public G4ParticleHPFinalState
 
     ~G4ParticleHPFissionBaseFS() override { delete theXsection; }
 
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& bit,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& bit, G4ParticleDefinition*) override;
 
     G4DynamicParticleVector* ApplyYourself(G4int Prompt);
 
-    G4double GetXsec(G4double anEnergy) override
+    G4double GetXsec(G4double anEnergy) const override
     {
       return std::max(0., theXsection->GetY(anEnergy));
     }
 
-    G4ParticleHPVector* GetXsec() override { return theXsection; }
+    G4ParticleHPVector* GetXsec() const override { return theXsection; }
 
     inline void SetNeutronRP(const G4ReactionProduct& aNeutron)
     {
@@ -82,6 +83,7 @@ class G4ParticleHPFissionBaseFS : public G4ParticleHPFinalState
     }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 
     G4ParticleHPVector* theXsection;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPFissionFS.hh

@@ -44,10 +44,12 @@
 class G4ParticleHPFissionFS : public G4ParticleHPFinalState
 {
   public:
+
     G4ParticleHPFissionFS();
     ~G4ParticleHPFissionFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
@@ -56,6 +58,7 @@ class G4ParticleHPFissionFS : public G4ParticleHPFinalState
     }
 
   private:
+
     G4ParticleHPFSFissionFS theFS;
     G4ParticleHPFCFissionFS theFC;
     G4ParticleHPSCFissionFS theSC;
@@ -65,4 +68,5 @@ class G4ParticleHPFissionFS : public G4ParticleHPFinalState
     G4ParticleHPFFFissionFS theFF;
     G4bool produceFissionFragments;
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPHe3InelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPHe3InelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPHe3InelasticFS();
     ~G4ParticleHPHe3InelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPHe3InelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPInelasticBaseFS.hh

@@ -45,13 +45,13 @@
 
 class G4ParticleHPInelasticBaseFS : public G4ParticleHPFinalState
 {
-public:
+ public:
 
   G4ParticleHPInelasticBaseFS();
   ~G4ParticleHPInelasticBaseFS() override;
 
-  void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& bit,
-	    G4ParticleDefinition*) override;
+  void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+            const G4String& bit, G4ParticleDefinition*) override;
 
   void BaseApply(const G4HadProjectile& theTrack, G4ParticleDefinition** theDefs, G4int nDef);
 
@@ -61,18 +61,17 @@ public:
 
   G4ParticleHPFinalState* New() override = 0;
 
-  G4double GetXsec(G4double anEnergy) override
+  G4double GetXsec(G4double anEnergy) const override
   {
     return std::max(0., theXsection->GetY(anEnergy));
   }
 
-  G4ParticleHPVector* GetXsec() override { return theXsection; }
+  G4ParticleHPVector* GetXsec() const override { return theXsection; }
 
-  G4ParticleHPInelasticBaseFS& operator=
-  (const G4ParticleHPInelasticBaseFS& right) = delete;
+  G4ParticleHPInelasticBaseFS& operator=(const G4ParticleHPInelasticBaseFS& right) = delete;
   G4ParticleHPInelasticBaseFS(const G4ParticleHPInelasticBaseFS&) = delete;
 
-protected:
+ protected:
 
   G4ParticleHPVector* theXsection;
   G4ParticleHPEnergyDistribution* theEnergyDistribution{nullptr};

source/processes/hadronic/models/particle_hp/include/G4ParticleHPInelasticCompFS.hh

@@ -50,12 +50,13 @@
 
 class G4ParticleHPInelasticCompFS : public G4ParticleHPFinalState
 {
-public:
+ public:
+
   G4ParticleHPInelasticCompFS();
   ~G4ParticleHPInelasticCompFS() override;
 
-  void Init(G4double A, G4double Z, G4int M, G4String& dirName,
-            G4String& aSFType, G4ParticleDefinition*) override;
+  void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+            const G4String& aSFType, G4ParticleDefinition*) override;
 
   void InitGammas(G4double AR, G4double ZR);
 
@@ -63,12 +64,12 @@ public:
 
   G4ParticleHPFinalState* New() override = 0;
 
-  G4double GetXsec(G4double anEnergy) override
+  G4double GetXsec(G4double anEnergy) const override
   {
     return std::max(0., theXsection[50]->GetY(anEnergy));
   }
 
-  G4ParticleHPVector* GetXsec() override { return theXsection[50]; }
+  G4ParticleHPVector* GetXsec() const override { return theXsection[50]; }
 
   G4int SelectExitChannel(G4double eKinetic);
 
@@ -79,10 +80,9 @@ public:
 				    G4ReactionProduct& aTarget, G4int it);
 
   G4ParticleHPInelasticCompFS(G4ParticleHPInelasticCompFS&) = delete;
-  G4ParticleHPInelasticCompFS& operator=
-  (const G4ParticleHPInelasticCompFS &right) = delete;
+  G4ParticleHPInelasticCompFS& operator=(const G4ParticleHPInelasticCompFS &right) = delete;
 
-private:
+ private:
 
   void two_body_reaction(G4ReactionProduct* proj, G4ReactionProduct* targ,
 			 G4ReactionProduct* product, G4double exEnergy);
@@ -93,7 +93,7 @@ private:
 
   G4NRESP71M03 nresp71_model;
 
-protected:
+ protected:
 
   G4ParticleHPVector* theXsection[51];
   G4ParticleHPEnergyDistribution* theEnergyDistribution[51];

source/processes/hadronic/models/particle_hp/include/G4ParticleHPInelasticDataPT.hh

@@ -79,6 +79,7 @@ class G4ParticleHPInelasticDataPT : public G4VCrossSectionDataSet {
 
    private:
      std::vector< std::pair< G4double, G4double > >* URRlimits;
+     G4bool doNOTusePTforInelastic{ true };
 };
 
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPIsoData.hh

@@ -43,6 +43,7 @@ class G4ParticleDefinition;
 class G4ParticleHPIsoData
 {
   public:
+
     G4ParticleHPIsoData() = default;
 
     ~G4ParticleHPIsoData() { delete theChannelData; }
@@ -52,12 +53,12 @@ class G4ParticleHPIsoData
       return std::max(0., theChannelData->GetXsec(energy));
     }
 
-    G4bool Init(G4int A, G4int Z, G4double abun, G4String dirName, G4String aFSType)
+    G4bool Init(G4int A, G4int Z, G4double abun, const G4String& dirName, const G4String& aFSType)
     {
       return Init(A, Z, 0, abun, dirName, aFSType);
-    };
+    }
 
-    G4bool Init(G4int A, G4int Z, G4int M, G4double abun, G4String dirName, G4String aFSType);
+    G4bool Init(G4int A, G4int Z, G4int M, G4double abun, const G4String& dirName, const G4String& aFSType);
 
     void Init(G4int A, G4int Z, G4double abun, G4ParticleDefinition* projectile,
               const char* dataDirVariable)
@@ -68,13 +69,13 @@ class G4ParticleHPIsoData
     void Init(G4int A, G4int Z, G4int M, G4double abun, G4ParticleDefinition* projectile,
               const char* dataDirVariable);  // fill PhysicsVector for this Isotope
 
-    G4ParticleHPVector* MakeElasticData() { return theElasticData; }
-    G4ParticleHPVector* MakeFissionData() { return theFissionData; }
-    G4ParticleHPVector* MakeCaptureData() { return theCaptureData; }
-    G4ParticleHPVector* MakeInelasticData() { return theInelasticData; }
-    G4ParticleHPVector* MakeChannelData() { return theChannelData; }
+    G4ParticleHPVector* MakeElasticData() const { return theElasticData; }
+    G4ParticleHPVector* MakeFissionData() const { return theFissionData; }
+    G4ParticleHPVector* MakeCaptureData() const { return theCaptureData; }
+    G4ParticleHPVector* MakeInelasticData() const { return theInelasticData; }
+    G4ParticleHPVector* MakeChannelData() const { return theChannelData; }
 
-    G4String GetName(G4int A, G4int Z, G4String base, G4String rest);
+    G4String GetName(G4int A, G4int Z, const G4String& base, const G4String& rest);
 
     void FillChannelData(G4ParticleHPVector* aBuffer);
 
@@ -90,6 +91,7 @@ class G4ParticleHPIsoData
     G4ParticleHPIsoData(const G4ParticleHPIsoData&) = delete;
 
   private:
+
     G4ParticleHPVector* theFissionData{nullptr};
     G4ParticleHPVector* theCaptureData{nullptr};
     G4ParticleHPVector* theElasticData{nullptr};

source/processes/hadronic/models/particle_hp/include/G4ParticleHPIsoProbabilityTable.hh

@@ -49,6 +49,7 @@
 #define G4ParticleHPIsoProbabilityTable_h 1
 
 #include "globals.hh"
+
 #include <vector>
 #include <thread>
 #include <map>
@@ -57,43 +58,45 @@ class G4ParticleHPVector;
 class G4DynamicParticle;
 class G4Element;
 
+class G4ParticleHPIsoProbabilityTable
+{
+ public:
 
-class G4ParticleHPIsoProbabilityTable {
-public:
-  G4ParticleHPIsoProbabilityTable();
+  G4ParticleHPIsoProbabilityTable() = default;
   virtual ~G4ParticleHPIsoProbabilityTable();
-  virtual void Init( G4int, G4int, G4int, G4double, G4String );
+  virtual void Init( G4int, G4int, G4int, G4double, const G4String& );
   virtual G4double GetCorrelatedIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, 
                                                    G4double&, G4double&, std::thread::id& );
   virtual G4double GetIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, G4double&, 
                                          std::map< std::thread::id, G4double >&, std::thread::id& );
 
-protected:
+ protected:
+
   G4double GetDopplerBroadenedElasticXS( const G4DynamicParticle*, G4int, G4int );
   G4double GetDopplerBroadenedCaptureXS( const G4DynamicParticle*, G4int, G4int );
   G4double GetDopplerBroadenedFissionXS( const G4DynamicParticle*, G4int, G4int );
   G4double GetDopplerBroadenedInelasticXS( const G4DynamicParticle*, G4int, G4int );
 
-  G4int Z;
-  G4int A;
-  G4int m;
-  G4double T;
+  G4int Z = 0;
+  G4int A = 0;
+  G4int m = -1;
+  G4double T = -1.;
 
-  G4double Emin;
-  G4double Emax;
-  G4int nEnergies;
+  G4double Emin = DBL_MAX;
+  G4double Emax = 0.;
+  G4int nEnergies = 0;
 
   std::map< std::thread::id, G4double > energy_cache;
   std::map< std::thread::id, G4double > xsela_cache;
   std::map< std::thread::id, G4double > xscap_cache;
   std::map< std::thread::id, G4double > xsfiss_cache;
 
-  G4ParticleHPVector* theEnergies;
-  std::vector< std::vector< G4double >* >* theProbabilities;
-  std::vector< std::vector< G4double >* >* theElasticData;
-  std::vector< std::vector< G4double >* >* theCaptureData;
-  std::vector< std::vector< G4double >* >* theFissionData;
-  std::vector< std::vector< G4double >* >* theInelasticData;
+  G4ParticleHPVector* theEnergies = nullptr;
+  std::vector< std::vector< G4double >* >* theProbabilities = nullptr;
+  std::vector< std::vector< G4double >* >* theElasticData = nullptr;
+  std::vector< std::vector< G4double >* >* theCaptureData = nullptr;
+  std::vector< std::vector< G4double >* >* theFissionData = nullptr;
+  std::vector< std::vector< G4double >* >* theInelasticData = nullptr;
 
   G4String filename;
 };

source/processes/hadronic/models/particle_hp/include/G4ParticleHPIsoProbabilityTable_CALENDF.hh

@@ -50,6 +50,7 @@
 
 #include "globals.hh"
 #include "G4ParticleHPIsoProbabilityTable.hh"
+
 #include <vector>
 #include <thread>
 #include <map>
@@ -57,17 +58,19 @@
 class G4DynamicParticle;
 class G4Element;
 
+class G4ParticleHPIsoProbabilityTable_CALENDF : public G4ParticleHPIsoProbabilityTable
+{
+ public:
 
-class G4ParticleHPIsoProbabilityTable_CALENDF : public G4ParticleHPIsoProbabilityTable {
-public:
   G4ParticleHPIsoProbabilityTable_CALENDF();
   ~G4ParticleHPIsoProbabilityTable_CALENDF();
-  void Init( G4int, G4int, G4int, G4double, G4String ) override;
+  void Init( G4int, G4int, G4int, G4double, const G4String& ) override;
   G4double GetCorrelatedIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, G4double&, G4double&, 
                                            std::thread::id& ) override;
   G4double GetIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, G4double&, 
                                  std::map< std::thread::id, G4double >&, std::thread::id& ) override;
-private:
+ private:
+
   std::map< std::thread::id, G4double > xsinela_cache;
   std::vector< std::vector< G4double >* >* theInelasticData;
 };

source/processes/hadronic/models/particle_hp/include/G4ParticleHPIsoProbabilityTable_NJOY.hh

@@ -51,6 +51,7 @@
 #include "globals.hh"
 #include "G4ParticleHPInterpolator.hh"
 #include "G4ParticleHPIsoProbabilityTable.hh"
+
 #include <vector>
 #include <thread>
 #include <map>
@@ -58,17 +59,19 @@
 class G4DynamicParticle;
 class G4Element;
 
+class G4ParticleHPIsoProbabilityTable_NJOY : public G4ParticleHPIsoProbabilityTable
+{
+ public:
 
-class G4ParticleHPIsoProbabilityTable_NJOY : public G4ParticleHPIsoProbabilityTable {
-public:
   G4ParticleHPIsoProbabilityTable_NJOY();
   ~G4ParticleHPIsoProbabilityTable_NJOY();
-  void Init( G4int, G4int, G4int, G4double, G4String ) override;
+  void Init( G4int, G4int, G4int, G4double, const G4String& ) override;
   G4double GetCorrelatedIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, G4double&, G4double&, 
                                            std::thread::id& ) override;
   G4double GetIsoCrossSectionPT( const G4DynamicParticle*, G4int, const G4Element*, G4double&, 
                                  std::map< std::thread::id, G4double >&, std::thread::id& ) override;
-private:
+ private:
+
   G4int tableOrder;
   G4int lssf_flag;
   G4ParticleHPInterpolator theInt;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPJENDLHEData.hh

@@ -50,7 +50,7 @@ class G4ParticleHPJENDLHEData : public G4VCrossSectionDataSet
 {
   public:
     G4ParticleHPJENDLHEData();
-    G4ParticleHPJENDLHEData(G4String, G4ParticleDefinition*);
+    G4ParticleHPJENDLHEData(const G4String&, G4ParticleDefinition*);
 
     ~G4ParticleHPJENDLHEData() override;
 

source/processes/hadronic/models/particle_hp/include/G4ParticleHPLCFissionFS.hh

@@ -37,10 +37,12 @@
 class G4ParticleHPLCFissionFS : public G4ParticleHPFissionBaseFS
 {
   public:
+
     G4ParticleHPLCFissionFS() { hasXsec = false; }
     ~G4ParticleHPLCFissionFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition* projectile) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition* projectile) override;
     G4DynamicParticleVector* ApplyYourself(G4int NNeutrons);
     G4ParticleHPFinalState* New() override
     {
@@ -49,6 +51,8 @@ class G4ParticleHPLCFissionFS : public G4ParticleHPFissionBaseFS
     }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPList.hh

@@ -37,6 +37,7 @@
 class G4ParticleHPList
 {
   public:
+
     G4ParticleHPList()
     {
       theData = new G4double[2];
@@ -52,9 +53,9 @@ class G4ParticleHPList
       Check(i);
       theData[i] = y;
     }
-    G4double GetValue(G4int i);
+    G4double GetValue(G4int i) const;
 
-    inline G4int GetListLength() { return nEntries; }
+    inline G4int GetListLength() const { return nEntries; }
 
     void Dump();
 
@@ -64,9 +65,10 @@ class G4ParticleHPList
 
     inline void SetLabel(G4double aLabel) { theLabel = aLabel; }
 
-    inline G4double GetLabel() { return theLabel; }
+    inline G4double GetLabel() const { return theLabel; }
 
   private:
+
     void Check(G4int i);
 
     G4double theLabel;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPManager.hh

@@ -44,12 +44,14 @@ class G4ParticleHPMessenger;
 class G4ParticleHPVector;
 class G4ParticleHPIsoProbabilityTable;
 class G4PhysicsTable;
+
 struct E_isoAng;
 struct E_P_E_isoAng;
 
 class G4ParticleHPManager
 {
   public:
+
     static G4ParticleHPManager* GetInstance();
     ~G4ParticleHPManager();
 
@@ -60,177 +62,175 @@ class G4ParticleHPManager
     void GetDataStream(const G4String&, std::istringstream& iss);
     void GetDataStream2(const G4String&, std::istringstream& iss);
     void SetVerboseLevel(G4int i);
-    G4int GetVerboseLevel() const { return verboseLevel; };
+    G4int GetVerboseLevel() const { return verboseLevel; }
 
-    void DumpDataSource();
+    void DumpDataSource() const;
 
-    G4bool GetUseOnlyPhotoEvaporation() const { return USE_ONLY_PHOTONEVAPORATION; };
-    G4bool GetSkipMissingIsotopes() const { return SKIP_MISSING_ISOTOPES; };
-    G4bool GetNeglectDoppler() const { return NEGLECT_DOPPLER; };
-    G4bool GetDoNotAdjustFinalState() const { return DO_NOT_ADJUST_FINAL_STATE; };
-    G4bool GetProduceFissionFragments() const { return PRODUCE_FISSION_FRAGMENTS; };
-    G4bool GetUseWendtFissionModel() const { return USE_WENDT_FISSION_MODEL; };
-    G4bool GetUseNRESP71Model() const { return USE_NRESP71_MODEL; };
-    G4bool GetUseDBRC() const { return USE_DBRC; };
-    G4bool GetCheckHPNames() const { return CHECK_HP_NAMES; };
-    G4bool GetPHPCheck() const { return PHP_CHECK; };
-    G4bool GetPHCUsePoisson() const { return PHP_USE_POISSON; };
-    G4bool GetDEBUG() const { return DEBUG; };
+    G4bool GetUseOnlyPhotoEvaporation() const { return USE_ONLY_PHOTONEVAPORATION; }
+    G4bool GetSkipMissingIsotopes() const { return SKIP_MISSING_ISOTOPES; }
+    G4bool GetNeglectDoppler() const { return NEGLECT_DOPPLER; }
+    G4bool GetDoNotAdjustFinalState() const { return DO_NOT_ADJUST_FINAL_STATE; }
+    G4bool GetProduceFissionFragments() const { return PRODUCE_FISSION_FRAGMENTS; }
+    G4bool GetUseWendtFissionModel() const { return USE_WENDT_FISSION_MODEL; }
+    G4bool GetUseNRESP71Model() const { return USE_NRESP71_MODEL; }
+    G4bool GetUseDBRC() const { return USE_DBRC; }
+    G4bool GetCheckHPNames() const { return CHECK_HP_NAMES; }
+    G4bool GetPHPCheck() const { return PHP_CHECK; }
+    G4bool GetPHCUsePoisson() const { return PHP_USE_POISSON; }
+    G4bool GetDEBUG() const { return DEBUG; }
 
-    const G4String& GetNeutronHPPath() const { return fDataPath[0]; }; 
+    const G4String& GetNeutronHPPath() const { return fDataPath[0]; };
     const G4String& GetParticleHPPath(const G4ParticleDefinition*) const;
     G4int GetPHPIndex(const G4ParticleDefinition*) const;
 
-    void SetUseOnlyPhotoEvaporation(G4bool val) { USE_ONLY_PHOTONEVAPORATION = val; };
-    void SetSkipMissingIsotopes(G4bool val) { SKIP_MISSING_ISOTOPES = val; };
-    void SetNeglectDoppler(G4bool val) { NEGLECT_DOPPLER = val; };
-    void SetDoNotAdjustFinalState(G4bool val) { DO_NOT_ADJUST_FINAL_STATE = val; };
+    void SetUseOnlyPhotoEvaporation(G4bool val) { USE_ONLY_PHOTONEVAPORATION = val; }
+    void SetSkipMissingIsotopes(G4bool val) { SKIP_MISSING_ISOTOPES = val; }
+    void SetNeglectDoppler(G4bool val) { NEGLECT_DOPPLER = val; }
+    void SetDoNotAdjustFinalState(G4bool val) { DO_NOT_ADJUST_FINAL_STATE = val; }
     void SetProduceFissionFragments(G4bool val)
     {
       // Make sure both fission fragment models are not active at same time
       PRODUCE_FISSION_FRAGMENTS = USE_WENDT_FISSION_MODEL ? false : val;
-    };
+    }
     void SetUseWendtFissionModel(G4bool val)
     {
       USE_WENDT_FISSION_MODEL = val;
       // Make sure both fission fragment models are not active at same time
       if (USE_WENDT_FISSION_MODEL) PRODUCE_FISSION_FRAGMENTS = false;
-    };
-    void SetUseNRESP71Model(G4bool val) { USE_NRESP71_MODEL = val; };
-    void SetUseDBRC(G4bool val) { USE_DBRC = val; };
+    }
+    void SetUseNRESP71Model(G4bool val) { USE_NRESP71_MODEL = val; }
+    void SetUseDBRC(G4bool val) { USE_DBRC = val; }
 
     void DumpSetting();
 
-    void RegisterElasticCrossSections(G4PhysicsTable* val) { theElasticCrossSections = val; };
-    G4PhysicsTable* GetElasticCrossSections() const { return theElasticCrossSections; };
-    void RegisterCaptureCrossSections(G4PhysicsTable* val) { theCaptureCrossSections = val; };
-    G4PhysicsTable* GetCaptureCrossSections() const { return theCaptureCrossSections; };
+    void RegisterElasticCrossSections(G4PhysicsTable* val) { theElasticCrossSections = val; }
+    G4PhysicsTable* GetElasticCrossSections() const { return theElasticCrossSections; }
+    void RegisterCaptureCrossSections(G4PhysicsTable* val) { theCaptureCrossSections = val; }
+    G4PhysicsTable* GetCaptureCrossSections() const { return theCaptureCrossSections; }
     void RegisterInelasticCrossSections(const G4ParticleDefinition* part, G4PhysicsTable* ptr)
     {
       theInelasticCrossSections[GetPHPIndex(part)] = ptr;
-    };
+    }
     G4PhysicsTable* GetInelasticCrossSections(const G4ParticleDefinition* part) const
     {
       return theInelasticCrossSections[GetPHPIndex(part)];
-    };
-    void RegisterFissionCrossSections(G4PhysicsTable* val) { theFissionCrossSections = val; };
-    G4PhysicsTable* GetFissionCrossSections() const { return theFissionCrossSections; };
+    }
+    void RegisterFissionCrossSections(G4PhysicsTable* val) { theFissionCrossSections = val; }
+    G4PhysicsTable* GetFissionCrossSections() const { return theFissionCrossSections; }
 
-    std::vector<G4ParticleHPChannel*>* GetElasticFinalStates() const { return theElasticFSs; };
+    std::vector<G4ParticleHPChannel*>* GetElasticFinalStates() const { return theElasticFSs; }
     void RegisterElasticFinalStates(std::vector<G4ParticleHPChannel*>* val)
     {
       theElasticFSs = val;
-    };
+    }
 
     std::vector<G4ParticleHPChannelList*>*
     GetInelasticFinalStates(const G4ParticleDefinition* part) const
     {
       return theInelasticFSs[GetPHPIndex(part)];
-    };
+    }
     void RegisterInelasticFinalStates(const G4ParticleDefinition* part,
                                       std::vector<G4ParticleHPChannelList*>* ptr)
     {
       theInelasticFSs[GetPHPIndex(part)] = ptr;
-    };
+    }
 
-    std::vector<G4ParticleHPChannel*>* GetCaptureFinalStates() const { return theCaptureFSs; };
+    std::vector<G4ParticleHPChannel*>* GetCaptureFinalStates() const { return theCaptureFSs; }
     void RegisterCaptureFinalStates(std::vector<G4ParticleHPChannel*>* val)
     {
       theCaptureFSs = val;
-    };
-    std::vector<G4ParticleHPChannel*>* GetFissionFinalStates() const { return theFissionFSs; };
+    }
+    std::vector<G4ParticleHPChannel*>* GetFissionFinalStates() const { return theFissionFSs; }
     void RegisterFissionFinalStates(std::vector<G4ParticleHPChannel*>* val)
     {
       theFissionFSs = val;
-    };
+    }
 
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
     GetThermalScatteringCoherentCrossSections() const
     {
       return theTSCoherentCrossSections;
-    };
+    }
     void RegisterThermalScatteringCoherentCrossSections(
       std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
     {
       theTSCoherentCrossSections = val;
-    };
+    }
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
     GetThermalScatteringIncoherentCrossSections() const
     {
       return theTSIncoherentCrossSections;
-    };
+    }
     void RegisterThermalScatteringIncoherentCrossSections(
       std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
     {
       theTSIncoherentCrossSections = val;
-    };
+    }
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>*
     GetThermalScatteringInelasticCrossSections() const
     {
       return theTSInelasticCrossSections;
-    };
+    }
     void RegisterThermalScatteringInelasticCrossSections(
       std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* val)
     {
       theTSInelasticCrossSections = val;
-    };
+    }
 
     std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>*
     GetThermalScatteringCoherentFinalStates() const
     {
       return theTSCoherentFinalStates;
-    };
+    }
     void RegisterThermalScatteringCoherentFinalStates(
       std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>* val)
     {
       theTSCoherentFinalStates = val;
-    };
+    }
     std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>*
     GetThermalScatteringIncoherentFinalStates() const
     {
       return theTSIncoherentFinalStates;
-    };
+    }
     void RegisterThermalScatteringIncoherentFinalStates(
       std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* val)
     {
       theTSIncoherentFinalStates = val;
-    };
+    }
     std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>*
     GetThermalScatteringInelasticFinalStates() const
     {
       return theTSInelasticFinalStates;
-    };
+    }
     void RegisterThermalScatteringInelasticFinalStates(
       std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* val)
     {
       theTSInelasticFinalStates = val;
-    };
+    }
 
-    std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* GetProbabilityTables() 
-      { return theProbabilityTables; };
+    std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* GetProbabilityTables() const
+      { return theProbabilityTables; }
     void RegisterProbabilityTables( std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* val ) 
-      { theProbabilityTables = val; };
+      { theProbabilityTables = val; }
 
-    std::vector< std::pair< G4double, G4double > >* GetURRlimits() { return theURRlimits; };
-    void RegisterURRlimits( std::vector< std::pair< G4double, G4double > >* val ) { theURRlimits = val; };
+    std::vector< std::pair< G4double, G4double > >* GetURRlimits() const { return theURRlimits; }
+    void RegisterURRlimits( std::vector< std::pair< G4double, G4double > >* val ) { theURRlimits = val; }
 
-    G4String GetUsedPTformat() { return USE_PROBABILITY_TABLE_FROM; };
-    void SetUsedPTformat( G4String val ) { USE_PROBABILITY_TABLE_FROM = val; };
+    G4double GetMinADBRC() const { return theMinADBRC; }
+    G4double GetMinEnergyDBRC() const { return theMinEnergyDBRC; }
+    G4double GetMaxEnergyDBRC() const { return theMaxEnergyDBRC; }
+    G4double GetMaxEnergyDoppler() const { return theMaxEnergyDoppler; }
 
-    G4double GetMinADBRC() const { return theMinADBRC; };
-    G4double GetMinEnergyDBRC() const { return theMinEnergyDBRC; };
-    G4double GetMaxEnergyDBRC() const { return theMaxEnergyDBRC; };
-    G4double GetMaxEnergyDoppler() const { return theMaxEnergyDoppler; };
-
-    void SetMinADBRC(G4double val) { theMinADBRC = val; };
-    void SetMinEnergyDBRC(G4double val) { theMinEnergyDBRC = val; };
-    void SetMaxEnergyDBRC(G4double val) { theMaxEnergyDBRC = val; };
-    void SetMaxEnergyDoppler(G4double val) { theMaxEnergyDoppler = val; };
+    void SetMinADBRC(G4double val) { theMinADBRC = val; }
+    void SetMinEnergyDBRC(G4double val) { theMinEnergyDBRC = val; }
+    void SetMaxEnergyDBRC(G4double val) { theMaxEnergyDBRC = val; }
+    void SetMaxEnergyDoppler(G4double val) { theMaxEnergyDoppler = val; }
 
     G4ParticleHPManager(G4ParticleHPManager &) = delete;
     G4ParticleHPManager & operator=(const G4ParticleHPManager &right) = delete;
 
   private:
+
     G4ParticleHPManager();
     void register_data_file(const G4String&, const G4String&);
 
@@ -266,16 +266,13 @@ class G4ParticleHPManager
     std::vector<G4ParticleHPChannel*>* theFissionFSs{nullptr};
 
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSCoherentCrossSections{nullptr};
-    std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSIncoherentCrossSections{
-      nullptr};
+    std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSIncoherentCrossSections{nullptr};
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* theTSInelasticCrossSections{nullptr};
 
     std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>*
       theTSCoherentFinalStates{nullptr};
-    std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* theTSIncoherentFinalStates{
-      nullptr};
-    std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* theTSInelasticFinalStates{
-      nullptr};
+    std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* theTSIncoherentFinalStates{nullptr};
+    std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* theTSInelasticFinalStates{nullptr};
 
     G4double theMinADBRC{200.};
     G4double theMinEnergyDBRC;
@@ -284,9 +281,8 @@ class G4ParticleHPManager
 
     G4String fDataPath[6]{""};
 
-    std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* theProbabilityTables{ nullptr };
-    std::vector< std::pair< G4double, G4double > >* theURRlimits{ nullptr };
+    std::vector< std::map< G4int, G4ParticleHPIsoProbabilityTable* > >* theProbabilityTables{nullptr};
+    std::vector< std::pair< G4double, G4double > >* theURRlimits{nullptr};
 
-    G4String USE_PROBABILITY_TABLE_FROM{ "njoy" };
 };
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPMessenger.hh

@@ -62,7 +62,6 @@ class G4ParticleHPMessenger : public G4UImessenger
     G4UIcmdWithADouble* MinADBRCCmd;
     G4UIcmdWithADoubleAndUnit* MinEnergyDBRCCmd;
     G4UIcmdWithADoubleAndUnit* MaxEnergyDBRCCmd;
-    G4UIcmdWithAString* PTformatCmd;
 };
 
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPN2AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPN2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPN2AInelasticFS();
     ~G4ParticleHPN2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPN2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPN2PInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPN2PInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPN2PInelasticFS();
     ~G4ParticleHPN2PInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPN2PInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPN3AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPN3AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPN3AInelasticFS();
     ~G4ParticleHPN3AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPN3AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNAInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNAInelasticFS();
     ~G4ParticleHPNAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPND2AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPND2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPND2AInelasticFS();
     ~G4ParticleHPND2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPND2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNDInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNDInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNDInelasticFS();
     ~G4ParticleHPNDInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNDInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNHe3InelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNHe3InelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNHe3InelasticFS();
     ~G4ParticleHPNHe3InelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNHe3InelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNInelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPNInelasticFS();
     ~G4ParticleHPNInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNPAInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNPAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNPAInelasticFS();
     ~G4ParticleHPNPAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNPAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNPInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNPInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNPInelasticFS();
     ~G4ParticleHPNPInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNPInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNT2AInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNT2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNT2AInelasticFS();
     ~G4ParticleHPNT2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNT2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNTInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNTInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNTInelasticFS();
     ~G4ParticleHPNTInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNTInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNXInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPNXInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPNXInelasticFS();
     ~G4ParticleHPNXInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPNXInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPNames.hh

@@ -38,19 +38,20 @@ class G4ParticleHPManager;
 class G4ParticleHPNames
 {
   public:
+
     explicit G4ParticleHPNames(G4int maxOffSet = 5);
     ~G4ParticleHPNames() = default;
 
     G4ParticleHPDataUsed GetName(G4int A, G4int Z, const G4String& base,
-                                 const G4String& rest, G4bool& active)
+                                 const G4String& rest, G4bool& active) const
     {
       return GetName(A, Z, 0, base, rest, active);
     }
     G4ParticleHPDataUsed GetName(G4int A, G4int Z, G4int M,
-                                 const G4String& base, const G4String& rest, G4bool& active);
-    G4String GetName(G4int i);
+                                 const G4String& base, const G4String& rest, G4bool& active) const;
+    G4String GetName(G4int i) const;
 
-    G4String itoa(G4int current);
+    G4String itoa(G4int current) const;
 
     void SetMaxOffSet(G4int anOffset) { theMaxOffSet = anOffset; }
 
@@ -58,6 +59,7 @@ class G4ParticleHPNames
     G4ParticleHPNames& operator=(const G4ParticleHPNames &right) = delete;
 
   private:
+
     G4ParticleHPManager* fManager;
     static const G4String theString[100];
     G4int theMaxOffSet;

source/processes/hadronic/models/particle_hp/include/G4ParticleHPPAInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPPAInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPPAInelasticFS();
     ~G4ParticleHPPAInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPPAInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPPDInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPPDInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPPDInelasticFS();
     ~G4ParticleHPPDInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPPDInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPPInelasticFS.hh

@@ -41,17 +41,17 @@
 class G4ParticleHPPInelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPPInelasticFS();
     ~G4ParticleHPPInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPPInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPPTInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPPTInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPPTInelasticFS();
     ~G4ParticleHPPTInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPPTInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPParticleYield.hh

@@ -39,6 +39,7 @@
 class G4ParticleHPParticleYield
 {
   public:
+
     G4ParticleHPParticleYield()
     {
       simpleMean = true;
@@ -51,11 +52,12 @@ class G4ParticleHPParticleYield
       spontDelayed = true;
       theSpontDelayed = 0.0;
     }
+
     ~G4ParticleHPParticleYield() = default;
 
-    G4double GetTargetMass() { return targetMass; }
+    inline G4double GetTargetMass() const { return targetMass; }
 
-    void InitMean(std::istream& aDataFile)
+    inline void InitMean(std::istream& aDataFile)
     {
       G4int iflag;
       aDataFile >> targetMass >> iflag;
@@ -68,7 +70,7 @@ class G4ParticleHPParticleYield
       }
     }
 
-    void InitPrompt(std::istream& aDataFile)
+    inline void InitPrompt(std::istream& aDataFile)
     {
       hasPromptData = true;
       G4int iflag;
@@ -82,7 +84,7 @@ class G4ParticleHPParticleYield
       }
     }
 
-    void InitDelayed(std::istream& aDataFile)
+    inline void InitDelayed(std::istream& aDataFile)
     {
       hasDelayedData = true;
       G4int iflag;
@@ -97,7 +99,7 @@ class G4ParticleHPParticleYield
       }
     }
 
-    G4double GetMean(G4double anEnergy)
+    inline G4double GetMean(G4double anEnergy) const
     {
       if (simpleMean) {
         return theSimpleMean.GetY(anEnergy);
@@ -105,7 +107,7 @@ class G4ParticleHPParticleYield
       return theMean.GetValue(anEnergy);
     }
 
-    G4double GetPrompt(G4double anEnergy)
+    inline G4double GetPrompt(G4double anEnergy) const
     {
       if (!hasPromptData) return 0;
       if (spontPrompt) {
@@ -114,7 +116,7 @@ class G4ParticleHPParticleYield
       return thePrompt.GetY(anEnergy);
     }
 
-    G4double GetDelayed(G4double anEnergy)
+    inline G4double GetDelayed(G4double anEnergy) const
     {
       if (!hasDelayedData) return 0;
       if (spontDelayed) {
@@ -123,9 +125,13 @@ class G4ParticleHPParticleYield
       return theDelayed.GetY(anEnergy);
     }
 
-    inline G4double GetDecayConstant(G4int i) { return thePrecursorDecayConstants.GetValue(i); }
+    inline G4double GetDecayConstant(G4int i) const
+    {
+      return thePrecursorDecayConstants.GetValue(i);
+    }
 
   private:
+
     G4double targetMass;
     // total mean
     G4bool simpleMean;
@@ -145,4 +151,5 @@ class G4ParticleHPParticleYield
     G4ParticleHPVector theDelayed;
     G4double theSpontDelayed;
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPPolynomExpansion.hh

@@ -39,6 +39,7 @@
 class G4ParticleHPPolynomExpansion
 {
   public:
+
     G4ParticleHPPolynomExpansion()
     {
       theCoeff = nullptr;
@@ -56,7 +57,7 @@ class G4ParticleHPPolynomExpansion
       }
     }
 
-    inline G4double GetValue(G4double anEnergy)
+    inline G4double GetValue(G4double anEnergy) const
     {
       G4int i;
       G4double result = 0;
@@ -70,6 +71,7 @@ class G4ParticleHPPolynomExpansion
     }
 
   private:
+
     G4int nPoly;
     G4double* theCoeff;
 };

source/processes/hadronic/models/particle_hp/include/G4ParticleHPReactionWhiteBoard.hh

@@ -42,26 +42,27 @@
 class G4ParticleHPReactionWhiteBoard
 {
   public:
+
     G4ParticleHPReactionWhiteBoard();
     ~G4ParticleHPReactionWhiteBoard();
 
-  public:
-    void Dump();
+    void Dump() const;
 
     void SetTargZ(G4int Z) { targZ = Z; };
     void SetTargA(G4int A) { targA = A; };
     void SetTargM(G4int M) { targM = M; };
-    G4int GetTargZ() { return targZ; };
-    G4int GetTargA() { return targA; };
-    G4int GetTargM() { return targM; };
+    G4int GetTargZ() const { return targZ; };
+    G4int GetTargA() const { return targA; };
+    G4int GetTargM() const { return targM; };
 
-    bool AddRecord(std::pair<G4String, G4String>);
-    G4String GetValue(G4String);
+    G4bool AddRecord(std::pair<G4String, G4String>);
+    G4String GetValue(const G4String&) const;
     // "0" or "0.0" will retrun for invalid key by following two methods
-    G4int GetValueInInt(G4String);
-    G4double GetValueInDouble(G4String);
+    G4int GetValueInInt(const G4String&) const;
+    G4double GetValueInDouble(const G4String&) const;
 
   private:
+
     G4int targZ{0};
     G4int targA{0};
     G4int targM{0};

source/processes/hadronic/models/particle_hp/include/G4ParticleHPSCFissionFS.hh

@@ -37,10 +37,12 @@
 class G4ParticleHPSCFissionFS : public G4ParticleHPFissionBaseFS
 {
   public:
+
     G4ParticleHPSCFissionFS() { hasXsec = false; }
     ~G4ParticleHPSCFissionFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition* projectile) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition* projectile) override;
     G4DynamicParticleVector* ApplyYourself(G4int NNeutrons);
     G4ParticleHPFinalState* New() override
     {
@@ -49,6 +51,8 @@ class G4ParticleHPSCFissionFS : public G4ParticleHPFissionBaseFS
     }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPT2AInelasticFS.hh

@@ -37,17 +37,18 @@
 class G4ParticleHPT2AInelasticFS : public G4ParticleHPInelasticBaseFS
 {
   public:
+
     G4ParticleHPT2AInelasticFS();
     ~G4ParticleHPT2AInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPT2AInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPTCFissionFS.hh

@@ -37,10 +37,12 @@
 class G4ParticleHPTCFissionFS : public G4ParticleHPFissionBaseFS
 {
   public:
+
     G4ParticleHPTCFissionFS() { hasXsec = false; }
     ~G4ParticleHPTCFissionFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition* projectile) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition* projectile) override;
     G4DynamicParticleVector* ApplyYourself(G4int NNeutrons);
     G4ParticleHPFinalState* New() override
     {
@@ -49,6 +51,8 @@ class G4ParticleHPTCFissionFS : public G4ParticleHPFissionBaseFS
     }
 
   private:
+
     G4HadFinalState* ApplyYourself(const G4HadProjectile&) override { return nullptr; }
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPTInelasticFS.hh

@@ -41,17 +41,18 @@
 class G4ParticleHPTInelasticFS : public G4ParticleHPInelasticCompFS
 {
   public:
+
     G4ParticleHPTInelasticFS();
     ~G4ParticleHPTInelasticFS() override = default;
-    void Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String& aFSType,
-              G4ParticleDefinition*) override;
+
+    void Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+              const G4String& aFSType, G4ParticleDefinition*) override;
     G4HadFinalState* ApplyYourself(const G4HadProjectile& theTrack) override;
     G4ParticleHPFinalState* New() override
     {
       auto theNew = new G4ParticleHPTInelasticFS;
       return theNew;
     }
-
-  private:
 };
+
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPThermalScattering.hh

@@ -23,16 +23,10 @@
 // * acceptance of all terms of the Geant4 Software license.          *
 // ********************************************************************
 //
+// G4ParticleHPThermalScattering
 //
-// P. Arce, June-2014 Conversion neutron_hp to particle_hp
+// Class Description:
 //
-#ifndef G4ParticleHPThermalScattering_h
-#define G4ParticleHPThermalScattering_h 1
-
-// Thermal Neutron Scattering
-// Koi, Tatsumi (SLAC/SCCS)
-//
-// Class Description
 // Final State Generators for a high precision (based on evaluated data
 // libraries) description of themal neutron scattering below 4 eV;
 // Based on Thermal neutron scattering files
@@ -40,7 +34,12 @@
 // To be used in your physics list in case you need this physics.
 // In this case you want to register an object of this class with
 // the corresponding process.
-// Class Description - End
+//
+// Author: T. Koi (SLAC/SCCS), November-2006 - First implementation.
+//         P. Arce (CIEMAT), June-2014 - Conversion neutron_hp to particle_hp
+// --------------------------------------------------------------------
+#ifndef G4ParticleHPThermalScattering_h
+#define G4ParticleHPThermalScattering_h 1
 
 #include "G4HadronicInteraction.hh"
 #include "G4ParticleHPThermalScatteringNames.hh"
@@ -84,6 +83,7 @@ struct E_P_E_isoAng
 class G4ParticleHPThermalScattering : public G4HadronicInteraction
 {
   public:
+
     G4ParticleHPThermalScattering();
 
     ~G4ParticleHPThermalScattering() override;
@@ -95,39 +95,16 @@ class G4ParticleHPThermalScattering : public G4HadronicInteraction
 
     // For user prepared thermal files
     // Name of G4Element , Name of NDL file
-    void AddUserThermalScatteringFile(G4String, G4String);
+    void AddUserThermalScatteringFile(const G4String&, const G4String&);
 
     void BuildPhysicsTable(const G4ParticleDefinition&) override;
 
     void ModelDescription(std::ostream& outFile) const override;
 
   private:
+
     void clearCurrentFSData();
 
-    G4ParticleHPThermalScatteringNames names;
-
-    // Coherent Elastic
-    //         ElementID             temp                             BraggE     cumulativeP
-    std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>* coherentFSs{
-      nullptr};
-    std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>* readACoherentFSDATA(G4String);
-
-    // Incoherent Elastic
-    //         ElementID          temp       aFS for this temp (and this element)
-    std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* incoherentFSs{nullptr};
-    std::map<G4double, std::vector<E_isoAng*>*>* readAnIncoherentFSDATA(G4String);
-    E_isoAng* readAnE_isoAng(std::istream*);
-
-    // Inelastic
-    //         ElementID          temp        aFS for this temp (and this element)
-    std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* inelasticFSs{nullptr};
-    std::map<G4double, std::vector<E_P_E_isoAng*>*>* readAnInelasticFSDATA(G4String);
-    E_P_E_isoAng* readAnE_P_E_isoAng(std::istream*);
-
-    G4ParticleHPThermalScatteringData* theXSection;
-
-    G4ParticleHPElastic* theHPElastic;
-
     G4double getMu(E_isoAng*);
     G4double getMu(G4double rndm1, G4double rndm2, E_isoAng* anEPM);
 
@@ -147,17 +124,41 @@ class G4ParticleHPThermalScattering : public G4HadronicInteraction
     std::pair<G4double, E_isoAng>
     create_sE_and_EPM_from_pE_and_vE_P_E_isoAng(G4double, G4double, std::vector<E_P_E_isoAng*>*);
 
-    std::map<std::pair<const G4Material*, const G4Element*>, G4int> dic;
     void buildPhysicsTable();
     G4int getTS_ID(const G4Material*, const G4Element*);
 
-    // size_t sizeOfMaterialTable;
-
     G4bool check_E_isoAng(E_isoAng*);
 
+  private:
+
+    G4ParticleHPThermalScatteringNames names;
+
+    // Coherent Elastic
+    //         ElementID             temp                             BraggE     cumulativeP
+    std::map<G4int, std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>*>* coherentFSs{nullptr};
+    std::map<G4double, std::vector<std::pair<G4double, G4double>*>*>* readACoherentFSDATA(const G4String&);
+
+    // Incoherent Elastic
+    //         ElementID          temp       aFS for this temp (and this element)
+    std::map<G4int, std::map<G4double, std::vector<E_isoAng*>*>*>* incoherentFSs{nullptr};
+    std::map<G4double, std::vector<E_isoAng*>*>* readAnIncoherentFSDATA(const G4String&);
+    E_isoAng* readAnE_isoAng(std::istream*);
+
+    // Inelastic
+    //         ElementID          temp        aFS for this temp (and this element)
+    std::map<G4int, std::map<G4double, std::vector<E_P_E_isoAng*>*>*>* inelasticFSs{nullptr};
+    std::map<G4double, std::vector<E_P_E_isoAng*>*>* readAnInelasticFSDATA(const G4String&);
+    E_P_E_isoAng* readAnE_P_E_isoAng(std::istream*);
+
+    G4ParticleHPThermalScatteringData* theXSection;
+
+    G4ParticleHPElastic* theHPElastic;
+
+    std::map<std::pair<const G4Material*, const G4Element*>, G4int> dic;
+
     // In order to judge whether the rebuilding of physics table is a necessity or not
-    size_t nMaterial;
-    size_t nElement;
+    std::size_t nMaterial;
+    std::size_t nElement;
 };
 
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPThermalScatteringData.hh

@@ -24,15 +24,10 @@
 // ********************************************************************
 //
 //
-// P. Arce, June-2014 Conversion neutron_hp to particle_hp
+// G4ParticleHPThermalScatteringData
 //
-#ifndef G4ParticleHPThermalScatteringData_h
-#define G4ParticleHPThermalScatteringData_h 1
-
-// Thermal Neutron Scattering
-// Koi, Tatsumi (SCCS/SLAC)
+// Class Description:
 //
-// Class Description
 // Cross Sections for a high precision (based on evaluated data
 // libraries) description of themal neutron scattering below 4 eV;
 // Based on Thermal neutron scattering files
@@ -40,11 +35,12 @@
 // To be used in your physics list in case you need this physics.
 // In this case you want to register an object of this class with
 // the corresponding process.
-// Class Description - End
-
-// 15-Nov-06 First implementation is done by T. Koi (SLAC/SCCS)
-// 070625 create clearCurrentXSData to fix memory leaking by T. Koi
-// 080417 Add IsZAApplicable method (return false) by T. Koi
+//
+// Author: T. Koi (SLAC/SCCS), November-2006 - First implementation.
+//         P. Arce (CIEMAT), June-2014 - Conversion neutron_hp to particle_hp
+// ---------------------------------------------------------------------
+#ifndef G4ParticleHPThermalScatteringData_h
+#define G4ParticleHPThermalScatteringData_h 1
 
 #include "G4DynamicParticle.hh"
 #include "G4Element.hh"
@@ -53,7 +49,6 @@
 #include "G4ParticleHPThermalScatteringNames.hh"
 #include "G4ParticleHPVector.hh"
 #include "G4VCrossSectionDataSet.hh"
-// #include "G4PhysicsTable.hh"
 
 #include <map>
 #include <vector>
@@ -61,6 +56,7 @@
 class G4ParticleHPThermalScatteringData : public G4VCrossSectionDataSet
 {
   public:
+
     G4ParticleHPThermalScatteringData();
 
     ~G4ParticleHPThermalScatteringData() override;
@@ -90,28 +86,31 @@ class G4ParticleHPThermalScatteringData : public G4VCrossSectionDataSet
 
     // For user prepared thermal files
     // Name of G4Element , Name of NDL file
-    void AddUserThermalScatteringFile(G4String, G4String);
+    void AddUserThermalScatteringFile(const G4String&, const G4String&);
 
     void CrossSectionDescription(std::ostream&) const override;
 
   private:
+
     G4double GetX(const G4DynamicParticle*, G4double aT, std::map<G4double, G4ParticleHPVector*>*);
 
-    G4double emax;
-
     void clearCurrentXSData();
 
+    std::map<G4double, G4ParticleHPVector*>* readData(const G4String&);
+
+    G4int getTS_ID(const G4Material*, const G4Element*);
+
+  private:
+
+    G4double emax;
+
     //              element            temp       x section from E
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* coherent{nullptr};
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* incoherent{nullptr};
     std::map<G4int, std::map<G4double, G4ParticleHPVector*>*>* inelastic{nullptr};
 
-    std::map<G4double, G4ParticleHPVector*>* readData(G4String);
-
     std::vector<G4int> indexOfThermalElement;
     G4ParticleHPThermalScatteringNames* names;
-    //              G4Element  NDL name
-    //      std::map< G4String , G4String > names;
 
     G4double ke_cache;
     G4double xs_cache;
@@ -119,7 +118,6 @@ class G4ParticleHPThermalScatteringData : public G4VCrossSectionDataSet
     const G4Material* material_cache;
 
     std::map<std::pair<const G4Material*, const G4Element*>, G4int> dic;
-    G4int getTS_ID(const G4Material*, const G4Element*);
 };
 
 #endif

source/processes/hadronic/models/particle_hp/include/G4ParticleHPThermalScatteringNames.hh

@@ -48,25 +48,30 @@
 class G4ParticleHPThermalScatteringNames
 {
   public:
+
     G4ParticleHPThermalScatteringNames();
 
-    ~G4ParticleHPThermalScatteringNames();
+    ~G4ParticleHPThermalScatteringNames() = default;
 
-    G4bool IsThisThermalElement(G4String);
-    G4bool IsThisThermalElement(G4String, G4String);
-    size_t GetSize() { return names.size(); };
-    G4String GetTS_NDL_Name(G4String nameG4Element) { return names.find(nameG4Element)->second; };
-    G4String GetTS_NDL_Name(G4String material, G4String element)
+    G4bool IsThisThermalElement(const G4String&) const;
+    G4bool IsThisThermalElement(const G4String&, const G4String&) const;
+    inline std::size_t GetSize() const { return names.size(); }
+    inline const G4String& GetTS_NDL_Name(const G4String& nameG4Element) const
+    {
+      return names.find(nameG4Element)->second;
+    }
+    inline const G4String& GetTS_NDL_Name(const G4String& material,
+                                          const G4String& element) const
     {
       return nist_names.find(std::pair<G4String, G4String>(material, element))->second;
-    };
-    // G4String GetTS_G4E_Name( G4int i ) { return  names[i]->first; };
+    }
 
     // For user prepared thermal files
     // Name of G4Element , Name of NDL file
-    void AddThermalElement(G4String, G4String);
+    void AddThermalElement(const G4String&, const G4String&);
 
   private:
+
     //              G4Element  NDL name
     std::map<G4String, G4String> names;
 

source/processes/hadronic/models/particle_hp/src/G4CrossSectionHP.cc

@@ -140,23 +140,26 @@ G4double G4CrossSectionHP::IsoCrossSection(const G4double ekin,
 					   const G4int Z, const G4int A,
                                            const G4double T)
 {
-  //G4cout << "G4CrossSectionHP::IsoCrossSection Z=" << Z << " A=" << A
+  // G4cout << "G4CrossSectionHP::IsoCrossSection Z=" << Z << " A=" << A
   // << " E(MeV)=" << ekin/MeV << " T=" << T << "  " << GetName() << G4endl;
   G4double xs = 0.0;
   if (ekin > emax || Z > maxZ || Z < minZ || ekin < elimit) { return xs; }
 
-  const G4PhysicsVector* pv0 = fData->GetElementData(Z - minZ);
+  auto pv0 = fData->GetElementData(Z - minZ);
   if (nullptr == pv0) {
-    InitialiseOnFly(Z);
+    Initialise(Z);
     pv0 = fData->GetElementData(Z - minZ);
   }
+
+  // if there is no element data then no iso data
   if (nullptr == pv0) { return xs; }
-  const G4PhysicsVector* pv = fData->GetComponentDataByID(Z - minZ, A);
+
+  const auto pv = fData->GetComponentDataByID(Z - minZ, A);
   if (nullptr == pv) { return xs; }
 
   // no Doppler broading
-  G4double factT = T/CLHEP::STP_Temperature;
-  if (ekin >= emaxT*factT || fManagerHP->GetNeglectDoppler()) {
+  // G4double factT = T/CLHEP::STP_Temperature;
+  if (ekin >= emaxT*T/CLHEP::STP_Temperature || fManagerHP->GetNeglectDoppler()) {
     xs = pv->LogFreeVectorValue(ekin, logek);
 
   } else {
@@ -165,6 +168,7 @@ G4double G4CrossSectionHP::IsoCrossSection(const G4double ekin,
     G4double e0 = CLHEP::k_Boltzmann*T;
     G4double mass = fParticle->GetPDGMass();
     G4double massTarget = G4NucleiProperties::GetNuclearMass(A, Z);
+    G4double sig = std::sqrt(2.0*e0/(3.0*massTarget));
 
     // projectile
     G4LorentzVector lv(0., 0., std::sqrt(ekin*(ekin + 2*mass)), mass + ekin);
@@ -177,11 +181,12 @@ G4double G4CrossSectionHP::IsoCrossSection(const G4double ekin,
     G4double xs2 = 0.0;
 
     for (G4int i=0; i<nn; ++i) {
-      G4double erand = G4RandGamma::shoot(2.0, e0);
-      auto mom = G4RandomDirection()*std::sqrt(2*massTarget*erand);
-      fLV.set(mom.x(), mom.y(), mom.z(), massTarget + erand);
+      G4double vx = G4RandGauss::shoot(0., sig);
+      G4double vy = G4RandGauss::shoot(0., sig);
+      G4double vz = G4RandGauss::shoot(0., sig);
+      fLV.set(massTarget*vx, massTarget*vy, massTarget*vz, massTarget*(1.0 + 0.5*(vx*vx + vy*vy + vz*vz)));
       fBoost = fLV.boostVector();
-      fLV = lv.boost(fBoost);
+      fLV = lv.boost(-fBoost);
       if (fLV.pz() <= 0.0) { continue; }
       ++ii;
       G4double e = fLV.e() - mass;
@@ -223,7 +228,7 @@ const G4Isotope* G4CrossSectionHP::SelectIsotope(const G4Element* elm,
   // more than 1 isotope
   G4int Z = elm->GetZasInt();
   if (Z >= minZ && Z <= maxZ && nullptr == fData->GetElementData(Z - minZ)) {
-    InitialiseOnFly(Z);
+    Initialise(Z);
   }
   
   const G4double* abundVector = elm->GetRelativeAbundanceVector();
@@ -264,7 +269,7 @@ const G4Isotope* G4CrossSectionHP::SelectIsotope(const G4Element* elm,
 
 void G4CrossSectionHP::BuildPhysicsTable(const G4ParticleDefinition& p)
 {
-  if (verboseLevel > 1){
+  if (verboseLevel > 1) {
     G4cout << "G4CrossSectionHP::BuildPhysicsTable for "
 	   << p.GetParticleName() << " and " << fDataName << G4endl;
   }
@@ -275,9 +280,8 @@ void G4CrossSectionHP::BuildPhysicsTable(const G4ParticleDefinition& p)
   // Access to elements
   for ( auto const & elm : *table ) {
     G4int Z = elm->GetZasInt();
-    if (Z >= minZ && Z <= maxZ &&
-        nullptr == fData->GetElementData(Z - minZ)) { 
-      InitialiseOnFly(Z);
+    if (Z >= minZ && Z <= maxZ && nullptr == fData->GetElementData(Z - minZ)) { 
+      Initialise(Z);
     }
   }
 
@@ -349,13 +353,6 @@ void G4CrossSectionHP::PrepareCache(const G4Material* mat)
   fIsoXS.resize(fZA.size(), 0.0);
 }
 
-void G4CrossSectionHP::InitialiseOnFly(const G4int Z)
-{
-  G4AutoLock l(&theHPXS);
-  Initialise(Z);
-  l.unlock();
-}
-
 void G4CrossSectionHP::Initialise(const G4int Z)
 {
   if (fManagerHP->GetVerboseLevel() > 1) {
@@ -366,6 +363,11 @@ void G4CrossSectionHP::Initialise(const G4int Z)
   if (Z < minZ || Z > maxZ || nullptr != fData->GetElementData(Z - minZ)) { 
     return;
   }
+  G4AutoLock l(&theHPXS);
+  if (nullptr != fData->GetElementData(Z - minZ)) { 
+    l.unlock();
+    return;
+  }
 
   // add empty vector to avoid double initialisation
   fData->InitialiseForElement(Z - minZ, new G4PhysicsVector());
@@ -432,5 +434,6 @@ void G4CrossSectionHP::Initialise(const G4int Z)
     }
   }   
   if (noComp) { fData->InitialiseForComponent(Z - minZ, 0); }
+  l.unlock();
 }
 

source/processes/hadronic/models/particle_hp/src/G4ENDFTapeRead.cc

@@ -44,7 +44,7 @@
 #include <map>
 #include <vector>
 
-G4ENDFTapeRead::G4ENDFTapeRead(G4String FileLocation, G4String FileName,
+G4ENDFTapeRead::G4ENDFTapeRead(const G4String& FileLocation, const G4String& FileName,
                                G4FFGEnumerations::YieldType WhichYield,
                                G4FFGEnumerations::FissionCause /*WhichCause*/)
   : /* Cause_(WhichCause),*/
@@ -55,7 +55,7 @@ G4ENDFTapeRead::G4ENDFTapeRead(G4String FileLocation, G4String FileName,
   Initialize(FileLocation + FileName);
 }
 
-G4ENDFTapeRead::G4ENDFTapeRead(G4String FileLocation, G4String FileName,
+G4ENDFTapeRead::G4ENDFTapeRead(const G4String& FileLocation, const G4String& FileName,
                                G4FFGEnumerations::YieldType WhichYield,
                                G4FFGEnumerations::FissionCause /*WhichCause*/, G4int Verbosity)
   : /*Cause_(WhichCause),*/
@@ -77,7 +77,7 @@ G4ENDFTapeRead::G4ENDFTapeRead(std::istringstream& dataStream,
   Initialize(dataStream);
 }
 
-void G4ENDFTapeRead::Initialize(G4String dataFile)
+void G4ENDFTapeRead::Initialize(const G4String& dataFile)
 {
   std::istringstream dataStream(std::ios::in);
   G4ParticleHPManager::GetInstance()->GetDataStream(dataFile, dataStream);
@@ -107,7 +107,7 @@ void G4ENDFTapeRead::Initialize(std::istringstream& dataStream)
   G4FFG_FUNCTIONLEAVE__
 }
 
-G4double* G4ENDFTapeRead::G4GetEnergyGroupValues()
+G4double* G4ENDFTapeRead::G4GetEnergyGroupValues() const
 {
   G4FFG_FUNCTIONENTER__
 
@@ -115,7 +115,7 @@ G4double* G4ENDFTapeRead::G4GetEnergyGroupValues()
   return EnergyGroupValues_;
 }
 
-G4int G4ENDFTapeRead::G4GetNumberOfEnergyGroups()
+G4int G4ENDFTapeRead::G4GetNumberOfEnergyGroups() const
 {
   G4FFG_FUNCTIONENTER__
 
@@ -123,7 +123,7 @@ G4int G4ENDFTapeRead::G4GetNumberOfEnergyGroups()
   return EnergyGroups_;
 }
 
-G4int G4ENDFTapeRead::G4GetNumberOfFissionProducts()
+G4int G4ENDFTapeRead::G4GetNumberOfFissionProducts() const
 {
   G4FFG_FUNCTIONENTER__
 
@@ -133,7 +133,7 @@ G4int G4ENDFTapeRead::G4GetNumberOfFissionProducts()
   return NumberOfElements;
 }
 
-G4ENDFYieldDataContainer* G4ENDFTapeRead::G4GetYield(G4int WhichYield)
+G4ENDFYieldDataContainer* G4ENDFTapeRead::G4GetYield(G4int WhichYield) const
 {
   G4FFG_DATA_FUNCTIONENTER__
 

source/processes/hadronic/models/particle_hp/src/G4NeutronHPCaptureFS.cc

@@ -282,7 +282,7 @@ G4NeutronHPCaptureFS::ApplyYourself(const G4HadProjectile& theTrack)
 }
 
 void G4NeutronHPCaptureFS::Init(G4double AA, G4double ZZ, G4int M,
-                                G4String& dirName, G4String&,
+                                const G4String& dirName, const G4String&,
                                 G4ParticleDefinition*)
 {
   G4int Z = G4lrint(ZZ);
@@ -321,12 +321,12 @@ void G4NeutronHPCaptureFS::Init(G4double AA, G4double ZZ, G4int M,
   }
   // TK110430 END
 
-  G4String tString = "/FS";
+  const G4String& tString = "/FS";
   G4bool dbool;
-  G4ParticleHPDataUsed aFile =
+  const G4ParticleHPDataUsed& aFile =
     theNames.GetName(A, Z, M, dirName, tString, dbool);
 
-  G4String filename = aFile.GetName();
+  const G4String& filename = aFile.GetName();
   SetAZMs(A, Z, M, aFile);
   if (!dbool || (Z <= 2 && (theBaseZ != Z || theBaseA != A))) {
     hasAnyData = false;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2AInelasticFS.cc

@@ -55,8 +55,8 @@ G4HadFinalState* G4ParticleHP2AInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP2AInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2AInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2N2AInelasticFS.cc

@@ -58,8 +58,8 @@ G4HadFinalState* G4ParticleHP2N2AInelasticFS::ApplyYourself(const G4HadProjectil
   return theResult.Get();
 }
 
-void G4ParticleHP2N2AInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                       G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2N2AInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                       const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2NAInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHP2NAInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHP2NAInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2NAInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2NDInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHP2NDInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHP2NDInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2NDInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2NInelasticFS.cc

@@ -55,8 +55,8 @@ G4HadFinalState* G4ParticleHP2NInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP2NInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2NInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2NPInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHP2NPInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHP2NPInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2NPInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP2PInelasticFS.cc

@@ -55,8 +55,8 @@ G4HadFinalState* G4ParticleHP2PInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP2PInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP2PInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP3AInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHP3AInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP3AInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP3AInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP3NAInelasticFS.cc

@@ -57,8 +57,8 @@ G4HadFinalState* G4ParticleHP3NAInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHP3NAInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP3NAInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP3NInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHP3NInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP3NInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP3NInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP3NPInelasticFS.cc

@@ -57,8 +57,8 @@ G4HadFinalState* G4ParticleHP3NPInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHP3NPInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP3NPInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHP4NInelasticFS.cc

@@ -57,8 +57,8 @@ G4HadFinalState* G4ParticleHP4NInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHP4NInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHP4NInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPAInelasticFS.cc

@@ -40,8 +40,8 @@ G4ParticleHPAInelasticFS::G4ParticleHPAInelasticFS()
   secID = G4PhysicsModelCatalog::GetModelID("model_G4ParticleHPAInelasticFS_F27");
 }
 
-void G4ParticleHPAInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                    G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHPAInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                    const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticCompFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPChannel.cc

@@ -76,19 +76,19 @@ G4ParticleHPChannel::~G4ParticleHPChannel()
   delete[] active;
 }
 
-G4double G4ParticleHPChannel::GetXsec(G4double energy)
+G4double G4ParticleHPChannel::GetXsec(G4double energy) const
 {
   return std::max(0., theChannelData->GetXsec(energy));
 }
 
 G4double G4ParticleHPChannel::GetWeightedXsec(G4double energy,
-					      G4int isoNumber)
+					      G4int isoNumber) const
 {
   return theIsotopeWiseData[isoNumber].GetXsec(energy);
 }
 
 G4double G4ParticleHPChannel::GetFSCrossSection(G4double energy,
-						G4int isoNumber)
+						G4int isoNumber) const
 {
   return theFinalStates[isoNumber]->GetXsec(energy);
 }
@@ -168,7 +168,7 @@ void G4ParticleHPChannel::UpdateData(G4int A, G4int Z, G4int M, G4int index,
   }
   else  // get data from CrossSection directory
   {
-    G4String tString = "/CrossSection";
+    const G4String& tString = "/CrossSection";
     active[index] = theIsotopeWiseData[index].Init(A, Z, M, abundance,
                                                    theDir, tString);
     if (active[index]) theBuffer = theIsotopeWiseData[index].MakeChannelData();
@@ -223,7 +223,7 @@ void G4ParticleHPChannel::Harmonise(G4ParticleHPVector*& theStore,
   theStore = theMerge;
 }
 
-G4WendtFissionFragmentGenerator* G4ParticleHPChannel::GetWendtFissionGenerator() {
+G4WendtFissionFragmentGenerator* G4ParticleHPChannel::GetWendtFissionGenerator() const {
   if ( wendtFissionGenerator ) return wendtFissionGenerator;
   else                         return nullptr;
 }
@@ -322,7 +322,7 @@ G4ParticleHPChannel::ApplyYourself(const G4HadProjectile& theTrack,
   return theFinalState;
 }
 
-void G4ParticleHPChannel::DumpInfo()
+void G4ParticleHPChannel::DumpInfo() const
 {
   G4cout << " Element: " << theElement->GetName() << G4endl;
   G4cout << " Directory name: " << theDir << G4endl;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPD2AInelasticFS.cc

@@ -57,8 +57,8 @@ G4HadFinalState* G4ParticleHPD2AInelasticFS::ApplyYourself(const G4HadProjectile
   return theResult.Get();
 }
 
-void G4ParticleHPD2AInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                      G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHPD2AInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                      const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPDAInelasticFS.cc

@@ -56,8 +56,8 @@ G4HadFinalState* G4ParticleHPDAInelasticFS::ApplyYourself(const G4HadProjectile&
   return theResult.Get();
 }
 
-void G4ParticleHPDAInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHPDAInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticBaseFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPDInelasticFS.cc

@@ -40,8 +40,8 @@ G4ParticleHPDInelasticFS::G4ParticleHPDInelasticFS()
   secID = G4PhysicsModelCatalog::GetModelID("model_G4ParticleHPDInelasticFS_F24");
 }
 
-void G4ParticleHPDInelasticFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                    G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHPDInelasticFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                    const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   G4ParticleHPInelasticCompFS::Init(A, Z, M, dirName, aFSType, projectile);
   G4double ResidualA = 0;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPElasticData.cc

@@ -101,16 +101,6 @@ G4double G4ParticleHPElasticData::GetIsoCrossSection(const G4DynamicParticle* dp
   return xs;
 }
 
-/*
-G4bool G4ParticleHPElasticData::IsApplicable(const G4DynamicParticle*aP, const G4Element*)
-{
-  G4bool result = true;
-  G4double eKin = aP->GetKineticEnergy();
-  if(eKin>20*MeV||aP->GetDefinition()!=G4Neutron::Neutron()) result = false;
-  return result;
-}
-*/
-
 void G4ParticleHPElasticData::BuildPhysicsTable(const G4ParticleDefinition& aP)
 {
   if (&aP != G4Neutron::Neutron())
@@ -132,8 +122,7 @@ void G4ParticleHPElasticData::BuildPhysicsTable(const G4ParticleDefinition& aP)
 
   // make a PhysicsVector for each element
 
-  static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
-  if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
+  auto theElementTable = G4Element::GetElementTable();
   for (std::size_t i = 0; i < numberOfElements; ++i) {
     G4PhysicsVector* physVec = G4ParticleHPData::Instance(G4Neutron::Neutron())
                                  ->MakePhysicsVector((*theElementTable)[i], this);
@@ -143,12 +132,8 @@ void G4ParticleHPElasticData::BuildPhysicsTable(const G4ParticleDefinition& aP)
   G4ParticleHPManager::GetInstance()->RegisterElasticCrossSections(theCrossSections);
 }
 
-void G4ParticleHPElasticData::DumpPhysicsTable(const G4ParticleDefinition& aP)
+void G4ParticleHPElasticData::DumpPhysicsTable(const G4ParticleDefinition&)
 {
-  if (&aP != G4Neutron::Neutron())
-    throw G4HadronicException(__FILE__, __LINE__,
-                              "Attempt to use NeutronHP data for particles other than neutrons!!!");
-
 #ifdef G4VERBOSE
   if (G4HadronicParameters::Instance()->GetVerboseLevel() == 0) return;
 
@@ -169,8 +154,7 @@ void G4ParticleHPElasticData::DumpPhysicsTable(const G4ParticleDefinition& aP)
   G4cout << G4endl;
 
   std::size_t numberOfElements = G4Element::GetNumberOfElements();
-  static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
-  if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
+  auto theElementTable = G4Element::GetElementTable();
 
   for (std::size_t i = 0; i < numberOfElements; ++i) {
     G4cout << (*theElementTable)[i]->GetName() << G4endl;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPElasticFS.cc

@@ -77,15 +77,15 @@ G4ParticleHPElasticFS::G4ParticleHPElasticFS()
 }
 
 void G4ParticleHPElasticFS::Init(G4double A, G4double Z, G4int M,
-                                 G4String& dirName, G4String&,
+                                 const G4String& dirName, const G4String&,
                                  G4ParticleDefinition*)
 {
   G4String tString = "/FS";
   G4bool dbool = true;
   SetA_Z(A, Z, M);
-  G4ParticleHPDataUsed aFile =
+  const G4ParticleHPDataUsed& aFile =
     theNames.GetName(theBaseA, theBaseZ, M, dirName, tString, dbool);
-  G4String filename = aFile.GetName();
+  const G4String& filename = aFile.GetName();
   SetAZMs(aFile);
   if (!dbool) {
     hasAnyData = false;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPElasticURR.cc

@@ -53,8 +53,11 @@
 #include "G4Threading.hh"
 
 
-G4ParticleHPElasticURR::G4ParticleHPElasticURR() : G4HadronicInteraction( "NeutronHPElasticURR" ) {
-  SetMinEnergy(  0.0 * CLHEP::eV );
+G4ParticleHPElasticURR::G4ParticleHPElasticURR( G4bool isThermalScatteringOn ) :
+  G4HadronicInteraction( "NeutronHPElasticURR" ) {
+  G4double minEnergy = 0.0;
+  if ( isThermalScatteringOn ) minEnergy = 4.0 * CLHEP::eV;
+  SetMinEnergy(  minEnergy );
   SetMaxEnergy( 20.0 * CLHEP::MeV );
   particleHPelastic = new G4ParticleHPElastic;
 }

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFCFissionFS.cc

@@ -31,8 +31,8 @@
 //
 #include "G4ParticleHPFCFissionFS.hh"
 
-void G4ParticleHPFCFissionFS::Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String&,
-                                   G4ParticleDefinition* projectile)
+void G4ParticleHPFCFissionFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                   const G4String&, G4ParticleDefinition* projectile)
 {
   G4String aString = "/FC/";
   G4ParticleHPFissionBaseFS::Init(A, Z, M, dirName, aString, projectile);

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFFFissionFS.cc

@@ -62,8 +62,8 @@ G4ParticleHPFFFissionFS::~G4ParticleHPFFFissionFS()
   }
 }
 
-void G4ParticleHPFFFissionFS::Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String&,
-                                   G4ParticleDefinition*)
+void G4ParticleHPFFFissionFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                   const G4String&, G4ParticleDefinition*)
 {
   // G4cout << "G4ParticleHPFFFissionFS::Init" << G4endl;
   G4String aString = "FF";

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFSFissionFS.cc

@@ -43,14 +43,14 @@
 #include "G4ThreeVector.hh"
 #include "G4Triton.hh"
 
-void G4ParticleHPFSFissionFS::Init(G4double A, G4double Z, G4int M, G4String& dirName, G4String&,
-                                   G4ParticleDefinition*)
+void G4ParticleHPFSFissionFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                   const G4String&, G4ParticleDefinition*)
 {
   G4String tString = "/FS/";
   G4bool dbool;
-  G4ParticleHPDataUsed aFile =
+  const G4ParticleHPDataUsed& aFile =
     theNames.GetName(static_cast<G4int>(A), static_cast<G4int>(Z), M, dirName, tString, dbool);
-  G4String filename = aFile.GetName();
+  const G4String& filename = aFile.GetName();
   SetAZMs(A, Z, M, aFile);
   if (!dbool) {
     hasAnyData = false;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFissionBaseFS.cc

@@ -43,14 +43,14 @@
 #include "G4ThreeVector.hh"
 #include "G4Triton.hh"
 
-void G4ParticleHPFissionBaseFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                     G4String& bit, G4ParticleDefinition*)
+void G4ParticleHPFissionBaseFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                     const G4String& bit, G4ParticleDefinition*)
 {
   G4String tString = dirName;
   G4bool dbool;
-  G4ParticleHPDataUsed aFile =
+  const G4ParticleHPDataUsed& aFile =
     theNames.GetName(static_cast<G4int>(A), static_cast<G4int>(Z), M, tString, bit, dbool);
-  G4String filename = aFile.GetName();
+  const G4String& filename = aFile.GetName();
   SetAZMs(A, Z, M, aFile);
   // theBaseA = aFile.GetA();
   // theBaseZ = aFile.GetZ();

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFissionData.cc

@@ -60,7 +60,6 @@ G4ParticleHPFissionData::G4ParticleHPFissionData() : G4VCrossSectionDataSet("Neu
   material_cache = nullptr;
   ke_cache = 0.0;
   xs_cache = 0.0;
-  // BuildPhysicsTable(*G4Neutron::Neutron());
 }
 
 G4ParticleHPFissionData::~G4ParticleHPFissionData()
@@ -97,12 +96,8 @@ G4double G4ParticleHPFissionData::GetIsoCrossSection(const G4DynamicParticle* dp
   return xs;
 }
 
-void G4ParticleHPFissionData::BuildPhysicsTable(const G4ParticleDefinition& aP)
+void G4ParticleHPFissionData::BuildPhysicsTable(const G4ParticleDefinition&)
 {
-  if (&aP != G4Neutron::Neutron())
-    throw G4HadronicException(__FILE__, __LINE__,
-                              "Attempt to use NeutronHP data for particles other than neutrons!!!");
-
   if (G4Threading::IsWorkerThread()) {
     theCrossSections = G4ParticleHPManager::GetInstance()->GetFissionCrossSections();
     return;
@@ -116,8 +111,7 @@ void G4ParticleHPFissionData::BuildPhysicsTable(const G4ParticleDefinition& aP)
 
   // make a PhysicsVector for each element
 
-  static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
-  if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
+  auto theElementTable = G4Element::GetElementTable();
   for (std::size_t i = 0; i < numberOfElements; ++i) {
     G4PhysicsVector* physVec = G4ParticleHPData::Instance(G4Neutron::Neutron())
                                  ->MakePhysicsVector((*theElementTable)[i], this);
@@ -127,12 +121,8 @@ void G4ParticleHPFissionData::BuildPhysicsTable(const G4ParticleDefinition& aP)
   G4ParticleHPManager::GetInstance()->RegisterFissionCrossSections(theCrossSections);
 }
 
-void G4ParticleHPFissionData::DumpPhysicsTable(const G4ParticleDefinition& aP)
+void G4ParticleHPFissionData::DumpPhysicsTable(const G4ParticleDefinition&)
 {
-  if (&aP != G4Neutron::Neutron())
-    throw G4HadronicException(__FILE__, __LINE__,
-                              "Attempt to use NeutronHP data for particles other than neutrons!!!");
-
 #ifdef G4VERBOSE
   if (G4HadronicParameters::Instance()->GetVerboseLevel() == 0) return;
 
@@ -152,8 +142,7 @@ void G4ParticleHPFissionData::DumpPhysicsTable(const G4ParticleDefinition& aP)
   G4cout << G4endl;
 
   std::size_t numberOfElements = G4Element::GetNumberOfElements();
-  static G4ThreadLocal G4ElementTable* theElementTable = nullptr;
-  if (theElementTable == nullptr) theElementTable = G4Element::GetElementTable();
+  auto theElementTable = G4Element::GetElementTable();
 
   for (std::size_t i = 0; i < numberOfElements; ++i) {
     G4cout << (*theElementTable)[i]->GetName() << G4endl;

source/processes/hadronic/models/particle_hp/src/G4ParticleHPFissionFS.cc

@@ -49,8 +49,8 @@ G4ParticleHPFissionFS::G4ParticleHPFissionFS()
   produceFissionFragments = false;
 }
 
-void G4ParticleHPFissionFS::Init(G4double A, G4double Z, G4int M, G4String& dirName,
-                                 G4String& aFSType, G4ParticleDefinition* projectile)
+void G4ParticleHPFissionFS::Init(G4double A, G4double Z, G4int M, const G4String& dirName,
+                                 const G4String& aFSType, G4ParticleDefinition* projectile)
 {
   theFS.Init(A, Z, M, dirName, aFSType, projectile);
   theFC.Init(A, Z, M, dirName, aFSType, projectile);