| 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 85424 2014-10-29 08:23:44Z gcosmo $
>> 27 //
26 // ------------------------------------------- 28 // -------------------------------------------------------------------
27 // 29 //
28 // GEANT4 Class file 30 // GEANT4 Class file
29 // 31 //
30 // 32 //
31 // File name: G4LossTableManager 33 // File name: G4LossTableManager
32 // 34 //
33 // Author: Vladimir Ivanchenko 35 // Author: Vladimir Ivanchenko
34 // 36 //
35 // Creation date: 03.01.2002 37 // Creation date: 03.01.2002
36 // 38 //
37 // Modifications: by V.Ivanchenko << 39 // Modifications:
38 // 40 //
>> 41 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
>> 42 // 15-02-03 Lambda table can be scaled (V.Ivanchenko)
>> 43 // 17-02-03 Fix problem of store/restore tables (V.Ivanchenko)
>> 44 // 10-03-03 Add Ion registration (V.Ivanchenko)
>> 45 // 25-03-03 Add deregistration (V.Ivanchenko)
>> 46 // 02-04-03 Change messenger (V.Ivanchenko)
>> 47 // 26-04-03 Fix retrieve tables (V.Ivanchenko)
>> 48 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
>> 49 // 23-07-03 Add exchange with G4EnergyLossTables (V.Ivanchenko)
>> 50 // 05-10-03 Add G4VEmProcesses registration and Verbose command (V.Ivanchenko)
>> 51 // 17-10-03 Add SetParameters method (V.Ivanchenko)
>> 52 // 23-10-03 Add control on inactive processes (V.Ivanchenko)
>> 53 // 04-11-03 Add checks in RetrievePhysicsTable (V.Ivanchenko)
>> 54 // 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko)
>> 55 // 14-01-04 Activate precise range calculation (V.Ivanchenko)
>> 56 // 10-03-04 Fix a problem of Precise Range table (V.Ivanchenko)
>> 57 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
>> 58 // 13-01-04 Fix problem which takes place for inactivate eIoni (V.Ivanchenko)
>> 59 // 25-01-04 Fix initialisation problem for ions (V.Ivanchenko)
>> 60 // 11-03-05 Shift verbose level by 1 (V.Ivantchenko)
>> 61 // 10-01-06 PreciseRange -> CSDARange (V.Ivantchenko)
>> 62 // 20-01-06 Introduce G4EmTableType to remove repeating code (VI)
>> 63 // 23-03-06 Set flag isIonisation (VI)
>> 64 // 10-05-06 Add methods SetMscStepLimitation, FacRange and MscFlag (VI)
>> 65 // 22-05-06 Add methods Set/Get bremsTh (VI)
>> 66 // 05-06-06 Do not clear loss_table map between runs (VI)
>> 67 // 16-01-07 Create new energy loss table for e+,e-,mu+,mu- and
>> 68 // left ionisation table for further usage (VI)
>> 69 // 12-02-07 Add SetSkin, SetLinearLossLimit (V.Ivanchenko)
>> 70 // 18-06-07 Move definition of msc parameters to G4EmProcessOptions (V.Ivanchenko)
>> 71 // 21-02-08 Added G4EmSaturation (V.Ivanchenko)
>> 72 // 12-04-10 Added PreparePhysicsTables and BuildPhysicsTables entries (V.Ivanchenko)
>> 73 // 04-06-13 (V.Ivanchenko) Adaptation for MT mode; new method LocalPhysicsTables;
>> 74 // ions expect G4GenericIon are not included in the map of energy loss
>> 75 // processes for performnc reasons
39 // 76 //
40 // Class Description: 77 // Class Description:
41 // 78 //
42 // ------------------------------------------- 79 // -------------------------------------------------------------------
43 // 80 //
44 //....oooOO0OOooo........oooOO0OOooo........oo 81 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
45 //....oooOO0OOooo........oooOO0OOooo........oo 82 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
46 83
47 #include "G4LossTableManager.hh" 84 #include "G4LossTableManager.hh"
48 #include "G4SystemOfUnits.hh" 85 #include "G4SystemOfUnits.hh"
49 <<
50 #include "G4VMultipleScattering.hh" <<
51 #include "G4VEmProcess.hh" <<
52 <<
53 #include "G4EmParameters.hh" 86 #include "G4EmParameters.hh"
54 #include "G4EmSaturation.hh" << 87 #include "G4EnergyLossMessenger.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" 88 #include "G4PhysicsTable.hh"
64 #include "G4ParticleDefinition.hh" 89 #include "G4ParticleDefinition.hh"
65 #include "G4MaterialCutsCouple.hh" 90 #include "G4MaterialCutsCouple.hh"
66 #include "G4ProcessManager.hh" 91 #include "G4ProcessManager.hh"
67 #include "G4Electron.hh" 92 #include "G4Electron.hh"
68 #include "G4Proton.hh" 93 #include "G4Proton.hh"
>> 94 #include "G4VMultipleScattering.hh"
>> 95 #include "G4VEmProcess.hh"
69 #include "G4ProductionCutsTable.hh" 96 #include "G4ProductionCutsTable.hh"
70 #include "G4PhysicsTableHelper.hh" 97 #include "G4PhysicsTableHelper.hh"
>> 98 #include "G4EmCorrections.hh"
>> 99 #include "G4EmSaturation.hh"
>> 100 #include "G4EmConfigurator.hh"
>> 101 #include "G4ElectronIonPair.hh"
71 #include "G4EmTableType.hh" 102 #include "G4EmTableType.hh"
>> 103 #include "G4LossTableBuilder.hh"
>> 104 #include "G4VAtomDeexcitation.hh"
>> 105 #include "G4VSubCutProducer.hh"
72 #include "G4Region.hh" 106 #include "G4Region.hh"
73 #include "G4PhysicalConstants.hh" 107 #include "G4PhysicalConstants.hh"
74 << 108 #include "G4Threading.hh"
75 #include "G4Gamma.hh" <<
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 109
83 //....oooOO0OOooo........oooOO0OOooo........oo 110 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
84 111
85 static std::once_flag applyOnce; << 112 G4ThreadLocal G4LossTableManager* G4LossTableManager::instance = 0;
86 G4ThreadLocal G4LossTableManager* G4LossTableM <<
87 113
88 G4LossTableManager* G4LossTableManager::Instan 114 G4LossTableManager* G4LossTableManager::Instance()
89 { 115 {
90 if(nullptr == instance) { << 116 if(!instance) {
91 static G4ThreadLocalSingleton<G4LossTableM 117 static G4ThreadLocalSingleton<G4LossTableManager> inst;
92 instance = inst.Instance(); 118 instance = inst.Instance();
93 } 119 }
94 return instance; 120 return instance;
95 } 121 }
96 122
97 //....oooOO0OOooo........oooOO0OOooo........oo 123 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
98 124
99 G4LossTableManager::~G4LossTableManager() 125 G4LossTableManager::~G4LossTableManager()
100 { 126 {
101 for (auto const & p : loss_vector) { delete << 127 //G4cout << "### G4LossTableManager::~G4LossTableManager()" << G4endl;
102 for (auto const & p : msc_vector) { delete p << 128 for (G4int i=0; i<n_loss; ++i) {
103 for (auto const & p : emp_vector) { delete p << 129 //G4cout << "### eloss #" << i << G4endl;
104 for (auto const & p : p_vector) { delete p; << 130 if( loss_vector[i] ) {
105 << 131 delete loss_vector[i];
106 std::size_t mod = mod_vector.size(); << 132 }
107 std::size_t fmod = fmod_vector.size(); << 133 }
108 for (std::size_t a=0; a<mod; ++a) { << 134 size_t msc = msc_vector.size();
109 if( nullptr != mod_vector[a] ) { << 135 for (size_t j=0; j<msc; ++j) {
110 for (std::size_t b=0; b<fmod; ++b) { << 136 if( msc_vector[j] ) { delete msc_vector[j]; }
111 if((G4VEmModel*)(fmod_vector[b]) == mo << 137 }
112 fmod_vector[b] = nullptr; << 138 size_t emp = emp_vector.size();
113 } << 139 for (size_t k=0; k<emp; ++k) {
>> 140 if( emp_vector[k] ) { delete emp_vector[k]; }
>> 141 }
>> 142 size_t mod = mod_vector.size();
>> 143 size_t fmod = fmod_vector.size();
>> 144 for (size_t a=0; a<mod; ++a) {
>> 145 if( mod_vector[a] ) {
>> 146 for (size_t b=0; b<fmod; ++b) {
>> 147 if((G4VEmModel*)(fmod_vector[b]) == mod_vector[a]) {
>> 148 fmod_vector[b] = 0;
>> 149 }
114 } 150 }
115 delete mod_vector[a]; 151 delete mod_vector[a];
116 mod_vector[a] = nullptr; <<
117 } 152 }
118 } 153 }
119 for (auto const & p : fmod_vector) { delete << 154 for (size_t b=0; b<fmod; ++b) {
120 << 155 if( fmod_vector[b] ) { delete fmod_vector[b]; }
>> 156 }
121 Clear(); 157 Clear();
>> 158 delete theMessenger;
122 delete tableBuilder; 159 delete tableBuilder;
123 delete emCorrections; 160 delete emCorrections;
>> 161 delete emSaturation;
124 delete emConfigurator; 162 delete emConfigurator;
125 delete emElectronIonPair; 163 delete emElectronIonPair;
126 delete nielCalculator; <<
127 delete atomDeexcitation; 164 delete atomDeexcitation;
128 delete subcutProducer; 165 delete subcutProducer;
129 } 166 }
130 167
131 //....oooOO0OOooo........oooOO0OOooo........oo 168 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
132 169
133 G4LossTableManager::G4LossTableManager() 170 G4LossTableManager::G4LossTableManager()
134 { 171 {
135 theParameters = G4EmParameters::Instance(); 172 theParameters = G4EmParameters::Instance();
136 theElectron = G4Electron::Electron(); << 173 n_loss = 0;
137 << 174 run = -1;
138 // only one thread is the master << 175 startInitialisation = false;
139 std::call_once(applyOnce, [this]() { isMaste << 176 all_tables_are_built = false;
140 verbose = isMaster ? theParameters->Verbose( << 177 currentLoss = 0;
141 << 178 currentParticle = 0;
142 tableBuilder = new G4LossTableBuilder(isMast << 179 firstParticle = 0;
143 emCorrections = new G4EmCorrections(verbose) << 180 subCutoffFlag = false;
144 << 181 maxRangeVariation = 0.2;
145 std::size_t n = 70; << 182 maxFinalStep = CLHEP::mm;
146 loss_vector.reserve(n); << 183 integral = true;
147 part_vector.reserve(n); << 184 integralActive = false;
148 base_part_vector.reserve(n); << 185 stepFunctionActive = false;
149 dedx_vector.reserve(n); << 186 isMaster = true;
150 range_vector.reserve(n); << 187 verbose = theParameters->Verbose();
151 inv_range_vector.reserve(n); << 188 theMessenger = new G4EnergyLossMessenger();
152 tables_are_built.reserve(n); << 189 theElectron = G4Electron::Electron();
153 isActive.reserve(n); << 190 theGenericIon= 0;
154 msc_vector.reserve(10); << 191 if(G4Threading::IsWorkerThread()) {
155 emp_vector.reserve(16); << 192 verbose = theParameters->WorkerVerbose();
156 mod_vector.reserve(150); << 193 isMaster = false;
157 fmod_vector.reserve(60); << 194 }
>> 195 tableBuilder = new G4LossTableBuilder();
>> 196 emCorrections= new G4EmCorrections(verbose);
>> 197 emSaturation = 0;
>> 198 emConfigurator = 0;
>> 199 emElectronIonPair = 0;
>> 200 atomDeexcitation = 0;
>> 201 subcutProducer = 0;
158 } 202 }
159 203
160 //....oooOO0OOooo........oooOO0OOooo........oo 204 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
161 205
162 void G4LossTableManager::Clear() 206 void G4LossTableManager::Clear()
163 { 207 {
164 all_tables_are_built = false; 208 all_tables_are_built = false;
165 currentLoss = nullptr; << 209 currentLoss = 0;
166 currentParticle = nullptr; << 210 currentParticle = 0;
167 if(n_loss) { << 211 if(n_loss)
168 dedx_vector.clear(); << 212 {
169 range_vector.clear(); << 213 dedx_vector.clear();
170 inv_range_vector.clear(); << 214 range_vector.clear();
171 loss_map.clear(); << 215 inv_range_vector.clear();
172 loss_vector.clear(); << 216 loss_map.clear();
173 part_vector.clear(); << 217 loss_vector.clear();
174 base_part_vector.clear(); << 218 part_vector.clear();
175 tables_are_built.clear(); << 219 base_part_vector.clear();
176 isActive.clear(); << 220 tables_are_built.clear();
177 n_loss = 0; << 221 isActive.clear();
178 } << 222 n_loss = 0;
>> 223 }
179 } 224 }
180 225
181 //....oooOO0OOooo........oooOO0OOooo........oo 226 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
182 227
183 void G4LossTableManager::Register(G4VEnergyLos 228 void G4LossTableManager::Register(G4VEnergyLossProcess* p)
184 { 229 {
185 if (nullptr == p) { return; } << 230 if(!p) { return; }
186 for (G4int i=0; i<n_loss; ++i) { 231 for (G4int i=0; i<n_loss; ++i) {
187 if(loss_vector[i] == p) { return; } 232 if(loss_vector[i] == p) { return; }
188 } 233 }
189 if(verbose > 1) { 234 if(verbose > 1) {
190 G4cout << "G4LossTableManager::Register G4 235 G4cout << "G4LossTableManager::Register G4VEnergyLossProcess : "
191 << p->GetProcessName() << " idx= " << 236 << p->GetProcessName() << " idx= " << n_loss << G4endl;
192 } 237 }
193 ++n_loss; 238 ++n_loss;
194 loss_vector.push_back(p); 239 loss_vector.push_back(p);
195 part_vector.push_back(nullptr); << 240 part_vector.push_back(0);
196 base_part_vector.push_back(nullptr); << 241 base_part_vector.push_back(0);
197 dedx_vector.push_back(nullptr); << 242 dedx_vector.push_back(0);
198 range_vector.push_back(nullptr); << 243 range_vector.push_back(0);
199 inv_range_vector.push_back(nullptr); << 244 inv_range_vector.push_back(0);
200 tables_are_built.push_back(false); 245 tables_are_built.push_back(false);
201 isActive.push_back(true); 246 isActive.push_back(true);
202 all_tables_are_built = false; 247 all_tables_are_built = false;
>> 248 if(subCutoffFlag) { p->ActivateSubCutoff(true); }
>> 249 if(stepFunctionActive) { p->SetStepFunction(maxRangeVariation,
>> 250 maxFinalStep); }
>> 251 if(integralActive) { p->SetIntegral(integral); }
203 } 252 }
204 253
205 //....oooOO0OOooo........oooOO0OOooo........oo 254 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
206 255
207 void G4LossTableManager::ResetParameters() 256 void G4LossTableManager::ResetParameters()
208 { 257 {
209 // initialisation once per run <<
210 if (!resetParam) { return; } <<
211 resetParam = false; <<
212 startInitialisation = true; <<
213 verbose = theParameters->Verbose(); 258 verbose = theParameters->Verbose();
214 if(!isMaster) { 259 if(!isMaster) {
215 verbose = theParameters->WorkerVerbose(); 260 verbose = theParameters->WorkerVerbose();
216 } else { <<
217 if(verbose > 0) { theParameters->Dump(); } <<
218 } 261 }
219 << 262 tableBuilder->SetSplineFlag(theParameters->Spline());
220 tableBuilder->InitialiseBaseMaterials(); << 263 tableBuilder->SetInitialisationFlag(false);
221 if (nullptr != nielCalculator) { nielCalcula <<
222 <<
223 emCorrections->SetVerbose(verbose); 264 emCorrections->SetVerbose(verbose);
224 if(nullptr != emConfigurator) { emConfigurat << 265 if(emSaturation) { emSaturation->SetVerbose(verbose); }
225 if(nullptr != emElectronIonPair) { emElectro << 266 if(emConfigurator) { emConfigurator->SetVerbose(verbose); };
226 if(nullptr != atomDeexcitation) { << 267 if(emElectronIonPair) { emElectronIonPair->SetVerbose(verbose); };
>> 268 if(atomDeexcitation) {
227 atomDeexcitation->SetVerboseLevel(verbose) 269 atomDeexcitation->SetVerboseLevel(verbose);
228 atomDeexcitation->InitialiseAtomicDeexcita << 270 atomDeexcitation->SetFluo(theParameters->Fluo());
229 } << 271 atomDeexcitation->SetAuger(theParameters->Auger());
230 if (1 < verbose) { << 272 atomDeexcitation->SetPIXE(theParameters->Pixe());
231 G4cout << "====== G4LossTableManager::Rese << 273 atomDeexcitation->SetIgnoreCuts(theParameters->DeexcitationIgnoreCut());
232 << " Nloss=" << loss_vector.size() <<
233 << " run=" << run << " master=" << isMast <<
234 << G4endl; <<
235 } 274 }
236 } 275 }
237 276
238 //....oooOO0OOooo........oooOO0OOooo........oo 277 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
239 278
240 void G4LossTableManager::DeRegister(G4VEnergyL 279 void G4LossTableManager::DeRegister(G4VEnergyLossProcess* p)
241 { 280 {
242 if (nullptr == p) { return; } << 281 if(!p) { return; }
243 for (G4int i=0; i<n_loss; ++i) { 282 for (G4int i=0; i<n_loss; ++i) {
244 if(loss_vector[i] == p) { << 283 if(loss_vector[i] == p) { loss_vector[i] = 0; }
245 loss_vector[i] = nullptr; <<
246 break; <<
247 } <<
248 } 284 }
249 } 285 }
250 286
251 //....oooOO0OOooo........oooOO0OOooo........oo 287 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
252 288
253 void G4LossTableManager::Register(G4VMultipleS 289 void G4LossTableManager::Register(G4VMultipleScattering* p)
254 { 290 {
255 if (nullptr == p) { return; } << 291 if(!p) { return; }
256 std::size_t n = msc_vector.size(); << 292 G4int n = msc_vector.size();
257 for (std::size_t i=0; i<n; ++i) { << 293 for (G4int i=0; i<n; ++i) {
258 if(msc_vector[i] == p) { return; } 294 if(msc_vector[i] == p) { return; }
259 } 295 }
260 if(verbose > 1) { 296 if(verbose > 1) {
261 G4cout << "G4LossTableManager::Register G4 297 G4cout << "G4LossTableManager::Register G4VMultipleScattering : "
262 << p->GetProcessName() << " idx= " << 298 << p->GetProcessName() << " idx= " << msc_vector.size() << G4endl;
263 } 299 }
264 msc_vector.push_back(p); 300 msc_vector.push_back(p);
265 } 301 }
266 302
267 //....oooOO0OOooo........oooOO0OOooo........oo 303 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
268 304
269 void G4LossTableManager::DeRegister(G4VMultipl 305 void G4LossTableManager::DeRegister(G4VMultipleScattering* p)
270 { 306 {
271 if (nullptr == p) { return; } << 307 if(!p) { return; }
272 std::size_t msc = msc_vector.size(); << 308 size_t msc = msc_vector.size();
273 for (std::size_t i=0; i<msc; ++i) { << 309 for (size_t i=0; i<msc; ++i) {
274 if(msc_vector[i] == p) { << 310 if(msc_vector[i] == p) { msc_vector[i] = 0; }
275 msc_vector[i] = nullptr; <<
276 break; <<
277 } <<
278 } 311 }
279 } 312 }
280 313
281 //....oooOO0OOooo........oooOO0OOooo........oo 314 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
282 315
283 void G4LossTableManager::Register(G4VEmProcess 316 void G4LossTableManager::Register(G4VEmProcess* p)
284 { 317 {
285 if (nullptr == p) { return; } << 318 if(!p) { return; }
286 std::size_t n = emp_vector.size(); << 319 G4int n = emp_vector.size();
287 for (std::size_t i=0; i<n; ++i) { << 320 for (G4int i=0; i<n; ++i) {
288 if(emp_vector[i] == p) { return; } 321 if(emp_vector[i] == p) { return; }
289 } 322 }
290 if(verbose > 1) { 323 if(verbose > 1) {
291 G4cout << "G4LossTableManager::Register G4 324 G4cout << "G4LossTableManager::Register G4VEmProcess : "
292 << p->GetProcessName() << " idx= " << 325 << p->GetProcessName() << " idx= " << emp_vector.size() << G4endl;
293 } 326 }
294 emp_vector.push_back(p); 327 emp_vector.push_back(p);
295 } 328 }
296 329
297 //....oooOO0OOooo........oooOO0OOooo........oo 330 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
298 331
299 void G4LossTableManager::DeRegister(G4VEmProce 332 void G4LossTableManager::DeRegister(G4VEmProcess* p)
300 { 333 {
301 if (nullptr == p) { return; } << 334 if(!p) { return; }
302 std::size_t emp = emp_vector.size(); << 335 size_t emp = emp_vector.size();
303 for (std::size_t i=0; i<emp; ++i) { << 336 for (size_t i=0; i<emp; ++i) {
304 if(emp_vector[i] == p) { << 337 if(emp_vector[i] == p) { emp_vector[i] = 0; }
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 } 338 }
339 } 339 }
340 340
341 //....oooOO0OOooo........oooOO0OOooo........oo 341 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
342 342
343 void G4LossTableManager::Register(G4VEmModel* 343 void G4LossTableManager::Register(G4VEmModel* p)
344 { 344 {
345 mod_vector.push_back(p); 345 mod_vector.push_back(p);
346 if(verbose > 1) { 346 if(verbose > 1) {
347 G4cout << "G4LossTableManager::Register G4 347 G4cout << "G4LossTableManager::Register G4VEmModel : "
348 << p->GetName() << " " << p << " << 348 << p->GetName() << G4endl;
349 } 349 }
350 } 350 }
351 351
352 //....oooOO0OOooo........oooOO0OOooo........oo 352 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
353 353
354 void G4LossTableManager::DeRegister(G4VEmModel 354 void G4LossTableManager::DeRegister(G4VEmModel* p)
355 { 355 {
356 //G4cout << "G4LossTableManager::DeRegister << 356 size_t n = mod_vector.size();
357 std::size_t n = mod_vector.size(); << 357 for (size_t i=0; i<n; ++i) {
358 for (std::size_t i=0; i<n; ++i) { << 358 if(mod_vector[i] == p) { mod_vector[i] = 0; }
359 if(mod_vector[i] == p) { <<
360 mod_vector[i] = nullptr; <<
361 break; <<
362 } <<
363 } 359 }
364 } 360 }
365 361
366 //....oooOO0OOooo........oooOO0OOooo........oo 362 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
367 363
368 void G4LossTableManager::Register(G4VEmFluctua 364 void G4LossTableManager::Register(G4VEmFluctuationModel* p)
369 { 365 {
370 fmod_vector.push_back(p); 366 fmod_vector.push_back(p);
371 if(verbose > 1) { 367 if(verbose > 1) {
372 G4cout << "G4LossTableManager::Register G4 368 G4cout << "G4LossTableManager::Register G4VEmFluctuationModel : "
373 << p->GetName() << " " << fmod_vec << 369 << p->GetName() << G4endl;
374 } 370 }
375 } 371 }
376 372
377 //....oooOO0OOooo........oooOO0OOooo........oo 373 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
378 374
379 void G4LossTableManager::DeRegister(G4VEmFluct 375 void G4LossTableManager::DeRegister(G4VEmFluctuationModel* p)
380 { 376 {
381 std::size_t n = fmod_vector.size(); << 377 size_t n = fmod_vector.size();
382 for (std::size_t i=0; i<n; ++i) { << 378 for (size_t i=0; i<n; ++i) {
383 if(fmod_vector[i] == p) { fmod_vector[i] = << 379 if(fmod_vector[i] == p) { fmod_vector[i] = 0; }
384 } 380 }
385 } 381 }
386 382
387 //....oooOO0OOooo........oooOO0OOooo........oo 383 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
388 384
389 void G4LossTableManager::RegisterExtraParticle 385 void G4LossTableManager::RegisterExtraParticle(
390 const G4ParticleDefinition* part, 386 const G4ParticleDefinition* part,
391 G4VEnergyLossProcess* p) 387 G4VEnergyLossProcess* p)
392 { 388 {
393 if (nullptr == p || nullptr == part) { retur << 389 if(!p || !part) { return; }
394 for (G4int i=0; i<n_loss; ++i) { 390 for (G4int i=0; i<n_loss; ++i) {
395 if(loss_vector[i] == p) { return; } 391 if(loss_vector[i] == p) { return; }
396 } 392 }
397 if(verbose > 1) { 393 if(verbose > 1) {
398 G4cout << "G4LossTableManager::RegisterExt 394 G4cout << "G4LossTableManager::RegisterExtraParticle "
399 << part->GetParticleName() << " G4 << 395 << part->GetParticleName() << " G4VEnergyLossProcess : "
400 << p->GetProcessName() << " idx= " << 396 << p->GetProcessName() << " idx= " << n_loss << G4endl;
401 } 397 }
402 ++n_loss; 398 ++n_loss;
403 loss_vector.push_back(p); 399 loss_vector.push_back(p);
404 part_vector.push_back(part); 400 part_vector.push_back(part);
405 base_part_vector.push_back(p->BaseParticle() 401 base_part_vector.push_back(p->BaseParticle());
406 dedx_vector.push_back(nullptr); << 402 dedx_vector.push_back(0);
407 range_vector.push_back(nullptr); << 403 range_vector.push_back(0);
408 inv_range_vector.push_back(nullptr); << 404 inv_range_vector.push_back(0);
409 tables_are_built.push_back(false); 405 tables_are_built.push_back(false);
410 all_tables_are_built = false; 406 all_tables_are_built = false;
411 } 407 }
412 408
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 409 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
435 410
436 void 411 void
437 G4LossTableManager::PreparePhysicsTable(const 412 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
438 G4VEne << 413 G4VEnergyLossProcess* p,
>> 414 G4bool theMaster)
439 { 415 {
440 if (1 < verbose) { 416 if (1 < verbose) {
441 G4cout << "G4LossTableManager::PreparePhys 417 G4cout << "G4LossTableManager::PreparePhysicsTable for "
442 << particle->GetParticleName() << 418 << particle->GetParticleName()
443 << " and " << p->GetProcessName() < << 419 << " and " << p->GetProcessName() << " run= " << run
444 << " loss_vector " << loss_vector << 420 << " loss_vector " << loss_vector.size() << G4endl;
445 << " run=" << run << " master=" << isMast << 421 }
446 << G4endl; << 422
>> 423 isMaster = theMaster;
>> 424
>> 425 if(!startInitialisation) {
>> 426 ResetParameters();
>> 427 if (1 < verbose) {
>> 428 G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
>> 429 << G4endl;
>> 430 }
447 } 431 }
448 432
449 // start initialisation for the first run 433 // start initialisation for the first run
450 if( -1 == run ) { 434 if( -1 == run ) {
451 if (nullptr != emConfigurator) { emConfigu << 435 if(emConfigurator) { emConfigurator->PrepareModels(particle, p); }
452 436
453 // initialise particles for given process 437 // initialise particles for given process
454 for (G4int j=0; j<n_loss; ++j) { 438 for (G4int j=0; j<n_loss; ++j) {
455 if (p == loss_vector[j] && nullptr == pa << 439 if (p == loss_vector[j] && !part_vector[j]) {
456 part_vector[j] = particle; << 440 part_vector[j] = particle;
457 if (particle->GetParticleName() == "Ge << 441 if(particle->GetParticleName() == "GenericIon") {
458 theGenericIon = particle; << 442 theGenericIon = particle;
459 } << 443 }
460 } 444 }
461 } 445 }
462 } 446 }
463 ResetParameters(); << 447 startInitialisation = true;
464 } 448 }
465 449
466 //....oooOO0OOooo........oooOO0OOooo........oo 450 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
467 451
468 void 452 void
469 G4LossTableManager::PreparePhysicsTable(const 453 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
470 G4VEmP << 454 G4VEmProcess* p, G4bool theMaster)
471 { 455 {
472 if (1 < verbose) { 456 if (1 < verbose) {
473 G4cout << "G4LossTableManager::PreparePhys 457 G4cout << "G4LossTableManager::PreparePhysicsTable for "
474 << particle->GetParticleName() << 458 << particle->GetParticleName()
475 << " and " << p->GetProcessName() << 459 << " and " << p->GetProcessName() << G4endl;
476 << " run=" << run << " master=" << isMast << 460 }
477 << G4endl; << 461 isMaster = theMaster;
>> 462
>> 463 if(!startInitialisation) {
>> 464 ResetParameters();
>> 465 if (1 < verbose) {
>> 466 G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
>> 467 << G4endl;
>> 468 }
478 } 469 }
479 470
480 // start initialisation for the first run 471 // start initialisation for the first run
481 if( -1 == run ) { 472 if( -1 == run ) {
482 if (nullptr != emConfigurator) { emConfigu << 473 if(emConfigurator) { emConfigurator->PrepareModels(particle, p); }
483 } 474 }
484 << 475 startInitialisation = true;
485 ResetParameters(); <<
486 } 476 }
487 477
488 //....oooOO0OOooo........oooOO0OOooo........oo 478 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
489 479
490 void 480 void
491 G4LossTableManager::PreparePhysicsTable(const 481 G4LossTableManager::PreparePhysicsTable(const G4ParticleDefinition* particle,
492 G4VMul << 482 G4VMultipleScattering* p,
>> 483 G4bool theMaster)
493 { 484 {
494 if (1 < verbose) { 485 if (1 < verbose) {
495 G4cout << "G4LossTableManager::PreparePhys 486 G4cout << "G4LossTableManager::PreparePhysicsTable for "
496 << particle->GetParticleName() << 487 << particle->GetParticleName()
497 << " and " << p->GetProcessName() << 488 << " and " << p->GetProcessName() << G4endl;
498 << " run=" << run << " master=" << isMast << 489 }
499 << G4endl; << 490
>> 491 isMaster = theMaster;
>> 492
>> 493 if(!startInitialisation) {
>> 494 ResetParameters();
>> 495 if (1 < verbose) {
>> 496 G4cout << "====== G4LossTableManager::PreparePhysicsTable start ====="
>> 497 << G4endl;
>> 498 }
500 } 499 }
501 500
502 // start initialisation for the first run 501 // start initialisation for the first run
503 if ( -1 == run ) { << 502 if( -1 == run ) {
504 if (nullptr != emConfigurator) { emConfigu << 503 if(emConfigurator) { emConfigurator->PrepareModels(particle, p); }
505 } 504 }
506 << 505 startInitialisation = true;
507 ResetParameters(); <<
508 } 506 }
509 507
510 //....oooOO0OOooo........oooOO0OOooo........oo 508 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
511 509
512 void 510 void
513 G4LossTableManager::BuildPhysicsTable(const G4 511 G4LossTableManager::BuildPhysicsTable(const G4ParticleDefinition*)
514 { 512 {
515 if(-1 == run && startInitialisation) { 513 if(-1 == run && startInitialisation) {
516 if (nullptr != emConfigurator) { emConfigu << 514 if(emConfigurator) { emConfigurator->Clear(); }
517 } 515 }
518 if (startInitialisation) { resetParam = true <<
519 } 516 }
520 517
521 //....oooOO0OOooo........oooOO0OOooo........oo 518 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
522 519
523 void G4LossTableManager::LocalPhysicsTables( 520 void G4LossTableManager::LocalPhysicsTables(
524 const G4ParticleDefinition* aParticle, 521 const G4ParticleDefinition* aParticle,
525 G4VEnergyLossProcess* p) 522 G4VEnergyLossProcess* p)
526 { 523 {
527 if (1 < verbose) { << 524 if(1 < verbose) {
528 G4cout << "### G4LossTableManager::LocalPh 525 G4cout << "### G4LossTableManager::LocalPhysicsTable() for "
529 << aParticle->GetParticleName() << 526 << aParticle->GetParticleName()
530 << " and process " << p->GetProcess << 527 << " and process " << p->GetProcessName()
531 << G4endl; << 528 << G4endl;
532 } 529 }
533 530
534 if(-1 == run && startInitialisation) { 531 if(-1 == run && startInitialisation) {
535 if (nullptr != emConfigurator) { emConfigu << 532 if(emConfigurator) { emConfigurator->Clear(); }
536 firstParticle = aParticle; 533 firstParticle = aParticle;
537 } 534 }
538 535
539 if (startInitialisation) { << 536 if(startInitialisation) {
540 ++run; 537 ++run;
541 if (1 < verbose) { << 538 SetVerbose(verbose);
>> 539 if(1 < verbose) {
542 G4cout << "===== G4LossTableManager::Loc 540 G4cout << "===== G4LossTableManager::LocalPhysicsTable() for run "
543 << run << " =====" << G4endl; << 541 << run << " =====" << G4endl;
544 } 542 }
545 currentParticle = nullptr; << 543 if(0 < verbose) { emSaturation->DumpG4BirksCoefficients(); }
>> 544 if(atomDeexcitation) {
>> 545 atomDeexcitation->InitialiseAtomicDeexcitation();
>> 546 }
>> 547 currentParticle = 0;
546 startInitialisation = false; 548 startInitialisation = false;
547 resetParam = true; <<
548 for (G4int i=0; i<n_loss; ++i) { 549 for (G4int i=0; i<n_loss; ++i) {
549 if (nullptr != loss_vector[i]) { << 550 if(loss_vector[i]) {
550 tables_are_built[i] = false; << 551 tables_are_built[i] = false;
551 } else { 552 } else {
552 tables_are_built[i] = true; << 553 tables_are_built[i] = true;
553 part_vector[i] = nullptr; << 554 part_vector[i] = 0;
554 } 555 }
555 } 556 }
556 } 557 }
557 558
558 all_tables_are_built= true; 559 all_tables_are_built= true;
559 for (G4int i=0; i<n_loss; ++i) { 560 for (G4int i=0; i<n_loss; ++i) {
560 if(p == loss_vector[i]) { 561 if(p == loss_vector[i]) {
561 tables_are_built[i] = true; 562 tables_are_built[i] = true;
562 isActive[i] = true; 563 isActive[i] = true;
>> 564 /*
>> 565 const G4ProcessManager* pm = p->GetProcessManager();
>> 566 isActive[i] = false;
>> 567 if(pm) { isActive[i] = pm->GetProcessActivation(p); }
>> 568 */
563 part_vector[i] = p->Particle(); 569 part_vector[i] = p->Particle();
564 base_part_vector[i] = p->BaseParticle(); 570 base_part_vector[i] = p->BaseParticle();
565 dedx_vector[i] = p->DEDXTable(); 571 dedx_vector[i] = p->DEDXTable();
566 range_vector[i] = p->RangeTableForLoss() 572 range_vector[i] = p->RangeTableForLoss();
567 inv_range_vector[i] = p->InverseRangeTab 573 inv_range_vector[i] = p->InverseRangeTable();
568 if(0 == run && p->IsIonisationProcess()) 574 if(0 == run && p->IsIonisationProcess()) {
569 loss_map[part_vector[i]] = p; << 575 loss_map[part_vector[i]] = loss_vector[i];
570 } 576 }
571 577
572 if(1 < verbose) { 578 if(1 < verbose) {
573 G4cout << i <<". "<< p->GetProcessNa << 579 G4cout << i <<". "<< p->GetProcessName();
574 if(part_vector[i]) { << 580 if(part_vector[i]) {
575 G4cout << " for " << part_vector[i << 581 G4cout << " for " << part_vector[i]->GetParticleName();
576 } << 582 }
577 G4cout << " active= " << isActive[i] << 583 G4cout << " active= " << isActive[i]
578 << " table= " << tables_are_bu << 584 << " table= " << tables_are_built[i]
579 << " isIonisation= " << p->IsI << 585 << " isIonisation= " << p->IsIonisationProcess()
580 << G4endl; << 586 << G4endl;
581 } 587 }
582 break; 588 break;
583 } else if(!tables_are_built[i]) { 589 } else if(!tables_are_built[i]) {
584 all_tables_are_built = false; 590 all_tables_are_built = false;
585 } 591 }
586 } 592 }
587 593
>> 594 // Set run time parameters
>> 595 SetParameters(aParticle, p);
>> 596
588 if(1 < verbose) { 597 if(1 < verbose) {
589 G4cout << "### G4LossTableManager::LocalPh 598 G4cout << "### G4LossTableManager::LocalPhysicsTable end"
590 << G4endl; << 599 << G4endl;
591 } 600 }
592 if(all_tables_are_built) { 601 if(all_tables_are_built) {
593 if(1 < verbose) { 602 if(1 < verbose) {
594 G4cout << "%%%%% All dEdx and Range tabl 603 G4cout << "%%%%% All dEdx and Range tables for worker are ready for run "
595 << run << " %%%%%" << G4endl; << 604 << run << " %%%%%" << G4endl;
596 } 605 }
597 } 606 }
598 } 607 }
599 608
600 //....oooOO0OOooo........oooOO0OOooo........oo 609 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
601 610
602 void G4LossTableManager::BuildPhysicsTable( 611 void G4LossTableManager::BuildPhysicsTable(
603 const G4ParticleDefinition* aParticle, 612 const G4ParticleDefinition* aParticle,
604 G4VEnergyLossProcess* p) 613 G4VEnergyLossProcess* p)
605 { 614 {
606 if(1 < verbose) { 615 if(1 < verbose) {
607 G4cout << "### G4LossTableManager::BuildPh 616 G4cout << "### G4LossTableManager::BuildPhysicsTable() for "
608 << aParticle->GetParticleName() 617 << aParticle->GetParticleName()
609 << " and process " << p->GetProcess << 618 << " and process " << p->GetProcessName() << G4endl;
610 } 619 }
611 // clear configurator 620 // clear configurator
612 if(-1 == run && startInitialisation) { 621 if(-1 == run && startInitialisation) {
613 if( nullptr != emConfigurator) { emConfigu << 622 if(emConfigurator) { emConfigurator->Clear(); }
614 firstParticle = aParticle; 623 firstParticle = aParticle;
615 } 624 }
616 if(startInitialisation) { 625 if(startInitialisation) {
617 ++run; 626 ++run;
618 resetParam = true; <<
619 startInitialisation = false; <<
620 if(1 < verbose) { 627 if(1 < verbose) {
621 G4cout << "===== G4LossTableManager::Bui 628 G4cout << "===== G4LossTableManager::BuildPhysicsTable() for run "
622 << run << " ===== " << atomDeexci << 629 << run << " ===== " << atomDeexcitation << G4endl;
>> 630 }
>> 631 if(atomDeexcitation) {
>> 632 atomDeexcitation->InitialiseAtomicDeexcitation();
623 } 633 }
624 currentParticle = nullptr; << 634 currentParticle = 0;
625 all_tables_are_built = false; << 635 all_tables_are_built= true;
>> 636 }
>> 637
>> 638 // initialisation before any table is built
>> 639 if ( startInitialisation && aParticle == firstParticle ) {
626 640
>> 641 startInitialisation = false;
>> 642 if(1 < verbose) {
>> 643 G4cout << "### G4LossTableManager start initilisation for first particle "
>> 644 << firstParticle->GetParticleName()
>> 645 << G4endl;
>> 646 }
627 for (G4int i=0; i<n_loss; ++i) { 647 for (G4int i=0; i<n_loss; ++i) {
628 G4VEnergyLossProcess* el = loss_vector[i 648 G4VEnergyLossProcess* el = loss_vector[i];
629 649
630 if(nullptr != el) { << 650 if(el) {
631 isActive[i] = true; 651 isActive[i] = true;
632 part_vector[i] = el->Particle(); << 652 /*
633 base_part_vector[i] = el->BaseParticle << 653 const G4ProcessManager* pm = el->GetProcessManager();
634 tables_are_built[i] = false; << 654 isActive[i] = false;
635 if(1 < verbose) { << 655 if(pm) { isActive[i] = pm->GetProcessActivation(el); }
636 G4cout << i <<". "<< el->GetProces << 656 */
>> 657 base_part_vector[i] = el->BaseParticle();
>> 658 tables_are_built[i] = false;
>> 659 all_tables_are_built= false;
>> 660 if(!isActive[i]) {
>> 661 el->SetIonisation(false);
>> 662 tables_are_built[i] = true;
>> 663 }
>> 664
>> 665 if(1 < verbose) {
>> 666 G4cout << i <<". "<< el->GetProcessName();
637 if(el->Particle()) { 667 if(el->Particle()) {
638 G4cout << " for " << el->Particl << 668 G4cout << " for " << el->Particle()->GetParticleName();
639 } << 669 }
640 G4cout << " active= " << isActive[i << 670 G4cout << " active= " << isActive[i]
641 << " table= " << tables_are_ 671 << " table= " << tables_are_built[i]
642 << " isIonisation= " << el-> << 672 << " isIonisation= " << el->IsIonisationProcess();
643 if(base_part_vector[i]) { << 673 if(base_part_vector[i]) {
644 G4cout << " base particle " << 674 G4cout << " base particle "
645 << base_part_vector[i]->Get << 675 << base_part_vector[i]->GetParticleName();
646 } << 676 }
647 G4cout << G4endl; << 677 G4cout << G4endl;
648 } << 678 }
649 } else { 679 } else {
650 tables_are_built[i] = true; 680 tables_are_built[i] = true;
651 part_vector[i] = nullptr; << 681 part_vector[i] = 0;
652 isActive[i] = false; << 682 isActive[i] = false;
653 } 683 }
654 } 684 }
655 } 685 }
656 686
657 if (all_tables_are_built) { << 687 // Set run time parameters
658 theParameters->SetIsPrintedFlag(true); << 688 SetParameters(aParticle, p);
659 return; << 689
660 } << 690 if (all_tables_are_built) { return; }
661 691
662 // Build tables for given particle 692 // Build tables for given particle
663 all_tables_are_built = true; 693 all_tables_are_built = true;
664 694
665 for(G4int i=0; i<n_loss; ++i) { 695 for(G4int i=0; i<n_loss; ++i) {
666 if(p == loss_vector[i] && !tables_are_buil << 696 if(p == loss_vector[i] && !tables_are_built[i] && !base_part_vector[i]) {
667 const G4ParticleDefinition* curr_part = 697 const G4ParticleDefinition* curr_part = part_vector[i];
668 if(1 < verbose) { 698 if(1 < verbose) {
669 G4cout << "### Build Table for " << p- 699 G4cout << "### Build Table for " << p->GetProcessName()
670 << " and " << curr_part->GetPar << 700 << " and " << curr_part->GetParticleName() << G4endl;
671 << " " << tables_are_built[i] <<
672 << G4endl; <<
673 } 701 }
674 G4VEnergyLossProcess* curr_proc = BuildT 702 G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
675 if(curr_proc) { << 703 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 } 704 }
685 if ( !tables_are_built[i] ) { all_tables_a 705 if ( !tables_are_built[i] ) { all_tables_are_built = false; }
686 } 706 }
>> 707 if(0 == run && p->IsIonisationProcess()) { loss_map[aParticle] = p; }
>> 708
687 if(1 < verbose) { 709 if(1 < verbose) {
688 G4cout << "### G4LossTableManager::BuildPh 710 G4cout << "### G4LossTableManager::BuildPhysicsTable end: "
689 << "all_tables_are_built= " << all_ << 711 << "all_tables_are_built= " << all_tables_are_built
690 << aParticle->GetParticleName() << << 712 << G4endl;
>> 713 }
>> 714 if(all_tables_are_built) {
>> 715 if(1 < verbose) {
>> 716 G4cout << "%%%%% All dEdx and Range tables are built for master run= "
>> 717 << run << " %%%%%" << G4endl;
>> 718 }
691 } 719 }
692 } 720 }
693 721
694 //....oooOO0OOooo........oooOO0OOooo........oo 722 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
695 723
696 void G4LossTableManager::CopyTables(const G4Pa 724 void G4LossTableManager::CopyTables(const G4ParticleDefinition* part,
697 G4VEnergyL << 725 G4VEnergyLossProcess* base_proc)
698 { 726 {
699 for (G4int j=0; j<n_loss; ++j) { 727 for (G4int j=0; j<n_loss; ++j) {
700 728
701 G4VEnergyLossProcess* proc = loss_vector[j 729 G4VEnergyLossProcess* proc = loss_vector[j];
702 730
703 if (!tables_are_built[j] && part == base_p 731 if (!tables_are_built[j] && part == base_part_vector[j]) {
704 tables_are_built[j] = true; 732 tables_are_built[j] = true;
705 // for base particle approach only ionis <<
706 proc->SetDEDXTable(base_proc->Ionisation 733 proc->SetDEDXTable(base_proc->IonisationTable(),fRestricted);
>> 734 proc->SetDEDXTable(base_proc->DEDXTableForSubsec(),fSubRestricted);
707 proc->SetDEDXTable(base_proc->DEDXunRest 735 proc->SetDEDXTable(base_proc->DEDXunRestrictedTable(),fTotal);
708 proc->SetCSDARangeTable(base_proc->CSDAR 736 proc->SetCSDARangeTable(base_proc->CSDARangeTable());
709 proc->SetRangeTableForLoss(base_proc->Ra 737 proc->SetRangeTableForLoss(base_proc->RangeTableForLoss());
710 proc->SetInverseRangeTable(base_proc->In 738 proc->SetInverseRangeTable(base_proc->InverseRangeTable());
711 proc->SetLambdaTable(base_proc->LambdaTa 739 proc->SetLambdaTable(base_proc->LambdaTable());
>> 740 proc->SetSubLambdaTable(base_proc->SubLambdaTable());
>> 741 proc->SetIonisation(base_proc->IsIonisationProcess());
712 if(proc->IsIonisationProcess()) { 742 if(proc->IsIonisationProcess()) {
713 range_vector[j] = base_proc->RangeTabl << 743 range_vector[j] = base_proc->RangeTableForLoss();
714 inv_range_vector[j] = base_proc->Inver << 744 inv_range_vector[j] = base_proc->InverseRangeTable();
715 loss_map[part_vector[j]] = proc; << 745 loss_map[part_vector[j]] = proc;
716 //G4cout << "G4LossTableManager::CopyT <<
717 // << part_vector[j]->GetParticl <<
718 // << " added to map " << proc < <<
719 } 746 }
720 if (1 < verbose) { 747 if (1 < verbose) {
721 G4cout << " CopyTables for " << pro << 748 G4cout << "For " << proc->GetProcessName()
722 << " for " << part_vector[j]-> 749 << " for " << part_vector[j]->GetParticleName()
723 << " base_part= " << part->Get 750 << " base_part= " << part->GetParticleName()
724 << " tables are assigned" << 751 << " tables are assigned "
725 << G4endl; 752 << G4endl;
726 } 753 }
727 } 754 }
>> 755
>> 756 if (theElectron == part && theElectron == proc->SecondaryParticle() ) {
>> 757 proc->SetSecondaryRangeTable(base_proc->RangeTableForLoss());
>> 758 }
728 } 759 }
729 } 760 }
730 761
731 //....oooOO0OOooo........oooOO0OOooo........oo 762 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
732 763
733 G4VEnergyLossProcess* G4LossTableManager::Buil 764 G4VEnergyLossProcess* G4LossTableManager::BuildTables(
734 const G4ParticleDefiniti 765 const G4ParticleDefinition* aParticle)
735 { 766 {
736 if(1 < verbose) { 767 if(1 < verbose) {
737 G4cout << " G4LossTableManager::BuildTab << 768 G4cout << "G4LossTableManager::BuildTables() for "
738 << aParticle->GetParticleName() << 769 << aParticle->GetParticleName() << G4endl;
739 } 770 }
740 771
741 std::vector<G4PhysicsTable*> t_list; 772 std::vector<G4PhysicsTable*> t_list;
742 std::vector<G4VEnergyLossProcess*> loss_list 773 std::vector<G4VEnergyLossProcess*> loss_list;
743 std::vector<G4bool> build_flags; 774 std::vector<G4bool> build_flags;
744 G4VEnergyLossProcess* em = nullptr; << 775 G4VEnergyLossProcess* em = 0;
745 G4VEnergyLossProcess* p = nullptr; << 776 G4VEnergyLossProcess* p = 0;
746 G4int iem = 0; 777 G4int iem = 0;
747 G4PhysicsTable* dedx = nullptr; << 778 G4PhysicsTable* dedx = 0;
748 G4int i; 779 G4int i;
749 780
750 G4ProcessVector* pvec = 781 G4ProcessVector* pvec =
751 aParticle->GetProcessManager()->GetProcess 782 aParticle->GetProcessManager()->GetProcessList();
752 G4int nvec = (G4int)pvec->size(); << 783 G4int nvec = pvec->size();
753 784
754 for (i=0; i<n_loss; ++i) { 785 for (i=0; i<n_loss; ++i) {
755 p = loss_vector[i]; 786 p = loss_vector[i];
756 if (nullptr != p) { << 787 if (p) {
757 G4bool yes = (aParticle == part_vector[i 788 G4bool yes = (aParticle == part_vector[i]);
758 789
759 // possible case of process sharing betw 790 // possible case of process sharing between particle/anti-particle
760 if(!yes) { 791 if(!yes) {
761 auto ptr = static_cast<G4VProcess*>(p) << 792 G4VProcess* ptr = static_cast<G4VProcess*>(p);
762 for(G4int j=0; j<nvec; ++j) { 793 for(G4int j=0; j<nvec; ++j) {
763 //G4cout << "j= " << j << " " << (*p 794 //G4cout << "j= " << j << " " << (*pvec)[j] << " " << ptr << G4endl;
764 if(ptr == (*pvec)[j]) { 795 if(ptr == (*pvec)[j]) {
765 yes = true; << 796 yes = true;
766 break; 797 break;
767 } << 798 }
768 } << 799 }
769 } 800 }
770 // process belong to this particle 801 // process belong to this particle
771 if(yes && isActive[i]) { 802 if(yes && isActive[i]) {
772 if (p->IsIonisationProcess() || !em) { << 803 if (p->IsIonisationProcess() || !em) {
773 em = p; << 804 em = p;
774 iem= i; << 805 iem= i;
775 } << 806 }
776 // tables may be shared between partic << 807 // tables may be shared between particle/anti-particle
777 G4bool val = false; << 808 G4bool val = false;
778 if (!tables_are_built[i]) { << 809 if (!tables_are_built[i]) {
779 val = true; 810 val = true;
780 dedx = p->BuildDEDXTable(fRestricted << 811 dedx = p->BuildDEDXTable(fRestricted);
781 //G4cout << "===Build DEDX table for << 812 //G4cout << "Build DEDX table for " << p->GetProcessName()
782 // << " idx= " << i << " dedx:" << d << 813 // << " idx= " << i << dedx << " " << dedx->length() << G4endl;
783 p->SetDEDXTable(dedx,fRestricted); << 814 p->SetDEDXTable(dedx,fRestricted);
784 tables_are_built[i] = true; << 815 tables_are_built[i] = true;
785 } else { << 816 } else {
786 dedx = p->DEDXTable(); 817 dedx = p->DEDXTable();
787 } << 818 }
788 t_list.push_back(dedx); << 819 t_list.push_back(dedx);
789 loss_list.push_back(p); << 820 loss_list.push_back(p);
790 build_flags.push_back(val); 821 build_flags.push_back(val);
791 } 822 }
792 } 823 }
793 } 824 }
794 825
795 G4int n_dedx = (G4int)t_list.size(); << 826 G4int n_dedx = t_list.size();
796 if (0 == n_dedx || !em) { 827 if (0 == n_dedx || !em) {
797 G4cout << "G4LossTableManager WARNING: no 828 G4cout << "G4LossTableManager WARNING: no DEDX processes for "
798 << aParticle->GetParticleName() << << 829 << aParticle->GetParticleName() << G4endl;
799 return nullptr; << 830 return 0;
800 } 831 }
801 G4int nSubRegions = em->NumberOfSubCutoffReg 832 G4int nSubRegions = em->NumberOfSubCutoffRegions();
802 833
803 if (1 < verbose) { 834 if (1 < verbose) {
804 G4cout << " Start to build the sum of << 835 G4cout << "G4LossTableManager::BuildTables() start to build range tables"
>> 836 << " and the sum of " << n_dedx << " processes"
805 << " iem= " << iem << " em= " << em 837 << " iem= " << iem << " em= " << em->GetProcessName()
806 << " buildCSDARange= " << theParame 838 << " buildCSDARange= " << theParameters->BuildCSDARange()
807 << " nSubRegions= " << nSubRegions; << 839 << " nSubRegions= " << nSubRegions;
808 if(subcutProducer) { 840 if(subcutProducer) {
809 G4cout << " SubCutProducer " << subcutPr 841 G4cout << " SubCutProducer " << subcutProducer->GetName();
810 } 842 }
811 G4cout << G4endl; 843 G4cout << G4endl;
812 } 844 }
813 // do not build tables if producer class is 845 // do not build tables if producer class is defined
814 if(subcutProducer) { nSubRegions = 0; } 846 if(subcutProducer) { nSubRegions = 0; }
815 847
816 dedx = em->DEDXTable(); << 848 dedx = em->DEDXTable();
>> 849 em->SetIonisation(true);
817 em->SetDEDXTable(dedx, fIsIonisation); 850 em->SetDEDXTable(dedx, fIsIonisation);
818 851
819 if (1 < n_dedx) { 852 if (1 < n_dedx) {
820 dedx = nullptr; << 853 dedx = 0;
821 dedx = G4PhysicsTableHelper::PreparePhysic 854 dedx = G4PhysicsTableHelper::PreparePhysicsTable(dedx);
822 tableBuilder->BuildDEDXTable(dedx, t_list) 855 tableBuilder->BuildDEDXTable(dedx, t_list);
823 em->SetDEDXTable(dedx, fRestricted); 856 em->SetDEDXTable(dedx, fRestricted);
824 } 857 }
825 858
>> 859 /*
>> 860 if(2==run && "e-" == aParticle->GetParticleName()) {
>> 861 G4cout << "G4LossTableManager::BuildTables for e- " << dedx << G4endl;
>> 862 G4cout << (*dedx) << G4endl;
>> 863 G4cout << "%%%%% Instance ID= " << (*dedx)[0]->GetInstanceID() << G4endl;
>> 864 G4cout << "%%%%% LastValue= " << (*dedx)[0]->GetLastValue() << G4endl;
>> 865 G4cout << "%%%%% 1.2 " << (*(dedx))[0]->Value(1.2) << G4endl;
>> 866 }
>> 867 */
826 dedx_vector[iem] = dedx; 868 dedx_vector[iem] = dedx;
827 869
828 G4PhysicsTable* range = em->RangeTableForLos 870 G4PhysicsTable* range = em->RangeTableForLoss();
829 if(!range) range = G4PhysicsTableHelper::Pr 871 if(!range) range = G4PhysicsTableHelper::PreparePhysicsTable(range);
830 range_vector[iem] = range; 872 range_vector[iem] = range;
831 873
832 G4PhysicsTable* invrange = em->InverseRangeT 874 G4PhysicsTable* invrange = em->InverseRangeTable();
833 if(!invrange) invrange = G4PhysicsTableHelpe 875 if(!invrange) invrange = G4PhysicsTableHelper::PreparePhysicsTable(invrange);
834 inv_range_vector[iem] = invrange; 876 inv_range_vector[iem] = invrange;
835 877
836 tableBuilder->BuildRangeTable(dedx, range); << 878 tableBuilder->BuildRangeTable(dedx, range, true);
837 tableBuilder->BuildInverseRangeTable(range, << 879 tableBuilder->BuildInverseRangeTable(range, invrange, true);
>> 880
>> 881 // if(1<verbose) G4cout << *dedx << G4endl;
838 882
839 em->SetRangeTableForLoss(range); 883 em->SetRangeTableForLoss(range);
840 em->SetInverseRangeTable(invrange); 884 em->SetInverseRangeTable(invrange);
841 885
>> 886 // if(1<verbose) G4cout << *range << G4endl;
>> 887
>> 888 std::vector<G4PhysicsTable*> listSub;
842 std::vector<G4PhysicsTable*> listCSDA; 889 std::vector<G4PhysicsTable*> listCSDA;
843 890
844 for (i=0; i<n_dedx; ++i) { 891 for (i=0; i<n_dedx; ++i) {
845 p = loss_list[i]; 892 p = loss_list[i];
>> 893 if(p != em) { p->SetIonisation(false); }
846 if(build_flags[i]) { 894 if(build_flags[i]) {
847 p->SetLambdaTable(p->BuildLambdaTable(fR 895 p->SetLambdaTable(p->BuildLambdaTable(fRestricted));
848 } 896 }
>> 897 if (0 < nSubRegions) {
>> 898 dedx = p->BuildDEDXTable(fSubRestricted);
>> 899 p->SetDEDXTable(dedx,fSubRestricted);
>> 900 listSub.push_back(dedx);
>> 901 if(build_flags[i]) {
>> 902 p->SetSubLambdaTable(p->BuildLambdaTable(fSubRestricted));
>> 903 if(p != em) { em->AddCollaborativeProcess(p); }
>> 904 }
>> 905 }
849 if(theParameters->BuildCSDARange()) { 906 if(theParameters->BuildCSDARange()) {
850 dedx = p->BuildDEDXTable(fTotal); 907 dedx = p->BuildDEDXTable(fTotal);
851 p->SetDEDXTable(dedx,fTotal); 908 p->SetDEDXTable(dedx,fTotal);
852 listCSDA.push_back(dedx); 909 listCSDA.push_back(dedx);
853 } 910 }
854 } 911 }
855 912
>> 913 if (0 < nSubRegions) {
>> 914 G4PhysicsTable* dedxSub = em->IonisationTableForSubsec();
>> 915 if (1 < listSub.size()) {
>> 916 em->SetDEDXTable(dedxSub, fIsSubIonisation);
>> 917 dedxSub = 0;
>> 918 dedxSub = G4PhysicsTableHelper::PreparePhysicsTable(dedxSub);
>> 919 tableBuilder->BuildDEDXTable(dedxSub, listSub);
>> 920 em->SetDEDXTable(dedxSub, fSubRestricted);
>> 921 }
>> 922 }
856 if(theParameters->BuildCSDARange()) { 923 if(theParameters->BuildCSDARange()) {
857 G4PhysicsTable* dedxCSDA = em->DEDXunRestr 924 G4PhysicsTable* dedxCSDA = em->DEDXunRestrictedTable();
858 if (1 < n_dedx) { 925 if (1 < n_dedx) {
859 dedxCSDA = G4PhysicsTableHelper::Prepare << 926 dedxCSDA = 0;
>> 927 dedxCSDA = G4PhysicsTableHelper::PreparePhysicsTable(dedxCSDA);
860 tableBuilder->BuildDEDXTable(dedxCSDA, l 928 tableBuilder->BuildDEDXTable(dedxCSDA, listCSDA);
861 em->SetDEDXTable(dedxCSDA,fTotal); 929 em->SetDEDXTable(dedxCSDA,fTotal);
862 } 930 }
863 G4PhysicsTable* rCSDA = em->CSDARangeTable 931 G4PhysicsTable* rCSDA = em->CSDARangeTable();
864 if(!rCSDA) { rCSDA = G4PhysicsTableHelper: 932 if(!rCSDA) { rCSDA = G4PhysicsTableHelper::PreparePhysicsTable(rCSDA); }
865 tableBuilder->BuildRangeTable(dedxCSDA, rC << 933 tableBuilder->BuildRangeTable(dedxCSDA, rCSDA, true);
866 em->SetCSDARangeTable(rCSDA); 934 em->SetCSDARangeTable(rCSDA);
867 } 935 }
868 936
869 if (1 < verbose) { 937 if (1 < verbose) {
870 G4cout << "G4LossTableManager::BuildTables 938 G4cout << "G4LossTableManager::BuildTables: Tables are built for "
871 << aParticle->GetParticleName() 939 << aParticle->GetParticleName()
872 << "; ionisation process: " << em-> << 940 << "; ionisation process: " << em->GetProcessName()
873 << " " << em << 941 << " " << em
874 << G4endl; 942 << G4endl;
875 } 943 }
876 return em; 944 return em;
877 } 945 }
878 946
879 //....oooOO0OOooo........oooOO0OOooo........oo 947 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
880 948
>> 949 G4EnergyLossMessenger* G4LossTableManager::GetMessenger()
>> 950 {
>> 951 return theMessenger;
>> 952 }
>> 953
>> 954 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 955
881 void G4LossTableManager::ParticleHaveNoLoss( 956 void G4LossTableManager::ParticleHaveNoLoss(
882 const G4ParticleDefinition* aParticle) 957 const G4ParticleDefinition* aParticle)
883 { 958 {
884 G4ExceptionDescription ed; 959 G4ExceptionDescription ed;
885 ed << "Energy loss process not found for " < 960 ed << "Energy loss process not found for " << aParticle->GetParticleName()
886 << " !"; 961 << " !";
887 G4Exception("G4LossTableManager::ParticleHav 962 G4Exception("G4LossTableManager::ParticleHaveNoLoss", "em0001",
888 FatalException, ed); << 963 FatalException, ed);
>> 964 }
>> 965
>> 966 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 967
>> 968 G4bool G4LossTableManager::BuildCSDARange() const
>> 969 {
>> 970 return theParameters->BuildCSDARange();
>> 971 }
>> 972
>> 973 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 974
>> 975 void G4LossTableManager::SetLossFluctuations(G4bool /*val*/)
>> 976 {
>> 977 }
>> 978
>> 979 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 980
>> 981 void G4LossTableManager::SetSubCutoff(G4bool val, const G4Region* r)
>> 982 {
>> 983 subCutoffFlag = val;
>> 984 for(G4int i=0; i<n_loss; ++i) {
>> 985 if(loss_vector[i]) { loss_vector[i]->ActivateSubCutoff(val, r); }
>> 986 }
>> 987 }
>> 988
>> 989 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 990
>> 991 void G4LossTableManager::SetIntegral(G4bool val)
>> 992 {
>> 993 integral = val;
>> 994 integralActive = true;
>> 995 for(G4int i=0; i<n_loss; ++i) {
>> 996 if(loss_vector[i]) { loss_vector[i]->SetIntegral(val); }
>> 997 }
>> 998 size_t emp = emp_vector.size();
>> 999 for (size_t k=0; k<emp; ++k) {
>> 1000 if(emp_vector[k]) { emp_vector[k]->SetIntegral(val); }
>> 1001 }
>> 1002 }
>> 1003
>> 1004 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1005
>> 1006 void G4LossTableManager::SetMinSubRange(G4double /*val*/)
>> 1007 {
>> 1008 }
>> 1009
>> 1010 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1011
>> 1012 void G4LossTableManager::SetRandomStep(G4bool /*val*/)
>> 1013 {
>> 1014 }
>> 1015
>> 1016 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1017
>> 1018 void G4LossTableManager::SetMinEnergy(G4double val)
>> 1019 {
>> 1020 theParameters->SetMinEnergy(val);
>> 1021 }
>> 1022
>> 1023 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1024
>> 1025 void G4LossTableManager::SetMaxEnergy(G4double val)
>> 1026 {
>> 1027 theParameters->SetMaxEnergy(val);
>> 1028 }
>> 1029
>> 1030 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1031
>> 1032 void G4LossTableManager::SetMaxEnergyForCSDARange(G4double val)
>> 1033 {
>> 1034 theParameters->SetMaxEnergyForCSDARange(val);
>> 1035 }
>> 1036
>> 1037 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1038
>> 1039 void G4LossTableManager::SetMaxEnergyForMuons(G4double val)
>> 1040 {
>> 1041 theParameters->SetMaxEnergy(val);
>> 1042 }
>> 1043
>> 1044 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1045
>> 1046 void G4LossTableManager::SetDEDXBinning(G4int val)
>> 1047 {
>> 1048 theParameters->SetNumberOfBins(val);
>> 1049 }
>> 1050
>> 1051 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1052
>> 1053 void G4LossTableManager::SetDEDXBinningForCSDARange(G4int /*n*/)
>> 1054 {
>> 1055 }
>> 1056
>> 1057 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1058
>> 1059 void G4LossTableManager::SetLambdaBinning(G4int val)
>> 1060 {
>> 1061 theParameters->SetNumberOfBins(val);
>> 1062 }
>> 1063
>> 1064 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1065
>> 1066 G4int G4LossTableManager::GetNumberOfBinsPerDecade() const
>> 1067 {
>> 1068 return theParameters->NumberOfBinsPerDecade();
>> 1069 }
>> 1070
>> 1071 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1072
>> 1073 void G4LossTableManager::SetVerbose(G4int /*val*/)
>> 1074 {
>> 1075 }
>> 1076
>> 1077 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1078
>> 1079 void G4LossTableManager::SetStepFunction(G4double v1, G4double v2)
>> 1080 {
>> 1081 if(0.0 < v1 && 0.0 < v2 && v2 < 1.e+50) {
>> 1082 stepFunctionActive = true;
>> 1083 maxRangeVariation = v1;
>> 1084 maxFinalStep = v2;
>> 1085 for(G4int i=0; i<n_loss; ++i) {
>> 1086 if(loss_vector[i]) { loss_vector[i]->SetStepFunction(v1, v2); }
>> 1087 }
>> 1088 } else if(v1 <= 0.0) {
>> 1089 PrintEWarning("SetStepFunction", v1);
>> 1090 } else {
>> 1091 PrintEWarning("SetStepFunction", v2);
>> 1092 }
>> 1093 }
>> 1094
>> 1095 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1096
>> 1097 void G4LossTableManager::SetLinearLossLimit(G4double /*val*/)
>> 1098 {
889 } 1099 }
890 1100
891 //....oooOO0OOooo........oooOO0OOooo........oo 1101 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
892 1102
893 void G4LossTableManager::SetVerbose(G4int val) << 1103 void G4LossTableManager::SetBuildCSDARange(G4bool /*val*/)
894 { 1104 {
895 verbose = val; << 1105 }
>> 1106
>> 1107 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1108
>> 1109 void
>> 1110 G4LossTableManager::SetParameters(const G4ParticleDefinition* /*aParticle*/,
>> 1111 G4VEnergyLossProcess* p)
>> 1112 {
>> 1113 if(stepFunctionActive) {
>> 1114 p->SetStepFunction(maxRangeVariation, maxFinalStep);
>> 1115 }
>> 1116 if(integralActive) { p->SetIntegral(integral); }
896 } 1117 }
897 1118
898 //....oooOO0OOooo........oooOO0OOooo........oo 1119 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
899 1120
900 const std::vector<G4VEnergyLossProcess*>& 1121 const std::vector<G4VEnergyLossProcess*>&
901 G4LossTableManager::GetEnergyLossProcessVector 1122 G4LossTableManager::GetEnergyLossProcessVector()
902 { 1123 {
903 return loss_vector; 1124 return loss_vector;
904 } 1125 }
905 1126
906 //....oooOO0OOooo........oooOO0OOooo........oo 1127 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
907 1128
908 const std::vector<G4VEmProcess*>& G4LossTableM 1129 const std::vector<G4VEmProcess*>& G4LossTableManager::GetEmProcessVector()
909 { 1130 {
910 return emp_vector; 1131 return emp_vector;
911 } 1132 }
912 1133
913 //....oooOO0OOooo........oooOO0OOooo........oo 1134 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
914 1135
915 const std::vector<G4VMultipleScattering*>& 1136 const std::vector<G4VMultipleScattering*>&
916 G4LossTableManager::GetMultipleScatteringVecto 1137 G4LossTableManager::GetMultipleScatteringVector()
917 { 1138 {
918 return msc_vector; 1139 return msc_vector;
919 } 1140 }
920 1141
>> 1142 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1143
>> 1144 G4bool G4LossTableManager::IsMaster() const
>> 1145 {
>> 1146 return isMaster;
>> 1147 }
>> 1148
>> 1149 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1150
>> 1151 G4double G4LossTableManager::MinKinEnergy() const
>> 1152 {
>> 1153 return theParameters->MinKinEnergy();
>> 1154 }
>> 1155
>> 1156 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1157
>> 1158 G4double G4LossTableManager::MaxKinEnergy() const
>> 1159 {
>> 1160 return theParameters->MaxKinEnergy();
>> 1161 }
>> 1162
>> 1163 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1164
>> 1165 G4EmCorrections* G4LossTableManager::EmCorrections()
>> 1166 {
>> 1167 return emCorrections;
>> 1168 }
>> 1169
921 //....oooOO0OOooo........oooOO0OOooo........oo 1170 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
922 1171
923 G4EmSaturation* G4LossTableManager::EmSaturati 1172 G4EmSaturation* G4LossTableManager::EmSaturation()
924 { 1173 {
925 return theParameters->GetEmSaturation(); << 1174 if(!emSaturation) { emSaturation = new G4EmSaturation(verbose); }
>> 1175 return emSaturation;
926 } 1176 }
927 1177
928 //....oooOO0OOooo........oooOO0OOooo........oo 1178 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
929 1179
930 G4EmConfigurator* G4LossTableManager::EmConfig 1180 G4EmConfigurator* G4LossTableManager::EmConfigurator()
931 { 1181 {
932 if(!emConfigurator) { << 1182 if(!emConfigurator) { emConfigurator = new G4EmConfigurator(verbose); }
933 emConfigurator = new G4EmConfigurator(verb <<
934 } <<
935 return emConfigurator; 1183 return emConfigurator;
936 } 1184 }
937 1185
938 //....oooOO0OOooo........oooOO0OOooo........oo 1186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
939 1187
940 G4ElectronIonPair* G4LossTableManager::Electro 1188 G4ElectronIonPair* G4LossTableManager::ElectronIonPair()
941 { 1189 {
942 if(!emElectronIonPair) { 1190 if(!emElectronIonPair) {
943 emElectronIonPair = new G4ElectronIonPair( 1191 emElectronIonPair = new G4ElectronIonPair(verbose);
944 } 1192 }
945 return emElectronIonPair; 1193 return emElectronIonPair;
946 } 1194 }
947 1195
948 //....oooOO0OOooo........oooOO0OOooo........oo << 1196 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
949 1197
950 void G4LossTableManager::SetNIELCalculator(G4N << 1198 G4VAtomDeexcitation* G4LossTableManager::AtomDeexcitation()
951 { 1199 {
952 if(nullptr != ptr && ptr != nielCalculator) << 1200 return atomDeexcitation;
953 delete nielCalculator; <<
954 nielCalculator = ptr; <<
955 } <<
956 } 1201 }
957 1202
958 //....oooOO0OOooo........oooOO0OOooo........oo << 1203 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
959 1204
960 G4NIELCalculator* G4LossTableManager::NIELCalc << 1205 G4LossTableBuilder* G4LossTableManager::GetTableBuilder()
961 { 1206 {
962 if(!nielCalculator) { << 1207 return tableBuilder;
963 nielCalculator = new G4NIELCalculator(null <<
964 } <<
965 return nielCalculator; <<
966 } 1208 }
967 1209
968 //....oooOO0OOooo........oooOO0OOooo........oo 1210 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
969 1211
970 void G4LossTableManager::SetAtomDeexcitation(G 1212 void G4LossTableManager::SetAtomDeexcitation(G4VAtomDeexcitation* p)
971 { 1213 {
972 if(atomDeexcitation != p) { 1214 if(atomDeexcitation != p) {
973 delete atomDeexcitation; 1215 delete atomDeexcitation;
974 atomDeexcitation = p; 1216 atomDeexcitation = p;
975 } 1217 }
976 } 1218 }
977 1219
978 //....oooOO0OOooo........oooOO0OOooo........oo 1220 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
979 1221
980 void G4LossTableManager::SetSubCutProducer(G4V 1222 void G4LossTableManager::SetSubCutProducer(G4VSubCutProducer* p)
981 { 1223 {
982 if(subcutProducer != p) { 1224 if(subcutProducer != p) {
983 delete subcutProducer; 1225 delete subcutProducer;
984 subcutProducer = p; 1226 subcutProducer = p;
985 } 1227 }
986 } 1228 }
987 1229
>> 1230 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1231
>> 1232 G4VSubCutProducer* G4LossTableManager::SubCutProducer()
>> 1233 {
>> 1234 return subcutProducer;
>> 1235 }
>> 1236
>> 1237 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1238
>> 1239 G4VEnergyLossProcess*
>> 1240 G4LossTableManager::GetEnergyLossProcess(const G4ParticleDefinition *aParticle)
>> 1241 {
>> 1242 //G4cout << aParticle << " " << currentParticle
>> 1243 //<< " " << currentLoss << G4endl;
>> 1244 if(aParticle != currentParticle) {
>> 1245 currentParticle = aParticle;
>> 1246 std::map<PD,G4VEnergyLossProcess*,std::less<PD> >::const_iterator pos;
>> 1247 if ((pos = loss_map.find(aParticle)) != loss_map.end()) {
>> 1248 currentLoss = (*pos).second;
>> 1249 } else {
>> 1250 currentLoss = 0;
>> 1251 if(aParticle->GetParticleType() == "nucleus") {
>> 1252 if ((pos = loss_map.find(theGenericIon)) != loss_map.end()) {
>> 1253 currentLoss = (*pos).second;
>> 1254 }
>> 1255 }
>> 1256 }
>> 1257 }
>> 1258 return currentLoss;
>> 1259 }
>> 1260
>> 1261 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1262
>> 1263 G4double G4LossTableManager::GetDEDX(const G4ParticleDefinition *aParticle,
>> 1264 G4double kineticEnergy,
>> 1265 const G4MaterialCutsCouple *couple)
>> 1266 {
>> 1267 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1268 G4double x = 0.0;
>> 1269 if(currentLoss) { x = currentLoss->GetDEDX(kineticEnergy, couple); }
>> 1270 return x;
>> 1271 }
>> 1272
>> 1273 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1274
>> 1275 G4double G4LossTableManager::GetSubDEDX(const G4ParticleDefinition *aParticle,
>> 1276 G4double kineticEnergy,
>> 1277 const G4MaterialCutsCouple *couple)
>> 1278 {
>> 1279 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1280 G4double x = 0.0;
>> 1281 if(currentLoss) { x = currentLoss->GetDEDXForSubsec(kineticEnergy, couple); }
>> 1282 return x;
>> 1283 }
>> 1284
>> 1285 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1286
>> 1287 G4double G4LossTableManager::GetCSDARange(const G4ParticleDefinition *aParticle,
>> 1288 G4double kineticEnergy,
>> 1289 const G4MaterialCutsCouple *couple)
>> 1290 {
>> 1291 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1292 G4double x = DBL_MAX;
>> 1293 if(currentLoss) { x = currentLoss->GetCSDARange(kineticEnergy, couple); }
>> 1294 return x;
>> 1295 }
>> 1296
>> 1297 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1298
>> 1299 G4double G4LossTableManager::GetRangeFromRestricteDEDX(
>> 1300 const G4ParticleDefinition *aParticle,
>> 1301 G4double kineticEnergy,
>> 1302 const G4MaterialCutsCouple *couple)
>> 1303 {
>> 1304 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1305 G4double x = DBL_MAX;
>> 1306 if(currentLoss) { x = currentLoss->GetRangeForLoss(kineticEnergy, couple); }
>> 1307 return x;
>> 1308 }
>> 1309
>> 1310 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
>> 1311
>> 1312 G4double G4LossTableManager::GetRange(const G4ParticleDefinition *aParticle,
>> 1313 G4double kineticEnergy,
>> 1314 const G4MaterialCutsCouple *couple)
>> 1315 {
>> 1316 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1317 G4double x = DBL_MAX;
>> 1318 if(currentLoss) {
>> 1319 x = currentLoss->GetRange(kineticEnergy, couple);
>> 1320 }
>> 1321 return x;
>> 1322 }
>> 1323
>> 1324 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1325
>> 1326 G4double G4LossTableManager::GetEnergy(const G4ParticleDefinition *aParticle,
>> 1327 G4double range,
>> 1328 const G4MaterialCutsCouple *couple)
>> 1329 {
>> 1330 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1331 G4double x = 0;
>> 1332 if(currentLoss) { x = currentLoss->GetKineticEnergy(range, couple); }
>> 1333 return x;
>> 1334 }
>> 1335
>> 1336 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 1337
>> 1338 G4double G4LossTableManager::GetDEDXDispersion(
>> 1339 const G4MaterialCutsCouple *couple,
>> 1340 const G4DynamicParticle* dp,
>> 1341 G4double& length)
>> 1342 {
>> 1343 const G4ParticleDefinition* aParticle = dp->GetParticleDefinition();
>> 1344 if(aParticle != currentParticle) { GetEnergyLossProcess(aParticle); }
>> 1345 G4double x = 0.0;
>> 1346 if(currentLoss) { currentLoss->GetDEDXDispersion(couple, dp, length); }
>> 1347 return x;
>> 1348 }
>> 1349
988 //....oooOO0OOooo........oooOO0OOooo........oo 1350 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
989 1351
990 void G4LossTableManager::PrintEWarning(G4Strin 1352 void G4LossTableManager::PrintEWarning(G4String tit, G4double /*val*/)
991 { 1353 {
992 G4String ss = "G4LossTableManager::" + tit; 1354 G4String ss = "G4LossTableManager::" + tit;
993 G4ExceptionDescription ed; 1355 G4ExceptionDescription ed;
994 /* 1356 /*
995 ed << "Parameter is out of range: " << val 1357 ed << "Parameter is out of range: " << val
996 << " it will have no effect!\n" << " ## " 1358 << " it will have no effect!\n" << " ## "
997 << " nbins= " << nbinsLambda 1359 << " nbins= " << nbinsLambda
998 << " nbinsPerDecade= " << nbinsPerDecade 1360 << " nbinsPerDecade= " << nbinsPerDecade
999 << " Emin(keV)= " << minKinEnergy/keV 1361 << " Emin(keV)= " << minKinEnergy/keV
1000 << " Emax(GeV)= " << maxKinEnergy/GeV; 1362 << " Emax(GeV)= " << maxKinEnergy/GeV;
1001 */ 1363 */
1002 G4Exception(ss, "em0044", JustWarning, ed); 1364 G4Exception(ss, "em0044", JustWarning, ed);
1003 } 1365 }
1004 1366
1005 //....oooOO0OOooo........oooOO0OOooo........o 1367 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1006 <<
1007 void G4LossTableManager::DumpHtml() <<
1008 { <<
1009 // Automatic generation of html documentati <<
1010 // List processes and models for the most i <<
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 <<
1061 for (auto mscproc : mscat_vector) { <<
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 <<
1072 for (auto enlossproc : enloss_vector) { <<
1073 for (G4int i = 0; i < plen; ++i) { <<
1074 G4VProcess* proc = (*pv)[i]; <<
1075 if (proc == enlossproc) { <<
1076 outFile << G4endl; <<
1077 proc->ProcessDescription(outFile) <<
1078 break; <<
1079 } <<
1080 } <<
1081 } <<
1082 } <<
1083 outFile.close(); <<
1084 } <<
1085 } <<
1086 <<
1087 //....oooOO0OOooo........oooOO0OOooo........o <<
1088 <<
1089 1368