#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")

virtual	~G4ForwardXrayTR ()

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

G4bool	IsApplicable (const G4ParticleDefinition &aParticleType) override

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

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

virtual G4double	SpectralAngleTRdensity (G4double energy, G4double varAngle) const =0

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 G4VParticleChange *	PostStepDoIt (const G4Track &, const G4Step &)

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

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

virtual G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4VParticleChange *	AtRestDoIt (const G4Track &track, const G4Step &stepData)=0

virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)=0

virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &track, G4ForceCondition *condition)=0

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

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

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

virtual void	DumpInfo () const

virtual void	ProcessDescription (std::ostream &outfile) 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
G4ParticleDefinition *	fPtrGamma

const std::vector< G4double > *	fGammaCutInKineticEnergy

G4double	fGammaTkinCut

G4PhysicsTable *	fAngleDistrTable

G4PhysicsTable *	fEnergyDistrTable

G4PhysicsLogVector *	fProtonEnergyVector

G4double	fMinEnergyTR

G4double	fMaxEnergyTR

G4double	fMaxThetaTR

G4double	fGamma

G4double	fSigma1

G4double	fSigma2

Protected Attributes inherited from G4TransitionRadiation
G4int	fMatIndex1

G4int	fMatIndex2

G4double	fGamma

G4double	fEnergy

G4double	fVarAngle

G4double	fMinEnergy

G4double	fMaxEnergy

G4double	fMaxTheta

G4double	fSigma1

G4double	fSigma2

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 G4int	fSympsonNumber = 100

static G4double	fTheMinEnergyTR = 1.0*keV

static G4double	fTheMaxEnergyTR = 100.0*keV

static G4double	fTheMaxAngle = 1.0e-3

static G4double	fTheMinAngle = 5.0e-6

static G4int	fBinTR = 50

static G4double	fMinProtonTkin = 100.0*GeV

static G4double	fMaxProtonTkin = 100.0*TeV

static G4int	fTotBin = 50

static G4double	fPlasmaCof

static G4double	fCofTR = fine_structure_const/pi

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

static const G4int	fGammaNumber = 15

static const G4int	fPointNumber = 100

Additional Inherited Members
virtual G4double	GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)=0

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

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 65 of file G4ForwardXrayTR.hh.

Constructor & Destructor Documentation

◆ G4ForwardXrayTR() [1/2]

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

explicit

Definition at line 81 of file G4ForwardXrayTR.cc.

  :        G4TransitionRadiation(processName)
{
  fPtrGamma = nullptr;
  fGammaCutInKineticEnergy = nullptr;
  fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR =  fMaxThetaTR = 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 = 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;
      }
  }
  //  G4cout<<"G4ForwardXray constructor is called"<<G4endl;
  if(build) { BuildXrayTRtables(); }
}

◆ G4ForwardXrayTR() [2/2]

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

explicit

Definition at line 145 of file G4ForwardXrayTR.cc.

   :        G4TransitionRadiation(processName)
{
  fPtrGamma = nullptr;
  fGammaCutInKineticEnergy = nullptr;
  fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR =  fMaxThetaTR = 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 ( )

virtual

Definition at line 169 of file G4ForwardXrayTR.cc.

{
  delete fAngleDistrTable;
  delete fEnergyDistrTable;
  delete fProtonEnergyVector;
}

Member Function Documentation

◆ AngleDensity()

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

Definition at line 339 of file G4ForwardXrayTR.cc.

{
  G4double x, x2, /*a, b,*/ 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;
  //a = std::sqrt(a2);
  // b = std::sqrt(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 426 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 381 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 188 of file G4ForwardXrayTR.cc.

{
  G4int iMat, jMat, iTkin, iTR, iPlace;
  const G4ProductionCutsTable* theCoupleTable=
        G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = 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 = fGammaCutInKineticEnergy[jMat]; // TR photon in jMat !
 
        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
    {
          G4PhysicsLogVector*
                    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;
        }
      }
   // G4cout<<G4endl<<"fGamma = "<<fGamma<<"  fMaxThetaTR = "<<fMaxThetaTR<<G4endl;
          G4PhysicsLinearVector*
                     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);
      }
      // G4cout<<"sumE = "<<energySum<<"; sumA = "<<angleSum<<G4endl;
 
          if(jMat < iMat)
      {
            iPlace = fTotBin+iTkin;   // (iMat*(numOfMat-1)+jMat)*
      }
          else   // jMat > iMat right part of matrices (jMat-1) !
      {
            iPlace = iTkin;  // (iMat*(numOfMat-1)+jMat-1)*fTotBin+
      }
          fEnergyDistrTable->insertAt(iPlace,energyVector);
          fAngleDistrTable->insertAt(iPlace,angleVector);
    }    //                      iTkin
      }      //         jMat != iMat
    }        //     jMat
  }          // iMat
  //  G4cout<<"G4ForwardXrayTR::BuildXrayTRtables have been called"<<G4endl;
}

Referenced by G4ForwardXrayTR().

◆ EnergyInterval()

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

Definition at line 367 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 440 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 813 of file G4ForwardXrayTR.cc.

{ 
  return fBinTR;
}

◆ GetEnergyDistrTable()

G4PhysicsTable * G4ForwardXrayTR::GetEnergyDistrTable ( )

◆ GetEnergyTR()

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

Definition at line 695 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 = 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 = 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 = 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 823 of file G4ForwardXrayTR.cc.

{ 
  return fMaxProtonTkin; 
}

◆ GetMeanFreePath()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 176 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 818 of file G4ForwardXrayTR.cc.

{ 
  return fMinProtonTkin; 
}

◆ GetSympsonNumber()

G4int G4ForwardXrayTR::GetSympsonNumber ( )

static

Definition at line 808 of file G4ForwardXrayTR.cc.

{ 
  return fSympsonNumber;
}

◆ GetThetaTR()

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

Definition at line 803 of file G4ForwardXrayTR.cc.

{
  return 0.0;
}

◆ GetTotBin()

G4int G4ForwardXrayTR::GetTotBin ( )

static

Definition at line 828 of file G4ForwardXrayTR.cc.

{ 
  return fTotBin;
}

◆ PostStepDoIt()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 465 of file G4ForwardXrayTR.cc.

{
  aParticleChange.Initialize(aTrack);
  //  G4cout<<"call G4ForwardXrayTR::PostStepDoIt"<<G4endl;
  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);
  }
  // Come on 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; // (iMat*(numOfMat - 1) + jMat)*
  }
  else
  {
    iPlace = iTkin - 1;  // (iMat*(numOfMat - 1) + jMat - 1)*fTotBin +
  }
  //  G4PhysicsVector*  energyVector1 = (*fEnergyDistrTable)(iPlace)    ;
  //  G4PhysicsVector*  energyVector2 = (*fEnergyDistrTable)(iPlace + 1);
 
  //  G4PhysicsVector*   angleVector1 = (*fAngleDistrTable)(iPlace)     ;
  //  G4PhysicsVector*   angleVector2 = (*fAngleDistrTable)(iPlace + 1) ;
 
  G4ParticleMomentum particleDir = aParticle->GetMomentumDirection();
 
  if(iTkin == fTotBin)                 // TR plato, try from left
  {
 // G4cout<<iTkin<<" mean TR number = "<<( (*(*fEnergyDistrTable)(iPlace))(0) +
 //                                   (*(*fAngleDistrTable)(iPlace))(0) )
 //      *chargeSq*0.5<<G4endl;
 
    numOfTR = G4Poisson( ( (*(*fEnergyDistrTable)(iPlace))(0) +
                           (*(*fAngleDistrTable)(iPlace))(0) )
                         *chargeSq*0.5 );
    if(numOfTR == 0)
    {
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else
    {
      // G4cout<<"Number of X-ray TR photons = "<<numOfTR<<G4endl;
 
      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);
 
    // G4cout<<"energyTR = "<<energyTR/keV<<"keV"<<G4endl;
 
        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));
 
    // G4cout<<iTransfer<<" :  theta = "<<theta<<G4endl;
 
        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);
        G4DynamicParticle* aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(),
                                                             directionTR,
                                                             energyTR     );
        aParticleChange.AddSecondary(aPhotonTR);
      }
    }
  }
  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;
 
  // G4cout<<iTkin<<" mean TR number = "<<(((*(*fEnergyDistrTable)(iPlace))(0)+
  // (*(*fAngleDistrTable)(iPlace))(0))*W1 +
  //                                ((*(*fEnergyDistrTable)(iPlace + 1))(0)+
  // (*(*fAngleDistrTable)(iPlace + 1))(0))*W2)
  //                                    *chargeSq*0.5<<G4endl;
 
      numOfTR = 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
      {
        // G4cout<<"Number of X-ray TR photons = "<<numOfTR<<G4endl;
 
        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;
 
      // G4cout<<"energyTR = "<<energyTR/keV<<"keV"<<G4endl;
 
          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);
 
      // G4cout<<iTransfer<<" : theta = "<<theta<<G4endl;
 
          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);
          G4DynamicParticle* aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(),
                                                               directionTR,
                                                               energyTR     );
          aParticleChange.AddSecondary(aPhotonTR);
        }
      }
    }
  }
  return &aParticleChange;
}

◆ SpectralAngleTRdensity()

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

overridevirtual

Implements G4TransitionRadiation.

Definition at line 316 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 407 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 148 of file G4ForwardXrayTR.hh.

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

◆ fBinTR

G4int G4ForwardXrayTR::fBinTR = 50

staticprotected

Definition at line 162 of file G4ForwardXrayTR.hh.

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

◆ fCofTR

G4double G4ForwardXrayTR::fCofTR = fine_structure_const/pi

staticprotected

Definition at line 170 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fEnergyDistrTable

G4PhysicsTable* G4ForwardXrayTR::fEnergyDistrTable

protected

Definition at line 149 of file G4ForwardXrayTR.hh.

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

◆ fGamma

G4double G4ForwardXrayTR::fGamma

protected

Definition at line 167 of file G4ForwardXrayTR.hh.

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

◆ fGammaCutInKineticEnergy

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

protected

Definition at line 144 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), and G4ForwardXrayTR().

◆ fGammaTkinCut

G4double G4ForwardXrayTR::fGammaTkinCut

protected

Definition at line 146 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), and G4ForwardXrayTR().

◆ fMaxEnergyTR

G4double G4ForwardXrayTR::fMaxEnergyTR

protected

Definition at line 158 of file G4ForwardXrayTR.hh.

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

◆ fMaxProtonTkin

G4double G4ForwardXrayTR::fMaxProtonTkin = 100.0*TeV

staticprotected

Definition at line 165 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and GetMaxProtonTkin().

◆ fMaxThetaTR

G4double G4ForwardXrayTR::fMaxThetaTR

protected

Definition at line 161 of file G4ForwardXrayTR.hh.

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

◆ fMinEnergyTR

G4double G4ForwardXrayTR::fMinEnergyTR

protected

Definition at line 157 of file G4ForwardXrayTR.hh.

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

◆ fMinProtonTkin

G4double G4ForwardXrayTR::fMinProtonTkin = 100.0*GeV

staticprotected

Definition at line 164 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and GetMinProtonTkin().

◆ fPlasmaCof

G4double G4ForwardXrayTR::fPlasmaCof

staticprotected

Initial value:

= 4.0*pi*fine_structure_const*

hbarc*hbarc*hbarc/electron_mass_c2

Definition at line 169 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fProtonEnergyVector

G4PhysicsLogVector* G4ForwardXrayTR::fProtonEnergyVector

protected

Definition at line 151 of file G4ForwardXrayTR.hh.

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

◆ fPtrGamma

G4ParticleDefinition* G4ForwardXrayTR::fPtrGamma

protected

Definition at line 142 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR().

◆ fSigma1

G4double G4ForwardXrayTR::fSigma1

protected

Definition at line 172 of file G4ForwardXrayTR.hh.

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

◆ fSigma2

G4double G4ForwardXrayTR::fSigma2

protected

Definition at line 173 of file G4ForwardXrayTR.hh.

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

◆ fSympsonNumber

G4int G4ForwardXrayTR::fSympsonNumber = 100

staticprotected

Definition at line 153 of file G4ForwardXrayTR.hh.

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

◆ fTheMaxAngle

G4double G4ForwardXrayTR::fTheMaxAngle = 1.0e-3

staticprotected

Definition at line 159 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMaxEnergyTR

G4double G4ForwardXrayTR::fTheMaxEnergyTR = 100.0*keV

staticprotected

Definition at line 156 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMinAngle

G4double G4ForwardXrayTR::fTheMinAngle = 5.0e-6

staticprotected

Definition at line 160 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTheMinEnergyTR

G4double G4ForwardXrayTR::fTheMinEnergyTR = 1.0*keV

staticprotected

Definition at line 155 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

◆ fTotBin

G4int G4ForwardXrayTR::fTotBin = 50

staticprotected

Definition at line 166 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), GetEnergyTR(), GetTotBin(), 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/2]

◆ G4ForwardXrayTR() [2/2]

◆ ~G4ForwardXrayTR()

Member Function Documentation

◆ AngleDensity()

◆ AngleInterval()

◆ AngleSum()

◆ BuildXrayTRtables()

◆ EnergyInterval()

◆ EnergySum()

◆ GetAngleDistrTable()

◆ GetBinTR()

◆ GetEnergyDistrTable()

◆ GetEnergyTR()

◆ GetMaxProtonTkin()

◆ GetMeanFreePath()

◆ GetMinProtonTkin()

◆ GetSympsonNumber()

◆ GetThetaTR()

◆ GetTotBin()

◆ PostStepDoIt()

◆ 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