| Geant4 Cross Reference |
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 // G4VRangeToEnergyConverter 26 // G4VRangeToEnergyConverter
27 // 27 //
28 // Class description: 28 // Class description:
29 // 29 //
30 // Base class for Range to Energy Converters. 30 // Base class for Range to Energy Converters.
31 // Cut in energy corresponding to given cut va 31 // Cut in energy corresponding to given cut value in range
32 // is calculated for a material by using Conve 32 // is calculated for a material by using Convert() method.
33 33
34 // Author: H.Kurashige, 05 October 2002 - Firs 34 // Author: H.Kurashige, 05 October 2002 - First implementation
35 // ------------------------------------------- 35 // --------------------------------------------------------------------
36 #ifndef G4VRangeToEnergyConverter_hh 36 #ifndef G4VRangeToEnergyConverter_hh
37 #define G4VRangeToEnergyConverter_hh 1 37 #define G4VRangeToEnergyConverter_hh 1
38 38
>> 39 #include <cmath>
39 #include <vector> 40 #include <vector>
40 41
41 #include "globals.hh" 42 #include "globals.hh"
>> 43 #include "G4ios.hh"
42 #include "G4ParticleDefinition.hh" 44 #include "G4ParticleDefinition.hh"
>> 45 #include "G4PhysicsTable.hh"
>> 46 #include "G4Element.hh"
43 #include "G4Material.hh" 47 #include "G4Material.hh"
44 48
>> 49 class G4PhysicsLogVector;
>> 50
45 class G4VRangeToEnergyConverter 51 class G4VRangeToEnergyConverter
46 { 52 {
47 public: << 53 public:
>> 54
>> 55 G4VRangeToEnergyConverter();
>> 56 // Constructor
>> 57
>> 58 G4VRangeToEnergyConverter(const G4VRangeToEnergyConverter& r);
>> 59 // Copy constructor
>> 60
>> 61 G4VRangeToEnergyConverter& operator=(const G4VRangeToEnergyConverter &r);
>> 62 // Assignment operator
>> 63
>> 64 virtual ~G4VRangeToEnergyConverter();
>> 65 // Destructor
48 66
49 explicit G4VRangeToEnergyConverter(); << 67 G4bool operator==(const G4VRangeToEnergyConverter& r) const;
>> 68 G4bool operator!=(const G4VRangeToEnergyConverter& r) const;
>> 69 // Equality operators
50 70
51 virtual ~G4VRangeToEnergyConverter(); << 71 virtual G4double Convert(G4double rangeCut, const G4Material* material);
>> 72 // Calculate energy cut from given range cut for the material
52 73
53 // operators are not used << 74 static void SetEnergyRange(G4double lowedge, G4double highedge);
54 G4VRangeToEnergyConverter(const G4VRangeToEn << 75 // Set energy range for all particle type
55 G4VRangeToEnergyConverter& operator= << 76
56 (const G4VRangeToEnergyConverter &r) = delet << 77 static G4double GetLowEdgeEnergy();
57 G4bool operator==(const G4VRangeToEnergyConv << 78 static G4double GetHighEdgeEnergy();
58 G4bool operator!=(const G4VRangeToEnergyConv << 79 // Get energy range for all particle type
59 << 80
60 // Calculate energy cut from given range cut << 81 static G4double GetMaxEnergyCut();
61 virtual G4double Convert(const G4double rang << 82 static void SetMaxEnergyCut(G4double value);
62 << 83 // Get/set max cut energy for all particle type
63 // Set energy range for all particle type <<
64 // if highedge > 10 GeV, highedge value is n <<
65 static void SetEnergyRange(const G4double lo <<
66 <<
67 // Get energy range for all particle type <<
68 static G4double GetLowEdgeEnergy(); <<
69 static G4double GetHighEdgeEnergy(); <<
70 <<
71 // Get/set max cut energy for all particle t <<
72 // No check on the value <<
73 static G4double GetMaxEnergyCut(); <<
74 static void SetMaxEnergyCut(const G4double v <<
75 84
76 // Return pointer to the particle type which << 85 inline const G4ParticleDefinition* GetParticleType() const;
77 inline const G4ParticleDefinition* GetPartic << 86 // Return pointer to the particle type which this converter takes care of
>> 87
>> 88 const G4PhysicsTable* GetLossTable() const;
>> 89 // theLossTable is a collection of loss vectors for all elements.
>> 90 // Each loss vector has energy loss values (cross-section values
>> 91 // for neutral particles) which are calculated by
>> 92 // ComputeLoss(G4double AtomicNumber, G4double KineticEnergy).
>> 93 // ComputeLoss method is pure virtual and should be provided
>> 94 // for each particle type
>> 95
>> 96 virtual void Reset();
>> 97 // Reset Loss Table and Range Vectors
78 98
79 inline void SetVerboseLevel(G4int value); << 99 inline void SetVerboseLevel(G4int value);
80 inline G4int GetVerboseLevel() const; << 100 inline G4int GetVerboseLevel() const;
81 // control flag for output message 101 // control flag for output message
82 // 0: Silent 102 // 0: Silent
83 // 1: Warning message 103 // 1: Warning message
84 // 2: More 104 // 2: More
85 105
86 protected: << 106 protected:
87 107
88 virtual G4double ComputeValue(const G4int Z, << 108 virtual void BuildLossTable();
89 109
90 private: << 110 virtual G4double ComputeLoss(G4double AtomicNumber,
>> 111 G4double KineticEnergy) = 0;
91 112
92 static void FillEnergyVector(const G4double << 113 // ------------- Range Table --------------------------------------
93 114
94 G4double ConvertForGamma(const G4double rang << 115 using G4LossVector = G4PhysicsLogVector;
95 << 116 using G4RangeVector = G4PhysicsLogVector;
96 G4double ConvertForElectron(const G4double r << 117 using G4LossTable = G4PhysicsTable;
97 const G4Material << 118
98 << 119 virtual void BuildRangeVector(const G4Material* aMaterial,
99 inline G4double LiniearInterpolation(const G << 120 G4RangeVector* rangeVector);
100 const G << 121
101 const G << 122 G4double ConvertCutToKineticEnergy(G4RangeVector* theRangeVector,
102 << 123 G4double theCutInLength,
103 protected: << 124 std::size_t materialIndex ) const;
104 << 125 protected:
105 const G4ParticleDefinition* theParticle = nu << 126
106 G4int fPDG = 0; << 127 static G4double LowestEnergy, HighestEnergy;
>> 128 static G4double MaxEnergyCut;
>> 129 G4double fMaxEnergyCut = 0.0;
>> 130
>> 131 const G4ParticleDefinition* theParticle = nullptr;
>> 132 G4LossTable* theLossTable = nullptr;
>> 133 G4int NumberOfElements = 0;
>> 134
>> 135 const G4int TotBin = 300;
107 136
108 private: << 137 std::vector< G4RangeVector* > fRangeVectorStore;
109 138
110 static G4double sEmin; << 139 private:
111 static G4double sEmax; <<
112 static std::vector<G4double>* sEnergy; <<
113 static G4int sNbinPerDecade; <<
114 static G4int sNbin; <<
115 140
116 G4int verboseLevel = 1; << 141 G4int verboseLevel = 1;
117 G4bool isFirstInstance = false; <<
118 }; 142 };
119 143
120 // ------------------ 144 // ------------------
121 // Inline methods 145 // Inline methods
122 // ------------------ 146 // ------------------
123 147
124 inline 148 inline
125 void G4VRangeToEnergyConverter::SetVerboseLeve 149 void G4VRangeToEnergyConverter::SetVerboseLevel(G4int value)
126 { 150 {
127 verboseLevel = value; 151 verboseLevel = value;
128 } 152 }
129 153
130 inline 154 inline
131 G4int G4VRangeToEnergyConverter::GetVerboseLev 155 G4int G4VRangeToEnergyConverter::GetVerboseLevel() const
132 { 156 {
133 return verboseLevel; 157 return verboseLevel;
134 } 158 }
135 159
136 inline 160 inline
137 const G4ParticleDefinition* G4VRangeToEnergyCo 161 const G4ParticleDefinition* G4VRangeToEnergyConverter::GetParticleType() const
138 { 162 {
139 return theParticle; 163 return theParticle;
140 } <<
141 <<
142 inline G4double G4VRangeToEnergyConverter::Lin <<
143 const G4double e1, const G4dou <<
144 const G4double r1, const G4dou <<
145 { <<
146 return (r1 == r2) ? e1 : e1 + (e2 - e1)*(r - <<
147 } 164 }
148 165
149 #endif 166 #endif
150 167