#include <G4VXTRenergyLoss.hh>

Inheritance diagram for G4VXTRenergyLoss:

Collaboration diagram for G4VXTRenergyLoss:

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

virtual	~G4VXTRenergyLoss ()

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

virtual G4bool	IsApplicable (const G4ParticleDefinition &) override

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

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

virtual void	BuildPhysicsTable (const G4ParticleDefinition &) override

void	BuildEnergyTable ()

void	BuildAngleForEnergyBank ()

void	BuildTable ()

void	BuildAngleTable ()

void	BuildGlobalAngleTable ()

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

G4double	SpectralAngleXTRdEdx (G4double varAngle)

virtual G4double	SpectralXTRdEdx (G4double energy)

G4double	AngleSpectralXTRdEdx (G4double energy)

G4double	AngleXTRdEdx (G4double varAngle)

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

G4double	XTRNSpectralAngleDensity (G4double varAngle)

G4double	XTRNSpectralDensity (G4double energy)

G4double	XTRNAngleSpectralDensity (G4double energy)

G4double	XTRNAngleDensity (G4double varAngle)

void	GetNumberOfPhotons ()

G4double	GetPlateFormationZone (G4double, G4double, G4double)

G4complex	GetPlateComplexFZ (G4double, G4double, G4double)

void	ComputePlatePhotoAbsCof ()

G4double	GetPlateLinearPhotoAbs (G4double)

void	GetPlateZmuProduct ()

G4double	GetPlateZmuProduct (G4double, G4double, G4double)

G4double	GetGasFormationZone (G4double, G4double, G4double)

G4complex	GetGasComplexFZ (G4double, G4double, G4double)

void	ComputeGasPhotoAbsCof ()

G4double	GetGasLinearPhotoAbs (G4double)

void	GetGasZmuProduct ()

G4double	GetGasZmuProduct (G4double, G4double, G4double)

G4double	GetPlateCompton (G4double)

G4double	GetGasCompton (G4double)

G4double	GetComptonPerAtom (G4double, G4double)

G4double	GetXTRrandomEnergy (G4double scaledTkin, G4int iTkin)

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

G4double	GetRandomAngle (G4double energyXTR, G4int iTkin)

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

G4double	GetGamma ()

G4double	GetEnergy ()

G4double	GetVarAngle ()

void	SetGamma (G4double gamma)

void	SetEnergy (G4double energy)

void	SetVarAngle (G4double varAngle)

void	SetAngleRadDistr (G4bool pAngleRadDistr)

void	SetCompton (G4bool pC)

G4PhysicsLogVector *	GetProtonVector ()

G4int	GetTotBin ()

G4PhysicsFreeVector *	GetAngleVector (G4double energy, G4int n)

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

Protected Attributes
G4ParticleDefinition *	fPtrGamma

G4double *	fGammaCutInKineticEnergy

G4double	fGammaTkinCut

G4LogicalVolume *	fEnvelope

G4PhysicsTable *	fAngleDistrTable

G4PhysicsTable *	fEnergyDistrTable

G4PhysicsLogVector *	fProtonEnergyVector

G4PhysicsLogVector *	fXTREnergyVector

G4double	fTheMinEnergyTR

G4double	fTheMaxEnergyTR

G4double	fMinEnergyTR

G4double	fMaxEnergyTR

G4double	fTheMaxAngle

G4double	fTheMinAngle

G4double	fMaxThetaTR

G4int	fBinTR

G4double	fMinProtonTkin

G4double	fMaxProtonTkin

G4int	fTotBin

G4double	fGamma

G4double	fEnergy

G4double	fVarAngle

G4double	fLambda

G4double	fPlasmaCof

G4double	fCofTR

G4bool	fExitFlux

G4bool	fAngleRadDistr

G4bool	fCompton

G4double	fSigma1

G4double	fSigma2

G4int	fMatIndex1

G4int	fMatIndex2

G4int	fPlateNumber

G4double	fTotalDist

G4double	fPlateThick

G4double	fGasThick

G4double	fAlphaPlate

G4double	fAlphaGas

G4SandiaTable *	fPlatePhotoAbsCof

G4SandiaTable *	fGasPhotoAbsCof

G4ParticleChange	fParticleChange

G4PhysicsTable *	fAngleForEnergyTable

std::vector< G4PhysicsTable * >	fAngleBank

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

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

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

void	ClearNumberOfInteractionLengthLeft ()

Detailed Description

Definition at line 74 of file G4VXTRenergyLoss.hh.

Constructor & Destructor Documentation

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

explicit

Definition at line 64 of file G4VXTRenergyLoss.cc.

                                        :
   G4VDiscreteProcess(processName, type),
   fGammaCutInKineticEnergy(nullptr),
   fGammaTkinCut(0.0),
   fAngleDistrTable(nullptr),
   fEnergyDistrTable(nullptr),
   fPlatePhotoAbsCof(nullptr),
   fGasPhotoAbsCof(nullptr),
   fAngleForEnergyTable(nullptr)
 {
   verboseLevel = 1;
   SetProcessSubType(fTransitionRadiation);
 
   fPtrGamma = nullptr;
   fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = fGamma = fEnergy = fVarAngle 
     = fLambda = fTotalDist = fPlateThick = fGasThick = fAlphaPlate = fAlphaGas = 0.0;
 
   // Initialization of local constants
   fTheMinEnergyTR = 1.0*keV;
   fTheMaxEnergyTR = 100.0*keV;
   fTheMaxAngle    = 1.0e-2;
   fTheMinAngle    = 5.0e-6;
   fBinTR          = 50;
 
   fMinProtonTkin  = 100.0*GeV;
   fMaxProtonTkin  = 100.0*TeV;
   fTotBin         = 50;
 
   // Proton energy vector initialization
   fProtonEnergyVector = new G4PhysicsLogVector(fMinProtonTkin,
                            fMaxProtonTkin,
                            fTotBin  );
 
   fXTREnergyVector = new G4PhysicsLogVector(fTheMinEnergyTR,
                         fTheMaxEnergyTR,
                         fBinTR  );
 
   fPlasmaCof = 4.0*pi*fine_structure_const*hbarc*hbarc*hbarc/electron_mass_c2;
 
   fCofTR     = fine_structure_const/pi;
 
   fEnvelope  = anEnvelope;
 
   fPlateNumber = n;
   if(verboseLevel > 0)
     G4cout<<"### G4VXTRenergyLoss: the number of TR radiator plates = "
       <<fPlateNumber<<G4endl;
   if(fPlateNumber == 0)
   {
     G4Exception("G4VXTRenergyLoss::G4VXTRenergyLoss()","VXTRELoss01",
     FatalException,"No plates in X-ray TR radiator");
   }
   // default is XTR dEdx, not flux after radiator
 
   fExitFlux      = false;
   fAngleRadDistr = false;
   fCompton       = false;
 
   fLambda = DBL_MAX;
   // Mean thicknesses of plates and gas gaps
 
   fPlateThick = a;
   fGasThick   = b;
   fTotalDist  = fPlateNumber*(fPlateThick+fGasThick);
   if(verboseLevel > 0)
     G4cout<<"total radiator thickness = "<<fTotalDist/cm<<" cm"<<G4endl;
 
   // index of plate material
   fMatIndex1 = foilMat->GetIndex();
   if(verboseLevel > 0)
     G4cout<<"plate material = "<<foilMat->GetName()<<G4endl;
 
   // index of gas material
   fMatIndex2 = gasMat->GetIndex();
   if(verboseLevel > 0)
     G4cout<<"gas material = "<<gasMat->GetName()<<G4endl;
 
   // plasma energy squared for plate material
 
   fSigma1 = fPlasmaCof*foilMat->GetElectronDensity();
   //  fSigma1 = (20.9*eV)*(20.9*eV);
   if(verboseLevel > 0)
     G4cout<<"plate plasma energy = "<<std::sqrt(fSigma1)/eV<<" eV"<<G4endl;
 
   // plasma energy squared for gas material
 
   fSigma2 = fPlasmaCof*gasMat->GetElectronDensity();
   if(verboseLevel > 0)
     G4cout<<"gas plasma energy = "<<std::sqrt(fSigma2)/eV<<" eV"<<G4endl;
 
   // Compute cofs for preparation of linear photo absorption
 
   ComputePlatePhotoAbsCof();
   ComputeGasPhotoAbsCof();
 
   pParticleChange = &fParticleChange;
 }

Here is the call graph for this function:

G4VXTRenergyLoss::~G4VXTRenergyLoss ( )

virtual

Definition at line 168 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Member Function Documentation

G4double G4VXTRenergyLoss::AngleSpectralXTRdEdx ( G4double energy )

Definition at line 945 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

G4double G4VXTRenergyLoss::AngleXTRdEdx ( G4double varAngle )

Definition at line 956 of file G4VXTRenergyLoss.cc.

 {
   // G4cout<<"angle2 = "<<varAngle<<"; fGamma = "<<fGamma<<G4endl;
  
   G4double result;
   G4double sum = 0., tmp1, tmp2, tmp=0., cof1, cof2, cofMin, cofPHC, energy1, energy2;
   G4int k, kMax, kMin, i;
 
   cofPHC  = twopi*hbarc;
 
   cof1    = (fPlateThick + fGasThick)*(1./fGamma/fGamma + varAngle);
   cof2    = fPlateThick*fSigma1 + fGasThick*fSigma2;
 
   // G4cout<<"cof1 = "<<cof1<<"; cof2 = "<<cof2<<"; cofPHC = "<<cofPHC<<G4endl; 
 
   cofMin  =  std::sqrt(cof1*cof2); 
   cofMin /= cofPHC;
 
   kMin = G4int(cofMin);
   if (cofMin > kMin) kMin++;
 
   kMax = kMin + 9; //  9; // kMin + G4int(tmp);
 
   // G4cout<<"cofMin = "<<cofMin<<"; kMin = "<<kMin<<"; kMax = "<<kMax<<G4endl;
 
   for( k = kMin; k <= kMax; k++ )
   {
     tmp1 = cofPHC*k;
     tmp2 = std::sqrt(tmp1*tmp1-cof1*cof2);
     energy1 = (tmp1+tmp2)/cof1;
     energy2 = (tmp1-tmp2)/cof1;
 
     for(i = 0; i < 2; i++)
     {
       if( i == 0 )
       {
         if (energy1 > fTheMaxEnergyTR || energy1 < fTheMinEnergyTR) continue;
         tmp1 = ( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma1 )
       * fPlateThick/(4*hbarc*energy1);
         tmp2 = std::sin(tmp1);
         tmp  = energy1*tmp2*tmp2;
         tmp2 = fPlateThick/(4.*tmp1);
         tmp1 = hbarc*energy1/( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma2 );
     tmp *= (tmp1-tmp2)*(tmp1-tmp2);
     tmp1 = cof1/(4.*hbarc) - cof2/(4.*hbarc*energy1*energy1);
     tmp2 = std::abs(tmp1);
     if(tmp2 > 0.) tmp /= tmp2;
         else continue;
       }
       else
       {
         if (energy2 > fTheMaxEnergyTR || energy2 < fTheMinEnergyTR) continue;
         tmp1 = ( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma1 )
       * fPlateThick/(4.*hbarc*energy2);
         tmp2 = std::sin(tmp1);
         tmp  = energy2*tmp2*tmp2;
         tmp2 = fPlateThick/(4.*tmp1);
         tmp1 = hbarc*energy2/( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma2 );
     tmp *= (tmp1-tmp2)*(tmp1-tmp2);
     tmp1 = cof1/(4.*hbarc) - cof2/(4.*hbarc*energy2*energy2);
     tmp2 = std::abs(tmp1);
     if(tmp2 > 0.) tmp /= tmp2;
         else continue;
       }
       sum += tmp;
     }
     // G4cout<<"k = "<<k<<"; energy1 = "<<energy1/keV<<" keV; energy2 = "<<energy2/keV
     //  <<" keV; tmp = "<<tmp<<"; sum = "<<sum<<G4endl;
   }
   result = 4.*pi*fPlateNumber*sum*varAngle;
   result /= hbarc*hbarc;
 
   // old code based on general numeric integration
   // fVarAngle = varAngle;
   // G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
   // result = integral.Legendre10(this,&G4VXTRenergyLoss::AngleSpectralXTRdEdx,
   //                 fMinEnergyTR,fMaxEnergyTR);
   return result;
 }

Here is the caller graph for this function:

void G4VXTRenergyLoss::BuildAngleForEnergyBank ( )

Definition at line 391 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::BuildAngleTable ( )

Definition at line 482 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::BuildEnergyTable ( )

Definition at line 299 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::BuildGlobalAngleTable ( )

Definition at line 637 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

void G4VXTRenergyLoss::BuildPhysicsTable ( const G4ParticleDefinition & pd )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 274 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

void G4VXTRenergyLoss::BuildTable ( )

inline

Definition at line 102 of file G4VXTRenergyLoss.hh.

102 {} ;

void G4VXTRenergyLoss::ComputeGasPhotoAbsCof ( )

Definition at line 1154 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::ComputePlatePhotoAbsCof ( )

Definition at line 1079 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 555 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1590 of file G4VXTRenergyLoss.cc.

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

Here is the caller graph for this function:

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

Definition at line 1310 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::GetEnergy ( )

inline

Definition at line 165 of file G4VXTRenergyLoss.hh.

165 {return fEnergy;};

G4VXTRenergyLoss::fEnergy

G4double fEnergy

Definition: G4VXTRenergyLoss.hh:205

G4double G4VXTRenergyLoss::GetGamma ( )

inline

Definition at line 164 of file G4VXTRenergyLoss.hh.

164 {return fGamma;};

G4VXTRenergyLoss::fGamma

G4double fGamma

Definition: G4VXTRenergyLoss.hh:204

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

Definition at line 1130 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::GetGasCompton ( G4double omega )

Definition at line 1286 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1115 of file G4VXTRenergyLoss.cc.

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

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::GetGasLinearPhotoAbs ( G4double omega )

Definition at line 1167 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::GetGasZmuProduct ( )

Definition at line 1237 of file G4VXTRenergyLoss.cc.

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

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

Definition at line 1226 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

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

overridevirtual

Implements G4VDiscreteProcess.

Definition at line 201 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

void G4VXTRenergyLoss::GetNumberOfPhotons ( )

Definition at line 1442 of file G4VXTRenergyLoss.cc.

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

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

Definition at line 1057 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::GetPlateCompton ( G4double omega )

Definition at line 1262 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 1043 of file G4VXTRenergyLoss.cc.

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

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::GetPlateLinearPhotoAbs ( G4double omega )

Definition at line 1095 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

void G4VXTRenergyLoss::GetPlateZmuProduct ( )

Definition at line 1199 of file G4VXTRenergyLoss.cc.

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

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

Definition at line 1187 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

G4PhysicsLogVector* G4VXTRenergyLoss::GetProtonVector ( )

inline

Definition at line 174 of file G4VXTRenergyLoss.hh.

174 { return fProtonEnergyVector;};

G4VXTRenergyLoss::fProtonEnergyVector

G4PhysicsLogVector * fProtonEnergyVector

Definition: G4VXTRenergyLoss.hh:189

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

Definition at line 1560 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

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

Definition at line 1381 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4VXTRenergyLoss::GetTotBin ( )

inline

Definition at line 175 of file G4VXTRenergyLoss.hh.

175 {return fTotBin;};

G4VXTRenergyLoss::fTotBin

G4int fTotBin

Definition: G4VXTRenergyLoss.hh:203

G4double G4VXTRenergyLoss::GetVarAngle ( )

inline

Definition at line 166 of file G4VXTRenergyLoss.hh.

166 {return fVarAngle;};

G4VXTRenergyLoss::fVarAngle

G4double fVarAngle

Definition: G4VXTRenergyLoss.hh:206

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

Definition at line 1524 of file G4VXTRenergyLoss.cc.

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

Here is the caller graph for this function:

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

Definition at line 1473 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4VXTRenergyLoss::IsApplicable ( const G4ParticleDefinition & particle )

overridevirtual

Reimplemented from G4VProcess.

Definition at line 192 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

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

Definition at line 1364 of file G4VXTRenergyLoss.cc.

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

Here is the caller graph for this function:

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

Definition at line 868 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

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

overridevirtual

Reimplemented from G4VDiscreteProcess.

Definition at line 728 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

void G4VXTRenergyLoss::SetAngleRadDistr ( G4bool pAngleRadDistr )

inline

Definition at line 171 of file G4VXTRenergyLoss.hh.

171 {fAngleRadDistr=pAngleRadDistr;};

G4VXTRenergyLoss::fAngleRadDistr

G4bool fAngleRadDistr

Definition: G4VXTRenergyLoss.hh:213

void G4VXTRenergyLoss::SetCompton ( G4bool pC )

inline

Definition at line 172 of file G4VXTRenergyLoss.hh.

172 {fCompton=pC;};

G4VXTRenergyLoss::fCompton

G4bool fCompton

Definition: G4VXTRenergyLoss.hh:214

void G4VXTRenergyLoss::SetEnergy ( G4double energy )

inline

Definition at line 169 of file G4VXTRenergyLoss.hh.

169 {fEnergy = energy;};

G4VXTRenergyLoss::fEnergy

G4double fEnergy

Definition: G4VXTRenergyLoss.hh:205

G4INCL::KinematicsUtils::energy

G4double energy(const ThreeVector &p, const G4double m)

Definition: G4INCLKinematicsUtils.cc:157

Here is the call graph for this function:

void G4VXTRenergyLoss::SetGamma ( G4double gamma )

inline

Definition at line 168 of file G4VXTRenergyLoss.hh.

168 {fGamma = gamma;};

G4VXTRenergyLoss::fGamma

G4double fGamma

Definition: G4VXTRenergyLoss.hh:204

void G4VXTRenergyLoss::SetVarAngle ( G4double varAngle )

inline

Definition at line 170 of file G4VXTRenergyLoss.hh.

170 {fVarAngle = varAngle;};

G4VXTRenergyLoss::fVarAngle

G4double fVarAngle

Definition: G4VXTRenergyLoss.hh:206

G4double G4VXTRenergyLoss::SpectralAngleXTRdEdx ( G4double varAngle )

Definition at line 887 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::SpectralXTRdEdx ( G4double energy )

virtual

Reimplemented in G4TransparentRegXTRadiator, G4RegularXTRadiator, G4XTRTransparentRegRadModel, and G4XTRRegularRadModel.

Definition at line 898 of file G4VXTRenergyLoss.cc.

 {
   G4int i, iMax = 8;
   G4double angleSum = 0.0;
 
   G4double lim[8] = { 0.0, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0 };
 
   for( i = 0; i < iMax; i++ ) lim[i] *= fMaxThetaTR;
 
   G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
 
   fEnergy = energy;
   /*
   if( fAngleRadDistr && ( fEnergy == fEnergyForAngle ) )
   {
     fAngleVector ->PutValue(fBinTR - 1, angleSum);
 
     for( i = fBinTR - 2; i >= 0; i-- )
     {
 
       angleSum  += integral.Legendre10(
                this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
                fAngleVector->GetLowEdgeEnergy(i),
                fAngleVector->GetLowEdgeEnergy(i+1) );
 
       fAngleVector ->PutValue(i, angleSum);
     }
   }
   else
   */
   {
     for( i = 0; i < iMax-1; i++ )
     {
       angleSum += integral.Legendre96(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
                    lim[i],lim[i+1]);
       // result += integral.Legendre10(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
       //               lim[i],lim[i+1]);
     }
   }
   return angleSum;
 } 

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::XTRNAngleDensity ( G4double varAngle )

Definition at line 1429 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

G4double G4VXTRenergyLoss::XTRNAngleSpectralDensity ( G4double energy )

Definition at line 1419 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::XTRNSpectralAngleDensity ( G4double varAngle )

Definition at line 1394 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4VXTRenergyLoss::XTRNSpectralDensity ( G4double energy )

Definition at line 1404 of file G4VXTRenergyLoss.cc.

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

Here is the call graph for this function:

Member Data Documentation

G4double G4VXTRenergyLoss::fAlphaGas

protected

Definition at line 226 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fAlphaPlate

protected

Definition at line 225 of file G4VXTRenergyLoss.hh.

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

protected

Definition at line 235 of file G4VXTRenergyLoss.hh.

G4PhysicsTable* G4VXTRenergyLoss::fAngleDistrTable

protected

Definition at line 186 of file G4VXTRenergyLoss.hh.

G4PhysicsTable* G4VXTRenergyLoss::fAngleForEnergyTable

protected

Definition at line 234 of file G4VXTRenergyLoss.hh.

G4bool G4VXTRenergyLoss::fAngleRadDistr

protected

Definition at line 213 of file G4VXTRenergyLoss.hh.

G4int G4VXTRenergyLoss::fBinTR

protected

Definition at line 199 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fCofTR

protected

Definition at line 210 of file G4VXTRenergyLoss.hh.

G4bool G4VXTRenergyLoss::fCompton

protected

Definition at line 214 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fEnergy

protected

Definition at line 205 of file G4VXTRenergyLoss.hh.

G4PhysicsTable* G4VXTRenergyLoss::fEnergyDistrTable

protected

Definition at line 187 of file G4VXTRenergyLoss.hh.

G4LogicalVolume* G4VXTRenergyLoss::fEnvelope

protected

Definition at line 185 of file G4VXTRenergyLoss.hh.

G4bool G4VXTRenergyLoss::fExitFlux

protected

Definition at line 212 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fGamma

protected

Definition at line 204 of file G4VXTRenergyLoss.hh.

G4double* G4VXTRenergyLoss::fGammaCutInKineticEnergy

protected

Definition at line 182 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fGammaTkinCut

protected

Definition at line 184 of file G4VXTRenergyLoss.hh.

G4SandiaTable* G4VXTRenergyLoss::fGasPhotoAbsCof

protected

Definition at line 230 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fGasThick

protected

Definition at line 224 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fLambda

protected

Definition at line 207 of file G4VXTRenergyLoss.hh.

G4int G4VXTRenergyLoss::fMatIndex1

protected

Definition at line 218 of file G4VXTRenergyLoss.hh.

G4int G4VXTRenergyLoss::fMatIndex2

protected

Definition at line 219 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fMaxEnergyTR

protected

Definition at line 195 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fMaxProtonTkin

protected

Definition at line 202 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fMaxThetaTR

protected

Definition at line 198 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fMinEnergyTR

protected

Definition at line 194 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fMinProtonTkin

protected

Definition at line 201 of file G4VXTRenergyLoss.hh.

G4ParticleChange G4VXTRenergyLoss::fParticleChange

protected

Definition at line 232 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fPlasmaCof

protected

Definition at line 209 of file G4VXTRenergyLoss.hh.

G4int G4VXTRenergyLoss::fPlateNumber

protected

Definition at line 220 of file G4VXTRenergyLoss.hh.

G4SandiaTable* G4VXTRenergyLoss::fPlatePhotoAbsCof

protected

Definition at line 228 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fPlateThick

protected

Definition at line 223 of file G4VXTRenergyLoss.hh.

G4PhysicsLogVector* G4VXTRenergyLoss::fProtonEnergyVector

protected

Definition at line 189 of file G4VXTRenergyLoss.hh.

G4ParticleDefinition* G4VXTRenergyLoss::fPtrGamma

protected

Definition at line 180 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fSigma1

protected

Definition at line 215 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fSigma2

protected

Definition at line 216 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fTheMaxAngle

protected

Definition at line 196 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fTheMaxEnergyTR

protected

Definition at line 193 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fTheMinAngle

protected

Definition at line 197 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fTheMinEnergyTR

protected

Definition at line 192 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fTotalDist

protected

Definition at line 222 of file G4VXTRenergyLoss.hh.

G4int G4VXTRenergyLoss::fTotBin

protected

Definition at line 203 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fVarAngle

protected

Definition at line 206 of file G4VXTRenergyLoss.hh.

G4PhysicsLogVector* G4VXTRenergyLoss::fXTREnergyVector

protected

Definition at line 190 of file G4VXTRenergyLoss.hh.

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

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

Public Member Functions

Protected Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation