#include <G4PenelopeIonisationModel.hh>

Inheritance diagram for G4PenelopeIonisationModel:

Public Member Functions
	G4PenelopeIonisationModel (const G4ParticleDefinition *p=0, const G4String &processName="PenIoni")

virtual	~G4PenelopeIonisationModel ()

virtual void	Initialise (const G4ParticleDefinition *, const G4DataVector &)

virtual void	InitialiseLocal (const G4ParticleDefinition , G4VEmModel )

virtual G4double	ComputeCrossSectionPerAtom (const G4ParticleDefinition *, G4double, G4double, G4double, G4double, G4double)

virtual G4double	CrossSectionPerVolume (const G4Material material, const G4ParticleDefinition theParticle, G4double kineticEnergy, G4double cutEnergy, G4double maxEnergy=DBL_MAX)

virtual void	SampleSecondaries (std::vector< G4DynamicParticle * > , const G4MaterialCutsCouple , const G4DynamicParticle *, G4double tmin, G4double maxEnergy)

virtual G4double	ComputeDEDXPerVolume (const G4Material , const G4ParticleDefinition , G4double kineticEnergy, G4double cutEnergy)

virtual G4double	MinEnergyCut (const G4ParticleDefinition , const G4MaterialCutsCouple )

void	SetVerbosityLevel (G4int lev)

G4int	GetVerbosityLevel ()

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	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 G4MaterialCutsCouple , const G4DynamicParticle , G4double &eloss, G4double &niel, G4double length)

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 *)

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)

G4int	SelectIsotopeNumber (const G4Element *)

const G4Element *	SelectRandomAtom (const G4MaterialCutsCouple , const G4ParticleDefinition , G4double kineticEnergy, 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)

G4int	SelectRandomAtomNumber (const G4Material *)

void	SetParticleChange (G4VParticleChange , G4VEmFluctuationModel f=0)

void	SetCrossSectionTable (G4PhysicsTable *, G4bool isLocal)

G4ElementData *	GetElementData ()

G4PhysicsTable *	GetCrossSectionTable ()

G4VEmFluctuationModel *	GetModelOfFluctuations ()

G4VEmAngularDistribution *	GetAngularDistribution ()

void	SetAngularDistribution (G4VEmAngularDistribution *)

G4double	HighEnergyLimit () const

G4double	LowEnergyLimit () const

G4double	HighEnergyActivationLimit () const

G4double	LowEnergyActivationLimit () const

G4double	PolarAngleLimit () const

G4double	SecondaryThreshold () const

G4bool	LPMFlag () 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)

void	SetPolarAngleLimit (G4double)

void	SetSecondaryThreshold (G4double)

void	SetLPMFlag (G4bool val)

void	SetDeexcitationFlag (G4bool val)

void	SetForceBuildTable (G4bool val)

void	SetMasterThread (G4bool val)

G4bool	IsMaster () const

G4double	MaxSecondaryKinEnergy (const G4DynamicParticle *dynParticle)

const G4String &	GetName () const

void	SetCurrentCouple (const G4MaterialCutsCouple *)

const G4Element *	GetCurrentElement () const

Protected Attributes
G4ParticleChangeForLoss *	fParticleChange

const G4ParticleDefinition *	fParticle

Protected Attributes inherited from G4VEmModel
G4ElementData *	fElementData

G4VParticleChange *	pParticleChange

G4PhysicsTable *	xSectionTable

const std::vector< G4double > *	theDensityFactor

const std::vector< G4int > *	theDensityIdx

size_t	idxTable

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::G4PenelopeIonisationModel	(	const G4ParticleDefinition *	p = `0`,
		const G4String &	processName = `"PenIoni"`
	)

Definition at line 70 of file G4PenelopeIonisationModel.cc.

References python.hepunit::eV, G4PenelopeOscillatorManager::GetOscillatorManager(), python.hepunit::GeV, G4VEmModel::SetDeexcitationFlag(), and G4VEmModel::SetHighEnergyLimit().

   :G4VEmModel(nam),fParticleChange(0),fParticle(0),isInitialised(false),
    fAtomDeexcitation(0),kineticEnergy1(0.*eV),
    cosThetaPrimary(1.0),energySecondary(0.*eV),
    cosThetaSecondary(0.0),targetOscillator(-1),
    theCrossSectionHandler(0),fLocalTable(false)
 {
   fIntrinsicLowEnergyLimit = 100.0*eV;
   fIntrinsicHighEnergyLimit = 100.0*GeV;
   //  SetLowEnergyLimit(fIntrinsicLowEnergyLimit);
   SetHighEnergyLimit(fIntrinsicHighEnergyLimit);
   nBins = 200;
 
   if (part)
     SetParticle(part);
 
   //
   oscManager = G4PenelopeOscillatorManager::GetOscillatorManager();
   //
   verboseLevel= 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);
 }

G4PenelopeIonisationModel::~G4PenelopeIonisationModel ( )

virtual

Definition at line 105 of file G4PenelopeIonisationModel.cc.

References G4VEmModel::IsMaster().

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

Member Function Documentation

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

virtual

Reimplemented from G4VEmModel.

Definition at line 322 of file G4PenelopeIonisationModel.cc.

References G4cout, and G4endl.

 {
   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;
 }

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

virtual

Reimplemented from G4VEmModel.

Definition at line 338 of file G4PenelopeIonisationModel.cc.

References G4PenelopeIonisationXSHandler::BuildXSTable(), G4cout, G4endl, G4Exception(), G4PenelopeOscillatorManager::GetAtomsPerMolecule(), G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4PenelopeCrossSection::GetSoftStoppingPower(), G4Material::GetTotNbOfAtomsPerVolume(), JustWarning, python.hepunit::keV, python.hepunit::mm, and G4TemplateAutoLock< M, L, U >::unlock().

 {
   // 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 (verboseLevel > 3)
     G4cout << "Calling ComputeDEDX() of G4PenelopeIonisationModel" << G4endl;
  
   //Either Initialize() was not called, or we are in a slave and InitializeLocal() was 
   //not invoked
   if (!theCrossSectionHandler)
     {
       //create a **thread-local** version of the table. Used only for G4EmCalculator and 
       //Unit Tests
       fLocalTable = true;
       theCrossSectionHandler = new G4PenelopeIonisationXSHandler(nBins);    
     }
 
   const G4PenelopeCrossSection* theXS = 
     theCrossSectionHandler->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 (verboseLevel > 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);
       theCrossSectionHandler->BuildXSTable(material,cutEnergy,theParticle);
       lock.unlock();
       //now it should be ok
       theXS = 
     theCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,
                               material,
                               cutEnergy);
     }
 
  G4double sPowerPerMolecule = 0.0;
   if (theXS)
     sPowerPerMolecule = theXS->GetSoftStoppingPower(kineticEnergy);
 
   
   G4double atomDensity = material->GetTotNbOfAtomsPerVolume();
   G4double atPerMol =  oscManager->GetAtomsPerMolecule(material);
                                                                                         
   G4double moleculeDensity = 0.; 
   if (atPerMol)
     moleculeDensity = atomDensity/atPerMol;
  
   G4double sPowerPerVolume = sPowerPerMolecule*moleculeDensity;
 
   if (verboseLevel > 2)
     {
       G4cout << "G4PenelopeIonisationModel " << G4endl;
       G4cout << "Stopping power < " << cutEnergy/keV << " keV at " <<
         kineticEnergy/keV << " keV = " << 
     sPowerPerVolume/(keV/mm) << " keV/mm" << G4endl;
     }
   return sPowerPerVolume;
 }

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

virtual

Reimplemented from G4VEmModel.

Definition at line 217 of file G4PenelopeIonisationModel.cc.

References G4PenelopeIonisationXSHandler::BuildXSTable(), G4cout, G4endl, G4Exception(), G4PenelopeOscillatorManager::GetAtomsPerMolecule(), G4PenelopeIonisationXSHandler::GetCrossSectionTableForCouple(), G4PenelopeCrossSection::GetHardCrossSection(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4PenelopeCrossSection::GetTotalCrossSection(), G4Material::GetTotNbOfAtomsPerVolume(), JustWarning, python.hepunit::keV, python.hepunit::mm, G4VEmModel::SetupForMaterial(), and G4TemplateAutoLock< M, L, U >::unlock().

 {
   // 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 (verboseLevel > 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 (!theCrossSectionHandler)
     {
       //create a **thread-local** version of the table. Used only for G4EmCalculator and 
       //Unit Tests
       fLocalTable = true;
       theCrossSectionHandler = new G4PenelopeIonisationXSHandler(nBins);    
     }
   
   const G4PenelopeCrossSection* theXS = 
     theCrossSectionHandler->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 (verboseLevel > 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);
       theCrossSectionHandler->BuildXSTable(material,cutEnergy,theParticle);
       lock.unlock();
       //now it should be ok
       theXS = 
     theCrossSectionHandler->GetCrossSectionTableForCouple(theParticle,
                               material,
                               cutEnergy);
     }
 
 
   if (theXS)
     crossPerMolecule = theXS->GetHardCrossSection(energy);
 
   G4double atomDensity = material->GetTotNbOfAtomsPerVolume();
   G4double atPerMol =  oscManager->GetAtomsPerMolecule(material);
  
   if (verboseLevel > 3)
     G4cout << "Material " << material->GetName() << " has " << atPerMol <<
       "atoms per molecule" << G4endl;
 
   G4double moleculeDensity = 0.; 
   if (atPerMol)
     moleculeDensity = atomDensity/atPerMol;
  
   G4double crossPerVolume = crossPerMolecule*moleculeDensity;
 
   if (verboseLevel > 2)
   {
     G4cout << "G4PenelopeIonisationModel " << G4endl;
     G4cout << "Mean free path for delta emission > " << cutEnergy/keV << " keV at " <<
       energy/keV << " keV = " << (1./crossPerVolume)/mm << " mm" << G4endl;
     if (theXS)
       totalCross = (theXS->GetTotalCrossSection(energy))*moleculeDensity;
     G4cout << "Total free path for ionisation (no threshold) at " <<
       energy/keV << " keV = " << (1./totalCross)/mm << " mm" << G4endl;
   }
   return crossPerVolume;
 }

G4int G4PenelopeIonisationModel::GetVerbosityLevel ( )

inline

Definition at line 111 of file G4PenelopeIonisationModel.hh.

111 {return verboseLevel;};

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

virtual

Implements G4VEmModel.

Definition at line 116 of file G4PenelopeIonisationModel.cc.

References G4LossTableManager::AtomDeexcitation(), G4PenelopeIonisationXSHandler::BuildXSTable(), fParticle, fParticleChange, G4cout, G4endl, G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4VEmModel::GetParticleChangeForLoss(), G4ProductionCutsTable::GetProductionCutsTable(), G4ProductionCutsTable::GetTableSize(), python.hepunit::GeV, G4VEmModel::HighEnergyLimit(), G4LossTableManager::Instance(), G4VEmModel::IsMaster(), python.hepunit::keV, G4VEmModel::LowEnergyLimit(), G4INCL::Math::max(), and G4PenelopeIonisationXSHandler::SetVerboseLevel().

 {
   if (verboseLevel > 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;
     }
   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
       nBins = (size_t) (20*std::log10(HighEnergyLimit()/LowEnergyLimit()));
       nBins = std::max(nBins,(size_t)100);
       
       //Clear and re-build the tables
       if (theCrossSectionHandler)
     {
       delete theCrossSectionHandler;
       theCrossSectionHandler = 0;
     }
       theCrossSectionHandler = new G4PenelopeIonisationXSHandler(nBins);
       theCrossSectionHandler->SetVerboseLevel(verboseLevel);
 
       //Build tables for all materials
       G4ProductionCutsTable* theCoupleTable = 
     G4ProductionCutsTable::GetProductionCutsTable();      
       for (size_t i=0;i<theCoupleTable->GetTableSize();i++)
     {
       const G4Material* theMat = 
         theCoupleTable->GetMaterialCutsCouple(i)->GetMaterial();
       //Forces the building of the cross section tables
       theCrossSectionHandler->BuildXSTable(theMat,theCuts.at(i),particle,
                            IsMaster());
      
     }
 
       if (verboseLevel > 2) {
     G4cout << "Penelope Ionisation model v2008 is initialized " << G4endl
            << "Energy range: "
            << LowEnergyLimit() / keV << " keV - "
            << HighEnergyLimit() / GeV << " GeV. Using " 
            << nBins << " bins." 
            << G4endl;
       }
     }
  
   if(isInitialised) 
     return;
   fParticleChange = GetParticleChangeForLoss();
   isInitialised = true;
 
   return;
 }

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

virtual

Reimplemented from G4VEmModel.

Definition at line 185 of file G4PenelopeIonisationModel.cc.

References fParticle, G4cout, and G4endl.

 {
   if (verboseLevel > 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
       theCrossSectionHandler = theModel->theCrossSectionHandler;
       
       //copy data
       nBins = theModel->nBins;
       
       //Same verbosity for all workers, as the master
       verboseLevel = theModel->verboseLevel;
     }
 
   return;
 }

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

virtual

Reimplemented from G4VEmModel.

Definition at line 426 of file G4PenelopeIonisationModel.cc.

 {
   return fIntrinsicLowEnergyLimit;
 }

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

virtual

Implements G4VEmModel.

Definition at line 434 of file G4PenelopeIonisationModel.cc.

References G4InuclSpecialFunctions::bindingEnergy(), G4AtomicShell::BindingEnergy(), G4VAtomDeexcitation::CheckDeexcitationActiveRegion(), G4Electron::Definition(), G4Gamma::Definition(), G4InuclParticleNames::electron, G4Electron::Electron(), python.hepunit::eV, FatalException, fParticleChange, G4cout, G4endl, G4Exception(), G4UniformRand, G4VAtomDeexcitation::GenerateParticles(), G4DynamicParticle::GetDefinition(), G4MaterialCutsCouple::GetIndex(), G4DynamicParticle::GetKineticEnergy(), G4MaterialCutsCouple::GetMaterial(), G4DynamicParticle::GetMomentumDirection(), G4PenelopeOscillatorManager::GetOscillatorTableIonisation(), G4ParticleDefinition::GetParticleName(), G4AtomicTransitionManager::Instance(), python.hepunit::keV, eplot::material, python.hepunit::pi, G4Positron::Positron(), G4VParticleChange::ProposeLocalEnergyDeposit(), G4ParticleChangeForLoss::ProposeMomentumDirection(), CLHEP::Hep3Vector::rotateUz(), G4ParticleChangeForLoss::SetProposedKineticEnergy(), G4AtomicTransitionManager::Shell(), and python.hepunit::twopi.

 {
   // 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 (verboseLevel > 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 = oscManager->GetOscillatorTableIonisation(material); 
 
   G4ParticleMomentum particleDirection0 = aDynamicParticle->GetMomentumDirection();
  
   //Initialise final-state variables. The proper values will be set by the methods
   // SampleFinalStateElectron() and SampleFinalStatePositron()
   kineticEnergy1=kineticEnergy0;
   cosThetaPrimary=1.0;
   energySecondary=0.0;
   cosThetaSecondary=1.0;
   targetOscillator = -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 (energySecondary == 0) return;
 
   if (verboseLevel > 3)
   {
      G4cout << "G4PenelopeIonisationModel::SamplingSecondaries() for " << 
     theParticle->GetParticleName() << G4endl;
       G4cout << "Final eKin = " << kineticEnergy1 << " keV" << G4endl;
       G4cout << "Final cosTheta = " << cosThetaPrimary << G4endl;
       G4cout << "Delta-ray eKin = " << energySecondary << " keV" << G4endl;
       G4cout << "Delta-ray cosTheta = " << cosThetaSecondary << G4endl;
       G4cout << "Oscillator: " << targetOscillator << G4endl;
    }
    
   //Update the primary particle
   G4double sint = std::sqrt(1. - cosThetaPrimary*cosThetaPrimary);
   G4double phiPrimary  = twopi * G4UniformRand();
   G4double dirx = sint * std::cos(phiPrimary);
   G4double diry = sint * std::sin(phiPrimary);
   G4double dirz = cosThetaPrimary;
  
   G4ThreeVector electronDirection1(dirx,diry,dirz);
   electronDirection1.rotateUz(particleDirection0);
    
   if (kineticEnergy1 > 0)
     {
       fParticleChange->ProposeMomentumDirection(electronDirection1);
       fParticleChange->SetProposedKineticEnergy(kineticEnergy1);
     }
   else    
     fParticleChange->SetProposedKineticEnergy(0.);
     
   
   //Generate the delta ray
   G4double ionEnergyInPenelopeDatabase = 
     (*theTable)[targetOscillator]->GetIonisationEnergy();
   
   //Now, try to handle fluorescence
   //Notice: merged levels are indicated with Z=0 and flag=30
   G4int shFlag = (*theTable)[targetOscillator]->GetShellFlag(); 
   G4int Z = (G4int) (*theTable)[targetOscillator]->GetParentZ();
 
   //initialize here, then check photons created by Atomic-Deexcitation, and the final state e-
   const G4AtomicTransitionManager* transitionManager = G4AtomicTransitionManager::Instance();
   G4double bindingEnergy = 0.*eV;
   //G4int shellId = 0;
 
   const G4AtomicShell* shell = 0;
   //Real level
   if (Z > 0 && shFlag<30)
     {
       shell = transitionManager->Shell(Z,shFlag-1);
       bindingEnergy = shell->BindingEnergy();
       //shellId = shell->ShellId();
     }
 
   //correct the energySecondary to account for the fact that the Penelope 
   //database of ionisation energies is in general (slightly) different 
   //from the fluorescence database used in Geant4.
   energySecondary += ionEnergyInPenelopeDatabase-bindingEnergy;
   
   G4double localEnergyDeposit = bindingEnergy;
   //testing purposes only
   G4double energyInFluorescence = 0;
   G4double energyInAuger = 0; 
 
   if (energySecondary < 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 += energySecondary;
       energySecondary = 0.0;
     }
 
   //Notice: shell might be NULL (invalid!) if shFlag=30. Must be protected
   //Now, take care of fluorescence, if required
   if (fAtomDeexcitation && shell)
     {
       G4int index = couple->GetIndex();
       if (fAtomDeexcitation->CheckDeexcitationActiveRegion(index))
     {
       size_t nBefore = fvect->size();
       fAtomDeexcitation->GenerateParticles(fvect,shell,Z,index);
       size_t nAfter = fvect->size(); 
       
       if (nAfter > nBefore) //actual production of fluorescence
         {
           for (size_t j=nBefore;j<nAfter;j++) //loop on products
         {
           G4double itsEnergy = ((*fvect)[j])->GetKineticEnergy();
           localEnergyDeposit -= itsEnergy;
           if (((*fvect)[j])->GetParticleDefinition() == G4Gamma::Definition())
             energyInFluorescence += itsEnergy;
           else if (((*fvect)[j])->GetParticleDefinition() == G4Electron::Definition())
             energyInAuger += itsEnergy;
         }
         }
     }
     }
 
   // Generate the delta ray --> to be done only if above cut
   if (energySecondary > cutE)
     {
       G4DynamicParticle* electron = 0;
       G4double sinThetaE = std::sqrt(1.-cosThetaSecondary*cosThetaSecondary);
       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 = cosThetaSecondary;
       G4ThreeVector eDirection(xEl,yEl,zEl); //electron direction
       eDirection.rotateUz(particleDirection0);
       electron = new G4DynamicParticle (G4Electron::Electron(),
                     eDirection,energySecondary) ;
       fvect->push_back(electron);
     }
   else
     {
       localEnergyDeposit += energySecondary;
       energySecondary = 0;
     }
 
   if (localEnergyDeposit < 0)
     {
       G4cout << "WARNING-" 
          << "G4PenelopeIonisationModel::SampleSecondaries - Negative energy deposit"
          << G4endl;
       localEnergyDeposit=0.;
     }
   fParticleChange->ProposeLocalEnergyDeposit(localEnergyDeposit);
 
   if (verboseLevel > 1)
     {
       G4cout << "-----------------------------------------------------------" << G4endl;
       G4cout << "Energy balance from G4PenelopeIonisation" << G4endl;
       G4cout << "Incoming primary energy: " << kineticEnergy0/keV << " keV" << G4endl;
       G4cout << "-----------------------------------------------------------" << G4endl;
       G4cout << "Outgoing primary energy: " << kineticEnergy1/keV << " keV" << G4endl;
       G4cout << "Delta ray " << energySecondary/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: " << (energySecondary+energyInFluorescence+kineticEnergy1+
                       localEnergyDeposit+energyInAuger)/keV <<
     " keV" << G4endl;
       G4cout << "-----------------------------------------------------------" << G4endl;
     }
       
   if (verboseLevel > 0)
     {
       G4double energyDiff = std::fabs(energySecondary+energyInFluorescence+kineticEnergy1+
                       localEnergyDeposit+energyInAuger-kineticEnergy0);
       if (energyDiff > 0.05*keV)
     G4cout << "Warning from G4PenelopeIonisation: problem with energy conservation: " <<  
       (energySecondary+energyInFluorescence+kineticEnergy1+localEnergyDeposit+energyInAuger)/keV <<
       " keV (final) vs. " <<
       kineticEnergy0/keV << " keV (initial)" << G4endl;      
     }
     
 }