| 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 // 26 //
27 //-------------------------------------------- 27 //---------------------------------------------------------------------------
28 // 28 //
29 // ClassName: G4HadronicParameters 29 // ClassName: G4HadronicParameters
30 // 30 //
31 // Author: 2018 Alberto Ribon 31 // Author: 2018 Alberto Ribon
32 // 32 //
33 // Description: Singleton to keep global ha 33 // Description: Singleton to keep global hadronic parameters.
34 // 34 //
35 // Modified: 35 // Modified:
36 // 36 //
37 //-------------------------------------------- 37 //----------------------------------------------------------------------------
38 38
39 #include "G4HadronicParameters.hh" 39 #include "G4HadronicParameters.hh"
40 #include <CLHEP/Units/PhysicalConstants.h> 40 #include <CLHEP/Units/PhysicalConstants.h>
41 #include "G4ApplicationState.hh" 41 #include "G4ApplicationState.hh"
42 #include "G4StateManager.hh" 42 #include "G4StateManager.hh"
43 #include "G4HadronicParametersMessenger.hh" 43 #include "G4HadronicParametersMessenger.hh"
44 #include "G4Threading.hh" 44 #include "G4Threading.hh"
45 #include "G4AutoLock.hh" 45 #include "G4AutoLock.hh"
46 46
47 G4HadronicParameters* G4HadronicParameters::sI 47 G4HadronicParameters* G4HadronicParameters::sInstance = nullptr;
48 48
49 namespace 49 namespace
50 { 50 {
51 G4Mutex paramMutex = G4MUTEX_INITIALIZER; 51 G4Mutex paramMutex = G4MUTEX_INITIALIZER;
52 } 52 }
53 53
54 G4HadronicParameters* G4HadronicParameters::In 54 G4HadronicParameters* G4HadronicParameters::Instance() {
55 if ( sInstance == nullptr ) { 55 if ( sInstance == nullptr ) {
56 G4AutoLock l(¶mMutex); 56 G4AutoLock l(¶mMutex);
57 if ( sInstance == nullptr ) { 57 if ( sInstance == nullptr ) {
58 static G4HadronicParameters theHadronicP 58 static G4HadronicParameters theHadronicParametersObject;
59 sInstance = &theHadronicParametersObject 59 sInstance = &theHadronicParametersObject;
60 } 60 }
61 l.unlock(); 61 l.unlock();
62 } 62 }
63 return sInstance; 63 return sInstance;
64 } 64 }
65 65
66 66
67 G4HadronicParameters::~G4HadronicParameters() 67 G4HadronicParameters::~G4HadronicParameters() {
68 delete fMessenger; 68 delete fMessenger;
69 } 69 }
70 70
71 71
72 G4HadronicParameters::G4HadronicParameters() { 72 G4HadronicParameters::G4HadronicParameters() {
73 fMaxEnergy = 100.0*CLHEP::TeV; 73 fMaxEnergy = 100.0*CLHEP::TeV;
74 fMinEnergyTransitionFTF_Cascade = 3.0*CLHEP: 74 fMinEnergyTransitionFTF_Cascade = 3.0*CLHEP::GeV;
75 fMaxEnergyTransitionFTF_Cascade = 6.0*CLHEP: 75 fMaxEnergyTransitionFTF_Cascade = 6.0*CLHEP::GeV;
76 fMinEnergyTransitionQGS_FTF = 12.0*CLHEP::Ge 76 fMinEnergyTransitionQGS_FTF = 12.0*CLHEP::GeV;
77 fMaxEnergyTransitionQGS_FTF = 25.0*CLHEP::Ge 77 fMaxEnergyTransitionQGS_FTF = 25.0*CLHEP::GeV;
78 fMinEnergyINCLXX_Pbar = 0.0*CLHEP::GeV; 78 fMinEnergyINCLXX_Pbar = 0.0*CLHEP::GeV;
79 fMaxEnergyINCLXX_Pbar = 10.0*CLHEP::GeV; 79 fMaxEnergyINCLXX_Pbar = 10.0*CLHEP::GeV;
80 fEnergyThresholdForHeavyHadrons = 1.1*CLHEP: 80 fEnergyThresholdForHeavyHadrons = 1.1*CLHEP::GeV;
81 fMessenger = new G4HadronicParametersMesseng 81 fMessenger = new G4HadronicParametersMessenger( this );
82 82
83 // read environment variables 83 // read environment variables
84 fReportLevel = G4GetEnv<G4int>("G4Hadronic_e 84 fReportLevel = G4GetEnv<G4int>("G4Hadronic_epReportLevel", 0);
85 const char* ep1 = std::getenv("G4Hadronic_ep 85 const char* ep1 = std::getenv("G4Hadronic_epCheckRelativeLevel");
86 if(nullptr != ep1) { fRelativeDiff = std::st 86 if(nullptr != ep1) { fRelativeDiff = std::strtod(ep1, 0); }
87 const char* ep2 = std::getenv("G4Hadronic_ep 87 const char* ep2 = std::getenv("G4Hadronic_epCheckAbsoluteLevel");
88 if(nullptr != ep2) { fAbsoluteDiff = std::st 88 if(nullptr != ep2) { fAbsoluteDiff = std::strtod(ep2, 0); }
89 const char* v = G4FindDataDir("G4PARTICLEXSD 89 const char* v = G4FindDataDir("G4PARTICLEXSDATA");
90 if(nullptr != v) { 90 if(nullptr != v) {
91 fDirPARTICLEXS = G4String(v); 91 fDirPARTICLEXS = G4String(v);
92 } else { 92 } else {
93 if(1 < fVerboseLevel) { 93 if(1 < fVerboseLevel) {
94 G4ExceptionDescription ed; 94 G4ExceptionDescription ed;
95 ed << "Environment variable G4PARTICLEXS 95 ed << "Environment variable G4PARTICLEXSDATA is not defined or "
96 << " it is pointing out to not existi 96 << " it is pointing out to not existing directory";
97 G4Exception("G4LevelReader::LevelManager 97 G4Exception("G4LevelReader::LevelManager(..)","had014",
98 JustWarning, ed, "Check file path"); 98 JustWarning, ed, "Check file path");
99 } 99 }
100 } 100 }
101 const char* x = std::getenv("G4PhysListDocDi 101 const char* x = std::getenv("G4PhysListDocDir");
102 if(nullptr != x) { fPhysListDocDir = G4Strin 102 if(nullptr != x) { fPhysListDocDir = G4String(x); }
103 const char* y = std::getenv("G4PhysListName" 103 const char* y = std::getenv("G4PhysListName");
104 if(nullptr != y) { fPhysListName = G4String( 104 if(nullptr != y) { fPhysListName = G4String(y); }
105 const char* z = std::getenv("BINARY_CASCADE_ 105 const char* z = std::getenv("BINARY_CASCADE_DEBUG");
106 if(nullptr != z) { fBinaryDebug = true; } 106 if(nullptr != z) { fBinaryDebug = true; }
107 } 107 }
108 108
109 109
110 G4bool G4HadronicParameters::IsLocked() const 110 G4bool G4HadronicParameters::IsLocked() const {
111 return ( ! G4Threading::IsMasterThread() || 111 return ( ! G4Threading::IsMasterThread() ||
112 G4StateManager::GetStateManager()-> 112 G4StateManager::GetStateManager()->GetCurrentState() != G4State_PreInit );
113 } 113 }
114 114
115 115
116 void G4HadronicParameters::SetMaxEnergy( const 116 void G4HadronicParameters::SetMaxEnergy( const G4double val ) {
117 if ( ! IsLocked() && val > 0.0 ) { 117 if ( ! IsLocked() && val > 0.0 ) {
118 fMaxEnergy = val; 118 fMaxEnergy = val;
119 } 119 }
120 } 120 }
121 121
122 122
123 void G4HadronicParameters::SetMinEnergyTransit 123 void G4HadronicParameters::SetMinEnergyTransitionFTF_Cascade( const G4double val ) {
124 if ( ! IsLocked() && val > 0.0 ) { 124 if ( ! IsLocked() && val > 0.0 ) {
125 fMinEnergyTransitionFTF_Cascade = val; 125 fMinEnergyTransitionFTF_Cascade = val;
126 } 126 }
127 } 127 }
128 128
129 129
130 void G4HadronicParameters::SetMaxEnergyTransit 130 void G4HadronicParameters::SetMaxEnergyTransitionFTF_Cascade( const G4double val ) {
131 if ( ! IsLocked() && val > fMinEnergyTrans 131 if ( ! IsLocked() && val > fMinEnergyTransitionFTF_Cascade ) {
132 fMaxEnergyTransitionFTF_Cascade = val; 132 fMaxEnergyTransitionFTF_Cascade = val;
133 } 133 }
134 } 134 }
135 135
136 136
137 void G4HadronicParameters::SetMinEnergyTransit 137 void G4HadronicParameters::SetMinEnergyTransitionQGS_FTF( const G4double val ) {
138 if ( ! IsLocked() && val > 0.0 ) { 138 if ( ! IsLocked() && val > 0.0 ) {
139 fMinEnergyTransitionQGS_FTF = val; 139 fMinEnergyTransitionQGS_FTF = val;
140 } 140 }
141 } 141 }
142 142
143 void G4HadronicParameters::SetMaxEnergyTransit 143 void G4HadronicParameters::SetMaxEnergyTransitionQGS_FTF( const G4double val ) {
144 if ( ! IsLocked() && val > fMinEnergyTrans 144 if ( ! IsLocked() && val > fMinEnergyTransitionQGS_FTF ) {
145 fMaxEnergyTransitionQGS_FTF = val; 145 fMaxEnergyTransitionQGS_FTF = val;
146 } 146 }
147 } 147 }
148 148
149 void G4HadronicParameters::SetMinEnergyINCLXX_ 149 void G4HadronicParameters::SetMinEnergyINCLXX_Pbar( const G4double val ) {
150 if ( ! IsLocked() && val >= 0.0 ) { 150 if ( ! IsLocked() && val >= 0.0 ) {
151 fMinEnergyINCLXX_Pbar = val; 151 fMinEnergyINCLXX_Pbar = val;
152 } 152 }
153 } 153 }
154 154
155 155
156 void G4HadronicParameters::SetMaxEnergyINCLXX_ 156 void G4HadronicParameters::SetMaxEnergyINCLXX_Pbar( const G4double val ) {
157 if ( ! IsLocked() && val > fMinEnergyINCLX 157 if ( ! IsLocked() && val > fMinEnergyINCLXX_Pbar ) {
158 fMaxEnergyINCLXX_Pbar = val; 158 fMaxEnergyINCLXX_Pbar = val;
159 } 159 }
160 } 160 }
161 161
162 void G4HadronicParameters::SetEnableBCParticle 162 void G4HadronicParameters::SetEnableBCParticles( G4bool val ) {
163 if ( ! IsLocked() ) fEnableBC = val; 163 if ( ! IsLocked() ) fEnableBC = val;
164 } 164 }
165 165
166 166
167 void G4HadronicParameters::SetEnableHyperNucle 167 void G4HadronicParameters::SetEnableHyperNuclei( G4bool val ) {
168 if ( ! IsLocked() ) fEnableHyperNuclei = val 168 if ( ! IsLocked() ) fEnableHyperNuclei = val;
169 } 169 }
170 170
171 171
172 void G4HadronicParameters::SetVerboseLevel( co 172 void G4HadronicParameters::SetVerboseLevel( const G4int val ) {
173 if ( ! IsLocked() && val >= 0 ) fVerboseLe 173 if ( ! IsLocked() && val >= 0 ) fVerboseLevel = val;
174 } 174 }
175 175
176 176
177 void G4HadronicParameters::SetEnergyThresholdF 177 void G4HadronicParameters::SetEnergyThresholdForHeavyHadrons( G4double val ) {
178 if ( ! IsLocked() && val >= 0 && val < 5*C 178 if ( ! IsLocked() && val >= 0 && val < 5*CLHEP::GeV ) {
179 fEnergyThresholdForHeavyHadrons = val; 179 fEnergyThresholdForHeavyHadrons = val;
180 } 180 }
181 } 181 }
182 182
183 183
184 void G4HadronicParameters::SetXSFactorNucleonI 184 void G4HadronicParameters::SetXSFactorNucleonInelastic( G4double val ) {
185 if ( ! IsLocked() && std::abs(val - 1.0) < 185 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
186 fXSFactorNucleonInelastic = val; 186 fXSFactorNucleonInelastic = val;
187 } 187 }
188 } 188 }
189 189
190 190
191 void G4HadronicParameters::SetXSFactorNucleonE 191 void G4HadronicParameters::SetXSFactorNucleonElastic( G4double val ) {
192 if ( ! IsLocked() && std::abs(val - 1.0) < 192 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
193 fXSFactorNucleonElastic = val; 193 fXSFactorNucleonElastic = val;
194 } 194 }
195 } 195 }
196 196
197 197
198 void G4HadronicParameters::SetXSFactorPionInel 198 void G4HadronicParameters::SetXSFactorPionInelastic( G4double val ) {
199 if ( ! IsLocked() && std::abs(val - 1.0) < 199 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
200 fXSFactorPionInelastic = val; 200 fXSFactorPionInelastic = val;
201 } 201 }
202 } 202 }
203 203
204 204
205 void G4HadronicParameters::SetXSFactorPionElas 205 void G4HadronicParameters::SetXSFactorPionElastic( G4double val ) {
206 if ( ! IsLocked() && std::abs(val - 1.0) < 206 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
207 fXSFactorPionElastic = val; 207 fXSFactorPionElastic = val;
208 } 208 }
209 } 209 }
210 210
211 211
212 void G4HadronicParameters::SetXSFactorHadronIn 212 void G4HadronicParameters::SetXSFactorHadronInelastic( G4double val ) {
213 if ( ! IsLocked() && std::abs(val - 1.0) < 213 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
214 fXSFactorHadronInelastic = val; 214 fXSFactorHadronInelastic = val;
215 } 215 }
216 } 216 }
217 217
218 218
219 void G4HadronicParameters::SetXSFactorHadronEl 219 void G4HadronicParameters::SetXSFactorHadronElastic( G4double val ) {
220 if ( ! IsLocked() && std::abs(val - 1.0) < 220 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
221 fXSFactorHadronElastic = val; 221 fXSFactorHadronElastic = val;
222 } 222 }
223 } 223 }
224 224
225 225
226 void G4HadronicParameters::SetXSFactorEM( G4do 226 void G4HadronicParameters::SetXSFactorEM( G4double val ) {
227 if ( ! IsLocked() && std::abs(val - 1.0) < 227 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
228 fXSFactorEM = val; 228 fXSFactorEM = val;
229 } 229 }
230 } 230 }
231 231
232 232
233 void G4HadronicParameters::SetNeutronKineticEn 233 void G4HadronicParameters::SetNeutronKineticEnergyThresholdForSVT( const G4double val ) {
234 // This setting works only after initializat 234 // This setting works only after initialization (i.e. for G4State_Idle,
235 // whereas it does not work for G4State_PreI 235 // whereas it does not work for G4State_PreInit).
236 if ( G4Threading::IsMasterThread() && val 236 if ( G4Threading::IsMasterThread() && val > 0.0 ) {
237 fNeutronEkinThresholdForSVT = val; 237 fNeutronEkinThresholdForSVT = val;
238 } 238 }
239 } 239 }
240 240
241 241
242 void G4HadronicParameters::SetTimeThresholdFor 242 void G4HadronicParameters::SetTimeThresholdForRadioactiveDecay( const G4double val ) {
243 // This setting works only before initializa 243 // This setting works only before initialization
244 // (else, if used after initialization, it w 244 // (else, if used after initialization, it will be ignored).
245 if ( G4Threading::IsMasterThread() && val 245 if ( G4Threading::IsMasterThread() && val > 0.0 ) {
246 fTimeThresholdForRadioactiveDecays = val; 246 fTimeThresholdForRadioactiveDecays = val;
247 } 247 }
248 } 248 }
249 249
250 250
251 void G4HadronicParameters::SetApplyFactorXS( G 251 void G4HadronicParameters::SetApplyFactorXS( G4bool val ) {
252 if ( ! IsLocked() ) fApplyFactorXS = val; 252 if ( ! IsLocked() ) fApplyFactorXS = val;
253 } 253 }
254 254
255 255
256 void G4HadronicParameters::SetEnableCRCoalesce 256 void G4HadronicParameters::SetEnableCRCoalescence( G4bool val ) {
257 if ( ! IsLocked() ) fEnableCRCoalescence = v 257 if ( ! IsLocked() ) fEnableCRCoalescence = val;
258 } 258 }
259 259
260 260
261 void G4HadronicParameters::SetEnableIntegralIn 261 void G4HadronicParameters::SetEnableIntegralInelasticXS( G4bool val ) {
262 if ( ! IsLocked() ) fEnableIntegralInelastic 262 if ( ! IsLocked() ) fEnableIntegralInelasticXS = val;
263 } 263 }
264 264
265 265
266 void G4HadronicParameters::SetEnableIntegralEl 266 void G4HadronicParameters::SetEnableIntegralElasticXS( G4bool val ) {
267 if ( ! IsLocked() ) fEnableIntegralElasticXS 267 if ( ! IsLocked() ) fEnableIntegralElasticXS = val;
268 } 268 }
269 269
270 270
271 void G4HadronicParameters::SetEnableDiffDissoc 271 void G4HadronicParameters::SetEnableDiffDissociationForBGreater10( G4bool val ) {
272 if ( ! IsLocked() ) fEnableDiffDissociationF 272 if ( ! IsLocked() ) fEnableDiffDissociationForBGreater10 = val;
273 } 273 }
274 274
275 275
276 void G4HadronicParameters::SetEnableNeutronGen 276 void G4HadronicParameters::SetEnableNeutronGeneralProcess( G4bool val ) {
277 if ( ! IsLocked() ) fNeutronGeneral = val; 277 if ( ! IsLocked() ) fNeutronGeneral = val;
278 } 278 }
279 279
280 280
281 void G4HadronicParameters::SetEnableNUDEX( G4b <<
282 if ( ! IsLocked() ) fEnableNUDEX = val; <<
283 } <<
284 <<
285 <<
286 void G4HadronicParameters::SetTypeTablePT( con <<
287 if ( ! IsLocked() ) fTypeTablePT = typeTable <<
288 } <<
289 <<
290 <<
291 void G4HadronicParameters::SetEnableCoherentCh 281 void G4HadronicParameters::SetEnableCoherentChargeExchange( G4bool val ) {
292 if ( ! IsLocked() ) fChargeExchange = val; 282 if ( ! IsLocked() ) fChargeExchange = val;
293 } 283 }
294 284