Geant4  10.02.p01
G4VEmProcess.cc
Go to the documentation of this file.
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: G4VEmProcess.cc 93264 2015-10-14 09:30:04Z gcosmo $
27 //
28 // -------------------------------------------------------------------
29 //
30 // GEANT4 Class file
31 //
32 //
33 // File name: G4VEmProcess
34 //
35 // Author: Vladimir Ivanchenko on base of Laszlo Urban code
36 //
37 // Creation date: 01.10.2003
38 //
39 // Modifications:
40 // 30-06-04 make it to be pure discrete process (V.Ivanchenko)
41 // 30-09-08 optimise integral option (V.Ivanchenko)
42 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
43 // 11-03-05 Shift verbose level by 1, add applyCuts and killPrimary flags (VI)
44 // 14-03-05 Update logic PostStepDoIt (V.Ivanchenko)
45 // 08-04-05 Major optimisation of internal interfaces (V.Ivanchenko)
46 // 18-04-05 Use G4ParticleChangeForGamma (V.Ivanchenko)
47 // 25-07-05 Add protection: integral mode only for charged particles (VI)
48 // 04-09-05 default lambdaFactor 0.8 (V.Ivanchenko)
49 // 11-01-06 add A to parameters of ComputeCrossSectionPerAtom (VI)
50 // 12-09-06 add SetModel() (mma)
51 // 12-04-07 remove double call to Clear model manager (V.Ivanchenko)
52 // 27-10-07 Virtual functions moved to source (V.Ivanchenko)
53 // 24-06-09 Removed hidden bin in G4PhysicsVector (V.Ivanchenko)
54 // 17-02-10 Added pointer currentParticle (VI)
55 // 30-05-12 allow Russian roulette, brem splitting (D. Sawkey)
56 //
57 // Class Description:
58 //
59 
60 // -------------------------------------------------------------------
61 //
62 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
63 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
64 
65 #include "G4VEmProcess.hh"
66 #include "G4PhysicalConstants.hh"
67 #include "G4SystemOfUnits.hh"
68 #include "G4ProcessManager.hh"
69 #include "G4LossTableManager.hh"
70 #include "G4LossTableBuilder.hh"
71 #include "G4Step.hh"
72 #include "G4ParticleDefinition.hh"
73 #include "G4VEmModel.hh"
74 #include "G4DataVector.hh"
75 #include "G4PhysicsTable.hh"
76 #include "G4PhysicsLogVector.hh"
77 #include "G4VParticleChange.hh"
78 #include "G4ProductionCutsTable.hh"
79 #include "G4Region.hh"
80 #include "G4Gamma.hh"
81 #include "G4Electron.hh"
82 #include "G4Positron.hh"
83 #include "G4PhysicsTableHelper.hh"
84 #include "G4EmBiasingManager.hh"
85 #include "G4GenericIon.hh"
86 #include "G4Log.hh"
87 #include <iostream>
88 
89 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
90 
92  G4VDiscreteProcess(name, type),
93  secondaryParticle(nullptr),
94  buildLambdaTable(true),
95  numberOfModels(0),
96  theLambdaTable(nullptr),
97  theLambdaTablePrim(nullptr),
98  theDensityFactor(nullptr),
99  theDensityIdx(nullptr),
100  integral(false),
101  applyCuts(false),
102  startFromNull(false),
103  splineFlag(true),
104  currentModel(nullptr),
105  particle(nullptr),
106  currentParticle(nullptr),
107  currentCouple(nullptr)
108 {
110  SetVerboseLevel(1);
111 
112  // Size of tables assuming spline
113  minKinEnergy = 0.1*keV;
114  maxKinEnergy = 10.0*TeV;
115  nLambdaBins = 77;
117  actBinning = false;
118  actSpline = false;
119  actMinKinEnergy = false;
120  actMaxKinEnergy = false;
121 
122  // default lambda factor
123  lambdaFactor = 0.8;
124 
125  // default limit on polar angle
126  biasFactor = fFactor = 1.0;
127 
128  // particle types
132 
134 
137  secParticles.reserve(5);
138 
139  baseMaterial = currentMaterial = nullptr;
140 
143 
145  = basedCoupleIndex = 0;
146 
148  biasManager = nullptr;
149  biasFlag = false;
150  weightFlag = false;
152  lManager->Register(this);
153  secID = fluoID = augerID = biasID = -1;
154  mainSecondaries = 100;
155  if("phot" == GetProcessName() || "compt" == GetProcessName()) {
156  mainSecondaries = 1;
157  }
158 }
159 
160 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
161 
163 {
164  /*
165  if(1 < verboseLevel) {
166  G4cout << "G4VEmProcess destruct " << GetProcessName()
167  << " " << this << " " << theLambdaTable <<G4endl;
168  }
169  */
170  if(lManager->IsMaster()) {
171  if(theLambdaTable) {
173  delete theLambdaTable;
174  }
175  if(theLambdaTablePrim) {
177  delete theLambdaTablePrim;
178  }
179  }
180  delete modelManager;
181  delete biasManager;
182  lManager->DeRegister(this);
183  //G4cout << "G4VEmProcess removed " << G4endl;
184 }
185 
186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
187 
189 {
190  currentCouple = nullptr;
191  preStepLambda = 0.0;
193  idxLambda = idxLambdaPrim = 0;
194 }
195 
196 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
197 
199  const G4Material*)
200 {
201  return 0.0;
202 }
203 
204 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
205 
207  const G4Region* region)
208 {
209  G4VEmFluctuationModel* fm = nullptr;
210  modelManager->AddEmModel(order, p, fm, region);
211  if(p) { p->SetParticleChange(pParticleChange); }
212 }
213 
214 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
215 
217 {
218  G4int n = emModels.size();
219  if(index >= n) { for(G4int i=n; i<=index; ++i) {emModels.push_back(0);} }
220  emModels[index] = p;
221 }
222 
223 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
224 
226 {
227  G4VEmModel* p = nullptr;
228  if(index >= 0 && index < G4int(emModels.size())) { p = emModels[index]; }
229  return p;
230 }
231 
232 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
233 
235  G4double emin, G4double emax)
236 {
237  modelManager->UpdateEmModel(nam, emin, emax);
238 }
239 
240 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
241 
243 {
244  return modelManager->GetModel(idx, ver);
245 }
246 
247 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
248 
250 {
251  G4bool isMaster = true;
252  const G4VEmProcess* masterProcess =
253  static_cast<const G4VEmProcess*>(GetMasterProcess());
254  if(masterProcess && masterProcess != this) { isMaster = false; }
255 
256  if(!particle) { SetParticle(&part); }
257 
258  if(part.GetParticleType() == "nucleus" &&
259  part.GetParticleSubType() == "generic") {
260 
261  G4String pname = part.GetParticleName();
262  if(pname != "deuteron" && pname != "triton" &&
263  pname != "alpha" && pname != "He3" &&
264  pname != "alpha+" && pname != "helium" &&
265  pname != "hydrogen") {
266 
268  }
269  }
270 
271  if(1 < verboseLevel) {
272  G4cout << "G4VEmProcess::PreparePhysicsTable() for "
273  << GetProcessName()
274  << " and particle " << part.GetParticleName()
275  << " local particle " << particle->GetParticleName()
276  << G4endl;
277  }
278 
279  if(particle != &part) { return; }
280 
282 
283  lManager->PreparePhysicsTable(&part, this, isMaster);
284 
285  Clear();
287 
288  const G4ProductionCutsTable* theCoupleTable=
290  size_t n = theCoupleTable->GetTableSize();
291 
292  theEnergyOfCrossSectionMax.resize(n, 0.0);
293  theCrossSectionMax.resize(n, DBL_MAX);
294 
295  // initialisation of the process
298  if(isMaster) { SetVerboseLevel(theParameters->Verbose()); }
302 
303  // initialisation of models
305  for(G4int i=0; i<numberOfModels; ++i) {
306  G4VEmModel* mod = modelManager->GetModel(i);
307  if(0 == i) { currentModel = mod; }
309  mod->SetMasterThread(isMaster);
310  if(mod->HighEnergyLimit() > maxKinEnergy) {
312  }
313  }
314 
317  2.,verboseLevel);
321 
322  // prepare tables
323  if(buildLambdaTable && isMaster){
324  theLambdaTable =
327  }
328  // high energy table
329  if(isMaster && minKinEnergyPrim < maxKinEnergy){
333  }
334  // forced biasing
335  if(biasManager) {
337  biasFlag = false;
338  }
339  // defined ID of secondary particles
340  G4String nam1 = GetProcessName();
341  G4String nam2 = nam1 + "_fluo" ;
342  G4String nam3 = nam1 + "_auger";
343  G4String nam4 = nam1 + "_split";
348 }
349 
350 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
351 
353 {
354  G4bool isMaster = true;
355  const G4VEmProcess* masterProc =
356  static_cast<const G4VEmProcess*>(GetMasterProcess());
357  if(masterProc && masterProc != this) { isMaster = false; }
358 
359  G4String num = part.GetParticleName();
360  if(1 < verboseLevel) {
361  G4cout << "### G4VEmProcess::BuildPhysicsTable() for "
362  << GetProcessName()
363  << " and particle " << num
364  << " buildLambdaTable= " << buildLambdaTable
365  << " isMaster= " << isMaster
366  << G4endl;
367  }
368 
369  if(particle == &part) {
370 
372 
373  // worker initialisation
374  if(!isMaster) {
375  theLambdaTable = masterProc->LambdaTable();
376  theLambdaTablePrim = masterProc->LambdaTablePrim();
377 
378  if(theLambdaTable) {
380  } else if(theLambdaTablePrim) {
382  }
385  if(theLambdaTable) { FindLambdaMax(); }
386 
387  // local initialisation of models
388  G4bool printing = true;
390  for(G4int i=0; i<numberOfModels; ++i) {
391  G4VEmModel* mod = GetModelByIndex(i, printing);
392  G4VEmModel* mod0= masterProc->GetModelByIndex(i, printing);
393  mod->InitialiseLocal(particle, mod0);
394  }
395  // master thread
396  } else {
401  }
402  }
403  }
404 
405  // explicitly defined printout by particle name
406  if(1 < verboseLevel ||
407  (0 < verboseLevel && (num == "gamma" || num == "e-" ||
408  num == "e+" || num == "mu+" ||
409  num == "mu-" || num == "proton"||
410  num == "pi+" || num == "pi-" ||
411  num == "kaon+" || num == "kaon-" ||
412  num == "alpha" || num == "anti_proton" ||
413  num == "GenericIon")))
414  {
415  PrintInfoProcess(part);
416  }
417 
418  if(1 < verboseLevel) {
419  G4cout << "### G4VEmProcess::BuildPhysicsTable() done for "
420  << GetProcessName()
421  << " and particle " << num
422  << G4endl;
423  }
424 }
425 
426 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
427 
429 {
430  if(1 < verboseLevel) {
431  G4cout << "G4EmProcess::BuildLambdaTable() for process "
432  << GetProcessName() << " and particle "
433  << particle->GetParticleName() << " " << this
434  << G4endl;
435  }
436 
437  // Access to materials
438  const G4ProductionCutsTable* theCoupleTable=
440  size_t numOfCouples = theCoupleTable->GetTableSize();
441 
443 
444  G4PhysicsLogVector* aVector = nullptr;
445  G4PhysicsLogVector* aVectorPrim = nullptr;
446  G4PhysicsLogVector* bVectorPrim = nullptr;
447 
448  G4double scale =
450  G4int nbin = theParameters->NumberOfBins();
451  if(actBinning) { nbin = std::max(nbin, nLambdaBins); }
454 
455  for(size_t i=0; i<numOfCouples; ++i) {
456 
457  if (bld->GetFlag(i)) {
458 
459  // create physics vector and fill it
460  const G4MaterialCutsCouple* couple =
461  theCoupleTable->GetMaterialCutsCouple(i);
462 
463  // build main table
464  if(buildLambdaTable) {
465  delete (*theLambdaTable)[i];
466 
467  // if start from zero then change the scale
468  G4double emin = minKinEnergy;
469  G4bool startNull = false;
470  if(startFromNull) {
472  if(e >= emin) {
473  emin = e;
474  startNull = true;
475  }
476  }
477  G4double emax = emax1;
478  if(emax <= emin) { emax = 2*emin; }
479  G4int bin = G4lrint(nbin*G4Log(emax/emin)/scale);
480  if(bin < 3) { bin = 3; }
481  aVector = new G4PhysicsLogVector(emin, emax, bin);
482  aVector->SetSpline(splineFlag);
483  modelManager->FillLambdaVector(aVector, couple, startNull);
484  if(splineFlag) { aVector->FillSecondDerivatives(); }
486  }
487  // build high energy table
489  delete (*theLambdaTablePrim)[i];
490 
491  // start not from zero
492  if(!bVectorPrim) {
493  G4int bin = G4lrint(nbin*G4Log(maxKinEnergy/minKinEnergyPrim)/scale);
494  if(bin < 3) { bin = 3; }
495  aVectorPrim =
497  bVectorPrim = aVectorPrim;
498  } else {
499  aVectorPrim = new G4PhysicsLogVector(*bVectorPrim);
500  }
501  // always use spline
502  aVectorPrim->SetSpline(splineFlag);
503  modelManager->FillLambdaVector(aVectorPrim, couple, false,
505  aVectorPrim->FillSecondDerivatives();
507  aVectorPrim);
508  }
509  }
510  }
511 
513 
514  if(1 < verboseLevel) {
515  G4cout << "Lambda table is built for "
517  << G4endl;
518  }
519 }
520 
521 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
522 
524 {
525  if(verboseLevel > 0) {
526  G4cout << std::setprecision(6);
527  G4cout << G4endl << GetProcessName() << ": for "
528  << part.GetParticleName();
529  if(integral) { G4cout << ", integral: 1 "; }
530  if(applyCuts) { G4cout << ", applyCuts: 1 "; }
531  G4cout << " SubType= " << GetProcessSubType();;
532  if(biasFactor != 1.0) { G4cout << " BiasingFactor= " << biasFactor; }
533  G4cout << " BuildTable= " << buildLambdaTable;
534  G4cout << G4endl;
535  if(buildLambdaTable) {
536  if(particle == &part) {
537  size_t length = theLambdaTable->length();
538  for(size_t i=0; i<length; ++i) {
539  G4PhysicsVector* v = (*theLambdaTable)[i];
540  if(v) {
541  G4cout << " Lambda table from ";
542  G4double emin = v->Energy(0);
543  G4double emax = v->GetMaxEnergy();
544  G4int nbin = v->GetVectorLength() - 1;
545  if(emin > minKinEnergy) { G4cout << "threshold "; }
546  else { G4cout << G4BestUnit(emin,"Energy"); }
547  G4cout << " to "
548  << G4BestUnit(emax,"Energy")
549  << ", " << G4lrint(nbin/std::log10(emax/emin))
550  << " bins per decade, spline: "
551  << splineFlag
552  << G4endl;
553  break;
554  }
555  }
556  } else {
557  G4cout << " Used Lambda table of "
558  << particle->GetParticleName() << G4endl;;
559  }
560  }
562  if(particle == &part) {
563  size_t length = theLambdaTablePrim->length();
564  for(size_t i=0; i<length; ++i) {
565  G4PhysicsVector* v = (*theLambdaTablePrim)[i];
566  if(v) {
567  G4cout << " LambdaPrime table from "
568  << G4BestUnit(v->Energy(0),"Energy")
569  << " to "
570  << G4BestUnit(v->GetMaxEnergy(),"Energy")
571  << " in " << v->GetVectorLength()-1
572  << " bins "
573  << G4endl;
574  break;
575  }
576  }
577  } else {
578  G4cout << " Used LambdaPrime table of "
579  << particle->GetParticleName() << G4endl;;
580  }
581  }
582  PrintInfo();
584  }
585 
586  if(verboseLevel > 2 && buildLambdaTable) {
587  G4cout << " LambdaTable address= " << theLambdaTable << G4endl;
588  if(theLambdaTable && particle == &part) {
589  G4cout << (*theLambdaTable) << G4endl;
590  }
591  }
592 }
593 
594 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
595 
597 {
598  // reset parameters for the new track
602 
603  // forced biasing only for primary particles
604  if(biasManager) {
605  if(0 == track->GetParentID()) {
606  // primary particle
607  biasFlag = true;
609  }
610  }
611 }
612 
613 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
614 
616  const G4Track& track,
617  G4double previousStepSize,
619 {
620  *condition = NotForced;
621  G4double x = DBL_MAX;
622 
626 
630  return x;
631  }
632 
633  // forced biasing only for primary particles
634  if(biasManager) {
635  if(0 == track.GetParentID()) {
636  if(biasFlag &&
638  return biasManager->GetStepLimit(currentCoupleIndex, previousStepSize);
639  }
640  }
641  }
642 
643  // compute mean free path
647 
648  // zero cross section
649  if(preStepLambda <= 0.0) {
652  }
653  }
654 
655  // non-zero cross section
656  if(preStepLambda > 0.0) {
657 
659 
660  // beggining of tracking (or just after DoIt of this process)
663 
664  } else if(currentInteractionLength < DBL_MAX) {
665 
666  // subtract NumberOfInteractionLengthLeft using previous step
668  previousStepSize/currentInteractionLength;
669  //SubtractNumberOfInteractionLengthLeft(previousStepSize);
672  }
673 
674  // new mean free path and step limit for the next step
677  /*
678 #ifdef G4VERBOSE
679  if (verboseLevel>2){
680  G4cout << "G4VEmProcess::PostStepGetPhysicalInteractionLength ";
681  G4cout << "[ " << GetProcessName() << "]" << G4endl;
682  G4cout << " for " << currentParticle->GetParticleName()
683  << " in Material " << currentMaterial->GetName()
684  << " Ekin(MeV)= " << preStepKinEnergy/MeV
685  <<G4endl;
686  G4cout << " MeanFreePath = " << currentInteractionLength/cm << "[cm]"
687  << " InteractionLength= " << x/cm <<"[cm] " <<G4endl;
688  }
689 #endif
690  */
691  }
692  return x;
693 }
694 
695 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
696 
698  const G4Step& step)
699 {
700  // In all cases clear number of interaction lengths
703 
705 
706  // Do not make anything if particle is stopped, the annihilation then
707  // should be performed by the AtRestDoIt!
708  if (track.GetTrackStatus() == fStopButAlive) { return &fParticleChange; }
709 
710  G4double finalT = track.GetKineticEnergy();
711 
712  // forced process - should happen only once per track
713  if(biasFlag) {
715  biasFlag = false;
716  }
717  }
718 
719  // Integral approach
720  if (integral) {
721  G4double lx = GetLambda(finalT, currentCouple);
722  if(preStepLambda<lx && 1 < verboseLevel) {
723  G4cout << "WARNING: for " << currentParticle->GetParticleName()
724  << " and " << GetProcessName()
725  << " E(MeV)= " << finalT/MeV
726  << " preLambda= " << preStepLambda << " < "
727  << lx << " (postLambda) "
728  << G4endl;
729  }
730 
731  if(preStepLambda*G4UniformRand() > lx) {
733  return &fParticleChange;
734  }
735  }
736 
738  if(!currentModel->IsActive(finalT)) { return &fParticleChange; }
739 
740  // define new weight for primary and secondaries
742  if(weightFlag) {
743  weight /= biasFactor;
745  }
746 
747  /*
748  if(0 < verboseLevel) {
749  G4cout << "G4VEmProcess::PostStepDoIt: Sample secondary; E= "
750  << finalT/MeV
751  << " MeV; model= (" << currentModel->LowEnergyLimit()
752  << ", " << currentModel->HighEnergyLimit() << ")"
753  << G4endl;
754  }
755  */
756 
757  // sample secondaries
758  secParticles.clear();
760  currentCouple,
761  track.GetDynamicParticle(),
762  (*theCuts)[currentCoupleIndex]);
763 
764  G4int num0 = secParticles.size();
765 
766  // splitting or Russian roulette
767  if(biasManager) {
769  G4double eloss = 0.0;
771  secParticles, track, currentModel, &fParticleChange, eloss,
773  step.GetPostStepPoint()->GetSafety());
774  if(eloss > 0.0) {
777  }
778  }
779  }
780 
781  // save secondaries
782  G4int num = secParticles.size();
783  if(num > 0) {
784 
787  G4double time = track.GetGlobalTime();
788 
789  for (G4int i=0; i<num; ++i) {
790  if (secParticles[i]) {
793  G4double e = dp->GetKineticEnergy();
794  G4bool good = true;
795  if(applyCuts) {
796  if (p == theGamma) {
797  if (e < (*theCutsGamma)[currentCoupleIndex]) { good = false; }
798 
799  } else if (p == theElectron) {
800  if (e < (*theCutsElectron)[currentCoupleIndex]) { good = false; }
801 
802  } else if (p == thePositron) {
803  if (electron_mass_c2 < (*theCutsGamma)[currentCoupleIndex] &&
805  good = false;
806  e += 2.0*electron_mass_c2;
807  }
808  }
809  // added secondary if it is good
810  }
811  if (good) {
812  G4Track* t = new G4Track(dp, time, track.GetPosition());
814  t->SetWeight(weight);
816 
817  // define type of secondary
819  else if(i < num0) {
820  if(p == theGamma) {
822  } else {
824  }
825  } else {
827  }
828 
829  //G4cout << "Secondary(post step) has weight " << t->GetWeight()
830  // << ", Ekin= " << t->GetKineticEnergy()/MeV << " MeV" <<G4endl;
831  } else {
832  delete dp;
833  edep += e;
834  }
835  }
836  }
838  }
839 
845  }
846 
847  return &fParticleChange;
848 }
849 
850 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
851 
853  const G4String& directory,
854  G4bool ascii)
855 {
856  G4bool yes = true;
857  const G4VEmProcess* masterProc =
858  static_cast<const G4VEmProcess*>(GetMasterProcess());
859  if(masterProc && masterProc != this) { return yes; }
860 
861  if ( theLambdaTable && part == particle) {
862  const G4String name =
863  GetPhysicsTableFileName(part,directory,"Lambda",ascii);
864  yes = theLambdaTable->StorePhysicsTable(name,ascii);
865 
866  if ( yes ) {
867  G4cout << "Physics table is stored for " << particle->GetParticleName()
868  << " and process " << GetProcessName()
869  << " in the directory <" << directory
870  << "> " << G4endl;
871  } else {
872  G4cout << "Fail to store Physics Table for "
874  << " and process " << GetProcessName()
875  << " in the directory <" << directory
876  << "> " << G4endl;
877  }
878  }
879  if ( theLambdaTablePrim && part == particle) {
880  const G4String name =
881  GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
882  yes = theLambdaTablePrim->StorePhysicsTable(name,ascii);
883 
884  if ( yes ) {
885  G4cout << "Physics table prim is stored for "
887  << " and process " << GetProcessName()
888  << " in the directory <" << directory
889  << "> " << G4endl;
890  } else {
891  G4cout << "Fail to store Physics Table Prim for "
893  << " and process " << GetProcessName()
894  << " in the directory <" << directory
895  << "> " << G4endl;
896  }
897  }
898  return yes;
899 }
900 
901 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
902 
904  const G4String& directory,
905  G4bool ascii)
906 {
907  if(1 < verboseLevel) {
908  G4cout << "G4VEmProcess::RetrievePhysicsTable() for "
909  << part->GetParticleName() << " and process "
910  << GetProcessName() << G4endl;
911  }
912  G4bool yes = true;
913 
915  || particle != part) { return yes; }
916 
917  const G4String particleName = part->GetParticleName();
918  G4String filename;
919 
920  if(buildLambdaTable) {
921  filename = GetPhysicsTableFileName(part,directory,"Lambda",ascii);
923  filename,ascii);
924  if ( yes ) {
925  if (0 < verboseLevel) {
926  G4cout << "Lambda table for " << particleName
927  << " is Retrieved from <"
928  << filename << ">"
929  << G4endl;
930  }
931  if(theParameters->Spline()) {
932  size_t n = theLambdaTable->length();
933  for(size_t i=0; i<n; ++i) {
934  if((* theLambdaTable)[i]) {
935  (* theLambdaTable)[i]->SetSpline(true);
936  }
937  }
938  }
939  } else {
940  if (1 < verboseLevel) {
941  G4cout << "Lambda table for " << particleName << " in file <"
942  << filename << "> is not exist"
943  << G4endl;
944  }
945  }
946  }
948  filename = GetPhysicsTableFileName(part,directory,"LambdaPrim",ascii);
950  filename,ascii);
951  if ( yes ) {
952  if (0 < verboseLevel) {
953  G4cout << "Lambda table prim for " << particleName
954  << " is Retrieved from <"
955  << filename << ">"
956  << G4endl;
957  }
958  if(theParameters->Spline()) {
959  size_t n = theLambdaTablePrim->length();
960  for(size_t i=0; i<n; ++i) {
961  if((* theLambdaTablePrim)[i]) {
962  (* theLambdaTablePrim)[i]->SetSpline(true);
963  }
964  }
965  }
966  } else {
967  if (1 < verboseLevel) {
968  G4cout << "Lambda table prim for " << particleName << " in file <"
969  << filename << "> is not exist"
970  << G4endl;
971  }
972  }
973  }
974 
975  return yes;
976 }
977 
978 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
979 
980 G4double
982  const G4MaterialCutsCouple* couple)
983 {
984  // Cross section per atom is calculated
985  DefineMaterial(couple);
986  G4double cross = 0.0;
988  cross = GetCurrentLambda(kineticEnergy);
989  } else {
990  SelectModel(kineticEnergy, currentCoupleIndex);
993  kineticEnergy);
994  }
995 
996  if(cross < 0.0) { cross = 0.0; }
997  return cross;
998 }
999 
1000 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1001 
1003  G4double,
1005 {
1006  *condition = NotForced;
1007  return G4VEmProcess::MeanFreePath(track);
1008 }
1009 
1010 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1011 
1013 {
1016  G4double x = DBL_MAX;
1017  if(0.0 < preStepLambda) { x = 1.0/preStepLambda; }
1018  return x;
1019 }
1020 
1021 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1022 
1023 G4double
1025  G4double Z, G4double A, G4double cut)
1026 {
1027  SelectModel(kineticEnergy, currentCoupleIndex);
1028  G4double x = 0.0;
1029  if(currentModel) {
1031  Z,A,cut);
1032  }
1033  return x;
1034 }
1035 
1036 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1037 
1039 {
1040  if(1 < verboseLevel) {
1041  G4cout << "### G4VEmProcess::FindLambdaMax: "
1042  << particle->GetParticleName()
1043  << " and process " << GetProcessName() << " " << G4endl;
1044  }
1045  size_t n = theLambdaTable->length();
1046  G4PhysicsVector* pv;
1047  G4double e, ss, emax, smax;
1048 
1049  size_t i;
1050 
1051  // first loop on existing vectors
1052  for (i=0; i<n; ++i) {
1053  pv = (*theLambdaTable)[i];
1054  if(pv) {
1055  size_t nb = pv->GetVectorLength();
1056  emax = DBL_MAX;
1057  smax = 0.0;
1058  if(nb > 0) {
1059  for (size_t j=0; j<nb; ++j) {
1060  e = pv->Energy(j);
1061  ss = (*pv)(j);
1062  if(ss > smax) {
1063  smax = ss;
1064  emax = e;
1065  }
1066  }
1067  }
1069  theCrossSectionMax[i] = smax;
1070  if(1 < verboseLevel) {
1071  G4cout << "For " << particle->GetParticleName()
1072  << " Max CS at i= " << i << " emax(MeV)= " << emax/MeV
1073  << " lambda= " << smax << G4endl;
1074  }
1075  }
1076  }
1077  // second loop using base materials
1078  for (i=0; i<n; ++i) {
1079  pv = (*theLambdaTable)[i];
1080  if(!pv){
1081  G4int j = (*theDensityIdx)[i];
1083  theCrossSectionMax[i] = (*theDensityFactor)[i]*theCrossSectionMax[j];
1084  }
1085  }
1086 }
1087 
1088 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1089 
1092 {
1093  G4PhysicsVector* v =
1096  return v;
1097 }
1098 
1099 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1100 
1102 {
1103  const G4Element* elm = nullptr;
1105  return elm;
1106 }
1107 
1108 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1109 
1111 {
1112  if(f > 0.0) {
1113  biasFactor = f;
1114  weightFlag = flag;
1115  if(1 < verboseLevel) {
1116  G4cout << "### SetCrossSectionBiasingFactor: for "
1117  << particle->GetParticleName()
1118  << " and process " << GetProcessName()
1119  << " biasFactor= " << f << " weightFlag= " << flag
1120  << G4endl;
1121  }
1122  }
1123 }
1124 
1125 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1126 
1127 void
1129  G4bool flag)
1130 {
1131  if(!biasManager) { biasManager = new G4EmBiasingManager(); }
1132  if(1 < verboseLevel) {
1133  G4cout << "### ActivateForcedInteraction: for "
1134  << particle->GetParticleName()
1135  << " and process " << GetProcessName()
1136  << " length(mm)= " << length/mm
1137  << " in G4Region <" << r
1138  << "> weightFlag= " << flag
1139  << G4endl;
1140  }
1141  weightFlag = flag;
1143 }
1144 
1145 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1146 
1147 void
1149  G4double factor,
1150  G4double energyLimit)
1151 {
1152  if (0.0 <= factor) {
1153 
1154  // Range cut can be applied only for e-
1155  if(0.0 == factor && secondaryParticle != G4Electron::Electron())
1156  { return; }
1157 
1158  if(!biasManager) { biasManager = new G4EmBiasingManager(); }
1159  biasManager->ActivateSecondaryBiasing(region, factor, energyLimit);
1160  if(1 < verboseLevel) {
1161  G4cout << "### ActivateSecondaryBiasing: for "
1162  << " process " << GetProcessName()
1163  << " factor= " << factor
1164  << " in G4Region <" << region
1165  << "> energyLimit(MeV)= " << energyLimit/MeV
1166  << G4endl;
1167  }
1168  }
1169 }
1170 
1171 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1172 
1174 {
1175  if(5 < n && n < 10000000) {
1176  nLambdaBins = n;
1177  actBinning = true;
1178  } else {
1179  G4double e = (G4double)n;
1180  PrintWarning("SetLambdaBinning", e);
1181  }
1182 }
1183 
1184 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1185 
1187 {
1188  if(1.e-3*eV < e && e < maxKinEnergy) {
1191  minKinEnergy = e;
1192  actMinKinEnergy = true;
1193  } else { PrintWarning("SetMinKinEnergy", e); }
1194 }
1195 
1196 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1197 
1199 {
1200  if(minKinEnergy < e && e < 1.e+6*TeV) {
1203  maxKinEnergy = e;
1204  actMaxKinEnergy = true;
1205  } else { PrintWarning("SetMaxKinEnergy", e); }
1206 }
1207 
1208 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1209 
1211 {
1212  if(theParameters->MinKinEnergy() <= e &&
1213  e <= theParameters->MaxKinEnergy()) { minKinEnergyPrim = e; }
1214  else { PrintWarning("SetMinKinEnergyPrim", e); }
1215 }
1216 
1217 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1218 
1220 {
1221  G4String ss = "G4VEmProcess::" + tit;
1223  ed << "Parameter is out of range: " << val
1224  << " it will have no effect!\n" << " Process "
1225  << GetProcessName() << " nbins= " << theParameters->NumberOfBins()
1226  << " Emin(keV)= " << theParameters->MinKinEnergy()/keV
1227  << " Emax(GeV)= " << theParameters->MaxKinEnergy()/GeV;
1228  G4Exception(ss, "em0044", JustWarning, ed);
1229 }
1230 
1231 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1232 
1233 void G4VEmProcess::ProcessDescription(std::ostream& outFile) const
1234 {
1235  outFile << "EM process <" << GetProcessName() << ">" << G4endl;
1236 }
1237 
1238 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void ActivateForcedInteraction(G4double length=0.0, const G4String &r="", G4bool flag=true)
G4double condition(const G4ErrorSymMatrix &m)
G4PhysicsTable * LambdaTable() const
const std::vector< G4double > * theCutsGamma
const G4VProcess * GetMasterProcess() const
Definition: G4VProcess.hh:538
std::vector< G4double > theCrossSectionMax
void DefineMaterial(const G4MaterialCutsCouple *couple)
virtual void PrintInfo()=0
G4int GetParentID() const
G4double GetLambda(G4double &kinEnergy, const G4MaterialCutsCouple *couple)
virtual G4double CrossSectionPerVolume(const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:258
static const double MeV
Definition: G4SIunits.hh:211
G4int NumberOfBins() const
G4PhysicsTable * LambdaTablePrim() const
const std::vector< G4double > * GetEnergyCutsVector(size_t pcIdx) const
G4VEmModel * SelectModel(G4double &kinEnergy, size_t index)
const std::vector< G4double > * GetDensityFactors()
static void SetPhysicsVector(G4PhysicsTable *physTable, size_t idx, G4PhysicsVector *vec)
G4bool Spline() const
G4int WorkerVerbose() const
G4double MaxKinEnergy() const
G4bool weightFlag
static G4LossTableManager * Instance()
void ActivateForcedInteraction(G4double length=0.0, const G4String &r="")
G4double GetMaxEnergy() const
G4double ApplySecondaryBiasing(std::vector< G4DynamicParticle * > &, const G4Track &track, G4VEmModel *currentModel, G4ParticleChangeForGamma *pParticleChange, G4double &eloss, G4int coupleIdx, G4double tcut, G4double safety=0.0)
G4int verboseLevel
Definition: G4VProcess.hh:368
void UpdateEmModel(const G4String &, G4double, G4double)
virtual void SampleSecondaries(std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin=0.0, G4double tmax=DBL_MAX)=0
std::ostringstream G4ExceptionDescription
Definition: globals.hh:76
G4PhysicsTable * theLambdaTablePrim
G4double GetKineticEnergy() const
G4double HighEnergyLimit() const
Definition: G4VEmModel.hh:634
G4VEmProcess(const G4String &name, G4ProcessType type=fElectromagnetic)
Definition: G4VEmProcess.cc:91
const G4DynamicParticle * GetDynamicParticle() const
G4VEmModel * currentModel
G4bool SecondaryBiasingRegion(G4int coupleIdx)
G4double ComputeCrossSectionPerAtom(G4double kineticEnergy, G4double Z, G4double A=0., G4double cut=0.0)
G4VEmModel * EmModel(G4int index=1) const
G4VEmModel * GetModel(G4int, G4bool ver=false)
void DeRegister(G4VEnergyLossProcess *p)
G4String name
Definition: TRTMaterials.hh:40
G4double MscThetaLimit() const
const G4ThreeVector & GetPosition() const
G4ParticleChangeForGamma fParticleChange
virtual void InitialiseLocal(const G4ParticleDefinition *, G4VEmModel *masterModel)
Definition: G4VEmModel.cc:219
G4TrackStatus GetTrackStatus() const
G4bool ForcedInteractionRegion(G4int coupleIdx)
G4EmParameters * theParameters
const G4MaterialCutsCouple * GetMaterialCutsCouple() const
const std::vector< G4double > * theCutsPositron
virtual void InitialiseProcess(const G4ParticleDefinition *)=0
size_t basedCoupleIndex
virtual ~G4VEmProcess()
G4double theNumberOfInteractionLengthLeft
Definition: G4VProcess.hh:293
const G4MaterialCutsCouple * currentCouple
G4bool GetFlag(size_t idx) const
void SetTouchableHandle(const G4TouchableHandle &apValue)
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *, const G4Region *)
G4double GetParentWeight() const
G4double lambdaFactor
#define G4BestUnit(a, b)
#define G4_USE_G4BESTUNIT_FOR_VERBOSE 1
virtual void BuildPhysicsTable(const G4ParticleDefinition &)
G4bool ApplyCuts() const
virtual G4double PostStepGetPhysicalInteractionLength(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
size_t GetVectorLength() const
const G4String & GetParticleSubType() const
const G4Material * baseMaterial
G4double fFactor
G4PhysicsTable * theLambdaTable
void ClearNumberOfInteractionLengthLeft()
Definition: G4VProcess.hh:447
void FillLambdaVector(G4PhysicsVector *, const G4MaterialCutsCouple *, G4bool startFromNull=true, G4EmTableType t=fRestricted)
G4double minKinEnergyPrim
G4ProcessManager * GetProcessManager() const
int G4int
Definition: G4Types.hh:78
void FillSecondDerivatives()
void UpdateEmModel(const G4String &, G4double, G4double)
G4double GetCurrentLambda(G4double kinEnergy)
const G4String & GetPhysicsTableFileName(const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
Definition: G4VProcess.cc:186
static G4PhysicsTable * PreparePhysicsTable(G4PhysicsTable *physTable)
const G4int smax
const G4String & GetParticleName() const
G4bool applyCuts
void ActivateSecondaryBiasing(const G4String &region, G4double factor, G4double energyLimit)
G4LossTableBuilder * GetTableBuilder()
void SetWeight(G4double aValue)
void ProposeLocalEnergyDeposit(G4double anEnergyPart)
void SetCreatorModelIndex(G4int idx)
void SetSpline(G4bool)
void Initialise(const G4ParticleDefinition &part, const G4String &procName, G4int verbose)
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:725
void SetMinKinEnergyPrim(G4double e)
G4double mfpKinEnergy
void SetCrossSectionBiasingFactor(G4double f, G4bool flag=true)
virtual G4double MinPrimaryEnergy(const G4ParticleDefinition *, const G4Material *)
G4double MeanFreePath(const G4Track &track)
const G4ParticleDefinition * currentParticle
void SetLambdaBinning(G4int nbins)
void ProposeWeight(G4double finalWeight)
G4double minKinEnergy
void SetSecondaryWeightByProcess(G4bool)
G4double LambdaFactor() const
void SetEmModel(G4VEmModel *, G4int index=1)
G4ProcessVector * GetAtRestProcessVector(G4ProcessVectorTypeIndex typ=typeGPIL) const
G4double GetKineticEnergy() const
G4bool splineFlag
#define G4UniformRand()
Definition: Randomize.hh:97
G4GLOB_DLL std::ostream G4cout
G4int Verbose() const
double A(double temperature)
virtual G4bool RetrievePhysicsTable(const G4ParticleDefinition *, const G4String &directory, G4bool ascii)
void SetParticleChange(G4VParticleChange *, G4VEmFluctuationModel *f=0)
Definition: G4VEmModel.cc:410
G4bool startFromNull
bool G4bool
Definition: G4Types.hh:79
const std::vector< G4int > * theDensityIdx
void SetParticle(const G4ParticleDefinition *p)
G4double GetStepLimit(G4int coupleIdx, G4double previousStep)
G4double currentInteractionLength
Definition: G4VProcess.hh:297
void PrintInfoProcess(const G4ParticleDefinition &)
std::vector< G4DynamicParticle * > secParticles
virtual G4double GetMeanFreePath(const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
const G4ParticleDefinition * GetParticleDefinition() const
G4bool actSpline
G4bool IsMaster() const
G4LossTableManager * lManager
static const double GeV
Definition: G4SIunits.hh:214
const G4String & GetParticleType() const
void Register(G4VEnergyLossProcess *p)
const G4ParticleDefinition * secondaryParticle
Definition: G4Step.hh:76
G4double MinKinEnergy() const
std::vector< G4double > theEnergyOfCrossSectionMax
G4bool actBinning
const G4ParticleDefinition * GetParticleDefinition() const
const G4int n
G4double GetGlobalTime() const
const G4ParticleDefinition * particle
virtual void PreparePhysicsTable(const G4ParticleDefinition &)
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4double Energy(size_t index) const
const std::vector< G4double > * theCuts
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
void AddSecondary(G4Track *aSecondary)
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:313
const G4TouchableHandle & GetTouchableHandle() const
G4bool IsActive(G4double kinEnergy)
Definition: G4VEmModel.hh:753
void DumpModelList(G4int verb)
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
const G4DataVector * Initialise(const G4ParticleDefinition *part, const G4ParticleDefinition *secPart, G4double minSubRange, G4int verb)
static const G4double emax
void SetMasterThread(G4bool val)
Definition: G4VEmModel.hh:711
size_t length() const
G4double G4Log(G4double x)
Definition: G4Log.hh:230
std::vector< G4VEmModel * > emModels
G4int size() const
void ActivateSecondaryBiasing(const G4String &region, G4double factor, G4double energyLimit)
static G4ProductionCutsTable * GetProductionCutsTable()
static const double eV
Definition: G4SIunits.hh:212
G4PhysicsVector * LambdaPhysicsVector(const G4MaterialCutsCouple *)
static G4Positron * Positron()
Definition: G4Positron.cc:94
static G4GenericIon * GenericIon()
Definition: G4GenericIon.cc:93
G4int NumberOfModels() const
const G4Material * currentMaterial
void SetMaxKinEnergy(G4double e)
size_t idxLambdaPrim
void FindLambdaMax()
static const G4double factor
const G4ParticleDefinition * theElectron
const G4MaterialCutsCouple * GetMaterialCutsCouple(G4int i) const
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=0)
int G4lrint(double ad)
Definition: templates.hh:163
virtual void ProcessDescription(std::ostream &outFile) const
G4bool actMaxKinEnergy
G4double GetProposedKineticEnergy() const
T max(const T t1, const T t2)
brief Return the largest of the two arguments
void InitialiseBaseMaterials(G4PhysicsTable *table)
size_t idxLambda
void SetNumberOfSecondaries(G4int totSecondaries)
static G4int Register(const G4String &)
G4double GetLocalEnergyDeposit() const
G4StepPoint * GetPostStepPoint() const
G4EmModelManager * modelManager
const G4double x[NPOINTSGL]
static G4EmParameters * Instance()
G4VParticleChange * pParticleChange
Definition: G4VProcess.hh:283
const G4Element * GetCurrentElement() const
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
G4double preStepLambda
void ComputeIntegralLambda(G4double kinEnergy)
G4EmBiasingManager * biasManager
G4double GetSafety() const
void PreparePhysicsTable(const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p, G4bool theMaster)
static G4Electron * Electron()
Definition: G4Electron.cc:94
#define G4endl
Definition: G4ios.hh:61
void SetFluoFlag(G4bool val)
static const double TeV
Definition: G4SIunits.hh:215
G4bool StorePhysicsTable(const G4String &filename, G4bool ascii=false)
G4TrackStatus GetTrackStatus() const
G4VEmModel * GetModelByIndex(G4int idx=0, G4bool ver=false) const
G4int numberOfModels
const std::vector< G4double > * theDensityFactor
G4VAtomDeexcitation * AtomDeexcitation()
static const double keV
Definition: G4SIunits.hh:213
G4double biasFactor
size_t currentCoupleIndex
G4bool actMinKinEnergy
void SetMinKinEnergy(G4double e)
G4double theInitialNumberOfInteractionLength
Definition: G4VProcess.hh:300
double G4double
Definition: G4Types.hh:76
void ProposeTrackStatus(G4TrackStatus status)
const std::vector< G4double > * theCutsElectron
void InitializeForPostStep(const G4Track &)
G4ForceCondition
virtual void StartTracking(G4Track *)
static G4bool RetrievePhysicsTable(G4PhysicsTable *physTable, const G4String &fileName, G4bool ascii)
#define DBL_MAX
Definition: templates.hh:83
G4double CrossSectionPerVolume(G4double kineticEnergy, const G4MaterialCutsCouple *couple)
void PrintWarning(G4String tit, G4double val)
virtual G4bool StorePhysicsTable(const G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)
static const double mm
Definition: G4SIunits.hh:114
G4int GetProcessSubType() const
Definition: G4VProcess.hh:426
G4double maxKinEnergy
G4double preStepKinEnergy
G4bool buildLambdaTable
void SetPolarAngleLimit(G4double)
Definition: G4VEmModel.hh:760
virtual G4VParticleChange * PostStepDoIt(const G4Track &, const G4Step &)
void clearAndDestroy()
const G4ParticleDefinition * theGamma
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:437
const G4ParticleDefinition * thePositron
const G4Material * GetMaterial() const
G4int mainSecondaries
void BuildLambdaTable()
const std::vector< G4int > * GetCoupleIndexes()
G4ProcessType
const G4Element * GetCurrentElement() const
Definition: G4VEmModel.hh:467