G4PenelopeIonisationModel Class Reference

#include <G4PenelopeIonisationModel.hh>

Inheritance diagram for G4PenelopeIonisationModel:

Public Member Functions
	G4PenelopeIonisationModel (const G4ParticleDefinition *p=nullptr, const G4String &processName="PenIoni")
virtual	~G4PenelopeIonisationModel ()
void	Initialise (const G4ParticleDefinition *, const G4DataVector &) override
void	InitialiseLocal (const G4ParticleDefinition *, G4VEmModel *) override
G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double, G4double, G4double, G4double, G4double) override
G4double	CrossSectionPerVolume (const G4Material *material, const G4ParticleDefinition *theParticle, G4double kineticEnergy, G4double cutEnergy, G4double maxEnergy=DBL_MAX) override
void	SampleSecondaries (std::vector< G4DynamicParticle * > *, const G4MaterialCutsCouple *, const G4DynamicParticle *, G4double tmin, G4double maxEnergy) override
G4double	ComputeDEDXPerVolume (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy) override
G4double	MinEnergyCut (const G4ParticleDefinition *, const G4MaterialCutsCouple *) override
void	SetVerbosityLevel (G4int lev)
G4int	GetVerbosityLevel ()
G4PenelopeIonisationModel &	operator= (const G4PenelopeIonisationModel &right)=delete
	G4PenelopeIonisationModel (const G4PenelopeIonisationModel &)=delete
Public Member Functions inherited from G4VEmModel
	G4VEmModel (const G4String &nam)
virtual	~G4VEmModel ()
virtual void	InitialiseForMaterial (const G4ParticleDefinition *, const G4Material *)
virtual void	InitialiseForElement (const G4ParticleDefinition *, G4int Z)
virtual G4double	GetPartialCrossSection (const G4Material *, G4int level, const G4ParticleDefinition *, G4double kineticEnergy)
virtual G4double	ComputeCrossSectionPerShell (const G4ParticleDefinition *, G4int Z, G4int shellIdx, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
virtual G4double	ChargeSquareRatio (const G4Track &)
virtual G4double	GetChargeSquareRatio (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual G4double	GetParticleCharge (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual void	StartTracking (G4Track *)
virtual void	CorrectionsAlongStep (const G4Material *, const G4ParticleDefinition *, const G4double kinEnergy, const G4double cutEnergy, const G4double &length, G4double &eloss)
virtual G4double	Value (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy)
virtual G4double	MinPrimaryEnergy (const G4Material *, const G4ParticleDefinition *, G4double cut=0.0)
virtual void	SetupForMaterial (const G4ParticleDefinition *, const G4Material *, G4double kineticEnergy)
virtual void	DefineForRegion (const G4Region *)
virtual void	FillNumberOfSecondaries (G4int &numberOfTriplets, G4int &numberOfRecoil)
virtual void	ModelDescription (std::ostream &outFile) const
void	InitialiseElementSelectors (const G4ParticleDefinition *, const G4DataVector &)
std::vector< G4EmElementSelector * > *	GetElementSelectors ()
void	SetElementSelectors (std::vector< G4EmElementSelector * > *)
G4double	ComputeDEDX (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=DBL_MAX)
G4double	CrossSection (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4double	ComputeMeanFreePath (const G4ParticleDefinition *, G4double kineticEnergy, const G4Material *, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, const G4Element *, G4double kinEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
const G4Element *	SelectRandomAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
const G4Element *	SelectTargetAtom (const G4MaterialCutsCouple *, const G4ParticleDefinition *, G4double kineticEnergy, G4double logKineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
const G4Element *	SelectRandomAtom (const G4Material *, const G4ParticleDefinition *, G4double kineticEnergy, G4double cutEnergy=0.0, G4double maxEnergy=DBL_MAX)
const G4Element *	GetCurrentElement (const G4Material *mat=nullptr) const
G4int	SelectRandomAtomNumber (const G4Material *) const
const G4Isotope *	GetCurrentIsotope (const G4Element *elm=nullptr) const
G4int	SelectIsotopeNumber (const G4Element *) const
void	SetParticleChange (G4VParticleChange *, G4VEmFluctuationModel *f=nullptr)
void	SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)
G4ElementData *	GetElementData ()
G4PhysicsTable *	GetCrossSectionTable ()
G4VEmFluctuationModel *	GetModelOfFluctuations ()
G4VEmAngularDistribution *	GetAngularDistribution ()
G4VEmModel *	GetTripletModel ()
void	SetTripletModel (G4VEmModel *)
void	SetAngularDistribution (G4VEmAngularDistribution *)
G4double	HighEnergyLimit () const
G4double	LowEnergyLimit () const
G4double	HighEnergyActivationLimit () const
G4double	LowEnergyActivationLimit () const
G4double	PolarAngleLimit () const
G4double	SecondaryThreshold () const
G4bool	DeexcitationFlag () const
G4bool	ForceBuildTableFlag () const
G4bool	UseAngularGeneratorFlag () const
void	SetAngularGeneratorFlag (G4bool)
void	SetHighEnergyLimit (G4double)
void	SetLowEnergyLimit (G4double)
void	SetActivationHighEnergyLimit (G4double)
void	SetActivationLowEnergyLimit (G4double)
G4bool	IsActive (G4double kinEnergy) const
void	SetPolarAngleLimit (G4double)
void	SetSecondaryThreshold (G4double)
void	SetDeexcitationFlag (G4bool val)
void	SetForceBuildTable (G4bool val)
void	SetFluctuationFlag (G4bool val)
G4bool	IsMaster () const
void	SetUseBaseMaterials (G4bool val)
G4bool	UseBaseMaterials () const
G4double	MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)
const G4String &	GetName () const
void	SetCurrentCouple (const G4MaterialCutsCouple *)
G4bool	IsLocked () const
void	SetLocked (G4bool)
void	SetLPMFlag (G4bool)
void	SetMasterThread (G4bool)
G4VEmModel &	operator= (const G4VEmModel &right)=delete
	G4VEmModel (const G4VEmModel &)=delete

Protected Attributes
G4ParticleChangeForLoss *	fParticleChange
const G4ParticleDefinition *	fParticle
Protected Attributes inherited from G4VEmModel
G4ElementData *	fElementData = nullptr
G4VParticleChange *	pParticleChange = nullptr
G4PhysicsTable *	xSectionTable = nullptr
const G4Material *	pBaseMaterial = nullptr
const std::vector< G4double > *	theDensityFactor = nullptr
const std::vector< G4int > *	theDensityIdx = nullptr
G4double	inveplus
G4double	pFactor = 1.0
std::size_t	currentCoupleIndex = 0
std::size_t	basedCoupleIndex = 0
G4bool	lossFlucFlag = true

Additional Inherited Members
Protected Member Functions inherited from G4VEmModel
G4ParticleChangeForLoss *	GetParticleChangeForLoss ()
G4ParticleChangeForGamma *	GetParticleChangeForGamma ()
virtual G4double	MaxSecondaryEnergy (const G4ParticleDefinition *, G4double kineticEnergy)
const G4MaterialCutsCouple *	CurrentCouple () const
void	SetCurrentElement (const G4Element *)

Detailed Description

Definition at line 65 of file G4PenelopeIonisationModel.hh.

Constructor & Destructor Documentation

G4PenelopeIonisationModel() [1/2]

G4PenelopeIonisationModel::G4PenelopeIonisationModel ( const G4ParticleDefinition * p = nullptr, const G4String & processName = "PenIoni" )

explicit

Definition at line 73 of file G4PenelopeIonisationModel.cc.

  :G4VEmModel(nam),fParticleChange(nullptr),fParticle(nullptr),
   fCrossSectionHandler(nullptr), 
   fAtomDeexcitation(nullptr), fKineticEnergy1(0.*eV),
   fCosThetaPrimary(1.0),fEnergySecondary(0.*eV),
   fCosThetaSecondary(0.0),fTargetOscillator(-1),
   fIsInitialised(false),fPIXEflag(false),fLocalTable(false)
{
  fIntrinsicLowEnergyLimit = 100.0*eV;
  fIntrinsicHighEnergyLimit = 100.0*GeV;
  //  SetLowEnergyLimit(fIntrinsicLowEnergyLimit);
  SetHighEnergyLimit(fIntrinsicHighEnergyLimit);
  fNBins = 200;
 
  if (part)
    SetParticle(part);
 
  //
  fOscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
  //
  fVerboseLevel= 0;   
  // Verbosity scale:
  // 0 = nothing
  // 1 = warning for energy non-conservation
  // 2 = details of energy budget
  // 3 = calculation of cross sections, file openings, sampling of atoms
  // 4 = entering in methods
 
  // Atomic deexcitation model activated by default
  SetDeexcitationFlag(true);
}

Referenced by G4PenelopeIonisationModel(), InitialiseLocal(), and operator=().

~G4PenelopeIonisationModel()

G4PenelopeIonisationModel::~G4PenelopeIonisationModel ( )

virtual

Definition at line 108 of file G4PenelopeIonisationModel.cc.

{
  if (IsMaster() || fLocalTable)
    {
      if (fCrossSectionHandler)
    delete fCrossSectionHandler;
    }
}

G4PenelopeIonisationModel() [2/2]

G4PenelopeIonisationModel::G4PenelopeIonisationModel ( const G4PenelopeIonisationModel & )

delete

Member Function Documentation

ComputeCrossSectionPerAtom()

G4double G4PenelopeIonisationModel::ComputeCrossSectionPerAtom ( const G4ParticleDefinition * , G4double , G4double , G4double , G4double , G4double  )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 342 of file G4PenelopeIonisationModel.cc.

{
  G4cout << "*** G4PenelopeIonisationModel -- WARNING ***" << G4endl;
  G4cout << "Penelope Ionisation model v2008 does not calculate cross section _per atom_ " << G4endl;
  G4cout << "so the result is always zero. For physics values, please invoke " << G4endl;
  G4cout << "GetCrossSectionPerVolume() or GetMeanFreePath() via the G4EmCalculator" << G4endl;
  return 0;
}

ComputeDEDXPerVolume()

G4double G4PenelopeIonisationModel::ComputeDEDXPerVolume ( const G4Material * material, const G4ParticleDefinition * theParticle, G4double kineticEnergy, G4double cutEnergy )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 358 of file G4PenelopeIonisationModel.cc.

{
  // Penelope model v2008 to calculate the stopping power for soft inelastic collisions
  // below the threshold. It makes use of the Generalised Oscillator Strength (GOS)
  // model from
  //  D. Liljequist, J. Phys. D: Appl. Phys. 16 (1983) 1567
  //
  // The stopping power is calculated analytically using the dsigma/dW cross
  // section from the GOS models, which includes separate contributions from
  // distant longitudinal collisions, distant transverse collisions and
  // close collisions. Only the atomic oscillators that come in the play
  // (according to the threshold) are considered for the calculation.
  // Differential cross sections have a different form for e+ and e-.
  //
  // Fermi density correction is calculated analytically according to
  //  U. Fano, Ann. Rev. Nucl. Sci. 13 (1963),1
 
  if (fVerboseLevel > 3)
    G4cout << "Calling ComputeDEDX() of G4PenelopeIonisationModel" << G4endl;
 
  //Either Initialize() was not called, or we are in a slave and InitializeLocal() was 
  //not invoked
  if (!fCrossSectionHandler)
    {
      //create a **thread-local** version of the table. Used only for G4EmCalculator and 
      //Unit Tests
      fLocalTable = true;
      fCrossSectionHandler = new G4PenelopeIonisationXSHandler(fNBins); 
    }
 
  const G4PenelopeCrossSection* theXS = 
    fCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,material,
                              cutEnergy);
  if (!theXS)
    {
      //If we are here, it means that Initialize() was inkoved, but the MaterialTable was 
      //not filled up. This can happen in a UnitTest or via G4EmCalculator
      if (fVerboseLevel > 0)
    {   
      //Issue a G4Exception (warning) only in verbose mode
      G4ExceptionDescription ed;
      ed << "Unable to retrieve the cross section table for " << 
        theParticle->GetParticleName() <<
        " in " << material->GetName() << ", cut = " << cutEnergy/keV << " keV " << G4endl;
      ed << "This can happen only in Unit Tests or via G4EmCalculator" << G4endl;
      G4Exception("G4PenelopeIonisationModel::ComputeDEDXPerVolume()",
              "em2038",JustWarning,ed);
    }
      //protect file reading via autolock
      G4AutoLock lock(&PenelopeIonisationModelMutex);
      fCrossSectionHandler->BuildXSTable(material,cutEnergy,theParticle);
      lock.unlock();
      //now it should be ok
      theXS = 
    fCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,
                              material,
                              cutEnergy);
    }
 
  G4double sPowerPerMolecule = 0.0;
  if (theXS)
    sPowerPerMolecule = theXS->GetSoftStoppingPower(kineticEnergy);
 
  G4double atomDensity = material->GetTotNbOfAtomsPerVolume();
  G4double atPerMol =  fOscManager->GetAtomsPerMolecule(material);
                                                                                        
  G4double moleculeDensity = 0.; 
  if (atPerMol)
    moleculeDensity = atomDensity/atPerMol;
  G4double sPowerPerVolume = sPowerPerMolecule*moleculeDensity;
 
  if (fVerboseLevel > 2)
    {
      G4cout << "G4PenelopeIonisationModel " << G4endl;
      G4cout << "Stopping power < " << cutEnergy/keV << " keV at " <<
        kineticEnergy/keV << " keV = " << 
    sPowerPerVolume/(keV/mm) << " keV/mm" << G4endl;
    }
  return sPowerPerVolume;
}

CrossSectionPerVolume()

G4double G4PenelopeIonisationModel::CrossSectionPerVolume ( const G4Material * material, const G4ParticleDefinition * theParticle, G4double kineticEnergy, G4double cutEnergy, G4double maxEnergy = DBL_MAX )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 236 of file G4PenelopeIonisationModel.cc.

{
  // Penelope model v2008 to calculate the cross section for inelastic collisions above the
  // threshold. It makes use of the Generalised Oscillator Strength (GOS) model from
  //  D. Liljequist, J. Phys. D: Appl. Phys. 16 (1983) 1567
  //
  // The total cross section is calculated analytically by taking
  // into account the atomic oscillators coming into the play for a given threshold.
  //
  // For incident e- the maximum energy allowed for the delta-rays is energy/2.
  // because particles are undistinghishable.
  //
  // The contribution is splitted in three parts: distant longitudinal collisions,
  // distant transverse collisions and close collisions. Each term is described by
  // its own analytical function.
  // Fermi density correction is calculated analytically according to
  //  U. Fano, Ann. Rev. Nucl. Sci. 13 (1963),1
  //
  if (fVerboseLevel > 3)
    G4cout << "Calling CrossSectionPerVolume() of G4PenelopeIonisationModel" << G4endl;
 
  SetupForMaterial(theParticle, material, energy);
   
  G4double totalCross = 0.0;
  G4double crossPerMolecule = 0.;
 
  //Either Initialize() was not called, or we are in a slave and InitializeLocal() was 
  //not invoked
  if (!fCrossSectionHandler)
    {
      //create a **thread-local** version of the table. Used only for G4EmCalculator and 
      //Unit Tests
      fLocalTable = true;
      fCrossSectionHandler = new G4PenelopeIonisationXSHandler(fNBins); 
    }
  
  const G4PenelopeCrossSection* theXS = 
    fCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,
                              material,
                              cutEnergy);
  if (!theXS)
    {
      //If we are here, it means that Initialize() was inkoved, but the MaterialTable was 
      //not filled up. This can happen in a UnitTest or via G4EmCalculator
      if (fVerboseLevel > 0)
    {
      //Issue a G4Exception (warning) only in verbose mode
      G4ExceptionDescription ed;
      ed << "Unable to retrieve the cross section table for " << 
        theParticle->GetParticleName() << 
        " in " << material->GetName() << ", cut = " << cutEnergy/keV << " keV " << G4endl;
      ed << "This can happen only in Unit Tests or via G4EmCalculator" << G4endl;
      G4Exception("G4PenelopeIonisationModel::CrossSectionPerVolume()",
              "em2038",JustWarning,ed);
    }
      //protect file reading via autolock
      G4AutoLock lock(&PenelopeIonisationModelMutex);
      fCrossSectionHandler->BuildXSTable(material,cutEnergy,theParticle);
      lock.unlock();
      //now it should be ok
      theXS = 
    fCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,
                              material,
                              cutEnergy);
    }
 
  if (theXS)
    crossPerMolecule = theXS->GetHardCrossSection(energy);
 
  G4double atomDensity = material->GetTotNbOfAtomsPerVolume();
  G4double atPerMol =  fOscManager->GetAtomsPerMolecule(material);
 
  if (fVerboseLevel > 3)
    G4cout << "Material " << material->GetName() << " has " << atPerMol <<
      "atoms per molecule" << G4endl;
 
  G4double moleculeDensity = 0.; 
  if (atPerMol)
    moleculeDensity = atomDensity/atPerMol;
  G4double crossPerVolume = crossPerMolecule*moleculeDensity;
 
  if (fVerboseLevel > 2)
  {
    G4cout << "G4PenelopeIonisationModel " << G4endl;
    G4cout << "Mean free path for delta emission > " << cutEnergy/keV << " keV at " <<
      energy/keV << " keV = " << 
      (crossPerVolume ? (1./crossPerVolume)/mm : DBL_MAX) << " mm" << G4endl;
    if (theXS)
      totalCross = (theXS->GetTotalCrossSection(energy))*moleculeDensity;
    G4cout << "Total free path for ionisation (no threshold) at " <<
      energy/keV << " keV = " << 
      (totalCross ? (1./totalCross)/mm : DBL_MAX) << " mm" << G4endl;
  }
  return crossPerVolume;
}

GetVerbosityLevel()

G4int G4PenelopeIonisationModel::GetVerbosityLevel ( )

inline

Definition at line 109 of file G4PenelopeIonisationModel.hh.

{return fVerboseLevel;};

Initialise()

void G4PenelopeIonisationModel::Initialise ( const G4ParticleDefinition * particle, const G4DataVector & theCuts )

overridevirtual

Implements G4VEmModel.

Definition at line 119 of file G4PenelopeIonisationModel.cc.

{
  if (fVerboseLevel > 3)
    G4cout << "Calling G4PenelopeIonisationModel::Initialise()" << G4endl;
 
  fAtomDeexcitation = G4LossTableManager::Instance()->AtomDeexcitation();
  //Issue warning if the AtomicDeexcitation has not been declared
  if (!fAtomDeexcitation)
    {
      G4cout << G4endl;
      G4cout << "WARNING from G4PenelopeIonisationModel " << G4endl;
      G4cout << "Atomic de-excitation module is not instantiated, so there will not be ";
      G4cout << "any fluorescence/Auger emission." << G4endl;
      G4cout << "Please make sure this is intended" << G4endl;
    }
 
  if (fAtomDeexcitation)
    fPIXEflag = fAtomDeexcitation->IsPIXEActive();
 
  //If the PIXE flag is active, the PIXE interface will take care of the 
  //atomic de-excitation. The model does not need to do that.
  //Issue warnings here
  if (fPIXEflag && IsMaster() && particle==G4Electron::Electron())
    {
      G4String theModel = G4EmParameters::Instance()->PIXEElectronCrossSectionModel();
      G4cout << "======================================================================" << G4endl;
      G4cout << "The G4PenelopeIonisationModel is being used with the PIXE flag ON." << G4endl;
      G4cout << "Atomic de-excitation will be produced statistically by the PIXE " << G4endl;
      G4cout << "interface by using the shell cross section --> " << theModel << G4endl;
      G4cout << "The built-in model procedure for atomic de-excitation is disabled. " << G4endl;
      G4cout << "*Please be sure this is intended*, or disable PIXE by" << G4endl;
      G4cout << "/process/em/pixe false" << G4endl;    
      G4cout << "======================================================================" << G4endl;
    }
 
  SetParticle(particle);
 
  //Only the master model creates/manages the tables. All workers get the 
  //pointer to the table, and use it as readonly
  if (IsMaster() && particle == fParticle)
    {
      //Set the number of bins for the tables. 20 points per decade
      fNBins = (std::size_t) (20*std::log10(HighEnergyLimit()/LowEnergyLimit()));
      fNBins = std::max(fNBins,(std::size_t)100);
      
      //Clear and re-build the tables
      if (fCrossSectionHandler)
    {
      delete fCrossSectionHandler;
      fCrossSectionHandler = 0;
    }
      fCrossSectionHandler = new G4PenelopeIonisationXSHandler(fNBins);
      fCrossSectionHandler->SetVerboseLevel(fVerboseLevel);
 
      //Build tables for all materials
      G4ProductionCutsTable* theCoupleTable = 
    G4ProductionCutsTable::GetProductionCutsTable();      
      for (G4int i=0;i<(G4int)theCoupleTable->GetTableSize();++i)
    {
      const G4Material* theMat = 
        theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial();
      //Forces the building of the cross section tables
      fCrossSectionHandler->BuildXSTable(theMat,theCuts.at(i),particle,
                           IsMaster());  
    }
 
      if (fVerboseLevel > 2) {
    G4cout << "Penelope Ionisation model v2008 is initialized " << G4endl
           << "Energy range: "
           << LowEnergyLimit() / keV << " keV - "
           << HighEnergyLimit() / GeV << " GeV. Using " 
           << fNBins << " bins." 
           << G4endl;
      }
    }
 
  if(fIsInitialised) 
    return;
  fParticleChange = GetParticleChangeForLoss();
  fIsInitialised = true;
 
  return;
}

InitialiseLocal()

void G4PenelopeIonisationModel::InitialiseLocal ( const G4ParticleDefinition * part, G4VEmModel * masterModel )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 206 of file G4PenelopeIonisationModel.cc.

{
  if (fVerboseLevel > 3)
    G4cout << "Calling  G4PenelopeIonisationModel::InitialiseLocal()" << G4endl;
  //
  //Check that particle matches: one might have multiple master models (e.g. 
  //for e+ and e-).
  //
  if (part == fParticle)
    {
      //Get the const table pointers from the master to the workers
      const G4PenelopeIonisationModel* theModel = 
    static_cast<G4PenelopeIonisationModel*> (masterModel);
      
      //Copy pointers to the data tables
      fCrossSectionHandler = theModel->fCrossSectionHandler;
      
      //copy data
      fNBins = theModel->fNBins;
      
      //Same verbosity for all workers, as the master
      fVerboseLevel = theModel->fVerboseLevel;
    }
  return;
}

MinEnergyCut()

G4double G4PenelopeIonisationModel::MinEnergyCut ( const G4ParticleDefinition * , const G4MaterialCutsCouple *  )

overridevirtual

Reimplemented from G4VEmModel.

Definition at line 444 of file G4PenelopeIonisationModel.cc.

{
  return fIntrinsicLowEnergyLimit;
}

operator=()

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

delete

SampleSecondaries()

void G4PenelopeIonisationModel::SampleSecondaries ( std::vector< G4DynamicParticle * > * fvect, const G4MaterialCutsCouple * couple, const G4DynamicParticle * aDynamicParticle, G4double tmin, G4double maxEnergy )

overridevirtual

Implements G4VEmModel.

Definition at line 452 of file G4PenelopeIonisationModel.cc.

{
  // Penelope model v2008 to sample the final state following an hard inelastic interaction.
  // It makes use of the Generalised Oscillator Strength (GOS) model from
  //  D. Liljequist, J. Phys. D: Appl. Phys. 16 (1983) 1567
  //
  // The GOS model is used to calculate the individual cross sections for all
  // the atomic oscillators coming in the play, taking into account the three
  // contributions (distant longitudinal collisions, distant transverse collisions and
  // close collisions). Then the target shell and the interaction channel are
  // sampled. Final state of the delta-ray (energy, angle) are generated according
  // to the analytical distributions (dSigma/dW) for the selected interaction
  // channels.
  // For e-, the maximum energy for the delta-ray is initialEnergy/2. (because
  // particles are indistinghusbable), while it is the full initialEnergy for
  // e+.
  // The efficiency of the random sampling algorithm (e.g. for close collisions)
  // decreases when initial and cutoff energy increase (e.g. 87% for 10-keV primary
  // and 1 keV threshold, 99% for 10-MeV primary and 10-keV threshold).
  // Differential cross sections have a different form for e+ and e-.
  //
  // WARNING: The model provides an _average_ description of inelastic collisions.
  // Anyway, the energy spectrum associated to distant excitations of a given
  // atomic shell is approximated as a single resonance. The simulated energy spectra
  // show _unphysical_ narrow peaks at energies that are multiple of the shell
  // resonance energies. The spurious speaks are automatically smoothed out after
  // multiple inelastic collisions.
  //
  // The model determines also the original shell from which the delta-ray is expelled,
  // in order to produce fluorescence de-excitation (from G4DeexcitationManager)
  //
  // Fermi density correction is calculated analytically according to
  //  U. Fano, Ann. Rev. Nucl. Sci. 13 (1963),1
 
  if (fVerboseLevel > 3)
    G4cout << "Calling SamplingSecondaries() of G4PenelopeIonisationModel" << G4endl;
 
  G4double kineticEnergy0 = aDynamicParticle->GetKineticEnergy();
  const G4ParticleDefinition* theParticle = aDynamicParticle->GetDefinition();
 
  if (kineticEnergy0 <= fIntrinsicLowEnergyLimit)
  {
    fParticleChange->SetProposedKineticEnergy(0.);
    fParticleChange->ProposeLocalEnergyDeposit(kineticEnergy0);
    return ;
  }
 
  const G4Material* material = couple->GetMaterial();
  const G4PenelopeOscillatorTable* theTable = fOscManager->GetOscillatorTableIonisation(material); 
 
  G4ParticleMomentum particleDirection0 = aDynamicParticle->GetMomentumDirection();
 
  //Initialise final-state variables. The proper values will be set by the methods
  // SampleFinalStateElectron() and SampleFinalStatePositron()
  fKineticEnergy1=kineticEnergy0;
  fCosThetaPrimary=1.0;
  fEnergySecondary=0.0;
  fCosThetaSecondary=1.0;
  fTargetOscillator = -1;
     
  if (theParticle == G4Electron::Electron())
    SampleFinalStateElectron(material,cutE,kineticEnergy0);
  else if (theParticle == G4Positron::Positron())
    SampleFinalStatePositron(material,cutE,kineticEnergy0);
  else
    {
      G4ExceptionDescription ed;
      ed << "Invalid particle " << theParticle->GetParticleName() << G4endl;
      G4Exception("G4PenelopeIonisationModel::SamplingSecondaries()",
          "em0001",FatalException,ed);
      
    }
  if (fEnergySecondary == 0) return;
 
  if (fVerboseLevel > 3)
  {
     G4cout << "G4PenelopeIonisationModel::SamplingSecondaries() for " << 
    theParticle->GetParticleName() << G4endl;
      G4cout << "Final eKin = " << fKineticEnergy1 << " keV" << G4endl;
      G4cout << "Final cosTheta = " << fCosThetaPrimary << G4endl;
      G4cout << "Delta-ray eKin = " << fEnergySecondary << " keV" << G4endl;
      G4cout << "Delta-ray cosTheta = " << fCosThetaSecondary << G4endl;
      G4cout << "Oscillator: " << fTargetOscillator << G4endl;
   }
   
  //Update the primary particle
  G4double sint = std::sqrt(1. - fCosThetaPrimary*fCosThetaPrimary);
  G4double phiPrimary  = twopi * G4UniformRand();
  G4double dirx = sint * std::cos(phiPrimary);
  G4double diry = sint * std::sin(phiPrimary);
  G4double dirz = fCosThetaPrimary;
 
  G4ThreeVector electronDirection1(dirx,diry,dirz);
  electronDirection1.rotateUz(particleDirection0);
   
  if (fKineticEnergy1 > 0)
    {
      fParticleChange->ProposeMomentumDirection(electronDirection1);
      fParticleChange->SetProposedKineticEnergy(fKineticEnergy1);
    }
  else    
    fParticleChange->SetProposedKineticEnergy(0.);
    
  //Generate the delta ray
  G4double ionEnergyInPenelopeDatabase = 
    (*theTable)[fTargetOscillator]->GetIonisationEnergy();
  
  //Now, try to handle fluorescence
  //Notice: merged levels are indicated with Z=0 and flag=30
  G4int shFlag = (*theTable)[fTargetOscillator]->GetShellFlag(); 
  G4int Z = (G4int) (*theTable)[fTargetOscillator]->GetParentZ();
 
  //initialize here, then check photons created by Atomic-Deexcitation, and the final state e-
  const G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
  G4double bindingEnergy = 0.*eV;  
 
  const G4AtomicShell* shell = nullptr;
  //Real level
  if (Z > 0 && shFlag<30)
    {
      shell = transitionManager->Shell(Z,shFlag-1);
      bindingEnergy = shell->BindingEnergy();
      //shellId = shell->ShellId();
    }
 
  //correct the fEnergySecondary to account for the fact that the Penelope 
  //database of ionisation energies is in general (slightly) different 
  //from the fluorescence database used in Geant4.
  fEnergySecondary += ionEnergyInPenelopeDatabase-bindingEnergy;
  
  G4double localEnergyDeposit = bindingEnergy;
  //testing purposes only
  G4double energyInFluorescence = 0;
  G4double energyInAuger = 0; 
 
  if (fEnergySecondary < 0)
    {
      //It means that there was some problem/mismatch between the two databases. 
      //In this case, the available energy is ok to excite the level according 
      //to the Penelope database, but not according to the Geant4 database
      //Full residual energy is deposited locally
      localEnergyDeposit += fEnergySecondary;
      fEnergySecondary = 0.0;
    }
 
  //Notice: shell might be nullptr (invalid!) if shFlag=30. Must be protected
  //Disable the built-in de-excitation of the PIXE flag is active. In this 
  //case, the PIXE interface takes care (statistically) of producing the 
  //de-excitation.
  //Now, take care of fluorescence, if required
  if (fAtomDeexcitation && !fPIXEflag && shell)
    {
      G4int index = couple->GetIndex();
      if (fAtomDeexcitation->CheckDeexcitationActiveRegion(index))
    {
      std::size_t nBefore = fvect->size();
      fAtomDeexcitation->GenerateParticles(fvect,shell,Z,index);
      std::size_t nAfter = fvect->size(); 
      
      if (nAfter>nBefore) //actual production of fluorescence
        {
          for (std::size_t j=nBefore;j<nAfter;++j) //loop on products
        {
          G4double itsEnergy = ((*fvect)[j])->GetKineticEnergy();
                  if (itsEnergy < localEnergyDeposit) // valid secondary, generate it
                    {
              localEnergyDeposit -= itsEnergy;
              if (((*fvect)[j])->GetParticleDefinition() == G4Gamma::Definition())
                energyInFluorescence += itsEnergy;
              else if (((*fvect)[j])->GetParticleDefinition() == G4Electron::Definition())
                energyInAuger += itsEnergy;
                    }
                  else //invalid secondary: takes more than the available energy: delete it
            {
              delete (*fvect)[j];
              (*fvect)[j] = nullptr;
            }           
        }
        }
    }
    }
 
  // Generate the delta ray --> to be done only if above cut
  if (fEnergySecondary > cutE)
    {
      G4DynamicParticle* electron = nullptr;
      G4double sinThetaE = std::sqrt(1.-fCosThetaSecondary*fCosThetaSecondary);
      G4double phiEl = phiPrimary+pi; //pi with respect to the primary electron/positron
      G4double xEl = sinThetaE * std::cos(phiEl);
      G4double yEl = sinThetaE * std::sin(phiEl);
      G4double zEl = fCosThetaSecondary;
      G4ThreeVector eDirection(xEl,yEl,zEl); //electron direction
      eDirection.rotateUz(particleDirection0);
      electron = new G4DynamicParticle (G4Electron::Electron(),
                    eDirection,fEnergySecondary) ;
      fvect->push_back(electron);
    }
  else
    {
      localEnergyDeposit += fEnergySecondary;
      fEnergySecondary = 0;
    }
 
  if (localEnergyDeposit < 0) //Should not be: issue a G4Exception (warning)
    {
      G4Exception("G4PenelopeIonisationModel::SampleSecondaries()",
          "em2099",JustWarning,"WARNING: Negative local energy deposit");
      localEnergyDeposit=0.;
    }
  fParticleChange->ProposeLocalEnergyDeposit(localEnergyDeposit);
 
  if (fVerboseLevel > 1)
    {
      G4cout << "-----------------------------------------------------------" << G4endl;
      G4cout << "Energy balance from G4PenelopeIonisation" << G4endl;
      G4cout << "Incoming primary energy: " << kineticEnergy0/keV << " keV" << G4endl;
      G4cout << "-----------------------------------------------------------" << G4endl;
      G4cout << "Outgoing primary energy: " << fKineticEnergy1/keV << " keV" << G4endl;
      G4cout << "Delta ray " << fEnergySecondary/keV << " keV" << G4endl;
      if (energyInFluorescence)
    G4cout << "Fluorescence x-rays: " << energyInFluorescence/keV << " keV" << G4endl;
      if (energyInAuger)
    G4cout << "Auger electrons: " << energyInAuger/keV << " keV" << G4endl;     
      G4cout << "Local energy deposit " << localEnergyDeposit/keV << " keV" << G4endl;
      G4cout << "Total final state: " << (fEnergySecondary+energyInFluorescence+fKineticEnergy1+
                      localEnergyDeposit+energyInAuger)/keV <<
    " keV" << G4endl;
      G4cout << "-----------------------------------------------------------" << G4endl;
    }
      
  if (fVerboseLevel > 0)
    {
      G4double energyDiff = std::fabs(fEnergySecondary+energyInFluorescence+fKineticEnergy1+
                      localEnergyDeposit+energyInAuger-kineticEnergy0);
      if (energyDiff > 0.05*keV)
    G4cout << "Warning from G4PenelopeIonisation: problem with energy conservation: " <<  
      (fEnergySecondary+energyInFluorescence+fKineticEnergy1+localEnergyDeposit+energyInAuger)/keV <<
      " keV (final) vs. " <<
      kineticEnergy0/keV << " keV (initial)" << G4endl;      
    }
    
}

SetVerbosityLevel()

void G4PenelopeIonisationModel::SetVerbosityLevel ( G4int lev )

inline

Definition at line 108 of file G4PenelopeIonisationModel.hh.

{fVerboseLevel = lev;};

Member Data Documentation

fParticle

const G4ParticleDefinition* G4PenelopeIonisationModel::fParticle

protected

Definition at line 116 of file G4PenelopeIonisationModel.hh.

Referenced by G4PenelopeIonisationModel(), Initialise(), and InitialiseLocal().

fParticleChange

G4ParticleChangeForLoss* G4PenelopeIonisationModel::fParticleChange

protected

Definition at line 115 of file G4PenelopeIonisationModel.hh.

Referenced by G4PenelopeIonisationModel(), Initialise(), and SampleSecondaries().

---

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

• G4PenelopeIonisationModel.hh
• G4PenelopeIonisationModel.cc