G4hImpactIonisation Class Reference

#include <G4hImpactIonisation.hh>

Inheritance diagram for G4hImpactIonisation:

Collaboration diagram for G4hImpactIonisation:

Public Member Functions
	G4hImpactIonisation (const G4String &processName="hImpactIoni")
	~G4hImpactIonisation ()
G4bool	IsApplicable (const G4ParticleDefinition &)
void	BuildPhysicsTable (const G4ParticleDefinition &aParticleType)
G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, enum G4ForceCondition *condition)
void	PrintInfoDefinition () const
void	SetHighEnergyForProtonParametrisation (G4double energy)
void	SetLowEnergyForProtonParametrisation (G4double energy)
void	SetHighEnergyForAntiProtonParametrisation (G4double energy)
void	SetLowEnergyForAntiProtonParametrisation (G4double energy)
G4double	GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)
void	SetElectronicStoppingPowerModel (const G4ParticleDefinition *aParticle, const G4String &dedxTable)
void	SetNuclearStoppingPowerModel (const G4String &dedxTable)
void	SetNuclearStoppingOn ()
void	SetNuclearStoppingOff ()
void	SetBarkasOn ()
void	SetBarkasOff ()
void	SetPixe (const G4bool)
G4VParticleChange *	AlongStepDoIt (const G4Track &trackData, const G4Step &stepData)
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &Step)
G4double	ComputeDEDX (const G4ParticleDefinition *aParticle, const G4MaterialCutsCouple *couple, G4double kineticEnergy)
void	SetCutForSecondaryPhotons (G4double cut)
void	SetCutForAugerElectrons (G4double cut)
void	ActivateAugerElectronProduction (G4bool val)
void	SetPixeCrossSectionK (const G4String &name)
void	SetPixeCrossSectionL (const G4String &name)
void	SetPixeCrossSectionM (const G4String &name)
void	SetPixeProjectileMinEnergy (G4double energy)
void	SetPixeProjectileMaxEnergy (G4double energy)
Public Member Functions inherited from G4hRDEnergyLoss
	G4hRDEnergyLoss (const G4String &)
	~G4hRDEnergyLoss ()
Public Member Functions inherited from G4VContinuousDiscreteProcess
	G4VContinuousDiscreteProcess (const G4String &, G4ProcessType aType=fNotDefined)
	G4VContinuousDiscreteProcess (G4VContinuousDiscreteProcess &)
virtual	~G4VContinuousDiscreteProcess ()
virtual G4double	PostStepGetPhysicalInteractionLength (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual G4double	AlongStepGetPhysicalInteractionLength (const G4Track &, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety, G4GPILSelection *selection)
virtual G4double	AtRestGetPhysicalInteractionLength (const G4Track &, G4ForceCondition *)
virtual G4VParticleChange *	AtRestDoIt (const G4Track &, const G4Step &)
Public Member Functions inherited from G4VProcess
	G4VProcess (const G4String &aName="NoName", G4ProcessType aType=fNotDefined)
	G4VProcess (const G4VProcess &right)
virtual	~G4VProcess ()
G4int	operator== (const G4VProcess &right) const
G4int	operator!= (const G4VProcess &right) const
G4double	GetCurrentInteractionLength () const
void	SetPILfactor (G4double value)
G4double	GetPILfactor () const
G4double	AlongStepGPIL (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &proposedSafety, G4GPILSelection *selection)
G4double	AtRestGPIL (const G4Track &track, G4ForceCondition *condition)
G4double	PostStepGPIL (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual void	PreparePhysicsTable (const G4ParticleDefinition &)
virtual G4bool	StorePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
virtual G4bool	RetrievePhysicsTable (const G4ParticleDefinition *, const G4String &, G4bool)
const G4String &	GetPhysicsTableFileName (const G4ParticleDefinition *, const G4String &directory, const G4String &tableName, G4bool ascii=false)
const G4String &	GetProcessName () const
G4ProcessType	GetProcessType () const
void	SetProcessType (G4ProcessType)
G4int	GetProcessSubType () const
void	SetProcessSubType (G4int)
virtual void	StartTracking (G4Track *)
virtual void	EndTracking ()
virtual void	SetProcessManager (const G4ProcessManager *)
virtual const G4ProcessManager *	GetProcessManager ()
virtual void	ResetNumberOfInteractionLengthLeft ()
G4double	GetNumberOfInteractionLengthLeft () const
G4double	GetTotalNumberOfInteractionLengthTraversed () const
G4bool	isAtRestDoItIsEnabled () const
G4bool	isAlongStepDoItIsEnabled () const
G4bool	isPostStepDoItIsEnabled () const
virtual void	DumpInfo () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
virtual void	SetMasterProcess (G4VProcess *masterP)
const G4VProcess *	GetMasterProcess () const
virtual void	BuildWorkerPhysicsTable (const G4ParticleDefinition &part)
virtual void	PrepareWorkerPhysicsTable (const G4ParticleDefinition &)

Private Member Functions
void	InitializeMe ()
void	InitializeParametrisation ()
void	BuildLossTable (const G4ParticleDefinition &aParticleType)
void	BuildLambdaTable (const G4ParticleDefinition &aParticleType)
void	SetProtonElectronicStoppingPowerModel (const G4String &dedxTable)
void	SetAntiProtonElectronicStoppingPowerModel (const G4String &dedxTable)
G4double	MicroscopicCrossSection (const G4ParticleDefinition &aParticleType, G4double kineticEnergy, G4double atomicNumber, G4double deltaCutInEnergy) const
G4double	GetConstraints (const G4DynamicParticle *particle, const G4MaterialCutsCouple *couple)
G4double	ProtonParametrisedDEDX (const G4MaterialCutsCouple *couple, G4double kineticEnergy) const
G4double	AntiProtonParametrisedDEDX (const G4MaterialCutsCouple *couple, G4double kineticEnergy) const
G4double	DeltaRaysEnergy (const G4MaterialCutsCouple *couple, G4double kineticEnergy, G4double particleMass) const
G4double	BarkasTerm (const G4Material *material, G4double kineticEnergy) const
G4double	BlochTerm (const G4Material *material, G4double kineticEnergy, G4double cSquare) const
G4double	ElectronicLossFluctuation (const G4DynamicParticle *particle, const G4MaterialCutsCouple *material, G4double meanLoss, G4double step) const
G4hImpactIonisation &	operator= (const G4hImpactIonisation &right)
	G4hImpactIonisation (const G4hImpactIonisation &)

Private Attributes
G4VLowEnergyModel *	betheBlochModel
G4VLowEnergyModel *	protonModel
G4VLowEnergyModel *	antiprotonModel
G4VLowEnergyModel *	theIonEffChargeModel
G4VLowEnergyModel *	theNuclearStoppingModel
G4VLowEnergyModel *	theIonChuFluctuationModel
G4VLowEnergyModel *	theIonYangFluctuationModel
G4String	protonTable
G4String	antiprotonTable
G4String	theNuclearTable
G4double	protonLowEnergy
G4double	protonHighEnergy
G4double	antiprotonLowEnergy
G4double	antiprotonHighEnergy
G4bool	nStopping
G4bool	theBarkas
G4DataVector	cutForDelta
G4DataVector	cutForGamma
G4double	minGammaEnergy
G4double	minElectronEnergy
G4PhysicsTable *	theMeanFreePathTable
const G4double	paramStepLimit
G4double	fdEdx
G4double	fRangeNow
G4double	charge
G4double	chargeSquare
G4double	initialMass
G4double	fBarkas
G4PixeCrossSectionHandler *	pixeCrossSectionHandler
G4AtomicDeexcitation	atomicDeexcitation
G4String	modelK
G4String	modelL
G4String	modelM
G4double	eMinPixe
G4double	eMaxPixe
G4bool	pixeIsActive

Additional Inherited Members
Static Public Member Functions inherited from G4hRDEnergyLoss
static G4int	GetNumberOfProcesses ()
static void	SetNumberOfProcesses (G4int number)
static void	PlusNumberOfProcesses ()
static void	MinusNumberOfProcesses ()
static void	SetdRoverRange (G4double value)
static void	SetRndmStep (G4bool value)
static void	SetEnlossFluc (G4bool value)
static void	SetStepFunction (G4double c1, G4double c2)
Static Public Member Functions inherited from G4VProcess
static const G4String &	GetProcessTypeName (G4ProcessType)
Protected Member Functions inherited from G4hRDEnergyLoss
G4bool	CutsWhereModified ()
Protected Member Functions inherited from G4VContinuousDiscreteProcess
void	SetGPILSelection (G4GPILSelection selection)
G4GPILSelection	GetGPILSelection () const
Protected Member Functions inherited from G4VProcess
void	SubtractNumberOfInteractionLengthLeft (G4double previousStepSize)
void	ClearNumberOfInteractionLengthLeft ()
Static Protected Member Functions inherited from G4hRDEnergyLoss
static void	BuildDEDXTable (const G4ParticleDefinition &aParticleType)
Protected Attributes inherited from G4hRDEnergyLoss
const G4double	MaxExcitationNumber
const G4double	probLimFluct
const long	nmaxDirectFluct
const long	nmaxCont1
const long	nmaxCont2
G4PhysicsTable *	theLossTable
G4double	linLossLimit
G4double	MinKineticEnergy
Protected Attributes inherited from G4VProcess
const G4ProcessManager *	aProcessManager
G4VParticleChange *	pParticleChange
G4ParticleChange	aParticleChange
G4double	theNumberOfInteractionLengthLeft
G4double	currentInteractionLength
G4double	theInitialNumberOfInteractionLength
G4String	theProcessName
G4String	thePhysicsTableFileName
G4ProcessType	theProcessType
G4int	theProcessSubType
G4double	thePILfactor
G4bool	enableAtRestDoIt
G4bool	enableAlongStepDoIt
G4bool	enablePostStepDoIt
G4int	verboseLevel
Static Protected Attributes inherited from G4hRDEnergyLoss
static G4ThreadLocal G4PhysicsTable *	theDEDXpTable = 0
static G4ThreadLocal G4PhysicsTable *	theDEDXpbarTable = 0
static G4ThreadLocal G4PhysicsTable *	theRangepTable = 0
static G4ThreadLocal G4PhysicsTable *	theRangepbarTable = 0
static G4ThreadLocal G4PhysicsTable *	theInverseRangepTable = 0
static G4ThreadLocal G4PhysicsTable *	theInverseRangepbarTable = 0
static G4ThreadLocal G4PhysicsTable *	theLabTimepTable = 0
static G4ThreadLocal G4PhysicsTable *	theLabTimepbarTable = 0
static G4ThreadLocal G4PhysicsTable *	theProperTimepTable = 0
static G4ThreadLocal G4PhysicsTable *	theProperTimepbarTable = 0
static G4ThreadLocal G4PhysicsTable **	RecorderOfpProcess = 0
static G4ThreadLocal G4PhysicsTable **	RecorderOfpbarProcess = 0
static G4ThreadLocal G4int	CounterOfpProcess = 0
static G4ThreadLocal G4int	CounterOfpbarProcess = 0
static G4ThreadLocal G4double	ParticleMass
static G4ThreadLocal G4double	ptableElectronCutInRange = 0.0
static G4ThreadLocal G4double	pbartableElectronCutInRange = 0.0
static G4ThreadLocal G4double	Charge
static G4ThreadLocal G4double	LowestKineticEnergy = 1e-05
static G4ThreadLocal G4double	HighestKineticEnergy = 1.e5
static G4ThreadLocal G4int	TotBin = 360
static G4ThreadLocal G4double	RTable
static G4ThreadLocal G4double	LOGRTable
static G4ThreadLocal G4double	dRoverRange = 0.20
static G4ThreadLocal G4double	finalRange = 0.2
static G4ThreadLocal G4double	c1lim = 0.20
static G4ThreadLocal G4double	c2lim = 0.32
static G4ThreadLocal G4double	c3lim = -0.032
static G4ThreadLocal G4bool	rndmStepFlag = false
static G4ThreadLocal G4bool	EnlossFlucFlag = true

Detailed Description

Definition at line 75 of file G4hImpactIonisation.hh.

Constructor & Destructor Documentation

G4hImpactIonisation() [1/2]

G4hImpactIonisation::G4hImpactIonisation

(

const G4String &

processName = "hImpactIoni"

)

Definition at line 83 of file G4hImpactIonisation.cc.

  : G4hRDEnergyLoss(processName),
    betheBlochModel(0),
    protonModel(0),
    antiprotonModel(0),
    theIonEffChargeModel(0),
    theNuclearStoppingModel(0),
    theIonChuFluctuationModel(0),
    theIonYangFluctuationModel(0),
    protonTable("ICRU_R49p"),
    antiprotonTable("ICRU_R49p"),
    theNuclearTable("ICRU_R49"),
    nStopping(true),
    theBarkas(true),
    theMeanFreePathTable(0),
    paramStepLimit (0.005),
    pixeCrossSectionHandler(0)
{ 
  InitializeMe();
}

Here is the call graph for this function:

Here is the caller graph for this function:

~G4hImpactIonisation()

G4hImpactIonisation::~G4hImpactIonisation

(

)

Definition at line 132 of file G4hImpactIonisation.cc.

{
  if (theMeanFreePathTable) 
    {
      theMeanFreePathTable->clearAndDestroy();
      delete theMeanFreePathTable;
    }

  if (betheBlochModel) delete betheBlochModel;
  if (protonModel) delete protonModel;
  if (antiprotonModel) delete antiprotonModel;
  if (theNuclearStoppingModel) delete theNuclearStoppingModel;
  if (theIonEffChargeModel) delete theIonEffChargeModel;
  if (theIonChuFluctuationModel) delete theIonChuFluctuationModel;
  if (theIonYangFluctuationModel) delete theIonYangFluctuationModel;

  delete pixeCrossSectionHandler;

  // ---- MGP ---- The following is to be checked
  //  if (shellVacancy) delete shellVacancy;

  cutForDelta.clear();
}

Here is the call graph for this function:

G4hImpactIonisation() [2/2]

G4hImpactIonisation::G4hImpactIonisation ( const G4hImpactIonisation &  )

private

Member Function Documentation

ActivateAugerElectronProduction()

void G4hImpactIonisation::ActivateAugerElectronProduction

(

G4bool

val

)

Definition at line 1707 of file G4hImpactIonisation.cc.

{
  atomicDeexcitation.ActivateAugerElectronProduction(val);
}

Here is the call graph for this function:

Here is the caller graph for this function:

AlongStepDoIt()

G4VParticleChange * G4hImpactIonisation::AlongStepDoIt ( const G4Track &  trackData, const G4Step &  stepData  )

virtual

Reimplemented from G4VContinuousDiscreteProcess.

Definition at line 718 of file G4hImpactIonisation.cc.

{
  // compute the energy loss after a step
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double finalT = 0.;

  aParticleChange.Initialize(track) ;

  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  const G4Material* material = couple->GetMaterial();

  // get the actual (true) Step length from step
  const G4double stepLength = step.GetStepLength() ;

  const G4DynamicParticle* particle = track.GetDynamicParticle() ;

  G4double kineticEnergy = particle->GetKineticEnergy() ;
  G4double massRatio = proton_mass_c2/(particle->GetMass()) ;
  G4double tScaled = kineticEnergy * massRatio ;
  G4double eLoss = 0.0 ;
  G4double nLoss = 0.0 ;


  // very small particle energy
  if (kineticEnergy < MinKineticEnergy) 
    {
      eLoss = kineticEnergy ;
      // particle energy outside tabulated energy range
    } 
  
  else if( kineticEnergy > HighestKineticEnergy) 
    {
      eLoss = stepLength * fdEdx ;
      // big step
    } 
  else if (stepLength >= fRangeNow ) 
    {
      eLoss = kineticEnergy ;
      
      // tabulated range
    } 
  else 
    {
      // step longer than linear step limit
      if(stepLength > linLossLimit * fRangeNow) 
    {
      G4double rScaled = fRangeNow * massRatio * chargeSquare ;
      G4double sScaled = stepLength * massRatio * chargeSquare ;
      
      if(charge > 0.0) 
        {
          eLoss = G4EnergyLossTables::GetPreciseEnergyFromRange(proton,rScaled, couple) -
        G4EnergyLossTables::GetPreciseEnergyFromRange(proton,rScaled-sScaled,couple) ;
        
        } 
      else 
        {
          // Antiproton
          eLoss = G4EnergyLossTables::GetPreciseEnergyFromRange(antiproton,rScaled,couple) -
        G4EnergyLossTables::GetPreciseEnergyFromRange(antiproton,rScaled-sScaled,couple) ;
        }
      eLoss /= massRatio ;
      
      // Barkas correction at big step      
      eLoss += fBarkas * stepLength;
      
      // step shorter than linear step limit
    } 
      else 
    {
      eLoss = stepLength *fdEdx  ;
    }
      if (nStopping && tScaled < protonHighEnergy) 
    {
      nLoss = (theNuclearStoppingModel->TheValue(particle, material)) * stepLength;
    }
    }
  
  if (eLoss < 0.0) eLoss = 0.0;

  finalT = kineticEnergy - eLoss - nLoss;

  if ( EnlossFlucFlag && 0.0 < eLoss && finalT > MinKineticEnergy) 
    {
      
      //  now the electron loss with fluctuation
      eLoss = ElectronicLossFluctuation(particle, couple, eLoss, stepLength) ;
      if (eLoss < 0.0) eLoss = 0.0;
      finalT = kineticEnergy - eLoss - nLoss;
    }

  //  stop particle if the kinetic energy <= MinKineticEnergy
  if (finalT*massRatio <= MinKineticEnergy ) 
    {
      
      finalT = 0.0;
      if (!particle->GetDefinition()->GetProcessManager()->GetAtRestProcessVector()->size())
        aParticleChange.ProposeTrackStatus(fStopAndKill);
      else
        aParticleChange.ProposeTrackStatus(fStopButAlive);
    }

  aParticleChange.ProposeEnergy( finalT );
  eLoss = kineticEnergy-finalT;

  aParticleChange.ProposeLocalEnergyDeposit(eLoss);
  return &aParticleChange ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AntiProtonParametrisedDEDX()

G4double G4hImpactIonisation::AntiProtonParametrisedDEDX ( const G4MaterialCutsCouple *  couple, G4double  kineticEnergy  ) const

private

Definition at line 867 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double eLoss = 0.0 ;

  // Antiproton model is used
  if(antiprotonModel->IsInCharge(antiproton,material)) {
    if(kineticEnergy < antiprotonLowEnergy) {
      eLoss = antiprotonModel->TheValue(antiproton,material,antiprotonLowEnergy)
    * std::sqrt(kineticEnergy/antiprotonLowEnergy) ;

      // Parametrisation
    } else {
      eLoss = antiprotonModel->TheValue(antiproton,material,
                    kineticEnergy);
    }

    // The proton model is used + Barkas correction
  } else {
    if(kineticEnergy < protonLowEnergy) {
      eLoss = protonModel->TheValue(G4Proton::Proton(),material,protonLowEnergy)
    * std::sqrt(kineticEnergy/protonLowEnergy) ;

      // Parametrisation
    } else {
      eLoss = protonModel->TheValue(G4Proton::Proton(),material,
                    kineticEnergy);
    }
    //if(theBarkas) eLoss -= 2.0*BarkasTerm(material, kineticEnergy);
  }

  // Delta rays energy
  eLoss -= DeltaRaysEnergy(couple,kineticEnergy,proton_mass_c2) ;

  if(verboseLevel > 2) {
    G4cout << "pbar E(MeV)= " << kineticEnergy/MeV
           << " dE/dx(MeV/mm)= " << eLoss*mm/MeV
           << " for " << material->GetName()
           << " model: " << protonModel << G4endl;
  }

  if(eLoss < 0.0) eLoss = 0.0 ;

  return eLoss ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BarkasTerm()

G4double G4hImpactIonisation::BarkasTerm ( const G4Material *  material, G4double  kineticEnergy  ) const

private

Definition at line 1306 of file G4hImpactIonisation.cc.

{
  static G4ThreadLocal G4double FTable[47][2] = {
    { 0.02, 21.5},
    { 0.03, 20.0},
    { 0.04, 18.0},
    { 0.05, 15.6},
    { 0.06, 15.0},
    { 0.07, 14.0},
    { 0.08, 13.5},
    { 0.09, 13.},
    { 0.1,  12.2},
    { 0.2,  9.25},
    { 0.3,  7.0},
    { 0.4,  6.0},
    { 0.5,  4.5},
    { 0.6,  3.5},
    { 0.7,  3.0},
    { 0.8,  2.5},
    { 0.9,  2.0},
    { 1.0,  1.7},
    { 1.2,  1.2},
    { 1.3,  1.0},
    { 1.4,  0.86},
    { 1.5,  0.7},
    { 1.6,  0.61},
    { 1.7,  0.52},
    { 1.8,  0.5},
    { 1.9,  0.43},
    { 2.0,  0.42},
    { 2.1,  0.3},
    { 2.4,  0.2},
    { 3.0,  0.13},
    { 3.08, 0.1},
    { 3.1,  0.09},
    { 3.3,  0.08},
    { 3.5,  0.07},
    { 3.8,  0.06},
    { 4.0,  0.051},
    { 4.1,  0.04},
    { 4.8,  0.03},
    { 5.0,  0.024},
    { 5.1,  0.02},
    { 6.0,  0.013},
    { 6.5,  0.01},
    { 7.0,  0.009},
    { 7.1,  0.008},
    { 8.0,  0.006},
    { 9.0,  0.0032},
    { 10.0, 0.0025} };

  // Information on particle and material
  G4double kinE  = kineticEnergy ;
  if(0.5*MeV > kinE) kinE = 0.5*MeV ;
  G4double gamma = 1.0 + kinE / proton_mass_c2 ;
  G4double beta2 = 1.0 - 1.0/(gamma*gamma) ;
  if(0.0 >= beta2) return 0.0;

  G4double BTerm = 0.0;
  //G4double AMaterial = 0.0;
  G4double ZMaterial = 0.0;
  const G4ElementVector* theElementVector = material->GetElementVector();
  G4int numberOfElements = material->GetNumberOfElements();

  for (G4int i = 0; i<numberOfElements; i++) {

    //AMaterial = (*theElementVector)[i]->GetA()*mole/g;
    ZMaterial = (*theElementVector)[i]->GetZ();

    G4double X = 137.0 * 137.0 * beta2 / ZMaterial;

    // Variables to compute L_1
    G4double Eta0Chi = 0.8;
    G4double EtaChi = Eta0Chi * ( 1.0 + 6.02*std::pow( ZMaterial,-1.19 ) );
    G4double W = ( EtaChi * std::pow( ZMaterial,1.0/6.0 ) ) / std::sqrt(X);
    G4double FunctionOfW = FTable[46][1]*FTable[46][0]/W ;

    for(G4int j=0; j<47; j++) {

      if( W < FTable[j][0] ) {

        if(0 == j) {
          FunctionOfW = FTable[0][1] ;

        } else {
          FunctionOfW = (FTable[j][1] - FTable[j-1][1]) * (W - FTable[j-1][0])
        / (FTable[j][0] - FTable[j-1][0])
        +  FTable[j-1][1] ;
    }

        break;
      }

    }

    BTerm += FunctionOfW /( std::sqrt(ZMaterial * X) * X);
  }

  BTerm *= twopi_mc2_rcl2 * (material->GetElectronDensity()) / beta2 ;

  return BTerm;
}

Here is the caller graph for this function:

BlochTerm()

G4double G4hImpactIonisation::BlochTerm ( const G4Material *  material, G4double  kineticEnergy, G4double  cSquare  ) const

private

Definition at line 1418 of file G4hImpactIonisation.cc.

{
  G4double eLoss = 0.0 ;
  G4double gamma = 1.0 + kineticEnergy / proton_mass_c2 ;
  G4double beta2 = 1.0 - 1.0/(gamma*gamma) ;
  G4double y = cSquare / (137.0*137.0*beta2) ;

  if(y < 0.05) {
    eLoss = 1.202 ;

  } else {
    eLoss = 1.0 / (1.0 + y) ;
    G4double de = eLoss ;

    for(G4int i=2; de>eLoss*0.01; i++) {
      de = 1.0/( i * (i*i + y)) ;
      eLoss += de ;
    }
  }
  eLoss *= -1.0 * y * cSquare * twopi_mc2_rcl2 *
    (material->GetElectronDensity()) / beta2 ;

  return eLoss;
}

Here is the caller graph for this function:

BuildLambdaTable()

void G4hImpactIonisation::BuildLambdaTable ( const G4ParticleDefinition &  aParticleType )

private

Definition at line 446 of file G4hImpactIonisation.cc.

{
  // Build mean free path tables for the delta ray production process
  //     tables are built for MATERIALS

  if(verboseLevel > 1) {
    G4cout << "G4hImpactIonisation::BuildLambdaTable for "
           << particleDef.GetParticleName() << " is started" << G4endl;
  }


  G4double lowEdgeEnergy, value;
  charge = particleDef.GetPDGCharge()/eplus ;
  chargeSquare = charge*charge ;
  initialMass = particleDef.GetPDGMass();

  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();


  if (theMeanFreePathTable) {
    theMeanFreePathTable->clearAndDestroy();
    delete theMeanFreePathTable;
  }

  theMeanFreePathTable = new G4PhysicsTable(numOfCouples);

  // loop for materials

  for (size_t j=0 ; j < numOfCouples; j++) {

    //create physics vector then fill it ....
    G4PhysicsLogVector* aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                                                         HighestKineticEnergy,
                                                         TotBin);

    // compute the (macroscopic) cross section first
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();

    const G4ElementVector* theElementVector =  material->GetElementVector() ;
    const G4double* theAtomicNumDensityVector = material->GetAtomicNumDensityVector();
    const G4int numberOfElements = material->GetNumberOfElements() ;

    // get the electron kinetic energy cut for the actual material,
    //  it will be used in ComputeMicroscopicCrossSection
    // ( it is the SAME for ALL the ELEMENTS in THIS MATERIAL )
    //   ------------------------------------------------------

    G4double deltaCut = cutForDelta[j];

    for ( G4int i = 0 ; i < TotBin ; i++ ) {
      lowEdgeEnergy = aVector->GetLowEdgeEnergy(i) ;
      G4double sigma = 0.0 ;
      G4int Z;
      
      for (G4int iel=0; iel<numberOfElements; iel++ ) 
    {
      Z = (G4int) (*theElementVector)[iel]->GetZ();
      // ---- MGP --- Corrected duplicated cross section calculation here from
      // G4hLowEnergyIonisation original
      G4double microCross = MicroscopicCrossSection( particleDef,
                             lowEdgeEnergy,
                             Z,
                             deltaCut ) ;   
      //totalCrossSectionMap [Z] = microCross;
      sigma += theAtomicNumDensityVector[iel] * microCross ; 
    }

      // mean free path = 1./macroscopic cross section

      value = sigma<=0 ? DBL_MAX : 1./sigma ;

      aVector->PutValue(i, value) ;
    }

    theMeanFreePathTable->insert(aVector);
  }

}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildLossTable()

void G4hImpactIonisation::BuildLossTable ( const G4ParticleDefinition &  aParticleType )

private

Definition at line 348 of file G4hImpactIonisation.cc.

{
  // Initialisation
  G4double lowEdgeEnergy , ionloss, ionlossBB, paramB ;
  //G4double lowEnergy, highEnergy;
  G4double highEnergy;
  G4Proton* proton = G4Proton::Proton();

  if (particleDef == *proton) 
    {
      //lowEnergy = protonLowEnergy ;
      highEnergy = protonHighEnergy ;
      charge = 1. ;
    } 
  else 
    {
      //lowEnergy = antiprotonLowEnergy ;
      highEnergy = antiprotonHighEnergy ;
      charge = -1. ;
    }
  chargeSquare = 1. ;

  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();

  if ( theLossTable) 
    {
      theLossTable->clearAndDestroy();
      delete theLossTable;
    }

  theLossTable = new G4PhysicsTable(numOfCouples);

  //  loop for materials
  for (size_t j=0; j<numOfCouples; j++) {

    // create physics vector and fill it
    G4PhysicsLogVector* aVector = new G4PhysicsLogVector(LowestKineticEnergy,
                                                         HighestKineticEnergy,
                                                         TotBin);

    // get material parameters needed for the energy loss calculation
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();

    if ( charge > 0.0 ) {
      ionloss = ProtonParametrisedDEDX(couple,highEnergy) ;
    } else {
      ionloss = AntiProtonParametrisedDEDX(couple,highEnergy) ;
    }

    ionlossBB = betheBlochModel->TheValue(&particleDef,material,highEnergy) ;
    ionlossBB -= DeltaRaysEnergy(couple,highEnergy,proton_mass_c2) ;


    paramB =  ionloss/ionlossBB - 1.0 ;

    // now comes the loop for the kinetic energy values
    for (G4int i = 0 ; i < TotBin ; i++) {
      lowEdgeEnergy = aVector->GetLowEdgeEnergy(i) ;

      // low energy part for this material, parametrised energy loss formulae
      if ( lowEdgeEnergy < highEnergy ) {

        if ( charge > 0.0 ) {
          ionloss = ProtonParametrisedDEDX(couple,lowEdgeEnergy) ;
    } else {
          ionloss = AntiProtonParametrisedDEDX(couple,lowEdgeEnergy) ;
    }

      } else {

        // high energy part for this material, Bethe-Bloch formula
        ionloss = betheBlochModel->TheValue(proton,material,
                        lowEdgeEnergy) ;

        ionloss -= DeltaRaysEnergy(couple,lowEdgeEnergy,proton_mass_c2) ;

    ionloss *= (1.0 + paramB*highEnergy/lowEdgeEnergy) ;
      }

      // now put the loss into the vector
      if(verboseLevel > 1) {
        G4cout << "E(MeV)= " << lowEdgeEnergy/MeV
               << "  dE/dx(MeV/mm)= " << ionloss*mm/MeV
               << " in " << material->GetName() << G4endl;
      }
      aVector->PutValue(i,ionloss) ;
    }
    // Insert vector for this material into the table
    theLossTable->insert(aVector) ;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildPhysicsTable()

void G4hImpactIonisation::BuildPhysicsTable ( const G4ParticleDefinition &  aParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 191 of file G4hImpactIonisation.cc.

{

  // Verbose print-out
  if(verboseLevel > 0) 
    {
      G4cout << "G4hImpactIonisation::BuildPhysicsTable for "
         << particleDef.GetParticleName()
         << " mass(MeV)= " << particleDef.GetPDGMass()/MeV
         << " charge= " << particleDef.GetPDGCharge()/eplus
         << " type= " << particleDef.GetParticleType()
         << G4endl;
      
      if(verboseLevel > 1) 
    {
      G4ProcessVector* pv = particleDef.GetProcessManager()->GetProcessList();
      
      G4cout << " 0: " << (*pv)[0]->GetProcessName() << " " << (*pv)[0]
         << " 1: " << (*pv)[1]->GetProcessName() << " " << (*pv)[1]
        //        << " 2: " << (*pv)[2]->GetProcessName() << " " << (*pv)[2]
         << G4endl;
      G4cout << "ionModel= " << theIonEffChargeModel
         << " MFPtable= " << theMeanFreePathTable
         << " iniMass= " << initialMass
         << G4endl;
    }
    }
  // End of verbose print-out

  if (particleDef.GetParticleType() == "nucleus" &&
      particleDef.GetParticleName() != "GenericIon" &&
      particleDef.GetParticleSubType() == "generic")
    {

      G4EnergyLossTables::Register(&particleDef,
                   theDEDXpTable,
                   theRangepTable,
                   theInverseRangepTable,
                   theLabTimepTable,
                   theProperTimepTable,
                   LowestKineticEnergy, HighestKineticEnergy,
                   proton_mass_c2/particleDef.GetPDGMass(),
                   TotBin);

      return;
    }

  if( !CutsWhereModified() && theLossTable) return;

  InitializeParametrisation() ;
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();

  charge = particleDef.GetPDGCharge() / eplus;
  chargeSquare = charge*charge ;

  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();

  cutForDelta.clear();
  cutForGamma.clear();

  for (size_t j=0; j<numOfCouples; j++) {

    // get material parameters needed for the energy loss calculation
    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();

    // the cut cannot be below lowest limit
    G4double tCut = (*(theCoupleTable->GetEnergyCutsVector(1)))[j];
    if(tCut > HighestKineticEnergy) tCut = HighestKineticEnergy;

    G4double excEnergy = material->GetIonisation()->GetMeanExcitationEnergy();

    tCut = std::max(tCut,excEnergy);
    cutForDelta.push_back(tCut);

    // the cut cannot be below lowest limit
    tCut = (*(theCoupleTable->GetEnergyCutsVector(0)))[j];
    if(tCut > HighestKineticEnergy) tCut = HighestKineticEnergy;
    tCut = std::max(tCut,minGammaEnergy);
    cutForGamma.push_back(tCut);
  }

  if(verboseLevel > 0) {
    G4cout << "Cuts are defined " << G4endl;
  }

  if(0.0 < charge)
    {
      {
        BuildLossTable(*proton) ;

    //      The following vector has a fixed dimension (see src/G4hImpactLoss.cc for more details)        
    //      It happended in the past that caused memory corruption errors. The problem is still pending, even if temporary solved
    //        G4cout << "[NOTE]: __LINE__=" << __LINE__ << ", particleDef=" << particleDef.GetParticleName() << ", proton=" << proton << ", theLossTable=" << theLossTable << ", CounterOfpProcess=" << CounterOfpProcess << G4endl;
        
        RecorderOfpProcess[CounterOfpProcess] = theLossTable ;
        CounterOfpProcess++;
      }
    } else {
    {
      BuildLossTable(*antiproton) ;
        
      //      The following vector has a fixed dimension (see src/G4hImpactLoss.cc for more details)        
      //      It happended in the past that caused memory corruption errors. The problem is still pending, even if temporary solved
      //        G4cout << "[NOTE]: __LINE__=" << __LINE__ << ", particleDef=" << particleDef.GetParticleName() << ", antiproton=" << antiproton << ", theLossTable=" << theLossTable << ", CounterOfpbarProcess=" << CounterOfpbarProcess << G4endl;
        
      RecorderOfpbarProcess[CounterOfpbarProcess] = theLossTable ;
      CounterOfpbarProcess++;
    }
  }

  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: "
           << "Loss table is built "
      //       << theLossTable
       << G4endl;
  }

  BuildLambdaTable(particleDef) ;
  //  BuildDataForFluorescence(particleDef);

  if(verboseLevel > 1) {
    G4cout << (*theMeanFreePathTable) << G4endl;
  }

  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: "
           << "DEDX table will be built "
      //       << theDEDXpTable << " " << theDEDXpbarTable
      //       << " " << theRangepTable << " " << theRangepbarTable
       << G4endl;
  }

  BuildDEDXTable(particleDef) ;

  if(verboseLevel > 1) {
    G4cout << (*theDEDXpTable) << G4endl;
  }

  if((&particleDef == proton) ||  (&particleDef == antiproton)) PrintInfoDefinition() ;

  if(verboseLevel > 0) {
    G4cout << "G4hImpactIonisation::BuildPhysicsTable: end for "
           << particleDef.GetParticleName() << G4endl;
  }
}

Here is the call graph for this function:

ComputeDEDX()

G4double G4hImpactIonisation::ComputeDEDX	(	const G4ParticleDefinition *	aParticle,
		const G4MaterialCutsCouple *	couple,
		G4double	kineticEnergy
	)

Definition at line 1266 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();
  G4double dedx = 0.;

  G4double tScaled = kineticEnergy * proton_mass_c2 / (aParticle->GetPDGMass()) ;
  charge  = aParticle->GetPDGCharge() ;

  if( charge > 0.) 
    {
      if (tScaled > protonHighEnergy) 
    {
      dedx = G4EnergyLossTables::GetDEDX(proton,tScaled,couple) ;  
    }
      else 
    {
      dedx = ProtonParametrisedDEDX(couple,tScaled) ;
    }
    } 
  else 
    {
      if (tScaled > antiprotonHighEnergy) 
    {
      dedx = G4EnergyLossTables::GetDEDX(antiproton,tScaled,couple);
    } 
      else
    {
      dedx = AntiProtonParametrisedDEDX(couple,tScaled) ;
    }
    }
  dedx *= theIonEffChargeModel->TheValue(aParticle, material, kineticEnergy) ;
  
  return dedx ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

DeltaRaysEnergy()

G4double G4hImpactIonisation::DeltaRaysEnergy ( const G4MaterialCutsCouple *  couple, G4double  kineticEnergy, G4double  particleMass  ) const

private

Definition at line 917 of file G4hImpactIonisation.cc.

{
  G4double dLoss = 0.;

  G4double deltaCutNow = cutForDelta[(couple->GetIndex())] ;
  const G4Material* material = couple->GetMaterial();
  G4double electronDensity = material->GetElectronDensity();
  G4double excitationEnergy = material->GetIonisation()->GetMeanExcitationEnergy();

  G4double tau = kineticEnergy / particleMass ;
  G4double rateMass = electron_mass_c2/particleMass ;

  // some local variables

  G4double gamma = tau + 1.0 ;
  G4double bg2 = tau*(tau+2.0) ;
  G4double beta2 = bg2/(gamma*gamma) ;
  G4double tMax = 2.*electron_mass_c2*bg2/(1.0+2.0*gamma*rateMass+rateMass*rateMass) ;

  // Validity range for delta electron cross section
  G4double deltaCut = std::max(deltaCutNow, excitationEnergy);

  if ( deltaCut < tMax) 
    {
      G4double x = deltaCut / tMax ;
      dLoss = ( beta2 * (x-1.) - std::log(x) ) * twopi_mc2_rcl2 * electronDensity / beta2 ;
    }
  return dLoss ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ElectronicLossFluctuation()

G4double G4hImpactIonisation::ElectronicLossFluctuation ( const G4DynamicParticle *  particle, const G4MaterialCutsCouple *  material, G4double  meanLoss, G4double  step  ) const

private

Definition at line 1453 of file G4hImpactIonisation.cc.

{
  // data members to speed up the fluctuation calculation
  //  G4int imat ;
  //  G4double f1Fluct,f2Fluct,e1Fluct,e2Fluct,rateFluct,ipotFluct;
  //  G4double e1LogFluct,e2LogFluct,ipotLogFluct;

  static const G4double minLoss = 1.*eV ;
  static const G4double kappa = 10. ;
  static const G4double theBohrBeta2 = 50.0 * keV/proton_mass_c2 ;

  const G4Material* material = couple->GetMaterial();
  G4int    imaterial   = couple->GetIndex() ;
  G4double ipotFluct   = material->GetIonisation()->GetMeanExcitationEnergy() ;
  G4double electronDensity = material->GetElectronDensity() ;
  G4double zeff = electronDensity/(material->GetTotNbOfAtomsPerVolume()) ;

  // get particle data
  G4double tkin   = particle->GetKineticEnergy();
  G4double particleMass = particle->GetMass() ;
  G4double deltaCutInKineticEnergyNow = cutForDelta[imaterial];

  // shortcut for very very small loss
  if(meanLoss < minLoss) return meanLoss ;

  // Validity range for delta electron cross section
  G4double threshold = std::max(deltaCutInKineticEnergyNow,ipotFluct);
  G4double loss, siga;

  G4double rmass = electron_mass_c2/particleMass;
  G4double tau   = tkin/particleMass;
  G4double tau1 = tau+1.0;
  G4double tau2 = tau*(tau+2.);
  G4double tMax    = 2.*electron_mass_c2*tau2/(1.+2.*tau1*rmass+rmass*rmass);


  if(tMax > threshold) tMax = threshold;
  G4double beta2 = tau2/(tau1*tau1);

  // Gaussian fluctuation
  if(meanLoss > kappa*tMax || tMax < kappa*ipotFluct )
    {
      siga = tMax * (1.0-0.5*beta2) * step * twopi_mc2_rcl2
    * electronDensity / beta2 ;

      // High velocity or negatively charged particle
      if( beta2 > 3.0*theBohrBeta2*zeff || charge < 0.0) {
    siga = std::sqrt( siga * chargeSquare ) ;

    // Low velocity - additional ion charge fluctuations according to
    // Q.Yang et al., NIM B61(1991)149-155.
      } else {
    G4double chu = theIonChuFluctuationModel->TheValue(particle, material);
    G4double yang = theIonYangFluctuationModel->TheValue(particle, material);
    siga = std::sqrt( siga * (chargeSquare * chu + yang)) ;
      }

      do {
        loss = G4RandGauss::shoot(meanLoss,siga);
      } while (loss < 0. || loss > 2.0*meanLoss);
      return loss;
    }

  // Non Gaussian fluctuation
  static const G4double probLim = 0.01 ;
  static const G4double sumaLim = -std::log(probLim) ;
  static const G4double alim = 10.;

  G4double suma,w1,w2,C,e0,lossc,w;
  G4double a1,a2,a3;
  G4int p1,p2,p3;
  G4int nb;
  G4double corrfac, na,alfa,rfac,namean,sa,alfa1,ea,sea;
  G4double dp3;

  G4double f1Fluct     = material->GetIonisation()->GetF1fluct();
  G4double f2Fluct     = material->GetIonisation()->GetF2fluct();
  G4double e1Fluct     = material->GetIonisation()->GetEnergy1fluct();
  G4double e2Fluct     = material->GetIonisation()->GetEnergy2fluct();
  G4double e1LogFluct  = material->GetIonisation()->GetLogEnergy1fluct();
  G4double e2LogFluct  = material->GetIonisation()->GetLogEnergy2fluct();
  G4double rateFluct   = material->GetIonisation()->GetRateionexcfluct();
  G4double ipotLogFluct= material->GetIonisation()->GetLogMeanExcEnergy();

  w1 = tMax/ipotFluct;
  w2 = std::log(2.*electron_mass_c2*tau2);

  C = meanLoss*(1.-rateFluct)/(w2-ipotLogFluct-beta2);

  a1 = C*f1Fluct*(w2-e1LogFluct-beta2)/e1Fluct;
  a2 = C*f2Fluct*(w2-e2LogFluct-beta2)/e2Fluct;
  a3 = rateFluct*meanLoss*(tMax-ipotFluct)/(ipotFluct*tMax*std::log(w1));
  if(a1 < 0.0) a1 = 0.0;
  if(a2 < 0.0) a2 = 0.0;
  if(a3 < 0.0) a3 = 0.0;

  suma = a1+a2+a3;

  loss = 0.;


  if(suma < sumaLim)             // very small Step
    {
      e0 = material->GetIonisation()->GetEnergy0fluct();

      if(tMax == ipotFluct)
    {
      a3 = meanLoss/e0;

      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);

      loss = p3*e0 ;

      if(p3 > 0)
        loss += (1.-2.*G4UniformRand())*e0 ;

    }
      else
    {
      tMax = tMax-ipotFluct+e0 ;
      a3 = meanLoss*(tMax-e0)/(tMax*e0*std::log(tMax/e0));

      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);

      if(p3 > 0)
        {
          w = (tMax-e0)/tMax ;
          if(p3 > nmaxCont2)
        {
          dp3 = G4float(p3) ;
          corrfac = dp3/G4float(nmaxCont2) ;
          p3 = nmaxCont2 ;
        }
          else
        corrfac = 1. ;

          for(G4int i=0; i<p3; i++) loss += 1./(1.-w*G4UniformRand()) ;
          loss *= e0*corrfac ;
        }
    }
    }

  else                              // not so small Step
    {
      // excitation type 1
      if(a1>alim)
    {
      siga=std::sqrt(a1) ;
      p1 = std::max(0,G4int(G4RandGauss::shoot(a1,siga)+0.5));
    }
      else
    p1 = G4Poisson(a1);

      // excitation type 2
      if(a2>alim)
    {
      siga=std::sqrt(a2) ;
      p2 = std::max(0,G4int(G4RandGauss::shoot(a2,siga)+0.5));
    }
      else
        p2 = G4Poisson(a2);

      loss = p1*e1Fluct+p2*e2Fluct;

      // smearing to avoid unphysical peaks
      if(p2 > 0)
        loss += (1.-2.*G4UniformRand())*e2Fluct;
      else if (loss>0.)
        loss += (1.-2.*G4UniformRand())*e1Fluct;

      // ionisation .......................................
      if(a3 > 0.)
    {
      if(a3>alim)
        {
          siga=std::sqrt(a3) ;
          p3 = std::max(0,G4int(G4RandGauss::shoot(a3,siga)+0.5));
        }
      else
        p3 = G4Poisson(a3);

      lossc = 0.;
      if(p3 > 0)
        {
          na = 0.;
          alfa = 1.;
          if (p3 > nmaxCont2)
        {
          dp3        = G4float(p3);
          rfac       = dp3/(G4float(nmaxCont2)+dp3);
          namean     = G4float(p3)*rfac;
          sa         = G4float(nmaxCont1)*rfac;
          na         = G4RandGauss::shoot(namean,sa);
          if (na > 0.)
            {
              alfa   = w1*G4float(nmaxCont2+p3)/
            (w1*G4float(nmaxCont2)+G4float(p3));
              alfa1  = alfa*std::log(alfa)/(alfa-1.);
              ea     = na*ipotFluct*alfa1;
              sea    = ipotFluct*std::sqrt(na*(alfa-alfa1*alfa1));
              lossc += G4RandGauss::shoot(ea,sea);
            }
        }

          nb = G4int(G4float(p3)-na);
          if (nb > 0)
        {
          w2 = alfa*ipotFluct;
          w  = (tMax-w2)/tMax;
          for (G4int k=0; k<nb; k++) lossc += w2/(1.-w*G4UniformRand());
        }
        }
      loss += lossc;
    }
    }

  return loss ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetConstraints()

G4double G4hImpactIonisation::GetConstraints ( const G4DynamicParticle *  particle, const G4MaterialCutsCouple *  couple  )

private

Definition at line 623 of file G4hImpactIonisation.cc.

{
  // returns the Step limit
  // dEdx is calculated as well as the range
  // based on Effective Charge Approach

  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4AntiProton* antiproton = G4AntiProton::AntiProton();

  G4double stepLimit = 0.;
  G4double dx, highEnergy;

  G4double massRatio = proton_mass_c2/(particle->GetMass()) ;
  G4double kineticEnergy = particle->GetKineticEnergy() ;

  // Scale the kinetic energy

  G4double tScaled = kineticEnergy*massRatio ;
  fBarkas = 0.;

  if (charge > 0.) 
    {
      highEnergy = protonHighEnergy ;
      fRangeNow = G4EnergyLossTables::GetRange(proton, tScaled, couple);
      dx = G4EnergyLossTables::GetRange(proton, highEnergy, couple);
      fdEdx = G4EnergyLossTables::GetDEDX(proton, tScaled, couple)
    * chargeSquare ;
      
      // Correction for positive ions
      if (theBarkas && tScaled > highEnergy) 
    { 
      fBarkas = BarkasTerm(material,tScaled)*std::sqrt(chargeSquare)*chargeSquare
        + BlochTerm(material,tScaled,chargeSquare);
    }
      // Antiprotons and negative hadrons
    } 
  else 
    {
      highEnergy = antiprotonHighEnergy ;
      fRangeNow = G4EnergyLossTables::GetRange(antiproton, tScaled, couple);
      dx = G4EnergyLossTables::GetRange(antiproton, highEnergy, couple);
      fdEdx = G4EnergyLossTables::GetDEDX(antiproton, tScaled, couple) * chargeSquare ;
      
      if (theBarkas && tScaled > highEnergy) 
    { 
      fBarkas = -BarkasTerm(material,tScaled)*std::sqrt(chargeSquare)*chargeSquare
        + BlochTerm(material,tScaled,chargeSquare);
    } 
    } 
  /*
    const G4Material* mat = couple->GetMaterial();
    G4double fac = gram/(MeV*cm2*mat->GetDensity());
    G4cout << particle->GetDefinition()->GetParticleName()
    << " in " << mat->GetName()
    << " E(MeV)= " << kineticEnergy/MeV
    << " dedx(MeV*cm^2/g)= " << fdEdx*fac
    << " barcas(MeV*cm^2/gram)= " << fBarkas*fac
    << " Q^2= " << chargeSquare
    << G4endl;
  */
  // scaling back
  fRangeNow /= (chargeSquare*massRatio) ;
  dx        /= (chargeSquare*massRatio) ;

  stepLimit  = fRangeNow ;
  G4double r = std::min(finalRange, couple->GetProductionCuts()
            ->GetProductionCut(idxG4ElectronCut));

  if (fRangeNow > r) 
    {  
      stepLimit = dRoverRange*fRangeNow + r*(1.0 - dRoverRange)*(2.0 - r/fRangeNow);
      if (stepLimit > fRangeNow) stepLimit = fRangeNow;
    }  
  //   compute the (random) Step limit in standard energy range
  if(tScaled > highEnergy ) 
    {    
      // add Barkas correction directly to dedx
      fdEdx  += fBarkas;
      
      if(stepLimit > fRangeNow - dx*0.9) stepLimit = fRangeNow - dx*0.9 ;
      
      // Step limit in low energy range
    } 
  else 
    {
      G4double x = dx*paramStepLimit;
      if (stepLimit > x) stepLimit = x;
    }
  return stepLimit;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetContinuousStepLimit()

G4double G4hImpactIonisation::GetContinuousStepLimit ( const G4Track &  track, G4double  previousStepSize, G4double  currentMinimumStep, G4double &  currentSafety  )

inlinevirtual

Implements G4VContinuousDiscreteProcess.

Definition at line 294 of file G4hImpactIonisation.hh.

{
  G4double step = GetConstraints(track.GetDynamicParticle(),track.GetMaterialCutsCouple()) ;

  // ---- MGP ---- The following line, taken as is from G4hLowEnergyIonisation,
  // is meaningless: currentMinimumStep is passed by value,
  // therefore any local modification to it has no effect

  if ((step > 0.) && (step < currentMinimumStep)) currentMinimumStep = step ;

  return step ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMeanFreePath()

G4double G4hImpactIonisation::GetMeanFreePath ( const G4Track &  track, G4double  previousStepSize, enum G4ForceCondition *  condition  )

virtual

Implements G4hRDEnergyLoss.

Definition at line 589 of file G4hImpactIonisation.cc.

{
  const G4DynamicParticle* dynamicParticle = track.GetDynamicParticle();
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  const G4Material* material = couple->GetMaterial();

  G4double meanFreePath = DBL_MAX;
  // ---- MGP ---- What is the meaning of the local variable isOutOfRange?
  G4bool isOutRange = false;

  *condition = NotForced ;

  G4double kineticEnergy = (dynamicParticle->GetKineticEnergy())*initialMass/(dynamicParticle->GetMass());
  charge = dynamicParticle->GetCharge()/eplus;
  chargeSquare = theIonEffChargeModel->TheValue(dynamicParticle, material);

  if (kineticEnergy < LowestKineticEnergy) 
    {
      meanFreePath = DBL_MAX;
    }
  else 
    {
      if (kineticEnergy > HighestKineticEnergy)  kineticEnergy = HighestKineticEnergy;
      meanFreePath = (((*theMeanFreePathTable)(couple->GetIndex()))->
              GetValue(kineticEnergy,isOutRange))/chargeSquare;
    }

  return meanFreePath ;
}

Here is the call graph for this function:

InitializeMe()

void G4hImpactIonisation::InitializeMe ( )

private

Definition at line 106 of file G4hImpactIonisation.cc.

{
  LowestKineticEnergy  = 10.0*eV ;
  HighestKineticEnergy = 100.0*GeV ;
  MinKineticEnergy     = 10.0*eV ; 
  TotBin               = 360 ;
  protonLowEnergy      = 1.*keV ;
  protonHighEnergy     = 100.*MeV ;
  antiprotonLowEnergy  = 25.*keV ;
  antiprotonHighEnergy = 2.*MeV ;
  minGammaEnergy       = 100 * eV;
  minElectronEnergy    = 250.* eV;
  verboseLevel         = 0;
 
  // Min and max energy of incident particle for the calculation of shell cross sections
  // for PIXE generation
  eMinPixe = 1.* keV;
  eMaxPixe = 200. * MeV;
  
  G4String defaultPixeModel("ecpssr"); 
  modelK = defaultPixeModel;
  modelL = defaultPixeModel;
  modelM = defaultPixeModel;
}

Here is the caller graph for this function:

InitializeParametrisation()

void G4hImpactIonisation::InitializeParametrisation ( )

private

Definition at line 175 of file G4hImpactIonisation.cc.

{
  // Define models for parametrisation of electronic energy losses
  betheBlochModel = new G4hBetheBlochModel("Bethe-Bloch") ;
  protonModel = new G4hParametrisedLossModel(protonTable) ;
  protonHighEnergy = std::min(protonHighEnergy,protonModel->HighEnergyLimit(0, 0));
  antiprotonModel = new G4QAOLowEnergyLoss(antiprotonTable) ;
  theNuclearStoppingModel = new G4hNuclearStoppingModel(theNuclearTable) ;
  theIonEffChargeModel = new G4hIonEffChargeSquare("Ziegler1988") ;
  theIonChuFluctuationModel = new G4IonChuFluctuationModel("Chu") ;
  theIonYangFluctuationModel = new G4IonYangFluctuationModel("Yang") ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsApplicable()

G4bool G4hImpactIonisation::IsApplicable ( const G4ParticleDefinition &  particle )

inlinevirtual

Reimplemented from G4VProcess.

Definition at line 311 of file G4hImpactIonisation.hh.

{
  // ---- MGP ---- Better criterion for applicability to be defined;
  // now hard-coded particle mass > 0.1 * proton_mass

  return (particle.GetPDGCharge() != 0.0 && particle.GetPDGMass() > CLHEP::proton_mass_c2*0.1);
}

Here is the call graph for this function:

MicroscopicCrossSection()

G4double G4hImpactIonisation::MicroscopicCrossSection ( const G4ParticleDefinition &  aParticleType, G4double  kineticEnergy, G4double  atomicNumber, G4double  deltaCutInEnergy  ) const

private

Definition at line 531 of file G4hImpactIonisation.cc.

{
  //******************************************************************
    // cross section formula is OK for spin=0, 1/2, 1 only !
    // *****************************************************************

    // Calculates the microscopic cross section in GEANT4 internal units
    // Formula documented in Geant4 Phys. Ref. Manual
    // ( it is called for elements, AtomicNumber = z )

    G4double totalCrossSection = 0.;

  // Particle mass and energy
  G4double particleMass = initialMass;
  G4double energy = kineticEnergy + particleMass;

  // Some kinematics
  G4double gamma = energy / particleMass;
  G4double beta2 = 1. - 1. / (gamma * gamma);
  G4double var = electron_mass_c2 / particleMass;
  G4double tMax   = 2. * electron_mass_c2 * (gamma*gamma - 1.) / (1. + 2.* gamma*var + var*var);

  // Calculate the total cross section

  if ( tMax > deltaCutInEnergy ) 
    {
      var = deltaCutInEnergy / tMax;
      totalCrossSection = (1. - var * (1. - beta2 * std::log(var))) / deltaCutInEnergy ;
      
      G4double spin = particleDef.GetPDGSpin() ;
      
      // +term for spin=1/2 particle
      if (spin == 0.5) 
    {
      totalCrossSection +=  0.5 * (tMax - deltaCutInEnergy) / (energy*energy);
    }
      // +term for spin=1 particle
      else if (spin > 0.9 )
    {
      totalCrossSection += -std::log(var) / 
        (3. * deltaCutInEnergy) + (tMax - deltaCutInEnergy) * ( (5. + 1. /var)*0.25 / (energy*energy) -
                                    beta2 / (tMax * deltaCutInEnergy) ) / 3. ;
    }
      totalCrossSection *= twopi_mc2_rcl2 * atomicNumber / beta2 ;
    }

  //std::cout << "Microscopic = " << totalCrossSection/barn 
  //    << ", e = " << kineticEnergy/MeV <<std:: endl; 

  return totalCrossSection ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator=()

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

private

Here is the caller graph for this function:

PostStepDoIt()

G4VParticleChange * G4hImpactIonisation::PostStepDoIt ( const G4Track &  track, const G4Step &  Step  )

virtual

Implements G4hRDEnergyLoss.

Definition at line 952 of file G4hImpactIonisation.cc.

{
  // Units are expressed in GEANT4 internal units.

  //  std::cout << "----- Calling PostStepDoIt ----- " << std::endl;

  aParticleChange.Initialize(track) ;
  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();  
  const G4DynamicParticle* aParticle = track.GetDynamicParticle() ;
  
  // Some kinematics

  G4ParticleDefinition* definition = track.GetDefinition();
  G4double mass = definition->GetPDGMass();
  G4double kineticEnergy = aParticle->GetKineticEnergy();
  G4double totalEnergy = kineticEnergy + mass ;
  G4double pSquare = kineticEnergy *( totalEnergy + mass) ;
  G4double eSquare = totalEnergy * totalEnergy;
  G4double betaSquare = pSquare / eSquare;
  G4ThreeVector particleDirection = aParticle->GetMomentumDirection() ;

  G4double gamma = kineticEnergy / mass + 1.;
  G4double r = electron_mass_c2 / mass;
  G4double tMax = 2. * electron_mass_c2 *(gamma*gamma - 1.) / (1. + 2.*gamma*r + r*r);

  // Validity range for delta electron cross section
  G4double deltaCut = cutForDelta[couple->GetIndex()];

  // This should not be a case
  if (deltaCut >= tMax)
    return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);

  G4double xc = deltaCut / tMax;
  G4double rate = tMax / totalEnergy;
  rate = rate*rate ;
  G4double spin = aParticle->GetDefinition()->GetPDGSpin() ;

  // Sampling follows ...
  G4double x = 0.;
  G4double gRej = 0.;

  do {
    x = xc / (1. - (1. - xc) * G4UniformRand());
    
    if (0.0 == spin) 
      {
    gRej = 1.0 - betaSquare * x ;
      }
    else if (0.5 == spin) 
      {
    gRej = (1. - betaSquare * x + 0.5 * x*x * rate) / (1. + 0.5 * rate) ;
      } 
    else 
      {
    gRej = (1. - betaSquare * x ) * (1. + x/(3.*xc)) +
      x*x * rate * (1. + 0.5*x/xc) / 3.0 /
      (1. + 1./(3.*xc) + rate *(1.+ 0.5/xc) / 3.);
      }
    
  } while( G4UniformRand() > gRej );

  G4double deltaKineticEnergy = x * tMax;
  G4double deltaTotalMomentum = std::sqrt(deltaKineticEnergy * 
                      (deltaKineticEnergy + 2. * electron_mass_c2 ));
  G4double totalMomentum = std::sqrt(pSquare) ;
  G4double cosTheta = deltaKineticEnergy * (totalEnergy + electron_mass_c2) / (deltaTotalMomentum*totalMomentum);

  //  protection against cosTheta > 1 or < -1 
  if ( cosTheta < -1. ) cosTheta = -1.;
  if ( cosTheta > 1. ) cosTheta = 1.;

  //  direction of the delta electron 
  G4double phi = twopi * G4UniformRand();
  G4double sinTheta = std::sqrt(1. - cosTheta*cosTheta);
  G4double dirX = sinTheta * std::cos(phi);
  G4double dirY = sinTheta * std::sin(phi);
  G4double dirZ = cosTheta;

  G4ThreeVector deltaDirection(dirX,dirY,dirZ);
  deltaDirection.rotateUz(particleDirection);

  // create G4DynamicParticle object for delta ray
  G4DynamicParticle* deltaRay = new G4DynamicParticle;
  deltaRay->SetKineticEnergy( deltaKineticEnergy );
  deltaRay->SetMomentumDirection(deltaDirection.x(),
                 deltaDirection.y(),
                 deltaDirection.z());
  deltaRay->SetDefinition(G4Electron::Electron());

  // fill aParticleChange
  G4double finalKineticEnergy = kineticEnergy - deltaKineticEnergy;
  size_t totalNumber = 1;

  // Atomic relaxation

  // ---- MGP ---- Temporary limitation: currently PIXE only for incident protons

  size_t nSecondaries = 0;
  std::vector<G4DynamicParticle*>* secondaryVector = 0;

  if (definition == G4Proton::ProtonDefinition())
    {
      const G4Material* material = couple->GetMaterial();

      // Lazy initialization of pixeCrossSectionHandler
      if (pixeCrossSectionHandler == 0)
    {
      // Instantiate pixeCrossSectionHandler with selected shell cross section models
      // Ownership of interpolation is transferred to pixeCrossSectionHandler
      G4IInterpolator* interpolation = new G4LogLogInterpolator();
      pixeCrossSectionHandler = 
        new G4PixeCrossSectionHandler(interpolation,modelK,modelL,modelM,eMinPixe,eMaxPixe);
      G4String fileName("proton");
      pixeCrossSectionHandler->LoadShellData(fileName);
      //      pixeCrossSectionHandler->PrintData();
    }
      
      // Select an atom in the current material based on the total shell cross sections
      G4int Z = pixeCrossSectionHandler->SelectRandomAtom(material,kineticEnergy);
      //      std::cout << "G4hImpactIonisation::PostStepDoIt - Z = " << Z << std::endl;

      //      G4double microscopicCross = MicroscopicCrossSection(*definition,
      //                              kineticEnergy,
      //                      Z, deltaCut);
  //    G4double crossFromShells = pixeCrossSectionHandler->FindValue(Z,kineticEnergy);

      //std::cout << "G4hImpactIonisation: Z= "
      //        << Z
      //        << ", energy = "
      //        << kineticEnergy/MeV
      //        <<" MeV, microscopic = "
      //        << microscopicCross/barn 
      //        << " barn, from shells = "
      //        << crossFromShells/barn
      //        << " barn" 
      //        << std::endl;

      // Select a shell in the target atom based on the individual shell cross sections
      G4int shellIndex = pixeCrossSectionHandler->SelectRandomShell(Z,kineticEnergy);
    
      G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
      const G4AtomicShell* atomicShell = transitionManager->Shell(Z,shellIndex);
      G4double bindingEnergy = atomicShell->BindingEnergy();
      
      //     if (verboseLevel > 1) 
      //       {
      //     G4cout << "G4hImpactIonisation::PostStepDoIt - Z = " 
      //         << Z 
      //     << ", shell = " 
      //     << shellIndex
      //     << ", bindingE (keV) = " 
      //     << bindingEnergy/keV
      //     << G4endl;
      //       }
      
      // Generate PIXE if binding energy larger than cut for photons or electrons
      
      G4ParticleDefinition* type = 0;
      
      if (finalKineticEnergy >= bindingEnergy)
    //    && (bindingEnergy >= minGammaEnergy ||  bindingEnergy >= minElectronEnergy) ) 
    {
      // Vacancy in subshell shellIndex; shellId is the subshell identifier in EADL jargon 
      G4int shellId = atomicShell->ShellId();
      // Atomic relaxation: generate secondaries
      secondaryVector = atomicDeexcitation.GenerateParticles(Z, shellId);

      // ---- Debug ----
      //std::cout << "ShellId = "
      //    <<shellId << " ---- Atomic relaxation secondaries: ---- " 
      //    << secondaryVector->size()
      //    << std::endl;

      // ---- End debug ---

      if (secondaryVector != 0) 
        {
          nSecondaries = secondaryVector->size();
          for (size_t i = 0; i<nSecondaries; i++) 
        {
          G4DynamicParticle* aSecondary = (*secondaryVector)[i];
          if (aSecondary) 
            {
              G4double e = aSecondary->GetKineticEnergy();
              type = aSecondary->GetDefinition();

              // ---- Debug ----
              //if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //            << ", shell: " << shellId
              //            << ", PIXE photon energy (keV) = " << e/keV 
              //            << std::endl;
              //    }
              // ---- End debug ---

              if (e < finalKineticEnergy &&
              ((type == G4Gamma::Gamma() && e > minGammaEnergy ) ||
               (type == G4Electron::Electron() && e > minElectronEnergy ))) 
            {
              // Subtract the energy of the emitted secondary from the primary
              finalKineticEnergy -= e;
              totalNumber++;
              // ---- Debug ----
              //if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //            << ", shell: " << shellId
              //            << ", PIXE photon energy (keV) = " << e/keV
              //            << std::endl;
              //    }
              // ---- End debug ---
            } 
              else 
            {
              // The atomic relaxation product has energy below the cut
              // ---- Debug ----
              // if (type == G4Gamma::GammaDefinition())
              //    {           
              //      std::cout << "Z = " << Z 
              //
              //            << ", PIXE photon energy = " << e/keV 
              //            << " keV below threshold " << minGammaEnergy/keV << " keV"
              //            << std::endl;
              //    }   
              // ---- End debug ---
     
              delete aSecondary;
              (*secondaryVector)[i] = 0;
            }
            }
        }
        }
    }
    }


  // Save delta-electrons

  G4double eDeposit = 0.;

  if (finalKineticEnergy > MinKineticEnergy)
    {
      G4double finalPx = totalMomentum*particleDirection.x() - deltaTotalMomentum*deltaDirection.x();
      G4double finalPy = totalMomentum*particleDirection.y() - deltaTotalMomentum*deltaDirection.y();
      G4double finalPz = totalMomentum*particleDirection.z() - deltaTotalMomentum*deltaDirection.z();
      G4double finalMomentum = std::sqrt(finalPx*finalPx + finalPy*finalPy + finalPz*finalPz) ;
      finalPx /= finalMomentum;
      finalPy /= finalMomentum;
      finalPz /= finalMomentum;

      aParticleChange.ProposeMomentumDirection( finalPx,finalPy,finalPz );
    }
  else
    {
      eDeposit = finalKineticEnergy;
      finalKineticEnergy = 0.;
      aParticleChange.ProposeMomentumDirection(particleDirection.x(),
                           particleDirection.y(),
                           particleDirection.z());
      if(!aParticle->GetDefinition()->GetProcessManager()->
     GetAtRestProcessVector()->size())
        aParticleChange.ProposeTrackStatus(fStopAndKill);
      else
        aParticleChange.ProposeTrackStatus(fStopButAlive);
    }

  aParticleChange.ProposeEnergy(finalKineticEnergy);
  aParticleChange.ProposeLocalEnergyDeposit (eDeposit);
  aParticleChange.SetNumberOfSecondaries(totalNumber);
  aParticleChange.AddSecondary(deltaRay);

  // ---- Debug ----
  //  std::cout << "RDHadronIonisation - finalKineticEnergy (MeV) = " 
  //        << finalKineticEnergy/MeV 
  //        << ", delta KineticEnergy (keV) = " 
  //        << deltaKineticEnergy/keV 
  //        << ", energy deposit (MeV) = "
  //        << eDeposit/MeV
  //        << std::endl;
  // ---- End debug ---
  
  // Save Fluorescence and Auger

  if (secondaryVector != 0) 
    { 
      for (size_t l = 0; l < nSecondaries; l++) 
    { 
      G4DynamicParticle* secondary = (*secondaryVector)[l];
      if (secondary) aParticleChange.AddSecondary(secondary);

      // ---- Debug ----
      //if (secondary != 0) 
      // {
      //   if (secondary->GetDefinition() == G4Gamma::GammaDefinition())
      //    {
      //      G4double eX = secondary->GetKineticEnergy();          
      //      std::cout << " PIXE photon of energy " << eX/keV 
      //            << " keV added to ParticleChange; total number of secondaries is " << totalNumber 
      //            << std::endl;
      //    }
      //}
      // ---- End debug ---   

    }
      delete secondaryVector;
    }

  return G4VContinuousDiscreteProcess::PostStepDoIt(track,step);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PrintInfoDefinition()

void G4hImpactIonisation::PrintInfoDefinition

(

)

const

Definition at line 1714 of file G4hImpactIonisation.cc.

{
  G4String comments = "  Knock-on electron cross sections . ";
  comments += "\n        Good description above the mean excitation energy.\n";
  comments += "        Delta ray energy sampled from  differential Xsection.";

  G4cout << G4endl << GetProcessName() << ":  " << comments
         << "\n        PhysicsTables from " << LowestKineticEnergy / eV << " eV "
         << " to " << HighestKineticEnergy / TeV << " TeV "
         << " in " << TotBin << " bins."
     << "\n        Electronic stopping power model is  "
     << protonTable
         << "\n        from " << protonLowEnergy / keV << " keV "
         << " to " << protonHighEnergy / MeV << " MeV " << "." << G4endl ;
  G4cout << "\n        Parametrisation model for antiprotons is  "
         << antiprotonTable
         << "\n        from " << antiprotonLowEnergy / keV << " keV "
         << " to " << antiprotonHighEnergy / MeV << " MeV " << "." << G4endl ;
  if(theBarkas){
    G4cout << "        Parametrization of the Barkas effect is switched on."
       << G4endl ;
  }
  if(nStopping) {
    G4cout << "        Nuclear stopping power model is " << theNuclearTable
       << G4endl ;
  }

  G4bool printHead = true;

  const G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();

  // loop for materials

  for (size_t j=0 ; j < numOfCouples; j++) {

    const G4MaterialCutsCouple* couple = theCoupleTable->GetMaterialCutsCouple(j);
    const G4Material* material= couple->GetMaterial();
    G4double deltaCutNow = cutForDelta[(couple->GetIndex())] ;
    G4double excitationEnergy = material->GetIonisation()->GetMeanExcitationEnergy();

    if(excitationEnergy > deltaCutNow) {
      if(printHead) {
        printHead = false ;

        G4cout << "           material       min.delta energy(keV) " << G4endl;
        G4cout << G4endl;
      }

      G4cout << std::setw(20) << material->GetName()
         << std::setw(15) << excitationEnergy/keV << G4endl;
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

ProtonParametrisedDEDX()

G4double G4hImpactIonisation::ProtonParametrisedDEDX ( const G4MaterialCutsCouple *  couple, G4double  kineticEnergy  ) const

private

Definition at line 832 of file G4hImpactIonisation.cc.

{
  const G4Material* material = couple->GetMaterial();
  G4Proton* proton = G4Proton::Proton();
  G4double eLoss = 0.;

  // Free Electron Gas Model
  if(kineticEnergy < protonLowEnergy) {
    eLoss = (protonModel->TheValue(proton, material, protonLowEnergy))
      * std::sqrt(kineticEnergy/protonLowEnergy) ;

    // Parametrisation
  } else {
    eLoss = protonModel->TheValue(proton, material, kineticEnergy) ;
  }

  // Delta rays energy
  eLoss -= DeltaRaysEnergy(couple,kineticEnergy,proton_mass_c2) ;

  if(verboseLevel > 2) {
    G4cout << "p E(MeV)= " << kineticEnergy/MeV
           << " dE/dx(MeV/mm)= " << eLoss*mm/MeV
           << " for " << material->GetName()
           << " model: " << protonModel << G4endl;
  }

  if(eLoss < 0.0) eLoss = 0.0 ;

  return eLoss ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetAntiProtonElectronicStoppingPowerModel()

void G4hImpactIonisation::SetAntiProtonElectronicStoppingPowerModel ( const G4String &  dedxTable )

inlineprivate

Definition at line 196 of file G4hImpactIonisation.hh.

  {antiprotonTable = dedxTable;};

Here is the call graph for this function:

Here is the caller graph for this function:

SetBarkasOff()

void G4hImpactIonisation::SetBarkasOff ( )

inline

Definition at line 148 of file G4hImpactIonisation.hh.

{theBarkas = false;};

SetBarkasOn()

void G4hImpactIonisation::SetBarkasOn ( )

inline

Definition at line 145 of file G4hImpactIonisation.hh.

{theBarkas = true;};

SetCutForAugerElectrons()

void G4hImpactIonisation::SetCutForAugerElectrons

(

G4double

cut

)

Definition at line 1700 of file G4hImpactIonisation.cc.

{
  minElectronEnergy = cut;
}

Here is the caller graph for this function:

SetCutForSecondaryPhotons()

void G4hImpactIonisation::SetCutForSecondaryPhotons

(

G4double

cut

)

Definition at line 1693 of file G4hImpactIonisation.cc.

{
  minGammaEnergy = cut;
}

Here is the caller graph for this function:

SetElectronicStoppingPowerModel()

void G4hImpactIonisation::SetElectronicStoppingPowerModel	(	const G4ParticleDefinition *	aParticle,
		const G4String &	dedxTable
	)

Definition at line 157 of file G4hImpactIonisation.cc.

{
  if (particle->GetPDGCharge() > 0 ) 
    {
      // Positive charge
      SetProtonElectronicStoppingPowerModel(dedxTable) ;
    } 
  else 
    {
      // Antiprotons
      SetAntiProtonElectronicStoppingPowerModel(dedxTable) ;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetHighEnergyForAntiProtonParametrisation()

void G4hImpactIonisation::SetHighEnergyForAntiProtonParametrisation ( G4double  energy )

inline

Definition at line 110 of file G4hImpactIonisation.hh.

{antiprotonHighEnergy = energy;} ;

SetHighEnergyForProtonParametrisation()

void G4hImpactIonisation::SetHighEnergyForProtonParametrisation ( G4double  energy )

inline

Definition at line 100 of file G4hImpactIonisation.hh.

{protonHighEnergy = energy;} ;

SetLowEnergyForAntiProtonParametrisation()

void G4hImpactIonisation::SetLowEnergyForAntiProtonParametrisation ( G4double  energy )

inline

Definition at line 115 of file G4hImpactIonisation.hh.

{antiprotonLowEnergy = energy;} ;

Here is the call graph for this function:

SetLowEnergyForProtonParametrisation()

void G4hImpactIonisation::SetLowEnergyForProtonParametrisation ( G4double  energy )

inline

Definition at line 105 of file G4hImpactIonisation.hh.

{protonLowEnergy = energy;} ;

SetNuclearStoppingOff()

void G4hImpactIonisation::SetNuclearStoppingOff ( )

inline

Definition at line 142 of file G4hImpactIonisation.hh.

{nStopping = false;};

SetNuclearStoppingOn()

void G4hImpactIonisation::SetNuclearStoppingOn ( )

inline

Definition at line 139 of file G4hImpactIonisation.hh.

{nStopping = true;};

Here is the caller graph for this function:

SetNuclearStoppingPowerModel()

void G4hImpactIonisation::SetNuclearStoppingPowerModel ( const G4String &  dedxTable )

inline

Definition at line 131 of file G4hImpactIonisation.hh.

  {theNuclearTable = dedxTable; SetNuclearStoppingOn();};

Here is the call graph for this function:

SetPixe()

void G4hImpactIonisation::SetPixe ( const G4bool  )

inline

Definition at line 151 of file G4hImpactIonisation.hh.

{pixeIsActive = true;};

Here is the call graph for this function:

SetPixeCrossSectionK()

void G4hImpactIonisation::SetPixeCrossSectionK ( const G4String &  name )

inline

Definition at line 177 of file G4hImpactIonisation.hh.

{ modelK = name; }

Here is the caller graph for this function:

SetPixeCrossSectionL()

void G4hImpactIonisation::SetPixeCrossSectionL ( const G4String &  name )

inline

Definition at line 178 of file G4hImpactIonisation.hh.

{ modelL = name; }

Here is the caller graph for this function:

SetPixeCrossSectionM()

void G4hImpactIonisation::SetPixeCrossSectionM ( const G4String &  name )

inline

Definition at line 179 of file G4hImpactIonisation.hh.

{ modelM = name; }

Here is the caller graph for this function:

SetPixeProjectileMaxEnergy()

void G4hImpactIonisation::SetPixeProjectileMaxEnergy ( G4double  energy )

inline

Definition at line 181 of file G4hImpactIonisation.hh.

{ eMaxPixe = energy; }

Here is the call graph for this function:

Here is the caller graph for this function:

SetPixeProjectileMinEnergy()

void G4hImpactIonisation::SetPixeProjectileMinEnergy ( G4double  energy )

inline

Definition at line 180 of file G4hImpactIonisation.hh.

{ eMinPixe = energy; }

Here is the caller graph for this function:

SetProtonElectronicStoppingPowerModel()

void G4hImpactIonisation::SetProtonElectronicStoppingPowerModel ( const G4String &  dedxTable )

inlineprivate

Definition at line 192 of file G4hImpactIonisation.hh.

  {protonTable = dedxTable ;};

Here is the caller graph for this function:

Member Data Documentation

antiprotonHighEnergy

G4double G4hImpactIonisation::antiprotonHighEnergy

private

Definition at line 260 of file G4hImpactIonisation.hh.

antiprotonLowEnergy

G4double G4hImpactIonisation::antiprotonLowEnergy

private

Definition at line 259 of file G4hImpactIonisation.hh.

antiprotonModel

G4VLowEnergyModel* G4hImpactIonisation::antiprotonModel

private

Definition at line 243 of file G4hImpactIonisation.hh.

antiprotonTable

G4String G4hImpactIonisation::antiprotonTable

private

Definition at line 253 of file G4hImpactIonisation.hh.

atomicDeexcitation

G4AtomicDeexcitation G4hImpactIonisation::atomicDeexcitation

private

Definition at line 282 of file G4hImpactIonisation.hh.

betheBlochModel

G4VLowEnergyModel* G4hImpactIonisation::betheBlochModel

private

Definition at line 241 of file G4hImpactIonisation.hh.

charge

G4double G4hImpactIonisation::charge

private

Definition at line 276 of file G4hImpactIonisation.hh.

chargeSquare

G4double G4hImpactIonisation::chargeSquare

private

Definition at line 277 of file G4hImpactIonisation.hh.

cutForDelta

G4DataVector G4hImpactIonisation::cutForDelta

private

Definition at line 266 of file G4hImpactIonisation.hh.

cutForGamma

G4DataVector G4hImpactIonisation::cutForGamma

private

Definition at line 267 of file G4hImpactIonisation.hh.

eMaxPixe

G4double G4hImpactIonisation::eMaxPixe

private

Definition at line 287 of file G4hImpactIonisation.hh.

eMinPixe

G4double G4hImpactIonisation::eMinPixe

private

Definition at line 286 of file G4hImpactIonisation.hh.

fBarkas

G4double G4hImpactIonisation::fBarkas

private

Definition at line 279 of file G4hImpactIonisation.hh.

fdEdx

G4double G4hImpactIonisation::fdEdx

private

Definition at line 274 of file G4hImpactIonisation.hh.

fRangeNow

G4double G4hImpactIonisation::fRangeNow

private

Definition at line 275 of file G4hImpactIonisation.hh.

initialMass

G4double G4hImpactIonisation::initialMass

private

Definition at line 278 of file G4hImpactIonisation.hh.

minElectronEnergy

G4double G4hImpactIonisation::minElectronEnergy

private

Definition at line 269 of file G4hImpactIonisation.hh.

minGammaEnergy

G4double G4hImpactIonisation::minGammaEnergy

private

Definition at line 268 of file G4hImpactIonisation.hh.

modelK

G4String G4hImpactIonisation::modelK

private

Definition at line 283 of file G4hImpactIonisation.hh.

modelL

G4String G4hImpactIonisation::modelL

private

Definition at line 284 of file G4hImpactIonisation.hh.

modelM

G4String G4hImpactIonisation::modelM

private

Definition at line 285 of file G4hImpactIonisation.hh.

nStopping

G4bool G4hImpactIonisation::nStopping

private

Definition at line 263 of file G4hImpactIonisation.hh.

paramStepLimit

const G4double G4hImpactIonisation::paramStepLimit

private

Definition at line 272 of file G4hImpactIonisation.hh.

pixeCrossSectionHandler

G4PixeCrossSectionHandler* G4hImpactIonisation::pixeCrossSectionHandler

private

Definition at line 281 of file G4hImpactIonisation.hh.

pixeIsActive

G4bool G4hImpactIonisation::pixeIsActive

private

Definition at line 289 of file G4hImpactIonisation.hh.

protonHighEnergy

G4double G4hImpactIonisation::protonHighEnergy

private

Definition at line 258 of file G4hImpactIonisation.hh.

protonLowEnergy

G4double G4hImpactIonisation::protonLowEnergy

private

Definition at line 257 of file G4hImpactIonisation.hh.

protonModel

G4VLowEnergyModel* G4hImpactIonisation::protonModel

private

Definition at line 242 of file G4hImpactIonisation.hh.

protonTable

G4String G4hImpactIonisation::protonTable

private

Definition at line 252 of file G4hImpactIonisation.hh.

theBarkas

G4bool G4hImpactIonisation::theBarkas

private

Definition at line 264 of file G4hImpactIonisation.hh.

theIonChuFluctuationModel

G4VLowEnergyModel* G4hImpactIonisation::theIonChuFluctuationModel

private

Definition at line 246 of file G4hImpactIonisation.hh.

theIonEffChargeModel

G4VLowEnergyModel* G4hImpactIonisation::theIonEffChargeModel

private

Definition at line 244 of file G4hImpactIonisation.hh.

theIonYangFluctuationModel

G4VLowEnergyModel* G4hImpactIonisation::theIonYangFluctuationModel

private

Definition at line 247 of file G4hImpactIonisation.hh.

theMeanFreePathTable

G4PhysicsTable* G4hImpactIonisation::theMeanFreePathTable

private

Definition at line 270 of file G4hImpactIonisation.hh.

theNuclearStoppingModel

G4VLowEnergyModel* G4hImpactIonisation::theNuclearStoppingModel

private

Definition at line 245 of file G4hImpactIonisation.hh.

theNuclearTable

G4String G4hImpactIonisation::theNuclearTable

private

Definition at line 254 of file G4hImpactIonisation.hh.

---

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

• G4hImpactIonisation.hh
• G4hImpactIonisation.cc