| 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: G4EmConfigurator.cc 86129 2014-11-07 11:16:37Z gcosmo $
26 // 27 //
27 // ------------------------------------------- 28 // -------------------------------------------------------------------
28 // 29 //
29 // GEANT4 Class 30 // GEANT4 Class
30 // 31 //
31 // File name: G4EmConfigurator 32 // File name: G4EmConfigurator
32 // 33 //
33 // Author: Vladimir Ivanchenko 34 // Author: Vladimir Ivanchenko
34 // 35 //
35 // Creation date: 14.07.2008 36 // Creation date: 14.07.2008
36 // 37 //
37 // Modifications: 38 // Modifications:
38 // 39 //
39 // Class Description: 40 // Class Description:
40 // 41 //
41 // This class provides configuration EM models 42 // This class provides configuration EM models for
42 // particles/processes/regions 43 // particles/processes/regions
43 // 44 //
44 45
45 // ------------------------------------------- 46 // -------------------------------------------------------------------
46 // 47 //
47 48
48 #include "G4EmConfigurator.hh" 49 #include "G4EmConfigurator.hh"
49 #include "G4EmUtility.hh" <<
50 #include "G4SystemOfUnits.hh" 50 #include "G4SystemOfUnits.hh"
51 #include "G4ParticleTable.hh" 51 #include "G4ParticleTable.hh"
52 #include "G4ParticleDefinition.hh" 52 #include "G4ParticleDefinition.hh"
53 #include "G4ProcessManager.hh" 53 #include "G4ProcessManager.hh"
54 #include "G4VProcess.hh" 54 #include "G4VProcess.hh"
55 #include "G4ProcessVector.hh" 55 #include "G4ProcessVector.hh"
56 #include "G4RegionStore.hh" 56 #include "G4RegionStore.hh"
57 #include "G4Region.hh" 57 #include "G4Region.hh"
58 #include "G4DummyModel.hh" 58 #include "G4DummyModel.hh"
59 #include "G4VEnergyLossProcess.hh" 59 #include "G4VEnergyLossProcess.hh"
60 #include "G4VEmProcess.hh" 60 #include "G4VEmProcess.hh"
61 #include "G4VMultipleScattering.hh" 61 #include "G4VMultipleScattering.hh"
62 #include "G4TransportationWithMsc.hh" <<
63 62
64 //....oooOO0OOooo........oooOO0OOooo........oo 63 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
65 64
66 G4EmConfigurator::G4EmConfigurator(G4int val): 65 G4EmConfigurator::G4EmConfigurator(G4int val):verbose(val)
67 { 66 {
68 index = -10; 67 index = -10;
69 } 68 }
70 69
71 //....oooOO0OOooo........oooOO0OOooo........oo 70 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
72 71
73 G4EmConfigurator::~G4EmConfigurator() = defaul << 72 G4EmConfigurator::~G4EmConfigurator()
>> 73 {}
74 74
75 //....oooOO0OOooo........oooOO0OOooo........oo 75 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
76 76
77 void G4EmConfigurator::SetExtraEmModel(const G 77 void G4EmConfigurator::SetExtraEmModel(const G4String& particleName,
78 const G << 78 const G4String& processName,
79 G4VEmMo << 79 G4VEmModel* mod,
80 const G << 80 const G4String& regionName,
81 G4doubl << 81 G4double emin,
82 G4doubl << 82 G4double emax,
83 G4VEmFl << 83 G4VEmFluctuationModel* fm)
84 { 84 {
85 if(nullptr == mod) { return; } <<
86 if(1 < verbose) { 85 if(1 < verbose) {
87 G4cout << " G4EmConfigurator::SetExtraEmMo 86 G4cout << " G4EmConfigurator::SetExtraEmModel " << mod->GetName()
88 << " for " << particleName << 87 << " for " << particleName
89 << " and " << processName << 88 << " and " << processName
90 << " in the region <" << regionName << 89 << " in the region <" << regionName
91 << "> Emin(MeV)= " << emin/MeV << 90 << "> Emin(MeV)= " << emin/MeV
92 << " Emax(MeV)= " << emax/MeV << 91 << " Emax(MeV)= " << emax/MeV
93 << G4endl; << 92 << G4endl;
>> 93 }
>> 94 if(mod) {
>> 95 models.push_back(mod);
>> 96 flucModels.push_back(fm);
>> 97 emax = std::min(emax, mod->HighEnergyLimit());
>> 98 mod->SetActivationHighEnergyLimit(emax);
>> 99 } else {
>> 100 models.push_back(new G4DummyModel());
>> 101 flucModels.push_back(0);
94 } 102 }
95 103
96 models.push_back(mod); <<
97 flucModels.push_back(fm); <<
98 G4double emin0 = std::max(emin, mod->LowEner <<
99 G4double emax0 = std::min(emax, mod->HighEne <<
100 mod->SetActivationHighEnergyLimit(emax0); <<
101 <<
102 particles.push_back(particleName); 104 particles.push_back(particleName);
103 processes.push_back(processName); 105 processes.push_back(processName);
104 regions.push_back(regionName); 106 regions.push_back(regionName);
105 lowEnergy.push_back(emin0); << 107 lowEnergy.push_back(emin);
106 highEnergy.push_back(emax0); << 108 highEnergy.push_back(emax);
107 } 109 }
108 110
109 //....oooOO0OOooo........oooOO0OOooo........oo 111 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
110 112
111 void G4EmConfigurator::AddModels() 113 void G4EmConfigurator::AddModels()
112 { 114 {
113 size_t n = models.size(); 115 size_t n = models.size();
114 if(1 < verbose) { << 116 if(0 < verbose) {
115 G4cout << "### G4EmConfigurator::AddModels 117 G4cout << "### G4EmConfigurator::AddModels n= " << n << G4endl;
116 } 118 }
117 if(n > 0) { 119 if(n > 0) {
118 for(size_t i=0; i<n; ++i) { 120 for(size_t i=0; i<n; ++i) {
119 if(nullptr != models[i]) { << 121 if(models[i]) {
120 const G4Region* reg = G4EmUtility::Fin << 122 G4Region* reg = FindRegion(regions[i]);
121 if(nullptr != reg) { << 123 if(reg) {
122 --index; << 124 --index;
123 SetModelForRegion(models[i],flucMode << 125 SetModelForRegion(models[i],flucModels[i],reg,
124 particles[i],proce << 126 particles[i],processes[i],
125 lowEnergy[i],highE << 127 lowEnergy[i],highEnergy[i]);
126 } << 128 }
127 } 129 }
128 } 130 }
129 } 131 }
130 Clear(); 132 Clear();
131 } 133 }
132 134
133 //....oooOO0OOooo........oooOO0OOooo........oo 135 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
134 136
135 void G4EmConfigurator::SetModelForRegion(G4VEm 137 void G4EmConfigurator::SetModelForRegion(G4VEmModel* mod,
136 G4VEm << 138 G4VEmFluctuationModel* fm,
137 const << 139 G4Region* reg,
138 const << 140 const G4String& particleName,
139 const << 141 const G4String& processName,
140 G4dou << 142 G4double emin, G4double emax)
141 { 143 {
142 if(nullptr == mod) { return; } <<
143 if(1 < verbose) { 144 if(1 < verbose) {
144 G4cout << " G4EmConfigurator::SetModelForR 145 G4cout << " G4EmConfigurator::SetModelForRegion: " << mod->GetName()
145 << G4endl; << 146 << G4endl;
146 G4cout << " For " << particleName 147 G4cout << " For " << particleName
147 << " and " << processName << 148 << " and " << processName
148 << " in the region <" << reg->GetNa << 149 << " in the region <" << reg->GetName()
149 << " Emin(MeV)= " << emin/MeV << 150 << " Emin(MeV)= " << emin/MeV
150 << " Emax(MeV)= " << emax/MeV; << 151 << " Emax(MeV)= " << emax/MeV;
151 if(nullptr != fm) { G4cout << " FLmodel " << 152 if(fm) { G4cout << " FLmodel " << fm->GetName(); }
152 G4cout << G4endl; 153 G4cout << G4endl;
153 } 154 }
>> 155 G4ParticleTable::G4PTblDicIterator* theParticleIterator =
>> 156 G4ParticleTable::GetParticleTable()->GetIterator();
>> 157
>> 158 theParticleIterator->reset();
>> 159 while( (*theParticleIterator)() ) {
>> 160 const G4ParticleDefinition* part = theParticleIterator->value();
154 161
155 // Loop checking, 03-Aug-2015, Vladimir Ivan << 162 //G4cout << particleName << " " << part->GetParticleName() << G4endl;
156 auto myParticleIterator = G4ParticleTable::G <<
157 myParticleIterator->reset(); <<
158 while( (*myParticleIterator)() ) { <<
159 const G4ParticleDefinition* part = myParti <<
160 163
161 if((part->GetParticleName() == particleNam 164 if((part->GetParticleName() == particleName) ||
162 (particleName == "all") || 165 (particleName == "all") ||
163 (particleName == "charged" && part->Get 166 (particleName == "charged" && part->GetPDGCharge() != 0.0)) {
164 167
165 // search for process 168 // search for process
166 G4ProcessManager* pmanager = part->GetPr 169 G4ProcessManager* pmanager = part->GetProcessManager();
167 G4ProcessVector* plist = pmanager->GetPr 170 G4ProcessVector* plist = pmanager->GetProcessList();
168 G4int np = pmanager->GetProcessListLengt 171 G4int np = pmanager->GetProcessListLength();
169 172
170 if(1 < verbose) { << 173 //G4cout << processName << " in list of " << np << G4endl;
171 G4cout << "Check process <" << process << 174
172 << np << " processes" << G4endl << 175 G4VProcess* proc = 0;
173 } <<
174 G4VProcess* proc = nullptr; <<
175 for(G4int i=0; i<np; ++i) { 176 for(G4int i=0; i<np; ++i) {
176 if(processName == (*plist)[i]->GetProc << 177 if(processName == (*plist)[i]->GetProcessName()) {
177 proc = (*plist)[i]; << 178 proc = (*plist)[i];
178 break; << 179 break;
179 } << 180 }
180 } <<
181 if(nullptr == proc) { <<
182 if(processName == "msc") { <<
183 for (G4int i = 0; i < np; ++i) { <<
184 auto* trans = dynamic_cast<G4Trans <<
185 if (nullptr != trans) { <<
186 G4cout << "G4TransportationWithM <<
187 proc = trans; <<
188 break; <<
189 } <<
190 } <<
191 } <<
192 if (nullptr == proc) { <<
193 if (0 < verbose) { <<
194 G4cout << "### G4EmConfigurator WA <<
195 << "> for " << particleName <<
196 } <<
197 return; <<
198 } <<
199 } 181 }
>> 182 if(!proc) {
>> 183 G4cout << "### G4EmConfigurator WARNING: fails to find a process <"
>> 184 << processName << "> for " << particleName << G4endl;
>> 185 return;
>> 186 }
200 187
201 if(!UpdateModelEnergyRange(mod, emin, em << 188 if(mod) {
>> 189 if(!UpdateModelEnergyRange(mod, emin, emax)) { return; }
>> 190 }
202 // classify process 191 // classify process
203 G4int ii = proc->GetProcessSubType(); 192 G4int ii = proc->GetProcessSubType();
204 auto msc = dynamic_cast<G4VMscModel*>(mo << 193 if(10 == ii && mod) {
205 if (nullptr != msc) { << 194 G4VMultipleScattering* p = static_cast<G4VMultipleScattering*>(proc);
206 if (auto* trans = dynamic_cast<G4Trans << 195 p->AddEmModel(index,mod,reg);
207 trans->AddMscModel(msc, index, reg); << 196 if(1 < verbose) {
208 if (1 < verbose) { << 197 G4cout << "### Added msc model order= " << index << " for "
209 G4cout << "### Added msc model ord << 198 << particleName << " and " << processName << G4endl;
210 << proc->GetProcessName() < << 199 }
211 } << 200 return;
212 } << 201 } else if(2 <= ii && 4 >= ii) {
213 else if (10 == ii) { << 202 G4VEnergyLossProcess* p = static_cast<G4VEnergyLossProcess*>(proc);
214 auto p = dynamic_cast<G4VMultipleSca << 203 if(!mod && fm) {
215 if (nullptr != p) { << 204 p->SetFluctModel(fm);
216 p->AddEmModel(index, msc, reg); << 205 } else {
217 if (1 < verbose) { << 206 p->AddEmModel(index,mod,fm,reg);
218 G4cout << "### Added msc model o << 207 if(1 < verbose) {
219 << processName << G4endl; << 208 G4cout << "### Added eloss model order= " << index << " for "
220 } << 209 << particleName << " and " << processName << G4endl;
221 } << 210 }
222 } << 211 }
223 else { << 212 return;
224 G4cout << "### Unable to add msc mod << 213 } else if(mod) {
225 << G4endl; << 214 G4VEmProcess* p = static_cast<G4VEmProcess*>(proc);
226 } << 215 p->AddEmModel(index,mod,reg);
227 } << 216 if(1 < verbose) {
228 else if (2 <= ii && 4 >= ii) { << 217 G4cout << "### Added em model order= " << index << " for "
229 auto p = dynamic_cast<G4VEnergyLossPro << 218 << particleName << " and " << processName << G4endl;
230 if (nullptr != p) { << 219 }
231 p->AddEmModel(index, mod, fm, reg); << 220 return;
232 if (1 < verbose) { << 221 } else {
233 G4cout << "### Added eloss model o << 222 return;
234 << processName << G4endl; <<
235 } <<
236 } <<
237 } <<
238 else { <<
239 auto p = dynamic_cast<G4VEmProcess*>(p <<
240 if (nullptr != p) { <<
241 p->AddEmModel(index, mod, reg); <<
242 if (1 < verbose) { <<
243 G4cout << "### Added em model orde <<
244 << processName << G4endl; <<
245 } <<
246 } <<
247 else { <<
248 G4cout << "### Unable to add em mode <<
249 << G4endl; <<
250 } <<
251 } 223 }
252 return; <<
253 } 224 }
254 } 225 }
255 } 226 }
256 227
257 //....oooOO0OOooo........oooOO0OOooo........oo 228 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
258 229
259 void 230 void
260 G4EmConfigurator::PrepareModels(const G4Partic 231 G4EmConfigurator::PrepareModels(const G4ParticleDefinition* aParticle,
261 G4VEnergyLossP << 232 G4VEnergyLossProcess* p)
262 { 233 {
263 size_t n = particles.size(); 234 size_t n = particles.size();
264 if(1 < verbose) { 235 if(1 < verbose) {
265 G4cout << " G4EmConfigurator::PrepareModel 236 G4cout << " G4EmConfigurator::PrepareModels for EnergyLoss n= "
266 << n << G4endl; << 237 << n << G4endl;
267 } 238 }
268 if(n > 0) { 239 if(n > 0) {
269 G4String particleName = aParticle->GetPart 240 G4String particleName = aParticle->GetParticleName();
270 G4String processName = p->GetProcessName( 241 G4String processName = p->GetProcessName();
271 //G4cout << particleName << " " << proc 242 //G4cout << particleName << " " << processName << G4endl;
272 for(size_t i=0; i<n; ++i) { 243 for(size_t i=0; i<n; ++i) {
273 //G4cout << particles[i] << " " << pr 244 //G4cout << particles[i] << " " << processes[i] << G4endl;
274 if(processName == processes[i]) { 245 if(processName == processes[i]) {
275 if((particleName == particles[i]) || 246 if((particleName == particles[i]) ||
276 (particles[i] == "all") || << 247 (particles[i] == "all") ||
277 (particles[i] == "charged" && aPart << 248 (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
278 const G4Region* reg = G4EmUtility::F << 249 G4Region* reg = FindRegion(regions[i]);
279 //G4cout << "Region " << reg << G4en << 250 //G4cout << "Region " << reg << G4endl;
280 if(nullptr != reg) { << 251 if(reg) {
281 --index; << 252 --index;
282 G4VEmModel* mod = models[i]; << 253 G4VEmModel* mod = models[i];
283 G4VEmFluctuationModel* fm = flucMo << 254 G4VEmFluctuationModel* fm = flucModels[i];
284 if(nullptr != mod) { << 255 if(mod) {
285 if(UpdateModelEnergyRange(mod, l << 256 if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
286 p->AddEmModel(index,mod,fm,reg << 257 p->AddEmModel(index,mod,fm,reg);
287 if(1 < verbose) { << 258 if(1 < verbose) {
288 G4cout << "### Added eloss m << 259 G4cout << "### Added eloss model order= " << index << " for "
289 << " and " << process << 260 << particleName << " and " << processName << G4endl;
290 } << 261 }
291 } << 262 }
292 } else if(nullptr != fm) { << 263 } else if(fm) {
293 p->SetFluctModel(fm); << 264 p->SetFluctModel(fm);
294 } << 265 }
295 } << 266 }
296 } << 267 }
297 } 268 }
298 } 269 }
299 } 270 }
300 } 271 }
301 272
302 //....oooOO0OOooo........oooOO0OOooo........oo 273 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
303 274
304 void 275 void
305 G4EmConfigurator::PrepareModels(const G4Partic 276 G4EmConfigurator::PrepareModels(const G4ParticleDefinition* aParticle,
306 G4VEmProcess* << 277 G4VEmProcess* p)
307 { 278 {
308 size_t n = particles.size(); 279 size_t n = particles.size();
309 if(1 < verbose) { 280 if(1 < verbose) {
310 G4cout << " G4EmConfigurator::PrepareModel 281 G4cout << " G4EmConfigurator::PrepareModels for EM process n= "
311 << n << G4endl; << 282 << n << G4endl;
312 } 283 }
313 if(n > 0) { 284 if(n > 0) {
314 G4String particleName = aParticle->GetPart 285 G4String particleName = aParticle->GetParticleName();
315 G4String processName = p->GetProcessName( 286 G4String processName = p->GetProcessName();
316 //G4cout << particleName << " " << part 287 //G4cout << particleName << " " << particleName << G4endl;
317 for(size_t i=0; i<n; ++i) { 288 for(size_t i=0; i<n; ++i) {
318 if(processName == processes[i]) { 289 if(processName == processes[i]) {
319 if((particleName == particles[i]) || 290 if((particleName == particles[i]) ||
320 (particles[i] == "all") || << 291 (particles[i] == "all") ||
321 (particles[i] == "charged" && aPart << 292 (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
322 const G4Region* reg = G4EmUtility::F << 293 G4Region* reg = FindRegion(regions[i]);
323 //G4cout << "Region " << reg << G4en << 294 //G4cout << "Region " << reg << G4endl;
324 if(nullptr != reg) { << 295 if(reg) {
325 --index; << 296 --index;
326 G4VEmModel* mod = models[i]; << 297 G4VEmModel* mod = models[i];
327 if(nullptr != mod) { << 298 if(mod) {
328 if(UpdateModelEnergyRange(mod, l << 299 if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
329 p->AddEmModel(index,mod,reg); << 300 p->AddEmModel(index,mod,reg);
330 if(1 < verbose) { << 301 if(1 < verbose) {
331 G4cout << "### Added em mode << 302 G4cout << "### Added em model order= " << index << " for "
332 << particleName << " << 303 << particleName << " and " << processName << G4endl;
333 } << 304 }
334 } << 305 }
335 } << 306 }
336 } << 307 }
337 } << 308 }
338 } 309 }
339 } 310 }
340 } 311 }
341 } 312 }
342 313
343 //....oooOO0OOooo........oooOO0OOooo........oo 314 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
344 315
345 void 316 void
346 G4EmConfigurator::PrepareModels(const G4Partic 317 G4EmConfigurator::PrepareModels(const G4ParticleDefinition* aParticle,
347 G4VMultipleSca << 318 G4VMultipleScattering* p)
348 G4Transportati <<
349 { 319 {
350 size_t n = particles.size(); 320 size_t n = particles.size();
351 if(1 < verbose) { 321 if(1 < verbose) {
352 G4cout << " G4EmConfigurator::PrepareModel 322 G4cout << " G4EmConfigurator::PrepareModels for MSC process n= "
353 << n << G4endl; << 323 << n << G4endl;
354 } 324 }
355 325
356 if(n > 0) { 326 if(n > 0) {
357 G4String particleName = aParticle->GetPart << 327 G4String particleName = aParticle->GetParticleName();
358 G4String processName = (nullptr == p) ? G4 << 328 G4String processName = p->GetProcessName();
359 for(size_t i=0; i<n; ++i) { 329 for(size_t i=0; i<n; ++i) {
360 if(processName == processes[i]) { 330 if(processName == processes[i]) {
361 if ((particleName == particles[i]) || << 331 if((particleName == particles[i]) ||
362 || (particles[i] == "charged" && a << 332 (particles[i] == "all") ||
363 { << 333 (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
364 const G4Region* reg = G4EmUtility::F << 334 G4Region* reg = FindRegion(regions[i]);
365 if (nullptr != reg) { << 335 if(reg) {
366 --index; << 336 --index;
367 auto mod = dynamic_cast<G4VMscMode << 337 G4VEmModel* mod = models[i];
368 if(nullptr != mod) { << 338 if(mod) {
369 if(UpdateModelEnergyRange(mod, l << 339 if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
370 if(nullptr != p) { << 340 p->AddEmModel(index,mod,reg);
371 p->AddEmModel(index, mod, re << 341 G4cout << "### Added msc model order= " << index << " for "
372 } << 342 << particleName << " and " << processName << G4endl;
373 else { << 343 }
374 trans->AddMscModel(mod, inde << 344 }
375 } << 345 }
376 //G4cout << "### Added msc mod << 346 }
377 // << particleName << " and <<
378 } <<
379 } <<
380 } <<
381 } <<
382 } 347 }
383 } 348 }
384 } 349 }
385 } 350 }
386 351
387 //....oooOO0OOooo........oooOO0OOooo........oo 352 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
388 353
389 void G4EmConfigurator::Clear() 354 void G4EmConfigurator::Clear()
390 { 355 {
391 particles.clear(); 356 particles.clear();
392 processes.clear(); 357 processes.clear();
393 models.clear(); 358 models.clear();
394 flucModels.clear(); 359 flucModels.clear();
395 regions.clear(); 360 regions.clear();
396 lowEnergy.clear(); 361 lowEnergy.clear();
397 highEnergy.clear(); 362 highEnergy.clear();
398 } 363 }
399 364
400 //....oooOO0OOooo........oooOO0OOooo........oo 365 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
401 366
>> 367 G4Region* G4EmConfigurator::FindRegion(const G4String& regionName)
>> 368 {
>> 369 // search for region
>> 370 G4Region* reg = 0;
>> 371 G4RegionStore* regStore = G4RegionStore::GetInstance();
>> 372 G4String r = regionName;
>> 373 if(r == "" || r == "world" || r == "World") {
>> 374 r = "DefaultRegionForTheWorld";
>> 375 }
>> 376 reg = regStore->GetRegion(r, true);
>> 377 if(!reg) {
>> 378 G4cout << "### G4EmConfigurator WARNING: fails to find a region <"
>> 379 << r << G4endl;
>> 380 } else if(verbose > 1) {
>> 381 G4cout << "### G4EmConfigurator finds out G4Region <" << r << ">"
>> 382 << G4endl;
>> 383 }
>> 384 return reg;
>> 385 }
>> 386
>> 387 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
>> 388
402 G4bool G4EmConfigurator::UpdateModelEnergyRang 389 G4bool G4EmConfigurator::UpdateModelEnergyRange(G4VEmModel* mod,
403 << 390 G4double emin, G4double emax)
404 { 391 {
405 // energy limits 392 // energy limits
406 G4double e1 = std::max(emin,mod->LowEnergyLi 393 G4double e1 = std::max(emin,mod->LowEnergyLimit());
407 G4double e2 = std::min(emax,mod->HighEnergyL 394 G4double e2 = std::min(emax,mod->HighEnergyLimit());
408 if(e2 <= e1) { 395 if(e2 <= e1) {
409 G4cout << "### G4EmConfigurator WARNING: e 396 G4cout << "### G4EmConfigurator WARNING: empty energy interval"
410 << " for <" << mod->GetName() << 397 << " for <" << mod->GetName()
411 << "> Emin(MeV)= " << e1/CLHEP::Me << 398 << "> Emin(MeV)= " << e1/CLHEP::MeV
412 << "> Emax(MeV)= " << e2/CLHEP::Me << 399 << "> Emax(MeV)= " << e2/CLHEP::MeV
413 << G4endl; << 400 << G4endl;
414 return false; << 401 return false;
415 } 402 }
416 mod->SetLowEnergyLimit(e1); 403 mod->SetLowEnergyLimit(e1);
417 mod->SetHighEnergyLimit(e2); 404 mod->SetHighEnergyLimit(e2);
418 if(verbose > 1) { 405 if(verbose > 1) {
419 G4cout << "### G4EmConfigurator for " << m 406 G4cout << "### G4EmConfigurator for " << mod->GetName()
420 << " Emin(MeV)= " << e1/MeV << " Em << 407 << " Emin(MeV)= " << e1/MeV << " Emax(MeV)= " << e2/MeV
421 << G4endl; << 408 << G4endl;
422 } 409 }
423 return true; 410 return true;
424 } 411 }
425 412
426 //....oooOO0OOooo........oooOO0OOooo........oo 413 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
427 414