Files
geant4/source/processes/electromagnetic/standard/include/G4IhIonisation.icc
T
2016-06-08 15:28:20 +02:00

146 lines
5.2 KiB
Plaintext

// This code implementation is the intellectual property of
// the GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4IhIonisation.icc,v 1.1.10.1 1999/12/07 20:50:50 gunter Exp $
// GEANT4 tag $Name: geant4-01-00 $
//
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// For information related to this code contact:
// CERN, IT Division, ASD group
// ------------ G4IhIonisation physics process ------------
// by Laszlo Urban, 30 May 1997
// ***************************************************************
// It is the first implementation of the NEW IONISATION PROCESS.
// It calculates the ionisation of charged hadrons.
// ***************************************************************
// 24/09/97: corrected by L.Urban
// 20/11/97: correction on MeanFreePath for KineticEnergy > HighestLimit
// 29/10/98: some cleanup + small changes , L.Urban
// ---------------------------------------------------------------
inline G4double G4IhIonisation::PostStepGetPhysicalInteractionLength(
const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition)
{// get particle,particle type,kin.energy,material,mat.index
const G4double Tfac=0.95,Tfac1=1.-Tfac,eps=1.e-2 ;
G4double nl,nll,nlold,range,rangeold,rangenext,
dEdx,KineticEnergyOld,KineticEnergyNext,value;
G4bool isOut;
const G4DynamicParticle* particle = track.GetDynamicParticle();
const G4ParticleDefinition* particletype = particle->GetDefinition() ;
G4double KineticEnergy = particle->GetKineticEnergy();
G4Material* material = track.GetMaterial();
const G4MaterialTable* theMaterialTable =
G4Material::GetMaterialTable();
G4int materialindex = material->GetIndex();
nl = (*theNlambdaTable)[materialindex]->
GetValue(KineticEnergy,isOut);
range = G4EnergyLossTables::GetPreciseRangeFromEnergy(particletype,
KineticEnergy,material) ;
if ( (previousStepSize <=0.0) || (theNumberOfInteractionLengthLeft<=0.0)) {
ResetNumberOfInteractionLengthLeft();
} else {
if(previousStepSize/range < eps)
{
nll = (*theNlambdaTable)[materialindex]->
GetValue(Tfac*KineticEnergy,isOut) ;
dEdx = G4EnergyLossTables::GetPreciseDEDX(particletype,
KineticEnergy,
material) ;
nlold = nl + dEdx*previousStepSize*(nl-nll)/
(Tfac1*KineticEnergy) ;
}
else
{
rangeold = range + previousStepSize ;
KineticEnergyOld = G4EnergyLossTables::GetPreciseEnergyFromRange(
particletype,
rangeold,material);
nlold = (*theNlambdaTable)[materialindex]->
GetValue(KineticEnergyOld,isOut);
if(nlold < nl)
{
if(verboseLevel>2)
{
G4cout << "G4IhIonisation PostStepGPIL : Nlambda has been" <<
" increased at update.Nlambda old/new :" << nlold <<
" " << nl << endl;
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)"
<< endl;
G4cout << " correction : Nlambda old=new ........." << endl;
}
nlold = nl ;
}
}
theNumberOfInteractionLengthLeft -= nlold-nl ;
if(theNumberOfInteractionLengthLeft<perMillion)
theNumberOfInteractionLengthLeft=0.;
}
// condition is set to "Not Forced"
*condition = NotForced;
if(nl <= theNumberOfInteractionLengthLeft)
{
value = DBL_MAX ;
}
else
{
if(theNumberOfInteractionLengthLeft/nl < eps)
{
nll = (*theNlambdaTable)[materialindex]->
GetValue(Tfac*KineticEnergy,isOut) ;
dEdx = G4EnergyLossTables::GetPreciseDEDX(particletype,
KineticEnergy,
material) ;
value = theNumberOfInteractionLengthLeft*Tfac1*KineticEnergy/
(dEdx*(nl-nll));
}
else
{
KineticEnergyNext = (*theInverseNlambdaTable)[materialindex]->
GetValue(nl-theNumberOfInteractionLengthLeft,isOut);
rangenext = G4EnergyLossTables::GetPreciseRangeFromEnergy(particletype,
KineticEnergyNext,material);
value = range - rangenext ;
if(range<rangenext)
{
if(verboseLevel>2)
{
G4cout << "G4IhIonisation PostStepGPIL: Step < 0.!, Step="
<< value << endl;
G4cout << "range,rangenext:" << range << " " << rangenext << endl ;
G4cout << "correction : rangenext=range ....." << endl;
}
rangenext = range ;
value = range - rangenext ;
}
}
}
return value;
}
inline G4bool G4IhIonisation::IsApplicable(
const G4ParticleDefinition& particle)
{
return(particle.GetPDGCharge() != 0.);
}