#include <G4VXTRenergyLoss.hh>

Inheritance diagram for G4VXTRenergyLoss:

Public Member Functions
	G4VXTRenergyLoss (G4LogicalVolume anEnvelope, G4Material , G4Material *, G4double, G4double, G4int, const G4String &processName="XTRenergyLoss", G4ProcessType type=fElectromagnetic)

virtual	~G4VXTRenergyLoss ()

virtual void	ProcessDescription (std::ostream &) const override

virtual void	DumpInfo () const override

	G4VXTRenergyLoss (G4VXTRenergyLoss &)=delete

G4VXTRenergyLoss &	operator= (const G4VXTRenergyLoss &right)=delete

virtual G4double	GetStackFactor (G4double energy, G4double gamma, G4double varAngle)

virtual G4bool	IsApplicable (const G4ParticleDefinition &) override

virtual G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override

virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition) override

virtual void	BuildPhysicsTable (const G4ParticleDefinition &) override

void	BuildEnergyTable ()

void	BuildAngleForEnergyBank ()

void	BuildTable ()

void	BuildAngleTable ()

void	BuildGlobalAngleTable ()

G4complex	OneInterfaceXTRdEdx (G4double energy, G4double gamma, G4double varAngle)

G4double	SpectralAngleXTRdEdx (G4double varAngle)

virtual G4double	SpectralXTRdEdx (G4double energy)

G4double	AngleSpectralXTRdEdx (G4double energy)

G4double	AngleXTRdEdx (G4double varAngle)

G4double	OneBoundaryXTRNdensity (G4double energy, G4double gamma, G4double varAngle) const

G4double	XTRNSpectralAngleDensity (G4double varAngle)

G4double	XTRNSpectralDensity (G4double energy)

G4double	XTRNAngleSpectralDensity (G4double energy)

G4double	XTRNAngleDensity (G4double varAngle)

void	GetNumberOfPhotons ()

G4double	GetPlateFormationZone (G4double, G4double, G4double)

G4complex	GetPlateComplexFZ (G4double, G4double, G4double)

void	ComputePlatePhotoAbsCof ()

G4double	GetPlateLinearPhotoAbs (G4double)

void	GetPlateZmuProduct ()

G4double	GetPlateZmuProduct (G4double, G4double, G4double)

G4double	GetGasFormationZone (G4double, G4double, G4double)

G4complex	GetGasComplexFZ (G4double, G4double, G4double)

void	ComputeGasPhotoAbsCof ()

G4double	GetGasLinearPhotoAbs (G4double)

void	GetGasZmuProduct ()

G4double	GetGasZmuProduct (G4double, G4double, G4double)

G4double	GetPlateCompton (G4double)

G4double	GetGasCompton (G4double)

G4double	GetComptonPerAtom (G4double, G4double)

G4double	GetXTRrandomEnergy (G4double scaledTkin, G4int iTkin)

G4double	GetXTRenergy (G4int iPlace, G4double position, G4int iTransfer)

G4double	GetRandomAngle (G4double energyXTR, G4int iTkin)

G4double	GetAngleXTR (G4int iTR, G4double position, G4int iAngle)

void	SetGamma (G4double gamma)

G4double	GetGamma ()

void	SetEnergy (G4double energy)

G4double	GetEnergy ()

void	SetVarAngle (G4double varAngle)

G4double	GetVarAngle ()

void	SetCompton (G4bool pC)

G4bool	GetCompton ()

G4int	GetKrange ()

void	SetKrange (G4int kk)

void	SetAlphaGas (G4double ag)

G4double	GetAlphaGas ()

void	SetAlphaPlate (G4double ap)

G4double	GetAlphaPlate ()

void	SetTheMinEnergyTR (G4double minetr)

G4double	GetTheMinEnergyTR ()

void	SetTheMaxEnergyTR (G4double maxetr)

G4double	GetTheMaxEnergyTR ()

void	SetMinEnergyTR (G4double minetr)

G4double	GetMinEnergyTR ()

void	SetMaxEnergyTR (G4double maxetr)

G4double	GetMaxEnergyTR ()

void	SetTheMinAngle (G4double minang)

G4double	GetTheMinAngle ()

void	SetTheMaxAngle (G4double maxang)

G4double	GetTheMaxAngle ()

void	SetMinThetaTR (G4double minatr)

G4double	GetMinThetaTR ()

void	SetMaxThetaTR (G4double maxatr)

G4double	GetMaxThetaTR ()

void	SetFastAngle (G4bool fatr)

G4bool	GetFastAngle ()

void	SetAngleRadDistr (G4bool fatr)

G4bool	GetAngleRadDistr ()

G4PhysicsLogVector *	GetProtonVector ()

G4int	GetTotBin ()

G4PhysicsFreeVector *	GetAngleVector (G4double energy, G4int n)

Public Member Functions inherited from G4VDiscreteProcess
	G4VDiscreteProcess (const G4String &aName, G4ProcessType aType=fNotDefined)

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

G4VDiscreteProcess &	operator= (const G4VDiscreteProcess &)=delete

virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)

virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)

virtual G4double	GetCrossSection (const G4double, const G4MaterialCutsCouple *)

virtual G4double	MinPrimaryEnergy (const G4ParticleDefinition , const G4Material )

Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4VProcess &	operator= (const G4VProcess &)=delete

G4bool	operator== (const G4VProcess &right) const

G4bool	operator!= (const G4VProcess &right) const

G4double	GetCurrentInteractionLength () const

void	SetPILfactor (G4double value)

G4double	GetPILfactor () const

G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)

G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)

G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)

virtual void	PreparePhysicsTable (const G4ParticleDefinition &)

virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)

const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)

const G4String &	GetProcessName () const

G4ProcessType	GetProcessType () const

void	SetProcessType (G4ProcessType)

G4int	GetProcessSubType () const

void	SetProcessSubType (G4int)

virtual const G4VProcess *	GetCreatorProcess () const

virtual void	StartTracking (G4Track *)

virtual void	EndTracking ()

virtual void	SetProcessManager (const G4ProcessManager *)

virtual const G4ProcessManager *	GetProcessManager ()

virtual void	ResetNumberOfInteractionLengthLeft ()

G4double	GetNumberOfInteractionLengthLeft () const

G4double	GetTotalNumberOfInteractionLengthTraversed () const

G4bool	isAtRestDoItIsEnabled () const

G4bool	isAlongStepDoItIsEnabled () const

G4bool	isPostStepDoItIsEnabled () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

virtual void	SetMasterProcess (G4VProcess *masterP)

const G4VProcess *	GetMasterProcess () const

virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)

virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Protected Attributes
G4double	fTheMinEnergyTR

G4double	fTheMaxEnergyTR

G4double	fTheMinAngle

G4double	fTheMaxAngle

G4int	fTotBin

G4int	fBinTR

G4int	fKrange

G4ParticleDefinition *	fPtrGamma

G4double *	fGammaCutInKineticEnergy

G4LogicalVolume *	fEnvelope

G4PhysicsTable *	fAngleDistrTable

G4PhysicsTable *	fEnergyDistrTable

G4PhysicsTable *	fAngleForEnergyTable

G4PhysicsLogVector *	fProtonEnergyVector

G4PhysicsLogVector *	fXTREnergyVector

G4SandiaTable *	fPlatePhotoAbsCof

G4SandiaTable *	fGasPhotoAbsCof

G4ParticleChange	fParticleChange

std::vector< G4PhysicsTable * >	fAngleBank

G4double	fGammaTkinCut

G4double	fMinEnergyTR

G4double	fMaxEnergyTR

G4double	fMinThetaTR

G4double	fMaxThetaTR

G4double	fTotalDist

G4double	fPlateThick

G4double	fGasThick

G4double	fAlphaPlate

G4double	fAlphaGas

G4double	fGamma

G4double	fEnergy

G4double	fVarAngle

G4double	fLambda

G4double	fSigma1

G4double	fSigma2

G4int	fMatIndex1

G4int	fMatIndex2

G4int	fPlateNumber

G4bool	fExitFlux

G4bool	fFastAngle

G4bool	fAngleRadDistr

G4bool	fCompton

G4int	secID = -1

Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager = nullptr

G4VParticleChange *	pParticleChange = nullptr

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft = -1.0

G4double	currentInteractionLength = -1.0

G4double	theInitialNumberOfInteractionLength = -1.0

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType = fNotDefined

G4int	theProcessSubType = -1

G4double	thePILfactor = 1.0

G4int	verboseLevel = 0

G4bool	enableAtRestDoIt = true

G4bool	enableAlongStepDoIt = true

G4bool	enablePostStepDoIt = true

Static Protected Attributes
static constexpr G4double	fMinProtonTkin = 100. * CLHEP::GeV

static constexpr G4double	fMaxProtonTkin = 100. * CLHEP::TeV

static constexpr G4double	fPlasmaCof

static constexpr G4double	fCofTR = CLHEP::fine_structure_const / CLHEP::pi

Additional Inherited Members
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)

Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 58 of file G4VXTRenergyLoss.hh.

Constructor & Destructor Documentation

◆ G4VXTRenergyLoss() [1/2]

G4VXTRenergyLoss::G4VXTRenergyLoss	(	G4LogicalVolume *	anEnvelope,
		G4Material *	foilMat,
		G4Material *	gasMat,
		G4double	a,
		G4double	b,
		G4int	n,
		const G4String &	processName = "XTRenergyLoss",
		G4ProcessType	type = fElectromagnetic )

explicit

Definition at line 59 of file G4VXTRenergyLoss.cc.

  : G4VDiscreteProcess(processName, type)
  , fGammaCutInKineticEnergy(nullptr)
  , fAngleDistrTable(nullptr)
  , fEnergyDistrTable(nullptr)
  , fAngleForEnergyTable(nullptr)
  , fPlatePhotoAbsCof(nullptr)
  , fGasPhotoAbsCof(nullptr)
  , fGammaTkinCut(0.0)
{
  verboseLevel = 1;
  secID = G4PhysicsModelCatalog::GetModelID("model_XTRenergyLoss");
  SetProcessSubType(fTransitionRadiation);
 
  fPtrGamma    = nullptr;
  fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = fGamma = fEnergy = 0.0;
  fVarAngle = fLambda = fTotalDist = fPlateThick = fGasThick = 0.0;
  fAlphaPlate = 100.;
  fAlphaGas = 40.;
 
  fTheMinEnergyTR = CLHEP::keV * 1.; //  1.; // 
  fTheMaxEnergyTR = CLHEP::keV * 100.; // 40.; //
 
  fTheMinAngle    = 1.e-8;  //
  fTheMaxAngle    = 4.e-4;
 
  fTotBin = 50;  //  number of bins in log scale 
  fBinTR  = 100; //   number of bins in TR vectors
  fKrange = 229;
  // min/max angle2 in log-vectors
 
  fMinThetaTR = 3.0e-9; 
  fMaxThetaTR = 1.0e-4;
 
  
  // Proton energy vector initialization
  fProtonEnergyVector =
    new G4PhysicsLogVector(fMinProtonTkin, fMaxProtonTkin, fTotBin);
 
  fXTREnergyVector =
    new G4PhysicsLogVector(fTheMinEnergyTR, fTheMaxEnergyTR, fBinTR);
 
  fEnvelope = anEnvelope;
 
  fPlateNumber = n;
  if(verboseLevel > 0)
    G4cout << "### G4VXTRenergyLoss: the number of TR radiator plates = "
           << fPlateNumber << G4endl;
  if(fPlateNumber == 0)
  {
    G4Exception("G4VXTRenergyLoss::G4VXTRenergyLoss()", "VXTRELoss01",
                FatalException, "No plates in X-ray TR radiator");
  }
  // default is XTR dEdx, not flux after radiator
  fExitFlux      = false;
  // default angle distribution according numerical integration
  fFastAngle     = false; // no angle according sum of delta-functions by default
  fAngleRadDistr = true;
  fCompton       = false;
 
  fLambda = DBL_MAX;
 
  // Mean thicknesses of plates and gas gaps
  fPlateThick = a;
  fGasThick   = b;
  fTotalDist  = fPlateNumber * (fPlateThick + fGasThick);
  if(verboseLevel > 0)
    G4cout << "total radiator thickness = " << fTotalDist / cm << " cm"
           << G4endl;
 
  // index of plate material
  fMatIndex1 = (G4int)foilMat->GetIndex();
  if(verboseLevel > 0)
    G4cout << "plate material = " << foilMat->GetName() << G4endl;
 
  // index of gas material
  fMatIndex2 = (G4int)gasMat->GetIndex();
  if(verboseLevel > 0)
    G4cout << "gas material = " << gasMat->GetName() << G4endl;
 
  // plasma energy squared for plate material
  fSigma1 = fPlasmaCof * foilMat->GetElectronDensity();
  if(verboseLevel > 0)
    G4cout << "plate plasma energy = " << std::sqrt(fSigma1) / eV << " eV"
           << G4endl;
 
  // plasma energy squared for gas material
  fSigma2 = fPlasmaCof * gasMat->GetElectronDensity();
  if(verboseLevel > 0)
    G4cout << "gas plasma energy = " << std::sqrt(fSigma2) / eV << " eV"
           << G4endl;
 
  // Compute cofs for preparation of linear photo absorption
  ComputePlatePhotoAbsCof();
  ComputeGasPhotoAbsCof();
 
  pParticleChange = &fParticleChange;
}

Referenced by BuildAngleForEnergyBank(), BuildEnergyTable(), BuildGlobalAngleTable(), G4GammaXTRadiator::G4GammaXTRadiator(), G4GaussXTRadiator::G4GaussXTRadiator(), G4RegularXTRadiator::G4RegularXTRadiator(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRGaussRadModel::G4XTRGaussRadModel(), G4XTRRegularRadModel::G4XTRRegularRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), operator=(), SpectralXTRdEdx(), XTRNAngleDensity(), and XTRNSpectralDensity().

◆ ~G4VXTRenergyLoss()

G4VXTRenergyLoss::~G4VXTRenergyLoss ( )

virtual

Definition at line 163 of file G4VXTRenergyLoss.cc.

{
  delete fProtonEnergyVector;
  delete fXTREnergyVector;
  if(fEnergyDistrTable)
  {
    fEnergyDistrTable->clearAndDestroy();
    delete fEnergyDistrTable;
  }
  if(fAngleRadDistr)
  {
    fAngleDistrTable->clearAndDestroy();
    delete fAngleDistrTable;
  }
  if(fAngleForEnergyTable)
  {
    fAngleForEnergyTable->clearAndDestroy();
    delete fAngleForEnergyTable;
  }
}

◆ G4VXTRenergyLoss() [2/2]

G4VXTRenergyLoss::G4VXTRenergyLoss ( G4VXTRenergyLoss & )

delete

Member Function Documentation

◆ AngleSpectralXTRdEdx()

G4double G4VXTRenergyLoss::AngleSpectralXTRdEdx ( G4double energy )

Definition at line 901 of file G4VXTRenergyLoss.cc.

{
  G4double result = GetStackFactor(energy, fGamma, fVarAngle);
  if(result < 0)
    result = 0.0;
  return result;
}

◆ AngleXTRdEdx()

G4double G4VXTRenergyLoss::AngleXTRdEdx ( G4double varAngle )

Definition at line 911 of file G4VXTRenergyLoss.cc.

{
  G4double result;
  G4double sum = 0., tmp1, tmp2, tmp = 0., cof1, cof2, cofMin, cofPHC, energy1,
           energy2;
  G4int k, kMax, kMin, i;
 
  cofPHC = twopi * hbarc;
 
  cof1 = (fPlateThick + fGasThick) * (1. / fGamma / fGamma + varAngle);
  cof2 = fPlateThick * fSigma1 + fGasThick * fSigma2;
 
  cofMin = std::sqrt(cof1 * cof2);
  cofMin /= cofPHC;
 
  kMin = G4int(cofMin);
  if(cofMin > kMin)
    kMin++;
 
  kMax = kMin + 9;
 
  for(k = kMin; k <= kMax; ++k)
  {
    tmp1    = cofPHC * k;
    tmp2    = std::sqrt(tmp1 * tmp1 - cof1 * cof2);
    energy1 = (tmp1 + tmp2) / cof1;
    energy2 = (tmp1 - tmp2) / cof1;
 
    for(i = 0; i < 2; ++i)
    {
      if(i == 0)
      {
        if(energy1 > fTheMaxEnergyTR || energy1 < fTheMinEnergyTR)
          continue;
 
        tmp1 =
          (energy1 * energy1 * (1. / fGamma / fGamma + varAngle) + fSigma1) *
          fPlateThick / (4 * hbarc * energy1);
        tmp2 = std::sin(tmp1);
        tmp  = energy1 * tmp2 * tmp2;
        tmp2 = fPlateThick / (4. * tmp1);
        tmp1 =
          hbarc * energy1 /
          (energy1 * energy1 * (1. / fGamma / fGamma + varAngle) + fSigma2);
        tmp *= (tmp1 - tmp2) * (tmp1 - tmp2);
        tmp1 = cof1 / (4. * hbarc) - cof2 / (4. * hbarc * energy1 * energy1);
        tmp2 = std::abs(tmp1);
 
        if(tmp2 > 0.)
          tmp /= tmp2;
        else
          continue;
      }
      else
      {
        if(energy2 > fTheMaxEnergyTR || energy2 < fTheMinEnergyTR)
          continue;
 
        tmp1 =
          (energy2 * energy2 * (1. / fGamma / fGamma + varAngle) + fSigma1) *
          fPlateThick / (4. * hbarc * energy2);
        tmp2 = std::sin(tmp1);
        tmp  = energy2 * tmp2 * tmp2;
        tmp2 = fPlateThick / (4. * tmp1);
        tmp1 =
          hbarc * energy2 /
          (energy2 * energy2 * (1. / fGamma / fGamma + varAngle) + fSigma2);
        tmp *= (tmp1 - tmp2) * (tmp1 - tmp2);
        tmp1 = cof1 / (4. * hbarc) - cof2 / (4. * hbarc * energy2 * energy2);
        tmp2 = std::abs(tmp1);
 
        if(tmp2 > 0.)
          tmp /= tmp2;
        else
          continue;
      }
      sum += tmp;
    }
  }
  result = 4. * pi * fPlateNumber * sum * varAngle;
  result /= hbarc * hbarc;
 
  return result;
}

Referenced by BuildGlobalAngleTable().

◆ BuildAngleForEnergyBank()

void G4VXTRenergyLoss::BuildAngleForEnergyBank ( )

Definition at line 390 of file G4VXTRenergyLoss.cc.

{
  
  if( ( this->GetProcessName() == "TranspRegXTRadiator" ||
        this->GetProcessName() == "TranspRegXTRmodel" ||
        this->GetProcessName() == "RegularXTRadiator" ||
    this->GetProcessName() == "RegularXTRmodel"  )       && fFastAngle    ) // ffastAngle=true!
  {
    BuildAngleTable(); // by sum of delta-functions
    return;
  }
  G4int i, iTkin, iTR;
  G4double angleSum = 0.0;
 
  fGammaTkinCut = 0.0;
 
  // setting of min/max TR energies
  if(fGammaTkinCut > fTheMinEnergyTR)
    fMinEnergyTR = fGammaTkinCut;
  else
    fMinEnergyTR = fTheMinEnergyTR;
 
  if(fGammaTkinCut > fTheMaxEnergyTR)
    fMaxEnergyTR = 2.0 * fGammaTkinCut;
  else
    fMaxEnergyTR = fTheMaxEnergyTR;
 
  auto energyVector =
    new G4PhysicsLogVector(fMinEnergyTR, fMaxEnergyTR, fBinTR);
 
  G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
    integral;
 
  G4cout.precision(4);
  G4Timer timer;
  timer.Start();
 
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
  {
    fGamma =
      1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) / proton_mass_c2);
 
    if(fMaxThetaTR > fTheMaxAngle)
      fMaxThetaTR = fTheMaxAngle;
    else if(fMaxThetaTR < fTheMinAngle)
      fMaxThetaTR = fTheMinAngle;
 
    fAngleForEnergyTable = new G4PhysicsTable(fBinTR);
 
    for(iTR = 0; iTR < fBinTR; ++iTR)
    {
      angleSum = 0.0;
      fEnergy  = energyVector->GetLowEdgeEnergy(iTR);
      
     // log-vector to increase number of thin bins for small angles
      auto angleVector = new G4PhysicsLogVector(fMinThetaTR, fMaxThetaTR, fBinTR);
 
      
 
      angleVector->PutValue(fBinTR - 1, angleSum);
 
      for(i = fBinTR - 2; i >= 0; --i)
      {
        // Legendre96 or Legendre10
 
        angleSum +=
          integral.Legendre10(this, &G4VXTRenergyLoss::SpectralAngleXTRdEdx,
                              angleVector->GetLowEdgeEnergy(i),
                              angleVector->GetLowEdgeEnergy(i + 1));
 
        angleVector->PutValue(i, angleSum);
      }
      fAngleForEnergyTable->insertAt(iTR, angleVector);
    }
    fAngleBank.push_back(fAngleForEnergyTable);
  }
  timer.Stop();
  G4cout.precision(6);
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "total time for build X-ray TR angle for energy loss tables = "
           << timer.GetUserElapsed() << " s" << G4endl;
  }
  fGamma = 0.;
  delete energyVector;
}

Referenced by BuildPhysicsTable().

◆ BuildAngleTable()

void G4VXTRenergyLoss::BuildAngleTable ( )

Definition at line 481 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin, iTR;
  G4double energy;
 
  fGammaTkinCut = 0.0;
 
  // setting of min/max TR energies
  if(fGammaTkinCut > fTheMinEnergyTR)
    fMinEnergyTR = fGammaTkinCut;
  else
    fMinEnergyTR = fTheMinEnergyTR;
 
  if(fGammaTkinCut > fTheMaxEnergyTR)
    fMaxEnergyTR = 2.0 * fGammaTkinCut;
  else
    fMaxEnergyTR = fTheMaxEnergyTR;
 
  G4cout.precision(4);
  G4Timer timer;
  timer.Start();
  if(verboseLevel > 0)
  {
    G4cout << G4endl << "Lorentz Factor" << "\t"
           << "XTR photon number" << G4endl << G4endl;
  }
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
  {
    fGamma =
      1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) / proton_mass_c2);
 
    // fMaxThetaTR = 25. * 2500.0 / (fGamma * fGamma);  // theta^2
 
    if(fMaxThetaTR > fTheMaxAngle)
      fMaxThetaTR = fTheMaxAngle;
    else
    {
      if(fMaxThetaTR < fTheMinAngle)
        fMaxThetaTR = fTheMinAngle;
    }
 
    fAngleForEnergyTable = new G4PhysicsTable(fBinTR);
 
    for(iTR = 0; iTR < fBinTR; ++iTR)
    {
      energy = fXTREnergyVector->GetLowEdgeEnergy(iTR);
 
      G4PhysicsFreeVector* angleVector = GetAngleVector(energy, fBinTR);
 
      fAngleForEnergyTable->insertAt(iTR, angleVector);
    }
    fAngleBank.push_back(fAngleForEnergyTable);
  }
  timer.Stop();
  G4cout.precision(6);
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "total time for build XTR angle for given energy tables = "
           << timer.GetUserElapsed() << " s" << G4endl;
  }
  fGamma = 0.;
 
  return;
}

Referenced by BuildAngleForEnergyBank().

◆ BuildEnergyTable()

void G4VXTRenergyLoss::BuildEnergyTable ( )

Definition at line 299 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin, iTR, iPlace;
  G4double radiatorCof = 1.0;  // for tuning of XTR yield
  G4double energySum   = 0.0;
 
  fEnergyDistrTable = new G4PhysicsTable(fTotBin);
  if(fAngleRadDistr)
    fAngleDistrTable = new G4PhysicsTable(fTotBin);
 
  fGammaTkinCut = 0.0;
 
  // setting of min/max TR energies
  if(fGammaTkinCut > fTheMinEnergyTR)
    fMinEnergyTR = fGammaTkinCut;
  else
    fMinEnergyTR = fTheMinEnergyTR;
 
  if(fGammaTkinCut > fTheMaxEnergyTR)
    fMaxEnergyTR = 2.0 * fGammaTkinCut;
  else
    fMaxEnergyTR = fTheMaxEnergyTR;
 
  G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
    integral;
 
  G4cout.precision(4);
  G4Timer timer;
  timer.Start();
 
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "Lorentz Factor"
           << "\t"
           << "XTR photon number" << G4endl;
    G4cout << G4endl;
  }
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
  {
    auto energyVector =
      new G4PhysicsLogVector(fMinEnergyTR, fMaxEnergyTR, fBinTR);
 
    fGamma =
      1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) / proton_mass_c2);
 
    // if(fMaxThetaTR > fTheMaxAngle)     fMaxThetaTR = fTheMaxAngle;
    // else if(fMaxThetaTR < fTheMinAngle)     fMaxThetaTR = fTheMinAngle;
 
    energySum = 0.0;
 
    energyVector->PutValue(fBinTR - 1, energySum);
 
    for(iTR = fBinTR - 2; iTR >= 0; --iTR)
    {
      // Legendre96 or Legendre10
 
      energySum += radiatorCof * fCofTR *
    
    // integral.Legendre10(this, &G4VXTRenergyLoss::SpectralXTRdEdx,
    
                   integral.Legendre96(this, &G4VXTRenergyLoss::SpectralXTRdEdx,
                       
                                       energyVector->GetLowEdgeEnergy(iTR),
                                       energyVector->GetLowEdgeEnergy(iTR + 1));
 
      energyVector->PutValue(iTR, energySum / fTotalDist);
    }
    iPlace = iTkin;
    fEnergyDistrTable->insertAt(iPlace, energyVector);
 
    if(verboseLevel > 0)
    {
      G4cout << fGamma << "\t" << energySum << G4endl;
    }
  }
  timer.Stop();
  G4cout.precision(6);
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "total time for build X-ray TR energy loss tables = "
           << timer.GetUserElapsed() << " s" << G4endl;
  }
  fGamma = 0.;
  return;
}

Referenced by BuildPhysicsTable().

◆ BuildGlobalAngleTable()

void G4VXTRenergyLoss::BuildGlobalAngleTable ( )

Definition at line 624 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin, iTR, iPlace;
  G4double radiatorCof = 1.0;  // for tuning of XTR yield
  G4double angleSum;
  fAngleDistrTable = new G4PhysicsTable(fTotBin);
 
  fGammaTkinCut = 0.0;
 
  // setting of min/max TR energies
  if(fGammaTkinCut > fTheMinEnergyTR)
    fMinEnergyTR = fGammaTkinCut;
  else
    fMinEnergyTR = fTheMinEnergyTR;
 
  if(fGammaTkinCut > fTheMaxEnergyTR)
    fMaxEnergyTR = 2.0 * fGammaTkinCut;
  else
    fMaxEnergyTR = fTheMaxEnergyTR;
 
  G4cout.precision(4);
  G4Timer timer;
  timer.Start();
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "Lorentz Factor"
           << "\t"
           << "XTR photon number" << G4endl;
    G4cout << G4endl;
  }
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
  {
    fGamma =
      1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) / proton_mass_c2);
 
    // fMaxThetaTR = 25.0 / (fGamma * fGamma);  // theta^2
    // fMaxThetaTR = 1.e-4;  // theta^2
 
    if(fMaxThetaTR > fTheMaxAngle)
      fMaxThetaTR = fTheMaxAngle;
    else
    {
      if(fMaxThetaTR < fTheMinAngle)
        fMaxThetaTR = fTheMinAngle;
    }
    auto angleVector =
    // G4PhysicsLogVector* angleVector =
      new G4PhysicsLinearVector(0.0, fMaxThetaTR, fBinTR);
    //  new G4PhysicsLogVector(1.e-8, fMaxThetaTR, fBinTR);
 
    angleSum = 0.0;
 
    G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
      integral;
 
    angleVector->PutValue(fBinTR - 1, angleSum);
 
    for(iTR = fBinTR - 2; iTR >= 0; --iTR)
    {
      angleSum += radiatorCof * fCofTR *
                  integral.Legendre96(this, &G4VXTRenergyLoss::AngleXTRdEdx,
                                      angleVector->GetLowEdgeEnergy(iTR),
                                      angleVector->GetLowEdgeEnergy(iTR + 1));
 
      angleVector->PutValue(iTR, angleSum);
    }
    if(verboseLevel > 1)
    {
      G4cout << fGamma << "\t" << angleSum << G4endl;
    }
    iPlace = iTkin;
    fAngleDistrTable->insertAt(iPlace, angleVector);
  }
  timer.Stop();
  G4cout.precision(6);
  if(verboseLevel > 0)
  {
    G4cout << G4endl;
    G4cout << "total time for build X-ray TR angle tables = "
           << timer.GetUserElapsed() << " s" << G4endl;
  }
  fGamma = 0.;
 
  return;
}

◆ BuildPhysicsTable()

void G4VXTRenergyLoss::BuildPhysicsTable ( const G4ParticleDefinition & pd )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 276 of file G4VXTRenergyLoss.cc.

{
  if(pd.GetPDGCharge() == 0.)
  {
    G4Exception("G4VXTRenergyLoss::BuildPhysicsTable", "Notification",
                JustWarning, "XTR initialisation for neutral particle ?!");
  }
  BuildEnergyTable();
 
  if(fAngleRadDistr)
  {
    if(verboseLevel > 0)
    {
      G4cout
        << "Build angle for energy distribution according the current radiator"
        << G4endl;
    }
    BuildAngleForEnergyBank();
  }
}

◆ BuildTable()

void G4VXTRenergyLoss::BuildTable ( )

inline

Definition at line 90 of file G4VXTRenergyLoss.hh.

90{};

◆ ComputeGasPhotoAbsCof()

void G4VXTRenergyLoss::ComputeGasPhotoAbsCof ( )

Definition at line 1086 of file G4VXTRenergyLoss.cc.

{
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  const G4Material* mat                   = (*theMaterialTable)[fMatIndex2];
  fGasPhotoAbsCof                         = mat->GetSandiaTable();
  return;
}

Referenced by G4VXTRenergyLoss().

◆ ComputePlatePhotoAbsCof()

void G4VXTRenergyLoss::ComputePlatePhotoAbsCof ( )

Definition at line 1028 of file G4VXTRenergyLoss.cc.

{
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  const G4Material* mat                   = (*theMaterialTable)[fMatIndex1];
  fPlatePhotoAbsCof                       = mat->GetSandiaTable();
 
  return;
}

Referenced by G4VXTRenergyLoss().

◆ DumpInfo()

virtual void G4VXTRenergyLoss::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4StrawTubeXTRadiator, G4TransparentRegXTRadiator, G4XTRGammaRadModel, G4XTRGaussRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 68 of file G4VXTRenergyLoss.hh.

68{ ProcessDescription(G4cout); };

G4VXTRenergyLoss::ProcessDescription

virtual void ProcessDescription(std::ostream &) const override

Definition G4VXTRenergyLoss.cc:184

◆ GetAlphaGas()

G4double G4VXTRenergyLoss::GetAlphaGas ( )

inline

Definition at line 159 of file G4VXTRenergyLoss.hh.

159{ return fAlphaGas; };

◆ GetAlphaPlate()

G4double G4VXTRenergyLoss::GetAlphaPlate ( )

inline

Definition at line 161 of file G4VXTRenergyLoss.hh.

161{ return fAlphaPlate; };

◆ GetAngleRadDistr()

G4bool G4VXTRenergyLoss::GetAngleRadDistr ( )

inline

Definition at line 188 of file G4VXTRenergyLoss.hh.

188{ return fAngleRadDistr; };

◆ GetAngleVector()

G4PhysicsFreeVector * G4VXTRenergyLoss::GetAngleVector	(	G4double	energy,
		G4int	n )

Definition at line 549 of file G4VXTRenergyLoss.cc.

{
  G4double theta = 0., result, tmp = 0., cof1, cof2, cofMin, cofPHC,
           angleSum = 0.;
  G4int iTheta, k, kMin;
 
  auto angleVector = new G4PhysicsFreeVector(n);
 
  cofPHC = 4. * pi * hbarc;
  tmp    = (fSigma1 - fSigma2) / cofPHC / energy;
  cof1   = fPlateThick * tmp;
  cof2   = fGasThick * tmp;
 
  cofMin = energy * (fPlateThick + fGasThick) / fGamma / fGamma;
  cofMin += (fPlateThick * fSigma1 + fGasThick * fSigma2) / energy;
  cofMin /= cofPHC;
 
  kMin = G4int(cofMin);
  if(cofMin > kMin)
    kMin++;
 
  if(verboseLevel > 2)
  {
    G4cout << "n-1 = " << n - 1
           << "; theta = " << std::sqrt(fMaxThetaTR) * fGamma
           << "; tmp = " << 0. << ";    angleSum = " << angleSum << G4endl;
  }
 
  for(iTheta = n - 1; iTheta >= 1; --iTheta)
  {
    k      = iTheta - 1 + kMin;
    tmp    = pi * fPlateThick * (k + cof2) / (fPlateThick + fGasThick);
    result = (k - cof1) * (k - cof1) * (k + cof2) * (k + cof2);
    tmp    = std::sin(tmp) * std::sin(tmp) * std::abs(k - cofMin) / result;
 
    if(k == kMin && kMin == G4int(cofMin))
    {
      // angleSum += 0.5 * tmp;
      angleSum += tmp; // ATLAS TB 
    }
    else if(iTheta == n - 1)
      ;
    else
    {
      angleSum += tmp;
    }
    theta = std::abs(k - cofMin) * cofPHC / energy / (fPlateThick + fGasThick);
 
    if(verboseLevel > 2)
    {
      G4cout << "iTheta = " << iTheta << "; k = " << k
             << "; theta = " << std::sqrt(theta) * fGamma << "; tmp = " << tmp
             << ";    angleSum = " << angleSum << G4endl;
    }
    angleVector->PutValue(iTheta, theta, angleSum);
  }
  if(theta > 0.)
  {
    // angleSum += 0.5 * tmp;
    angleSum += 0.;  // ATLAS TB
    theta     = 0.;
  }
  if(verboseLevel > 2)
  {
    G4cout << "iTheta = " << iTheta << "; theta = " << std::sqrt(theta) * fGamma
           << "; tmp = " << tmp << ";    angleSum = " << angleSum << G4endl;
  }
  angleVector->PutValue(iTheta, theta, angleSum);
 
  return angleVector;
}

Referenced by BuildAngleTable().

◆ GetAngleXTR()

G4double G4VXTRenergyLoss::GetAngleXTR	(	G4int	iTR,
		G4double	position,
		G4int	iAngle )

Definition at line 1491 of file G4VXTRenergyLoss.cc.

{
  G4double x1, x2, y1, y2, result;
 
  if( iTransfer == 0 )
  // if( iTransfer == 1 ) // ATLAS TB
  {
    result = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
  }
  else
  {
    y1 = (*(*fAngleForEnergyTable)(iPlace))(iTransfer - 1);
    y2 = (*(*fAngleForEnergyTable)(iPlace))(iTransfer);
 
    x1 = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 1);
    x2 = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
 
    if(x1 == x2) result = x2;
    else
    {
      if( y1 == y2 )  result = x1 + (x2 - x1) * G4UniformRand();
      else
      {
        result = x1 + (position - y1) * (x2 - x1) / (y2 - y1);
        // result = x1 + 0.1*(position - y1) * (x2 - x1) / (y2 - y1); // ATLAS TB
        // result = x1 + 0.05*(position - y1) * (x2 - x1) / (y2 - y1); // ATLAS TB
      }
    }
  }
  return result;
}

Referenced by GetRandomAngle().

◆ GetCompton()

G4bool G4VXTRenergyLoss::GetCompton ( )

inline

Definition at line 152 of file G4VXTRenergyLoss.hh.

152{ return fCompton; };

◆ GetComptonPerAtom()

G4double G4VXTRenergyLoss::GetComptonPerAtom	(	G4double	GammaEnergy,
		G4double	Z )

Definition at line 1227 of file G4VXTRenergyLoss.cc.

{
  G4double CrossSection = 0.0;
  if(Z < 0.9999)
    return CrossSection;
  if(GammaEnergy < 0.1 * keV)
    return CrossSection;
  if(GammaEnergy > (100. * GeV / Z))
    return CrossSection;
 
  static constexpr G4double a = 20.0;
  static constexpr G4double b = 230.0;
  static constexpr G4double c = 440.0;
 
  static constexpr G4double d1 = 2.7965e-1 * barn, d2 = -1.8300e-1 * barn,
                            d3 = 6.7527 * barn, d4 = -1.9798e+1 * barn,
                            e1 = 1.9756e-5 * barn, e2 = -1.0205e-2 * barn,
                            e3 = -7.3913e-2 * barn, e4 = 2.7079e-2 * barn,
                            f1 = -3.9178e-7 * barn, f2 = 6.8241e-5 * barn,
                            f3 = 6.0480e-5 * barn, f4 = 3.0274e-4 * barn;
 
  G4double p1Z = Z * (d1 + e1 * Z + f1 * Z * Z);
  G4double p2Z = Z * (d2 + e2 * Z + f2 * Z * Z);
  G4double p3Z = Z * (d3 + e3 * Z + f3 * Z * Z);
  G4double p4Z = Z * (d4 + e4 * Z + f4 * Z * Z);
 
  G4double T0 = 15.0 * keV;
  if(Z < 1.5)
    T0 = 40.0 * keV;
 
  G4double X = std::max(GammaEnergy, T0) / electron_mass_c2;
  CrossSection =
    p1Z * std::log(1. + 2. * X) / X +
    (p2Z + p3Z * X + p4Z * X * X) / (1. + a * X + b * X * X + c * X * X * X);
 
  //  modification for low energy. (special case for Hydrogen)
  if(GammaEnergy < T0)
  {
    G4double dT0 = 1. * keV;
    X            = (T0 + dT0) / electron_mass_c2;
    G4double sigma =
      p1Z * std::log(1. + 2. * X) / X +
      (p2Z + p3Z * X + p4Z * X * X) / (1. + a * X + b * X * X + c * X * X * X);
    G4double c1 = -T0 * (sigma - CrossSection) / (CrossSection * dT0);
    G4double c2 = 0.150;
    if(Z > 1.5)
      c2 = 0.375 - 0.0556 * std::log(Z);
    G4double y = std::log(GammaEnergy / T0);
    CrossSection *= std::exp(-y * (c1 + c2 * y));
  }
  return CrossSection;
}

Referenced by GetGasCompton(), and GetPlateCompton().

◆ GetEnergy()

G4double G4VXTRenergyLoss::GetEnergy ( )

inline

Definition at line 148 of file G4VXTRenergyLoss.hh.

148{ return fEnergy; };

◆ GetFastAngle()

G4bool G4VXTRenergyLoss::GetFastAngle ( )

inline

Definition at line 186 of file G4VXTRenergyLoss.hh.

186{ return fFastAngle; };

◆ GetGamma()

G4double G4VXTRenergyLoss::GetGamma ( )

inline

Definition at line 146 of file G4VXTRenergyLoss.hh.

146{ return fGamma; };

◆ GetGasComplexFZ()

G4complex G4VXTRenergyLoss::GetGasComplexFZ	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 1067 of file G4VXTRenergyLoss.cc.

{
  G4double cof, length, delta, real_v, image_v;
 
  length = 0.5 * GetGasFormationZone(omega, gamma, varAngle);
  delta  = length * GetGasLinearPhotoAbs(omega);
  cof    = 1.0 / (1.0 + delta * delta);
 
  real_v  = length * cof;
  image_v = real_v * delta;
 
  G4complex zone(real_v, image_v);
  return zone;
}

Referenced by G4GaussXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), and OneInterfaceXTRdEdx().

◆ GetGasCompton()

G4double G4VXTRenergyLoss::GetGasCompton ( G4double omega )

Definition at line 1206 of file G4VXTRenergyLoss.cc.

{
  G4double xSection = 0., sumZ = 0.;
 
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  G4int numberOfElements = (G4int)(*theMaterialTable)[fMatIndex2]->GetNumberOfElements();
 
  for (G4int i = 0; i < numberOfElements; ++i)
  {
    G4double nowZ = (*theMaterialTable)[fMatIndex2]->GetElement(i)->GetZ();
    sumZ += nowZ;
    xSection += GetComptonPerAtom(omega, nowZ);
  }
  if (sumZ > 0.0) { xSection /= sumZ; }
  xSection *= (*theMaterialTable)[fMatIndex2]->GetElectronDensity();
  return xSection;
}

Referenced by G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ GetGasFormationZone()

G4double G4VXTRenergyLoss::GetGasFormationZone	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 1056 of file G4VXTRenergyLoss.cc.

{
  G4double cof, lambda;
  lambda = 1.0 / gamma / gamma + varAngle + fSigma2 / omega / omega;
  cof    = 2.0 * hbarc / omega / lambda;
  return cof;
}

Referenced by GetGasComplexFZ(), GetGasZmuProduct(), G4GammaXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRRegularRadModel::GetStackFactor(), and G4XTRTransparentRegRadModel::GetStackFactor().

◆ GetGasLinearPhotoAbs()

G4double G4VXTRenergyLoss::GetGasLinearPhotoAbs ( G4double omega )

Definition at line 1097 of file G4VXTRenergyLoss.cc.

{
  G4double omega2, omega3, omega4;
 
  omega2 = omega * omega;
  omega3 = omega2 * omega;
  omega4 = omega2 * omega2;
 
  const G4double* SandiaCof = fGasPhotoAbsCof->GetSandiaCofForMaterial(omega);
  G4double cross            = SandiaCof[0] / omega + SandiaCof[1] / omega2 +
                   SandiaCof[2] / omega3 + SandiaCof[3] / omega4;
  return cross;
}

◆ GetGasZmuProduct() [1/2]

void G4VXTRenergyLoss::GetGasZmuProduct ( )

Definition at line 1160 of file G4VXTRenergyLoss.cc.

{
  std::ofstream outGas("gasZmu.dat", std::ios::out);
  outGas.setf(std::ios::scientific, std::ios::floatfield);
  G4int i;
  G4double omega, varAngle, gamma;
  gamma    = 10000.;
  varAngle = 1 / gamma / gamma;
  if(verboseLevel > 0)
    G4cout << "energy, keV" << "\t" << "Zmu for gas" << G4endl;
  for(i = 0; i < 100; ++i)
  {
    omega = (1.0 + i) * keV;
    if(verboseLevel > 1)
      G4cout << omega / keV << "\t" << GetGasZmuProduct(omega, gamma, varAngle)
             << "\t";
    if(verboseLevel > 0)
      outGas << omega / keV << "\t\t"
             << GetGasZmuProduct(omega, gamma, varAngle) << G4endl;
  }
  return;
}

Referenced by GetGasZmuProduct().

◆ GetGasZmuProduct() [2/2]

G4double G4VXTRenergyLoss::GetGasZmuProduct	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 1150 of file G4VXTRenergyLoss.cc.

{
  return GetGasFormationZone(omega, gamma, varAngle) *
         GetGasLinearPhotoAbs(omega);
}

◆ GetKrange()

G4int G4VXTRenergyLoss::GetKrange ( )

inline

Definition at line 154 of file G4VXTRenergyLoss.hh.

154{ return fKrange;};

◆ GetMaxEnergyTR()

G4double G4VXTRenergyLoss::GetMaxEnergyTR ( )

inline

Definition at line 171 of file G4VXTRenergyLoss.hh.

171{ return fMaxEnergyTR; };

◆ GetMaxThetaTR()

G4double G4VXTRenergyLoss::GetMaxThetaTR ( )

inline

Definition at line 181 of file G4VXTRenergyLoss.hh.

181{ return fMaxThetaTR; };

◆ GetMeanFreePath()

G4double G4VXTRenergyLoss::GetMeanFreePath	(	const G4Track &	aTrack,
		G4double	previousStepSize,
		G4ForceCondition *	condition )

overridevirtual

Implements G4VDiscreteProcess.

Definition at line 200 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin, iPlace;
  G4double lambda, sigma, kinEnergy, mass, gamma;
  G4double charge, chargeSq, massRatio, TkinScaled;
  G4double E1, E2, W, W1, W2;
 
  *condition = NotForced;
 
  if(aTrack.GetVolume()->GetLogicalVolume() != fEnvelope)
    lambda = DBL_MAX;
  else
  {
    const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
    kinEnergy                          = aParticle->GetKineticEnergy();
    mass  = aParticle->GetDefinition()->GetPDGMass();
    gamma = 1.0 + kinEnergy / mass;
    if(verboseLevel > 1)
    {
      G4cout << " gamma = " << gamma << ";   fGamma = " << fGamma << G4endl;
    }
 
    if(std::fabs(gamma - fGamma) < 0.05 * gamma)
      lambda = fLambda;
    else
    {
      charge     = aParticle->GetDefinition()->GetPDGCharge();
      chargeSq   = charge * charge;
      massRatio  = proton_mass_c2 / mass;
      TkinScaled = kinEnergy * massRatio;
 
      for(iTkin = 0; iTkin < fTotBin; ++iTkin)
      {
        if(TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin))
          break;
      }
      iPlace = iTkin - 1;
 
      if(iTkin == 0)
        lambda = DBL_MAX;  // Tkin is too small, neglect of TR photon generation
      else  // general case: Tkin between two vectors of the material
      {
        if(iTkin == fTotBin)
        {
          sigma = (*(*fEnergyDistrTable)(iPlace))(0) * chargeSq;
        }
        else
        {
          E1    = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
          E2    = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
          W     = 1.0 / (E2 - E1);
          W1    = (E2 - TkinScaled) * W;
          W2    = (TkinScaled - E1) * W;
          sigma = ((*(*fEnergyDistrTable)(iPlace))(0) * W1 +
                   (*(*fEnergyDistrTable)(iPlace + 1))(0) * W2) *
                  chargeSq;
        }
        if(sigma < DBL_MIN)
          lambda = DBL_MAX;
        else
          lambda = 1. / sigma;
        fLambda = lambda;
        fGamma  = gamma;
        if(verboseLevel > 1)
        {
          G4cout << " lambda = " << lambda / mm << " mm" << G4endl;
        }
      }
    }
  }
  return lambda;
}

◆ GetMinEnergyTR()

G4double G4VXTRenergyLoss::GetMinEnergyTR ( )

inline

Definition at line 169 of file G4VXTRenergyLoss.hh.

169{ return fMinEnergyTR; };

◆ GetMinThetaTR()

G4double G4VXTRenergyLoss::GetMinThetaTR ( )

inline

Definition at line 179 of file G4VXTRenergyLoss.hh.

179{ return fMinThetaTR; };

◆ GetNumberOfPhotons()

void G4VXTRenergyLoss::GetNumberOfPhotons ( )

Definition at line 1349 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin;
  G4double gamma, numberE;
 
  std::ofstream outEn("numberE.dat", std::ios::out);
  outEn.setf(std::ios::scientific, std::ios::floatfield);
 
  std::ofstream outAng("numberAng.dat", std::ios::out);
  outAng.setf(std::ios::scientific, std::ios::floatfield);
 
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
  {
    gamma =
      1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) / proton_mass_c2);
    numberE = (*(*fEnergyDistrTable)(iTkin))(0);
    if(verboseLevel > 1)
      G4cout << gamma << "\t\t" << numberE << "\t" << G4endl;
    if(verboseLevel > 0)
      outEn << gamma << "\t\t" << numberE << G4endl;
  }
  return;
}

◆ GetPlateComplexFZ()

G4complex G4VXTRenergyLoss::GetPlateComplexFZ	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 1009 of file G4VXTRenergyLoss.cc.

{
  G4double cof, length, delta, real_v, image_v;
 
  length = 0.5 * GetPlateFormationZone(omega, gamma, varAngle);
  delta  = length * GetPlateLinearPhotoAbs(omega);
  cof    = 1.0 / (1.0 + delta * delta);
 
  real_v  = length * cof;
  image_v = real_v * delta;
 
  G4complex zone(real_v, image_v);
  return zone;
}

Referenced by G4GaussXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), and OneInterfaceXTRdEdx().

◆ GetPlateCompton()

G4double G4VXTRenergyLoss::GetPlateCompton ( G4double omega )

Definition at line 1185 of file G4VXTRenergyLoss.cc.

{
  G4int i, numberOfElements;
  G4double xSection = 0., nowZ, sumZ = 0.;
 
  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
  numberOfElements = (G4int)(*theMaterialTable)[fMatIndex1]->GetNumberOfElements();
 
  for(i = 0; i < numberOfElements; ++i)
  {
    nowZ = (*theMaterialTable)[fMatIndex1]->GetElement(i)->GetZ();
    sumZ += nowZ;
    xSection += GetComptonPerAtom(omega, nowZ);
  }
  xSection /= sumZ;
  xSection *= (*theMaterialTable)[fMatIndex1]->GetElectronDensity();
  return xSection;
}

Referenced by G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ GetPlateFormationZone()

G4double G4VXTRenergyLoss::GetPlateFormationZone	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 998 of file G4VXTRenergyLoss.cc.

{
  G4double cof, lambda;
  lambda = 1.0 / gamma / gamma + varAngle + fSigma1 / omega / omega;
  cof    = 2.0 * hbarc / omega / lambda;
  return cof;
}

Referenced by GetPlateComplexFZ(), GetPlateZmuProduct(), G4GammaXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRRegularRadModel::GetStackFactor(), and G4XTRTransparentRegRadModel::GetStackFactor().

◆ GetPlateLinearPhotoAbs()

G4double G4VXTRenergyLoss::GetPlateLinearPhotoAbs ( G4double omega )

Definition at line 1040 of file G4VXTRenergyLoss.cc.

{
  G4double omega2, omega3, omega4;
 
  omega2 = omega * omega;
  omega3 = omega2 * omega;
  omega4 = omega2 * omega2;
 
  const G4double* SandiaCof = fPlatePhotoAbsCof->GetSandiaCofForMaterial(omega);
  G4double cross            = SandiaCof[0] / omega + SandiaCof[1] / omega2 +
                   SandiaCof[2] / omega3 + SandiaCof[3] / omega4;
  return cross;
}

◆ GetPlateZmuProduct() [1/2]

void G4VXTRenergyLoss::GetPlateZmuProduct ( )

Definition at line 1123 of file G4VXTRenergyLoss.cc.

{
  std::ofstream outPlate("plateZmu.dat", std::ios::out);
  outPlate.setf(std::ios::scientific, std::ios::floatfield);
 
  G4int i;
  G4double omega, varAngle, gamma;
  gamma    = 10000.;
  varAngle = 1 / gamma / gamma;
  if(verboseLevel > 0)
    G4cout << "energy, keV" << "\t" << "Zmu for plate" << G4endl;
  for(i = 0; i < 100; ++i)
  {
    omega = (1.0 + i) * keV;
    if(verboseLevel > 1)
      G4cout << omega / keV << "\t"
             << GetPlateZmuProduct(omega, gamma, varAngle) << "\t";
    if(verboseLevel > 0)
      outPlate << omega / keV << "\t\t"
               << GetPlateZmuProduct(omega, gamma, varAngle) << G4endl;
  }
  return;
}

Referenced by GetPlateZmuProduct().

◆ GetPlateZmuProduct() [2/2]

G4double G4VXTRenergyLoss::GetPlateZmuProduct	(	G4double	omega,
		G4double	gamma,
		G4double	varAngle )

Definition at line 1114 of file G4VXTRenergyLoss.cc.

{
  return GetPlateFormationZone(omega, gamma, varAngle) *
         GetPlateLinearPhotoAbs(omega);
}

◆ GetProtonVector()

G4PhysicsLogVector * G4VXTRenergyLoss::GetProtonVector ( )

inline

Definition at line 193 of file G4VXTRenergyLoss.hh.

193{ return fProtonEnergyVector; };

◆ GetRandomAngle()

G4double G4VXTRenergyLoss::GetRandomAngle	(	G4double	energyXTR,
		G4int	iTkin )

Definition at line 1456 of file G4VXTRenergyLoss.cc.

{
  G4int iTR, iAngle;
  G4double position, angle;
 
  if(iTkin == fTotBin)
    --iTkin;
 
  fAngleForEnergyTable = fAngleBank[iTkin];
 
  for(iTR = 0; iTR < fBinTR; ++iTR)
  {
    if(energyXTR < fXTREnergyVector->GetLowEdgeEnergy(iTR))
      break;
  }
  if(iTR == fBinTR)
    --iTR;
 
  position = (*(*fAngleForEnergyTable)(iTR))(0) * G4UniformRand();
  // position = (*(*fAngleForEnergyTable)(iTR))(1) * G4UniformRand(); // ATLAS TB
 
  for(iAngle = 0;; ++iAngle)
  // for(iAngle = 1;; ++iAngle) // ATLAS TB
  {
    if(position >= (*(*fAngleForEnergyTable)(iTR))(iAngle))
      break;
  }
  angle = GetAngleXTR(iTR, position, iAngle);
  return angle;
}

Referenced by PostStepDoIt().

◆ GetStackFactor()

G4double G4VXTRenergyLoss::GetStackFactor	(	G4double	energy,
		G4double	gamma,
		G4double	varAngle )

virtual

Reimplemented in G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4StrawTubeXTRadiator, G4TransparentRegXTRadiator, G4XTRGammaRadModel, G4XTRGaussRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 1300 of file G4VXTRenergyLoss.cc.

{
  // return stack factor corresponding to one interface
  return std::real(OneInterfaceXTRdEdx(energy, gamma, varAngle));
}

Referenced by AngleSpectralXTRdEdx(), SpectralAngleXTRdEdx(), XTRNAngleSpectralDensity(), and XTRNSpectralAngleDensity().

◆ GetTheMaxAngle()

G4double G4VXTRenergyLoss::GetTheMaxAngle ( )

inline

Definition at line 176 of file G4VXTRenergyLoss.hh.

176{ return fTheMaxAngle; };

◆ GetTheMaxEnergyTR()

G4double G4VXTRenergyLoss::GetTheMaxEnergyTR ( )

inline

Definition at line 166 of file G4VXTRenergyLoss.hh.

166{ return fTheMaxEnergyTR; };

◆ GetTheMinAngle()

G4double G4VXTRenergyLoss::GetTheMinAngle ( )

inline

Definition at line 174 of file G4VXTRenergyLoss.hh.

174{ return fTheMinAngle; };

◆ GetTheMinEnergyTR()

G4double G4VXTRenergyLoss::GetTheMinEnergyTR ( )

inline

Definition at line 164 of file G4VXTRenergyLoss.hh.

164{ return fTheMinEnergyTR; };

◆ GetTotBin()

G4int G4VXTRenergyLoss::GetTotBin ( )

inline

Definition at line 194 of file G4VXTRenergyLoss.hh.

194{ return fTotBin; };

◆ GetVarAngle()

G4double G4VXTRenergyLoss::GetVarAngle ( )

inline

Definition at line 150 of file G4VXTRenergyLoss.hh.

150{ return fVarAngle; };

◆ GetXTRenergy()

G4double G4VXTRenergyLoss::GetXTRenergy	(	G4int	iPlace,
		G4double	position,
		G4int	iTransfer )

Definition at line 1422 of file G4VXTRenergyLoss.cc.

{
  G4double x1, x2, y1, y2, result;
 
  if(iTransfer == 0)
  {
    result = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
  }
  else
  {
    y1 = (*(*fEnergyDistrTable)(iPlace))(iTransfer - 1);
    y2 = (*(*fEnergyDistrTable)(iPlace))(iTransfer);
 
    x1 = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 1);
    x2 = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
 
    if(x1 == x2)
      result = x2;
    else
    {
      if(y1 == y2)
        result = x1 + (x2 - x1) * G4UniformRand();
      else
      {
        result = x1 + (x2 - x1) * G4UniformRand();
      }
    }
  }
  return result;
}

Referenced by GetXTRrandomEnergy().

◆ GetXTRrandomEnergy()

G4double G4VXTRenergyLoss::GetXTRrandomEnergy	(	G4double	scaledTkin,
		G4int	iTkin )

Definition at line 1376 of file G4VXTRenergyLoss.cc.

{
  G4int iTransfer, iPlace;
  G4double transfer = 0.0, position, E1, E2, W1, W2, W;
 
  iPlace = iTkin - 1;
 
  if(iTkin == fTotBin)  // relativistic plato, try from left
  {
    position = (*(*fEnergyDistrTable)(iPlace))(0) * G4UniformRand();
 
    for(iTransfer = 0;; ++iTransfer)
    {
      if(position >= (*(*fEnergyDistrTable)(iPlace))(iTransfer))
        break;
    }
    transfer = GetXTRenergy(iPlace, position, iTransfer);
  }
  else
  {
    E1 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
    E2 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
    W  = 1.0 / (E2 - E1);
    W1 = (E2 - scaledTkin) * W;
    W2 = (scaledTkin - E1) * W;
 
    position = ((*(*fEnergyDistrTable)(iPlace))(0) * W1 +
                (*(*fEnergyDistrTable)(iPlace + 1))(0) * W2) *
               G4UniformRand();
 
    for(iTransfer = 0;; ++iTransfer)
    {
      if(position >= ((*(*fEnergyDistrTable)(iPlace))(iTransfer) *W1 +
                      (*(*fEnergyDistrTable)(iPlace + 1))(iTransfer) *W2))
        break;
    }
    transfer = GetXTRenergy(iPlace, position, iTransfer);
  }
  if(transfer < 0.0)
    transfer = 0.0;
  return transfer;
}

Referenced by PostStepDoIt().

◆ IsApplicable()

G4bool G4VXTRenergyLoss::IsApplicable ( const G4ParticleDefinition & particle )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 193 of file G4VXTRenergyLoss.cc.

{
  return (particle.GetPDGCharge() != 0.0);
}

◆ OneBoundaryXTRNdensity()

G4double G4VXTRenergyLoss::OneBoundaryXTRNdensity	(	G4double	energy,
		G4double	gamma,
		G4double	varAngle ) const

Definition at line 1287 of file G4VXTRenergyLoss.cc.

{
  G4double formationLength1, formationLength2;
  formationLength1 =
    1.0 / (1.0 / (gamma * gamma) + fSigma1 / (energy * energy) + varAngle);
  formationLength2 =
    1.0 / (1.0 / (gamma * gamma) + fSigma2 / (energy * energy) + varAngle);
  return (varAngle / energy) * (formationLength1 - formationLength2) *
         (formationLength1 - formationLength2);
}

Referenced by XTRNAngleSpectralDensity(), and XTRNSpectralAngleDensity().

◆ OneInterfaceXTRdEdx()

G4complex G4VXTRenergyLoss::OneInterfaceXTRdEdx	(	G4double	energy,
		G4double	gamma,
		G4double	varAngle )

Definition at line 852 of file G4VXTRenergyLoss.cc.

{
  G4complex Z1 = GetPlateComplexFZ(energy, gamma, varAngle);
  G4complex Z2 = GetGasComplexFZ(energy, gamma, varAngle);
 
  G4complex zOut = (Z1 - Z2) * (Z1 - Z2) * (varAngle * energy / hbarc / hbarc);
  return zOut;
}

Referenced by G4GammaXTRadiator::GetStackFactor(), G4GaussXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), G4XTRRegularRadModel::GetStackFactor(), and G4XTRTransparentRegRadModel::GetStackFactor().

◆ operator=()

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

delete

◆ PostStepDoIt()

G4VParticleChange * G4VXTRenergyLoss::PostStepDoIt	(	const G4Track &	aTrack,
		const G4Step &	aStep )

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 714 of file G4VXTRenergyLoss.cc.

{
  G4int iTkin;
  G4double energyTR, theta, theta2, phi, dirX, dirY, dirZ;
 
  fParticleChange.Initialize(aTrack);
 
  if(verboseLevel > 1)
  {
    G4cout << "Start of G4VXTRenergyLoss::PostStepDoIt " << G4endl;
    G4cout << "name of current material =  "
           << aTrack.GetVolume()->GetLogicalVolume()->GetMaterial()->GetName()
           << G4endl;
  }
  if(aTrack.GetVolume()->GetLogicalVolume() != fEnvelope)
  {
    if(verboseLevel > 0)
    {
      G4cout << "Go out from G4VXTRenergyLoss::PostStepDoIt: wrong volume "
             << G4endl;
    }
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  else
  {
    G4StepPoint* pPostStepPoint        = aStep.GetPostStepPoint();
    const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
 
    // Now we are ready to Generate one TR photon
    G4double kinEnergy = aParticle->GetKineticEnergy();
    G4double mass      = aParticle->GetDefinition()->GetPDGMass();
    G4double gamma     = 1.0 + kinEnergy / mass;
 
    if(verboseLevel > 1)
    {
      G4cout << "gamma = " << gamma << G4endl;
    }
    G4double massRatio           = proton_mass_c2 / mass;
    G4double TkinScaled          = kinEnergy * massRatio;
    G4ThreeVector position       = pPostStepPoint->GetPosition();
    G4ParticleMomentum direction = aParticle->GetMomentumDirection();
    G4double startTime           = pPostStepPoint->GetGlobalTime();
 
    for(iTkin = 0; iTkin < fTotBin; ++iTkin)
    {
      if(TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin))
        break;
    }
 
    if(iTkin == 0)  // Tkin is too small, neglect of TR photon generation
    {
      if(verboseLevel > 0)
      {
        G4cout << "Go out from G4VXTRenergyLoss::PostStepDoIt:iTkin = " << iTkin
               << G4endl;
      }
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else  // general case: Tkin between two vectors of the material
    {
      fParticleChange.SetNumberOfSecondaries(1);
 
      energyTR = GetXTRrandomEnergy(TkinScaled, iTkin);
 
      if(verboseLevel > 1)
      {
        G4cout << "energyTR = " << energyTR / keV << " keV" << G4endl;
      }
      if(fAngleRadDistr)
      {
        theta2 = GetRandomAngle(energyTR, iTkin);
        if(theta2 > 0.)
          theta = std::sqrt(theta2);
        else
          theta = 0.;
      }
      else
        theta = std::fabs(G4RandGauss::shoot(0.0, pi / gamma));
 
      if(theta >= 0.1)
        theta = 0.1;
 
      phi = twopi * G4UniformRand();
 
      dirX = std::sin(theta) * std::cos(phi);
      dirY = std::sin(theta) * std::sin(phi);
      dirZ = std::cos(theta);
 
      G4ThreeVector directionTR(dirX, dirY, dirZ);
      directionTR.rotateUz(direction);
      directionTR.unit();
 
      auto aPhotonTR =
        new G4DynamicParticle(G4Gamma::Gamma(), directionTR, energyTR);
 
      // A XTR photon is set on the particle track inside the radiator
      // and is moved to the G4Envelope surface for standard X-ray TR models
      // only. The case of fExitFlux=true
 
      if(fExitFlux)
      {
        const G4RotationMatrix* rotM =
          pPostStepPoint->GetTouchable()->GetRotation();
        G4ThreeVector transl = pPostStepPoint->GetTouchable()->GetTranslation();
        G4AffineTransform transform = G4AffineTransform(rotM, transl);
        transform.Invert();
        G4ThreeVector localP = transform.TransformPoint(position);
        G4ThreeVector localV = transform.TransformAxis(directionTR);
 
        G4double distance =
          fEnvelope->GetSolid()->DistanceToOut(localP, localV);
        if(verboseLevel > 1)
        {
          G4cout << "distance to exit = " << distance / mm << " mm" << G4endl;
        }
        position += distance * directionTR;
        startTime += distance / c_light;
      }
      G4Track* aSecondaryTrack = new G4Track(aPhotonTR, startTime, position);
      aSecondaryTrack->SetTouchableHandle(
        aStep.GetPostStepPoint()->GetTouchableHandle());
      aSecondaryTrack->SetParentID(aTrack.GetTrackID());
 
      fParticleChange.AddSecondary(aSecondaryTrack);
      fParticleChange.ProposeEnergy(kinEnergy);
    }
  }
  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
}

◆ ProcessDescription()

void G4VXTRenergyLoss::ProcessDescription ( std::ostream & out ) const

overridevirtual

Reimplemented from G4VProcess.

Reimplemented in G4GammaXTRadiator, G4GaussXTRadiator, G4RegularXTRadiator, G4StrawTubeXTRadiator, G4TransparentRegXTRadiator, G4XTRGammaRadModel, G4XTRGaussRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 184 of file G4VXTRenergyLoss.cc.

{
  out << "Base class for 'fast' parameterisation model describing X-ray "
         "transition\n"
         "radiation. Angular distribution is very rough.\n";
}

Referenced by DumpInfo().

◆ SetAlphaGas()

void G4VXTRenergyLoss::SetAlphaGas ( G4double ag )

inline

Definition at line 158 of file G4VXTRenergyLoss.hh.

158{ fAlphaGas = ag;};

◆ SetAlphaPlate()

void G4VXTRenergyLoss::SetAlphaPlate ( G4double ap )

inline

Definition at line 160 of file G4VXTRenergyLoss.hh.

160{ fAlphaPlate = ap;};

G4InuclParticleNames::ap

@ ap

Definition G4InuclParticleNames.hh:64

◆ SetAngleRadDistr()

void G4VXTRenergyLoss::SetAngleRadDistr ( G4bool fatr )

inline

Definition at line 187 of file G4VXTRenergyLoss.hh.

187{ fAngleRadDistr = fatr;};

◆ SetCompton()

void G4VXTRenergyLoss::SetCompton ( G4bool pC )

inline

Definition at line 151 of file G4VXTRenergyLoss.hh.

151{ fCompton = pC; };

◆ SetEnergy()

void G4VXTRenergyLoss::SetEnergy ( G4double energy )

inline

Definition at line 147 of file G4VXTRenergyLoss.hh.

147{ fEnergy = energy; };

◆ SetFastAngle()

void G4VXTRenergyLoss::SetFastAngle ( G4bool fatr )

inline

Definition at line 185 of file G4VXTRenergyLoss.hh.

185{ fFastAngle = fatr;};

◆ SetGamma()

void G4VXTRenergyLoss::SetGamma ( G4double gamma )

inline

Definition at line 145 of file G4VXTRenergyLoss.hh.

145{ fGamma = gamma; };

◆ SetKrange()

void G4VXTRenergyLoss::SetKrange ( G4int kk )

inline

Definition at line 155 of file G4VXTRenergyLoss.hh.

155{ fKrange = kk;};

◆ SetMaxEnergyTR()

void G4VXTRenergyLoss::SetMaxEnergyTR ( G4double maxetr )

inline

Definition at line 170 of file G4VXTRenergyLoss.hh.

170{ fMaxEnergyTR = maxetr;};

◆ SetMaxThetaTR()

void G4VXTRenergyLoss::SetMaxThetaTR ( G4double maxatr )

inline

Definition at line 180 of file G4VXTRenergyLoss.hh.

180{ fMaxThetaTR = maxatr;};

◆ SetMinEnergyTR()

void G4VXTRenergyLoss::SetMinEnergyTR ( G4double minetr )

inline

Definition at line 168 of file G4VXTRenergyLoss.hh.

168{ fMinEnergyTR = minetr;};

◆ SetMinThetaTR()

void G4VXTRenergyLoss::SetMinThetaTR ( G4double minatr )

inline

Definition at line 178 of file G4VXTRenergyLoss.hh.

178{ fMinThetaTR = minatr;};

◆ SetTheMaxAngle()

void G4VXTRenergyLoss::SetTheMaxAngle ( G4double maxang )

inline

Definition at line 175 of file G4VXTRenergyLoss.hh.

175{ fTheMaxAngle = maxang;};

◆ SetTheMaxEnergyTR()

void G4VXTRenergyLoss::SetTheMaxEnergyTR ( G4double maxetr )

inline

Definition at line 165 of file G4VXTRenergyLoss.hh.

165{ fTheMaxEnergyTR = maxetr;};

◆ SetTheMinAngle()

void G4VXTRenergyLoss::SetTheMinAngle ( G4double minang )

inline

Definition at line 173 of file G4VXTRenergyLoss.hh.

173{ fTheMinAngle = minang;};

◆ SetTheMinEnergyTR()

void G4VXTRenergyLoss::SetTheMinEnergyTR ( G4double minetr )

inline

Definition at line 163 of file G4VXTRenergyLoss.hh.

163{ fTheMinEnergyTR = minetr;};

◆ SetVarAngle()

void G4VXTRenergyLoss::SetVarAngle ( G4double varAngle )

inline

Definition at line 149 of file G4VXTRenergyLoss.hh.

149{ fVarAngle = varAngle; };

◆ SpectralAngleXTRdEdx()

G4double G4VXTRenergyLoss::SpectralAngleXTRdEdx ( G4double varAngle )

Definition at line 864 of file G4VXTRenergyLoss.cc.

{
  G4double result = GetStackFactor(fEnergy, fGamma, varAngle);
  if(result < 0.0)
    result = 0.0;
  return result;
}

Referenced by BuildAngleForEnergyBank(), and SpectralXTRdEdx().

◆ SpectralXTRdEdx()

G4double G4VXTRenergyLoss::SpectralXTRdEdx ( G4double energy )

virtual

Reimplemented in G4GaussXTRadiator, G4RegularXTRadiator, G4TransparentRegXTRadiator, G4XTRGaussRadModel, G4XTRRegularRadModel, and G4XTRTransparentRegRadModel.

Definition at line 874 of file G4VXTRenergyLoss.cc.

{
  G4int i;
  static constexpr G4int iMax = 8;
  G4double angleSum           = 0.0;
 
  G4double lim[iMax] = { 0.0, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0 };
 
  for(i = 0; i < iMax; ++i)
    lim[i] *= fMaxThetaTR;
 
  G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
    integral;
 
  fEnergy = energy;
  {
    for(i = 0; i < iMax - 1; ++i)
    {
      angleSum += integral.Legendre96(
        this, &G4VXTRenergyLoss::SpectralAngleXTRdEdx, lim[i], lim[i + 1]);
    }
  }
  return angleSum;
}

Referenced by BuildEnergyTable().

◆ XTRNAngleDensity()

G4double G4VXTRenergyLoss::XTRNAngleDensity ( G4double varAngle )

Definition at line 1337 of file G4VXTRenergyLoss.cc.

{
  fVarAngle = varAngle;
  G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
    integral;
  return integral.Legendre96(this, &G4VXTRenergyLoss::XTRNAngleSpectralDensity,
                             fMinEnergyTR, fMaxEnergyTR);
}

◆ XTRNAngleSpectralDensity()

G4double G4VXTRenergyLoss::XTRNAngleSpectralDensity ( G4double energy )

Definition at line 1330 of file G4VXTRenergyLoss.cc.

{
  return OneBoundaryXTRNdensity(energy, fGamma, fVarAngle) *
         GetStackFactor(energy, fGamma, fVarAngle);
}

Referenced by XTRNAngleDensity().

◆ XTRNSpectralAngleDensity()

G4double G4VXTRenergyLoss::XTRNSpectralAngleDensity ( G4double varAngle )

Definition at line 1309 of file G4VXTRenergyLoss.cc.

{
  return OneBoundaryXTRNdensity(fEnergy, fGamma, varAngle) *
         GetStackFactor(fEnergy, fGamma, varAngle);
}

Referenced by XTRNSpectralDensity().

◆ XTRNSpectralDensity()

G4double G4VXTRenergyLoss::XTRNSpectralDensity ( G4double energy )

Definition at line 1317 of file G4VXTRenergyLoss.cc.

{
  fEnergy = energy;
  G4Integrator<G4VXTRenergyLoss, G4double (G4VXTRenergyLoss::*)(G4double)>
    integral;
  return integral.Legendre96(this, &G4VXTRenergyLoss::XTRNSpectralAngleDensity,
                             0.0, 0.2 * fMaxThetaTR) +
         integral.Legendre10(this, &G4VXTRenergyLoss::XTRNSpectralAngleDensity,
                             0.2 * fMaxThetaTR, fMaxThetaTR);
}

Member Data Documentation

◆ fAlphaGas

G4double G4VXTRenergyLoss::fAlphaGas

protected

Definition at line 243 of file G4VXTRenergyLoss.hh.

Referenced by G4GammaXTRadiator::G4GammaXTRadiator(), G4GaussXTRadiator::G4GaussXTRadiator(), G4RegularXTRadiator::G4RegularXTRadiator(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRGaussRadModel::G4XTRGaussRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), GetAlphaGas(), G4GammaXTRadiator::GetStackFactor(), G4GaussXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), and SetAlphaGas().

◆ fAlphaPlate

G4double G4VXTRenergyLoss::fAlphaPlate

protected

Definition at line 242 of file G4VXTRenergyLoss.hh.

Referenced by G4GammaXTRadiator::G4GammaXTRadiator(), G4GaussXTRadiator::G4GaussXTRadiator(), G4RegularXTRadiator::G4RegularXTRadiator(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRGaussRadModel::G4XTRGaussRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), GetAlphaPlate(), G4GammaXTRadiator::GetStackFactor(), G4GaussXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), and SetAlphaPlate().

◆ fAngleBank

std::vector<G4PhysicsTable*> G4VXTRenergyLoss::fAngleBank

protected

Definition at line 233 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), and GetRandomAngle().

◆ fAngleDistrTable

G4PhysicsTable* G4VXTRenergyLoss::fAngleDistrTable

protected

Definition at line 224 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), and ~G4VXTRenergyLoss().

◆ fAngleForEnergyTable

G4PhysicsTable* G4VXTRenergyLoss::fAngleForEnergyTable

protected

Definition at line 226 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), G4VXTRenergyLoss(), GetRandomAngle(), and ~G4VXTRenergyLoss().

◆ fAngleRadDistr

G4bool G4VXTRenergyLoss::fAngleRadDistr

protected

Definition at line 256 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), BuildPhysicsTable(), G4VXTRenergyLoss(), GetAngleRadDistr(), PostStepDoIt(), SetAngleRadDistr(), and ~G4VXTRenergyLoss().

◆ fBinTR

G4int G4VXTRenergyLoss::fBinTR

protected

Definition at line 218 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), and GetRandomAngle().

◆ fCofTR

G4double G4VXTRenergyLoss::fCofTR = CLHEP::fine_structure_const / CLHEP::pi

staticconstexprprotected

Definition at line 215 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), and BuildGlobalAngleTable().

◆ fCompton

G4bool G4VXTRenergyLoss::fCompton

protected

Definition at line 257 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), GetCompton(), SetCompton(), and G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ fEnergy

G4double G4VXTRenergyLoss::fEnergy

protected

Definition at line 245 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), G4VXTRenergyLoss(), GetEnergy(), SetEnergy(), SpectralAngleXTRdEdx(), SpectralXTRdEdx(), XTRNSpectralAngleDensity(), and XTRNSpectralDensity().

◆ fEnergyDistrTable

G4PhysicsTable* G4VXTRenergyLoss::fEnergyDistrTable

protected

Definition at line 225 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), G4VXTRenergyLoss(), GetXTRrandomEnergy(), and ~G4VXTRenergyLoss().

◆ fEnvelope

G4LogicalVolume* G4VXTRenergyLoss::fEnvelope

protected

Definition at line 223 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), GetMeanFreePath(), and PostStepDoIt().

◆ fExitFlux

G4bool G4VXTRenergyLoss::fExitFlux

protected

Definition at line 255 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRGaussRadModel::G4XTRGaussRadModel(), G4XTRRegularRadModel::G4XTRRegularRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), and PostStepDoIt().

◆ fFastAngle

G4bool G4VXTRenergyLoss::fFastAngle

protected

Definition at line 256 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), G4VXTRenergyLoss(), GetFastAngle(), and SetFastAngle().

◆ fGamma

◆ fGammaCutInKineticEnergy

G4double* G4VXTRenergyLoss::fGammaCutInKineticEnergy

protected

Definition at line 222 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

◆ fGammaTkinCut

G4double G4VXTRenergyLoss::fGammaTkinCut

protected

Definition at line 235 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

◆ fGasPhotoAbsCof

G4SandiaTable* G4VXTRenergyLoss::fGasPhotoAbsCof

protected

Definition at line 230 of file G4VXTRenergyLoss.hh.

Referenced by ComputeGasPhotoAbsCof(), G4VXTRenergyLoss(), and GetGasLinearPhotoAbs().

◆ fGasThick

G4double G4VXTRenergyLoss::fGasThick

protected

◆ fKrange

G4int G4VXTRenergyLoss::fKrange

protected

Definition at line 219 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), GetKrange(), SetKrange(), and G4GaussXTRadiator::SpectralXTRdEdx().

◆ fLambda

G4double G4VXTRenergyLoss::fLambda

protected

Definition at line 247 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), and GetMeanFreePath().

◆ fMatIndex1

G4int G4VXTRenergyLoss::fMatIndex1

protected

Definition at line 251 of file G4VXTRenergyLoss.hh.

Referenced by ComputePlatePhotoAbsCof(), G4VXTRenergyLoss(), and GetPlateCompton().

◆ fMatIndex2

G4int G4VXTRenergyLoss::fMatIndex2

protected

Definition at line 252 of file G4VXTRenergyLoss.hh.

Referenced by ComputeGasPhotoAbsCof(), G4VXTRenergyLoss(), and GetGasCompton().

◆ fMaxEnergyTR

G4double G4VXTRenergyLoss::fMaxEnergyTR

protected

Definition at line 237 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMaxEnergyTR(), SetMaxEnergyTR(), and XTRNAngleDensity().

◆ fMaxProtonTkin

G4double G4VXTRenergyLoss::fMaxProtonTkin = 100. * CLHEP::TeV

staticconstexprprotected

Definition at line 210 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

◆ fMaxThetaTR

G4double G4VXTRenergyLoss::fMaxThetaTR

protected

Definition at line 238 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetAngleVector(), GetMaxThetaTR(), SetMaxThetaTR(), SpectralXTRdEdx(), and XTRNSpectralDensity().

◆ fMinEnergyTR

G4double G4VXTRenergyLoss::fMinEnergyTR

protected

Definition at line 236 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMinEnergyTR(), SetMinEnergyTR(), and XTRNAngleDensity().

◆ fMinProtonTkin

G4double G4VXTRenergyLoss::fMinProtonTkin = 100. * CLHEP::GeV

staticconstexprprotected

Definition at line 208 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

◆ fMinThetaTR

G4double G4VXTRenergyLoss::fMinThetaTR

protected

Definition at line 238 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), G4VXTRenergyLoss(), GetMinThetaTR(), and SetMinThetaTR().

◆ fParticleChange

G4ParticleChange G4VXTRenergyLoss::fParticleChange

protected

Definition at line 232 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), and PostStepDoIt().

◆ fPlasmaCof

G4double G4VXTRenergyLoss::fPlasmaCof

staticconstexprprotected

Initial value:

=
    4. * CLHEP::pi * CLHEP::fine_structure_const * CLHEP::hbarc * CLHEP::hbarc *
    CLHEP::hbarc / CLHEP::electron_mass_c2

Definition at line 212 of file G4VXTRenergyLoss.hh.

Referenced by G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), and G4VXTRenergyLoss().

◆ fPlateNumber

G4int G4VXTRenergyLoss::fPlateNumber

protected

Definition at line 253 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), G4GammaXTRadiator::GetStackFactor(), G4GaussXTRadiator::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4XTRGaussRadModel::GetStackFactor(), G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRGaussRadModel::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), and G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ fPlatePhotoAbsCof

G4SandiaTable* G4VXTRenergyLoss::fPlatePhotoAbsCof

protected

Definition at line 229 of file G4VXTRenergyLoss.hh.

Referenced by ComputePlatePhotoAbsCof(), G4VXTRenergyLoss(), and GetPlateLinearPhotoAbs().

◆ fPlateThick

G4double G4VXTRenergyLoss::fPlateThick

protected

◆ fProtonEnergyVector

G4PhysicsLogVector* G4VXTRenergyLoss::fProtonEnergyVector

protected

Definition at line 227 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMeanFreePath(), GetNumberOfPhotons(), GetProtonVector(), GetXTRrandomEnergy(), and ~G4VXTRenergyLoss().

◆ fPtrGamma

G4ParticleDefinition* G4VXTRenergyLoss::fPtrGamma

protected

Definition at line 220 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

◆ fSigma1

G4double G4VXTRenergyLoss::fSigma1

protected

Definition at line 248 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), GetPlateFormationZone(), OneBoundaryXTRNdensity(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRGaussRadModel::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), and G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ fSigma2

G4double G4VXTRenergyLoss::fSigma2

protected

Definition at line 249 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), GetGasFormationZone(), OneBoundaryXTRNdensity(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRGaussRadModel::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), and G4XTRTransparentRegRadModel::SpectralXTRdEdx().

◆ fTheMaxAngle

G4double G4VXTRenergyLoss::fTheMaxAngle

protected

Definition at line 203 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetTheMaxAngle(), and SetTheMaxAngle().

◆ fTheMaxEnergyTR

G4double G4VXTRenergyLoss::fTheMaxEnergyTR

protected

Definition at line 201 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetTheMaxEnergyTR(), and SetTheMaxEnergyTR().

◆ fTheMinAngle

G4double G4VXTRenergyLoss::fTheMinAngle

protected

Definition at line 202 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetTheMinAngle(), and SetTheMinAngle().

◆ fTheMinEnergyTR

G4double G4VXTRenergyLoss::fTheMinEnergyTR

protected

Definition at line 199 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetTheMinEnergyTR(), and SetTheMinEnergyTR().

◆ fTotalDist

G4double G4VXTRenergyLoss::fTotalDist

protected

Definition at line 239 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), and G4VXTRenergyLoss().

◆ fTotBin

G4int G4VXTRenergyLoss::fTotBin

protected

Definition at line 217 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMeanFreePath(), GetNumberOfPhotons(), GetRandomAngle(), GetTotBin(), GetXTRrandomEnergy(), and PostStepDoIt().

◆ fVarAngle

G4double G4VXTRenergyLoss::fVarAngle

protected

Definition at line 246 of file G4VXTRenergyLoss.hh.

Referenced by AngleSpectralXTRdEdx(), G4VXTRenergyLoss(), GetVarAngle(), SetVarAngle(), XTRNAngleDensity(), and XTRNAngleSpectralDensity().

◆ fXTREnergyVector

G4PhysicsLogVector* G4VXTRenergyLoss::fXTREnergyVector

protected

Definition at line 228 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleTable(), G4VXTRenergyLoss(), and ~G4VXTRenergyLoss().

◆ secID

G4int G4VXTRenergyLoss::secID = -1

protected

Definition at line 259 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

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

Public Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4VXTRenergyLoss() [1/2]

◆ ~G4VXTRenergyLoss()

◆ G4VXTRenergyLoss() [2/2]

Member Function Documentation

◆ AngleSpectralXTRdEdx()

◆ AngleXTRdEdx()

◆ BuildAngleForEnergyBank()

◆ BuildAngleTable()

◆ BuildEnergyTable()

◆ BuildGlobalAngleTable()

◆ BuildPhysicsTable()

◆ BuildTable()

◆ ComputeGasPhotoAbsCof()

◆ ComputePlatePhotoAbsCof()

◆ DumpInfo()

◆ GetAlphaGas()

◆ GetAlphaPlate()

◆ GetAngleRadDistr()

◆ GetAngleVector()

◆ GetAngleXTR()

◆ GetCompton()

◆ GetComptonPerAtom()

◆ GetEnergy()

◆ GetFastAngle()

◆ GetGamma()

◆ GetGasComplexFZ()

◆ GetGasCompton()

◆ GetGasFormationZone()

◆ GetGasLinearPhotoAbs()

◆ GetGasZmuProduct() [1/2]

◆ GetGasZmuProduct() [2/2]

◆ GetKrange()

◆ GetMaxEnergyTR()

◆ GetMaxThetaTR()

◆ GetMeanFreePath()

◆ GetMinEnergyTR()

◆ GetMinThetaTR()

◆ GetNumberOfPhotons()

◆ GetPlateComplexFZ()

◆ GetPlateCompton()

◆ GetPlateFormationZone()

◆ GetPlateLinearPhotoAbs()

◆ GetPlateZmuProduct() [1/2]

◆ GetPlateZmuProduct() [2/2]

◆ GetProtonVector()

◆ GetRandomAngle()

◆ GetStackFactor()

◆ GetTheMaxAngle()

◆ GetTheMaxEnergyTR()

◆ GetTheMinAngle()

◆ GetTheMinEnergyTR()

◆ GetTotBin()

◆ GetVarAngle()

◆ GetXTRenergy()

◆ GetXTRrandomEnergy()

◆ IsApplicable()

◆ OneBoundaryXTRNdensity()

◆ OneInterfaceXTRdEdx()

◆ operator=()

◆ PostStepDoIt()

◆ ProcessDescription()

◆ SetAlphaGas()

◆ SetAlphaPlate()

◆ SetAngleRadDistr()

◆ SetCompton()

◆ SetEnergy()

◆ SetFastAngle()

◆ SetGamma()

◆ SetKrange()

◆ SetMaxEnergyTR()

◆ SetMaxThetaTR()

◆ SetMinEnergyTR()

◆ SetMinThetaTR()

◆ SetTheMaxAngle()