#include <G4AdjointhIonisationModel.hh>

Inheritance diagram for G4AdjointhIonisationModel:

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.)

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

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

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

	G4AdjointhIonisationModel (G4AdjointhIonisationModel &)=delete

	G4AdjointhIonisationModel (G4ParticleDefinition *pDef)

G4ParticleDefinition *	GetAdjointEquivalentOfDirectPrimaryParticleDefinition ()

G4ParticleDefinition *	GetAdjointEquivalentOfDirectSecondaryParticleDefinition ()

G4bool	GetApplyCutInRange ()

G4double	GetHighEnergyLimit ()

G4double	GetLowEnergyLimit ()

G4String	GetName ()

G4double	GetSecondAdjEnergyMaxForProdToProj (G4double primAdjEnergy) override

G4double	GetSecondAdjEnergyMaxForScatProjToProj (G4double primAdjEnergy) override

G4double	GetSecondAdjEnergyMinForProdToProj (G4double primAdjEnergy) override

G4double	GetSecondAdjEnergyMinForScatProjToProj (G4double primAdjEnergy, G4double tcut=0.) override

G4bool	GetSecondPartOfSameType ()

G4bool	GetUseMatrix ()

G4bool	GetUseMatrixPerElement ()

G4bool	GetUseOnlyOneMatrixForAllElements ()

G4AdjointhIonisationModel &	operator= (const G4AdjointhIonisationModel &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)

	~G4AdjointhIonisationModel () 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.

G4AdjointCSManager *	fCSManager

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	DefineProjectileProperty ()

Private Attributes
G4VEmModel *	fBraggDirectEMModel

G4double	fFormFact = 0.

G4double	fMagMoment2 = 0.

G4double	fMass = 0.

G4double	fMassRatio = 0.

G4double	fOneMinusRatio2 = 0.

G4double	fOnePlusRatio2 = 0.

G4double	fSpin = 0.

Detailed Description

Definition at line 47 of file G4AdjointhIonisationModel.hh.

Constructor & Destructor Documentation

◆ G4AdjointhIonisationModel() [1/2]

G4AdjointhIonisationModel::G4AdjointhIonisationModel ( G4ParticleDefinition * pDef )

explicit

Definition at line 42 of file G4AdjointhIonisationModel.cc.

  : G4VEmAdjointModel("Adjoint_hIonisation")
{
  fUseMatrix               = true;
  fUseMatrixPerElement     = true;
  fApplyCutInRange         = true;
  fOneMatrixForAllElements = true;
  fSecondPartSameType      = false;
 
  // The direct EM Model is taken as BetheBloch. It is only used for the
  // computation of the differential cross section.
  // The Bragg model could be used as an alternative as it offers the same
  // differential cross section
 
  fDirectModel              = new G4BetheBlochModel(pDef);
  fBraggDirectEMModel       = new G4BraggModel(pDef);
  fAdjEquivDirectSecondPart = G4AdjointElectron::AdjointElectron();
  fDirectPrimaryPart        = pDef;
 
  if(pDef == G4Proton::Proton())
  {
    fAdjEquivDirectPrimPart = G4AdjointProton::AdjointProton();
  }
 
  DefineProjectileProperty();
}

◆ ~G4AdjointhIonisationModel()

G4AdjointhIonisationModel::~G4AdjointhIonisationModel ( )

override

Definition at line 70 of file G4AdjointhIonisationModel.cc.

70{}

◆ G4AdjointhIonisationModel() [2/2]

G4AdjointhIonisationModel::G4AdjointhIonisationModel ( G4AdjointhIonisationModel & )

delete

Member Function Documentation

◆ AdjointCrossSection()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 397 of file G4AdjointhIonisationModel.cc.

{
  if(fUseMatrix)
    return G4VEmAdjointModel::AdjointCrossSection(aCouple, primEnergy,
                                                  isScatProjToProj);
  DefineCurrentMaterial(aCouple);
 
  G4double Cross =
    fCurrentMaterial->GetElectronDensity() * twopi_mc2_rcl2 * fMass;
 
  if(!isScatProjToProj)
  {
    G4double Emax_proj = GetSecondAdjEnergyMaxForProdToProj(primEnergy);
    G4double Emin_proj = GetSecondAdjEnergyMinForProdToProj(primEnergy);
    if(Emax_proj > Emin_proj && primEnergy > fTcutSecond)
    {
      Cross *= (1. / Emin_proj - 1. / Emax_proj) / primEnergy;
    }
    else
      Cross = 0.;
  }
  else
  {
    G4double Emax_proj = GetSecondAdjEnergyMaxForScatProjToProj(primEnergy);
    G4double Emin_proj =
      GetSecondAdjEnergyMinForScatProjToProj(primEnergy, fTcutSecond);
    G4double diff1 = Emin_proj - primEnergy;
    G4double diff2 = Emax_proj - primEnergy;
    G4double t1 =
      (1. / diff1 + 1. / Emin_proj - 1. / diff2 - 1. / Emax_proj) / primEnergy;
    G4double t2 =
      2. * std::log(Emax_proj / Emin_proj) / primEnergy / primEnergy;
    Cross *= (t1 + t2);
  }
  fLastCS = Cross;
  return Cross;
}

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

◆ ComputeAdjointCrossSectionVectorPerAtomForScatProj()

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

inherited

Definition at line 252 of file G4VEmAdjointModel.cc.

{
  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);
}

Referenced by G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and 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(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), RapidSampleSecondaries(), and G4AdjointBremsstrahlungModel::SampleSecondaries().

◆ DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel * aModel )

inlineinherited

Definition at line 160 of file G4VEmAdjointModel.hh.

160{ fDirectModel = aModel; }

References G4VEmAdjointModel::fDirectModel.

◆ DefineProjectileProperty()

void G4AdjointhIonisationModel::DefineProjectileProperty ( )

private

Definition at line 367 of file G4AdjointhIonisationModel.cc.

{
  // Slightly modified code taken from G4BetheBlochModel::SetParticle
  G4String pname = fDirectPrimaryPart->GetParticleName();
 
  fMass           = fDirectPrimaryPart->GetPDGMass();
  fSpin           = fDirectPrimaryPart->GetPDGSpin();
  fMassRatio      = electron_mass_c2 / fMass;
  fOnePlusRatio2  = (1. + fMassRatio) * (1. + fMassRatio);
  fOneMinusRatio2 = (1. - fMassRatio) * (1. - fMassRatio);
  G4double magmom = fDirectPrimaryPart->GetPDGMagneticMoment() * fMass /
                    (0.5 * eplus * hbar_Planck * c_squared);
  fMagMoment2 = magmom * magmom - 1.0;
  fFormFact   = 0.0;
  if(fDirectPrimaryPart->GetLeptonNumber() == 0)
  {
    G4double x = 0.8426 * GeV;
    if(fSpin == 0.0 && fMass < GeV)
    {
      x = 0.736 * GeV;
    }
    else if(fMass > GeV)
    {
      x /= G4NistManager::Instance()->GetZ13(fMass / proton_mass_c2);
    }
    fFormFact = 2.0 * electron_mass_c2 / (x * x);
  }
}

References source.hepunit::c_squared, source.hepunit::electron_mass_c2, eplus, G4VEmAdjointModel::fDirectPrimaryPart, fFormFact, fMagMoment2, fMass, fMassRatio, fOneMinusRatio2, fOnePlusRatio2, fSpin, G4ParticleDefinition::GetLeptonNumber(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGMagneticMoment(), G4ParticleDefinition::GetPDGMass(), G4ParticleDefinition::GetPDGSpin(), G4NistManager::GetZ13(), GeV, source.hepunit::hbar_Planck, G4NistManager::Instance(), eplot::pname, and source.hepunit::proton_mass_c2.

Referenced by G4AdjointhIonisationModel().

◆ 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 G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond	(	G4double	kinEnergyProj,
		G4double	kinEnergyProd,
		G4double	Z,
		G4double	A = `0.`
	)

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 280 of file G4AdjointhIonisationModel.cc.

{  // Probably here the Bragg Model should be also used for
   // kinEnergyProj/nuc < 2 MeV
 
  G4double dSigmadEprod = 0.;
  G4double Emax_proj    = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
  G4double Emin_proj    = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
 
  // the produced particle should have a kinetic energy smaller than the
  // projectile
  if(kinEnergyProj > Emin_proj && kinEnergyProj <= Emax_proj)
  {
    G4double Tmax = kinEnergyProj;
    G4double E1   = kinEnergyProd;
    //1.0006 factor seems to give the best diff CS, important impact on proton correction factor
    G4double E2   = kinEnergyProd *1.0006;
    G4double sigma1, sigma2;
    if(kinEnergyProj > 2. * MeV)
    {
      sigma1 = fDirectModel->ComputeCrossSectionPerAtom(
        fDirectPrimaryPart, kinEnergyProj, Z, A, E1, 1.e20);
      sigma2 = fDirectModel->ComputeCrossSectionPerAtom(
        fDirectPrimaryPart, kinEnergyProj, Z, A, E2, 1.e20);
    }
    else
    {
      sigma1 = fBraggDirectEMModel->ComputeCrossSectionPerAtom(
        fDirectPrimaryPart, kinEnergyProj, Z, A, E1, 1.e20);
      sigma2 = fBraggDirectEMModel->ComputeCrossSectionPerAtom(
        fDirectPrimaryPart, kinEnergyProj, Z, A, E2, 1.e20);
    }
 
    dSigmadEprod = (sigma1 - sigma2) / (E2 - E1);
    if(dSigmadEprod > 1.)
    {
      G4cout << "sigma1 " << kinEnergyProj / MeV << '\t' << kinEnergyProd / MeV
             << '\t' << sigma1 << G4endl;
      G4cout << "sigma2 " << kinEnergyProj / MeV << '\t' << kinEnergyProd / MeV
             << '\t' << sigma2 << G4endl;
      G4cout << "dsigma " << kinEnergyProj / MeV << '\t' << kinEnergyProd / MeV
             << '\t' << dSigmadEprod << G4endl;
    }
 
    // correction of differential cross section at high energy to correct for
    // the suppression of particle at secondary at high energy used in the Bethe
    // Bloch Model. This correction consists of multiplying by g the probability
    // function used to test the rejection of a secondary. Source code taken
    // from G4BetheBlochModel::SampleSecondaries
    G4double deltaKinEnergy = kinEnergyProd;
 
    // projectile formfactor - suppression of high energy
    // delta-electron production at high energy
    G4double x = fFormFact * deltaKinEnergy;
    if(x > 1.e-6)
    {
      G4double totEnergy = kinEnergyProj + fMass;
      G4double etot2     = totEnergy * totEnergy;
      G4double beta2 = kinEnergyProj * (kinEnergyProj + 2.0 * fMass) / etot2;
      G4double f     = 1.0 - beta2 * deltaKinEnergy / Tmax;
      G4double f1    = 0.0;
      if(0.5 == fSpin)
      {
        f1 = 0.5 * deltaKinEnergy * deltaKinEnergy / etot2;
        f += f1;
      }
      G4double x1 = 1.0 + x;
      G4double gg = 1.0 / (x1 * x1);
      if(0.5 == fSpin)
      {
        G4double x2 = 0.5 * electron_mass_c2 * deltaKinEnergy / (fMass * fMass);
        gg *= (1.0 + fMagMoment2 * (x2 - f1 / f) / (1.0 + x2));
      }
      if(gg > 1.0)
      {
        G4cout << "### G4BetheBlochModel in Adjoint Sim WARNING: g= " << g
               << G4endl;
        gg = 1.;
      }
      dSigmadEprod *= gg;
    }
  }
 
  return dSigmadEprod;
}

References A, G4VEmModel::ComputeCrossSectionPerAtom(), source.hepunit::electron_mass_c2, fBraggDirectEMModel, G4VEmAdjointModel::fDirectModel, G4VEmAdjointModel::fDirectPrimaryPart, fFormFact, fMagMoment2, fMass, fSpin, g, G4cout, G4endl, GetSecondAdjEnergyMaxForProdToProj(), GetSecondAdjEnergyMinForProdToProj(), MeV, and Z.

Referenced by RapidSampleSecondaries().

◆ 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 G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond	(	const G4Material *	aMaterial,
		G4double	kinEnergyProj,
		G4double	kinEnergyProd
	)

virtualinherited

Reimplemented in G4AdjointBremsstrahlungModel.

Definition at line 119 of file G4VEmAdjointModel.cc.

{
  G4double dSigmadEprod = 0.;
  G4double Emax_proj    = GetSecondAdjEnergyMaxForProdToProj(kinEnergyProd);
  G4double Emin_proj    = GetSecondAdjEnergyMinForProdToProj(kinEnergyProd);
 
  if(kinEnergyProj > Emin_proj && kinEnergyProj <= Emax_proj)
  {
    G4double E1     = kinEnergyProd;
    G4double E2     = kinEnergyProd * 1.0001;
    G4double sigma1 = fDirectModel->CrossSectionPerVolume(
      aMaterial, fDirectPrimaryPart, kinEnergyProj, E1, 1.e20);
    G4double sigma2 = fDirectModel->CrossSectionPerVolume(
      aMaterial, fDirectPrimaryPart, kinEnergyProj, E2, 1.e20);
    dSigmadEprod = (sigma1 - sigma2) / (E2 - E1);
  }
  return dSigmadEprod;
}

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

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

◆ GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( )

inlineinherited

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.

201{ 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.

152{ return fHighEnergyLimit; }

G4VEmAdjointModel::fHighEnergyLimit

G4double fHighEnergyLimit

Definition: G4VEmAdjointModel.hh:283

References G4VEmAdjointModel::fHighEnergyLimit.

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

◆ GetLowEnergyLimit()

G4double G4VEmAdjointModel::GetLowEnergyLimit ( )

inlineinherited

Definition at line 154 of file G4VEmAdjointModel.hh.

154{ return fLowEnergyLimit; }

G4VEmAdjointModel::fLowEnergyLimit

G4double fLowEnergyLimit

Definition: G4VEmAdjointModel.hh:284

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.

203{ return fName; }

G4VEmAdjointModel::fName

const G4String fName

Definition: G4VEmAdjointModel.hh:252

References G4VEmAdjointModel::fName.

◆ GetSecondAdjEnergyMaxForProdToProj()

G4double G4AdjointhIonisationModel::GetSecondAdjEnergyMaxForProdToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 454 of file G4AdjointhIonisationModel.cc.

{
  return GetHighEnergyLimit();
}

References G4VEmAdjointModel::GetHighEnergyLimit().

Referenced by AdjointCrossSection(), DiffCrossSectionPerAtomPrimToSecond(), and RapidSampleSecondaries().

◆ GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4AdjointhIonisationModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 438 of file G4AdjointhIonisationModel.cc.

{
  G4double Tmax = primAdjEnergy * fOnePlusRatio2 /
                  (fOneMinusRatio2 - 2. * fMassRatio * primAdjEnergy / fMass);
  return Tmax;
}

References fMass, fMassRatio, fOneMinusRatio2, and fOnePlusRatio2.

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

◆ GetSecondAdjEnergyMinForProdToProj()

G4double G4AdjointhIonisationModel::GetSecondAdjEnergyMinForProdToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 460 of file G4AdjointhIonisationModel.cc.

{
  G4double Tmin =
    (2. * primAdjEnergy - 4. * fMass +
     std::sqrt(4. * primAdjEnergy * primAdjEnergy + 16. * fMass * fMass +
               8. * primAdjEnergy * fMass * (1. / fMassRatio + fMassRatio))) /
    4.;
  return Tmin;
}

References fMass, and fMassRatio.

Referenced by AdjointCrossSection(), DiffCrossSectionPerAtomPrimToSecond(), and RapidSampleSecondaries().

◆ GetSecondAdjEnergyMinForScatProjToProj()

G4double G4AdjointhIonisationModel::GetSecondAdjEnergyMinForScatProjToProj	(	G4double	primAdjEnergy,
		G4double	tcut = `0.`
	)

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 447 of file G4AdjointhIonisationModel.cc.

{
  return primAdjEnergy + tcut;
}

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

◆ GetSecondPartOfSameType()

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( )

inlineinherited

Definition at line 176 of file G4VEmAdjointModel.hh.

176{ 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.

192{ return fUseMatrix; }

References G4VEmAdjointModel::fUseMatrix.

Referenced by G4AdjointCSManager::ComputeAdjointCS().

◆ GetUseMatrixPerElement()

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( )

inlineinherited

Definition at line 194 of file G4VEmAdjointModel.hh.

194{ 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().

◆ operator=()

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

delete

◆ RapidSampleSecondaries()

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

Definition at line 143 of file G4AdjointhIonisationModel.cc.

{
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
  DefineCurrentMaterial(aTrack.GetMaterialCutsCouple());
 
  G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
  G4double adjointPrimP         = theAdjointPrimary->GetTotalMomentum();
 
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  G4double projectileKinEnergy = 0.;
  G4double eEnergy             = 0.;
  G4double newCS =
    fCurrentMaterial->GetElectronDensity() * twopi_mc2_rcl2 * fMass;
  if(!isScatProjToProj)
  {  // 1/E^2 distribution
 
    eEnergy       = adjointPrimKinEnergy;
    G4double Emax = GetSecondAdjEnergyMaxForProdToProj(adjointPrimKinEnergy);
    G4double Emin = GetSecondAdjEnergyMinForProdToProj(adjointPrimKinEnergy);
    if(Emin >= Emax)
      return;
    G4double a = 1. / Emax;
    G4double b = 1. / Emin;
    newCS      = newCS * (b - a) / eEnergy;
 
    projectileKinEnergy = 1. / (b - (b - a) * G4UniformRand());
  }
  else
  {
    G4double Emax =
      GetSecondAdjEnergyMaxForScatProjToProj(adjointPrimKinEnergy);
    G4double Emin =
      GetSecondAdjEnergyMinForScatProjToProj(adjointPrimKinEnergy, fTcutSecond);
    if(Emin >= Emax)
      return;
    G4double diff1 = Emin - adjointPrimKinEnergy;
    G4double diff2 = Emax - adjointPrimKinEnergy;
 
    G4double t1    = adjointPrimKinEnergy * (1. / diff1 - 1. / diff2);
    G4double t2    = adjointPrimKinEnergy * (1. / Emin - 1. / Emax);
    G4double t3    = 2. * std::log(Emax / Emin);
    G4double sum_t = t1 + t2 + t3;
    newCS      = newCS * sum_t / adjointPrimKinEnergy / adjointPrimKinEnergy;
    G4double t = G4UniformRand() * sum_t;
    if(t <= t1)
    {
      G4double q          = G4UniformRand() * t1 / adjointPrimKinEnergy;
      projectileKinEnergy = adjointPrimKinEnergy + 1. / (1. / diff1 - q);
    }
    else if(t <= t2)
    {
      G4double q          = G4UniformRand() * t2 / adjointPrimKinEnergy;
      projectileKinEnergy = 1. / (1. / Emin - q);
    }
    else
    {
      projectileKinEnergy = Emin * std::pow(Emax / Emin, G4UniformRand());
    }
    eEnergy = projectileKinEnergy - adjointPrimKinEnergy;
  }
 
  G4double diffCS_perAtom_Used = twopi_mc2_rcl2 * fMass * adjointPrimKinEnergy /
                                 projectileKinEnergy / projectileKinEnergy /
                                 eEnergy / eEnergy;
 
  // Weight correction
  // First w_corr is set to the ratio between adjoint total CS and fwd total CS
  G4double w_corr =
    G4AdjointCSManager::GetAdjointCSManager()->GetPostStepWeightCorrection();
 
  w_corr *= newCS / fLastCS;
  // 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
 
  G4double diffCS =
    DiffCrossSectionPerAtomPrimToSecond(projectileKinEnergy, eEnergy, 1, 1);
  w_corr *= diffCS / diffCS_perAtom_Used;
 
  if (isScatProjToProj && fTcutSecond>0.005) w_corr=1.;
 
  G4double new_weight = aTrack.GetWeight() * w_corr;
  fParticleChange->SetParentWeightByProcess(false);
  fParticleChange->SetSecondaryWeightByProcess(false);
  fParticleChange->ProposeParentWeight(new_weight);
 
  // Kinematic:
  // we consider a two body elastic scattering for the forward processes where
  // the projectile knocks on an e- at rest and gives it part of its energy
  G4double projectileM0          = fAdjEquivDirectPrimPart->GetPDGMass();
  G4double projectileTotalEnergy = projectileM0 + projectileKinEnergy;
  G4double projectileP2 =
    projectileTotalEnergy * projectileTotalEnergy - projectileM0 * projectileM0;
 
  // Companion
  G4double companionM0 = fAdjEquivDirectPrimPart->GetPDGMass();
  if(isScatProjToProj)
  {
    companionM0 = fAdjEquivDirectSecondPart->GetPDGMass();
  }
  G4double companionTotalEnergy =
    companionM0 + projectileKinEnergy - adjointPrimKinEnergy;
  G4double companionP2 =
    companionTotalEnergy * companionTotalEnergy - companionM0 * companionM0;
 
  // Projectile momentum
  G4double P_parallel =
    (adjointPrimP * adjointPrimP + projectileP2 - companionP2) /
    (2. * adjointPrimP);
  G4double P_perp = std::sqrt(projectileP2 - P_parallel * P_parallel);
  G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
  G4double phi               = G4UniformRand() * twopi;
  G4ThreeVector projectileMomentum =
    G4ThreeVector(P_perp * std::cos(phi), P_perp * std::sin(phi), P_parallel);
  projectileMomentum.rotateUz(dir_parallel);
 
  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(), G4VEmAdjointModel::DefineCurrentMaterial(), DiffCrossSectionPerAtomPrimToSecond(), Emax, Emin, G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fAdjEquivDirectSecondPart, G4VEmAdjointModel::fCurrentMaterial, G4VEmAdjointModel::fLastCS, fMass, fStopAndKill, G4VEmAdjointModel::fTcutSecond, G4UniformRand, G4AdjointCSManager::GetAdjointCSManager(), G4Track::GetDynamicParticle(), G4Material::GetElectronDensity(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4Track::GetMaterialCutsCouple(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGMass(), G4AdjointCSManager::GetPostStepWeightCorrection(), GetSecondAdjEnergyMaxForProdToProj(), GetSecondAdjEnergyMaxForScatProjToProj(), GetSecondAdjEnergyMinForProdToProj(), GetSecondAdjEnergyMinForScatProjToProj(), G4DynamicParticle::GetTotalMomentum(), G4Track::GetWeight(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeParentWeight(), G4VParticleChange::ProposeTrackStatus(), CLHEP::Hep3Vector::rotateUz(), G4VParticleChange::SetParentWeightByProcess(), G4VParticleChange::SetSecondaryWeightByProcess(), twopi, source.hepunit::twopi_mc2_rcl2, and CLHEP::Hep3Vector::unit().

Referenced by SampleSecondaries().

◆ SampleAdjSecEnergyFromCSMatrix() [1/2]

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

protectedinherited

Definition at line 518 of file G4VEmAdjointModel.cc.

{
  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(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), 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 G4AdjointhIonisationModel::SampleSecondaries	(	const G4Track &	aTrack,
		G4bool	isScatProjToProj,
		G4ParticleChange *	fParticleChange
	)

overridevirtual

Implements G4VEmAdjointModel.

Definition at line 73 of file G4AdjointhIonisationModel.cc.

{
  if(!fUseMatrix)
    return RapidSampleSecondaries(aTrack, isScatProjToProj, fParticleChange);
 
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
 
  // Elastic inverse scattering
  G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
  G4double adjointPrimP         = theAdjointPrimary->GetTotalMomentum();
 
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  // Sample secondary energy
  G4double projectileKinEnergy =
    SampleAdjSecEnergyFromCSMatrix(adjointPrimKinEnergy, isScatProjToProj);
  CorrectPostStepWeight(fParticleChange, aTrack.GetWeight(),
                        adjointPrimKinEnergy, projectileKinEnergy,
                        isScatProjToProj);
  // Caution!!! this weight correction should be always applied
 
  // Kinematic:
  // we consider a two body elastic scattering for the forward processes where
  // the projectile knock on an e- at rest and gives it part of its energy
  G4double projectileM0          = fAdjEquivDirectPrimPart->GetPDGMass();
  G4double projectileTotalEnergy = projectileM0 + projectileKinEnergy;
  G4double projectileP2 =
    projectileTotalEnergy * projectileTotalEnergy - projectileM0 * projectileM0;
 
  // Companion
  G4double companionM0 = fAdjEquivDirectPrimPart->GetPDGMass();
  if(isScatProjToProj)
  {
    companionM0 = fAdjEquivDirectSecondPart->GetPDGMass();
  }
  G4double companionTotalEnergy =
    companionM0 + projectileKinEnergy - adjointPrimKinEnergy;
  G4double companionP2 =
    companionTotalEnergy * companionTotalEnergy - companionM0 * companionM0;
 
  // Projectile momentum
  G4double P_parallel =
    (adjointPrimP * adjointPrimP + projectileP2 - companionP2) /
    (2. * adjointPrimP);
  G4double P_perp = std::sqrt(projectileP2 - P_parallel * P_parallel);
  G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
  G4double phi               = G4UniformRand() * twopi;
  G4ThreeVector projectileMomentum =
    G4ThreeVector(P_perp * std::cos(phi), P_perp * std::sin(phi), P_parallel);
  projectileMomentum.rotateUz(dir_parallel);
 
  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(), G4VEmAdjointModel::CorrectPostStepWeight(), G4VEmAdjointModel::fAdjEquivDirectPrimPart, G4VEmAdjointModel::fAdjEquivDirectSecondPart, fStopAndKill, G4VEmAdjointModel::fUseMatrix, G4UniformRand, G4Track::GetDynamicParticle(), G4VEmAdjointModel::GetHighEnergyLimit(), G4DynamicParticle::GetKineticEnergy(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGMass(), G4DynamicParticle::GetTotalMomentum(), G4Track::GetWeight(), G4ParticleChange::ProposeEnergy(), G4ParticleChange::ProposeMomentumDirection(), G4VParticleChange::ProposeTrackStatus(), RapidSampleSecondaries(), CLHEP::Hep3Vector::rotateUz(), G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), twopi, and CLHEP::Hep3Vector::unit().

◆ SelectCSMatrix()

void G4VEmAdjointModel::SelectCSMatrix ( G4bool isScatProjToProj )

protectedinherited

Definition at line 527 of file G4VEmAdjointModel.cc.

{
  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.

190{ fApplyCutInRange = aBool; }

References G4VEmAdjointModel::fApplyCutInRange.

Referenced by G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), and G4AdjointBremsstrahlungModel::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.

178{ fUseMatrix = aBool; }

References G4VEmAdjointModel::fUseMatrix.

Referenced by G4AdjointComptonModel::G4AdjointComptonModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), and G4AdjointBremsstrahlungModel::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 G4AdjointBremsstrahlungModel::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(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition(), G4AdjointBremsstrahlungModel::Initialize(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), 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(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition(), G4AdjointBremsstrahlungModel::Initialize(), RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), 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(), 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().

◆ fBraggDirectEMModel

G4VEmModel* G4AdjointhIonisationModel::fBraggDirectEMModel

private

Definition at line 86 of file G4AdjointhIonisationModel.hh.

Referenced by DiffCrossSectionPerAtomPrimToSecond(), and G4AdjointhIonisationModel().

◆ fCsBiasingFactor

G4double G4VEmAdjointModel::fCsBiasingFactor = 1.

protectedinherited

Definition at line 287 of file G4VEmAdjointModel.hh.

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

◆ fCSManager

G4AdjointCSManager* G4VEmAdjointModel::fCSManager

protectedinherited

Definition at line 249 of file G4VEmAdjointModel.hh.

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

◆ 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(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), and G4AdjointComptonModel::RapidSampleSecondaries().

◆ fCurrentMaterial

G4Material* G4VEmAdjointModel::fCurrentMaterial = nullptr

protectedinherited

Definition at line 255 of file G4VEmAdjointModel.hh.

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

◆ fDirectModel

G4VEmModel* G4VEmAdjointModel::fDirectModel = nullptr

protectedinherited

Definition at line 250 of file G4VEmAdjointModel.hh.

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

◆ fDirectPrimaryPart

G4ParticleDefinition* G4VEmAdjointModel::fDirectPrimaryPart = nullptr

protectedinherited

Definition at line 261 of file G4VEmAdjointModel.hh.

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

◆ 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().

◆ fFormFact

G4double G4AdjointhIonisationModel::fFormFact = 0.

private

Definition at line 93 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), and DiffCrossSectionPerAtomPrimToSecond().

◆ 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 G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), and G4VEmAdjointModel::SetCorrectWeightForPostStepInModel().

◆ 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(), AdjointCrossSection(), G4VEmAdjointModel::CorrectPostStepWeight(), RapidSampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), and G4VEmAdjointModel::SelectCSMatrix().

◆ fLowEnergyLimit

G4double G4VEmAdjointModel::fLowEnergyLimit = 0.

protectedinherited

Definition at line 284 of file G4VEmAdjointModel.hh.

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

◆ fMagMoment2

G4double G4AdjointhIonisationModel::fMagMoment2 = 0.

private

Definition at line 91 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), and DiffCrossSectionPerAtomPrimToSecond().

◆ fMass

G4double G4AdjointhIonisationModel::fMass = 0.

private

Definition at line 89 of file G4AdjointhIonisationModel.hh.

Referenced by AdjointCrossSection(), DefineProjectileProperty(), DiffCrossSectionPerAtomPrimToSecond(), GetSecondAdjEnergyMaxForScatProjToProj(), GetSecondAdjEnergyMinForProdToProj(), and RapidSampleSecondaries().

◆ fMassRatio

G4double G4AdjointhIonisationModel::fMassRatio = 0.

private

Definition at line 92 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), GetSecondAdjEnergyMaxForScatProjToProj(), and GetSecondAdjEnergyMinForProdToProj().

◆ 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(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements(), G4VEmAdjointModel::SelectCSMatrix(), and G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements().

◆ fOneMinusRatio2

G4double G4AdjointhIonisationModel::fOneMinusRatio2 = 0.

private

Definition at line 95 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), and GetSecondAdjEnergyMaxForScatProjToProj().

◆ fOnePlusRatio2

G4double G4AdjointhIonisationModel::fOnePlusRatio2 = 0.

private

Definition at line 94 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), and GetSecondAdjEnergyMaxForScatProjToProj().

◆ fOutsideWeightFactor

G4double G4VEmAdjointModel::fOutsideWeightFactor = 1.

protectedinherited

Definition at line 292 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::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(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj(), G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj(), G4VEmAdjointModel::GetSecondPartOfSameType(), G4AdjointBremsstrahlungModel::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().

◆ fSpin

G4double G4AdjointhIonisationModel::fSpin = 0.

private

Definition at line 90 of file G4AdjointhIonisationModel.hh.

Referenced by DefineProjectileProperty(), and DiffCrossSectionPerAtomPrimToSecond().

◆ 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(), G4AdjointBremsstrahlungModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointIonIonisationModel::CorrectPostStepWeight(), G4VEmAdjointModel::DefineCurrentMaterial(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), RapidSampleSecondaries(), G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

◆ fUseMatrix

G4bool G4VEmAdjointModel::fUseMatrix = false

protectedinherited

Definition at line 307 of file G4VEmAdjointModel.hh.

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointComptonModel::AdjointCrossSection(), AdjointCrossSection(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4VEmAdjointModel::GetUseMatrix(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), 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(), 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/G4AdjointhIonisationModel.hh
source/processes/electromagnetic/adjoint/src/G4AdjointhIonisationModel.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4AdjointhIonisationModel() [1/2]

◆ ~G4AdjointhIonisationModel()

◆ G4AdjointhIonisationModel() [2/2]

Member Function Documentation

◆ AdjointCrossSection()

◆ ComputeAdjointCrossSectionVectorPerAtomForScatProj()

◆ ComputeAdjointCrossSectionVectorPerAtomForSecond()

◆ ComputeAdjointCrossSectionVectorPerVolumeForScatProj()

◆ ComputeAdjointCrossSectionVectorPerVolumeForSecond()

◆ CorrectPostStepWeight()

◆ DefineCurrentMaterial()

◆ DefineDirectEMModel()

◆ DefineProjectileProperty()

◆ DiffCrossSectionFunction1()

◆ DiffCrossSectionFunction2()

◆ DiffCrossSectionPerAtomPrimToScatPrim()

◆ DiffCrossSectionPerAtomPrimToSecond()

◆ DiffCrossSectionPerVolumePrimToScatPrim()

◆ DiffCrossSectionPerVolumePrimToSecond()

◆ GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

◆ GetAdjointEquivalentOfDirectSecondaryParticleDefinition()

◆ GetApplyCutInRange()

◆ GetHighEnergyLimit()

◆ GetLowEnergyLimit()

◆ GetName()

◆ GetSecondAdjEnergyMaxForProdToProj()

◆ GetSecondAdjEnergyMaxForScatProjToProj()

◆ GetSecondAdjEnergyMinForProdToProj()

◆ GetSecondAdjEnergyMinForScatProjToProj()

◆ GetSecondPartOfSameType()

◆ GetUseMatrix()

◆ GetUseMatrixPerElement()

◆ GetUseOnlyOneMatrixForAllElements()

◆ operator=()

◆ RapidSampleSecondaries()

◆ SampleAdjSecEnergyFromCSMatrix() [1/2]

◆ SampleAdjSecEnergyFromCSMatrix() [2/2]

◆ SampleAdjSecEnergyFromDiffCrossSectionPerAtom()

◆ SampleSecondaries()

◆ SelectCSMatrix()

◆ SetAdditionalWeightCorrectionFactorForPostStepOutsideModel()

◆ SetAdjointEquivalentOfDirectPrimaryParticleDefinition()

◆ SetAdjointEquivalentOfDirectSecondaryParticleDefinition()

◆ SetApplyCutInRange()

◆ SetCorrectWeightForPostStepInModel()

◆ SetCSBiasingFactor()

◆ SetCSMatrices()

◆ SetHighEnergyLimit()

◆ SetLowEnergyLimit()

◆ SetSecondPartOfSameType()

◆ SetUseMatrix()

◆ SetUseMatrixPerElement()

◆ SetUseOnlyOneMatrixForAllElements()

Field Documentation

◆ fAdjEquivDirectPrimPart

◆ fAdjEquivDirectSecondPart

◆ fApplyCutInRange

◆ fASelectedNucleus

◆ fBraggDirectEMModel

◆ fCsBiasingFactor

◆ fCSManager

◆ fCSMatrixProdToProjBackScat

◆ fCSMatrixProjToProjBackScat

◆ fCSMatrixUsed

◆ fCurrentCouple

◆ fCurrentMaterial

◆ fDirectModel

◆ fDirectPrimaryPart

◆ fElementCSProdToProj

◆ fElementCSScatProjToProj

◆ fFormFact

◆ fHighEnergyLimit

◆ fInModelWeightCorr