Import Geant4 3.1.0 source tree
This commit is contained in:
Gabriele Cosmo
@@ -0,0 +1,159 @@
|
||||
// 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: G4IMuBremsstrahlung.hh,v 1.1 2001/03/05 10:55:19 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// -------- G4IMuBremsstrahlung physics process ---------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ************************************************************
|
||||
|
||||
#ifndef G4IMuBremsstrahlung_h
|
||||
#define G4IMuBremsstrahlung_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIMuEnergyLoss.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Gamma.hh"
|
||||
#include "G4MuonMinus.hh"
|
||||
#include "G4MuonPlus.hh"
|
||||
#include "G4OrderedTable.hh"
|
||||
#include "G4PhysicsTable.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
|
||||
class G4IMuBremsstrahlung : public G4VIMuEnergyLoss
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IMuBremsstrahlung(const G4String& processName = "IMuBremsstrahlung");
|
||||
|
||||
~G4IMuBremsstrahlung();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
private:
|
||||
|
||||
G4IMuBremsstrahlung & operator=(const G4IMuBremsstrahlung &right);
|
||||
G4IMuBremsstrahlung(const G4IMuBremsstrahlung&);
|
||||
|
||||
public:
|
||||
// post Step functions .......................................
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
) ;
|
||||
|
||||
G4VParticleChange *PostStepDoIt(
|
||||
const G4Track& track,
|
||||
const G4Step& Step ) ;
|
||||
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
protected:
|
||||
|
||||
inline G4double ComputeMeanFreePath( const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
void ComputePartialSumSigma( const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber,
|
||||
G4double GammaEnergyCut);
|
||||
|
||||
private:
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
G4double ComputeBremLoss(G4double Z,G4double T,
|
||||
G4double Cut);
|
||||
|
||||
G4Element* SelectRandomAtom(G4Material* aMaterial) const;
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable ;
|
||||
|
||||
G4OrderedTable PartialSumSigma; // partial sum of total crosssection
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
const G4double LowestKineticEnergy; // low energy limit of the crossection formula
|
||||
const G4double HighestKineticEnergy; // high energy limit of the crossection formula
|
||||
G4int TotBin; // number of bins in the tables
|
||||
|
||||
G4double MinKineticEnergy; //process is ignored if T<MinKineticEnergy
|
||||
G4double MinCutValue; //protection against divergencies
|
||||
|
||||
// 1 = 2/(3.*Z**(1/3)) , 2= exp(-0.128*(1.18*A**(1/3)-0.48)
|
||||
G4int NuclearFormFactor ;
|
||||
|
||||
G4double CutInRange;
|
||||
|
||||
const G4Gamma* theGamma;
|
||||
const G4MuonMinus* theMuonMinus;
|
||||
const G4MuonPlus* theMuonPlus;
|
||||
|
||||
const G4double* GammaCutInKineticEnergy;
|
||||
const G4double* MuonMinusCutInKineticEnergy;
|
||||
const G4double* MuonPlusCutInKineticEnergy;
|
||||
const G4double* ParticleCutInKineticEnergy;
|
||||
|
||||
|
||||
G4double GammaCutInKineticEnergyNow;
|
||||
G4double MuonMinusCutInKineticEnergyNow;
|
||||
G4double MuonPlusCutInKineticEnergyNow;
|
||||
G4double ParticleCutInKineticEnergyNow;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
};
|
||||
|
||||
#include "G4IMuBremsstrahlung.icc"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,171 @@
|
||||
// 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: G4IMuBremsstrahlung.icc,v 1.1 2001/03/05 10:55:19 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// -------- G4IMuBremsstrahlung physics process ---------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ***************************************************************
|
||||
inline G4double G4IMuBremsstrahlung::PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
)
|
||||
{// get particle,particle type,kin.energy,material,mat.index
|
||||
const G4double eps=1.e-2 ;
|
||||
const G4double Tfac=0.95,Tfac1=1.-Tfac ;
|
||||
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)) {
|
||||
// beggining of tracking (or just after DoIt of this process)
|
||||
ResetNumberOfInteractionLengthLeft();
|
||||
} else {
|
||||
// subtract NumberOfInteractionLengthLeft
|
||||
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 << "G4IMuBremsstrahlung PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)" << G4endl
|
||||
;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
//corr. of num errror
|
||||
nlold = nl ;
|
||||
}
|
||||
}
|
||||
|
||||
theNumberOfInteractionLengthLeft -= nlold-nl ;
|
||||
|
||||
if(theNumberOfInteractionLengthLeft<perMillion)
|
||||
theNumberOfInteractionLengthLeft=0.;
|
||||
}
|
||||
|
||||
|
||||
// condition is set to "Not Forced"
|
||||
*condition = NotForced;
|
||||
if(nl <= theNumberOfInteractionLengthLeft)
|
||||
{
|
||||
value = BIGSTEP ;
|
||||
}
|
||||
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 << G4endl
|
||||
;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
//corr. of num error
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
inline G4double G4IMuBremsstrahlung::ComputeMeanFreePath(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial)
|
||||
{
|
||||
const G4ElementVector* theElementVector = aMaterial->GetElementVector() ;
|
||||
const G4double* theAtomNumDensityVector = aMaterial->GetAtomicNumDensityVector();
|
||||
G4double GammaEnergyCut = (G4Gamma::GetCutsInEnergy())[aMaterial->GetIndex()];
|
||||
|
||||
const G4double BigPath= DBL_MAX;
|
||||
|
||||
G4double SIGMA = 0 ;
|
||||
|
||||
for ( G4int i=0 ; i < aMaterial->GetNumberOfElements() ; i++ )
|
||||
{
|
||||
SIGMA += theAtomNumDensityVector[i] *
|
||||
ComputeMicroscopicCrossSection( ParticleType, KineticEnergy,
|
||||
(*theElementVector)(i)->GetZ(),
|
||||
GammaEnergyCut );
|
||||
}
|
||||
|
||||
return SIGMA<=0.0 ? BigPath : 1./SIGMA ;
|
||||
}
|
||||
|
||||
|
||||
inline G4bool G4IMuBremsstrahlung::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return( (&particle == (const G4ParticleDefinition *)theMuonMinus)
|
||||
||(&particle == (const G4ParticleDefinition *)theMuonPlus)
|
||||
) ;
|
||||
}
|
||||
@@ -0,0 +1,148 @@
|
||||
// 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: G4IMuIonisation.hh,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IMuIonisation physics process ------------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ------------------------------------------------------------
|
||||
// It is the implementation of the NEW IONISATION
|
||||
// PROCESS. ( delta rays + continuous energy loss)
|
||||
// It calculates the ionisation for muons.
|
||||
// ************************************************************
|
||||
//
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef G4IMuIonisation_h
|
||||
#define G4IMuIonisation_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIMuEnergyLoss.hh"
|
||||
#include "globals.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
|
||||
class G4IMuIonisation : public G4VIMuEnergyLoss
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IMuIonisation(const G4String& processName = "IMuIonisation");
|
||||
|
||||
~G4IMuIonisation();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator
|
||||
G4IMuIonisation & operator=(const G4IMuIonisation &right);
|
||||
G4IMuIonisation(const G4IMuIonisation&);
|
||||
|
||||
public:
|
||||
|
||||
// post Step functions .......................................
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
) ;
|
||||
|
||||
G4VParticleChange *PostStepDoIt(
|
||||
const G4Track& track,
|
||||
const G4Step& Step ) ;
|
||||
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition& aParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber);
|
||||
|
||||
private:
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
|
||||
// private data members ...............................
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable;
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
|
||||
// LowestKineticEnergy = lower limit of particle kinetic energy
|
||||
// HighestKineticEnergy = upper limit of particle kinetic energy
|
||||
// TotBin = number of bins
|
||||
// ---------in the energy ionisation loss table-------------------
|
||||
const G4double LowestKineticEnergy;
|
||||
const G4double HighestKineticEnergy;
|
||||
G4int TotBin;
|
||||
|
||||
// cut in range
|
||||
G4double CutInRange ;
|
||||
G4double lastCutInRange ;
|
||||
|
||||
// particles , cuts in kinetic energy ........
|
||||
const G4Electron* theElectron;
|
||||
const G4MuonPlus* theMuonPlus;
|
||||
const G4MuonMinus* theMuonMinus;
|
||||
|
||||
const G4double* ParticleCutInKineticEnergy;
|
||||
const G4double* DeltaCutInKineticEnergy ;
|
||||
|
||||
G4double ParticleCutInKineticEnergyNow ;
|
||||
G4double DeltaCutInKineticEnergyNow ;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
};
|
||||
|
||||
#include "G4IMuIonisation.icc"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,151 @@
|
||||
// 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: G4IMuIonisation.icc,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IMuIonisation physics process -------------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ---------------------------------------------------------------
|
||||
// It is the implementation of the NEW IONISATION PROCESS.
|
||||
// It calculates the ionisation of muons.
|
||||
// ***************************************************************
|
||||
// 24/11/97: correction on MeanFreePath for KinEnergy > HighestLimit
|
||||
// ---------------------------------------------------------------
|
||||
inline G4double G4IMuIonisation::PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
)
|
||||
{// get particle,particle type,kin.energy,material,mat.index
|
||||
const G4double eps=1.e-2 ;
|
||||
const G4double Tfac=0.95,Tfac1=1.-Tfac ;
|
||||
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)) {
|
||||
// beggining of tracking (or just after DoIt of this process)
|
||||
ResetNumberOfInteractionLengthLeft();
|
||||
} else {
|
||||
// subtract NumberOfInteractionLengthLeft
|
||||
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 << "G4IMuIonisation PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)" << G4endl
|
||||
;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
//corr. of num errror
|
||||
nlold = nl ;
|
||||
}
|
||||
}
|
||||
|
||||
theNumberOfInteractionLengthLeft -= nlold-nl ;
|
||||
|
||||
if(theNumberOfInteractionLengthLeft<perMillion)
|
||||
theNumberOfInteractionLengthLeft=0.;
|
||||
}
|
||||
|
||||
|
||||
// condition is set to "Not Forced"
|
||||
*condition = NotForced;
|
||||
if(nl <= theNumberOfInteractionLengthLeft)
|
||||
{
|
||||
value = BIGSTEP ;
|
||||
}
|
||||
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 << "G4IMuIonisation PostStepGPIL: Step < 0.!, Step=" << value << G4endl
|
||||
;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
//corr. of num error
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
inline G4bool G4IMuIonisation::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return ( (&particle == (const G4ParticleDefinition *)theMuonPlus)
|
||||
||(&particle == (const G4ParticleDefinition *)theMuonMinus)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,188 @@
|
||||
// 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: G4IMuPairProduction.hh,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// -------- G4IMuPairProduction physics process ---------
|
||||
// by Laszlo Urban, May 1998
|
||||
// ************************************************************
|
||||
|
||||
#ifndef G4IMuPairproduction_h
|
||||
#define G4IMuPairproduction_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIMuEnergyLoss.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4MuonMinus.hh"
|
||||
#include "G4MuonPlus.hh"
|
||||
#include "G4OrderedTable.hh"
|
||||
#include "G4PhysicsTable.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
|
||||
class G4IMuPairProduction : public G4VIMuEnergyLoss
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IMuPairProduction(const G4String& processName = "IMuPairProduction");
|
||||
|
||||
~G4IMuPairProduction();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
private:
|
||||
|
||||
G4IMuPairProduction & operator=(const G4IMuPairProduction &right);
|
||||
G4IMuPairProduction(const G4IMuPairProduction&);
|
||||
|
||||
public:
|
||||
// post Step functions .......................................
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
) ;
|
||||
|
||||
G4VParticleChange *PostStepDoIt(
|
||||
const G4Track& track,
|
||||
const G4Step& Step ) ;
|
||||
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
protected:
|
||||
|
||||
inline G4double ComputeMeanFreePath( const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
void ComputePartialSumSigma( const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber,
|
||||
G4double ElectronEnergyCut,
|
||||
G4double PositronEnergyCut);
|
||||
|
||||
G4double ComputeDDMicroscopicCrossSection(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber,
|
||||
G4double PairEnergy,
|
||||
G4double asymmetry);
|
||||
|
||||
|
||||
G4double ComputeDMicroscopicCrossSection(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber,
|
||||
G4double PairEnergy);
|
||||
|
||||
void MakeSamplingTables( const G4ParticleDefinition* ParticleType );
|
||||
|
||||
private:
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
G4double ComputePairLoss( const G4ParticleDefinition* ParticleType,
|
||||
G4double Z,G4double T,G4double ElectronCut,
|
||||
G4double PositronCut);
|
||||
|
||||
G4Element* SelectRandomAtom(G4Material* aMaterial) const;
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable ;
|
||||
|
||||
static G4PhysicsTable* themuplusLambdaTable ;
|
||||
static G4PhysicsTable* themuminusLambdaTable ;
|
||||
|
||||
G4OrderedTable PartialSumSigma; // partial sum of total crosssection
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
const G4double LowestKineticEnergy; // low energy limit of the crossection formula
|
||||
const G4double HighestKineticEnergy; // high energy limit of the crossection formula
|
||||
G4int TotBin; // number of bins in the tables
|
||||
|
||||
G4double MinKineticEnergy; //process is ignored if T<MinKineticEnergy
|
||||
G4double MinCutValue; //protection against divergencies
|
||||
|
||||
G4double CutInRange;
|
||||
|
||||
const G4Electron* theElectron;
|
||||
const G4Positron* thePositron;
|
||||
const G4MuonMinus* theMuonMinus;
|
||||
const G4MuonPlus* theMuonPlus;
|
||||
|
||||
const G4double* ElectronCutInKineticEnergy;
|
||||
const G4double* PositronCutInKineticEnergy;
|
||||
const G4double* MuonMinusCutInKineticEnergy;
|
||||
const G4double* MuonPlusCutInKineticEnergy;
|
||||
const G4double* ParticleCutInKineticEnergy;
|
||||
|
||||
|
||||
G4double ElectronCutInKineticEnergyNow;
|
||||
G4double PositronCutInKineticEnergyNow;
|
||||
G4double MuonMinusCutInKineticEnergyNow;
|
||||
G4double MuonPlusCutInKineticEnergyNow;
|
||||
G4double ParticleCutInKineticEnergyNow;
|
||||
|
||||
// tables for sampling ..............
|
||||
static G4int nzdat,ntdat,NBIN ;
|
||||
static G4double zdat[5],tdat[8] ;
|
||||
static G4double ya[1000],proba[5][8][1000] ;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#include "G4IMuPairProduction.icc"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,180 @@
|
||||
// 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: G4IMuPairProduction.icc,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// -------- G4IMuPairProduction physics process ---------
|
||||
// by Laszlo Urban, May 1998
|
||||
// ***************************************************************
|
||||
inline G4double G4IMuPairProduction::PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
)
|
||||
{// get particle,particle type,kin.energy,material,mat.index
|
||||
const G4double eps=1.e-2 ;
|
||||
const G4double Tfac=0.95,Tfac1=1.-Tfac ;
|
||||
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);
|
||||
|
||||
// if ( nl == 0.)
|
||||
// {
|
||||
// value = BIGSTEP ;
|
||||
// return value ;
|
||||
// }
|
||||
|
||||
range = G4EnergyLossTables::GetPreciseRangeFromEnergy(particletype,
|
||||
KineticEnergy,material) ;
|
||||
|
||||
if ( (previousStepSize <=0.0) || (theNumberOfInteractionLengthLeft<=0.0)) {
|
||||
// beggining of tracking (or just after DoIt of this process)
|
||||
ResetNumberOfInteractionLengthLeft();
|
||||
} else {
|
||||
// subtract NumberOfInteractionLengthLeft
|
||||
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 << "G4IMuPairProduction PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)" << G4endl
|
||||
;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
//corr. of num errror
|
||||
nlold = nl ;
|
||||
}
|
||||
}
|
||||
|
||||
theNumberOfInteractionLengthLeft -= nlold-nl ;
|
||||
|
||||
if(theNumberOfInteractionLengthLeft<perMillion)
|
||||
theNumberOfInteractionLengthLeft=0.;
|
||||
}
|
||||
|
||||
|
||||
// condition is set to "Not Forced"
|
||||
*condition = NotForced;
|
||||
if(nl <= theNumberOfInteractionLengthLeft)
|
||||
{
|
||||
value = BIGSTEP ;
|
||||
}
|
||||
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 << "G4IMuPairProduction PostStepGPIL: Step < 0.!, Step=" << value << G4endl
|
||||
;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
//corr. of num error
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
|
||||
inline G4double G4IMuPairProduction::ComputeMeanFreePath(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial)
|
||||
{
|
||||
const G4ElementVector* theElementVector = aMaterial->GetElementVector() ;
|
||||
const G4double* theAtomNumDensityVector = aMaterial->GetAtomicNumDensityVector();
|
||||
G4double ElectronEnergyCut = (G4Electron::GetCutsInEnergy())[aMaterial->GetIndex()];
|
||||
G4double PositronEnergyCut = (G4Positron::GetCutsInEnergy())[aMaterial->GetIndex()];
|
||||
|
||||
const G4double BigPath= DBL_MAX;
|
||||
|
||||
G4double SIGMA = 0 ;
|
||||
|
||||
for ( G4int i=0 ; i < aMaterial->GetNumberOfElements() ; i++ )
|
||||
{
|
||||
SIGMA += theAtomNumDensityVector[i] *
|
||||
ComputeMicroscopicCrossSection( ParticleType, KineticEnergy,
|
||||
(*theElementVector)(i)->GetZ(),
|
||||
ElectronEnergyCut,PositronEnergyCut );
|
||||
}
|
||||
|
||||
return SIGMA<=0.0 ? BigPath : 1./SIGMA ;
|
||||
}
|
||||
|
||||
|
||||
inline G4bool G4IMuPairProduction::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return( (&particle == (const G4ParticleDefinition *)theMuonMinus)
|
||||
||(&particle == (const G4ParticleDefinition *)theMuonPlus)
|
||||
) ;
|
||||
}
|
||||
@@ -0,0 +1,156 @@
|
||||
// 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: G4IMultipleScattering.hh,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// --------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD Group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// --------- G4IMultipleScattering physics process --------
|
||||
// by Laszlo Urban, October 1997
|
||||
// **************************************************************
|
||||
// UNIVERSAL: for arbitrary single charged particle
|
||||
// 09/12/98: charge can be != +- 1 !!!! L.Urban
|
||||
// --------------------------------------------------------------
|
||||
// *****************************************************************
|
||||
// It is the first implementation of the multiple scattering process
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// *****************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// -----------------------------------------------------------------
|
||||
// 27/10/98: cleanup , L.Urban
|
||||
|
||||
#ifndef G4IMultipleScattering_h
|
||||
#define G4IMultipleScattering_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/fstream"
|
||||
#include "g4std/iomanip"
|
||||
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4MuonPlus.hh"
|
||||
#include "G4Proton.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4GPILSelection.hh"
|
||||
#include "G4VContinuousDiscreteProcess.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4MaterialTable.hh"
|
||||
#include "G4ElementTable.hh"
|
||||
#include "G4ElementVector.hh"
|
||||
#include "G4VParticleChange.hh"
|
||||
|
||||
class G4IMultipleScattering : public G4VContinuousDiscreteProcess
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IMultipleScattering(const G4String& processName="Imsc") ;
|
||||
|
||||
~G4IMultipleScattering() ;
|
||||
|
||||
G4bool IsApplicable ( const G4ParticleDefinition& ) ;
|
||||
|
||||
void SetPhysicsTableBining(G4double lowE,G4double highE,G4int nBins);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void BuildIntegralITable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildIntegralJTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
G4double GetIntegralI(const G4ParticleDefinition *aParticle,
|
||||
G4double KineticEnergy,G4Material* aMaterial) ;
|
||||
G4double GetIntegralJ(const G4ParticleDefinition *aParticle,
|
||||
G4double KineticEnergy,G4Material* aMaterial) ;
|
||||
|
||||
void PrintInfoDefinition();
|
||||
|
||||
G4double GetContinuousStepLimit(const G4Track& aTrack,
|
||||
G4double previousStepSize,
|
||||
G4double currentMinimumStep,
|
||||
G4double& currentSafety) ;
|
||||
|
||||
G4double GetMeanFreePath(const G4Track& aTrack,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition) ;
|
||||
|
||||
G4VParticleChange* AlongStepDoIt(const G4Track& aTrack,const G4Step& aStep) ;
|
||||
|
||||
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,const G4Step& aStep) ;
|
||||
|
||||
protected:
|
||||
|
||||
G4double ComputeTransportCrossSection(
|
||||
const G4ParticleDefinition& aParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber) ;
|
||||
|
||||
G4double TrueToGeomTransformation(const G4DynamicParticle* aParticle,
|
||||
G4Material* aMaterial,
|
||||
G4double truePathLength) ;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator as private
|
||||
G4IMultipleScattering & operator = (const G4IMultipleScattering &right) ;
|
||||
G4IMultipleScattering ( const G4IMultipleScattering &) ;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// data members ...................................................
|
||||
G4PhysicsTable* theTransportMeanFreePathTable;
|
||||
G4PhysicsTable* theIntegralITable ;
|
||||
G4PhysicsTable* theIntegralJTable ;
|
||||
|
||||
G4double fTransportMeanFreePath ;
|
||||
|
||||
G4double fMeanLateralDisplacement ;
|
||||
|
||||
G4double LowestKineticEnergy ;
|
||||
G4double HighestKineticEnergy ;
|
||||
G4int TotBin ;
|
||||
|
||||
const G4Electron* theElectron ;
|
||||
const G4Positron* thePositron ;
|
||||
|
||||
G4Material* lastMaterial;
|
||||
G4double lastKineticEnergy;
|
||||
|
||||
// GeomStepFinal is the geom.steplength at the end of the AlongStep loop
|
||||
// the others are some 'cache' variables
|
||||
G4double GeomStepFinal ;
|
||||
G4double tLast,zLast,CosTheta ;
|
||||
|
||||
G4double biglambda ;
|
||||
|
||||
//parameters for low energy extrapolation of dE/dx and lambda
|
||||
const G4double plowloss,plowlambda ;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
G4double tuning ;
|
||||
};
|
||||
|
||||
#include "G4IMultipleScattering.icc"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,268 @@
|
||||
// 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: G4IMultipleScattering.icc,v 1.1 2001/03/05 10:55:20 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// -------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD Group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------- G4IMultipleScattering physics process ------
|
||||
// by Laszlo Urban, October 1997
|
||||
// **************************************************************
|
||||
// 25/11/97: mods for KinEnergy > HighestLimit
|
||||
//---------------------------------------------------------------
|
||||
// *****************************************************************
|
||||
// It is the first implementation of the multiple scattering process
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// *****************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// -----------------------------------------------------------------
|
||||
// 27/10/98: cleanup , L.Urban
|
||||
|
||||
inline G4double G4IMultipleScattering::TrueToGeomTransformation(
|
||||
const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial,
|
||||
G4double truePathLength)
|
||||
|
||||
// it sets the data member fTransportMeanFreePath and
|
||||
// performs the true path length -> geometrical path length
|
||||
// transformation
|
||||
|
||||
{
|
||||
const G4double factt=1.-1.e-6,tausmall=5.e-5,taubig=50.,
|
||||
minim=1.e-6,smalldroverr=1.e-2,smalldToverT=2.e-2 ;
|
||||
|
||||
G4double KineticEnergy,Tfinal,tau,etau,geomPathLength,range,w1,w2,ww1,ww2 ;
|
||||
G4int materialIndex ;
|
||||
G4bool isOut ;
|
||||
|
||||
KineticEnergy = aParticle->GetKineticEnergy() ;
|
||||
|
||||
if((lastMaterial == aMaterial) && (lastKineticEnergy == KineticEnergy))
|
||||
{ ; }
|
||||
else
|
||||
{
|
||||
lastMaterial=aMaterial;
|
||||
lastKineticEnergy=KineticEnergy;
|
||||
materialIndex = aMaterial->GetIndex() ;
|
||||
|
||||
if(KineticEnergy<LowestKineticEnergy)
|
||||
{
|
||||
fTransportMeanFreePath =
|
||||
exp(plowlambda*log((KineticEnergy/LowestKineticEnergy)))*
|
||||
(*theTransportMeanFreePathTable)
|
||||
(materialIndex)->GetValue(LowestKineticEnergy,isOut);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(KineticEnergy>HighestKineticEnergy)
|
||||
KineticEnergy=HighestKineticEnergy;
|
||||
fTransportMeanFreePath = (*theTransportMeanFreePathTable)
|
||||
(materialIndex)->GetValue(KineticEnergy,isOut);
|
||||
}
|
||||
}
|
||||
|
||||
// do the true -> geom transformation
|
||||
if( fTransportMeanFreePath > biglambda )
|
||||
{
|
||||
geomPathLength = truePathLength ;
|
||||
CosTheta = 1. ;
|
||||
}
|
||||
else
|
||||
{
|
||||
const G4ParticleDefinition *theParticle = aParticle->GetDefinition() ;
|
||||
G4double range = G4EnergyLossTables::GetPreciseRangeFromEnergy(
|
||||
theParticle,KineticEnergy,aMaterial) ;
|
||||
if(truePathLength > factt*range)
|
||||
{
|
||||
geomPathLength = GetIntegralJ(theParticle,
|
||||
KineticEnergy,aMaterial) ;
|
||||
CosTheta = 0. ;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(truePathLength/range < smalldroverr)
|
||||
{
|
||||
Tfinal = KineticEnergy - truePathLength*
|
||||
G4EnergyLossTables::GetPreciseDEDX(
|
||||
theParticle,KineticEnergy,aMaterial) ;
|
||||
}
|
||||
else
|
||||
{
|
||||
Tfinal = G4EnergyLossTables::GetPreciseEnergyFromRange(
|
||||
theParticle,range-truePathLength,
|
||||
aMaterial) ;
|
||||
}
|
||||
|
||||
if((KineticEnergy-Tfinal)> smalldToverT)
|
||||
{
|
||||
w1 = GetIntegralI(theParticle,KineticEnergy,aMaterial) ;
|
||||
w2 = GetIntegralI(theParticle,Tfinal ,aMaterial) ;
|
||||
CosTheta = exp(w2-w1) ;
|
||||
if( CosTheta < minim)
|
||||
CosTheta = 0. ;
|
||||
|
||||
ww1 = GetIntegralJ(theParticle,KineticEnergy,aMaterial) ;
|
||||
ww2 = GetIntegralJ(theParticle,Tfinal ,aMaterial) ;
|
||||
|
||||
geomPathLength = ww1 - ww2*CosTheta ;
|
||||
}
|
||||
else
|
||||
{
|
||||
tau = truePathLength/fTransportMeanFreePath ;
|
||||
|
||||
if(tau<tausmall)
|
||||
etau = tau ;
|
||||
else
|
||||
{
|
||||
if(tau>taubig)
|
||||
etau = 1. ;
|
||||
else
|
||||
etau = 1.-exp(-tau) ;
|
||||
}
|
||||
|
||||
geomPathLength = fTransportMeanFreePath*etau ;
|
||||
|
||||
CosTheta = exp(-truePathLength/fTransportMeanFreePath) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(geomPathLength>truePathLength)
|
||||
geomPathLength = truePathLength ;
|
||||
|
||||
tLast = truePathLength ;
|
||||
zLast = geomPathLength ;
|
||||
|
||||
return geomPathLength ;
|
||||
}
|
||||
|
||||
inline G4double G4IMultipleScattering::GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double,
|
||||
G4double currentMinimumStep,
|
||||
G4double&)
|
||||
{
|
||||
G4double zPathLength,tPathLength ;
|
||||
const G4DynamicParticle* aParticle ;
|
||||
// this process is not a candidate for selection!!!!!!!!!
|
||||
SetGPILSelection(NotCandidateForSelection) ;
|
||||
|
||||
tPathLength = currentMinimumStep ;
|
||||
aParticle = track.GetDynamicParticle() ;
|
||||
|
||||
zPathLength = TrueToGeomTransformation(aParticle,
|
||||
track.GetMaterial(),tPathLength);
|
||||
return zPathLength ;
|
||||
}
|
||||
|
||||
inline G4double G4IMultipleScattering::GetMeanFreePath(const G4Track&,
|
||||
G4double,
|
||||
G4ForceCondition* condition)
|
||||
// it does not limit the Step size , but it sets condition to
|
||||
// Forced , because the PostStepDoIt always has to be called
|
||||
{
|
||||
*condition = Forced ;
|
||||
|
||||
return DBL_MAX ;
|
||||
}
|
||||
|
||||
inline G4VParticleChange* G4IMultipleScattering::AlongStepDoIt(
|
||||
const G4Track& track,const G4Step& Step)
|
||||
// only a geom path->true path transformation is performed
|
||||
{
|
||||
const G4double Tlowlimit=100.*keV ;
|
||||
const G4double fact = 1.-1.e-10 ;
|
||||
//!! const G4double tausmall=5.e-5,taubig=0.9999,trueBig=5. ;
|
||||
const G4double tausmall=5.e-5,taubig=0.9999,trueBig=9.21034 ;
|
||||
G4double tau ,geomPathLength, truePathLength ;
|
||||
|
||||
aParticleChange.Initialize(track);
|
||||
|
||||
geomPathLength = track.GetStepLength() ;
|
||||
|
||||
//Store this value for later use in PostStepDoIt
|
||||
GeomStepFinal = geomPathLength ;
|
||||
|
||||
if(geomPathLength == zLast)
|
||||
{
|
||||
truePathLength = tLast ;
|
||||
}
|
||||
else
|
||||
{
|
||||
if( fTransportMeanFreePath > biglambda )
|
||||
{
|
||||
truePathLength = track.GetStepLength() ;
|
||||
CosTheta = 1. ;
|
||||
}
|
||||
else
|
||||
{
|
||||
G4double T = track.GetDynamicParticle()->GetKineticEnergy() ;
|
||||
if(T < Tlowlimit)
|
||||
{ // spec. low energy msc code
|
||||
G4double range = G4EnergyLossTables::GetPreciseRangeFromEnergy(
|
||||
track.GetDynamicParticle()->GetDefinition(),
|
||||
T,track.GetMaterial()) ;
|
||||
G4double alfa = 1.+range/fTransportMeanFreePath ;
|
||||
G4double z = geomPathLength ;
|
||||
//protection: z can not be greater than zmax !!!!!!!
|
||||
G4double zmax = fact*range/alfa ;
|
||||
if(z > zmax)
|
||||
z = zmax ;
|
||||
|
||||
if(z == zmax)
|
||||
{
|
||||
truePathLength = range ;
|
||||
CosTheta = 0. ;
|
||||
}
|
||||
else
|
||||
{
|
||||
truePathLength = range*
|
||||
(1.-exp(log(1.-alfa*z/range)/alfa)) ;
|
||||
CosTheta = (1.-alfa*z/range)/(1.-truePathLength/range) ;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
tau = geomPathLength/fTransportMeanFreePath ;
|
||||
|
||||
if(tau<tausmall)
|
||||
truePathLength = fTransportMeanFreePath*tau*(1.+0.5*tau) ;
|
||||
else
|
||||
{
|
||||
if(tau<taubig)
|
||||
truePathLength = -fTransportMeanFreePath*log(1.-tau) ;
|
||||
else
|
||||
truePathLength = fTransportMeanFreePath*trueBig ;
|
||||
}
|
||||
CosTheta = exp(-truePathLength/fTransportMeanFreePath) ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(truePathLength<geomPathLength)
|
||||
truePathLength = geomPathLength ;
|
||||
|
||||
aParticleChange.SetTrueStepLength(truePathLength) ;
|
||||
|
||||
return &aParticleChange ;
|
||||
}
|
||||
|
||||
|
||||
inline G4bool G4IMultipleScattering::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return(particle.GetPDGCharge() != 0.);
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,180 @@
|
||||
// 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: G4IeBremsstrahlung.hh,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
// CERN Geneva Switzerland
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IeBremsstrahlung physics process ------
|
||||
// by Michel Maire, 24 July 1996
|
||||
// ************************************************************
|
||||
// 1-10-96 : new type G4OrderedTable; ComputePartialSumSigma()
|
||||
// 20/03/97: new energy loss+ionisation+brems scheme, L.Urban
|
||||
// ------------------------------------------------------------
|
||||
// ************************************************************
|
||||
// It is the first implementation of the BREMSSTRAHLUNG
|
||||
// PROCESS. ( photons + continuous energy loss)
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ------------------------------------------------------------
|
||||
// 28/10/98: small changes, cleanup L.Urban
|
||||
|
||||
#ifndef G4IeBremsstrahlung_h
|
||||
#define G4IeBremsstrahlung_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIeEnergyLoss.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Gamma.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4OrderedTable.hh"
|
||||
#include "G4PhysicsTable.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
|
||||
class G4IeBremsstrahlung : public G4VIeEnergyLoss
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IeBremsstrahlung(const G4String& processName = "IeBrems");
|
||||
|
||||
~G4IeBremsstrahlung();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
void SetPhysicsTableBining(G4double lowE, G4double highE, G4int nBins);
|
||||
|
||||
void PrintInfoDefinition();
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& ParticleType);
|
||||
|
||||
G4double GetMeanFreePath(const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition );
|
||||
|
||||
G4VParticleChange *PostStepDoIt(const G4Track& track,
|
||||
const G4Step& step);
|
||||
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength( const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition);
|
||||
G4double GetNlambda(
|
||||
G4double KineticEnergy,G4Material* material);
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
inline G4double ComputeMeanFreePath(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
void ComputePartialSumSigma( const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial);
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber,
|
||||
G4double GammaEnergyCut);
|
||||
|
||||
private:
|
||||
|
||||
G4IeBremsstrahlung & operator=(const G4IeBremsstrahlung &right);
|
||||
G4IeBremsstrahlung(const G4IeBremsstrahlung&);
|
||||
|
||||
G4double ComputeBremLoss(G4double Z,G4double natom,G4double T,
|
||||
G4double Cut,G4double x);
|
||||
|
||||
G4double ComputeXYPolynomial(G4double x,G4double y,G4int xSize,
|
||||
G4int ySize,const G4double coeff[]);
|
||||
|
||||
G4double ComputePositronCorrFactorLoss( G4double AtomicNumber,
|
||||
G4double KineticEnergy, G4double GammaEnergyCut);
|
||||
|
||||
G4double ComputePositronCorrFactorSigma( G4double AtomicNumber,
|
||||
G4double KineticEnergy, G4double GammaEnergyCut);
|
||||
|
||||
G4Element* SelectRandomAtom(G4Material* aMaterial) const;
|
||||
|
||||
G4double ScreenFunction1(G4double ScreenVariable);
|
||||
|
||||
G4double ScreenFunction2(G4double ScreenVariable);
|
||||
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable ;
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
G4OrderedTable PartialSumSigma;
|
||||
|
||||
G4double LowestKineticEnergy;
|
||||
G4double HighestKineticEnergy;
|
||||
G4int TotBin;
|
||||
|
||||
G4double RTable ;
|
||||
G4double CutInRange;
|
||||
|
||||
const G4Gamma* theGamma;
|
||||
const G4Electron* theElectron;
|
||||
const G4Positron* thePositron;
|
||||
|
||||
const G4double* GammaCutInKineticEnergy;
|
||||
|
||||
G4double GammaCutInKineticEnergyNow;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
};
|
||||
|
||||
#include "G4IeBremsstrahlung.icc"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,214 @@
|
||||
// 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: G4IeBremsstrahlung.icc,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IeBremsstrahlung physics process ---------
|
||||
// by Michel Maire, 27 July 1996
|
||||
// ***************************************************************
|
||||
// It is the first implementation of the BREMSSTRAHLUNG
|
||||
// PROCESS. ( photons + continuous energy loss)
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ----------------------------------------------------------------
|
||||
// 28/10/98: small changes, cleanup L.Urban
|
||||
|
||||
inline G4double G4IeBremsstrahlung::PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition
|
||||
)
|
||||
{
|
||||
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 << "G4IeBremsstrahlung PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)"
|
||||
<< G4endl;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
nlold = nl ;
|
||||
}
|
||||
}
|
||||
|
||||
theNumberOfInteractionLengthLeft -= nlold-nl ;
|
||||
|
||||
if(theNumberOfInteractionLengthLeft<perMillion)
|
||||
theNumberOfInteractionLengthLeft=0.;
|
||||
}
|
||||
|
||||
*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 << "G4IeBremsstrahlung PostStepGPIL: Step < 0.!, Step=" <<
|
||||
value << G4endl;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
inline G4double G4IeBremsstrahlung::ScreenFunction1(G4double ScreenVariable)
|
||||
// compute the value of the screening function 3*PHI1 - PHI2
|
||||
{
|
||||
G4double screenVal;
|
||||
|
||||
if (ScreenVariable > 1.)
|
||||
screenVal = 42.24 - 8.368*log(ScreenVariable+0.952);
|
||||
else
|
||||
screenVal = 42.392 - ScreenVariable* (7.796 - 1.961*ScreenVariable);
|
||||
|
||||
return screenVal;
|
||||
}
|
||||
|
||||
inline G4double G4IeBremsstrahlung::ScreenFunction2(G4double ScreenVariable)
|
||||
|
||||
// compute the value of the screening function 1.5*PHI1 - 0.5*PHI2
|
||||
{
|
||||
G4double screenVal;
|
||||
|
||||
if (ScreenVariable > 1.)
|
||||
screenVal = 42.24 - 8.368*log(ScreenVariable+0.952);
|
||||
else
|
||||
screenVal = 41.734 - ScreenVariable* (6.484 - 1.250*ScreenVariable);
|
||||
|
||||
return screenVal;
|
||||
}
|
||||
|
||||
inline G4double G4IeBremsstrahlung::ComputeMeanFreePath(
|
||||
const G4ParticleDefinition* ParticleType,
|
||||
G4double KineticEnergy,
|
||||
const G4Material* aMaterial)
|
||||
{
|
||||
const G4ElementVector* theElementVector = aMaterial->GetElementVector() ;
|
||||
const G4double* theAtomNumDensityVector =
|
||||
aMaterial->GetAtomicNumDensityVector();
|
||||
G4double GammaEnergyCut = (G4Gamma::GetCutsInEnergy())[aMaterial->GetIndex()];
|
||||
|
||||
G4double SIGMA = 0 ;
|
||||
|
||||
for ( G4int i=0 ; i < aMaterial->GetNumberOfElements() ; i++ )
|
||||
{
|
||||
SIGMA += theAtomNumDensityVector[i] *
|
||||
ComputeMicroscopicCrossSection( ParticleType, KineticEnergy,
|
||||
(*theElementVector)(i)->GetZ(),
|
||||
GammaEnergyCut );
|
||||
}
|
||||
return SIGMA<=0.0 ? DBL_MAX : 1./SIGMA ;
|
||||
}
|
||||
|
||||
inline G4bool G4IeBremsstrahlung::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return( (&particle == (const G4ParticleDefinition *)theElectron)
|
||||
||(&particle == (const G4ParticleDefinition *)thePositron)
|
||||
) ;
|
||||
}
|
||||
|
||||
inline G4double G4IeBremsstrahlung::GetNlambda(
|
||||
G4double KineticEnergy,
|
||||
G4Material* material)
|
||||
{
|
||||
G4bool isOut;
|
||||
const G4MaterialTable* theMaterialTable =
|
||||
G4Material::GetMaterialTable() ;
|
||||
|
||||
G4double lambda = (*theNlambdaTable)
|
||||
[material->GetIndex()]->
|
||||
GetValue(KineticEnergy,isOut);
|
||||
return lambda;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
// 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: G4IeIonisation.hh,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ---------- G4IeIonisation physics process -----------
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ************************************************************
|
||||
// It is the first implementation of the IONISATION
|
||||
// PROCESS. ( delta rays + continuous energy loss)
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// 27/10/98 : minor changes+cleanup , L.Urban
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef G4IeIonisation_h
|
||||
#define G4IeIonisation_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/iomanip"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIeEnergyLoss.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "globals.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4Gamma.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
class G4IeIonisation : public G4VIeEnergyLoss
|
||||
{
|
||||
public:
|
||||
|
||||
G4IeIonisation(const G4String& processName = "IeIoni");
|
||||
|
||||
~G4IeIonisation();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
void SetPhysicsTableBining(G4double lowE, G4double highE, G4int nBins);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void PrintInfoDefinition();
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength( const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition);
|
||||
|
||||
G4VParticleChange *PostStepDoIt(const G4Track& track,
|
||||
const G4Step& Step ) ;
|
||||
|
||||
G4double GetNlambda(
|
||||
G4double KineticEnergy,G4Material* material);
|
||||
|
||||
protected:
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition& aParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber);
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator
|
||||
G4IeIonisation & operator=(const G4IeIonisation &right);
|
||||
G4IeIonisation(const G4IeIonisation&);
|
||||
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
private:
|
||||
// private data members ...............................
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable;
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
G4double LowestKineticEnergy;
|
||||
G4double HighestKineticEnergy;
|
||||
G4int TotBin;
|
||||
G4double RTable ;
|
||||
|
||||
// cut in range
|
||||
G4double CutInRange ;
|
||||
|
||||
// particles , cuts in kinetic energy ........
|
||||
const G4Electron* theElectron;
|
||||
const G4Positron* thePositron;
|
||||
|
||||
const G4double* ParticleCutInKineticEnergy;
|
||||
const G4double* DeltaCutInKineticEnergy ;
|
||||
|
||||
G4double ParticleCutInKineticEnergyNow ;
|
||||
G4double DeltaKineticEnergyCutNow ;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
};
|
||||
|
||||
#include "G4IeIonisation.icc"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,163 @@
|
||||
// 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: G4IeIonisation.icc,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// ------------ G4IeIonisation physics process ------------
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ************************************************************
|
||||
// It is the first implementation of the IONISATION
|
||||
// PROCESS. ( delta rays + continuous energy loss)
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// 27/10/98: minor changes , cleanup , L.Urban
|
||||
// ------------------------------------------------------------
|
||||
|
||||
inline G4double G4IeIonisation::PostStepGetPhysicalInteractionLength(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition)
|
||||
{
|
||||
const G4double eps=1.e-2,Tfac=0.95,Tfac1=1.-Tfac ;
|
||||
|
||||
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)) {
|
||||
// beggining of tracking (or just after DoIt of this process)
|
||||
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 << "G4IeIonisation PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)"
|
||||
<< G4endl;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
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 << "G4IeIonisation PostStepGPIL: Step < 0.!, Step="
|
||||
<< value << G4endl;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
inline G4bool G4IeIonisation::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return( (&particle == (const G4ParticleDefinition *)theElectron)
|
||||
||(&particle == (const G4ParticleDefinition *)thePositron)
|
||||
) ;
|
||||
}
|
||||
|
||||
inline G4double G4IeIonisation::GetNlambda(
|
||||
G4double KineticEnergy,
|
||||
G4Material* material)
|
||||
{
|
||||
G4bool isOut;
|
||||
const G4MaterialTable* theMaterialTable =
|
||||
G4Material::GetMaterialTable() ;
|
||||
|
||||
G4double lambda = (*theNlambdaTable)
|
||||
[material->GetIndex()]->
|
||||
GetValue(KineticEnergy,isOut);
|
||||
return lambda;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,144 @@
|
||||
// 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: G4IeplusAnnihilation.hh,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
// CERN Geneva Switzerland
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IeplusAnnihilation process ------
|
||||
// by Michel Maire, 7 july 1996
|
||||
// ************************************************************
|
||||
// ************************************************************
|
||||
// It is the first implementation of the
|
||||
// eplusANNIHILATION PROCESS
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ----------------------------------------------------------
|
||||
// 28/10/98: cleanup L. Urban
|
||||
|
||||
|
||||
#ifndef G4IeplusAnnihilation_h
|
||||
#define G4IeplusAnnihilation_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4IVRestDiscreteProcess.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "G4PhysicsTable.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
#include "G4ElementTable.hh"
|
||||
#include "G4Gamma.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4Step.hh"
|
||||
|
||||
class G4IeplusAnnihilation : public G4IVRestDiscreteProcess
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IeplusAnnihilation(const G4String& processName ="Iannihil");
|
||||
|
||||
~G4IeplusAnnihilation();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
void SetPhysicsTableBining(G4double lowE, G4double highE, G4int nBins);
|
||||
|
||||
void PrintInfoDefinition();
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& PositronType);
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength(const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition) ;
|
||||
|
||||
G4double GetMicroscopicCrossSection(G4DynamicParticle* aDynamicPositron,
|
||||
G4Element* anElement);
|
||||
|
||||
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
|
||||
const G4Step& aStep);
|
||||
|
||||
G4double GetMeanLifeTime(const G4Track& aTrack,
|
||||
G4ForceCondition* condition);
|
||||
|
||||
G4VParticleChange* AtRestDoIt(const G4Track& aTrack,
|
||||
const G4Step& aStep);
|
||||
|
||||
protected:
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(G4double PositKinEnergy,
|
||||
G4double AtomicNumber);
|
||||
|
||||
virtual G4double ComputeMeanFreePath(G4double PositKinEnergy,
|
||||
G4Material* aMaterial);
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator as private
|
||||
G4IeplusAnnihilation& operator=(const G4IeplusAnnihilation &right);
|
||||
G4IeplusAnnihilation(const G4IeplusAnnihilation& );
|
||||
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theCrossSectionTable; // table for crossection
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable ;
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
G4double LowestEnergyLimit ; // low energy limit of the crossection formula
|
||||
G4double HighestEnergyLimit ; // high energy limit of the crossection formula
|
||||
G4int NumbBinTable ; // number of bins in the crossection table
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
G4double LowestKineticEnergy ;
|
||||
G4double HighestKineticEnergy;
|
||||
G4int TotBin ;
|
||||
|
||||
G4double RTable ;
|
||||
|
||||
};
|
||||
|
||||
#include "G4IeplusAnnihilation.icc"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,197 @@
|
||||
// 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: G4IeplusAnnihilation.icc,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4IeplusAnnihilation process ---------
|
||||
// by Michel Maire, 7 July 1996
|
||||
// ***************************************************************
|
||||
// ************************************************************
|
||||
// It is the first implementation of the
|
||||
// eplusANNIHILATION PROCESS
|
||||
// using an INTEGRAL APPROACH instead of the differential
|
||||
// one used in the standard implementation .
|
||||
// ************************************************************
|
||||
// by Laszlo Urban, 23 June 1998
|
||||
// ---------------------------------------------------------
|
||||
// 28/10/98: some cleanup , L.Urban
|
||||
|
||||
inline G4bool G4IeplusAnnihilation::IsApplicable(const G4ParticleDefinition& particle)
|
||||
{
|
||||
return ( &particle == G4Positron::Positron() );
|
||||
}
|
||||
inline G4double G4IeplusAnnihilation::GetMicroscopicCrossSection(
|
||||
G4DynamicParticle* aDynamicPositron,
|
||||
G4Element* anElement)
|
||||
|
||||
// gives the microscopic total cross section in GEANT4 internal units
|
||||
|
||||
{
|
||||
G4double crossSection;
|
||||
G4double PositronEnergy = aDynamicPositron->GetKineticEnergy();
|
||||
G4bool isOutRange ;
|
||||
|
||||
if (PositronEnergy > HighestEnergyLimit)
|
||||
crossSection = 0. ;
|
||||
else {
|
||||
if (PositronEnergy < LowestEnergyLimit) PositronEnergy = 1.01*LowestEnergyLimit;
|
||||
crossSection = (*theCrossSectionTable)(anElement->GetIndex())->
|
||||
GetValue( PositronEnergy, isOutRange );
|
||||
}
|
||||
|
||||
return crossSection;
|
||||
}
|
||||
|
||||
|
||||
inline G4double G4IeplusAnnihilation::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 << "G4IeplusAnnihilation PostStepGPIL : Nlambda has been" <<
|
||||
" increased at update.Nlambda old/new :" << nlold <<
|
||||
" " << nl << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)" << G4endl;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
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 << "G4IeplusAnnihilation PostStepGPIL: Step < 0.!, Step=" <<
|
||||
value << G4endl;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
inline G4double G4IeplusAnnihilation::ComputeMeanFreePath(G4double PositKinEnergy,
|
||||
G4Material* aMaterial)
|
||||
|
||||
// returns the positron mean free path in GEANT4 internal units
|
||||
|
||||
{
|
||||
const G4ElementVector* theElementVector = aMaterial->GetElementVector() ;
|
||||
const G4double* theAtomNumDensityVector = aMaterial->GetAtomicNumDensityVector();
|
||||
|
||||
G4double SIGMA = 0 ;
|
||||
|
||||
for ( G4int i=0 ; i < aMaterial->GetNumberOfElements() ; i++ )
|
||||
{
|
||||
SIGMA += theAtomNumDensityVector[i] *
|
||||
ComputeMicroscopicCrossSection( PositKinEnergy,
|
||||
(*theElementVector)(i)->GetZ() );
|
||||
}
|
||||
|
||||
return SIGMA<=0.0 ? DBL_MAX : 1./SIGMA ;
|
||||
}
|
||||
|
||||
inline G4double G4IeplusAnnihilation::GetMeanLifeTime(const G4Track&,
|
||||
G4ForceCondition*)
|
||||
// returns the annihilation mean life time in GEANT4 internal units
|
||||
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
// 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.hh,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ---------- G4IhIonisation physics process -----------
|
||||
// by Laszlo Urban, 30 May 1997
|
||||
// ************************************************************
|
||||
// It is the first implementation of the NEW IONISATION
|
||||
// PROCESS. ( delta rays + continuous energy loss)
|
||||
// It calculates the ionisation for charged hadrons.
|
||||
// ************************************************************
|
||||
// corrected by L.Urban on 24/09/97
|
||||
// corrected by L.Urban on 13/01/98
|
||||
// 28/10/98: some cleanup , L.Urban
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef G4IhIonisation_h
|
||||
#define G4IhIonisation_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4VIhEnergyLoss.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "globals.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Proton.hh"
|
||||
#include "G4AntiProton.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
|
||||
class G4IhIonisation : public G4VIhEnergyLoss
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4IhIonisation(const G4String& processName = "IhIoni");
|
||||
|
||||
~G4IhIonisation();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
void SetPhysicsTableBining(G4double lowE, G4double highE, G4int nBins);
|
||||
|
||||
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLossTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLambdaTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void PrintInfoDefinition();
|
||||
|
||||
G4double PostStepGetPhysicalInteractionLength(const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4ForceCondition* condition);
|
||||
|
||||
G4VParticleChange *PostStepDoIt(const G4Track& track,
|
||||
const G4Step& Step ) ;
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
virtual G4double ComputeMicroscopicCrossSection(
|
||||
const G4ParticleDefinition& aParticleType,
|
||||
G4double KineticEnergy,
|
||||
G4double AtomicNumber);
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator
|
||||
G4IhIonisation & operator=(const G4IhIonisation &right);
|
||||
G4IhIonisation(const G4IhIonisation&);
|
||||
|
||||
void BuildNlambdaTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
void BuildInverseNlambdaTable(
|
||||
const G4ParticleDefinition& aParticleType) ;
|
||||
void InvertNlambdaVector(const G4ParticleDefinition& aParticleType,
|
||||
G4int materialIndex,
|
||||
G4PhysicsLogVector* nlambdaVector) ;
|
||||
|
||||
void BuildCoeffATable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffBTable(const G4ParticleDefinition& aParticleType) ;
|
||||
void BuildCoeffCTable(const G4ParticleDefinition& aParticleType) ;
|
||||
|
||||
void TestOfInversion(const G4ParticleDefinition& aParticleType,
|
||||
G4int printflag) ;
|
||||
|
||||
private:
|
||||
// private data members ...............................
|
||||
|
||||
G4PhysicsTable* theMeanFreePathTable;
|
||||
|
||||
G4PhysicsTable* theNlambdaTable;
|
||||
G4PhysicsTable* theInverseNlambdaTable;
|
||||
|
||||
G4PhysicsTable* theCoeffATable;
|
||||
G4PhysicsTable* theCoeffBTable;
|
||||
G4PhysicsTable* theCoeffCTable;
|
||||
|
||||
const G4Electron* theElectron;
|
||||
const G4Proton* theProton;
|
||||
const G4AntiProton* theAntiProton;
|
||||
|
||||
const G4double* ParticleCutInKineticEnergy;
|
||||
const G4double* DeltaCutInKineticEnergy ;
|
||||
|
||||
G4double ParticleCutInKineticEnergyNow ;
|
||||
G4double DeltaCutInKineticEnergyNow ;
|
||||
|
||||
G4int NumberOfBuildPhysicsTableCalls ;
|
||||
|
||||
};
|
||||
|
||||
#include "G4IhIonisation.icc"
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -0,0 +1,145 @@
|
||||
// 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 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
//
|
||||
// ---------------------------------------------------------------
|
||||
// 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 << G4endl;
|
||||
G4cout << "(theNumberOfInteractionLengthLeft has been increased!)"
|
||||
<< G4endl;
|
||||
G4cout << " correction : Nlambda old=new ........." << G4endl;
|
||||
}
|
||||
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 << G4endl;
|
||||
G4cout << "range,rangenext:" << range << " " << rangenext << G4endl ;
|
||||
G4cout << "correction : rangenext=range ....." << G4endl;
|
||||
}
|
||||
rangenext = range ;
|
||||
value = range - rangenext ;
|
||||
}
|
||||
}
|
||||
}
|
||||
return value;
|
||||
}
|
||||
|
||||
inline G4bool G4IhIonisation::IsApplicable(
|
||||
const G4ParticleDefinition& particle)
|
||||
{
|
||||
return(particle.GetPDGCharge() != 0.);
|
||||
}
|
||||
|
||||
@@ -0,0 +1,280 @@
|
||||
// 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: G4VIMuEnergyLoss.hh,v 1.1 2001/03/05 10:55:21 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// -------------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ---------- G4VIMuEnergyLoss physics process -----------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ********************************************************************
|
||||
// It is the implementation of the NEW UNIFIED ENERGY LOSS PROCESS.
|
||||
// It calculates the continuous energy loss for muons.
|
||||
// Processes giving contribution to the continuous loss :
|
||||
// ionisation (= cont.ion.loss + delta ray production)
|
||||
// bremsstrahlung
|
||||
// e+e- pair production
|
||||
// can be added more easily ..........
|
||||
// This class creates static muplus/muminus dE/dx and range tables ,
|
||||
// which tables can be used by other processes.
|
||||
// ************************************************************
|
||||
// some corrections by L.Urban on 27/05/98 , (but other corrections come soon!)
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef G4VIMuEnergyLoss_h
|
||||
#define G4VIMuEnergyLoss_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "g4std/fstream"
|
||||
#include "g4std/iomanip"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4IVContinuousDiscreteProcess.hh"
|
||||
#include "G4Material.hh"
|
||||
#include "G4Element.hh"
|
||||
#include "G4EnergyLossTables.hh"
|
||||
#include "G4VParticleChange.hh"
|
||||
#include "globals.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4MuonMinus.hh"
|
||||
#include "G4MuonPlus.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
|
||||
class G4VIMuEnergyLoss : public G4IVContinuousDiscreteProcess
|
||||
|
||||
{
|
||||
public:
|
||||
G4VIMuEnergyLoss(const G4String& );
|
||||
G4VIMuEnergyLoss(G4VIMuEnergyLoss &);
|
||||
|
||||
virtual ~G4VIMuEnergyLoss();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator
|
||||
G4VIMuEnergyLoss & operator=(const G4VIMuEnergyLoss &right);
|
||||
|
||||
public:
|
||||
|
||||
G4double GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4double currentMinimumStep,
|
||||
G4double& currentSafety) ;
|
||||
|
||||
|
||||
G4VParticleChange* AlongStepDoIt(const G4Track& track ,const G4Step& Step) ;
|
||||
|
||||
|
||||
virtual G4VParticleChange* PostStepDoIt(const G4Track& track,const G4Step& Step) = 0 ;
|
||||
|
||||
// Build energy loss table (total continuous energy loss)
|
||||
|
||||
void BuildDEDXTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
//----------------------------------------------
|
||||
// public functions .........................
|
||||
// get the number of processes contributing to the cont.energy loss
|
||||
static G4int GetNUMBEROFPROCESSES() { return NUMBEROFPROCESSES; };
|
||||
// set the number of processes contributing to the cont.energy loss
|
||||
static void SetNUMBEROFPROCESSES(G4int number)
|
||||
{ NUMBEROFPROCESSES=number ; };
|
||||
// Increment the number of processes contributing to the cont.energy loss
|
||||
static void PlusNUMBEROFPROCESSES()
|
||||
{ NUMBEROFPROCESSES++ ; };
|
||||
// decrement the number of processes contributing to the cont.energy loss
|
||||
static void MinusNUMBEROFPROCESSES()
|
||||
{ NUMBEROFPROCESSES-- ; };
|
||||
|
||||
|
||||
//*****************************************************************************
|
||||
//
|
||||
|
||||
G4double GetConstraints(const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial);
|
||||
|
||||
G4double GetLossWithFluct(const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial,
|
||||
G4double ChargeSquare,
|
||||
G4double MeanLoss,
|
||||
G4double Step ) ;
|
||||
|
||||
protected:
|
||||
|
||||
G4PhysicsTable* theLossTable ;
|
||||
|
||||
static G4PhysicsTable* theDEDXmuplusTable ;
|
||||
static G4PhysicsTable* theDEDXmuminusTable ;
|
||||
static G4PhysicsTable* theRangemuplusTable ;
|
||||
static G4PhysicsTable* theRangemuminusTable ;
|
||||
static G4PhysicsTable* theInverseRangemuplusTable ;
|
||||
static G4PhysicsTable* theInverseRangemuminusTable ;
|
||||
|
||||
static G4PhysicsTable* theLabTimemuplusTable ;
|
||||
static G4PhysicsTable* theLabTimemuminusTable ;
|
||||
|
||||
static G4PhysicsTable* theProperTimemuplusTable ;
|
||||
static G4PhysicsTable* theProperTimemuminusTable ;
|
||||
|
||||
static G4PhysicsTable* themuplusRangeCoeffATable;
|
||||
static G4PhysicsTable* themuplusRangeCoeffBTable;
|
||||
static G4PhysicsTable* themuplusRangeCoeffCTable;
|
||||
static G4PhysicsTable* themuminusRangeCoeffATable;
|
||||
static G4PhysicsTable* themuminusRangeCoeffBTable;
|
||||
static G4PhysicsTable* themuminusRangeCoeffCTable;
|
||||
|
||||
static G4double CutInmupluslossTable;
|
||||
static G4double CutInmuminuslossTable;
|
||||
|
||||
// processes inherited from G4VIMuEnergyLoss
|
||||
// register themselves in the static array Recorder
|
||||
// nb of contributing processes = NUMBEROFPROCESSES
|
||||
static G4int NUMBEROFPROCESSES ;
|
||||
static G4PhysicsTable** RecorderOfmuplusProcess;
|
||||
static G4PhysicsTable** RecorderOfmuminusProcess;
|
||||
static G4int CounterOfmuplusProcess ;
|
||||
static G4int CounterOfmuminusProcess ;
|
||||
|
||||
G4double RTable,LOGRTable; // LOGRTable=log(HighestKineticEnergy
|
||||
// /LowestKineticEnergy)/TotBin
|
||||
// RTable = exp(LOGRTable)
|
||||
|
||||
// cut in range
|
||||
G4double CutInRange ;
|
||||
// last cut in range
|
||||
G4double lastCutInRange ;
|
||||
|
||||
// particle mass
|
||||
G4double ParticleMass;
|
||||
|
||||
G4double BIGSTEP ;
|
||||
|
||||
private:
|
||||
// private functions ..................................
|
||||
|
||||
void BuildRangeTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildInverseRangeTable(
|
||||
const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildTimeTables(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildLabTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
void BuildProperTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
void InvertRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
|
||||
void BuildRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
G4double LabTimeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
G4double ProperTimeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
|
||||
G4double RangeIntLin(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
|
||||
G4double RangeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
|
||||
void BuildRangeCoeffATable(const G4ParticleDefinition& aParticleType);
|
||||
void BuildRangeCoeffBTable(const G4ParticleDefinition& aParticleType);
|
||||
void BuildRangeCoeffCTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theDEDXTable;
|
||||
|
||||
G4PhysicsTable* theRangeTable;
|
||||
G4PhysicsTable* theInverseRangeTable;
|
||||
|
||||
G4PhysicsTable* theLabTimeTable;
|
||||
G4PhysicsTable* theProperTimeTable;
|
||||
|
||||
G4PhysicsTable** RecorderOfProcess;
|
||||
G4int CounterOfProcess;
|
||||
|
||||
// private data members ...............................
|
||||
|
||||
// fdEdx=(-dE/dx)
|
||||
// computed in GetConstraints at every call;
|
||||
G4double fdEdx;
|
||||
|
||||
// fRangeNow is the actual range of the particle
|
||||
// computed in GetConstraints
|
||||
G4double fRangeNow ;
|
||||
|
||||
// fMeanLoss is the energyloss without fluctuation
|
||||
// computed in AlongStepDoIt ;
|
||||
G4double fMeanLoss ;
|
||||
|
||||
// EnergyBinNumber,RangeCoeffA,... are needed to compute range
|
||||
G4int EnergyBinNumber ;
|
||||
G4double RangeCoeffA,RangeCoeffB,RangeCoeffC ;
|
||||
|
||||
//................................................................
|
||||
G4PhysicsTable* theRangeCoeffATable;
|
||||
G4PhysicsTable* theRangeCoeffBTable;
|
||||
G4PhysicsTable* theRangeCoeffCTable;
|
||||
|
||||
// dToverTini is the maximum allowed deltarange/range in one Step
|
||||
// ( set in this class for the moment)
|
||||
const G4double dToverTini;
|
||||
|
||||
// LowestKineticEnergy = lower limit of particle kinetic energy
|
||||
// HighestKineticEnergy = upper limit of particle kinetic energy
|
||||
// TotBin = number of bins
|
||||
// ---------in the energy loss/range tables-------------------
|
||||
const G4double LowestKineticEnergy;
|
||||
const G4double HighestKineticEnergy;
|
||||
G4int TotBin;// number of bins in table, calculated in BuildPhysicsTable
|
||||
// from LowestKineticEnergy,HighestKineticEnergy and
|
||||
// dToverTini
|
||||
|
||||
// variables for the integration routines
|
||||
G4double taulow,tauhigh,ltaulow,ltauhigh;
|
||||
|
||||
// cuts in kinetic energy ........
|
||||
G4double* ParticleCutInKineticEnergy ;
|
||||
G4double ParticleCutInKineticEnergyNow ;
|
||||
|
||||
// ...............
|
||||
const G4Electron* theElectron;
|
||||
const G4Positron* thePositron;
|
||||
const G4MuonPlus* theMuonPlus;
|
||||
const G4MuonMinus* theMuonMinus;
|
||||
|
||||
// data members to speed up the fluctuation calculation
|
||||
G4Material *lastMaterial ;
|
||||
G4int imat ;
|
||||
G4double f1Fluct,f2Fluct,e1Fluct,e2Fluct,rateFluct,ipotFluct;
|
||||
G4double e1LogFluct,e2LogFluct,ipotLogFluct;
|
||||
const G4double MaxExcitationNumber ;
|
||||
const G4double probLimFluct ;
|
||||
const long nmaxDirectFluct,nmaxCont1,nmaxCont2 ;
|
||||
|
||||
};
|
||||
|
||||
#include "G4VIMuEnergyLoss.icc"
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,146 @@
|
||||
// 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: G4VIMuEnergyLoss.icc,v 1.1 2001/03/05 10:55:22 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, CN Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4VIMuEnergyLoss physics process ------------
|
||||
// by Laszlo Urban, September 1997
|
||||
// ***************************************************************
|
||||
// It is the implementation of the NEW UNIFIED ENERGY LOSS PROCESS.
|
||||
// It calculates the energy loss of muons.
|
||||
// ***************************************************************
|
||||
// correction for KineticEnergy< LowestKineticEnergy by L.Urban on 27/11/97
|
||||
// corrections by L. Urban on 27/05/98 ( other corrs come soon!)
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
inline G4double G4VIMuEnergyLoss::GetConstraints(const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial)
|
||||
{
|
||||
|
||||
// returns the Step limit
|
||||
// dToverTini is the max. allowed relative range loss in one Step
|
||||
// it calculates dEdx and the range as well....
|
||||
|
||||
G4double KineticEnergy,StepLimit;
|
||||
const G4double BigStep = DBL_MAX ;
|
||||
G4bool isOutRange ;
|
||||
G4int index,bin ;
|
||||
|
||||
if(aParticle->GetDefinition()->GetPDGCharge()>0.)
|
||||
{
|
||||
theDEDXTable = theDEDXmuplusTable ;
|
||||
theRangeTable = theRangemuplusTable ;
|
||||
theRangeCoeffATable=themuplusRangeCoeffATable ;
|
||||
theRangeCoeffBTable=themuplusRangeCoeffBTable ;
|
||||
theRangeCoeffCTable=themuplusRangeCoeffCTable ;
|
||||
}
|
||||
else
|
||||
{
|
||||
theDEDXTable = theDEDXmuminusTable ;
|
||||
theRangeTable = theRangemuminusTable ;
|
||||
theRangeCoeffATable=themuminusRangeCoeffATable ;
|
||||
theRangeCoeffBTable=themuminusRangeCoeffBTable ;
|
||||
theRangeCoeffCTable=themuminusRangeCoeffCTable ;
|
||||
}
|
||||
|
||||
|
||||
// min.stepsize = p*CutInRange at energy , where range=p*CutInRange
|
||||
// random steplimit.........................
|
||||
const G4double p=1. , cc=p*CutInRange ;
|
||||
const G4double c1=dToverTini , c2=(1.-2.*dToverTini)*cc ,
|
||||
c3=dToverTini*cc*cc ;
|
||||
const G4double rangelim=1.5*cc ;
|
||||
const G4double Thigh = 0.9*HighestKineticEnergy ;
|
||||
const G4double alfa = 0.05 , alfa1 = 1.-alfa , alfa2 = 2.*alfa ;
|
||||
KineticEnergy = aParticle->GetKineticEnergy();
|
||||
bin = G4int(log(KineticEnergy/LowestKineticEnergy)/LOGRTable) ;
|
||||
EnergyBinNumber = bin ;
|
||||
index = aMaterial->GetIndex() ;
|
||||
|
||||
if( KineticEnergy < LowestKineticEnergy )
|
||||
{
|
||||
fdEdx = sqrt(KineticEnergy/LowestKineticEnergy)*
|
||||
(*theDEDXTable)(index)->GetValue(LowestKineticEnergy,isOutRange) ;
|
||||
fRangeNow = sqrt(KineticEnergy/LowestKineticEnergy)*
|
||||
(*theRangeTable)(index)->GetValue(LowestKineticEnergy,isOutRange) ;
|
||||
StepLimit = fRangeNow ;
|
||||
}
|
||||
else
|
||||
{
|
||||
if ( KineticEnergy > HighestKineticEnergy )
|
||||
StepLimit = BigStep ;
|
||||
else
|
||||
{
|
||||
|
||||
fdEdx = (*theDEDXTable)(index)->
|
||||
GetValue(KineticEnergy,isOutRange) ;
|
||||
|
||||
|
||||
RangeCoeffA = (*(*theRangeCoeffATable)(index))(EnergyBinNumber) ;
|
||||
RangeCoeffB = (*(*theRangeCoeffBTable)(index))(EnergyBinNumber) ;
|
||||
RangeCoeffC = (*(*theRangeCoeffCTable)(index))(EnergyBinNumber) ;
|
||||
|
||||
fRangeNow = (RangeCoeffA*KineticEnergy+RangeCoeffB)
|
||||
*KineticEnergy+RangeCoeffC ;
|
||||
|
||||
// vacuum ?
|
||||
if(fRangeNow>=BigStep)
|
||||
StepLimit = BigStep ;
|
||||
else
|
||||
{
|
||||
// new method to compute the (random) Step limit ..............
|
||||
if(fRangeNow>cc)
|
||||
{
|
||||
StepLimit = c1*fRangeNow+c2+c3/fRangeNow ;
|
||||
|
||||
// randomise this value
|
||||
StepLimit = cc + (StepLimit-cc)*G4UniformRand() ;
|
||||
if(StepLimit > fRangeNow) StepLimit = fRangeNow ;
|
||||
}
|
||||
else
|
||||
StepLimit = fRangeNow ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return StepLimit ;
|
||||
|
||||
}
|
||||
|
||||
|
||||
inline G4double G4VIMuEnergyLoss::GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double,
|
||||
G4double currentMinimumStep,
|
||||
G4double&)
|
||||
{
|
||||
|
||||
G4double Step =
|
||||
GetConstraints(track.GetDynamicParticle(),track.GetMaterial()) ;
|
||||
|
||||
if((Step>0.0)&&(Step<currentMinimumStep))
|
||||
currentMinimumStep = Step ;
|
||||
|
||||
return Step ;
|
||||
}
|
||||
|
||||
inline G4bool G4VIMuEnergyLoss::IsApplicable(const G4ParticleDefinition&
|
||||
particle)
|
||||
{
|
||||
return ( (&particle == (const G4ParticleDefinition *)theMuonPlus)
|
||||
||(&particle == (const G4ParticleDefinition *)theMuonMinus)
|
||||
);
|
||||
}
|
||||
@@ -0,0 +1,243 @@
|
||||
// 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: G4VIeEnergyLoss.hh,v 1.1 2001/03/05 10:55:22 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ---------- G4VIeEnergyLoss physics process -----------
|
||||
// by Laszlo Urban, 20 March 1997
|
||||
// ************************************************************
|
||||
// It is the first implementation of the new unified Energy Loss process.
|
||||
// It calculates the continuous energy loss for e+/e-.
|
||||
// Processes giving contribution to the continuous loss :
|
||||
// ionisation (= cont.ion.loss + delta ray production)
|
||||
// bremsstrahlung (= cont.loss due to sooft brems+discrete bremsstrahlung)
|
||||
// can be added more easily ..........
|
||||
// This class creates static dE/dx and range tables for e+ and e-,
|
||||
// which tables can be used by other processes.
|
||||
// ------------------------------------------------------------
|
||||
//
|
||||
// 27.05.98 OldGetRange removed + other corrs , L.Urban
|
||||
// 26.10.98 revision , L.Urban
|
||||
// ------------------------------------------------------------
|
||||
|
||||
#ifndef G4VIeEnergyLoss_h
|
||||
#define G4VIeEnergyLoss_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4IVContinuousDiscreteProcess.hh"
|
||||
#include "G4Material.hh"
|
||||
#include "G4Element.hh"
|
||||
#include "G4VParticleChange.hh"
|
||||
#include "globals.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4Positron.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
class G4EnergyLossMessenger;
|
||||
|
||||
|
||||
class G4VIeEnergyLoss : public G4IVContinuousDiscreteProcess
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4VIeEnergyLoss(const G4String& );
|
||||
|
||||
virtual ~G4VIeEnergyLoss();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
|
||||
public:
|
||||
|
||||
void BuildDEDXTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
G4double GetContinuousStepLimit(const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4double currentMinimumStep,
|
||||
G4double& currentSafety);
|
||||
|
||||
G4VParticleChange* AlongStepDoIt(const G4Track& track,
|
||||
const G4Step& Step) ;
|
||||
|
||||
virtual G4VParticleChange* PostStepDoIt(const G4Track& track,
|
||||
const G4Step& Step) = 0;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
void BuildRangeTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildInverseRangeTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildTimeTables(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
void BuildRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
void BuildLabTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
void BuildProperTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
void InvertRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
G4double RangeIntLin(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
|
||||
G4double RangeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
G4double LabTimeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
G4double ProperTimeIntLog(G4PhysicsVector* physicsVector,G4int nbin);
|
||||
|
||||
void BuildRangeCoeffATable(const G4ParticleDefinition& aParticleType);
|
||||
void BuildRangeCoeffBTable(const G4ParticleDefinition& aParticleType);
|
||||
void BuildRangeCoeffCTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
G4double GetConstraints(const G4DynamicParticle* aParticle,
|
||||
G4Material* aMaterial);
|
||||
|
||||
G4double GetLossWithFluct(const G4DynamicParticle* aParticle,
|
||||
G4Material* aMaterial,
|
||||
G4double ChargeSquare,
|
||||
G4double MeanLoss,
|
||||
G4double step) ;
|
||||
|
||||
// hide assignment operator
|
||||
G4VIeEnergyLoss (G4VIeEnergyLoss &);
|
||||
G4VIeEnergyLoss & operator=(const G4VIeEnergyLoss &right);
|
||||
|
||||
protected:
|
||||
|
||||
G4PhysicsTable* theLossTable;
|
||||
|
||||
G4double ParticleMass; // heavily used
|
||||
|
||||
private:
|
||||
|
||||
G4PhysicsTable* theDEDXTable;
|
||||
|
||||
G4PhysicsTable* theRangeTable;
|
||||
G4PhysicsTable* theInverseRangeTable;
|
||||
|
||||
G4PhysicsTable* theLabTimeTable ;
|
||||
G4PhysicsTable* theProperTimeTable ;
|
||||
|
||||
G4int CounterOfProcess;
|
||||
G4PhysicsTable** RecorderOfProcess;
|
||||
|
||||
G4double fdEdx; // computed in GetConstraints
|
||||
G4double fRangeNow; // computed in GetConstraints
|
||||
|
||||
G4int EnergyBinNumber; // computed in GetConstraints
|
||||
// (needed to compute range)
|
||||
G4int TotBin; // number of bins in table,
|
||||
// calculated in BuildPhysicTable
|
||||
G4double LowestKineticEnergy;
|
||||
G4double HighestKineticEnergy;
|
||||
G4double RTable,LOGRTable; // LOGRTable=log(HighestKineticEnergy-
|
||||
// LowestKineticEnergy)/TotBin
|
||||
// RTable = exp(LOGRTable)
|
||||
|
||||
G4PhysicsTable* theRangeCoeffATable;
|
||||
G4PhysicsTable* theRangeCoeffBTable;
|
||||
G4PhysicsTable* theRangeCoeffCTable;
|
||||
|
||||
// variables for the integration routines
|
||||
G4double taulow,tauhigh,ltaulow,ltauhigh;
|
||||
|
||||
// data members to speed up the fluctuation calculation
|
||||
G4Material* lastMaterial;
|
||||
G4int imat;
|
||||
G4double f1Fluct,f2Fluct,e1Fluct,e2Fluct,rateFluct,ipotFluct;
|
||||
G4double e1LogFluct,e2LogFluct,ipotLogFluct;
|
||||
const G4double MaxExcitationNumber ;
|
||||
const G4double probLimFluct ;
|
||||
const long nmaxDirectFluct,nmaxCont1,nmaxCont2 ;
|
||||
|
||||
//
|
||||
// static part of the class
|
||||
//
|
||||
|
||||
protected:
|
||||
|
||||
//basic DEDX and Range tables
|
||||
static G4PhysicsTable* theDEDXElectronTable ;
|
||||
static G4PhysicsTable* theDEDXPositronTable ;
|
||||
static G4PhysicsTable* theRangeElectronTable ;
|
||||
static G4PhysicsTable* theRangePositronTable ;
|
||||
|
||||
//inverse tables of the range tables
|
||||
static G4PhysicsTable* theInverseRangeElectronTable;
|
||||
static G4PhysicsTable* theInverseRangePositronTable;
|
||||
|
||||
// lab and proper time tables
|
||||
static G4PhysicsTable* theLabTimeElectronTable ;
|
||||
static G4PhysicsTable* theLabTimePositronTable ;
|
||||
static G4PhysicsTable* theProperTimeElectronTable ;
|
||||
static G4PhysicsTable* theProperTimePositronTable ;
|
||||
|
||||
//processes inherited from G4VIeEnergyLoss
|
||||
//register themselves in the static array Recorder
|
||||
//for electrons/positrons separately
|
||||
//nb of contributing processes = NbOfProcesses
|
||||
static G4int NbOfProcesses;
|
||||
static G4int CounterOfElectronProcess;
|
||||
static G4int CounterOfPositronProcess ;
|
||||
static G4PhysicsTable** RecorderOfElectronProcess;
|
||||
static G4PhysicsTable** RecorderOfPositronProcess;
|
||||
|
||||
private:
|
||||
|
||||
//for interpolation within the tables
|
||||
static G4PhysicsTable* theeRangeCoeffATable;
|
||||
static G4PhysicsTable* theeRangeCoeffBTable;
|
||||
static G4PhysicsTable* theeRangeCoeffCTable;
|
||||
static G4PhysicsTable* thepRangeCoeffATable;
|
||||
static G4PhysicsTable* thepRangeCoeffBTable;
|
||||
static G4PhysicsTable* thepRangeCoeffCTable;
|
||||
|
||||
static G4double dRoverRange; // dRoverRange is the maximum allowed
|
||||
// deltarange/range in one Step
|
||||
static G4double finalRange; // final step before stopping
|
||||
|
||||
static G4bool rndmStepFlag; // control the randomization of the step
|
||||
static G4bool EnlossFlucFlag; // control the energy loss fluctuation
|
||||
|
||||
static G4EnergyLossMessenger* eLossMessenger;
|
||||
|
||||
public:
|
||||
|
||||
static void SetNbOfProcesses(G4int nb) {NbOfProcesses=nb;};
|
||||
static void PlusNbOfProcesses() {NbOfProcesses++ ;};
|
||||
static void MinusNbOfProcesses() {NbOfProcesses-- ;};
|
||||
static G4int GetNbOfProcesses() {return NbOfProcesses;};
|
||||
|
||||
static void SetRndmStep (G4bool value) {rndmStepFlag = value;}
|
||||
static void SetEnlossFluc (G4bool value) {EnlossFlucFlag = value;}
|
||||
static void SetStepFunction (G4double c1, G4double c2)
|
||||
{dRoverRange = c1; finalRange = c2;}
|
||||
};
|
||||
|
||||
#include "G4VIeEnergyLoss.icc"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,55 @@
|
||||
// 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: G4VIeEnergyLoss.icc,v 1.1 2001/03/05 10:55:22 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4VIeEnergyLoss physics process ------------
|
||||
// by Laszlo Urban, 20 March 1997
|
||||
// ***************************************************************
|
||||
// It is the first implementation of the NEW UNIFIED ENERGY LOSS PROCESS.
|
||||
// It calculates the energy loss of e+/e-.
|
||||
// -------------------------------------------------------------
|
||||
//
|
||||
// 27-05-98: new randomization of the Step limit , new extrapolations for
|
||||
// high/low energies. L.Urban
|
||||
// 26-10-98: cleanup , L.Urban
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
inline G4bool G4VIeEnergyLoss::IsApplicable(const G4ParticleDefinition&
|
||||
particle)
|
||||
{
|
||||
return( (&particle == G4Electron::Electron())
|
||||
||(&particle == G4Positron::Positron()) );
|
||||
}
|
||||
|
||||
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
|
||||
|
||||
inline G4double G4VIeEnergyLoss::GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double,
|
||||
G4double currentMinimumStep,
|
||||
G4double&)
|
||||
{
|
||||
|
||||
G4double Step =
|
||||
GetConstraints(track.GetDynamicParticle(),track.GetMaterial());
|
||||
|
||||
if ((Step>0.0)&&(Step<currentMinimumStep)) currentMinimumStep = Step;
|
||||
|
||||
return Step ;
|
||||
}
|
||||
|
||||
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
|
||||
@@ -0,0 +1,295 @@
|
||||
// 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: G4VIhEnergyLoss.hh,v 1.1 2001/03/05 10:55:22 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ------------------------------------------------------------
|
||||
// GEANT 4 class header file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: first implementation, based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ---------- G4VIhEnergyLoss physics process -----------
|
||||
// by Laszlo Urban, 30 May 1997
|
||||
//
|
||||
// ************************************************************
|
||||
// It is the first implementation of the NEW UNIFIED ENERGY LOSS PROCESS.
|
||||
// It calculates the continuous energy loss for charged hadrons.
|
||||
// Processes giving contribution to the continuous loss :
|
||||
// ionisation (= cont.ion.loss + delta ray production)
|
||||
// can be added more easily ..........
|
||||
// This class creates static proton/antiproton dE/dx and range tables ,
|
||||
// which tables can be used by other processes.
|
||||
// The energy loss for other charged hadrons is calculated from the p/pbar
|
||||
// tables with scaled kinetic energy.
|
||||
//
|
||||
// ****************************************************************************
|
||||
// It is assumed that the cut in range is the same for all the charged hadrons!
|
||||
// ****************************************************************************
|
||||
//
|
||||
// 7/10/98 some bugs fixed + some cleanup , L.Urban
|
||||
// 26/10/98 cleanup , L.Urban
|
||||
//
|
||||
|
||||
#ifndef G4VIhEnergyLoss_h
|
||||
#define G4VIhEnergyLoss_h 1
|
||||
|
||||
#include "G4ios.hh"
|
||||
#include "globals.hh"
|
||||
#include "Randomize.hh"
|
||||
#include "G4IVContinuousDiscreteProcess.hh"
|
||||
#include "G4Material.hh"
|
||||
#include "G4Element.hh"
|
||||
#include "G4Proton.hh"
|
||||
#include "G4AntiProton.hh"
|
||||
#include "G4Electron.hh"
|
||||
#include "G4VParticleChange.hh"
|
||||
#include "G4Track.hh"
|
||||
#include "G4Step.hh"
|
||||
#include "G4PhysicsLogVector.hh"
|
||||
#include "G4PhysicsLinearVector.hh"
|
||||
|
||||
class G4EnergyLossMessenger;
|
||||
|
||||
class G4VIhEnergyLoss : public G4IVContinuousDiscreteProcess
|
||||
|
||||
{
|
||||
public:
|
||||
|
||||
G4VIhEnergyLoss(const G4String& );
|
||||
|
||||
virtual ~G4VIhEnergyLoss();
|
||||
|
||||
G4bool IsApplicable(const G4ParticleDefinition&);
|
||||
|
||||
G4double GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double previousStepSize,
|
||||
G4double currentMinimumStep,
|
||||
G4double& currentSafety) ;
|
||||
|
||||
G4VParticleChange* AlongStepDoIt(const G4Track& track ,const G4Step& Step) ;
|
||||
|
||||
virtual G4VParticleChange* PostStepDoIt(const G4Track& track,
|
||||
const G4Step& Step) = 0 ;
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
|
||||
private:
|
||||
|
||||
// hide assignment operator
|
||||
|
||||
G4VIhEnergyLoss(G4VIhEnergyLoss &);
|
||||
G4VIhEnergyLoss & operator=(const G4VIhEnergyLoss &right);
|
||||
|
||||
G4double GetConstraints(const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial);
|
||||
|
||||
G4double GetLossWithFluct(const G4DynamicParticle *aParticle,
|
||||
G4Material *aMaterial,
|
||||
G4double ChargeSquare,
|
||||
G4double MeanLoss,
|
||||
G4double Step) ;
|
||||
|
||||
// =====================================================================
|
||||
|
||||
public:
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
G4PhysicsTable* theLossTable ;
|
||||
|
||||
|
||||
private:
|
||||
|
||||
G4double fdEdx; // computed in GetContraints
|
||||
|
||||
G4double fRangeNow ; // computed in GetContraints
|
||||
|
||||
G4int EnergyBinNumber ;
|
||||
G4double RangeCoeffA,RangeCoeffB,RangeCoeffC ;
|
||||
|
||||
// variables for the integration routines
|
||||
static G4double Mass,taulow,tauhigh,ltaulow,ltauhigh;
|
||||
|
||||
// data members to speed up the fluctuation calculation
|
||||
G4Material *lastMaterial ;
|
||||
G4int imat ;
|
||||
G4double f1Fluct,f2Fluct,e1Fluct,e2Fluct,rateFluct,ipotFluct;
|
||||
G4double e1LogFluct,e2LogFluct,ipotLogFluct;
|
||||
const G4double MaxExcitationNumber ;
|
||||
const G4double probLimFluct ;
|
||||
const long nmaxDirectFluct,nmaxCont1,nmaxCont2 ;
|
||||
|
||||
// ====================================================================
|
||||
// static part of the class
|
||||
|
||||
public:
|
||||
|
||||
// get the number of processes contributing to the cont.energy loss
|
||||
static G4int GetNumberOfProcesses() { return NumberOfProcesses; };
|
||||
|
||||
// set the number of processes contributing to the cont.energy loss
|
||||
static void SetNumberOfProcesses(G4int number)
|
||||
{NumberOfProcesses=number ; };
|
||||
|
||||
// Increment the number of processes contributing to the cont.energy loss
|
||||
static void PlusNumberOfProcesses()
|
||||
{ NumberOfProcesses++ ; };
|
||||
|
||||
// decrement the number of processes contributing to the cont.energy loss
|
||||
static void MinusNumberOfProcesses()
|
||||
{ NumberOfProcesses-- ; };
|
||||
|
||||
static void SetdRoverRange(G4double value) {dRoverRange = value;}
|
||||
static void SetRndmStep (G4bool value) {rndmStepFlag = value;}
|
||||
static void SetEnlossFluc (G4bool value) {EnlossFlucFlag = value;}
|
||||
static void SetStepFunction (G4double c1, G4double c2)
|
||||
{dRoverRange = c1; finalRange = c2;}
|
||||
|
||||
protected:
|
||||
|
||||
static void BuildDEDXTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
private:
|
||||
|
||||
static void BuildRangeTable(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
static void BuildInverseRangeTable(
|
||||
const G4ParticleDefinition& aParticleType);
|
||||
|
||||
static void BuildTimeTables(const G4ParticleDefinition& aParticleType);
|
||||
|
||||
static void BuildLabTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
static void BuildProperTimeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
static void InvertRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
static void BuildRangeVector(G4int materialIndex,
|
||||
G4PhysicsLogVector* rangeVector);
|
||||
|
||||
static G4double LabTimeIntLog(G4PhysicsVector* physicsVector
|
||||
,G4int nbin);
|
||||
|
||||
static G4double ProperTimeIntLog(G4PhysicsVector* physicsVector,
|
||||
G4int nbin);
|
||||
|
||||
static G4double RangeIntLin(G4PhysicsVector* physicsVector
|
||||
,G4int nbin);
|
||||
|
||||
static G4double RangeIntLog(G4PhysicsVector* physicsVector
|
||||
,G4int nbin);
|
||||
|
||||
static void BuildRangeCoeffATable(
|
||||
const G4ParticleDefinition& aParticleType);
|
||||
static void BuildRangeCoeffBTable(
|
||||
const G4ParticleDefinition& aParticleType);
|
||||
static void BuildRangeCoeffCTable(
|
||||
const G4ParticleDefinition& aParticleType);
|
||||
|
||||
|
||||
|
||||
// ====================================================================
|
||||
|
||||
|
||||
public:
|
||||
|
||||
|
||||
protected:
|
||||
|
||||
static G4PhysicsTable* theDEDXpTable ;
|
||||
static G4PhysicsTable* theDEDXpbarTable ;
|
||||
static G4PhysicsTable* theRangepTable ;
|
||||
static G4PhysicsTable* theRangepbarTable ;
|
||||
|
||||
//inverse of the range tables
|
||||
static G4PhysicsTable* theInverseRangepTable ;
|
||||
static G4PhysicsTable* theInverseRangepbarTable ;
|
||||
|
||||
//lab and proper time tables
|
||||
static G4PhysicsTable* theLabTimepTable ;
|
||||
static G4PhysicsTable* theLabTimepbarTable ;
|
||||
|
||||
static G4PhysicsTable* theProperTimepTable ;
|
||||
static G4PhysicsTable* theProperTimepbarTable ;
|
||||
|
||||
// processes inherited from G4VIhEnergyLoss
|
||||
// register themselves in the static array Recorder
|
||||
static G4PhysicsTable** RecorderOfpProcess;
|
||||
static G4PhysicsTable** RecorderOfpbarProcess;
|
||||
static G4int CounterOfpProcess ;
|
||||
static G4int CounterOfpbarProcess ;
|
||||
|
||||
// particle mass
|
||||
static G4double ParticleMass ;
|
||||
|
||||
static const G4Proton* theProton ;
|
||||
static const G4AntiProton* theAntiProton ;
|
||||
|
||||
// cut in range
|
||||
static G4double CutInRange;
|
||||
|
||||
static G4double LowestKineticEnergy;
|
||||
static G4double HighestKineticEnergy;
|
||||
static G4int TotBin; // number of bins in table,
|
||||
// calculated in BuildPhysicsTable
|
||||
static G4double RTable,LOGRTable; // LOGRTable=log(HighestKineticEnergy
|
||||
// /LowestKineticEnergy)/TotBin
|
||||
// RTable = exp(LOGRTable)
|
||||
|
||||
private:
|
||||
|
||||
static G4PhysicsTable* theDEDXTable;
|
||||
|
||||
static G4PhysicsTable* theRangeTable;
|
||||
static G4PhysicsTable* theInverseRangeTable;
|
||||
|
||||
static G4PhysicsTable* theLabTimeTable;
|
||||
static G4PhysicsTable* theProperTimeTable;
|
||||
|
||||
static G4PhysicsTable** RecorderOfProcess;
|
||||
static G4int CounterOfProcess;
|
||||
|
||||
|
||||
static G4PhysicsTable* thepRangeCoeffATable;
|
||||
static G4PhysicsTable* thepRangeCoeffBTable;
|
||||
static G4PhysicsTable* thepRangeCoeffCTable;
|
||||
static G4PhysicsTable* thepbarRangeCoeffATable;
|
||||
static G4PhysicsTable* thepbarRangeCoeffBTable;
|
||||
static G4PhysicsTable* thepbarRangeCoeffCTable;
|
||||
|
||||
static G4PhysicsTable* theRangeCoeffATable;
|
||||
static G4PhysicsTable* theRangeCoeffBTable;
|
||||
static G4PhysicsTable* theRangeCoeffCTable;
|
||||
|
||||
static G4double dRoverRange ; // maximum allowed deltarange/range
|
||||
// in one step
|
||||
|
||||
static G4double finalRange ; // last step before stop
|
||||
|
||||
static G4bool rndmStepFlag ;
|
||||
static G4bool EnlossFlucFlag ;
|
||||
|
||||
static G4int NumberOfProcesses ;
|
||||
|
||||
|
||||
};
|
||||
|
||||
#include "G4VIhEnergyLoss.icc"
|
||||
|
||||
#endif
|
||||
|
||||
@@ -0,0 +1,49 @@
|
||||
// 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: G4VIhEnergyLoss.icc,v 1.1 2001/03/05 10:55:22 maire Exp $
|
||||
// GEANT4 tag $Name: geant4-03-01 $
|
||||
//
|
||||
// $Id:
|
||||
// ---------------------------------------------------------------
|
||||
// GEANT 4 class inlined methods file
|
||||
//
|
||||
// For information related to this code contact:
|
||||
// CERN, IT Division, ASD group
|
||||
// History: based on object model of
|
||||
// 2nd December 1995, G.Cosmo
|
||||
// ------------ G4VIhEnergyLoss physics process ------------
|
||||
// by Laszlo Urban, 30 May 1997
|
||||
// ***************************************************************
|
||||
// It is the first implementation of the NEW UNIFIED ENERGY LOSS PROCESS.
|
||||
// It calculates the energy loss of charged hadrons.
|
||||
// ***************************************************************
|
||||
// 26/10/98: cleanup , L.Urban
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
inline G4bool G4VIhEnergyLoss::IsApplicable(const G4ParticleDefinition&
|
||||
particle)
|
||||
{
|
||||
return(particle.GetPDGCharge()!= 0.);
|
||||
}
|
||||
|
||||
inline G4double G4VIhEnergyLoss::GetContinuousStepLimit(
|
||||
const G4Track& track,
|
||||
G4double,
|
||||
G4double currentMinimumStep,
|
||||
G4double&)
|
||||
{
|
||||
|
||||
G4double Step =
|
||||
GetConstraints(track.GetDynamicParticle(),track.GetMaterial()) ;
|
||||
|
||||
if((Step>0.0)&&(Step<currentMinimumStep))
|
||||
currentMinimumStep = Step ;
|
||||
|
||||
return Step ;
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user