G4AdjointBremsstrahlungModel Class Reference

#include <G4AdjointBremsstrahlungModel.hh>

Inheritance diagram for G4AdjointBremsstrahlungModel:

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)
virtual G4double	DiffCrossSectionPerAtomPrimToScatPrim (G4double kinEnergyProj, G4double kinEnergyScatProj, G4double Z, G4double A=0.)
virtual G4double	DiffCrossSectionPerAtomPrimToSecond (G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.)
virtual G4double	DiffCrossSectionPerVolumePrimToScatPrim (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyScatProj)
G4double	DiffCrossSectionPerVolumePrimToSecond (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd) override
	G4AdjointBremsstrahlungModel ()
	G4AdjointBremsstrahlungModel (G4AdjointBremsstrahlungModel &)=delete
	G4AdjointBremsstrahlungModel (G4VEmModel *aModel)
G4ParticleDefinition *	GetAdjointEquivalentOfDirectPrimaryParticleDefinition ()
G4ParticleDefinition *	GetAdjointEquivalentOfDirectSecondaryParticleDefinition ()
G4bool	GetApplyCutInRange ()
G4double	GetHighEnergyLimit ()
G4double	GetLowEnergyLimit ()
G4String	GetName ()
virtual G4double	GetSecondAdjEnergyMaxForProdToProj (G4double primAdjEnergy)
virtual G4double	GetSecondAdjEnergyMaxForScatProjToProj (G4double primAdjEnergy)
virtual G4double	GetSecondAdjEnergyMinForProdToProj (G4double primAdjEnergy)
virtual G4double	GetSecondAdjEnergyMinForScatProjToProj (G4double primAdjEnergy, G4double tcut=0.)
G4bool	GetSecondPartOfSameType ()
G4bool	GetUseMatrix ()
G4bool	GetUseMatrixPerElement ()
G4bool	GetUseOnlyOneMatrixForAllElements ()
G4AdjointBremsstrahlungModel &	operator= (const G4AdjointBremsstrahlungModel &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	SetHighEnergyLimit (G4double aVal)
void	SetLowEnergyLimit (G4double aVal)
void	SetSecondPartOfSameType (G4bool aBool)
void	SetUseMatrix (G4bool aBool)
void	SetUseMatrixPerElement (G4bool aBool)
void	SetUseOnlyOneMatrixForAllElements (G4bool aBool)
	~G4AdjointBremsstrahlungModel () 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
G4ParticleDefinition *	fAdjEquivDirectPrimPart = nullptr
G4ParticleDefinition *	fAdjEquivDirectSecondPart = nullptr
G4bool	fApplyCutInRange = true
G4int	fASelectedNucleus = 0
G4double	fCsBiasingFactor = 1.
std::vector< G4AdjointCSMatrix * > *	fCSMatrixProdToProjBackScat = nullptr
std::vector< G4AdjointCSMatrix * > *	fCSMatrixProjToProjBackScat = nullptr
size_t	fCSMatrixUsed = 0
G4MaterialCutsCouple *	fCurrentCouple = nullptr
G4Material *	fCurrentMaterial = nullptr
G4VEmModel *	fDirectModel = nullptr
G4ParticleDefinition *	fDirectPrimaryPart = nullptr
std::vector< G4double >	fElementCSProdToProj
std::vector< G4double >	fElementCSScatProjToProj
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
G4Material *	fSelectedMaterial = nullptr
G4double	fTcutPrim = 0.
G4double	fTcutSecond = 0.
G4bool	fUseMatrix = false
G4bool	fUseMatrixPerElement = false
G4int	fZSelectedNucleus = 0

Private Member Functions
void	Initialize ()

Private Attributes
G4AdjointCSManager *	fCSManager
G4ParticleDefinition *	fElectron
G4EmModelManager *	fEmModelManagerForFwdModels
G4ParticleDefinition *	fGamma
G4bool	fIsDirectModelInitialised = false
G4double	fLastCZ = 0.

Detailed Description

Definition at line 52 of file G4AdjointBremsstrahlungModel.hh.

Constructor & Destructor Documentation

G4AdjointBremsstrahlungModel() [1/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel ( G4VEmModel *  aModel )

explicit

Definition at line 42 of file G4AdjointBremsstrahlungModel.cc.

  : G4VEmAdjointModel("AdjointeBremModel")
{
  fDirectModel = aModel;
  Initialize();
}

References G4VEmAdjointModel::fDirectModel, and Initialize().

G4AdjointBremsstrahlungModel() [2/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel

(

)

Definition at line 50 of file G4AdjointBremsstrahlungModel.cc.

  : G4VEmAdjointModel("AdjointeBremModel")
{
  fDirectModel = new G4SeltzerBergerModel();
  Initialize();
}

References G4VEmAdjointModel::fDirectModel, and Initialize().

~G4AdjointBremsstrahlungModel()

G4AdjointBremsstrahlungModel::~G4AdjointBremsstrahlungModel ( )

override

Definition at line 79 of file G4AdjointBremsstrahlungModel.cc.

{
  if(fEmModelManagerForFwdModels)
    delete fEmModelManagerForFwdModels;
}

References fEmModelManagerForFwdModels.

G4AdjointBremsstrahlungModel() [3/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel ( G4AdjointBremsstrahlungModel &  )

delete

Member Function Documentation

AdjointCrossSection()

G4double G4AdjointBremsstrahlungModel::AdjointCrossSection ( const G4MaterialCutsCouple *  aCouple, G4double  primEnergy, G4bool  isScatProjToProj  )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 304 of file G4AdjointBremsstrahlungModel.cc.

{
  static constexpr G4double maxEnergy = 100. * MeV / 2.718281828459045;
  // 2.78.. == std::exp(1.)
  if(!fIsDirectModelInitialised)
  {
    fEmModelManagerForFwdModels->Initialise(fElectron, fGamma, 1., 0);
    fIsDirectModelInitialised = true;
  }
  if(fUseMatrix)
    return G4VEmAdjointModel::AdjointCrossSection(aCouple, primEnergy,
                                                  isScatProjToProj);
  DefineCurrentMaterial(aCouple);
  G4double Cross = 0.;
  // this gives the constant above
  fLastCZ = fDirectModel->CrossSectionPerVolume(
    aCouple->GetMaterial(), fDirectPrimaryPart, 100. * MeV, maxEnergy);
 
  if(!isScatProjToProj)
  {
    G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProj(primEnergy);
    G4double Emin_proj = GetSecondAdjEnergyMinForProdToProj(primEnergy);
    if(Emax_proj > Emin_proj && primEnergy > fTcutSecond)
      Cross = fCsBiasingFactor * fLastCZ * std::log(Emax_proj / Emin_proj);
  }
  else
  {
    G4double Emax_proj = GetSecondAdjEnergyMaxForScatProjToProj(primEnergy);
    G4double Emin_proj =
      GetSecondAdjEnergyMinForScatProjToProj(primEnergy, fTcutSecond);
    if(Emax_proj > Emin_proj)
      Cross = fLastCZ * std::log((Emax_proj - primEnergy) * Emin_proj /
                                 Emax_proj / (Emin_proj - primEnergy));
  }
  return Cross;
}

References G4VEmAdjointModel::AdjointCrossSection(), G4VEmModel::CrossSectionPerVolume(), G4VEmAdjointModel::DefineCurrentMaterial(), G4VEmAdjointModel::fCsBiasingFactor, G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, fElectron, fEmModelManagerForFwdModels, fGamma, fIsDirectModelInitialised, fLastCZ, G4VEmAdjointModel::fTcutSecond, G4VEmAdjointModel::fUseMatrix, G4MaterialCutsCouple::GetMaterial(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4EmModelManager::Initialise(), and MeV.

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.

{
  G4Integrator<G4VEmAdjointModel, G4double (G4VEmAdjointModel::*)(G4double)>
    integral;
  fASelectedNucleus                = G4lrint(A);
  fZSelectedNucleus                = G4lrint(Z);
  fKinEnergyScatProjForIntegration = kinEnergyScatProj;
 
  // compute the vector of integrated cross sections
  G4double minEProj = GetSecondAdjEnergyMinForScatProjToProj(kinEnergyScatProj);
  G4double maxEProj = GetSecondAdjEnergyMaxForScatProjToProj(kinEnergyScatProj);
  G4double dEmax    = maxEProj - kinEnergyScatProj;
  G4double dEmin    = GetLowEnergyLimit();
  G4double dE1      = dEmin;
  G4double dE2      = dEmin;
 
  std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
  std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
  log_ESec_vector->push_back(std::log(dEmin));
  log_Prob_vector->push_back(-50.);
  G4int nbins = std::max(G4int(std::log10(dEmax / dEmin)) * nbin_pro_decade, 5);
  G4double fE = std::pow(dEmax / dEmin, 1. / nbins);
 
  G4double int_cross_section = 0.;
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while(dE1 < dEmax * 0.9999999999999)
  {
    dE2 = dE1 * fE;
    int_cross_section +=
      integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction2,
                       minEProj + dE1, std::min(minEProj + dE2, maxEProj), 5);
    log_ESec_vector->push_back(std::log(std::min(dE2, maxEProj - minEProj)));
    log_Prob_vector->push_back(std::log(int_cross_section));
    dE1 = dE2;
  }
 
  std::vector<std::vector<G4double>*> res_mat;
  if(int_cross_section > 0.)
  {
    res_mat.push_back(log_ESec_vector);
    res_mat.push_back(log_Prob_vector);
  }
  else {
    delete  log_ESec_vector;
    delete  log_Prob_vector;
  }
 
  return res_mat;
}

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.

{
  G4Integrator<G4VEmAdjointModel, G4double (G4VEmAdjointModel::*)(G4double)>
    integral;
  fASelectedNucleus            = G4lrint(A);
  fZSelectedNucleus            = G4lrint(Z);
  fKinEnergyProdForIntegration = kinEnergyProd;
 
  // compute the vector of integrated cross sections
  G4double minEProj = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
  G4double maxEProj = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
  G4double E1       = minEProj;
  std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
  std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
  log_ESec_vector->push_back(std::log(E1));
  log_Prob_vector->push_back(-50.);
 
  G4double E2 =
    std::pow(10., G4double(G4int(std::log10(minEProj) * nbin_pro_decade) + 1) /
                    nbin_pro_decade);
  G4double fE = std::pow(10., 1. / nbin_pro_decade);
 
  if(std::pow(fE, 5.) > (maxEProj / minEProj))
    fE = std::pow(maxEProj / minEProj, 0.2);
 
  G4double int_cross_section = 0.;
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while(E1 < maxEProj * 0.9999999)
  {
    int_cross_section +=
      integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction1, E1,
                       std::min(E2, maxEProj * 0.99999999), 5);
    log_ESec_vector->push_back(std::log(std::min(E2, maxEProj)));
    log_Prob_vector->push_back(std::log(int_cross_section));
    E1 = E2;
    E2 *= fE;
  }
  std::vector<std::vector<G4double>*> res_mat;
  if(int_cross_section > 0.)
  {
    res_mat.push_back(log_ESec_vector);
    res_mat.push_back(log_Prob_vector);
  }
  else {
    delete  log_ESec_vector;
    delete  log_Prob_vector;
  }
  return res_mat;
}

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.

{
  G4Integrator<G4VEmAdjointModel, G4double (G4VEmAdjointModel::*)(G4double)>
    integral;
  fSelectedMaterial                = aMaterial;
  fKinEnergyScatProjForIntegration = kinEnergyScatProj;
 
  // compute the vector of integrated cross sections
  G4double minEProj = GetSecondAdjEnergyMinForScatProjToProj(kinEnergyScatProj);
  G4double maxEProj = GetSecondAdjEnergyMaxForScatProjToProj(kinEnergyScatProj);
 
  G4double dEmax = maxEProj - kinEnergyScatProj;
  G4double dEmin = GetLowEnergyLimit();
  G4double dE1   = dEmin;
  G4double dE2   = dEmin;
 
  std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
  std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
  log_ESec_vector->push_back(std::log(dEmin));
  log_Prob_vector->push_back(-50.);
  G4int nbins = std::max(int(std::log10(dEmax / dEmin)) * nbin_pro_decade, 5);
  G4double fE = std::pow(dEmax / dEmin, 1. / nbins);
 
  G4double int_cross_section = 0.;
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while(dE1 < dEmax * 0.9999999999999)
  {
    dE2 = dE1 * fE;
    int_cross_section +=
      integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction2,
                       minEProj + dE1, std::min(minEProj + dE2, maxEProj), 5);
    log_ESec_vector->push_back(std::log(std::min(dE2, maxEProj - minEProj)));
    log_Prob_vector->push_back(std::log(int_cross_section));
    dE1 = dE2;
  }
 
  std::vector<std::vector<G4double>*> res_mat;
  if(int_cross_section > 0.)
  {
    res_mat.push_back(log_ESec_vector);
    res_mat.push_back(log_Prob_vector);
  }
  else {
    delete  log_ESec_vector;
    delete  log_Prob_vector;
  }
 
  return res_mat;
}

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.

{
  G4Integrator<G4VEmAdjointModel, G4double (G4VEmAdjointModel::*)(G4double)>
    integral;
  fSelectedMaterial            = aMaterial;
  fKinEnergyProdForIntegration = kinEnergyProd;
 
  // compute the vector of integrated cross sections
  G4double minEProj = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
  G4double maxEProj = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
  G4double E1       = minEProj;
  std::vector<G4double>* log_ESec_vector = new std::vector<G4double>();
  std::vector<G4double>* log_Prob_vector = new std::vector<G4double>();
  log_ESec_vector->push_back(std::log(E1));
  log_Prob_vector->push_back(-50.);
 
  G4double E2 =
    std::pow(10., G4double(G4int(std::log10(minEProj) * nbin_pro_decade) + 1) /
                    nbin_pro_decade);
  G4double fE = std::pow(10., 1. / nbin_pro_decade);
 
  if(std::pow(fE, 5.) > (maxEProj / minEProj))
    fE = std::pow(maxEProj / minEProj, 0.2);
 
  G4double int_cross_section = 0.;
  // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
  while(E1 < maxEProj * 0.9999999)
  {
    int_cross_section +=
      integral.Simpson(this, &G4VEmAdjointModel::DiffCrossSectionFunction1, E1,
                       std::min(E2, maxEProj * 0.99999999), 5);
    log_ESec_vector->push_back(std::log(std::min(E2, maxEProj)));
    log_Prob_vector->push_back(std::log(int_cross_section));
    E1 = E2;
    E2 *= fE;
  }
  std::vector<std::vector<G4double>*> res_mat;
 
  if(int_cross_section > 0.)
  {
    res_mat.push_back(log_ESec_vector);
    res_mat.push_back(log_Prob_vector);
  }
  else {
    delete  log_ESec_vector;
    delete  log_Prob_vector;
  }
  return res_mat;
}

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.

{
  G4double new_weight = old_weight;
  G4double w_corr =
    fCSManager->GetPostStepWeightCorrection() / fCsBiasingFactor;
 
  fLastCS = fLastAdjointCSForScatProjToProj;
  if(!isScatProjToProj)
    fLastCS = fLastAdjointCSForProdToProj;
  if((adjointPrimKinEnergy - fPreStepEnergy) / fPreStepEnergy > 0.001)
  {
    G4double post_stepCS = AdjointCrossSection(
      fCurrentCouple, adjointPrimKinEnergy, isScatProjToProj);
    if(post_stepCS > 0. && fLastCS > 0.)
      w_corr *= post_stepCS / fLastCS;
  }
 
  new_weight *= w_corr;
  new_weight *= projectileKinEnergy / adjointPrimKinEnergy;
  // This is needed due to the biasing of diff CS
  // by the factor adjointPrimKinEnergy/projectileKinEnergy
 
  fParticleChange->SetParentWeightByProcess(false);
  fParticleChange->SetSecondaryWeightByProcess(false);
  fParticleChange->ProposeParentWeight(new_weight);
}

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 SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and G4AdjointhIonisationModel::SampleSecondaries().

DefineCurrentMaterial()

void G4VEmAdjointModel::DefineCurrentMaterial ( const G4MaterialCutsCouple *  couple )

inherited

Definition at line 684 of file G4VEmAdjointModel.cc.

{
  if(couple != fCurrentCouple)
  {
    fCurrentCouple   = const_cast<G4MaterialCutsCouple*>(couple);
    fCurrentMaterial = const_cast<G4Material*>(couple->GetMaterial());
    size_t idx       = 56;
    fTcutSecond      = 1.e-11;
    if(fAdjEquivDirectSecondPart)
    {
      if(fAdjEquivDirectSecondPart == G4AdjointGamma::AdjointGamma())
        idx = 0;
      else if(fAdjEquivDirectSecondPart == G4AdjointElectron::AdjointElectron())
        idx = 1;
      else if(fAdjEquivDirectSecondPart == G4AdjointPositron::AdjointPositron())
        idx = 2;
      if(idx < 56)
      {
        const std::vector<G4double>* aVec =
          G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(
            idx);
        fTcutSecond = (*aVec)[couple->GetIndex()];
      }
    }
  }
}

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(), AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), and SampleSecondaries().

DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel *  aModel )

inlineinherited

Definition at line 160 of file G4VEmAdjointModel.hh.

{ fDirectModel = aModel; }

References G4VEmAdjointModel::fDirectModel.

DiffCrossSectionFunction1()

G4double G4VEmAdjointModel::DiffCrossSectionFunction1 ( G4double  kinEnergyProj )

protectedinherited

Definition at line 155 of file G4VEmAdjointModel.cc.

{
  G4double bias_factor =
    fCsBiasingFactor * fKinEnergyProdForIntegration / kinEnergyProj;
 
  if(fUseMatrixPerElement)
  {
    return DiffCrossSectionPerAtomPrimToSecond(
             kinEnergyProj, fKinEnergyProdForIntegration, fZSelectedNucleus,
             fASelectedNucleus) *
           bias_factor;
  }
  else
  {
    return DiffCrossSectionPerVolumePrimToSecond(
             fSelectedMaterial, kinEnergyProj, fKinEnergyProdForIntegration) *
           bias_factor;
  }
}

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.

{
  G4double bias_factor =
    fCsBiasingFactor * fKinEnergyScatProjForIntegration / kinEnergyProj;
  if(fUseMatrixPerElement)
  {
    return DiffCrossSectionPerAtomPrimToScatPrim(
             kinEnergyProj, fKinEnergyScatProjForIntegration, fZSelectedNucleus,
             fASelectedNucleus) *
           bias_factor;
  }
  else
  {
    return DiffCrossSectionPerVolumePrimToScatPrim(
             fSelectedMaterial, kinEnergyProj,
             fKinEnergyScatProjForIntegration) *
           bias_factor;
  }
}

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 G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToScatPrim ( G4double  kinEnergyProj, G4double  kinEnergyScatProj, G4double  Z, G4double  A = 0.  )

virtualinherited

Reimplemented in G4AdjointComptonModel.

Definition at line 105 of file G4VEmAdjointModel.cc.

{
  G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
  G4double dSigmadEprod;
  if(kinEnergyProd <= 0.)
    dSigmadEprod = 0.;
  else
    dSigmadEprod =
      DiffCrossSectionPerAtomPrimToSecond(kinEnergyProj, kinEnergyProd, Z, A);
  return dSigmadEprod;
}

References A, G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), and Z.

Referenced by G4VEmAdjointModel::DiffCrossSectionFunction2(), and G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

DiffCrossSectionPerAtomPrimToSecond()

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

virtualinherited

Reimplemented in G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 82 of file G4VEmAdjointModel.cc.

{
  G4double dSigmadEprod = 0.;
  G4double Emax_proj    = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
  G4double Emin_proj    = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
 
  // the produced particle should have a kinetic energy less than the projectile
  if(kinEnergyProj > Emin_proj && kinEnergyProj <= Emax_proj)
  {
    G4double E1     = kinEnergyProd;
    G4double E2     = kinEnergyProd * 1.000001;
    G4double sigma1 = fDirectModel->ComputeCrossSectionPerAtom(
      fDirectPrimaryPart, kinEnergyProj, Z, A, E1, 1.e20);
    G4double sigma2 = fDirectModel->ComputeCrossSectionPerAtom(
      fDirectPrimaryPart, kinEnergyProj, Z, A, E2, 1.e20);
 
    dSigmadEprod = (sigma1 - sigma2) / (E2 - E1);
  }
  return dSigmadEprod;
}

References A, G4VEmModel::ComputeCrossSectionPerAtom(), G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), and Z.

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

DiffCrossSectionPerVolumePrimToScatPrim()

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

virtualinherited

Definition at line 140 of file G4VEmAdjointModel.cc.

{
  G4double kinEnergyProd = kinEnergyProj - kinEnergyScatProj;
  G4double dSigmadEprod;
  if(kinEnergyProd <= 0.)
    dSigmadEprod = 0.;
  else
    dSigmadEprod = DiffCrossSectionPerVolumePrimToSecond(
      aMaterial, kinEnergyProj, kinEnergyProd);
  return dSigmadEprod;
}

References G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond().

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

DiffCrossSectionPerVolumePrimToSecond()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 288 of file G4AdjointBremsstrahlungModel.cc.

{
  if(!fIsDirectModelInitialised)
  {
    fEmModelManagerForFwdModels->Initialise(fElectron, fGamma, 1., 0);
    fIsDirectModelInitialised = true;
  }
  return G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(
    aMaterial, kinEnergyProj, kinEnergyProd);
}

References G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), fElectron, fEmModelManagerForFwdModels, fGamma, fIsDirectModelInitialised, and G4EmModelManager::Initialise().

Referenced by RapidSampleSecondaries().

GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( )

inlineinherited

Definition at line 141 of file G4VEmAdjointModel.hh.

  {
    return fAdjEquivDirectPrimPart;
  }

References G4VEmAdjointModel::fAdjEquivDirectPrimPart.

Referenced by G4AdjointCSManager::ComputeTotalAdjointCS().

GetAdjointEquivalentOfDirectSecondaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition ( )

inlineinherited

Definition at line 147 of file G4VEmAdjointModel.hh.

  {
    return fAdjEquivDirectSecondPart;
  }

References G4VEmAdjointModel::fAdjEquivDirectSecondPart.

Referenced by G4AdjointCSManager::ComputeTotalAdjointCS().

GetApplyCutInRange()

G4bool G4VEmAdjointModel::GetApplyCutInRange ( )

inlineinherited

Definition at line 201 of file G4VEmAdjointModel.hh.

{ return fApplyCutInRange; }

References G4VEmAdjointModel::fApplyCutInRange.

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

GetHighEnergyLimit()

G4double G4VEmAdjointModel::GetHighEnergyLimit ( )

inlineinherited

Definition at line 152 of file G4VEmAdjointModel.hh.

{ return fHighEnergyLimit; }

References G4VEmAdjointModel::fHighEnergyLimit.

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndElement(), G4AdjointCSManager::BuildCrossSectionsModelAndMaterial(), G4AdjointhIonisationModel::GetSecondAdjEnergyMaxForProdToProj(), G4AdjointIonIonisationModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4AdjointComptonModel::GetSecondAdjEnergyMaxForScatProjToProj(), RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), and G4AdjointIonIonisationModel::SampleSecondaries().

GetLowEnergyLimit()

G4double G4VEmAdjointModel::GetLowEnergyLimit ( )

inlineinherited

Definition at line 154 of file G4VEmAdjointModel.hh.

{ return fLowEnergyLimit; }

References G4VEmAdjointModel::fLowEnergyLimit.

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndElement(), G4AdjointCSManager::BuildCrossSectionsModelAndMaterial(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), and G4AdjointCSManager::ComputeTotalAdjointCS().

GetName()

G4String G4VEmAdjointModel::GetName ( )

inlineinherited

Definition at line 203 of file G4VEmAdjointModel.hh.

{ return fName; }

References G4VEmAdjointModel::fName.

GetSecondAdjEnergyMaxForProdToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj ( G4double  primAdjEnergy )

virtualinherited

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 668 of file G4VEmAdjointModel.cc.

{
  return fHighEnergyLimit;
}

References G4VEmAdjointModel::fHighEnergyLimit.

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

GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double  primAdjEnergy )

virtualinherited

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 648 of file G4VEmAdjointModel.cc.

{
  G4double maxEProj = GetHighEnergyLimit();
  if(fSecondPartSameType)
    maxEProj = std::min(kinEnergyScatProj * 2., maxEProj);
  return maxEProj;
}

References G4VEmAdjointModel::fSecondPartSameType, G4VEmAdjointModel::GetHighEnergyLimit(), and G4INCL::Math::min().

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

GetSecondAdjEnergyMinForProdToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj ( G4double  primAdjEnergy )

virtualinherited

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 674 of file G4VEmAdjointModel.cc.

{
  G4double minEProj = primAdjEnergy;
  if(fSecondPartSameType)
    minEProj = primAdjEnergy * 2.;
  return minEProj;
}

References G4VEmAdjointModel::fSecondPartSameType.

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

GetSecondAdjEnergyMinForScatProjToProj()

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

virtualinherited

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 658 of file G4VEmAdjointModel.cc.

{
  G4double Emin = primAdjEnergy;
  if(fApplyCutInRange)
    Emin += tcut;
  return Emin;
}

References Emin, and G4VEmAdjointModel::fApplyCutInRange.

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

GetSecondPartOfSameType()

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( )

inlineinherited

Definition at line 176 of file G4VEmAdjointModel.hh.

{ return fSecondPartSameType; }

References G4VEmAdjointModel::fSecondPartSameType.

Referenced by G4AdjointCSManager::BuildCrossSectionsModelAndElement(), and G4AdjointCSManager::BuildCrossSectionsModelAndMaterial().

GetUseMatrix()

G4bool G4VEmAdjointModel::GetUseMatrix ( )

inlineinherited

Definition at line 192 of file G4VEmAdjointModel.hh.

{ return fUseMatrix; }

References G4VEmAdjointModel::fUseMatrix.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

GetUseMatrixPerElement()

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( )

inlineinherited

Definition at line 194 of file G4VEmAdjointModel.hh.

{ return fUseMatrixPerElement; }

References G4VEmAdjointModel::fUseMatrixPerElement.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

GetUseOnlyOneMatrixForAllElements()

G4bool G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements ( )

inlineinherited

Definition at line 196 of file G4VEmAdjointModel.hh.

  {
    return fOneMatrixForAllElements;
  }

References G4VEmAdjointModel::fOneMatrixForAllElements.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

Initialize()

void G4AdjointBremsstrahlungModel::Initialize ( )

private

Definition at line 58 of file G4AdjointBremsstrahlungModel.cc.

{
  SetUseMatrix(false);
  SetUseMatrixPerElement(false);
 
  fEmModelManagerForFwdModels = new G4EmModelManager();
  fEmModelManagerForFwdModels->AddEmModel(1, fDirectModel, nullptr, nullptr);
  SetApplyCutInRange(true);
 
  fElectron = G4Electron::Electron();
  fGamma    = G4Gamma::Gamma();
 
  fAdjEquivDirectPrimPart   = G4AdjointElectron::AdjointElectron();
  fAdjEquivDirectSecondPart = G4AdjointGamma::AdjointGamma();
  fDirectPrimaryPart        = fElectron;
  fSecondPartSameType       = false;
 
  fCSManager = G4AdjointCSManager::GetAdjointCSManager();
}

References G4EmModelManager::AddEmModel(), G4AdjointElectron::AdjointElectron(), G4AdjointGamma::AdjointGamma(), G4Electron::Electron(), G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fAdjEquivDirectSecondPart, fCSManager, G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, fElectron, fEmModelManagerForFwdModels, fGamma, G4VEmAdjointModel::fSecondPartSameType, G4Gamma::Gamma(), G4AdjointCSManager::GetAdjointCSManager(), G4VEmAdjointModel::SetApplyCutInRange(), G4VEmAdjointModel::SetUseMatrix(), and G4VEmAdjointModel::SetUseMatrixPerElement().

Referenced by G4AdjointBremsstrahlungModel().

operator=()

G4AdjointBremsstrahlungModel & G4AdjointBremsstrahlungModel::operator= ( const G4AdjointBremsstrahlungModel &  right )

delete

RapidSampleSecondaries()

void G4AdjointBremsstrahlungModel::RapidSampleSecondaries	(	const G4Track &	aTrack,
		G4bool	isScatProjToProj,
		G4ParticleChange *	fParticleChange
	)

Definition at line 165 of file G4AdjointBremsstrahlungModel.cc.

{
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
  DefineCurrentMaterial(aTrack.GetMaterialCutsCouple());
 
  G4double adjointPrimKinEnergy   = theAdjointPrimary->GetKineticEnergy();
  G4double adjointPrimTotalEnergy = theAdjointPrimary->GetTotalEnergy();
 
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  G4double projectileKinEnergy = 0.;
  G4double gammaEnergy         = 0.;
  G4double diffCSUsed          = 0.;
  if(!isScatProjToProj)
  {
    gammaEnergy   = adjointPrimKinEnergy;
    G4double Emax = GetSecondAdjEnergyMaxForProdToProj(adjointPrimKinEnergy);
    G4double Emin = GetSecondAdjEnergyMinForProdToProj(adjointPrimKinEnergy);
    if(Emin >= Emax)
      return;
    projectileKinEnergy = Emin * std::pow(Emax / Emin, G4UniformRand());
    diffCSUsed          = fCsBiasingFactor * fLastCZ / projectileKinEnergy;
  }
  else
  {
    G4double Emax =
      GetSecondAdjEnergyMaxForScatProjToProj(adjointPrimKinEnergy);
    G4double Emin =
      GetSecondAdjEnergyMinForScatProjToProj(adjointPrimKinEnergy, fTcutSecond);
    if(Emin >= Emax)
      return;
    G4double f1 = (Emin - adjointPrimKinEnergy) / Emin;
    G4double f2 = (Emax - adjointPrimKinEnergy) / Emax / f1;
    projectileKinEnergy =
      adjointPrimKinEnergy / (1. - f1 * std::pow(f2, G4UniformRand()));
    gammaEnergy = projectileKinEnergy - adjointPrimKinEnergy;
    diffCSUsed =
      fLastCZ * adjointPrimKinEnergy / projectileKinEnergy / gammaEnergy;
  }
 
  // Weight correction:
  // First w_corr is set to the ratio between adjoint total CS and fwd total CS
  // if this has to be done in the model.
  // For the case of forced interaction this will be done in the PostStepDoIt of
  // the forced interaction.  It is important to set the weight before the
  // creation of the secondary
  G4double w_corr = fOutsideWeightFactor;
  if(fInModelWeightCorr)
  {
    w_corr = fCSManager->GetPostStepWeightCorrection();
  }
 
  // Then another correction is needed due to the fact that a biaised
  // differential CS has been used rather than the one consistent with the
  // direct model Here we consider the true diffCS as the one obtained by the
  // numerical differentiation over Tcut of the direct CS, corrected by the
  // Migdal term. Basically any other differential CS could be used here
  // (example Penelope).
  G4double diffCS = DiffCrossSectionPerVolumePrimToSecond(
    fCurrentMaterial, projectileKinEnergy, gammaEnergy);
  w_corr *= diffCS / diffCSUsed;
 
  G4double new_weight = aTrack.GetWeight() * w_corr;
  fParticleChange->SetParentWeightByProcess(false);
  fParticleChange->SetSecondaryWeightByProcess(false);
  fParticleChange->ProposeParentWeight(new_weight);
 
  // Kinematic
  G4double projectileM0          = fAdjEquivDirectPrimPart->GetPDGMass();
  G4double projectileTotalEnergy = projectileM0 + projectileKinEnergy;
  G4double projectileP2 =
    projectileTotalEnergy * projectileTotalEnergy - projectileM0 * projectileM0;
  G4double projectileP = std::sqrt(projectileP2);
 
  // Use the angular model of the forward model to generate the gamma direction
  // Dummy dynamic particle to use the model
  G4DynamicParticle* aDynPart =
    new G4DynamicParticle(fElectron, G4ThreeVector(0., 0., 1.) * projectileP);
 
  // Get the element from the direct model
  const G4Element* elm = fDirectModel->SelectRandomAtom(
    fCurrentCouple, fElectron, projectileKinEnergy, fTcutSecond);
  G4int Z         = elm->GetZasInt();
  G4double energy = aDynPart->GetTotalEnergy() - gammaEnergy;
  G4ThreeVector projectileMomentum =
    fDirectModel->GetAngularDistribution()->SampleDirection(aDynPart, energy, Z,
                                            fCurrentMaterial) * projectileP;
  G4double phi = projectileMomentum.getPhi();
 
  if(isScatProjToProj)
  {  // the adjoint primary is the scattered e-
    G4ThreeVector gammaMomentum =
      (projectileTotalEnergy - adjointPrimTotalEnergy) *
      G4ThreeVector(0., 0., 1.);
    G4ThreeVector dirProd = projectileMomentum - gammaMomentum;
    G4double cost1        = std::cos(dirProd.angle(projectileMomentum));
    G4double sint1        = std::sqrt(1. - cost1 * cost1);
    projectileMomentum =
      G4ThreeVector(std::cos(phi) * sint1, std::sin(phi) * sint1, cost1) *
      projectileP;
  }
 
  projectileMomentum.rotateUz(theAdjointPrimary->GetMomentumDirection());
 
  if(!isScatProjToProj)
  {  // kill the primary and add a secondary
    fParticleChange->ProposeTrackStatus(fStopAndKill);
    fParticleChange->AddSecondary(
      new G4DynamicParticle(fAdjEquivDirectPrimPart, projectileMomentum));
  }
  else
  {
    fParticleChange->ProposeEnergy(projectileKinEnergy);
    fParticleChange->ProposeMomentumDirection(projectileMomentum.unit());
  }
}

References G4ParticleChange::AddSecondary(), CLHEP::Hep3Vector::angle(), G4VEmAdjointModel::DefineCurrentMaterial(), DiffCrossSectionPerVolumePrimToSecond(), Emax, Emin, G4INCL::KinematicsUtils::energy(), G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fCsBiasingFactor, fCSManager, G4VEmAdjointModel::fCurrentCouple, G4VEmAdjointModel::fCurrentMaterial, G4VEmAdjointModel::fDirectModel, fElectron, G4VEmAdjointModel::fInModelWeightCorr, fLastCZ, G4VEmAdjointModel::fOutsideWeightFactor, fStopAndKill, G4VEmAdjointModel::fTcutSecond, G4UniformRand, G4VEmModel::GetAngularDistribution(), G4Track::GetDynamicParticle(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGMass(), CLHEP::Hep3Vector::getPhi(), G4AdjointCSManager::GetPostStepWeightCorrection(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForScatProjToProj(), G4DynamicParticle::GetTotalEnergy(), G4Track::GetWeight(), G4Element::GetZasInt(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeParentWeight(), G4VParticleChange::ProposeTrackStatus(), CLHEP::Hep3Vector::rotateUz(), G4VEmAngularDistribution::SampleDirection(), G4VEmModel::SelectRandomAtom(), G4VParticleChange::SetParentWeightByProcess(), G4VParticleChange::SetSecondaryWeightByProcess(), CLHEP::Hep3Vector::unit(), and Z.

Referenced by SampleSecondaries().

SampleAdjSecEnergyFromCSMatrix() [1/2]

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

protectedinherited

Definition at line 518 of file G4VEmAdjointModel.cc.

{
  SelectCSMatrix(isScatProjToProj);
  return SampleAdjSecEnergyFromCSMatrix(fCSMatrixUsed, aPrimEnergy,
                                        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.

{
  G4AdjointCSMatrix* theMatrix = (*fCSMatrixProdToProjBackScat)[MatrixIndex];
  if(isScatProjToProj)
    theMatrix = (*fCSMatrixProjToProjBackScat)[MatrixIndex];
  std::vector<G4double>* theLogPrimEnergyVector =
    theMatrix->GetLogPrimEnergyVector();
 
  if(theLogPrimEnergyVector->empty())
  {
    G4cout << "No data are contained in the given AdjointCSMatrix!" << G4endl;
    G4cout << "The sampling procedure will be stopped." << G4endl;
    return 0.;
  }
 
  G4AdjointInterpolator* theInterpolator = G4AdjointInterpolator::GetInstance();
  G4double aLogPrimEnergy                = std::log(aPrimEnergy);
  size_t ind = theInterpolator->FindPositionForLogVector(
    aLogPrimEnergy, *theLogPrimEnergyVector);
 
  G4double aLogPrimEnergy1, aLogPrimEnergy2;
  G4double aLogCS1, aLogCS2;
  G4double log01, log02;
  std::vector<double>* aLogSecondEnergyVector1 = nullptr;
  std::vector<double>* aLogSecondEnergyVector2 = nullptr;
  std::vector<double>* aLogProbVector1         = nullptr;
  std::vector<double>* aLogProbVector2         = nullptr;
  std::vector<size_t>* aLogProbVectorIndex1    = nullptr;
  std::vector<size_t>* aLogProbVectorIndex2    = nullptr;
 
  theMatrix->GetData(ind, aLogPrimEnergy1, aLogCS1, log01,
                     aLogSecondEnergyVector1, aLogProbVector1,
                     aLogProbVectorIndex1 );
  theMatrix->GetData(ind + 1, aLogPrimEnergy2, aLogCS2, log02,
                     aLogSecondEnergyVector2, aLogProbVector2,
                     aLogProbVectorIndex2);
 
  if (! (aLogProbVector1 && aLogProbVector2 &&
               aLogSecondEnergyVector1 && aLogSecondEnergyVector2)){
     return  0.;
  }
 
  G4double rand_var     = G4UniformRand();
  G4double log_rand_var = std::log(rand_var);
  G4double log_Tcut     = std::log(fTcutSecond);
  G4double Esec         = 0.;
  G4double log_dE1, log_dE2;
  G4double log_rand_var1, log_rand_var2;
  G4double log_E1, log_E2;
  log_rand_var1 = log_rand_var;
  log_rand_var2 = log_rand_var;
 
  G4double Emin = 0.;
  G4double Emax = 0.;
  if(theMatrix->IsScatProjToProj())
  {  // case where Tcut plays a role
    Emin = GetSecondAdjEnergyMinForScatProjToProj(aPrimEnergy, fTcutSecond);
    Emax = GetSecondAdjEnergyMaxForScatProjToProj(aPrimEnergy);
    G4double dE = 0.;
    if(Emin < Emax)
    {
      if(fApplyCutInRange)
      {
        if(fSecondPartSameType && fTcutSecond > aPrimEnergy)
          return aPrimEnergy;
 
        log_rand_var1 = log_rand_var +
                        theInterpolator->InterpolateForLogVector(
                          log_Tcut, *aLogSecondEnergyVector1, *aLogProbVector1);
        log_rand_var2 = log_rand_var +
                        theInterpolator->InterpolateForLogVector(
                          log_Tcut, *aLogSecondEnergyVector2, *aLogProbVector2);
      }
      log_dE1 = theInterpolator->Interpolate(log_rand_var1, *aLogProbVector1,
                                             *aLogSecondEnergyVector1, "Lin");
      log_dE2 = theInterpolator->Interpolate(log_rand_var2, *aLogProbVector2,
                                             *aLogSecondEnergyVector2, "Lin");
      dE      = std::exp(theInterpolator->LinearInterpolation(
        aLogPrimEnergy, aLogPrimEnergy1, aLogPrimEnergy2, log_dE1, log_dE2));
    }
 
    Esec = aPrimEnergy + dE;
    Esec = std::max(Esec, Emin);
    Esec = std::min(Esec, Emax);
  }
  else
  {  // Tcut condition is already full-filled
 
    log_E1 = theInterpolator->Interpolate(log_rand_var, *aLogProbVector1,
                                          *aLogSecondEnergyVector1, "Lin");
    log_E2 = theInterpolator->Interpolate(log_rand_var, *aLogProbVector2,
                                          *aLogSecondEnergyVector2, "Lin");
 
    Esec = std::exp(theInterpolator->LinearInterpolation(
      aLogPrimEnergy, aLogPrimEnergy1, aLogPrimEnergy2, log_E1, log_E2));
    Emin = GetSecondAdjEnergyMinForProdToProj(aPrimEnergy);
    Emax = GetSecondAdjEnergyMaxForProdToProj(aPrimEnergy);
    Esec = std::max(Esec, Emin);
    Esec = std::min(Esec, Emax);
  }
  return Esec;
}

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(), SampleSecondaries(), G4AdjointComptonModel::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.

{
  // here we try to use the rejection method
  constexpr G4int iimax = 1000;
  G4double E            = 0.;
  G4double x, xmin, greject;
  if(isScatProjToProj)
  {
    G4double Emax = GetSecondAdjEnergyMaxForScatProjToProj(prim_energy);
    G4double Emin = prim_energy + fTcutSecond;
    xmin          = Emin / Emax;
    G4double grejmax =
      DiffCrossSectionPerAtomPrimToScatPrim(Emin, prim_energy, 1) * prim_energy;
 
    G4int ii = 0;
    do
    {
      // q = G4UniformRand();
      x = 1. / (G4UniformRand() * (1. / xmin - 1.) + 1.);
      E = x * Emax;
      greject =
        DiffCrossSectionPerAtomPrimToScatPrim(E, prim_energy, 1) * prim_energy;
      ++ii;
      if(ii >= iimax)
      {
        break;
      }
    }
    // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
    while(greject < G4UniformRand() * grejmax);
  }
  else
  {
    G4double Emax = GetSecondAdjEnergyMaxForProdToProj(prim_energy);
    G4double Emin = GetSecondAdjEnergyMinForProdToProj(prim_energy);
    xmin          = Emin / Emax;
    G4double grejmax =
      DiffCrossSectionPerAtomPrimToSecond(Emin, prim_energy, 1);
    G4int ii = 0;
    do
    {
      x       = std::pow(xmin, G4UniformRand());
      E       = x * Emax;
      greject = DiffCrossSectionPerAtomPrimToSecond(E, prim_energy, 1);
      ++ii;
      if(ii >= iimax)
      {
        break;
      }
    }
    // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
    while(greject < G4UniformRand() * grejmax);
  }
 
  return E;
}

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

SampleSecondaries()

void G4AdjointBremsstrahlungModel::SampleSecondaries ( const G4Track &  aTrack, G4bool  isScatProjToProj, G4ParticleChange *  fParticleChange  )

overridevirtual

Implements G4VEmAdjointModel.

Definition at line 86 of file G4AdjointBremsstrahlungModel.cc.

{
  if(!fUseMatrix)
    return RapidSampleSecondaries(aTrack, isScatProjToProj, fParticleChange);
 
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
  DefineCurrentMaterial(aTrack.GetMaterialCutsCouple());
 
  G4double adjointPrimKinEnergy   = theAdjointPrimary->GetKineticEnergy();
  G4double adjointPrimTotalEnergy = theAdjointPrimary->GetTotalEnergy();
 
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  G4double projectileKinEnergy =
    SampleAdjSecEnergyFromCSMatrix(adjointPrimKinEnergy, isScatProjToProj);
 
  // Weight correction
  CorrectPostStepWeight(fParticleChange, aTrack.GetWeight(),
                        adjointPrimKinEnergy, projectileKinEnergy,
                        isScatProjToProj);
 
  // Kinematic
  G4double projectileM0          = fAdjEquivDirectPrimPart->GetPDGMass();
  G4double projectileTotalEnergy = projectileM0 + projectileKinEnergy;
  G4double projectileP2 =
    projectileTotalEnergy * projectileTotalEnergy - projectileM0 * projectileM0;
  G4double projectileP = std::sqrt(projectileP2);
 
  // Angle of the gamma direction with the projectile taken from
  // G4eBremsstrahlungModel
  G4double u;
  if(0.25 > G4UniformRand())
    u = -std::log(G4UniformRand() * G4UniformRand()) / 0.625;
  else
    u = -std::log(G4UniformRand() * G4UniformRand()) / 1.875;
 
  G4double theta = u * electron_mass_c2 / projectileTotalEnergy;
  G4double sint  = std::sin(theta);
  G4double cost  = std::cos(theta);
 
  G4double phi = twopi * G4UniformRand();
 
  G4ThreeVector projectileMomentum =
    G4ThreeVector(std::cos(phi) * sint, std::sin(phi) * sint, cost) *
    projectileP;  // gamma frame
  if(isScatProjToProj)
  {  // the adjoint primary is the scattered e-
    G4ThreeVector gammaMomentum =
      (projectileTotalEnergy - adjointPrimTotalEnergy) *
      G4ThreeVector(0., 0., 1.);
    G4ThreeVector dirProd = projectileMomentum - gammaMomentum;
    G4double cost1        = std::cos(dirProd.angle(projectileMomentum));
    G4double sint1        = std::sqrt(1. - cost1 * cost1);
    projectileMomentum =
      G4ThreeVector(std::cos(phi) * sint1, std::sin(phi) * sint1, cost1) *
      projectileP;
  }
 
  projectileMomentum.rotateUz(theAdjointPrimary->GetMomentumDirection());
 
  if(!isScatProjToProj)
  {  // kill the primary and add a secondary
    fParticleChange->ProposeTrackStatus(fStopAndKill);
    fParticleChange->AddSecondary(
      new G4DynamicParticle(fAdjEquivDirectPrimPart, projectileMomentum));
  }
  else
  {
    fParticleChange->ProposeEnergy(projectileKinEnergy);
    fParticleChange->ProposeMomentumDirection(projectileMomentum.unit());
  }
}

References G4ParticleChange::AddSecondary(), CLHEP::Hep3Vector::angle(), G4VEmAdjointModel::CorrectPostStepWeight(), G4VEmAdjointModel::DefineCurrentMaterial(), source.hepunit::electron_mass_c2, G4VEmAdjointModel::fAdjEquivDirectPrimPart, fStopAndKill, G4VEmAdjointModel::fUseMatrix, G4UniformRand, G4Track::GetDynamicParticle(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGMass(), G4DynamicParticle::GetTotalEnergy(), 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.

{
  fCSMatrixUsed = 0;
  if(!fUseMatrixPerElement)
    fCSMatrixUsed = fCurrentMaterial->GetIndex();
  else if(!fOneMatrixForAllElements)
  {  // Select Material
    std::vector<G4double>* CS_Vs_Element = &fElementCSScatProjToProj;
    fLastCS                              = fLastAdjointCSForScatProjToProj;
    if(!isScatProjToProj)
    {
      CS_Vs_Element = &fElementCSProdToProj;
      fLastCS       = fLastAdjointCSForProdToProj;
    }
    G4double SumCS = 0.;
    size_t ind     = 0;
    for(size_t i = 0; i < CS_Vs_Element->size(); ++i)
    {
      SumCS += (*CS_Vs_Element)[i];
      if(G4UniformRand() <= SumCS / fLastCS)
      {
        ind = i;
        break;
      }
    }
    fCSMatrixUsed = fCurrentMaterial->GetElement(ind)->GetIndex();
  }
}

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

Definition at line 215 of file G4VEmAdjointModel.hh.

  {
    fOutsideWeightFactor = factor;
  }

References G4VEmAdjointModel::fOutsideWeightFactor.

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

SetAdjointEquivalentOfDirectPrimaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition ( G4ParticleDefinition *  aPart )

inherited

Definition at line 729 of file G4VEmAdjointModel.cc.

{
  fAdjEquivDirectPrimPart = aPart;
  if(fAdjEquivDirectPrimPart->GetParticleName() == "adj_e-")
    fDirectPrimaryPart = G4Electron::Electron();
  else if(fAdjEquivDirectPrimPart->GetParticleName() == "adj_gamma")
    fDirectPrimaryPart = G4Gamma::Gamma();
}

References G4Electron::Electron(), G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fDirectPrimaryPart, G4Gamma::Gamma(), and G4ParticleDefinition::GetParticleName().

SetAdjointEquivalentOfDirectSecondaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectSecondaryParticleDefinition ( G4ParticleDefinition *  aPart )

inlineinherited

Definition at line 165 of file G4VEmAdjointModel.hh.

  {
    fAdjEquivDirectSecondPart = aPart;
  }

References G4VEmAdjointModel::fAdjEquivDirectSecondPart.

SetApplyCutInRange()

void G4VEmAdjointModel::SetApplyCutInRange ( G4bool  aBool )

inlineinherited

Definition at line 190 of file G4VEmAdjointModel.hh.

{ fApplyCutInRange = aBool; }

References G4VEmAdjointModel::fApplyCutInRange.

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

SetCorrectWeightForPostStepInModel()

void G4VEmAdjointModel::SetCorrectWeightForPostStepInModel ( G4bool  aBool )

inlineinherited

Definition at line 210 of file G4VEmAdjointModel.hh.

  {
    fInModelWeightCorr = aBool;
  }

References G4VEmAdjointModel::fInModelWeightCorr.

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

SetCSBiasingFactor()

virtual void G4VEmAdjointModel::SetCSBiasingFactor ( G4double  aVal )

inlinevirtualinherited

Definition at line 205 of file G4VEmAdjointModel.hh.

  {
    fCsBiasingFactor = aVal;
  }

References G4VEmAdjointModel::fCsBiasingFactor.

SetCSMatrices()

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

inlineinherited

Definition at line 133 of file G4VEmAdjointModel.hh.

  {
    fCSMatrixProdToProjBackScat = Vec1CSMatrix;
    fCSMatrixProjToProjBackScat = Vec2CSMatrix;
  };

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

SetHighEnergyLimit()

void G4VEmAdjointModel::SetHighEnergyLimit ( G4double  aVal )

inherited

Definition at line 713 of file G4VEmAdjointModel.cc.

{
  fHighEnergyLimit = aVal;
  if(fDirectModel)
    fDirectModel->SetHighEnergyLimit(aVal);
}

References G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fHighEnergyLimit, and G4VEmModel::SetHighEnergyLimit().

SetLowEnergyLimit()

void G4VEmAdjointModel::SetLowEnergyLimit ( G4double  aVal )

inherited

Definition at line 721 of file G4VEmAdjointModel.cc.

{
  fLowEnergyLimit = aVal;
  if(fDirectModel)
    fDirectModel->SetLowEnergyLimit(aVal);
}

References G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fLowEnergyLimit, and G4VEmModel::SetLowEnergyLimit().

SetSecondPartOfSameType()

void G4VEmAdjointModel::SetSecondPartOfSameType ( G4bool  aBool )

inlineinherited

Definition at line 171 of file G4VEmAdjointModel.hh.

  {
    fSecondPartSameType = aBool;
  }

References G4VEmAdjointModel::fSecondPartSameType.

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

SetUseMatrix()

void G4VEmAdjointModel::SetUseMatrix ( G4bool  aBool )

inlineinherited

Definition at line 178 of file G4VEmAdjointModel.hh.

{ fUseMatrix = aBool; }

References G4VEmAdjointModel::fUseMatrix.

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

SetUseMatrixPerElement()

void G4VEmAdjointModel::SetUseMatrixPerElement ( G4bool  aBool )

inlineinherited

Definition at line 180 of file G4VEmAdjointModel.hh.

  {
    fUseMatrixPerElement = aBool;
  }

References G4VEmAdjointModel::fUseMatrixPerElement.

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

SetUseOnlyOneMatrixForAllElements()

void G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements ( G4bool  aBool )

inlineinherited

Definition at line 185 of file G4VEmAdjointModel.hh.

  {
    fOneMatrixForAllElements = aBool;
  }

References G4VEmAdjointModel::fOneMatrixForAllElements.

Referenced by G4AdjointComptonModel::G4AdjointComptonModel().

Field Documentation

fAdjEquivDirectPrimPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectPrimPart = nullptr

protectedinherited

Definition at line 259 of file G4VEmAdjointModel.hh.

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

fAdjEquivDirectSecondPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectSecondPart = nullptr

protectedinherited

Definition at line 260 of file G4VEmAdjointModel.hh.

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

fApplyCutInRange

G4bool G4VEmAdjointModel::fApplyCutInRange = true

protectedinherited

Definition at line 304 of file G4VEmAdjointModel.hh.

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

fASelectedNucleus

G4int G4VEmAdjointModel::fASelectedNucleus = 0

protectedinherited

Definition at line 295 of file G4VEmAdjointModel.hh.

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

fCsBiasingFactor

G4double G4VEmAdjointModel::fCsBiasingFactor = 1.

protectedinherited

Definition at line 287 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4VEmAdjointModel::CorrectPostStepWeight(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4VEmAdjointModel::DiffCrossSectionFunction1(), G4VEmAdjointModel::DiffCrossSectionFunction2(), RapidSampleSecondaries(), and G4VEmAdjointModel::SetCSBiasingFactor().

fCSManager

G4AdjointCSManager* G4AdjointBremsstrahlungModel::fCSManager

private

Definition at line 86 of file G4AdjointBremsstrahlungModel.hh.

Referenced by Initialize(), and RapidSampleSecondaries().

fCSMatrixProdToProjBackScat

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

protectedinherited

Definition at line 264 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::SetCSMatrices(), and G4VEmAdjointModel::~G4VEmAdjointModel().

fCSMatrixProjToProjBackScat

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

protectedinherited

Definition at line 265 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::SetCSMatrices(), and G4VEmAdjointModel::~G4VEmAdjointModel().

fCSMatrixUsed

size_t G4VEmAdjointModel::fCSMatrixUsed = 0

protectedinherited

Definition at line 298 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), and G4VEmAdjointModel::SelectCSMatrix().

fCurrentCouple

G4MaterialCutsCouple* G4VEmAdjointModel::fCurrentCouple = nullptr

protectedinherited

Definition at line 256 of file G4VEmAdjointModel.hh.

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

fCurrentMaterial

G4Material* G4VEmAdjointModel::fCurrentMaterial = nullptr

protectedinherited

Definition at line 255 of file G4VEmAdjointModel.hh.

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

fDirectModel

G4VEmModel* G4VEmAdjointModel::fDirectModel = nullptr

protectedinherited

Definition at line 250 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4AdjointPhotoElectricModel::AdjointCrossSectionPerAtom(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointPhotoElectricModel::DefineCurrentMaterialAndElectronEnergy(), G4VEmAdjointModel::DefineDirectEMModel(), G4AdjointComptonModel::DiffCrossSectionPerAtomPrimToScatPrim(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), Initialize(), RapidSampleSecondaries(), G4VEmAdjointModel::SetHighEnergyLimit(), and G4VEmAdjointModel::SetLowEnergyLimit().

fDirectPrimaryPart

G4ParticleDefinition* G4VEmAdjointModel::fDirectPrimaryPart = nullptr

protectedinherited

Definition at line 261 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4AdjointhIonisationModel::DefineProjectileProperty(), G4AdjointIonIonisationModel::DefineProjectileProperty(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), Initialize(), G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition(), and G4AdjointIonIonisationModel::SetIon().

fElectron

G4ParticleDefinition* G4AdjointBremsstrahlungModel::fElectron

private

Definition at line 87 of file G4AdjointBremsstrahlungModel.hh.

Referenced by AdjointCrossSection(), DiffCrossSectionPerVolumePrimToSecond(), Initialize(), and RapidSampleSecondaries().

fElementCSProdToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSProdToProj

protectedinherited

Definition at line 268 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::AdjointCrossSection(), and G4VEmAdjointModel::SelectCSMatrix().

fElementCSScatProjToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSScatProjToProj

protectedinherited

Definition at line 267 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::AdjointCrossSection(), and G4VEmAdjointModel::SelectCSMatrix().

fEmModelManagerForFwdModels

G4EmModelManager* G4AdjointBremsstrahlungModel::fEmModelManagerForFwdModels

private

Definition at line 85 of file G4AdjointBremsstrahlungModel.hh.

Referenced by AdjointCrossSection(), DiffCrossSectionPerVolumePrimToSecond(), Initialize(), and ~G4AdjointBremsstrahlungModel().

fGamma

G4ParticleDefinition* G4AdjointBremsstrahlungModel::fGamma

private

Definition at line 88 of file G4AdjointBremsstrahlungModel.hh.

Referenced by AdjointCrossSection(), DiffCrossSectionPerVolumePrimToSecond(), and Initialize().

fHighEnergyLimit

G4double G4VEmAdjointModel::fHighEnergyLimit = 0.

protectedinherited

Definition at line 283 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::GetHighEnergyLimit(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj(), and G4VEmAdjointModel::SetHighEnergyLimit().

fInModelWeightCorr

G4bool G4VEmAdjointModel::fInModelWeightCorr

protectedinherited

Initial value:

=
    false

Definition at line 301 of file G4VEmAdjointModel.hh.

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

fIsDirectModelInitialised

G4bool G4AdjointBremsstrahlungModel::fIsDirectModelInitialised = false

private

Definition at line 92 of file G4AdjointBremsstrahlungModel.hh.

Referenced by AdjointCrossSection(), and DiffCrossSectionPerVolumePrimToSecond().

fKinEnergyProdForIntegration

G4double G4VEmAdjointModel::fKinEnergyProdForIntegration = 0.

protectedinherited

Definition at line 270 of file G4VEmAdjointModel.hh.

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

fKinEnergyScatProjForIntegration

G4double G4VEmAdjointModel::fKinEnergyScatProjForIntegration = 0.

protectedinherited

Definition at line 271 of file G4VEmAdjointModel.hh.

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

fLastAdjointCSForProdToProj

G4double G4VEmAdjointModel::fLastAdjointCSForProdToProj = 0.

protectedinherited

Definition at line 275 of file G4VEmAdjointModel.hh.

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

fLastAdjointCSForScatProjToProj

G4double G4VEmAdjointModel::fLastAdjointCSForScatProjToProj = 0.

protectedinherited

Definition at line 274 of file G4VEmAdjointModel.hh.

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

fLastCS

G4double G4VEmAdjointModel::fLastCS = 0.

protectedinherited

Definition at line 273 of file G4VEmAdjointModel.hh.

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

fLastCZ

G4double G4AdjointBremsstrahlungModel::fLastCZ = 0.

private

Definition at line 90 of file G4AdjointBremsstrahlungModel.hh.

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

fLowEnergyLimit

G4double G4VEmAdjointModel::fLowEnergyLimit = 0.

protectedinherited

Definition at line 284 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::GetLowEnergyLimit(), and G4VEmAdjointModel::SetLowEnergyLimit().

fName

const G4String G4VEmAdjointModel::fName

protectedinherited

Definition at line 252 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::GetName().

fOneMatrixForAllElements

G4bool G4VEmAdjointModel::fOneMatrixForAllElements = false

protectedinherited

Definition at line 309 of file G4VEmAdjointModel.hh.

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

fOutsideWeightFactor

G4double G4VEmAdjointModel::fOutsideWeightFactor = 1.

protectedinherited

Definition at line 292 of file G4VEmAdjointModel.hh.

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

fPreStepEnergy

G4double G4VEmAdjointModel::fPreStepEnergy = 0.

protectedinherited

Definition at line 277 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::AdjointCrossSection(), and G4VEmAdjointModel::CorrectPostStepWeight().

fSecondPartSameType

G4bool G4VEmAdjointModel::fSecondPartSameType = false

protectedinherited

Definition at line 300 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondPartOfSameType(), Initialize(), G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), and G4VEmAdjointModel::SetSecondPartOfSameType().

fSelectedMaterial

G4Material* G4VEmAdjointModel::fSelectedMaterial = nullptr

protectedinherited

Definition at line 254 of file G4VEmAdjointModel.hh.

Referenced by G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4VEmAdjointModel::DiffCrossSectionFunction1(), and G4VEmAdjointModel::DiffCrossSectionFunction2().

fTcutPrim

G4double G4VEmAdjointModel::fTcutPrim = 0.

protectedinherited

Definition at line 279 of file G4VEmAdjointModel.hh.

fTcutSecond

G4double G4VEmAdjointModel::fTcutSecond = 0.

protectedinherited

Definition at line 280 of file G4VEmAdjointModel.hh.

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

fUseMatrix

G4bool G4VEmAdjointModel::fUseMatrix = false

protectedinherited

Definition at line 307 of file G4VEmAdjointModel.hh.

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

fUseMatrixPerElement

G4bool G4VEmAdjointModel::fUseMatrixPerElement = false

protectedinherited

Definition at line 308 of file G4VEmAdjointModel.hh.

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

fZSelectedNucleus

G4int G4VEmAdjointModel::fZSelectedNucleus = 0

protectedinherited

Definition at line 296 of file G4VEmAdjointModel.hh.

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

---

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

• source/processes/electromagnetic/adjoint/include/G4AdjointBremsstrahlungModel.hh
• source/processes/electromagnetic/adjoint/src/G4AdjointBremsstrahlungModel.cc