#include <G4ForwardXrayTR.hh>

Inheritance diagram for G4ForwardXrayTR:

Public Member Functions
	G4ForwardXrayTR (const G4String &matName1, const G4String &matName2, const G4String &processName="XrayTR")

	G4ForwardXrayTR (const G4String &processName="XrayTR")

	~G4ForwardXrayTR ()

	G4ForwardXrayTR (const G4ForwardXrayTR &right)=delete

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

void	ProcessDescription (std::ostream &) const override

void	DumpInfo () const override

void	BuildXrayTRtables ()

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

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

G4double	GetEnergyTR (G4int iMat, G4int jMat, G4int iTkin) const

G4double	GetThetaTR (G4int iMat, G4int jMat, G4int iTkin) const

G4double	SpectralAngleTRdensity (G4double energy, G4double varAngle) const override

G4double	AngleDensity (G4double energy, G4double varAngle) const

G4double	EnergyInterval (G4double energy1, G4double energy2, G4double varAngle) const

G4double	AngleSum (G4double varAngle1, G4double varAngle2) const

G4double	SpectralDensity (G4double energy, G4double x) const

G4double	AngleInterval (G4double energy, G4double varAngle1, G4double varAngle2) const

G4double	EnergySum (G4double energy1, G4double energy2) const

G4PhysicsTable *	GetAngleDistrTable ()

G4PhysicsTable *	GetEnergyDistrTable ()

Public Member Functions inherited from G4TransitionRadiation
	G4TransitionRadiation (const G4String &processName="TR", G4ProcessType type=fElectromagnetic)

virtual	~G4TransitionRadiation ()

	G4TransitionRadiation (const G4TransitionRadiation &right)=delete

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

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType) override

G4double	IntegralOverEnergy (G4double energy1, G4double energy2, G4double varAngle) const

G4double	IntegralOverAngle (G4double energy, G4double varAngle1, G4double varAngle2) const

G4double	AngleIntegralDistribution (G4double varAngle1, G4double varAngle2) const

G4double	EnergyIntegralDistribution (G4double energy1, G4double energy2) const

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	BuildPhysicsTable (const G4ParticleDefinition &)

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 &)

Static Public Member Functions
static G4int	GetSympsonNumber ()

static G4int	GetBinTR ()

static G4double	GetMinProtonTkin ()

static G4double	GetMaxProtonTkin ()

static G4int	GetTotBin ()

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

Protected Attributes
const std::vector< G4double > *	fGammaCutInKineticEnergy

G4ParticleDefinition *	fPtrGamma

G4PhysicsTable *	fAngleDistrTable

G4PhysicsTable *	fEnergyDistrTable

G4PhysicsLogVector *	fProtonEnergyVector

G4double	fMinEnergyTR

G4double	fMaxEnergyTR

G4double	fMaxThetaTR

G4double	fGamma

G4double	fGammaTkinCut

G4double	fSigma1

G4double	fSigma2

G4int	secID = -1

Protected Attributes inherited from G4TransitionRadiation
G4double	fGamma

G4double	fEnergy

G4double	fVarAngle

G4double	fMinEnergy

G4double	fMaxEnergy

G4double	fMaxTheta

G4double	fSigma1

G4double	fSigma2

G4int	fMatIndex1

G4int	fMatIndex2

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	fTheMinEnergyTR

static constexpr G4double	fTheMaxEnergyTR

static constexpr G4double	fTheMaxAngle = 1.0e-3

static constexpr G4double	fTheMinAngle = 5.0e-6

static constexpr G4double	fMinProtonTkin

static constexpr G4double	fMaxProtonTkin

static constexpr G4double	fPlasmaCof

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

static constexpr G4int	fSympsonNumber

static constexpr G4int	fBinTR = 50

static constexpr G4int	fTotBin = 50

Static Protected Attributes inherited from G4TransitionRadiation
static constexpr G4int	fSympsonNumber = 100

static constexpr G4int	fGammaNumber = 15

static constexpr G4int	fPointNumber = 100

Additional Inherited Members
Protected Member Functions inherited from G4VDiscreteProcess
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 52 of file G4ForwardXrayTR.hh.

Constructor & Destructor Documentation

◆ G4ForwardXrayTR() [1/3]

G4ForwardXrayTR::G4ForwardXrayTR	(	const G4String &	matName1,
		const G4String &	matName2,
		const G4String &	processName = "XrayTR" )

explicit

Definition at line 57 of file G4ForwardXrayTR.cc.

  : G4TransitionRadiation(processName)
{
  secID = G4PhysicsModelCatalog::GetModelID("model_XrayTR");
  fPtrGamma                = nullptr;
  fGammaCutInKineticEnergy = nullptr;
  fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = 0.0;
  fGamma = fSigma1 = fSigma2 = 0.0;
  fAngleDistrTable           = nullptr;
  fEnergyDistrTable          = nullptr;
  fMatIndex1 = fMatIndex2 = 0;
 
  // Proton energy vector initialization
  fProtonEnergyVector =
    new G4PhysicsLogVector(fMinProtonTkin, fMaxProtonTkin, fTotBin);
  G4int iMat;
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = (G4int)theCoupleTable->GetTableSize();
 
  G4bool build = true;
 
  for(iMat = 0; iMat < numOfCouples; ++iMat)  // check first material name
  {
    const G4MaterialCutsCouple* couple =
      theCoupleTable->GetMaterialCutsCouple(iMat);
    if(matName1 == couple->GetMaterial()->GetName())
    {
      fMatIndex1 = couple->GetIndex();
      break;
    }
  }
  if(iMat == numOfCouples)
  {
    G4Exception("G4ForwardXrayTR::G4ForwardXrayTR", "ForwardXrayTR01",
                JustWarning,
                "Invalid first material name in G4ForwardXrayTR constructor!");
    build = false;
  }
 
  if(build)
  {
    for(iMat = 0; iMat < numOfCouples; ++iMat)  // check second material name
    {
      const G4MaterialCutsCouple* couple =
        theCoupleTable->GetMaterialCutsCouple(iMat);
      if(matName2 == couple->GetMaterial()->GetName())
      {
        fMatIndex2 = couple->GetIndex();
        break;
      }
    }
    if(iMat == numOfCouples)
    {
      G4Exception(
        "G4ForwardXrayTR::G4ForwardXrayTR", "ForwardXrayTR02", JustWarning,
        "Invalid second material name in G4ForwardXrayTR constructor!");
      build = false;
    }
  }
  if(build)
  {
    BuildXrayTRtables();
  }
}

◆ G4ForwardXrayTR() [2/3]

G4ForwardXrayTR::G4ForwardXrayTR ( const G4String & processName = "XrayTR" )

explicit

Definition at line 127 of file G4ForwardXrayTR.cc.

  : G4TransitionRadiation(processName)
{
  fPtrGamma                = nullptr;
  fGammaCutInKineticEnergy = nullptr;
  fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = 0.0;
  fGamma = fSigma1 = fSigma2 = 0.0;
  fAngleDistrTable           = nullptr;
  fEnergyDistrTable          = nullptr;
  fMatIndex1 = fMatIndex2 = 0;
 
  // Proton energy vector initialization
  fProtonEnergyVector =
    new G4PhysicsLogVector(fMinProtonTkin, fMaxProtonTkin, fTotBin);
}

◆ ~G4ForwardXrayTR()

G4ForwardXrayTR::~G4ForwardXrayTR ( )

Definition at line 145 of file G4ForwardXrayTR.cc.

{
  delete fAngleDistrTable;
  delete fEnergyDistrTable;
  delete fProtonEnergyVector;
}

◆ G4ForwardXrayTR() [3/3]

G4ForwardXrayTR::G4ForwardXrayTR ( const G4ForwardXrayTR & right )

delete

Member Function Documentation

◆ AngleDensity()

G4double G4ForwardXrayTR::AngleDensity	(	G4double	energy,
		G4double	varAngle ) const

Definition at line 304 of file G4ForwardXrayTR.cc.

{
  G4double x, x2, c, d, f, a2, b2, a4, b4;
  G4double cof1, cof2, cof3;
  x    = 1.0 / energy;
  x2   = x * x;
  c    = 1.0 / fSigma1;
  d    = 1.0 / fSigma2;
  f    = (varAngle + 1.0 / (fGamma * fGamma));
  a2   = c * f;
  b2   = d * f;
  a4   = a2 * a2;
  b4   = b2 * b2;
  cof1 = c * c * (0.5 / (a2 * (x2 + a2)) + 0.5 * std::log(x2 / (x2 + a2)) / a4);
  cof3 = d * d * (0.5 / (b2 * (x2 + b2)) + 0.5 * std::log(x2 / (x2 + b2)) / b4);
  cof2 = -c * d *
         (std::log(x2 / (x2 + b2)) / b2 - std::log(x2 / (x2 + a2)) / a2) /
         (a2 - b2);
  return -varAngle * (cof1 + cof2 + cof3);
}

Referenced by EnergyInterval().

◆ AngleInterval()

G4double G4ForwardXrayTR::AngleInterval	(	G4double	energy,
		G4double	varAngle1,
		G4double	varAngle2 ) const

Definition at line 375 of file G4ForwardXrayTR.cc.

{
  return SpectralDensity(energy, varAngle2) -
         SpectralDensity(energy, varAngle1);
}

Referenced by EnergySum().

◆ AngleSum()

G4double G4ForwardXrayTR::AngleSum	(	G4double	varAngle1,
		G4double	varAngle2 ) const

Definition at line 337 of file G4ForwardXrayTR.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (varAngle2 - varAngle1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven +=
      EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1 + 2 * i * h);
    sumOdd +=
      EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1 + (2 * i - 1) * h);
  }
  sumOdd += EnergyInterval(fMinEnergyTR, fMaxEnergyTR,
                           varAngle1 + (2 * fSympsonNumber - 1) * h);
 
  return h *
         (EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1) +
          EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle2) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

Referenced by BuildXrayTRtables().

◆ BuildXrayTRtables()

void G4ForwardXrayTR::BuildXrayTRtables ( )

Definition at line 168 of file G4ForwardXrayTR.cc.

{
  G4int iMat, jMat, iTkin, iTR, iPlace;
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = (G4int)theCoupleTable->GetTableSize();
 
  fGammaCutInKineticEnergy = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
 
  fAngleDistrTable  = new G4PhysicsTable(2 * fTotBin);
  fEnergyDistrTable = new G4PhysicsTable(2 * fTotBin);
 
  for(iMat = 0; iMat < numOfCouples;
      ++iMat)  // loop over pairs of different materials
  {
    if(iMat != fMatIndex1 && iMat != fMatIndex2)
      continue;
 
    for(jMat = 0; jMat < numOfCouples; ++jMat)  // transition iMat -> jMat !!!
    {
      if(iMat == jMat || (jMat != fMatIndex1 && jMat != fMatIndex2))
      {
        continue;
      }
      else
      {
        const G4MaterialCutsCouple* iCouple =
          theCoupleTable->GetMaterialCutsCouple(iMat);
        const G4MaterialCutsCouple* jCouple =
          theCoupleTable->GetMaterialCutsCouple(jMat);
        const G4Material* mat1 = iCouple->GetMaterial();
        const G4Material* mat2 = jCouple->GetMaterial();
 
        fSigma1 = fPlasmaCof * (mat1->GetElectronDensity());
        fSigma2 = fPlasmaCof * (mat2->GetElectronDensity());
 
        fGammaTkinCut = 0.0;
 
        if(fGammaTkinCut > fTheMinEnergyTR)  // setting of min/max TR energies
        {
          fMinEnergyTR = fGammaTkinCut;
        }
        else
        {
          fMinEnergyTR = fTheMinEnergyTR;
        }
        if(fGammaTkinCut > fTheMaxEnergyTR)
        {
          fMaxEnergyTR = 2.0 * fGammaTkinCut;  // usually very low TR rate
        }
        else
        {
          fMaxEnergyTR = fTheMaxEnergyTR;
        }
        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);
 
          fMaxThetaTR = 10000.0 / (fGamma * fGamma);
 
          if(fMaxThetaTR > fTheMaxAngle)
          {
            fMaxThetaTR = fTheMaxAngle;
          }
          else
          {
            if(fMaxThetaTR < fTheMinAngle)
            {
              fMaxThetaTR = fTheMinAngle;
            }
          }
          auto angleVector =
            new G4PhysicsLinearVector(0.0, fMaxThetaTR, fBinTR);
          G4double energySum = 0.0;
          G4double angleSum  = 0.0;
 
          energyVector->PutValue(fBinTR - 1, energySum);
          angleVector->PutValue(fBinTR - 1, angleSum);
 
          for(iTR = fBinTR - 2; iTR >= 0; --iTR)
          {
            energySum +=
              fCofTR * EnergySum(energyVector->GetLowEdgeEnergy(iTR),
                                 energyVector->GetLowEdgeEnergy(iTR + 1));
 
            angleSum +=
              fCofTR * AngleSum(angleVector->GetLowEdgeEnergy(iTR),
                                angleVector->GetLowEdgeEnergy(iTR + 1));
 
            energyVector->PutValue(iTR, energySum);
            angleVector->PutValue(iTR, angleSum);
          }
 
          if(jMat < iMat)
          {
            iPlace = fTotBin + iTkin;
          }
          else  // jMat > iMat right part of matrices (jMat-1) !
          {
            iPlace = iTkin;
          }
          fEnergyDistrTable->insertAt(iPlace, energyVector);
          fAngleDistrTable->insertAt(iPlace, angleVector);
        }  //                      iTkin
      }    //         jMat != iMat
    }      //     jMat
  }        // iMat
}

Referenced by G4ForwardXrayTR().

◆ DumpInfo()

void G4ForwardXrayTR::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 68 of file G4ForwardXrayTR.hh.

68{ ProcessDescription(G4cout); };

G4cout

G4GLOB_DLL std::ostream G4cout

G4ForwardXrayTR::ProcessDescription

void ProcessDescription(std::ostream &) const override

Definition G4ForwardXrayTR.cc:152

◆ EnergyInterval()

G4double G4ForwardXrayTR::EnergyInterval	(	G4double	energy1,
		G4double	energy2,
		G4double	varAngle ) const

Definition at line 328 of file G4ForwardXrayTR.cc.

{
  return AngleDensity(energy2, varAngle) - AngleDensity(energy1, varAngle);
}

Referenced by AngleSum().

◆ EnergySum()

G4double G4ForwardXrayTR::EnergySum	(	G4double	energy1,
		G4double	energy2 ) const

Definition at line 385 of file G4ForwardXrayTR.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (energy2 - energy1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven += AngleInterval(energy1 + 2 * i * h, 0.0, fMaxThetaTR);
    sumOdd += AngleInterval(energy1 + (2 * i - 1) * h, 0.0, fMaxThetaTR);
  }
  sumOdd +=
    AngleInterval(energy1 + (2 * fSympsonNumber - 1) * h, 0.0, fMaxThetaTR);
 
  return h *
         (AngleInterval(energy1, 0.0, fMaxThetaTR) +
          AngleInterval(energy2, 0.0, fMaxThetaTR) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

Referenced by BuildXrayTRtables().

◆ GetAngleDistrTable()

G4PhysicsTable * G4ForwardXrayTR::GetAngleDistrTable ( )

◆ GetBinTR()

G4int G4ForwardXrayTR::GetBinTR ( )

static

Definition at line 746 of file G4ForwardXrayTR.cc.

746{ return fBinTR; }

◆ GetEnergyDistrTable()

G4PhysicsTable * G4ForwardXrayTR::GetEnergyDistrTable ( )

◆ GetEnergyTR()

G4double G4ForwardXrayTR::GetEnergyTR	(	G4int	iMat,
		G4int	jMat,
		G4int	iTkin ) const

Definition at line 634 of file G4ForwardXrayTR.cc.

{
  G4int iPlace, numOfTR, iTR, iTransfer;
  G4double energyTR = 0.0;  // return this value for no TR photons
  G4double energyPos;
  G4double W1, W2;
 
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = (G4int)theCoupleTable->GetTableSize();
 
  // The case of equal or approximate (in terms of plasma energy) materials
  // No TR photons ?!
 
  const G4MaterialCutsCouple* iCouple =
    theCoupleTable->GetMaterialCutsCouple(iMat);
  const G4MaterialCutsCouple* jCouple =
    theCoupleTable->GetMaterialCutsCouple(jMat);
  const G4Material* iMaterial = iCouple->GetMaterial();
  const G4Material* jMaterial = jCouple->GetMaterial();
 
  if(iMat == jMat
 
     || iMaterial->GetState() == jMaterial->GetState()
 
     || (iMaterial->GetState() == kStateSolid &&
         jMaterial->GetState() == kStateLiquid)
 
     || (iMaterial->GetState() == kStateLiquid &&
         jMaterial->GetState() == kStateSolid))
 
  {
    return energyTR;
  }
 
  if(jMat < iMat)
  {
    iPlace = (iMat * (numOfCouples - 1) + jMat) * fTotBin + iTkin - 1;
  }
  else
  {
    iPlace = (iMat * (numOfCouples - 1) + jMat - 1) * fTotBin + iTkin - 1;
  }
  G4PhysicsVector* energyVector1 = (*fEnergyDistrTable)(iPlace);
  G4PhysicsVector* energyVector2 = (*fEnergyDistrTable)(iPlace + 1);
 
  if(iTkin == fTotBin)  // TR plato, try from left
  {
    numOfTR = (G4int)G4Poisson((*energyVector1)(0));
    if(numOfTR == 0)
    {
      return energyTR;
    }
    else
    {
      for(iTR = 0; iTR < numOfTR; ++iTR)
      {
        energyPos = (*energyVector1)(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(energyPos >= (*energyVector1)(iTransfer))
            break;
        }
        energyTR += energyVector1->GetLowEdgeEnergy(iTransfer);
      }
    }
  }
  else
  {
    if(iTkin == 0)  // Tkin is too small, neglect of TR photon generation
    {
      return energyTR;
    }
    else  // general case: Tkin between two vectors of the material
    {     // use trivial mean half/half
      W1      = 0.5;
      W2      = 0.5;
      numOfTR = (G4int)G4Poisson((*energyVector1)(0) * W1 + (*energyVector2)(0) * W2);
      if(numOfTR == 0)
      {
        return energyTR;
      }
      else
      {
        G4cout << "It is still OK in GetEnergyTR(int,int,int)" << G4endl;
        for(iTR = 0; iTR < numOfTR; ++iTR)
        {
          energyPos = ((*energyVector1)(0) * W1 + (*energyVector2)(0) * W2) *
                      G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(energyPos >= ((*energyVector1)(iTransfer) *W1 +
                             (*energyVector2)(iTransfer) *W2))
              break;
          }
          energyTR += (energyVector1->GetLowEdgeEnergy(iTransfer)) * W1 +
                      (energyVector2->GetLowEdgeEnergy(iTransfer)) * W2;
        }
      }
    }
  }
 
  return energyTR;
}

◆ GetMaxProtonTkin()

G4double G4ForwardXrayTR::GetMaxProtonTkin ( )

static

Definition at line 750 of file G4ForwardXrayTR.cc.

750{ return fMaxProtonTkin; }

◆ GetMeanFreePath()

G4double G4ForwardXrayTR::GetMeanFreePath	(	const G4Track &	,
		G4double	,
		G4ForceCondition *	condition )

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 159 of file G4ForwardXrayTR.cc.

{
  *condition = Forced;
  return DBL_MAX;  // so TR doesn't limit mean free path
}

◆ GetMinProtonTkin()

G4double G4ForwardXrayTR::GetMinProtonTkin ( )

static

Definition at line 748 of file G4ForwardXrayTR.cc.

748{ return fMinProtonTkin; }

◆ GetSympsonNumber()

G4int G4ForwardXrayTR::GetSympsonNumber ( )

static

Definition at line 744 of file G4ForwardXrayTR.cc.

744{ return fSympsonNumber; }

◆ GetThetaTR()

G4double G4ForwardXrayTR::GetThetaTR	(	G4int	iMat,
		G4int	jMat,
		G4int	iTkin ) const

Definition at line 742 of file G4ForwardXrayTR.cc.

742{ return 0.0; }

◆ GetTotBin()

G4int G4ForwardXrayTR::GetTotBin ( )

static

Definition at line 752 of file G4ForwardXrayTR.cc.

752{ return fTotBin; }

◆ operator=()

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

delete

◆ PostStepDoIt()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 408 of file G4ForwardXrayTR.cc.

{
  aParticleChange.Initialize(aTrack);
  G4int iMat, jMat, iTkin, iPlace, numOfTR, iTR, iTransfer;
 
  G4double energyPos, anglePos, energyTR, theta, phi, dirX, dirY, dirZ;
  G4double W, W1, W2, E1, E2;
 
  G4StepPoint* pPreStepPoint  = aStep.GetPreStepPoint();
  G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
  G4double tol =
    0.5 * G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  if(pPostStepPoint->GetStepStatus() != fGeomBoundary)
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  if(aTrack.GetStepLength() <= tol)
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  // Arrived at boundary, so begin to try TR
 
  const G4MaterialCutsCouple* iCouple = pPreStepPoint->GetPhysicalVolume()
                                          ->GetLogicalVolume()
                                          ->GetMaterialCutsCouple();
  const G4MaterialCutsCouple* jCouple = pPostStepPoint->GetPhysicalVolume()
                                          ->GetLogicalVolume()
                                          ->GetMaterialCutsCouple();
  const G4Material* iMaterial = iCouple->GetMaterial();
  const G4Material* jMaterial = jCouple->GetMaterial();
  iMat                        = iCouple->GetIndex();
  jMat                        = jCouple->GetIndex();
 
  // The case of equal or approximate (in terms of plasma energy) materials
  // No TR photons ?!
 
  if(iMat == jMat ||
     ((fMatIndex1 >= 0 && fMatIndex2 >= 0) &&
      (iMat != fMatIndex1 && iMat != fMatIndex2) &&
      (jMat != fMatIndex1 && jMat != fMatIndex2))
 
     || iMaterial->GetState() == jMaterial->GetState()
 
     || (iMaterial->GetState() == kStateSolid &&
         jMaterial->GetState() == kStateLiquid)
 
     || (iMaterial->GetState() == kStateLiquid &&
         jMaterial->GetState() == kStateSolid))
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  G4double charge = aParticle->GetDefinition()->GetPDGCharge();
 
  if(charge == 0.0)  // Uncharged particle doesn't Generate TR photons
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  // Now we are ready to Generate TR photons
 
  G4double chargeSq  = charge * charge;
  G4double kinEnergy = aParticle->GetKineticEnergy();
  G4double massRatio =
    proton_mass_c2 / aParticle->GetDefinition()->GetPDGMass();
  G4double TkinScaled = kinEnergy * massRatio;
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)
  {
    if(TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin))
    {
      break;
    }
  }
  if(jMat < iMat)
  {
    iPlace = fTotBin + iTkin - 1;
  }
  else
  {
    iPlace = iTkin - 1;
  }
 
  G4ParticleMomentum particleDir = aParticle->GetMomentumDirection();
 
  if(iTkin == fTotBin)  // TR plato, try from left
  {
    numOfTR = (G4int)G4Poisson(
      ((*(*fEnergyDistrTable)(iPlace))(0) + (*(*fAngleDistrTable)(iPlace))(0)) *
      chargeSq * 0.5);
    if(numOfTR == 0)
    {
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else
    {
      aParticleChange.SetNumberOfSecondaries(numOfTR);
 
      for(iTR = 0; iTR < numOfTR; ++iTR)
      {
        energyPos = (*(*fEnergyDistrTable)(iPlace))(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(energyPos >= (*(*fEnergyDistrTable)(iPlace))(iTransfer))
            break;
        }
        energyTR = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
 
        kinEnergy -= energyTR;
        aParticleChange.ProposeEnergy(kinEnergy);
 
        anglePos = (*(*fAngleDistrTable)(iPlace))(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(anglePos > (*(*fAngleDistrTable)(iPlace))(iTransfer))
            break;
        }
        theta = std::sqrt(
          (*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 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(particleDir);
        auto aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(), directionTR, energyTR);
 
    // Create the G4Track
    auto aSecondaryTrack = new G4Track(aPhotonTR, aTrack.GetGlobalTime(), aTrack.GetPosition());
    aSecondaryTrack->SetTouchableHandle(aStep.GetPostStepPoint()->GetTouchableHandle());
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aSecondaryTrack->SetCreatorModelID(secID);
    aParticleChange.AddSecondary(aSecondaryTrack);  
      }
    }
  }
  else
  {
    if(iTkin == 0)  // Tkin is too small, neglect of TR photon generation
    {
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else  // general case: Tkin between two vectors of the material
    {
      E1 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
      E2 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
      W  = 1.0 / (E2 - E1);
      W1 = (E2 - TkinScaled) * W;
      W2 = (TkinScaled - E1) * W;
 
      numOfTR = (G4int)G4Poisson((((*(*fEnergyDistrTable)(iPlace))(0) +
                                   (*(*fAngleDistrTable)(iPlace))(0)) *
                                    W1 +
                                  ((*(*fEnergyDistrTable)(iPlace + 1))(0) +
                                   (*(*fAngleDistrTable)(iPlace + 1))(0)) *
                                    W2) *
                                 chargeSq * 0.5);
      if(numOfTR == 0)
      {
        return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
      }
      else
      {
        aParticleChange.SetNumberOfSecondaries(numOfTR);
        for(iTR = 0; iTR < numOfTR; ++iTR)
        {
          energyPos = ((*(*fEnergyDistrTable)(iPlace))(0) * W1 +
                       (*(*fEnergyDistrTable)(iPlace + 1))(0) * W2) *
                      G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(energyPos >=
               ((*(*fEnergyDistrTable)(iPlace))(iTransfer) *W1 +
                (*(*fEnergyDistrTable)(iPlace + 1))(iTransfer) *W2))
              break;
          }
          energyTR =
            ((*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer)) * W1 +
            ((*fEnergyDistrTable)(iPlace + 1)->GetLowEdgeEnergy(iTransfer)) *
              W2;
 
          kinEnergy -= energyTR;
          aParticleChange.ProposeEnergy(kinEnergy);
 
          anglePos = ((*(*fAngleDistrTable)(iPlace))(0) * W1 +
                      (*(*fAngleDistrTable)(iPlace + 1))(0) * W2) *
                     G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(anglePos > ((*(*fAngleDistrTable)(iPlace))(iTransfer) *W1 +
                           (*(*fAngleDistrTable)(iPlace + 1))(iTransfer) *W2))
              break;
          }
          theta = std::sqrt(
            ((*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 1)) *
              W1 +
            ((*fAngleDistrTable)(iPlace + 1)->GetLowEdgeEnergy(iTransfer - 1)) *
              W2);
 
          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(particleDir);
          auto aPhotonTR =
            new G4DynamicParticle(G4Gamma::Gamma(), directionTR, energyTR);
 
      // Create the G4Track
      G4Track* aSecondaryTrack = new G4Track(aPhotonTR, aTrack.GetGlobalTime(), aTrack.GetPosition());
      aSecondaryTrack->SetTouchableHandle(aStep.GetPostStepPoint()->GetTouchableHandle());
      aSecondaryTrack->SetParentID(aTrack.GetTrackID());
      aSecondaryTrack->SetCreatorModelID(secID);
      aParticleChange.AddSecondary(aSecondaryTrack);          
        }
      }
    }
  }
  return &aParticleChange;
}

◆ ProcessDescription()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 152 of file G4ForwardXrayTR.cc.

{
  out << "Simulation of forward X-ray transition radiation generated by\n"
         "relativistic charged particles crossing the interface between\n"
         "two materials.\n";
}

Referenced by DumpInfo().

◆ SpectralAngleTRdensity()

G4double G4ForwardXrayTR::SpectralAngleTRdensity	(	G4double	energy,
		G4double	varAngle ) const

overridevirtual

Implements G4TransitionRadiation.

Definition at line 290 of file G4ForwardXrayTR.cc.

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

◆ SpectralDensity()

G4double G4ForwardXrayTR::SpectralDensity	(	G4double	energy,
		G4double	x ) const

Definition at line 362 of file G4ForwardXrayTR.cc.

{
  G4double a, b;
  a = 1.0 / (fGamma * fGamma) + fSigma1 / (energy * energy);
  b = 1.0 / (fGamma * fGamma) + fSigma2 / (energy * energy);
  return ((a + b) * std::log((x + b) / (x + a)) / (a - b) + a / (x + a) +
          b / (x + b)) /
         energy;
}

Referenced by AngleInterval().

Member Data Documentation

◆ fAngleDistrTable

G4PhysicsTable* G4ForwardXrayTR::fAngleDistrTable

protected

Definition at line 142 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), PostStepDoIt(), and ~G4ForwardXrayTR().

◆ fBinTR

G4int G4ForwardXrayTR::fBinTR = 50

staticconstexprprotected

Definition at line 134 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), GetBinTR(), GetEnergyTR(), and PostStepDoIt().

◆ fCofTR

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

staticconstexprprotected

Definition at line 130 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fEnergyDistrTable

G4PhysicsTable* G4ForwardXrayTR::fEnergyDistrTable

protected

Definition at line 143 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), PostStepDoIt(), and ~G4ForwardXrayTR().

◆ fGamma

G4double G4ForwardXrayTR::fGamma

protected

Definition at line 150 of file G4ForwardXrayTR.hh.

Referenced by AngleDensity(), BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), SpectralAngleTRdensity(), and SpectralDensity().

◆ fGammaCutInKineticEnergy

const std::vector<G4double>* G4ForwardXrayTR::fGammaCutInKineticEnergy

protected

Definition at line 137 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fGammaTkinCut

G4double G4ForwardXrayTR::fGammaTkinCut

protected

Definition at line 151 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fMaxEnergyTR

G4double G4ForwardXrayTR::fMaxEnergyTR

protected

Definition at line 148 of file G4ForwardXrayTR.hh.

Referenced by AngleSum(), BuildXrayTRtables(), G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fMaxProtonTkin

G4double G4ForwardXrayTR::fMaxProtonTkin

staticconstexprprotected

Initial value:

=

100. * CLHEP::TeV

Definition at line 124 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), G4ForwardXrayTR(), and GetMaxProtonTkin().

◆ fMaxThetaTR

G4double G4ForwardXrayTR::fMaxThetaTR

protected

Definition at line 149 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), EnergySum(), G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fMinEnergyTR

G4double G4ForwardXrayTR::fMinEnergyTR

protected

Definition at line 147 of file G4ForwardXrayTR.hh.

Referenced by AngleSum(), BuildXrayTRtables(), G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fMinProtonTkin

G4double G4ForwardXrayTR::fMinProtonTkin

staticconstexprprotected

Initial value:

=

100. * CLHEP::GeV

Definition at line 122 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), G4ForwardXrayTR(), and GetMinProtonTkin().

◆ fPlasmaCof

G4double G4ForwardXrayTR::fPlasmaCof

staticconstexprprotected

Initial value:

=
    4.0 * CLHEP::pi * CLHEP::fine_structure_const * CLHEP::hbarc *
    CLHEP::hbarc * CLHEP::hbarc /
    CLHEP::electron_mass_c2

Definition at line 126 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fProtonEnergyVector

G4PhysicsLogVector* G4ForwardXrayTR::fProtonEnergyVector

protected

Definition at line 145 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), PostStepDoIt(), and ~G4ForwardXrayTR().

◆ fPtrGamma

G4ParticleDefinition* G4ForwardXrayTR::fPtrGamma

protected

Definition at line 140 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and G4ForwardXrayTR().

◆ fSigma1

G4double G4ForwardXrayTR::fSigma1

protected

Definition at line 152 of file G4ForwardXrayTR.hh.

Referenced by AngleDensity(), BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), SpectralAngleTRdensity(), and SpectralDensity().

◆ fSigma2

G4double G4ForwardXrayTR::fSigma2

protected

Definition at line 153 of file G4ForwardXrayTR.hh.

Referenced by AngleDensity(), BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), SpectralAngleTRdensity(), and SpectralDensity().

◆ fSympsonNumber

G4int G4ForwardXrayTR::fSympsonNumber

staticconstexprprotected

Initial value:

=

100

Definition at line 132 of file G4ForwardXrayTR.hh.

Referenced by AngleSum(), EnergySum(), and GetSympsonNumber().

◆ fTheMaxAngle

G4double G4ForwardXrayTR::fTheMaxAngle = 1.0e-3

staticconstexprprotected

Definition at line 120 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMaxEnergyTR

G4double G4ForwardXrayTR::fTheMaxEnergyTR

staticconstexprprotected

Initial value:

=

100. * CLHEP::keV

Definition at line 118 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMinAngle

G4double G4ForwardXrayTR::fTheMinAngle = 5.0e-6

staticconstexprprotected

Definition at line 121 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMinEnergyTR

G4double G4ForwardXrayTR::fTheMinEnergyTR

staticconstexprprotected

Initial value:

=

1. * CLHEP::keV

Definition at line 116 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTotBin

G4int G4ForwardXrayTR::fTotBin = 50

staticconstexprprotected

Definition at line 135 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4ForwardXrayTR(), GetEnergyTR(), GetTotBin(), and PostStepDoIt().

◆ secID

G4int G4ForwardXrayTR::secID = -1

protected

Definition at line 155 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and PostStepDoIt().

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

Public Member Functions

Static Public Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4ForwardXrayTR() [1/3]

◆ G4ForwardXrayTR() [2/3]

◆ ~G4ForwardXrayTR()

◆ G4ForwardXrayTR() [3/3]

Member Function Documentation

◆ AngleDensity()

◆ AngleInterval()

◆ AngleSum()

◆ BuildXrayTRtables()

◆ DumpInfo()

◆ EnergyInterval()

◆ EnergySum()

◆ GetAngleDistrTable()

◆ GetBinTR()

◆ GetEnergyDistrTable()

◆ GetEnergyTR()

◆ GetMaxProtonTkin()

◆ GetMeanFreePath()

◆ GetMinProtonTkin()

◆ GetSympsonNumber()

◆ GetThetaTR()

◆ GetTotBin()

◆ operator=()

◆ PostStepDoIt()

◆ ProcessDescription()

◆ SpectralAngleTRdensity()

◆ SpectralDensity()

Member Data Documentation

◆ fAngleDistrTable

◆ fBinTR

◆ fCofTR

◆ fEnergyDistrTable

◆ fGamma

◆ fGammaCutInKineticEnergy

◆ fGammaTkinCut

◆ fMaxEnergyTR

◆ fMaxProtonTkin

◆ fMaxThetaTR

◆ fMinEnergyTR

◆ fMinProtonTkin

◆ fPlasmaCof

◆ fProtonEnergyVector

◆ fPtrGamma

◆ fSigma1

◆ fSigma2

◆ fSympsonNumber

◆ fTheMaxAngle

◆ fTheMaxEnergyTR

◆ fTheMinAngle

◆ fTheMinEnergyTR

◆ fTotBin

◆ secID