#include <G4ForwardXrayTR.hh>

Inheritance diagram for G4ForwardXrayTR:

Collaboration 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

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

explicit

Definition at line 83 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(); }
 }

Here is the call graph for this function:

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

explicit

Definition at line 147 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 ( )

virtual

Definition at line 170 of file G4ForwardXrayTR.cc.

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 427 of file G4ForwardXrayTR.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 382 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ForwardXrayTR::BuildXrayTRtables ( )

Definition at line 189 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 368 of file G4ForwardXrayTR.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 441 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4PhysicsTable* G4ForwardXrayTR::GetAngleDistrTable ( )

inline

Definition at line 128 of file G4ForwardXrayTR.hh.

128 { return fAngleDistrTable; };

G4ForwardXrayTR::fAngleDistrTable

G4PhysicsTable * fAngleDistrTable

Definition: G4ForwardXrayTR.hh:149

static G4int G4ForwardXrayTR::GetBinTR ( )

inlinestatic

Definition at line 132 of file G4ForwardXrayTR.hh.

132 { return fBinTR; };

G4ForwardXrayTR::fBinTR

static G4int fBinTR

Definition: G4ForwardXrayTR.hh:163

G4PhysicsTable* G4ForwardXrayTR::GetEnergyDistrTable ( )

inline

Definition at line 129 of file G4ForwardXrayTR.hh.

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.

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

Here is the call graph for this function:

static G4double G4ForwardXrayTR::GetMaxProtonTkin ( )

inlinestatic

Definition at line 135 of file G4ForwardXrayTR.hh.

135 { return fMaxProtonTkin; };

G4ForwardXrayTR::fMaxProtonTkin

static G4double fMaxProtonTkin

Definition: G4ForwardXrayTR.hh:166

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 177 of file G4ForwardXrayTR.cc.

 {
   *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.

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.

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.

136 { return fTotBin; };

G4ForwardXrayTR::fTotBin

static G4int fTotBin

Definition: G4ForwardXrayTR.hh:167

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 466 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;
 }

Here is the call graph for this function:

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

overridevirtual

Implements G4TransitionRadiation.

Definition at line 317 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);
 
 }

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

Definition at line 408 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;
 
 }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

G4PhysicsTable* G4ForwardXrayTR::fAngleDistrTable

protected

Definition at line 149 of file G4ForwardXrayTR.hh.

G4int G4ForwardXrayTR::fBinTR = 50

staticprotected

Definition at line 163 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fCofTR = fine_structure_const/pi

staticprotected

Definition at line 171 of file G4ForwardXrayTR.hh.

G4PhysicsTable* G4ForwardXrayTR::fEnergyDistrTable

protected

Definition at line 150 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fGamma

protected

Definition at line 168 of file G4ForwardXrayTR.hh.

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

protected

Definition at line 145 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fGammaTkinCut

protected

Definition at line 147 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fMaxEnergyTR

protected

Definition at line 159 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fMaxProtonTkin = 100.0*TeV

staticprotected

Definition at line 166 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fMaxThetaTR

protected

Definition at line 162 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fMinEnergyTR

protected

Definition at line 158 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fMinProtonTkin = 100.0*GeV

staticprotected

Definition at line 165 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fPlasmaCof

staticprotected

Initial value:

= 4.0*pi*fine_structure_const*

hbarc*hbarc*hbarc/electron_mass_c2

Definition at line 170 of file G4ForwardXrayTR.hh.

G4PhysicsLogVector* G4ForwardXrayTR::fProtonEnergyVector

protected

Definition at line 152 of file G4ForwardXrayTR.hh.

G4ParticleDefinition* G4ForwardXrayTR::fPtrGamma

protected

Definition at line 136 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fSigma1

protected

Definition at line 173 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fSigma2

protected

Definition at line 174 of file G4ForwardXrayTR.hh.

G4int G4ForwardXrayTR::fSympsonNumber = 100

staticprotected

Definition at line 154 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fTheMaxAngle = 1.0e-3

staticprotected

Definition at line 160 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fTheMaxEnergyTR = 100.0*keV

staticprotected

Definition at line 157 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fTheMinAngle = 5.0e-6

staticprotected

Definition at line 161 of file G4ForwardXrayTR.hh.

G4double G4ForwardXrayTR::fTheMinEnergyTR = 1.0*keV

staticprotected

Definition at line 156 of file G4ForwardXrayTR.hh.

G4int G4ForwardXrayTR::fTotBin = 50

staticprotected

Definition at line 167 of file G4ForwardXrayTR.hh.

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

geant4.10.03.p01/source/processes/electromagnetic/xrays/include/G4ForwardXrayTR.hh
geant4.10.03.p01/source/processes/electromagnetic/xrays/src/G4ForwardXrayTR.cc

Public Member Functions

Static Public Member Functions

Protected Attributes

Static Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation