G4VEmAdjointModel Class Reference

#include <G4VEmAdjointModel.hh>

Inheritance diagram for G4VEmAdjointModel:

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

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

Protected Attributes
G4AdjointCSManager *	fCSManager
G4VEmModel *	fDirectModel = nullptr
const G4String	fName
G4Material *	fSelectedMaterial = nullptr
G4Material *	fCurrentMaterial = nullptr
G4MaterialCutsCouple *	fCurrentCouple = nullptr
G4ParticleDefinition *	fAdjEquivDirectPrimPart = nullptr
G4ParticleDefinition *	fAdjEquivDirectSecondPart = nullptr
G4ParticleDefinition *	fDirectPrimaryPart = nullptr
std::vector< G4AdjointCSMatrix * > *	fCSMatrixProdToProjBackScat = nullptr
std::vector< G4AdjointCSMatrix * > *	fCSMatrixProjToProjBackScat = nullptr
std::vector< G4double >	fElementCSScatProjToProj
std::vector< G4double >	fElementCSProdToProj
G4double	fKinEnergyProdForIntegration = 0.
G4double	fKinEnergyScatProjForIntegration = 0.
G4double	fLastCS = 0.
G4double	fLastAdjointCSForScatProjToProj = 0.
G4double	fLastAdjointCSForProdToProj = 0.
G4double	fPreStepEnergy = 0.
G4double	fTcutPrim = 0.
G4double	fTcutSecond = 0.
G4double	fHighEnergyLimit = 0.
G4double	fLowEnergyLimit = 0.
G4double	fCsBiasingFactor = 1.
G4double	fOutsideWeightFactor = 1.
G4int	fASelectedNucleus = 0
G4int	fZSelectedNucleus = 0
std::size_t	fCSMatrixUsed = 0
G4bool	fSecondPartSameType = false
G4bool	fInModelWeightCorr
G4bool	fApplyCutInRange = true
G4bool	fUseMatrix = false
G4bool	fUseMatrixPerElement = false
G4bool	fOneMatrixForAllElements = false

Detailed Description

Definition at line 50 of file G4VEmAdjointModel.hh.

Constructor & Destructor Documentation

G4VEmAdjointModel() [1/2]

G4VEmAdjointModel::G4VEmAdjointModel ( const G4String & nam )

explicit

Definition at line 42 of file G4VEmAdjointModel.cc.

  : fName(nam)
{
  fCSManager = G4AdjointCSManager::GetAdjointCSManager();
  fCSManager->RegisterEmAdjointModel(this);
}

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), ComputeAdjointCrossSectionVectorPerAtomForSecond(), ComputeAdjointCrossSectionVectorPerVolumeForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForSecond().

~G4VEmAdjointModel()

G4VEmAdjointModel::~G4VEmAdjointModel ( )

virtual

Definition at line 50 of file G4VEmAdjointModel.cc.

{
  delete fCSMatrixProdToProjBackScat;
  fCSMatrixProdToProjBackScat = nullptr;
 
  delete fCSMatrixProjToProjBackScat;
  fCSMatrixProjToProjBackScat = nullptr;
}

G4VEmAdjointModel() [2/2]

G4VEmAdjointModel::G4VEmAdjointModel ( G4VEmAdjointModel & )

delete

Member Function Documentation

AdjointCrossSection()

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

virtual

Reimplemented in G4AdjointBremsstrahlungModel, G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointPhotoElectricModel.

Definition at line 60 of file G4VEmAdjointModel.cc.

{
  DefineCurrentMaterial(aCouple);
  fPreStepEnergy = primEnergy;
 
  std::vector<G4double>* CS_Vs_Element = &fElementCSProdToProj;
  if(isScatProjToProj)
    CS_Vs_Element = &fElementCSScatProjToProj;
  fLastCS =
    fCSManager->ComputeAdjointCS(fCurrentMaterial, this, primEnergy,
                                 fTcutSecond, isScatProjToProj, *CS_Vs_Element);
  if(isScatProjToProj)
    fLastAdjointCSForScatProjToProj = fLastCS;
  else
    fLastAdjointCSForProdToProj = fLastCS;
 
  return fLastCS;
}

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

ComputeAdjointCrossSectionVectorPerAtomForScatProj()

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

Definition at line 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;
}

ComputeAdjointCrossSectionVectorPerAtomForSecond()

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

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

ComputeAdjointCrossSectionVectorPerVolumeForScatProj()

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

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

ComputeAdjointCrossSectionVectorPerVolumeForSecond()

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

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

CorrectPostStepWeight()

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

protectedvirtual

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

DefineCurrentMaterial()

void G4VEmAdjointModel::DefineCurrentMaterial

(

const G4MaterialCutsCouple *

couple

)

Definition at line 684 of file G4VEmAdjointModel.cc.

{
  if(couple != fCurrentCouple)
  {
    fCurrentCouple   = const_cast<G4MaterialCutsCouple*>(couple);
    fCurrentMaterial = const_cast<G4Material*>(couple->GetMaterial());
    std::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()];
      }
    }
  }
}

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

DefineDirectEMModel()

void G4VEmAdjointModel::DefineDirectEMModel ( G4VEmModel * aModel )

inline

Definition at line 160 of file G4VEmAdjointModel.hh.

{ fDirectModel = aModel; }

DiffCrossSectionFunction1()

G4double G4VEmAdjointModel::DiffCrossSectionFunction1 ( G4double kinEnergyProj )

protected

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

Referenced by ComputeAdjointCrossSectionVectorPerAtomForSecond(), and ComputeAdjointCrossSectionVectorPerVolumeForSecond().

DiffCrossSectionFunction2()

G4double G4VEmAdjointModel::DiffCrossSectionFunction2 ( G4double kinEnergyProj )

protected

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

Referenced by ComputeAdjointCrossSectionVectorPerAtomForScatProj(), and ComputeAdjointCrossSectionVectorPerVolumeForScatProj().

DiffCrossSectionPerAtomPrimToScatPrim()

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

virtual

Reimplemented in G4AdjointComptonModel.

Definition at line 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;
}

Referenced by DiffCrossSectionFunction2(), and SampleAdjSecEnergyFromDiffCrossSectionPerAtom().

DiffCrossSectionPerAtomPrimToSecond()

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

virtual

Reimplemented in G4AdjointComptonModel, G4AdjointeIonisationModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 82 of file G4VEmAdjointModel.cc.

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

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

DiffCrossSectionPerVolumePrimToScatPrim()

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

virtual

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

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

DiffCrossSectionPerVolumePrimToSecond()

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

virtual

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

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

GetAdjointEquivalentOfDirectPrimaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectPrimaryParticleDefinition ( )

inline

Definition at line 141 of file G4VEmAdjointModel.hh.

  {
    return fAdjEquivDirectPrimPart;
  }

Referenced by G4AdjointCSManager::ComputeTotalAdjointCS().

GetAdjointEquivalentOfDirectSecondaryParticleDefinition()

G4ParticleDefinition * G4VEmAdjointModel::GetAdjointEquivalentOfDirectSecondaryParticleDefinition ( )

inline

Definition at line 147 of file G4VEmAdjointModel.hh.

  {
    return fAdjEquivDirectSecondPart;
  }

Referenced by G4AdjointCSManager::ComputeTotalAdjointCS().

GetApplyCutInRange()

G4bool G4VEmAdjointModel::GetApplyCutInRange ( )

inline

Definition at line 201 of file G4VEmAdjointModel.hh.

{ return fApplyCutInRange; }

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

GetHighEnergyLimit()

G4double G4VEmAdjointModel::GetHighEnergyLimit ( )

inline

Definition at line 152 of file G4VEmAdjointModel.hh.

{ return fHighEnergyLimit; }

Referenced by G4AdjointhIonisationModel::GetSecondAdjEnergyMaxForProdToProj(), G4AdjointIonIonisationModel::GetSecondAdjEnergyMaxForProdToProj(), G4AdjointComptonModel::GetSecondAdjEnergyMaxForScatProjToProj(), GetSecondAdjEnergyMaxForScatProjToProj(), G4AdjointBremsstrahlungModel::RapidSampleSecondaries(), G4AdjointComptonModel::RapidSampleSecondaries(), G4AdjointhIonisationModel::RapidSampleSecondaries(), G4AdjointBremsstrahlungModel::SampleSecondaries(), G4AdjointComptonModel::SampleSecondaries(), G4AdjointeIonisationModel::SampleSecondaries(), G4AdjointhIonisationModel::SampleSecondaries(), and G4AdjointIonIonisationModel::SampleSecondaries().

GetLowEnergyLimit()

G4double G4VEmAdjointModel::GetLowEnergyLimit ( )

inline

Definition at line 154 of file G4VEmAdjointModel.hh.

{ return fLowEnergyLimit; }

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

GetName()

G4String G4VEmAdjointModel::GetName ( )

inline

Definition at line 203 of file G4VEmAdjointModel.hh.

{ return fName; }

GetSecondAdjEnergyMaxForProdToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForProdToProj ( G4double primAdjEnergy )

virtual

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 668 of file G4VEmAdjointModel.cc.

{
  return fHighEnergyLimit;
}

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

GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double primAdjEnergy )

virtual

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 648 of file G4VEmAdjointModel.cc.

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

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

GetSecondAdjEnergyMinForProdToProj()

G4double G4VEmAdjointModel::GetSecondAdjEnergyMinForProdToProj ( G4double primAdjEnergy )

virtual

Reimplemented in G4AdjointComptonModel, G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 674 of file G4VEmAdjointModel.cc.

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

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

GetSecondAdjEnergyMinForScatProjToProj()

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

virtual

Reimplemented in G4AdjointhIonisationModel, and G4AdjointIonIonisationModel.

Definition at line 658 of file G4VEmAdjointModel.cc.

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

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

GetSecondPartOfSameType()

G4bool G4VEmAdjointModel::GetSecondPartOfSameType ( )

inline

Definition at line 176 of file G4VEmAdjointModel.hh.

{ return fSecondPartSameType; }

GetUseMatrix()

G4bool G4VEmAdjointModel::GetUseMatrix ( )

inline

Definition at line 192 of file G4VEmAdjointModel.hh.

{ return fUseMatrix; }

Referenced by G4AdjointCSManager::ComputeAdjointCS().

GetUseMatrixPerElement()

G4bool G4VEmAdjointModel::GetUseMatrixPerElement ( )

inline

Definition at line 194 of file G4VEmAdjointModel.hh.

{ return fUseMatrixPerElement; }

Referenced by G4AdjointCSManager::ComputeAdjointCS().

GetUseOnlyOneMatrixForAllElements()

G4bool G4VEmAdjointModel::GetUseOnlyOneMatrixForAllElements ( )

inline

Definition at line 196 of file G4VEmAdjointModel.hh.

  {
    return fOneMatrixForAllElements;
  }

Referenced by G4AdjointCSManager::ComputeAdjointCS().

operator=()

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

delete

SampleAdjSecEnergyFromCSMatrix() [1/2]

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

protected

Definition at line 518 of file G4VEmAdjointModel.cc.

{
  SelectCSMatrix(isScatProjToProj);
  return SampleAdjSecEnergyFromCSMatrix(fCSMatrixUsed, aPrimEnergy,
                                        isScatProjToProj);
}

SampleAdjSecEnergyFromCSMatrix() [2/2]

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

protected

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);
  G4int ind = (G4int)theInterpolator->FindPositionForLogVector(
    aLogPrimEnergy, *theLogPrimEnergyVector);
 
  G4double aLogPrimEnergy1, aLogPrimEnergy2;
  G4double aLogCS1, aLogCS2;
  G4double log01, log02;
  std::vector<G4double>* aLogSecondEnergyVector1 = nullptr;
  std::vector<G4double>* aLogSecondEnergyVector2 = nullptr;
  std::vector<G4double>* aLogProbVector1         = nullptr;
  std::vector<G4double>* aLogProbVector2         = nullptr;
  std::vector<std::size_t>* aLogProbVectorIndex1    = nullptr;
  std::vector<std::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;
}

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

SampleAdjSecEnergyFromDiffCrossSectionPerAtom()

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

protectedvirtual

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

SampleSecondaries()

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

pure virtual

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

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

SelectCSMatrix()

void G4VEmAdjointModel::SelectCSMatrix ( G4bool isScatProjToProj )

protected

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.;
    std::size_t ind = 0;
    for(std::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((G4int)ind)->GetIndex();
  }
}

Referenced by SampleAdjSecEnergyFromCSMatrix().

SetAdditionalWeightCorrectionFactorForPostStepOutsideModel()

void G4VEmAdjointModel::SetAdditionalWeightCorrectionFactorForPostStepOutsideModel ( G4double factor )

inline

Definition at line 215 of file G4VEmAdjointModel.hh.

  {
    fOutsideWeightFactor = factor;
  }

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

SetAdjointEquivalentOfDirectPrimaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectPrimaryParticleDefinition

(

G4ParticleDefinition *

aPart

)

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

SetAdjointEquivalentOfDirectSecondaryParticleDefinition()

void G4VEmAdjointModel::SetAdjointEquivalentOfDirectSecondaryParticleDefinition ( G4ParticleDefinition * aPart )

inline

Definition at line 165 of file G4VEmAdjointModel.hh.

  {
    fAdjEquivDirectSecondPart = aPart;
  }

SetApplyCutInRange()

void G4VEmAdjointModel::SetApplyCutInRange ( G4bool aBool )

inline

Definition at line 190 of file G4VEmAdjointModel.hh.

{ fApplyCutInRange = aBool; }

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

SetCorrectWeightForPostStepInModel()

void G4VEmAdjointModel::SetCorrectWeightForPostStepInModel ( G4bool aBool )

inline

Definition at line 210 of file G4VEmAdjointModel.hh.

  {
    fInModelWeightCorr = aBool;
  }

Referenced by G4AdjointForcedInteractionForGamma::PostStepDoIt().

SetCSBiasingFactor()

virtual void G4VEmAdjointModel::SetCSBiasingFactor ( G4double aVal )

inlinevirtual

Definition at line 205 of file G4VEmAdjointModel.hh.

  {
    fCsBiasingFactor = aVal;
  }

SetCSMatrices()

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

inline

Definition at line 133 of file G4VEmAdjointModel.hh.

  {
    fCSMatrixProdToProjBackScat = Vec1CSMatrix;
    fCSMatrixProjToProjBackScat = Vec2CSMatrix;
  };

SetHighEnergyLimit()

void G4VEmAdjointModel::SetHighEnergyLimit

(

G4double

aVal

)

Definition at line 713 of file G4VEmAdjointModel.cc.

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

SetLowEnergyLimit()

void G4VEmAdjointModel::SetLowEnergyLimit

(

G4double

aVal

)

Definition at line 721 of file G4VEmAdjointModel.cc.

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

SetSecondPartOfSameType()

void G4VEmAdjointModel::SetSecondPartOfSameType ( G4bool aBool )

inline

Definition at line 171 of file G4VEmAdjointModel.hh.

  {
    fSecondPartSameType = aBool;
  }

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

SetUseMatrix()

void G4VEmAdjointModel::SetUseMatrix ( G4bool aBool )

inline

Definition at line 178 of file G4VEmAdjointModel.hh.

{ fUseMatrix = aBool; }

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

SetUseMatrixPerElement()

void G4VEmAdjointModel::SetUseMatrixPerElement ( G4bool aBool )

inline

Definition at line 180 of file G4VEmAdjointModel.hh.

  {
    fUseMatrixPerElement = aBool;
  }

Referenced by G4AdjointComptonModel::G4AdjointComptonModel().

SetUseOnlyOneMatrixForAllElements()

void G4VEmAdjointModel::SetUseOnlyOneMatrixForAllElements ( G4bool aBool )

inline

Definition at line 185 of file G4VEmAdjointModel.hh.

  {
    fOneMatrixForAllElements = aBool;
  }

Referenced by G4AdjointComptonModel::G4AdjointComptonModel().

Member Data Documentation

fAdjEquivDirectPrimPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectPrimPart = nullptr

protected

Definition at line 259 of file G4VEmAdjointModel.hh.

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

fAdjEquivDirectSecondPart

G4ParticleDefinition* G4VEmAdjointModel::fAdjEquivDirectSecondPart = nullptr

protected

Definition at line 260 of file G4VEmAdjointModel.hh.

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

fApplyCutInRange

G4bool G4VEmAdjointModel::fApplyCutInRange = true

protected

Definition at line 304 of file G4VEmAdjointModel.hh.

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

fASelectedNucleus

G4int G4VEmAdjointModel::fASelectedNucleus = 0

protected

Definition at line 295 of file G4VEmAdjointModel.hh.

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

fCsBiasingFactor

G4double G4VEmAdjointModel::fCsBiasingFactor = 1.

protected

Definition at line 287 of file G4VEmAdjointModel.hh.

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

fCSManager

G4AdjointCSManager* G4VEmAdjointModel::fCSManager

protected

Definition at line 249 of file G4VEmAdjointModel.hh.

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

fCSMatrixProdToProjBackScat

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

protected

Definition at line 264 of file G4VEmAdjointModel.hh.

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

fCSMatrixProjToProjBackScat

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

protected

Definition at line 265 of file G4VEmAdjointModel.hh.

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

fCSMatrixUsed

std::size_t G4VEmAdjointModel::fCSMatrixUsed = 0

protected

Definition at line 298 of file G4VEmAdjointModel.hh.

Referenced by SampleAdjSecEnergyFromCSMatrix(), and SelectCSMatrix().

fCurrentCouple

G4MaterialCutsCouple* G4VEmAdjointModel::fCurrentCouple = nullptr

protected

Definition at line 256 of file G4VEmAdjointModel.hh.

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

fCurrentMaterial

G4Material* G4VEmAdjointModel::fCurrentMaterial = nullptr

protected

Definition at line 255 of file G4VEmAdjointModel.hh.

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

fDirectModel

G4VEmModel* G4VEmAdjointModel::fDirectModel = nullptr

protected

Definition at line 250 of file G4VEmAdjointModel.hh.

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

fDirectPrimaryPart

G4ParticleDefinition* G4VEmAdjointModel::fDirectPrimaryPart = nullptr

protected

Definition at line 261 of file G4VEmAdjointModel.hh.

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

fElementCSProdToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSProdToProj

protected

Definition at line 268 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

fElementCSScatProjToProj

std::vector<G4double> G4VEmAdjointModel::fElementCSScatProjToProj

protected

Definition at line 267 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and SelectCSMatrix().

fHighEnergyLimit

G4double G4VEmAdjointModel::fHighEnergyLimit = 0.

protected

Definition at line 283 of file G4VEmAdjointModel.hh.

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

fInModelWeightCorr

G4bool G4VEmAdjointModel::fInModelWeightCorr

protected

Initial value:

=
    false

Definition at line 301 of file G4VEmAdjointModel.hh.

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

fKinEnergyProdForIntegration

G4double G4VEmAdjointModel::fKinEnergyProdForIntegration = 0.

protected

Definition at line 270 of file G4VEmAdjointModel.hh.

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

fKinEnergyScatProjForIntegration

G4double G4VEmAdjointModel::fKinEnergyScatProjForIntegration = 0.

protected

Definition at line 271 of file G4VEmAdjointModel.hh.

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

fLastAdjointCSForProdToProj

G4double G4VEmAdjointModel::fLastAdjointCSForProdToProj = 0.

protected

Definition at line 275 of file G4VEmAdjointModel.hh.

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

fLastAdjointCSForScatProjToProj

G4double G4VEmAdjointModel::fLastAdjointCSForScatProjToProj = 0.

protected

Definition at line 274 of file G4VEmAdjointModel.hh.

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

fLastCS

G4double G4VEmAdjointModel::fLastCS = 0.

protected

Definition at line 273 of file G4VEmAdjointModel.hh.

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

fLowEnergyLimit

G4double G4VEmAdjointModel::fLowEnergyLimit = 0.

protected

Definition at line 284 of file G4VEmAdjointModel.hh.

Referenced by GetLowEnergyLimit(), and SetLowEnergyLimit().

fName

const G4String G4VEmAdjointModel::fName

protected

Definition at line 252 of file G4VEmAdjointModel.hh.

Referenced by GetName().

fOneMatrixForAllElements

G4bool G4VEmAdjointModel::fOneMatrixForAllElements = false

protected

Definition at line 309 of file G4VEmAdjointModel.hh.

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

fOutsideWeightFactor

G4double G4VEmAdjointModel::fOutsideWeightFactor = 1.

protected

Definition at line 292 of file G4VEmAdjointModel.hh.

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

fPreStepEnergy

G4double G4VEmAdjointModel::fPreStepEnergy = 0.

protected

Definition at line 277 of file G4VEmAdjointModel.hh.

Referenced by AdjointCrossSection(), and CorrectPostStepWeight().

fSecondPartSameType

G4bool G4VEmAdjointModel::fSecondPartSameType = false

protected

Definition at line 300 of file G4VEmAdjointModel.hh.

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

fSelectedMaterial

G4Material* G4VEmAdjointModel::fSelectedMaterial = nullptr

protected

Definition at line 254 of file G4VEmAdjointModel.hh.

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

fTcutPrim

G4double G4VEmAdjointModel::fTcutPrim = 0.

protected

Definition at line 279 of file G4VEmAdjointModel.hh.

fTcutSecond

G4double G4VEmAdjointModel::fTcutSecond = 0.

protected

Definition at line 280 of file G4VEmAdjointModel.hh.

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

fUseMatrix

G4bool G4VEmAdjointModel::fUseMatrix = false

protected

Definition at line 307 of file G4VEmAdjointModel.hh.

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

fUseMatrixPerElement

G4bool G4VEmAdjointModel::fUseMatrixPerElement = false

protected

Definition at line 308 of file G4VEmAdjointModel.hh.

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

fZSelectedNucleus

G4int G4VEmAdjointModel::fZSelectedNucleus = 0

protected

Definition at line 296 of file G4VEmAdjointModel.hh.

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

---

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

• G4VEmAdjointModel.hh
• G4VEmAdjointModel.cc