G4AdjointIonIonisationModel Class Reference

#include <G4AdjointIonIonisationModel.hh>

Inheritance diagram for G4AdjointIonIonisationModel:

Public Member Functions
	G4AdjointIonIonisationModel ()
	~G4AdjointIonIonisationModel () override
void	SampleSecondaries (const G4Track &aTrack, G4bool isScatProjToProj, G4ParticleChange *fParticleChange) override
G4double	DiffCrossSectionPerAtomPrimToSecond (G4double kinEnergyProj, G4double kinEnergyProd, G4double Z, G4double A=0.) override
void	CorrectPostStepWeight (G4ParticleChange *fParticleChange, G4double old_weight, G4double adjointPrimKinEnergy, G4double projectileKinEnergy, G4bool isScatProjToProj) override
G4double	GetSecondAdjEnergyMaxForScatProjToProj (G4double primAdjEnergy) override
G4double	GetSecondAdjEnergyMinForScatProjToProj (G4double primAdjEnergy, G4double tcut=0.) override
G4double	GetSecondAdjEnergyMaxForProdToProj (G4double primAdjEnergy) override
G4double	GetSecondAdjEnergyMinForProdToProj (G4double primAdjEnergy) override
void	SetUseOnlyBragg (G4bool aBool)
void	SetIon (G4ParticleDefinition *adj_ion, G4ParticleDefinition *fwd_ion)
	G4AdjointIonIonisationModel (G4AdjointIonIonisationModel &)=delete
G4AdjointIonIonisationModel &	operator= (const G4AdjointIonIonisationModel &right)=delete
Public Member Functions inherited from G4VEmAdjointModel
	G4VEmAdjointModel (const G4String &nam)
virtual	~G4VEmAdjointModel ()
virtual G4double	AdjointCrossSection (const G4MaterialCutsCouple *aCouple, G4double primEnergy, G4bool isScatProjToProj)
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)
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)
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 46 of file G4AdjointIonIonisationModel.hh.

Constructor & Destructor Documentation

G4AdjointIonIonisationModel() [1/2]

G4AdjointIonIonisationModel::G4AdjointIonIonisationModel

(

)

Definition at line 41 of file G4AdjointIonIonisationModel.cc.

  : G4VEmAdjointModel("Adjoint_IonIonisation")
{
  fUseMatrix               = true;
  fUseMatrixPerElement     = true;
  fApplyCutInRange         = true;
  fOneMatrixForAllElements = true;
  fSecondPartSameType      = false;
 
  // The direct EM Model is taken as BetheBloch. It is only used for the
  // computation of the differential cross section.
  // The Bragg model could be used as an alternative as it offers the same
  // differential cross section
 
  fBetheBlochDirectEMModel  = new G4BetheBlochModel(G4GenericIon::GenericIon());
  fBraggIonDirectEMModel    = new G4BraggIonModel(G4GenericIon::GenericIon());
  fAdjEquivDirectSecondPart = G4AdjointElectron::AdjointElectron();
  fDirectPrimaryPart        = nullptr;
}

~G4AdjointIonIonisationModel()

G4AdjointIonIonisationModel::~G4AdjointIonIonisationModel ( )

override

Definition at line 62 of file G4AdjointIonIonisationModel.cc.

{}

G4AdjointIonIonisationModel() [2/2]

G4AdjointIonIonisationModel::G4AdjointIonIonisationModel ( G4AdjointIonIonisationModel & )

delete

Member Function Documentation

CorrectPostStepWeight()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 228 of file G4AdjointIonIonisationModel.cc.

{
  // It is needed because the direct cross section used to compute the
  // differential cross section is not the one used in
  // the direct model where the GenericIon stuff is considered with correction
  // of effective charge.  In the direct model the samnepl of secondaries does
  // not reflect the integral cross section. The integral fwd cross section that
  // we used to compute the differential CS match the sample of secondaries in
  // the forward case despite the fact that its is not the same total CS than in
  // the FWD case. For this reason an extra weight correction is needed at the
  // end.
 
  G4double new_weight = old_weight;
 
  // the correction of CS due to the problem explained above
  G4double kinEnergyProjScaled = fMassRatio * projectileKinEnergy;
  fDirectModel                 = fBraggIonDirectEMModel;
  if(kinEnergyProjScaled > 2. * MeV && !fUseOnlyBragg)
    fDirectModel = fBetheBlochDirectEMModel;
  G4double UsedFwdCS = fDirectModel->ComputeCrossSectionPerAtom(
    fDirectPrimaryPart, projectileKinEnergy, 1, 1, fTcutSecond, 1.e20);
  G4double chargeSqRatio = 1.;
  if(fChargeSquare > 1.)
    chargeSqRatio = fDirectModel->GetChargeSquareRatio(
      fDirectPrimaryPart, fCurrentMaterial, projectileKinEnergy);
  G4double CorrectFwdCS =
    chargeSqRatio * fDirectModel->ComputeCrossSectionPerAtom(
                      G4GenericIon::GenericIon(), kinEnergyProjScaled, 1, 1,
                      fTcutSecond, 1.e20);
  // May be some check is needed if UsedFwdCS ==0 probably that then we should
  // avoid a secondary to be produced,
  if(UsedFwdCS > 0.)
    new_weight *= CorrectFwdCS / UsedFwdCS;
 
  // additional CS correction needed for cross section biasing in general.
  // May be wrong for ions. Most of the time not used.
  new_weight *=
    G4AdjointCSManager::GetAdjointCSManager()->GetPostStepWeightCorrection() /
    fCsBiasingFactor;
 
  new_weight *= projectileKinEnergy / adjointPrimKinEnergy;
 
  fParticleChange->SetParentWeightByProcess(false);
  fParticleChange->SetSecondaryWeightByProcess(false);
  fParticleChange->ProposeParentWeight(new_weight);
}

Referenced by SampleSecondaries().

DiffCrossSectionPerAtomPrimToSecond()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 132 of file G4AdjointIonIonisationModel.cc.

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

GetSecondAdjEnergyMaxForProdToProj()

G4double G4AdjointIonIonisationModel::GetSecondAdjEnergyMaxForProdToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 325 of file G4AdjointIonIonisationModel.cc.

{
  return GetHighEnergyLimit();
}

Referenced by DiffCrossSectionPerAtomPrimToSecond().

GetSecondAdjEnergyMaxForScatProjToProj()

G4double G4AdjointIonIonisationModel::GetSecondAdjEnergyMaxForScatProjToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 310 of file G4AdjointIonIonisationModel.cc.

{
  return primAdjEnergy * fOnePlusRatio2 /
         (fOneMinusRatio2 - 2. * fRatio * primAdjEnergy / fMass);
}

GetSecondAdjEnergyMinForProdToProj()

G4double G4AdjointIonIonisationModel::GetSecondAdjEnergyMinForProdToProj ( G4double primAdjEnergy )

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 332 of file G4AdjointIonIonisationModel.cc.

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

Referenced by DiffCrossSectionPerAtomPrimToSecond().

GetSecondAdjEnergyMinForScatProjToProj()

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

overridevirtual

Reimplemented from G4VEmAdjointModel.

Definition at line 318 of file G4AdjointIonIonisationModel.cc.

{
  return primAdjEnergy + tcut;
}

operator=()

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

delete

SampleSecondaries()

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

overridevirtual

Implements G4VEmAdjointModel.

Definition at line 65 of file G4AdjointIonIonisationModel.cc.

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

SetIon()

void G4AdjointIonIonisationModel::SetIon	(	G4ParticleDefinition *	adj_ion,
		G4ParticleDefinition *	fwd_ion )

Definition at line 218 of file G4AdjointIonIonisationModel.cc.

{
  fDirectPrimaryPart      = fwd_ion;
  fAdjEquivDirectPrimPart = adj_ion;
 
  DefineProjectileProperty();
}

SetUseOnlyBragg()

void G4AdjointIonIonisationModel::SetUseOnlyBragg ( G4bool aBool )

inline

Definition at line 76 of file G4AdjointIonIonisationModel.hh.

{ fUseOnlyBragg = aBool; }

---

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

• G4AdjointIonIonisationModel.hh
• G4AdjointIonIonisationModel.cc