| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 //
27 //---------------------------------------------------------------------------
28 //
29 // ClassName: G4HadronicParameters
30 //
31 // Author: 2018 Alberto Ribon
32 //
33 // Description: Singleton to keep global hadronic parameters.
34 //
35 // Modified:
36 //
37 //----------------------------------------------------------------------------
38
39 #include "G4HadronicParameters.hh"
40 #include <CLHEP/Units/PhysicalConstants.h>
41 #include "G4ApplicationState.hh"
42 #include "G4StateManager.hh"
43 #include "G4HadronicParametersMessenger.hh"
44 #include "G4Threading.hh"
45 #include "G4AutoLock.hh"
46
47 G4HadronicParameters* G4HadronicParameters::sInstance = nullptr;
48
49 namespace
50 {
51 G4Mutex paramMutex = G4MUTEX_INITIALIZER;
52 }
53
54 G4HadronicParameters* G4HadronicParameters::Instance() {
55 if ( sInstance == nullptr ) {
56 G4AutoLock l(¶mMutex);
57 if ( sInstance == nullptr ) {
58 static G4HadronicParameters theHadronicParametersObject;
59 sInstance = &theHadronicParametersObject;
60 }
61 l.unlock();
62 }
63 return sInstance;
64 }
65
66
67 G4HadronicParameters::~G4HadronicParameters() {
68 delete fMessenger;
69 }
70
71
72 G4HadronicParameters::G4HadronicParameters() {
73 fMaxEnergy = 100.0*CLHEP::TeV;
74 fMinEnergyTransitionFTF_Cascade = 3.0*CLHEP::GeV;
75 fMaxEnergyTransitionFTF_Cascade = 6.0*CLHEP::GeV;
76 fMinEnergyTransitionQGS_FTF = 12.0*CLHEP::GeV;
77 fMaxEnergyTransitionQGS_FTF = 25.0*CLHEP::GeV;
78 fMinEnergyINCLXX_Pbar = 0.0*CLHEP::GeV;
79 fMaxEnergyINCLXX_Pbar = 10.0*CLHEP::GeV;
80 fEnergyThresholdForHeavyHadrons = 1.1*CLHEP::GeV;
81 fMessenger = new G4HadronicParametersMessenger( this );
82
83 // read environment variables
84 fReportLevel = G4GetEnv<G4int>("G4Hadronic_epReportLevel", 0);
85 const char* ep1 = std::getenv("G4Hadronic_epCheckRelativeLevel");
86 if(nullptr != ep1) { fRelativeDiff = std::strtod(ep1, 0); }
87 const char* ep2 = std::getenv("G4Hadronic_epCheckAbsoluteLevel");
88 if(nullptr != ep2) { fAbsoluteDiff = std::strtod(ep2, 0); }
89 const char* v = G4FindDataDir("G4PARTICLEXSDATA");
90 if(nullptr != v) {
91 fDirPARTICLEXS = G4String(v);
92 } else {
93 if(1 < fVerboseLevel) {
94 G4ExceptionDescription ed;
95 ed << "Environment variable G4PARTICLEXSDATA is not defined or "
96 << " it is pointing out to not existing directory";
97 G4Exception("G4LevelReader::LevelManager(..)","had014",
98 JustWarning, ed, "Check file path");
99 }
100 }
101 const char* x = std::getenv("G4PhysListDocDir");
102 if(nullptr != x) { fPhysListDocDir = G4String(x); }
103 const char* y = std::getenv("G4PhysListName");
104 if(nullptr != y) { fPhysListName = G4String(y); }
105 const char* z = std::getenv("BINARY_CASCADE_DEBUG");
106 if(nullptr != z) { fBinaryDebug = true; }
107 }
108
109
110 G4bool G4HadronicParameters::IsLocked() const {
111 return ( ! G4Threading::IsMasterThread() ||
112 G4StateManager::GetStateManager()->GetCurrentState() != G4State_PreInit );
113 }
114
115
116 void G4HadronicParameters::SetMaxEnergy( const G4double val ) {
117 if ( ! IsLocked() && val > 0.0 ) {
118 fMaxEnergy = val;
119 }
120 }
121
122
123 void G4HadronicParameters::SetMinEnergyTransitionFTF_Cascade( const G4double val ) {
124 if ( ! IsLocked() && val > 0.0 ) {
125 fMinEnergyTransitionFTF_Cascade = val;
126 }
127 }
128
129
130 void G4HadronicParameters::SetMaxEnergyTransitionFTF_Cascade( const G4double val ) {
131 if ( ! IsLocked() && val > fMinEnergyTransitionFTF_Cascade ) {
132 fMaxEnergyTransitionFTF_Cascade = val;
133 }
134 }
135
136
137 void G4HadronicParameters::SetMinEnergyTransitionQGS_FTF( const G4double val ) {
138 if ( ! IsLocked() && val > 0.0 ) {
139 fMinEnergyTransitionQGS_FTF = val;
140 }
141 }
142
143 void G4HadronicParameters::SetMaxEnergyTransitionQGS_FTF( const G4double val ) {
144 if ( ! IsLocked() && val > fMinEnergyTransitionQGS_FTF ) {
145 fMaxEnergyTransitionQGS_FTF = val;
146 }
147 }
148
149 void G4HadronicParameters::SetMinEnergyINCLXX_Pbar( const G4double val ) {
150 if ( ! IsLocked() && val >= 0.0 ) {
151 fMinEnergyINCLXX_Pbar = val;
152 }
153 }
154
155
156 void G4HadronicParameters::SetMaxEnergyINCLXX_Pbar( const G4double val ) {
157 if ( ! IsLocked() && val > fMinEnergyINCLXX_Pbar ) {
158 fMaxEnergyINCLXX_Pbar = val;
159 }
160 }
161
162 void G4HadronicParameters::SetEnableBCParticles( G4bool val ) {
163 if ( ! IsLocked() ) fEnableBC = val;
164 }
165
166
167 void G4HadronicParameters::SetEnableHyperNuclei( G4bool val ) {
168 if ( ! IsLocked() ) fEnableHyperNuclei = val;
169 }
170
171
172 void G4HadronicParameters::SetVerboseLevel( const G4int val ) {
173 if ( ! IsLocked() && val >= 0 ) fVerboseLevel = val;
174 }
175
176
177 void G4HadronicParameters::SetEnergyThresholdForHeavyHadrons( G4double val ) {
178 if ( ! IsLocked() && val >= 0 && val < 5*CLHEP::GeV ) {
179 fEnergyThresholdForHeavyHadrons = val;
180 }
181 }
182
183
184 void G4HadronicParameters::SetXSFactorNucleonInelastic( G4double val ) {
185 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
186 fXSFactorNucleonInelastic = val;
187 }
188 }
189
190
191 void G4HadronicParameters::SetXSFactorNucleonElastic( G4double val ) {
192 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
193 fXSFactorNucleonElastic = val;
194 }
195 }
196
197
198 void G4HadronicParameters::SetXSFactorPionInelastic( G4double val ) {
199 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
200 fXSFactorPionInelastic = val;
201 }
202 }
203
204
205 void G4HadronicParameters::SetXSFactorPionElastic( G4double val ) {
206 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
207 fXSFactorPionElastic = val;
208 }
209 }
210
211
212 void G4HadronicParameters::SetXSFactorHadronInelastic( G4double val ) {
213 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
214 fXSFactorHadronInelastic = val;
215 }
216 }
217
218
219 void G4HadronicParameters::SetXSFactorHadronElastic( G4double val ) {
220 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
221 fXSFactorHadronElastic = val;
222 }
223 }
224
225
226 void G4HadronicParameters::SetXSFactorEM( G4double val ) {
227 if ( ! IsLocked() && std::abs(val - 1.0) < fXSFactorLimit ) {
228 fXSFactorEM = val;
229 }
230 }
231
232
233 void G4HadronicParameters::SetNeutronKineticEnergyThresholdForSVT( const G4double val ) {
234 // This setting works only after initialization (i.e. for G4State_Idle,
235 // whereas it does not work for G4State_PreInit).
236 if ( G4Threading::IsMasterThread() && val > 0.0 ) {
237 fNeutronEkinThresholdForSVT = val;
238 }
239 }
240
241
242 void G4HadronicParameters::SetTimeThresholdForRadioactiveDecay( const G4double val ) {
243 // This setting works only before initialization
244 // (else, if used after initialization, it will be ignored).
245 if ( G4Threading::IsMasterThread() && val > 0.0 ) {
246 fTimeThresholdForRadioactiveDecays = val;
247 }
248 }
249
250
251 void G4HadronicParameters::SetApplyFactorXS( G4bool val ) {
252 if ( ! IsLocked() ) fApplyFactorXS = val;
253 }
254
255
256 void G4HadronicParameters::SetEnableCRCoalescence( G4bool val ) {
257 if ( ! IsLocked() ) fEnableCRCoalescence = val;
258 }
259
260
261 void G4HadronicParameters::SetEnableIntegralInelasticXS( G4bool val ) {
262 if ( ! IsLocked() ) fEnableIntegralInelasticXS = val;
263 }
264
265
266 void G4HadronicParameters::SetEnableIntegralElasticXS( G4bool val ) {
267 if ( ! IsLocked() ) fEnableIntegralElasticXS = val;
268 }
269
270
271 void G4HadronicParameters::SetEnableDiffDissociationForBGreater10( G4bool val ) {
272 if ( ! IsLocked() ) fEnableDiffDissociationForBGreater10 = val;
273 }
274
275
276 void G4HadronicParameters::SetEnableNeutronGeneralProcess( G4bool val ) {
277 if ( ! IsLocked() ) fNeutronGeneral = val;
278 }
279
280
281 void G4HadronicParameters::SetEnableNUDEX( G4bool val ) {
282 if ( ! IsLocked() ) fEnableNUDEX = val;
283 }
284
285
286 void G4HadronicParameters::SetTypeTablePT( const G4String& typeTablePT ) {
287 if ( ! IsLocked() ) fTypeTablePT = typeTablePT;
288 }
289
290
291 void G4HadronicParameters::SetEnableCoherentChargeExchange( G4bool val ) {
292 if ( ! IsLocked() ) fChargeExchange = val;
293 }
294