Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Protected Attributes | List of all members
G4KleinNishinaModel Class Reference

#include <G4KleinNishinaModel.hh>

Inheritance diagram for G4KleinNishinaModel:
Inheritance graph
[legend]
Collaboration diagram for G4KleinNishinaModel:
Collaboration graph
[legend]

Public Member Functions

 G4KleinNishinaModel (const G4String &nam="KleinNishina")
 
virtual ~G4KleinNishinaModel ()
 
virtual void Initialise (const G4ParticleDefinition *, const G4DataVector &) override
 
virtual void InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *masterModel) override
 
virtual G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A, G4double cut, G4double emax) override
 
virtual void SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy) override
 
- Public Member Functions inherited from G4VEmModel
 G4VEmModel (const G4String &nam)
 
virtual ~G4VEmModel ()
 
virtual void InitialiseForMaterial (const G4ParticleDefinition *, const G4Material *)
 
virtual void InitialiseForElement (const G4ParticleDefinition *, G4int Z)
 
virtual G4double ComputeDEDXPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
 
virtual G4double CrossSectionPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
virtual G4double GetPartialCrossSection (const G4Material *, G4int level, const G4ParticleDefinition *, G4double kineticEnergy)
 
virtual G4double ComputeCrossSectionPerShell (const G4ParticleDefinition *, G4int Z, G4int shellIdx, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
virtual G4double ChargeSquareRatio (const G4Track &)
 
virtual G4double GetChargeSquareRatio (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual G4double GetParticleCharge (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual void StartTracking (G4Track *)
 
virtual void CorrectionsAlongStep (const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double &eloss, G4double &niel, G4double length)
 
virtual G4double Value (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy)
 
virtual G4double MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double cut=0.0)
 
virtual G4double MinEnergyCut (const G4ParticleDefinition *, const G4MaterialCutsCouple *)
 
virtual void SetupForMaterial (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
 
virtual void DefineForRegion (const G4Region *)
 
virtual void ModelDescription (std::ostream &outFile) const
 
void InitialiseElementSelectors (const G4ParticleDefinition *, const G4DataVector &)
 
std::vector
< G4EmElementSelector * > * 		GetElementSelectors ()
 
void SetElementSelectors (std::vector< G4EmElementSelector * > *)
 
virtual G4double ComputeDEDX (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
 
G4double CrossSection (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4double ComputeMeanFreePath (const G4ParticleDefinition *, G4double kineticEnergy, const G4Material *, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4double ComputeCrossSectionPerAtom (const G4ParticleDefinition *, const G4Element *, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4int SelectIsotopeNumber (const G4Element *)
 
const G4Element * SelectRandomAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
const G4Element * SelectRandomAtom (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
 
G4int SelectRandomAtomNumber (const G4Material *)
 
void SetParticleChange (G4VParticleChange *, G4VEmFluctuationModel *f=nullptr)
 
void SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)
 
G4ElementData * GetElementData ()
 
G4PhysicsTable * GetCrossSectionTable ()
 
G4VEmFluctuationModel * GetModelOfFluctuations ()
 
G4VEmAngularDistribution * GetAngularDistribution ()
 
void SetAngularDistribution (G4VEmAngularDistribution *)
 
G4double HighEnergyLimit () const
 
G4double LowEnergyLimit () const
 
G4double HighEnergyActivationLimit () const
 
G4double LowEnergyActivationLimit () const
 
G4double PolarAngleLimit () const
 
G4double SecondaryThreshold () const
 
G4bool LPMFlag () const
 
G4bool DeexcitationFlag () const
 
G4bool ForceBuildTableFlag () const
 
G4bool UseAngularGeneratorFlag () const
 
void SetAngularGeneratorFlag (G4bool)
 
void SetHighEnergyLimit (G4double)
 
void SetLowEnergyLimit (G4double)
 
void SetActivationHighEnergyLimit (G4double)
 
void SetActivationLowEnergyLimit (G4double)
 
G4bool IsActive (G4double kinEnergy)
 
void SetPolarAngleLimit (G4double)
 
void SetSecondaryThreshold (G4double)
 
void SetLPMFlag (G4bool val)
 
void SetDeexcitationFlag (G4bool val)
 
void SetForceBuildTable (G4bool val)
 
void SetFluctuationFlag (G4bool val)
 
void SetMasterThread (G4bool val)
 
G4bool IsMaster () const
 
G4double MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)
 
const G4String & GetName () const
 
void SetCurrentCouple (const G4MaterialCutsCouple *)
 
const G4Element * GetCurrentElement () const
 
const G4Isotope * GetCurrentIsotope () const
 
G4bool IsLocked () const
 
void SetLocked (G4bool)
 

Protected Attributes

G4ParticleDefinition * theGamma
 
G4ParticleDefinition * theElectron
 
G4ParticleChangeForGamma * fParticleChange
 
G4double lowestSecondaryEnergy
 
- Protected Attributes inherited from G4VEmModel
G4ElementData * fElementData
 
G4VParticleChange * pParticleChange
 
G4PhysicsTable * xSectionTable
 
const std::vector< G4double > * theDensityFactor
 
const std::vector< G4int > * theDensityIdx
 
size_t idxTable
 
G4bool lossFlucFlag
 

Additional Inherited Members

- Protected Member Functions inherited from G4VEmModel
G4ParticleChangeForLoss * GetParticleChangeForLoss ()
 
G4ParticleChangeForGamma * GetParticleChangeForGamma ()
 
virtual G4double MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kineticEnergy)
 
const G4MaterialCutsCouple * CurrentCouple () const
 
void SetCurrentElement (const G4Element *)
 
- Static Protected Attributes inherited from G4VEmModel
static const G4double inveplus = 1.0/CLHEP::eplus
 

Detailed Description

Definition at line 59 of file G4KleinNishinaModel.hh.

Constructor & Destructor Documentation

G4KleinNishinaModel::G4KleinNishinaModel ( const G4String &  nam = "KleinNishina")
explicit

Definition at line 67 of file G4KleinNishinaModel.cc.

68  : G4VEmModel(nam),
69  lv1(0.,0.,0.,0.),
70  lv2(0.,0.,0.,0.),
71  bst(0.,0.,0.)
72 {
73  theGamma = G4Gamma::Gamma();
74  theElectron = G4Electron::Electron();
75  lowestSecondaryEnergy = 10*eV;
76  limitFactor = 4;
77  fProbabilities.resize(9,0.0);
78  SetDeexcitationFlag(true);
79  fParticleChange = nullptr;
80  fAtomDeexcitation = nullptr;
81 }
G4KleinNishinaModel::fParticleChange
G4ParticleChangeForGamma * fParticleChange
Definition: G4KleinNishinaModel.hh:92
G4VEmModel::G4VEmModel
G4VEmModel(const G4String &nam)
Definition: G4VEmModel.cc:68
eV
static constexpr double eV
Definition: G4SIunits.hh:215
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4KleinNishinaModel::theElectron
G4ParticleDefinition * theElectron
Definition: G4KleinNishinaModel.hh:91
G4KleinNishinaModel::theGamma
G4ParticleDefinition * theGamma
Definition: G4KleinNishinaModel.hh:90
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94
G4VEmModel::SetDeexcitationFlag
void SetDeexcitationFlag(G4bool val)
Definition: G4VEmModel.hh:788

Here is the call graph for this function:

G4KleinNishinaModel::~G4KleinNishinaModel ( )
virtual

Definition at line 85 of file G4KleinNishinaModel.cc.

86 {}

Member Function Documentation

G4double G4KleinNishinaModel::ComputeCrossSectionPerAtom ( const G4ParticleDefinition *  ,
G4double  kinEnergy,
G4double  Z,
G4double  A,
G4double  cut,
G4double  emax 
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 111 of file G4KleinNishinaModel.cc.

115 {
116  G4double xSection = 0.0 ;
117  if (gammaEnergy <= LowEnergyLimit()) { return xSection; }
118 
119  static const G4double a = 20.0 , b = 230.0 , c = 440.0;
120 
121 static const G4double
122  d1= 2.7965e-1*CLHEP::barn, d2=-1.8300e-1*CLHEP::barn,
123  d3= 6.7527 *CLHEP::barn, d4=-1.9798e+1*CLHEP::barn,
124  e1= 1.9756e-5*CLHEP::barn, e2=-1.0205e-2*CLHEP::barn,
125  e3=-7.3913e-2*CLHEP::barn, e4= 2.7079e-2*CLHEP::barn,
126  f1=-3.9178e-7*CLHEP::barn, f2= 6.8241e-5*CLHEP::barn,
127  f3= 6.0480e-5*CLHEP::barn, f4= 3.0274e-4*CLHEP::barn;
128 
129  G4double p1Z = Z*(d1 + e1*Z + f1*Z*Z), p2Z = Z*(d2 + e2*Z + f2*Z*Z),
130  p3Z = Z*(d3 + e3*Z + f3*Z*Z), p4Z = Z*(d4 + e4*Z + f4*Z*Z);
131 
132  G4double T0 = 15.0*keV;
133  if (Z < 1.5) { T0 = 40.0*keV; }
134 
135  G4double X = max(gammaEnergy, T0) / electron_mass_c2;
136  xSection = p1Z*G4Log(1.+2.*X)/X
137  + (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
138 
139  // modification for low energy. (special case for Hydrogen)
140  static const G4double dT0 = keV;
141  if (gammaEnergy < T0) {
142  X = (T0+dT0) / electron_mass_c2 ;
143  G4double sigma = p1Z*G4Log(1.+2*X)/X
144  + (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
145  G4double c1 = -T0*(sigma-xSection)/(xSection*dT0);
146  G4double c2 = 0.150;
147  if (Z > 1.5) { c2 = 0.375-0.0556*G4Log(Z); }
148  G4double y = G4Log(gammaEnergy/T0);
149  xSection *= G4Exp(-y*(c1+c2*y));
150  }
151 
152  if(xSection < 0.0) { xSection = 0.0; }
153  // G4cout << "e= " << GammaEnergy << " Z= " << Z
154  // << " cross= " << xSection << G4endl;
155  return xSection;
156 }
c2
static c2_factory< G4double > c2
Definition: G4ScreenedNuclearRecoil.cc:126
G4VEmModel::LowEnergyLimit
G4double LowEnergyLimit() const
Definition: G4VEmModel.hh:643
a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
d2
static const G4double d2
Definition: G4ElectroNuclearCrossSection.cc:89
test.b
tuple b
Definition: test.py:12
CLHEP::barn
static constexpr double barn
Definition: SystemOfUnits.h:85
python.hepunit.electron_mass_c2
float electron_mass_c2
Definition: hepunit.py:274
d1
static const G4double d1
Definition: G4ElectroNuclearCrossSection.cc:88
G4Log
G4double G4Log(G4double x)
Definition: G4Log.hh:230
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition: G4INCLGlobals.hh:112
T0
static const G4double T0[78]
Definition: G4NISTStoppingData.hh:91
G4double
double G4double
Definition: G4Types.hh:76
test.c
tuple c
Definition: test.py:13
keV
static constexpr double keV
Definition: G4SIunits.hh:216
plottest35.c1
tuple c1
Definition: plottest35.py:14
Z
G4int Z
Definition: G4ParticleHPJENDLHEData.cc:262

Here is the call graph for this function:

void G4KleinNishinaModel::Initialise ( const G4ParticleDefinition *  p,
const G4DataVector &  cuts 
)
overridevirtual

Implements G4VEmModel.

Definition at line 90 of file G4KleinNishinaModel.cc.

92 {
93  fAtomDeexcitation = G4LossTableManager::Instance()->AtomDeexcitation();
94  if(IsMaster()) { InitialiseElementSelectors(p, cuts); }
95  if(nullptr == fParticleChange) {
96  fParticleChange = GetParticleChangeForGamma();
97  }
98 }
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:112
G4VEmModel::InitialiseElementSelectors
void InitialiseElementSelectors(const G4ParticleDefinition *, const G4DataVector &)
Definition: G4VEmModel.cc:146
G4KleinNishinaModel::fParticleChange
G4ParticleChangeForGamma * fParticleChange
Definition: G4KleinNishinaModel.hh:92
G4VEmModel::IsMaster
G4bool IsMaster() const
Definition: G4VEmModel.hh:725
G4LossTableManager::AtomDeexcitation
G4VAtomDeexcitation * AtomDeexcitation()
Definition: G4LossTableManager.hh:444
G4VEmModel::GetParticleChangeForGamma
G4ParticleChangeForGamma * GetParticleChangeForGamma()
Definition: G4VEmModel.cc:132

Here is the call graph for this function:

void G4KleinNishinaModel::InitialiseLocal ( const G4ParticleDefinition *  ,
G4VEmModel *  masterModel 
)
overridevirtual

Reimplemented from G4VEmModel.

Definition at line 102 of file G4KleinNishinaModel.cc.

104 {
105  SetElementSelectors(masterModel->GetElementSelectors());
106 }
G4VEmModel::GetElementSelectors
std::vector< G4EmElementSelector * > * GetElementSelectors()
Definition: G4VEmModel.hh:809
G4VEmModel::SetElementSelectors
void SetElementSelectors(std::vector< G4EmElementSelector * > *)
Definition: G4VEmModel.hh:817

Here is the call graph for this function:

void G4KleinNishinaModel::SampleSecondaries ( std::vector< G4DynamicParticle * > *  fvect,
const G4MaterialCutsCouple *  couple,
const G4DynamicParticle *  aDynamicGamma,
G4double  tmin,
G4double  maxEnergy 
)
overridevirtual

Implements G4VEmModel.

Definition at line 160 of file G4KleinNishinaModel.cc.

166 {
167  // primary gamma
168  G4double energy = aDynamicGamma->GetKineticEnergy();
169 
170  // do nothing below the threshold
171  if(energy <= LowEnergyLimit()) { return; }
172 
173  G4ThreeVector direction = aDynamicGamma->GetMomentumDirection();
174 
175  // select atom
176  const G4Element* elm = SelectRandomAtom(couple, theGamma, energy);
177 
178  // select shell first
179  G4int nShells = elm->GetNbOfAtomicShells();
180  if(nShells > (G4int)fProbabilities.size()) { fProbabilities.resize(nShells); }
181  G4double totprob = 0.0;
182  G4int i;
183  for(i=0; i<nShells; ++i) {
184  //G4double bindingEnergy = elm->GetAtomicShell(i);
185  totprob += elm->GetNbOfShellElectrons(i);
186  //totprob += elm->GetNbOfShellElectrons(i)/(bindingEnergy*bindingEnergy);
187  fProbabilities[i] = totprob;
188  }
189 
190  // Loop on sampling
191  static const G4int nlooplim = 1000;
192  G4int nloop = 0;
193 
194  G4double bindingEnergy, ePotEnergy, eKinEnergy;
195  G4double gamEnergy0, gamEnergy1;
196 
197  CLHEP::HepRandomEngine* rndmEngineMod = G4Random::getTheEngine();
198  G4double rndm[4];
199 
200  do {
201  ++nloop;
202 
203  // 4 random numbers to select e-
204  rndmEngineMod->flatArray(4, rndm);
205  G4double xprob = totprob*rndm[0];
206 
207  // select shell
208  for(i=0; i<nShells; ++i) { if(xprob <= fProbabilities[i]) { break; } }
209 
210  bindingEnergy = elm->GetAtomicShell(i);
211  lv1.set(0.0,0.0,energy,energy);
212  /*
213  G4cout << "nShells= " << nShells << " i= " << i
214  << " Egamma= " << energy << " Ebind= " << bindingEnergy
215  << G4endl;
216  */
217  // for rest frame of the electron
218  G4double x = -G4Log(rndm[1]);
219  eKinEnergy = bindingEnergy*x;
220  ePotEnergy = bindingEnergy*(1.0 + x);
221 
222  // for rest frame of the electron
223  G4double eTotMomentum = sqrt(eKinEnergy*(eKinEnergy + 2*electron_mass_c2));
224  G4double phi = rndm[2]*twopi;
225  G4double costet = 2*rndm[3] - 1;
226  G4double sintet = sqrt((1 - costet)*(1 + costet));
227  lv2.set(eTotMomentum*sintet*cos(phi),eTotMomentum*sintet*sin(phi),
228  eTotMomentum*costet,eKinEnergy + electron_mass_c2);
229  bst = lv2.boostVector();
230  lv1.boost(-bst);
231 
232  gamEnergy0 = lv1.e();
233 
234  // In the rest frame of the electron
235  // The scattered gamma energy is sampled according to Klein-Nishina formula
236  // The random number techniques of Butcher & Messel are used
237  // (Nuc Phys 20(1960),15).
238  G4double E0_m = gamEnergy0/electron_mass_c2;
239 
240  //G4cout << "Nloop= "<< nloop << " Ecm(keV)= " << gamEnergy0/keV << G4endl;
241  //
242  // sample the energy rate of the scattered gamma
243  //
244 
245  G4double epsilon, epsilonsq, onecost, sint2, greject ;
246 
247  G4double eps0 = 1./(1 + 2*E0_m);
248  G4double epsilon0sq = eps0*eps0;
249  G4double alpha1 = - G4Log(eps0);
250  G4double alpha2 = alpha1 + 0.5*(1 - epsilon0sq);
251 
252  do {
253  ++nloop;
254  // false interaction if too many iterations
255  if(nloop > nlooplim) { return; }
256 
257  // 3 random numbers to sample scattering
258  rndmEngineMod->flatArray(3, rndm);
259 
260  if ( alpha1 > alpha2*rndm[0] ) {
261  epsilon = G4Exp(-alpha1*rndm[1]); // epsilon0**r
262  epsilonsq = epsilon*epsilon;
263 
264  } else {
265  epsilonsq = epsilon0sq + (1.- epsilon0sq)*rndm[1];
266  epsilon = sqrt(epsilonsq);
267  }
268 
269  onecost = (1.- epsilon)/(epsilon*E0_m);
270  sint2 = onecost*(2.-onecost);
271  greject = 1. - epsilon*sint2/(1.+ epsilonsq);
272 
273  // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
274  } while (greject < rndm[2]);
275  gamEnergy1 = epsilon*gamEnergy0;
276 
277  // before scattering total 4-momentum in e- system
278  lv2.set(0.0,0.0,0.0,electron_mass_c2);
279  lv2 += lv1;
280 
281  //
282  // scattered gamma angles. ( Z - axis along the parent gamma)
283  //
284  if(sint2 < 0.0) { sint2 = 0.0; }
285  costet = 1. - onecost;
286  sintet = sqrt(sint2);
287  phi = twopi * rndmEngineMod->flat();
288 
289  // e- recoil
290  //
291  // in rest frame of the electron
292  G4ThreeVector gamDir = lv1.vect().unit();
293  G4ThreeVector v = G4ThreeVector(sintet*cos(phi),sintet*sin(phi),costet);
294  v.rotateUz(gamDir);
295  lv1.set(gamEnergy1*v.x(),gamEnergy1*v.y(),gamEnergy1*v.z(),gamEnergy1);
296  lv2 -= lv1;
297  //G4cout<<"Egam(keV)= " << lv1.e()/keV
298  // <<" Ee(keV)= " << (lv2.e()-electron_mass_c2)/keV << G4endl;
299  lv2.boost(bst);
300  eKinEnergy = lv2.e() - electron_mass_c2 - ePotEnergy;
301  //G4cout << "Nloop= " << nloop << " eKinEnergy= " << eKinEnergy << G4endl;
302 
303  // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
304  } while ( eKinEnergy < 0.0 );
305 
306  //
307  // update G4VParticleChange for the scattered gamma
308  //
309 
310  lv1.boost(bst);
311  gamEnergy1 = lv1.e();
312  if(gamEnergy1 > lowestSecondaryEnergy) {
313  G4ThreeVector gamDirection1 = lv1.vect().unit();
314  gamDirection1.rotateUz(direction);
315  fParticleChange->ProposeMomentumDirection(gamDirection1);
316  } else {
317  fParticleChange->ProposeTrackStatus(fStopAndKill);
318  gamEnergy1 = 0.0;
319  }
320  fParticleChange->SetProposedKineticEnergy(gamEnergy1);
321 
322  //
323  // kinematic of the scattered electron
324  //
325 
326  if(eKinEnergy > lowestSecondaryEnergy) {
327  G4ThreeVector eDirection = lv2.vect().unit();
328  eDirection.rotateUz(direction);
329  G4DynamicParticle* dp =
330  new G4DynamicParticle(theElectron,eDirection,eKinEnergy);
331  fvect->push_back(dp);
332  } else { eKinEnergy = 0.0; }
333 
334  G4double edep = energy - gamEnergy1 - eKinEnergy;
335  G4double esec = 0.0;
336 
337  // sample deexcitation
338  //
339  if(fAtomDeexcitation) {
340  G4int index = couple->GetIndex();
341  if(fAtomDeexcitation->CheckDeexcitationActiveRegion(index)) {
342  G4int Z = G4lrint(elm->GetZ());
343  G4AtomicShellEnumerator as = G4AtomicShellEnumerator(i);
344  const G4AtomicShell* shell = fAtomDeexcitation->GetAtomicShell(Z, as);
345  G4int nbefore = fvect->size();
346  fAtomDeexcitation->GenerateParticles(fvect, shell, Z, index);
347  G4int nafter = fvect->size();
348  //G4cout << "N1= " << nbefore << " N2= " << nafter << G4endl;
349  for (G4int j=nbefore; j<nafter; ++j) {
350  G4double e = ((*fvect)[j])->GetKineticEnergy();
351  if(esec + e > edep) {
352  // correct energy in order to have energy balance
353  e = edep - esec;
354  ((*fvect)[j])->SetKineticEnergy(e);
355  esec += e;
356  /*
357  G4cout << "### G4KleinNishinaModel Edep(eV)= " << edep/eV
358  << " Esec(eV)= " << esec/eV
359  << " E["<< j << "](eV)= " << e/eV
360  << " N= " << nafter
361  << " Z= " << Z << " shell= " << i
362  << " Ebind(keV)= " << bindingEnergy/keV
363  << " Eshell(keV)= " << shell->BindingEnergy()/keV
364  << G4endl;
365  */
366  // delete the rest of secondaries (should not happens)
367  for (G4int jj=nafter-1; jj>j; --jj) {
368  delete (*fvect)[jj];
369  fvect->pop_back();
370  }
371  break;
372  }
373  esec += e;
374  }
375  edep -= esec;
376  }
377  }
378  if(std::abs(energy - gamEnergy1 - eKinEnergy - esec - edep) > eV) {
379  G4cout << "### G4KleinNishinaModel dE(eV)= "
380  << (energy - gamEnergy1 - eKinEnergy - esec - edep)/eV
381  << " shell= " << i
382  << " E(keV)= " << energy/keV
383  << " Ebind(keV)= " << bindingEnergy/keV
384  << " Eg(keV)= " << gamEnergy1/keV
385  << " Ee(keV)= " << eKinEnergy/keV
386  << " Esec(keV)= " << esec/keV
387  << " Edep(keV)= " << edep/keV
388  << G4endl;
389  }
390  // energy balance
391  if(edep > 0.0) {
392  fParticleChange->ProposeLocalEnergyDeposit(edep);
393  }
394 }
CLHEP::HepLorentzVector::boostVector
Hep3Vector boostVector() const
Definition: LorentzVector.cc:177
G4VEmModel::LowEnergyLimit
G4double LowEnergyLimit() const
Definition: G4VEmModel.hh:643
G4VAtomDeexcitation::CheckDeexcitationActiveRegion
G4bool CheckDeexcitationActiveRegion(G4int coupleIndex)
Definition: G4VAtomDeexcitation.hh:262
G4Element::GetNbOfAtomicShells
G4int GetNbOfAtomicShells() const
Definition: G4Element.hh:147
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:42
CLHEP::Hep3Vector::x
double x() const
G4KleinNishinaModel::fParticleChange
G4ParticleChangeForGamma * fParticleChange
Definition: G4KleinNishinaModel.hh:92
nlooplim
static const G4int nlooplim
Definition: G4PolarizedComptonModel.cc:70
G4Element::GetZ
G4double GetZ() const
Definition: G4Element.hh:131
test.x
tuple x
Definition: test.py:50
CLHEP::HepRandomEngine::flat
virtual double flat()=0
G4Element::GetNbOfShellElectrons
G4int GetNbOfShellElectrons(G4int index) const
Definition: G4Element.cc:382
G4int
int G4int
Definition: G4Types.hh:78
G4ParticleChangeForGamma::ProposeMomentumDirection
void ProposeMomentumDirection(G4double Px, G4double Py, G4double Pz)
Definition: G4ParticleChangeForGamma.hh:147
CLHEP::Hep3Vector::z
double z() const
G4VParticleChange::ProposeLocalEnergyDeposit
void ProposeLocalEnergyDeposit(G4double anEnergyPart)
twopi
static constexpr double twopi
Definition: G4SIunits.hh:76
G4VAtomDeexcitation::GetAtomicShell
virtual const G4AtomicShell * GetAtomicShell(G4int Z, G4AtomicShellEnumerator shell)=0
CLHEP::HepLorentzVector::vect
Hep3Vector vect() const
G4cout
G4GLOB_DLL std::ostream G4cout
G4DynamicParticle::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
CLHEP::HepLorentzVector::boost
HepLorentzVector & boost(double, double, double)
Definition: LorentzVector.cc:59
CLHEP::Hep3Vector::rotateUz
Hep3Vector & rotateUz(const Hep3Vector &)
Definition: ThreeVector.cc:38
eV
static constexpr double eV
Definition: G4SIunits.hh:215
python.hepunit.electron_mass_c2
float electron_mass_c2
Definition: hepunit.py:274
test.v
tuple v
Definition: test.py:18
G4Log
G4double G4Log(G4double x)
Definition: G4Log.hh:230
G4Exp
G4double G4Exp(G4double initial_x)
Exponential Function double precision.
Definition: G4Exp.hh:183
CLHEP::HepLorentzVector::set
void set(double x, double y, double z, double t)
G4KleinNishinaModel::theElectron
G4ParticleDefinition * theElectron
Definition: G4KleinNishinaModel.hh:91
G4lrint
int G4lrint(double ad)
Definition: templates.hh:163
G4INCL::KinematicsUtils::energy
G4double energy(const ThreeVector &p, const G4double m)
Definition: G4INCLKinematicsUtils.cc:157
CLHEP::Hep3Vector::unit
Hep3Vector unit() const
CLHEP::Hep3Vector::y
double y() const
fStopAndKill
Definition: G4TrackStatus.hh:56
G4KleinNishinaModel::theGamma
G4ParticleDefinition * theGamma
Definition: G4KleinNishinaModel.hh:90
G4ParticleChangeForGamma::SetProposedKineticEnergy
void SetProposedKineticEnergy(G4double proposedKinEnergy)
Definition: G4ParticleChangeForGamma.hh:129
G4endl
#define G4endl
Definition: G4ios.hh:61
G4Element::GetAtomicShell
G4double GetAtomicShell(G4int index) const
Definition: G4Element.cc:367
G4double
double G4double
Definition: G4Types.hh:76
G4VParticleChange::ProposeTrackStatus
void ProposeTrackStatus(G4TrackStatus status)
G4VAtomDeexcitation::GenerateParticles
void GenerateParticles(std::vector< G4DynamicParticle * > *secVect, const G4AtomicShell *, G4int Z, G4int coupleIndex)
Definition: G4VAtomDeexcitation.hh:274
G4InuclSpecialFunctions::bindingEnergy
G4double bindingEnergy(G4int A, G4int Z)
Definition: bindingEnergy.cc:37
CLHEP::HepRandomEngine::flatArray
virtual void flatArray(const int size, double *vect)=0
keV
static constexpr double keV
Definition: G4SIunits.hh:216
epsilon
double epsilon(double density, double temperature)
Definition: G4DNAElectronHoleRecombination.cc:96
G4AtomicShellEnumerator
G4AtomicShellEnumerator
Definition: G4AtomicShellEnumerator.hh:50
G4VEmModel::SelectRandomAtom
const G4Element * SelectRandomAtom(const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.hh:544
Z
G4int Z
Definition: G4ParticleHPJENDLHEData.cc:262

Here is the call graph for this function:

Member Data Documentation

G4ParticleChangeForGamma* G4KleinNishinaModel::fParticleChange
protected

Definition at line 92 of file G4KleinNishinaModel.hh.

G4double G4KleinNishinaModel::lowestSecondaryEnergy
protected

Definition at line 93 of file G4KleinNishinaModel.hh.

G4ParticleDefinition* G4KleinNishinaModel::theElectron
protected

Definition at line 91 of file G4KleinNishinaModel.hh.

G4ParticleDefinition* G4KleinNishinaModel::theGamma
protected

Definition at line 90 of file G4KleinNishinaModel.hh.

The documentation for this class was generated from the following files: