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/utils/include/G4EnergyLossMessenger.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4EnergyLossMessenger.hh,v 1.3 2000/11/09 15:52:23 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
//
// Class Description:
source/processes/electromagnetic/utils/include/G4EnergyLossTables.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4EnergyLossTables.hh,v 1.10 2000/11/04 16:47:28 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// $Id:
//
source/processes/electromagnetic/utils/include/G4EnergyLossTables.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4EnergyLossTables.icc,v 1.12 2000/11/04 16:47:28 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// $Id:
// Inline members of the G4EnergyLossTables class
source/processes/electromagnetic/utils/include/G4IMultipleScattering.hh
-156
View File
@@ -1,156 +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: G4IMultipleScattering.hh,v 1.1 2000/03/20 14:44:03 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $Id:
// --------------------------------------------------------------
// GEANT 4 class header file
//
// For information related to this code contact:
// CERN, IT Division, ASD Group
// History: based on object model of
// 2nd December 1995, G.Cosmo
// --------- G4IMultipleScattering physics process --------
// by Laszlo Urban, October 1997
// **************************************************************
// UNIVERSAL: for arbitrary single charged particle
// 09/12/98: charge can be != +- 1 !!!! L.Urban
// --------------------------------------------------------------
// *****************************************************************
// It is the first implementation of the multiple scattering process
// using an INTEGRAL APPROACH instead of the differential
// one used in the standard implementation .
// *****************************************************************
// by Laszlo Urban, 23 June 1998
// -----------------------------------------------------------------
// 27/10/98: cleanup , L.Urban
#ifndef G4IMultipleScattering_h
#define G4IMultipleScattering_h 1
#include "G4ios.hh"
#include "g4std/fstream"
#include "g4std/iomanip"
#include "globals.hh"
#include "Randomize.hh"
#include "G4EnergyLossTables.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4Proton.hh"
#include "G4PhysicsLogVector.hh"
#include "G4GPILSelection.hh"
#include "G4VContinuousDiscreteProcess.hh"
#include "G4Step.hh"
#include "G4Track.hh"
#include "G4MaterialTable.hh"
#include "G4ElementTable.hh"
#include "G4ElementVector.hh"
#include "G4VParticleChange.hh"
class G4IMultipleScattering : public G4VContinuousDiscreteProcess
{
public:
G4IMultipleScattering(const G4String& processName="Imsc") ;
~G4IMultipleScattering() ;
G4bool IsApplicable ( const G4ParticleDefinition& ) ;
void SetPhysicsTableBining(G4double lowE,G4double highE,G4int nBins);
void BuildPhysicsTable(const G4ParticleDefinition& aParticleType) ;
void BuildIntegralITable(const G4ParticleDefinition& aParticleType) ;
void BuildIntegralJTable(const G4ParticleDefinition& aParticleType) ;
G4double GetIntegralI(const G4ParticleDefinition *aParticle,
G4double KineticEnergy,G4Material* aMaterial) ;
G4double GetIntegralJ(const G4ParticleDefinition *aParticle,
G4double KineticEnergy,G4Material* aMaterial) ;
void PrintInfoDefinition();
G4double GetContinuousStepLimit(const G4Track& aTrack,
G4double previousStepSize,
G4double currentMinimumStep,
G4double& currentSafety) ;
G4double GetMeanFreePath(const G4Track& aTrack,
G4double previousStepSize,
G4ForceCondition* condition) ;
G4VParticleChange* AlongStepDoIt(const G4Track& aTrack,const G4Step& aStep) ;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,const G4Step& aStep) ;
protected:
G4double ComputeTransportCrossSection(
const G4ParticleDefinition& aParticleType,
G4double KineticEnergy,
G4double AtomicNumber) ;
G4double TrueToGeomTransformation(const G4DynamicParticle* aParticle,
G4Material* aMaterial,
G4double truePathLength) ;
private:
// hide assignment operator as private
G4IMultipleScattering & operator = (const G4IMultipleScattering &right) ;
G4IMultipleScattering ( const G4IMultipleScattering &) ;
private:
// data members ...................................................
G4PhysicsTable* theTransportMeanFreePathTable;
G4PhysicsTable* theIntegralITable ;
G4PhysicsTable* theIntegralJTable ;
G4double fTransportMeanFreePath ;
G4double fMeanLateralDisplacement ;
G4double LowestKineticEnergy ;
G4double HighestKineticEnergy ;
G4int TotBin ;
const G4Electron* theElectron ;
const G4Positron* thePositron ;
G4Material* lastMaterial;
G4double lastKineticEnergy;
// GeomStepFinal is the geom.steplength at the end of the AlongStep loop
// the others are some 'cache' variables
G4double GeomStepFinal ;
G4double tLast,zLast,CosTheta ;
G4double biglambda ;
//parameters for low energy extrapolation of dE/dx and lambda
const G4double plowloss,plowlambda ;
G4int NumberOfBuildPhysicsTableCalls ;
G4double tuning ;
};
#include "G4IMultipleScattering.icc"
#endif
source/processes/electromagnetic/utils/include/G4IMultipleScattering.icc
-268
View File
@@ -1,268 +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: G4IMultipleScattering.icc,v 1.1 2000/03/20 14:44:03 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
//
// $Id:
// -------------------------------------------------------------
// GEANT 4 class inlined methods file
//
// For information related to this code contact:
// CERN, IT Division, ASD Group
// History: based on object model of
// 2nd December 1995, G.Cosmo
// ------- G4IMultipleScattering physics process ------
// by Laszlo Urban, October 1997
// **************************************************************
// 25/11/97: mods for KinEnergy > HighestLimit
//---------------------------------------------------------------
// *****************************************************************
// It is the first implementation of the multiple scattering process
// using an INTEGRAL APPROACH instead of the differential
// one used in the standard implementation .
// *****************************************************************
// by Laszlo Urban, 23 June 1998
// -----------------------------------------------------------------
// 27/10/98: cleanup , L.Urban
inline G4double G4IMultipleScattering::TrueToGeomTransformation(
const G4DynamicParticle *aParticle,
G4Material *aMaterial,
G4double truePathLength)
// it sets the data member fTransportMeanFreePath and
// performs the true path length -> geometrical path length
// transformation
{
const G4double factt=1.-1.e-6,tausmall=5.e-5,taubig=50.,
minim=1.e-6,smalldroverr=1.e-2,smalldToverT=2.e-2 ;
G4double KineticEnergy,Tfinal,tau,etau,geomPathLength,range,w1,w2,ww1,ww2 ;
G4int materialIndex ;
G4bool isOut ;
KineticEnergy = aParticle->GetKineticEnergy() ;
if((lastMaterial == aMaterial) && (lastKineticEnergy == KineticEnergy))
{ ; }
else
{
lastMaterial=aMaterial;
lastKineticEnergy=KineticEnergy;
materialIndex = aMaterial->GetIndex() ;
if(KineticEnergy<LowestKineticEnergy)
{
fTransportMeanFreePath =
exp(plowlambda*log((KineticEnergy/LowestKineticEnergy)))*
(*theTransportMeanFreePathTable)
(materialIndex)->GetValue(LowestKineticEnergy,isOut);
}
else
{
if(KineticEnergy>HighestKineticEnergy)
KineticEnergy=HighestKineticEnergy;
fTransportMeanFreePath = (*theTransportMeanFreePathTable)
(materialIndex)->GetValue(KineticEnergy,isOut);
}
}
// do the true -> geom transformation
if( fTransportMeanFreePath > biglambda )
{
geomPathLength = truePathLength ;
CosTheta = 1. ;
}
else
{
const G4ParticleDefinition *theParticle = aParticle->GetDefinition() ;
G4double range = G4EnergyLossTables::GetPreciseRangeFromEnergy(
theParticle,KineticEnergy,aMaterial) ;
if(truePathLength > factt*range)
{
geomPathLength = GetIntegralJ(theParticle,
KineticEnergy,aMaterial) ;
CosTheta = 0. ;
}
else
{
if(truePathLength/range < smalldroverr)
{
Tfinal = KineticEnergy - truePathLength*
G4EnergyLossTables::GetPreciseDEDX(
theParticle,KineticEnergy,aMaterial) ;
}
else
{
Tfinal = G4EnergyLossTables::GetPreciseEnergyFromRange(
theParticle,range-truePathLength,
aMaterial) ;
}
if((KineticEnergy-Tfinal)> smalldToverT)
{
w1 = GetIntegralI(theParticle,KineticEnergy,aMaterial) ;
w2 = GetIntegralI(theParticle,Tfinal ,aMaterial) ;
CosTheta = exp(w2-w1) ;
if( CosTheta < minim)
CosTheta = 0. ;
ww1 = GetIntegralJ(theParticle,KineticEnergy,aMaterial) ;
ww2 = GetIntegralJ(theParticle,Tfinal ,aMaterial) ;
geomPathLength = ww1 - ww2*CosTheta ;
}
else
{
tau = truePathLength/fTransportMeanFreePath ;
if(tau<tausmall)
etau = tau ;
else
{
if(tau>taubig)
etau = 1. ;
else
etau = 1.-exp(-tau) ;
}
geomPathLength = fTransportMeanFreePath*etau ;
CosTheta = exp(-truePathLength/fTransportMeanFreePath) ;
}
}
}
if(geomPathLength>truePathLength)
geomPathLength = truePathLength ;
tLast = truePathLength ;
zLast = geomPathLength ;
return geomPathLength ;
}
inline G4double G4IMultipleScattering::GetContinuousStepLimit(
const G4Track& track,
G4double,
G4double currentMinimumStep,
G4double&)
{
G4double zPathLength,tPathLength ;
const G4DynamicParticle* aParticle ;
// this process is not a candidate for selection!!!!!!!!!
SetGPILSelection(NotCandidateForSelection) ;
tPathLength = currentMinimumStep ;
aParticle = track.GetDynamicParticle() ;
zPathLength = TrueToGeomTransformation(aParticle,
track.GetMaterial(),tPathLength);
return zPathLength ;
}
inline G4double G4IMultipleScattering::GetMeanFreePath(const G4Track&,
G4double,
G4ForceCondition* condition)
// it does not limit the Step size , but it sets condition to
// Forced , because the PostStepDoIt always has to be called
{
*condition = Forced ;
return DBL_MAX ;
}
inline G4VParticleChange* G4IMultipleScattering::AlongStepDoIt(
const G4Track& track,const G4Step& Step)
// only a geom path->true path transformation is performed
{
const G4double Tlowlimit=100.*keV ;
const G4double fact = 1.-1.e-10 ;
//!! const G4double tausmall=5.e-5,taubig=0.9999,trueBig=5. ;
const G4double tausmall=5.e-5,taubig=0.9999,trueBig=9.21034 ;
G4double tau ,geomPathLength, truePathLength ;
aParticleChange.Initialize(track);
geomPathLength = track.GetStepLength() ;
//Store this value for later use in PostStepDoIt
GeomStepFinal = geomPathLength ;
if(geomPathLength == zLast)
{
truePathLength = tLast ;
}
else
{
if( fTransportMeanFreePath > biglambda )
{
truePathLength = track.GetStepLength() ;
CosTheta = 1. ;
}
else
{
G4double T = track.GetDynamicParticle()->GetKineticEnergy() ;
if(T < Tlowlimit)
{ // spec. low energy msc code
G4double range = G4EnergyLossTables::GetPreciseRangeFromEnergy(
track.GetDynamicParticle()->GetDefinition(),
T,track.GetMaterial()) ;
G4double alfa = 1.+range/fTransportMeanFreePath ;
G4double z = geomPathLength ;
//protection: z can not be greater than zmax !!!!!!!
G4double zmax = fact*range/alfa ;
if(z > zmax)
z = zmax ;
if(z == zmax)
{
truePathLength = range ;
CosTheta = 0. ;
}
else
{
truePathLength = range*
(1.-exp(log(1.-alfa*z/range)/alfa)) ;
CosTheta = (1.-alfa*z/range)/(1.-truePathLength/range) ;
}
}
else
{
tau = geomPathLength/fTransportMeanFreePath ;
if(tau<tausmall)
truePathLength = fTransportMeanFreePath*tau*(1.+0.5*tau) ;
else
{
if(tau<taubig)
truePathLength = -fTransportMeanFreePath*log(1.-tau) ;
else
truePathLength = fTransportMeanFreePath*trueBig ;
}
CosTheta = exp(-truePathLength/fTransportMeanFreePath) ;
}
}
}
if(truePathLength<geomPathLength)
truePathLength = geomPathLength ;
aParticleChange.SetTrueStepLength(truePathLength) ;
return &aParticleChange ;
}
inline G4bool G4IMultipleScattering::IsApplicable(
const G4ParticleDefinition& particle)
{
return(particle.GetPDGCharge() != 0.);
}
source/processes/electromagnetic/utils/include/G4MultipleScattering.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MultipleScattering.hh,v 1.1 2000/03/20 14:44:04 maire Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// $Id:
// --------------------------------------------------------------
source/processes/electromagnetic/utils/include/G4MultipleScattering.icc
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4MultipleScattering.icc,v 1.2 2000/03/24 08:08:08 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
// $Id:
// -------------------------------------------------------------
source/processes/electromagnetic/utils/include/G4VEnergyLoss.hh
+1 -1
View File
@@ -6,7 +6,7 @@
// and all its terms.
//
// $Id: G4VEnergyLoss.hh,v 1.9 2000/10/30 06:49:46 urban Exp $
// GEANT4 tag $Name: geant4-03-00 $
// GEANT4 tag $Name: geant4-03-01 $
//
//
// ------------------------------------------------------------