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

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

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

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)

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

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

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 &, G4ProcessType aType=fNotDefined)

	G4VDiscreteProcess (G4VDiscreteProcess &)

virtual	~G4VDiscreteProcess ()

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

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

	G4VProcess (const G4VProcess &right)

virtual	~G4VProcess ()

G4int	operator== (const G4VProcess &right) const

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

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

G4VParticleChange *	pParticleChange

G4ParticleChange	aParticleChange

G4double	theNumberOfInteractionLengthLeft

G4double	currentInteractionLength

G4double	theInitialNumberOfInteractionLength

G4String	theProcessName

G4String	thePhysicsTableFileName

G4ProcessType	theProcessType

G4int	theProcessSubType

G4double	thePILfactor

G4bool	enableAtRestDoIt

G4bool	enableAlongStepDoIt

G4bool	enablePostStepDoIt

G4int	verboseLevel

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
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 66 of file G4ForwardXrayTR.hh.

Constructor & Destructor Documentation

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

Definition at line 83 of file G4ForwardXrayTR.cc.

References BuildXrayTRtables(), fAngleDistrTable, fEnergyDistrTable, fGamma, fGammaCutInKineticEnergy, fGammaTkinCut, G4TransitionRadiation::fMatIndex1, G4TransitionRadiation::fMatIndex2, fMaxEnergyTR, fMaxProtonTkin, fMaxThetaTR, fMinEnergyTR, fMinProtonTkin, fProtonEnergyVector, fPtrGamma, fSigma1, fSigma2, fTotBin, G4Exception(), G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Material::GetName(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), and JustWarning.

   :        G4TransitionRadiation(processName)
 {
   fPtrGamma = 0;
   fGammaCutInKineticEnergy = 0;
   fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR =  fMaxThetaTR = fGamma = 
     fSigma1 = fSigma2 = 0.0; 
   fAngleDistrTable = 0;
   fEnergyDistrTable = 0;
   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::G4ForwardXrayTR ( const G4String & processName = "XrayTR" )

Definition at line 147 of file G4ForwardXrayTR.cc.

References fAngleDistrTable, fEnergyDistrTable, fGamma, fGammaCutInKineticEnergy, fGammaTkinCut, G4TransitionRadiation::fMatIndex1, G4TransitionRadiation::fMatIndex2, fMaxEnergyTR, fMaxProtonTkin, fMaxThetaTR, fMinEnergyTR, fMinProtonTkin, fProtonEnergyVector, fPtrGamma, fSigma1, fSigma2, and fTotBin.

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

G4ForwardXrayTR::~G4ForwardXrayTR ( )

virtual

Definition at line 170 of file G4ForwardXrayTR.cc.

References fAngleDistrTable, fEnergyDistrTable, and fProtonEnergyVector.

 {
   delete fAngleDistrTable;
   delete fEnergyDistrTable;
   delete fProtonEnergyVector;
 }

Member Function Documentation

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

Definition at line 340 of file G4ForwardXrayTR.cc.

References test::c, energy(), fGamma, fSigma1, fSigma2, and test::x.

Referenced by EnergyInterval().

 {
   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);
 }

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

Definition at line 427 of file G4ForwardXrayTR.cc.

References SpectralDensity().

Referenced by EnergySum().

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

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

Definition at line 382 of file G4ForwardXrayTR.cc.

References EnergyInterval(), fMaxEnergyTR, fMinEnergyTR, and fSympsonNumber.

Referenced by BuildXrayTRtables().

 {
   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;
 }

void G4ForwardXrayTR::BuildXrayTRtables ( )

Definition at line 189 of file G4ForwardXrayTR.cc.

References AngleSum(), EnergySum(), fAngleDistrTable, fBinTR, fCofTR, fEnergyDistrTable, fGamma, fGammaCutInKineticEnergy, fGammaTkinCut, G4TransitionRadiation::fMatIndex1, G4TransitionRadiation::fMatIndex2, fMaxEnergyTR, fMaxThetaTR, fMinEnergyTR, fPlasmaCof, fProtonEnergyVector, fSigma1, fSigma2, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotBin, G4Material::GetElectronDensity(), G4ProductionCutsTable::GetEnergyCutsVector(), G4PhysicsVector::GetLowEdgeEnergy(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), idxG4GammaCut, G4PhysicsTable::insertAt(), python.hepunit::proton_mass_c2, and G4PhysicsVector::PutValue().

Referenced by G4ForwardXrayTR().

 {
   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;
 }

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

Definition at line 368 of file G4ForwardXrayTR.cc.

References AngleDensity().

Referenced by AngleSum().

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

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

Definition at line 441 of file G4ForwardXrayTR.cc.

References AngleInterval(), fMaxThetaTR, and fSympsonNumber.

Referenced by BuildXrayTRtables().

 {
   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;
 }

G4PhysicsTable* G4ForwardXrayTR::GetAngleDistrTable ( )

inline

Definition at line 128 of file G4ForwardXrayTR.hh.

References fAngleDistrTable.

128 { return fAngleDistrTable; };

G4ForwardXrayTR::fAngleDistrTable

G4PhysicsTable * fAngleDistrTable

Definition: G4ForwardXrayTR.hh:149

static G4int G4ForwardXrayTR::GetBinTR ( )

inlinestatic

Definition at line 132 of file G4ForwardXrayTR.hh.

References fBinTR.

132 { return fBinTR; };

G4ForwardXrayTR::fBinTR

static G4int fBinTR

Definition: G4ForwardXrayTR.hh:163

G4PhysicsTable* G4ForwardXrayTR::GetEnergyDistrTable ( )

inline

Definition at line 129 of file G4ForwardXrayTR.hh.

References fEnergyDistrTable.

129 { return fEnergyDistrTable; };

G4ForwardXrayTR::fEnergyDistrTable

G4PhysicsTable * fEnergyDistrTable

Definition: G4ForwardXrayTR.hh:150

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

Definition at line 696 of file G4ForwardXrayTR.cc.

References fBinTR, fTotBin, G4cout, G4endl, G4Poisson(), G4UniformRand, G4PhysicsVector::GetLowEdgeEnergy(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4ProductionCutsTable::GetProductionCutsTable(), G4Material::GetState(), G4ProductionCutsTable::GetTableSize(), kStateLiquid, and kStateSolid.

 {
   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;
 }

static G4double G4ForwardXrayTR::GetMaxProtonTkin ( )

inlinestatic

Definition at line 135 of file G4ForwardXrayTR.hh.

References fMaxProtonTkin.

135 { return fMaxProtonTkin; };

G4ForwardXrayTR::fMaxProtonTkin

static G4double fMaxProtonTkin

Definition: G4ForwardXrayTR.hh:166

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

virtual

Implements G4VDiscreteProcess.

Definition at line 177 of file G4ForwardXrayTR.cc.

References DBL_MAX, and Forced.

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

static G4double G4ForwardXrayTR::GetMinProtonTkin ( )

inlinestatic

Definition at line 134 of file G4ForwardXrayTR.hh.

References fMinProtonTkin.

134 { return fMinProtonTkin; };

G4ForwardXrayTR::fMinProtonTkin

static G4double fMinProtonTkin

Definition: G4ForwardXrayTR.hh:165

static G4int G4ForwardXrayTR::GetSympsonNumber ( )

inlinestatic

Definition at line 131 of file G4ForwardXrayTR.hh.

References fSympsonNumber.

131 { return fSympsonNumber; };

G4ForwardXrayTR::fSympsonNumber

static G4int fSympsonNumber

Definition: G4ForwardXrayTR.hh:154

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

Definition at line 805 of file G4ForwardXrayTR.cc.

 {
   G4double theta = 0.0;
 
   return theta;
 }

static G4int G4ForwardXrayTR::GetTotBin ( )

inlinestatic

Definition at line 136 of file G4ForwardXrayTR.hh.

References fTotBin.

136 { return fTotBin; };

G4ForwardXrayTR::fTotBin

static G4int fTotBin

Definition: G4ForwardXrayTR.hh:167

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

virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 466 of file G4ForwardXrayTR.cc.

References G4ParticleChange::AddSecondary(), G4VProcess::aParticleChange, fAngleDistrTable, fBinTR, fEnergyDistrTable, fGeomBoundary, G4TransitionRadiation::fMatIndex1, G4TransitionRadiation::fMatIndex2, fProtonEnergyVector, fTotBin, G4Poisson(), G4UniformRand, G4Gamma::Gamma(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4MaterialCutsCouple::GetIndex(), G4GeometryTolerance::GetInstance(), G4DynamicParticle::GetKineticEnergy(), G4PhysicsVector::GetLowEdgeEnergy(), G4MaterialCutsCouple::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4StepPoint::GetPhysicalVolume(), G4Step::GetPostStepPoint(), G4Step::GetPreStepPoint(), G4Material::GetState(), G4Track::GetStepLength(), G4StepPoint::GetStepStatus(), G4GeometryTolerance::GetSurfaceTolerance(), G4ParticleChange::Initialize(), kStateLiquid, kStateSolid, G4VDiscreteProcess::PostStepDoIt(), G4ParticleChange::ProposeEnergy(), python.hepunit::proton_mass_c2, CLHEP::Hep3Vector::rotateUz(), G4VParticleChange::SetNumberOfSecondaries(), and python.hepunit::twopi.

 {
   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 && fMatIndex1 >= 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;
 }

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

virtual

Implements G4TransitionRadiation.

Definition at line 317 of file G4ForwardXrayTR.cc.

References fGamma, fSigma1, and fSigma2.

 {
   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);
 
 }

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

Definition at line 408 of file G4ForwardXrayTR.cc.

References test::a, test::b, energy(), fGamma, fSigma1, and fSigma2.

Referenced by AngleInterval().

 {
   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;
 
 }