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/History
+21 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.5 2000/11/08 14:29:11 maire Exp $
$Id: History,v 1.11 2001/03/23 15:09:37 maire Exp $
-------------------------------------------------------------------
=========================================================
@@ -16,6 +16,26 @@ committal in the CVS repository !
----------------------------------------------------------
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
23 mar 01 L.Urban (muons-V03-00-05)
- R.Kokoulin's correction to energy loss has been commented out
in G4MuIonisation.cc
05 mar 01 mma (muons-V03-00-04)
- new subdirectory: integral
migration of all G4I.. processes from muons, standard, utils into integral
05 feb 01: G. Cosmo (muons-V03-00-02)
- STL migration for G4OrderedTable and G4DataVector.
Modified files: G4IMuBremsstrahlung.cc, G4IMuPairProduction.cc,
G4MuBremsstrahlung.cc, G4MuPairProduction.cc
24 jan 01: L. Urban (muons-V03-00-01)
- bug fixed in muon bremstrahlung , in G4MuBremstrahlung.cc
in PostStepDoIt.
16 jan 01: mma (muons-V03-00-00)
- small corrections in MuEnergyLoss.cc L.Urban 11-01-01
08 nov 00: mma (muons-V02-00-03)
- signature in GetLossWithFluct changed L.Urban 30/10/00
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
//
source/processes/electromagnetic/muons/src/G4IMuBremsstrahlung.cc
-1190
View File
File diff suppressed because it is too large Load Diff
source/processes/electromagnetic/muons/src/G4IMuIonisation.cc
-1062
View File
File diff suppressed because it is too large Load Diff
source/processes/electromagnetic/muons/src/G4IMuPairProduction.cc
-1416
View File
File diff suppressed because it is too large Load Diff
source/processes/electromagnetic/muons/src/G4MuBremsstrahlung.cc
+31 -19
View File
@@ -5,8 +5,8 @@
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4MuBremsstrahlung.cc,v 1.12 2000/05/23 09:58:48 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// $Id: G4MuBremsstrahlung.cc,v 1.14 2001/02/05 17:50:29 gcosmo Exp $
// GEANT4 tag $Name: geant4-03-01 $
//
//
// --------------------------------------------------------------
@@ -35,7 +35,7 @@ G4double G4MuBremsstrahlung::tdat[]={1.e3,1.e4,1.e5,1.e6,1.e7,1.e8,1.e9,1.e10};
G4int G4MuBremsstrahlung::NBIN = 1000; // 100 ;
G4double G4MuBremsstrahlung::ya[1001]={0.};
G4double G4MuBremsstrahlung::proba[5][8][1001]={0.};
G4double G4MuBremsstrahlung::CutFixed=1.*keV ;
G4double G4MuBremsstrahlung::CutFixed=0.98*keV ;
G4double G4MuBremsstrahlung::LowerBoundLambda = 1.*keV ;
@@ -210,6 +210,7 @@ void G4MuBremsstrahlung::BuildLambdaTable(
delete theMeanFreePathTable;
}
theMeanFreePathTable = new G4PhysicsTable(G4Material::GetNumberOfMaterials());
PartialSumSigma.clearAndDestroy();
PartialSumSigma.resize(G4Material::GetNumberOfMaterials());
G4PhysicsLogVector* ptrVector;
@@ -249,7 +250,7 @@ void G4MuBremsstrahlung::ComputePartialSumSigma(
aMaterial->GetAtomicNumDensityVector();
G4double GammaEnergyCut = (G4Gamma::Gamma()->GetCutsInEnergy())[Imate];
PartialSumSigma(Imate) = new G4ValVector(NbOfElements);
PartialSumSigma[Imate] = new G4DataVector();
G4double SIGMA = 0. ;
@@ -260,7 +261,7 @@ void G4MuBremsstrahlung::ComputePartialSumSigma(
(*theElementVector)(Ielem)->GetZ(),
(*theElementVector)(Ielem)->GetA(),
GammaEnergyCut );
PartialSumSigma(Imate)->insertAt(Ielem, SIGMA);
PartialSumSigma[Imate]->push_back(SIGMA);
}
}
@@ -448,7 +449,6 @@ void G4MuBremsstrahlung::MakeSamplingTables(
for(G4int ib=0; ib<=nbin; ib++)
{
proba[iz][it][ib] /= CrossSection ;
}
}
}
@@ -461,6 +461,9 @@ G4VParticleChange* G4MuBremsstrahlung::PostStepDoIt(const G4Track& trackData,
const G4Step& stepData)
{
static G4double ysmall = -100. ;
static G4double ytablelow = -5. ;
aParticleChange.Initialize(trackData);
G4Material* aMaterial=trackData.GetMaterial() ;
@@ -487,7 +490,9 @@ G4VParticleChange* G4MuBremsstrahlung::PostStepDoIt(const G4Track& trackData,
G4double dy = 5./G4float(NBIN) ;
G4double ymin=log(log(GammaEnergyCut/CutFixed)/log(KineticEnergy/CutFixed)) ;
G4int iymin = G4int((ymin+5.)/dy+0.5) ;
if(ymin < ysmall)
return G4VContinuousDiscreteProcess::PostStepDoIt(trackData,stepData);
// sampling using tables
G4double v,xc,x,yc,y ;
@@ -518,23 +523,30 @@ G4VParticleChange* G4MuBremsstrahlung::PostStepDoIt(const G4Track& trackData,
itt=it ;
}
}
G4int iymin = G4int((ymin+5.)/dy+0.5) ;
G4double r = G4UniformRand() ;
if(ymin < ytablelow)
{
y = ymin + G4UniformRand()*(ytablelow-ymin) ;
}
else
{
G4double r = G4UniformRand() ;
iy = iymin-1 ;
delmin = proba[izz][itt][NBINminus1]-proba[izz][itt][iymin] ;
do {
iy += 1 ;
} while ((r > (proba[izz][itt][iy]-proba[izz][itt][iymin])/delmin)
&&(iy < NBINminus1)) ;
iy = iymin-1 ;
delmin = proba[izz][itt][NBINminus1]-proba[izz][itt][iymin] ;
do {
iy += 1 ;
} while ((r > (proba[izz][itt][iy]-proba[izz][itt][iymin])/delmin)
&&(iy < NBINminus1)) ;
//sampling is Done uniformly in y in the bin
y = ya[iy] + G4UniformRand() * ( ya[iy+1] - ya[iy] ) ;
//sampling is Done uniformly in y in the bin
y = ya[iy] + G4UniformRand() * ( ya[iy+1] - ya[iy] ) ;
}
x = exp(y) ;
v = CutFixed*exp(x*log(KineticEnergy/CutFixed)) ;
if( v <= 0.)
return G4VContinuousDiscreteProcess::PostStepDoIt(trackData,stepData);
@@ -584,9 +596,9 @@ G4Element* G4MuBremsstrahlung::SelectRandomAtom(G4Material* aMaterial) const
const G4int NumberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
G4double rval = G4UniformRand()*((*PartialSumSigma(Index))(NumberOfElements-1));
G4double rval = G4UniformRand()*((*PartialSumSigma[Index])[NumberOfElements-1]);
for ( G4int i=0; i < NumberOfElements; i++ )
if (rval <= (*PartialSumSigma(Index))(i)) return ((*theElementVector)(i));
if (rval <= (*PartialSumSigma[Index])[i]) return ((*theElementVector)(i));
G4cout << " WARNING !!! - The Material " << aMaterial->GetName()
<< " has no elements, NULL pointer returned." << G4endl;
return NULL;
source/processes/electromagnetic/muons/src/G4MuIonisation.cc
+9 -8
View File
@@ -5,8 +5,8 @@
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4MuIonisation.cc,v 1.11 2000/05/23 09:58:47 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// $Id: G4MuIonisation.cc,v 1.12 2001/03/23 07:27:29 urban Exp $
// GEANT4 tag $Name: geant4-03-01 $
//
//
// --------------------------------------------------------------
@@ -25,6 +25,7 @@
// 08-04-98: remove 'tracking cut' of the ionizing particle, MMa
// 26/10/98: new stuff from R.Kokoulin + cleanup , L.Urban
// 10/02/00 modifications , new e.m. structure, L.Urban
// 23/03/01: R.Kokoulin's correction is commented out, L.Urban
// --------------------------------------------------------------
@@ -228,12 +229,12 @@ void G4MuIonisation::BuildLossTable(const G4ParticleDefinition& aParticleType)
ionloss -= delta + sh ;
ionloss /= beta2 ;
// correction of R. Kokoulin
G4double E = LowEdgeEnergy+ParticleMass ;
G4double epmax = RateMass*E*E/(RateMass*E+ParticleMass) ;
G4double apar = log(2.*epmax/electron_mass_c2) ;
ionloss += fine_structure_const*(log(2.*E/ParticleMass)-apar/3.)*
apar*apar/twopi ;
// correction of R. Kokoulin // has been taken out ***************
// G4double E = LowEdgeEnergy+ParticleMass ;
// G4double epmax = RateMass*E*E/(RateMass*E+ParticleMass) ;
// G4double apar = log(2.*epmax/electron_mass_c2) ;
// ionloss += fine_structure_const*(log(2.*E/ParticleMass)-apar/3.)*
// apar*apar/twopi ;
ionloss *= Factor*ElectronDensity ;
}
source/processes/electromagnetic/muons/src/G4MuPairProduction.cc
+10 -8
View File
@@ -5,8 +5,8 @@
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4MuPairProduction.cc,v 1.15 2000/05/23 09:58:49 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// $Id: G4MuPairProduction.cc,v 1.16 2001/02/05 17:50:29 gcosmo Exp $
// GEANT4 tag $Name: geant4-03-01 $
//
// --------------------------------------------------------------
// GEANT 4 class implementation file
@@ -237,7 +237,9 @@ void G4MuPairProduction::BuildLambdaTable(
}
theMeanFreePathTable = new
G4PhysicsTable( G4Material::GetNumberOfMaterials() ) ;
PartialSumSigma.resize(G4Material::GetNumberOfMaterials());
PartialSumSigma.clearAndDestroy();
PartialSumSigma.resize(G4Material::GetNumberOfMaterials());
G4PhysicsLogVector* ptrVector;
for ( G4int J=0 ; J < G4Material::GetNumberOfMaterials(); J++ )
@@ -276,7 +278,7 @@ void G4MuPairProduction::ComputePartialSumSigma(
G4double ElectronEnergyCut = (G4Electron::GetCutsInEnergy())[Imate];
G4double PositronEnergyCut = (G4Positron::GetCutsInEnergy())[Imate];
PartialSumSigma(Imate) = new G4ValVector(NbOfElements);
PartialSumSigma[Imate] = new G4DataVector();
G4double SIGMA = 0. ;
@@ -287,7 +289,7 @@ void G4MuPairProduction::ComputePartialSumSigma(
(*theElementVector)(Ielem)->GetZ(),
ElectronEnergyCut,PositronEnergyCut );
PartialSumSigma(Imate)->insertAt(Ielem, SIGMA);
PartialSumSigma[Imate]->push_back(SIGMA);
}
}
@@ -801,12 +803,12 @@ G4Element* G4MuPairProduction::SelectRandomAtom(G4Material* aMaterial) const
const G4int NumberOfElements = aMaterial->GetNumberOfElements();
const G4ElementVector* theElementVector = aMaterial->GetElementVector();
G4double rval = G4UniformRand()*((*PartialSumSigma(Index))
(NumberOfElements-1));
G4double rval = G4UniformRand()*((*PartialSumSigma[Index])
[NumberOfElements-1]);
for ( G4int i=0; i < NumberOfElements; i++ )
{
if (rval <= (*PartialSumSigma(Index))(i)) return ((*theElementVector)(i));
if (rval <= (*PartialSumSigma[Index])[i]) return ((*theElementVector)(i));
}
G4cout << " WARNING !!! - The Material '"<< aMaterial->GetName()
<< "' has no elements, NULL pointer returned." << G4endl;
source/processes/electromagnetic/muons/src/G4VIMuEnergyLoss.cc
-1570
View File
File diff suppressed because it is too large Load Diff
source/processes/electromagnetic/muons/src/G4VMuEnergyLoss.cc
+10 -2
View File
@@ -5,8 +5,8 @@
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4VMuEnergyLoss.cc,v 1.7 2000/10/30 07:17:30 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// $Id: G4VMuEnergyLoss.cc,v 1.8 2001/01/11 10:42:52 urban Exp $
// GEANT4 tag $Name: geant4-03-01 $
// --------------------------------------------------------------
// GEANT 4 class implementation file
//
@@ -104,6 +104,14 @@ G4VMuEnergyLoss::~G4VMuEnergyLoss()
LOGRTable=lrate/NbinEloss;
RTable =exp(LOGRTable);
//set physically consistent value for finalRange
// and parameters for en.loss step limit
if(finalRange > G4Electron::Electron()->GetCuts())
finalRange = G4Electron::Electron()->GetCuts() ;
c1lim = dRoverRange ;
c2lim = 2.*(1.-dRoverRange)*finalRange ;
c3lim = -(1.-dRoverRange)*finalRange*finalRange;
G4bool MakeTable ;
ParticleMass = aParticleType.GetPDGMass() ;
G4double Charge = aParticleType.GetPDGCharge()/eplus ;