Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | Protected Attributes
G4VXTRenergyLoss Class Reference

#include <G4VXTRenergyLoss.hh>

Inheritance diagram for G4VXTRenergyLoss:
G4VDiscreteProcess G4VProcess Em10XTRTransparentRegRadModel G4GammaXTRadiator G4RegularXTRadiator G4StrawTubeXTRadiator G4TransparentRegXTRadiator G4XTRGammaRadModel G4XTRRegularRadModel G4XTRTransparentRegRadModel

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)
 
G4bool IsApplicable (const G4ParticleDefinition &)
 
G4VParticleChange * PostStepDoIt (const G4Track &aTrack, const G4Step &aStep)
 
G4double GetMeanFreePath (const G4Track &aTrack, G4double previousStepSize, G4ForceCondition *condition)
 
void BuildPhysicsTable (const G4ParticleDefinition &)
 
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 
)

Definition at line 63 of file G4VXTRenergyLoss.cc.

References test::a, test::b, python.hepunit::cm, ComputeGasPhotoAbsCof(), ComputePlatePhotoAbsCof(), DBL_MAX, python.hepunit::electron_mass_c2, python.hepunit::eV, fAlphaGas, fAlphaPlate, fAngleRadDistr, FatalException, fBinTR, fCofTR, fCompton, fEnergy, fEnvelope, fExitFlux, fGamma, fGasThick, python.hepunit::fine_structure_const, fLambda, fMatIndex1, fMatIndex2, fMaxEnergyTR, fMaxProtonTkin, fMaxThetaTR, fMinEnergyTR, fMinProtonTkin, fParticleChange, fPlasmaCof, fPlateNumber, fPlateThick, fProtonEnergyVector, fPtrGamma, fSigma1, fSigma2, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotalDist, fTotBin, fVarAngle, fXTREnergyVector, G4cout, G4endl, G4Exception(), G4Material::GetElectronDensity(), G4Material::GetIndex(), G4Material::GetName(), python.hepunit::GeV, python.hepunit::hbarc, python.hepunit::keV, n, python.hepunit::pi, G4VProcess::pParticleChange, python.hepunit::TeV, and G4VProcess::verboseLevel.

67  :
68  G4VDiscreteProcess(processName, type),
69  fGammaCutInKineticEnergy(0),
70  fGammaTkinCut(0),
71  fAngleDistrTable(0),
72  fEnergyDistrTable(0),
73  fPlatePhotoAbsCof(0),
74  fGasPhotoAbsCof(0),
75  fAngleForEnergyTable(0)
76 {
77  verboseLevel = 1;
78 
79  fPtrGamma = 0;
80  fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = fGamma = fEnergy = fVarAngle
81  = fLambda = fTotalDist = fPlateThick = fGasThick = fAlphaPlate = fAlphaGas = 0.0;
82 
83  // Initialization of local constants
84  fTheMinEnergyTR = 1.0*keV;
85  fTheMaxEnergyTR = 100.0*keV;
86  fTheMaxAngle = 1.0e-2;
87  fTheMinAngle = 5.0e-6;
88  fBinTR = 50;
89 
90  fMinProtonTkin = 100.0*GeV;
91  fMaxProtonTkin = 100.0*TeV;
92  fTotBin = 50;
93 
94  // Proton energy vector initialization
95 
96  fProtonEnergyVector = new G4PhysicsLogVector(fMinProtonTkin,
97  fMaxProtonTkin,
98  fTotBin );
99 
100  fXTREnergyVector = new G4PhysicsLogVector(fTheMinEnergyTR,
101  fTheMaxEnergyTR,
102  fBinTR );
103 
104  fPlasmaCof = 4.0*pi*fine_structure_const*hbarc*hbarc*hbarc/electron_mass_c2;
105 
106  fCofTR = fine_structure_const/pi;
107 
108  fEnvelope = anEnvelope;
109 
110  fPlateNumber = n;
111  if(verboseLevel > 0)
112  G4cout<<"### G4VXTRenergyLoss: the number of TR radiator plates = "
113  <<fPlateNumber<<G4endl;
114  if(fPlateNumber == 0)
115  {
116  G4Exception("G4VXTRenergyLoss::G4VXTRenergyLoss()","VXTRELoss01",
117  FatalException,"No plates in X-ray TR radiator");
118  }
119  // default is XTR dEdx, not flux after radiator
120 
121  fExitFlux = false;
122  fAngleRadDistr = false;
123  fCompton = false;
124 
125  fLambda = DBL_MAX;
126  // Mean thicknesses of plates and gas gaps
127 
128  fPlateThick = a;
129  fGasThick = b;
130  fTotalDist = fPlateNumber*(fPlateThick+fGasThick);
131  if(verboseLevel > 0)
132  G4cout<<"total radiator thickness = "<<fTotalDist/cm<<" cm"<<G4endl;
133 
134  // index of plate material
135  fMatIndex1 = foilMat->GetIndex();
136  if(verboseLevel > 0)
137  G4cout<<"plate material = "<<foilMat->GetName()<<G4endl;
138 
139  // index of gas material
140  fMatIndex2 = gasMat->GetIndex();
141  if(verboseLevel > 0)
142  G4cout<<"gas material = "<<gasMat->GetName()<<G4endl;
143 
144  // plasma energy squared for plate material
145 
146  fSigma1 = fPlasmaCof*foilMat->GetElectronDensity();
147  // fSigma1 = (20.9*eV)*(20.9*eV);
148  if(verboseLevel > 0)
149  G4cout<<"plate plasma energy = "<<std::sqrt(fSigma1)/eV<<" eV"<<G4endl;
150 
151  // plasma energy squared for gas material
152 
153  fSigma2 = fPlasmaCof*gasMat->GetElectronDensity();
154  if(verboseLevel > 0)
155  G4cout<<"gas plasma energy = "<<std::sqrt(fSigma2)/eV<<" eV"<<G4endl;
156 
157  // Compute cofs for preparation of linear photo absorption
158 
159  ComputePlatePhotoAbsCof();
160  ComputeGasPhotoAbsCof();
161 
162  pParticleChange = &fParticleChange;
163 }
G4VXTRenergyLoss::fEnergyDistrTable
G4PhysicsTable * fEnergyDistrTable
Definition: G4VXTRenergyLoss.hh:187
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4VXTRenergyLoss::fEnvelope
G4LogicalVolume * fEnvelope
Definition: G4VXTRenergyLoss.hh:185
G4Material::GetIndex
size_t GetIndex() const
Definition: G4Material.hh:260
G4Material::GetName
const G4String & GetName() const
Definition: G4Material.hh:176
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4Material::GetElectronDensity
G4double GetElectronDensity() const
Definition: G4Material.hh:215
python.hepunit.electron_mass_c2
float electron_mass_c2
Definition: hepunit.py:274
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4VXTRenergyLoss::fGasPhotoAbsCof
G4SandiaTable * fGasPhotoAbsCof
Definition: G4VXTRenergyLoss.hh:230
G4VXTRenergyLoss::fGammaCutInKineticEnergy
G4double * fGammaCutInKineticEnergy
Definition: G4VXTRenergyLoss.hh:182
G4VProcess::pParticleChange
G4VParticleChange * pParticleChange
Definition: G4VProcess.hh:283
G4VXTRenergyLoss::fXTREnergyVector
G4PhysicsLogVector * fXTREnergyVector
Definition: G4VXTRenergyLoss.hh:190
FatalException
Definition: G4ExceptionSeverity.hh:60
G4VXTRenergyLoss::fAngleForEnergyTable
G4PhysicsTable * fAngleForEnergyTable
Definition: G4VXTRenergyLoss.hh:236
G4endl
#define G4endl
Definition: G4ios.hh:61
G4VXTRenergyLoss::fAngleDistrTable
G4PhysicsTable * fAngleDistrTable
Definition: G4VXTRenergyLoss.hh:186
G4VXTRenergyLoss::fPlatePhotoAbsCof
G4SandiaTable * fPlatePhotoAbsCof
Definition: G4VXTRenergyLoss.hh:228
G4VXTRenergyLoss::fPtrGamma
G4ParticleDefinition * fPtrGamma
Definition: G4VXTRenergyLoss.hh:180
G4VXTRenergyLoss::fParticleChange
G4ParticleChange fParticleChange
Definition: G4VXTRenergyLoss.hh:232
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
G4VXTRenergyLoss::~G4VXTRenergyLoss ( )
virtual

Definition at line 167 of file G4VXTRenergyLoss.cc.

References fAngleDistrTable, fAngleForEnergyTable, fAngleRadDistr, fEnergyDistrTable, fEnvelope, fProtonEnergyVector, and fXTREnergyVector.

168 {
169  if(fEnvelope) delete fEnvelope;
170  delete fProtonEnergyVector;
171  delete fXTREnergyVector;
172  delete fEnergyDistrTable;
173  if(fAngleRadDistr) delete fAngleDistrTable;
174  delete fAngleForEnergyTable;
175 }
G4VXTRenergyLoss::fEnergyDistrTable
G4PhysicsTable * fEnergyDistrTable
Definition: G4VXTRenergyLoss.hh:187
G4VXTRenergyLoss::fEnvelope
G4LogicalVolume * fEnvelope
Definition: G4VXTRenergyLoss.hh:185
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4VXTRenergyLoss::fXTREnergyVector
G4PhysicsLogVector * fXTREnergyVector
Definition: G4VXTRenergyLoss.hh:190
G4VXTRenergyLoss::fAngleForEnergyTable
G4PhysicsTable * fAngleForEnergyTable
Definition: G4VXTRenergyLoss.hh:236
G4VXTRenergyLoss::fAngleDistrTable
G4PhysicsTable * fAngleDistrTable
Definition: G4VXTRenergyLoss.hh:186

Member Function Documentation

G4double G4VXTRenergyLoss::AngleSpectralXTRdEdx ( G4double  energy)

Definition at line 935 of file G4VXTRenergyLoss.cc.

References fGamma, fVarAngle, and GetStackFactor().

936 {
937  G4double result = GetStackFactor(energy,fGamma,fVarAngle);
938  if(result < 0) result = 0.0;
939  return result;
940 }
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4double
double G4double
Definition: G4Types.hh:76
G4VXTRenergyLoss::GetStackFactor
virtual G4double GetStackFactor(G4double energy, G4double gamma, G4double varAngle)
Definition: G4VXTRenergyLoss.cc:1371
G4double G4VXTRenergyLoss::AngleXTRdEdx ( G4double  varAngle)

Definition at line 946 of file G4VXTRenergyLoss.cc.

References fGamma, fGasThick, fPlateNumber, fPlateThick, fSigma1, fSigma2, fTheMaxEnergyTR, fTheMinEnergyTR, python.hepunit::hbarc, python.hepunit::pi, and python.hepunit::twopi.

Referenced by BuildGlobalAngleTable().

947 {
948  // G4cout<<"angle2 = "<<varAngle<<"; fGamma = "<<fGamma<<G4endl;
949 
950  G4double result;
951  G4double sum = 0., tmp1, tmp2, tmp=0., cof1, cof2, cofMin, cofPHC, energy1, energy2;
952  G4int k, kMax, kMin, i;
953 
954  cofPHC = twopi*hbarc;
955 
956  cof1 = (fPlateThick + fGasThick)*(1./fGamma/fGamma + varAngle);
957  cof2 = fPlateThick*fSigma1 + fGasThick*fSigma2;
958 
959  // G4cout<<"cof1 = "<<cof1<<"; cof2 = "<<cof2<<"; cofPHC = "<<cofPHC<<G4endl;
960 
961  cofMin = std::sqrt(cof1*cof2);
962  cofMin /= cofPHC;
963 
964  kMin = G4int(cofMin);
965  if (cofMin > kMin) kMin++;
966 
967  kMax = kMin + 9; // 9; // kMin + G4int(tmp);
968 
969  // G4cout<<"cofMin = "<<cofMin<<"; kMin = "<<kMin<<"; kMax = "<<kMax<<G4endl;
970 
971  for( k = kMin; k <= kMax; k++ )
972  {
973  tmp1 = cofPHC*k;
974  tmp2 = std::sqrt(tmp1*tmp1-cof1*cof2);
975  energy1 = (tmp1+tmp2)/cof1;
976  energy2 = (tmp1-tmp2)/cof1;
977 
978  for(i = 0; i < 2; i++)
979  {
980  if( i == 0 )
981  {
982  if (energy1 > fTheMaxEnergyTR || energy1 < fTheMinEnergyTR) continue;
983  tmp1 = ( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma1 )
984  * fPlateThick/(4*hbarc*energy1);
985  tmp2 = std::sin(tmp1);
986  tmp = energy1*tmp2*tmp2;
987  tmp2 = fPlateThick/(4*tmp1);
988  tmp1 = hbarc*energy1/( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma2 );
989  tmp *= (tmp1-tmp2)*(tmp1-tmp2);
990  tmp1 = cof1/(4*hbarc) - cof2/(4*hbarc*energy1*energy1);
991  tmp2 = std::abs(tmp1);
992  if(tmp2 > 0.) tmp /= tmp2;
993  else continue;
994  }
995  else
996  {
997  if (energy2 > fTheMaxEnergyTR || energy2 < fTheMinEnergyTR) continue;
998  tmp1 = ( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma1 )
999  * fPlateThick/(4*hbarc*energy2);
1000  tmp2 = std::sin(tmp1);
1001  tmp = energy2*tmp2*tmp2;
1002  tmp2 = fPlateThick/(4*tmp1);
1003  tmp1 = hbarc*energy2/( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma2 );
1004  tmp *= (tmp1-tmp2)*(tmp1-tmp2);
1005  tmp1 = cof1/(4*hbarc) - cof2/(4*hbarc*energy2*energy2);
1006  tmp2 = std::abs(tmp1);
1007  if(tmp2 > 0.) tmp /= tmp2;
1008  else continue;
1009  }
1010  sum += tmp;
1011  }
1012  // G4cout<<"k = "<<k<<"; energy1 = "<<energy1/keV<<" keV; energy2 = "<<energy2/keV
1013  // <<" keV; tmp = "<<tmp<<"; sum = "<<sum<<G4endl;
1014  }
1015  result = 4.*pi*fPlateNumber*sum*varAngle;
1016  result /= hbarc*hbarc;
1017 
1018  // old code based on general numeric integration
1019  // fVarAngle = varAngle;
1020  // G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
1021  // result = integral.Legendre10(this,&G4VXTRenergyLoss::AngleSpectralXTRdEdx,
1022  // fMinEnergyTR,fMaxEnergyTR);
1023  return result;
1024 }
G4int
int G4int
Definition: G4Types.hh:78
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::BuildAngleForEnergyBank ( )

Definition at line 381 of file G4VXTRenergyLoss.cc.

References BuildAngleTable(), fAngleBank, fAngleForEnergyTable, fBinTR, fEnergy, fGamma, fGammaTkinCut, fMaxEnergyTR, fMaxThetaTR, fMinEnergyTR, fProtonEnergyVector, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotBin, G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4VProcess::GetProcessName(), G4Timer::GetUserElapsed(), G4PhysicsTable::insertAt(), G4Integrator< T, F >::Legendre10(), python.hepunit::proton_mass_c2, G4PhysicsVector::PutValue(), SpectralAngleXTRdEdx(), G4Timer::Start(), G4Timer::Stop(), and G4VProcess::verboseLevel.

Referenced by BuildPhysicsTable().

382 {
383  if( this->GetProcessName() == "TranspRegXTRadiator" ||
384  this->GetProcessName() == "TranspRegXTRmodel" ||
385  this->GetProcessName() == "RegularXTRadiator" ||
386  this->GetProcessName() == "RegularXTRmodel" )
387  {
388  BuildAngleTable();
389  return;
390  }
391  G4int i, iTkin, iTR;
392  G4double angleSum = 0.0;
393 
394 
395  fGammaTkinCut = 0.0;
396 
397  // setting of min/max TR energies
398 
399  if(fGammaTkinCut > fTheMinEnergyTR) fMinEnergyTR = fGammaTkinCut;
400  else fMinEnergyTR = fTheMinEnergyTR;
401 
402  if(fGammaTkinCut > fTheMaxEnergyTR) fMaxEnergyTR = 2.0*fGammaTkinCut;
403  else fMaxEnergyTR = fTheMaxEnergyTR;
404 
405  G4PhysicsLogVector* energyVector = new G4PhysicsLogVector( fMinEnergyTR,
406  fMaxEnergyTR,
407  fBinTR );
408 
409  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
410 
411  G4cout.precision(4);
412  G4Timer timer;
413  timer.Start();
414 
415  for( iTkin = 0; iTkin < fTotBin; iTkin++ ) // Lorentz factor loop
416  {
417 
418  fGamma = 1.0 + (fProtonEnergyVector->
419  GetLowEdgeEnergy(iTkin)/proton_mass_c2);
420 
421  fMaxThetaTR = 2500.0/(fGamma*fGamma) ; // theta^2
422 
423  fTheMinAngle = 1.0e-3; // was 5.e-6, e-6 !!!, e-5, e-4
424 
425  if( fMaxThetaTR > fTheMaxAngle ) fMaxThetaTR = fTheMaxAngle;
426  else if( fMaxThetaTR < fTheMinAngle ) fMaxThetaTR = fTheMinAngle;
427 
428  fAngleForEnergyTable = new G4PhysicsTable(fBinTR);
429 
430  for( iTR = 0; iTR < fBinTR; iTR++ )
431  {
432  angleSum = 0.0;
433  fEnergy = energyVector->GetLowEdgeEnergy(iTR);
434  G4PhysicsLinearVector* angleVector = new G4PhysicsLinearVector(0.0,
435  fMaxThetaTR,
436  fBinTR );
437 
438  angleVector ->PutValue(fBinTR - 1, angleSum);
439 
440  for( i = fBinTR - 2; i >= 0; i-- )
441  {
442  // Legendre96 or Legendre10
443 
444  angleSum += integral.Legendre10(
445  this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
446  angleVector->GetLowEdgeEnergy(i),
447  angleVector->GetLowEdgeEnergy(i+1) );
448 
449  angleVector ->PutValue(i, angleSum);
450  }
451  fAngleForEnergyTable->insertAt(iTR, angleVector);
452  }
453  fAngleBank.push_back(fAngleForEnergyTable);
454  }
455  timer.Stop();
456  G4cout.precision(6);
457  if(verboseLevel > 0)
458  {
459  G4cout<<G4endl;
460  G4cout<<"total time for build X-ray TR angle for energy loss tables = "
461  <<timer.GetUserElapsed()<<" s"<<G4endl;
462  }
463  fGamma = 0.;
464  return;
465 }
G4Integrator::Legendre10
G4double Legendre10(T &typeT, F f, G4double a, G4double b)
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4Timer::GetUserElapsed
G4double GetUserElapsed() const
Definition: G4Timer.cc:130
G4PhysicsVector::PutValue
void PutValue(size_t index, G4double theValue)
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4VProcess::GetProcessName
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4Timer::Stop
void Stop()
G4VXTRenergyLoss::SpectralAngleXTRdEdx
G4double SpectralAngleXTRdEdx(G4double varAngle)
Definition: G4VXTRenergyLoss.cc:877
G4VXTRenergyLoss::fAngleBank
std::vector< G4PhysicsTable * > fAngleBank
Definition: G4VXTRenergyLoss.hh:237
G4PhysicsTable::insertAt
void insertAt(size_t, G4PhysicsVector *)
G4VXTRenergyLoss::fAngleForEnergyTable
G4PhysicsTable * fAngleForEnergyTable
Definition: G4VXTRenergyLoss.hh:236
G4endl
#define G4endl
Definition: G4ios.hh:61
G4Timer::Start
void Start()
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::BuildAngleTable ( )

Definition at line 472 of file G4VXTRenergyLoss.cc.

References energy(), fAngleBank, fAngleForEnergyTable, fBinTR, fGamma, fGammaTkinCut, fMaxEnergyTR, fMaxThetaTR, fMinEnergyTR, fProtonEnergyVector, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotBin, fXTREnergyVector, G4cout, G4endl, GetAngleVector(), G4PhysicsVector::GetLowEdgeEnergy(), G4Timer::GetUserElapsed(), G4PhysicsTable::insertAt(), python.hepunit::proton_mass_c2, G4Timer::Start(), G4Timer::Stop(), and G4VProcess::verboseLevel.

Referenced by BuildAngleForEnergyBank().

473 {
474  G4int iTkin, iTR;
475  G4double energy;
476 
477  fGammaTkinCut = 0.0;
478 
479  // setting of min/max TR energies
480 
481  if(fGammaTkinCut > fTheMinEnergyTR) fMinEnergyTR = fGammaTkinCut;
482  else fMinEnergyTR = fTheMinEnergyTR;
483 
484  if(fGammaTkinCut > fTheMaxEnergyTR) fMaxEnergyTR = 2.0*fGammaTkinCut;
485  else fMaxEnergyTR = fTheMaxEnergyTR;
486 
487  G4cout.precision(4);
488  G4Timer timer;
489  timer.Start();
490  if(verboseLevel > 0)
491  {
492  G4cout<<G4endl;
493  G4cout<<"Lorentz Factor"<<"\t"<<"XTR photon number"<<G4endl;
494  G4cout<<G4endl;
495  }
496  for( iTkin = 0; iTkin < fTotBin; iTkin++ ) // Lorentz factor loop
497  {
498 
499  fGamma = 1.0 + (fProtonEnergyVector->
500  GetLowEdgeEnergy(iTkin)/proton_mass_c2);
501 
502  fMaxThetaTR = 25.0/(fGamma*fGamma); // theta^2
503 
504  fTheMinAngle = 1.0e-3; // was 5.e-6, e-6 !!!, e-5, e-4
505 
506  if( fMaxThetaTR > fTheMaxAngle ) fMaxThetaTR = fTheMaxAngle;
507  else
508  {
509  if( fMaxThetaTR < fTheMinAngle ) fMaxThetaTR = fTheMinAngle;
510  }
511 
512  fAngleForEnergyTable = new G4PhysicsTable(fBinTR);
513 
514  for( iTR = 0; iTR < fBinTR; iTR++ )
515  {
516  // energy = fMinEnergyTR*(iTR+1);
517 
518  energy = fXTREnergyVector->GetLowEdgeEnergy(iTR);
519 
520  G4PhysicsFreeVector* angleVector = GetAngleVector(energy,fBinTR);
521  // G4cout<<G4endl;
522 
523  fAngleForEnergyTable->insertAt(iTR,angleVector);
524  }
525 
526  fAngleBank.push_back(fAngleForEnergyTable);
527  }
528  timer.Stop();
529  G4cout.precision(6);
530  if(verboseLevel > 0)
531  {
532  G4cout<<G4endl;
533  G4cout<<"total time for build XTR angle for given energy tables = "
534  <<timer.GetUserElapsed()<<" s"<<G4endl;
535  }
536  fGamma = 0.;
537 
538  return;
539 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4Timer::GetUserElapsed
G4double GetUserElapsed() const
Definition: G4Timer.cc:130
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4VXTRenergyLoss::GetAngleVector
G4PhysicsFreeVector * GetAngleVector(G4double energy, G4int n)
Definition: G4VXTRenergyLoss.cc:545
G4Timer::Stop
void Stop()
G4VXTRenergyLoss::fXTREnergyVector
G4PhysicsLogVector * fXTREnergyVector
Definition: G4VXTRenergyLoss.hh:190
G4VXTRenergyLoss::fAngleBank
std::vector< G4PhysicsTable * > fAngleBank
Definition: G4VXTRenergyLoss.hh:237
G4PhysicsTable::insertAt
void insertAt(size_t, G4PhysicsVector *)
G4VXTRenergyLoss::fAngleForEnergyTable
G4PhysicsTable * fAngleForEnergyTable
Definition: G4VXTRenergyLoss.hh:236
G4endl
#define G4endl
Definition: G4ios.hh:61
G4Timer::Start
void Start()
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::BuildEnergyTable ( )

Definition at line 289 of file G4VXTRenergyLoss.cc.

References fAngleDistrTable, fAngleRadDistr, fBinTR, fCofTR, fEnergyDistrTable, fGamma, fGammaTkinCut, fMaxEnergyTR, fMaxThetaTR, fMinEnergyTR, fProtonEnergyVector, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotalDist, fTotBin, G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4Timer::GetUserElapsed(), G4PhysicsTable::insertAt(), G4Integrator< T, F >::Legendre10(), python.hepunit::proton_mass_c2, G4PhysicsVector::PutValue(), SpectralXTRdEdx(), G4Timer::Start(), G4Timer::Stop(), and G4VProcess::verboseLevel.

Referenced by BuildPhysicsTable().

290 {
291  G4int iTkin, iTR, iPlace;
292  G4double radiatorCof = 1.0; // for tuning of XTR yield
293  G4double energySum = 0.0;
294 
295  fEnergyDistrTable = new G4PhysicsTable(fTotBin);
296  if(fAngleRadDistr) fAngleDistrTable = new G4PhysicsTable(fTotBin);
297 
298  fGammaTkinCut = 0.0;
299 
300  // setting of min/max TR energies
301 
302  if(fGammaTkinCut > fTheMinEnergyTR) fMinEnergyTR = fGammaTkinCut;
303  else fMinEnergyTR = fTheMinEnergyTR;
304 
305  if(fGammaTkinCut > fTheMaxEnergyTR) fMaxEnergyTR = 2.0*fGammaTkinCut;
306  else fMaxEnergyTR = fTheMaxEnergyTR;
307 
308  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
309 
310  G4cout.precision(4);
311  G4Timer timer;
312  timer.Start();
313 
314  if(verboseLevel > 0)
315  {
316  G4cout<<G4endl;
317  G4cout<<"Lorentz Factor"<<"\t"<<"XTR photon number"<<G4endl;
318  G4cout<<G4endl;
319  }
320  for( iTkin = 0; iTkin < fTotBin; iTkin++ ) // Lorentz factor loop
321  {
322  G4PhysicsLogVector* energyVector = new G4PhysicsLogVector( fMinEnergyTR,
323  fMaxEnergyTR,
324  fBinTR );
325 
326  fGamma = 1.0 + (fProtonEnergyVector->
327  GetLowEdgeEnergy(iTkin)/proton_mass_c2);
328 
329  fMaxThetaTR = 2500.0/(fGamma*fGamma) ; // theta^2
330 
331  fTheMinAngle = 1.0e-3; // was 5.e-6, e-6 !!!, e-5, e-4
332 
333  if( fMaxThetaTR > fTheMaxAngle ) fMaxThetaTR = fTheMaxAngle;
334  else if( fMaxThetaTR < fTheMinAngle ) fMaxThetaTR = fTheMinAngle;
335 
336  energySum = 0.0;
337 
338  energyVector->PutValue(fBinTR-1,energySum);
339 
340  for( iTR = fBinTR - 2; iTR >= 0; iTR-- )
341  {
342  // Legendre96 or Legendre10
343 
344  energySum += radiatorCof*fCofTR*integral.Legendre10(
345  this,&G4VXTRenergyLoss::SpectralXTRdEdx,
346  energyVector->GetLowEdgeEnergy(iTR),
347  energyVector->GetLowEdgeEnergy(iTR+1) );
348 
349  energyVector->PutValue(iTR,energySum/fTotalDist);
350  }
351  iPlace = iTkin;
352  fEnergyDistrTable->insertAt(iPlace,energyVector);
353 
354  if(verboseLevel > 0)
355  {
356  G4cout
357  // <<iTkin<<"\t"
358  // <<"fGamma = "
359  <<fGamma<<"\t" // <<" fMaxThetaTR = "<<fMaxThetaTR
360  // <<"sumN = "
361  <<energySum // <<"; sumA = "<<angleSum
362  <<G4endl;
363  }
364  }
365  timer.Stop();
366  G4cout.precision(6);
367  if(verboseLevel > 0)
368  {
369  G4cout<<G4endl;
370  G4cout<<"total time for build X-ray TR energy loss tables = "
371  <<timer.GetUserElapsed()<<" s"<<G4endl;
372  }
373  fGamma = 0.;
374  return;
375 }
G4Integrator::Legendre10
G4double Legendre10(T &typeT, F f, G4double a, G4double b)
G4VXTRenergyLoss::fEnergyDistrTable
G4PhysicsTable * fEnergyDistrTable
Definition: G4VXTRenergyLoss.hh:187
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4Timer::GetUserElapsed
G4double GetUserElapsed() const
Definition: G4Timer.cc:130
G4PhysicsVector::PutValue
void PutValue(size_t index, G4double theValue)
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4Timer::Stop
void Stop()
G4VXTRenergyLoss::SpectralXTRdEdx
virtual G4double SpectralXTRdEdx(G4double energy)
Definition: G4VXTRenergyLoss.cc:888
G4PhysicsTable::insertAt
void insertAt(size_t, G4PhysicsVector *)
G4endl
#define G4endl
Definition: G4ios.hh:61
G4VXTRenergyLoss::fAngleDistrTable
G4PhysicsTable * fAngleDistrTable
Definition: G4VXTRenergyLoss.hh:186
G4Timer::Start
void Start()
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::BuildGlobalAngleTable ( )

Definition at line 627 of file G4VXTRenergyLoss.cc.

References AngleXTRdEdx(), fAngleDistrTable, fBinTR, fCofTR, fGamma, fGammaTkinCut, fMaxEnergyTR, fMaxThetaTR, fMinEnergyTR, fProtonEnergyVector, fTheMaxAngle, fTheMaxEnergyTR, fTheMinAngle, fTheMinEnergyTR, fTotBin, G4cout, G4endl, G4PhysicsVector::GetLowEdgeEnergy(), G4Timer::GetUserElapsed(), G4PhysicsTable::insertAt(), G4Integrator< T, F >::Legendre96(), python.hepunit::proton_mass_c2, G4PhysicsVector::PutValue(), G4Timer::Start(), G4Timer::Stop(), and G4VProcess::verboseLevel.

628 {
629  G4int iTkin, iTR, iPlace;
630  G4double radiatorCof = 1.0; // for tuning of XTR yield
631  G4double angleSum;
632  fAngleDistrTable = new G4PhysicsTable(fTotBin);
633 
634  fGammaTkinCut = 0.0;
635 
636  // setting of min/max TR energies
637 
638  if(fGammaTkinCut > fTheMinEnergyTR) fMinEnergyTR = fGammaTkinCut;
639  else fMinEnergyTR = fTheMinEnergyTR;
640 
641  if(fGammaTkinCut > fTheMaxEnergyTR) fMaxEnergyTR = 2.0*fGammaTkinCut;
642  else fMaxEnergyTR = fTheMaxEnergyTR;
643 
644  G4cout.precision(4);
645  G4Timer timer;
646  timer.Start();
647  if(verboseLevel > 0) {
648  G4cout<<G4endl;
649  G4cout<<"Lorentz Factor"<<"\t"<<"XTR photon number"<<G4endl;
650  G4cout<<G4endl;
651  }
652  for( iTkin = 0; iTkin < fTotBin; iTkin++ ) // Lorentz factor loop
653  {
654 
655  fGamma = 1.0 + (fProtonEnergyVector->
656  GetLowEdgeEnergy(iTkin)/proton_mass_c2);
657 
658  fMaxThetaTR = 25.0/(fGamma*fGamma); // theta^2
659 
660  fTheMinAngle = 1.0e-3; // was 5.e-6, e-6 !!!, e-5, e-4
661 
662  if( fMaxThetaTR > fTheMaxAngle ) fMaxThetaTR = fTheMaxAngle;
663  else
664  {
665  if( fMaxThetaTR < fTheMinAngle ) fMaxThetaTR = fTheMinAngle;
666  }
667  G4PhysicsLinearVector* angleVector = new G4PhysicsLinearVector(0.0,
668  fMaxThetaTR,
669  fBinTR );
670 
671  angleSum = 0.0;
672 
673  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
674 
675 
676  angleVector->PutValue(fBinTR-1,angleSum);
677 
678  for( iTR = fBinTR - 2; iTR >= 0; iTR-- )
679  {
680 
681  angleSum += radiatorCof*fCofTR*integral.Legendre96(
682  this,&G4VXTRenergyLoss::AngleXTRdEdx,
683  angleVector->GetLowEdgeEnergy(iTR),
684  angleVector->GetLowEdgeEnergy(iTR+1) );
685 
686  angleVector ->PutValue(iTR,angleSum);
687  }
688  if(verboseLevel > 1) {
689  G4cout
690  // <<iTkin<<"\t"
691  // <<"fGamma = "
692  <<fGamma<<"\t" // <<" fMaxThetaTR = "<<fMaxThetaTR
693  // <<"sumN = "<<energySum // <<"; sumA = "
694  <<angleSum
695  <<G4endl;
696  }
697  iPlace = iTkin;
698  fAngleDistrTable->insertAt(iPlace,angleVector);
699  }
700  timer.Stop();
701  G4cout.precision(6);
702  if(verboseLevel > 0) {
703  G4cout<<G4endl;
704  G4cout<<"total time for build X-ray TR angle tables = "
705  <<timer.GetUserElapsed()<<" s"<<G4endl;
706  }
707  fGamma = 0.;
708 
709  return;
710 }
G4Integrator::Legendre96
G4double Legendre96(T &typeT, F f, G4double a, G4double b)
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4Timer::GetUserElapsed
G4double GetUserElapsed() const
Definition: G4Timer.cc:130
G4PhysicsVector::PutValue
void PutValue(size_t index, G4double theValue)
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4Timer::Stop
void Stop()
G4PhysicsTable::insertAt
void insertAt(size_t, G4PhysicsVector *)
G4endl
#define G4endl
Definition: G4ios.hh:61
G4VXTRenergyLoss::fAngleDistrTable
G4PhysicsTable * fAngleDistrTable
Definition: G4VXTRenergyLoss.hh:186
G4Timer::Start
void Start()
G4double
double G4double
Definition: G4Types.hh:76
G4VXTRenergyLoss::AngleXTRdEdx
G4double AngleXTRdEdx(G4double varAngle)
Definition: G4VXTRenergyLoss.cc:946
void G4VXTRenergyLoss::BuildPhysicsTable ( const G4ParticleDefinition &  pd)
virtual

Reimplemented from G4VProcess.

Definition at line 264 of file G4VXTRenergyLoss.cc.

References BuildAngleForEnergyBank(), BuildEnergyTable(), fAngleRadDistr, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetPDGCharge(), JustWarning, and G4VProcess::verboseLevel.

265 {
266  if(pd.GetPDGCharge() == 0.)
267  {
268  G4Exception("G4VXTRenergyLoss::BuildPhysicsTable", "Notification", JustWarning,
269  "XTR initialisation for neutral particle ?!" );
270  }
271  BuildEnergyTable();
272 
273  if (fAngleRadDistr)
274  {
275  if(verboseLevel > 0)
276  {
277  G4cout<<"Build angle for energy distribution according the current radiator"
278  <<G4endl;
279  }
280  BuildAngleForEnergyBank();
281  }
282 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4cout
G4GLOB_DLL std::ostream G4cout
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4endl
#define G4endl
Definition: G4ios.hh:61
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
void G4VXTRenergyLoss::BuildTable ( )
inline

Definition at line 102 of file G4VXTRenergyLoss.hh.

102 {} ;
void G4VXTRenergyLoss::ComputeGasPhotoAbsCof ( )

Definition at line 1144 of file G4VXTRenergyLoss.cc.

References fGasPhotoAbsCof, fMatIndex2, G4Material::GetMaterialTable(), and G4Material::GetSandiaTable().

Referenced by G4VXTRenergyLoss().

1145 {
1146  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
1147  const G4Material* mat = (*theMaterialTable)[fMatIndex2];
1148  fGasPhotoAbsCof = mat->GetSandiaTable();
1149  return;
1150 }
G4Material::GetMaterialTable
static G4MaterialTable * GetMaterialTable()
Definition: G4Material.cc:564
G4MaterialTable
std::vector< G4Material * > G4MaterialTable
Definition: G4MaterialTable.hh:41
G4Material::GetSandiaTable
G4SandiaTable * GetSandiaTable() const
Definition: G4Material.hh:227
G4VXTRenergyLoss::fGasPhotoAbsCof
G4SandiaTable * fGasPhotoAbsCof
Definition: G4VXTRenergyLoss.hh:230
void G4VXTRenergyLoss::ComputePlatePhotoAbsCof ( )

Definition at line 1069 of file G4VXTRenergyLoss.cc.

References fMatIndex1, fPlatePhotoAbsCof, G4Material::GetMaterialTable(), and G4Material::GetSandiaTable().

Referenced by G4VXTRenergyLoss().

1070 {
1071  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
1072  const G4Material* mat = (*theMaterialTable)[fMatIndex1];
1073  fPlatePhotoAbsCof = mat->GetSandiaTable();
1074 
1075  return;
1076 }
G4Material::GetMaterialTable
static G4MaterialTable * GetMaterialTable()
Definition: G4Material.cc:564
G4MaterialTable
std::vector< G4Material * > G4MaterialTable
Definition: G4MaterialTable.hh:41
G4Material::GetSandiaTable
G4SandiaTable * GetSandiaTable() const
Definition: G4Material.hh:227
G4VXTRenergyLoss::fPlatePhotoAbsCof
G4SandiaTable * fPlatePhotoAbsCof
Definition: G4VXTRenergyLoss.hh:228
G4PhysicsFreeVector * G4VXTRenergyLoss::GetAngleVector ( G4double  energy,
G4int  n 
)

Definition at line 545 of file G4VXTRenergyLoss.cc.

References fGamma, fGasThick, fMaxThetaTR, fPlateThick, fSigma1, fSigma2, G4cout, G4endl, python.hepunit::hbarc, python.hepunit::pi, G4PhysicsFreeVector::PutValue(), and G4VProcess::verboseLevel.

Referenced by BuildAngleTable().

546 {
547  G4double theta=0., result, tmp=0., cof1, cof2, cofMin, cofPHC, angleSum = 0.;
548  G4int iTheta, k, /*kMax,*/ kMin;
549 
550  G4PhysicsFreeVector* angleVector = new G4PhysicsFreeVector(n);
551 
552  cofPHC = 4*pi*hbarc;
553  tmp = (fSigma1 - fSigma2)/cofPHC/energy;
554  cof1 = fPlateThick*tmp;
555  cof2 = fGasThick*tmp;
556 
557  cofMin = energy*(fPlateThick + fGasThick)/fGamma/fGamma;
558  cofMin += (fPlateThick*fSigma1 + fGasThick*fSigma2)/energy;
559  cofMin /= cofPHC;
560 
561  kMin = G4int(cofMin);
562  if (cofMin > kMin) kMin++;
563 
564  //kMax = kMin + fBinTR -1;
565 
566  if(verboseLevel > 2)
567  {
568  G4cout<<"n-1 = "<<n-1<<"; theta = "
569  <<std::sqrt(fMaxThetaTR)*fGamma<<"; tmp = "
570  <<0.
571  <<"; angleSum = "<<angleSum<<G4endl;
572  }
573  // angleVector->PutValue(n-1,fMaxThetaTR, angleSum);
574 
575  for( iTheta = n - 1; iTheta >= 1; iTheta-- )
576  {
577 
578  k = iTheta- 1 + kMin;
579 
580  tmp = pi*fPlateThick*(k + cof2)/(fPlateThick + fGasThick);
581 
582  result = (k - cof1)*(k - cof1)*(k + cof2)*(k + cof2);
583 
584  tmp = std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
585 
586  if( k == kMin && kMin == G4int(cofMin) )
587  {
588  angleSum += 0.5*tmp; // 0.5*std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
589  }
590  else if(iTheta == n-1);
591  else
592  {
593  angleSum += tmp; // std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
594  }
595  theta = std::abs(k-cofMin)*cofPHC/energy/(fPlateThick + fGasThick);
596 
597  if(verboseLevel > 2)
598  {
599  G4cout<<"iTheta = "<<iTheta<<"; k = "<<k<<"; theta = "
600  <<std::sqrt(theta)*fGamma<<"; tmp = "
601  <<tmp // std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result
602  <<"; angleSum = "<<angleSum<<G4endl;
603  }
604  angleVector->PutValue( iTheta, theta, angleSum );
605  }
606  if (theta > 0.)
607  {
608  angleSum += 0.5*tmp;
609  theta = 0.;
610  }
611  if(verboseLevel > 2)
612  {
613  G4cout<<"iTheta = "<<iTheta<<"; theta = "
614  <<std::sqrt(theta)*fGamma<<"; tmp = "
615  <<tmp
616  <<"; angleSum = "<<angleSum<<G4endl;
617  }
618  angleVector->PutValue( iTheta, theta, angleSum );
619 
620  return angleVector;
621 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4PhysicsFreeVector::PutValue
void PutValue(size_t binNumber, G4double binValue, G4double dataValue)
Definition: G4PhysicsFreeVector.cc:94
G4int
int G4int
Definition: G4Types.hh:78
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4cout
G4GLOB_DLL std::ostream G4cout
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetAngleXTR ( G4int  iTR,
G4double  position,
G4int  iAngle 
)

Definition at line 1580 of file G4VXTRenergyLoss.cc.

References G4UniformRand.

Referenced by GetRandomAngle().

1583 {
1584  G4double x1, x2, y1, y2, result;
1585 
1586  if(iTransfer == 0)
1587  {
1588  result = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
1589  }
1590  else
1591  {
1592  y1 = (*(*fAngleForEnergyTable)(iPlace))(iTransfer-1);
1593  y2 = (*(*fAngleForEnergyTable)(iPlace))(iTransfer);
1594 
1595  x1 = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer-1);
1596  x2 = (*fAngleForEnergyTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
1597 
1598  if ( x1 == x2 ) result = x2;
1599  else
1600  {
1601  if ( y1 == y2 ) result = x1 + (x2 - x1)*G4UniformRand();
1602  else
1603  {
1604  result = x1 + (position - y1)*(x2 - x1)/(y2 - y1);
1605  }
1606  }
1607  }
1608  return result;
1609 }
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetComptonPerAtom ( G4double  GammaEnergy,
G4double  Z 
)

Definition at line 1300 of file G4VXTRenergyLoss.cc.

References test::a, test::b, python.hepunit::barn, test::c, plottest35::c1, python.hepunit::electron_mass_c2, python.hepunit::GeV, python.hepunit::keV, and G4INCL::Math::max().

Referenced by GetGasCompton(), and GetPlateCompton().

1301 {
1302  G4double CrossSection = 0.0;
1303  if ( Z < 0.9999 ) return CrossSection;
1304  if ( GammaEnergy < 0.1*keV ) return CrossSection;
1305  if ( GammaEnergy > (100.*GeV/Z) ) return CrossSection;
1306 
1307  static const G4double a = 20.0 , b = 230.0 , c = 440.0;
1308 
1309  static const G4double
1310  d1= 2.7965e-1*barn, d2=-1.8300e-1*barn, d3= 6.7527 *barn, d4=-1.9798e+1*barn,
1311  e1= 1.9756e-5*barn, e2=-1.0205e-2*barn, e3=-7.3913e-2*barn, e4= 2.7079e-2*barn,
1312  f1=-3.9178e-7*barn, f2= 6.8241e-5*barn, f3= 6.0480e-5*barn, f4= 3.0274e-4*barn;
1313 
1314  G4double p1Z = Z*(d1 + e1*Z + f1*Z*Z), p2Z = Z*(d2 + e2*Z + f2*Z*Z),
1315  p3Z = Z*(d3 + e3*Z + f3*Z*Z), p4Z = Z*(d4 + e4*Z + f4*Z*Z);
1316 
1317  G4double T0 = 15.0*keV;
1318  if (Z < 1.5) T0 = 40.0*keV;
1319 
1320  G4double X = std::max(GammaEnergy, T0) / electron_mass_c2;
1321  CrossSection = p1Z*std::log(1.+2.*X)/X
1322  + (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
1323 
1324  // modification for low energy. (special case for Hydrogen)
1325 
1326  if (GammaEnergy < T0)
1327  {
1328  G4double dT0 = 1.*keV;
1329  X = (T0+dT0) / electron_mass_c2;
1330  G4double sigma = p1Z*std::log(1.+2*X)/X
1331  + (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
1332  G4double c1 = -T0*(sigma-CrossSection)/(CrossSection*dT0);
1333  G4double c2 = 0.150;
1334  if (Z > 1.5) c2 = 0.375-0.0556*std::log(Z);
1335  G4double y = std::log(GammaEnergy/T0);
1336  CrossSection *= std::exp(-y*(c1+c2*y));
1337  }
1338  // G4cout << "e= " << GammaEnergy << " Z= " << Z << " cross= " << CrossSection << G4endl;
1339  return CrossSection;
1340 }
python.hepunit.electron_mass_c2
float electron_mass_c2
Definition: hepunit.py:274
G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition: G4INCLGlobals.hh:116
G4double
double G4double
Definition: G4Types.hh:76
plottest35.c1
tuple c1
Definition: plottest35.py:14
G4double G4VXTRenergyLoss::GetEnergy ( )
inline

Definition at line 165 of file G4VXTRenergyLoss.hh.

References fEnergy.

165 {return fEnergy;};
G4double G4VXTRenergyLoss::GetGamma ( )
inline

Definition at line 164 of file G4VXTRenergyLoss.hh.

References fGamma.

164 {return fGamma;};
G4complex G4VXTRenergyLoss::GetGasComplexFZ ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1120 of file G4VXTRenergyLoss.cc.

References GetGasFormationZone(), and GetGasLinearPhotoAbs().

Referenced by G4StrawTubeXTRadiator::GetStackFactor(), and OneInterfaceXTRdEdx().

1123 {
1124  G4double cof, length,delta, real_v, image_v;
1125 
1126  length = 0.5*GetGasFormationZone(omega,gamma,varAngle);
1127  delta = length*GetGasLinearPhotoAbs(omega);
1128  cof = 1.0/(1.0 + delta*delta);
1129 
1130  real_v = length*cof;
1131  image_v = real_v*delta;
1132 
1133  G4complex zone(real_v,image_v);
1134  return zone;
1135 }
G4VXTRenergyLoss::GetGasFormationZone
G4double GetGasFormationZone(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1105
G4VXTRenergyLoss::GetGasLinearPhotoAbs
G4double GetGasLinearPhotoAbs(G4double)
Definition: G4VXTRenergyLoss.cc:1157
G4complex
std::complex< G4double > G4complex
Definition: G4Types.hh:81
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetGasCompton ( G4double  omega)

Definition at line 1276 of file G4VXTRenergyLoss.cc.

References fMatIndex2, GetComptonPerAtom(), and G4Material::GetMaterialTable().

Referenced by G4XTRTransparentRegRadModel::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

1277 {
1278  G4int i, numberOfElements;
1279  G4double xSection = 0., nowZ, sumZ = 0.;
1280 
1281  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
1282  numberOfElements = (*theMaterialTable)[fMatIndex2]->GetNumberOfElements();
1283 
1284  for( i = 0; i < numberOfElements; i++ )
1285  {
1286  nowZ = (*theMaterialTable)[fMatIndex2]->GetElement(i)->GetZ();
1287  sumZ += nowZ;
1288  xSection += GetComptonPerAtom(omega,nowZ); // *nowZ;
1289  }
1290  xSection /= sumZ;
1291  xSection *= (*theMaterialTable)[fMatIndex2]->GetElectronDensity();
1292  return xSection;
1293 }
G4Material::GetMaterialTable
static G4MaterialTable * GetMaterialTable()
Definition: G4Material.cc:564
G4MaterialTable
std::vector< G4Material * > G4MaterialTable
Definition: G4MaterialTable.hh:41
G4int
int G4int
Definition: G4Types.hh:78
G4VXTRenergyLoss::GetComptonPerAtom
G4double GetComptonPerAtom(G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1300
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetGasFormationZone ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1105 of file G4VXTRenergyLoss.cc.

References fSigma2, python.hepunit::hbarc, and G4InuclParticleNames::lambda.

Referenced by GetGasComplexFZ(), GetGasZmuProduct(), G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), and G4StrawTubeXTRadiator::GetStackFactor().

1108 {
1109  G4double cof, lambda;
1110  lambda = 1.0/gamma/gamma + varAngle + fSigma2/omega/omega;
1111  cof = 2.0*hbarc/omega/lambda;
1112  return cof;
1113 }
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetGasLinearPhotoAbs ( G4double  omega)

Definition at line 1157 of file G4VXTRenergyLoss.cc.

References fGasPhotoAbsCof, and G4SandiaTable::GetSandiaCofForMaterial().

Referenced by GetGasComplexFZ(), GetGasZmuProduct(), G4XTRRegularRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

1158 {
1159  G4double omega2, omega3, omega4;
1160 
1161  omega2 = omega*omega;
1162  omega3 = omega2*omega;
1163  omega4 = omega2*omega2;
1164 
1165  const G4double* SandiaCof = fGasPhotoAbsCof->GetSandiaCofForMaterial(omega);
1166  G4double cross = SandiaCof[0]/omega + SandiaCof[1]/omega2 +
1167  SandiaCof[2]/omega3 + SandiaCof[3]/omega4;
1168  return cross;
1169 
1170 }
G4SandiaTable::GetSandiaCofForMaterial
G4double GetSandiaCofForMaterial(G4int, G4int)
Definition: G4SandiaTable.cc:925
G4VXTRenergyLoss::fGasPhotoAbsCof
G4SandiaTable * fGasPhotoAbsCof
Definition: G4VXTRenergyLoss.hh:230
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::GetGasZmuProduct ( )

Definition at line 1227 of file G4VXTRenergyLoss.cc.

References G4cout, G4endl, python.hepunit::keV, and G4VProcess::verboseLevel.

1228 {
1229  std::ofstream outGas("gasZmu.dat", std::ios::out );
1230  outGas.setf( std::ios::scientific, std::ios::floatfield );
1231  G4int i;
1232  G4double omega, varAngle, gamma;
1233  gamma = 10000.;
1234  varAngle = 1/gamma/gamma;
1235  if(verboseLevel > 0)
1236  G4cout<<"energy, keV"<<"\t"<<"Zmu for gas"<<G4endl;
1237  for(i=0;i<100;i++)
1238  {
1239  omega = (1.0 + i)*keV;
1240  if(verboseLevel > 1)
1241  G4cout<<omega/keV<<"\t"<<GetGasZmuProduct(omega,gamma,varAngle)<<"\t";
1242  if(verboseLevel > 0)
1243  outGas<<omega/keV<<"\t\t"<<GetGasZmuProduct(omega,gamma,varAngle)<<G4endl;
1244  }
1245  return;
1246 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetGasZmuProduct ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1216 of file G4VXTRenergyLoss.cc.

References GetGasFormationZone(), and GetGasLinearPhotoAbs().

1219 {
1220  return GetGasFormationZone(omega,gamma,varAngle)*GetGasLinearPhotoAbs(omega);
1221 }
G4VXTRenergyLoss::GetGasFormationZone
G4double GetGasFormationZone(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1105
G4VXTRenergyLoss::GetGasLinearPhotoAbs
G4double GetGasLinearPhotoAbs(G4double)
Definition: G4VXTRenergyLoss.cc:1157
G4double G4VXTRenergyLoss::GetMeanFreePath ( const G4Track &  aTrack,
G4double  previousStepSize,
G4ForceCondition *  condition 
)
virtual

Implements G4VDiscreteProcess.

Definition at line 191 of file G4VXTRenergyLoss.cc.

References DBL_MAX, DBL_MIN, fEnergyDistrTable, fEnvelope, fGamma, fLambda, fProtonEnergyVector, fTotBin, G4cout, G4endl, G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4DynamicParticle::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4PhysicsVector::GetLowEdgeEnergy(), G4ParticleDefinition::GetPDGCharge(), G4ParticleDefinition::GetPDGMass(), G4Track::GetVolume(), G4InuclParticleNames::lambda, python.hepunit::mm, NotForced, python.hepunit::proton_mass_c2, and G4VProcess::verboseLevel.

194 {
195  G4int iTkin, iPlace;
196  G4double lambda, sigma, kinEnergy, mass, gamma;
197  G4double charge, chargeSq, massRatio, TkinScaled;
198  G4double E1,E2,W,W1,W2;
199 
200  *condition = NotForced;
201 
202  if( aTrack.GetVolume()->GetLogicalVolume() != fEnvelope ) lambda = DBL_MAX;
203  else
204  {
205  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
206  kinEnergy = aParticle->GetKineticEnergy();
207  mass = aParticle->GetDefinition()->GetPDGMass();
208  gamma = 1.0 + kinEnergy/mass;
209  if(verboseLevel > 1)
210  {
211  G4cout<<" gamma = "<<gamma<<"; fGamma = "<<fGamma<<G4endl;
212  }
213 
214  if ( std::fabs( gamma - fGamma ) < 0.05*gamma ) lambda = fLambda;
215  else
216  {
217  charge = aParticle->GetDefinition()->GetPDGCharge();
218  chargeSq = charge*charge;
219  massRatio = proton_mass_c2/mass;
220  TkinScaled = kinEnergy*massRatio;
221 
222  for(iTkin = 0; iTkin < fTotBin; iTkin++)
223  {
224  if( TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin)) break;
225  }
226  iPlace = iTkin - 1;
227 
228  if(iTkin == 0) lambda = DBL_MAX; // Tkin is too small, neglect of TR photon generation
229  else // general case: Tkin between two vectors of the material
230  {
231  if(iTkin == fTotBin)
232  {
233  sigma = (*(*fEnergyDistrTable)(iPlace))(0)*chargeSq;
234  }
235  else
236  {
237  E1 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
238  E2 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
239  W = 1.0/(E2 - E1);
240  W1 = (E2 - TkinScaled)*W;
241  W2 = (TkinScaled - E1)*W;
242  sigma = ( (*(*fEnergyDistrTable)(iPlace ))(0)*W1 +
243  (*(*fEnergyDistrTable)(iPlace+1))(0)*W2 )*chargeSq;
244 
245  }
246  if (sigma < DBL_MIN) lambda = DBL_MAX;
247  else lambda = 1./sigma;
248  fLambda = lambda;
249  fGamma = gamma;
250  if(verboseLevel > 1)
251  {
252  G4cout<<" lambda = "<<lambda/mm<<" mm"<<G4endl;
253  }
254  }
255  }
256  }
257  return lambda;
258 }
condition
G4double condition(const G4ErrorSymMatrix &m)
G4VXTRenergyLoss::fEnergyDistrTable
G4PhysicsTable * fEnergyDistrTable
Definition: G4VXTRenergyLoss.hh:187
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4Track::GetDynamicParticle
const G4DynamicParticle * GetDynamicParticle() const
G4VXTRenergyLoss::fEnvelope
G4LogicalVolume * fEnvelope
Definition: G4VXTRenergyLoss.hh:185
G4DynamicParticle::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:161
NotForced
Definition: G4ForceCondition.hh:56
DBL_MIN
#define DBL_MIN
Definition: templates.hh:75
G4Track::GetVolume
G4VPhysicalVolume * GetVolume() const
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
DBL_MAX
#define DBL_MAX
Definition: templates.hh:83
void G4VXTRenergyLoss::GetNumberOfPhotons ( )

Definition at line 1432 of file G4VXTRenergyLoss.cc.

References fProtonEnergyVector, fTotBin, G4cout, G4endl, python.hepunit::proton_mass_c2, and G4VProcess::verboseLevel.

1433 {
1434  G4int iTkin;
1435  G4double gamma, numberE;
1436 
1437  std::ofstream outEn("numberE.dat", std::ios::out );
1438  outEn.setf( std::ios::scientific, std::ios::floatfield );
1439 
1440  std::ofstream outAng("numberAng.dat", std::ios::out );
1441  outAng.setf( std::ios::scientific, std::ios::floatfield );
1442 
1443  for(iTkin=0;iTkin<fTotBin;iTkin++) // Lorentz factor loop
1444  {
1445  gamma = 1.0 + (fProtonEnergyVector->
1446  GetLowEdgeEnergy(iTkin)/proton_mass_c2);
1447  numberE = (*(*fEnergyDistrTable)(iTkin))(0);
1448  // numberA = (*(*fAngleDistrTable)(iTkin))(0);
1449  if(verboseLevel > 1)
1450  G4cout<<gamma<<"\t\t"<<numberE<<"\t" // <<numberA
1451  <<G4endl;
1452  if(verboseLevel > 0)
1453  outEn<<gamma<<"\t\t"<<numberE<<G4endl;
1454  }
1455  return;
1456 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4complex G4VXTRenergyLoss::GetPlateComplexFZ ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1047 of file G4VXTRenergyLoss.cc.

References GetPlateFormationZone(), and GetPlateLinearPhotoAbs().

Referenced by G4StrawTubeXTRadiator::GetStackFactor(), and OneInterfaceXTRdEdx().

1050 {
1051  G4double cof, length,delta, real_v, image_v;
1052 
1053  length = 0.5*GetPlateFormationZone(omega,gamma,varAngle);
1054  delta = length*GetPlateLinearPhotoAbs(omega);
1055  cof = 1.0/(1.0 + delta*delta);
1056 
1057  real_v = length*cof;
1058  image_v = real_v*delta;
1059 
1060  G4complex zone(real_v,image_v);
1061  return zone;
1062 }
G4VXTRenergyLoss::GetPlateLinearPhotoAbs
G4double GetPlateLinearPhotoAbs(G4double)
Definition: G4VXTRenergyLoss.cc:1085
G4VXTRenergyLoss::GetPlateFormationZone
G4double GetPlateFormationZone(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1033
G4complex
std::complex< G4double > G4complex
Definition: G4Types.hh:81
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetPlateCompton ( G4double  omega)

Definition at line 1252 of file G4VXTRenergyLoss.cc.

References fMatIndex1, GetComptonPerAtom(), and G4Material::GetMaterialTable().

Referenced by G4XTRTransparentRegRadModel::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

1253 {
1254  G4int i, numberOfElements;
1255  G4double xSection = 0., nowZ, sumZ = 0.;
1256 
1257  const G4MaterialTable* theMaterialTable = G4Material::GetMaterialTable();
1258  numberOfElements = (*theMaterialTable)[fMatIndex1]->GetNumberOfElements();
1259 
1260  for( i = 0; i < numberOfElements; i++ )
1261  {
1262  nowZ = (*theMaterialTable)[fMatIndex1]->GetElement(i)->GetZ();
1263  sumZ += nowZ;
1264  xSection += GetComptonPerAtom(omega,nowZ); // *nowZ;
1265  }
1266  xSection /= sumZ;
1267  xSection *= (*theMaterialTable)[fMatIndex1]->GetElectronDensity();
1268  return xSection;
1269 }
G4Material::GetMaterialTable
static G4MaterialTable * GetMaterialTable()
Definition: G4Material.cc:564
G4MaterialTable
std::vector< G4Material * > G4MaterialTable
Definition: G4MaterialTable.hh:41
G4int
int G4int
Definition: G4Types.hh:78
G4VXTRenergyLoss::GetComptonPerAtom
G4double GetComptonPerAtom(G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1300
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetPlateFormationZone ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1033 of file G4VXTRenergyLoss.cc.

References fSigma1, python.hepunit::hbarc, and G4InuclParticleNames::lambda.

Referenced by GetPlateComplexFZ(), GetPlateZmuProduct(), G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), and G4StrawTubeXTRadiator::GetStackFactor().

1036 {
1037  G4double cof, lambda;
1038  lambda = 1.0/gamma/gamma + varAngle + fSigma1/omega/omega;
1039  cof = 2.0*hbarc/omega/lambda;
1040  return cof;
1041 }
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetPlateLinearPhotoAbs ( G4double  omega)

Definition at line 1085 of file G4VXTRenergyLoss.cc.

References fPlatePhotoAbsCof, and G4SandiaTable::GetSandiaCofForMaterial().

Referenced by GetPlateComplexFZ(), GetPlateZmuProduct(), G4XTRRegularRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

1086 {
1087  // G4int i;
1088  G4double omega2, omega3, omega4;
1089 
1090  omega2 = omega*omega;
1091  omega3 = omega2*omega;
1092  omega4 = omega2*omega2;
1093 
1094  const G4double* SandiaCof = fPlatePhotoAbsCof->GetSandiaCofForMaterial(omega);
1095  G4double cross = SandiaCof[0]/omega + SandiaCof[1]/omega2 +
1096  SandiaCof[2]/omega3 + SandiaCof[3]/omega4;
1097  return cross;
1098 }
G4SandiaTable::GetSandiaCofForMaterial
G4double GetSandiaCofForMaterial(G4int, G4int)
Definition: G4SandiaTable.cc:925
G4VXTRenergyLoss::fPlatePhotoAbsCof
G4SandiaTable * fPlatePhotoAbsCof
Definition: G4VXTRenergyLoss.hh:228
G4double
double G4double
Definition: G4Types.hh:76
void G4VXTRenergyLoss::GetPlateZmuProduct ( )

Definition at line 1189 of file G4VXTRenergyLoss.cc.

References G4cout, G4endl, python.hepunit::keV, and G4VProcess::verboseLevel.

1190 {
1191  std::ofstream outPlate("plateZmu.dat", std::ios::out );
1192  outPlate.setf( std::ios::scientific, std::ios::floatfield );
1193 
1194  G4int i;
1195  G4double omega, varAngle, gamma;
1196  gamma = 10000.;
1197  varAngle = 1/gamma/gamma;
1198  if(verboseLevel > 0)
1199  G4cout<<"energy, keV"<<"\t"<<"Zmu for plate"<<G4endl;
1200  for(i=0;i<100;i++)
1201  {
1202  omega = (1.0 + i)*keV;
1203  if(verboseLevel > 1)
1204  G4cout<<omega/keV<<"\t"<<GetPlateZmuProduct(omega,gamma,varAngle)<<"\t";
1205  if(verboseLevel > 0)
1206  outPlate<<omega/keV<<"\t\t"<<GetPlateZmuProduct(omega,gamma,varAngle)<<G4endl;
1207  }
1208  return;
1209 }
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4int
int G4int
Definition: G4Types.hh:78
G4cout
G4GLOB_DLL std::ostream G4cout
G4endl
#define G4endl
Definition: G4ios.hh:61
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetPlateZmuProduct ( G4double  omega,
G4double  gamma,
G4double  varAngle 
)

Definition at line 1177 of file G4VXTRenergyLoss.cc.

References GetPlateFormationZone(), and GetPlateLinearPhotoAbs().

1180 {
1181  return GetPlateFormationZone(omega,gamma,varAngle)
1182  * GetPlateLinearPhotoAbs(omega);
1183 }
G4VXTRenergyLoss::GetPlateLinearPhotoAbs
G4double GetPlateLinearPhotoAbs(G4double)
Definition: G4VXTRenergyLoss.cc:1085
G4VXTRenergyLoss::GetPlateFormationZone
G4double GetPlateFormationZone(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1033
G4PhysicsLogVector* G4VXTRenergyLoss::GetProtonVector ( )
inline

Definition at line 174 of file G4VXTRenergyLoss.hh.

References fProtonEnergyVector.

174 { return fProtonEnergyVector;};
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4double G4VXTRenergyLoss::GetRandomAngle ( G4double  energyXTR,
G4int  iTkin 
)

Definition at line 1550 of file G4VXTRenergyLoss.cc.

References fAngleBank, fAngleForEnergyTable, fBinTR, fTotBin, G4UniformRand, GetAngleXTR(), and position.

Referenced by PostStepDoIt().

1551 {
1552  G4int iTR, iAngle;
1553  G4double position, angle;
1554 
1555  if (iTkin == fTotBin) iTkin--;
1556 
1557  fAngleForEnergyTable = fAngleBank[iTkin];
1558 
1559  for( iTR = 0; iTR < fBinTR; iTR++ )
1560  {
1561  if( energyXTR < fXTREnergyVector->GetLowEdgeEnergy(iTR) ) break;
1562  }
1563  if (iTR == fBinTR) iTR--;
1564 
1565  position = (*(*fAngleForEnergyTable)(iTR))(0)*G4UniformRand();
1566 
1567  for(iAngle = 0;;iAngle++)
1568  {
1569  if(position >= (*(*fAngleForEnergyTable)(iTR))(iAngle)) break;
1570  }
1571  angle = GetAngleXTR(iTR,position,iAngle);
1572  return angle;
1573 }
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4VXTRenergyLoss::GetAngleXTR
G4double GetAngleXTR(G4int iTR, G4double position, G4int iAngle)
Definition: G4VXTRenergyLoss.cc:1580
position
int position
Definition: filter.cc:7
G4VXTRenergyLoss::fAngleBank
std::vector< G4PhysicsTable * > fAngleBank
Definition: G4VXTRenergyLoss.hh:237
G4VXTRenergyLoss::fAngleForEnergyTable
G4PhysicsTable * fAngleForEnergyTable
Definition: G4VXTRenergyLoss.hh:236
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetStackFactor ( G4double  energy,
G4double  gamma,
G4double  varAngle 
)
virtual

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

Definition at line 1371 of file G4VXTRenergyLoss.cc.

References OneInterfaceXTRdEdx().

Referenced by AngleSpectralXTRdEdx(), SpectralAngleXTRdEdx(), XTRNAngleSpectralDensity(), and XTRNSpectralAngleDensity().

1373 {
1374  // return stack factor corresponding to one interface
1375 
1376  return std::real( OneInterfaceXTRdEdx(energy,gamma,varAngle) );
1377 }
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4VXTRenergyLoss::OneInterfaceXTRdEdx
G4complex OneInterfaceXTRdEdx(G4double energy, G4double gamma, G4double varAngle)
Definition: G4VXTRenergyLoss.cc:858
G4int G4VXTRenergyLoss::GetTotBin ( )
inline

Definition at line 175 of file G4VXTRenergyLoss.hh.

References fTotBin.

175 {return fTotBin;};
G4double G4VXTRenergyLoss::GetVarAngle ( )
inline

Definition at line 166 of file G4VXTRenergyLoss.hh.

References fVarAngle.

166 {return fVarAngle;};
G4double G4VXTRenergyLoss::GetXTRenergy ( G4int  iPlace,
G4double  position,
G4int  iTransfer 
)

Definition at line 1514 of file G4VXTRenergyLoss.cc.

References G4UniformRand.

Referenced by GetXTRrandomEnergy().

1517 {
1518  G4double x1, x2, y1, y2, result;
1519 
1520  if(iTransfer == 0)
1521  {
1522  result = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
1523  }
1524  else
1525  {
1526  y1 = (*(*fEnergyDistrTable)(iPlace))(iTransfer-1);
1527  y2 = (*(*fEnergyDistrTable)(iPlace))(iTransfer);
1528 
1529  x1 = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer-1);
1530  x2 = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
1531 
1532  if ( x1 == x2 ) result = x2;
1533  else
1534  {
1535  if ( y1 == y2 ) result = x1 + (x2 - x1)*G4UniformRand();
1536  else
1537  {
1538  // result = x1 + (position - y1)*(x2 - x1)/(y2 - y1);
1539  result = x1 + (x2 - x1)*G4UniformRand();
1540  }
1541  }
1542  }
1543  return result;
1544 }
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::GetXTRrandomEnergy ( G4double  scaledTkin,
G4int  iTkin 
)

Definition at line 1463 of file G4VXTRenergyLoss.cc.

References fEnergyDistrTable, fProtonEnergyVector, fTotBin, G4UniformRand, G4PhysicsVector::GetLowEdgeEnergy(), GetXTRenergy(), and position.

Referenced by PostStepDoIt().

1464 {
1465  G4int iTransfer, iPlace;
1466  G4double transfer = 0.0, position, E1, E2, W1, W2, W;
1467 
1468  iPlace = iTkin - 1;
1469 
1470  // G4cout<<"iPlace = "<<iPlace<<endl;
1471 
1472  if(iTkin == fTotBin) // relativistic plato, try from left
1473  {
1474  position = (*(*fEnergyDistrTable)(iPlace))(0)*G4UniformRand();
1475 
1476  for(iTransfer=0;;iTransfer++)
1477  {
1478  if(position >= (*(*fEnergyDistrTable)(iPlace))(iTransfer)) break;
1479  }
1480  transfer = GetXTRenergy(iPlace,position,iTransfer);
1481  }
1482  else
1483  {
1484  E1 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
1485  E2 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
1486  W = 1.0/(E2 - E1);
1487  W1 = (E2 - scaledTkin)*W;
1488  W2 = (scaledTkin - E1)*W;
1489 
1490  position =( (*(*fEnergyDistrTable)(iPlace))(0)*W1 +
1491  (*(*fEnergyDistrTable)(iPlace+1))(0)*W2 )*G4UniformRand();
1492 
1493  // G4cout<<position<<"\t";
1494 
1495  for(iTransfer=0;;iTransfer++)
1496  {
1497  if( position >=
1498  ( (*(*fEnergyDistrTable)(iPlace))(iTransfer)*W1 +
1499  (*(*fEnergyDistrTable)(iPlace+1))(iTransfer)*W2) ) break;
1500  }
1501  transfer = GetXTRenergy(iPlace,position,iTransfer);
1502 
1503  }
1504  // G4cout<<"XTR transfer = "<<transfer/keV<<" keV"<<endl;
1505  if(transfer < 0.0 ) transfer = 0.0;
1506  return transfer;
1507 }
G4VXTRenergyLoss::fEnergyDistrTable
G4PhysicsTable * fEnergyDistrTable
Definition: G4VXTRenergyLoss.hh:187
G4PhysicsVector::GetLowEdgeEnergy
G4double GetLowEdgeEnergy(size_t binNumber) const
Definition: G4PhysicsVector.cc:157
G4int
int G4int
Definition: G4Types.hh:78
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4VXTRenergyLoss::fProtonEnergyVector
G4PhysicsLogVector * fProtonEnergyVector
Definition: G4VXTRenergyLoss.hh:189
G4VXTRenergyLoss::GetXTRenergy
G4double GetXTRenergy(G4int iPlace, G4double position, G4int iTransfer)
Definition: G4VXTRenergyLoss.cc:1514
position
int position
Definition: filter.cc:7
G4double
double G4double
Definition: G4Types.hh:76
G4bool G4VXTRenergyLoss::IsApplicable ( const G4ParticleDefinition &  particle)
virtual

Reimplemented from G4VProcess.

Definition at line 182 of file G4VXTRenergyLoss.cc.

References G4ParticleDefinition::GetPDGCharge().

183 {
184  return ( particle.GetPDGCharge() != 0.0 );
185 }
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:163
G4double G4VXTRenergyLoss::OneBoundaryXTRNdensity ( G4double  energy,
G4double  gamma,
G4double  varAngle 
) const

Definition at line 1354 of file G4VXTRenergyLoss.cc.

References fSigma1, and fSigma2.

Referenced by XTRNAngleSpectralDensity(), and XTRNSpectralAngleDensity().

1356 {
1357  G4double formationLength1, formationLength2;
1358  formationLength1 = 1.0/
1359  (1.0/(gamma*gamma)
1360  + fSigma1/(energy*energy)
1361  + varAngle);
1362  formationLength2 = 1.0/
1363  (1.0/(gamma*gamma)
1364  + fSigma2/(energy*energy)
1365  + varAngle);
1366  return (varAngle/energy)*(formationLength1 - formationLength2)
1367  *(formationLength1 - formationLength2);
1368 
1369 }
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4double
double G4double
Definition: G4Types.hh:76
G4complex G4VXTRenergyLoss::OneInterfaceXTRdEdx ( G4double  energy,
G4double  gamma,
G4double  varAngle 
)

Definition at line 858 of file G4VXTRenergyLoss.cc.

References GetGasComplexFZ(), GetPlateComplexFZ(), and python.hepunit::hbarc.

Referenced by G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), and GetStackFactor().

861 {
862  G4complex Z1 = GetPlateComplexFZ(energy,gamma,varAngle);
863  G4complex Z2 = GetGasComplexFZ(energy,gamma,varAngle);
864 
865  G4complex zOut = (Z1 - Z2)*(Z1 - Z2)
866  * (varAngle*energy/hbarc/hbarc);
867  return zOut;
868 
869 }
G4VXTRenergyLoss::GetPlateComplexFZ
G4complex GetPlateComplexFZ(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1047
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4complex
std::complex< G4double > G4complex
Definition: G4Types.hh:81
G4VXTRenergyLoss::GetGasComplexFZ
G4complex GetGasComplexFZ(G4double, G4double, G4double)
Definition: G4VXTRenergyLoss.cc:1120
G4VParticleChange * G4VXTRenergyLoss::PostStepDoIt ( const G4Track &  aTrack,
const G4Step &  aStep 
)
virtual

Reimplemented from G4VDiscreteProcess.

Definition at line 718 of file G4VXTRenergyLoss.cc.

References G4ParticleChange::AddSecondary(), python.hepunit::c_light, G4VSolid::DistanceToOut(), fAngleRadDistr, fEnvelope, fExitFlux, fParticleChange, fTotBin, G4cout, G4endl, G4UniformRand, G4Gamma::Gamma(), G4DynamicParticle::GetDefinition(), G4Track::GetDynamicParticle(), G4StepPoint::GetGlobalTime(), G4DynamicParticle::GetKineticEnergy(), G4VPhysicalVolume::GetLogicalVolume(), G4LogicalVolume::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4Material::GetName(), G4ParticleDefinition::GetPDGMass(), G4StepPoint::GetPosition(), G4Step::GetPostStepPoint(), GetRandomAngle(), G4VTouchable::GetRotation(), G4LogicalVolume::GetSolid(), G4StepPoint::GetTouchable(), G4StepPoint::GetTouchableHandle(), G4Track::GetTrackID(), G4VTouchable::GetTranslation(), G4Track::GetVolume(), GetXTRrandomEnergy(), G4ParticleChange::Initialize(), G4AffineTransform::Invert(), python.hepunit::keV, python.hepunit::mm, python.hepunit::pi, G4VDiscreteProcess::PostStepDoIt(), G4ParticleChange::ProposeEnergy(), python.hepunit::proton_mass_c2, CLHEP::Hep3Vector::rotateUz(), G4VParticleChange::SetNumberOfSecondaries(), G4Track::SetParentID(), G4Track::SetTouchableHandle(), G4INCL::DeJongSpin::shoot(), G4AffineTransform::TransformAxis(), G4AffineTransform::TransformPoint(), python.hepunit::twopi, CLHEP::Hep3Vector::unit(), and G4VProcess::verboseLevel.

720 {
721  G4int iTkin /*, iPlace*/;
722  G4double energyTR, theta,theta2, phi, dirX, dirY, dirZ;
723 
724 
725  fParticleChange.Initialize(aTrack);
726 
727  if(verboseLevel > 1)
728  {
729  G4cout<<"Start of G4VXTRenergyLoss::PostStepDoIt "<<G4endl;
730  G4cout<<"name of current material = "
731  <<aTrack.GetVolume()->GetLogicalVolume()->GetMaterial()->GetName()<<G4endl;
732  }
733  if( aTrack.GetVolume()->GetLogicalVolume() != fEnvelope )
734  {
735  if(verboseLevel > 0)
736  {
737  G4cout<<"Go out from G4VXTRenergyLoss::PostStepDoIt: wrong volume "<<G4endl;
738  }
739  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
740  }
741  else
742  {
743  G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
744  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
745 
746  // Now we are ready to Generate one TR photon
747 
748  G4double kinEnergy = aParticle->GetKineticEnergy();
749  G4double mass = aParticle->GetDefinition()->GetPDGMass();
750  G4double gamma = 1.0 + kinEnergy/mass;
751 
752  if(verboseLevel > 1 )
753  {
754  G4cout<<"gamma = "<<gamma<<G4endl;
755  }
756  G4double massRatio = proton_mass_c2/mass;
757  G4double TkinScaled = kinEnergy*massRatio;
758  G4ThreeVector position = pPostStepPoint->GetPosition();
759  G4ParticleMomentum direction = aParticle->GetMomentumDirection();
760  G4double startTime = pPostStepPoint->GetGlobalTime();
761 
762  for( iTkin = 0; iTkin < fTotBin; iTkin++ )
763  {
764  if(TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin)) break;
765  }
766  //iPlace = iTkin - 1;
767 
768  if(iTkin == 0) // Tkin is too small, neglect of TR photon generation
769  {
770  if( verboseLevel > 0)
771  {
772  G4cout<<"Go out from G4VXTRenergyLoss::PostStepDoIt:iTkin = "<<iTkin<<G4endl;
773  }
774  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
775  }
776  else // general case: Tkin between two vectors of the material
777  {
778  fParticleChange.SetNumberOfSecondaries(1);
779 
780  energyTR = GetXTRrandomEnergy(TkinScaled,iTkin);
781 
782  if( verboseLevel > 1)
783  {
784  G4cout<<"energyTR = "<<energyTR/keV<<" keV"<<G4endl;
785  }
786  if (fAngleRadDistr)
787  {
788  // theta = std::fabs(G4RandGauss::shoot(0.0,pi/gamma));
789  theta2 = GetRandomAngle(energyTR,iTkin);
790  if(theta2 > 0.) theta = std::sqrt(theta2);
791  else theta = 0.; // theta2;
792  }
793  else theta = std::fabs(G4RandGauss::shoot(0.0,pi/gamma));
794 
795  // theta = 0.; // check no spread
796 
797  if( theta >= 0.1 ) theta = 0.1;
798 
799  // G4cout<<" : theta = "<<theta<<endl;
800 
801  phi = twopi*G4UniformRand();
802 
803  dirX = std::sin(theta)*std::cos(phi);
804  dirY = std::sin(theta)*std::sin(phi);
805  dirZ = std::cos(theta);
806 
807  G4ThreeVector directionTR(dirX,dirY,dirZ);
808  directionTR.rotateUz(direction);
809  directionTR.unit();
810 
811  G4DynamicParticle* aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(),
812  directionTR, energyTR);
813 
814  // A XTR photon is set on the particle track inside the radiator
815  // and is moved to the G4Envelope surface for standard X-ray TR models
816  // only. The case of fExitFlux=true
817 
818  if( fExitFlux )
819  {
820  const G4RotationMatrix* rotM = pPostStepPoint->GetTouchable()->GetRotation();
821  G4ThreeVector transl = pPostStepPoint->GetTouchable()->GetTranslation();
822  G4AffineTransform transform = G4AffineTransform(rotM,transl);
823  transform.Invert();
824  G4ThreeVector localP = transform.TransformPoint(position);
825  G4ThreeVector localV = transform.TransformAxis(directionTR);
826 
827  G4double distance = fEnvelope->GetSolid()->DistanceToOut(localP, localV);
828  if(verboseLevel > 1)
829  {
830  G4cout<<"distance to exit = "<<distance/mm<<" mm"<<G4endl;
831  }
832  position += distance*directionTR;
833  startTime += distance/c_light;
834  }
835  G4Track* aSecondaryTrack = new G4Track( aPhotonTR,
836  startTime, position );
837  aSecondaryTrack->SetTouchableHandle(
838  aStep.GetPostStepPoint()->GetTouchableHandle());
839  aSecondaryTrack->SetParentID( aTrack.GetTrackID() );
840 
841  fParticleChange.AddSecondary(aSecondaryTrack);
842  fParticleChange.ProposeEnergy(kinEnergy);
843  }
844  }
845  return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
846 }
G4VXTRenergyLoss::GetXTRrandomEnergy
G4double GetXTRrandomEnergy(G4double scaledTkin, G4int iTkin)
Definition: G4VXTRenergyLoss.cc:1463
G4INCL::DeJongSpin::shoot
ThreeVector shoot(const G4int Ap, const G4int Af)
Definition: G4INCLDeJongSpin.cc:67
G4VProcess::verboseLevel
G4int verboseLevel
Definition: G4VProcess.hh:368
G4DynamicParticle::GetKineticEnergy
G4double GetKineticEnergy() const
G4Track::GetDynamicParticle
const G4DynamicParticle * GetDynamicParticle() const
G4VXTRenergyLoss::fEnvelope
G4LogicalVolume * fEnvelope
Definition: G4VXTRenergyLoss.hh:185
G4LogicalVolume::GetMaterial
G4Material * GetMaterial() const
G4Material::GetName
const G4String & GetName() const
Definition: G4Material.hh:176
G4Track::SetTouchableHandle
void SetTouchableHandle(const G4TouchableHandle &apValue)
G4DynamicParticle::GetDefinition
G4ParticleDefinition * GetDefinition() const
G4StepPoint::GetTouchable
const G4VTouchable * GetTouchable() const
G4int
int G4int
Definition: G4Types.hh:78
G4AffineTransform::Invert
G4AffineTransform & Invert()
G4UniformRand
#define G4UniformRand()
Definition: Randomize.hh:87
G4cout
G4GLOB_DLL std::ostream G4cout
G4StepPoint::GetPosition
const G4ThreeVector & GetPosition() const
G4DynamicParticle::GetMomentumDirection
const G4ThreeVector & GetMomentumDirection() const
python.hepunit.proton_mass_c2
float proton_mass_c2
Definition: hepunit.py:275
G4Track::GetTrackID
G4int GetTrackID() const
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86
G4ParticleChange::Initialize
virtual void Initialize(const G4Track &)
Definition: G4ParticleChange.cc:228
G4AffineTransform::TransformPoint
G4ThreeVector TransformPoint(const G4ThreeVector &vec) const
G4VTouchable::GetTranslation
virtual const G4ThreeVector & GetTranslation(G4int depth=0) const =0
G4VPhysicalVolume::GetLogicalVolume
G4LogicalVolume * GetLogicalVolume() const
G4ParticleDefinition::GetPDGMass
G4double GetPDGMass() const
Definition: G4ParticleDefinition.hh:161
G4VParticleChange::SetNumberOfSecondaries
void SetNumberOfSecondaries(G4int totSecondaries)
G4Track::SetParentID
void SetParentID(const G4int aValue)
G4Step::GetPostStepPoint
G4StepPoint * GetPostStepPoint() const
G4AffineTransform::TransformAxis
G4ThreeVector TransformAxis(const G4ThreeVector &axis) const
G4ParticleChange::ProposeEnergy
void ProposeEnergy(G4double finalEnergy)
G4Track::GetVolume
G4VPhysicalVolume * GetVolume() const
G4ParticleChange::AddSecondary
void AddSecondary(G4Track *aSecondary)
Definition: G4ParticleChange.cc:218
G4VXTRenergyLoss::GetRandomAngle
G4double GetRandomAngle(G4double energyXTR, G4int iTkin)
Definition: G4VXTRenergyLoss.cc:1550
G4endl
#define G4endl
Definition: G4ios.hh:61
G4StepPoint::GetGlobalTime
G4double GetGlobalTime() const
G4double
double G4double
Definition: G4Types.hh:76
G4VXTRenergyLoss::fParticleChange
G4ParticleChange fParticleChange
Definition: G4VXTRenergyLoss.hh:232
G4VSolid::DistanceToOut
virtual G4double DistanceToOut(const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const =0
G4VDiscreteProcess::PostStepDoIt
virtual G4VParticleChange * PostStepDoIt(const G4Track &, const G4Step &)
Definition: G4VDiscreteProcess.cc:112
python.hepunit.c_light
float c_light
Definition: hepunit.py:257
G4StepPoint::GetTouchableHandle
const G4TouchableHandle & GetTouchableHandle() const
G4LogicalVolume::GetSolid
G4VSolid * GetSolid() const
G4VTouchable::GetRotation
virtual const G4RotationMatrix * GetRotation(G4int depth=0) const =0
void G4VXTRenergyLoss::SetAngleRadDistr ( G4bool  pAngleRadDistr)
inline

Definition at line 171 of file G4VXTRenergyLoss.hh.

References fAngleRadDistr.

171 {fAngleRadDistr=pAngleRadDistr;};
void G4VXTRenergyLoss::SetCompton ( G4bool  pC)
inline

Definition at line 172 of file G4VXTRenergyLoss.hh.

References fCompton.

172 {fCompton=pC;};
void G4VXTRenergyLoss::SetEnergy ( G4double  energy)
inline

Definition at line 169 of file G4VXTRenergyLoss.hh.

References energy(), and fEnergy.

169 {fEnergy = energy;};
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
void G4VXTRenergyLoss::SetGamma ( G4double  gamma)
inline

Definition at line 168 of file G4VXTRenergyLoss.hh.

References fGamma.

168 {fGamma = gamma;};
void G4VXTRenergyLoss::SetVarAngle ( G4double  varAngle)
inline

Definition at line 170 of file G4VXTRenergyLoss.hh.

References fVarAngle.

170 {fVarAngle = varAngle;};
G4double G4VXTRenergyLoss::SpectralAngleXTRdEdx ( G4double  varAngle)

Definition at line 877 of file G4VXTRenergyLoss.cc.

References fEnergy, fGamma, and GetStackFactor().

Referenced by BuildAngleForEnergyBank(), and SpectralXTRdEdx().

878 {
879  G4double result = GetStackFactor(fEnergy,fGamma,varAngle);
880  if(result < 0.0) result = 0.0;
881  return result;
882 }
G4double
double G4double
Definition: G4Types.hh:76
G4VXTRenergyLoss::GetStackFactor
virtual G4double GetStackFactor(G4double energy, G4double gamma, G4double varAngle)
Definition: G4VXTRenergyLoss.cc:1371
G4double G4VXTRenergyLoss::SpectralXTRdEdx ( G4double  energy)
virtual

Reimplemented in Em10XTRTransparentRegRadModel, G4TransparentRegXTRadiator, G4RegularXTRadiator, G4XTRTransparentRegRadModel, and G4XTRRegularRadModel.

Definition at line 888 of file G4VXTRenergyLoss.cc.

References energy(), fEnergy, fMaxThetaTR, G4Integrator< T, F >::Legendre96(), and SpectralAngleXTRdEdx().

Referenced by BuildEnergyTable().

889 {
890  G4int i, iMax = 8;
891  G4double angleSum = 0.0;
892 
893  G4double lim[8] = { 0.0, 0.01, 0.02, 0.05, 0.1, 0.2, 0.5, 1.0 };
894 
895  for( i = 0; i < iMax; i++ ) lim[i] *= fMaxThetaTR;
896 
897  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
898 
899  fEnergy = energy;
900  /*
901  if( fAngleRadDistr && ( fEnergy == fEnergyForAngle ) )
902  {
903  fAngleVector ->PutValue(fBinTR - 1, angleSum);
904 
905  for( i = fBinTR - 2; i >= 0; i-- )
906  {
907 
908  angleSum += integral.Legendre10(
909  this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
910  fAngleVector->GetLowEdgeEnergy(i),
911  fAngleVector->GetLowEdgeEnergy(i+1) );
912 
913  fAngleVector ->PutValue(i, angleSum);
914  }
915  }
916  else
917  */
918  {
919  for( i = 0; i < iMax-1; i++ )
920  {
921  angleSum += integral.Legendre96(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
922  lim[i],lim[i+1]);
923  // result += integral.Legendre10(this,&G4VXTRenergyLoss::SpectralAngleXTRdEdx,
924  // lim[i],lim[i+1]);
925  }
926  }
927  return angleSum;
928 }
G4Integrator::Legendre96
G4double Legendre96(T &typeT, F f, G4double a, G4double b)
G4int
int G4int
Definition: G4Types.hh:78
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4VXTRenergyLoss::SpectralAngleXTRdEdx
G4double SpectralAngleXTRdEdx(G4double varAngle)
Definition: G4VXTRenergyLoss.cc:877
G4double
double G4double
Definition: G4Types.hh:76
G4double G4VXTRenergyLoss::XTRNAngleDensity ( G4double  varAngle)

Definition at line 1419 of file G4VXTRenergyLoss.cc.

References fMaxEnergyTR, fMinEnergyTR, fVarAngle, G4Integrator< T, F >::Legendre96(), and XTRNAngleSpectralDensity().

1420 {
1421  fVarAngle = varAngle;
1422  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
1423  return integral.Legendre96(this,&G4VXTRenergyLoss::XTRNAngleSpectralDensity,
1424  fMinEnergyTR,fMaxEnergyTR);
1425 }
G4Integrator::Legendre96
G4double Legendre96(T &typeT, F f, G4double a, G4double b)
G4VXTRenergyLoss::XTRNAngleSpectralDensity
G4double XTRNAngleSpectralDensity(G4double energy)
Definition: G4VXTRenergyLoss.cc:1409
G4double G4VXTRenergyLoss::XTRNAngleSpectralDensity ( G4double  energy)

Definition at line 1409 of file G4VXTRenergyLoss.cc.

References fGamma, fVarAngle, GetStackFactor(), and OneBoundaryXTRNdensity().

Referenced by XTRNAngleDensity().

1410 {
1411  return OneBoundaryXTRNdensity(energy,fGamma,fVarAngle)*
1412  GetStackFactor(energy,fGamma,fVarAngle);
1413 }
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4VXTRenergyLoss::OneBoundaryXTRNdensity
G4double OneBoundaryXTRNdensity(G4double energy, G4double gamma, G4double varAngle) const
Definition: G4VXTRenergyLoss.cc:1354
G4VXTRenergyLoss::GetStackFactor
virtual G4double GetStackFactor(G4double energy, G4double gamma, G4double varAngle)
Definition: G4VXTRenergyLoss.cc:1371
G4double G4VXTRenergyLoss::XTRNSpectralAngleDensity ( G4double  varAngle)

Definition at line 1384 of file G4VXTRenergyLoss.cc.

References fEnergy, fGamma, GetStackFactor(), and OneBoundaryXTRNdensity().

Referenced by XTRNSpectralDensity().

1385 {
1386  return OneBoundaryXTRNdensity(fEnergy,fGamma,varAngle)*
1387  GetStackFactor(fEnergy,fGamma,varAngle);
1388 }
G4VXTRenergyLoss::OneBoundaryXTRNdensity
G4double OneBoundaryXTRNdensity(G4double energy, G4double gamma, G4double varAngle) const
Definition: G4VXTRenergyLoss.cc:1354
G4VXTRenergyLoss::GetStackFactor
virtual G4double GetStackFactor(G4double energy, G4double gamma, G4double varAngle)
Definition: G4VXTRenergyLoss.cc:1371
G4double G4VXTRenergyLoss::XTRNSpectralDensity ( G4double  energy)

Definition at line 1394 of file G4VXTRenergyLoss.cc.

References energy(), fEnergy, fMaxThetaTR, G4Integrator< T, F >::Legendre10(), G4Integrator< T, F >::Legendre96(), and XTRNSpectralAngleDensity().

1395 {
1396  fEnergy = energy;
1397  G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
1398  return integral.Legendre96(this,&G4VXTRenergyLoss::XTRNSpectralAngleDensity,
1399  0.0,0.2*fMaxThetaTR) +
1400  integral.Legendre10(this,&G4VXTRenergyLoss::XTRNSpectralAngleDensity,
1401  0.2*fMaxThetaTR,fMaxThetaTR);
1402 }
G4Integrator::Legendre10
G4double Legendre10(T &typeT, F f, G4double a, G4double b)
G4Integrator::Legendre96
G4double Legendre96(T &typeT, F f, G4double a, G4double b)
energy
double precision function energy(A, Z)
Definition: dpm25nuc6.f:4106
G4VXTRenergyLoss::XTRNSpectralAngleDensity
G4double XTRNSpectralAngleDensity(G4double varAngle)
Definition: G4VXTRenergyLoss.cc:1384

Field Documentation

G4double G4VXTRenergyLoss::fAlphaGas
protected

Definition at line 226 of file G4VXTRenergyLoss.hh.

Referenced by Em10XTRTransparentRegRadModel::Em10XTRTransparentRegRadModel(), G4GammaXTRadiator::G4GammaXTRadiator(), G4RegularXTRadiator::G4RegularXTRadiator(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), G4RegularXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), and G4StrawTubeXTRadiator::GetStackFactor().

G4double G4VXTRenergyLoss::fAlphaPlate
protected

Definition at line 225 of file G4VXTRenergyLoss.hh.

Referenced by Em10XTRTransparentRegRadModel::Em10XTRTransparentRegRadModel(), G4GammaXTRadiator::G4GammaXTRadiator(), G4RegularXTRadiator::G4RegularXTRadiator(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), G4RegularXTRadiator::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), and G4StrawTubeXTRadiator::GetStackFactor().

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

Definition at line 237 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), and GetRandomAngle().

G4PhysicsTable* G4VXTRenergyLoss::fAngleDistrTable
protected

Definition at line 186 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), BuildGlobalAngleTable(), and ~G4VXTRenergyLoss().

G4PhysicsTable* G4VXTRenergyLoss::fAngleForEnergyTable
protected

Definition at line 236 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), GetRandomAngle(), and ~G4VXTRenergyLoss().

G4bool G4VXTRenergyLoss::fAngleRadDistr
protected

Definition at line 213 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), BuildPhysicsTable(), G4VXTRenergyLoss(), PostStepDoIt(), SetAngleRadDistr(), and ~G4VXTRenergyLoss().

G4int G4VXTRenergyLoss::fBinTR
protected

Definition at line 199 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), and GetRandomAngle().

G4double G4VXTRenergyLoss::fCofTR
protected

Definition at line 210 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

G4bool G4VXTRenergyLoss::fCompton
protected

Definition at line 214 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), SetCompton(), and G4XTRTransparentRegRadModel::SpectralXTRdEdx().

G4double G4VXTRenergyLoss::fEnergy
protected

Definition at line 205 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), G4VXTRenergyLoss(), GetEnergy(), SetEnergy(), SpectralAngleXTRdEdx(), SpectralXTRdEdx(), XTRNSpectralAngleDensity(), and XTRNSpectralDensity().

G4PhysicsTable* G4VXTRenergyLoss::fEnergyDistrTable
protected

Definition at line 187 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), GetMeanFreePath(), GetXTRrandomEnergy(), and ~G4VXTRenergyLoss().

G4LogicalVolume* G4VXTRenergyLoss::fEnvelope
protected

Definition at line 185 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), GetMeanFreePath(), PostStepDoIt(), and ~G4VXTRenergyLoss().

G4bool G4VXTRenergyLoss::fExitFlux
protected

Definition at line 212 of file G4VXTRenergyLoss.hh.

Referenced by Em10XTRTransparentRegRadModel::Em10XTRTransparentRegRadModel(), G4VXTRenergyLoss(), G4XTRGammaRadModel::G4XTRGammaRadModel(), G4XTRRegularRadModel::G4XTRRegularRadModel(), G4XTRTransparentRegRadModel::G4XTRTransparentRegRadModel(), and PostStepDoIt().

G4double G4VXTRenergyLoss::fGamma
protected

Definition at line 204 of file G4VXTRenergyLoss.hh.

Referenced by AngleSpectralXTRdEdx(), AngleXTRdEdx(), BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetAngleVector(), GetGamma(), GetMeanFreePath(), SetGamma(), SpectralAngleXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), Em10XTRTransparentRegRadModel::SpectralXTRdEdx(), XTRNAngleSpectralDensity(), and XTRNSpectralAngleDensity().

G4double* G4VXTRenergyLoss::fGammaCutInKineticEnergy
protected

Definition at line 182 of file G4VXTRenergyLoss.hh.

G4double G4VXTRenergyLoss::fGammaTkinCut
protected

Definition at line 184 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), and BuildGlobalAngleTable().

G4SandiaTable* G4VXTRenergyLoss::fGasPhotoAbsCof
protected

Definition at line 230 of file G4VXTRenergyLoss.hh.

Referenced by ComputeGasPhotoAbsCof(), and GetGasLinearPhotoAbs().

G4double G4VXTRenergyLoss::fGasThick
protected

Definition at line 224 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

G4double G4VXTRenergyLoss::fLambda
protected

Definition at line 207 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), and GetMeanFreePath().

G4int G4VXTRenergyLoss::fMatIndex1
protected

Definition at line 218 of file G4VXTRenergyLoss.hh.

Referenced by ComputePlatePhotoAbsCof(), G4VXTRenergyLoss(), and GetPlateCompton().

G4int G4VXTRenergyLoss::fMatIndex2
protected

Definition at line 219 of file G4VXTRenergyLoss.hh.

Referenced by ComputeGasPhotoAbsCof(), G4VXTRenergyLoss(), and GetGasCompton().

G4double G4VXTRenergyLoss::fMaxEnergyTR
protected

Definition at line 195 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), and XTRNAngleDensity().

G4double G4VXTRenergyLoss::fMaxProtonTkin
protected

Definition at line 202 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fMaxThetaTR
protected

Definition at line 198 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetAngleVector(), SpectralXTRdEdx(), and XTRNSpectralDensity().

G4double G4VXTRenergyLoss::fMinEnergyTR
protected

Definition at line 194 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), and XTRNAngleDensity().

G4double G4VXTRenergyLoss::fMinProtonTkin
protected

Definition at line 201 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

G4ParticleChange G4VXTRenergyLoss::fParticleChange
protected

Definition at line 232 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss(), and PostStepDoIt().

G4double G4VXTRenergyLoss::fPlasmaCof
protected

Definition at line 209 of file G4VXTRenergyLoss.hh.

Referenced by G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), and G4VXTRenergyLoss().

G4int G4VXTRenergyLoss::fPlateNumber
protected

Definition at line 220 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), G4XTRRegularRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

G4SandiaTable* G4VXTRenergyLoss::fPlatePhotoAbsCof
protected

Definition at line 228 of file G4VXTRenergyLoss.hh.

Referenced by ComputePlatePhotoAbsCof(), and GetPlateLinearPhotoAbs().

G4double G4VXTRenergyLoss::fPlateThick
protected

Definition at line 223 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), G4XTRRegularRadModel::GetStackFactor(), G4XTRTransparentRegRadModel::GetStackFactor(), G4RegularXTRadiator::GetStackFactor(), G4TransparentRegXTRadiator::GetStackFactor(), Em10XTRTransparentRegRadModel::GetStackFactor(), G4XTRGammaRadModel::GetStackFactor(), G4StrawTubeXTRadiator::GetStackFactor(), G4GammaXTRadiator::GetStackFactor(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

G4PhysicsLogVector* G4VXTRenergyLoss::fProtonEnergyVector
protected

Definition at line 189 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMeanFreePath(), GetNumberOfPhotons(), GetProtonVector(), GetXTRrandomEnergy(), and ~G4VXTRenergyLoss().

G4ParticleDefinition* G4VXTRenergyLoss::fPtrGamma
protected

Definition at line 180 of file G4VXTRenergyLoss.hh.

Referenced by G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fSigma1
protected

Definition at line 215 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), GetPlateFormationZone(), OneBoundaryXTRNdensity(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

G4double G4VXTRenergyLoss::fSigma2
protected

Definition at line 216 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), G4VXTRenergyLoss(), GetAngleVector(), GetGasFormationZone(), OneBoundaryXTRNdensity(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4XTRTransparentRegRadModel::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), and Em10XTRTransparentRegRadModel::SpectralXTRdEdx().

G4double G4VXTRenergyLoss::fTheMaxAngle
protected

Definition at line 196 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fTheMaxEnergyTR
protected

Definition at line 193 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fTheMinAngle
protected

Definition at line 197 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fTheMinEnergyTR
protected

Definition at line 192 of file G4VXTRenergyLoss.hh.

Referenced by AngleXTRdEdx(), BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), and G4VXTRenergyLoss().

G4double G4VXTRenergyLoss::fTotalDist
protected

Definition at line 222 of file G4VXTRenergyLoss.hh.

Referenced by BuildEnergyTable(), and G4VXTRenergyLoss().

G4int G4VXTRenergyLoss::fTotBin
protected

Definition at line 203 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleForEnergyBank(), BuildAngleTable(), BuildEnergyTable(), BuildGlobalAngleTable(), G4VXTRenergyLoss(), GetMeanFreePath(), GetNumberOfPhotons(), GetRandomAngle(), GetTotBin(), GetXTRrandomEnergy(), and PostStepDoIt().

G4double G4VXTRenergyLoss::fVarAngle
protected

Definition at line 206 of file G4VXTRenergyLoss.hh.

Referenced by AngleSpectralXTRdEdx(), G4VXTRenergyLoss(), GetVarAngle(), SetVarAngle(), XTRNAngleDensity(), and XTRNAngleSpectralDensity().

G4PhysicsLogVector* G4VXTRenergyLoss::fXTREnergyVector
protected

Definition at line 190 of file G4VXTRenergyLoss.hh.

Referenced by BuildAngleTable(), G4VXTRenergyLoss(), and ~G4VXTRenergyLoss().

The documentation for this class was generated from the following files:
Generated on Wed Apr 30 2014 15:57:20 for Geant4.10 by   doxygen 1.8.7