G4AdjointBremsstrahlungModel Class Reference

#include <G4AdjointBremsstrahlungModel.hh>

Inheritance diagram for G4AdjointBremsstrahlungModel:

Public Member Functions
	G4AdjointBremsstrahlungModel (G4VEmModel *aModel)
	G4AdjointBremsstrahlungModel ()
	~G4AdjointBremsstrahlungModel () override
void	SampleSecondaries (const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange) override
void	RapidSampleSecondaries (const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange)
G4double	DiffCrossSectionPerVolumePrimToSecond (const G4Material *aMaterial, G4double kinEnergyProj, G4double kinEnergyProd) override
G4double	AdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool isScatProjToProj) override
	G4AdjointBremsstrahlungModel (G4AdjointBremsstrahlungModel &)=delete
G4AdjointBremsstrahlungModel &	operator= (const G4AdjointBremsstrahlungModel &right)=delete
Public Member Functions inherited from G4VEmAdjointModel
	G4VEmAdjointModel (const G4String &nam)
virtual	~G4VEmAdjointModel ()
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	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

Additional Inherited Members
Protected Member Functions inherited from G4VEmAdjointModel
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 inherited from G4VEmAdjointModel
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 52 of file G4AdjointBremsstrahlungModel.hh.

Constructor & Destructor Documentation

G4AdjointBremsstrahlungModel() [1/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel ( G4VEmModel * aModel )

explicit

Definition at line 42 of file G4AdjointBremsstrahlungModel.cc.

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

G4AdjointBremsstrahlungModel() [2/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel

(

)

Definition at line 50 of file G4AdjointBremsstrahlungModel.cc.

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

~G4AdjointBremsstrahlungModel()

G4AdjointBremsstrahlungModel::~G4AdjointBremsstrahlungModel ( )

override

Definition at line 79 of file G4AdjointBremsstrahlungModel.cc.

{
  if(fEmModelManagerForFwdModels)
    delete fEmModelManagerForFwdModels;
}

G4AdjointBremsstrahlungModel() [3/3]

G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel ( G4AdjointBremsstrahlungModel & )

delete

Member Function Documentation

AdjointCrossSection()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 304 of file G4AdjointBremsstrahlungModel.cc.

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

DiffCrossSectionPerVolumePrimToSecond()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 288 of file G4AdjointBremsstrahlungModel.cc.

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

Referenced by RapidSampleSecondaries().

operator=()

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

delete

RapidSampleSecondaries()

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

Definition at line 165 of file G4AdjointBremsstrahlungModel.cc.

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

Referenced by SampleSecondaries().

SampleSecondaries()

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

overridevirtual

Implements G4VEmAdjointModel.

Definition at line 86 of file G4AdjointBremsstrahlungModel.cc.

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

---

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

• G4AdjointBremsstrahlungModel.hh
• G4AdjointBremsstrahlungModel.cc