G4LowEnergyIonisation Class Reference

#include <G4LowEnergyIonisation.hh>

Inheritance diagram for G4LowEnergyIonisation:

Collaboration diagram for G4LowEnergyIonisation:

Public Member Functions
	G4LowEnergyIonisation (const G4String &processName="LowEnergyIoni")
	~G4LowEnergyIonisation ()
G4bool	IsApplicable (const G4ParticleDefinition &)
void	PrintInfoDefinition ()
void	BuildPhysicsTable (const G4ParticleDefinition &ParticleType)
G4VParticleChange *	PostStepDoIt (const G4Track &track, const G4Step &step)
void	SetCutForLowEnSecPhotons (G4double cut)
void	SetCutForLowEnSecElectrons (G4double cut)
void	ActivateAuger (G4bool val)
Public Member Functions inherited from G4eLowEnergyLoss
	G4eLowEnergyLoss (const G4String &)
	~G4eLowEnergyLoss ()
void	BuildDEDXTable (const G4ParticleDefinition &aParticleType)
G4double	GetContinuousStepLimit (const G4Track &track, G4double previousStepSize, G4double currentMinimumStep, G4double &currentSafety)
G4VParticleChange *	AlongStepDoIt (const G4Track &track, const G4Step &Step)
void	ActivateFluorescence (G4bool val)
G4bool	Fluorescence () const
Public Member Functions inherited from G4RDVeLowEnergyLoss
	G4RDVeLowEnergyLoss (const G4String &, G4ProcessType aType=fNotDefined)
	G4RDVeLowEnergyLoss (G4RDVeLowEnergyLoss &)
virtual	~G4RDVeLowEnergyLoss ()
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 &)

Protected Member Functions
G4double	GetMeanFreePath (const G4Track &track, G4double previousStepSize, G4ForceCondition *condition)
virtual std::vector < G4DynamicParticle * > *	DeexciteAtom (const G4MaterialCutsCouple *couple, G4double incidentEnergy, G4double eLoss)
Protected Member Functions inherited from G4RDVeLowEnergyLoss
G4double	GetLossWithFluct (const G4DynamicParticle *aParticle, const G4MaterialCutsCouple *couple, G4double MeanLoss, G4double step)
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 ()

Additional Inherited Members
Static Public Member Functions inherited from G4eLowEnergyLoss
static void	SetNbOfProcesses (G4int nb)
static void	PlusNbOfProcesses ()
static void	MinusNbOfProcesses ()
static G4int	GetNbOfProcesses ()
static void	SetLowerBoundEloss (G4double val)
static void	SetUpperBoundEloss (G4double val)
static void	SetNbinEloss (G4int nb)
static G4double	GetLowerBoundEloss ()
static G4double	GetUpperBoundEloss ()
static G4int	GetNbinEloss ()
Static Public Member Functions inherited from G4RDVeLowEnergyLoss
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)
Static Protected Member Functions inherited from G4RDVeLowEnergyLoss
static G4PhysicsTable *	BuildRangeTable (G4PhysicsTable *theDEDXTable, G4PhysicsTable *theRangeTable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildLabTimeTable (G4PhysicsTable *theDEDXTable, G4PhysicsTable *theLabTimeTable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildProperTimeTable (G4PhysicsTable *theDEDXTable, G4PhysicsTable *ProperTimeTable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildRangeCoeffATable (G4PhysicsTable *theRangeTable, G4PhysicsTable *theCoeffATable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildRangeCoeffBTable (G4PhysicsTable *theRangeTable, G4PhysicsTable *theCoeffBTable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildRangeCoeffCTable (G4PhysicsTable *theRangeTable, G4PhysicsTable *theCoeffCTable, G4double Tmin, G4double Tmax, G4int nbin)
static G4PhysicsTable *	BuildInverseRangeTable (G4PhysicsTable *theRangeTable, G4PhysicsTable *theRangeCoeffATable, G4PhysicsTable *theRangeCoeffBTable, G4PhysicsTable *theRangeCoeffCTable, G4PhysicsTable *theInverseRangeTable, G4double Tmin, G4double Tmax, G4int nbin)
Protected Attributes inherited from G4eLowEnergyLoss
G4PhysicsTable *	theLossTable
G4double	MinKineticEnergy
G4double	Charge
G4double	lastCharge
Protected Attributes inherited from G4RDVeLowEnergyLoss
const G4Material *	lastMaterial
G4int	imat
G4double	f1Fluct
G4double	f2Fluct
G4double	e1Fluct
G4double	e2Fluct
G4double	rateFluct
G4double	ipotFluct
G4double	e1LogFluct
G4double	e2LogFluct
G4double	ipotLogFluct
const G4int	nmaxCont1
const G4int	nmaxCont2
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 G4eLowEnergyLoss
static G4PhysicsTable *	theDEDXElectronTable = 0
static G4PhysicsTable *	theDEDXPositronTable = 0
static G4PhysicsTable *	theRangeElectronTable = 0
static G4PhysicsTable *	theRangePositronTable = 0
static G4PhysicsTable *	theInverseRangeElectronTable = 0
static G4PhysicsTable *	theInverseRangePositronTable = 0
static G4PhysicsTable *	theLabTimeElectronTable = 0
static G4PhysicsTable *	theLabTimePositronTable = 0
static G4PhysicsTable *	theProperTimeElectronTable = 0
static G4PhysicsTable *	theProperTimePositronTable = 0
static G4int	NbOfProcesses = 2
static G4int	CounterOfElectronProcess = 0
static G4int	CounterOfPositronProcess = 0
static G4PhysicsTable **	RecorderOfElectronProcess
static G4PhysicsTable **	RecorderOfPositronProcess
Static Protected Attributes inherited from G4RDVeLowEnergyLoss
static G4double	ParticleMass
static G4double	taulow
static G4double	tauhigh
static G4double	ltaulow
static G4double	ltauhigh
static G4double	dRoverRange = 20*perCent
static G4double	finalRange = 200*micrometer
static G4double	c1lim = dRoverRange
static G4double	c2lim = 2.*(1.-dRoverRange)*finalRange
static G4double	c3lim = -(1.-dRoverRange)*finalRange*finalRange
static G4bool	rndmStepFlag = false
static G4bool	EnlossFlucFlag = true

Detailed Description

Definition at line 71 of file G4LowEnergyIonisation.hh.

Constructor & Destructor Documentation

G4LowEnergyIonisation::G4LowEnergyIonisation

(

const G4String &

processName = "LowEnergyIoni"

)

Definition at line 125 of file G4LowEnergyIonisation.cc.

  : G4eLowEnergyLoss(nam), 
  crossSectionHandler(0),
  theMeanFreePath(0),
  energySpectrum(0),
  shellVacancy(0)
{
  cutForPhotons = 250.0*eV;
  cutForElectrons = 250.0*eV;
  verboseLevel = 0;
}

G4LowEnergyIonisation::~G4LowEnergyIonisation

(

)

Definition at line 138 of file G4LowEnergyIonisation.cc.

{
  delete crossSectionHandler;
  delete energySpectrum;
  delete theMeanFreePath;
  delete shellVacancy;
}

Member Function Documentation

void G4LowEnergyIonisation::ActivateAuger

(

G4bool

val

)

Definition at line 713 of file G4LowEnergyIonisation.cc.

{
  deexcitationManager.ActivateAugerElectronProduction(val);
}

Here is the call graph for this function:

void G4LowEnergyIonisation::BuildPhysicsTable ( const G4ParticleDefinition &  ParticleType )

virtual

Reimplemented from G4VProcess.

Definition at line 147 of file G4LowEnergyIonisation.cc.

{
  if(verboseLevel > 0) {
    G4cout << "G4LowEnergyIonisation::BuildPhysicsTable start"
           << G4endl;
      }

  cutForDelta.clear();

  // Create and fill IonisationParameters once
  if( energySpectrum != 0 ) delete energySpectrum;
  energySpectrum = new G4RDeIonisationSpectrum();

  if(verboseLevel > 0) {
    G4cout << "G4RDVEnergySpectrum is initialized"
           << G4endl;
      }

  // Create and fill G4RDCrossSectionHandler once

  if ( crossSectionHandler != 0 ) delete crossSectionHandler;
  G4RDVDataSetAlgorithm* interpolation = new G4RDSemiLogInterpolation();
  G4double lowKineticEnergy  = GetLowerBoundEloss();
  G4double highKineticEnergy = GetUpperBoundEloss();
  G4int    totBin = GetNbinEloss();
  crossSectionHandler = new G4RDeIonisationCrossSectionHandler(energySpectrum,
                                 interpolation,
                                 lowKineticEnergy,
                                 highKineticEnergy,
                                 totBin);
  crossSectionHandler->LoadShellData("ioni/ion-ss-cs-");

  if (verboseLevel > 0) {
    G4cout << GetProcessName()
           << " is created; Cross section data: "
           << G4endl;
    crossSectionHandler->PrintData();
    G4cout << "Parameters: "
           << G4endl;
    energySpectrum->PrintData();
  }

  // Build loss table for IonisationIV

  BuildLossTable(aParticleType);

  if(verboseLevel > 0) {
    G4cout << "The loss table is built"
           << G4endl;
      }

  if (&aParticleType==G4Electron::Electron()) {

    RecorderOfElectronProcess[CounterOfElectronProcess] = (*this).theLossTable;
    CounterOfElectronProcess++;
    PrintInfoDefinition();  

  } else {

    RecorderOfPositronProcess[CounterOfPositronProcess] = (*this).theLossTable;
    CounterOfPositronProcess++;
  }

  // Build mean free path data using cut values

  if( theMeanFreePath ) delete theMeanFreePath;
  theMeanFreePath = crossSectionHandler->
                    BuildMeanFreePathForMaterials(&cutForDelta);

  if(verboseLevel > 0) {
    G4cout << "The MeanFreePath table is built"
           << G4endl;
    if(verboseLevel > 1) theMeanFreePath->PrintData();
  }

  // Build common DEDX table for all ionisation processes
 
  BuildDEDXTable(aParticleType);

  if (verboseLevel > 0) {
    G4cout << "G4LowEnergyIonisation::BuildPhysicsTable end"
           << G4endl;
  }
}

Here is the call graph for this function:

std::vector< G4DynamicParticle * > * G4LowEnergyIonisation::DeexciteAtom ( const G4MaterialCutsCouple *  couple, G4double  incidentEnergy, G4double  eLoss  )

protectedvirtual

Reimplemented from G4eLowEnergyLoss.

Definition at line 606 of file G4LowEnergyIonisation.cc.

{
  // create vector of secondary particles
  const G4Material* material = couple->GetMaterial();

  std::vector<G4DynamicParticle*>* partVector =
                                 new std::vector<G4DynamicParticle*>;

  if(eLoss > cutForPhotons && eLoss > cutForElectrons) {

    const G4RDAtomicTransitionManager* transitionManager =
                               G4RDAtomicTransitionManager::Instance();

    size_t nElements = material->GetNumberOfElements();
    const G4ElementVector* theElementVector = material->GetElementVector();

    std::vector<G4DynamicParticle*>* secVector = 0;
    G4DynamicParticle* aSecondary = 0;
    G4ParticleDefinition* type = 0;
    G4double e;
    G4ThreeVector position;
    G4int shell, shellId;

    // sample secondaries

    G4double eTot = 0.0;
    std::vector<G4int> n =
           shellVacancy->GenerateNumberOfIonisations(couple,
                                                     incidentEnergy,eLoss);
    for (size_t i=0; i<nElements; i++) {

      G4int Z = (G4int)((*theElementVector)[i]->GetZ());
      size_t nVacancies = n[i];

      G4double maxE = transitionManager->Shell(Z, 0)->BindingEnergy();

      if (nVacancies && Z > 5 && (maxE>cutForPhotons || maxE>cutForElectrons)) {

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

      shell = crossSectionHandler->SelectRandomShell(Z, incidentEnergy);
          shellId = transitionManager->Shell(Z, shell)->ShellId();
      G4double maxEShell =
                     transitionManager->Shell(Z, shell)->BindingEnergy();

          if (maxEShell>cutForPhotons || maxEShell>cutForElectrons ) {

        secVector = deexcitationManager.GenerateParticles(Z, shellId);

        if (secVector != 0) {

          for (size_t l = 0; l<secVector->size(); l++) {

            aSecondary = (*secVector)[l];
            if (aSecondary != 0) {

              e = aSecondary->GetKineticEnergy();
              type = aSecondary->GetDefinition();
              if ( eTot + e <= eLoss &&
                 ((type == G4Gamma::Gamma() && e>cutForPhotons ) ||
                 (type == G4Electron::Electron() && e>cutForElectrons))) {

              eTot += e;
                          partVector->push_back(aSecondary);

          } else {

                           delete aSecondary;

              }
            }
          }
              delete secVector;
        }
      }
    }
      }
    }
  }
  return partVector;
}

Here is the call graph for this function:

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

protectedvirtual

Implements G4eLowEnergyLoss.

Definition at line 690 of file G4LowEnergyIonisation.cc.

{
   *cond = NotForced;
   G4int index = (track.GetMaterialCutsCouple())->GetIndex();
   const G4RDVEMDataSet* data = theMeanFreePath->GetComponent(index);
   G4double meanFreePath = data->FindValue(track.GetKineticEnergy());
   return meanFreePath;
}

Here is the call graph for this function:

G4bool G4LowEnergyIonisation::IsApplicable ( const G4ParticleDefinition &  particle )

virtual

Reimplemented from G4eLowEnergyLoss.

Definition at line 600 of file G4LowEnergyIonisation.cc.

{
   return ( (&particle == G4Electron::Electron()) );
}

Here is the call graph for this function:

G4VParticleChange * G4LowEnergyIonisation::PostStepDoIt ( const G4Track &  track, const G4Step &  step  )

virtual

Implements G4eLowEnergyLoss.

Definition at line 405 of file G4LowEnergyIonisation.cc.

{
  // Delta electron production mechanism on base of the model
  // J. Stepanek " A program to determine the radiation spectra due
  // to a single atomic subshell ionisation by a particle or due to
  // deexcitation or decay of radionuclides",
  // Comp. Phys. Comm. 1206 pp 1-19 (1997)

  aParticleChange.Initialize(track);

  const G4MaterialCutsCouple* couple = track.GetMaterialCutsCouple();
  G4double kineticEnergy = track.GetKineticEnergy();

  // Select atom and shell

  G4int Z = crossSectionHandler->SelectRandomAtom(couple, kineticEnergy);
  G4int shell = crossSectionHandler->SelectRandomShell(Z, kineticEnergy);
  const G4RDAtomicShell* atomicShell =
                (G4RDAtomicTransitionManager::Instance())->Shell(Z, shell);
  G4double bindingEnergy = atomicShell->BindingEnergy();
  G4int shellId = atomicShell->ShellId();

  // Sample delta energy

  G4int    index  = couple->GetIndex();
  G4double tCut   = cutForDelta[index];
  G4double tmax   = energySpectrum->MaxEnergyOfSecondaries(kineticEnergy);
  G4double tDelta = energySpectrum->SampleEnergy(Z, tCut, tmax,
                                                 kineticEnergy, shell);

  if(tDelta == 0.0)
    return G4VContinuousDiscreteProcess::PostStepDoIt(track, step);

  // Transform to shell potential
  G4double deltaKinE = tDelta + 2.0*bindingEnergy;
  G4double primaryKinE = kineticEnergy + 2.0*bindingEnergy;

  // sampling of scattering angle neglecting atomic motion
  G4double deltaMom = std::sqrt(deltaKinE*(deltaKinE + 2.0*electron_mass_c2));
  G4double primaryMom = std::sqrt(primaryKinE*(primaryKinE + 2.0*electron_mass_c2));

  G4double cost = deltaKinE * (primaryKinE + 2.0*electron_mass_c2)
                            / (deltaMom * primaryMom);

  if (cost > 1.) cost = 1.;
  G4double sint = std::sqrt(1. - cost*cost);
  G4double phi  = twopi * G4UniformRand();
  G4double dirx = sint * std::cos(phi);
  G4double diry = sint * std::sin(phi);
  G4double dirz = cost;

  // Rotate to incident electron direction
  G4ThreeVector primaryDirection = track.GetMomentumDirection();
  G4ThreeVector deltaDir(dirx,diry,dirz);
  deltaDir.rotateUz(primaryDirection);
  dirx = deltaDir.x();
  diry = deltaDir.y();
  dirz = deltaDir.z();


  // Take into account atomic motion del is relative momentum of the motion
  // kinetic energy of the motion == bindingEnergy in V.Ivanchenko model

  cost = 2.0*G4UniformRand() - 1.0;
  sint = std::sqrt(1. - cost*cost);
  phi  = twopi * G4UniformRand();
  G4double del = std::sqrt(bindingEnergy *(bindingEnergy + 2.0*electron_mass_c2))
               / deltaMom;
  dirx += del* sint * std::cos(phi);
  diry += del* sint * std::sin(phi);
  dirz += del* cost;

  // Find out new primary electron direction
  G4double finalPx = primaryMom*primaryDirection.x() - deltaMom*dirx;
  G4double finalPy = primaryMom*primaryDirection.y() - deltaMom*diry;
  G4double finalPz = primaryMom*primaryDirection.z() - deltaMom*dirz;

  // create G4DynamicParticle object for delta ray
  G4DynamicParticle* theDeltaRay = new G4DynamicParticle();
  theDeltaRay->SetKineticEnergy(tDelta);
  G4double norm = 1.0/std::sqrt(dirx*dirx + diry*diry + dirz*dirz);
  dirx *= norm;
  diry *= norm;
  dirz *= norm;
  theDeltaRay->SetMomentumDirection(dirx, diry, dirz);
  theDeltaRay->SetDefinition(G4Electron::Electron());

  G4double theEnergyDeposit = bindingEnergy;

  // fill ParticleChange
  // changed energy and momentum of the actual particle

  G4double finalKinEnergy = kineticEnergy - tDelta - theEnergyDeposit;
  if(finalKinEnergy < 0.0) {
    theEnergyDeposit += finalKinEnergy;
    finalKinEnergy    = 0.0;
    aParticleChange.ProposeTrackStatus(fStopAndKill);

  } else {

    G4double norm = 1.0/std::sqrt(finalPx*finalPx+finalPy*finalPy+finalPz*finalPz);
    finalPx *= norm;
    finalPy *= norm;
    finalPz *= norm;
    aParticleChange.ProposeMomentumDirection(finalPx, finalPy, finalPz);
  }

  aParticleChange.ProposeEnergy(finalKinEnergy);

  // Generation of Fluorescence and Auger
  size_t nSecondaries = 0;
  size_t totalNumber  = 1;
  std::vector<G4DynamicParticle*>* secondaryVector = 0;
  G4DynamicParticle* aSecondary = 0;
  G4ParticleDefinition* type = 0;

  // Fluorescence data start from element 6

  if (Fluorescence() && Z > 5 && (bindingEnergy >= cutForPhotons
            ||  bindingEnergy >= cutForElectrons)) {

    secondaryVector = deexcitationManager.GenerateParticles(Z, shellId);

    if (secondaryVector != 0) {

      nSecondaries = secondaryVector->size();
      for (size_t i = 0; i<nSecondaries; i++) {

        aSecondary = (*secondaryVector)[i];
        if (aSecondary) {

          G4double e = aSecondary->GetKineticEnergy();
          type = aSecondary->GetDefinition();
          if (e < theEnergyDeposit &&
                ((type == G4Gamma::Gamma() && e > cutForPhotons ) ||
                 (type == G4Electron::Electron() && e > cutForElectrons ))) {

             theEnergyDeposit -= e;
             totalNumber++;

      } else {

             delete aSecondary;
             (*secondaryVector)[i] = 0;
      }
    }
      }
    }
  }

  // Save delta-electrons

  aParticleChange.SetNumberOfSecondaries(totalNumber);
  aParticleChange.AddSecondary(theDeltaRay);

  // Save Fluorescence and Auger

  if (secondaryVector) {

    for (size_t l = 0; l < nSecondaries; l++) {

      aSecondary = (*secondaryVector)[l];

      if(aSecondary) {

        aParticleChange.AddSecondary(aSecondary);
      }
    }
    delete secondaryVector;
  }

  if(theEnergyDeposit < 0.) {
    G4cout << "G4LowEnergyIonisation: Negative energy deposit: "
           << theEnergyDeposit/eV << " eV" << G4endl;
    theEnergyDeposit = 0.0;
  }
  aParticleChange.ProposeLocalEnergyDeposit(theEnergyDeposit);

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

Here is the call graph for this function:

void G4LowEnergyIonisation::PrintInfoDefinition

(

)

Definition at line 588 of file G4LowEnergyIonisation.cc.

{
  G4String comments = "Total cross sections from EEDL database.";
  comments += "\n      Gamma energy sampled from a parametrised formula.";
  comments += "\n      Implementation of the continuous dE/dx part.";
  comments += "\n      At present it can be used for electrons ";
  comments += "in the energy range [250eV,100GeV].";
  comments += "\n      The process must work with G4LowEnergyBremsstrahlung.";

  G4cout << G4endl << GetProcessName() << ":  " << comments << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4LowEnergyIonisation::SetCutForLowEnSecElectrons

(

G4double

cut

)

Definition at line 707 of file G4LowEnergyIonisation.cc.

{
  cutForElectrons = cut;
  deexcitationManager.SetCutForAugerElectrons(cut);
}

Here is the call graph for this function:

void G4LowEnergyIonisation::SetCutForLowEnSecPhotons

(

G4double

cut

)

Definition at line 701 of file G4LowEnergyIonisation.cc.

{
  cutForPhotons = cut;
  deexcitationManager.SetCutForSecondaryPhotons(cut);
}

Here is the call graph for this function:

---

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

• source/geant4.10.03.p03/examples/advanced/eRosita/physics/include/G4LowEnergyIonisation.hh
• source/geant4.10.03.p03/examples/advanced/eRosita/physics/src/G4LowEnergyIonisation.cc