Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
G4VEmAdjointModel Class Referenceabstract

#include <G4VEmAdjointModel.hh>

+ Inheritance diagram for G4VEmAdjointModel:

Public Member Functions

 G4VEmAdjointModel (const G4String &nam)
 
virtual ~G4VEmAdjointModel ()
 
virtual void SampleSecondaries (const G4Track &aTrack, G4bool IsScatProjToProjCase, G4ParticleChange *fParticleChange)=0
 
virtual G4double AdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool IsScatProjToProjCase)
 
virtual G4double GetAdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool IsScatProjToProjCase)
 
virtual G4double DiffCrossSectionPerAtomPrimToSecond (G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.)
 
virtual G4double DiffCrossSectionPerAtomPrimToScatPrim (G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.)
 
virtual G4double DiffCrossSectionPerVolumePrimToSecond (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd)
 
virtual G4double DiffCrossSectionPerVolumePrimToScatPrim (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
 
virtual G4double GetSecondAdjEnergyMaxForScatProjToProjCase (G4double PrimAdjEnergy)
 
virtual G4double GetSecondAdjEnergyMinForScatProjToProjCase (G4double PrimAdjEnergy, G4double Tcut=0)
 
virtual G4double GetSecondAdjEnergyMaxForProdToProjCase (G4double PrimAdjEnergy)
 
virtual G4double GetSecondAdjEnergyMinForProdToProjCase (G4double PrimAdjEnergy)
 
void DefineCurrentMaterial (const G4MaterialCutsCouple *couple)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerAtomForSecond (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerAtomForScatProj (G4double kinEnergyProd, G4double Z, G4double A=0., G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerVolumeForSecond (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
 
std::vector< std::vector< double > * > ComputeAdjointCrossSectionVectorPerVolumeForScatProj (G4Material *aMaterial, G4double kinEnergyProd, G4int nbin_pro_decade=10)
 
void SetCSMatrices (std::vector< G4AdjointCSMatrix * > *Vec1CSMatrix, std::vector< G4AdjointCSMatrix * > *Vec2CSMatrix)
 
G4ParticleDefinition * GetAdjointEquivalentOfDirectPrimaryParticleDefinition ()
 
G4ParticleDefinition * GetAdjointEquivalentOfDirectSecondaryParticleDefinition ()
 
G4double GetHighEnergyLimit ()
 
G4double GetLowEnergyLimit ()
 
void SetHighEnergyLimit (G4double aVal)
 
void SetLowEnergyLimit (G4double aVal)
 
void DefineDirectEMModel (G4VEmModel *aModel)
 
void SetAdjointEquivalentOfDirectPrimaryParticleDefinition (G4ParticleDefinition *aPart)
 
void SetAdjointEquivalentOfDirectSecondaryParticleDefinition (G4ParticleDefinition *aPart)
 
void SetSecondPartOfSameType (G4bool aBool)
 
G4bool GetSecondPartOfSameType ()
 
void SetUseMatrix (G4bool aBool)
 
void SetUseMatrixPerElement (G4bool aBool)
 
void SetUseOnlyOneMatrixForAllElements (G4bool aBool)
 
void SetApplyCutInRange (G4bool aBool)
 
G4bool GetUseMatrix ()
 
G4bool GetUseMatrixPerElement ()
 
G4bool GetUseOnlyOneMatrixForAllElements ()
 
G4bool GetApplyCutInRange ()
 
G4String GetName ()
 
virtual void SetCSBiasingFactor (G4double aVal)
 
void SetCorrectWeightForPostStepInModel (G4bool aBool)
 
void SetAdditionalWeightCorrectionFactorForPostStepOutsideModel (G4double factor)
 

Protected Member Functions

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

Protected Attributes

G4VEmModel * theDirectEMModel
 
G4VParticleChange * pParticleChange
 
const G4String name
 
G4int ASelectedNucleus
 
G4int ZSelectedNucleus
 
G4Material * SelectedMaterial
 
G4double kinEnergyProdForIntegration
 
G4double kinEnergyScatProjForIntegration
 
G4double kinEnergyProjForIntegration
 
std::vector< G4AdjointCSMatrix * > * pOnCSMatrixForProdToProjBackwardScattering
 
std::vector< G4AdjointCSMatrix * > * pOnCSMatrixForScatProjToProjBackwardScattering
 
std::vector< G4double > CS_Vs_ElementForScatProjToProjCase
 
std::vector< G4double > CS_Vs_ElementForProdToProjCase
 
G4double lastCS
 
G4double lastAdjointCSForScatProjToProjCase
 
G4double lastAdjointCSForProdToProjCase
 
G4ParticleDefinition * theAdjEquivOfDirectPrimPartDef
 
G4ParticleDefinition * theAdjEquivOfDirectSecondPartDef
 
G4ParticleDefinition * theDirectPrimaryPartDef
 
G4bool second_part_of_same_type
 
G4double preStepEnergy
 
G4Material * currentMaterial
 
G4MaterialCutsCouple * currentCouple
 
size_t currentMaterialIndex
 
size_t currentCoupleIndex
 
G4double currentTcutForDirectPrim
 
G4double currentTcutForDirectSecond
 
G4bool ApplyCutInRange
 
G4double mass_ratio_product
 
G4double mass_ratio_projectile
 
G4double HighEnergyLimit
 
G4double LowEnergyLimit
 
G4double CS_biasing_factor
 
G4bool UseMatrix
 
G4bool UseMatrixPerElement
 
G4bool UseOnlyOneMatrixForAllElements
 
size_t indexOfUsedCrossSectionMatrix
 
size_t model_index
 
G4bool correct_weight_for_post_step_in_model
 
G4double additional_weight_correction_factor_for_post_step_outside_model
 

Detailed Description

Definition at line 71 of file G4VEmAdjointModel.hh.

Constructor & Destructor Documentation

◆ G4VEmAdjointModel()

G4VEmAdjointModel::G4VEmAdjointModel ( const G4String &  nam)

Definition at line 40 of file G4VEmAdjointModel.cc.

40 :
41name(nam)
42// lowLimit(0.1*keV), highLimit(100.0*TeV), fluc(0), name(nam), pParticleChange(0)
43{
44 model_index = G4AdjointCSManager::GetAdjointCSManager()->RegisterEmAdjointModel(this);
45 second_part_of_same_type =false;
46 theDirectEMModel=0;
47 mass_ratio_product=1.;
48 mass_ratio_projectile=1.;
49 currentCouple=0;
50 additional_weight_correction_factor_for_post_step_outside_model=1.;
51}
G4AdjointCSManager::RegisterEmAdjointModel
size_t RegisterEmAdjointModel(G4VEmAdjointModel *)
Definition: G4AdjointCSManager.cc:122
G4AdjointCSManager::GetAdjointCSManager
static G4AdjointCSManager * GetAdjointCSManager()
Definition: G4AdjointCSManager.cc:60
G4VEmAdjointModel::theDirectEMModel
G4VEmModel * theDirectEMModel
Definition: G4VEmAdjointModel.hh:257
G4VEmAdjointModel::additional_weight_correction_factor_for_post_step_outside_model
G4double additional_weight_correction_factor_for_post_step_outside_model
Definition: G4VEmAdjointModel.hh:344
G4VEmAdjointModel::currentCouple
G4MaterialCutsCouple * currentCouple
Definition: G4VEmAdjointModel.hh:306

◆ ~G4VEmAdjointModel()

G4VEmAdjointModel::~G4VEmAdjointModel ( )
virtual

Definition at line 54 of file G4VEmAdjointModel.cc.

55{;}

Member Function Documentation

◆ AdjointCrossSection()

G4double G4VEmAdjointModel::AdjointCrossSection ( const G4MaterialCutsCouple *  aCouple,
G4double  primEnergy,
G4bool  IsScatProjToProjCase 
)
virtual

Reimplemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 58 of file G4VEmAdjointModel.cc.

61{
62 DefineCurrentMaterial(aCouple);
63 preStepEnergy=primEnergy;
64
65 std::vector<G4double>* CS_Vs_Element = &CS_Vs_ElementForProdToProjCase;
66 if (IsScatProjToProjCase) CS_Vs_Element = &CS_Vs_ElementForScatProjToProjCase;
67 lastCS = G4AdjointCSManager::GetAdjointCSManager()->ComputeAdjointCS(currentMaterial,
68 this,
69 primEnergy,
70 currentTcutForDirectSecond,
71 IsScatProjToProjCase,
72 *CS_Vs_Element);
73 if (IsScatProjToProjCase) lastAdjointCSForScatProjToProjCase = lastCS;
74 else lastAdjointCSForProdToProjCase =lastCS;
75
76
77
78 return lastCS;
79
80}
G4AdjointCSManager::ComputeAdjointCS
G4double ComputeAdjointCS(G4Material *aMaterial, G4VEmAdjointModel *aModel, G4double PrimEnergy, G4double Tcut, G4bool IsScatProjToProjCase, std::vector< G4double > &AdjointCS_for_each_element)
Definition: G4AdjointCSManager.cc:533
G4VEmAdjointModel::lastAdjointCSForProdToProjCase
G4double lastAdjointCSForProdToProjCase
Definition: G4VEmAdjointModel.hh:289
G4VEmAdjointModel::lastAdjointCSForScatProjToProjCase
G4double lastAdjointCSForScatProjToProjCase
Definition: G4VEmAdjointModel.hh:288
G4VEmAdjointModel::CS_Vs_ElementForScatProjToProjCase
std::vector< G4double > CS_Vs_ElementForScatProjToProjCase
Definition: G4VEmAdjointModel.hh:284
G4VEmAdjointModel::DefineCurrentMaterial
void DefineCurrentMaterial(const G4MaterialCutsCouple *couple)
Definition: G4VEmAdjointModel.cc:692
G4VEmAdjointModel::currentMaterial
G4Material * currentMaterial
Definition: G4VEmAdjointModel.hh:305
G4VEmAdjointModel::CS_Vs_ElementForProdToProjCase
std::vector< G4double > CS_Vs_ElementForProdToProjCase
Definition: G4VEmAdjointModel.hh:285
G4VEmAdjointModel::currentTcutForDirectSecond
G4double currentTcutForDirectSecond
Definition: G4VEmAdjointModel.hh:310

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointCSManager::ComputeAdjointCS(), CorrectPostStepWeight(), GetAdjointCrossSection(), and G4AdjointForcedInteractionForGamma::PostStepDoIt().

◆ ComputeAdjointCrossSectionVectorPerAtomForScatProj()

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

Definition at line 292 of file G4VEmAdjointModel.cc.

297{ G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
298 ASelectedNucleus=int(A);
299 ZSelectedNucleus=int(Z);
300 kinEnergyScatProjForIntegration = kinEnergyScatProj;
301
302 //compute the vector of integrated cross sections
303 //-------------------
304
305 G4double minEProj= GetSecondAdjEnergyMinForScatProjToProjCase(kinEnergyScatProj);
306 G4double maxEProj= GetSecondAdjEnergyMaxForScatProjToProjCase(kinEnergyScatProj);
307 G4double dEmax=maxEProj-kinEnergyScatProj;
308 G4double dEmin=GetLowEnergyLimit();
309 G4double dE1=dEmin;
310 G4double dE2=dEmin;
311
312
313 std::vector< double>* log_ESec_vector = new std::vector< double>();
314 std::vector< double>* log_Prob_vector = new std::vector< double>();
315 log_ESec_vector->push_back(std::log(dEmin));
316 log_Prob_vector->push_back(-50.);
317 G4int nbins=std::max( int(std::log10(dEmax/dEmin))*nbin_pro_decade,5);
318 G4double fE=std::pow(dEmax/dEmin,1./nbins);
319
320
321
322
323
324 G4double int_cross_section=0.;
325
326 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
327 while (dE1 <dEmax*0.9999999999999){
328 dE2=dE1*fE;
329 int_cross_section +=integral.Simpson(this,
330 &G4VEmAdjointModel::DiffCrossSectionFunction2,minEProj+dE1,std::min(minEProj+dE2,maxEProj), 5);
331 //G4cout<<"int_cross_section "<<minEProj+dE1<<'\t'<<int_cross_section<<G4endl;
332 log_ESec_vector->push_back(std::log(std::min(dE2,maxEProj-minEProj)));
333 log_Prob_vector->push_back(std::log(int_cross_section));
334 dE1=dE2;
335
336 }
337
338
339 std::vector< std::vector<G4double> *> res_mat;
340 res_mat.clear();
341 if (int_cross_section >0.) {
342 res_mat.push_back(log_ESec_vector);
343 res_mat.push_back(log_Prob_vector);
344 }
345
346 return res_mat;
347}
G4double
double G4double
Definition: G4Types.hh:83
G4int
int G4int
Definition: G4Types.hh:85
G4VEmAdjointModel::GetLowEnergyLimit
G4double GetLowEnergyLimit()
Definition: G4VEmAdjointModel.hh:186
G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProjCase
virtual G4double GetSecondAdjEnergyMaxForScatProjToProjCase(G4double PrimAdjEnergy)
Definition: G4VEmAdjointModel.cc:666
G4VEmAdjointModel::kinEnergyScatProjForIntegration
G4double kinEnergyScatProjForIntegration
Definition: G4VEmAdjointModel.hh:275
G4VEmAdjointModel::DiffCrossSectionFunction2
G4double DiffCrossSectionFunction2(G4double kinEnergyProj)
Definition: G4VEmAdjointModel.cc:217
G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProjCase
virtual G4double GetSecondAdjEnergyMinForScatProjToProjCase(G4double PrimAdjEnergy, G4double Tcut=0)
Definition: G4VEmAdjointModel.cc:673

◆ ComputeAdjointCrossSectionVectorPerAtomForSecond()

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

Definition at line 238 of file G4VEmAdjointModel.cc.

243{
244 G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
245 ASelectedNucleus= int(A);
246 ZSelectedNucleus=int(Z);
247 kinEnergyProdForIntegration = kinEnergyProd;
248
249 //compute the vector of integrated cross sections
250 //-------------------
251
252 G4double minEProj= GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
253 G4double maxEProj= GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
254 G4double E1=minEProj;
255 std::vector< double>* log_ESec_vector = new std::vector< double>();
256 std::vector< double>* log_Prob_vector = new std::vector< double>();
257 log_ESec_vector->clear();
258 log_Prob_vector->clear();
259 log_ESec_vector->push_back(std::log(E1));
260 log_Prob_vector->push_back(-50.);
261
262 G4double E2=std::pow(10.,double( int(std::log10(minEProj)*nbin_pro_decade)+1)/nbin_pro_decade);
263 G4double fE=std::pow(10.,1./nbin_pro_decade);
264 G4double int_cross_section=0.;
265
266 if (std::pow(fE,5.)>(maxEProj/minEProj)) fE = std::pow(maxEProj/minEProj,0.2);
267
268 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
269 while (E1 <maxEProj*0.9999999){
270 //G4cout<<E1<<'\t'<<E2<<G4endl;
271
272 int_cross_section +=integral.Simpson(this,
273 &G4VEmAdjointModel::DiffCrossSectionFunction1,E1,std::min(E2,maxEProj*0.99999999), 5);
274 log_ESec_vector->push_back(std::log(std::min(E2,maxEProj)));
275 log_Prob_vector->push_back(std::log(int_cross_section));
276 E1=E2;
277 E2*=fE;
278
279 }
280 std::vector< std::vector<G4double>* > res_mat;
281 res_mat.clear();
282 if (int_cross_section >0.) {
283 res_mat.push_back(log_ESec_vector);
284 res_mat.push_back(log_Prob_vector);
285 }
286
287 return res_mat;
288}
G4VEmAdjointModel::DiffCrossSectionFunction1
G4double DiffCrossSectionFunction1(G4double kinEnergyProj)
Definition: G4VEmAdjointModel.cc:201
G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProjCase
virtual G4double GetSecondAdjEnergyMaxForProdToProjCase(G4double PrimAdjEnergy)
Definition: G4VEmAdjointModel.cc:680
G4VEmAdjointModel::kinEnergyProdForIntegration
G4double kinEnergyProdForIntegration
Definition: G4VEmAdjointModel.hh:274
G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProjCase
virtual G4double GetSecondAdjEnergyMinForProdToProjCase(G4double PrimAdjEnergy)
Definition: G4VEmAdjointModel.cc:685

◆ ComputeAdjointCrossSectionVectorPerVolumeForScatProj()

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

Definition at line 402 of file G4VEmAdjointModel.cc.

406{ G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
407 SelectedMaterial= aMaterial;
408 kinEnergyScatProjForIntegration = kinEnergyScatProj;
409
410 //compute the vector of integrated cross sections
411 //-------------------
412
413 G4double minEProj= GetSecondAdjEnergyMinForScatProjToProjCase(kinEnergyScatProj);
414 G4double maxEProj= GetSecondAdjEnergyMaxForScatProjToProjCase(kinEnergyScatProj);
415
416
417 G4double dEmax=maxEProj-kinEnergyScatProj;
418 G4double dEmin=GetLowEnergyLimit();
419 G4double dE1=dEmin;
420 G4double dE2=dEmin;
421
422
423 std::vector< double>* log_ESec_vector = new std::vector< double>();
424 std::vector< double>* log_Prob_vector = new std::vector< double>();
425 log_ESec_vector->push_back(std::log(dEmin));
426 log_Prob_vector->push_back(-50.);
427 G4int nbins=std::max( int(std::log10(dEmax/dEmin))*nbin_pro_decade,5);
428 G4double fE=std::pow(dEmax/dEmin,1./nbins);
429
430 G4double int_cross_section=0.;
431
432 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
433 while (dE1 <dEmax*0.9999999999999){
434 dE2=dE1*fE;
435 int_cross_section +=integral.Simpson(this,
436 &G4VEmAdjointModel::DiffCrossSectionFunction2,minEProj+dE1,std::min(minEProj+dE2,maxEProj), 5);
437 log_ESec_vector->push_back(std::log(std::min(dE2,maxEProj-minEProj)));
438 log_Prob_vector->push_back(std::log(int_cross_section));
439 dE1=dE2;
440
441 }
442
443
444
445
446
447 std::vector< std::vector<G4double> *> res_mat;
448 res_mat.clear();
449 if (int_cross_section >0.) {
450 res_mat.push_back(log_ESec_vector);
451 res_mat.push_back(log_Prob_vector);
452 }
453
454 return res_mat;
455}
G4VEmAdjointModel::SelectedMaterial
G4Material * SelectedMaterial
Definition: G4VEmAdjointModel.hh:273

◆ ComputeAdjointCrossSectionVectorPerVolumeForSecond()

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

Definition at line 350 of file G4VEmAdjointModel.cc.

354{ G4Integrator<G4VEmAdjointModel, double(G4VEmAdjointModel::*)(double)> integral;
355 SelectedMaterial= aMaterial;
356 kinEnergyProdForIntegration = kinEnergyProd;
357 //compute the vector of integrated cross sections
358 //-------------------
359
360 G4double minEProj= GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
361 G4double maxEProj= GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
362 G4double E1=minEProj;
363 std::vector< double>* log_ESec_vector = new std::vector< double>();
364 std::vector< double>* log_Prob_vector = new std::vector< double>();
365 log_ESec_vector->clear();
366 log_Prob_vector->clear();
367 log_ESec_vector->push_back(std::log(E1));
368 log_Prob_vector->push_back(-50.);
369
370 G4double E2=std::pow(10.,double( int(std::log10(minEProj)*nbin_pro_decade)+1)/nbin_pro_decade);
371 G4double fE=std::pow(10.,1./nbin_pro_decade);
372 G4double int_cross_section=0.;
373
374 if (std::pow(fE,5.)>(maxEProj/minEProj)) fE = std::pow(maxEProj/minEProj,0.2);
375
376 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
377 while (E1 <maxEProj*0.9999999){
378
379 int_cross_section +=integral.Simpson(this,
380 &G4VEmAdjointModel::DiffCrossSectionFunction1,E1,std::min(E2,maxEProj*0.99999999), 5);
381 log_ESec_vector->push_back(std::log(std::min(E2,maxEProj)));
382 log_Prob_vector->push_back(std::log(int_cross_section));
383 E1=E2;
384 E2*=fE;
385
386 }
387 std::vector< std::vector<G4double>* > res_mat;
388 res_mat.clear();
389
390 if (int_cross_section >0.) {
391 res_mat.push_back(log_ESec_vector);
392 res_mat.push_back(log_Prob_vector);
393 }
394
395
396
397 return res_mat;
398}

◆ CorrectPostStepWeight()

void G4VEmAdjointModel::CorrectPostStepWeight ( G4ParticleChange *  fParticleChange,
G4double  old_weight,
G4double  adjointPrimKinEnergy,
G4double  projectileKinEnergy,
G4bool  IsScatProjToProjCase 
)
protectedvirtual

Reimplemented in G4AdjointIonIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 633 of file G4VEmAdjointModel.cc.

638{
639 G4double new_weight=old_weight;
640 G4double w_corr =1./CS_biasing_factor;
641 w_corr*=G4AdjointCSManager::GetAdjointCSManager()->GetPostStepWeightCorrection();
642
643
644 lastCS=lastAdjointCSForScatProjToProjCase;
645 if ( !IsScatProjToProjCase) lastCS=lastAdjointCSForProdToProjCase;
646 if ((adjointPrimKinEnergy-preStepEnergy)/preStepEnergy>0.001){ //Is that in all cases needed???
647 G4double post_stepCS=AdjointCrossSection(currentCouple, adjointPrimKinEnergy
648 ,IsScatProjToProjCase );
649 if (post_stepCS>0 && lastCS>0) w_corr*=post_stepCS/lastCS;
650 }
651
652 new_weight*=w_corr;
653
654 //G4cout<<"Post step "<<new_weight<<'\t'<<w_corr<<'\t'<<old_weight<<G4endl;
655 new_weight*=projectileKinEnergy/adjointPrimKinEnergy;//This is needed due to the biasing of diff CS
656 //by the factor adjointPrimKinEnergy/projectileKinEnergy
657
658
659
660 fParticleChange->SetParentWeightByProcess(false);
661 fParticleChange->SetSecondaryWeightByProcess(false);
662 fParticleChange->ProposeParentWeight(new_weight);
663}
G4AdjointCSManager::GetPostStepWeightCorrection
G4double GetPostStepWeightCorrection()
Definition: G4AdjointCSManager.cc:526
G4VEmAdjointModel::AdjointCrossSection
virtual G4double AdjointCrossSection(const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool IsScatProjToProjCase)
Definition: G4VEmAdjointModel.cc:58
G4VParticleChange::SetSecondaryWeightByProcess
void SetSecondaryWeightByProcess(G4bool)
G4VParticleChange::SetParentWeightByProcess
void SetParentWeightByProcess(G4bool)
Definition: G4VParticleChange.cc:515
G4VParticleChange::ProposeParentWeight
void ProposeParentWeight(G4double finalWeight)

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

◆ DefineCurrentMaterial()

void G4VEmAdjointModel::DefineCurrentMaterial ( const G4MaterialCutsCouple *  couple)

Definition at line 692 of file G4VEmAdjointModel.cc.

693{ if(couple != currentCouple) {
694 currentCouple = const_cast<G4MaterialCutsCouple*> (couple);
695 currentMaterial = const_cast<G4Material*> (couple->GetMaterial());
696 currentCoupleIndex = couple->GetIndex();
697 currentMaterialIndex = currentMaterial->GetIndex();
698 size_t idx=56;
699 currentTcutForDirectSecond =0.00000000001;
700 if (theAdjEquivOfDirectSecondPartDef) {
701 if (theAdjEquivOfDirectSecondPartDef == G4AdjointGamma::AdjointGamma()) idx = 0;
702 else if (theAdjEquivOfDirectSecondPartDef == G4AdjointElectron::AdjointElectron()) idx = 1;
703 else if (theAdjEquivOfDirectSecondPartDef == G4AdjointPositron::AdjointPositron()) idx = 2;
704 if (idx <56){
705 const std::vector<G4double>* aVec = G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(idx);
706 currentTcutForDirectSecond=(*aVec)[currentCoupleIndex];
707 }
708 }
709
710
711 }
712}
G4AdjointElectron::AdjointElectron
static G4AdjointElectron * AdjointElectron()
Definition: G4AdjointElectron.cc:99
G4AdjointGamma::AdjointGamma
static G4AdjointGamma * AdjointGamma()
Definition: G4AdjointGamma.cc:83
G4AdjointPositron::AdjointPositron
static G4AdjointPositron * AdjointPositron()
Definition: G4AdjointPositron.cc:98
G4MaterialCutsCouple::GetMaterial
const G4Material * GetMaterial() const
Definition: G4MaterialCutsCouple.hh:166
G4Material::GetIndex
size_t GetIndex() const
Definition: G4Material.hh:258
G4ProductionCutsTable::GetEnergyCutsVector
const std::vector< G4double > * GetEnergyCutsVector(std::size_t pcIdx) const
Definition: G4ProductionCutsTable.hh:233
G4ProductionCutsTable::GetProductionCutsTable
static G4ProductionCutsTable * GetProductionCutsTable()
Definition: G4ProductionCutsTable.cc:58
G4VEmAdjointModel::theAdjEquivOfDirectSecondPartDef
G4ParticleDefinition * theAdjEquivOfDirectSecondPartDef
Definition: G4VEmAdjointModel.hh:295

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

◆ DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel *  aModel)
inline

Definition at line 192 of file G4VEmAdjointModel.hh.

192{theDirectEMModel = aModel;}

Referenced by G4AdjointPhotoElectricModel::SetTheDirectPEEffectModel().

◆ DiffCrossSectionFunction1()

G4double G4VEmAdjointModel::DiffCrossSectionFunction1 ( G4double  kinEnergyProj)
protected

Definition at line 201 of file G4VEmAdjointModel.cc.

201 {
202
203
204 G4double bias_factor = CS_biasing_factor*kinEnergyProdForIntegration/kinEnergyProj;
205
206
207 if (UseMatrixPerElement ) {
208 return DiffCrossSectionPerAtomPrimToSecond(kinEnergyProj,kinEnergyProdForIntegration,ZSelectedNucleus,ASelectedNucleus)*bias_factor;
209 }
210 else {
211 return DiffCrossSectionPerVolumePrimToSecond(SelectedMaterial,kinEnergyProj,kinEnergyProdForIntegration)*bias_factor;
212 }
213}
G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond
virtual G4double DiffCrossSectionPerVolumePrimToSecond(const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd)
Definition: G4VEmAdjointModel.cc:160
G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond
virtual G4double DiffCrossSectionPerAtomPrimToSecond(G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.)
Definition: G4VEmAdjointModel.cc:112

Referenced by ComputeAdjointCrossSectionVectorPerAtomForSecond(), and ComputeAdjointCrossSectionVectorPerVolumeForSecond().

◆ DiffCrossSectionFunction2()

G4double G4VEmAdjointModel::DiffCrossSectionFunction2 ( G4double  kinEnergyProj)
protected

Definition at line 217 of file G4VEmAdjointModel.cc.

217 {
218
219 G4double bias_factor = CS_biasing_factor*kinEnergyScatProjForIntegration/kinEnergyProj;
220 if (UseMatrixPerElement ) {
221 return DiffCrossSectionPerAtomPrimToScatPrim(kinEnergyProj,kinEnergyScatProjForIntegration,ZSelectedNucleus,ASelectedNucleus)*bias_factor;
222 }
223 else {
224 return DiffCrossSectionPerVolumePrimToScatPrim(SelectedMaterial,kinEnergyProj,kinEnergyScatProjForIntegration)*bias_factor;
225
226 }
227
228}
G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToScatPrim
virtual G4double DiffCrossSectionPerVolumePrimToScatPrim(const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
Definition: G4VEmAdjointModel.cc:188
G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim
virtual G4double DiffCrossSectionPerAtomPrimToScatPrim(G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.)
Definition: G4VEmAdjointModel.cc:144

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

◆ DiffCrossSectionPerAtomPrimToScatPrim()

G4double G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim ( G4double  kinEnergyProj,
G4double  kinEnergyScatProj,
G4double  Z,
G4double  A = 0. 
)
virtual

Reimplemented in G4AdjointComptonModel.

Definition at line 144 of file G4VEmAdjointModel.cc.

149{ G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
150 G4double dSigmadEprod;
151 if (kinEnergyProd <=0) dSigmadEprod=0;
152 else dSigmadEprod=DiffCrossSectionPerAtomPrimToSecond(kinEnergyProj,kinEnergyProd,Z,A);
153 return dSigmadEprod;
154
155}

Referenced by DiffCrossSectionFunction2(), and SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

◆ DiffCrossSectionPerAtomPrimToSecond()

G4double G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond ( G4double  kinEnergyProj,
G4double  kinEnergyProd,
G4double  Z,
G4double  A = 0. 
)
virtual

Reimplemented in G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 112 of file G4VEmAdjointModel.cc.

117{
118 G4double dSigmadEprod=0;
119 G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
120 G4double Emin_proj = GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
121
122
123 if (kinEnergyProj>Emin_proj && kinEnergyProj<=Emax_proj){ //the produced particle should have a kinetic energy smaller than the projectile
124
125 /*G4double Tmax=kinEnergyProj;
126 if (second_part_of_same_type) Tmax = kinEnergyProj/2.;*/
127
128 G4double E1=kinEnergyProd;
129 G4double E2=kinEnergyProd*1.000001;
130 G4double dE=(E2-E1);
131 G4double sigma1=theDirectEMModel->ComputeCrossSectionPerAtom(theDirectPrimaryPartDef,kinEnergyProj,Z,A ,E1,1.e20);
132 G4double sigma2=theDirectEMModel->ComputeCrossSectionPerAtom(theDirectPrimaryPartDef,kinEnergyProj,Z,A ,E2,1.e20);
133
134 dSigmadEprod=(sigma1-sigma2)/dE;
135 }
136 return dSigmadEprod;
137
138
139
140}
G4VEmAdjointModel::theDirectPrimaryPartDef
G4ParticleDefinition * theDirectPrimaryPartDef
Definition: G4VEmAdjointModel.hh:296
G4VEmModel::ComputeCrossSectionPerAtom
virtual G4double ComputeCrossSectionPerAtom(const G4ParticleDefinition *, G4double kinEnergy, G4double Z, G4double A=0., G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:359

Referenced by DiffCrossSectionFunction1(), DiffCrossSectionPerAtomPrimToScatPrim(), and SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

◆ DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj()

G4double G4VEmAdjointModel::DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj ( G4double  EkinProd)
protected

Definition at line 232 of file G4VEmAdjointModel.cc.

233{
234 return DiffCrossSectionPerVolumePrimToSecond(SelectedMaterial,kinEnergyProjForIntegration,kinEnergyProd);
235}
G4VEmAdjointModel::kinEnergyProjForIntegration
G4double kinEnergyProjForIntegration
Definition: G4VEmAdjointModel.hh:276

◆ DiffCrossSectionPerVolumePrimToScatPrim()

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

Definition at line 188 of file G4VEmAdjointModel.cc.

192{ G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
193 G4double dSigmadEprod;
194 if (kinEnergyProd <=0) dSigmadEprod=0;
195 else dSigmadEprod=DiffCrossSectionPerVolumePrimToSecond(aMaterial,kinEnergyProj,kinEnergyProd);
196 return dSigmadEprod;
197
198}

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

◆ DiffCrossSectionPerVolumePrimToSecond()

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

Reimplemented in G4AdjointBremsstrahlungModel.

Definition at line 160 of file G4VEmAdjointModel.cc.

164{
165 G4double dSigmadEprod=0;
166 G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProjCase(kinEnergyProd);
167 G4double Emin_proj = GetSecondAdjEnergyMinForProdToProjCase(kinEnergyProd);
168
169
170 if (kinEnergyProj>Emin_proj && kinEnergyProj<=Emax_proj){
171 /*G4double Tmax=kinEnergyProj;
172 if (second_part_of_same_type) Tmax = kinEnergyProj/2.;*/
173 G4double E1=kinEnergyProd;
174 G4double E2=kinEnergyProd*1.0001;
175 G4double dE=(E2-E1);
176 G4double sigma1=theDirectEMModel->CrossSectionPerVolume(aMaterial,theDirectPrimaryPartDef,kinEnergyProj,E1,1.e20);
177 G4double sigma2=theDirectEMModel->CrossSectionPerVolume(aMaterial,theDirectPrimaryPartDef,kinEnergyProj,E2,1.e20);
178 dSigmadEprod=(sigma1-sigma2)/dE;
179 }
180 return dSigmadEprod;
181
182
183
184}
G4VEmModel::CrossSectionPerVolume
virtual G4double CrossSectionPerVolume(const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
Definition: G4VEmModel.cc:254

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

◆ GetAdjointCrossSection()

G4double G4VEmAdjointModel::GetAdjointCrossSection ( const G4MaterialCutsCouple *  aCouple,
G4double  primEnergy,
G4bool  IsScatProjToProjCase 
)
virtual

Reimplemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, and G4AdjointPhotoElectricModel.

Definition at line 83 of file G4VEmAdjointModel.cc.

86{
87 return AdjointCrossSection(aCouple, primEnergy,
88 IsScatProjToProjCase);
89
90 /*
91 //To continue
92 DefineCurrentMaterial(aCouple);
93 preStepEnergy=primEnergy;
94 if (IsScatProjToProjCase){
95 G4double ekin=primEnergy*mass_ratio_projectile;
96 lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,true, aCouple);
97 lastAdjointCSForScatProjToProjCase = lastCS;
98 //G4cout<<ekin<<std::endl;
99 }
100 else {
101 G4double ekin=primEnergy*mass_ratio_product;
102 lastCS = G4AdjointCSManager::GetAdjointCSManager()->GetAdjointSigma(ekin, model_index,false, aCouple);
103 lastAdjointCSForProdToProjCase = lastCS;
104 //G4cout<<ekin<<std::endl;
105 }
106 return lastCS;
107 */
108}

Referenced by G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), and G4VAdjointReverseReaction::GetMeanFreePath().

◆ GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( )
inline

Definition at line 180 of file G4VEmAdjointModel.hh.

180{return theAdjEquivOfDirectPrimPartDef;}
G4VEmAdjointModel::theAdjEquivOfDirectPrimPartDef
G4ParticleDefinition * theAdjEquivOfDirectPrimPartDef
Definition: G4VEmAdjointModel.hh:294

◆ GetAdjointEquivalentOfDirectSecondaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition ( )
inline

Definition at line 182 of file G4VEmAdjointModel.hh.

182{return theAdjEquivOfDirectSecondPartDef;}

◆ GetApplyCutInRange()

G4bool G4VEmAdjointModel::GetApplyCutInRange ( )
inline

Definition at line 213 of file G4VEmAdjointModel.hh.

213{ return ApplyCutInRange;}

Referenced by G4AdjointCSManager::ComputeAdjointCS().

◆ GetHighEnergyLimit()

G4double G4VEmAdjointModel::GetHighEnergyLimit ( )
inline

Definition at line 184 of file G4VEmAdjointModel.hh.

184{return HighEnergyLimit;}

◆ GetLowEnergyLimit()

G4double G4VEmAdjointModel::GetLowEnergyLimit ( )
inline

Definition at line 186 of file G4VEmAdjointModel.hh.

186{return LowEnergyLimit;}

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

◆ GetName()

G4String G4VEmAdjointModel::GetName ( )
inline

Definition at line 215 of file G4VEmAdjointModel.hh.

215{ return name;}

Referenced by G4AdjointCSManager::BuildCrossSectionMatrices().

◆ GetSecondAdjEnergyMaxForProdToProjCase()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProjCase ( G4double  PrimAdjEnergy)
virtual

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 680 of file G4VEmAdjointModel.cc.

681{ return HighEnergyLimit;
682}

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointeIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ GetSecondAdjEnergyMaxForScatProjToProjCase()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProjCase ( G4double  PrimAdjEnergy)
virtual

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 666 of file G4VEmAdjointModel.cc.

667{ G4double maxEProj= HighEnergyLimit;
668 if (second_part_of_same_type) maxEProj=std::min(kinEnergyScatProj*2.,HighEnergyLimit);
669 return maxEProj;
670}

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ GetSecondAdjEnergyMinForProdToProjCase()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProjCase ( G4double  PrimAdjEnergy)
virtual

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 685 of file G4VEmAdjointModel.cc.

686{ G4double minEProj=PrimAdjEnergy;
687 if (second_part_of_same_type) minEProj=PrimAdjEnergy*2.;
688 return minEProj;
689}

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointeIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ GetSecondAdjEnergyMinForScatProjToProjCase()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProjCase ( G4double  PrimAdjEnergy,
G4double  Tcut = 0 
)
virtual

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 673 of file G4VEmAdjointModel.cc.

674{ G4double Emin=PrimAdjEnergy;
675 if (ApplyCutInRange) Emin=PrimAdjEnergy+Tcut;
676 return Emin;
677}

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ GetSecondPartOfSameType()

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( )
inline

Definition at line 202 of file G4VEmAdjointModel.hh.

202{return second_part_of_same_type;}

◆ GetUseMatrix()

G4bool G4VEmAdjointModel::GetUseMatrix ( )
inline

Definition at line 210 of file G4VEmAdjointModel.hh.

210{return UseMatrix;}

Referenced by G4AdjointCSManager::BuildCrossSectionMatrices(), and G4AdjointCSManager::ComputeAdjointCS().

◆ GetUseMatrixPerElement()

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( )
inline

Definition at line 211 of file G4VEmAdjointModel.hh.

211{ return UseMatrixPerElement;}

Referenced by G4AdjointCSManager::BuildCrossSectionMatrices(), and G4AdjointCSManager::ComputeAdjointCS().

◆ GetUseOnlyOneMatrixForAllElements()

G4bool G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements ( )
inline

Definition at line 212 of file G4VEmAdjointModel.hh.

212{ return UseOnlyOneMatrixForAllElements;}
G4VEmAdjointModel::UseOnlyOneMatrixForAllElements
G4bool UseOnlyOneMatrixForAllElements
Definition: G4VEmAdjointModel.hh:332

Referenced by G4AdjointCSManager::BuildCrossSectionMatrices(), and G4AdjointCSManager::ComputeAdjointCS().

◆ SampleAdjSecEnergyFromCSMatrix() [1/2]

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix ( G4double  prim_energy,
G4bool  IsScatProjToProjCase 
)
protected

Definition at line 548 of file G4VEmAdjointModel.cc.

549{ SelectCSMatrix(IsScatProjToProjCase);
550 return SampleAdjSecEnergyFromCSMatrix(indexOfUsedCrossSectionMatrix, aPrimEnergy, IsScatProjToProjCase);
551}
G4VEmAdjointModel::indexOfUsedCrossSectionMatrix
size_t indexOfUsedCrossSectionMatrix
Definition: G4VEmAdjointModel.hh:336
G4VEmAdjointModel::SelectCSMatrix
void SelectCSMatrix(G4bool IsScatProjToProjCase)
Definition: G4VEmAdjointModel.cc:554
G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix
G4double SampleAdjSecEnergyFromCSMatrix(size_t MatrixIndex, G4double prim_energy, G4bool IsScatProjToProjCase)
Definition: G4VEmAdjointModel.cc:458

◆ SampleAdjSecEnergyFromCSMatrix() [2/2]

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix ( size_t  MatrixIndex,
G4double  prim_energy,
G4bool  IsScatProjToProjCase 
)
protected

Definition at line 458 of file G4VEmAdjointModel.cc.

459{
460
461
462 G4AdjointCSMatrix* theMatrix= (*pOnCSMatrixForProdToProjBackwardScattering)[MatrixIndex];
463 if (IsScatProjToProjCase) theMatrix= (*pOnCSMatrixForScatProjToProjBackwardScattering)[MatrixIndex];
464 std::vector< double>* theLogPrimEnergyVector = theMatrix->GetLogPrimEnergyVector();
465
466 if (theLogPrimEnergyVector->size() ==0){
467 G4cout<<"No data are contained in the given AdjointCSMatrix!"<<G4endl;
468 G4cout<<"The sampling procedure will be stopped."<<G4endl;
469 return 0.;
470
471 }
472
473 G4AdjointInterpolator* theInterpolator=G4AdjointInterpolator::GetInstance();
474 G4double aLogPrimEnergy = std::log(aPrimEnergy);
475 size_t ind =theInterpolator->FindPositionForLogVector(aLogPrimEnergy,*theLogPrimEnergyVector);
476
477
478 G4double aLogPrimEnergy1,aLogPrimEnergy2;
479 G4double aLogCS1,aLogCS2;
480 G4double log01,log02;
481 std::vector< double>* aLogSecondEnergyVector1 =0;
482 std::vector< double>* aLogSecondEnergyVector2 =0;
483 std::vector< double>* aLogProbVector1=0;
484 std::vector< double>* aLogProbVector2=0;
485 std::vector< size_t>* aLogProbVectorIndex1=0;
486 std::vector< size_t>* aLogProbVectorIndex2=0;
487
488 theMatrix->GetData(ind, aLogPrimEnergy1,aLogCS1,log01, aLogSecondEnergyVector1,aLogProbVector1,aLogProbVectorIndex1);
489 theMatrix->GetData(ind+1, aLogPrimEnergy2,aLogCS2,log02, aLogSecondEnergyVector2,aLogProbVector2,aLogProbVectorIndex2);
490
491 G4double rand_var = G4UniformRand();
492 G4double log_rand_var= std::log(rand_var);
493 G4double log_Tcut =std::log(currentTcutForDirectSecond);
494 G4double Esec=0;
495 G4double log_dE1,log_dE2;
496 G4double log_rand_var1,log_rand_var2;
497 G4double log_E1,log_E2;
498 log_rand_var1=log_rand_var;
499 log_rand_var2=log_rand_var;
500
501 G4double Emin=0.;
502 G4double Emax=0.;
503 if (theMatrix->IsScatProjToProjCase()){ //case where Tcut plays a role
504 Emin=GetSecondAdjEnergyMinForScatProjToProjCase(aPrimEnergy,currentTcutForDirectSecond);
505 Emax=GetSecondAdjEnergyMaxForScatProjToProjCase(aPrimEnergy);
506 G4double dE=0;
507 if (Emin < Emax ){
508 if (ApplyCutInRange) {
509 if (second_part_of_same_type && currentTcutForDirectSecond>aPrimEnergy) return aPrimEnergy;
510
511 log_rand_var1=log_rand_var+theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector1,*aLogProbVector1);
512 log_rand_var2=log_rand_var+theInterpolator->InterpolateForLogVector(log_Tcut,*aLogSecondEnergyVector2,*aLogProbVector2);
513
514 }
515 log_dE1 = theInterpolator->Interpolate(log_rand_var1,*aLogProbVector1,*aLogSecondEnergyVector1,"Lin");
516 log_dE2 = theInterpolator->Interpolate(log_rand_var2,*aLogProbVector2,*aLogSecondEnergyVector2,"Lin");
517 dE=std::exp(theInterpolator->LinearInterpolation(aLogPrimEnergy,aLogPrimEnergy1,aLogPrimEnergy2,log_dE1,log_dE2));
518 }
519
520 Esec = aPrimEnergy +dE;
521 Esec=std::max(Esec,Emin);
522 Esec=std::min(Esec,Emax);
523
524 }
525 else { //Tcut condition is already full-filled
526
527 log_E1 = theInterpolator->Interpolate(log_rand_var,*aLogProbVector1,*aLogSecondEnergyVector1,"Lin");
528 log_E2 = theInterpolator->Interpolate(log_rand_var,*aLogProbVector2,*aLogSecondEnergyVector2,"Lin");
529
530 Esec = std::exp(theInterpolator->LinearInterpolation(aLogPrimEnergy,aLogPrimEnergy1,aLogPrimEnergy2,log_E1,log_E2));
531 Emin=GetSecondAdjEnergyMinForProdToProjCase(aPrimEnergy);
532 Emax=GetSecondAdjEnergyMaxForProdToProjCase(aPrimEnergy);
533 Esec=std::max(Esec,Emin);
534 Esec=std::min(Esec,Emax);
535
536 }
537
538 return Esec;
539
540
541
542
543
544}
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:52
G4AdjointCSMatrix::GetData
G4bool GetData(unsigned int i, G4double &aPrimEnergy, G4double &aCS, G4double &log0, std::vector< double > *&aLogSecondEnergyVector, std::vector< double > *&aLogProbVector, std::vector< size_t > *&aLogProbVectorIndex)
Definition: G4AdjointCSMatrix.cc:108
G4AdjointCSMatrix::GetLogPrimEnergyVector
std::vector< double > * GetLogPrimEnergyVector()
Definition: G4AdjointCSMatrix.hh:79
G4AdjointInterpolator::LinearInterpolation
G4double LinearInterpolation(G4double &x, G4double &x1, G4double &x2, G4double &y1, G4double &y2)
Definition: G4AdjointInterpolator.cc:63
G4AdjointInterpolator::Interpolate
G4double Interpolate(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec, G4String InterPolMethod="Log")
Definition: G4AdjointInterpolator.cc:188
G4AdjointInterpolator::GetInstance
static G4AdjointInterpolator * GetInstance()
Definition: G4AdjointInterpolator.cc:40
G4AdjointInterpolator::FindPositionForLogVector
size_t FindPositionForLogVector(G4double &x, std::vector< G4double > &x_vec)
Definition: G4AdjointInterpolator.cc:163
G4AdjointInterpolator::InterpolateForLogVector
G4double InterpolateForLogVector(G4double &x, std::vector< G4double > &x_vec, std::vector< G4double > &y_vec)
Definition: G4AdjointInterpolator.cc:219

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

◆ SampleAdjSecEnergyFromDiffCrossSectionPerAtom()

G4double G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom ( G4double  prim_energy,
G4bool  IsScatProjToProjCase 
)
protectedvirtual

Definition at line 580 of file G4VEmAdjointModel.cc.

581{
582 // here we try to use the rejection method
583 //-----------------------------------------
584
585 const G4int iimax = 1000;
586 G4double E=0;
587 G4double x,xmin,greject,q;
588 if ( IsScatProjToProjCase){
589 G4double Emax = GetSecondAdjEnergyMaxForScatProjToProjCase(prim_energy);
590 G4double Emin= prim_energy+currentTcutForDirectSecond;
591 xmin=Emin/Emax;
592 G4double grejmax = DiffCrossSectionPerAtomPrimToScatPrim(Emin,prim_energy,1)*prim_energy;
593
594 G4int ii =0;
595 do {
596 q = G4UniformRand();
597 x = 1./(q*(1./xmin -1.) +1.);
598 E=x*Emax;
599 greject = DiffCrossSectionPerAtomPrimToScatPrim( E,prim_energy ,1)*prim_energy;
600 ++ii;
601 if(ii >= iimax) { break; }
602 }
603 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
604 while( greject < G4UniformRand()*grejmax );
605
606 }
607 else {
608 G4double Emax = GetSecondAdjEnergyMaxForProdToProjCase(prim_energy);
609 G4double Emin= GetSecondAdjEnergyMinForProdToProjCase(prim_energy);;
610 xmin=Emin/Emax;
611 G4double grejmax = DiffCrossSectionPerAtomPrimToSecond(Emin,prim_energy,1);
612 G4int ii =0;
613 do {
614 q = G4UniformRand();
615 x = std::pow(xmin, q);
616 E=x*Emax;
617 greject = DiffCrossSectionPerAtomPrimToSecond( E,prim_energy ,1);
618 ++ii;
619 if(ii >= iimax) { break; }
620 }
621 // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
622 while( greject < G4UniformRand()*grejmax );
623
624
625
626 }
627
628 return E;
629}

◆ SampleSecondaries()

virtual void G4VEmAdjointModel::SampleSecondaries ( const G4Track &  aTrack,
G4bool  IsScatProjToProjCase,
G4ParticleChange *  fParticleChange 
)
pure virtual

Implemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, G4AdjointIonIonisationModel, and G4AdjointPhotoElectricModel.

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt(), and G4VAdjointReverseReaction::PostStepDoIt().

◆ SelectCSMatrix()

void G4VEmAdjointModel::SelectCSMatrix ( G4bool  IsScatProjToProjCase)
protected

Definition at line 554 of file G4VEmAdjointModel.cc.

555{
556 indexOfUsedCrossSectionMatrix=0;
557 if (!UseMatrixPerElement) indexOfUsedCrossSectionMatrix = currentMaterialIndex;
558 else if (!UseOnlyOneMatrixForAllElements) { //Select Material
559 std::vector<G4double>* CS_Vs_Element = &CS_Vs_ElementForScatProjToProjCase;
560 lastCS=lastAdjointCSForScatProjToProjCase;
561 if ( !IsScatProjToProjCase) {
562 CS_Vs_Element = &CS_Vs_ElementForProdToProjCase;
563 lastCS=lastAdjointCSForProdToProjCase;
564 }
565 G4double rand_var= G4UniformRand();
566 G4double SumCS=0.;
567 size_t ind=0;
568 for (size_t i=0;i<CS_Vs_Element->size();i++){
569 SumCS+=(*CS_Vs_Element)[i];
570 if (rand_var<=SumCS/lastCS){
571 ind=i;
572 break;
573 }
574 }
575 indexOfUsedCrossSectionMatrix = currentMaterial->GetElement(ind)->GetIndex();
576 }
577}
G4Element::GetIndex
size_t GetIndex() const
Definition: G4Element.hh:181
G4Material::GetElement
const G4Element * GetElement(G4int iel) const
Definition: G4Material.hh:200

Referenced by SampleAdjSecEnergyFromCSMatrix().

◆ SetAdditionalWeightCorrectionFactorForPostStepOutsideModel()

void G4VEmAdjointModel::SetAdditionalWeightCorrectionFactorForPostStepOutsideModel ( G4double  factor)
inline

Definition at line 219 of file G4VEmAdjointModel.hh.

219{additional_weight_correction_factor_for_post_step_outside_model = factor;}

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

◆ SetAdjointEquivalentOfDirectPrimaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition ( G4ParticleDefinition *  aPart)

Definition at line 728 of file G4VEmAdjointModel.cc.

729{
730 theAdjEquivOfDirectPrimPartDef=aPart;
731 if (theAdjEquivOfDirectPrimPartDef->GetParticleName() =="adj_e-")
732 theDirectPrimaryPartDef=G4Electron::Electron();
733 if (theAdjEquivOfDirectPrimPartDef->GetParticleName() =="adj_gamma")
734 theDirectPrimaryPartDef=G4Gamma::Gamma();
735}
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:108

◆ SetAdjointEquivalentOfDirectSecondaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectSecondaryParticleDefinition ( G4ParticleDefinition *  aPart)
inline

Definition at line 196 of file G4VEmAdjointModel.hh.

196 {
197 theAdjEquivOfDirectSecondPartDef =aPart;
198 }

◆ SetApplyCutInRange()

void G4VEmAdjointModel::SetApplyCutInRange ( G4bool  aBool)
inline

Definition at line 209 of file G4VEmAdjointModel.hh.

209{ ApplyCutInRange = aBool;}

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), and G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel().

◆ SetCorrectWeightForPostStepInModel()

void G4VEmAdjointModel::SetCorrectWeightForPostStepInModel ( G4bool  aBool)
inline

Definition at line 218 of file G4VEmAdjointModel.hh.

218{correct_weight_for_post_step_in_model = aBool;}
G4VEmAdjointModel::correct_weight_for_post_step_in_model
G4bool correct_weight_for_post_step_in_model
Definition: G4VEmAdjointModel.hh:343

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

◆ SetCSBiasingFactor()

virtual void G4VEmAdjointModel::SetCSBiasingFactor ( G4double  aVal)
inlinevirtual

Definition at line 216 of file G4VEmAdjointModel.hh.

216{CS_biasing_factor = aVal;}

◆ SetCSMatrices()

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

Definition at line 173 of file G4VEmAdjointModel.hh.

173 {
174 pOnCSMatrixForProdToProjBackwardScattering = Vec1CSMatrix;
175 pOnCSMatrixForScatProjToProjBackwardScattering = Vec2CSMatrix;
176
177
178 };
G4VEmAdjointModel::pOnCSMatrixForScatProjToProjBackwardScattering
std::vector< G4AdjointCSMatrix * > * pOnCSMatrixForScatProjToProjBackwardScattering
Definition: G4VEmAdjointModel.hh:283
G4VEmAdjointModel::pOnCSMatrixForProdToProjBackwardScattering
std::vector< G4AdjointCSMatrix * > * pOnCSMatrixForProdToProjBackwardScattering
Definition: G4VEmAdjointModel.hh:282

Referenced by G4AdjointCSManager::BuildCrossSectionMatrices().

◆ SetHighEnergyLimit()

void G4VEmAdjointModel::SetHighEnergyLimit ( G4double  aVal)

Definition at line 715 of file G4VEmAdjointModel.cc.

716{ HighEnergyLimit=aVal;
717 if (theDirectEMModel) theDirectEMModel->SetHighEnergyLimit( aVal);
718}
G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:757

◆ SetLowEnergyLimit()

void G4VEmAdjointModel::SetLowEnergyLimit ( G4double  aVal)

Definition at line 721 of file G4VEmAdjointModel.cc.

722{
723 LowEnergyLimit=aVal;
724 if (theDirectEMModel) theDirectEMModel->SetLowEnergyLimit( aVal);
725}
G4VEmModel::SetLowEnergyLimit
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:764

◆ SetSecondPartOfSameType()

void G4VEmAdjointModel::SetSecondPartOfSameType ( G4bool  aBool)
inline

Definition at line 200 of file G4VEmAdjointModel.hh.

200{second_part_of_same_type =aBool;}

Referenced by G4eInverseBremsstrahlung::G4eInverseBremsstrahlung(), G4eInverseCompton::G4eInverseCompton(), G4eInverseIonisation::G4eInverseIonisation(), G4hInverseIonisation::G4hInverseIonisation(), G4InversePEEffect::G4InversePEEffect(), and G4IonInverseIonisation::G4IonInverseIonisation().

◆ SetUseMatrix()

void G4VEmAdjointModel::SetUseMatrix ( G4bool  aBool)
inline

Definition at line 204 of file G4VEmAdjointModel.hh.

204{ UseMatrix = aBool;}

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), and G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel().

◆ SetUseMatrixPerElement()

void G4VEmAdjointModel::SetUseMatrixPerElement ( G4bool  aBool)
inline

Definition at line 206 of file G4VEmAdjointModel.hh.

206{ UseMatrixPerElement = aBool;}

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), and G4AdjointComptonModel::G4AdjointComptonModel().

◆ SetUseOnlyOneMatrixForAllElements()

void G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements ( G4bool  aBool)
inline

Definition at line 207 of file G4VEmAdjointModel.hh.

207{ UseOnlyOneMatrixForAllElements = aBool;}

Referenced by G4AdjointComptonModel::G4AdjointComptonModel().

Member Data Documentation

◆ additional_weight_correction_factor_for_post_step_outside_model

G4double G4VEmAdjointModel::additional_weight_correction_factor_for_post_step_outside_model
protected

Definition at line 344 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), and SetAdditionalWeightCorrectionFactorForPostStepOutsideModel().

◆ ApplyCutInRange

G4bool G4VEmAdjointModel::ApplyCutInRange
protected

Definition at line 311 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetApplyCutInRange(), GetSecondAdjEnergyMinForScatProjToProjCase(), SampleAdjSecEnergyFromCSMatrix(), and SetApplyCutInRange().

◆ ASelectedNucleus

G4int G4VEmAdjointModel::ASelectedNucleus
protected

Definition at line 271 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), DiffCrossSectionFunction1(), and DiffCrossSectionFunction2().

◆ correct_weight_for_post_step_in_model

G4bool G4VEmAdjointModel::correct_weight_for_post_step_in_model
protected

Definition at line 343 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), and SetCorrectWeightForPostStepInModel().

◆ CS_biasing_factor

G4double G4VEmAdjointModel::CS_biasing_factor
protected

Definition at line 326 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), CorrectPostStepWeight(), DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), and SetCSBiasingFactor().

◆ CS_Vs_ElementForProdToProjCase

std::vector<G4double> G4VEmAdjointModel::CS_Vs_ElementForProdToProjCase
protected

Definition at line 285 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

◆ CS_Vs_ElementForScatProjToProjCase

std::vector<G4double> G4VEmAdjointModel::CS_Vs_ElementForScatProjToProjCase
protected

Definition at line 284 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

◆ currentCouple

G4MaterialCutsCouple* G4VEmAdjointModel::currentCouple
protected

Definition at line 306 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointPhotoElectricModel::AdjointCrossSection(), CorrectPostStepWeight(), DefineCurrentMaterial(), G4VEmAdjointModel(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), and G4AdjointComptonModel::RapidSampleSecondaries().

◆ currentCoupleIndex

size_t G4VEmAdjointModel::currentCoupleIndex
protected

Definition at line 308 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial().

◆ currentMaterial

G4Material* G4VEmAdjointModel::currentMaterial
protected

Definition at line 305 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointComptonModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointPhotoElectricModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineCurrentMaterial(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointPhotoElectricModel::SampleSecondaries(), and SelectCSMatrix().

◆ currentMaterialIndex

size_t G4VEmAdjointModel::currentMaterialIndex
protected

Definition at line 307 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial(), and SelectCSMatrix().

◆ currentTcutForDirectPrim

G4double G4VEmAdjointModel::currentTcutForDirectPrim
protected

Definition at line 309 of file G4VEmAdjointModel.hh.

◆ currentTcutForDirectSecond

G4double G4VEmAdjointModel::currentTcutForDirectSecond
protected

Definition at line 310 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineCurrentMaterial(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), SampleAdjSecEnergyFromCSMatrix(), SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ HighEnergyLimit

G4double G4VEmAdjointModel::HighEnergyLimit
protected

Definition at line 321 of file G4VEmAdjointModel.hh.

Referenced by GetHighEnergyLimit(), G4AdjointhIonisationModel::GetSecondAdjEnergyMaxForProdToProjCase(), G4AdjointIonIonisationModel::GetSecondAdjEnergyMaxForProdToProjCase(), GetSecondAdjEnergyMaxForProdToProjCase(), G4AdjointComptonModel::GetSecondAdjEnergyMaxForScatProjToProjCase(), GetSecondAdjEnergyMaxForScatProjToProjCase(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointIonIonisationModel::SampleSecondaries(), and SetHighEnergyLimit().

◆ indexOfUsedCrossSectionMatrix

size_t G4VEmAdjointModel::indexOfUsedCrossSectionMatrix
protected

Definition at line 336 of file G4VEmAdjointModel.hh.

Referenced by SampleAdjSecEnergyFromCSMatrix(), and SelectCSMatrix().

◆ kinEnergyProdForIntegration

G4double G4VEmAdjointModel::kinEnergyProdForIntegration
protected

Definition at line 274 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), and DiffCrossSectionFunction1().

◆ kinEnergyProjForIntegration

G4double G4VEmAdjointModel::kinEnergyProjForIntegration
protected

Definition at line 276 of file G4VEmAdjointModel.hh.

Referenced by DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj().

◆ kinEnergyScatProjForIntegration

G4double G4VEmAdjointModel::kinEnergyScatProjForIntegration
protected

Definition at line 275 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), and DiffCrossSectionFunction2().

◆ lastAdjointCSForProdToProjCase

G4double G4VEmAdjointModel::lastAdjointCSForProdToProjCase
protected

Definition at line 289 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

◆ lastAdjointCSForScatProjToProjCase

G4double G4VEmAdjointModel::lastAdjointCSForScatProjToProjCase
protected

Definition at line 288 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

◆ lastCS

G4double G4VEmAdjointModel::lastCS
protected

Definition at line 287 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointComptonModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointPhotoElectricModel::AdjointCrossSection(), AdjointCrossSection(), CorrectPostStepWeight(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and SelectCSMatrix().

◆ LowEnergyLimit

G4double G4VEmAdjointModel::LowEnergyLimit
protected

Definition at line 322 of file G4VEmAdjointModel.hh.

Referenced by GetLowEnergyLimit(), and SetLowEnergyLimit().

◆ mass_ratio_product

G4double G4VEmAdjointModel::mass_ratio_product
protected

Definition at line 315 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

◆ mass_ratio_projectile

G4double G4VEmAdjointModel::mass_ratio_projectile
protected

Definition at line 316 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

◆ model_index

size_t G4VEmAdjointModel::model_index
protected

Definition at line 338 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel().

◆ name

const G4String G4VEmAdjointModel::name
protected

Definition at line 266 of file G4VEmAdjointModel.hh.

Referenced by GetName().

◆ pOnCSMatrixForProdToProjBackwardScattering

std::vector< G4AdjointCSMatrix* >* G4VEmAdjointModel::pOnCSMatrixForProdToProjBackwardScattering
protected

Definition at line 282 of file G4VEmAdjointModel.hh.

Referenced by SetCSMatrices().

◆ pOnCSMatrixForScatProjToProjBackwardScattering

std::vector< G4AdjointCSMatrix* >* G4VEmAdjointModel::pOnCSMatrixForScatProjToProjBackwardScattering
protected

Definition at line 283 of file G4VEmAdjointModel.hh.

Referenced by SetCSMatrices().

◆ pParticleChange

G4VParticleChange* G4VEmAdjointModel::pParticleChange
protected

Definition at line 258 of file G4VEmAdjointModel.hh.

◆ preStepEnergy

G4double G4VEmAdjointModel::preStepEnergy
protected

Definition at line 301 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and CorrectPostStepWeight().

◆ second_part_of_same_type

G4bool G4VEmAdjointModel::second_part_of_same_type
protected

Definition at line 297 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4VEmAdjointModel(), GetSecondAdjEnergyMaxForScatProjToProjCase(), GetSecondAdjEnergyMinForProdToProjCase(), GetSecondPartOfSameType(), SampleAdjSecEnergyFromCSMatrix(), and SetSecondPartOfSameType().

◆ SelectedMaterial

G4Material* G4VEmAdjointModel::SelectedMaterial
protected

Definition at line 273 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), ComputeAdjointCrossSectionVectorPerVolumeForSecond(), DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), and DiffCrossSectionPerVolumeFunctionForIntegrationOverEkinProj().

◆ theAdjEquivOfDirectPrimPartDef

G4ParticleDefinition* G4VEmAdjointModel::theAdjEquivOfDirectPrimPartDef
protected

Definition at line 294 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), GetAdjointEquivalentOfDirectPrimaryParticleDefinition(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointIonIonisationModel::SampleSecondaries(), SetAdjointEquivalentOfDirectPrimaryParticleDefinition(), and G4AdjointIonIonisationModel::SetIon().

◆ theAdjEquivOfDirectSecondPartDef

G4ParticleDefinition* G4VEmAdjointModel::theAdjEquivOfDirectSecondPartDef
protected

Definition at line 295 of file G4VEmAdjointModel.hh.

Referenced by DefineCurrentMaterial(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), GetAdjointEquivalentOfDirectSecondaryParticleDefinition(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), G4AdjointIonIonisationModel::SampleSecondaries(), and SetAdjointEquivalentOfDirectSecondaryParticleDefinition().

◆ theDirectEMModel

G4VEmModel* G4VEmAdjointModel::theDirectEMModel
protected

Definition at line 257 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), DefineDirectEMModel(), G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToScatPrim(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated2(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4VEmAdjointModel(), G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), SetHighEnergyLimit(), and SetLowEnergyLimit().

◆ theDirectPrimaryPartDef

G4ParticleDefinition* G4VEmAdjointModel::theDirectPrimaryPartDef
protected

Definition at line 296 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerAtomPrimToSecond(), DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated1(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecondApproximated2(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4AdjointBremsstrahlungModel::GetAdjointCrossSection(), SetAdjointEquivalentOfDirectPrimaryParticleDefinition(), and G4AdjointIonIonisationModel::SetIon().

◆ UseMatrix

G4bool G4VEmAdjointModel::UseMatrix
protected

Definition at line 330 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseMatrix(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), and SetUseMatrix().

◆ UseMatrixPerElement

G4bool G4VEmAdjointModel::UseMatrixPerElement
protected

Definition at line 331 of file G4VEmAdjointModel.hh.

Referenced by DiffCrossSectionFunction1(), DiffCrossSectionFunction2(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseMatrixPerElement(), SelectCSMatrix(), and SetUseMatrixPerElement().

◆ UseOnlyOneMatrixForAllElements

G4bool G4VEmAdjointModel::UseOnlyOneMatrixForAllElements
protected

Definition at line 332 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), GetUseOnlyOneMatrixForAllElements(), SelectCSMatrix(), and SetUseOnlyOneMatrixForAllElements().

◆ ZSelectedNucleus

G4int G4VEmAdjointModel::ZSelectedNucleus
protected

Definition at line 272 of file G4VEmAdjointModel.hh.

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), DiffCrossSectionFunction1(), and DiffCrossSectionFunction2().

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