source: trunk/source/processes/electromagnetic/utils/src/G4EmProcessOptions.cc @ 961

Last change on this file since 961 was 961, checked in by garnier, 15 years ago

update processes
File size: 17.9 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer                                           *
4// *                                                                  *
5// * The  Geant4 software  is  copyright of the Copyright Holders  of *
6// * the Geant4 Collaboration.  It is provided  under  the terms  and *
7// * conditions of the Geant4 Software License,  included in the file *
8// * LICENSE and available at  http://cern.ch/geant4/license .  These *
9// * include a list of copyright holders.                             *
10// *                                                                  *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work  make  any representation or  warranty, express or implied, *
14// * regarding  this  software system or assume any liability for its *
15// * use.  Please see the license in the file  LICENSE  and URL above *
16// * for the full disclaimer and the limitation of liability.         *
17// *                                                                  *
18// * This  code  implementation is the result of  the  scientific and *
19// * technical work of the GEANT4 collaboration.                      *
20// * By using,  copying,  modifying or  distributing the software (or *
21// * any work based  on the software)  you  agree  to acknowledge its *
22// * use  in  resulting  scientific  publications,  and indicate your *
23// * acceptance of all terms of the Geant4 Software license.          *
24// ********************************************************************
25//
26// $Id: G4EmProcessOptions.cc,v 1.26 2009/02/18 14:43:27 vnivanch Exp $
27// GEANT4 tag $Name: geant4-09-02-ref-02 $
28//
29// -------------------------------------------------------------------
30//
31// GEANT4 Class file
32//
33//
34// File name:     G4EmProcessOptions
35//
36// Author:        Vladimir Ivanchenko
37//
38// Creation date: 27.02.2004
39//
40// Modifications:
41// 30-06-04 G4EmProcess is pure discrete (V.Ivanchenko)
42// 24-03-05 Add ApplyCuts and RandomStep (V.Ivanchenko)
43// 10-01-06 PreciseRange -> CSDARange (V.Ivantchenko)
44// 10-05-06 Add command MscStepLimit to G4LossTableManager (V.Ivantchenko)
45// 22-05-06 Add SetBremsstrahlungTh (V.Ivanchenko)
46// 12-02-07 Add SetSkin, SetLinearLossLimit (V.Ivanchenko)
47//
48// Class Description:
49//
50// -------------------------------------------------------------------
51//
52//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
53//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
54
55#include "G4EmProcessOptions.hh"
56#include "G4LossTableManager.hh"
57#include "G4VEmProcess.hh"
58#include "G4VEnergyLossProcess.hh"
59#include "G4VMultipleScattering.hh"
60#include "G4Region.hh"
61#include "G4RegionStore.hh"
62
63//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
64
65G4EmProcessOptions::G4EmProcessOptions()
66{
67  theManager = G4LossTableManager::Instance();
68}
69
70//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
71
72G4EmProcessOptions::~G4EmProcessOptions()
73{
74}
75
76//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
77
78void G4EmProcessOptions::SetLossFluctuations(G4bool val)
79{
80  theManager->SetLossFluctuations(val);
81  const std::vector<G4VEnergyLossProcess*>& v =
82        theManager->GetEnergyLossProcessVector();
83  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
84  for(itr = v.begin(); itr != v.end(); itr++) {
85    G4VEnergyLossProcess* p = *itr;
86    if(p) p->SetLossFluctuations(val);
87  }
88}
89
90//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
91
92void G4EmProcessOptions::SetSubCutoff(G4bool val, const G4Region* r)
93{
94  theManager->SetSubCutoff(val);
95  const std::vector<G4VEnergyLossProcess*>& v =
96        theManager->GetEnergyLossProcessVector();
97  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
98  for(itr = v.begin(); itr != v.end(); itr++) {
99    G4VEnergyLossProcess* p = *itr;
100    if(p) p->ActivateSubCutoff(val, r);
101  }
102}
103
104//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
105
106void G4EmProcessOptions::SetIntegral(G4bool val)
107{
108  theManager->SetIntegral(val);
109  const std::vector<G4VEnergyLossProcess*>& v =
110        theManager->GetEnergyLossProcessVector();
111  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
112  for(itr = v.begin(); itr != v.end(); itr++) {
113    G4VEnergyLossProcess* p = *itr;
114    if(p) p->SetIntegral(val);
115  }
116}
117
118//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
119
120void G4EmProcessOptions::SetMinSubRange(G4double val)
121{
122  theManager->SetMinSubRange(val);
123  const std::vector<G4VEnergyLossProcess*>& v =
124        theManager->GetEnergyLossProcessVector();
125  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
126  for(itr = v.begin(); itr != v.end(); itr++) {
127    G4VEnergyLossProcess* p = *itr;
128    if(p) p->SetMinSubRange(val);
129  }
130}
131
132//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
133
134void G4EmProcessOptions::SetMinEnergy(G4double val)
135{
136  theManager->SetMinEnergy(val);
137  const std::vector<G4VEnergyLossProcess*>& v =
138        theManager->GetEnergyLossProcessVector();
139  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
140  for(itr = v.begin(); itr != v.end(); itr++) {
141    G4VEnergyLossProcess* p = *itr;
142    if(p) p->SetMinKinEnergy(val);
143  }
144  const std::vector<G4VEmProcess*>& w =
145        theManager->GetEmProcessVector();
146  std::vector<G4VEmProcess*>::const_iterator itp;
147  for(itp = w.begin(); itp != w.end(); itp++) {
148    G4VEmProcess* q = *itp;
149    if(q) q->SetMinKinEnergy(val);
150  }
151  const std::vector<G4VMultipleScattering*>& u =
152        theManager->GetMultipleScatteringVector();
153  std::vector<G4VMultipleScattering*>::const_iterator itm;
154  for(itm = u.begin(); itm != u.end(); itm++) {
155    G4VMultipleScattering* s = *itm;
156    if(s) s->SetMinKinEnergy(val);
157  }
158}
159
160//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
161
162void G4EmProcessOptions::SetMaxEnergy(G4double val)
163{
164  theManager->SetMaxEnergy(val);
165  const std::vector<G4VEnergyLossProcess*>& v =
166        theManager->GetEnergyLossProcessVector();
167  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
168  for(itr = v.begin(); itr != v.end(); itr++) {
169    G4VEnergyLossProcess* p = *itr;
170    if(p) p->SetMaxKinEnergy(val);
171  }
172  const std::vector<G4VEmProcess*>& w =
173        theManager->GetEmProcessVector();
174  std::vector<G4VEmProcess*>::const_iterator itp;
175  for(itp = w.begin(); itp != w.end(); itp++) {
176    G4VEmProcess* q = *itp;
177    if(q) q->SetMaxKinEnergy(val);
178  }
179  const std::vector<G4VMultipleScattering*>& u =
180        theManager->GetMultipleScatteringVector();
181  std::vector<G4VMultipleScattering*>::const_iterator itm;
182  for(itm = u.begin(); itm != u.end(); itm++) {
183    G4VMultipleScattering* s = *itm;
184    if(s) s->SetMaxKinEnergy(val);
185  }
186}
187
188//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
189
190void G4EmProcessOptions::SetMaxEnergyForCSDARange(G4double val)
191{
192  theManager->SetMaxEnergyForCSDARange(val);
193  const std::vector<G4VEnergyLossProcess*>& v =
194        theManager->GetEnergyLossProcessVector();
195  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
196  for(itr = v.begin(); itr != v.end(); itr++) {
197    G4VEnergyLossProcess* p = *itr;
198    if(p) p->SetMaxKinEnergyForCSDARange(val);
199  }
200}
201
202//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
203
204void G4EmProcessOptions::SetMaxEnergyForMuons(G4double val)
205{
206  theManager->SetMaxEnergyForMuons(val);
207  const std::vector<G4VEnergyLossProcess*>& v =
208        theManager->GetEnergyLossProcessVector();
209  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
210  for(itr = v.begin(); itr != v.end(); itr++) {
211    G4VEnergyLossProcess* p = *itr;
212    if(p) {
213      if(std::abs(p->Particle()->GetPDGMass() - 105.66*MeV) < MeV)
214        p->SetMaxKinEnergy(val);
215    }
216  }
217  const std::vector<G4VEmProcess*>& w =
218        theManager->GetEmProcessVector();
219  std::vector<G4VEmProcess*>::const_iterator itp;
220  for(itp = w.begin(); itp != w.end(); itp++) {
221    G4VEmProcess* q = *itp;
222    if(q) {
223      if(std::abs(q->Particle()->GetPDGMass() - 105.66*MeV) < MeV)
224        q->SetMaxKinEnergy(val);
225    }
226  }
227  /*
228  const std::vector<G4VMultipleScattering*>& u =
229        theManager->GetMultipleScatteringVector();
230  std::vector<G4VMultipleScattering*>::const_iterator itm;
231  for(itm = u.begin(); itm != u.end(); itm++) {
232    G4VMultipleScattering* s = *itm;
233    if(s) {
234      if(std::abs(s->Particle()->GetPDGMass() - 105.66*MeV) < MeV)
235        s->SetMaxKinEnergy(val);
236    }
237  }
238  */
239}
240
241//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
242
243void G4EmProcessOptions::SetDEDXBinning(G4int val)
244{
245  theManager->SetDEDXBinning(val);
246  const std::vector<G4VEnergyLossProcess*>& v =
247        theManager->GetEnergyLossProcessVector();
248  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
249  for(itr = v.begin(); itr != v.end(); itr++) {
250    G4VEnergyLossProcess* p = *itr;
251    if(p) p->SetDEDXBinning(val);
252  }
253}
254
255//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
256
257void G4EmProcessOptions::SetDEDXBinningForCSDARange(G4int val)
258{
259  theManager->SetDEDXBinningForCSDARange(val);
260  const std::vector<G4VEnergyLossProcess*>& v =
261        theManager->GetEnergyLossProcessVector();
262  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
263  for(itr = v.begin(); itr != v.end(); itr++) {
264    G4VEnergyLossProcess* p = *itr;
265    if(p) p->SetDEDXBinningForCSDARange(val);
266  }
267}
268
269//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
270
271void G4EmProcessOptions::SetLambdaBinning(G4int val)
272{
273  theManager->SetLambdaBinning(val);
274  const std::vector<G4VEmProcess*>& w =
275        theManager->GetEmProcessVector();
276  std::vector<G4VEmProcess*>::const_iterator itp;
277  for(itp = w.begin(); itp != w.end(); itp++) {
278    G4VEmProcess* q = *itp;
279    if(q) q->SetLambdaBinning(val);
280  }
281  const std::vector<G4VMultipleScattering*>& u =
282        theManager->GetMultipleScatteringVector();
283  std::vector<G4VMultipleScattering*>::const_iterator itm;
284  for(itm = u.begin(); itm != u.end(); itm++) {
285    G4VMultipleScattering* s = *itm;
286    if(s) s->SetBinning(val);
287  }
288}
289
290//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
291
292void G4EmProcessOptions::SetStepFunction(G4double v1, G4double v2)
293{
294  theManager->SetStepFunction(v1, v2);
295  const std::vector<G4VEnergyLossProcess*>& v =
296        theManager->GetEnergyLossProcessVector();
297  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
298  for(itr = v.begin(); itr != v.end(); itr++) {
299    G4VEnergyLossProcess* p = *itr;
300    if(p) p->SetStepFunction(v1, v2);
301  }
302}
303
304//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
305
306void G4EmProcessOptions::SetRandomStep(G4bool val)
307{
308  theManager->SetRandomStep(val);
309  const std::vector<G4VEnergyLossProcess*>& v =
310        theManager->GetEnergyLossProcessVector();
311  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
312  for(itr = v.begin(); itr != v.end(); itr++) {
313    G4VEnergyLossProcess* p = *itr;
314    if(p) p->SetRandomStep(val);
315  }
316}
317
318//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
319
320void G4EmProcessOptions::SetApplyCuts(G4bool val)
321{
322  const std::vector<G4VEmProcess*>& w =
323        theManager->GetEmProcessVector();
324  std::vector<G4VEmProcess*>::const_iterator itp;
325  for(itp = w.begin(); itp != w.end(); itp++) {
326    G4VEmProcess* q = *itp;
327    if(q) q->SetApplyCuts(val);
328  }
329}
330
331//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
332
333void G4EmProcessOptions::SetBuildCSDARange(G4bool val)
334{
335  theManager->SetBuildCSDARange(val);
336}
337
338//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
339
340void G4EmProcessOptions::SetVerbose(G4int val, const G4String& name)
341{
342  G4bool all = false;
343  if("all" == name) all = true;
344  const std::vector<G4VEnergyLossProcess*>& v =
345        theManager->GetEnergyLossProcessVector();
346
347  if(all) theManager->SetVerbose(val);
348
349  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
350  for(itr = v.begin(); itr != v.end(); itr++) {
351    G4VEnergyLossProcess* p = *itr;
352    if(p) {
353      if(all) p->SetVerboseLevel(val);
354      else if (p->GetProcessName() == name) p->SetVerboseLevel(val);
355    }
356  }
357  const std::vector<G4VEmProcess*>& w =
358        theManager->GetEmProcessVector();
359  std::vector<G4VEmProcess*>::const_iterator itp;
360  for(itp = w.begin(); itp != w.end(); itp++) {
361    G4VEmProcess* q = *itp;
362    if(q) {
363      if(all) q->SetVerboseLevel(val);
364      else if (q->GetProcessName() == name) q->SetVerboseLevel(val);
365    }
366  }
367  const std::vector<G4VMultipleScattering*>& u =
368        theManager->GetMultipleScatteringVector();
369  std::vector<G4VMultipleScattering*>::const_iterator itm;
370  for(itm = u.begin(); itm != u.end(); itm++) {
371    G4VMultipleScattering* s = *itm;
372    if(s) {
373      if(all) s->SetVerboseLevel(val);
374      else if (s->GetProcessName() == name) s->SetVerboseLevel(val);
375    }
376  }
377}
378
379//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
380
381void G4EmProcessOptions::SetLambdaFactor(G4double val)
382{
383  const std::vector<G4VEnergyLossProcess*>& v =
384        theManager->GetEnergyLossProcessVector();
385  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
386  for(itr = v.begin(); itr != v.end(); itr++) {
387    G4VEnergyLossProcess* p = *itr;
388    if(p) p->SetLambdaFactor(val);
389  }
390
391}
392
393//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
394
395void G4EmProcessOptions::ActivateDeexcitation(const G4String& pname, 
396                                              G4bool val, 
397                                              const G4String& reg)
398{
399  G4RegionStore* regionStore = G4RegionStore::GetInstance();
400  const G4Region* r = 0;
401  if(reg == "" || reg == "World") {
402    r = regionStore->GetRegion("DefaultRegionForTheWorld", false);
403  } else {
404    r = regionStore->GetRegion(reg, false);
405  }
406  if(!r) {
407    G4cout << "G4EmProcessOptions::ActivateDeexcitation ERROR: G4Region <"
408           << reg << "> not found, the command ignored" << G4endl;
409    return;
410  }
411
412  const std::vector<G4VEnergyLossProcess*>& v =
413        theManager->GetEnergyLossProcessVector();
414  std::vector<G4VEnergyLossProcess*>::const_iterator itr;
415  for(itr = v.begin(); itr != v.end(); itr++) {
416    G4VEnergyLossProcess* p = *itr;
417    if(p) {
418      if(pname == p->GetProcessName()) p->ActivateDeexcitation(val,r);
419    }
420  }
421  const std::vector<G4VEmProcess*>& w =
422        theManager->GetEmProcessVector();
423  std::vector<G4VEmProcess*>::const_iterator itp;
424  for(itp = w.begin(); itp != w.end(); itp++) {
425    G4VEmProcess* q = *itp;
426    if(q) {
427      if(pname == q->GetProcessName()) q->ActivateDeexcitation(val,r);
428    }
429  }
430}
431
432//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
433
434void G4EmProcessOptions::SetMscStepLimitation(G4MscStepLimitType val)
435{
436  const std::vector<G4VMultipleScattering*>& u =
437        theManager->GetMultipleScatteringVector();
438  std::vector<G4VMultipleScattering*>::const_iterator itm;
439  for(itm = u.begin(); itm != u.end(); itm++) {
440    if(*itm) (*itm)->SetStepLimitType(val);
441  }
442}
443
444//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
445
446void G4EmProcessOptions::SetMscLateralDisplacement(G4bool val)
447{
448  const std::vector<G4VMultipleScattering*>& u =
449        theManager->GetMultipleScatteringVector();
450  std::vector<G4VMultipleScattering*>::const_iterator itm;
451  for(itm = u.begin(); itm != u.end(); itm++) {
452    if(*itm) (*itm)->SetLateralDisplasmentFlag(val);
453  }
454}
455
456//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
457
458void G4EmProcessOptions::SetSkin(G4double val)
459{
460  if(val < 0.0) return;
461  const std::vector<G4VMultipleScattering*>& u =
462        theManager->GetMultipleScatteringVector();
463  std::vector<G4VMultipleScattering*>::const_iterator itm;
464  for(itm = u.begin(); itm != u.end(); itm++) {
465    if(*itm) {
466      (*itm)->SetSkin(val);
467    }
468  }
469}
470
471//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
472
473void G4EmProcessOptions::SetMscRangeFactor(G4double val)
474{
475  if(val < 0.0) return;
476  const std::vector<G4VMultipleScattering*>& u =
477        theManager->GetMultipleScatteringVector();
478  std::vector<G4VMultipleScattering*>::const_iterator itm;
479  for(itm = u.begin(); itm != u.end(); itm++) {
480    if(*itm) (*itm)->SetRangeFactor(val);
481  }
482}
483
484//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
485
486void G4EmProcessOptions::SetMscGeomFactor(G4double val)
487{
488  if(val < 0.0) return;
489  const std::vector<G4VMultipleScattering*>& u =
490        theManager->GetMultipleScatteringVector();
491  std::vector<G4VMultipleScattering*>::const_iterator itm;
492  for(itm = u.begin(); itm != u.end(); itm++) {
493    if(*itm) (*itm)->SetGeomFactor(val);
494  }
495}
496
497//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
498
499void G4EmProcessOptions::SetPolarAngleLimit(G4double val)
500{
501  const std::vector<G4VMultipleScattering*>& u =
502        theManager->GetMultipleScatteringVector();
503  std::vector<G4VMultipleScattering*>::const_iterator itm;
504  for(itm = u.begin(); itm != u.end(); itm++) {
505    if(*itm) (*itm)->SetPolarAngleLimit(val);
506  }
507  const std::vector<G4VEmProcess*>& w =
508        theManager->GetEmProcessVector();
509  std::vector<G4VEmProcess*>::const_iterator itp;
510  for(itp = w.begin(); itp != w.end(); itp++) {
511    G4VEmProcess* q = *itp;
512    if(q) q->SetPolarAngleLimit(val);
513  }
514}
515
516//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
517
518void G4EmProcessOptions::SetLPMFlag(G4bool val)
519{
520  theManager->SetLPMFlag(val);
521}
522
523//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
524
525void G4EmProcessOptions::SetSplineFlag(G4bool val)
526{
527  theManager->SetSplineFlag(val);
528}
529
530//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
531
532void G4EmProcessOptions::SetLinearLossLimit(G4double val)
533{
534  theManager->SetLinearLossLimit(val);
535}
536
537//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
538
539void G4EmProcessOptions::SetBremsstrahlungTh(G4double val)
540{
541  theManager->SetBremsstrahlungTh(val);
542}
543
544//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
545
Note: See TracBrowser for help on using the repository browser.