| 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 // 15.03.2016 V.Ivanchenko 26 // 15.03.2016 V.Ivanchenko
27 // 27 //
28 // List of parameters of the pre-compound mode 28 // List of parameters of the pre-compound model
29 // and the deexcitation module 29 // and the deexcitation module
30 // 30 //
31 31
32 #include "G4DeexPrecoParameters.hh" 32 #include "G4DeexPrecoParameters.hh"
33 #include "G4ApplicationState.hh" 33 #include "G4ApplicationState.hh"
34 #include "G4StateManager.hh" 34 #include "G4StateManager.hh"
35 #include "G4SystemOfUnits.hh" 35 #include "G4SystemOfUnits.hh"
36 #include "G4UnitsTable.hh" <<
37 #include "G4PhysicsModelCatalog.hh" 36 #include "G4PhysicsModelCatalog.hh"
38 #include "G4DeexParametersMessenger.hh" 37 #include "G4DeexParametersMessenger.hh"
39 #include "G4HadronicParameters.hh" 38 #include "G4HadronicParameters.hh"
40 #include "G4Threading.hh" << 39
>> 40 #ifdef G4MULTITHREADED
>> 41 G4Mutex G4DeexPrecoParameters::deexPrecoMutex = G4MUTEX_INITIALIZER;
>> 42 #endif
41 43
42 G4DeexPrecoParameters::G4DeexPrecoParameters() 44 G4DeexPrecoParameters::G4DeexPrecoParameters()
43 { 45 {
44 fStateManager = G4StateManager::GetStateMana << 46 SetDefaults();
45 theMessenger = new G4DeexParametersMessenger <<
46 Initialise(); <<
47 } 47 }
48 48
49 G4DeexPrecoParameters::~G4DeexPrecoParameters( 49 G4DeexPrecoParameters::~G4DeexPrecoParameters()
50 { 50 {
51 delete theMessenger; 51 delete theMessenger;
52 } 52 }
53 53
54 void G4DeexPrecoParameters::SetDefaults() 54 void G4DeexPrecoParameters::SetDefaults()
55 { 55 {
56 if(!IsLocked()) { Initialise(); } << 56 #ifdef G4MULTITHREADED
57 } << 57 G4MUTEXLOCK(&G4DeexPrecoParameters::deexPrecoMutex);
>> 58 #endif
>> 59 fStateManager = G4StateManager::GetStateManager();
>> 60 theMessenger = new G4DeexParametersMessenger(this);
58 61
59 void G4DeexPrecoParameters::Initialise() <<
60 { <<
61 // common parameters <<
62 fVerbose = 1; <<
63 fLevelDensity = 0.075/CLHEP::MeV; 62 fLevelDensity = 0.075/CLHEP::MeV;
64 fR0 = 1.5*CLHEP::fermi; 63 fR0 = 1.5*CLHEP::fermi;
65 fTransitionsR0 = 0.6*CLHEP::fermi; 64 fTransitionsR0 = 0.6*CLHEP::fermi;
66 << 65 fFBUEnergyLimit = 20.0*CLHEP::MeV;
67 // preco parameters << 66 fFermiEnergy = 35.0*CLHEP::MeV;
68 fPrecoLowEnergy = 0.1*CLHEP::MeV; 67 fPrecoLowEnergy = 0.1*CLHEP::MeV;
69 fPrecoHighEnergy = 30*CLHEP::MeV; 68 fPrecoHighEnergy = 30*CLHEP::MeV;
70 fPhenoFactor = 1.0; << 69 fPhenoFactor = 1.0;
71 << 70 fMinExcitation = 10*CLHEP::eV;
72 fPrecoType = 1; << 71 fMaxLifeTime = 1*CLHEP::nanosecond;
>> 72 fMinExPerNucleounForMF = 200*CLHEP::GeV;
73 fMinZForPreco = 3; 73 fMinZForPreco = 3;
74 fMinAForPreco = 5; 74 fMinAForPreco = 5;
75 << 75 fPrecoType = 3;
>> 76 fDeexType = 3;
>> 77 fTwoJMAX = 10;
>> 78 fVerbose = 1;
76 fNeverGoBack = false; 79 fNeverGoBack = false;
77 fUseSoftCutoff = false; 80 fUseSoftCutoff = false;
78 fUseCEM = true; 81 fUseCEM = true;
79 fUseGNASH = false; 82 fUseGNASH = false;
80 fUseHETC = false; 83 fUseHETC = false;
81 fUseAngularGen = true; << 84 fUseAngularGen = false;
82 fPrecoDummy = false; 85 fPrecoDummy = false;
83 <<
84 // de-exitation parameters <<
85 fMinExcitation = 10*CLHEP::eV; <<
86 fNuclearLevelWidth = 0.2*CLHEP::MeV; <<
87 fFBUEnergyLimit = 20.0*CLHEP::MeV; <<
88 fFermiEnergy = 35.0*CLHEP::MeV; <<
89 fMaxLifeTime = 1*CLHEP::nanosecond; <<
90 fMinExPerNucleounForMF = 200*CLHEP::GeV; <<
91 <<
92 fDeexChannelType = fCombined; <<
93 fDeexType = 3; <<
94 fTwoJMAX = 10; <<
95 <<
96 fCorrelatedGamma = false; 86 fCorrelatedGamma = false;
97 fStoreAllLevels = true; << 87 fStoreAllLevels = false;
98 fInternalConversion = true; 88 fInternalConversion = true;
99 fLD = true; // use simple level density mod << 89 fLD = true;
100 fFD = false; // use transition to discrete l << 90 fFD = false;
101 fIsomerFlag = true; // enable isomere produc << 91 fIsomerFlag = true;
>> 92 fDeexChannelType = fCombined;
>> 93 #ifdef G4MULTITHREADED
>> 94 G4MUTEXUNLOCK(&G4DeexPrecoParameters::deexPrecoMutex);
>> 95 #endif
102 } 96 }
103 97
104 void G4DeexPrecoParameters::SetLevelDensity(G4 98 void G4DeexPrecoParameters::SetLevelDensity(G4double val)
105 { 99 {
106 if(IsLocked() || val <= 0.0) { return; } 100 if(IsLocked() || val <= 0.0) { return; }
107 fLevelDensity = val/CLHEP::MeV; 101 fLevelDensity = val/CLHEP::MeV;
108 } 102 }
109 103
110 void G4DeexPrecoParameters::SetR0(G4double val 104 void G4DeexPrecoParameters::SetR0(G4double val)
111 { 105 {
112 if(IsLocked() || val <= 0.0) { return; } 106 if(IsLocked() || val <= 0.0) { return; }
113 fR0 = val; 107 fR0 = val;
114 } 108 }
115 109
116 void G4DeexPrecoParameters::SetTransitionsR0(G 110 void G4DeexPrecoParameters::SetTransitionsR0(G4double val)
117 { 111 {
118 if(IsLocked() || val <= 0.0) { return; } 112 if(IsLocked() || val <= 0.0) { return; }
119 fTransitionsR0 = val; 113 fTransitionsR0 = val;
120 } 114 }
121 115
122 void G4DeexPrecoParameters::SetFBUEnergyLimit( 116 void G4DeexPrecoParameters::SetFBUEnergyLimit(G4double val)
123 { 117 {
124 if(IsLocked() || val <= 0.0) { return; } 118 if(IsLocked() || val <= 0.0) { return; }
125 fFBUEnergyLimit = val; 119 fFBUEnergyLimit = val;
126 } 120 }
127 121
128 void G4DeexPrecoParameters::SetFermiEnergy(G4d 122 void G4DeexPrecoParameters::SetFermiEnergy(G4double val)
129 { 123 {
130 if(IsLocked() || val <= 0.0) { return; } 124 if(IsLocked() || val <= 0.0) { return; }
131 fFermiEnergy = val; 125 fFermiEnergy = val;
132 } 126 }
133 127
134 void G4DeexPrecoParameters::SetPrecoLowEnergy( 128 void G4DeexPrecoParameters::SetPrecoLowEnergy(G4double val)
135 { 129 {
136 if(IsLocked() || val < 0.0) { return; } 130 if(IsLocked() || val < 0.0) { return; }
137 fPrecoLowEnergy = val; 131 fPrecoLowEnergy = val;
138 } 132 }
139 133
140 void G4DeexPrecoParameters::SetPrecoHighEnergy 134 void G4DeexPrecoParameters::SetPrecoHighEnergy(G4double val)
141 { 135 {
142 if(IsLocked() || val < 0.0) { return; } 136 if(IsLocked() || val < 0.0) { return; }
143 fPrecoHighEnergy = val; 137 fPrecoHighEnergy = val;
144 } 138 }
145 139
146 void G4DeexPrecoParameters::SetPhenoFactor(G4d 140 void G4DeexPrecoParameters::SetPhenoFactor(G4double val)
147 { 141 {
148 if(IsLocked() || val <= 0.0) { return; } 142 if(IsLocked() || val <= 0.0) { return; }
149 fPhenoFactor = val; 143 fPhenoFactor = val;
150 } 144 }
151 145
152 void G4DeexPrecoParameters::SetMinExcitation(G 146 void G4DeexPrecoParameters::SetMinExcitation(G4double val)
153 { 147 {
154 if(IsLocked() || val < 0.0) { return; } 148 if(IsLocked() || val < 0.0) { return; }
155 fMinExcitation = val; 149 fMinExcitation = val;
156 } 150 }
157 151
158 void G4DeexPrecoParameters::SetNuclearLevelWid <<
159 { <<
160 if(IsLocked() || val < 0.0) { return; } <<
161 fNuclearLevelWidth = val; <<
162 } <<
163 <<
164 void G4DeexPrecoParameters::SetMaxLifeTime(G4d 152 void G4DeexPrecoParameters::SetMaxLifeTime(G4double val)
165 { 153 {
166 if(IsLocked() || val < 0.0) { return; } 154 if(IsLocked() || val < 0.0) { return; }
167 fMaxLifeTime = val; 155 fMaxLifeTime = val;
168 } 156 }
169 157
170 void G4DeexPrecoParameters::SetMinExPerNucleou 158 void G4DeexPrecoParameters::SetMinExPerNucleounForMF(G4double val)
171 { 159 {
172 if(IsLocked() || val < 0.0) { return; } 160 if(IsLocked() || val < 0.0) { return; }
173 fMinExPerNucleounForMF = val; 161 fMinExPerNucleounForMF = val;
174 } 162 }
175 163
176 void G4DeexPrecoParameters::SetMinZForPreco(G4 164 void G4DeexPrecoParameters::SetMinZForPreco(G4int n)
177 { 165 {
178 if(IsLocked() || n < 2) { return; } 166 if(IsLocked() || n < 2) { return; }
179 fMinZForPreco = n; 167 fMinZForPreco = n;
180 } 168 }
181 169
182 void G4DeexPrecoParameters::SetMinAForPreco(G4 170 void G4DeexPrecoParameters::SetMinAForPreco(G4int n)
183 { 171 {
184 if(IsLocked() || n < 0) { return; } 172 if(IsLocked() || n < 0) { return; }
185 fMinAForPreco = n; 173 fMinAForPreco = n;
186 } 174 }
187 175
188 void G4DeexPrecoParameters::SetPrecoModelType( 176 void G4DeexPrecoParameters::SetPrecoModelType(G4int n)
189 { 177 {
190 if(IsLocked() || n < 0 || n > 3) { return; } 178 if(IsLocked() || n < 0 || n > 3) { return; }
191 fPrecoType = n; 179 fPrecoType = n;
192 } 180 }
193 181
194 void G4DeexPrecoParameters::SetDeexModelType(G 182 void G4DeexPrecoParameters::SetDeexModelType(G4int n)
195 { 183 {
196 if(IsLocked() || n < 0 || n > 3) { return; } 184 if(IsLocked() || n < 0 || n > 3) { return; }
197 fDeexType = n; 185 fDeexType = n;
198 } 186 }
199 187
200 void G4DeexPrecoParameters::SetTwoJMAX(G4int n 188 void G4DeexPrecoParameters::SetTwoJMAX(G4int n)
201 { 189 {
202 if(IsLocked() || n < 0) { return; } 190 if(IsLocked() || n < 0) { return; }
203 fTwoJMAX = n; 191 fTwoJMAX = n;
204 } 192 }
205 193
206 void G4DeexPrecoParameters::SetVerbose(G4int n 194 void G4DeexPrecoParameters::SetVerbose(G4int n)
207 { 195 {
208 if(IsLocked()) { return; } 196 if(IsLocked()) { return; }
209 fVerbose = n; 197 fVerbose = n;
210 } 198 }
211 199
212 void G4DeexPrecoParameters::SetNeverGoBack(G4b 200 void G4DeexPrecoParameters::SetNeverGoBack(G4bool val)
213 { 201 {
214 if(IsLocked()) { return; } 202 if(IsLocked()) { return; }
215 fNeverGoBack = val; 203 fNeverGoBack = val;
216 } 204 }
217 205
218 void G4DeexPrecoParameters::SetUseSoftCutoff(G 206 void G4DeexPrecoParameters::SetUseSoftCutoff(G4bool val)
219 { 207 {
220 if(IsLocked()) { return; } 208 if(IsLocked()) { return; }
221 fUseSoftCutoff = val; 209 fUseSoftCutoff = val;
222 } 210 }
223 211
224 void G4DeexPrecoParameters::SetUseCEM(G4bool v 212 void G4DeexPrecoParameters::SetUseCEM(G4bool val)
225 { 213 {
226 if(IsLocked()) { return; } 214 if(IsLocked()) { return; }
227 fUseCEM = val; 215 fUseCEM = val;
228 } 216 }
229 217
230 void G4DeexPrecoParameters::SetUseGNASH(G4bool 218 void G4DeexPrecoParameters::SetUseGNASH(G4bool val)
231 { 219 {
232 if(IsLocked()) { return; } 220 if(IsLocked()) { return; }
233 fUseGNASH = val; 221 fUseGNASH = val;
234 } 222 }
235 223
236 void G4DeexPrecoParameters::SetUseHETC(G4bool 224 void G4DeexPrecoParameters::SetUseHETC(G4bool val)
237 { 225 {
238 if(IsLocked()) { return; } 226 if(IsLocked()) { return; }
239 fUseHETC = val; 227 fUseHETC = val;
240 } 228 }
241 229
242 void G4DeexPrecoParameters::SetUseAngularGen(G 230 void G4DeexPrecoParameters::SetUseAngularGen(G4bool val)
243 { 231 {
244 if(IsLocked()) { return; } 232 if(IsLocked()) { return; }
245 fUseAngularGen = val; 233 fUseAngularGen = val;
246 } 234 }
247 235
248 void G4DeexPrecoParameters::SetPrecoDummy(G4bo 236 void G4DeexPrecoParameters::SetPrecoDummy(G4bool val)
249 { 237 {
250 if(IsLocked()) { return; } 238 if(IsLocked()) { return; }
251 fPrecoDummy = val; 239 fPrecoDummy = val;
252 fDeexChannelType = fDummy; 240 fDeexChannelType = fDummy;
253 } 241 }
254 242
255 void G4DeexPrecoParameters::SetCorrelatedGamma 243 void G4DeexPrecoParameters::SetCorrelatedGamma(G4bool val)
256 { 244 {
257 if(IsLocked()) { return; } 245 if(IsLocked()) { return; }
258 fCorrelatedGamma = val; 246 fCorrelatedGamma = val;
259 } 247 }
260 248
261 void G4DeexPrecoParameters::SetStoreICLevelDat 249 void G4DeexPrecoParameters::SetStoreICLevelData(G4bool val)
262 { 250 {
263 if(IsLocked()) { return; } 251 if(IsLocked()) { return; }
264 fStoreAllLevels = val; 252 fStoreAllLevels = val;
265 } 253 }
266 254
267 void G4DeexPrecoParameters::SetStoreAllLevels( 255 void G4DeexPrecoParameters::SetStoreAllLevels(G4bool val)
268 { 256 {
269 SetStoreICLevelData(val); 257 SetStoreICLevelData(val);
270 } 258 }
271 259
272 void G4DeexPrecoParameters::SetInternalConvers 260 void G4DeexPrecoParameters::SetInternalConversionFlag(G4bool val)
273 { 261 {
274 if(IsLocked()) { return; } 262 if(IsLocked()) { return; }
275 fInternalConversion = val; 263 fInternalConversion = val;
276 } 264 }
277 265
278 void G4DeexPrecoParameters::SetLevelDensityFla 266 void G4DeexPrecoParameters::SetLevelDensityFlag(G4bool val)
279 { 267 {
280 if(IsLocked()) { return; } 268 if(IsLocked()) { return; }
281 fLD = val; 269 fLD = val;
282 } 270 }
283 271
284 void G4DeexPrecoParameters::SetDiscreteExcitat 272 void G4DeexPrecoParameters::SetDiscreteExcitationFlag(G4bool val)
285 { 273 {
286 if(IsLocked()) { return; } 274 if(IsLocked()) { return; }
287 fFD = val; 275 fFD = val;
288 } 276 }
289 277
290 void G4DeexPrecoParameters::SetIsomerProductio 278 void G4DeexPrecoParameters::SetIsomerProduction(G4bool val)
291 { 279 {
292 if(IsLocked()) { return; } 280 if(IsLocked()) { return; }
293 fIsomerFlag = val; 281 fIsomerFlag = val;
294 } 282 }
295 283
296 void G4DeexPrecoParameters::SetDeexChannelsTyp 284 void G4DeexPrecoParameters::SetDeexChannelsType(G4DeexChannelType val)
297 { 285 {
298 if(IsLocked()) { return; } 286 if(IsLocked()) { return; }
299 fDeexChannelType = val; 287 fDeexChannelType = val;
300 } 288 }
301 289
302 std::ostream& G4DeexPrecoParameters::StreamInf 290 std::ostream& G4DeexPrecoParameters::StreamInfo(std::ostream& os) const
303 { 291 {
304 static const G4String namm[5] = {"Evaporatio 292 static const G4String namm[5] = {"Evaporation","GEM","Evaporation+GEM","GEMVI","Dummy"};
305 static const G4int nmm[5] = {8, 68, 68, 31, 293 static const G4int nmm[5] = {8, 68, 68, 31, 0};
306 G4int idx = fDeexChannelType; << 294 size_t idx = (size_t)fDeexChannelType;
307 295
308 G4long prec = os.precision(5); << 296 G4int prec = os.precision(5);
309 os << "===================================== 297 os << "=======================================================================" << "\n";
310 os << "====== Geant4 Native Pre-compou << 298 os << "====== Pre-compound/De-excitation Physics Parameters ========" << "\n";
311 os << "===================================== 299 os << "=======================================================================" << "\n";
312 os << "Type of pre-compound inverse x-sectio 300 os << "Type of pre-compound inverse x-section " << fPrecoType << "\n";
313 os << "Pre-compound model active 301 os << "Pre-compound model active " << (!fPrecoDummy) << "\n";
314 os << "Pre-compound excitation low energy << 302 os << "Pre-compound excitation low energy (MeV) "
315 << G4BestUnit(fPrecoLowEnergy, "Energy") << 303 << fPrecoLowEnergy/CLHEP::MeV << "\n";
316 os << "Pre-compound excitation high energy << 304 os << "Pre-compound excitation high energy (MeV) "
317 << G4BestUnit(fPrecoHighEnergy, "Energy") << 305 << fPrecoHighEnergy/CLHEP::MeV << "\n";
318 os << "Angular generator for pre-compound mo <<
319 os << "Use NeverGoBack option for pre-compou <<
320 os << "Use SoftCutOff option for pre-compoun <<
321 os << "Use CEM transitions for pre-compound <<
322 os << "Use GNASH transitions for pre-compoun <<
323 os << "Use HETC submodel for pre-compound mo <<
324 os << "===================================== <<
325 os << "====== Nuclear De-excitation Mo <<
326 os << "===================================== <<
327 os << "Type of de-excitation inverse x-secti 306 os << "Type of de-excitation inverse x-section " << fDeexType << "\n";
328 os << "Type of de-excitation factory 307 os << "Type of de-excitation factory " << namm[idx] << "\n";
329 os << "Number of de-excitation channels 308 os << "Number of de-excitation channels " << nmm[idx] << "\n";
330 os << "Min excitation energy << 309 os << "Min excitation energy (keV) "
331 << G4BestUnit(fMinExcitation, "Energy") < << 310 << fMinExcitation/CLHEP::keV << "\n";
332 os << "Min energy per nucleon for multifragm << 311 os << "Min energy per nucleon for multifragmentation (MeV) "
333 << G4BestUnit(fMinExPerNucleounForMF, "En << 312 << fMinExPerNucleounForMF/CLHEP::MeV << "\n";
334 os << "Limit excitation energy for Fermi Bre << 313 os << "Limit excitation energy for Fermi BreakUp (MeV) "
335 << G4BestUnit(fFBUEnergyLimit, "Energy") << 314 << fFBUEnergyLimit/CLHEP::MeV << "\n";
336 os << "Level density (1/MeV) 315 os << "Level density (1/MeV) "
337 << fLevelDensity*CLHEP::MeV << "\n"; 316 << fLevelDensity*CLHEP::MeV << "\n";
338 os << "Use simple level density model 317 os << "Use simple level density model " << fLD << "\n";
339 os << "Use discrete excitation energy of the 318 os << "Use discrete excitation energy of the residual " << fFD << "\n";
340 os << "Time limit for long lived isomeres << 319 os << "Time limit for long lived isomeres (ns) "
341 << G4BestUnit(fMaxLifeTime, "Time") << "\ << 320 << fMaxLifeTime/CLHEP::ns << "\n";
342 os << "Isomer production flag 321 os << "Isomer production flag " << fIsomerFlag << "\n";
343 os << "Internal e- conversion flag 322 os << "Internal e- conversion flag "
344 << fInternalConversion << "\n"; 323 << fInternalConversion << "\n";
345 os << "Store e- internal conversion data 324 os << "Store e- internal conversion data " << fStoreAllLevels << "\n";
346 os << "Correlated gamma emission flag 325 os << "Correlated gamma emission flag " << fCorrelatedGamma << "\n";
347 os << "Max 2J for sampling of angular correl << 326 os << "Max 2J for sampling of angular correlations " << fTwoJMAX << "\n";
348 os << "===================================== 327 os << "=======================================================================" << G4endl;
349 os.precision(prec); 328 os.precision(prec);
350 return os; 329 return os;
351 } 330 }
352 331
353 G4int G4DeexPrecoParameters::GetVerbose() cons 332 G4int G4DeexPrecoParameters::GetVerbose() const
354 { 333 {
355 G4int verb = G4HadronicParameters::Instance( 334 G4int verb = G4HadronicParameters::Instance()->GetVerboseLevel();
356 return (verb > 0) ? std::max(fVerbose, verb) 335 return (verb > 0) ? std::max(fVerbose, verb) : verb;
357 } 336 }
358 337
359 void G4DeexPrecoParameters::Dump() << 338 void G4DeexPrecoParameters::Dump() const
360 { 339 {
361 if(!fIsPrinted && GetVerbose() > 0 && G4Thre << 340 if ( G4Threading::IsMasterThread() && GetVerbose() > 0 ) { StreamInfo(G4cout); }
362 StreamInfo(G4cout); <<
363 fIsPrinted = true; <<
364 } <<
365 } 341 }
366 342
367 std::ostream& operator<< (std::ostream& os, co 343 std::ostream& operator<< (std::ostream& os, const G4DeexPrecoParameters& par)
368 { 344 {
369 return par.StreamInfo(os); 345 return par.StreamInfo(os);
370 } 346 }
371 347
372 G4bool G4DeexPrecoParameters::IsLocked() const 348 G4bool G4DeexPrecoParameters::IsLocked() const
373 { 349 {
374 return (!G4Threading::IsMasterThread() || 350 return (!G4Threading::IsMasterThread() ||
375 (fStateManager->GetCurrentState() != G4Sta 351 (fStateManager->GetCurrentState() != G4State_PreInit));
376 } 352 }
377 353