Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/cuts/include/G4ProductionCutsTable.hh

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/cuts/include/G4ProductionCutsTable.hh (Version 11.3.0) and /processes/cuts/include/G4ProductionCutsTable.hh (Version 9.2.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4ProductionCutsTable                       << 
 27 //                                                 26 //
 28 // Class description:                          <<  27 // $Id: G4ProductionCutsTable.hh,v 1.9 2008/03/02 10:52:55 kurasige Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02 $
 29 //                                                 29 //
 30 // G4ProductionCutsTable is a singleton class  <<  30 // 
 31 // G4ProductionCuts objects. This class manage <<  31 // ------------------------------------------------------------
 32 // cuts and energy cuts for each particle type <<  32 //  GEANT 4 class header file 
 33                                                <<  33 //
 34 // Author: M.Asai, 5 October 2002 - First impl <<  34 // Class Description
 35 // Modifications: H.Kurashige, 2004-2008       <<  35 //  G4ProductionCutsTable is a static singleton class of a table of
 36 // ------------------------------------------- <<  36 //  G4ProductionCuts objects. This class also manages tables of
 37 #ifndef G4ProductionCutsTable_hh               <<  37 //  production cut and energy cut for each particle type.
 38 #define G4ProductionCutsTable_hh 1             <<  38 //
                                                   >>  39 // ------------------------------------------------------------
                                                   >>  40 //   First Implementation          05 Oct. 2002  M.Asai    
                                                   >>  41 //
                                                   >>  42 //   Modified                      03 Feb 2004 H.Kurashige
                                                   >>  43 //    Modify RetrieveCutsTable to allow ordering of materials and 
                                                   >>  44 //    couples can be different from one in file (i.e. at storing)
                                                   >>  45 //   Modified                      20 Aug. 2004 H.Kurashige
                                                   >>  46 //    Modify RetrieveCutsTable to allow materials and 
                                                   >>  47 //    couples can be different from one in file (i.e. at storing)
                                                   >>  48 //   Modified                      2 Mar. 2008 H.Kurashige
                                                   >>  49 //    add messenger
                                                   >>  50 // ------------------------------------------------------------
 39                                                    51 
 40 #include <cmath>                               <<  52 #ifndef G4ProductionCutsTable_h 
 41 #include <vector>                              <<  53 #define G4ProductionCutsTable_h 1
 42                                                << 
 43 #include "globals.hh"                          << 
 44 #include "G4ios.hh"                            << 
 45 #include "G4MaterialCutsCouple.hh"             << 
 46 #include "G4MCCIndexConversionTable.hh"        << 
 47 #include "G4Region.hh"                         << 
 48                                                    54 
 49 class G4RegionStore;                               55 class G4RegionStore;
 50 class G4VRangeToEnergyConverter;                   56 class G4VRangeToEnergyConverter;
 51 class G4LogicalVolume;                             57 class G4LogicalVolume;
 52 class G4VPhysicalVolume;                           58 class G4VPhysicalVolume;
 53 class G4ProductionCuts;                            59 class G4ProductionCuts;
                                                   >>  60 
 54 class G4ProductionCutsTableMessenger;              61 class G4ProductionCutsTableMessenger;
 55                                                    62 
                                                   >>  63 #include "globals.hh"
                                                   >>  64 #include <cmath>
                                                   >>  65 #include "G4ios.hh"
                                                   >>  66 #include <vector>
                                                   >>  67 #include "G4MaterialCutsCouple.hh"
                                                   >>  68 #include "G4MCCIndexConversionTable.hh"
                                                   >>  69 #include "G4Region.hh"
                                                   >>  70 
                                                   >>  71 
 56 class G4ProductionCutsTable                        72 class G4ProductionCutsTable  
 57 {                                                  73 {
 58   public:                                      <<  74   public: // with description
 59                                                << 
 60     static G4ProductionCutsTable* GetProductio     75     static G4ProductionCutsTable* GetProductionCutsTable();
 61       // This static method returns the single <<  76     // This static method returns the singleton pointer of this class object.
 62       // At first invocation, the singleton ob <<  77     // At the first invokation of this method, the singleton object is instantiated.
 63                                                    78 
 64     G4ProductionCutsTable(const G4ProductionCu <<  79   protected:
 65     G4ProductionCutsTable& operator=(const G4P <<  80     G4ProductionCutsTable();
                                                   >>  81   private:
                                                   >>  82     G4ProductionCutsTable(const G4ProductionCutsTable& right);
 66                                                    83 
                                                   >>  84   public:
 67     virtual ~G4ProductionCutsTable();              85     virtual ~G4ProductionCutsTable();
 68                                                    86 
 69     void CreateCoupleTables();                 <<  87   public: // with description
 70       // Creates material cuts couples table a << 
 71                                                << 
 72     void UpdateCoupleTable(G4VPhysicalVolume*      88     void UpdateCoupleTable(G4VPhysicalVolume* currentWorld);
 73       // Triggers an update of the table of G4 <<  89     // This method triggers an update of the table of G4ProductionCuts objects.
 74                                                    90 
 75     void SetEnergyRange(G4double lowedge, G4do     91     void SetEnergyRange(G4double lowedge, G4double highedge);
 76       // Sets the limits of energy cuts for al <<  92     // This method sets the limits of energy cuts for all particles.
 77                                                    93 
 78     G4double GetLowEdgeEnergy() const;             94     G4double GetLowEdgeEnergy() const;
 79     G4double GetHighEdgeEnergy() const;            95     G4double GetHighEdgeEnergy() const;
 80       // Get the limits of energy cuts for all <<  96     // These methods get the limits of energy cuts for all particles.
 81                                                    97 
 82     G4double GetMaxEnergyCut();                << 
 83     void SetMaxEnergyCut(G4double value);      << 
 84       // Get/set max cut energy of RangeToEner << 
 85       // for all particle types                << 
 86                                                    98 
 87     void DumpCouples() const;                      99     void DumpCouples() const;
 88       // Displays a list of registered couples << 100     // Display a list of registored couples
 89                                                   101 
 90     const G4MCCIndexConversionTable* GetMCCInd    102     const G4MCCIndexConversionTable* GetMCCIndexConversionTable() const;
 91       // Gives the pointer to the MCCIndexConv << 103     // gives the pointer to the MCCIndexConversionTable
 92                                                   104 
 93     const std::vector<G4double>* GetRangeCutsV << 105   private:
 94     const std::vector<G4double>* GetEnergyCuts << 
 95                                                << 
 96     std::size_t GetTableSize() const;          << 
 97       // Returns the size of the couple table  << 
 98                                                   106 
 99     const G4MaterialCutsCouple* GetMaterialCut << 107    static G4ProductionCutsTable* fG4ProductionCutsTable;
100       // Returns the pointer to the couple     << 
101                                                   108 
102     const G4MaterialCutsCouple* GetMaterialCut << 109    typedef std::vector<G4MaterialCutsCouple*> G4CoupleTable;
103                                             co << 110    typedef std::vector<G4MaterialCutsCouple*>::const_iterator CoupleTableIterator;
104      // Returns the pointer to the couple      << 111    typedef std::vector<G4double> G4CutVectorForAParticle;
105                                                << 112    typedef std::vector<G4CutVectorForAParticle*> G4CutTable;
106     G4int GetCoupleIndex(const G4MaterialCutsC << 113    G4CoupleTable coupleTable;
107     G4int GetCoupleIndex(const G4Material* aMa << 114    G4CutTable rangeCutTable;
108                          const G4ProductionCut << 115    G4CutTable energyCutTable;
109       // Return the index of the couple.       << 116 
110       // -1 is returned if index is not found  << 117    G4RegionStore* fG4RegionStore;
                                                   >> 118    G4VRangeToEnergyConverter* converters[NumberOfG4CutIndex]; 
                                                   >> 119 
                                                   >> 120    G4ProductionCuts* defaultProductionCuts;
                                                   >> 121 
                                                   >> 122    G4MCCIndexConversionTable mccConversionTable;
                                                   >> 123 
                                                   >> 124 // These two vectors are for the backward comparibility
                                                   >> 125    G4double* rangeDoubleVector[NumberOfG4CutIndex];
                                                   >> 126    G4double* energyDoubleVector[NumberOfG4CutIndex];
                                                   >> 127 
                                                   >> 128   public: 
                                                   >> 129    const std::vector<G4double>* GetRangeCutsVector(size_t pcIdx) const;
                                                   >> 130    const std::vector<G4double>* GetEnergyCutsVector(size_t pcIdx) const;
                                                   >> 131 
                                                   >> 132 // These two vectors are for the backward comparibility
                                                   >> 133    G4double* GetRangeCutsDoubleVector(size_t pcIdx) const;
                                                   >> 134    G4double* GetEnergyCutsDoubleVector(size_t pcIdx) const;
                                                   >> 135   
                                                   >> 136   public: // with description
                                                   >> 137    size_t GetTableSize() const;
                                                   >> 138      // This method returns the size of the couple table.
                                                   >> 139 
                                                   >> 140    const G4MaterialCutsCouple* GetMaterialCutsCouple(G4int i) const;
                                                   >> 141     // This method returns the pointer to the couple.
                                                   >> 142 
                                                   >> 143    const G4MaterialCutsCouple*
                                                   >> 144      GetMaterialCutsCouple(const G4Material* aMat,
                                                   >> 145                            const G4ProductionCuts* aCut) const;
                                                   >> 146     // This method returns the pointer to the couple.
                                                   >> 147 
                                                   >> 148    G4int GetCoupleIndex(const G4MaterialCutsCouple* aCouple) const;
                                                   >> 149    G4int GetCoupleIndex(const G4Material* aMat,
                                                   >> 150                            const G4ProductionCuts* aCut) const;
                                                   >> 151     // These methods return the index of the couple.
                                                   >> 152     // -1 is returned if index is not found.
111                                                   153 
112     G4bool IsModified() const;                 << 154    G4bool IsModified() const;
113       // Returns TRUE if at least one producti << 155     // This method returns TRUE if at least one production cut value is modified.
114                                                   156   
115     void PhysicsTableUpdated();                << 157    void PhysicsTableUpdated();
116       // Resets the status of IsModified(). Th << 158     // This method resets the status of IsModified(). This method must
117       // used by the RunManager when physics t << 159     // be exclusively used by RunManager when physics tables are built.
118                                                   160 
119     G4ProductionCuts* GetDefaultProductionCuts << 161    G4ProductionCuts* GetDefaultProductionCuts() const;
120       // Returns the default production cuts   << 162     // This method returns the default production cuts.
121                                                   163  
122     G4double ConvertRangeToEnergy(const G4Part << 164    G4double ConvertRangeToEnergy(const G4ParticleDefinition* particle,
123                                   const G4Mate << 165          const G4Material*           material, 
124                                         G4doub << 166          G4double                    range    );
125       // Gives energy corresponding to range v << 167     // This method gives energy corresponding to range value  
126       // -1 is returned if particle or materia << 168     // 
127                                                << 169     // -1 is returned if particle or material is not found.
128     void ResetConverters();                    << 170     
129       // Resets all range to energy converters << 
130                                                << 
131     G4bool StoreCutsTable(const G4String& dire << 
132                           G4bool ascii = false << 
133       // Stores cuts and material information  << 
134       // the specified directory               << 
135                                                << 
136     G4bool RetrieveCutsTable(const G4String& d << 
137                              G4bool ascii = fa << 
138       // Retrieve material cut couple informat << 
139       // in files under the specified director << 
140                                                << 
141     G4bool CheckForRetrieveCutsTable(const G4S << 
142                                      G4bool as << 
143       // Checks stored material and cut values << 
144       // with the current detector setup       << 
145                                                << 
146     G4double* GetRangeCutsDoubleVector(std::si << 
147     G4double* GetEnergyCutsDoubleVector(std::s << 
148       // Methods for backward compatibility    << 
149                                                << 
150     void SetEnergyCutVector(const std::vector< << 
151       // User defined cut vectors (idx < 4) ra << 
152       // to avoid inconsistency in physics     << 
153                                                << 
154     void  SetVerboseLevel(G4int value);        << 
155     G4int GetVerboseLevel() const;             << 
156       // Control flag for output message       << 
157       //  0: Silent                            << 
158       //  1: Warning message                   << 
159       //  2: More                              << 
160                                                << 
161   protected:                                   << 
162                                                << 
163     G4ProductionCutsTable();                   << 
164                                                << 
165     virtual G4bool StoreMaterialInfo(const G4S << 
166                                      G4bool as << 
167       // Stores material information in files  << 
168                                                << 
169     virtual G4bool CheckMaterialInfo(const G4S << 
170                                      G4bool as << 
171       // Checks stored material is consistent  << 
172                                                << 
173     virtual G4bool StoreMaterialCutsCoupleInfo << 
174                                                << 
175       // Stores materialCutsCouple information << 
176       // specified directory                   << 
177                                                << 
178     virtual G4bool CheckMaterialCutsCoupleInfo << 
179                                                << 
180       // Checks stored materialCutsCouple is c << 
181       // the current detector setup            << 
182                                                << 
183     virtual G4bool StoreCutsInfo(const G4Strin << 
184                                  G4bool ascii  << 
185       // Stores cut values information in file << 
186                                                << 
187     virtual G4bool  RetrieveCutsInfo(const G4S << 
188                                      G4bool as << 
189       // Retrieves cut values information in f << 
190       // specified directory                   << 
191                                                << 
192   private:                                        171   private:
193                                                << 
194     void ScanAndSetCouple(G4LogicalVolume* aLV    172     void ScanAndSetCouple(G4LogicalVolume* aLV,
195                           G4MaterialCutsCouple << 173         G4MaterialCutsCouple* aCouple,
196                           G4Region* aRegion);  << 174         G4Region* aRegion);
197                                                << 
198     G4bool IsCoupleUsedInTheRegion(const G4Mat << 
199                                    const G4Reg << 
200                                                << 
201                                                   175 
202   private:                                     << 176     bool IsCoupleUsedInTheRegion(const G4MaterialCutsCouple* aCouple,
203                                                << 177          const G4Region* aRegion) const;
204     static G4ProductionCutsTable* fProductionC << 
205                                                << 
206     std::vector<G4MaterialCutsCouple*> coupleT << 
207     std::vector<std::vector<G4double>*> rangeC << 
208     std::vector<std::vector<G4double>*> energy << 
209                                                   178 
210     std::vector<G4double>* userEnergyCuts[4] = << 179   public: // with description
                                                   >> 180    // Store cuts and material information in files under the specified directory.
                                                   >> 181   G4bool  StoreCutsTable(const G4String& directory, 
                                                   >> 182        G4bool          ascii = false);
                                                   >> 183   
                                                   >> 184   // Retrieve material cut couple information 
                                                   >> 185   //  in files under the specified directory.
                                                   >> 186   G4bool  RetrieveCutsTable(const G4String& directory,
                                                   >> 187           G4bool          ascii = false);
                                                   >> 188   
                                                   >> 189   // check stored material and cut values are consistent with the current detector setup. 
                                                   >> 190   G4bool CheckForRetrieveCutsTable(const G4String& directory, 
                                                   >> 191            G4bool          ascii = false);
211                                                   192 
212     G4RegionStore* fG4RegionStore = nullptr;   << 193   protected:
213     G4VRangeToEnergyConverter* converters[Numb << 
214                                                   194 
215     G4ProductionCuts* defaultProductionCuts =  << 195   // Store material information in files under the specified directory.
                                                   >> 196   virtual G4bool  StoreMaterialInfo(const G4String& directory, 
                                                   >> 197             G4bool          ascii = false);
                                                   >> 198 
                                                   >> 199   // check stored material is consistent with the current detector setup. 
                                                   >> 200   virtual G4bool  CheckMaterialInfo(const G4String& directory, 
                                                   >> 201             G4bool          ascii = false);
                                                   >> 202   
                                                   >> 203   // Store materialCutsCouple information in files under the specified directory.
                                                   >> 204   virtual G4bool  StoreMaterialCutsCoupleInfo(const G4String& directory, 
                                                   >> 205             G4bool          ascii = false);
                                                   >> 206 
                                                   >> 207   // check stored materialCutsCouple is consistent with the current detector setup. 
                                                   >> 208   virtual G4bool  CheckMaterialCutsCoupleInfo(const G4String& directory, 
                                                   >> 209             G4bool          ascii = false);
                                                   >> 210 
                                                   >> 211   // Store cut values information in files under the specified directory.
                                                   >> 212   virtual G4bool  StoreCutsInfo(const G4String& directory, 
                                                   >> 213                                 G4bool          ascii = false);
                                                   >> 214   
                                                   >> 215  // Retrieve cut values information in files under the specified directory.
                                                   >> 216   virtual G4bool  RetrieveCutsInfo(const G4String& directory,
                                                   >> 217                                    G4bool          ascii = false);
216                                                   218 
217     G4MCCIndexConversionTable mccConversionTab << 219   private:
                                                   >> 220    G4bool firstUse;
                                                   >> 221    enum { FixedStringLengthForStore = 32 }; 
218                                                   222 
219     // These two vectors are for backward comp << 223   public: // with description  
220     G4double* rangeDoubleVector[NumberOfG4CutI << 224       void  SetVerboseLevel(G4int value);
221     G4double* energyDoubleVector[NumberOfG4Cut << 225       G4int GetVerboseLevel() const;
                                                   >> 226       // controle flag for output message
                                                   >> 227       //  0: Silent
                                                   >> 228       //  1: Warning message
                                                   >> 229       //  2: More
222                                                   230 
223     enum { FixedStringLengthForStore = 32 };   << 231   private:
                                                   >> 232     G4int verboseLevel;
                                                   >> 233     G4ProductionCutsTableMessenger* fMessenger;
224                                                   234 
225     G4ProductionCutsTableMessenger* fMessenger << 
226     G4int verboseLevel = 1;                    << 
227     G4bool firstUse = true;                    << 
228 };                                                235 };
229                                                   236 
230 // ------------------                          << 
231 // Inline methods                              << 
232 // ------------------                          << 
233                                                << 
234 inline                                            237 inline 
235 const std::vector<G4double>*                   << 238  const std::vector<G4double>* G4ProductionCutsTable::GetRangeCutsVector(size_t pcIdx) const
236 G4ProductionCutsTable::GetRangeCutsVector(std: << 
237 {                                                 239 { 
238   return rangeCutTable[pcIdx];                    240   return rangeCutTable[pcIdx]; 
239 }                                                 241 }
240                                                   242 
241 inline                                            243 inline 
242 const std::vector<G4double>*                   << 244  const std::vector<G4double>* G4ProductionCutsTable::GetEnergyCutsVector(size_t pcIdx) const
243 G4ProductionCutsTable::GetEnergyCutsVector(std << 
244 {                                                 245 {
245   return energyCutTable[pcIdx];                << 246  return energyCutTable[pcIdx]; 
246 }                                                 247 }
247                                                   248 
248 inline                                            249 inline 
249 std::size_t G4ProductionCutsTable::GetTableSiz << 250  size_t G4ProductionCutsTable::GetTableSize() const
250 {                                                 251 {
251   return coupleTable.size();                      252   return coupleTable.size(); 
252 }                                                 253 }
253                                                   254 
254 inline                                            255 inline 
255 const G4MaterialCutsCouple*                    << 256  const G4MaterialCutsCouple* G4ProductionCutsTable::GetMaterialCutsCouple(G4int i) const
256 G4ProductionCutsTable::GetMaterialCutsCouple(G << 
257 {                                                 257 { 
258   return coupleTable[std::size_t(i)];          << 258   return coupleTable[size_t(i)]; 
259 }                                                 259 }
260                                                   260 
261 inline                                            261 inline 
262 G4bool G4ProductionCutsTable::IsModified() con << 262  G4bool G4ProductionCutsTable::IsModified() const
263 {                                                 263 { 
264   if(firstUse) return true;                       264   if(firstUse) return true;
265   for(auto itr=coupleTable.cbegin(); itr!=coup << 265   for(G4ProductionCutsTable::CoupleTableIterator itr=coupleTable.begin();
266   {                                            << 266     itr!=coupleTable.end();itr++){ 
267     if((*itr)->IsRecalcNeeded())                  267     if((*itr)->IsRecalcNeeded())
268     {                                             268     {
269       return true;                                269       return true; 
270     }                                             270     }
271   }                                               271   }
272   return false;                                   272   return false;
273 }                                                 273 }
274                                                   274   
275 inline                                            275 inline 
276 void G4ProductionCutsTable::PhysicsTableUpdate << 276  void G4ProductionCutsTable::PhysicsTableUpdated()
277 {                                                 277 { 
278   for(auto itr=coupleTable.cbegin(); itr!=coup << 278   for(G4ProductionCutsTable::CoupleTableIterator itr=coupleTable.begin();itr!=coupleTable.end();itr++){ 
279   {                                            << 
280     (*itr)->PhysicsTableUpdated();                279     (*itr)->PhysicsTableUpdated(); 
281   }                                               280   }
282 }                                                 281 }
283                                                   282 
284 inline                                            283 inline
285 G4double*                                      << 284  G4double* G4ProductionCutsTable::GetRangeCutsDoubleVector(size_t pcIdx) const
286 G4ProductionCutsTable::GetRangeCutsDoubleVecto << 285 { return rangeDoubleVector[pcIdx]; }
287 {                                              << 
288   return rangeDoubleVector[pcIdx];             << 
289 }                                              << 
290                                                   286 
291 inline                                            287 inline
292 G4double*                                      << 288  G4double* G4ProductionCutsTable::GetEnergyCutsDoubleVector(size_t pcIdx) const
293 G4ProductionCutsTable::GetEnergyCutsDoubleVect << 289 { return energyDoubleVector[pcIdx]; }
294 {                                              << 
295   return energyDoubleVector[pcIdx];            << 
296 }                                              << 
297                                                   290 
298 inline                                            291 inline
299 G4ProductionCuts* G4ProductionCutsTable::GetDe << 292  G4ProductionCuts* G4ProductionCutsTable::GetDefaultProductionCuts() const
300 {                                              << 293 { return defaultProductionCuts; }
301   return defaultProductionCuts;                << 
302 }                                              << 
303                                                   294 
304 inline                                            295 inline
305 G4bool G4ProductionCutsTable::IsCoupleUsedInTh << 296 bool G4ProductionCutsTable::IsCoupleUsedInTheRegion(
306                                  const G4Mater    297                                  const G4MaterialCutsCouple* aCouple,
307                                  const G4Regio    298                                  const G4Region* aRegion) const
308 {                                                 299 {
309   G4ProductionCuts* fProductionCut = aRegion->    300   G4ProductionCuts* fProductionCut = aRegion->GetProductionCuts();
310   auto mItr = aRegion->GetMaterialIterator();  << 301   std::vector<G4Material*>::const_iterator mItr = aRegion->GetMaterialIterator();
311   std::size_t nMaterial = aRegion->GetNumberOf << 302   size_t nMaterial = aRegion->GetNumberOfMaterials();
312   for(std::size_t iMate=0;iMate<nMaterial; ++i << 303   for(size_t iMate=0;iMate<nMaterial;iMate++, mItr++){
313   {                                            << 
314     if(aCouple->GetMaterial()==(*mItr) &&         304     if(aCouple->GetMaterial()==(*mItr) &&
315        aCouple->GetProductionCuts()==fProducti << 305        aCouple->GetProductionCuts()==fProductionCut){
316     {                                          << 
317       return true;                                306       return true;
318     }                                             307     }
319   }                                               308   }
320   return false;                                   309   return false;
321 }                                                 310 }
322                                                   311 
323 inline                                            312 inline
324 const G4MaterialCutsCouple*                       313 const G4MaterialCutsCouple* 
325 G4ProductionCutsTable::GetMaterialCutsCouple(c << 314      G4ProductionCutsTable::GetMaterialCutsCouple(const G4Material* aMat,
326                                              c << 315                            const G4ProductionCuts* aCut) const
327 {                                              << 316 { 
328   for(auto cItr=coupleTable.cbegin(); cItr!=co << 317   for(CoupleTableIterator cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++)
329   {                                               318   { 
330     if((*cItr)->GetMaterial()!=aMat) continue;    319     if((*cItr)->GetMaterial()!=aMat) continue;
331     if((*cItr)->GetProductionCuts()==aCut) ret    320     if((*cItr)->GetProductionCuts()==aCut) return (*cItr);
332   }                                               321   }
333   return nullptr;                              << 322   return 0;
334 }                                                 323 }
335                                                   324 
336 inline                                            325 inline
337 G4int                                          << 326 G4int G4ProductionCutsTable::GetCoupleIndex(const G4MaterialCutsCouple* aCouple) const
338 G4ProductionCutsTable::GetCoupleIndex(const G4 << 
339 {                                                 327 { 
340   G4int idx = 0;                                  328   G4int idx = 0;
341   for(auto cItr=coupleTable.cbegin(); cItr!=co << 329   for(CoupleTableIterator cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++)
342   {                                               330   {
343     if((*cItr)==aCouple) return idx;              331     if((*cItr)==aCouple) return idx;
344     ++idx;                                     << 332     idx++;
345   }                                               333   }
346   return -1;                                      334   return -1;
347 }                                                 335 }
348                                                   336 
349 inline                                            337 inline
350 G4int G4ProductionCutsTable::GetCoupleIndex(co << 338 G4int G4ProductionCutsTable:: GetCoupleIndex(const G4Material* aMat,
351                                             co << 339                            const G4ProductionCuts* aCut) const
352 {                                                 340 {
353   const G4MaterialCutsCouple* aCouple = GetMat    341   const G4MaterialCutsCouple* aCouple = GetMaterialCutsCouple(aMat,aCut);
354   return GetCoupleIndex(aCouple);                 342   return GetCoupleIndex(aCouple);
355 }                                                 343 }
356                                                   344 
357 inline                                            345 inline 
358 G4int G4ProductionCutsTable::GetVerboseLevel() << 346  G4int G4ProductionCutsTable::GetVerboseLevel() const
359 {                                                 347 {
360   return verboseLevel;                         << 348    return verboseLevel;
361 }                                                 349 }
362                                                   350 
363 inline                                            351 inline
364 const G4MCCIndexConversionTable*               << 352  const G4MCCIndexConversionTable* 
365 G4ProductionCutsTable::GetMCCIndexConversionTa << 353    G4ProductionCutsTable::GetMCCIndexConversionTable() const
366 {                                                 354 {
367   return &mccConversionTable;                     355   return &mccConversionTable;
368 }                                                 356 }
369                                                   357 
370 #endif                                            358 #endif
                                                   >> 359 
                                                   >> 360 
                                                   >> 361 
                                                   >> 362 
                                                   >> 363 
                                                   >> 364 
371                                                   365