G4ForwardXrayTR Class Reference

#include <G4ForwardXrayTR.hh>

Inheritance diagram for G4ForwardXrayTR:

Public Member Functions
virtual G4VParticleChange *	AlongStepDoIt (const G4Track &, const G4Step &)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double, G4double, G4double &, G4GPILSelection *)
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AngleDensity (G4double energy, G4double varAngle) const
G4double	AngleIntegralDistribution (G4double varAngle1, G4double varAngle2) const
G4double	AngleInterval (G4double energy, G4double varAngle1, G4double varAngle2) const
G4double	AngleSum (G4double varAngle1, G4double varAngle2) const
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
virtual void	BuildPhysicsTable (const G4ParticleDefinition &)
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
void	BuildXrayTRtables ()
void	DumpInfo () const override
virtual void	EndTracking ()
G4double	EnergyIntegralDistribution (G4double energy1, G4double energy2) const
G4double	EnergyInterval (G4double energy1, G4double energy2, G4double varAngle) const
G4double	EnergySum (G4double energy1, G4double energy2) const
	G4ForwardXrayTR (const G4ForwardXrayTR &right)=delete
	G4ForwardXrayTR (const G4String &matName1, const G4String &matName2, const G4String &processName="XrayTR")
	G4ForwardXrayTR (const G4String &processName="XrayTR")
G4PhysicsTable *	GetAngleDistrTable ()
G4double	GetCurrentInteractionLength () const
G4PhysicsTable *	GetEnergyDistrTable ()
G4double	GetEnergyTR (G4int iMat, G4int jMat, G4int iTkin) const
const G4VProcess *	GetMasterProcess () const
G4double	GetMeanFreePath (const G4Track &, G4double, G4ForceCondition *condition) override
G4double	GetNumberOfInteractionLengthLeft () const
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
G4double	GetPILfactor () const
virtual const G4ProcessManager *	GetProcessManager ()
const G4String &	GetProcessName () const
G4int	GetProcessSubType () const
G4ProcessType	GetProcessType () const
G4double	GetThetaTR (G4int iMat, G4int jMat, G4int iTkin) const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4int	GetVerboseLevel () const
G4double	IntegralOverAngle (G4double energy, G4double varAngle1, G4double varAngle2) const
G4double	IntegralOverEnergy (G4double energy1, G4double energy2, G4double varAngle) const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	IsApplicable (const G4ParticleDefinition &aParticleType) override
G4bool	isAtRestDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
G4bool	operator!= (const G4VProcess &right) const
G4ForwardXrayTR &	operator= (const G4ForwardXrayTR &right)=delete
G4bool	operator== (const G4VProcess &right) const
G4VParticleChange *	PostStepDoIt (const G4Track &aTrack, const G4Step &aStep) override
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)
void	ProcessDescription (std::ostream &) const override
virtual void	ResetNumberOfInteractionLengthLeft ()
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual void	SetMasterProcess (G4VProcess *masterP)
void	SetPILfactor (G4double value)
virtual void	SetProcessManager (const G4ProcessManager *)
void	SetProcessSubType (G4int)
void	SetProcessType (G4ProcessType)
void	SetVerboseLevel (G4int value)
G4double	SpectralAngleTRdensity (G4double energy, G4double varAngle) const override
G4double	SpectralDensity (G4double energy, G4double x) const
virtual void	StartTracking (G4Track *)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
	~G4ForwardXrayTR ()

Static Public Member Functions
static G4int	GetBinTR ()
static G4double	GetMaxProtonTkin ()
static G4double	GetMinProtonTkin ()
static const G4String &	GetProcessTypeName (G4ProcessType)
static G4int	GetSympsonNumber ()
static G4int	GetTotBin ()

Protected Member Functions
void	ClearNumberOfInteractionLengthLeft ()
void	SubtractNumberOfInteractionLengthLeft (G4double prevStepSize)

Protected Attributes
G4ParticleChange	aParticleChange
const G4ProcessManager *	aProcessManager = nullptr
G4double	currentInteractionLength = -1.0
G4bool	enableAlongStepDoIt = true
G4bool	enableAtRestDoIt = true
G4bool	enablePostStepDoIt = true
G4PhysicsTable *	fAngleDistrTable
G4double	fEnergy
G4PhysicsTable *	fEnergyDistrTable
G4double	fGamma
const std::vector< G4double > *	fGammaCutInKineticEnergy
G4double	fGammaTkinCut
G4int	fMatIndex1
G4int	fMatIndex2
G4double	fMaxEnergy
G4double	fMaxEnergyTR
G4double	fMaxTheta
G4double	fMaxThetaTR
G4double	fMinEnergy
G4double	fMinEnergyTR
G4PhysicsLogVector *	fProtonEnergyVector
G4ParticleDefinition *	fPtrGamma
G4double	fSigma1
G4double	fSigma2
G4double	fVarAngle
G4VParticleChange *	pParticleChange = nullptr
G4int	secID = -1
G4double	theInitialNumberOfInteractionLength = -1.0
G4double	theNumberOfInteractionLengthLeft = -1.0
G4String	thePhysicsTableFileName
G4double	thePILfactor = 1.0
G4String	theProcessName
G4int	theProcessSubType = -1
G4ProcessType	theProcessType = fNotDefined
G4int	verboseLevel = 0

Static Protected Attributes
static constexpr G4int	fBinTR = 50
static constexpr G4double	fCofTR = CLHEP::fine_structure_const / CLHEP::pi
static constexpr G4int	fGammaNumber = 15
static constexpr G4double	fMaxProtonTkin
static constexpr G4double	fMinProtonTkin
static constexpr G4double	fPlasmaCof
static constexpr G4int	fPointNumber = 100
static constexpr G4int	fSympsonNumber
static constexpr G4double	fTheMaxAngle = 1.0e-3
static constexpr G4double	fTheMaxEnergyTR
static constexpr G4double	fTheMinAngle = 5.0e-6
static constexpr G4double	fTheMinEnergyTR
static constexpr G4int	fTotBin = 50

Private Attributes
G4ProcessTable *	fProcessTable = nullptr
G4VProcess *	masterProcessShadow = nullptr

Detailed Description

Definition at line 52 of file G4ForwardXrayTR.hh.

Constructor & Destructor Documentation

G4ForwardXrayTR() [1/3]

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

explicit

Definition at line 57 of file G4ForwardXrayTR.cc.

  : G4TransitionRadiation(processName)
{
  secID = G4PhysicsModelCatalog::GetModelID("model_XrayTR");
  fPtrGamma                = nullptr;
  fGammaCutInKineticEnergy = nullptr;
  fGammaTkinCut = fMinEnergyTR = fMaxEnergyTR = fMaxThetaTR = 0.0;
  fGamma = fSigma1 = fSigma2 = 0.0;
  fAngleDistrTable           = nullptr;
  fEnergyDistrTable          = nullptr;
  fMatIndex1 = fMatIndex2 = 0;
 
  // Proton energy vector initialization
  fProtonEnergyVector =
    new G4PhysicsLogVector(fMinProtonTkin, fMaxProtonTkin, fTotBin);
  G4int iMat;
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = theCoupleTable->GetTableSize();
 
  G4bool build = true;
 
  for(iMat = 0; iMat < numOfCouples; ++iMat)  // check first material name
  {
    const G4MaterialCutsCouple* couple =
      theCoupleTable->GetMaterialCutsCouple(iMat);
    if(matName1 == couple->GetMaterial()->GetName())
    {
      fMatIndex1 = couple->GetIndex();
      break;
    }
  }
  if(iMat == numOfCouples)
  {
    G4Exception("G4ForwardXrayTR::G4ForwardXrayTR", "ForwardXrayTR01",
                JustWarning,
                "Invalid first material name in G4ForwardXrayTR constructor!");
    build = false;
  }
 
  if(build)
  {
    for(iMat = 0; iMat < numOfCouples; ++iMat)  // check second material name
    {
      const G4MaterialCutsCouple* couple =
        theCoupleTable->GetMaterialCutsCouple(iMat);
      if(matName2 == couple->GetMaterial()->GetName())
      {
        fMatIndex2 = couple->GetIndex();
        break;
      }
    }
    if(iMat == numOfCouples)
    {
      G4Exception(
        "G4ForwardXrayTR::G4ForwardXrayTR", "ForwardXrayTR02", JustWarning,
        "Invalid second material name in G4ForwardXrayTR constructor!");
      build = false;
    }
  }
  if(build)
  {
    BuildXrayTRtables();
  }
}

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

G4ForwardXrayTR() [2/3]

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

explicit

Definition at line 127 of file G4ForwardXrayTR.cc.

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

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

~G4ForwardXrayTR()

G4ForwardXrayTR::~G4ForwardXrayTR

(

)

Definition at line 145 of file G4ForwardXrayTR.cc.

{
  delete fAngleDistrTable;
  delete fEnergyDistrTable;
  delete fProtonEnergyVector;
}

References fAngleDistrTable, fEnergyDistrTable, and fProtonEnergyVector.

G4ForwardXrayTR() [3/3]

G4ForwardXrayTR::G4ForwardXrayTR ( const G4ForwardXrayTR &  right )

delete

Member Function Documentation

AlongStepDoIt()

virtual G4VParticleChange * G4VDiscreteProcess::AlongStepDoIt ( const G4Track &  , const G4Step &    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 90 of file G4VDiscreteProcess.hh.

                              { return 0; }

AlongStepGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AlongStepGetPhysicalInteractionLength ( const G4Track &  , G4double  , G4double  , G4double &  , G4GPILSelection *    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4NuclearStopping.

Definition at line 70 of file G4VDiscreteProcess.hh.

                              { return -1.0; }

AlongStepGPIL()

G4double G4VProcess::AlongStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  proposedSafety, G4GPILSelection *  selection  )

inlineinherited

Definition at line 461 of file G4VProcess.hh.

{
  return AlongStepGetPhysicalInteractionLength(track, previousStepSize,
                             currentMinimumStep, proposedSafety, selection);
}

References G4VProcess::AlongStepGetPhysicalInteractionLength().

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

AngleDensity()

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

Definition at line 304 of file G4ForwardXrayTR.cc.

{
  G4double x, x2, c, d, f, a2, b2, a4, b4;
  G4double cof1, cof2, cof3;
  x    = 1.0 / energy;
  x2   = x * x;
  c    = 1.0 / fSigma1;
  d    = 1.0 / fSigma2;
  f    = (varAngle + 1.0 / (fGamma * fGamma));
  a2   = c * f;
  b2   = d * f;
  a4   = a2 * a2;
  b4   = b2 * b2;
  cof1 = c * c * (0.5 / (a2 * (x2 + a2)) + 0.5 * std::log(x2 / (x2 + a2)) / a4);
  cof3 = d * d * (0.5 / (b2 * (x2 + b2)) + 0.5 * std::log(x2 / (x2 + b2)) / b4);
  cof2 = -c * d *
         (std::log(x2 / (x2 + b2)) / b2 - std::log(x2 / (x2 + a2)) / a2) /
         (a2 - b2);
  return -varAngle * (cof1 + cof2 + cof3);
}

References G4INCL::KinematicsUtils::energy(), fGamma, fSigma1, and fSigma2.

Referenced by EnergyInterval().

AngleIntegralDistribution()

G4double G4TransitionRadiation::AngleIntegralDistribution ( G4double  varAngle1, G4double  varAngle2  ) const

inherited

Definition at line 137 of file G4TransitionRadiation.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (varAngle2 - varAngle1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven += IntegralOverEnergy(fMinEnergy,
                                  fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                                  varAngle1 + 2 * i * h) +
               IntegralOverEnergy(fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                                  fMaxEnergy, varAngle1 + 2 * i * h);
    sumOdd += IntegralOverEnergy(fMinEnergy,
                                 fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                                 varAngle1 + (2 * i - 1) * h) +
              IntegralOverEnergy(fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                                 fMaxEnergy, varAngle1 + (2 * i - 1) * h);
  }
  sumOdd +=
    IntegralOverEnergy(fMinEnergy, fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                       varAngle1 + (2 * fSympsonNumber - 1) * h) +
    IntegralOverEnergy(fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy), fMaxEnergy,
                       varAngle1 + (2 * fSympsonNumber - 1) * h);
 
  return h *
         (IntegralOverEnergy(fMinEnergy,
                             fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                             varAngle1) +
          IntegralOverEnergy(fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                             fMaxEnergy, varAngle1) +
          IntegralOverEnergy(fMinEnergy,
                             fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                             varAngle2) +
          IntegralOverEnergy(fMinEnergy + 0.3 * (fMaxEnergy - fMinEnergy),
                             fMaxEnergy, varAngle2) +
          4.0 * sumOdd + 2.0 * sumEven) /
         3.0;
}

References G4TransitionRadiation::fMaxEnergy, G4TransitionRadiation::fMinEnergy, G4TransitionRadiation::fSympsonNumber, and G4TransitionRadiation::IntegralOverEnergy().

AngleInterval()

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

Definition at line 375 of file G4ForwardXrayTR.cc.

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

References G4INCL::KinematicsUtils::energy(), and SpectralDensity().

Referenced by EnergySum().

AngleSum()

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

Definition at line 337 of file G4ForwardXrayTR.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (varAngle2 - varAngle1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven +=
      EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1 + 2 * i * h);
    sumOdd +=
      EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1 + (2 * i - 1) * h);
  }
  sumOdd += EnergyInterval(fMinEnergyTR, fMaxEnergyTR,
                           varAngle1 + (2 * fSympsonNumber - 1) * h);
 
  return h *
         (EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle1) +
          EnergyInterval(fMinEnergyTR, fMaxEnergyTR, varAngle2) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

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

Referenced by BuildXrayTRtables().

AtRestDoIt()

virtual G4VParticleChange * G4VDiscreteProcess::AtRestDoIt ( const G4Track &  , const G4Step &    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 85 of file G4VDiscreteProcess.hh.

                              { return 0; }

AtRestGetPhysicalInteractionLength()

virtual G4double G4VDiscreteProcess::AtRestGetPhysicalInteractionLength ( const G4Track &  , G4ForceCondition *    )

inlinevirtualinherited

Implements G4VProcess.

Reimplemented in G4HadronStoppingProcess, and G4eplusAnnihilation.

Definition at line 78 of file G4VDiscreteProcess.hh.

                              { return -1.0; }

AtRestGPIL()

G4double G4VProcess::AtRestGPIL ( const G4Track &  track, G4ForceCondition *  condition  )

inlineinherited

Definition at line 472 of file G4VProcess.hh.

{
  return thePILfactor * AtRestGetPhysicalInteractionLength(track, condition);
}

References G4VProcess::AtRestGetPhysicalInteractionLength(), condition(), and G4VProcess::thePILfactor.

Referenced by G4ITStepProcessor::GetAtRestIL(), and G4SteppingManager::InvokeAtRestDoItProcs().

BuildPhysicsTable()

virtual void G4VProcess::BuildPhysicsTable ( const G4ParticleDefinition &  )

inlinevirtualinherited

Reimplemented in G4ITTransportation, G4VITProcess, G4DNABrownianTransportation, G4DNASecondOrderReaction, G4RadioactiveDecay, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4Channeling, G4GammaGeneralProcess, G4Decay, G4UnknownDecay, G4AdjointForcedInteractionForGamma, G4AdjointProcessEquivalentToDirectProcess, G4VAdjointReverseReaction, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4AnnihiToMuPair, G4GammaConversionToMuons, G4LowECapture, G4MicroElecSurface, G4PolarizedAnnihilation, G4PolarizedCompton, G4PolarizedIonisation, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4SynchrotronRadiation, G4VXTRenergyLoss, G4HadronicProcess, G4hImpactIonisation, G4ChargeExchangeProcess, G4Cerenkov, G4Scintillation, G4OpRayleigh, G4OpWLS, G4OpWLS2, and G4BiasingProcessInterface.

Definition at line 187 of file G4VProcess.hh.

{}

Referenced by G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4WrapperProcess::BuildPhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::BuildPhysicsTable(), G4BiasingProcessInterface::BuildPhysicsTable(), G4VProcess::BuildWorkerPhysicsTable(), and export_G4VProcess().

BuildWorkerPhysicsTable()

void G4VProcess::BuildWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 200 of file G4VProcess.cc.

{
  BuildPhysicsTable(part);
}

References G4VProcess::BuildPhysicsTable().

Referenced by G4BiasingProcessInterface::BuildWorkerPhysicsTable().

BuildXrayTRtables()

void G4ForwardXrayTR::BuildXrayTRtables

(

)

Definition at line 168 of file G4ForwardXrayTR.cc.

{
  G4int iMat, jMat, iTkin, iTR, iPlace;
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = theCoupleTable->GetTableSize();
 
  fGammaCutInKineticEnergy = theCoupleTable->GetEnergyCutsVector(idxG4GammaCut);
 
  fAngleDistrTable  = new G4PhysicsTable(2 * fTotBin);
  fEnergyDistrTable = new G4PhysicsTable(2 * fTotBin);
 
  for(iMat = 0; iMat < numOfCouples;
      ++iMat)  // loop over pairs of different materials
  {
    if(iMat != fMatIndex1 && iMat != fMatIndex2)
      continue;
 
    for(jMat = 0; jMat < numOfCouples; ++jMat)  // transition iMat -> jMat !!!
    {
      if(iMat == jMat || (jMat != fMatIndex1 && jMat != fMatIndex2))
      {
        continue;
      }
      else
      {
        const G4MaterialCutsCouple* iCouple =
          theCoupleTable->GetMaterialCutsCouple(iMat);
        const G4MaterialCutsCouple* jCouple =
          theCoupleTable->GetMaterialCutsCouple(jMat);
        const G4Material* mat1 = iCouple->GetMaterial();
        const G4Material* mat2 = jCouple->GetMaterial();
 
        fSigma1 = fPlasmaCof * (mat1->GetElectronDensity());
        fSigma2 = fPlasmaCof * (mat2->GetElectronDensity());
 
        fGammaTkinCut = 0.0;
 
        if(fGammaTkinCut > fTheMinEnergyTR)  // setting of min/max TR energies
        {
          fMinEnergyTR = fGammaTkinCut;
        }
        else
        {
          fMinEnergyTR = fTheMinEnergyTR;
        }
        if(fGammaTkinCut > fTheMaxEnergyTR)
        {
          fMaxEnergyTR = 2.0 * fGammaTkinCut;  // usually very low TR rate
        }
        else
        {
          fMaxEnergyTR = fTheMaxEnergyTR;
        }
        for(iTkin = 0; iTkin < fTotBin; ++iTkin)  // Lorentz factor loop
        {
          G4PhysicsLogVector* energyVector =
            new G4PhysicsLogVector(fMinEnergyTR, fMaxEnergyTR, fBinTR);
 
          fGamma = 1.0 + (fProtonEnergyVector->GetLowEdgeEnergy(iTkin) /
                          proton_mass_c2);
 
          fMaxThetaTR = 10000.0 / (fGamma * fGamma);
 
          if(fMaxThetaTR > fTheMaxAngle)
          {
            fMaxThetaTR = fTheMaxAngle;
          }
          else
          {
            if(fMaxThetaTR < fTheMinAngle)
            {
              fMaxThetaTR = fTheMinAngle;
            }
          }
          G4PhysicsLinearVector* angleVector =
            new G4PhysicsLinearVector(0.0, fMaxThetaTR, fBinTR);
          G4double energySum = 0.0;
          G4double angleSum  = 0.0;
 
          energyVector->PutValue(fBinTR - 1, energySum);
          angleVector->PutValue(fBinTR - 1, angleSum);
 
          for(iTR = fBinTR - 2; iTR >= 0; --iTR)
          {
            energySum +=
              fCofTR * EnergySum(energyVector->GetLowEdgeEnergy(iTR),
                                 energyVector->GetLowEdgeEnergy(iTR + 1));
 
            angleSum +=
              fCofTR * AngleSum(angleVector->GetLowEdgeEnergy(iTR),
                                angleVector->GetLowEdgeEnergy(iTR + 1));
 
            energyVector->PutValue(iTR, energySum);
            angleVector->PutValue(iTR, angleSum);
          }
 
          if(jMat < iMat)
          {
            iPlace = fTotBin + iTkin;
          }
          else  // jMat > iMat right part of matrices (jMat-1) !
          {
            iPlace = iTkin;
          }
          fEnergyDistrTable->insertAt(iPlace, energyVector);
          fAngleDistrTable->insertAt(iPlace, angleVector);
        }  //                      iTkin
      }    //         jMat != iMat
    }      //     jMat
  }        // iMat
}

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

Referenced by G4ForwardXrayTR().

ClearNumberOfInteractionLengthLeft()

void G4VProcess::ClearNumberOfInteractionLengthLeft ( )

inlineprotectedinherited

Definition at line 424 of file G4VProcess.hh.

{
  theInitialNumberOfInteractionLength = -1.0; 
  theNumberOfInteractionLengthLeft =  -1.0;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4RadioactiveDecay::DecayAnalog(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4Radioactivation::DecayIt(), G4RadioactiveDecay::DecayIt(), G4MuonicAtomDecay::DecayIt(), G4Decay::EndTracking(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4VAdjointReverseReaction::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4HadronicProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), and G4MuNeutrinoNucleusProcess::PostStepDoIt().

DumpInfo()

void G4ForwardXrayTR::DumpInfo ( ) const

inlineoverridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 68 of file G4ForwardXrayTR.hh.

{ ProcessDescription(G4cout); };

References G4cout, and ProcessDescription().

EndTracking()

void G4VProcess::EndTracking ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, G4WrapperProcess, G4FastSimulationManagerProcess, G4VPhononProcess, G4CoupledTransportation, G4Decay, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 102 of file G4VProcess.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::EndTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
  theNumberOfInteractionLengthLeft = -1.0;
  currentInteractionLength = -1.0;
  theInitialNumberOfInteractionLength=-1.0;
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4BiasingProcessInterface::EndTracking(), G4WrapperProcess::EndTracking(), G4VPhononProcess::EndTracking(), and G4AdjointProcessEquivalentToDirectProcess::EndTracking().

EnergyIntegralDistribution()

G4double G4TransitionRadiation::EnergyIntegralDistribution ( G4double  energy1, G4double  energy2  ) const

inherited

Definition at line 180 of file G4TransitionRadiation.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (energy2 - energy1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven +=
      IntegralOverAngle(energy1 + 2 * i * h, 0.0, 0.01 * fMaxTheta) +
      IntegralOverAngle(energy1 + 2 * i * h, 0.01 * fMaxTheta, fMaxTheta);
    sumOdd +=
      IntegralOverAngle(energy1 + (2 * i - 1) * h, 0.0, 0.01 * fMaxTheta) +
      IntegralOverAngle(energy1 + (2 * i - 1) * h, 0.01 * fMaxTheta, fMaxTheta);
  }
  sumOdd += IntegralOverAngle(energy1 + (2 * fSympsonNumber - 1) * h, 0.0,
                              0.01 * fMaxTheta) +
            IntegralOverAngle(energy1 + (2 * fSympsonNumber - 1) * h,
                              0.01 * fMaxTheta, fMaxTheta);
 
  return h *
         (IntegralOverAngle(energy1, 0.0, 0.01 * fMaxTheta) +
          IntegralOverAngle(energy1, 0.01 * fMaxTheta, fMaxTheta) +
          IntegralOverAngle(energy2, 0.0, 0.01 * fMaxTheta) +
          IntegralOverAngle(energy2, 0.01 * fMaxTheta, fMaxTheta) +
          4.0 * sumOdd + 2.0 * sumEven) /
         3.0;
}

References G4TransitionRadiation::fMaxTheta, G4TransitionRadiation::fSympsonNumber, and G4TransitionRadiation::IntegralOverAngle().

EnergyInterval()

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

Definition at line 328 of file G4ForwardXrayTR.cc.

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

References AngleDensity().

Referenced by AngleSum().

EnergySum()

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

Definition at line 385 of file G4ForwardXrayTR.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (energy2 - energy1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven += AngleInterval(energy1 + 2 * i * h, 0.0, fMaxThetaTR);
    sumOdd += AngleInterval(energy1 + (2 * i - 1) * h, 0.0, fMaxThetaTR);
  }
  sumOdd +=
    AngleInterval(energy1 + (2 * fSympsonNumber - 1) * h, 0.0, fMaxThetaTR);
 
  return h *
         (AngleInterval(energy1, 0.0, fMaxThetaTR) +
          AngleInterval(energy2, 0.0, fMaxThetaTR) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

References AngleInterval(), fMaxThetaTR, and fSympsonNumber.

Referenced by BuildXrayTRtables().

GetAngleDistrTable()

G4PhysicsTable * G4ForwardXrayTR::GetAngleDistrTable

(

)

GetBinTR()

G4int G4ForwardXrayTR::GetBinTR ( )

static

Definition at line 747 of file G4ForwardXrayTR.cc.

{ return fBinTR; }

References fBinTR.

GetCurrentInteractionLength()

G4double G4VProcess::GetCurrentInteractionLength ( ) const

inlineinherited

Definition at line 443 of file G4VProcess.hh.

{
  return currentInteractionLength;
}

References G4VProcess::currentInteractionLength.

Referenced by G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), and G4BOptrForceCollision::ProposeOccurenceBiasingOperation().

GetEnergyDistrTable()

G4PhysicsTable * G4ForwardXrayTR::GetEnergyDistrTable

(

)

GetEnergyTR()

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

Definition at line 635 of file G4ForwardXrayTR.cc.

{
  G4int iPlace, numOfTR, iTR, iTransfer;
  G4double energyTR = 0.0;  // return this value for no TR photons
  G4double energyPos;
  G4double W1, W2;
 
  const G4ProductionCutsTable* theCoupleTable =
    G4ProductionCutsTable::GetProductionCutsTable();
  G4int numOfCouples = theCoupleTable->GetTableSize();
 
  // The case of equal or approximate (in terms of plasma energy) materials
  // No TR photons ?!
 
  const G4MaterialCutsCouple* iCouple =
    theCoupleTable->GetMaterialCutsCouple(iMat);
  const G4MaterialCutsCouple* jCouple =
    theCoupleTable->GetMaterialCutsCouple(jMat);
  const G4Material* iMaterial = iCouple->GetMaterial();
  const G4Material* jMaterial = jCouple->GetMaterial();
 
  if(iMat == jMat
 
     || iMaterial->GetState() == jMaterial->GetState()
 
     || (iMaterial->GetState() == kStateSolid &&
         jMaterial->GetState() == kStateLiquid)
 
     || (iMaterial->GetState() == kStateLiquid &&
         jMaterial->GetState() == kStateSolid))
 
  {
    return energyTR;
  }
 
  if(jMat < iMat)
  {
    iPlace = (iMat * (numOfCouples - 1) + jMat) * fTotBin + iTkin - 1;
  }
  else
  {
    iPlace = (iMat * (numOfCouples - 1) + jMat - 1) * fTotBin + iTkin - 1;
  }
  G4PhysicsVector* energyVector1 = (*fEnergyDistrTable)(iPlace);
  G4PhysicsVector* energyVector2 = (*fEnergyDistrTable)(iPlace + 1);
 
  if(iTkin == fTotBin)  // TR plato, try from left
  {
    numOfTR = G4Poisson((*energyVector1)(0));
    if(numOfTR == 0)
    {
      return energyTR;
    }
    else
    {
      for(iTR = 0; iTR < numOfTR; ++iTR)
      {
        energyPos = (*energyVector1)(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(energyPos >= (*energyVector1)(iTransfer))
            break;
        }
        energyTR += energyVector1->GetLowEdgeEnergy(iTransfer);
      }
    }
  }
  else
  {
    if(iTkin == 0)  // Tkin is too small, neglect of TR photon generation
    {
      return energyTR;
    }
    else  // general case: Tkin between two vectors of the material
    {     // use trivial mean half/half
      W1      = 0.5;
      W2      = 0.5;
      numOfTR = G4Poisson((*energyVector1)(0) * W1 + (*energyVector2)(0) * W2);
      if(numOfTR == 0)
      {
        return energyTR;
      }
      else
      {
        G4cout << "It is still OK in GetEnergyTR(int,int,int)" << G4endl;
        for(iTR = 0; iTR < numOfTR; ++iTR)
        {
          energyPos = ((*energyVector1)(0) * W1 + (*energyVector2)(0) * W2) *
                      G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(energyPos >= ((*energyVector1)(iTransfer) *W1 +
                             (*energyVector2)(iTransfer) *W2))
              break;
          }
          energyTR += (energyVector1->GetLowEdgeEnergy(iTransfer)) * W1 +
                      (energyVector2->GetLowEdgeEnergy(iTransfer)) * W2;
        }
      }
    }
  }
 
  return energyTR;
}

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

GetMasterProcess()

const G4VProcess * G4VProcess::GetMasterProcess ( ) const

inlineinherited

Definition at line 518 of file G4VProcess.hh.

{
  return masterProcessShadow;
}

References G4VProcess::masterProcessShadow.

Referenced by G4PolarizedCompton::BuildPhysicsTable(), G4PolarizedIonisation::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4BiasingProcessInterface::SetMasterProcess(), and G4VMultipleScattering::StorePhysicsTable().

GetMaxProtonTkin()

G4double G4ForwardXrayTR::GetMaxProtonTkin ( )

static

Definition at line 751 of file G4ForwardXrayTR.cc.

{ return fMaxProtonTkin; }

References fMaxProtonTkin.

GetMeanFreePath()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 159 of file G4ForwardXrayTR.cc.

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

References condition(), DBL_MAX, and Forced.

GetMinProtonTkin()

G4double G4ForwardXrayTR::GetMinProtonTkin ( )

static

Definition at line 749 of file G4ForwardXrayTR.cc.

{ return fMinProtonTkin; }

References fMinProtonTkin.

GetNumberOfInteractionLengthLeft()

G4double G4VProcess::GetNumberOfInteractionLengthLeft ( ) const

inlineinherited

Definition at line 431 of file G4VProcess.hh.

{
  return theNumberOfInteractionLengthLeft;
}

References G4VProcess::theNumberOfInteractionLengthLeft.

GetPhysicsTableFileName()

const G4String & G4VProcess::GetPhysicsTableFileName ( const G4ParticleDefinition *  particle, const G4String &  directory, const G4String &  tableName, G4bool  ascii = false  )

inherited

Definition at line 181 of file G4VProcess.cc.

{
  G4String thePhysicsTableFileExt;
  if (ascii) thePhysicsTableFileExt = ".asc";
  else       thePhysicsTableFileExt = ".dat";
 
  thePhysicsTableFileName = directory + "/";
  thePhysicsTableFileName += tableName + "." +  theProcessName + ".";
  thePhysicsTableFileName += particle->GetParticleName()
                           + thePhysicsTableFileExt;
  
  return thePhysicsTableFileName;
}

References G4ParticleDefinition::GetParticleName(), G4VProcess::thePhysicsTableFileName, and G4VProcess::theProcessName.

Referenced by export_G4VProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4GammaGeneralProcess::StorePhysicsTable(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), and G4VEnergyLossProcess::StoreTable().

GetPILfactor()

G4double G4VProcess::GetPILfactor ( ) const

inlineinherited

Definition at line 455 of file G4VProcess.hh.

{
  return thePILfactor;
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

GetProcessManager()

const G4ProcessManager * G4VProcess::GetProcessManager ( )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 494 of file G4VProcess.hh.

{
  return aProcessManager; 
}

References G4VProcess::aProcessManager.

Referenced by G4BiasingProcessInterface::GetProcessManager(), and G4WrapperProcess::GetProcessManager().

GetProcessName()

const G4String & G4VProcess::GetProcessName ( ) const

inlineinherited

Definition at line 382 of file G4VProcess.hh.

{
  return theProcessName;
}

References G4VProcess::theProcessName.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4ProcessManager::ActivateProcess(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4ParallelGeometriesLimiterProcess::AddParallelWorld(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4ProcessManager::AddProcess(), G4ProcessPlacer::AddProcessAs(), G4ITSteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerbose::AlongStepDoItAllDone(), G4SteppingVerboseWithUnits::AlongStepDoItAllDone(), G4ITSteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerbose::AlongStepDoItOneByOne(), G4SteppingVerboseWithUnits::AlongStepDoItOneByOne(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4BOptnLeadingParticle::ApplyFinalStateBiasing(), G4ITSteppingVerbose::AtRestDoItInvoked(), G4SteppingVerbose::AtRestDoItInvoked(), G4SteppingVerboseWithUnits::AtRestDoItInvoked(), G4ITSteppingVerbose::AtRestDoItOneByOne(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4HadronicProcess::BiasCrossSectionByFactor(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VEnergyLossProcess::BuildDEDXTable(), G4VUserPhysicsList::BuildIntegralPhysicsTable(), G4VEmProcess::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4LossTableManager::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4HadronicProcess::CheckEnergyMomentumConservation(), G4ProcessManager::CheckOrderingParameters(), G4HadronicProcess::CheckResult(), G4StackChecker::ClassifyNewTrack(), G4BOptrForceCollision::ConfigureForWorker(), G4RunManagerKernel::ConfirmCoupledTransportation(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), G4LossTableManager::CopyTables(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4VPhononProcess::CreateSecondary(), G4EmExtraParameters::DefineRegParamForEM(), G4EmExtraParameters::DefineRegParamForLoss(), G4HadronicProcessStore::DeRegisterExtraProcess(), G4ITSteppingVerbose::DPSLAlongStep(), G4SteppingVerbose::DPSLAlongStep(), G4SteppingVerboseWithUnits::DPSLAlongStep(), G4ITSteppingVerbose::DPSLPostStep(), G4SteppingVerbose::DPSLPostStep(), G4SteppingVerboseWithUnits::DPSLPostStep(), G4HadronicProcessStore::Dump(), G4HadronicProcess::DumpState(), G4MuonicAtomDecay::DumpState(), G4ExceptionHandler::DumpTrackInfo(), export_G4VProcess(), G4EmCalculator::FindEmModel(), G4VEmProcess::FindLambdaMax(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4HadronicProcess::GetElementCrossSection(), G4VEmProcess::GetEmProcess(), G4GammaGeneralProcess::GetEmProcess(), G4WeightWindowProcess::GetName(), G4ProcessManager::GetProcess(), G4ProcessManager::GetProcessVectorIndex(), G4GammaGeneralProcess::GetSubProcessName(), G4ProcessManager::InActivateProcess(), G4hhIonisation::InitialiseEnergyLossProcess(), G4ProcessTable::Insert(), G4ITStepProcessor::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4LossTableManager::LocalPhysicsTables(), G4ErrorPropagator::MakeOneStep(), G4VEmProcess::PostStepDoIt(), G4ITSteppingVerbose::PostStepDoItAllDone(), G4SteppingVerbose::PostStepDoItAllDone(), G4SteppingVerboseWithUnits::PostStepDoItAllDone(), G4ITSteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerbose::PostStepDoItOneByOne(), G4SteppingVerboseWithUnits::PostStepDoItOneByOne(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4ITSteppingVerbose::PostStepVerbose(), G4EmConfigurator::PrepareModels(), G4HadronStoppingProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4HadronicProcessStore::PrintHtml(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4hImpactIonisation::PrintInfoDefinition(), G4ProcessPlacer::PrintProcVec(), G4VEnergyLossProcess::PrintWarning(), G4VEmProcess::PrintWarning(), G4SynchrotronRadiation::ProcessDescription(), G4Decay::ProcessDescription(), G4DecayWithSpin::ProcessDescription(), G4PionDecayMakeSpin::ProcessDescription(), G4UnknownDecay::ProcessDescription(), G4ChannelingOptrChangeCrossSection::ProposeOccurenceBiasingOperation(), G4StackManager::PushOneTrack(), G4HadronicProcessStore::Register(), G4LossTableManager::Register(), G4LossTableManager::RegisterExtraParticle(), G4HadronicProcessStore::RegisterExtraProcess(), G4HadronicProcessStore::RegisterParticle(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::Remove(), G4ParallelGeometriesLimiterProcess::RemoveParallelWorld(), G4ProcessManager::RemoveProcess(), G4ProcessPlacer::RemoveProcess(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4VEnergyLossProcess::SetInverseRangeTable(), G4VEnergyLossProcess::SetLambdaTable(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessManager::SetProcessOrderingToSecond(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4FastSimulationManagerProcess::SetWorldVolume(), G4ITSteppingVerbose::ShowStep(), G4SteppingVerbose::ShowStep(), G4SteppingVerboseWithUnits::ShowStep(), G4ChannelingOptrChangeCrossSection::StartRun(), G4ITSteppingVerbose::StepInfo(), G4SteppingVerbose::StepInfo(), G4SteppingVerboseWithUnits::StepInfo(), G4ITSteppingVerbose::StepInfoForLeadingTrack(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4EmCalculator::UpdateParticle(), G4ParallelWorldScoringProcess::Verbose(), G4ScoreSplittingProcess::Verbose(), G4ITSteppingVerbose::VerboseTrack(), G4SteppingVerbose::VerboseTrack(), and G4SteppingVerboseWithUnits::VerboseTrack().

GetProcessSubType()

G4int G4VProcess::GetProcessSubType ( ) const

inlineinherited

Definition at line 400 of file G4VProcess.hh.

{
  return theProcessSubType;
}

References G4VProcess::theProcessSubType.

Referenced by G4GammaGeneralProcess::AddEmProcess(), G4DNABrownianTransportation::BuildPhysicsTable(), G4HadronicProcessStore::FindProcess(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4HadronicProcessStore::GetCrossSectionPerAtom(), G4HadronicProcessStore::GetCrossSectionPerVolume(), G4GammaGeneralProcess::GetSubProcessSubType(), G4VEmProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4HadronicProcessStore::Print(), G4AnnihiToMuPair::PrintInfoDefinition(), G4GammaConversionToMuons::PrintInfoDefinition(), G4PhysicsListHelper::RegisterProcess(), G4ElectronIonPair::ResidualeChargePostStep(), G4EmConfigurator::SetModelForRegion(), G4ChannelingOptrChangeCrossSection::StartRun(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

GetProcessType()

G4ProcessType G4VProcess::GetProcessType ( ) const

inlineinherited

Definition at line 388 of file G4VProcess.hh.

{
  return theProcessType;
}

References G4VProcess::theProcessType.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4SteppingManager::DefinePhysicalStepLength(), export_G4VProcess(), G4ProcessTable::Find(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4WrapperProcess::RegisterProcess(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTableMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and G4ChannelingOptrChangeCrossSection::StartRun().

GetProcessTypeName()

const G4String & G4VProcess::GetProcessTypeName ( G4ProcessType  aType )

staticinherited

Definition at line 134 of file G4VProcess.cc.

{
  switch (aType)
  {
    case fNotDefined:         return typeNotDefined; break;
    case fTransportation:     return typeTransportation; break;
    case fElectromagnetic:    return typeElectromagnetic; break;
    case fOptical:            return typeOptical; break;
    case fHadronic:           return typeHadronic; break;
    case fPhotolepton_hadron: return typePhotolepton_hadron; break;
    case fDecay:              return typeDecay; break;
    case fGeneral:            return typeGeneral; break;
    case fParameterisation:   return typeParameterisation; break;
    case fUserDefined:        return typeUserDefined; break;
    case fPhonon:             return typePhonon; break;
    default: ;
  }
  return noType;  
}

References fDecay, fElectromagnetic, fGeneral, fHadronic, fNotDefined, fOptical, fParameterisation, fPhonon, fPhotolepton_hadron, fTransportation, fUserDefined, anonymous_namespace{G4VProcess.cc}::noType, anonymous_namespace{G4VProcess.cc}::typeDecay, anonymous_namespace{G4VProcess.cc}::typeElectromagnetic, anonymous_namespace{G4VProcess.cc}::typeGeneral, anonymous_namespace{G4VProcess.cc}::typeHadronic, anonymous_namespace{G4VProcess.cc}::typeNotDefined, anonymous_namespace{G4VProcess.cc}::typeOptical, anonymous_namespace{G4VProcess.cc}::typeParameterisation, anonymous_namespace{G4VProcess.cc}::typePhonon, anonymous_namespace{G4VProcess.cc}::typePhotolepton_hadron, anonymous_namespace{G4VProcess.cc}::typeTransportation, and anonymous_namespace{G4VProcess.cc}::typeUserDefined.

Referenced by G4RichTrajectory::CreateAttValues(), G4RichTrajectoryPoint::CreateAttValues(), G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4ProcessTableMessenger::GetProcessType(), G4ProcessTableMessenger::GetProcessTypeName(), and G4ProcessTableMessenger::SetNumberOfProcessType().

GetSympsonNumber()

G4int G4ForwardXrayTR::GetSympsonNumber ( )

static

Definition at line 745 of file G4ForwardXrayTR.cc.

{ return fSympsonNumber; }

References fSympsonNumber.

GetThetaTR()

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

Definition at line 743 of file G4ForwardXrayTR.cc.

{ return 0.0; }

GetTotalNumberOfInteractionLengthTraversed()

G4double G4VProcess::GetTotalNumberOfInteractionLengthTraversed ( ) const

inlineinherited

Definition at line 437 of file G4VProcess.hh.

{
  return theInitialNumberOfInteractionLength - theNumberOfInteractionLengthLeft;
}

References G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4HadronicProcess::XBiasSecondaryWeight(), and G4HadronicProcess::XBiasSurvivalProbability().

GetTotBin()

G4int G4ForwardXrayTR::GetTotBin ( )

static

Definition at line 753 of file G4ForwardXrayTR.cc.

{ return fTotBin; }

References fTotBin.

GetVerboseLevel()

G4int G4VProcess::GetVerboseLevel ( ) const

inlineinherited

Definition at line 418 of file G4VProcess.hh.

{
  return  verboseLevel;
}

References G4VProcess::verboseLevel.

Referenced by G4MuonMinusAtomicCapture::AtRestDoIt(), G4Decay::DecayIt(), G4UnknownDecay::DecayIt(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4Decay::G4Decay(), G4UnknownDecay::G4UnknownDecay(), G4Decay::GetMeanFreePath(), G4Decay::GetMeanLifeTime(), and G4DecayWithSpin::Spin_Precession().

IntegralOverAngle()

G4double G4TransitionRadiation::IntegralOverAngle ( G4double  energy, G4double  varAngle1, G4double  varAngle2  ) const

inherited

Definition at line 112 of file G4TransitionRadiation.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (varAngle2 - varAngle1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; ++i)
  {
    sumEven += SpectralAngleTRdensity(energy, varAngle1 + 2 * i * h);
    sumOdd += SpectralAngleTRdensity(energy, varAngle1 + (2 * i - 1) * h);
  }
  sumOdd +=
    SpectralAngleTRdensity(energy, varAngle1 + (2 * fSympsonNumber - 1) * h);
 
  return h *
         (SpectralAngleTRdensity(energy, varAngle1) +
          SpectralAngleTRdensity(energy, varAngle2) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

References G4INCL::KinematicsUtils::energy(), G4TransitionRadiation::fSympsonNumber, and G4TransitionRadiation::SpectralAngleTRdensity().

Referenced by G4TransitionRadiation::EnergyIntegralDistribution().

IntegralOverEnergy()

G4double G4TransitionRadiation::IntegralOverEnergy ( G4double  energy1, G4double  energy2, G4double  varAngle  ) const

inherited

Definition at line 88 of file G4TransitionRadiation.cc.

{
  G4int i;
  G4double h, sumEven = 0.0, sumOdd = 0.0;
  h = 0.5 * (energy2 - energy1) / fSympsonNumber;
  for(i = 1; i < fSympsonNumber; i++)
  {
    sumEven += SpectralAngleTRdensity(energy1 + 2 * i * h, varAngle);
    sumOdd += SpectralAngleTRdensity(energy1 + (2 * i - 1) * h, varAngle);
  }
  sumOdd +=
    SpectralAngleTRdensity(energy1 + (2 * fSympsonNumber - 1) * h, varAngle);
  return h *
         (SpectralAngleTRdensity(energy1, varAngle) +
          SpectralAngleTRdensity(energy2, varAngle) + 4.0 * sumOdd +
          2.0 * sumEven) /
         3.0;
}

References G4TransitionRadiation::fSympsonNumber, and G4TransitionRadiation::SpectralAngleTRdensity().

Referenced by G4TransitionRadiation::AngleIntegralDistribution().

isAlongStepDoItIsEnabled()

G4bool G4VProcess::isAlongStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 506 of file G4VProcess.hh.

{
  return enableAlongStepDoIt;
}

References G4VProcess::enableAlongStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

IsApplicable()

G4bool G4TransitionRadiation::IsApplicable ( const G4ParticleDefinition &  aParticleType )

overridevirtualinherited

Reimplemented from G4VProcess.

Definition at line 65 of file G4TransitionRadiation.cc.

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

References G4ParticleDefinition::GetPDGCharge().

isAtRestDoItIsEnabled()

G4bool G4VProcess::isAtRestDoItIsEnabled ( ) const

inlineinherited

Definition at line 500 of file G4VProcess.hh.

{
  return enableAtRestDoIt;
}

References G4VProcess::enableAtRestDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

isPostStepDoItIsEnabled()

G4bool G4VProcess::isPostStepDoItIsEnabled ( ) const

inlineinherited

Definition at line 512 of file G4VProcess.hh.

{
  return enablePostStepDoIt;
}

References G4VProcess::enablePostStepDoIt.

Referenced by G4ProcessManager::CheckOrderingParameters().

operator!=()

G4bool G4VProcess::operator!= ( const G4VProcess &  right ) const

inherited

Definition at line 161 of file G4VProcess.cc.

{
  return (this !=  &right);
}

operator=()

G4ForwardXrayTR & G4ForwardXrayTR::operator= ( const G4ForwardXrayTR &  right )

delete

operator==()

G4bool G4VProcess::operator== ( const G4VProcess &  right ) const

inherited

Definition at line 155 of file G4VProcess.cc.

{
  return (this == &right);
}

PostStepDoIt()

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

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 408 of file G4ForwardXrayTR.cc.

{
  aParticleChange.Initialize(aTrack);
  G4int iMat, jMat, iTkin, iPlace, numOfTR, iTR, iTransfer;
 
  G4double energyPos, anglePos, energyTR, theta, phi, dirX, dirY, dirZ;
  G4double W, W1, W2, E1, E2;
 
  G4StepPoint* pPreStepPoint  = aStep.GetPreStepPoint();
  G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
  G4double tol =
    0.5 * G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  if(pPostStepPoint->GetStepStatus() != fGeomBoundary)
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  if(aTrack.GetStepLength() <= tol)
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  // Arrived at boundary, so begin to try TR
 
  const G4MaterialCutsCouple* iCouple = pPreStepPoint->GetPhysicalVolume()
                                          ->GetLogicalVolume()
                                          ->GetMaterialCutsCouple();
  const G4MaterialCutsCouple* jCouple = pPostStepPoint->GetPhysicalVolume()
                                          ->GetLogicalVolume()
                                          ->GetMaterialCutsCouple();
  const G4Material* iMaterial = iCouple->GetMaterial();
  const G4Material* jMaterial = jCouple->GetMaterial();
  iMat                        = iCouple->GetIndex();
  jMat                        = jCouple->GetIndex();
 
  // The case of equal or approximate (in terms of plasma energy) materials
  // No TR photons ?!
 
  if(iMat == jMat ||
     ((fMatIndex1 >= 0 && fMatIndex2 >= 0) &&
      (iMat != fMatIndex1 && iMat != fMatIndex2) &&
      (jMat != fMatIndex1 && jMat != fMatIndex2))
 
     || iMaterial->GetState() == jMaterial->GetState()
 
     || (iMaterial->GetState() == kStateSolid &&
         jMaterial->GetState() == kStateLiquid)
 
     || (iMaterial->GetState() == kStateLiquid &&
         jMaterial->GetState() == kStateSolid))
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
 
  const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
  G4double charge = aParticle->GetDefinition()->GetPDGCharge();
 
  if(charge == 0.0)  // Uncharged particle doesn't Generate TR photons
  {
    return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
  }
  // Now we are ready to Generate TR photons
 
  G4double chargeSq  = charge * charge;
  G4double kinEnergy = aParticle->GetKineticEnergy();
  G4double massRatio =
    proton_mass_c2 / aParticle->GetDefinition()->GetPDGMass();
  G4double TkinScaled = kinEnergy * massRatio;
  for(iTkin = 0; iTkin < fTotBin; ++iTkin)
  {
    if(TkinScaled < fProtonEnergyVector->GetLowEdgeEnergy(iTkin))
    {
      break;
    }
  }
  if(jMat < iMat)
  {
    iPlace = fTotBin + iTkin - 1;
  }
  else
  {
    iPlace = iTkin - 1;
  }
 
  G4ParticleMomentum particleDir = aParticle->GetMomentumDirection();
 
  if(iTkin == fTotBin)  // TR plato, try from left
  {
    numOfTR = G4Poisson(
      ((*(*fEnergyDistrTable)(iPlace))(0) + (*(*fAngleDistrTable)(iPlace))(0)) *
      chargeSq * 0.5);
    if(numOfTR == 0)
    {
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else
    {
      aParticleChange.SetNumberOfSecondaries(numOfTR);
 
      for(iTR = 0; iTR < numOfTR; ++iTR)
      {
        energyPos = (*(*fEnergyDistrTable)(iPlace))(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(energyPos >= (*(*fEnergyDistrTable)(iPlace))(iTransfer))
            break;
        }
        energyTR = (*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer);
 
        kinEnergy -= energyTR;
        aParticleChange.ProposeEnergy(kinEnergy);
 
        anglePos = (*(*fAngleDistrTable)(iPlace))(0) * G4UniformRand();
        for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
        {
          if(anglePos > (*(*fAngleDistrTable)(iPlace))(iTransfer))
            break;
        }
        theta = std::sqrt(
          (*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 1));
 
        phi  = twopi * G4UniformRand();
        dirX = std::sin(theta) * std::cos(phi);
        dirY = std::sin(theta) * std::sin(phi);
        dirZ = std::cos(theta);
        G4ThreeVector directionTR(dirX, dirY, dirZ);
        directionTR.rotateUz(particleDir);
        G4DynamicParticle* aPhotonTR =
          new G4DynamicParticle(G4Gamma::Gamma(), directionTR, energyTR);
 
    // Create the G4Track
    G4Track* aSecondaryTrack = new G4Track(aPhotonTR, aTrack.GetGlobalTime(), aTrack.GetPosition());
    aSecondaryTrack->SetTouchableHandle(aStep.GetPostStepPoint()->GetTouchableHandle());
    aSecondaryTrack->SetParentID(aTrack.GetTrackID());
    aSecondaryTrack->SetCreatorModelID(secID);
    aParticleChange.AddSecondary(aSecondaryTrack);  
      }
    }
  }
  else
  {
    if(iTkin == 0)  // Tkin is too small, neglect of TR photon generation
    {
      return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
    }
    else  // general case: Tkin between two vectors of the material
    {
      E1 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin - 1);
      E2 = fProtonEnergyVector->GetLowEdgeEnergy(iTkin);
      W  = 1.0 / (E2 - E1);
      W1 = (E2 - TkinScaled) * W;
      W2 = (TkinScaled - E1) * W;
 
      numOfTR = G4Poisson((((*(*fEnergyDistrTable)(iPlace))(0) +
                            (*(*fAngleDistrTable)(iPlace))(0)) *
                             W1 +
                           ((*(*fEnergyDistrTable)(iPlace + 1))(0) +
                            (*(*fAngleDistrTable)(iPlace + 1))(0)) *
                             W2) *
                          chargeSq * 0.5);
      if(numOfTR == 0)
      {
        return G4VDiscreteProcess::PostStepDoIt(aTrack, aStep);
      }
      else
      {
        aParticleChange.SetNumberOfSecondaries(numOfTR);
        for(iTR = 0; iTR < numOfTR; ++iTR)
        {
          energyPos = ((*(*fEnergyDistrTable)(iPlace))(0) * W1 +
                       (*(*fEnergyDistrTable)(iPlace + 1))(0) * W2) *
                      G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(energyPos >=
               ((*(*fEnergyDistrTable)(iPlace))(iTransfer) *W1 +
                (*(*fEnergyDistrTable)(iPlace + 1))(iTransfer) *W2))
              break;
          }
          energyTR =
            ((*fEnergyDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer)) * W1 +
            ((*fEnergyDistrTable)(iPlace + 1)->GetLowEdgeEnergy(iTransfer)) *
              W2;
 
          kinEnergy -= energyTR;
          aParticleChange.ProposeEnergy(kinEnergy);
 
          anglePos = ((*(*fAngleDistrTable)(iPlace))(0) * W1 +
                      (*(*fAngleDistrTable)(iPlace + 1))(0) * W2) *
                     G4UniformRand();
          for(iTransfer = 0; iTransfer < fBinTR - 1; ++iTransfer)
          {
            if(anglePos > ((*(*fAngleDistrTable)(iPlace))(iTransfer) *W1 +
                           (*(*fAngleDistrTable)(iPlace + 1))(iTransfer) *W2))
              break;
          }
          theta = std::sqrt(
            ((*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer - 1)) *
              W1 +
            ((*fAngleDistrTable)(iPlace + 1)->GetLowEdgeEnergy(iTransfer - 1)) *
              W2);
 
          phi  = twopi * G4UniformRand();
          dirX = std::sin(theta) * std::cos(phi);
          dirY = std::sin(theta) * std::sin(phi);
          dirZ = std::cos(theta);
          G4ThreeVector directionTR(dirX, dirY, dirZ);
          directionTR.rotateUz(particleDir);
          G4DynamicParticle* aPhotonTR =
            new G4DynamicParticle(G4Gamma::Gamma(), directionTR, energyTR);
 
      // Create the G4Track
      G4Track* aSecondaryTrack = new G4Track(aPhotonTR, aTrack.GetGlobalTime(), aTrack.GetPosition());
      aSecondaryTrack->SetTouchableHandle(aStep.GetPostStepPoint()->GetTouchableHandle());
      aSecondaryTrack->SetParentID(aTrack.GetTrackID());
      aSecondaryTrack->SetCreatorModelID(secID);
      aParticleChange.AddSecondary(aSecondaryTrack);          
        }
      }
    }
  }
  return &aParticleChange;
}

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

PostStepGetPhysicalInteractionLength()

G4double G4VDiscreteProcess::PostStepGetPhysicalInteractionLength ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

virtualinherited

Implements G4VProcess.

Reimplemented in G4ErrorMagFieldLimitProcess, G4ErrorStepLengthLimitProcess, G4ErrorTrackLengthTarget, G4HadronStoppingProcess, G4NeutronKiller, G4GammaGeneralProcess, G4UnknownDecay, G4PolarizedAnnihilation, G4PolarizedCompton, G4VEmProcess, G4VErrorLimitProcess, and G4LowECapture.

Definition at line 70 of file G4VDiscreteProcess.cc.

{
  if ( (previousStepSize < 0.0) || (theNumberOfInteractionLengthLeft<=0.0))
  {
    // beginning of tracking (or just after DoIt() of this process)
    ResetNumberOfInteractionLengthLeft();
  }
  else if ( previousStepSize > 0.0)
  {
    // subtract NumberOfInteractionLengthLeft 
    SubtractNumberOfInteractionLengthLeft(previousStepSize);
  }
  else
  {
    // zero step
    // DO NOTHING
  }
 
  // condition is set to "Not Forced"
  *condition = NotForced;
 
  // get mean free path
  currentInteractionLength = GetMeanFreePath(track, previousStepSize, condition);
 
  G4double value;
  if (currentInteractionLength < DBL_MAX)
  {
    value = theNumberOfInteractionLengthLeft * currentInteractionLength;
  }
  else
  {
    value = DBL_MAX;
  }
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4VDiscreteProcess::PostStepGetPhysicalInteractionLength() - ";
    G4cout << "[ " << GetProcessName() << "]" <<G4endl;
    track.GetDynamicParticle()->DumpInfo();
    G4cout << " in Material  " <<  track.GetMaterial()->GetName() <<G4endl;
    G4cout << "InteractionLength= " << value/cm <<"[cm] " <<G4endl;
  }
#endif
  return value;
}

References cm, condition(), G4VProcess::currentInteractionLength, DBL_MAX, G4DynamicParticle::DumpInfo(), G4cout, G4endl, G4Track::GetDynamicParticle(), G4Track::GetMaterial(), G4VDiscreteProcess::GetMeanFreePath(), G4Material::GetName(), G4VProcess::GetProcessName(), NotForced, G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::SubtractNumberOfInteractionLengthLeft(), G4VProcess::theNumberOfInteractionLengthLeft, and G4VProcess::verboseLevel.

PostStepGPIL()

G4double G4VProcess::PostStepGPIL ( const G4Track &  track, G4double  previousStepSize, G4ForceCondition *  condition  )

inlineinherited

Definition at line 479 of file G4VProcess.hh.

{
  return thePILfactor *
      PostStepGetPhysicalInteractionLength(track, previousStepSize, condition);
}

References condition(), G4VProcess::PostStepGetPhysicalInteractionLength(), and G4VProcess::thePILfactor.

Referenced by G4SteppingManager::DefinePhysicalStepLength(), and G4ITStepProcessor::DoDefinePhysicalStepLength().

PreparePhysicsTable()

virtual void G4VProcess::PreparePhysicsTable ( const G4ParticleDefinition &  )

inlinevirtualinherited

Reimplemented in G4NeutrinoElectronProcess, G4HadronStoppingProcess, G4MuonMinusAtomicCapture, G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4HadronicProcess, G4ElNeutrinoNucleusProcess, G4MuNeutrinoNucleusProcess, G4OpAbsorption, G4OpBoundaryProcess, G4OpMieHG, G4OpRayleigh, G4OpWLS, G4OpWLS2, G4Cerenkov, G4Scintillation, and G4BiasingProcessInterface.

Definition at line 194 of file G4VProcess.hh.

{}

Referenced by export_G4VProcess(), G4WrapperProcess::PreparePhysicsTable(), G4GammaGeneralProcess::PreparePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::PreparePhysicsTable(), G4BiasingProcessInterface::PreparePhysicsTable(), and G4VProcess::PrepareWorkerPhysicsTable().

PrepareWorkerPhysicsTable()

void G4VProcess::PrepareWorkerPhysicsTable ( const G4ParticleDefinition &  part )

virtualinherited

Reimplemented in G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.cc.

{
  PreparePhysicsTable(part);
}

References G4VProcess::PreparePhysicsTable().

Referenced by G4BiasingProcessInterface::PrepareWorkerPhysicsTable().

ProcessDescription()

void G4ForwardXrayTR::ProcessDescription ( std::ostream &  out ) const

overridevirtual

Reimplemented from G4TransitionRadiation.

Definition at line 152 of file G4ForwardXrayTR.cc.

{
  out << "Simulation of forward X-ray transition radiation generated by\n"
         "relativistic charged particles crossing the interface between\n"
         "two materials.\n";
}

Referenced by DumpInfo().

ResetNumberOfInteractionLengthLeft()

void G4VProcess::ResetNumberOfInteractionLengthLeft ( )

virtualinherited

Reimplemented in G4BiasingProcessInterface, G4VITProcess, G4WrapperProcess, and G4AdjointProcessEquivalentToDirectProcess.

Definition at line 80 of file G4VProcess.cc.

{
  theNumberOfInteractionLengthLeft =  -1.*G4Log( G4UniformRand() );
  theInitialNumberOfInteractionLength = theNumberOfInteractionLengthLeft; 
}

References G4Log(), G4UniformRand, G4VProcess::theInitialNumberOfInteractionLength, and G4VProcess::theNumberOfInteractionLengthLeft.

Referenced by G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4BiasingProcessInterface::InvokeWrappedProcessPostStepGPIL(), G4BiasingProcessInterface::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4BiasingProcessInterface::ResetNumberOfInteractionLengthLeft(), G4WrapperProcess::ResetNumberOfInteractionLengthLeft(), G4AdjointProcessEquivalentToDirectProcess::ResetNumberOfInteractionLengthLeft(), and G4Decay::StartTracking().

RetrievePhysicsTable()

virtual G4bool G4VProcess::RetrievePhysicsTable ( const G4ParticleDefinition *  , const G4String &  , G4bool    )

inlinevirtualinherited

Reimplemented in G4GammaGeneralProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4WrapperProcess, G4AdjointProcessEquivalentToDirectProcess, and G4BiasingProcessInterface.

Definition at line 211 of file G4VProcess.hh.

                                                               { return false; }

Referenced by export_G4VProcess(), G4WrapperProcess::RetrievePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::RetrievePhysicsTable(), and G4BiasingProcessInterface::RetrievePhysicsTable().

SetMasterProcess()

void G4VProcess::SetMasterProcess ( G4VProcess *  masterP )

virtualinherited

Reimplemented in G4BiasingProcessInterface, and G4WrapperProcess.

Definition at line 212 of file G4VProcess.cc.

{
  masterProcessShadow = masterP;
}

References G4VProcess::masterProcessShadow.

Referenced by G4BiasingProcessInterface::SetMasterProcess(), and G4WrapperProcess::SetMasterProcess().

SetPILfactor()

void G4VProcess::SetPILfactor ( G4double  value )

inlineinherited

Definition at line 449 of file G4VProcess.hh.

{
  if (value>0.) { thePILfactor = value; }
}

References G4VProcess::thePILfactor.

Referenced by export_G4VProcess().

SetProcessManager()

void G4VProcess::SetProcessManager ( const G4ProcessManager *  procMan )

inlinevirtualinherited

Reimplemented in G4BiasingProcessInterface, G4ParallelGeometriesLimiterProcess, and G4WrapperProcess.

Definition at line 488 of file G4VProcess.hh.

{
  aProcessManager = procMan; 
}

References G4VProcess::aProcessManager.

Referenced by G4ProcessManager::AddProcess(), G4BiasingProcessInterface::SetProcessManager(), and G4WrapperProcess::SetProcessManager().

SetProcessSubType()

void G4VProcess::SetProcessSubType ( G4int  value )

inlineinherited

Definition at line 406 of file G4VProcess.hh.

{
  theProcessSubType = value;
}

References G4VProcess::theProcessSubType.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4AnnihiToMuPair::G4AnnihiToMuPair(), G4BiasingProcessInterface::G4BiasingProcessInterface(), G4Cerenkov::G4Cerenkov(), G4ComptonScattering::G4ComptonScattering(), G4CoulombScattering::G4CoulombScattering(), G4CoupledTransportation::G4CoupledTransportation(), G4Decay::G4Decay(), G4DecayWithSpin::G4DecayWithSpin(), G4DNAAttachment::G4DNAAttachment(), G4DNABrownianTransportation::G4DNABrownianTransportation(), G4DNAChargeDecrease::G4DNAChargeDecrease(), G4DNAChargeIncrease::G4DNAChargeIncrease(), G4DNAElastic::G4DNAElastic(), G4DNAElectronSolvation::G4DNAElectronSolvation(), G4DNAExcitation::G4DNAExcitation(), G4DNAIonisation::G4DNAIonisation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4DNAVibExcitation::G4DNAVibExcitation(), G4eBremsstrahlung::G4eBremsstrahlung(), G4eeToHadrons::G4eeToHadrons(), G4eIonisation::G4eIonisation(), G4ePairProduction::G4ePairProduction(), G4eplusAnnihilation::G4eplusAnnihilation(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GammaConversion::G4GammaConversion(), G4GammaConversionToMuons::G4GammaConversionToMuons(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4HadronicProcess::G4HadronicProcess(), G4hhIonisation::G4hhIonisation(), G4hIonisation::G4hIonisation(), G4ionIonisation::G4ionIonisation(), G4ITTransportation::G4ITTransportation(), G4JAEAElasticScattering::G4JAEAElasticScattering(), G4MicroElecElastic::G4MicroElecElastic(), G4MicroElecInelastic::G4MicroElecInelastic(), G4MicroElecLOPhononScattering::G4MicroElecLOPhononScattering(), G4MicroElecSurface::G4MicroElecSurface(), G4mplIonisation::G4mplIonisation(), G4MuBremsstrahlung::G4MuBremsstrahlung(), G4MuIonisation::G4MuIonisation(), G4MuonMinusAtomicCapture::G4MuonMinusAtomicCapture(), G4MuPairProduction::G4MuPairProduction(), G4NeutronKiller::G4NeutronKiller(), G4NuclearStopping::G4NuclearStopping(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4PhotoElectricEffect::G4PhotoElectricEffect(), G4PionDecayMakeSpin::G4PionDecayMakeSpin(), G4PolarizedCompton::G4PolarizedCompton(), G4PolarizedGammaConversion::G4PolarizedGammaConversion(), G4PolarizedIonisation::G4PolarizedIonisation(), G4PolarizedPhotoElectric::G4PolarizedPhotoElectric(), G4RadioactiveDecay::G4RadioactiveDecay(), G4RayleighScattering::G4RayleighScattering(), G4Scintillation::G4Scintillation(), G4StepLimiter::G4StepLimiter(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(), G4TransitionRadiation::G4TransitionRadiation(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UnknownDecay::G4UnknownDecay(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VMultipleScattering::G4VMultipleScattering(), G4VTransitionRadiation::G4VTransitionRadiation(), G4VXTRenergyLoss::G4VXTRenergyLoss(), and G4Decay::SetExtDecayer().

SetProcessType()

void G4VProcess::SetProcessType ( G4ProcessType  aType )

inlineinherited

Definition at line 394 of file G4VProcess.hh.

{
  theProcessType = aType;
}

References G4VProcess::theProcessType.

Referenced by G4MaxTimeCuts::G4MaxTimeCuts(), and G4MinEkineCuts::G4MinEkineCuts().

SetVerboseLevel()

void G4VProcess::SetVerboseLevel ( G4int  value )

inlineinherited

Definition at line 412 of file G4VProcess.hh.

{
  verboseLevel = value;
}

References G4VProcess::verboseLevel.

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4ProcessTable::DumpInfo(), export_G4VProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4GammaGeneralProcess::G4GammaGeneralProcess(), G4hhIonisation::G4hhIonisation(), G4mplIonisation::G4mplIonisation(), G4Transportation::G4Transportation(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4CoulombScattering::InitialiseProcess(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4ProcessManagerMessenger::SetNewValue(), and G4ProcessTableMessenger::SetNewValue().

SpectralAngleTRdensity()

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

overridevirtual

Implements G4TransitionRadiation.

Definition at line 290 of file G4ForwardXrayTR.cc.

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

References G4INCL::KinematicsUtils::energy(), fGamma, fSigma1, and fSigma2.

SpectralDensity()

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

Definition at line 362 of file G4ForwardXrayTR.cc.

{
  G4double a, b;
  a = 1.0 / (fGamma * fGamma) + fSigma1 / (energy * energy);
  b = 1.0 / (fGamma * fGamma) + fSigma2 / (energy * energy);
  return ((a + b) * std::log((x + b) / (x + a)) / (a - b) + a / (x + a) +
          b / (x + b)) /
         energy;
}

References G4INCL::KinematicsUtils::energy(), fGamma, fSigma1, and fSigma2.

Referenced by AngleInterval().

StartTracking()

void G4VProcess::StartTracking ( G4Track *  )

virtualinherited

Reimplemented in G4ParallelGeometriesLimiterProcess, G4ImportanceProcess, G4WeightCutOffProcess, G4WeightWindowProcess, G4VITProcess, G4DNASecondOrderReaction, G4WrapperProcess, G4FastSimulationManagerProcess, G4ParallelWorldProcess, G4ParallelWorldScoringProcess, G4ScoreSplittingProcess, G4GammaGeneralProcess, G4Decay, G4AdjointProcessEquivalentToDirectProcess, G4eAdjointMultipleScattering, G4DNAElectronHoleRecombination, G4DNAScavengerProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, G4ITTransportation, G4DNABrownianTransportation, G4CoupledTransportation, G4Transportation, G4BiasingProcessInterface, and G4VPhononProcess.

Definition at line 87 of file G4VProcess.cc.

{
  currentInteractionLength = -1.0;
  theNumberOfInteractionLengthLeft = -1.0;
  theInitialNumberOfInteractionLength = -1.0;
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout << "G4VProcess::StartTracking() - [" << theProcessName << "]"
           << G4endl;
  }
#endif
}

References G4VProcess::currentInteractionLength, G4cout, G4endl, G4VProcess::theInitialNumberOfInteractionLength, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4DNASecondOrderReaction::StartTracking(), G4WrapperProcess::StartTracking(), G4AdjointProcessEquivalentToDirectProcess::StartTracking(), G4DNAElectronHoleRecombination::StartTracking(), G4DNAScavengerProcess::StartTracking(), G4ITTransportation::StartTracking(), G4Transportation::StartTracking(), G4BiasingProcessInterface::StartTracking(), and G4VPhononProcess::StartTracking().

StorePhysicsTable()

virtual G4bool G4VProcess::StorePhysicsTable ( const G4ParticleDefinition *  , const G4String &  , G4bool    )

inlinevirtualinherited

Reimplemented in G4WrapperProcess, G4GammaGeneralProcess, G4AdjointProcessEquivalentToDirectProcess, G4VEmProcess, G4VEnergyLossProcess, G4VMultipleScattering, and G4BiasingProcessInterface.

Definition at line 206 of file G4VProcess.hh.

                                                              { return true; }

Referenced by export_G4VProcess(), G4WrapperProcess::StorePhysicsTable(), G4AdjointProcessEquivalentToDirectProcess::StorePhysicsTable(), and G4BiasingProcessInterface::StorePhysicsTable().

SubtractNumberOfInteractionLengthLeft()

void G4VProcess::SubtractNumberOfInteractionLengthLeft ( G4double  prevStepSize )

inlineprotectedinherited

Definition at line 524 of file G4VProcess.hh.

{
  if (currentInteractionLength>0.0)
  {
    theNumberOfInteractionLengthLeft -= prevStepSize/currentInteractionLength;
    if(theNumberOfInteractionLengthLeft<0.)
    {
       theNumberOfInteractionLengthLeft=CLHEP::perMillion;
    }
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4VProcess::SubtractNumberOfInteractionLengthLeft()";
      G4cerr << " [" << theProcessName << "]" <<G4endl;
      G4cerr << " currentInteractionLength = "
             << currentInteractionLength << " [mm]";
      G4cerr << " previousStepSize = " << prevStepSize << " [mm]";
      G4cerr << G4endl;
    }
#endif
    G4String msg = "Negative currentInteractionLength for ";
    msg += theProcessName;
    G4Exception("G4VProcess::SubtractNumberOfInteractionLengthLeft()",
                "ProcMan201", EventMustBeAborted, msg);
  }
}

References G4VProcess::currentInteractionLength, EventMustBeAborted, G4cerr, G4endl, G4Exception(), CLHEP::perMillion, G4VProcess::theNumberOfInteractionLengthLeft, G4VProcess::theProcessName, and G4VProcess::verboseLevel.

Referenced by G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), and G4Decay::PostStepGetPhysicalInteractionLength().

Field Documentation

aParticleChange

G4ParticleChange G4VProcess::aParticleChange

protectedinherited

Definition at line 327 of file G4VProcess.hh.

Referenced by G4ContinuousGainOfEnergy::AlongStepDoIt(), G4ErrorEnergyLoss::AlongStepDoIt(), G4hImpactIonisation::AlongStepDoIt(), G4DNAMolecularDissociation::DecayIt(), G4OpBoundaryProcess::DoAbsorption(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4VProcess::G4VProcess(), G4PhononDownconversion::MakeLTSecondaries(), G4PhononDownconversion::MakeTTSecondaries(), G4SpecialCuts::PostStepDoIt(), G4Channeling::PostStepDoIt(), G4PhononDownconversion::PostStepDoIt(), G4PhononReflection::PostStepDoIt(), G4PhononScattering::PostStepDoIt(), G4StepLimiter::PostStepDoIt(), G4UserSpecialCuts::PostStepDoIt(), G4TransitionRadiation::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4AnnihiToMuPair::PostStepDoIt(), G4GammaConversionToMuons::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4hImpactIonisation::PostStepDoIt(), G4SynchrotronRadiation::PostStepDoIt(), and G4SynchrotronRadiationInMat::PostStepDoIt().

aProcessManager

const G4ProcessManager* G4VProcess::aProcessManager = nullptr

protectedinherited

Definition at line 319 of file G4VProcess.hh.

Referenced by G4VProcess::GetProcessManager(), and G4VProcess::SetProcessManager().

currentInteractionLength

G4double G4VProcess::currentInteractionLength = -1.0

protectedinherited

Definition at line 335 of file G4VProcess.hh.

Referenced by G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VProcess::EndTracking(), G4Decay::EndTracking(), G4VProcess::GetCurrentInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::StartTracking(), G4Decay::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

enableAlongStepDoIt

G4bool G4VProcess::enableAlongStepDoIt = true

protectedinherited

Definition at line 360 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ITTransportation::G4ITTransportation(), G4NuclearStopping::G4NuclearStopping(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), G4VITRestDiscreteProcess::G4VITRestDiscreteProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestDiscreteProcess::G4VRestDiscreteProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isAlongStepDoItIsEnabled().

enableAtRestDoIt

G4bool G4VProcess::enableAtRestDoIt = true

protectedinherited

Definition at line 359 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4eplusAnnihilation::G4eplusAnnihilation(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VContinuousDiscreteProcess::G4VContinuousDiscreteProcess(), G4VContinuousProcess::G4VContinuousProcess(), G4VDiscreteProcess::G4VDiscreteProcess(), G4VITDiscreteProcess::G4VITDiscreteProcess(), and G4VProcess::isAtRestDoItIsEnabled().

enablePostStepDoIt

G4bool G4VProcess::enablePostStepDoIt = true

protectedinherited

Definition at line 361 of file G4VProcess.hh.

Referenced by G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4HadronStoppingProcess::G4HadronStoppingProcess(), G4ITTransportation::G4ITTransportation(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4NuclearStopping::G4NuclearStopping(), G4VContinuousProcess::G4VContinuousProcess(), G4VITRestProcess::G4VITRestProcess(), G4VRestContinuousProcess::G4VRestContinuousProcess(), G4VRestProcess::G4VRestProcess(), and G4VProcess::isPostStepDoItIsEnabled().

fAngleDistrTable

G4PhysicsTable* G4ForwardXrayTR::fAngleDistrTable

protected

Definition at line 142 of file G4ForwardXrayTR.hh.

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

fBinTR

constexpr G4int G4ForwardXrayTR::fBinTR = 50

staticconstexprprotected

Definition at line 134 of file G4ForwardXrayTR.hh.

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

fCofTR

constexpr G4double G4ForwardXrayTR::fCofTR = CLHEP::fine_structure_const / CLHEP::pi

staticconstexprprotected

Definition at line 130 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fEnergy

G4double G4TransitionRadiation::fEnergy

protectedinherited

Definition at line 98 of file G4TransitionRadiation.hh.

Referenced by G4TransitionRadiation::G4TransitionRadiation().

fEnergyDistrTable

G4PhysicsTable* G4ForwardXrayTR::fEnergyDistrTable

protected

Definition at line 143 of file G4ForwardXrayTR.hh.

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

fGamma

G4double G4ForwardXrayTR::fGamma

protected

Definition at line 150 of file G4ForwardXrayTR.hh.

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

fGammaCutInKineticEnergy

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

protected

Definition at line 137 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), and G4ForwardXrayTR().

fGammaNumber

constexpr G4int G4TransitionRadiation::fGammaNumber = 15

staticconstexprprotectedinherited

Definition at line 94 of file G4TransitionRadiation.hh.

fGammaTkinCut

G4double G4ForwardXrayTR::fGammaTkinCut

protected

Definition at line 151 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), and G4ForwardXrayTR().

fMatIndex1

G4int G4TransitionRadiation::fMatIndex1

protectedinherited

Definition at line 108 of file G4TransitionRadiation.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4TransitionRadiation::G4TransitionRadiation(), and PostStepDoIt().

fMatIndex2

G4int G4TransitionRadiation::fMatIndex2

protectedinherited

Definition at line 109 of file G4TransitionRadiation.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), G4TransitionRadiation::G4TransitionRadiation(), and PostStepDoIt().

fMaxEnergy

G4double G4TransitionRadiation::fMaxEnergy

protectedinherited

Definition at line 102 of file G4TransitionRadiation.hh.

Referenced by G4TransitionRadiation::AngleIntegralDistribution(), and G4TransitionRadiation::G4TransitionRadiation().

fMaxEnergyTR

G4double G4ForwardXrayTR::fMaxEnergyTR

protected

Definition at line 148 of file G4ForwardXrayTR.hh.

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

fMaxProtonTkin

constexpr G4double G4ForwardXrayTR::fMaxProtonTkin

staticconstexprprotected

Initial value:

=
    100. * CLHEP::TeV

Definition at line 124 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and GetMaxProtonTkin().

fMaxTheta

G4double G4TransitionRadiation::fMaxTheta

protectedinherited

Definition at line 103 of file G4TransitionRadiation.hh.

Referenced by G4TransitionRadiation::EnergyIntegralDistribution(), and G4TransitionRadiation::G4TransitionRadiation().

fMaxThetaTR

G4double G4ForwardXrayTR::fMaxThetaTR

protected

Definition at line 149 of file G4ForwardXrayTR.hh.

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

fMinEnergy

G4double G4TransitionRadiation::fMinEnergy

protectedinherited

Definition at line 101 of file G4TransitionRadiation.hh.

Referenced by G4TransitionRadiation::AngleIntegralDistribution(), and G4TransitionRadiation::G4TransitionRadiation().

fMinEnergyTR

G4double G4ForwardXrayTR::fMinEnergyTR

protected

Definition at line 147 of file G4ForwardXrayTR.hh.

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

fMinProtonTkin

constexpr G4double G4ForwardXrayTR::fMinProtonTkin

staticconstexprprotected

Initial value:

=
    100. * CLHEP::GeV

Definition at line 122 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and GetMinProtonTkin().

fPlasmaCof

constexpr G4double G4ForwardXrayTR::fPlasmaCof

staticconstexprprotected

Initial value:

=
    4.0 * CLHEP::pi * CLHEP::fine_structure_const * CLHEP::hbarc *
    CLHEP::hbarc * CLHEP::hbarc /
    CLHEP::electron_mass_c2

Definition at line 126 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fPointNumber

constexpr G4int G4TransitionRadiation::fPointNumber = 100

staticconstexprprotectedinherited

Definition at line 95 of file G4TransitionRadiation.hh.

fProcessTable

G4ProcessTable* G4VProcess::fProcessTable = nullptr

privateinherited

Definition at line 374 of file G4VProcess.hh.

Referenced by G4VProcess::G4VProcess(), and G4VProcess::~G4VProcess().

fProtonEnergyVector

G4PhysicsLogVector* G4ForwardXrayTR::fProtonEnergyVector

protected

Definition at line 145 of file G4ForwardXrayTR.hh.

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

fPtrGamma

G4ParticleDefinition* G4ForwardXrayTR::fPtrGamma

protected

Definition at line 140 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR().

fSigma1

G4double G4ForwardXrayTR::fSigma1

protected

Definition at line 152 of file G4ForwardXrayTR.hh.

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

fSigma2

G4double G4ForwardXrayTR::fSigma2

protected

Definition at line 153 of file G4ForwardXrayTR.hh.

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

fSympsonNumber

constexpr G4int G4ForwardXrayTR::fSympsonNumber

staticconstexprprotected

Initial value:

=
    100

Definition at line 132 of file G4ForwardXrayTR.hh.

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

fTheMaxAngle

constexpr G4double G4ForwardXrayTR::fTheMaxAngle = 1.0e-3

staticconstexprprotected

Definition at line 120 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fTheMaxEnergyTR

constexpr G4double G4ForwardXrayTR::fTheMaxEnergyTR

staticconstexprprotected

Initial value:

=
    100. * CLHEP::keV

Definition at line 118 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fTheMinAngle

constexpr G4double G4ForwardXrayTR::fTheMinAngle = 5.0e-6

staticconstexprprotected

Definition at line 121 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fTheMinEnergyTR

constexpr G4double G4ForwardXrayTR::fTheMinEnergyTR

staticconstexprprotected

Initial value:

=
    1. * CLHEP::keV

Definition at line 116 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables().

fTotBin

constexpr G4int G4ForwardXrayTR::fTotBin = 50

staticconstexprprotected

Definition at line 135 of file G4ForwardXrayTR.hh.

Referenced by BuildXrayTRtables(), G4ForwardXrayTR(), GetEnergyTR(), GetTotBin(), and PostStepDoIt().

fVarAngle

G4double G4TransitionRadiation::fVarAngle

protectedinherited

Definition at line 99 of file G4TransitionRadiation.hh.

Referenced by G4TransitionRadiation::G4TransitionRadiation().

masterProcessShadow

G4VProcess* G4VProcess::masterProcessShadow = nullptr

privateinherited

Definition at line 370 of file G4VProcess.hh.

Referenced by G4VProcess::GetMasterProcess(), and G4VProcess::SetMasterProcess().

pParticleChange

G4VParticleChange* G4VProcess::pParticleChange = nullptr

protectedinherited

Definition at line 321 of file G4VProcess.hh.

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), G4ImportanceProcess::AlongStepDoIt(), G4WeightCutOffProcess::AlongStepDoIt(), G4WeightWindowProcess::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepDoIt(), G4VContinuousProcess::AlongStepDoIt(), G4VRestContinuousDiscreteProcess::AlongStepDoIt(), G4VRestContinuousProcess::AlongStepDoIt(), G4ParallelWorldProcess::AlongStepDoIt(), G4ParallelWorldScoringProcess::AlongStepDoIt(), G4VITRestProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestDoIt(), G4VRestContinuousProcess::AtRestDoIt(), G4VRestDiscreteProcess::AtRestDoIt(), G4VRestProcess::AtRestDoIt(), G4ParallelWorldProcess::AtRestDoIt(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4ScoreSplittingProcess::AtRestDoIt(), G4VITRestDiscreteProcess::AtRestDoIt(), G4eplusAnnihilation::AtRestDoIt(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VEnergyLossProcess::FillSecondariesAlongStep(), G4Decay::G4Decay(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ImportanceProcess::G4ImportanceProcess(), G4ITTransportation::G4ITTransportation(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4RadioactiveDecay::G4RadioactiveDecay(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4Transportation::G4Transportation(), G4UnknownDecay::G4UnknownDecay(), G4VEmProcess::G4VEmProcess(), G4VEnergyLossProcess::G4VEnergyLossProcess(), G4VMultipleScattering::G4VMultipleScattering(), G4VProcess::G4VProcess(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VITDiscreteProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepDoIt(), G4VDiscreteProcess::PostStepDoIt(), G4VRestContinuousDiscreteProcess::PostStepDoIt(), G4VRestDiscreteProcess::PostStepDoIt(), G4ParallelWorldProcess::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4NeutronKiller::PostStepDoIt(), G4VITRestDiscreteProcess::PostStepDoIt(), G4LowECapture::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), and G4VTransitionRadiation::PostStepDoIt().

secID

G4int G4ForwardXrayTR::secID = -1

protected

Definition at line 155 of file G4ForwardXrayTR.hh.

Referenced by G4ForwardXrayTR(), and PostStepDoIt().

theInitialNumberOfInteractionLength

G4double G4VProcess::theInitialNumberOfInteractionLength = -1.0

protectedinherited

Definition at line 338 of file G4VProcess.hh.

Referenced by G4VProcess::ClearNumberOfInteractionLengthLeft(), G4VProcess::EndTracking(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), and G4VProcess::StartTracking().

theNumberOfInteractionLengthLeft

G4double G4VProcess::theNumberOfInteractionLengthLeft = -1.0

protectedinherited

Definition at line 331 of file G4VProcess.hh.

Referenced by G4AdjointForcedInteractionForGamma::AlongStepDoIt(), G4MuonicAtomDecay::AtRestGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4Decay::AtRestGetPhysicalInteractionLength(), G4VProcess::ClearNumberOfInteractionLengthLeft(), G4MuonicAtomDecay::DecayIt(), G4VProcess::EndTracking(), G4VProcess::GetNumberOfInteractionLengthLeft(), G4VProcess::GetTotalNumberOfInteractionLengthTraversed(), G4GammaGeneralProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PostStepGetPhysicalInteractionLength(), G4Decay::PostStepGetPhysicalInteractionLength(), G4AdjointForcedInteractionForGamma::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEmProcess::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4VProcess::ResetNumberOfInteractionLengthLeft(), G4VProcess::StartTracking(), G4GammaGeneralProcess::StartTracking(), G4VEmProcess::StartTracking(), G4VEnergyLossProcess::StartTracking(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

thePhysicsTableFileName

G4String G4VProcess::thePhysicsTableFileName

protectedinherited

Definition at line 344 of file G4VProcess.hh.

Referenced by G4VProcess::GetPhysicsTableFileName().

thePILfactor

G4double G4VProcess::thePILfactor = 1.0

protectedinherited

Definition at line 352 of file G4VProcess.hh.

Referenced by G4VProcess::AtRestGPIL(), G4VProcess::GetPILfactor(), G4VProcess::PostStepGPIL(), and G4VProcess::SetPILfactor().

theProcessName

G4String G4VProcess::theProcessName

protectedinherited

Definition at line 341 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4VProcess::EndTracking(), G4ImportanceProcess::GetName(), G4WeightCutOffProcess::GetName(), G4VProcess::GetPhysicsTableFileName(), G4VProcess::GetProcessName(), G4WrapperProcess::RegisterProcess(), G4VProcess::StartTracking(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

theProcessSubType

G4int G4VProcess::theProcessSubType = -1

protectedinherited

Definition at line 349 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4MuonicAtomDecay::G4MuonicAtomDecay(), G4VProcess::GetProcessSubType(), and G4VProcess::SetProcessSubType().

theProcessType

G4ProcessType G4VProcess::theProcessType = fNotDefined

protectedinherited

Definition at line 346 of file G4VProcess.hh.

Referenced by G4VProcess::DumpInfo(), G4AdjointProcessEquivalentToDirectProcess::G4AdjointProcessEquivalentToDirectProcess(), G4VProcess::GetProcessType(), G4WrapperProcess::RegisterProcess(), and G4VProcess::SetProcessType().

verboseLevel

G4int G4VProcess::verboseLevel = 0

protectedinherited

Definition at line 356 of file G4VProcess.hh.

Referenced by G4VEnergyLossProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateForcedInteraction(), G4VEmProcess::ActivateSecondaryBiasing(), G4VEnergyLossProcess::ActivateSecondaryBiasing(), G4LowECapture::AddRegion(), G4CoupledTransportation::AlongStepDoIt(), G4Transportation::AlongStepDoIt(), G4VContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4ParallelWorldProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::AlongStepGetPhysicalInteractionLength(), G4VRestContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4CoupledTransportation::AlongStepGetPhysicalInteractionLength(), G4Transportation::AlongStepGetPhysicalInteractionLength(), G4VContinuousProcess::AlongStepGetPhysicalInteractionLength(), G4hImpactIonisation::AntiProtonParametrisedDEDX(), G4ParallelWorldScoringProcess::AtRestDoIt(), G4VRestContinuousDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VRestContinuousProcess::AtRestGetPhysicalInteractionLength(), G4VRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::AtRestGetPhysicalInteractionLength(), G4VITRestProcess::AtRestGetPhysicalInteractionLength(), G4VRestProcess::AtRestGetPhysicalInteractionLength(), G4VXTRenergyLoss::BuildAngleForEnergyBank(), G4VXTRenergyLoss::BuildAngleTable(), G4VEnergyLossProcess::BuildDEDXTable(), G4VXTRenergyLoss::BuildEnergyTable(), G4VXTRenergyLoss::BuildGlobalAngleTable(), G4VEmProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLambdaTable(), G4VEnergyLossProcess::BuildLambdaTable(), G4hImpactIonisation::BuildLossTable(), G4DNABrownianTransportation::BuildPhysicsTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4LowECapture::BuildPhysicsTable(), G4VEmProcess::BuildPhysicsTable(), G4VEnergyLossProcess::BuildPhysicsTable(), G4VMultipleScattering::BuildPhysicsTable(), G4SynchrotronRadiation::BuildPhysicsTable(), G4VXTRenergyLoss::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4ChargeExchangeProcess::BuildPhysicsTable(), G4OpRayleigh::CalculateRayleighMeanFreePaths(), G4PolarizedAnnihilation::ComputeSaturationFactor(), G4PolarizedCompton::ComputeSaturationFactor(), G4PolarizedIonisation::ComputeSaturationFactor(), G4DNAElectronHoleRecombination::Create(), G4DNASecondOrderReaction::Create(), G4VPhononProcess::CreateSecondary(), G4VProcess::EndTracking(), G4VEmProcess::FindLambdaMax(), G4Cerenkov::G4Cerenkov(), G4ChargeExchangeProcess::G4ChargeExchangeProcess(), G4CoupledTransportation::G4CoupledTransportation(), G4DNAMolecularDissociation::G4DNAMolecularDissociation(), G4DNAScavengerProcess::G4DNAScavengerProcess(), G4ErrorEnergyLoss::G4ErrorEnergyLoss(), G4FastSimulationManagerProcess::G4FastSimulationManagerProcess(), G4GaussXTRadiator::G4GaussXTRadiator(), G4ImportanceProcess::G4ImportanceProcess(), G4MaxTimeCuts::G4MaxTimeCuts(), G4MicroElecSurface::G4MicroElecSurface(), G4MinEkineCuts::G4MinEkineCuts(), G4OpAbsorption::G4OpAbsorption(), G4OpBoundaryProcess::G4OpBoundaryProcess(), G4OpMieHG::G4OpMieHG(), G4OpRayleigh::G4OpRayleigh(), G4OpWLS::G4OpWLS(), G4OpWLS2::G4OpWLS2(), G4ParallelWorldProcess::G4ParallelWorldProcess(), G4ParallelWorldScoringProcess::G4ParallelWorldScoringProcess(), G4PolarizedIonisation::G4PolarizedIonisation(), G4Scintillation::G4Scintillation(), G4ScoreSplittingProcess::G4ScoreSplittingProcess(), G4SpecialCuts::G4SpecialCuts(), G4StepLimiter::G4StepLimiter(), G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(), G4SynchrotronRadiation::G4SynchrotronRadiation(), G4TransparentRegXTRadiator::G4TransparentRegXTRadiator(), G4Transportation::G4Transportation(), G4UCNAbsorption::G4UCNAbsorption(), G4UCNBoundaryProcess::G4UCNBoundaryProcess(), G4UCNLoss::G4UCNLoss(), G4UCNMultiScattering::G4UCNMultiScattering(), G4UserSpecialCuts::G4UserSpecialCuts(), G4VXTRenergyLoss::G4VXTRenergyLoss(), G4WeightCutOffProcess::G4WeightCutOffProcess(), G4WeightWindowProcess::G4WeightWindowProcess(), G4VXTRenergyLoss::GetAngleVector(), G4ChargeExchangeProcess::GetElementCrossSection(), G4VXTRenergyLoss::GetGasZmuProduct(), G4PhononDownconversion::GetMeanFreePath(), G4PhononScattering::GetMeanFreePath(), G4PolarizedCompton::GetMeanFreePath(), G4VXTRenergyLoss::GetMeanFreePath(), G4UCNAbsorption::GetMeanFreePath(), G4PolarizedAnnihilation::GetMeanFreePath(), G4PolarizedIonisation::GetMeanFreePath(), G4SynchrotronRadiation::GetMeanFreePath(), G4VXTRenergyLoss::GetNumberOfPhotons(), G4VXTRenergyLoss::GetPlateZmuProduct(), G4SynchrotronRadiation::GetRandomEnergySR(), G4VProcess::GetVerboseLevel(), G4hhIonisation::InitialiseEnergyLossProcess(), G4eeToHadrons::InitialiseProcess(), G4hImpactIonisation::InitializeMe(), G4UCNBoundaryProcess::MRreflect(), G4UCNBoundaryProcess::MRreflectHigh(), G4DNASecondOrderReaction::PostStepDoIt(), G4ParallelWorldScoringProcess::PostStepDoIt(), G4ScoreSplittingProcess::PostStepDoIt(), G4DNAScavengerProcess::PostStepDoIt(), G4VEmProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4UCNAbsorption::PostStepDoIt(), G4UCNBoundaryProcess::PostStepDoIt(), G4UCNLoss::PostStepDoIt(), G4UCNMultiScattering::PostStepDoIt(), G4MicroElecSurface::PostStepDoIt(), G4Cerenkov::PostStepDoIt(), G4Scintillation::PostStepDoIt(), G4VXTRenergyLoss::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4OpAbsorption::PostStepDoIt(), G4OpBoundaryProcess::PostStepDoIt(), G4OpMieHG::PostStepDoIt(), G4OpRayleigh::PostStepDoIt(), G4OpWLS::PostStepDoIt(), G4OpWLS2::PostStepDoIt(), G4CoupledTransportation::PostStepDoIt(), G4VITDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNASecondOrderReaction::PostStepGetPhysicalInteractionLength(), G4VContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestContinuousDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4VITRestDiscreteProcess::PostStepGetPhysicalInteractionLength(), G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength(), G4PolarizedAnnihilation::PostStepGetPhysicalInteractionLength(), G4PolarizedCompton::PostStepGetPhysicalInteractionLength(), G4PolarizedIonisation::PostStepGetPhysicalInteractionLength(), G4VEnergyLossProcess::PostStepGetPhysicalInteractionLength(), G4GammaGeneralProcess::PreparePhysicsTable(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4hImpactIonisation::ProtonParametrisedDEDX(), G4UCNBoundaryProcess::Reflect(), G4CoupledTransportation::ReportInexactEnergy(), G4CoupledTransportation::ReportMissingLogger(), G4GammaGeneralProcess::RetrievePhysicsTable(), G4VEmProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrievePhysicsTable(), G4VEnergyLossProcess::RetrieveTable(), G4VEmProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCrossSectionBiasingFactor(), G4VEnergyLossProcess::SetCSDARangeTable(), G4CoupledTransportation::SetHighLooperThresholds(), G4Transportation::SetHighLooperThresholds(), G4VEnergyLossProcess::SetInverseRangeTable(), G4LowECapture::SetKinEnergyLimit(), G4NeutronKiller::SetKinEnergyLimit(), G4VEnergyLossProcess::SetLambdaTable(), G4CoupledTransportation::SetLowLooperThresholds(), G4Transportation::SetLowLooperThresholds(), G4VEnergyLossProcess::SetRangeTableForLoss(), G4VEnergyLossProcess::SetSecondaryRangeTable(), G4NeutronKiller::SetTimeLimit(), G4VProcess::SetVerboseLevel(), G4Cerenkov::SetVerboseLevel(), G4Scintillation::SetVerboseLevel(), G4OpAbsorption::SetVerboseLevel(), G4OpBoundaryProcess::SetVerboseLevel(), G4OpMieHG::SetVerboseLevel(), G4OpRayleigh::SetVerboseLevel(), G4OpWLS::SetVerboseLevel(), G4OpWLS2::SetVerboseLevel(), G4FastSimulationManagerProcess::SetWorldVolume(), G4GaussXTRadiator::SpectralXTRdEdx(), G4RegularXTRadiator::SpectralXTRdEdx(), G4TransparentRegXTRadiator::SpectralXTRdEdx(), G4XTRRegularRadModel::SpectralXTRdEdx(), G4VProcess::StartTracking(), G4CoupledTransportation::StartTracking(), G4VEmProcess::StorePhysicsTable(), G4VMultipleScattering::StorePhysicsTable(), G4VEnergyLossProcess::StoreTable(), G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), G4VMultipleScattering::StreamInfo(), G4VITProcess::SubtractNumberOfInteractionLengthLeft(), and G4VProcess::SubtractNumberOfInteractionLengthLeft().

---

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

• source/processes/electromagnetic/xrays/include/G4ForwardXrayTR.hh
• source/processes/electromagnetic/xrays/src/G4ForwardXrayTR.cc