| 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 // $Id: G4LossTableManager.cc,v 1.105 2010-11-04 12:55:09 vnivanch Exp $
>> 27 // GEANT4 tag $Name: not supported by cvs2svn $
>> 28 //
26 // ------------------------------------------- 29 // -------------------------------------------------------------------
27 // 30 //
28 // GEANT4 Class file 31 // GEANT4 Class file
29 // 32 //
30 // 33 //
31 // File name: G4LossTableManager 34 // File name: G4LossTableManager
32 // 35 //
33 // Author: Vladimir Ivanchenko 36 // Author: Vladimir Ivanchenko
34 // 37 //
35 // Creation date: 03.01.2002 38 // Creation date: 03.01.2002
36 // 39 //
37 // Modifications: by V.Ivanchenko << 40 // Modifications:
38 // 41 //
>> 42 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
>> 43 // 15-02-03 Lambda table can be scaled (V.Ivanchenko)
>> 44 // 17-02-03 Fix problem of store/restore tables (V.Ivanchenko)
>> 45 // 10-03-03 Add Ion registration (V.Ivanchenko)
>> 46 // 25-03-03 Add deregistration (V.Ivanchenko)
>> 47 // 02-04-03 Change messenger (V.Ivanchenko)
>> 48 // 26-04-03 Fix retrieve tables (V.Ivanchenko)
>> 49 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
>> 50 // 23-07-03 Add exchange with G4EnergyLossTables (V.Ivanchenko)
>> 51 // 05-10-03 Add G4VEmProcesses registration and Verbose command (V.Ivanchenko)
>> 52 // 17-10-03 Add SetParameters method (V.Ivanchenko)
>> 53 // 23-10-03 Add control on inactive processes (V.Ivanchenko)
>> 54 // 04-11-03 Add checks in RetrievePhysicsTable (V.Ivanchenko)
>> 55 // 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko)
>> 56 // 14-01-04 Activate precise range calculation (V.Ivanchenko)
>> 57 // 10-03-04 Fix a problem of Precise Range table (V.Ivanchenko)
>> 58 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
>> 59 // 13-01-04 Fix problem which takes place for inactivate eIoni (V.Ivanchenko)
>> 60 // 25-01-04 Fix initialisation problem for ions (V.Ivanchenko)
>> 61 // 11-03-05 Shift verbose level by 1 (V.Ivantchenko)
>> 62 // 10-01-06 PreciseRange -> CSDARange (V.Ivantchenko)
>> 63 // 20-01-06 Introduce G4EmTableType to remove repeating code (VI)
>> 64 // 23-03-06 Set flag isIonisation (VI)
>> 65 // 10-05-06 Add methods SetMscStepLimitation, FacRange and MscFlag (VI)
>> 66 // 22-05-06 Add methods Set/Get bremsTh (VI)
>> 67 // 05-06-06 Do not clear loss_table map between runs (VI)
>> 68 // 16-01-07 Create new energy loss table for e+,e-,mu+,mu- and
>> 69 // left ionisation table for further usage (VI)
>> 70 // 12-02-07 Add SetSkin, SetLinearLossLimit (V.Ivanchenko)
>> 71 // 18-06-07 Move definition of msc parameters to G4EmProcessOptions (V.Ivanchenko)
>> 72 // 21-02-08 Added G4EmSaturation (V.Ivanchenko)
>> 73 // 12-04-10 Added PreparePhsyicsTables and BuildPhysicsTables entries (V.Ivanchenko)
39 // 74 //
40 // Class Description: 75 // Class Description:
41 // 76 //
42 // ------------------------------------------- 77 // -------------------------------------------------------------------
43 // 78 //
44 //....oooOO0OOooo........oooOO0OOooo........oo 79 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
45 //....oooOO0OOooo........oooOO0OOooo........oo 80 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
46 81
47 #include "G4LossTableManager.hh" 82 #include "G4LossTableManager.hh"
48 #include "G4SystemOfUnits.hh" << 83 #include "G4EnergyLossMessenger.hh"
49 <<
50 #include "G4VMultipleScattering.hh" <<
51 #include "G4VEmProcess.hh" <<
52 <<
53 #include "G4EmParameters.hh" <<
54 #include "G4EmSaturation.hh" <<
55 #include "G4EmConfigurator.hh" <<
56 #include "G4ElectronIonPair.hh" <<
57 #include "G4NIELCalculator.hh" <<
58 #include "G4EmCorrections.hh" <<
59 #include "G4LossTableBuilder.hh" <<
60 #include "G4VAtomDeexcitation.hh" <<
61 #include "G4VSubCutProducer.hh" <<
62 <<
63 #include "G4PhysicsTable.hh" 84 #include "G4PhysicsTable.hh"
64 #include "G4ParticleDefinition.hh" 85 #include "G4ParticleDefinition.hh"
65 #include "G4MaterialCutsCouple.hh" 86 #include "G4MaterialCutsCouple.hh"
66 #include "G4ProcessManager.hh" 87 #include "G4ProcessManager.hh"
67 #include "G4Electron.hh" 88 #include "G4Electron.hh"
68 #include "G4Proton.hh" 89 #include "G4Proton.hh"
>> 90 #include "G4VMultipleScattering.hh"
>> 91 #include "G4VEmProcess.hh"
69 #include "G4ProductionCutsTable.hh" 92 #include "G4ProductionCutsTable.hh"
70 #include "G4PhysicsTableHelper.hh" 93 #include "G4PhysicsTableHelper.hh"
>> 94 #include "G4EmCorrections.hh"
>> 95 #include "G4EmSaturation.hh"
>> 96 #include "G4EmConfigurator.hh"
>> 97 #include "G4ElectronIonPair.hh"
71 #include "G4EmTableType.hh" 98 #include "G4EmTableType.hh"
>> 99 #include "G4LossTableBuilder.hh"
>> 100 #include "G4VAtomDeexcitation.hh"
72 #include "G4Region.hh" 101 #include "G4Region.hh"
73 #include "G4PhysicalConstants.hh" <<
74 102
75 #include "G4Gamma.hh" << 103 G4LossTableManager* G4LossTableManager::theInstance = 0;
76 #include "G4Positron.hh" <<
77 #include "G4OpticalPhoton.hh" <<
78 #include "G4Neutron.hh" <<
79 #include "G4MuonPlus.hh" <<
80 #include "G4MuonMinus.hh" <<
81 #include "G4GenericIon.hh" <<
82 104
83 //....oooOO0OOooo........oooOO0OOooo........oo 105 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
84 106
85 static std::once_flag applyOnce; <<
86 G4ThreadLocal G4LossTableManager* G4LossTableM <<
87 <<
88 G4LossTableManager* G4LossTableManager::Instan 107 G4LossTableManager* G4LossTableManager::Instance()
89 { 108 {
90 if(nullptr == instance) { << 109 if(0 == theInstance) {
91 static G4ThreadLocalSingleton<G4LossTableM << 110 static G4LossTableManager manager;
92 instance = inst.Instance(); << 111 theInstance = &manager;
93 } 112 }
94 return instance; << 113 return theInstance;
95 } 114 }
96 115
97 //....oooOO0OOooo........oooOO0OOooo........oo 116 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
98 117
99 G4LossTableManager::~G4LossTableManager() 118 G4LossTableManager::~G4LossTableManager()
100 { 119 {
101 for (auto const & p : loss_vector) { delete << 120 for (G4int i=0; i<n_loss; ++i) {
102 for (auto const & p : msc_vector) { delete p << 121 if( loss_vector[i] ) { delete loss_vector[i]; }
103 for (auto const & p : emp_vector) { delete p << 122 }
104 for (auto const & p : p_vector) { delete p; << 123 size_t msc = msc_vector.size();
105 << 124 for (size_t j=0; j<msc; ++j) {
106 std::size_t mod = mod_vector.size(); << 125 if( msc_vector[j] ) { delete msc_vector[j]; }
107 std::size_t fmod = fmod_vector.size(); << 126 }
108 for (std::size_t a=0; a<mod; ++a) { << 127 size_t emp = emp_vector.size();
109 if( nullptr != mod_vector[a] ) { << 128 for (size_t k=0; k<emp; ++k) {
110 for (std::size_t b=0; b<fmod; ++b) { << 129 if( emp_vector[k] ) { delete emp_vector[k]; }
111 if((G4VEmModel*)(fmod_vector[b]) == mo << 130 }
112 fmod_vector[b] = nullptr; << 131 size_t mod = mod_vector.size();
113 } << 132 for (size_t a=0; a<mod; ++a) {
114 } << 133 if( mod_vector[a] ) { delete mod_vector[a]; }
115 delete mod_vector[a]; << 134 }
116 mod_vector[a] = nullptr; << 135 size_t fmod = fmod_vector.size();
117 } << 136 for (size_t b=0; b<fmod; ++b) {
>> 137 if( fmod_vector[b] ) { delete fmod_vector[b]; }
118 } 138 }
119 for (auto const & p : fmod_vector) { delete <<
120 <<
121 Clear(); 139 Clear();
>> 140 delete theMessenger;
122 delete tableBuilder; 141 delete tableBuilder;
123 delete emCorrections; 142 delete emCorrections;
>> 143 delete emSaturation;
124 delete emConfigurator; 144 delete emConfigurator;
125 delete emElectronIonPair; 145 delete emElectronIonPair;
126 delete nielCalculator; <<
127 delete atomDeexcitation; 146 delete atomDeexcitation;
128 delete subcutProducer; <<
129 } 147 }
130 148
131 //....oooOO0OOooo........oooOO0OOooo........oo 149 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
132 150
133 G4LossTableManager::G4LossTableManager() 151 G4LossTableManager::G4LossTableManager()
134 { 152 {
135 theParameters = G4EmParameters::Instance(); << 153 n_loss = 0;
136 theElectron = G4Electron::Electron(); << 154 run = 0;
137 << 155 startInitialisation = false;
138 // only one thread is the master << 156 all_tables_are_built = false;
139 std::call_once(applyOnce, [this]() { isMaste << 157 currentLoss = 0;
140 verbose = isMaster ? theParameters->Verbose( << 158 currentParticle = 0;
141 << 159 firstParticle = 0;
142 tableBuilder = new G4LossTableBuilder(isMast << 160 lossFluctuationFlag = true;
143 emCorrections = new G4EmCorrections(verbose) << 161 subCutoffFlag = false;
144 << 162 rndmStepFlag = false;
145 std::size_t n = 70; << 163 minSubRange = 0.0;
146 loss_vector.reserve(n); << 164 maxRangeVariation = 1.0;
147 part_vector.reserve(n); << 165 maxFinalStep = 0.0;
148 base_part_vector.reserve(n); << 166 minKinEnergy = 0.1*keV;
149 dedx_vector.reserve(n); << 167 maxKinEnergy = 10.0*TeV;
150 range_vector.reserve(n); << 168 nbinsLambda = 77;
151 inv_range_vector.reserve(n); << 169 nbinsPerDecade = 7;
152 tables_are_built.reserve(n); << 170 maxKinEnergyForMuons = 10.*TeV;
153 isActive.reserve(n); << 171 integral = true;
154 msc_vector.reserve(10); << 172 integralActive = false;
155 emp_vector.reserve(16); << 173 buildCSDARange = false;
156 mod_vector.reserve(150); << 174 minEnergyActive = false;
157 fmod_vector.reserve(60); << 175 maxEnergyActive = false;
>> 176 maxEnergyForMuonsActive = false;
>> 177 stepFunctionActive = false;
>> 178 flagLPM = true;
>> 179 splineFlag = true;
>> 180 bremsTh = DBL_MAX;
>> 181 factorForAngleLimit = 1.0;
>> 182 verbose = 1;
>> 183 theMessenger = new G4EnergyLossMessenger();
>> 184 theElectron = G4Electron::Electron();
>> 185 tableBuilder = new G4LossTableBuilder();
>> 186 emCorrections= new G4EmCorrections();
>> 187 emSaturation = new G4EmSaturation();
>> 188 emConfigurator = new G4EmConfigurator(verbose);
>> 189 emElectronIonPair = new G4ElectronIonPair();
>> 190 tableBuilder->SetSplineFlag(splineFlag);
>> 191 atomDeexcitation = 0;
158 } 192 }
159 193
160 //....oooOO0OOooo........oooOO0OOooo........oo 194 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
161 195
162 void G4LossTableManager::Clear() 196 void G4LossTableManager::Clear()
163 { 197 {
164 all_tables_are_built = false; 198 all_tables_are_built = false;
165 currentLoss = nullptr; << 199 currentLoss = 0;
166 currentParticle = nullptr; << 200 currentParticle = 0;
167 if(n_loss) { << 201 if(n_loss)
168 dedx_vector.clear(); << 202 {
169 range_vector.clear(); << 203 dedx_vector.clear();
170 inv_range_vector.clear(); << 204 range_vector.clear();
171 loss_map.clear(); << 205 inv_range_vector.clear();
172 loss_vector.clear(); << 206 loss_map.clear();
173 part_vector.clear(); << 207 loss_vector.clear();
174 base_part_vector.clear(); << 208 part_vector.clear();
175 tables_are_built.clear(); << 209 base_part_vector.clear();
176 isActive.clear(); << 210 tables_are_built.clear();
177 n_loss = 0; << 211 isActive.clear();
178 } << 212 n_loss = 0;
>> 213 }
179 } 214 }
180 215
181 //....oooOO0OOooo........oooOO0OOooo........oo 216 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
182 217
183 void G4LossTableManager::Register(G4VEnergyLos 218 void G4LossTableManager::Register(G4VEnergyLossProcess* p)
184 { 219 {
185 if (nullptr == p) { return; } <<
186 for (G4int i=0; i<n_loss; ++i) { <<
187 if(loss_vector[i] == p) { return; } <<
188 } <<
189 if(verbose > 1) { <<
190 G4cout << "G4LossTableManager::Register G4 <<
191 << p->GetProcessName() << " idx= " <<
192 } <<
193 ++n_loss; 220 ++n_loss;
194 loss_vector.push_back(p); 221 loss_vector.push_back(p);
195 part_vector.push_back(nullptr); << 222 part_vector.push_back(0);
196 base_part_vector.push_back(nullptr); << 223 base_part_vector.push_back(0);
197 dedx_vector.push_back(nullptr); << 224 dedx_vector.push_back(0);
198 range_vector.push_back(nullptr); << 225 range_vector.push_back(0);
199 inv_range_vector.push_back(nullptr); << 226 inv_range_vector.push_back(0);
200 tables_are_built.push_back(false); 227 tables_are_built.push_back(false);
201 isActive.push_back(true); 228 isActive.push_back(true);
202 all_tables_are_built = false; 229 all_tables_are_built = false;
203 } << 230 if(!lossFluctuationFlag) { p->SetLossFluctuations(false); }
204 << 231 if(subCutoffFlag) { p->ActivateSubCutoff(true); }
205 //....oooOO0OOooo........oooOO0OOooo........oo << 232 if(rndmStepFlag) { p->SetRandomStep(true); }
206 << 233 if(stepFunctionActive) { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
207 void G4LossTableManager::ResetParameters() << 234 if(integralActive) { p->SetIntegral(integral); }
208 { << 235 if(minEnergyActive) { p->SetMinKinEnergy(minKinEnergy); }
209 // initialisation once per run << 236 if(maxEnergyActive) { p->SetMaxKinEnergy(maxKinEnergy); }
210 if (!resetParam) { return; } << 237 if(verbose > 1)
211 resetParam = false; << 238 G4cout << "G4LossTableManager::Register G4VEnergyLossProcess : "
212 startInitialisation = true; << 239 << p->GetProcessName() << G4endl;
213 verbose = theParameters->Verbose(); <<
214 if(!isMaster) { <<
215 verbose = theParameters->WorkerVerbose(); <<
216 } else { <<
217 if(verbose > 0) { theParameters->Dump(); } <<
218 } <<
219 <<
220 tableBuilder->InitialiseBaseMaterials(); <<
221 if (nullptr != nielCalculator) { nielCalcula <<
222 <<
223 emCorrections->SetVerbose(verbose); <<
224 if(nullptr != emConfigurator) { emConfigurat <<
225 if(nullptr != emElectronIonPair) { emElectro <<
226 if(nullptr != atomDeexcitation) { <<
227 atomDeexcitation->SetVerboseLevel(verbose) <<
228 atomDeexcitation->InitialiseAtomicDeexcita <<
229 } <<
230 if (1 < verbose) { <<
231 G4cout << "====== G4LossTableManager::Rese <<
232 << " Nloss=" << loss_vector.size() <<
233 << " run=" << run << " master=" << isMast <<
234 << G4endl; <<
235 } <<
236 } 240 }
237 241
238 //....oooOO0OOooo........oooOO0OOooo........oo 242 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
239 243
240 void G4LossTableManager::DeRegister(G4VEnergyL 244 void G4LossTableManager::DeRegister(G4VEnergyLossProcess* p)
241 { 245 {
242 if (nullptr == p) { return; } <<
243 for (G4int i=0; i<n_loss; ++i) { 246 for (G4int i=0; i<n_loss; ++i) {
244 if(loss_vector[i] == p) { << 247 if(loss_vector[i] == p) { loss_vector[i] = 0; }
245 loss_vector[i] = nullptr; <<
246 break; <<
247 } <<
248 } 248 }
249 } 249 }
250 250
251 //....oooOO0OOooo........oooOO0OOooo........oo 251 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
252 252
253 void G4LossTableManager::Register(G4VMultipleS 253 void G4LossTableManager::Register(G4VMultipleScattering* p)
254 { 254 {
255 if (nullptr == p) { return; } << 255 msc_vector.push_back(p);
256 std::size_t n = msc_vector.size(); <<
257 for (std::size_t i=0; i<n; ++i) { <<
258 if(msc_vector[i] == p) { return; } <<
259 } <<
260 if(verbose > 1) { 256 if(verbose > 1) {
261 G4cout << "G4LossTableManager::Register G4 257 G4cout << "G4LossTableManager::Register G4VMultipleScattering : "
262 << p->GetProcessName() << " idx= " << 258 << p->GetProcessName() << G4endl;
263 } 259 }
264 msc_vector.push_back(p); <<
265 } 260 }
266 261
267 //....oooOO0OOooo........oooOO0OOooo........oo 262 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
268 263
269 void G4LossTableManager::DeRegister(G4VMultipl 264 void G4LossTableManager::DeRegister(G4VMultipleScattering* p)
270 { 265 {
271 if (nullptr == p) { return; } << 266 size_t msc = msc_vector.size();
272 std::size_t msc = msc_vector.size(); << 267 for (size_t i=0; i<msc; ++i) {
273 for (std::size_t i=0; i<msc; ++i) { << 268 if(msc_vector[i] == p) { msc_vector[i] = 0; }
274 if(msc_vector[i] == p) { <<
275 msc_vector[i] = nullptr; <<
276 break; <<
277 } <<
278 } 269 }
279 } 270 }
280 271
281 //....oooOO0OOooo........oooOO0OOooo........oo 272 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
282 273
283 void G4LossTableManager::Register(G4VEmProcess 274 void G4LossTableManager::Register(G4VEmProcess* p)
284 { 275 {
285 if (nullptr == p) { return; } << 276 emp_vector.push_back(p);
286 std::size_t n = emp_vector.size(); <<
287 for (std::size_t i=0; i<n; ++i) { <<
288 if(emp_vector[i] == p) { return; } <<
289 } <<
290 if(verbose > 1) { 277 if(verbose > 1) {
291 G4cout << "G4LossTableManager::Register G4 278 G4cout << "G4LossTableManager::Register G4VEmProcess : "
292 << p->GetProcessName() << " idx= " << 279 << p->GetProcessName() << G4endl;
293 } 280 }
294 emp_vector.push_back(p); <<
295 } 281 }
296 282
297 //....oooOO0OOooo........oooOO0OOooo........oo 283 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
298 284
299 void G4LossTableManager::DeRegister(G4VEmProce 285 void G4LossTableManager::DeRegister(G4VEmProcess* p)
300 { 286 {
301 if (nullptr == p) { return; } << 287 size_t emp = emp_vector.size();
302 std::size_t emp = emp_vector.size(); << 288 for (size_t i=0; i<emp; ++i) {
303 for (std::size_t i=0; i<emp; ++i) { << 289 if(emp_vector[i] == p) { emp_vector[i] = 0; }
304 if(emp_vector[i] == p) { <<
305 emp_vector[i] = nullptr; <<
306 break; <<
307 } <<
308 } <<
309 } <<
310 <<
311 //....oooOO0OOooo........oooOO0OOooo........oo <<
312 <<
313 void G4LossTableManager::Register(G4VProcess* <<
314 { <<
315 if (nullptr == p) { return; } <<
316 std::size_t n = p_vector.size(); <<
317 for (std::size_t i=0; i<n; ++i) { <<
318 if(p_vector[i] == p) { return; } <<
319 } <<
320 if(verbose > 1) { <<
321 G4cout << "G4LossTableManager::Register G4 <<
322 << p->GetProcessName() << " idx= " <<
323 } <<
324 p_vector.push_back(p); <<
325 } <<
326 <<
327 //....oooOO0OOooo........oooOO0OOooo........oo <<
328 <<
329 void G4LossTableManager::DeRegister(G4VProcess <<
330 { <<
331 if (nullptr == p) { return; } <<
332 std::size_t emp = p_vector.size(); <<
333 for (std::size_t i=0; i<emp; ++i) { <<
334 if(p_vector[i] == p) { <<
335 p_vector[i] = nullptr; <<
336 break; <<
337 } <<
338 } 290 }
339 } 291 }
340 292
341 //....oooOO0OOooo........oooOO0OOooo........oo 293 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
342 294
343 void G4LossTableManager::Register(G4VEmModel* 295 void G4LossTableManager::Register(G4VEmModel* p)
344 { 296 {
345 mod_vector.push_back(p); 297 mod_vector.push_back(p);
346 if(verbose > 1) { 298 if(verbose > 1) {
347 G4cout << "G4LossTableManager::Register G4 299 G4cout << "G4LossTableManager::Register G4VEmModel : "
348 << p->GetName() << " " << p << " << 300 << p->GetName() << G4endl;
349 } 301 }
350 } 302 }
351 303
352 //....oooOO0OOooo........oooOO0OOooo........oo 304 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
353 305
354 void G4LossTableManager::DeRegister(G4VEmModel 306 void G4LossTableManager::DeRegister(G4VEmModel* p)
355 { 307 {
356 //G4cout << "G4LossTableManager::DeRegister << 308 size_t n = mod_vector.size();
357 std::size_t n = mod_vector.size(); << 309 for (size_t i=0; i<n; ++i) {
358 for (std::size_t i=0; i<n; ++i) { << 310 if(mod_vector[i] == p) { mod_vector[i] = 0; }
359 if(mod_vector[i] == p) { <<
360 mod_vector[i] = nullptr; <<
361 break; <<
362 } <<
363 } 311 }
364 } 312 }
365 313
366 //....oooOO0OOooo........oooOO0OOooo........oo 314 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
367 315
368 void G4LossTableManager::Register(G4VEmFluctua 316 void G4LossTableManager::Register(G4VEmFluctuationModel* p)
369 { 317 {
370 fmod_vector.push_back(p); 318 fmod_vector.push_back(p);
371 if(verbose > 1) { 319 if(verbose > 1) {
372 G4cout << "G4LossTableManager::Register G4 320 G4cout << "G4LossTableManager::Register G4VEmFluctuationModel : "
373 << p->GetName() << " " << fmod_vec << 321 << p->GetName() << G4endl;
374 } 322 }
375 } 323 }
376 324
377 //....oooOO0OOooo........oooOO0OOooo........oo 325 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
378 326
379 void G4LossTableManager::DeRegister(G4VEmFluct 327 void G4LossTableManager::DeRegister(G4VEmFluctuationModel* p)
380 { 328 {
381 std::size_t n = fmod_vector.size(); << 329 size_t n = fmod_vector.size();
382 for (std::size_t i=0; i<n; ++i) { << 330 for (size_t i=0; i<n; ++i) {
383 if(fmod_vector[i] == p) { fmod_vector[i] = << 331 if(fmod_vector[i] == p) { fmod_vector[i] = 0; }
384 } 332 }
385 } 333 }
386 334
387 //....oooOO0OOooo........oooOO0OOooo........oo 335 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
388 336
>> 337 void G4LossTableManager::RegisterIon(const G4ParticleDefinition* ion,
>> 338 G4VEnergyLossProcess* p)
>> 339 {
>> 340 loss_map[ion] = p;
>> 341 }
>> 342
>> 343 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 344
389 void G4LossTableManager::RegisterExtraParticle 345 void G4LossTableManager::RegisterExtraParticle(
390 const G4ParticleDefinition* part, 346 const G4ParticleDefinition* part,
391 G4VEnergyLossProcess* p) 347 G4VEnergyLossProcess* p)
392 { << 348 {
393 if (nullptr == p || nullptr == part) { retur <<
394 for (G4int i=0; i<n_loss; ++i) { <<
395 if(loss_vector[i] == p) { return; } <<
396 } <<
397 if(verbose > 1) { <<
398 G4cout << "G4LossTableManager::RegisterExt <<
399 << part->GetParticleName() << " G4 <<
400 << p->GetProcessName() << " idx= " <<
401 } <<
402 ++n_loss; 349 ++n_loss;
403 loss_vector.push_back(p); 350 loss_vector.push_back(p);
404 part_vector.push_back(part); 351 part_vector.push_back(part);
405 base_part_vector.push_back(p->BaseParticle() 352 base_part_vector.push_back(p->BaseParticle());
406 dedx_vector.push_back(nullptr); << 353 dedx_vector.push_back(0);
407 range_vector.push_back(nullptr); << 354 range_vector.push_back(0);
408 inv_range_vector.push_back(nullptr); << 355 inv_range_vector.push_back(0);
409 tables_are_built.push_back(false); 356 tables_are_built.push_back(false);
410 all_tables_are_built = false; 357 all_tables_are_built = false;
411 } 358 }
412 359
413 //....oooOO0OOooo........oooOO0OOooo........oo <<
414 <<
415 G4VEnergyLossProcess* <<
416 G4LossTableManager::GetEnergyLossProcess(const <<
417 { <<
418 if(aParticle != currentParticle) { <<
419 currentParticle = aParticle; <<
420 std::map<PD,G4VEnergyLossProcess*,std::les <<
421 if ((pos = loss_map.find(aParticle)) != lo <<
422 currentLoss = (*pos).second; <<
423 } else { <<
424 currentLoss = nullptr; <<
425 if(0.0 != aParticle->GetPDGCharge() && <<
426 (pos = loss_map.find(theGenericIon)) != los <<
427 currentLoss = (*pos).second; <<
428 } <<
429 } <<
430 } <<
431 return currentLoss; <<
432 } <<
433 <<
434 //....oooOO0OOooo........oooOO0OOooo........oo 360 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
435 361
436 void 362 void
437 G4LossTableManager::PreparePhysicsTable(const 363 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
438 G4VEne << 364 G4VEnergyLossProcess* p)
439 { 365 {
440 if (1 < verbose) { 366 if (1 < verbose) {
441 G4cout << "G4LossTableManager::PreparePhys 367 G4cout << "G4LossTableManager::PreparePhysicsTable for "
442 << particle->GetParticleName() << 368 << particle->GetParticleName()
443 << " and " << p->GetProcessName() < << 369 << " and " << p->GetProcessName() << " run= " << run << G4endl;
444 << " loss_vector " << loss_vector <<
445 << " run=" << run << " master=" << isMast <<
446 << G4endl; <<
447 } 370 }
>> 371 if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
448 372
449 // start initialisation for the first run 373 // start initialisation for the first run
450 if( -1 == run ) { << 374 startInitialisation = true;
451 if (nullptr != emConfigurator) { emConfigu << 375
>> 376 if( 0 == run ) {
>> 377 emConfigurator->PrepareModels(particle, p);
452 378
453 // initialise particles for given process 379 // initialise particles for given process
454 for (G4int j=0; j<n_loss; ++j) { 380 for (G4int j=0; j<n_loss; ++j) {
455 if (p == loss_vector[j] && nullptr == pa << 381 if (p == loss_vector[j]) {
456 part_vector[j] = particle; << 382 if (!part_vector[j]) { part_vector[j] = particle; }
457 if (particle->GetParticleName() == "Ge <<
458 theGenericIon = particle; <<
459 } <<
460 } 383 }
461 } 384 }
462 } 385 }
463 ResetParameters(); <<
464 } 386 }
465 387
466 //....oooOO0OOooo........oooOO0OOooo........oo 388 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
467 389
468 void 390 void
469 G4LossTableManager::PreparePhysicsTable(const 391 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
470 G4VEmP << 392 G4VEmProcess* p)
471 { 393 {
472 if (1 < verbose) { 394 if (1 < verbose) {
473 G4cout << "G4LossTableManager::PreparePhys 395 G4cout << "G4LossTableManager::PreparePhysicsTable for "
474 << particle->GetParticleName() << 396 << particle->GetParticleName()
475 << " and " << p->GetProcessName() << 397 << " and " << p->GetProcessName() << G4endl;
476 << " run=" << run << " master=" << isMast <<
477 << G4endl; <<
478 } 398 }
>> 399 if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
479 400
480 // start initialisation for the first run 401 // start initialisation for the first run
481 if( -1 == run ) { << 402 if( 0 == run ) {
482 if (nullptr != emConfigurator) { emConfigu << 403 emConfigurator->PrepareModels(particle, p);
483 } 404 }
484 << 405 startInitialisation = true;
485 ResetParameters(); <<
486 } 406 }
487 407
488 //....oooOO0OOooo........oooOO0OOooo........oo 408 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
489 409
490 void 410 void
491 G4LossTableManager::PreparePhysicsTable(const 411 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
492 G4VMul << 412 G4VMultipleScattering* p)
493 { 413 {
494 if (1 < verbose) { 414 if (1 < verbose) {
495 G4cout << "G4LossTableManager::PreparePhys 415 G4cout << "G4LossTableManager::PreparePhysicsTable for "
496 << particle->GetParticleName() << 416 << particle->GetParticleName()
497 << " and " << p->GetProcessName() << 417 << " and " << p->GetProcessName() << G4endl;
498 << " run=" << run << " master=" << isMast <<
499 << G4endl; <<
500 } 418 }
>> 419 if(!startInitialisation) { tableBuilder->SetInitialisationFlag(false); }
501 420
502 // start initialisation for the first run 421 // start initialisation for the first run
503 if ( -1 == run ) { << 422 if( 0 == run ) {
504 if (nullptr != emConfigurator) { emConfigu << 423 emConfigurator->PrepareModels(particle, p);
505 } 424 }
506 <<
507 ResetParameters(); <<
508 } 425 }
509 426
510 //....oooOO0OOooo........oooOO0OOooo........oo 427 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
511 428
512 void 429 void
513 G4LossTableManager::BuildPhysicsTable(const G4 430 G4LossTableManager::BuildPhysicsTable(const G4ParticleDefinition*)
514 { 431 {
515 if(-1 == run && startInitialisation) { << 432 if(0 == run && startInitialisation) {
516 if (nullptr != emConfigurator) { emConfigu << 433 emConfigurator->Clear();
517 } 434 }
518 if (startInitialisation) { resetParam = true <<
519 } 435 }
520 436
521 //....oooOO0OOooo........oooOO0OOooo........oo 437 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
522 438
523 void G4LossTableManager::LocalPhysicsTables( << 439 void G4LossTableManager::BuildPhysicsTable(
524 const G4ParticleDefinition* aParticle, 440 const G4ParticleDefinition* aParticle,
525 G4VEnergyLossProcess* p) 441 G4VEnergyLossProcess* p)
526 { 442 {
527 if (1 < verbose) { << 443 if(1 < verbose) {
528 G4cout << "### G4LossTableManager::LocalPh << 444 G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
529 << aParticle->GetParticleName() 445 << aParticle->GetParticleName()
530 << " and process " << p->GetProcess << 446 << " and process " << p->GetProcessName()
531 << G4endl; 447 << G4endl;
532 } 448 }
533 << 449 // clear configurator
534 if(-1 == run && startInitialisation) { << 450 if(0 == run && startInitialisation) {
535 if (nullptr != emConfigurator) { emConfigu << 451 emConfigurator->Clear();
536 firstParticle = aParticle; 452 firstParticle = aParticle;
537 } 453 }
538 << 454 if(startInitialisation && atomDeexcitation) {
539 if (startInitialisation) { << 455 atomDeexcitation->InitialiseAtomicDeexcitation();
540 ++run; <<
541 if (1 < verbose) { <<
542 G4cout << "===== G4LossTableManager::Loc <<
543 << run << " =====" << G4endl; <<
544 } <<
545 currentParticle = nullptr; <<
546 startInitialisation = false; <<
547 resetParam = true; <<
548 for (G4int i=0; i<n_loss; ++i) { <<
549 if (nullptr != loss_vector[i]) { <<
550 tables_are_built[i] = false; <<
551 } else { <<
552 tables_are_built[i] = true; <<
553 part_vector[i] = nullptr; <<
554 } <<
555 } <<
556 } <<
557 <<
558 all_tables_are_built= true; <<
559 for (G4int i=0; i<n_loss; ++i) { <<
560 if(p == loss_vector[i]) { <<
561 tables_are_built[i] = true; <<
562 isActive[i] = true; <<
563 part_vector[i] = p->Particle(); <<
564 base_part_vector[i] = p->BaseParticle(); <<
565 dedx_vector[i] = p->DEDXTable(); <<
566 range_vector[i] = p->RangeTableForLoss() <<
567 inv_range_vector[i] = p->InverseRangeTab <<
568 if(0 == run && p->IsIonisationProcess()) <<
569 loss_map[part_vector[i]] = p; <<
570 } <<
571 <<
572 if(1 < verbose) { <<
573 G4cout << i <<". "<< p->GetProcessNa <<
574 if(part_vector[i]) { <<
575 G4cout << " for " << part_vector[i <<
576 } <<
577 G4cout << " active= " << isActive[i] <<
578 << " table= " << tables_are_bu <<
579 << " isIonisation= " << p->IsI <<
580 << G4endl; <<
581 } <<
582 break; <<
583 } else if(!tables_are_built[i]) { <<
584 all_tables_are_built = false; <<
585 } <<
586 } 456 }
>> 457 startInitialisation = false;
587 458
588 if(1 < verbose) { << 459 // initialisation before any table is built
589 G4cout << "### G4LossTableManager::LocalPh << 460 if ( aParticle == firstParticle ) {
590 << G4endl; << 461 all_tables_are_built = true;
591 } <<
592 if(all_tables_are_built) { <<
593 if(1 < verbose) { <<
594 G4cout << "%%%%% All dEdx and Range tabl <<
595 << run << " %%%%%" << G4endl; <<
596 } <<
597 } <<
598 } <<
599 462
600 //....oooOO0OOooo........oooOO0OOooo........oo <<
601 <<
602 void G4LossTableManager::BuildPhysicsTable( <<
603 const G4ParticleDefinition* aParticle, <<
604 G4VEnergyLossProcess* p) <<
605 { <<
606 if(1 < verbose) { <<
607 G4cout << "### G4LossTableManager::BuildPh <<
608 << aParticle->GetParticleName() <<
609 << " and process " << p->GetProcess <<
610 } <<
611 // clear configurator <<
612 if(-1 == run && startInitialisation) { <<
613 if( nullptr != emConfigurator) { emConfigu <<
614 firstParticle = aParticle; <<
615 } <<
616 if(startInitialisation) { <<
617 ++run; <<
618 resetParam = true; <<
619 startInitialisation = false; <<
620 if(1 < verbose) { 463 if(1 < verbose) {
621 G4cout << "===== G4LossTableManager::Bui << 464 G4cout << "### G4LossTableManager start initilisation for first particle "
622 << run << " ===== " << atomDeexci << 465 << firstParticle->GetParticleName()
>> 466 << G4endl;
623 } 467 }
624 currentParticle = nullptr; <<
625 all_tables_are_built = false; <<
626 <<
627 for (G4int i=0; i<n_loss; ++i) { 468 for (G4int i=0; i<n_loss; ++i) {
628 G4VEnergyLossProcess* el = loss_vector[i 469 G4VEnergyLossProcess* el = loss_vector[i];
629 470
630 if(nullptr != el) { << 471 if(el) {
631 isActive[i] = true; << 472 const G4ProcessManager* pm = el->GetProcessManager();
632 part_vector[i] = el->Particle(); << 473 isActive[i] = false;
633 base_part_vector[i] = el->BaseParticle << 474 if(pm) { isActive[i] = pm->GetProcessActivation(el); }
634 tables_are_built[i] = false; << 475 if(0 == run) { base_part_vector[i] = el->BaseParticle(); }
635 if(1 < verbose) { << 476 tables_are_built[i] = false;
636 G4cout << i <<". "<< el->GetProces << 477 all_tables_are_built= false;
>> 478 if(!isActive[i]) { el->SetIonisation(false); }
>> 479
>> 480 if(1 < verbose) {
>> 481 G4cout << i <<". "<< el->GetProcessName();
637 if(el->Particle()) { 482 if(el->Particle()) {
638 G4cout << " for " << el->Particl << 483 G4cout << " for " << el->Particle()->GetParticleName();
639 } << 484 }
640 G4cout << " active= " << isActive[i << 485 G4cout << " active= " << isActive[i]
641 << " table= " << tables_are_ 486 << " table= " << tables_are_built[i]
642 << " isIonisation= " << el-> << 487 << " isIonisation= " << el->IsIonisationProcess();
643 if(base_part_vector[i]) { << 488 if(base_part_vector[i]) {
644 G4cout << " base particle " << 489 G4cout << " base particle " << base_part_vector[i]->GetParticleName();
645 << base_part_vector[i]->Get << 490 }
646 } << 491 G4cout << G4endl;
647 G4cout << G4endl; << 492 }
648 } <<
649 } else { 493 } else {
650 tables_are_built[i] = true; 494 tables_are_built[i] = true;
651 part_vector[i] = nullptr; << 495 part_vector[i] = 0;
652 isActive[i] = false; <<
653 } 496 }
654 } 497 }
>> 498 ++run;
>> 499 currentParticle = 0;
655 } 500 }
656 501
657 if (all_tables_are_built) { << 502 // Set run time parameters
658 theParameters->SetIsPrintedFlag(true); << 503 SetParameters(aParticle, p);
659 return; << 504
660 } << 505 if (all_tables_are_built) { return; }
661 506
662 // Build tables for given particle 507 // Build tables for given particle
663 all_tables_are_built = true; 508 all_tables_are_built = true;
664 509
665 for(G4int i=0; i<n_loss; ++i) { 510 for(G4int i=0; i<n_loss; ++i) {
666 if(p == loss_vector[i] && !tables_are_buil << 511 if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
667 const G4ParticleDefinition* curr_part = 512 const G4ParticleDefinition* curr_part = part_vector[i];
668 if(1 < verbose) { 513 if(1 < verbose) {
669 G4cout << "### Build Table for " << p- << 514 G4cout << "### BuildPhysicsTable for " << p->GetProcessName()
670 << " and " << curr_part->GetPar << 515 << " and " << curr_part->GetParticleName()
671 << " " << tables_are_built[i] << 516 << " start BuildTable " << G4endl;
672 << G4endl; <<
673 } 517 }
674 G4VEnergyLossProcess* curr_proc = BuildT 518 G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
675 if(curr_proc) { << 519 if(curr_proc) { CopyTables(curr_part, curr_proc); }
676 CopyTables(curr_part, curr_proc); <<
677 if(p == curr_proc && 0 == run && p->Is <<
678 loss_map[aParticle] = p; <<
679 //G4cout << "G4LossTableManager::Bui <<
680 // << aParticle->GetParticleName <<
681 // << " added to map " << p <<
682 } <<
683 } <<
684 } 520 }
685 if ( !tables_are_built[i] ) { all_tables_a 521 if ( !tables_are_built[i] ) { all_tables_are_built = false; }
686 } 522 }
>> 523
687 if(1 < verbose) { 524 if(1 < verbose) {
688 G4cout << "### G4LossTableManager::BuildPh << 525 G4cout << "### G4LossTableManager::BuildDEDXTable end: "
689 << "all_tables_are_built= " << all_ << 526 << "all_tables_are_built= " << all_tables_are_built
690 << aParticle->GetParticleName() << << 527 << G4endl;
>> 528
>> 529 if(all_tables_are_built) {
>> 530 G4cout << "### All dEdx and Range tables are built #####" << G4endl;
>> 531 }
691 } 532 }
692 } 533 }
693 534
694 //....oooOO0OOooo........oooOO0OOooo........oo 535 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
695 536
696 void G4LossTableManager::CopyTables(const G4Pa 537 void G4LossTableManager::CopyTables(const G4ParticleDefinition* part,
697 G4VEnergyL << 538 G4VEnergyLossProcess* base_proc)
698 { 539 {
699 for (G4int j=0; j<n_loss; ++j) { 540 for (G4int j=0; j<n_loss; ++j) {
700 541
701 G4VEnergyLossProcess* proc = loss_vector[j 542 G4VEnergyLossProcess* proc = loss_vector[j];
>> 543 //if(proc == base_proc || proc->Particle() == part)
>> 544 // tables_are_built[j] = true;
702 545
703 if (!tables_are_built[j] && part == base_p 546 if (!tables_are_built[j] && part == base_part_vector[j]) {
704 tables_are_built[j] = true; 547 tables_are_built[j] = true;
705 // for base particle approach only ionis << 548 proc->SetDEDXTable(base_proc->DEDXTable(),fRestricted);
706 proc->SetDEDXTable(base_proc->Ionisation << 549 proc->SetDEDXTable(base_proc->DEDXTableForSubsec(),fSubRestricted);
707 proc->SetDEDXTable(base_proc->DEDXunRest 550 proc->SetDEDXTable(base_proc->DEDXunRestrictedTable(),fTotal);
708 proc->SetCSDARangeTable(base_proc->CSDAR 551 proc->SetCSDARangeTable(base_proc->CSDARangeTable());
709 proc->SetRangeTableForLoss(base_proc->Ra 552 proc->SetRangeTableForLoss(base_proc->RangeTableForLoss());
710 proc->SetInverseRangeTable(base_proc->In 553 proc->SetInverseRangeTable(base_proc->InverseRangeTable());
711 proc->SetLambdaTable(base_proc->LambdaTa 554 proc->SetLambdaTable(base_proc->LambdaTable());
712 if(proc->IsIonisationProcess()) { << 555 proc->SetSubLambdaTable(base_proc->SubLambdaTable());
713 range_vector[j] = base_proc->RangeTabl << 556 proc->SetIonisation(base_proc->IsIonisationProcess());
714 inv_range_vector[j] = base_proc->Inver << 557 loss_map[part_vector[j]] = proc;
715 loss_map[part_vector[j]] = proc; <<
716 //G4cout << "G4LossTableManager::CopyT <<
717 // << part_vector[j]->GetParticl <<
718 // << " added to map " << proc < <<
719 } <<
720 if (1 < verbose) { 558 if (1 < verbose) {
721 G4cout << " CopyTables for " << pro << 559 G4cout << "For " << proc->GetProcessName()
722 << " for " << part_vector[j]-> 560 << " for " << part_vector[j]->GetParticleName()
723 << " base_part= " << part->Get 561 << " base_part= " << part->GetParticleName()
724 << " tables are assigned" << 562 << " tables are assigned "
725 << G4endl; 563 << G4endl;
726 } 564 }
727 } 565 }
>> 566
>> 567 if (theElectron == part && theElectron == proc->SecondaryParticle() ) {
>> 568 proc->SetSecondaryRangeTable(base_proc->RangeTableForLoss());
>> 569 }
728 } 570 }
729 } 571 }
730 572
731 //....oooOO0OOooo........oooOO0OOooo........oo 573 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
732 574
733 G4VEnergyLossProcess* G4LossTableManager::Buil 575 G4VEnergyLossProcess* G4LossTableManager::BuildTables(
734 const G4ParticleDefiniti 576 const G4ParticleDefinition* aParticle)
735 { 577 {
736 if(1 < verbose) { 578 if(1 < verbose) {
737 G4cout << " G4LossTableManager::BuildTab << 579 G4cout << "G4LossTableManager::BuildTables() for "
738 << aParticle->GetParticleName() << 580 << aParticle->GetParticleName() << G4endl;
739 } 581 }
740 582
741 std::vector<G4PhysicsTable*> t_list; 583 std::vector<G4PhysicsTable*> t_list;
742 std::vector<G4VEnergyLossProcess*> loss_list 584 std::vector<G4VEnergyLossProcess*> loss_list;
743 std::vector<G4bool> build_flags; << 585 loss_list.clear();
744 G4VEnergyLossProcess* em = nullptr; << 586 G4VEnergyLossProcess* em = 0;
745 G4VEnergyLossProcess* p = nullptr; << 587 G4VEnergyLossProcess* p = 0;
746 G4int iem = 0; 588 G4int iem = 0;
747 G4PhysicsTable* dedx = nullptr; << 589 G4PhysicsTable* dedx = 0;
748 G4int i; 590 G4int i;
749 591
750 G4ProcessVector* pvec = <<
751 aParticle->GetProcessManager()->GetProcess <<
752 G4int nvec = (G4int)pvec->size(); <<
753 <<
754 for (i=0; i<n_loss; ++i) { 592 for (i=0; i<n_loss; ++i) {
755 p = loss_vector[i]; 593 p = loss_vector[i];
756 if (nullptr != p) { << 594 if (p && aParticle == part_vector[i] && !tables_are_built[i]) {
757 G4bool yes = (aParticle == part_vector[i << 595 if ((p->IsIonisationProcess() && isActive[i]) ||
758 << 596 !em || (em && !isActive[iem]) ) {
759 // possible case of process sharing betw << 597 em = p;
760 if(!yes) { << 598 iem= i;
761 auto ptr = static_cast<G4VProcess*>(p) <<
762 for(G4int j=0; j<nvec; ++j) { <<
763 //G4cout << "j= " << j << " " << (*p <<
764 if(ptr == (*pvec)[j]) { <<
765 yes = true; <<
766 break; <<
767 } <<
768 } <<
769 } <<
770 // process belong to this particle <<
771 if(yes && isActive[i]) { <<
772 if (p->IsIonisationProcess() || !em) { <<
773 em = p; <<
774 iem= i; <<
775 } <<
776 // tables may be shared between partic <<
777 G4bool val = false; <<
778 if (!tables_are_built[i]) { <<
779 val = true; <<
780 dedx = p->BuildDEDXTable(fRestricted <<
781 //G4cout << "===Build DEDX table for <<
782 // << " idx= " << i << " dedx:" << d <<
783 p->SetDEDXTable(dedx,fRestricted); <<
784 tables_are_built[i] = true; <<
785 } else { <<
786 dedx = p->DEDXTable(); <<
787 } <<
788 t_list.push_back(dedx); <<
789 loss_list.push_back(p); <<
790 build_flags.push_back(val); <<
791 } 599 }
>> 600 dedx = p->BuildDEDXTable(fRestricted);
>> 601 // G4cout << "Build DEDX table for " << aParticle->GetParticleName()
>> 602 // << " " << dedx << " " << dedx->length() << G4endl;
>> 603 p->SetDEDXTable(dedx,fRestricted);
>> 604 t_list.push_back(dedx);
>> 605 loss_list.push_back(p);
>> 606 tables_are_built[i] = true;
792 } 607 }
793 } 608 }
794 609
795 G4int n_dedx = (G4int)t_list.size(); << 610 G4int n_dedx = t_list.size();
796 if (0 == n_dedx || !em) { 611 if (0 == n_dedx || !em) {
797 G4cout << "G4LossTableManager WARNING: no 612 G4cout << "G4LossTableManager WARNING: no DEDX processes for "
798 << aParticle->GetParticleName() << << 613 << aParticle->GetParticleName() << G4endl;
799 return nullptr; << 614 return 0;
800 } 615 }
801 G4int nSubRegions = em->NumberOfSubCutoffReg 616 G4int nSubRegions = em->NumberOfSubCutoffRegions();
802 617
803 if (1 < verbose) { 618 if (1 < verbose) {
804 G4cout << " Start to build the sum of << 619 G4cout << "G4LossTableManager::BuildTables() start to build range tables"
>> 620 << " and the sum of " << n_dedx << " processes"
805 << " iem= " << iem << " em= " << em 621 << " iem= " << iem << " em= " << em->GetProcessName()
806 << " buildCSDARange= " << theParame << 622 << " buildCSDARange= " << buildCSDARange
807 << " nSubRegions= " << nSubRegions; << 623 << " nSubRegions= " << nSubRegions
808 if(subcutProducer) { << 624 << G4endl;
809 G4cout << " SubCutProducer " << subcutPr <<
810 } <<
811 G4cout << G4endl; <<
812 } 625 }
813 // do not build tables if producer class is <<
814 if(subcutProducer) { nSubRegions = 0; } <<
815 <<
816 dedx = em->DEDXTable(); <<
817 em->SetDEDXTable(dedx, fIsIonisation); <<
818 626
>> 627 dedx = em->IonisationTable();
819 if (1 < n_dedx) { 628 if (1 < n_dedx) {
820 dedx = nullptr; << 629 em->SetDEDXTable(dedx, fIsIonisation);
821 dedx = G4PhysicsTableHelper::PreparePhysic << 630 dedx = 0;
>> 631 dedx = G4PhysicsTableHelper::PreparePhysicsTable(dedx);
822 tableBuilder->BuildDEDXTable(dedx, t_list) 632 tableBuilder->BuildDEDXTable(dedx, t_list);
823 em->SetDEDXTable(dedx, fRestricted); 633 em->SetDEDXTable(dedx, fRestricted);
824 } 634 }
825 <<
826 dedx_vector[iem] = dedx; 635 dedx_vector[iem] = dedx;
827 636
828 G4PhysicsTable* range = em->RangeTableForLos 637 G4PhysicsTable* range = em->RangeTableForLoss();
829 if(!range) range = G4PhysicsTableHelper::Pr 638 if(!range) range = G4PhysicsTableHelper::PreparePhysicsTable(range);
830 range_vector[iem] = range; 639 range_vector[iem] = range;
831 640
832 G4PhysicsTable* invrange = em->InverseRangeT 641 G4PhysicsTable* invrange = em->InverseRangeTable();
833 if(!invrange) invrange = G4PhysicsTableHelpe 642 if(!invrange) invrange = G4PhysicsTableHelper::PreparePhysicsTable(invrange);
834 inv_range_vector[iem] = invrange; 643 inv_range_vector[iem] = invrange;
835 644
836 tableBuilder->BuildRangeTable(dedx, range); << 645 G4bool flag = em->IsIonisationProcess();
837 tableBuilder->BuildInverseRangeTable(range, << 646 tableBuilder->BuildRangeTable(dedx, range, flag);
>> 647 tableBuilder->BuildInverseRangeTable(range, invrange, flag);
>> 648
>> 649 // if(1<verbose) G4cout << *dedx << G4endl;
838 650
839 em->SetRangeTableForLoss(range); 651 em->SetRangeTableForLoss(range);
840 em->SetInverseRangeTable(invrange); 652 em->SetInverseRangeTable(invrange);
841 653
>> 654 // if(1<verbose) G4cout << *range << G4endl;
>> 655
>> 656 std::vector<G4PhysicsTable*> listSub;
842 std::vector<G4PhysicsTable*> listCSDA; 657 std::vector<G4PhysicsTable*> listCSDA;
843 658
844 for (i=0; i<n_dedx; ++i) { 659 for (i=0; i<n_dedx; ++i) {
845 p = loss_list[i]; 660 p = loss_list[i];
846 if(build_flags[i]) { << 661 p->SetIonisation(false);
847 p->SetLambdaTable(p->BuildLambdaTable(fR << 662 p->SetLambdaTable(p->BuildLambdaTable(fRestricted));
>> 663 if (0 < nSubRegions) {
>> 664 dedx = p->BuildDEDXTable(fSubRestricted);
>> 665 p->SetDEDXTable(dedx,fSubRestricted);
>> 666 listSub.push_back(dedx);
>> 667 p->SetSubLambdaTable(p->BuildLambdaTable(fSubRestricted));
>> 668 if(p != em) em->AddCollaborativeProcess(p);
848 } 669 }
849 if(theParameters->BuildCSDARange()) { << 670 if(buildCSDARange) {
850 dedx = p->BuildDEDXTable(fTotal); 671 dedx = p->BuildDEDXTable(fTotal);
851 p->SetDEDXTable(dedx,fTotal); 672 p->SetDEDXTable(dedx,fTotal);
852 listCSDA.push_back(dedx); 673 listCSDA.push_back(dedx);
853 } 674 }
854 } 675 }
855 676
856 if(theParameters->BuildCSDARange()) { << 677 if (0 < nSubRegions) {
>> 678 G4PhysicsTable* dedxSub = em->IonisationTableForSubsec();
>> 679 if (1 < listSub.size()) {
>> 680 em->SetDEDXTable(dedxSub, fIsSubIonisation);
>> 681 dedxSub = 0;
>> 682 dedxSub = G4PhysicsTableHelper::PreparePhysicsTable(dedxSub);
>> 683 tableBuilder->BuildDEDXTable(dedxSub, listSub);
>> 684 em->SetDEDXTable(dedxSub, fSubRestricted);
>> 685 }
>> 686 }
>> 687 if(buildCSDARange) {
857 G4PhysicsTable* dedxCSDA = em->DEDXunRestr 688 G4PhysicsTable* dedxCSDA = em->DEDXunRestrictedTable();
858 if (1 < n_dedx) { 689 if (1 < n_dedx) {
859 dedxCSDA = G4PhysicsTableHelper::Prepare << 690 dedxCSDA = 0;
>> 691 dedxCSDA = G4PhysicsTableHelper::PreparePhysicsTable(dedxCSDA);
860 tableBuilder->BuildDEDXTable(dedxCSDA, l 692 tableBuilder->BuildDEDXTable(dedxCSDA, listCSDA);
861 em->SetDEDXTable(dedxCSDA,fTotal); 693 em->SetDEDXTable(dedxCSDA,fTotal);
862 } 694 }
863 G4PhysicsTable* rCSDA = em->CSDARangeTable 695 G4PhysicsTable* rCSDA = em->CSDARangeTable();
864 if(!rCSDA) { rCSDA = G4PhysicsTableHelper: << 696 if(!rCSDA) rCSDA = G4PhysicsTableHelper::PreparePhysicsTable(rCSDA);
865 tableBuilder->BuildRangeTable(dedxCSDA, rC << 697 tableBuilder->BuildRangeTable(dedxCSDA, rCSDA, flag);
866 em->SetCSDARangeTable(rCSDA); 698 em->SetCSDARangeTable(rCSDA);
867 } 699 }
868 700
>> 701 em->SetIonisation(true);
>> 702 loss_map[aParticle] = em;
>> 703
869 if (1 < verbose) { 704 if (1 < verbose) {
870 G4cout << "G4LossTableManager::BuildTables 705 G4cout << "G4LossTableManager::BuildTables: Tables are built for "
871 << aParticle->GetParticleName() 706 << aParticle->GetParticleName()
872 << "; ionisation process: " << em-> << 707 << "; ionisation process: " << em->GetProcessName()
873 << " " << em <<
874 << G4endl; 708 << G4endl;
875 } 709 }
876 return em; 710 return em;
877 } 711 }
878 712
879 //....oooOO0OOooo........oooOO0OOooo........oo 713 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
880 714
>> 715 G4EnergyLossMessenger* G4LossTableManager::GetMessenger()
>> 716 {
>> 717 return theMessenger;
>> 718 }
>> 719
>> 720 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 721
881 void G4LossTableManager::ParticleHaveNoLoss( 722 void G4LossTableManager::ParticleHaveNoLoss(
882 const G4ParticleDefinition* aParticle) 723 const G4ParticleDefinition* aParticle)
883 { 724 {
884 G4ExceptionDescription ed; 725 G4ExceptionDescription ed;
885 ed << "Energy loss process not found for " < 726 ed << "Energy loss process not found for " << aParticle->GetParticleName()
886 << " !"; << 727 << " !" << G4endl;
887 G4Exception("G4LossTableManager::ParticleHav 728 G4Exception("G4LossTableManager::ParticleHaveNoLoss", "em0001",
888 FatalException, ed); << 729 FatalException, ed);
>> 730
>> 731 }
>> 732
>> 733 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 734
>> 735 G4bool G4LossTableManager::BuildCSDARange() const
>> 736 {
>> 737 return buildCSDARange;
>> 738 }
>> 739
>> 740 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 741
>> 742 void G4LossTableManager::SetLossFluctuations(G4bool val)
>> 743 {
>> 744 lossFluctuationFlag = val;
>> 745 for(G4int i=0; i<n_loss; ++i) {
>> 746 if(loss_vector[i]) { loss_vector[i]->SetLossFluctuations(val); }
>> 747 }
>> 748 }
>> 749
>> 750 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 751
>> 752 void G4LossTableManager::SetSubCutoff(G4bool val, const G4Region* r)
>> 753 {
>> 754 subCutoffFlag = val;
>> 755 for(G4int i=0; i<n_loss; ++i) {
>> 756 if(loss_vector[i]) { loss_vector[i]->ActivateSubCutoff(val, r); }
>> 757 }
>> 758 }
>> 759
>> 760 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 761
>> 762 void G4LossTableManager::SetIntegral(G4bool val)
>> 763 {
>> 764 integral = val;
>> 765 integralActive = true;
>> 766 for(G4int i=0; i<n_loss; ++i) {
>> 767 if(loss_vector[i]) { loss_vector[i]->SetIntegral(val); }
>> 768 }
>> 769 size_t emp = emp_vector.size();
>> 770 for (size_t k=0; k<emp; ++k) {
>> 771 if(emp_vector[k]) { emp_vector[k]->SetIntegral(val); }
>> 772 }
>> 773 }
>> 774
>> 775 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 776
>> 777 void G4LossTableManager::SetMinSubRange(G4double val)
>> 778 {
>> 779 minSubRange = val;
>> 780 for(G4int i=0; i<n_loss; ++i) {
>> 781 if(loss_vector[i]) { loss_vector[i]->SetMinSubRange(val); }
>> 782 }
>> 783 }
>> 784
>> 785 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 786
>> 787 void G4LossTableManager::SetRandomStep(G4bool val)
>> 788 {
>> 789 rndmStepFlag = val;
>> 790 for(G4int i=0; i<n_loss; ++i) {
>> 791 if(loss_vector[i]) { loss_vector[i]->SetRandomStep(val); }
>> 792 }
>> 793 }
>> 794
>> 795 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 796
>> 797 void G4LossTableManager::SetMinEnergy(G4double val)
>> 798 {
>> 799 minEnergyActive = true;
>> 800 minKinEnergy = val;
>> 801 for(G4int i=0; i<n_loss; ++i) {
>> 802 if(loss_vector[i]) { loss_vector[i]->SetMinKinEnergy(val); }
>> 803 }
>> 804 size_t msc = msc_vector.size();
>> 805 for (size_t j=0; j<msc; ++j) {
>> 806 if(msc_vector[j]) { msc_vector[j]->SetMinKinEnergy(val); }
>> 807 }
>> 808 size_t emp = emp_vector.size();
>> 809 for (size_t k=0; k<emp; ++k) {
>> 810 if(emp_vector[k]) { emp_vector[k]->SetMinKinEnergy(val); }
>> 811 }
>> 812 }
>> 813
>> 814 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 815
>> 816 void G4LossTableManager::SetMaxEnergy(G4double val)
>> 817 {
>> 818 maxEnergyActive = true;
>> 819 maxKinEnergy = val;
>> 820 for(G4int i=0; i<n_loss; ++i) {
>> 821 if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergy(val); }
>> 822 }
>> 823 size_t msc = msc_vector.size();
>> 824 for (size_t j=0; j<msc; ++j) {
>> 825 if(msc_vector[j]) { msc_vector[j]->SetMaxKinEnergy(val); }
>> 826 }
>> 827 size_t emp = emp_vector.size();
>> 828 for (size_t k=0; k<emp; ++k) {
>> 829 if(emp_vector[k]) { emp_vector[k]->SetMaxKinEnergy(val); }
>> 830 }
>> 831 }
>> 832
>> 833 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 834
>> 835 void G4LossTableManager::SetMaxEnergyForCSDARange(G4double val)
>> 836 {
>> 837 for(G4int i=0; i<n_loss; ++i) {
>> 838 if(loss_vector[i]) { loss_vector[i]->SetMaxKinEnergyForCSDARange(val); }
>> 839 }
>> 840 }
>> 841
>> 842 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 843
>> 844 void G4LossTableManager::SetMaxEnergyForMuons(G4double val)
>> 845 {
>> 846 maxEnergyForMuonsActive = true;
>> 847 maxKinEnergyForMuons = val;
>> 848 }
>> 849
>> 850 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 851
>> 852 void G4LossTableManager::SetDEDXBinning(G4int val)
>> 853 {
>> 854 for(G4int i=0; i<n_loss; ++i) {
>> 855 if(loss_vector[i]) { loss_vector[i]->SetDEDXBinning(val); }
>> 856 }
>> 857 }
>> 858
>> 859 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 860
>> 861 void G4LossTableManager::SetDEDXBinningForCSDARange(G4int val)
>> 862 {
>> 863 for(G4int i=0; i<n_loss; ++i) {
>> 864 if(loss_vector[i]) { loss_vector[i]->SetDEDXBinningForCSDARange(val); }
>> 865 }
>> 866 }
>> 867
>> 868 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 869
>> 870 void G4LossTableManager::SetLambdaBinning(G4int val)
>> 871 {
>> 872 G4int n = val/G4int(std::log10(maxKinEnergy/minKinEnergy));
>> 873 if(n < 5) {
>> 874 G4cout << "G4LossTableManager::SetLambdaBinning WARNING "
>> 875 << "too small number of bins " << val << " ignored"
>> 876 << G4endl;
>> 877 return;
>> 878 }
>> 879 nbinsLambda = val;
>> 880 nbinsPerDecade = n;
>> 881 size_t msc = msc_vector.size();
>> 882 for (size_t j=0; j<msc; ++j) {
>> 883 if(msc_vector[j]) { msc_vector[j]->SetBinning(val); }
>> 884 }
>> 885 size_t emp = emp_vector.size();
>> 886 for (size_t k=0; k<emp; ++k) {
>> 887 if(emp_vector[k]) { emp_vector[k]->SetLambdaBinning(val); }
>> 888 }
>> 889 }
>> 890
>> 891 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 892
>> 893 G4int G4LossTableManager::GetNumberOfBinsPerDecade() const
>> 894 {
>> 895 return nbinsPerDecade;
889 } 896 }
890 897
891 //....oooOO0OOooo........oooOO0OOooo........oo 898 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
892 899
893 void G4LossTableManager::SetVerbose(G4int val) 900 void G4LossTableManager::SetVerbose(G4int val)
894 { 901 {
895 verbose = val; 902 verbose = val;
>> 903 for(G4int i=0; i<n_loss; ++i) {
>> 904 if(loss_vector[i]) { loss_vector[i]->SetVerboseLevel(val); }
>> 905 }
>> 906 size_t msc = msc_vector.size();
>> 907 for (size_t j=0; j<msc; ++j) {
>> 908 if(msc_vector[j]) { msc_vector[j]->SetVerboseLevel(val); }
>> 909 }
>> 910 size_t emp = emp_vector.size();
>> 911 for (size_t k=0; k<emp; ++k) {
>> 912 if(emp_vector[k]) { emp_vector[k]->SetVerboseLevel(val); }
>> 913 }
>> 914 emConfigurator->SetVerbose(val);
>> 915 //tableBuilder->SetVerbose(val);
>> 916 //emCorrections->SetVerbose(val);
>> 917 emSaturation->SetVerbose(val);
>> 918 emElectronIonPair->SetVerbose(val);
>> 919 if(atomDeexcitation) { atomDeexcitation->SetVerboseLevel(val); }
>> 920 }
>> 921
>> 922 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 923
>> 924 void G4LossTableManager::SetStepFunction(G4double v1, G4double v2)
>> 925 {
>> 926 stepFunctionActive = true;
>> 927 maxRangeVariation = v1;
>> 928 maxFinalStep = v2;
>> 929 for(G4int i=0; i<n_loss; ++i) {
>> 930 if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
>> 931 }
>> 932 }
>> 933
>> 934 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 935
>> 936 void G4LossTableManager::SetLinearLossLimit(G4double val)
>> 937 {
>> 938 for(G4int i=0; i<n_loss; ++i) {
>> 939 if(loss_vector[i]) { loss_vector[i]->SetLinearLossLimit(val); }
>> 940 }
>> 941 }
>> 942
>> 943 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 944
>> 945 void G4LossTableManager::SetBuildCSDARange(G4bool val)
>> 946 {
>> 947 buildCSDARange = val;
>> 948 }
>> 949
>> 950 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 951
>> 952 void
>> 953 G4LossTableManager::SetParameters(const G4ParticleDefinition* aParticle,
>> 954 G4VEnergyLossProcess* p)
>> 955 {
>> 956 if(stepFunctionActive) { p->SetStepFunction(maxRangeVariation, maxFinalStep); }
>> 957 if(integralActive) { p->SetIntegral(integral); }
>> 958 if(minEnergyActive) { p->SetMinKinEnergy(minKinEnergy); }
>> 959 if(maxEnergyActive) { p->SetMaxKinEnergy(maxKinEnergy); }
>> 960 p->SetVerboseLevel(verbose);
>> 961 if(maxEnergyForMuonsActive) {
>> 962 G4double dm = std::abs(aParticle->GetPDGMass() - 105.7*MeV);
>> 963 if(dm < 5.*MeV) { p->SetMaxKinEnergy(maxKinEnergyForMuons); }
>> 964 }
896 } 965 }
897 966
898 //....oooOO0OOooo........oooOO0OOooo........oo 967 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
899 968
900 const std::vector<G4VEnergyLossProcess*>& 969 const std::vector<G4VEnergyLossProcess*>&
901 G4LossTableManager::GetEnergyLossProcessVector 970 G4LossTableManager::GetEnergyLossProcessVector()
902 { 971 {
903 return loss_vector; 972 return loss_vector;
904 } 973 }
905 974
906 //....oooOO0OOooo........oooOO0OOooo........oo 975 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
907 976
908 const std::vector<G4VEmProcess*>& G4LossTableM 977 const std::vector<G4VEmProcess*>& G4LossTableManager::GetEmProcessVector()
909 { 978 {
910 return emp_vector; 979 return emp_vector;
911 } 980 }
912 981
913 //....oooOO0OOooo........oooOO0OOooo........oo 982 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
914 983
915 const std::vector<G4VMultipleScattering*>& 984 const std::vector<G4VMultipleScattering*>&
916 G4LossTableManager::GetMultipleScatteringVecto 985 G4LossTableManager::GetMultipleScatteringVector()
917 { 986 {
918 return msc_vector; 987 return msc_vector;
919 } 988 }
920 989
921 //....oooOO0OOooo........oooOO0OOooo........oo << 990 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
922 991
923 G4EmSaturation* G4LossTableManager::EmSaturati << 992 void G4LossTableManager::SetLPMFlag(G4bool val)
924 { 993 {
925 return theParameters->GetEmSaturation(); << 994 flagLPM = val;
926 } 995 }
927 996
928 //....oooOO0OOooo........oooOO0OOooo........oo << 997 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
929 998
930 G4EmConfigurator* G4LossTableManager::EmConfig << 999 G4bool G4LossTableManager::LPMFlag() const
931 { 1000 {
932 if(!emConfigurator) { << 1001 return flagLPM;
933 emConfigurator = new G4EmConfigurator(verb <<
934 } <<
935 return emConfigurator; <<
936 } 1002 }
937 1003
938 //....oooOO0OOooo........oooOO0OOooo........oo << 1004 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
939 1005
940 G4ElectronIonPair* G4LossTableManager::Electro << 1006 void G4LossTableManager::SetSplineFlag(G4bool val)
941 { 1007 {
942 if(!emElectronIonPair) { << 1008 splineFlag = val;
943 emElectronIonPair = new G4ElectronIonPair( << 1009 tableBuilder->SetSplineFlag(splineFlag);
944 } <<
945 return emElectronIonPair; <<
946 } 1010 }
947 1011
948 //....oooOO0OOooo........oooOO0OOooo........oo << 1012 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
949 1013
950 void G4LossTableManager::SetNIELCalculator(G4N << 1014 G4bool G4LossTableManager::SplineFlag() const
951 { 1015 {
952 if(nullptr != ptr && ptr != nielCalculator) << 1016 return splineFlag;
953 delete nielCalculator; <<
954 nielCalculator = ptr; <<
955 } <<
956 } 1017 }
957 1018
958 //....oooOO0OOooo........oooOO0OOooo........oo << 1019 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
959 1020
960 G4NIELCalculator* G4LossTableManager::NIELCalc << 1021 void G4LossTableManager::SetBremsstrahlungTh(G4double val)
961 { 1022 {
962 if(!nielCalculator) { << 1023 bremsTh = val;
963 nielCalculator = new G4NIELCalculator(null <<
964 } <<
965 return nielCalculator; <<
966 } 1024 }
967 1025
968 //....oooOO0OOooo........oooOO0OOooo........oo 1026 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
969 << 1027
970 void G4LossTableManager::SetAtomDeexcitation(G << 1028 G4double G4LossTableManager::BremsstrahlungTh() const
971 { 1029 {
972 if(atomDeexcitation != p) { << 1030 return bremsTh;
973 delete atomDeexcitation; <<
974 atomDeexcitation = p; <<
975 } <<
976 } 1031 }
977 1032
978 //....oooOO0OOooo........oooOO0OOooo........oo << 1033 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
979 1034
980 void G4LossTableManager::SetSubCutProducer(G4V << 1035 void G4LossTableManager::SetFactorForAngleLimit(G4double val)
981 { 1036 {
982 if(subcutProducer != p) { << 1037 if(val > 0.0) { factorForAngleLimit = val; }
983 delete subcutProducer; <<
984 subcutProducer = p; <<
985 } <<
986 } 1038 }
987 1039
988 //....oooOO0OOooo........oooOO0OOooo........oo 1040 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
989 1041
990 void G4LossTableManager::PrintEWarning(G4Strin << 1042 G4double G4LossTableManager::FactorForAngleLimit() const
991 { 1043 {
992 G4String ss = "G4LossTableManager::" + tit; << 1044 return factorForAngleLimit;
993 G4ExceptionDescription ed; << 1045 }
994 /* << 1046
995 ed << "Parameter is out of range: " << val << 1047 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
996 << " it will have no effect!\n" << " ## " << 1048
997 << " nbins= " << nbinsLambda << 1049 G4EmCorrections* G4LossTableManager::EmCorrections()
998 << " nbinsPerDecade= " << nbinsPerDecade << 1050 {
999 << " Emin(keV)= " << minKinEnergy/keV << 1051 return emCorrections;
1000 << " Emax(GeV)= " << maxKinEnergy/GeV; << 1052 }
1001 */ << 1053
1002 G4Exception(ss, "em0044", JustWarning, ed); << 1054 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1055
>> 1056 G4EmSaturation* G4LossTableManager::EmSaturation()
>> 1057 {
>> 1058 return emSaturation;
>> 1059 }
>> 1060
>> 1061 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1062
>> 1063 G4EmConfigurator* G4LossTableManager::EmConfigurator()
>> 1064 {
>> 1065 return emConfigurator;
>> 1066 }
>> 1067
>> 1068 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1069
>> 1070 G4ElectronIonPair* G4LossTableManager::ElectronIonPair()
>> 1071 {
>> 1072 return emElectronIonPair;
1003 } 1073 }
1004 1074
1005 //....oooOO0OOooo........oooOO0OOooo........o 1075 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1006 1076
1007 void G4LossTableManager::DumpHtml() << 1077 G4VAtomDeexcitation* G4LossTableManager::AtomDeexcitation()
1008 { 1078 {
1009 // Automatic generation of html documentati << 1079 return atomDeexcitation;
1010 // List processes and models for the most i << 1080 }
1011 // particles in descending order of importa <<
1012 // NB. for model names with length > 18 cha <<
1013 // to be edited by hand. Or modify G4EmMod <<
1014 <<
1015 char* dirName = std::getenv("G4PhysListDocD <<
1016 char* physList = std::getenv("G4PhysListNam <<
1017 if (dirName && physList) { <<
1018 G4String physListName = G4String(physList <<
1019 G4String pathName = G4String(dirName) + " <<
1020 <<
1021 std::ofstream outFile; <<
1022 outFile.open(pathName); <<
1023 <<
1024 outFile << physListName << G4endl; <<
1025 outFile << std::string(physListName.lengt <<
1026 <<
1027 std::vector<G4ParticleDefinition*> partic <<
1028 G4Gamma::Gamma(), <<
1029 G4Electron::Electron(), <<
1030 G4Positron::Positron(), <<
1031 G4Proton::ProtonDefinition(), <<
1032 G4MuonPlus::MuonPlusDefinition(), <<
1033 G4MuonMinus::MuonMinusDefinition(), <<
1034 }; <<
1035 <<
1036 std::vector<G4VEmProcess*> emproc_vector <<
1037 std::vector<G4VEnergyLossProcess*> enloss <<
1038 GetEnergyLossProcessVector(); <<
1039 std::vector<G4VMultipleScattering*> mscat <<
1040 GetMultipleScatteringVector(); <<
1041 <<
1042 for (auto theParticle : particles) { <<
1043 outFile << G4endl << "**" << theParticl <<
1044 << "**" << G4endl << G4endl << <<
1045 <<
1046 G4ProcessManager* pm = theParticle->Get <<
1047 G4ProcessVector* pv = pm->GetProcessLi <<
1048 G4int plen = pm->GetProcessListLength() <<
1049 <<
1050 for (auto emproc : emproc_vector) { <<
1051 for (G4int i = 0; i < plen; ++i) { <<
1052 G4VProcess* proc = (*pv)[i]; <<
1053 if (proc == emproc) { <<
1054 outFile << G4endl; <<
1055 proc->ProcessDescription(outFile) <<
1056 break; <<
1057 } <<
1058 } <<
1059 } <<
1060 1081
1061 for (auto mscproc : mscat_vector) { << 1082 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1062 for (G4int i = 0; i < plen; ++i) { <<
1063 G4VProcess* proc = (*pv)[i]; <<
1064 if (proc == mscproc) { <<
1065 outFile << G4endl; <<
1066 proc->ProcessDescription(outFile) <<
1067 break; <<
1068 } <<
1069 } <<
1070 } <<
1071 1083
1072 for (auto enlossproc : enloss_vector) { << 1084 G4LossTableBuilder* G4LossTableManager::GetTableBuilder()
1073 for (G4int i = 0; i < plen; ++i) { << 1085 {
1074 G4VProcess* proc = (*pv)[i]; << 1086 return tableBuilder;
1075 if (proc == enlossproc) { <<
1076 outFile << G4endl; <<
1077 proc->ProcessDescription(outFile) <<
1078 break; <<
1079 } <<
1080 } <<
1081 } <<
1082 } <<
1083 outFile.close(); <<
1084 } <<
1085 } 1087 }
1086 1088
1087 //....oooOO0OOooo........oooOO0OOooo........o << 1089 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
>> 1090
>> 1091 void G4LossTableManager::SetAtomDeexcitation(G4VAtomDeexcitation* p)
>> 1092 {
>> 1093 atomDeexcitation = p;
>> 1094 }
1088 1095
>> 1096 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1089 1097