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

Import Geant4 11.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2024-12-06 11:11:40 +01:00
parent e58e650b32
commit 32390e802b
1984 changed files with 98713 additions and 83996 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/parameterisations/gflash/History
+8
View File
@@ -6,6 +6,14 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2024-10-21 Igor Semeniouk (gflash-V11-02-01)
- GFlashSamplingShowerParameterisation - add GetEffDensity function
- correction of Es and sampling resolution function
- Rossi approximation for Ec added as comment
## 2024-09-10 Igor Semeniouk (gflash-V11-02-00)
- clang-format for the files in parametrisation/gflash
## 2023-10-19 Ben Morgan (gflash-V11-01-01)
- Replace use of deprecated functions with modern equivalents
source/parameterisations/gflash/include/G4GFlashSpot.hh
+16 -16
View File
@@ -47,26 +47,26 @@
class G4GFlashSpot
{
public:
G4GFlashSpot(const GFlashEnergySpot* aSpot, const G4FastTrack* aTrack, G4TouchableHandle aH)
: theSpot(aSpot), theTrack(aTrack), theHandle(aH)
{}
G4GFlashSpot(const GFlashEnergySpot * aSpot,
const G4FastTrack * aTrack, G4TouchableHandle aH)
: theSpot(aSpot), theTrack(aTrack), theHandle(aH) {}
~G4GFlashSpot() {}
const GFlashEnergySpot * GetEnergySpot() const {return theSpot;}
const G4FastTrack * GetOriginatorTrack() const {return theTrack;}
G4TouchableHandle GetTouchableHandle() const {return theHandle;}
const GFlashEnergySpot* GetEnergySpot() const { return theSpot; }
const G4FastTrack* GetOriginatorTrack() const { return theTrack; }
G4TouchableHandle GetTouchableHandle() const { return theHandle; }
G4ThreeVector GetPosition() const
{return GetOriginatorTrack()->GetPrimaryTrack()->GetPosition();}
{
return GetOriginatorTrack()->GetPrimaryTrack()->GetPosition();
}
private:
const GFlashEnergySpot * theSpot;
const G4FastTrack * theTrack;
const GFlashEnergySpot* theSpot;
const G4FastTrack* theTrack;
G4TouchableHandle theHandle;
};
source/parameterisations/gflash/include/G4VGFlashSensitiveDetector.hh
+52 -67
View File
@@ -48,81 +48,66 @@
#include "G4GFlashSpot.hh"
#include "G4VSensitiveDetector.hh"
class G4VGFlashSensitiveDetector
class G4VGFlashSensitiveDetector
{
public: // with description
G4VGFlashSensitiveDetector() {}
G4VGFlashSensitiveDetector(const G4VGFlashSensitiveDetector&) {}
// Constructors. The user's concrete class must use one of these
// constructors by the constructor initializer of the derived class.
// The name of the sensitive detector must be the same as for the
// corresponding GG4VSensitiveDetector.
public: // with description
public: // without description
virtual ~G4VGFlashSensitiveDetector() {}
G4VGFlashSensitiveDetector() {}
G4VGFlashSensitiveDetector(const G4VGFlashSensitiveDetector &) {}
// Constructors. The user's concrete class must use one of these
// constructors by the constructor initializer of the derived class.
// The name of the sensitive detector must be the same as for the
// corresponding GG4VSensitiveDetector.
G4bool operator==(const G4VGFlashSensitiveDetector& right) const { return this == &right; }
G4bool operator!=(const G4VGFlashSensitiveDetector& right) const { return this != &right; }
public: // without description
public: // without description
inline G4bool Hit(G4GFlashSpot* aSpot)
{
// This is the public method invoked by GFlashHitMaker for generating
// hits. The actual user's implementation for generating hits must be
// implemented in GenerateHits() virtual protected method.
virtual ~G4VGFlashSensitiveDetector() {}
G4bool operator==(const G4VGFlashSensitiveDetector &right) const
{return this == &right;}
G4bool operator!=(const G4VGFlashSensitiveDetector &right) const
{return this != &right;}
public: // without description
inline G4bool Hit(G4GFlashSpot * aSpot)
{
// This is the public method invoked by GFlashHitMaker for generating
// hits. The actual user's implementation for generating hits must be
// implemented in GenerateHits() virtual protected method.
G4bool result = true;
G4VSensitiveDetector * This
= dynamic_cast<G4VSensitiveDetector *>(this);
if(!This)
{
G4Exception("G4VGFlashSensitiveDetector::Hit()",
"InvalidSetup", FatalException,
"Needs also to inherit from G4VSensitiveDetector!");
return false;
}
if(This->isActive())
{
G4VReadOutGeometry * ROgeometry = 0;
G4TouchableHistory* ROhis = 0;
if(This) ROgeometry = This->GetROgeometry();
if(ROgeometry)
{
// fake pre-step point for touchable from read-out geometry.
G4Step fakeStep;
G4StepPoint * tmpPoint = fakeStep.GetPreStepPoint();
tmpPoint->SetTouchableHandle(aSpot->GetTouchableHandle());
tmpPoint->SetPosition(aSpot->GetPosition());
tmpPoint->SetMomentumDirection(aSpot->GetOriginatorTrack()
->GetPrimaryTrack()->GetMomentumDirection());
result = ROgeometry->CheckROVolume(&fakeStep, ROhis);
}
if(result) result = ProcessHits(aSpot, ROhis);
}
else
{
result = false;
}
return result;
G4bool result = true;
G4VSensitiveDetector* This = dynamic_cast<G4VSensitiveDetector*>(this);
if (!This) {
G4Exception("G4VGFlashSensitiveDetector::Hit()", "InvalidSetup", FatalException,
"Needs also to inherit from G4VSensitiveDetector!");
return false;
}
if (This->isActive()) {
G4VReadOutGeometry* ROgeometry = 0;
G4TouchableHistory* ROhis = 0;
protected: // with description
if (This) ROgeometry = This->GetROgeometry();
if (ROgeometry) {
// fake pre-step point for touchable from read-out geometry.
G4Step fakeStep;
G4StepPoint* tmpPoint = fakeStep.GetPreStepPoint();
tmpPoint->SetTouchableHandle(aSpot->GetTouchableHandle());
tmpPoint->SetPosition(aSpot->GetPosition());
tmpPoint->SetMomentumDirection(
aSpot->GetOriginatorTrack()->GetPrimaryTrack()->GetMomentumDirection());
result = ROgeometry->CheckROVolume(&fakeStep, ROhis);
}
if (result) result = ProcessHits(aSpot, ROhis);
}
else {
result = false;
}
return result;
}
virtual G4bool ProcessHits(G4GFlashSpot*aSpot,
G4TouchableHistory*ROhist) = 0;
// The user MUST implement this method for generating hit(s) from the
// GFlashSpots. Be aware that this method is a protected method and it
// will be invoked by Hit() method of the Base class once the Readout
// geometry that may be associated to the corresponding
// G4VSensitiveDetector was taken into account.
protected: // with description
virtual G4bool ProcessHits(G4GFlashSpot* aSpot, G4TouchableHistory* ROhist) = 0;
// The user MUST implement this method for generating hit(s) from the
// GFlashSpots. Be aware that this method is a protected method and it
// will be invoked by Hit() method of the Base class once the Readout
// geometry that may be associated to the corresponding
// G4VSensitiveDetector was taken into account.
};
#endif
source/parameterisations/gflash/include/GFlashEnergySpot.hh
+9 -11
View File
@@ -46,21 +46,19 @@
class GFlashEnergySpot
{
public:
GFlashEnergySpot();
GFlashEnergySpot(const G4ThreeVector& point, G4double E);
~GFlashEnergySpot();
inline void SetEnergy(const G4double& E) {Energy = E;}
inline G4double GetEnergy() const {return Energy;}
inline void SetPosition(const G4ThreeVector& point) {Point = point;}
inline G4ThreeVector GetPosition() const {return Point;}
private:
G4double Energy; // energy deposition
G4ThreeVector Point; // locus of energy deposition
inline void SetEnergy(const G4double& E) { Energy = E; }
inline G4double GetEnergy() const { return Energy; }
inline void SetPosition(const G4ThreeVector& point) { Point = point; }
inline G4ThreeVector GetPosition() const { return Point; }
private:
G4double Energy; // energy deposition
G4ThreeVector Point; // locus of energy deposition
};
#endif
source/parameterisations/gflash/include/GFlashHitMaker.hh
+9 -16
View File
@@ -52,22 +52,20 @@ class G4Step;
class G4StepPoint;
class G4VProcess;
class GFlashHitMaker
class GFlashHitMaker
{
public:
GFlashHitMaker();
~GFlashHitMaker();
void make(GFlashEnergySpot * aSpot, const G4FastTrack * aT );
inline void SetNameOfWorldWithSD(const G4String& aName) {fWorldWithSdName = aName;};
void make(GFlashEnergySpot* aSpot, const G4FastTrack* aT);
inline void SetNameOfWorldWithSD(const G4String& aName) { fWorldWithSdName = aName; };
inline void SetProcess(G4VProcess* proc) { fpProcess = proc; }
private:
private:
G4TouchableHandle fTouchableHandle;
G4Navigator *fpNavigator;
G4Navigator* fpNavigator;
G4bool fNaviSetup;
/// Name of the world containing the sensitive detector. If empty, default mass world is used.
G4String fWorldWithSdName;
@@ -77,12 +75,7 @@ class GFlashHitMaker
G4VProcess* fpProcess = nullptr;
private:
GFlashHitMaker(const GFlashHitMaker & ) {}
GFlashHitMaker & operator = (const GFlashHitMaker & )
{
return *this;
}
GFlashHitMaker(const GFlashHitMaker&) {}
GFlashHitMaker& operator=(const GFlashHitMaker&) { return *this; }
};
#endif
source/parameterisations/gflash/include/GFlashHomoShowerParameterisation.hh
+33 -37
View File
@@ -49,13 +49,11 @@ class G4Material;
class GFlashHomoShowerParameterisation : public GVFlashShowerParameterisation
{
public: // with description
GFlashHomoShowerParameterisation(G4Material * aMat,
GVFlashHomoShowerTuning * aPar = 0);
GFlashHomoShowerParameterisation(G4Material* aMat, GVFlashHomoShowerTuning* aPar = 0);
~GFlashHomoShowerParameterisation();
void ComputeRadialParameters(G4double y, G4double Tau);
void GenerateLongitudinalProfile(G4double Energy);
void GenerateLongitudinalProfile(G4double Energy);
void ComputeZAX0EFFetc();
G4double IntegrateEneLongitudinal(G4double LongitudinalStep);
@@ -63,71 +61,69 @@ class GFlashHomoShowerParameterisation : public GVFlashShowerParameterisation
G4double ComputeTau(G4double LongitudinalPosition);
G4double GeneratePhi();
G4double GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition);
G4double GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition);
G4double GenerateExponential(G4double Energy);
void SetMaterial(G4Material *mat);
void SetMaterial(G4Material* mat);
inline G4double GetAveR99() {return (3.5 * Rm);}
inline G4double GetAveR90() {return (1.5 * Rm);} //ok
inline G4double GetAveR99() { return (3.5 * Rm); }
inline G4double GetAveR90() { return (1.5 * Rm); } // ok
inline G4double GetAveTmx() {return (X0 * std::exp(AveLogTmaxh));}
inline G4double GetAveT99() {return (X0 * AveLogTmaxh/(AveLogAlphah-1.00));}
inline G4double GetAveT90() {return (2.5* X0*std::exp( AveLogTmaxh) );}
inline G4double GetNspot(){ return NSpot;}
inline G4double GetX0(){return X0;}
inline G4double GetEc(){return Ec;}
inline G4double GetRm(){return Rm;}
inline G4double GetX0() { return X0; }
inline G4double GetEc() { return Ec; }
inline G4double GetRm() { return Rm; }
private:
G4Material* material;
G4Material *material;
//Resolution
G4double ConstantResolution;
G4double NoiseResolution;
// Resolution
G4double ConstantResolution;
G4double NoiseResolution;
G4double SamplingResolution;
// parametrization parameters
GVFlashHomoShowerTuning * thePar;
GVFlashHomoShowerTuning* thePar;
// Cashed parameters:
// Cashed parameters:
// Longitudinal Coefficients for a homogeneous calo
G4double ParAveT1;
G4double ParAveA1,ParAveA2,ParAveA3;
G4double ParSigLogT1,ParSigLogT2;
G4double ParSigLogA1,ParSigLogA2;
G4double ParRho1,ParRho2;
G4double ParAveA1, ParAveA2, ParAveA3;
G4double ParSigLogT1, ParSigLogT2;
G4double ParSigLogA1, ParSigLogA2;
G4double ParRho1, ParRho2;
void ComputeLongitudinalParameters(G4double y);
void GenerateEnergyProfile(G4double y);
void GenerateNSpotProfile(G4double y);
// Radial Coefficients
G4double ParRC1,ParRC2,ParRC3,ParRC4;
G4double ParWC1,ParWC2,ParWC3;
G4double ParWC4,ParWC5,ParWC6;
G4double ParRT1,ParRT2,ParRT3,ParRT4;
G4double ParRT5,ParRT6;
G4double ParRC1, ParRC2, ParRC3, ParRC4;
G4double ParWC1, ParWC2, ParWC3;
G4double ParWC4, ParWC5, ParWC6;
G4double ParRT1, ParRT2, ParRT3, ParRT4;
G4double ParRT5, ParRT6;
// Spot multiplicity Coefficients
G4double ParSpotT1,ParSpotT2,ParSpotA1, ParSpotA2;
G4double ParSpotN1,ParSpotN2;
G4double ParSpotT1, ParSpotT2, ParSpotA1, ParSpotA2;
G4double ParSpotN1, ParSpotN2;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// Longitudinal
// homogeneous
G4double AveLogAlphah,AveLogTmaxh;
G4double SigmaLogAlphah,SigmaLogTmaxh;
G4double AveLogAlphah, AveLogTmaxh;
G4double SigmaLogAlphah, SigmaLogTmaxh;
G4double Rhoh;
G4double Alphah,Tmaxh,Betah;
G4double Alphah, Tmaxh, Betah;
// Multiplicity
G4double NSpot,AlphaNSpot,TNSpot,BetaNSpot;
G4double NSpot, AlphaNSpot, TNSpot, BetaNSpot;
//Radial
G4double RadiusCore, WeightCore,RadiusTail;
// Radial
G4double RadiusCore, WeightCore, RadiusTail;
};
#endif
source/parameterisations/gflash/include/GFlashParticleBounds.hh
+11 -17
View File
@@ -39,36 +39,30 @@
// Author: Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashParticleBounds_h
#define GFlashParticleBounds_h
#define GFlashParticleBounds_h
#include "G4ParticleDefinition.hh"
#include "G4ParticleDefinition.hh"
class GFlashParticleBounds
class GFlashParticleBounds
{
public: // with description
GFlashParticleBounds();
~GFlashParticleBounds();
// methods to get/set ELE/Gamma max & min energy bounds
G4double GetMinEneToParametrise(G4ParticleDefinition &particleType);
G4double GetMaxEneToParametrise(G4ParticleDefinition &particleType);
G4double GetEneToKill(G4ParticleDefinition &particleType) ;
void SetMinEneToParametrise(G4ParticleDefinition &particleType,
G4double enemin);
void SetMaxEneToParametrise(G4ParticleDefinition &particleType,
G4double enemax);
void SetEneToKill(G4ParticleDefinition &particleType,
G4double enekill);
G4double GetMinEneToParametrise(G4ParticleDefinition& particleType);
G4double GetMaxEneToParametrise(G4ParticleDefinition& particleType);
G4double GetEneToKill(G4ParticleDefinition& particleType);
void SetMinEneToParametrise(G4ParticleDefinition& particleType, G4double enemin);
void SetMaxEneToParametrise(G4ParticleDefinition& particleType, G4double enemax);
void SetEneToKill(G4ParticleDefinition& particleType, G4double enekill);
private:
// electron and positron
G4double EMinEneToParametrise;
G4double EMaxEneToParametrise;
G4double EEneToKill;
};
#endif
source/parameterisations/gflash/include/GFlashSamplingShowerParameterisation.hh
+60 -63
View File
@@ -46,130 +46,127 @@
class G4Material;
class GFlashSamplingShowerParameterisation
: public GVFlashShowerParameterisation
class GFlashSamplingShowerParameterisation : public GVFlashShowerParameterisation
{
public:
GFlashSamplingShowerParameterisation(
G4Material* aMat1, G4Material* aMat2, G4double d1, G4double d2,
/// \param aMat1 passive material, \param dd1 - passive layer thickness
/// \param aMat2 active material, \param dd2 - acive layer thickness
GFlashSamplingShowerParameterisation(G4Material* aMat1, G4Material* aMat2,
G4double d1, G4double d2,
/// \param aMat1 passive material, \param dd1 - passive layer thickness
/// \param aMat2 active material, \param dd2 - acive layer thickness
GFlashSamplingShowerTuning * aPar = 0);
GFlashSamplingShowerTuning* aPar = 0);
~GFlashSamplingShowerParameterisation();
void ComputeRadialParameters(G4double y, G4double Tau);
void GenerateLongitudinalProfile(G4double Energy);
void GenerateLongitudinalProfile(G4double Energy);
void ComputeZAX0EFFetc();
G4double IntegrateEneLongitudinal(G4double LongitudinalStep);
G4double IntegrateNspLongitudinal(G4double LongitudinalStep);
G4double ComputeTau(G4double LongitudinalPosition);
void SetMaterial(G4Material *mat1, G4Material *mat2);
void SetMaterial(G4Material* mat1, G4Material* mat2);
G4double GeneratePhi();
G4double GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition);
G4double GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition);
G4double GenerateExponential(G4double Energy);
inline G4double GetAveR99() {return (3.5 * Rmeff);}
inline G4double GetAveR90() {return (1.5 * Rmeff);} //ok
inline G4double GetAveR99() { return (3.5 * Rmeff); }
inline G4double GetAveR90() { return (1.5 * Rmeff); } // ok
//
inline G4double GetAveTmx() {return (X0eff*std::exp(AveLogTmax));}
inline G4double GetAveT99() {return (X0eff*AveLogTmax/(AveLogAlpha-1.00));}
inline G4double GetAveT90() {return (2.5* X0eff* std::exp( AveLogTmax));}
//
inline G4double GetNspot() {return NSpot;}
inline G4double GetX0() {return X0eff;}
inline G4double GetEc() {return Eceff;}
inline G4double GetRm() {return Rmeff;}
inline G4double GetAveTmx() { return (X0eff * std::exp(AveLogTmax)); }
inline G4double GetAveT99() { return (X0eff * AveLogTmax / (AveLogAlpha - 1.00)); }
inline G4double GetAveT90() { return (2.5 * X0eff * std::exp(AveLogTmax)); }
//
inline G4double GetNspot() { return NSpot; }
inline G4double GetX0() { return X0eff; }
inline G4double GetEc() { return Eceff; }
inline G4double GetRm() { return Rmeff; }
inline G4double GetEffDensity() { return Rhoeff; }
G4double ApplySampling(const G4double DEne, const G4double Energy);
private:
// medium related quantities
//
G4Material *material1, *material2 ;
G4double density1, A1, Z1, X01, Ec1, Rm1, d1;
G4double density2, A2, Z2, X02, Ec2, Rm2, d2;
G4double Aeff, Rhoeff, X0eff, Eceff, Rmeff, Fs, ehat, Zeff;
G4Material *material1, *material2;
G4double density1, A1, Z1, X01, Ec1, Rm1, d1;
G4double density2, A2, Z2, X02, Ec2, Rm2, d2;
G4double Aeff, Rhoeff{1.0}, X0eff{1.0}, Eceff{1.0}, Rmeff{1.0}, Fs, ehat, Zeff;
// Resolution
//
G4double ConstantResolution;
G4double NoiseResolution;
G4double ConstantResolution;
G4double NoiseResolution;
G4double SamplingResolution;
// parametrization parameters
//
GFlashSamplingShowerTuning * thePar;
GFlashSamplingShowerTuning* thePar;
// Cashed parameters:
// Cashed parameters:
// Longitudinal Coefficients for a homogenious calo
//
G4double ParAveT1, ParAveT2;
G4double ParAveA1,ParAveA2, ParAveA3;
G4double ParSigLogT1,ParSigLogT2;
G4double ParSigLogA1,ParSigLogA2;
G4double ParRho1,ParRho2;
G4double ParAveA1, ParAveA2, ParAveA3;
G4double ParSigLogT1, ParSigLogT2;
G4double ParSigLogA1, ParSigLogA2;
G4double ParRho1, ParRho2;
//Cashed parameters:
// Longitudinal Coefficients for a sampling calo
// Cashed parameters:
// Longitudinal Coefficients for a sampling calo
//
G4double ParsAveT1, ParsAveT2;
G4double ParsAveA1,ParsAveA2;
G4double ParsSigLogT1,ParsSigLogT2;
G4double ParsSigLogA1,ParsSigLogA2;
G4double ParsRho1,ParsRho2;
G4double ParsAveA1, ParsAveA2;
G4double ParsSigLogT1, ParsSigLogT2;
G4double ParsSigLogA1, ParsSigLogA2;
G4double ParsRho1, ParsRho2;
void ComputeLongitudinalParameters(G4double y);
void GenerateEnergyProfile(G4double y);
void GenerateNSpotProfile(G4double y);
// Radial Coefficients homo
//
G4double ParRC1,ParRC2,ParRC3,ParRC4;
G4double ParWC1,ParWC2,ParWC3;
G4double ParWC4,ParWC5,ParWC6;
G4double ParRT1,ParRT2,ParRT3,ParRT4;
G4double ParRT5,ParRT6;
G4double ParRC1, ParRC2, ParRC3, ParRC4;
G4double ParWC1, ParWC2, ParWC3;
G4double ParWC4, ParWC5, ParWC6;
G4double ParRT1, ParRT2, ParRT3, ParRT4;
G4double ParRT5, ParRT6;
// Radial Coefficients sampling
//
G4double ParsRC1,ParsRC2;
G4double ParsWC1,ParsWC2;
G4double ParsRT1,ParsRT2;
G4double ParsRC1, ParsRC2;
G4double ParsWC1, ParsWC2;
G4double ParsRT1, ParsRT2;
// Spot multiplicity Coefficients
//
G4double ParsSpotT1,ParsSpotT2,ParsSpotA1, ParsSpotA2;
G4double ParsSpotN1,ParsSpotN2;
G4double ParsSpotT1, ParsSpotT2, ParsSpotA1, ParsSpotA2;
G4double ParsSpotN1, ParsSpotN2;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// Longitudinal
// homogeneous
//
G4double AveLogAlphah,AveLogTmaxh;
G4double SigmaLogAlphah,SigmaLogTmaxh;
G4double AveLogAlphah, AveLogTmaxh;
G4double SigmaLogAlphah, SigmaLogTmaxh;
G4double Rhoh;
G4double Alphah,Tmaxh,Betah;
G4double Alphah, Tmaxh, Betah;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// Longitudinal
// sampling
//
G4double AveLogAlpha,AveLogTmax;
G4double SigmaLogAlpha,SigmaLogTmax;
G4double AveLogAlpha, AveLogTmax;
G4double SigmaLogAlpha, SigmaLogTmax;
G4double Rho;
G4double Alpha,Tmax,Beta;
G4double Alpha, Tmax, Beta;
// Multiplicity
//
G4double NSpot,AlphaNSpot,TNSpot,BetaNSpot;
G4double NSpot, AlphaNSpot, TNSpot, BetaNSpot;
//Radial
// Radial
//
G4double RadiusCore, WeightCore,RadiusTail;
G4double RadiusCore, WeightCore, RadiusTail;
};
#endif
source/parameterisations/gflash/include/GFlashSamplingShowerTuning.hh
+41 -44
View File
@@ -60,75 +60,72 @@ class GFlashSamplingShowerTuning : public GVFlashHomoShowerTuning
GFlashSamplingShowerTuning() {}
virtual ~GFlashSamplingShowerTuning() {}
public: // with description
G4double ParsAveT1(){ return -0.55;} // t1
G4double ParsAveT2(){ return -0.69;} // t2
public: // with description
G4double ParsAveT1() { return -0.55; } // t1
G4double ParsAveT2() { return -0.69; } // t2
// T_sam = log(exp( log T_hom) + t1*Fs-1 + t2*(1-ehat))
G4double ParsAveA1(){ return -0.476; } // a1
G4double ParsAveA1() { return -0.476; } // a1
// alpha_sam = log(exp(log alphah_hom) +(a1*Fs-1))
G4double ParsSigLogT1(){ return -2.5;} // t1
G4double ParsSigLogT2(){ return 1.25;} // t2
G4double ParsSigLogT1() { return -2.5; } // t1
G4double ParsSigLogT2() { return 1.25; } // t2
// std::sqrt(var(ln(T_sam))) = 1/(t+t2*ln(y))
G4double ParsSigLogA1(){ return -0.82;} // a1
G4double ParsSigLogA2(){ return 0.79; } // a2
G4double ParsSigLogA1() { return -0.82; } // a1
G4double ParsSigLogA2() { return 0.79; } // a2
// std::sqrt(var(ln(alpha_sam))) = 1/(a1+a2*ln(y))
G4double ParsRho1(){ return 0.784; } // r1
G4double ParsRho2(){ return -0.023;} // r2
G4double ParsRho1() { return 0.784; } // r1
G4double ParsRho2() { return -0.023; } // r2
// Correlation(ln(T),ln(alpha))=r1+r2*ln(y)
// Radial profiles
// f(r) := (1/dE(t))(dE(t,r)/dr)
// Ansatz:
// f(r) = p(2*r*Rc**2)/(r**2+Rc**2)**2+(1-p)*(2*r*Rt**2)/(r**2+Rt**2)**2,
// 0<p<1
// Radial profiles
// f(r) := (1/dE(t))(dE(t,r)/dr)
// Ansatz:
// f(r) = p(2*r*Rc**2)/(r**2+Rc**2)**2+(1-p)*(2*r*Rt**2)/(r**2+Rt**2)**2,
// 0<p<1
G4double ParsRC1(){ return -0.0203; } // c1
G4double ParsRC2(){ return 0.0397; } // c2
G4double ParsRC1() { return -0.0203; } // c1
G4double ParsRC2() { return 0.0397; } // c2
// Rc_sam = Rc_hom + c1 * (1-ehat) + c2 *Fs-1*exp (-tau)
G4double ParsRT1(){ return -0.14; } // t1
G4double ParsRT2(){ return -0.495; } // t2
G4double ParsRT1() { return -0.14; } // t1
G4double ParsRT2() { return -0.495; } // t2
// Rt_sam = Rc_hom + t1 * (1-ehat) + t2 *Fs-1*exp (-tau)
G4double ParsWC1(){ return 0.348; } // c1
G4double ParsWC2(){ return -0.642;} // c2
G4double ParsWC1() { return 0.348; } // c1
G4double ParsWC2() { return -0.642; } // c2
// W_sam = W_hom + (1-ehat)*(c1 + c2 *Fs-1 * exp (- (tau -1 )**2))
// Fluctuations on radial profiles through number of spots
// The total number of spots needed for a shower is
// Fluctuations on radial profiles through number of spots
// The total number of spots needed for a shower is
G4double ParsSpotN1(){ return 10.3; } // n1
G4double ParsSpotN2(){ return 0.959;} // n2
G4double ParsSpotN1() { return 10.3; } // n1
G4double ParsSpotN2() { return 0.959; } // n2
// Ns = n1*ln(Z)(E/GeV)**n2
// The number of spots per longitudinal interval is:
// (1/Ns)(dNs(t)/dt) = f(t)
// = (beta*t)**(alpha-1)*beta*std::exp(-beta*t)/Gamma(alpha)
// <t> = alpha_s/beta_s
// Ts = (alpha_s-1)/beta_s
// and
// Ts = T*(t1+t2*Z)
// alpha_s = alpha*(a1+a2*Z)
// The number of spots per longitudinal interval is:
// (1/Ns)(dNs(t)/dt) = f(t)
// = (beta*t)**(alpha-1)*beta*std::exp(-beta*t)/Gamma(alpha)
// <t> = alpha_s/beta_s
// Ts = (alpha_s-1)/beta_s
// and
// Ts = T*(t1+t2*Z)
// alpha_s = alpha*(a1+a2*Z)
G4double ParsSpotT1(){ return 0.813; } // t1
G4double ParsSpotT2(){ return 0.0019;} // t2
G4double ParsSpotT1() { return 0.813; } // t1
G4double ParsSpotT2() { return 0.0019; } // t2
G4double ParsSpotA1(){ return 0.844; } //a1
G4double ParsSpotA2(){ return 0.0026;} //a2
G4double ParsSpotA1() { return 0.844; } // a1
G4double ParsSpotA2() { return 0.0026; } // a2
// Resolution
G4double ConstantResolution(){ return 0.00; }
G4double NoiseResolution() { return 0.00; } // not used
G4double SamplingResolution(){ return 0.11; } // not used
// Resolution
G4double ConstantResolution() { return 0.00; } // not used
G4double NoiseResolution() { return 0.00; } // not used
G4double SamplingResolution() { return 0.11; }
};
#endif
source/parameterisations/gflash/include/GFlashShowerModel.hh
+23 -36
View File
@@ -59,46 +59,35 @@ class GFlashSamplingShowerParameterisation;
class GFlashShowerModel : public G4VFastSimulationModel
{
public: // with description
GFlashShowerModel(G4String, G4Envelope*);
GFlashShowerModel(G4String);
~GFlashShowerModel();
// Constructors, destructor
GFlashShowerModel (G4String, G4Envelope*);
GFlashShowerModel (G4String);
~GFlashShowerModel ();
// Constructors, destructor
G4bool ModelTrigger(const G4FastTrack &);
G4bool ModelTrigger(const G4FastTrack&);
G4bool IsApplicable(const G4ParticleDefinition&);
void DoIt(const G4FastTrack&, G4FastStep&);
// Checks whether conditions of fast parameterisation are fullfilled
// Checks whether conditions of fast parameterisation are fullfilled
// setting
inline void SetFlagParamType(G4int I)
{ FlagParamType = I; }
inline void SetFlagParticleContainment(G4int I)
{ FlagParticleContainment = I; }
inline void SetStepInX0(G4double Lenght)
{ StepInX0=Lenght; }
inline void SetParameterisation(GVFlashShowerParameterisation &DP)
{ Parameterisation=&DP;}
inline void SetHitMaker(GFlashHitMaker &Maker)
{ HMaker=&Maker; }
inline void SetParticleBounds(GFlashParticleBounds &SpecificBound)
{ PBound =&SpecificBound; }
inline void SetFlagParamType(G4int I) { FlagParamType = I; }
inline void SetFlagParticleContainment(G4int I) { FlagParticleContainment = I; }
inline void SetStepInX0(G4double Lenght) { StepInX0 = Lenght; }
inline void SetParameterisation(GVFlashShowerParameterisation& DP) { Parameterisation = &DP; }
inline void SetHitMaker(GFlashHitMaker& Maker) { HMaker = &Maker; }
inline void SetParticleBounds(GFlashParticleBounds& SpecificBound) { PBound = &SpecificBound; }
// getting
inline G4int GetFlagParamType()
{ return FlagParamType; }
inline G4int GetFlagParticleContainment()
{ return FlagParticleContainment; }
inline G4double GetStepInX0()
{ return StepInX0; }
inline G4int GetFlagParamType() { return FlagParamType; }
inline G4int GetFlagParticleContainment() { return FlagParticleContainment; }
inline G4double GetStepInX0() { return StepInX0; }
public: // without description
// Gets ?
// Gets ?
GFlashParticleBounds *PBound;
GVFlashShowerParameterisation *Parameterisation;
GVFlashShowerParameterisation* Parameterisation;
private:
@@ -107,17 +96,15 @@ class GFlashShowerModel : public G4VFastSimulationModel
// void NeutrinoDoIt(const G4FastTrack&, G4FastStep&);
G4bool CheckParticleDefAndContainment(const G4FastTrack &fastTrack);
G4bool CheckContainment(const G4FastTrack &fastTrack);
private:
GFlashHitMaker *HMaker;
private:
GFlashHitMaker* HMaker;
GFlashShowerModelMessenger* Messenger;
//Control Flags
G4int FlagParamType; ///0=no GFlash 1=only em showers parametrized
G4int FlagParticleContainment; ///0=no check ///1=only fully contained...
G4double StepInX0;
G4double StepInX0;
G4double EnergyStop;
};
#endif
source/parameterisations/gflash/include/GFlashShowerModelMessenger.hh
+13 -15
View File
@@ -52,26 +52,24 @@ class G4UIcmdWithAnInteger;
class G4UIcmdWithADoubleAndUnit;
class G4UIcmdWithADouble;
class GFlashShowerModelMessenger: public G4UImessenger
class GFlashShowerModelMessenger : public G4UImessenger
{
public:
GFlashShowerModelMessenger(GFlashShowerModel * myModel);
GFlashShowerModelMessenger(GFlashShowerModel* myModel);
~GFlashShowerModelMessenger();
void SetNewValue(G4UIcommand * command,G4String newValues);
G4String GetCurrentValue(G4UIcommand * command);
private:
void SetNewValue(G4UIcommand* command, G4String newValues);
G4String GetCurrentValue(G4UIcommand* command);
private:
GFlashShowerModel* myModel;
G4UIdirectory* myParaDir;
G4UIcmdWithAnInteger* FlagCmd;
G4UIcmdWithAnInteger* ContCmd; // Containment Check
G4UIcmdWithADouble* StepInX0Cmd;
G4UIcmdWithADoubleAndUnit* EmaxCmd;
G4UIcmdWithADoubleAndUnit* EminCmd;
G4UIcmdWithADoubleAndUnit* EkillCmd;
G4UIdirectory* myParaDir;
G4UIcmdWithAnInteger* FlagCmd;
G4UIcmdWithAnInteger* ContCmd; // Containment Check
G4UIcmdWithADouble* StepInX0Cmd;
G4UIcmdWithADoubleAndUnit* EmaxCmd;
G4UIcmdWithADoubleAndUnit* EminCmd;
G4UIcmdWithADoubleAndUnit* EkillCmd;
};
#endif
source/parameterisations/gflash/include/GVFlashHomoShowerTuning.hh
+14 -16
View File
@@ -70,22 +70,21 @@ class GVFlashHomoShowerTuning
public:
GVFlashHomoShowerTuning() {}
virtual ~GVFlashHomoShowerTuning() {}
public: // with description
virtual G4double ParAveT1(){ return -0.812; } // t1
virtual G4double ParAveA1(){ return 0.81; } // a1
public: // with description
virtual G4double ParAveT1() { return -0.812; } // t1
virtual G4double ParAveA1() { return 0.81; } // a1
virtual G4double ParAveA2(){ return 0.458; } // a2
virtual G4double ParAveA3(){ return 2.26; } // a3
virtual G4double ParSigLogT1(){ return -1.4; } // t1
virtual G4double ParSigLogT2(){ return 1.26;} // t2
// std::sqrt(var(ln(T))) = 1/(t+t2*ln(y))
virtual G4double ParAveA3() { return 2.26; } // a3
virtual G4double ParSigLogT1() { return -1.4; } // t1
virtual G4double ParSigLogT2() { return 1.26; } // t2
// std::sqrt(var(ln(T))) = 1/(t+t2*ln(y))
virtual G4double ParSigLogA1(){ return -0.58; } // a1
virtual G4double ParSigLogA2(){ return 0.86; } // a2
// std::sqrt(var(ln(alpha))) = 1/(a1+a2*ln(y))
virtual G4double ParRho1(){ return 0.705; } // r1
virtual G4double ParRho2(){ return -0.023; } // r2
// Correlation(ln(T),ln(alpha))=r1+r2*ln(y)
@@ -103,7 +102,7 @@ class GVFlashHomoShowerTuning
// Rc (t/T)= z1 +z2*t/T
// z1 = c1+c2*ln(E/GeV)
// z2 = c3+c4*Z
virtual G4double ParRT1(){ return 0.659; } // t1
virtual G4double ParRT2(){ return -0.00309;} // t2
virtual G4double ParRT3(){ return 0.645; } // k2
@@ -113,7 +112,7 @@ class GVFlashHomoShowerTuning
// Rt (t/T)= k1*(std::exp(k3*(t/T-k2))+std::exp(k4*(t/T-k2)))
// k1 = t1+t2*Z
// k4 = t5+t6*ln(E/GeV)
virtual G4double ParWC1(){ return 2.632; } // c1
virtual G4double ParWC2(){ return -0.00094;} // c2
virtual G4double ParWC3(){ return 0.401; } // c3
@@ -141,11 +140,10 @@ class GVFlashHomoShowerTuning
// alpha_s = alpha*(a1+a2*Z)
virtual G4double ParSpotT1(){ return 0.698; } // t1
virtual G4double ParSpotT2(){ return 0.00212;} // t2
virtual G4double ParSpotA1(){ return 0.639; } //a1
virtual G4double ParSpotA2(){ return 0.00334;} //a2
virtual G4double ParSpotT2() { return 0.00212; } // t2
virtual G4double ParSpotA1() { return 0.639; } // a1
virtual G4double ParSpotA2() { return 0.00334; } // a2
};
#endif
source/parameterisations/gflash/include/GVFlashShowerParameterisation.hh
+43 -47
View File
@@ -46,55 +46,51 @@
class MyGamma;
class G4Material;
class GVFlashShowerParameterisation
{
public: // with description
GVFlashShowerParameterisation();
virtual ~GVFlashShowerParameterisation();
virtual void ComputeRadialParameters(G4double y, G4double Tau) = 0;
virtual void GenerateLongitudinalProfile(G4double Energy) = 0;
virtual G4double IntegrateEneLongitudinal(G4double LongitudinalStep) = 0;
virtual G4double IntegrateNspLongitudinal(G4double LongitudinalStep) = 0;
virtual G4double ComputeTau(G4double LongitudinalPosition) = 0;
virtual G4double GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition) = 0;
virtual void ComputeLongitudinalParameters(G4double y) = 0;
virtual void GenerateEnergyProfile(G4double y) = 0;
virtual void GenerateNSpotProfile(G4double y) = 0;
virtual G4double GenerateExponential(G4double Energy) = 0;
virtual G4double GetAveR99() = 0;
virtual G4double GetAveR90() = 0;
virtual G4double GetAveTmx() = 0;
virtual G4double GetAveT99() = 0;
virtual G4double GetAveT90() = 0;
virtual G4double GetNspot() = 0;
virtual G4double GetX0() = 0;
virtual G4double GetEc() = 0;
virtual G4double GetRm() = 0;
G4double GeneratePhi();
G4double GetEffZ(const G4Material * material);
G4double GetEffA(const G4Material * material);
G4double gam(G4double x, G4double a) const; // @@@@ gamma function
void PrintMaterial(const G4Material * mat);
protected:
GVFlashHomoShowerTuning * thePar;
// Parameterisation parameters
G4double density, A, Z, X0, Ec, Rm;
// Medium related quantities
G4double NSpot;
private:
MyGamma* fGamma;
public: // with description
GVFlashShowerParameterisation();
virtual ~GVFlashShowerParameterisation();
virtual void ComputeRadialParameters(G4double y, G4double Tau) = 0;
virtual void GenerateLongitudinalProfile(G4double Energy) = 0;
virtual G4double IntegrateEneLongitudinal(G4double LongitudinalStep) = 0;
virtual G4double IntegrateNspLongitudinal(G4double LongitudinalStep) = 0;
virtual G4double ComputeTau(G4double LongitudinalPosition) = 0;
virtual G4double GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition) = 0;
virtual void ComputeLongitudinalParameters(G4double y) = 0;
virtual void GenerateEnergyProfile(G4double y) = 0;
virtual void GenerateNSpotProfile(G4double y) = 0;
virtual G4double GenerateExponential(G4double Energy) = 0;
virtual G4double GetAveR99() = 0;
virtual G4double GetAveR90() = 0;
virtual G4double GetAveTmx() = 0;
virtual G4double GetAveT99() = 0;
virtual G4double GetAveT90() = 0;
virtual G4double GetNspot() = 0;
virtual G4double GetX0() = 0;
virtual G4double GetEc() = 0;
virtual G4double GetRm() = 0;
G4double GeneratePhi();
G4double GetEffZ(const G4Material* material);
G4double GetEffA(const G4Material* material);
G4double gam(G4double x, G4double a) const; // @@@@ gamma function
void PrintMaterial(const G4Material* mat);
protected:
GVFlashHomoShowerTuning* thePar;
// Parameterisation parameters
G4double density, A, Z, X0, Ec, Rm;
// Medium related quantities
G4double NSpot;
private:
MyGamma* fGamma;
};
#endif
source/parameterisations/gflash/include/Gamma.hh
+8 -10
View File
@@ -45,25 +45,23 @@
class MyGamma
{
public:
MyGamma ();
MyGamma();
~MyGamma();
double Gamma(double z);
double Gamma(double a,double x);
double Gamma(double a, double x);
private:
double GamCf(double a, double x);
double GamSer(double a, double x);
double GamCf(double a,double x);
double GamSer(double a,double x);
// Abs
static short Abs(short d) { return (d > 0) ? d : -d; }
static int Abs(int d) { return (d > 0) ? d : -d; }
static short Abs(short d) { return (d > 0) ? d : -d; }
static int Abs(int d) { return (d > 0) ? d : -d; }
static long Abs(long d) { return (d > 0) ? d : -d; }
static float Abs(float d) { return (d > 0) ? d : -d; }
static double Abs(double d) { return (d > 0) ? d : -d; }
static double LnGamma(double z);
static double LnGamma(double z);
static double Log(double x) { return std::log(x); }
static double Exp(double x) { return std::exp(x); }
};
source/parameterisations/gflash/src/GFlashHitMaker.cc
+39 -43
View File
@@ -30,26 +30,26 @@
//
// ---------------- GFlashHitMaker ----------------
//
// Authors: E.Barberio & Joanna Weng
// Authors: E.Barberio & Joanna Weng
// ------------------------------------------------------------
#include "G4ios.hh"
#include "G4TransportationManager.hh"
#include "G4VSensitiveDetector.hh"
#include "G4TouchableHandle.hh"
#include "G4VGFlashSensitiveDetector.hh"
#include "GFlashHitMaker.hh"
#include "G4GFlashSpot.hh"
#include "G4Step.hh"
#include "G4StepPoint.hh"
#include "G4TouchableHandle.hh"
#include "G4TransportationManager.hh"
#include "G4VGFlashSensitiveDetector.hh"
#include "G4VSensitiveDetector.hh"
#include "G4ios.hh"
GFlashHitMaker::GFlashHitMaker()
{
fTouchableHandle = new G4TouchableHistory(); // talk to ?@@@
fpNavigator = new G4Navigator();
fNaviSetup = false;
fWorldWithSdName = "";
fTouchableHandle = new G4TouchableHistory(); // talk to ?@@@
fpNavigator = new G4Navigator();
fNaviSetup = false;
fWorldWithSdName = "";
fpSpotS = new G4Step();
fpSpotP = new G4StepPoint();
// N.B. Pre and Post step points are common.
@@ -66,52 +66,49 @@ GFlashHitMaker::~GFlashHitMaker()
delete fpSpotS;
}
void GFlashHitMaker::make(GFlashEnergySpot * aSpot, const G4FastTrack * aT)
void GFlashHitMaker::make(GFlashEnergySpot* aSpot, const G4FastTrack* aT)
{
// Locate the spot
if (!fNaviSetup)
{
// Choose the world volume that contains the sensitive detector based on its name (empty name for mass geometry)
if (!fNaviSetup) {
// Choose the world volume that contains the sensitive detector based on its name (empty name
// for mass geometry)
G4VPhysicalVolume* worldWithSD = nullptr;
if(fWorldWithSdName.empty()) {
worldWithSD = G4TransportationManager::GetTransportationManager()->GetNavigatorForTracking()->GetWorldVolume();
} else {
worldWithSD = G4TransportationManager::GetTransportationManager()->GetParallelWorld(fWorldWithSdName);
if (fWorldWithSdName.empty()) {
worldWithSD = G4TransportationManager::GetTransportationManager()
->GetNavigatorForTracking()
->GetWorldVolume();
}
else {
worldWithSD =
G4TransportationManager::GetTransportationManager()->GetParallelWorld(fWorldWithSdName);
}
fpNavigator->SetWorldVolume(worldWithSD);
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(),
fTouchableHandle(), false);
fpNavigator->LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(), fTouchableHandle(),
false);
fNaviSetup = true;
}
else
{
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(),
fTouchableHandle());
else {
fpNavigator->LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(), fTouchableHandle());
}
//--------------------------------------
// Produce Hits
// call sensitive part: taken/adapted from the stepping:
// Send G4Step information to Hit/Dig if the volume is sensitive
//--------------G4TouchableHistory----------------------------------------
G4VPhysicalVolume* pCurrentVolume = fTouchableHandle()->GetVolume();
G4VPhysicalVolume* pCurrentVolume = fTouchableHandle()->GetVolume();
G4VSensitiveDetector* pSensitive;
if( pCurrentVolume != 0 )
{
if (pCurrentVolume != 0) {
pSensitive = pCurrentVolume->GetLogicalVolume()->GetSensitiveDetector();
G4VGFlashSensitiveDetector * gflashSensitive =
dynamic_cast<G4VGFlashSensitiveDetector * > (pSensitive);
if( gflashSensitive )
{
G4VGFlashSensitiveDetector* gflashSensitive =
dynamic_cast<G4VGFlashSensitiveDetector*>(pSensitive);
if (gflashSensitive) {
// set spot information:
G4GFlashSpot theSpot(aSpot, aT, fTouchableHandle);
gflashSensitive->Hit(&theSpot);
}
else if( pSensitive )
{
else if (pSensitive) {
fpSpotS->SetTotalEnergyDeposit(aSpot->GetEnergy());
fpSpotS->SetTrack(const_cast<G4Track*>(aT->GetPrimaryTrack()));
fpSpotP->SetWeight(aT->GetPrimaryTrack()->GetWeight());
@@ -125,10 +122,9 @@ void GFlashHitMaker::make(GFlashEnergySpot * aSpot, const G4FastTrack * aT)
pSensitive->Hit(fpSpotS);
}
}
else
{
#ifdef GFLASH_DEBUG
G4cout << "GFlashHitMaker::Out of volume "<< G4endl;
#endif
else {
#ifdef GFLASH_DEBUG
G4cout << "GFlashHitMaker::Out of volume " << G4endl;
#endif
}
}
source/parameterisations/gflash/src/GFlashHomoShowerParameterisation.cc
+120 -119
View File
@@ -44,18 +44,26 @@
#include "G4Material.hh"
#include "G4MaterialTable.hh"
GFlashHomoShowerParameterisation::
GFlashHomoShowerParameterisation(G4Material * aMat,
GVFlashHomoShowerTuning * aPar)
GFlashHomoShowerParameterisation::GFlashHomoShowerParameterisation(G4Material* aMat,
GVFlashHomoShowerTuning* aPar)
: GVFlashShowerParameterisation(),
ConstantResolution(0.), NoiseResolution(0.), SamplingResolution(0.),
AveLogAlphah(0.), AveLogTmaxh(0.), SigmaLogAlphah(0.), SigmaLogTmaxh(0.),
Rhoh(0.), Alphah(0.), Tmaxh(0.), Betah(0.)
ConstantResolution(0.),
NoiseResolution(0.),
SamplingResolution(0.),
AveLogAlphah(0.),
AveLogTmaxh(0.),
SigmaLogAlphah(0.),
SigmaLogTmaxh(0.),
Rhoh(0.),
Alphah(0.),
Tmaxh(0.),
Betah(0.)
{
if(!aPar) {
{
if (!aPar) {
thePar = new GVFlashHomoShowerTuning;
} else {
}
else {
thePar = aPar;
}
@@ -64,91 +72,94 @@ GFlashHomoShowerParameterisation(G4Material * aMat,
/********************************************/
/* Homo Calorimeter */
/********************************************/
/********************************************/
// Longitudinal Coefficients for a homogenious calo
// shower max
//
ParAveT1 = thePar->ParAveT1(); // ln (ln y -0.812)
ParAveA1 = thePar->ParAveA1(); // ln a (0.81 + (0.458 + 2.26/Z)ln y)
ParAveA2 = thePar->ParAveA2();
ParAveA3 = thePar->ParAveA3();
ParAveT1 = thePar->ParAveT1(); // ln (ln y -0.812)
ParAveA1 = thePar->ParAveA1(); // ln a (0.81 + (0.458 + 2.26/Z)ln y)
ParAveA2 = thePar->ParAveA2();
ParAveA3 = thePar->ParAveA3();
// Variance of shower max
ParSigLogT1 = thePar->ParSigLogT1(); // Sigma T1 (-1.4 + 1.26 ln y)**-1
ParSigLogT1 = thePar->ParSigLogT1(); // Sigma T1 (-1.4 + 1.26 ln y)**-1
ParSigLogT2 = thePar->ParSigLogT2();
// variance of 'alpha'
//
ParSigLogA1 = thePar->ParSigLogA1(); // Sigma a (-0.58 + 0.86 ln y)**-1
ParSigLogA1 = thePar->ParSigLogA1(); // Sigma a (-0.58 + 0.86 ln y)**-1
ParSigLogA2 = thePar->ParSigLogA2();
// correlation alpha%T
//
ParRho1 = thePar->ParRho1(); // Rho = 0.705 -0.023 ln y
ParRho2 = thePar->ParRho2();
ParRho1 = thePar->ParRho1(); // Rho = 0.705 -0.023 ln y
ParRho2 = thePar->ParRho2();
// Radial Coefficients
// r_C (tau)= z_1 +z_2 tau
// r_t (tau)= k1 (std::exp (k3(tau -k2 ))+std::exp (k_4 (tau- k_2))))
//
ParRC1 = thePar->ParRC1(); // z_1 = 0.0251 + 0.00319 ln E
ParRC2 = thePar->ParRC2();
ParRC1 = thePar->ParRC1(); // z_1 = 0.0251 + 0.00319 ln E
ParRC2 = thePar->ParRC2();
ParRC3 = thePar->ParRC3(); // z_2 = 0.1162 + - 0.000381 Z
ParRC4 = thePar->ParRC4();
ParRC3 = thePar->ParRC3(); // z_2 = 0.1162 + - 0.000381 Z
ParRC4 = thePar->ParRC4();
ParWC1 = thePar->ParWC1();
ParWC2 = thePar->ParWC2();
ParWC3 = thePar->ParWC3();
ParWC4 = thePar->ParWC4();
ParWC5 = thePar->ParWC5();
ParWC5 = thePar->ParWC5();
ParWC6 = thePar->ParWC6();
ParRT1 = thePar->ParRT1();
ParRT2 = thePar->ParRT2();
ParRT3 = thePar->ParRT3();
ParRT4 = thePar->ParRT4();
ParRT4 = thePar->ParRT4();
ParRT5 = thePar->ParRT5();
ParRT6 = thePar->ParRT6();
// Coeff for fluctueted radial profiles for a uniform media
//
ParSpotT1 = thePar->ParSpotT1(); // T_spot = T_hom =(0.698 + 0.00212)
ParSpotT2 = thePar->ParSpotT2();
ParSpotT1 = thePar->ParSpotT1(); // T_spot = T_hom =(0.698 + 0.00212)
ParSpotT2 = thePar->ParSpotT2();
ParSpotA1 = thePar->ParSpotA1(); // a_spot= a_hom (0.639 + 0.00334)
ParSpotA2 = thePar->ParSpotA2();
ParSpotA1 = thePar->ParSpotA1(); // a_spot= a_hom (0.639 + 0.00334)
ParSpotA2 = thePar->ParSpotA2();
ParSpotN1 = thePar->ParSpotN1(); // N_Spot 93 * ln(Z) E ** 0.876
ParSpotN2 = thePar->ParSpotN2();
ParSpotN1 = thePar->ParSpotN1(); // N_Spot 93 * ln(Z) E ** 0.876
ParSpotN2 = thePar->ParSpotN2();
// Inits
NSpot = 0.00;
AlphaNSpot = 0.00;
TNSpot = 0.00;
BetaNSpot = 0.00;
NSpot = 0.00;
AlphaNSpot = 0.00;
TNSpot = 0.00;
BetaNSpot = 0.00;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
G4cout << "/********************************************/ " << G4endl;
G4cout << " - GFlashHomoShowerParameterisation::Constructor - " << G4endl;
G4cout << " - GFlashHomoShowerParameterisation::Constructor - " << G4endl;
G4cout << "/********************************************/ " << G4endl;
}
void GFlashHomoShowerParameterisation::SetMaterial(G4Material *mat)
void GFlashHomoShowerParameterisation::SetMaterial(G4Material* mat)
{
material= mat;
material = mat;
Z = GetEffZ(material);
A = GetEffA(material);
density = material->GetDensity()/(g/cm3);
X0 = material->GetRadlen();
Ec = 2.66 * std::pow((X0 * Z / A),1.1);
G4double Es = 21*MeV;
Rm = X0*Es/Ec;
// PrintMaterial();
density = material->GetDensity() / (g / cm3);
X0 = material->GetRadlen();
// O. I. Dovzhenkko and A. A. Pommanskii
Ec = 2.66 * std::pow((X0 * Z / A), 1.1);
// // Rossi appriximation
// Ec = 610.0 * MeV / (Z + 1.24);
const G4double Es = 21.2 * MeV;
Rm = X0 * Es / Ec;
// PrintMaterial();
}
GFlashHomoShowerParameterisation::~GFlashHomoShowerParameterisation()
@@ -156,59 +167,56 @@ GFlashHomoShowerParameterisation::~GFlashHomoShowerParameterisation()
delete thePar;
}
void GFlashHomoShowerParameterisation::
GenerateLongitudinalProfile(G4double Energy)
void GFlashHomoShowerParameterisation::GenerateLongitudinalProfile(G4double Energy)
{
if (material==0)
{
G4Exception("GFlashHomoShowerParameterisation::GenerateLongitudinalProfile()",
"InvalidSetup", FatalException, "No material initialized!");
if (material == 0) {
G4Exception("GFlashHomoShowerParameterisation::GenerateLongitudinalProfile()", "InvalidSetup",
FatalException, "No material initialized!");
}
G4double y = Energy/Ec;
ComputeLongitudinalParameters(y);
G4double y = Energy / Ec;
ComputeLongitudinalParameters(y);
GenerateEnergyProfile(y);
GenerateNSpotProfile(y);
}
void
GFlashHomoShowerParameterisation::ComputeLongitudinalParameters(G4double y)
void GFlashHomoShowerParameterisation::ComputeLongitudinalParameters(G4double y)
{
AveLogTmaxh = std::log(ParAveT1 + std::log(y));
//ok <ln T hom>
AveLogAlphah = std::log(ParAveA1 + (ParAveA2+ParAveA3/Z)*std::log(y));
//ok <ln alpha hom>
AveLogTmaxh = std::log(ParAveT1 + std::log(y));
// ok <ln T hom>
AveLogAlphah = std::log(ParAveA1 + (ParAveA2 + ParAveA3 / Z) * std::log(y));
// ok <ln alpha hom>
SigmaLogTmaxh = 1.00/( ParSigLogT1 + ParSigLogT2*std::log(y)) ;
//ok sigma (ln T hom)
SigmaLogAlphah = 1.00/( ParSigLogA1 + ParSigLogA2*std::log(y));
//ok sigma (ln alpha hom)
Rhoh = ParRho1+ParRho2*std::log(y); //ok
SigmaLogTmaxh = 1.00 / (ParSigLogT1 + ParSigLogT2 * std::log(y));
// ok sigma (ln T hom)
SigmaLogAlphah = 1.00 / (ParSigLogA1 + ParSigLogA2 * std::log(y));
// ok sigma (ln alpha hom)
Rhoh = ParRho1 + ParRho2 * std::log(y); // ok
}
void GFlashHomoShowerParameterisation::GenerateEnergyProfile(G4double /* y */)
{
G4double Correlation1h = std::sqrt((1+Rhoh)/2);
G4double Correlation2h = std::sqrt((1-Rhoh)/2);
{
G4double Correlation1h = std::sqrt((1 + Rhoh) / 2);
G4double Correlation2h = std::sqrt((1 - Rhoh) / 2);
G4double Random1 = G4RandGauss::shoot();
G4double Random2 = G4RandGauss::shoot();
// Parameters for Enenrgy Profile including correaltion and sigmas
Tmaxh = std::exp( AveLogTmaxh + SigmaLogTmaxh *
(Correlation1h*Random1 + Correlation2h*Random2) );
Alphah = std::exp( AveLogAlphah + SigmaLogAlphah *
(Correlation1h*Random1 - Correlation2h*Random2) );
Betah = (Alphah-1.00)/Tmaxh;
// Parameters for Enenrgy Profile including correaltion and sigmas
Tmaxh =
std::exp(AveLogTmaxh + SigmaLogTmaxh * (Correlation1h * Random1 + Correlation2h * Random2));
Alphah =
std::exp(AveLogAlphah + SigmaLogAlphah * (Correlation1h * Random1 - Correlation2h * Random2));
Betah = (Alphah - 1.00) / Tmaxh;
}
void GFlashHomoShowerParameterisation::GenerateNSpotProfile(const G4double y)
{
TNSpot = Tmaxh * (ParSpotT1+ParSpotT2*Z); // ok
AlphaNSpot = Alphah * (ParSpotA1+ParSpotA2*Z);
BetaNSpot = (AlphaNSpot-1.00)/TNSpot; // ok
NSpot = ParSpotN1 * std::log(Z)*std::pow((y*Ec)/GeV,ParSpotN2 ); // ok
TNSpot = Tmaxh * (ParSpotT1 + ParSpotT2 * Z); // ok
AlphaNSpot = Alphah * (ParSpotA1 + ParSpotA2 * Z);
BetaNSpot = (AlphaNSpot - 1.00) / TNSpot; // ok
NSpot = ParSpotN1 * std::log(Z) * std::pow((y * Ec) / GeV, ParSpotN2); // ok
}
G4double GFlashHomoShowerParameterisation::
@@ -222,75 +230,68 @@ IntegrateEneLongitudinal(G4double LongitudinalStep)
return DEne;
}
G4double GFlashHomoShowerParameterisation::
IntegrateNspLongitudinal(G4double LongitudinalStep)
G4double GFlashHomoShowerParameterisation::IntegrateNspLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1 = BetaNSpot*LongitudinalStepInX0;
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1 = BetaNSpot * LongitudinalStepInX0;
G4float x2 = AlphaNSpot;
G4float x3 = gam(x1,x2);
G4float x3 = gam(x1, x2);
G4double DNsp = x3;
return DNsp;
}
G4double GFlashHomoShowerParameterisation::
GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition)
G4double GFlashHomoShowerParameterisation::GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition)
{
if(ispot < 1)
{
if (ispot < 1) {
// Determine lateral parameters in the middle of the step.
// They depend on energy & position along step.
//
G4double Tau = ComputeTau(LongitudinalPosition);
ComputeRadialParameters(Energy,Tau);
ComputeRadialParameters(Energy, Tau);
}
G4double Radius;
G4double Random1 = G4UniformRand();
G4double Random2 = G4UniformRand();
G4double Random2 = G4UniformRand();
if(Random1 <WeightCore) //WeightCore = p < w_i
if (Random1 < WeightCore) // WeightCore = p < w_i
{
Radius = Rm * RadiusCore * std::sqrt( Random2/(1. - Random2) );
Radius = Rm * RadiusCore * std::sqrt(Random2 / (1. - Random2));
}
else
{
Radius = Rm * RadiusTail * std::sqrt( Random2/(1. - Random2) );
}
Radius = std::min(Radius,DBL_MAX);
else {
Radius = Rm * RadiusTail * std::sqrt(Random2 / (1. - Random2));
}
Radius = std::min(Radius, DBL_MAX);
return Radius;
}
G4double GFlashHomoShowerParameterisation::
ComputeTau(G4double LongitudinalPosition)
G4double GFlashHomoShowerParameterisation::ComputeTau(G4double LongitudinalPosition)
{
G4double tau = LongitudinalPosition / Tmaxh / X0 //<t> = T* a /(a - 1)
* (Alphah-1.00) /Alphah *
std::exp(AveLogAlphah)/(std::exp(AveLogAlphah)-1.); //ok
G4double tau = LongitudinalPosition / Tmaxh / X0 //<t> = T* a /(a - 1)
* (Alphah - 1.00) / Alphah * std::exp(AveLogAlphah)
/ (std::exp(AveLogAlphah) - 1.); // ok
return tau;
}
void GFlashHomoShowerParameterisation::
ComputeRadialParameters(G4double Energy, G4double Tau)
void GFlashHomoShowerParameterisation::ComputeRadialParameters(G4double Energy, G4double Tau)
{
G4double z1 = ParRC1 + ParRC2* std::log(Energy/GeV) ; //ok
G4double z2 = ParRC3+ParRC4*Z ; //ok
RadiusCore = z1 + z2 * Tau ; //ok
G4double z1 = ParRC1 + ParRC2 * std::log(Energy / GeV); // ok
G4double z2 = ParRC3 + ParRC4 * Z; // ok
RadiusCore = z1 + z2 * Tau; // ok
G4double p1 = ParWC1+ParWC2*Z; //ok
G4double p2 = ParWC3+ParWC4*Z; //ok
G4double p3 = ParWC5+ParWC6*std::log(Energy/GeV); //ok
G4double p1 = ParWC1 + ParWC2 * Z; // ok
G4double p2 = ParWC3 + ParWC4 * Z; // ok
G4double p3 = ParWC5 + ParWC6 * std::log(Energy / GeV); // ok
WeightCore = p1 * std::exp( (p2-Tau)/p3 - std::exp( (p2-Tau) /p3) ); //ok
WeightCore = p1 * std::exp((p2 - Tau) / p3 - std::exp((p2 - Tau) / p3)); // ok
G4double k1 = ParRT1+ParRT2*Z; // ok
G4double k2 = ParRT3; // ok
G4double k3 = ParRT4; // ok
G4double k4 = ParRT5+ParRT6* std::log(Energy/GeV); // ok
G4double k1 = ParRT1 + ParRT2 * Z; // ok
G4double k2 = ParRT3; // ok
G4double k3 = ParRT4; // ok
G4double k4 = ParRT5 + ParRT6 * std::log(Energy / GeV); // ok
RadiusTail = k1*(std::exp(k3*(Tau-k2)) +
std::exp(k4*(Tau-k2)) ); //ok
RadiusTail = k1 * (std::exp(k3 * (Tau - k2)) + std::exp(k4 * (Tau - k2))); // ok
}
G4double GFlashHomoShowerParameterisation::
source/parameterisations/gflash/src/GFlashParticleBounds.cc
+42 -46
View File
@@ -39,72 +39,68 @@
#include "G4Electron.hh"
#include "G4Positron.hh"
GFlashParticleBounds::GFlashParticleBounds()
{
{
// e+e- defaults
EMinEneToParametrise = 0.10*GeV;
EMaxEneToParametrise = 10000.00*GeV;
EEneToKill = 0.1*GeV; // Energie at which electrons are killed
EMinEneToParametrise = 0.10 * GeV;
EMaxEneToParametrise = 10000.00 * GeV;
EEneToKill = 0.1 * GeV; // Energie at which electrons are killed
}
GFlashParticleBounds::~GFlashParticleBounds()
{
}
void GFlashParticleBounds::
SetMinEneToParametrise(G4ParticleDefinition &particleType, G4double enemin)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMinEneToParametrise = enemin;
}
void GFlashParticleBounds::
SetMaxEneToParametrise(G4ParticleDefinition &particleType, G4double enemax)
void GFlashParticleBounds::SetMinEneToParametrise(G4ParticleDefinition& particleType,
G4double enemin)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMaxEneToParametrise = enemax;
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
EMinEneToParametrise = enemin;
}
void GFlashParticleBounds::
SetEneToKill(G4ParticleDefinition &particleType, G4double enekill)
void GFlashParticleBounds::SetMaxEneToParametrise(G4ParticleDefinition& particleType,
G4double enemax)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EEneToKill = enekill;
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
EMaxEneToParametrise = enemax;
}
G4double GFlashParticleBounds::
GetMinEneToParametrise(G4ParticleDefinition &particleType)
{
void GFlashParticleBounds::SetEneToKill(G4ParticleDefinition& particleType, G4double enekill)
{
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
EEneToKill = enekill;
}
G4double GFlashParticleBounds::GetMinEneToParametrise(G4ParticleDefinition& particleType)
{
G4double result = DBL_MAX;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
{
result = EMinEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::
GetMaxEneToParametrise(G4ParticleDefinition &particleType)
{
G4double result = 0;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMaxEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::
GetEneToKill(G4ParticleDefinition & particleType)
G4double GFlashParticleBounds::GetMaxEneToParametrise(G4ParticleDefinition& particleType)
{
if (&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition())
return EEneToKill;
else return (-DBL_MAX);
G4double result = 0;
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
{
result = EMaxEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::GetEneToKill(G4ParticleDefinition& particleType)
{
if (&particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition())
return EEneToKill;
else
return (-DBL_MAX);
}
source/parameterisations/gflash/src/GFlashSamplingShowerParameterisation.cc
+238 -214
View File
@@ -43,110 +43,136 @@
#include "G4Material.hh"
#include "G4MaterialTable.hh"
GFlashSamplingShowerParameterisation::
GFlashSamplingShowerParameterisation(G4Material* aMat1, G4Material* aMat2,
G4double dd1, G4double dd2,
GFlashSamplingShowerTuning* aPar)
GFlashSamplingShowerParameterisation::GFlashSamplingShowerParameterisation(
G4Material* aMat1, G4Material* aMat2, G4double dd1, G4double dd2,
GFlashSamplingShowerTuning* aPar)
: GVFlashShowerParameterisation(),
ParAveT2(0.), ParSigLogT1(0.), ParSigLogT2(0.),
ParSigLogA1(0.), ParSigLogA2(0.), ParRho1(0.), ParRho2(0.), ParsAveA2(0.),
AveLogAlphah(0.), AveLogTmaxh(0.), SigmaLogAlphah(0.), SigmaLogTmaxh(0.),
Rhoh(0.), Alphah(0.), Tmaxh(0.), Betah(0.), AveLogAlpha(0.), AveLogTmax(0.),
SigmaLogAlpha(0.), SigmaLogTmax(0.), Rho(0.), Alpha(0.), Tmax(0.), Beta(0.)
{
if(!aPar) {
ParAveT2(0.),
ParSigLogT1(0.),
ParSigLogT2(0.),
ParSigLogA1(0.),
ParSigLogA2(0.),
ParRho1(0.),
ParRho2(0.),
ParsAveA2(0.),
AveLogAlphah(0.),
AveLogTmaxh(0.),
SigmaLogAlphah(0.),
SigmaLogTmaxh(0.),
Rhoh(0.),
Alphah(0.),
Tmaxh(0.),
Betah(0.),
AveLogAlpha(0.),
AveLogTmax(0.),
SigmaLogAlpha(0.),
SigmaLogTmax(0.),
Rho(0.),
Alpha(0.),
Tmax(0.),
Beta(0.)
{
if (!aPar) {
thePar = new GFlashSamplingShowerTuning;
} else {
}
else {
thePar = aPar;
}
SetMaterial(aMat1,aMat2 );
d1=dd1;
d2=dd2;
SetMaterial(aMat1, aMat2);
d1 = dd1;
d2 = dd2;
// Longitudinal Coefficients for a homogenious calo
// shower max
ParAveT1 = thePar->ParAveT1(); // ln (ln y -0.812)
ParAveA1 = thePar->ParAveA1(); // ln a (0.81 + (0.458 + 2.26/Z)ln y)
ParAveA2 = thePar->ParAveA2();
ParAveA3 = thePar->ParAveA3();
ParAveT1 = thePar->ParAveT1(); // ln (ln y -0.812)
ParAveA1 = thePar->ParAveA1(); // ln a (0.81 + (0.458 + 2.26/Z)ln y)
ParAveA2 = thePar->ParAveA2();
ParAveA3 = thePar->ParAveA3();
// Variance of shower max sampling
ParSigLogT1 = thePar->ParsSigLogT1(); // Sigma T1 (-1.4 + 1.26 ln y)**-1 --> bug : these two lines were missing,
ParSigLogT1 =
thePar
->ParsSigLogT1(); // Sigma T1 (-1.4 + 1.26 ln y)**-1 --> bug : these two lines were missing,
ParSigLogT2 = thePar->ParsSigLogT2(); // leaving ParSigLogT1, ParSigLogT2 as 0.0
// variance of 'alpha'
ParSigLogA1 = thePar->ParSigLogA1(); // Sigma a (-0.58 + 0.86 ln y)**-1 --> bug : these two lines were missing
ParSigLogA2 = thePar->ParSigLogA2(); // leaving ParSigLogA1 ParSigLogAé as 0.0
ParSigLogA1 =
thePar
->ParSigLogA1(); // Sigma a (-0.58 + 0.86 ln y)**-1 --> bug : these two lines were missing
ParSigLogA2 = thePar->ParSigLogA2(); // leaving ParSigLogA1 ParSigLogAé as 0.0
// correlation alpha%T
ParRho1 = thePar->ParRho1(); // Rho = 0.705 -0.023 ln y --> bug : these two lines were missing,
ParRho2 = thePar->ParRho2(); // leaving ParRho1 and ParRho2 being 0.0
ParRho1 = thePar->ParRho1(); // Rho = 0.705 -0.023 ln y --> bug : these two lines were missing,
ParRho2 = thePar->ParRho2(); // leaving ParRho1 and ParRho2 being 0.0
// Sampling
ParsAveT1 = thePar->ParsAveT1(); // T_sam = log(exp( log T_hom) + t1*Fs-1 + t2*(1-ehat));
ParsAveT2 = thePar->ParsAveT2();
ParsAveA1 = thePar->ParsAveA1();
ParsAveT1 = thePar->ParsAveT1(); // T_sam = log(exp( log T_hom) + t1*Fs-1 + t2*(1-ehat));
ParsAveT2 = thePar->ParsAveT2();
ParsAveA1 = thePar->ParsAveA1();
// Variance of shower max sampling
ParsSigLogT1 = thePar->ParsSigLogT1(); // Sigma T1 (-2.5 + 1.25 ln y)**-1 --> bug ParSigLogT1() was called instead of ParsSigLogT1(); Same for T2.
ParsSigLogT1 = thePar->ParsSigLogT1(); // Sigma T1 (-2.5 + 1.25 ln y)**-1 --> bug ParSigLogT1()
// was called instead of ParsSigLogT1(); Same for T2.
ParsSigLogT2 = thePar->ParsSigLogT2();
// variance of 'alpha'
ParsSigLogA1 = thePar->ParsSigLogA1(); // Sigma a (-0.82 + 0.79 ln y)**-1 --> bug ParSigLogA1() was called instead of ParsSigLogA1(); Same for A2
ParsSigLogA1 = thePar->ParsSigLogA1(); // Sigma a (-0.82 + 0.79 ln y)**-1 --> bug ParSigLogA1()
// was called instead of ParsSigLogA1(); Same for A2
ParsSigLogA2 = thePar->ParsSigLogA2();
// correlation alpha%T
ParsRho1 = thePar->ParsRho1(); // Rho = 0.784 -0.023 ln y --> bug was using ParRho1() and ParRho2()
ParsRho2 = thePar->ParsRho2();
ParsRho1 =
thePar->ParsRho1(); // Rho = 0.784 -0.023 ln y --> bug was using ParRho1() and ParRho2()
ParsRho2 = thePar->ParsRho2();
// Radial Coefficients
// r_C (tau)= z_1 +z_2 tau
// r_t (tau)= k1 (std::exp (k3(tau -k2 ))+std::exp (k_4 (tau- k_2))))
ParRC1 = thePar->ParRC1(); // z_1 = 0.0251 + 0.00319 ln E
ParRC2 = thePar->ParRC2();
ParRC3 = thePar->ParRC3(); // z_2 = 0.1162 + - 0.000381 Z
ParRC4 = thePar->ParRC4();
ParRC1 = thePar->ParRC1(); // z_1 = 0.0251 + 0.00319 ln E
ParRC2 = thePar->ParRC2();
ParRC3 = thePar->ParRC3(); // z_2 = 0.1162 + - 0.000381 Z
ParRC4 = thePar->ParRC4();
ParWC1 = thePar->ParWC1();
ParWC2 = thePar->ParWC2();
ParWC3 = thePar->ParWC3();
ParWC4 = thePar->ParWC4();
ParWC5 = thePar->ParWC5();
ParWC5 = thePar->ParWC5();
ParWC6 = thePar->ParWC6();
ParRT1 = thePar->ParRT1();
ParRT2 = thePar->ParRT2();
ParRT3 = thePar->ParRT3();
ParRT4 = thePar->ParRT4();
ParRT4 = thePar->ParRT4();
ParRT5 = thePar->ParRT5();
ParRT6 = thePar->ParRT6();
//additional sampling parameter
ParsRC1= thePar->ParsRC1();
ParsRC2= thePar->ParsRC2();
ParsWC1= thePar->ParsWC1();
ParsWC2= thePar->ParsWC2();
ParsRT1= thePar->ParsRT1();
ParsRT2= thePar->ParsRT2();
// additional sampling parameter
ParsRC1 = thePar->ParsRC1();
ParsRC2 = thePar->ParsRC2();
ParsWC1 = thePar->ParsWC1();
ParsWC2 = thePar->ParsWC2();
ParsRT1 = thePar->ParsRT1();
ParsRT2 = thePar->ParsRT2();
// Coeff for fluctuedted radial profiles for a sampling media
ParsSpotT1 = thePar->ParSpotT1(); // T_spot = T_hom =(0.698 + 0.00212)
ParsSpotT2 = thePar->ParSpotT2();
ParsSpotA1 = thePar->ParSpotA1(); // a_spot= a_hom (0.639 + 0.00334)
ParsSpotA2 = thePar->ParSpotA2();
ParsSpotN1 = thePar->ParSpotN1(); // N_Spot 93 * ln(Z) E ** 0.876
ParsSpotN2 = thePar->ParSpotN2();
SamplingResolution = thePar->SamplingResolution();
ConstantResolution = thePar->ConstantResolution();
NoiseResolution = thePar->NoiseResolution();
ParsSpotT1 = thePar->ParSpotT1(); // T_spot = T_hom =(0.698 + 0.00212)
ParsSpotT2 = thePar->ParSpotT2();
ParsSpotA1 = thePar->ParSpotA1(); // a_spot= a_hom (0.639 + 0.00334)
ParsSpotA2 = thePar->ParSpotA2();
ParsSpotN1 = thePar->ParSpotN1(); // N_Spot 93 * ln(Z) E ** 0.876
ParsSpotN2 = thePar->ParSpotN2();
SamplingResolution = thePar->SamplingResolution();
ConstantResolution = thePar->ConstantResolution();
NoiseResolution = thePar->NoiseResolution();
// Inits
NSpot = 0.00;
AlphaNSpot = 0.00;
TNSpot = 0.00;
BetaNSpot = 0.00;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
NSpot = 0.00;
AlphaNSpot = 0.00;
TNSpot = 0.00;
BetaNSpot = 0.00;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
ComputeZAX0EFFetc();
G4cout << "/********************************************/ " << G4endl;
G4cout << " - GFlashSamplingShowerParameterisation::Constructor - " << G4endl;
G4cout << "/********************************************/ " << G4endl;
G4cout << "/********************************************/ " << G4endl;
}
// ------------------------------------------------------------
@@ -158,26 +184,27 @@ GFlashSamplingShowerParameterisation::~GFlashSamplingShowerParameterisation()
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::
SetMaterial(G4Material *mat1, G4Material *mat2)
void GFlashSamplingShowerParameterisation::SetMaterial(G4Material* mat1, G4Material* mat2)
{
G4double Es = 21*MeV;
material1= mat1;
const G4double Es = 21.2 * MeV;
material1 = mat1;
Z1 = GetEffZ(material1);
A1 = GetEffA(material1);
density1 = material1->GetDensity();
X01 = material1->GetRadlen();
Ec1 = 2.66 * std::pow((X01 * Z1 / A1),1.1);
Rm1 = X01*Es/Ec1;
X01 = material1->GetRadlen();
Ec1 = 2.66 * std::pow((X01 * Z1 / A1), 1.1);
// Ec1 = 610.0 * MeV / (Z1 + 1.24);
Rm1 = X01 * Es / Ec1;
material2= mat2;
material2 = mat2;
Z2 = GetEffZ(material2);
A2 = GetEffA(material2);
density2 = material2->GetDensity();
X02 = material2->GetRadlen();
Ec2 = 2.66 * std::pow((X02 * Z2 / A2),1.1);
Rm2 = X02*Es/Ec2;
// PrintMaterial();
X02 = material2->GetRadlen();
Ec2 = 2.66 * std::pow((X02 * Z2 / A2), 1.1);
// Ec2 = 610.0 * MeV / (Z2 + 1.24);
Rm2 = X02 * Es / Ec2;
// PrintMaterial();
}
// ------------------------------------------------------------
@@ -187,154 +214,158 @@ void GFlashSamplingShowerParameterisation::ComputeZAX0EFFetc()
G4cout << "/************ ComputeZAX0EFFetc ************/" << G4endl;
G4cout << " - GFlashSamplingShowerParameterisation::Material - " << G4endl;
G4double Es = 21*MeV; //constant
const G4double Es = 21.2 * MeV;
// material and geometry parameters for a sampling calorimeter
G4double denominator = (d1*density1 + d2*density2);
G4double W1 = (d1*density1) / denominator;
G4double W2 = (d2*density2) / denominator;
Zeff = ( W1*Z1 ) + ( W2*Z2 ); //X0*Es/Ec;
Aeff = ( W1*A1 ) + ( W2*A2 );
Rhoeff = ( ( d1*density1 ) + ( d2*density2 ) ) / ( d1 + d2 ); // --> was G4double ( d2 + d1 );
X0eff = (W1 * Rhoeff) / (X01 * density1) + (W2 * Rhoeff) / (X02 * density2 );
X0eff = 1./ X0eff;
Rmeff = 1./ ( ( ((W1*Ec1)/X01) + ((W2*Ec2)/X02) ) / Es ) ;
Eceff = X0eff * ( (W1*Ec1)/X01 + (W2*Ec2)/X02 );
Fs = X0eff/(d1+d2);// --> was G4double ((d1/mm )+(d2/mm) ); Can't understand if dividing by mm makes sense... looks weird.
ehat = ( 1. / ( 1 + 0.007*(Z1- Z2) ) );
G4double denominator = (d1 * density1 + d2 * density2);
G4double W1 = (d1 * density1) / denominator;
G4double W2 = (d2 * density2) / denominator;
Zeff = (W1 * Z1) + (W2 * Z2); // X0*Es/Ec;
Aeff = (W1 * A1) + (W2 * A2);
Rhoeff = ((d1 * density1) + (d2 * density2)) / (d1 + d2); // --> was G4double ( d2 + d1 );
X0eff = (W1 * Rhoeff) / (X01 * density1) + (W2 * Rhoeff) / (X02 * density2);
X0eff = 1. / X0eff;
Rmeff = 1. / ((((W1 * Ec1) / X01) + ((W2 * Ec2) / X02)) / Es);
Eceff = X0eff * ((W1 * Ec1) / X01 + (W2 * Ec2) / X02);
Fs = X0eff / (d1 + d2); // --> was G4double ((d1/mm )+(d2/mm) ); Can't understand if dividing by
// mm makes sense... looks weird.
ehat = (1. / (1 + 0.007 * (Z1 - Z2)));
G4cout << "W1= " << W1 << G4endl;
G4cout << "W2= " << W2 << G4endl;
G4cout << "effective quantities Zeff = "<<Zeff<< G4endl;
G4cout << "effective quantities Aeff = "<<Aeff<< G4endl;
G4cout << "effective quantities Rhoeff = "<<Rhoeff/g *cm3<<" g/cm3" << G4endl;
G4cout << "effective quantities X0eff = "<<X0eff/cm <<" cm" << G4endl;
G4cout << "effective quantities Zeff = " << Zeff << G4endl;
G4cout << "effective quantities Aeff = " << Aeff << G4endl;
G4cout << "effective quantities Rhoeff = " << Rhoeff / g * cm3 << " g/cm3" << G4endl;
G4cout << "effective quantities X0eff = " << X0eff / cm << " cm" << G4endl;
X0eff = X0eff * Rhoeff;
G4cout << "effective quantities X0eff = "<<X0eff/g*cm2 <<" g/cm2" << G4endl;
X0eff = X0eff /Rhoeff;
G4cout << "effective quantities RMeff = "<<Rmeff/cm<<" cm" << G4endl;
Rmeff = Rmeff* Rhoeff;
G4cout << "effective quantities RMeff = "<<Rmeff/g *cm2<<" g/cm2" << G4endl;
Rmeff = Rmeff/ Rhoeff;
G4cout << "effective quantities Eceff = "<<Eceff/MeV<< " MeV"<< G4endl;
G4cout << "effective quantities Fs = "<<Fs<<G4endl;
G4cout << "effective quantities ehat = "<<ehat<<G4endl;
G4cout << "/********************************************/ " <<G4endl;
G4cout << "effective quantities X0eff = " << X0eff / g * cm2 << " g/cm2" << G4endl;
X0eff = X0eff / Rhoeff;
G4cout << "effective quantities RMeff = " << Rmeff / cm << " cm" << G4endl;
Rmeff = Rmeff * Rhoeff;
G4cout << "effective quantities RMeff = " << Rmeff / g * cm2 << " g/cm2" << G4endl;
Rmeff = Rmeff / Rhoeff;
G4cout << "effective quantities Eceff = " << Eceff / MeV << " MeV" << G4endl;
G4cout << "effective quantities Fs = " << Fs << G4endl;
G4cout << "effective quantities ehat = " << ehat << G4endl;
G4cout << "/********************************************/ " << G4endl;
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::
GenerateLongitudinalProfile(G4double Energy)
void GFlashSamplingShowerParameterisation::GenerateLongitudinalProfile(G4double Energy)
{
if ((material1==0) || (material2 ==0))
{
if ((material1 == 0) || (material2 == 0)) {
G4Exception("GFlashSamplingShowerParameterisation::GenerateLongitudinalProfile()",
"InvalidSetup", FatalException, "No material initialized!");
}
G4double y = Energy/Eceff;
ComputeLongitudinalParameters(y);
}
G4double y = Energy / Eceff;
ComputeLongitudinalParameters(y);
GenerateEnergyProfile(y);
GenerateNSpotProfile(y);
}
// ------------------------------------------------------------
void
GFlashSamplingShowerParameterisation::ComputeLongitudinalParameters(G4double y)
void GFlashSamplingShowerParameterisation::ComputeLongitudinalParameters(G4double y)
{
AveLogTmaxh = std::log( std::max( ParAveT1 + std::log(y), 0.1 ) ); // ok
AveLogAlphah = std::log( std::max( ParAveA1 + (ParAveA2+ParAveA3/Zeff)*std::log(y), 0.1 ) ); // ok
AveLogTmaxh = std::log(std::max(ParAveT1 + std::log(y), 0.1)); // ok
AveLogAlphah =
std::log(std::max(ParAveA1 + (ParAveA2 + ParAveA3 / Zeff) * std::log(y), 0.1)); // ok
// hom
SigmaLogTmaxh = std::min( 0.5, 1.00/( ParSigLogT1 + ParSigLogT2*std::log(y) ) ); // ok
SigmaLogAlphah = std::min( 0.5, 1.00/( ParSigLogA1 + ParSigLogA2*std::log(y) ) ); // ok
Rhoh = ParRho1 + ParRho2*std::log(y); //ok
// if sampling
AveLogTmax = std::max( 0.1, std::log(std::exp(AveLogTmaxh) + ParsAveT1/Fs + ParsAveT2*(1-ehat)) ); // ok
AveLogAlpha = std::max( 0.1, std::log(std::exp(AveLogAlphah) + ParsAveA1/Fs) ); // ok
SigmaLogTmaxh = std::min(0.5, 1.00 / (ParSigLogT1 + ParSigLogT2 * std::log(y))); // ok
SigmaLogAlphah = std::min(0.5, 1.00 / (ParSigLogA1 + ParSigLogA2 * std::log(y))); // ok
Rhoh = ParRho1 + ParRho2 * std::log(y); // ok
// if sampling
AveLogTmax =
std::max(0.1, std::log(std::exp(AveLogTmaxh) + ParsAveT1 / Fs + ParsAveT2 * (1 - ehat))); // ok
AveLogAlpha = std::max(0.1, std::log(std::exp(AveLogAlphah) + ParsAveA1 / Fs)); // ok
//
SigmaLogTmax = std::min( 0.5, 1.00 / (ParsSigLogT1 + ParsSigLogT2*std::log(y)) ); // ok
SigmaLogAlpha = std::min( 0.5, 1.00 / (ParsSigLogA1 + ParsSigLogA2*std::log(y)) ); // ok
Rho = ParsRho1 + ParsRho2*std::log(y); // ok
SigmaLogTmax = std::min(0.5, 1.00 / (ParsSigLogT1 + ParsSigLogT2 * std::log(y))); // ok
SigmaLogAlpha = std::min(0.5, 1.00 / (ParsSigLogA1 + ParsSigLogA2 * std::log(y))); // ok
Rho = ParsRho1 + ParsRho2 * std::log(y); // ok
if (0) {
G4cout << " y = " << y << G4endl;
G4cout << " std::log(std::exp(AveLogTmaxh) + ParsAveT1/Fs + ParsAveT2*(1-ehat)) = "
<< " std::log(" << std::exp(AveLogTmaxh) << " + " << ParsAveT1/Fs << " + " << ParsAveT2*(1-ehat) << ") = "
<< " std::log(" << std::exp(AveLogTmaxh) << " + " << ParsAveT1 << "/" << Fs << " + " << ParsAveT2 << "*" << (1-ehat) << ") = "
<< " std::log(" << std::exp(AveLogTmaxh) + ParsAveT1/Fs + ParsAveT2*(1-ehat) << ")" << G4endl;
G4cout << " AveLogTmaxh " << AveLogTmaxh << G4endl;
G4cout << " AveLogAlphah " << AveLogAlphah << G4endl;
G4cout << " SigmaLogTmaxh " << SigmaLogTmaxh << G4endl;
G4cout << " 1.00/( ParSigLogT1 + ParSigLogT2*std::log(y) ) = " << 1.00 << "/" << ( ParSigLogT1 + ParSigLogT2*std::log(y) ) << " = "
<< 1.00 << "/" << "(" << ParSigLogT1 << " + " << ParSigLogT2*std::log(y) << " ) = "
<< 1.00 << "/" << "(" << ParSigLogT1 << " + " << ParSigLogT2 << "*" << std::log(y) << " ) "
<< G4endl;
G4cout << " SigmaLogAlphah " << SigmaLogAlphah << G4endl;
G4cout << " Rhoh " << Rhoh << G4endl;
G4cout << " AveLogTmax " << AveLogTmax << G4endl;
G4cout << " AveLogAlpha " << AveLogAlpha << G4endl;
G4cout << " SigmaLogTmax " << SigmaLogTmax << G4endl;
G4cout << " SigmaLogAlpha " << SigmaLogAlpha << G4endl;
G4cout << " Rho " << Rho << G4endl;
<< " std::log(" << std::exp(AveLogTmaxh) << " + " << ParsAveT1 / Fs << " + "
<< ParsAveT2 * (1 - ehat) << ") = "
<< " std::log(" << std::exp(AveLogTmaxh) << " + " << ParsAveT1 << "/" << Fs << " + "
<< ParsAveT2 << "*" << (1 - ehat) << ") = "
<< " std::log(" << std::exp(AveLogTmaxh) + ParsAveT1 / Fs + ParsAveT2 * (1 - ehat) << ")"
<< G4endl;
G4cout << " AveLogTmaxh " << AveLogTmaxh << G4endl;
G4cout << " AveLogAlphah " << AveLogAlphah << G4endl;
G4cout << " SigmaLogTmaxh " << SigmaLogTmaxh << G4endl;
G4cout << " 1.00/( ParSigLogT1 + ParSigLogT2*std::log(y) ) = " << 1.00 << "/"
<< (ParSigLogT1 + ParSigLogT2 * std::log(y)) << " = " << 1.00 << "/" << "("
<< ParSigLogT1 << " + " << ParSigLogT2 * std::log(y) << " ) = " << 1.00 << "/" << "("
<< ParSigLogT1 << " + " << ParSigLogT2 << "*" << std::log(y) << " ) " << G4endl;
G4cout << " SigmaLogAlphah " << SigmaLogAlphah << G4endl;
G4cout << " Rhoh " << Rhoh << G4endl;
G4cout << " AveLogTmax " << AveLogTmax << G4endl;
G4cout << " AveLogAlpha " << AveLogAlpha << G4endl;
G4cout << " SigmaLogTmax " << SigmaLogTmax << G4endl;
G4cout << " SigmaLogAlpha " << SigmaLogAlpha << G4endl;
G4cout << " Rho " << Rho << G4endl;
}
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::GenerateEnergyProfile(G4double /* y */)
{
G4double Correlation1 = std::sqrt( (1+Rho )/2 );
G4double Correlation2 = std::sqrt( (1-Rho )/2 );
G4double Correlation1h = std::sqrt( (1+Rhoh)/2 );
G4double Correlation2h = std::sqrt( (1-Rhoh)/2 );
{
G4double Correlation1 = std::sqrt((1 + Rho) / 2);
G4double Correlation2 = std::sqrt((1 - Rho) / 2);
G4double Correlation1h = std::sqrt((1 + Rhoh) / 2);
G4double Correlation2h = std::sqrt((1 - Rhoh) / 2);
G4double Random1 = G4RandGauss::shoot();
G4double Random2 = G4RandGauss::shoot();
Tmax = std::max( 1., std::exp( AveLogTmax + SigmaLogTmax * (Correlation1*Random1 + Correlation2*Random2) ) );
Alpha = std::max( 1.1, std::exp( AveLogAlpha + SigmaLogAlpha * (Correlation1*Random1 - Correlation2*Random2) ) );
Beta = (Alpha-1.00)/Tmax;
//Parameters for Enenrgy Profile including correaltion and sigmas
Tmaxh = std::exp( AveLogTmaxh + SigmaLogTmaxh *
(Correlation1h*Random1 + Correlation2h*Random2) );
Alphah = std::exp( AveLogAlphah + SigmaLogAlphah *
(Correlation1h*Random1 - Correlation2h*Random2) );
Betah = (Alphah-1.00)/Tmaxh;
Tmax = std::max(
1., std::exp(AveLogTmax + SigmaLogTmax * (Correlation1 * Random1 + Correlation2 * Random2)));
Alpha = std::max(
1.1, std::exp(AveLogAlpha + SigmaLogAlpha * (Correlation1 * Random1 - Correlation2 * Random2)));
Beta = (Alpha - 1.00) / Tmax;
// Parameters for Enenrgy Profile including correaltion and sigmas
Tmaxh =
std::exp(AveLogTmaxh + SigmaLogTmaxh * (Correlation1h * Random1 + Correlation2h * Random2));
Alphah =
std::exp(AveLogAlphah + SigmaLogAlphah * (Correlation1h * Random1 - Correlation2h * Random2));
Betah = (Alphah - 1.00) / Tmaxh;
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::GenerateNSpotProfile(const G4double y)
{
TNSpot = Tmaxh * (ParsSpotT1+ParsSpotT2*Zeff); //ok.
TNSpot = std::max(0.5,Tmaxh * (ParsSpotT1+ParsSpotT2*Zeff));
AlphaNSpot = Alphah * (ParsSpotA1+ParsSpotA2*Zeff);
BetaNSpot = (AlphaNSpot-1.00)/TNSpot; // ok
NSpot = ParsSpotN1 /SamplingResolution * std::pow(y*Eceff/GeV,ParsSpotN2 );
TNSpot = Tmaxh * (ParsSpotT1 + ParsSpotT2 * Zeff); // ok.
TNSpot = std::max(0.5, Tmaxh * (ParsSpotT1 + ParsSpotT2 * Zeff));
AlphaNSpot = Alphah * (ParsSpotA1 + ParsSpotA2 * Zeff);
BetaNSpot = (AlphaNSpot - 1.00) / TNSpot; // ok
NSpot = ParsSpotN1 / SamplingResolution * std::pow(y * Eceff / GeV, ParsSpotN2);
}
// ------------------------------------------------------------
G4double
GFlashSamplingShowerParameterisation::
ApplySampling(const G4double DEne, const G4double )
G4double GFlashSamplingShowerParameterisation::ApplySampling(const G4double DEne, const G4double)
{
G4double DEneFluctuated = DEne;
G4double Resolution = std::pow(SamplingResolution,2);
G4double Resolution = std::pow(SamplingResolution, 2);
// +pow(NoiseResolution,2)/ //@@@@@@@@ FIXME
// +pow(NoiseResolution,2)/ //@@@@@@@@ FIXME
// Energy*(1.*MeV)+
// pow(ConstantResolution,2)*
// Energy/(1.*MeV);
if(Resolution >0.0 && DEne > 0.00)
{
G4float x1=DEne/Resolution;
G4float x2 = G4RandGamma::shoot(x1, 1.0)*Resolution;
DEneFluctuated=x2;
if (Resolution > 0.0 && DEne > 0.00) {
// G4float x1 = DEne / Resolution;
// G4float x2 = G4RandGamma::shoot(x1, 1.0) * Resolution;
// DEneFluctuated = x2;
G4double x1 = DEne / Resolution;
G4double x2 = 1.0 / Resolution;
DEneFluctuated = G4RandGamma::shoot(x1, x2);
}
return DEneFluctuated;
}
@@ -354,85 +385,78 @@ IntegrateEneLongitudinal(G4double LongitudinalStep)
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
IntegrateNspLongitudinal(G4double LongitudinalStep)
G4double GFlashSamplingShowerParameterisation::IntegrateNspLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0eff;
G4float x1 = BetaNSpot*LongitudinalStepInX0;
G4double LongitudinalStepInX0 = LongitudinalStep / X0eff;
G4float x1 = BetaNSpot * LongitudinalStepInX0;
G4float x2 = AlphaNSpot;
G4float x3 = gam(x1,x2);
G4float x3 = gam(x1, x2);
G4double DNsp = x3;
return DNsp;
}
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition)
G4double GFlashSamplingShowerParameterisation::GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition)
{
if(ispot < 1)
{
if (ispot < 1) {
// Determine lateral parameters in the middle of the step.
// They depend on energy & position along step
//
G4double Tau = ComputeTau(LongitudinalPosition);
ComputeRadialParameters(Energy,Tau);
ComputeRadialParameters(Energy, Tau);
}
G4double Radius;
G4double Random1 = G4UniformRand();
G4double Random2 = G4UniformRand();
if(Random1 <WeightCore) //WeightCore = p < w_i
G4double Random2 = G4UniformRand();
if (Random1 < WeightCore) // WeightCore = p < w_i
{
Radius = Rmeff * RadiusCore * std::sqrt( Random2/(1. - Random2) );
Radius = Rmeff * RadiusCore * std::sqrt(Random2 / (1. - Random2));
}
else
{
Radius = Rmeff * RadiusTail * std::sqrt( Random2/(1. - Random2) );
}
Radius = std::min(Radius,DBL_MAX);
else {
Radius = Rmeff * RadiusTail * std::sqrt(Random2 / (1. - Random2));
}
Radius = std::min(Radius, DBL_MAX);
return Radius;
}
// ------------------------------------------------------------
G4double
GFlashSamplingShowerParameterisation::
ComputeTau(G4double LongitudinalPosition)
G4double GFlashSamplingShowerParameterisation::ComputeTau(G4double LongitudinalPosition)
{
G4double tau = LongitudinalPosition / Tmax/ X0eff //<t> = T* a /(a - 1)
* (Alpha-1.00) /Alpha
* std::exp(AveLogAlpha)/(std::exp(AveLogAlpha)-1.); //ok
G4double tau = LongitudinalPosition / Tmax / X0eff //<t> = T* a /(a - 1)
* (Alpha - 1.00) / Alpha * std::exp(AveLogAlpha)
/ (std::exp(AveLogAlpha) - 1.); // ok
return tau;
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::
ComputeRadialParameters(G4double Energy, G4double Tau)
void GFlashSamplingShowerParameterisation::ComputeRadialParameters(G4double Energy, G4double Tau)
{
G4double z1 = ParRC1 + ParRC2* std::log(Energy/GeV); //ok
G4double z2 = ParRC3+ParRC4*Zeff; //ok
RadiusCore = z1 + z2 * Tau; //ok
G4double p1 = ParWC1+ParWC2*Zeff; //ok
G4double p2 = ParWC3+ParWC4*Zeff; //ok
G4double p3 = ParWC5+ParWC6*std::log(Energy/GeV); //ok
WeightCore = p1 * std::exp( (p2-Tau)/p3- std::exp( (p2-Tau) /p3) ); //ok
G4double k1 = ParRT1+ParRT2*Zeff; // ok
G4double k2 = ParRT3; // ok
G4double k3 = ParRT4; // ok
G4double k4 = ParRT5+ParRT6* std::log(Energy/GeV); // ok
RadiusTail = k1*(std::exp(k3*(Tau-k2))
+ std::exp(k4*(Tau-k2)) ); //ok
G4double z1 = ParRC1 + ParRC2 * std::log(Energy / GeV); // ok
G4double z2 = ParRC3 + ParRC4 * Zeff; // ok
RadiusCore = z1 + z2 * Tau; // ok
G4double p1 = ParWC1 + ParWC2 * Zeff; // ok
G4double p2 = ParWC3 + ParWC4 * Zeff; // ok
G4double p3 = ParWC5 + ParWC6 * std::log(Energy / GeV); // ok
WeightCore = p1 * std::exp((p2 - Tau) / p3 - std::exp((p2 - Tau) / p3)); // ok
// sampling calorimeter
G4double k1 = ParRT1 + ParRT2 * Zeff; // ok
G4double k2 = ParRT3; // ok
G4double k3 = ParRT4; // ok
G4double k4 = ParRT5 + ParRT6 * std::log(Energy / GeV); // ok
RadiusCore = RadiusCore + ParsRC1*(1-ehat) + ParsRC2/Fs*std::exp(-Tau); //ok
WeightCore = WeightCore + (1-ehat)
* (ParsWC1+ParsWC2/Fs * std::exp(-std::pow((Tau-1.),2))); //ok
RadiusTail = RadiusTail + (1-ehat)* ParsRT1+ ParsRT2/Fs *std::exp(-Tau); //ok
RadiusTail = k1 * (std::exp(k3 * (Tau - k2)) + std::exp(k4 * (Tau - k2))); // ok
// sampling calorimeter
RadiusCore = RadiusCore + ParsRC1 * (1 - ehat) + ParsRC2 / Fs * std::exp(-Tau); // ok
WeightCore =
WeightCore + (1 - ehat) * (ParsWC1 + ParsWC2 / Fs * std::exp(-std::pow((Tau - 1.), 2))); // ok
RadiusTail = RadiusTail + (1 - ehat) * ParsRT1 + ParsRT2 / Fs * std::exp(-Tau); // ok
}
// ------------------------------------------------------------
source/parameterisations/gflash/src/GFlashShowerModel.cc
+159 -195
View File
@@ -52,28 +52,24 @@
#include "GFlashSamplingShowerParameterisation.hh"
#include "GFlashEnergySpot.hh"
GFlashShowerModel::GFlashShowerModel(G4String modelName,
G4Envelope* envelope)
: G4VFastSimulationModel(modelName, envelope),
PBound(0), Parameterisation(0), HMaker(0)
GFlashShowerModel::GFlashShowerModel(G4String modelName, G4Envelope* envelope)
: G4VFastSimulationModel(modelName, envelope), PBound(0), Parameterisation(0), HMaker(0)
{
FlagParamType = 0;
FlagParticleContainment = 1;
FlagParamType = 0;
FlagParticleContainment = 1;
StepInX0 = 0.1;
EnergyStop = 0.0;
Messenger = new GFlashShowerModelMessenger(this);
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::GFlashShowerModel(G4String modelName)
: G4VFastSimulationModel(modelName),
PBound(0), Parameterisation(0), HMaker(0)
: G4VFastSimulationModel(modelName), PBound(0), Parameterisation(0), HMaker(0)
{
FlagParamType =1;
FlagParticleContainment = 1;
StepInX0 = 0.1;
FlagParamType = 1;
FlagParticleContainment = 1;
StepInX0 = 0.1;
EnergyStop = 0.0;
Messenger = new GFlashShowerModelMessenger(this);
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::~GFlashShowerModel()
@@ -81,252 +77,220 @@ GFlashShowerModel::~GFlashShowerModel()
delete Messenger;
}
G4bool
GFlashShowerModel::IsApplicable(const G4ParticleDefinition& particleType)
{
return
&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition();
G4bool GFlashShowerModel::IsApplicable(const G4ParticleDefinition& particleType)
{
return &particleType == G4Electron::ElectronDefinition()
|| &particleType == G4Positron::PositronDefinition();
}
/**********************************************************************/
/* Checks whether conditions of fast parameterisation are fullfilled */
/**********************************************************************/
G4bool GFlashShowerModel::ModelTrigger(const G4FastTrack & fastTrack )
G4bool GFlashShowerModel::ModelTrigger(const G4FastTrack& fastTrack)
{
G4bool select = false;
if(FlagParamType != 0)
{
G4double ParticleEnergy = fastTrack.GetPrimaryTrack()->GetKineticEnergy();
G4ParticleDefinition &ParticleType =
*(fastTrack.GetPrimaryTrack()->GetDefinition());
if(ParticleEnergy > PBound->GetMinEneToParametrise(ParticleType) &&
ParticleEnergy < PBound->GetMaxEneToParametrise(ParticleType) )
if (FlagParamType != 0) {
G4double ParticleEnergy = fastTrack.GetPrimaryTrack()->GetKineticEnergy();
G4ParticleDefinition& ParticleType = *(fastTrack.GetPrimaryTrack()->GetDefinition());
if (ParticleEnergy > PBound->GetMinEneToParametrise(ParticleType)
&& ParticleEnergy < PBound->GetMaxEneToParametrise(ParticleType))
{
// check conditions depending on particle flavour
// performance to be optimized @@@@@@@
Parameterisation->GenerateLongitudinalProfile(ParticleEnergy);
select = CheckParticleDefAndContainment(fastTrack);
if (select) EnergyStop= PBound->GetEneToKill(ParticleType);
select = CheckParticleDefAndContainment(fastTrack);
if (select) EnergyStop = PBound->GetEneToKill(ParticleType);
}
}
return select;
return select;
}
G4bool GFlashShowerModel::CheckParticleDefAndContainment(const G4FastTrack& fastTrack)
{
G4bool filter = false;
G4ParticleDefinition* ParticleType = fastTrack.GetPrimaryTrack()->GetDefinition();
G4bool
GFlashShowerModel::CheckParticleDefAndContainment(const G4FastTrack& fastTrack)
{
G4bool filter=false;
G4ParticleDefinition * ParticleType =
fastTrack.GetPrimaryTrack()->GetDefinition();
if( ParticleType == G4Electron::ElectronDefinition() ||
ParticleType == G4Positron::PositronDefinition() )
if (ParticleType == G4Electron::ElectronDefinition()
|| ParticleType == G4Positron::PositronDefinition())
{
filter=true;
if(FlagParticleContainment == 1)
{
filter=CheckContainment(fastTrack);
filter = true;
if (FlagParticleContainment == 1) {
filter = CheckContainment(fastTrack);
}
}
return filter;
return filter;
}
G4bool GFlashShowerModel::CheckContainment(const G4FastTrack& fastTrack)
{
G4bool filter=false;
G4bool filter = false;
// track informations
G4ThreeVector DirectionShower=fastTrack.GetPrimaryTrackLocalDirection();
G4ThreeVector InitialPositionShower=fastTrack.GetPrimaryTrackLocalPosition();
G4ThreeVector DirectionShower = fastTrack.GetPrimaryTrackLocalDirection();
G4ThreeVector InitialPositionShower = fastTrack.GetPrimaryTrackLocalPosition();
G4ThreeVector OrthoShower, CrossShower;
// Returns orthogonal vector
G4ThreeVector OrthoShower, CrossShower;
// Returns orthogonal vector
OrthoShower = DirectionShower.orthogonal();
// Shower in direction perpendicular to OrthoShower and DirectionShower
CrossShower = DirectionShower.cross(OrthoShower);
G4double R = Parameterisation->GetAveR90();
G4double Z = Parameterisation->GetAveT90();
G4int CosPhi[4] = {1,0,-1,0};
G4int SinPhi[4] = {0,1,0,-1};
G4double R = Parameterisation->GetAveR90();
G4double Z = Parameterisation->GetAveT90();
G4int CosPhi[4] = {1, 0, -1, 0};
G4int SinPhi[4] = {0, 1, 0, -1};
G4ThreeVector Position;
G4int NlateralInside=0;
G4int NlateralInside = 0;
// pointer to solid we're in
G4VSolid *SolidCalo = fastTrack.GetEnvelopeSolid();
for(int i=0; i<4 ;i++)
{
G4VSolid* SolidCalo = fastTrack.GetEnvelopeSolid();
for (int i = 0; i < 4; i++) {
// polar coordinates
Position = InitialPositionShower +
Z*DirectionShower +
R*CosPhi[i]*OrthoShower +
R*SinPhi[i]*CrossShower ;
if(SolidCalo->Inside(Position) != kOutside)
NlateralInside++;
Position = InitialPositionShower + Z * DirectionShower + R * CosPhi[i] * OrthoShower
+ R * SinPhi[i] * CrossShower;
if (SolidCalo->Inside(Position) != kOutside) NlateralInside++;
}
// choose to parameterise or flag when all inetc...
if(NlateralInside==4) filter=true;
if (NlateralInside == 4) filter = true;
// std::cout << " points = " <<NlateralInside << std::endl;
return filter;
}
void
GFlashShowerModel::DoIt(const G4FastTrack& fastTrack, G4FastStep& fastStep)
void GFlashShowerModel::DoIt(const G4FastTrack& fastTrack, G4FastStep& fastStep)
{
// parametrise electrons
if(fastTrack.GetPrimaryTrack()->GetDefinition()
== G4Electron::ElectronDefinition() ||
fastTrack.GetPrimaryTrack()->GetDefinition()
== G4Positron::PositronDefinition() )
ElectronDoIt(fastTrack,fastStep);
if (fastTrack.GetPrimaryTrack()->GetDefinition() == G4Electron::ElectronDefinition()
|| fastTrack.GetPrimaryTrack()->GetDefinition() == G4Positron::PositronDefinition())
ElectronDoIt(fastTrack, fastStep);
}
void
GFlashShowerModel::ElectronDoIt(const G4FastTrack& fastTrack,
G4FastStep& fastStep)
void GFlashShowerModel::ElectronDoIt(const G4FastTrack& fastTrack, G4FastStep& fastStep)
{
// std::cout<<"--- ElectronDoit --- "<<std::endl;
fastStep.KillPrimaryTrack();
fastStep.ProposePrimaryTrackPathLength(0.0);
fastStep.ProposeTotalEnergyDeposited(fastTrack.GetPrimaryTrack()->
GetKineticEnergy());
fastStep.ProposeTotalEnergyDeposited(fastTrack.GetPrimaryTrack()->GetKineticEnergy());
//-----------------------------
// Get track parameters
//-----------------------------
//E,vect{p} and t,vec(x)
// Get track parameters
//-----------------------------
// E,vect{p} and t,vec(x)
G4double Energy = fastTrack.GetPrimaryTrack()->GetKineticEnergy();
// axis of the shower, in global reference frame:
G4ThreeVector DirectionShower =
fastTrack.GetPrimaryTrack()->GetMomentumDirection();
G4ThreeVector DirectionShower = fastTrack.GetPrimaryTrack()->GetMomentumDirection();
G4ThreeVector OrthoShower, CrossShower;
OrthoShower = DirectionShower.orthogonal();
CrossShower = DirectionShower.cross(OrthoShower);
//--------------------------------
///Generate longitudinal profile
/// Generate longitudinal profile
//--------------------------------
Parameterisation->GenerateLongitudinalProfile(Energy);
// performance iteration @@@@@@@
///Initialisation of long. loop variables
G4VSolid *SolidCalo = fastTrack.GetEnvelopeSolid();
G4ThreeVector pos = fastTrack.GetPrimaryTrackLocalPosition();
G4ThreeVector dir = fastTrack.GetPrimaryTrackLocalDirection();
G4double Bound = SolidCalo->DistanceToOut(pos,dir);
G4double Dz = 0.00;
// performance iteration @@@@@@@
/// Initialisation of long. loop variables
G4VSolid* SolidCalo = fastTrack.GetEnvelopeSolid();
G4ThreeVector pos = fastTrack.GetPrimaryTrackLocalPosition();
G4ThreeVector dir = fastTrack.GetPrimaryTrackLocalDirection();
G4double Bound = SolidCalo->DistanceToOut(pos, dir);
G4double Dz = 0.00;
G4double ZEndStep = 0.00;
G4double EnergyNow = Energy;
G4double EneIntegral = 0.00;
G4double LastEneIntegral = 0.00;
G4double DEne = 0.00;
G4double NspIntegral = 0.00;
G4double LastNspIntegral = 0.00;
G4double DNsp = 0.00;
G4double EnergyNow = Energy;
G4double EneIntegral = 0.00;
G4double LastEneIntegral = 0.00;
G4double DEne = 0.00;
G4double NspIntegral = 0.00;
G4double LastNspIntegral = 0.00;
G4double DNsp = 0.00;
// starting point of the shower:
G4ThreeVector PositionShower = fastTrack.GetPrimaryTrack()->GetPosition();
G4ThreeVector NewPositionShower = PositionShower;
G4double StepLenght = 0.00;
G4ThreeVector PositionShower = fastTrack.GetPrimaryTrack()->GetPosition();
G4ThreeVector NewPositionShower = PositionShower;
G4double StepLenght = 0.00;
//--------------------------
/// Begin Longitudinal Loop
//-------------------------
do
{
//determine step size=min(1Xo,next boundary)
G4double stepLength = StepInX0*Parameterisation->GetX0();
if(Bound < stepLength)
{
Dz = Bound;
do {
// determine step size=min(1Xo,next boundary)
G4double stepLength = StepInX0 * Parameterisation->GetX0();
if (Bound < stepLength) {
Dz = Bound;
Bound = 0.00;
}
else
{
Dz = stepLength;
Bound = Bound-Dz;
else {
Dz = stepLength;
Bound = Bound - Dz;
}
ZEndStep=ZEndStep+Dz;
ZEndStep = ZEndStep + Dz;
// Determine Energy Release in Step
if(EnergyNow > EnergyStop)
{
LastEneIntegral = EneIntegral;
EneIntegral = Parameterisation->IntegrateEneLongitudinal(ZEndStep);
DEne = std::min( EnergyNow,
(EneIntegral-LastEneIntegral)*Energy);
LastNspIntegral = NspIntegral;
NspIntegral = Parameterisation->IntegrateNspLongitudinal(ZEndStep);
DNsp = std::max(1., std::floor( (NspIntegral-LastNspIntegral)
*Parameterisation->GetNspot() ));
if (EnergyNow > EnergyStop) {
LastEneIntegral = EneIntegral;
EneIntegral = Parameterisation->IntegrateEneLongitudinal(ZEndStep);
DEne = std::min(EnergyNow, (EneIntegral - LastEneIntegral) * Energy);
LastNspIntegral = NspIntegral;
NspIntegral = Parameterisation->IntegrateNspLongitudinal(ZEndStep);
DNsp =
std::max(1., std::floor((NspIntegral - LastNspIntegral) * Parameterisation->GetNspot()));
}
// end of the shower
else
{
else {
DEne = EnergyNow;
DNsp = std::max(1., std::floor( (1.- NspIntegral)
*Parameterisation->GetNspot() ));
}
EnergyNow = EnergyNow - DEne;
DNsp = std::max(1., std::floor((1. - NspIntegral) * Parameterisation->GetNspot()));
}
EnergyNow = EnergyNow - DEne;
// Apply sampling fluctuation - only in sampling calorimeters
//
GFlashSamplingShowerParameterisation* sp =
dynamic_cast<GFlashSamplingShowerParameterisation*>(Parameterisation);
if (sp)
{
G4double DEneSampling = sp->ApplySampling(DEne,Energy);
if (sp) {
G4double DEneSampling = sp->ApplySampling(DEne, Energy);
DEne = DEneSampling;
}
//move particle in the middle of the step
StepLenght = StepLenght + Dz/2.00;
NewPositionShower = NewPositionShower +
StepLenght*DirectionShower;
StepLenght = Dz/2.00;
//generate spots & hits:
for (G4int i = 0; i < DNsp; ++i)
{
GFlashEnergySpot Spot;
//Spot energy: the same for all spots
Spot.SetEnergy( DEne / DNsp );
G4double PhiSpot = Parameterisation->GeneratePhi(); // phi of spot
G4double RSpot = Parameterisation // radius of spot
->GenerateRadius(i,Energy,ZEndStep-Dz/2.);
// move particle in the middle of the step
StepLenght = StepLenght + Dz / 2.00;
NewPositionShower = NewPositionShower + StepLenght * DirectionShower;
StepLenght = Dz / 2.00;
// generate spots & hits:
for (G4int i = 0; i < DNsp; ++i) {
GFlashEnergySpot Spot;
// Spot energy: the same for all spots
Spot.SetEnergy(DEne / DNsp);
G4double PhiSpot = Parameterisation->GeneratePhi(); // phi of spot
G4double RSpot = Parameterisation // radius of spot
->GenerateRadius(i, Energy, ZEndStep - Dz / 2.);
// check reference-> may be need to introduce rot matrix @@@
// Position: equally spaced in z
G4ThreeVector SpotPosition = NewPositionShower +
Dz/DNsp*DirectionShower*(i+1/2.-DNsp/2.) +
RSpot*std::cos(PhiSpot)*OrthoShower +
RSpot*std::sin(PhiSpot)*CrossShower;
G4ThreeVector SpotPosition =
NewPositionShower + Dz / DNsp * DirectionShower * (i + 1 / 2. - DNsp / 2.)
+ RSpot * std::cos(PhiSpot) * OrthoShower + RSpot * std::sin(PhiSpot) * CrossShower;
Spot.SetPosition(SpotPosition);
//Generate Hits of this spot
// Generate Hits of this spot
HMaker->make(&Spot, &fastTrack);
}
}
while(EnergyNow > 0.0 && Bound> 0.0);
} while (EnergyNow > 0.0 && Bound > 0.0);
//---------------
/// End Loop
//---------------
//---------------
}
/*
@@ -334,28 +298,28 @@ GFlashShowerModel::ElectronDoIt(const G4FastTrack& fastTrack,
void
GFlashShowerModel::GammaDoIt(const G4FastTrack& fastTrack,
G4FastStep& fastStep)
{
{
if( fastTrack.GetPrimaryTrack()->GetKineticEnergy() > EnergyStop )
return;
//deposita in uno spot unico l'energia
//con andamento exp decrescente.
//deposita in uno spot unico l'energia
//con andamento exp decrescente.
// Kill the particle to be parametrised
fastStep.KillPrimaryTrack();
fastStep.SetPrimaryTrackPathLength(0.0);
fastStep.SetTotalEnergyDeposited(fastTrack.GetPrimaryTrack()
->GetKineticEnergy());
// other settings????
feSpotList.clear();
feSpotList.clear();
//-----------------------------
// Get track parameters
// Get track parameters
//-----------------------------
// E,vect{p} and t,vec(x)
G4double Energy =
G4double Energy =
fastTrack.GetPrimaryTrack()->GetKineticEnergy();
// axis of the shower, in global reference frame:
G4ThreeVector DirectionShower =
@@ -363,23 +327,23 @@ GFlashShowerModel::GammaDoIt(const G4FastTrack& fastTrack,
// starting point of the shower:
G4ThreeVector PositionShower =
fastTrack.GetPrimaryTrack()->GetPosition();
//G4double DEneSampling = Parameterisation->ApplySampling(Energy,Energy);
//if(DEneSampling <= 0.00) DEneSampling=Energy;
//if(DEneSampling <= 0.00) DEneSampling=Energy;
if(Energy > 0.0)
{
G4double dist = Parameterisation->GenerateExponential(Energy);
G4double dist = Parameterisation->GenerateExponential(Energy);
GFlashEnergySpot Spot;
Spot.SetEnergy( Energy );
G4ThreeVector SpotPosition = PositionShower + dist*DirectionShower;
G4ThreeVector SpotPosition = PositionShower + dist*DirectionShower;
Spot.SetPosition(SpotPosition);
// Record the Spot:
feSpotList.push_back(Spot);
//Generate Hits of this spot
//Generate Hits of this spot
HMaker->make(Spot);
}
}
source/parameterisations/gflash/src/GFlashShowerModelMessenger.cc
+84 -90
View File
@@ -33,143 +33,137 @@
// Author: Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include <iomanip>
#include <sstream>
#include "GFlashShowerModelMessenger.hh"
#include "GFlashShowerModel.hh"
#include "GFlashParticleBounds.hh"
#include "globals.hh"
#include "G4SystemOfUnits.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4SystemOfUnits.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4UIdirectory.hh"
#include "globals.hh"
GFlashShowerModelMessenger::
GFlashShowerModelMessenger(GFlashShowerModel * aModel)
{
#include "GFlashParticleBounds.hh"
#include "GFlashShowerModel.hh"
#include <iomanip>
#include <sstream>
GFlashShowerModelMessenger::GFlashShowerModelMessenger(GFlashShowerModel* aModel)
{
myParaDir = new G4UIdirectory("/GFlash/");
myParaDir->SetGuidance("Parametrisation control.");
myModel= aModel;
FlagCmd = new G4UIcmdWithAnInteger("/GFlash/flag",this);
myModel = aModel;
FlagCmd = new G4UIcmdWithAnInteger("/GFlash/flag", this);
FlagCmd->SetGuidance("Defines if GFlash is activated");
FlagCmd->SetParameterName("flag",false,false);
ContCmd = new G4UIcmdWithAnInteger("/GFlash/containment ",this);
FlagCmd->SetParameterName("flag", false, false);
ContCmd = new G4UIcmdWithAnInteger("/GFlash/containment ", this);
ContCmd->SetGuidance("Defines if Containment is checked");
ContCmd->SetParameterName("flag",false,false);
StepInX0Cmd = new G4UIcmdWithADouble("/GFlash/stepXo",this);
ContCmd->SetParameterName("flag", false, false);
StepInX0Cmd = new G4UIcmdWithADouble("/GFlash/stepXo", this);
StepInX0Cmd->SetGuidance("Defines step lenghts");
StepInX0Cmd->SetParameterName("flag",false,false);
EminCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Emin",this);
StepInX0Cmd->SetParameterName("flag", false, false);
EminCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Emin", this);
EminCmd->SetGuidance("Set minimum kinetic energy to trigger parametrisation");
EminCmd->SetParameterName("Emin",false,false);
EminCmd->SetParameterName("Emin", false, false);
EminCmd->SetDefaultUnit("GeV");
EminCmd->SetUnitCategory("Energy");
EminCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
EmaxCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Emax",this);
EminCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
EmaxCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Emax", this);
EmaxCmd->SetGuidance("Set maximum kinetic energy to trigger parametrisation");
EmaxCmd->SetParameterName("Emax",false,false);
EmaxCmd->SetParameterName("Emax", false, false);
EmaxCmd->SetDefaultUnit("GeV");
EmaxCmd->SetUnitCategory("Energy");
EmaxCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
EkillCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Ekill",this);
EmaxCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
EkillCmd = new G4UIcmdWithADoubleAndUnit("/GFlash/Ekill", this);
EkillCmd->SetGuidance("Set maximum kinetic energy for electrons to be killed");
EkillCmd->SetParameterName("Ekill",false,false);
EkillCmd->SetParameterName("Ekill", false, false);
EkillCmd->SetDefaultUnit("GeV");
EkillCmd->SetUnitCategory("Energy");
EkillCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
EkillCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
}
GFlashShowerModelMessenger::~GFlashShowerModelMessenger()
{
delete ContCmd;
delete FlagCmd;
delete StepInX0Cmd;
delete StepInX0Cmd;
delete EminCmd;
delete EmaxCmd;
delete EkillCmd;
}
void GFlashShowerModelMessenger::SetNewValue(G4UIcommand* command, G4String newValues)
{
if (command == FlagCmd) {
myModel->SetFlagParamType(FlagCmd->GetNewIntValue(newValues));
this->GetCurrentValue(command);
}
if (command == ContCmd) {
myModel->SetFlagParticleContainment(ContCmd->GetNewIntValue(newValues));
this->GetCurrentValue(command);
}
if (command == StepInX0Cmd) {
myModel->SetStepInX0(StepInX0Cmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
void GFlashShowerModelMessenger::
SetNewValue(G4UIcommand * command,G4String newValues)
{
if( command == FlagCmd ) {
myModel->SetFlagParamType(FlagCmd->GetNewIntValue(newValues));
this->GetCurrentValue(command);
}
if( command == ContCmd ) {
myModel->SetFlagParticleContainment(ContCmd->GetNewIntValue(newValues));
this->GetCurrentValue(command);
}
if( command == StepInX0Cmd ) {
myModel->SetStepInX0(StepInX0Cmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EminCmd ) {
else if (command == EminCmd) {
myModel->PBound->SetMinEneToParametrise(*G4Electron::ElectronDefinition(),
EminCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
EminCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EmaxCmd ) {
else if (command == EmaxCmd) {
myModel->PBound->SetMaxEneToParametrise(*G4Electron::ElectronDefinition(),
EmaxCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
EmaxCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EkillCmd ) {
else if (command == EkillCmd) {
myModel->PBound->SetEneToKill(*G4Electron::ElectronDefinition(),
EkillCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
EkillCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
}
G4String GFlashShowerModelMessenger::GetCurrentValue(G4UIcommand * command)
G4String GFlashShowerModelMessenger::GetCurrentValue(G4UIcommand* command)
{
G4String returnValue(1,'\0');
G4String returnValue(1, '\0');
std::ostringstream os;
if( command == FlagCmd ) {
os << "/GFlash/flag " << myModel->GetFlagParamType() << '\0';
if (command == FlagCmd) {
os << "/GFlash/flag " << myModel->GetFlagParamType() << '\0';
returnValue = G4String(os.str());
}
else if( command == EkillCmd ) {
os << "/GFlash/Ekill "
<< myModel->PBound->GetEneToKill(*G4Electron::ElectronDefinition())/GeV
else if (command == EkillCmd) {
os << "/GFlash/Ekill " << myModel->PBound->GetEneToKill(*G4Electron::ElectronDefinition()) / GeV
<< " GeV" << '\0';
returnValue = G4String(os.str());
}
else if( command == EminCmd ) {
else if (command == EminCmd) {
os << "/GFlash/Emin "
<< myModel->PBound->GetMinEneToParametrise(*G4Electron::ElectronDefinition())/GeV
<< " GeV" << '\0';
returnValue = G4String(os.str());
}
else if( command == EmaxCmd ) {
os << "/GFlash/Emax "
<< myModel->PBound->GetMaxEneToParametrise(*G4Electron::ElectronDefinition())/GeV
<< " GeV" << '\0';
<< myModel->PBound->GetMinEneToParametrise(*G4Electron::ElectronDefinition()) / GeV << " GeV"
<< '\0';
returnValue = G4String(os.str());
}
else if (command == EmaxCmd) {
os << "/GFlash/Emax "
<< myModel->PBound->GetMaxEneToParametrise(*G4Electron::ElectronDefinition()) / GeV << " GeV"
<< '\0';
returnValue = G4String(os.str());
}
return returnValue;
}
source/parameterisations/gflash/src/GVFlashShowerParameterisation.cc
+26 -27
View File
@@ -56,30 +56,29 @@ GVFlashShowerParameterisation::~GVFlashShowerParameterisation()
delete fGamma;
}
G4double GVFlashShowerParameterisation::GetEffZ(const G4Material * mat )
G4double GVFlashShowerParameterisation::GetEffZ(const G4Material* mat)
{
// Returns Z or effective Z=sum(pi*Zi) (if compound/mixture)
// of given material
//
G4double z = 0.;
G4int nofElements = (G4int)mat->GetNumberOfElements();
if (nofElements > 1)
{
for (G4int i=0; i<nofElements; ++i) {
if (nofElements > 1) {
for (G4int i = 0; i < nofElements; ++i) {
G4double zOfElement = mat->GetElement(i)->GetZ();
G4double massFraction = mat->GetFractionVector()[i];
// cout << mat->GetElement(i)->GetName()
// <<" Z= "<<zOfElement << " , Fraction= "<<massFraction <<endl;
z += zOfElement*massFraction;
z += zOfElement * massFraction;
}
}
else {
z = mat->GetZ();
}
else {
z = mat->GetZ();
}
return z;
}
G4double GVFlashShowerParameterisation::GetEffA (const G4Material * mat )
G4double GVFlashShowerParameterisation::GetEffA(const G4Material* mat)
{
// Returns A or effective A=sum(pi*Ai) (if compound/mixture)
// of given material
@@ -87,29 +86,29 @@ G4double GVFlashShowerParameterisation::GetEffA (const G4Material * mat )
G4double a = 0.;
G4int nofElements = (G4int)mat->GetNumberOfElements();
if (nofElements > 1) {
for (G4int i=0; i<nofElements; ++i) {
G4double aOfElement = mat->GetElement(i)->GetA()/(g/mole);
G4double massFraction = mat->GetFractionVector()[i];
a += aOfElement*massFraction;
for (G4int i = 0; i < nofElements; ++i) {
G4double aOfElement = mat->GetElement(i)->GetA() / (g / mole);
G4double massFraction = mat->GetFractionVector()[i];
a += aOfElement * massFraction;
}
}
else {
a = mat->GetA()/(g/mole);
else {
a = mat->GetA() / (g / mole);
}
return a;
}
void GVFlashShowerParameterisation::PrintMaterial(const G4Material * mat)
void GVFlashShowerParameterisation::PrintMaterial(const G4Material* mat)
{
G4cout<<"/********************************************/ " << G4endl;
G4cout<<" - GVFlashShowerParameterisation::Material - " << G4endl;
G4cout<<" Material : " << mat->GetName() << G4endl;
G4cout<<" Z = " << Z << G4endl;
G4cout<<" A = " << A << G4endl;
G4cout<<" X0 = " << X0/cm << " cm" << G4endl;
G4cout<<" Rm = " << Rm/cm << " cm" << G4endl;
G4cout<<" Ec = " << Ec/MeV << " MeV"<< G4endl;
G4cout<<"/********************************************/ " << G4endl;
G4cout << "/********************************************/ " << G4endl;
G4cout << " - GVFlashShowerParameterisation::Material - " << G4endl;
G4cout << " Material : " << mat->GetName() << G4endl;
G4cout << " Z = " << Z << G4endl;
G4cout << " A = " << A << G4endl;
G4cout << " X0 = " << X0 / cm << " cm" << G4endl;
G4cout << " Rm = " << Rm / cm << " cm" << G4endl;
G4cout << " Ec = " << Ec / MeV << " MeV" << G4endl;
G4cout << "/********************************************/ " << G4endl;
}
G4double GVFlashShowerParameterisation::GeneratePhi()
@@ -118,7 +117,7 @@ G4double GVFlashShowerParameterisation::GeneratePhi()
return Phi;
}
G4double GVFlashShowerParameterisation::gam(G4double x, G4double a) const
G4double GVFlashShowerParameterisation::gam(G4double x, G4double a) const
{
return fGamma->Gamma(a, x);
return fGamma->Gamma(a, x);
}
source/parameterisations/gflash/src/Gamma.cc
+44 -43
View File
@@ -47,7 +47,7 @@ double MyGamma::Gamma(double z)
}
//____________________________________________________________________________
double MyGamma::Gamma(double a,double x)
double MyGamma::Gamma(double a, double x)
{
// Computation of the incomplete gamma function P(a,x)
//
@@ -55,15 +55,17 @@ double MyGamma::Gamma(double a,double x)
// Numerical Recipes 2nd ed. on p. 210-212 (W.H.Press et al.).
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
if (a <= 0 || x <= 0) return 0;
if (x < (a+1)) return GamSer(a,x);
else return GamCf(a,x);
if (x < (a + 1))
return GamSer(a, x);
else
return GamCf(a, x);
}
//____________________________________________________________________________
double MyGamma::GamCf(double a,double x)
double MyGamma::GamCf(double a, double x)
{
// Computation of the incomplete gamma function P(a,x)
// via its continued fraction representation.
@@ -72,38 +74,38 @@ double MyGamma::GamCf(double a,double x)
// Numerical Recipes 2nd ed. on p. 210-212 (W.H.Press et al.).
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
int itmax = 100; // Maximum number of iterations
double eps = 3.e-7; // Relative accuracy
double fpmin = 1.e-30; // Smallest double value allowed here
int itmax = 100; // Maximum number of iterations
double eps = 3.e-7; // Relative accuracy
double fpmin = 1.e-30; // Smallest double value allowed here
if (a <= 0 || x <= 0) return 0;
double gln = LnGamma(a);
double b = x+1-a;
double c = 1/fpmin;
double d = 1/b;
double h = d;
double an,del;
for (int i=1; i<=itmax; i++) {
an = double(-i)*(double(i)-a);
double b = x + 1 - a;
double c = 1 / fpmin;
double d = 1 / b;
double h = d;
double an, del;
for (int i = 1; i <= itmax; i++) {
an = double(-i) * (double(i) - a);
b += 2;
d = an*d+b;
d = an * d + b;
if (Abs(d) < fpmin) d = fpmin;
c = b+an/c;
c = b + an / c;
if (Abs(c) < fpmin) c = fpmin;
d = 1/d;
del = d*c;
h = h*del;
if (Abs(del-1) < eps) break;
//if (i==itmax) cout << "*GamCf(a,x)* a too large or itmax too small" << endl;
d = 1 / d;
del = d * c;
h = h * del;
if (Abs(del - 1) < eps) break;
// if (i==itmax) cout << "*GamCf(a,x)* a too large or itmax too small" << endl;
}
double v = Exp(-x+a*Log(x)-gln)*h;
return (1-v);
double v = Exp(-x + a * Log(x) - gln) * h;
return (1 - v);
}
//____________________________________________________________________________
double MyGamma::GamSer(double a,double x)
double MyGamma::GamSer(double a, double x)
{
// Computation of the incomplete gamma function P(a,x)
// via its series representation.
@@ -112,28 +114,27 @@ double MyGamma::GamSer(double a,double x)
// Numerical Recipes 2nd ed. on p. 210-212 (W.H.Press et al.).
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
int itmax = 100; // Maximum number of iterations
double eps = 3.e-7; // Relative accuracy
int itmax = 100; // Maximum number of iterations
double eps = 3.e-7; // Relative accuracy
if (a <= 0 || x <= 0) return 0;
double gln = LnGamma(a);
double ap = a;
double sum = 1/a;
double ap = a;
double sum = 1 / a;
double del = sum;
for (int n=1; n<=itmax; n++) {
ap += 1;
del = del*x/ap;
for (int n = 1; n <= itmax; n++) {
ap += 1;
del = del * x / ap;
sum += del;
if (MyGamma::Abs(del) < Abs(sum*eps)) break;
//if (n==itmax) cout << "*GamSer(a,x)* a too large or itmax too small" << endl;
if (MyGamma::Abs(del) < Abs(sum * eps)) break;
// if (n==itmax) cout << "*GamSer(a,x)* a too large or itmax too small" << endl;
}
double v = sum*Exp(-x+a*Log(x)-gln);
double v = sum * Exp(-x + a * Log(x) - gln);
return v;
}
double MyGamma::LnGamma(double z)
{
if (z <= 0)