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