G4AdjointComptonModel Class Reference

#include <G4AdjointComptonModel.hh>

Inheritance diagram for G4AdjointComptonModel:

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

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

Protected Attributes
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 Attributes
G4double	fDirectCS = 0.
G4VEmProcess *	fDirectProcess = nullptr

Detailed Description

Definition at line 42 of file G4AdjointComptonModel.hh.

Constructor & Destructor Documentation

G4AdjointComptonModel() [1/2]

G4AdjointComptonModel::G4AdjointComptonModel

(

)

Definition at line 42 of file G4AdjointComptonModel.cc.

  : G4VEmAdjointModel("AdjointCompton")
{
  SetApplyCutInRange(false);
  SetUseMatrix(false);
  SetUseMatrixPerElement(true);
  SetUseOnlyOneMatrixForAllElements(true);
  fAdjEquivDirectPrimPart   = G4AdjointGamma::AdjointGamma();
  fAdjEquivDirectSecondPart = G4AdjointElectron::AdjointElectron();
  fDirectPrimaryPart        = G4Gamma::Gamma();
  fSecondPartSameType       = false;
  fDirectModel =
    new G4KleinNishinaCompton(G4Gamma::Gamma(), "ComptonDirectModel");
}

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

~G4AdjointComptonModel()

G4AdjointComptonModel::~G4AdjointComptonModel ( )

override

Definition at line 58 of file G4AdjointComptonModel.cc.

{}

G4AdjointComptonModel() [2/2]

G4AdjointComptonModel::G4AdjointComptonModel ( G4AdjointComptonModel &  )

delete

Member Function Documentation

AdjointCrossSection()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 325 of file G4AdjointComptonModel.cc.

{
  if(fUseMatrix)
    return G4VEmAdjointModel::AdjointCrossSection(aCouple, primEnergy,
                                                  isScatProjToProj);
  DefineCurrentMaterial(aCouple);
 
  G4float Cross     = 0.;
  G4float Emax_proj = 0.;
  G4float Emin_proj = 0.;
  if(!isScatProjToProj)
  {
    Emax_proj = GetSecondAdjEnergyMaxForProdToProj(primEnergy);
    Emin_proj = GetSecondAdjEnergyMinForProdToProj(primEnergy);
    if(Emax_proj > Emin_proj)
    {
      Cross = 0.1 *
              std::log((Emax_proj - G4float(primEnergy)) * Emin_proj /
                       Emax_proj / (Emin_proj - primEnergy)) *
              (1. + 2. * std::log(G4float(1. + electron_mass_c2 / primEnergy)));
    }
  }
  else
  {
    Emax_proj = GetSecondAdjEnergyMaxForScatProjToProj(primEnergy);
    Emin_proj = GetSecondAdjEnergyMinForScatProjToProj(primEnergy, 0.);
    if(Emax_proj > Emin_proj)
    {
      Cross = 0.1 * std::log(Emax_proj / Emin_proj);
    }
  }
 
  Cross *= fCurrentMaterial->GetElectronDensity() * twopi_mc2_rcl2;
  fLastCS = Cross;
  return double(Cross);
}

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

ComputeAdjointCrossSectionVectorPerAtomForScatProj()

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

inherited

Definition at line 252 of file G4VEmAdjointModel.cc.

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

DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel *  aModel )

inlineinherited

Definition at line 160 of file G4VEmAdjointModel.hh.

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 263 of file G4AdjointComptonModel.cc.

{
  // Based on Klein Nishina formula
  // In the forward case (see G4KleinNishinaCompton) the cross section is
  // parametrised but the secondaries are sampled from the Klein Nishina
  // differential cross section. The differential cross section used here
  // is therefore the cross section multiplied by the normalised
  // differential Klein Nishina cross section
 
  // Klein Nishina Cross Section
  G4double epsilon           = gamEnergy0 / electron_mass_c2;
  G4double one_plus_two_epsi = 1. + 2. * epsilon;
  if(gamEnergy1 > gamEnergy0 || gamEnergy1 < gamEnergy0 / one_plus_two_epsi)
  {
    return 0.;
  }
 
  G4double CS = std::log(one_plus_two_epsi) *
                (1. - 2. * (1. + epsilon) / (epsilon * epsilon));
  CS +=
    4. / epsilon + 0.5 * (1. - 1. / (one_plus_two_epsi * one_plus_two_epsi));
  CS /= epsilon;
  // Note that the pi*re2*Z factor is neglected because it is suppressed when
  // computing dCS_dE1/CS in the differential cross section
 
  // Klein Nishina Differential Cross Section
  G4double epsilon1 = gamEnergy1 / electron_mass_c2;
  G4double v        = epsilon1 / epsilon;
  G4double term1    = 1. + 1. / epsilon - 1. / epsilon1;
  G4double dCS_dE1  = 1. / v + v + term1 * term1 - 1.;
  dCS_dE1 *= 1. / epsilon / gamEnergy0;
 
  // Normalised to the CS used in G4
  fDirectCS = fDirectModel->ComputeCrossSectionPerAtom(
    G4Gamma::Gamma(), gamEnergy0, Z, 0., 0., 0.);
 
  dCS_dE1 *= fDirectCS / CS;
 
  return dCS_dE1;
}

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

Referenced by DiffCrossSectionPerAtomPrimToSecond(), and RapidSampleSecondaries().

DiffCrossSectionPerAtomPrimToSecond()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 251 of file G4AdjointComptonModel.cc.

{
  G4double gamEnergy1   = gamEnergy0 - kinEnergyElec;
  G4double dSigmadEprod = 0.;
  if(gamEnergy1 > 0.)
    dSigmadEprod =
      DiffCrossSectionPerAtomPrimToScatPrim(gamEnergy0, gamEnergy1, Z, A);
  return dSigmadEprod;
}

References A, DiffCrossSectionPerAtomPrimToScatPrim(), and Z.

DiffCrossSectionPerVolumePrimToScatPrim()

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

virtualinherited

Definition at line 140 of file G4VEmAdjointModel.cc.

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

{ 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(), GetSecondAdjEnergyMaxForScatProjToProj(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), 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 G4AdjointBremsstrahlungModel::AdjointCrossSection(), AdjointCrossSection(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForSecond(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForSecond(), G4AdjointCSManager::ComputeAdjointCS(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointeIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), RapidSampleSecondaries(), G4VEmAdjointModel::SampleAdjSecEnergyFromCSMatrix(), G4VEmAdjointModel::SampleAdjSecEnergyFromDiffCrossSectionPerAtom(), and G4AdjointeIonisationModel::SampleSecondaries().

GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4AdjointComptonModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double  primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 306 of file G4AdjointComptonModel.cc.

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

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

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

GetSecondAdjEnergyMinForProdToProj()

G4double G4AdjointComptonModel::GetSecondAdjEnergyMinForProdToProj ( G4double  primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 317 of file G4AdjointComptonModel.cc.

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

References source.hepunit::electron_mass_c2.

Referenced by AdjointCrossSection(), and RapidSampleSecondaries().

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 G4AdjointBremsstrahlungModel::AdjointCrossSection(), AdjointCrossSection(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerAtomForScatProj(), G4VEmAdjointModel::ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), G4AdjointCSManager::ComputeAdjointCS(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), 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().

operator=()

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

delete

RapidSampleSecondaries()

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

Definition at line 137 of file G4AdjointComptonModel.cc.

{
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
  DefineCurrentMaterial(aTrack.GetMaterialCutsCouple());
 
  G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
 
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  G4double diffCSUsed =
    0.1 * fCurrentMaterial->GetElectronDensity() * twopi_mc2_rcl2;
  G4double gammaE1 = 0.;
  G4double gammaE2 = 0.;
  if(!isScatProjToProj)
  {
    G4double Emax = GetSecondAdjEnergyMaxForProdToProj(adjointPrimKinEnergy);
    G4double Emin = GetSecondAdjEnergyMinForProdToProj(adjointPrimKinEnergy);
    if(Emin >= Emax)
      return;
    G4double f1 = (Emin - adjointPrimKinEnergy) / Emin;
    G4double f2 = (Emax - adjointPrimKinEnergy) / Emax / f1;
    gammaE1 = adjointPrimKinEnergy / (1. - f1 * std::pow(f2, G4UniformRand()));
    gammaE2 = gammaE1 - adjointPrimKinEnergy;
    diffCSUsed =
      diffCSUsed *
      (1. + 2. * std::log(1. + electron_mass_c2 / adjointPrimKinEnergy)) *
      adjointPrimKinEnergy / gammaE1 / gammaE2;
  }
  else
  {
    G4double Emax =
      GetSecondAdjEnergyMaxForScatProjToProj(adjointPrimKinEnergy);
    G4double Emin =
      GetSecondAdjEnergyMinForScatProjToProj(adjointPrimKinEnergy, fTcutSecond);
    if(Emin >= Emax)
      return;
    gammaE2    = adjointPrimKinEnergy;
    gammaE1    = Emin * std::pow(Emax / Emin, G4UniformRand());
    diffCSUsed = diffCSUsed / gammaE1;
  }
 
  // Weight correction
  // First w_corr is set to the ratio between adjoint total CS and fwd total CS
  G4double w_corr = fOutsideWeightFactor;
  if(fInModelWeightCorr)
  {
    w_corr =
      G4AdjointCSManager::GetAdjointCSManager()->GetPostStepWeightCorrection();
  }
  // Then another correction is needed because a biased differential CS has
  // been used rather than the one consistent with the direct model
 
  G4double diffCS =
    DiffCrossSectionPerAtomPrimToScatPrim(gammaE1, gammaE2, 1, 0.);
  if(diffCS > 0.)
    diffCS /= fDirectCS;  // here we have the normalised diffCS
  // And we remultiply by the lambda of the forward process
  diffCS *= fDirectProcess->GetLambda(gammaE1, fCurrentCouple);
 
  w_corr *= diffCS / diffCSUsed;
 
  G4double new_weight = aTrack.GetWeight() * w_corr;
  fParticleChange->SetParentWeightByProcess(false);
  fParticleChange->SetSecondaryWeightByProcess(false);
  fParticleChange->ProposeParentWeight(new_weight);
 
  G4double cos_th = 1. + electron_mass_c2 * (1. / gammaE1 - 1. / gammaE2);
  if(!isScatProjToProj)
  {
    G4double p_elec = theAdjointPrimary->GetTotalMomentum();
    cos_th          = (gammaE1 - gammaE2 * cos_th) / p_elec;
  }
  G4double sin_th = 0.;
  if(std::abs(cos_th) > 1.)
  {
    if(cos_th > 0.)
    {
      cos_th = 1.;
    }
    else
      cos_th = -1.;
  }
  else
    sin_th = std::sqrt(1. - cos_th * cos_th);
 
  // gamma0 momentum
  G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
  G4double phi               = G4UniformRand() * twopi;
  G4ThreeVector gammaMomentum1 =
    gammaE1 *
    G4ThreeVector(std::cos(phi) * sin_th, std::sin(phi) * sin_th, cos_th);
  gammaMomentum1.rotateUz(dir_parallel);
 
  if(!isScatProjToProj)
  {  // kill the primary and add a secondary
    fParticleChange->ProposeTrackStatus(fStopAndKill);
    fParticleChange->AddSecondary(
      new G4DynamicParticle(fAdjEquivDirectPrimPart, gammaMomentum1));
  }
  else
  {
    fParticleChange->ProposeEnergy(gammaE1);
    fParticleChange->ProposeMomentumDirection(gammaMomentum1.unit());
  }
}

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

Referenced by SampleSecondaries().

SampleAdjSecEnergyFromCSMatrix() [1/2]

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

protectedinherited

Definition at line 518 of file G4VEmAdjointModel.cc.

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

overridevirtual

Implements G4VEmAdjointModel.

Definition at line 61 of file G4AdjointComptonModel.cc.

{
  if(!fUseMatrix)
    return RapidSampleSecondaries(aTrack, isScatProjToProj, fParticleChange);
 
  // A recall of the compton scattering law:
  // Egamma2=Egamma1/(1+(Egamma1/E0_electron)(1.-cos_th))
  // Therefore Egamma2_max= Egamma2(cos_th=1) = Egamma1
  // and       Egamma2_min= Egamma2(cos_th=-1) =
  //             Egamma1/(1+2.(Egamma1/E0_electron))
  const G4DynamicParticle* theAdjointPrimary = aTrack.GetDynamicParticle();
  G4double adjointPrimKinEnergy = theAdjointPrimary->GetKineticEnergy();
  if(adjointPrimKinEnergy > GetHighEnergyLimit() * 0.999)
  {
    return;
  }
 
  // Sample secondary energy
  G4double gammaE1;
  gammaE1 =
    SampleAdjSecEnergyFromCSMatrix(adjointPrimKinEnergy, isScatProjToProj);
 
  // gammaE2
  G4double gammaE2 = adjointPrimKinEnergy;
  if(!isScatProjToProj)
    gammaE2 = gammaE1 - adjointPrimKinEnergy;
 
  // Cos th
  G4double cos_th = 1. + electron_mass_c2 * (1. / gammaE1 - 1. / gammaE2);
  if(!isScatProjToProj)
  {
    cos_th =
      (gammaE1 - gammaE2 * cos_th) / theAdjointPrimary->GetTotalMomentum();
  }
  G4double sin_th = 0.;
  if(std::abs(cos_th) > 1.)
  {
    if(cos_th > 0.)
    {
      cos_th = 1.;
    }
    else
      cos_th = -1.;
    sin_th = 0.;
  }
  else
    sin_th = std::sqrt(1. - cos_th * cos_th);
 
  // gamma0 momentum
  G4ThreeVector dir_parallel = theAdjointPrimary->GetMomentumDirection();
  G4double phi               = G4UniformRand() * twopi;
  G4ThreeVector gammaMomentum1 =
    gammaE1 *
    G4ThreeVector(std::cos(phi) * sin_th, std::sin(phi) * sin_th, cos_th);
  gammaMomentum1.rotateUz(dir_parallel);
 
  // correct the weight of particles before adding the secondary
  CorrectPostStepWeight(fParticleChange, aTrack.GetWeight(),
                        adjointPrimKinEnergy, gammaE1, isScatProjToProj);
 
  if(!isScatProjToProj)
  {  // kill the primary and add a secondary
    fParticleChange->ProposeTrackStatus(fStopAndKill);
    fParticleChange->AddSecondary(
      new G4DynamicParticle(fAdjEquivDirectPrimPart, gammaMomentum1));
  }
  else
  {
    fParticleChange->ProposeEnergy(gammaE1);
    fParticleChange->ProposeMomentumDirection(gammaMomentum1.unit());
  }
}

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

SelectCSMatrix()

void G4VEmAdjointModel::SelectCSMatrix ( G4bool  isScatProjToProj )

protectedinherited

Definition at line 527 of file G4VEmAdjointModel.cc.

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

SetDirectProcess()

void G4AdjointComptonModel::SetDirectProcess ( G4VEmProcess *  aProcess )

inline

Definition at line 72 of file G4AdjointComptonModel.hh.

  {
    fDirectProcess = aProcess;
  };

References fDirectProcess.

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

Field Documentation

fAdjEquivDirectPrimPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectPrimPart = nullptr

protectedinherited

Definition at line 259 of file G4VEmAdjointModel.hh.

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

fCurrentMaterial

G4Material* G4VEmAdjointModel::fCurrentMaterial = nullptr

protectedinherited

Definition at line 255 of file G4VEmAdjointModel.hh.

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

fDirectCS

G4double G4AdjointComptonModel::fDirectCS = 0.

private

Definition at line 83 of file G4AdjointComptonModel.hh.

Referenced by DiffCrossSectionPerAtomPrimToScatPrim(), and RapidSampleSecondaries().

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(), DiffCrossSectionPerAtomPrimToScatPrim(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel(), G4AdjointComptonModel(), G4AdjointhIonisationModel::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(), G4AdjointhIonisationModel::DefineProjectileProperty(), G4AdjointIonIonisationModel::DefineProjectileProperty(), G4VEmAdjointModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointhIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4AdjointIonIonisationModel::DiffCrossSectionPerAtomPrimToSecond(), G4VEmAdjointModel::DiffCrossSectionPerVolumePrimToSecond(), G4AdjointComptonModel(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::G4AdjointhIonisationModel(), G4AdjointIonIonisationModel::G4AdjointIonIonisationModel(), G4AdjointPhotoElectricModel::G4AdjointPhotoElectricModel(), G4AdjointBremsstrahlungModel::Initialize(), G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition(), and G4AdjointIonIonisationModel::SetIon().

fDirectProcess

G4VEmProcess* G4AdjointComptonModel::fDirectProcess = nullptr

private

Definition at line 81 of file G4AdjointComptonModel.hh.

Referenced by RapidSampleSecondaries(), and SetDirectProcess().

fElementCSProdToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSProdToProj

protectedinherited

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

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(), 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(), AdjointCrossSection(), G4AdjointhIonisationModel::AdjointCrossSection(), G4VEmAdjointModel::CorrectPostStepWeight(), G4AdjointhIonisationModel::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().

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 G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), 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(), G4AdjointeIonisationModel::G4AdjointeIonisationModel(), G4AdjointhIonisationModel::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().

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