lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 3.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:03:00 +02:00
parent cfcb558cfe
commit 137e303ecc
2843 changed files with 37082 additions and 38426 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/muons/include/G4IMuBremsstrahlung.hh
-159
View File
@@ -1,159 +0,0 @@
// 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.3 2000/04/25 14:18:57 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// ------------------------------------------------------------
// 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
source/processes/electromagnetic/muons/include/G4IMuBremsstrahlung.icc
-171
View File
@@ -1,171 +0,0 @@
// 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.2 1999/12/15 14:51:41 gunter Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// ---------------------------------------------------------------
// 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)
) ;
}
source/processes/electromagnetic/muons/include/G4IMuIonisation.hh
-148
View File
@@ -1,148 +0,0 @@
// 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.3 2000/04/25 14:18:58 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// ------------------------------------------------------------
// 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
source/processes/electromagnetic/muons/include/G4IMuIonisation.icc
-151
View File
@@ -1,151 +0,0 @@
// 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.2 1999/12/15 14:51:42 gunter Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
//
// ---------------------------------------------------------------
// 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)
);
}
source/processes/electromagnetic/muons/include/G4IMuPairProduction.hh
-188
View File
@@ -1,188 +0,0 @@
// 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.3 2000/04/25 14:18:58 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $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
source/processes/electromagnetic/muons/include/G4IMuPairProduction.icc
-180
View File
@@ -1,180 +0,0 @@
// 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.2 1999/12/15 14:51:42 gunter Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $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)
) ;
}
source/processes/electromagnetic/muons/include/G4MuBremsstrahlung.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuBremsstrahlung.hh,v 1.8 2000/05/23 09:55:37 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// ------------------------------------------------------------
// GEANT 4 class header file
source/processes/electromagnetic/muons/include/G4MuBremsstrahlung.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuBremsstrahlung.icc,v 1.3 1999/12/15 14:51:42 gunter Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
source/processes/electromagnetic/muons/include/G4MuIonisation.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuIonisation.hh,v 1.8 2000/04/25 14:18:58 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
// ------------------------------------------------------------
// GEANT 4 class header file
source/processes/electromagnetic/muons/include/G4MuIonisation.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuIonisation.icc,v 1.2 1999/12/15 14:51:43 gunter Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
//
// ---------------------------------------------------------------
source/processes/electromagnetic/muons/include/G4MuPairProduction.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuPairProduction.hh,v 1.8 2000/05/23 16:03:25 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// ------------------------------------------------------------
// GEANT 4 class header file
source/processes/electromagnetic/muons/include/G4MuPairProduction.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MuPairProduction.icc,v 1.3 2000/02/10 08:29:13 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
source/processes/electromagnetic/muons/include/G4VIMuEnergyLoss.hh
-280
View File
@@ -1,280 +0,0 @@
// 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.3 2000/08/15 09:40:16 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $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
source/processes/electromagnetic/muons/include/G4VIMuEnergyLoss.icc
-146
View File
@@ -1,146 +0,0 @@
// 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 2000/04/25 14:18:59 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $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)
);
}
source/processes/electromagnetic/muons/include/G4VMuEnergyLoss.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4VMuEnergyLoss.hh,v 1.2 2000/06/07 16:50:21 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
// -------------------------------------------------------------------
// GEANT 4 class header file
//
source/processes/electromagnetic/muons/include/G4VMuEnergyLoss.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4VMuEnergyLoss.icc,v 1.1 2000/04/25 14:18:59 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
// ---------------------------------------------------------------
// GEANT 4 class inlined methods file
//