Geant4-11
Public Member Functions | Protected Member Functions | Protected Attributes | Private Attributes
G4AdjointComptonModel Class Reference

#include <G4AdjointComptonModel.hh>

Inheritance diagram for G4AdjointComptonModel:
G4VEmAdjointModel

Public Member Functions

G4double AdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool isScatProjToProj) override
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerAtomForScatProj (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerAtomForSecond (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerVolumeForScatProj (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerVolumeForSecond (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
 
void DefineCurrentMaterial (const G4MaterialCutsCouple *couple)
 
void DefineDirectEMModel (G4VEmModel *aModel)
 
G4double DiffCrossSectionPerAtomPrimToScatPrim (G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.) override
 
G4double DiffCrossSectionPerAtomPrimToSecond (G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.) override
 
virtual G4double DiffCrossSectionPerVolumePrimToScatPrim (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
 
virtual G4double DiffCrossSectionPerVolumePrimToSecond (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd)
 
 G4AdjointComptonModel ()
 
 G4AdjointComptonModel (G4AdjointComptonModel &)=delete
 
G4ParticleDefinitionGetAdjointEquivalentOfDirectPrimaryParticleDefinition ()
 
G4ParticleDefinitionGetAdjointEquivalentOfDirectSecondaryParticleDefinition ()
 
G4bool GetApplyCutInRange ()
 
G4double GetHighEnergyLimit ()
 
G4double GetLowEnergyLimit ()
 
G4String GetName ()
 
virtual G4double GetSecondAdjEnergyMaxForProdToProj (G4double primAdjEnergy)
 
G4double GetSecondAdjEnergyMaxForScatProjToProj (G4double primAdjEnergy) override
 
G4double GetSecondAdjEnergyMinForProdToProj (G4double primAdjEnergy) override
 
virtual G4double GetSecondAdjEnergyMinForScatProjToProj (G4double primAdjEnergy, G4double tcut=0.)
 
G4bool GetSecondPartOfSameType ()
 
G4bool GetUseMatrix ()
 
G4bool GetUseMatrixPerElement ()
 
G4bool GetUseOnlyOneMatrixForAllElements ()
 
G4AdjointComptonModeloperator= (const G4AdjointComptonModel &right)=delete
 
void RapidSampleSecondaries (const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange)
 
void SampleSecondaries (const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange) override
 
void SetAdditionalWeightCorrectionFactorForPostStepOutsideModel (G4double factor)
 
void SetAdjointEquivalentOfDirectPrimaryParticleDefinition (G4ParticleDefinition *aPart)
 
void SetAdjointEquivalentOfDirectSecondaryParticleDefinition (G4ParticleDefinition *aPart)
 
void SetApplyCutInRange (G4bool aBool)
 
void SetCorrectWeightForPostStepInModel (G4bool aBool)
 
virtual void SetCSBiasingFactor (G4double aVal)
 
void SetCSMatrices (std::vector< G4AdjointCSMatrix * > *Vec1CSMatrix, std::vector< G4AdjointCSMatrix * > *Vec2CSMatrix)
 
void SetDirectProcess (G4VEmProcess *aProcess)
 
void SetHighEnergyLimit (G4double aVal)
 
void SetLowEnergyLimit (G4double aVal)
 
void SetSecondPartOfSameType (G4bool aBool)
 
void SetUseMatrix (G4bool aBool)
 
void SetUseMatrixPerElement (G4bool aBool)
 
void SetUseOnlyOneMatrixForAllElements (G4bool aBool)
 
 ~G4AdjointComptonModel () override
 

Protected Member Functions

virtual void CorrectPostStepWeight (G4ParticleChange *fParticleChange, G4double old_weight, G4double adjointPrimKinEnergy, G4double projectileKinEnergy, G4bool isScatProjToProj)
 
G4double DiffCrossSectionFunction1 (G4double kinEnergyProj)
 
G4double DiffCrossSectionFunction2 (G4double kinEnergyProj)
 
G4double SampleAdjSecEnergyFromCSMatrix (G4double prim_energy, G4bool isScatProjToProj)
 
G4double SampleAdjSecEnergyFromCSMatrix (size_t MatrixIndex, G4double prim_energy, G4bool isScatProjToProj)
 
virtual G4double SampleAdjSecEnergyFromDiffCrossSectionPerAtom (G4double prim_energy, G4bool isScatProjToProj)
 
void SelectCSMatrix (G4bool isScatProjToProj)
 

Protected Attributes

G4ParticleDefinitionfAdjEquivDirectPrimPart = nullptr
 
G4ParticleDefinitionfAdjEquivDirectSecondPart = nullptr
 
G4bool fApplyCutInRange = true
 
G4int fASelectedNucleus = 0
 
G4double fCsBiasingFactor = 1.
 
G4AdjointCSManagerfCSManager
 
std::vector< G4AdjointCSMatrix * > * fCSMatrixProdToProjBackScat = nullptr
 
std::vector< G4AdjointCSMatrix * > * fCSMatrixProjToProjBackScat = nullptr
 
size_t fCSMatrixUsed = 0
 
G4MaterialCutsCouplefCurrentCouple = nullptr
 
G4MaterialfCurrentMaterial = nullptr
 
G4VEmModelfDirectModel = nullptr
 
G4ParticleDefinitionfDirectPrimaryPart = nullptr
 
std::vector< G4doublefElementCSProdToProj
 
std::vector< G4doublefElementCSScatProjToProj
 
G4double fHighEnergyLimit = 0.
 
G4bool fInModelWeightCorr
 
G4double fKinEnergyProdForIntegration = 0.
 
G4double fKinEnergyScatProjForIntegration = 0.
 
G4double fLastAdjointCSForProdToProj = 0.
 
G4double fLastAdjointCSForScatProjToProj = 0.
 
G4double fLastCS = 0.
 
G4double fLowEnergyLimit = 0.
 
const G4String fName
 
G4bool fOneMatrixForAllElements = false
 
G4double fOutsideWeightFactor = 1.
 
G4double fPreStepEnergy = 0.
 
G4bool fSecondPartSameType = false
 
G4MaterialfSelectedMaterial = nullptr
 
G4double fTcutPrim = 0.
 
G4double fTcutSecond = 0.
 
G4bool fUseMatrix = false
 
G4bool fUseMatrixPerElement = false
 
G4int fZSelectedNucleus = 0
 

Private Attributes

G4double fDirectCS = 0.
 
G4VEmProcessfDirectProcess = nullptr
 

Detailed Description

Definition at line 42 of file G4AdjointComptonModel.hh.

Constructor & Destructor Documentation

◆ G4AdjointComptonModel() [1/2]

G4AdjointComptonModel::G4AdjointComptonModel ( )

Definition at line 42 of file G4AdjointComptonModel.cc.

43 : G4VEmAdjointModel("AdjointCompton")
44{
45 SetApplyCutInRange(false);
46 SetUseMatrix(false);
52 fSecondPartSameType = false;
54 new G4KleinNishinaCompton(G4Gamma::Gamma(), "ComptonDirectModel");
55}
static G4AdjointElectron * AdjointElectron()
static G4AdjointGamma * AdjointGamma()
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
void SetUseMatrixPerElement(G4bool aBool)
G4ParticleDefinition * fAdjEquivDirectSecondPart
void SetUseMatrix(G4bool aBool)
G4ParticleDefinition * fAdjEquivDirectPrimPart
G4VEmModel * fDirectModel
void SetUseOnlyOneMatrixForAllElements(G4bool aBool)
G4ParticleDefinition * fDirectPrimaryPart
G4VEmAdjointModel(const G4String &nam)
void SetApplyCutInRange(G4bool aBool)

References G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fAdjEquivDirectSecondPart, G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, G4VEmAdjointModel::fSecondPartSameType, G4Gamma::Gamma(), G4VEmAdjointModel::SetApplyCutInRange(), G4VEmAdjointModel::SetUseMatrix(), G4VEmAdjointModel::SetUseMatrixPerElement(), and G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements().

◆ ~G4AdjointComptonModel()

G4AdjointComptonModel::~G4AdjointComptonModel ( )
override

Definition at line 58 of file G4AdjointComptonModel.cc.

58{}

◆ G4AdjointComptonModel() [2/2]

G4AdjointComptonModel::G4AdjointComptonModel ( G4AdjointComptonModel )
delete

Member Function Documentation

◆ AdjointCrossSection()

G4double G4AdjointComptonModel::AdjointCrossSection ( const G4MaterialCutsCouple aCouple,
G4double  primEnergy,
G4bool  isScatProjToProj 
)
overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 325 of file G4AdjointComptonModel.cc.

328{
329 if(fUseMatrix)
330 return G4VEmAdjointModel::AdjointCrossSection(aCouple, primEnergy,
331 isScatProjToProj);
332 DefineCurrentMaterial(aCouple);
333
334 G4float Cross = 0.;
335 G4float Emax_proj = 0.;
336 G4float Emin_proj = 0.;
337 if(!isScatProjToProj)
338 {
339 Emax_proj = GetSecondAdjEnergyMaxForProdToProj(primEnergy);
340 Emin_proj = GetSecondAdjEnergyMinForProdToProj(primEnergy);
341 if(Emax_proj > Emin_proj)
342 {
343 Cross = 0.1 *
344 std::log((Emax_proj - G4float(primEnergy)) * Emin_proj /
345 Emax_proj / (Emin_proj - primEnergy)) *
346 (1. + 2. * std::log(G4float(1. + electron_mass_c2 / primEnergy)));
347 }
348 }
349 else
350 {
351 Emax_proj = GetSecondAdjEnergyMaxForScatProjToProj(primEnergy);
352 Emin_proj = GetSecondAdjEnergyMinForScatProjToProj(primEnergy, 0.);
353 if(Emax_proj > Emin_proj)
354 {
355 Cross = 0.1 * std::log(Emax_proj / Emin_proj);
356 }
357 }
358
360 fLastCS = Cross;
361 return double(Cross);
362}
float G4float
Definition: G4Types.hh:84
G4double GetSecondAdjEnergyMaxForScatProjToProj(G4double primAdjEnergy) override
G4double GetSecondAdjEnergyMinForProdToProj(G4double primAdjEnergy) override
G4double GetElectronDensity() const
Definition: G4Material.hh:213
virtual G4double GetSecondAdjEnergyMaxForProdToProj(G4double primAdjEnergy)
virtual G4double GetSecondAdjEnergyMinForScatProjToProj(G4double primAdjEnergy, G4double tcut=0.)
G4Material * fCurrentMaterial
void DefineCurrentMaterial(const G4MaterialCutsCouple *couple)
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool isScatProjToProj)
float electron_mass_c2
Definition: hepunit.py:273
int twopi_mc2_rcl2
Definition: hepunit.py:293

References G4VEmAdjointModel::AdjointCrossSection(), G4VEmAdjointModel::DefineCurrentMaterial(), source.hepunit::electron_mass_c2, G4VEmAdjointModel::fCurrentMaterial, G4VEmAdjointModel::fLastCS, G4VEmAdjointModel::fUseMatrix, G4Material::GetElectronDensity(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), GetSecondAdjEnergyMaxForScatProjToProj(), GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), and source.hepunit::twopi_mc2_rcl2.

◆ ComputeAdjointCrossSectionVectorPerAtomForScatProj()

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj ( G4double  kinEnergyProd,
G4double  Z,
G4double  A = 0.,
G4int  nbin_pro_decade = 10 
)
inherited

Definition at line 252 of file G4VEmAdjointModel.cc.

255{
257 integral;
260 fKinEnergyScatProjForIntegration = kinEnergyScatProj;
261
262 // compute the vector of integrated cross sections
263 G4double minEProj = GetSecondAdjEnergyMinForScatProjToProj(kinEnergyScatProj);
264 G4double maxEProj = GetSecondAdjEnergyMaxForScatProjToProj(kinEnergyScatProj);
265 G4double dEmax = maxEProj - kinEnergyScatProj;
266 G4double dEmin = GetLowEnergyLimit();
267 G4double dE1 = dEmin;
268 G4double dE2 = dEmin;
269
270 std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
271 std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
272 log_ESec_vector->push_back(std::log(dEmin));
273 log_Prob_vector->push_back(-50.);
274 G4int nbins = std::max(G4int(std::log10(dEmax / dEmin)) * nbin_pro_decade, 5);
275 G4double fE = std::pow(dEmax / dEmin, 1. / nbins);
276
277 G4double int_cross_section = 0.;
278 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
279 while(dE1 < dEmax * 0.9999999999999)
280 {
281 dE2 = dE1 * fE;
282 int_cross_section +=
283 integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction2,
284 minEProj + dE1, std::min(minEProj + dE2, maxEProj), 5);
285 log_ESec_vector->push_back(std::log(std::min(dE2, maxEProj - minEProj)));
286 log_Prob_vector->push_back(std::log(int_cross_section));
287 dE1 = dE2;
288 }
289
290 std::vector<std::vector<G4double>*> res_mat;
291 if(int_cross_section > 0.)
292 {
293 res_mat.push_back(log_ESec_vector);
294 res_mat.push_back(log_Prob_vector);
295 }
296 else {
297 delete log_ESec_vector;
298 delete log_Prob_vector;
299 }
300
301 return res_mat;
302}
double G4double
Definition: G4Types.hh:83
int G4int
Definition: G4Types.hh:85
const G4int Z[17]
const G4double A[17]
G4double fKinEnergyScatProjForIntegration
virtual G4double GetSecondAdjEnergyMaxForScatProjToProj(G4double primAdjEnergy)
G4double GetLowEnergyLimit()
G4double DiffCrossSectionFunction2(G4double kinEnergyProj)
T max(const T t1, const T t2)
brief Return the largest of the two arguments
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
int G4lrint(double ad)
Definition: templates.hh:134

References A, G4VEmAdjointModel::DiffCrossSectionFunction2(), G4VEmAdjointModel::fASelectedNucleus, G4VEmAdjointModel::fKinEnergyScatProjForIntegration, G4VEmAdjointModel::fZSelectedNucleus, G4lrint(), G4VEmAdjointModel::G4VEmAdjointModel(), G4VEmAdjointModel::GetLowEnergyLimit(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4INCL::Math::max(), G4INCL::Math::min(), and Z.

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndElement().

◆ ComputeAdjointCrossSectionVectorPerAtomForSecond()

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForSecond ( G4double  kinEnergyProd,
G4double  Z,
G4double  A = 0.,
G4int  nbin_pro_decade = 10 
)
inherited

Definition at line 198 of file G4VEmAdjointModel.cc.

201{
203 integral;
206 fKinEnergyProdForIntegration = kinEnergyProd;
207
208 // compute the vector of integrated cross sections
209 G4double minEProj = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
210 G4double maxEProj = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
211 G4double E1 = minEProj;
212 std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
213 std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
214 log_ESec_vector->push_back(std::log(E1));
215 log_Prob_vector->push_back(-50.);
216
217 G4double E2 =
218 std::pow(10., G4double(G4int(std::log10(minEProj) * nbin_pro_decade) + 1) /
219 nbin_pro_decade);
220 G4double fE = std::pow(10., 1. / nbin_pro_decade);
221
222 if(std::pow(fE, 5.) > (maxEProj / minEProj))
223 fE = std::pow(maxEProj / minEProj, 0.2);
224
225 G4double int_cross_section = 0.;
226 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
227 while(E1 < maxEProj * 0.9999999)
228 {
229 int_cross_section +=
230 integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction1, E1,
231 std::min(E2, maxEProj * 0.99999999), 5);
232 log_ESec_vector->push_back(std::log(std::min(E2, maxEProj)));
233 log_Prob_vector->push_back(std::log(int_cross_section));
234 E1 = E2;
235 E2 *= fE;
236 }
237 std::vector<std::vector<G4double>*> res_mat;
238 if(int_cross_section > 0.)
239 {
240 res_mat.push_back(log_ESec_vector);
241 res_mat.push_back(log_Prob_vector);
242 }
243 else {
244 delete log_ESec_vector;
245 delete log_Prob_vector;
246 }
247 return res_mat;
248}
G4double DiffCrossSectionFunction1(G4double kinEnergyProj)
G4double fKinEnergyProdForIntegration
virtual G4double GetSecondAdjEnergyMinForProdToProj(G4double primAdjEnergy)

References A, G4VEmAdjointModel::DiffCrossSectionFunction1(), G4VEmAdjointModel::fASelectedNucleus, G4VEmAdjointModel::fKinEnergyProdForIntegration, G4VEmAdjointModel::fZSelectedNucleus, G4lrint(), G4VEmAdjointModel::G4VEmAdjointModel(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4INCL::Math::min(), and Z.

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndElement().

◆ ComputeAdjointCrossSectionVectorPerVolumeForScatProj()

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj ( G4Material aMaterial,
G4double  kinEnergyProd,
G4int  nbin_pro_decade = 10 
)
inherited

Definition at line 360 of file G4VEmAdjointModel.cc.

363{
365 integral;
366 fSelectedMaterial = aMaterial;
367 fKinEnergyScatProjForIntegration = kinEnergyScatProj;
368
369 // compute the vector of integrated cross sections
370 G4double minEProj = GetSecondAdjEnergyMinForScatProjToProj(kinEnergyScatProj);
371 G4double maxEProj = GetSecondAdjEnergyMaxForScatProjToProj(kinEnergyScatProj);
372
373 G4double dEmax = maxEProj - kinEnergyScatProj;
374 G4double dEmin = GetLowEnergyLimit();
375 G4double dE1 = dEmin;
376 G4double dE2 = dEmin;
377
378 std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
379 std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
380 log_ESec_vector->push_back(std::log(dEmin));
381 log_Prob_vector->push_back(-50.);
382 G4int nbins = std::max(int(std::log10(dEmax / dEmin)) * nbin_pro_decade, 5);
383 G4double fE = std::pow(dEmax / dEmin, 1. / nbins);
384
385 G4double int_cross_section = 0.;
386 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
387 while(dE1 < dEmax * 0.9999999999999)
388 {
389 dE2 = dE1 * fE;
390 int_cross_section +=
391 integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction2,
392 minEProj + dE1, std::min(minEProj + dE2, maxEProj), 5);
393 log_ESec_vector->push_back(std::log(std::min(dE2, maxEProj - minEProj)));
394 log_Prob_vector->push_back(std::log(int_cross_section));
395 dE1 = dE2;
396 }
397
398 std::vector<std::vector<G4double>*> res_mat;
399 if(int_cross_section > 0.)
400 {
401 res_mat.push_back(log_ESec_vector);
402 res_mat.push_back(log_Prob_vector);
403 }
404 else {
405 delete log_ESec_vector;
406 delete log_Prob_vector;
407 }
408
409 return res_mat;
410}
G4Material * fSelectedMaterial

References G4VEmAdjointModel::DiffCrossSectionFunction2(), G4VEmAdjointModel::fKinEnergyScatProjForIntegration, G4VEmAdjointModel::fSelectedMaterial, G4VEmAdjointModel::G4VEmAdjointModel(), G4VEmAdjointModel::GetLowEnergyLimit(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4INCL::Math::max(), and G4INCL::Math::min().

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndMaterial().

◆ ComputeAdjointCrossSectionVectorPerVolumeForSecond()

std::vector< std::vector< G4double > * > G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond ( G4Material aMaterial,
G4double  kinEnergyProd,
G4int  nbin_pro_decade = 10 
)
inherited

Definition at line 306 of file G4VEmAdjointModel.cc.

309{
311 integral;
312 fSelectedMaterial = aMaterial;
313 fKinEnergyProdForIntegration = kinEnergyProd;
314
315 // compute the vector of integrated cross sections
316 G4double minEProj = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
317 G4double maxEProj = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
318 G4double E1 = minEProj;
319 std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
320 std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
321 log_ESec_vector->push_back(std::log(E1));
322 log_Prob_vector->push_back(-50.);
323
324 G4double E2 =
325 std::pow(10., G4double(G4int(std::log10(minEProj) * nbin_pro_decade) + 1) /
326 nbin_pro_decade);
327 G4double fE = std::pow(10., 1. / nbin_pro_decade);
328
329 if(std::pow(fE, 5.) > (maxEProj / minEProj))
330 fE = std::pow(maxEProj / minEProj, 0.2);
331
332 G4double int_cross_section = 0.;
333 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
334 while(E1 < maxEProj * 0.9999999)
335 {
336 int_cross_section +=
337 integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction1, E1,
338 std::min(E2, maxEProj * 0.99999999), 5);
339 log_ESec_vector->push_back(std::log(std::min(E2, maxEProj)));
340 log_Prob_vector->push_back(std::log(int_cross_section));
341 E1 = E2;
342 E2 *= fE;
343 }
344 std::vector<std::vector<G4double>*> res_mat;
345
346 if(int_cross_section > 0.)
347 {
348 res_mat.push_back(log_ESec_vector);
349 res_mat.push_back(log_Prob_vector);
350 }
351 else {
352 delete log_ESec_vector;
353 delete log_Prob_vector;
354 }
355 return res_mat;
356}

References G4VEmAdjointModel::DiffCrossSectionFunction1(), G4VEmAdjointModel::fKinEnergyProdForIntegration, G4VEmAdjointModel::fSelectedMaterial, G4VEmAdjointModel::G4VEmAdjointModel(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), and G4INCL::Math::min().

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndMaterial().

◆ CorrectPostStepWeight()

void G4VEmAdjointModel::CorrectPostStepWeight ( G4ParticleChange fParticleChange,
G4double  old_weight,
G4double  adjointPrimKinEnergy,
G4double  projectileKinEnergy,
G4bool  isScatProjToProj 
)
protectedvirtualinherited

Reimplemented in G4AdjointIonIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 616 of file G4VEmAdjointModel.cc.

621{
622 G4double new_weight = old_weight;
623 G4double w_corr =
625
627 if(!isScatProjToProj)
629 if((adjointPrimKinEnergy - fPreStepEnergy) / fPreStepEnergy > 0.001)
630 {
631 G4double post_stepCS = AdjointCrossSection(
632 fCurrentCouple, adjointPrimKinEnergy, isScatProjToProj);
633 if(post_stepCS > 0. && fLastCS > 0.)
634 w_corr *= post_stepCS / fLastCS;
635 }
636
637 new_weight *= w_corr;
638 new_weight *= projectileKinEnergy / adjointPrimKinEnergy;
639 // This is needed due to the biasing of diff CS
640 // by the factor adjointPrimKinEnergy/projectileKinEnergy
641
642 fParticleChange->SetParentWeightByProcess(false);
643 fParticleChange->SetSecondaryWeightByProcess(false);
644 fParticleChange->ProposeParentWeight(new_weight);
645}
G4double GetPostStepWeightCorrection()
G4double fLastAdjointCSForScatProjToProj
G4MaterialCutsCouple * fCurrentCouple
G4AdjointCSManager * fCSManager
G4double fLastAdjointCSForProdToProj
void SetSecondaryWeightByProcess(G4bool)
void SetParentWeightByProcess(G4bool)
void ProposeParentWeight(G4double finalWeight)

References G4VEmAdjointModel::AdjointCrossSection(), G4VEmAdjointModel::fCsBiasingFactor, G4VEmAdjointModel::fCSManager, G4VEmAdjointModel::fCurrentCouple, G4VEmAdjointModel::fLastAdjointCSForProdToProj, G4VEmAdjointModel::fLastAdjointCSForScatProjToProj, G4VEmAdjointModel::fLastCS, G4VEmAdjointModel::fPreStepEnergy, G4AdjointCSManager::GetPostStepWeightCorrection(), G4VParticleChange::ProposeParentWeight(), G4VParticleChange::SetParentWeightByProcess(), and G4VParticleChange::SetSecondaryWeightByProcess().

Referenced by G4AdjointBremsstrahlungModel::SampleSecondaries(), SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and G4AdjointhIonisationModel::SampleSecondaries().

◆ DefineCurrentMaterial()

void G4VEmAdjointModel::DefineCurrentMaterial ( const G4MaterialCutsCouple couple)
inherited

Definition at line 684 of file G4VEmAdjointModel.cc.

686{
687 if(couple != fCurrentCouple)
688 {
689 fCurrentCouple = const_cast<G4MaterialCutsCouple*>(couple);
690 fCurrentMaterial = const_cast<G4Material*>(couple->GetMaterial());
691 size_t idx = 56;
692 fTcutSecond = 1.e-11;
694 {
696 idx = 0;
698 idx = 1;
700 idx = 2;
701 if(idx < 56)
702 {
703 const std::vector<G4double>* aVec =
705 idx);
706 fTcutSecond = (*aVec)[couple->GetIndex()];
707 }
708 }
709 }
710}
static G4AdjointPositron * AdjointPositron()
const G4Material * GetMaterial() const
const std::vector< G4double > * GetEnergyCutsVector(std::size_t pcIdx) const
static G4ProductionCutsTable * GetProductionCutsTable()

References G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4AdjointPositron::AdjointPositron(), G4VEmAdjointModel::fAdjEquivDirectSecondPart, G4VEmAdjointModel::fCurrentCouple, G4VEmAdjointModel::fCurrentMaterial, G4VEmAdjointModel::fTcutSecond, G4ProductionCutsTable::GetEnergyCutsVector(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), and G4ProductionCutsTable::GetProductionCutsTable().

Referenced by G4VEmAdjointModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), and G4AdjointBremsstrahlungModel::SampleSecondaries().

◆ DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel aModel)
inlineinherited

Definition at line 160 of file G4VEmAdjointModel.hh.

160{ fDirectModel = aModel; }

References G4VEmAdjointModel::fDirectModel.

◆ DiffCrossSectionFunction1()

G4double G4VEmAdjointModel::DiffCrossSectionFunction1 ( G4double  kinEnergyProj)
protectedinherited

Definition at line 155 of file G4VEmAdjointModel.cc.

156{
157 G4double bias_factor =
159
161 {
165 bias_factor;
166 }
167 else
168 {
171 bias_factor;
172 }
173}
virtual G4double DiffCrossSectionPerVolumePrimToSecond(const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd)
virtual G4double DiffCrossSectionPerAtomPrimToSecond(G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.)

References G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4VEmAdjointModel::fASelectedNucleus, G4VEmAdjointModel::fCsBiasingFactor, G4VEmAdjointModel::fKinEnergyProdForIntegration, G4VEmAdjointModel::fSelectedMaterial, G4VEmAdjointModel::fUseMatrixPerElement, and G4VEmAdjointModel::fZSelectedNucleus.

Referenced by G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForSecond(), and G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond().

◆ DiffCrossSectionFunction2()

G4double G4VEmAdjointModel::DiffCrossSectionFunction2 ( G4double  kinEnergyProj)
protectedinherited

Definition at line 176 of file G4VEmAdjointModel.cc.

177{
178 G4double bias_factor =
181 {
185 bias_factor;
186 }
187 else
188 {
190 fSelectedMaterial, kinEnergyProj,
192 bias_factor;
193 }
194}
virtual G4double DiffCrossSectionPerVolumePrimToScatPrim(const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
virtual G4double DiffCrossSectionPerAtomPrimToScatPrim(G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.)

References G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToScatPrim(), G4VEmAdjointModel::fASelectedNucleus, G4VEmAdjointModel::fCsBiasingFactor, G4VEmAdjointModel::fKinEnergyScatProjForIntegration, G4VEmAdjointModel::fSelectedMaterial, G4VEmAdjointModel::fUseMatrixPerElement, and G4VEmAdjointModel::fZSelectedNucleus.

Referenced by G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

◆ DiffCrossSectionPerAtomPrimToScatPrim()

G4double G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToScatPrim ( G4double  kinEnergyProj,
G4double  kinEnergyScatProj,
G4double  Z,
G4double  A = 0. 
)
overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 263 of file G4AdjointComptonModel.cc.

265{
266 // Based on Klein Nishina formula
267 // In the forward case (see G4KleinNishinaCompton) the cross section is
268 // parametrised but the secondaries are sampled from the Klein Nishina
269 // differential cross section. The differential cross section used here
270 // is therefore the cross section multiplied by the normalised
271 // differential Klein Nishina cross section
272
273 // Klein Nishina Cross Section
274 G4double epsilon = gamEnergy0 / electron_mass_c2;
275 G4double one_plus_two_epsi = 1. + 2. * epsilon;
276 if(gamEnergy1 > gamEnergy0 || gamEnergy1 < gamEnergy0 / one_plus_two_epsi)
277 {
278 return 0.;
279 }
280
281 G4double CS = std::log(one_plus_two_epsi) *
282 (1. - 2. * (1. + epsilon) / (epsilon * epsilon));
283 CS +=
284 4. / epsilon + 0.5 * (1. - 1. / (one_plus_two_epsi * one_plus_two_epsi));
285 CS /= epsilon;
286 // Note that the pi*re2*Z factor is neglected because it is suppressed when
287 // computing dCS_dE1/CS in the differential cross section
288
289 // Klein Nishina Differential Cross Section
290 G4double epsilon1 = gamEnergy1 / electron_mass_c2;
291 G4double v = epsilon1 / epsilon;
292 G4double term1 = 1. + 1. / epsilon - 1. / epsilon1;
293 G4double dCS_dE1 = 1. / v + v + term1 * term1 - 1.;
294 dCS_dE1 *= 1. / epsilon / gamEnergy0;
295
296 // Normalised to the CS used in G4
298 G4Gamma::Gamma(), gamEnergy0, Z, 0., 0., 0.);
299
300 dCS_dE1 *= fDirectCS / CS;
301
302 return dCS_dE1;
303}
G4double epsilon(G4double density, G4double temperature)
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:341

References G4VEmModel::ComputeCrossSectionPerAtom(), source.hepunit::electron_mass_c2, epsilon(), fDirectCS, G4VEmAdjointModel::fDirectModel, G4Gamma::Gamma(), and Z.

Referenced by DiffCrossSectionPerAtomPrimToSecond(), and RapidSampleSecondaries().

◆ DiffCrossSectionPerAtomPrimToSecond()

G4double G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToSecond ( G4double  kinEnergyProj,
G4double  kinEnergyProd,
G4double  Z,
G4double  A = 0. 
)
overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 251 of file G4AdjointComptonModel.cc.

253{
254 G4double gamEnergy1 = gamEnergy0 - kinEnergyElec;
255 G4double dSigmadEprod = 0.;
256 if(gamEnergy1 > 0.)
257 dSigmadEprod =
258 DiffCrossSectionPerAtomPrimToScatPrim(gamEnergy0, gamEnergy1, Z, A);
259 return dSigmadEprod;
260}
G4double DiffCrossSectionPerAtomPrimToScatPrim(G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.) override

References A, DiffCrossSectionPerAtomPrimToScatPrim(), and Z.

◆ DiffCrossSectionPerVolumePrimToScatPrim()

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToScatPrim ( const G4Material aMaterial,
G4double  kinEnergyProj,
G4double  kinEnergyScatProj 
)
virtualinherited

Definition at line 140 of file G4VEmAdjointModel.cc.

143{
144 G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
145 G4double dSigmadEprod;
146 if(kinEnergyProd <= 0.)
147 dSigmadEprod = 0.;
148 else
150 aMaterial, kinEnergyProj, kinEnergyProd);
151 return dSigmadEprod;
152}

References G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond().

Referenced by G4VEmAdjointModel::DiffCrossSectionFunction2(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ DiffCrossSectionPerVolumePrimToSecond()

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond ( const G4Material aMaterial,
G4double  kinEnergyProj,
G4double  kinEnergyProd 
)
virtualinherited

Reimplemented in G4AdjointBremsstrahlungModel.

Definition at line 119 of file G4VEmAdjointModel.cc.

121{
122 G4double dSigmadEprod = 0.;
123 G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
124 G4double Emin_proj = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
125
126 if(kinEnergyProj > Emin_proj && kinEnergyProj <= Emax_proj)
127 {
128 G4double E1 = kinEnergyProd;
129 G4double E2 = kinEnergyProd * 1.0001;
131 aMaterial, fDirectPrimaryPart, kinEnergyProj, E1, 1.e20);
133 aMaterial, fDirectPrimaryPart, kinEnergyProj, E2, 1.e20);
134 dSigmadEprod = (sigma1 - sigma2) / (E2 - E1);
135 }
136 return dSigmadEprod;
137}
virtual G4double CrossSectionPerVolume(const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:237

References G4VEmModel::CrossSectionPerVolume(), G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), and G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj().

Referenced by G4VEmAdjointModel::DiffCrossSectionFunction1(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToScatPrim(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecond(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( )
inlineinherited

◆ GetAdjointEquivalentOfDirectSecondaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition ( )
inlineinherited

◆ GetApplyCutInRange()

G4bool G4VEmAdjointModel::GetApplyCutInRange ( )
inlineinherited

◆ GetHighEnergyLimit()

G4double G4VEmAdjointModel::GetHighEnergyLimit ( )
inlineinherited

◆ GetLowEnergyLimit()

G4double G4VEmAdjointModel::GetLowEnergyLimit ( )
inlineinherited

◆ GetName()

G4String G4VEmAdjointModel::GetName ( )
inlineinherited

Definition at line 203 of file G4VEmAdjointModel.hh.

203{ return fName; }
const G4String fName

References G4VEmAdjointModel::fName.

◆ GetSecondAdjEnergyMaxForProdToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj ( G4double  primAdjEnergy)
virtualinherited

◆ GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4AdjointComptonModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double  primAdjEnergy)
overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 306 of file G4AdjointComptonModel.cc.

308{
309 G4double inv_e_max = 1. / primAdjEnergy - 2. / electron_mass_c2;
311 if(inv_e_max > 0.)
312 e_max = std::min(1. / inv_e_max, e_max);
313 return e_max;
314}
G4double GetHighEnergyLimit()

References source.hepunit::electron_mass_c2, G4VEmAdjointModel::GetHighEnergyLimit(), and G4INCL::Math::min().

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

◆ GetSecondAdjEnergyMinForProdToProj()

G4double G4AdjointComptonModel::GetSecondAdjEnergyMinForProdToProj ( G4double  primAdjEnergy)
overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 317 of file G4AdjointComptonModel.cc.

319{
320 G4double half_e = primAdjEnergy / 2.;
321 return half_e + std::sqrt(half_e * (electron_mass_c2 + half_e));
322}

References source.hepunit::electron_mass_c2.

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

◆ GetSecondAdjEnergyMinForScatProjToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj ( G4double  primAdjEnergy,
G4double  tcut = 0. 
)
virtualinherited

◆ GetSecondPartOfSameType()

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( )
inlineinherited

◆ GetUseMatrix()

G4bool G4VEmAdjointModel::GetUseMatrix ( )
inlineinherited

Definition at line 192 of file G4VEmAdjointModel.hh.

192{ return fUseMatrix; }

References G4VEmAdjointModel::fUseMatrix.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

◆ GetUseMatrixPerElement()

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( )
inlineinherited

◆ GetUseOnlyOneMatrixForAllElements()

G4bool G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements ( )
inlineinherited

◆ operator=()

G4AdjointComptonModel & G4AdjointComptonModel::operator= ( const G4AdjointComptonModel right)
delete

◆ RapidSampleSecondaries()

void G4AdjointComptonModel::RapidSampleSecondaries ( const G4Track aTrack,
G4bool  isScatProjToProj,
G4ParticleChange fParticleChange 
)

Definition at line 137 of file G4AdjointComptonModel.cc.

140{
141 const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
143
144 G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
145
146 if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
147 {
148 return;
149 }
150
151 G4double diffCSUsed =
153 G4double gammaE1 = 0.;
154 G4double gammaE2 = 0.;
155 if(!isScatProjToProj)
156 {
157 G4double Emax = GetSecondAdjEnergyMaxForProdToProj(adjointPrimKinEnergy);
158 G4double Emin = GetSecondAdjEnergyMinForProdToProj(adjointPrimKinEnergy);
159 if(Emin >= Emax)
160 return;
161 G4double f1 = (Emin - adjointPrimKinEnergy) / Emin;
162 G4double f2 = (Emax - adjointPrimKinEnergy) / Emax / f1;
163 gammaE1 = adjointPrimKinEnergy / (1. - f1 * std::pow(f2, G4UniformRand()));
164 gammaE2 = gammaE1 - adjointPrimKinEnergy;
165 diffCSUsed =
166 diffCSUsed *
167 (1. + 2. * std::log(1. + electron_mass_c2 / adjointPrimKinEnergy)) *
168 adjointPrimKinEnergy / gammaE1 / gammaE2;
169 }
170 else
171 {
172 G4double Emax =
173 GetSecondAdjEnergyMaxForScatProjToProj(adjointPrimKinEnergy);
174 G4double Emin =
176 if(Emin >= Emax)
177 return;
178 gammaE2 = adjointPrimKinEnergy;
179 gammaE1 = Emin * std::pow(Emax / Emin, G4UniformRand());
180 diffCSUsed = diffCSUsed / gammaE1;
181 }
182
183 // Weight correction
184 // First w_corr is set to the ratio between adjoint total CS and fwd total CS
187 {
188 w_corr =
190 }
191 // Then another correction is needed because a biased differential CS has
192 // been used rather than the one consistent with the direct model
193
194 G4double diffCS =
195 DiffCrossSectionPerAtomPrimToScatPrim(gammaE1, gammaE2, 1, 0.);
196 if(diffCS > 0.)
197 diffCS /= fDirectCS; // here we have the normalised diffCS
198 // And we remultiply by the lambda of the forward process
199 diffCS *= fDirectProcess->GetLambda(gammaE1, fCurrentCouple);
200
201 w_corr *= diffCS / diffCSUsed;
202
203 G4double new_weight = aTrack.GetWeight() * w_corr;
204 fParticleChange->SetParentWeightByProcess(false);
205 fParticleChange->SetSecondaryWeightByProcess(false);
206 fParticleChange->ProposeParentWeight(new_weight);
207
208 G4double cos_th = 1. + electron_mass_c2 * (1. / gammaE1 - 1. / gammaE2);
209 if(!isScatProjToProj)
210 {
211 G4double p_elec = theAdjointPrimary->GetTotalMomentum();
212 cos_th = (gammaE1 - gammaE2 * cos_th) / p_elec;
213 }
214 G4double sin_th = 0.;
215 if(std::abs(cos_th) > 1.)
216 {
217 if(cos_th > 0.)
218 {
219 cos_th = 1.;
220 }
221 else
222 cos_th = -1.;
223 }
224 else
225 sin_th = std::sqrt(1. - cos_th * cos_th);
226
227 // gamma0 momentum
228 G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
229 G4double phi = G4UniformRand() * twopi;
230 G4ThreeVector gammaMomentum1 =
231 gammaE1 *
232 G4ThreeVector(std::cos(phi) * sin_th, std::sin(phi) * sin_th, cos_th);
233 gammaMomentum1.rotateUz(dir_parallel);
234
235 if(!isScatProjToProj)
236 { // kill the primary and add a secondary
237 fParticleChange->ProposeTrackStatus(fStopAndKill);
238 fParticleChange->AddSecondary(
239 new G4DynamicParticle(fAdjEquivDirectPrimPart, gammaMomentum1));
240 }
241 else
242 {
243 fParticleChange->ProposeEnergy(gammaE1);
244 fParticleChange->ProposeMomentumDirection(gammaMomentum1.unit());
245 }
246}
static const G4double Emax
static constexpr double twopi
Definition: G4SIunits.hh:56
CLHEP::Hep3Vector G4ThreeVector
@ fStopAndKill
#define G4UniformRand()
Definition: Randomize.hh:52
Hep3Vector unit() const
Hep3Vector & rotateUz(const Hep3Vector &)
Definition: ThreeVector.cc:33
static G4AdjointCSManager * GetAdjointCSManager()
const G4ThreeVector & GetMomentumDirection() const
G4double GetKineticEnergy() const
G4double GetTotalMomentum() const
void AddSecondary(G4Track *aSecondary)
void ProposeEnergy(G4double finalEnergy)
void ProposeMomentumDirection(G4double Px, G4double Py, G4double Pz)
G4double GetWeight() const
const G4DynamicParticle * GetDynamicParticle() const
const G4MaterialCutsCouple * GetMaterialCutsCouple() const
G4double GetLambda(G4double kinEnergy, const G4MaterialCutsCouple *couple)
void ProposeTrackStatus(G4TrackStatus status)

References G4ParticleChange::AddSecondary(), G4VEmAdjointModel::DefineCurrentMaterial(), DiffCrossSectionPerAtomPrimToScatPrim(), source.hepunit::electron_mass_c2, Emax, Emin, G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fCurrentCouple, G4VEmAdjointModel::fCurrentMaterial, fDirectCS, fDirectProcess, G4VEmAdjointModel::fInModelWeightCorr, G4VEmAdjointModel::fOutsideWeightFactor, fStopAndKill, G4VEmAdjointModel::fTcutSecond, G4UniformRand, G4AdjointCSManager::GetAdjointCSManager(), G4Track::GetDynamicParticle(), G4Material::GetElectronDensity(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4VEmProcess::GetLambda(), G4Track::GetMaterialCutsCouple(), G4DynamicParticle::GetMomentumDirection(), G4AdjointCSManager::GetPostStepWeightCorrection(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), GetSecondAdjEnergyMaxForScatProjToProj(), GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4DynamicParticle::GetTotalMomentum(), G4Track::GetWeight(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeParentWeight(), G4VParticleChange::ProposeTrackStatus(), CLHEP::Hep3Vector::rotateUz(), G4VParticleChange::SetParentWeightByProcess(), G4VParticleChange::SetSecondaryWeightByProcess(), twopi, source.hepunit::twopi_mc2_rcl2, and CLHEP::Hep3Vector::unit().

Referenced by SampleSecondaries().

◆ SampleAdjSecEnergyFromCSMatrix() [1/2]

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix ( G4double  prim_energy,
G4bool  isScatProjToProj 
)
protectedinherited

Definition at line 518 of file G4VEmAdjointModel.cc.

520{
521 SelectCSMatrix(isScatProjToProj);
523 isScatProjToProj);
524}
G4double SampleAdjSecEnergyFromCSMatrix(size_t MatrixIndex, G4double prim_energy, G4bool isScatProjToProj)
void SelectCSMatrix(G4bool isScatProjToProj)

References G4VEmAdjointModel::fCSMatrixUsed, G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), and G4VEmAdjointModel::SelectCSMatrix().

◆ SampleAdjSecEnergyFromCSMatrix() [2/2]

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix ( size_t  MatrixIndex,
G4double  prim_energy,
G4bool  isScatProjToProj 
)
protectedinherited

Definition at line 413 of file G4VEmAdjointModel.cc.

415{
416 G4AdjointCSMatrix* theMatrix = (*fCSMatrixProdToProjBackScat)[MatrixIndex];
417 if(isScatProjToProj)
418 theMatrix = (*fCSMatrixProjToProjBackScat)[MatrixIndex];
419 std::vector<G4double>* theLogPrimEnergyVector =
420 theMatrix->GetLogPrimEnergyVector();
421
422 if(theLogPrimEnergyVector->empty())
423 {
424 G4cout << "No data are contained in the given AdjointCSMatrix!" << G4endl;
425 G4cout << "The sampling procedure will be stopped." << G4endl;
426 return 0.;
427 }
428
430 G4double aLogPrimEnergy = std::log(aPrimEnergy);
431 size_t ind = theInterpolator->FindPositionForLogVector(
432 aLogPrimEnergy, *theLogPrimEnergyVector);
433
434 G4double aLogPrimEnergy1, aLogPrimEnergy2;
435 G4double aLogCS1, aLogCS2;
436 G4double log01, log02;
437 std::vector<double>* aLogSecondEnergyVector1 = nullptr;
438 std::vector<double>* aLogSecondEnergyVector2 = nullptr;
439 std::vector<double>* aLogProbVector1 = nullptr;
440 std::vector<double>* aLogProbVector2 = nullptr;
441 std::vector<size_t>* aLogProbVectorIndex1 = nullptr;
442 std::vector<size_t>* aLogProbVectorIndex2 = nullptr;
443
444 theMatrix->GetData(ind, aLogPrimEnergy1, aLogCS1, log01,
445 aLogSecondEnergyVector1, aLogProbVector1,
446 aLogProbVectorIndex1 );
447 theMatrix->GetData(ind + 1, aLogPrimEnergy2, aLogCS2, log02,
448 aLogSecondEnergyVector2, aLogProbVector2,
449 aLogProbVectorIndex2);
450
451 if (! (aLogProbVector1 && aLogProbVector2 &&
452 aLogSecondEnergyVector1 && aLogSecondEnergyVector2)){
453 return 0.;
454 }
455
456 G4double rand_var = G4UniformRand();
457 G4double log_rand_var = std::log(rand_var);
458 G4double log_Tcut = std::log(fTcutSecond);
459 G4double Esec = 0.;
460 G4double log_dE1, log_dE2;
461 G4double log_rand_var1, log_rand_var2;
462 G4double log_E1, log_E2;
463 log_rand_var1 = log_rand_var;
464 log_rand_var2 = log_rand_var;
465
466 G4double Emin = 0.;
467 G4double Emax = 0.;
468 if(theMatrix->IsScatProjToProj())
469 { // case where Tcut plays a role
472 G4double dE = 0.;
473 if(Emin < Emax)
474 {
476 {
477 if(fSecondPartSameType && fTcutSecond > aPrimEnergy)
478 return aPrimEnergy;
479
480 log_rand_var1 = log_rand_var +
481 theInterpolator->InterpolateForLogVector(
482 log_Tcut, *aLogSecondEnergyVector1, *aLogProbVector1);
483 log_rand_var2 = log_rand_var +
484 theInterpolator->InterpolateForLogVector(
485 log_Tcut, *aLogSecondEnergyVector2, *aLogProbVector2);
486 }
487 log_dE1 = theInterpolator->Interpolate(log_rand_var1, *aLogProbVector1,
488 *aLogSecondEnergyVector1, "Lin");
489 log_dE2 = theInterpolator->Interpolate(log_rand_var2, *aLogProbVector2,
490 *aLogSecondEnergyVector2, "Lin");
491 dE = std::exp(theInterpolator->LinearInterpolation(
492 aLogPrimEnergy, aLogPrimEnergy1, aLogPrimEnergy2, log_dE1, log_dE2));
493 }
494
495 Esec = aPrimEnergy + dE;
496 Esec = std::max(Esec, Emin);
497 Esec = std::min(Esec, Emax);
498 }
499 else
500 { // Tcut condition is already full-filled
501
502 log_E1 = theInterpolator->Interpolate(log_rand_var, *aLogProbVector1,
503 *aLogSecondEnergyVector1, "Lin");
504 log_E2 = theInterpolator->Interpolate(log_rand_var, *aLogProbVector2,
505 *aLogSecondEnergyVector2, "Lin");
506
507 Esec = std::exp(theInterpolator->LinearInterpolation(
508 aLogPrimEnergy, aLogPrimEnergy1, aLogPrimEnergy2, log_E1, log_E2));
511 Esec = std::max(Esec, Emin);
512 Esec = std::min(Esec, Emax);
513 }
514 return Esec;
515}
static const G4double dE
#define G4endl
Definition: G4ios.hh:57
G4GLOB_DLL std::ostream G4cout
G4bool GetData(unsigned int i, G4double &aPrimEnergy, G4double &aCS, G4double &log0, std::vector< double > *&aLogSecondEnergyVector, std::vector< double > *&aLogProbVector, std::vector< size_t > *&aLogProbVectorIndex)
std::vector< double > * GetLogPrimEnergyVector()
G4double LinearInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
G4double Interpolate(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, G4String InterPolMethod="Log")
static G4AdjointInterpolator * GetInstance()
size_t FindPositionForLogVector(G4double &x, std::vector< G4double > &x_vec)
G4double InterpolateForLogVector(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec)

References dE, Emax, Emin, G4VEmAdjointModel::fApplyCutInRange, G4AdjointInterpolator::FindPositionForLogVector(), G4VEmAdjointModel::fSecondPartSameType, G4VEmAdjointModel::fTcutSecond, G4cout, G4endl, G4UniformRand, G4AdjointCSMatrix::GetData(), G4AdjointInterpolator::GetInstance(), G4AdjointCSMatrix::GetLogPrimEnergyVector(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4AdjointInterpolator::Interpolate(), G4AdjointInterpolator::InterpolateForLogVector(), G4AdjointCSMatrix::IsScatProjToProj(), G4AdjointInterpolator::LinearInterpolation(), G4INCL::Math::max(), and G4INCL::Math::min().

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), G4AdjointBremsstrahlungModel::SampleSecondaries(), SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), and G4AdjointIonIonisationModel::SampleSecondaries().

◆ SampleAdjSecEnergyFromDiffCrossSectionPerAtom()

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom ( G4double  prim_energy,
G4bool  isScatProjToProj 
)
protectedvirtualinherited

Definition at line 557 of file G4VEmAdjointModel.cc.

559{
560 // here we try to use the rejection method
561 constexpr G4int iimax = 1000;
562 G4double E = 0.;
563 G4double x, xmin, greject;
564 if(isScatProjToProj)
565 {
567 G4double Emin = prim_energy + fTcutSecond;
568 xmin = Emin / Emax;
569 G4double grejmax =
570 DiffCrossSectionPerAtomPrimToScatPrim(Emin, prim_energy, 1) * prim_energy;
571
572 G4int ii = 0;
573 do
574 {
575 // q = G4UniformRand();
576 x = 1. / (G4UniformRand() * (1. / xmin - 1.) + 1.);
577 E = x * Emax;
578 greject =
579 DiffCrossSectionPerAtomPrimToScatPrim(E, prim_energy, 1) * prim_energy;
580 ++ii;
581 if(ii >= iimax)
582 {
583 break;
584 }
585 }
586 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
587 while(greject < G4UniformRand() * grejmax);
588 }
589 else
590 {
593 xmin = Emin / Emax;
594 G4double grejmax =
596 G4int ii = 0;
597 do
598 {
599 x = std::pow(xmin, G4UniformRand());
600 E = x * Emax;
601 greject = DiffCrossSectionPerAtomPrimToSecond(E, prim_energy, 1);
602 ++ii;
603 if(ii >= iimax)
604 {
605 break;
606 }
607 }
608 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
609 while(greject < G4UniformRand() * grejmax);
610 }
611
612 return E;
613}

References G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), Emax, Emin, G4VEmAdjointModel::fTcutSecond, G4UniformRand, G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), and G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj().

◆ SampleSecondaries()

void G4AdjointComptonModel::SampleSecondaries ( const G4Track aTrack,
G4bool  isScatProjToProj,
G4ParticleChange fParticleChange 
)
overridevirtual

Implements G4VEmAdjointModel.

Definition at line 61 of file G4AdjointComptonModel.cc.

64{
65 if(!fUseMatrix)
66 return RapidSampleSecondaries(aTrack, isScatProjToProj, fParticleChange);
67
68 // A recall of the compton scattering law:
69 // Egamma2=Egamma1/(1+(Egamma1/E0_electron)(1.-cos_th))
70 // Therefore Egamma2_max= Egamma2(cos_th=1) = Egamma1
71 // and Egamma2_min= Egamma2(cos_th=-1) =
72 // Egamma1/(1+2.(Egamma1/E0_electron))
73 const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
74 G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
75 if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
76 {
77 return;
78 }
79
80 // Sample secondary energy
81 G4double gammaE1;
82 gammaE1 =
83 SampleAdjSecEnergyFromCSMatrix(adjointPrimKinEnergy, isScatProjToProj);
84
85 // gammaE2
86 G4double gammaE2 = adjointPrimKinEnergy;
87 if(!isScatProjToProj)
88 gammaE2 = gammaE1 - adjointPrimKinEnergy;
89
90 // Cos th
91 G4double cos_th = 1. + electron_mass_c2 * (1. / gammaE1 - 1. / gammaE2);
92 if(!isScatProjToProj)
93 {
94 cos_th =
95 (gammaE1 - gammaE2 * cos_th) / theAdjointPrimary->GetTotalMomentum();
96 }
97 G4double sin_th = 0.;
98 if(std::abs(cos_th) > 1.)
99 {
100 if(cos_th > 0.)
101 {
102 cos_th = 1.;
103 }
104 else
105 cos_th = -1.;
106 sin_th = 0.;
107 }
108 else
109 sin_th = std::sqrt(1. - cos_th * cos_th);
110
111 // gamma0 momentum
112 G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
113 G4double phi = G4UniformRand() * twopi;
114 G4ThreeVector gammaMomentum1 =
115 gammaE1 *
116 G4ThreeVector(std::cos(phi) * sin_th, std::sin(phi) * sin_th, cos_th);
117 gammaMomentum1.rotateUz(dir_parallel);
118
119 // correct the weight of particles before adding the secondary
120 CorrectPostStepWeight(fParticleChange, aTrack.GetWeight(),
121 adjointPrimKinEnergy, gammaE1, isScatProjToProj);
122
123 if(!isScatProjToProj)
124 { // kill the primary and add a secondary
125 fParticleChange->ProposeTrackStatus(fStopAndKill);
126 fParticleChange->AddSecondary(
127 new G4DynamicParticle(fAdjEquivDirectPrimPart, gammaMomentum1));
128 }
129 else
130 {
131 fParticleChange->ProposeEnergy(gammaE1);
132 fParticleChange->ProposeMomentumDirection(gammaMomentum1.unit());
133 }
134}
void RapidSampleSecondaries(const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange)
virtual void CorrectPostStepWeight(G4ParticleChange *fParticleChange, G4double old_weight, G4double adjointPrimKinEnergy, G4double projectileKinEnergy, G4bool isScatProjToProj)

References G4ParticleChange::AddSecondary(), G4VEmAdjointModel::CorrectPostStepWeight(), source.hepunit::electron_mass_c2, G4VEmAdjointModel::fAdjEquivDirectPrimPart, fStopAndKill, G4VEmAdjointModel::fUseMatrix, G4UniformRand, G4Track::GetDynamicParticle(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentumDirection(), G4DynamicParticle::GetTotalMomentum(), G4Track::GetWeight(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), RapidSampleSecondaries(), CLHEP::Hep3Vector::rotateUz(), G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), twopi, and CLHEP::Hep3Vector::unit().

◆ SelectCSMatrix()

void G4VEmAdjointModel::SelectCSMatrix ( G4bool  isScatProjToProj)
protectedinherited

Definition at line 527 of file G4VEmAdjointModel.cc.

528{
529 fCSMatrixUsed = 0;
533 { // Select Material
534 std::vector<G4double>* CS_Vs_Element = &fElementCSScatProjToProj;
536 if(!isScatProjToProj)
537 {
538 CS_Vs_Element = &fElementCSProdToProj;
540 }
541 G4double SumCS = 0.;
542 size_t ind = 0;
543 for(size_t i = 0; i < CS_Vs_Element->size(); ++i)
544 {
545 SumCS += (*CS_Vs_Element)[i];
546 if(G4UniformRand() <= SumCS / fLastCS)
547 {
548 ind = i;
549 break;
550 }
551 }
553 }
554}
size_t GetIndex() const
Definition: G4Element.hh:182
const G4Element * GetElement(G4int iel) const
Definition: G4Material.hh:198
size_t GetIndex() const
Definition: G4Material.hh:256
std::vector< G4double > fElementCSScatProjToProj
std::vector< G4double > fElementCSProdToProj

References G4VEmAdjointModel::fCSMatrixUsed, G4VEmAdjointModel::fCurrentMaterial, G4VEmAdjointModel::fElementCSProdToProj, G4VEmAdjointModel::fElementCSScatProjToProj, G4VEmAdjointModel::fLastAdjointCSForProdToProj, G4VEmAdjointModel::fLastAdjointCSForScatProjToProj, G4VEmAdjointModel::fLastCS, G4VEmAdjointModel::fOneMatrixForAllElements, G4VEmAdjointModel::fUseMatrixPerElement, G4UniformRand, G4Material::GetElement(), G4Element::GetIndex(), and G4Material::GetIndex().

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix().

◆ SetAdditionalWeightCorrectionFactorForPostStepOutsideModel()

void G4VEmAdjointModel::SetAdditionalWeightCorrectionFactorForPostStepOutsideModel ( G4double  factor)
inlineinherited

◆ SetAdjointEquivalentOfDirectPrimaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition ( G4ParticleDefinition aPart)
inherited

◆ SetAdjointEquivalentOfDirectSecondaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectSecondaryParticleDefinition ( G4ParticleDefinition aPart)
inlineinherited

Definition at line 165 of file G4VEmAdjointModel.hh.

167 {
169 }

References G4VEmAdjointModel::fAdjEquivDirectSecondPart.

◆ SetApplyCutInRange()

void G4VEmAdjointModel::SetApplyCutInRange ( G4bool  aBool)
inlineinherited

◆ SetCorrectWeightForPostStepInModel()

void G4VEmAdjointModel::SetCorrectWeightForPostStepInModel ( G4bool  aBool)
inlineinherited

Definition at line 210 of file G4VEmAdjointModel.hh.

211 {
212 fInModelWeightCorr = aBool;
213 }

References G4VEmAdjointModel::fInModelWeightCorr.

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

◆ SetCSBiasingFactor()

virtual void G4VEmAdjointModel::SetCSBiasingFactor ( G4double  aVal)
inlinevirtualinherited

Definition at line 205 of file G4VEmAdjointModel.hh.

206 {
207 fCsBiasingFactor = aVal;
208 }

References G4VEmAdjointModel::fCsBiasingFactor.

◆ SetCSMatrices()

void G4VEmAdjointModel::SetCSMatrices ( std::vector< G4AdjointCSMatrix * > *  Vec1CSMatrix,
std::vector< G4AdjointCSMatrix * > *  Vec2CSMatrix 
)
inlineinherited

Definition at line 133 of file G4VEmAdjointModel.hh.

135 {
136 fCSMatrixProdToProjBackScat = Vec1CSMatrix;
137 fCSMatrixProjToProjBackScat = Vec2CSMatrix;
138 };
std::vector< G4AdjointCSMatrix * > * fCSMatrixProdToProjBackScat
std::vector< G4AdjointCSMatrix * > * fCSMatrixProjToProjBackScat

References G4VEmAdjointModel::fCSMatrixProdToProjBackScat, and G4VEmAdjointModel::fCSMatrixProjToProjBackScat.

◆ SetDirectProcess()

void G4AdjointComptonModel::SetDirectProcess ( G4VEmProcess aProcess)
inline

Definition at line 72 of file G4AdjointComptonModel.hh.

73 {
74 fDirectProcess = aProcess;
75 };

References fDirectProcess.

◆ SetHighEnergyLimit()

void G4VEmAdjointModel::SetHighEnergyLimit ( G4double  aVal)
inherited

◆ SetLowEnergyLimit()

void G4VEmAdjointModel::SetLowEnergyLimit ( G4double  aVal)
inherited

◆ SetSecondPartOfSameType()

void G4VEmAdjointModel::SetSecondPartOfSameType ( G4bool  aBool)
inlineinherited

◆ SetUseMatrix()

void G4VEmAdjointModel::SetUseMatrix ( G4bool  aBool)
inlineinherited

◆ SetUseMatrixPerElement()

void G4VEmAdjointModel::SetUseMatrixPerElement ( G4bool  aBool)
inlineinherited

◆ SetUseOnlyOneMatrixForAllElements()

void G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements ( G4bool  aBool)
inlineinherited

Definition at line 185 of file G4VEmAdjointModel.hh.

186 {
188 }

References G4VEmAdjointModel::fOneMatrixForAllElements.

Referenced by G4AdjointComptonModel().

Field Documentation

◆ fAdjEquivDirectPrimPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectPrimPart = nullptr
protectedinherited

◆ fAdjEquivDirectSecondPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectSecondPart = nullptr
protectedinherited

◆ fApplyCutInRange

G4bool G4VEmAdjointModel::fApplyCutInRange = true
protectedinherited

◆ fASelectedNucleus

G4int G4VEmAdjointModel::fASelectedNucleus = 0
protectedinherited

◆ fCsBiasingFactor

G4double G4VEmAdjointModel::fCsBiasingFactor = 1.
protectedinherited

◆ fCSManager

G4AdjointCSManager* G4VEmAdjointModel::fCSManager
protectedinherited

◆ fCSMatrixProdToProjBackScat

std::vector<G4AdjointCSMatrix*>* G4VEmAdjointModel::fCSMatrixProdToProjBackScat = nullptr
protectedinherited

◆ fCSMatrixProjToProjBackScat

std::vector<G4AdjointCSMatrix*>* G4VEmAdjointModel::fCSMatrixProjToProjBackScat = nullptr
protectedinherited

◆ fCSMatrixUsed

size_t G4VEmAdjointModel::fCSMatrixUsed = 0
protectedinherited

◆ fCurrentCouple

G4MaterialCutsCouple* G4VEmAdjointModel::fCurrentCouple = nullptr
protectedinherited

◆ fCurrentMaterial

G4Material* G4VEmAdjointModel::fCurrentMaterial = nullptr
protectedinherited

◆ fDirectCS

G4double G4AdjointComptonModel::fDirectCS = 0.
private

◆ fDirectModel

G4VEmModel* G4VEmAdjointModel::fDirectModel = nullptr
protectedinherited

◆ fDirectPrimaryPart

G4ParticleDefinition* G4VEmAdjointModel::fDirectPrimaryPart = nullptr
protectedinherited

◆ fDirectProcess

G4VEmProcess* G4AdjointComptonModel::fDirectProcess = nullptr
private

Definition at line 81 of file G4AdjointComptonModel.hh.

Referenced by RapidSampleSecondaries(), and SetDirectProcess().

◆ fElementCSProdToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSProdToProj
protectedinherited

◆ fElementCSScatProjToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSScatProjToProj
protectedinherited

◆ fHighEnergyLimit

G4double G4VEmAdjointModel::fHighEnergyLimit = 0.
protectedinherited

◆ fInModelWeightCorr

G4bool G4VEmAdjointModel::fInModelWeightCorr
protectedinherited

◆ fKinEnergyProdForIntegration

G4double G4VEmAdjointModel::fKinEnergyProdForIntegration = 0.
protectedinherited

◆ fKinEnergyScatProjForIntegration

G4double G4VEmAdjointModel::fKinEnergyScatProjForIntegration = 0.
protectedinherited

◆ fLastAdjointCSForProdToProj

G4double G4VEmAdjointModel::fLastAdjointCSForProdToProj = 0.
protectedinherited

◆ fLastAdjointCSForScatProjToProj

G4double G4VEmAdjointModel::fLastAdjointCSForScatProjToProj = 0.
protectedinherited

◆ fLastCS

G4double G4VEmAdjointModel::fLastCS = 0.
protectedinherited

◆ fLowEnergyLimit

G4double G4VEmAdjointModel::fLowEnergyLimit = 0.
protectedinherited

◆ fName

const G4String G4VEmAdjointModel::fName
protectedinherited

Definition at line 252 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::GetName().

◆ fOneMatrixForAllElements

G4bool G4VEmAdjointModel::fOneMatrixForAllElements = false
protectedinherited

◆ fOutsideWeightFactor

G4double G4VEmAdjointModel::fOutsideWeightFactor = 1.
protectedinherited

◆ fPreStepEnergy

G4double G4VEmAdjointModel::fPreStepEnergy = 0.
protectedinherited

◆ fSecondPartSameType

G4bool G4VEmAdjointModel::fSecondPartSameType = false
protectedinherited

◆ fSelectedMaterial

G4Material* G4VEmAdjointModel::fSelectedMaterial = nullptr
protectedinherited

◆ fTcutPrim

G4double G4VEmAdjointModel::fTcutPrim = 0.
protectedinherited

Definition at line 279 of file G4VEmAdjointModel.hh.

◆ fTcutSecond

G4double G4VEmAdjointModel::fTcutSecond = 0.
protectedinherited

◆ fUseMatrix

G4bool G4VEmAdjointModel::fUseMatrix = false
protectedinherited

◆ fUseMatrixPerElement

G4bool G4VEmAdjointModel::fUseMatrixPerElement = false
protectedinherited

◆ fZSelectedNucleus

G4int G4VEmAdjointModel::fZSelectedNucleus = 0
protectedinherited

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