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

Import Geant4 8.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 14:36:02 +02:00
parent d93e1e39a9
commit 8a51e0bc40
5471 changed files with 99628 additions and 55248 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/parameterisations/gflash/History
+23 -1
View File
@@ -1,4 +1,4 @@
$Id: History,v 1.5 2005/06/22 14:08:29 gcosmo Exp $
$Id: History,v 1.8 2005/11/30 19:17:08 gcosmo Exp $
-------------------------------------------------------------------
=========================================================
@@ -17,6 +17,28 @@ committal in the CVS repository !
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
Nov 28th, 2005 J.Weng (gflash-V07-01-02)
---------------------
- Design iteration. Added concrete sampling shower parameterisation
and tuning classes.
Nov 28th, 2005 G.Cosmo (gflash-V07-01-01)
----------------------
- Migration to <sstream> for GFlashShowerModelMessenger.
Oct 4th, 2005 G.Cosmo (gflash-V07-01-00)
---------------------
- Corrected typo to name GFlashHomoShowerParamterisation, to become
GFlashHomoShowerParameterisation. Replaced affected files.
- Code cleanup for Software Reference Manual.
- Fixed usage of random numbers in GFlashHomoShowerParameterisation
to allow for event reproducibility.
Jul 15th, 2005 J.Weng
---------------------
- Added overflow protection in method GenerateRadius() for
GFlashHomoShowerParamterisation.
Jun 22nd, 2005 G.Cosmo (gflash-V07-00-04)
----------------------
- Corrected signature for IntegrateNspLongitudinal() to remove
source/parameterisations/gflash/README
-3
View File
@@ -1,3 +0,0 @@
This directory contains the code re-implementation of the GFLASH package
in C++ for Geant4. At the time of the first release, the homogenous shower
parameterisation part is included.
source/parameterisations/gflash/include/G4GFlashSpot.hh
+37 -19
View File
@@ -20,6 +20,21 @@
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4GFlashSpot.hh,v 1.3 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// G4GFlashSpot
//
// Class description:
//
// Definition of energy spot for GFlash parameterisation.
//---------------------------------------------------------------
#ifndef G4GFlashSpot_h
#define G4GFlashSpot_h
@@ -30,25 +45,28 @@
class G4GFlashSpot
{
public:
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;}
G4ThreeVector GetPosition() const {return GetOriginatorTrack()->GetPrimaryTrack()->GetPosition();}
private:
const GFlashEnergySpot * theSpot;
const G4FastTrack * theTrack;
G4TouchableHandle theHandle;
public:
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;}
G4ThreeVector GetPosition() const
{return GetOriginatorTrack()->GetPrimaryTrack()->GetPosition();}
private:
const GFlashEnergySpot * theSpot;
const G4FastTrack * theTrack;
G4TouchableHandle theHandle;
};
#endif
source/parameterisations/gflash/include/G4VGFlashSensitiveDetector.hh
+71 -47
View File
@@ -20,6 +20,23 @@
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: G4VGFlashSensitiveDetector.hh,v 1.4 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// G4VGFlashSensitiveDetector
//
// Class description:
//
// Abstract base class of the sensitive detector for use with GFlash.
// The user's sensitive detector which generates hits must be derived
// from this class, and G4VSensitiveDetector.
//---------------------------------------------------------------
#ifndef G4VGFlashSensitiveDetector_h
#define G4VGFlashSensitiveDetector_h 1
@@ -29,72 +46,79 @@
#include "GFlashEnergySpot.hh"
#include "G4GFlashSpot.hh"
// class description:
//
// This is the abstract base class of the sensitive detector for use with GFlash. The user's
// sensitive detector which generates hits must be derived from this
// class, and G4VSensitiveDetector.
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.
// 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: // without description
public:
virtual ~G4VGFlashSensitiveDetector() {}
G4int operator==(const G4VGFlashSensitiveDetector &right) const {return this == &right;}
G4int operator!=(const G4VGFlashSensitiveDetector &right) const {return this != &right;};
G4int operator==(const G4VGFlashSensitiveDetector &right) const
{return this == &right;}
G4int operator!=(const G4VGFlashSensitiveDetector &right) const
{return this != &right;}
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.
public: // without description
public: // with 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("Sensitive detector using GFlash needs to also inherit from G4VSensitiveDetector");
}
G4VSensitiveDetector * This
= dynamic_cast<G4VSensitiveDetector *>(this);
if(!This)
{
G4Exception("G4VGFlashSensitiveDetector::Hit()",
"InvalidSetup", FatalException,
"Needs also to inherit from G4VSensitiveDetector!");
}
if(This->isActive())
{
G4VReadOutGeometry * ROgeometry = 0;
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;
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;
}
// This is the public method invoked by GFlashHitMaker for generating
// hit(s). The actual user's implementation for generating hit(s) must be
// implemented in GenerateHits() virtual protected method.
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
+34 -15
View File
@@ -20,27 +20,46 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng, 9.11.04
//
// $Id: GFlashEnergySpot.hh,v 1.4 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashEnergySpot
//
// Class description:
//
// Alternative definition of energy spot for GFlash parameterisation.
//
// Author: Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashEnergySpot_h
#define GFlashEnergySpot_h
#include "G4ThreeVector.hh"
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
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
};
#endif
source/parameterisations/gflash/include/GFlashHitMaker.hh
+36 -24
View File
@@ -20,11 +20,25 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng 9.11.2004
//
// $Id: GFlashHitMaker.hh,v 1.4 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashHitMaker
//
// Class description:
//
// Singleton for GFlash parameterisation hit creation.
//
// Author: Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashHitMaker_h
#define GFlashHitMaker_h 1
// has singleton semantics
#include "G4TouchableHandle.hh"
#include "G4Navigator.hh"
@@ -35,28 +49,26 @@
class GFlashHitMaker
{
public:
GFlashHitMaker();
~GFlashHitMaker();
void make(GFlashEnergySpot * aSpot, const G4FastTrack * aT );
private:
G4TouchableHandle fTouchableHandle;
G4Navigator *fpNavigator;
G4bool fNaviSetup;
private:
GFlashHitMaker(const GFlashHitMaker & )
{
G4Exception("GFlashHitMaker copy constructor not publicly available");
}
GFlashHitMaker & operator = (const GFlashHitMaker & )
{
G4Exception("GFlashHitMaker asignment operator not publicly available");
return *this;
}
public:
GFlashHitMaker();
~GFlashHitMaker();
void make(GFlashEnergySpot * aSpot, const G4FastTrack * aT );
private:
G4TouchableHandle fTouchableHandle;
G4Navigator *fpNavigator;
G4bool fNaviSetup;
private:
GFlashHitMaker(const GFlashHitMaker & ) {}
GFlashHitMaker & operator = (const GFlashHitMaker & )
{
return *this;
}
};
#endif
source/parameterisations/gflash/include/GFlashHomoShowerParameterisation.hh
+133
View File
@@ -0,0 +1,133 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: GFlashHomoShowerParameterisation.hh,v 1.3 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashHomoShowerParameterisation
//
// Class description:
//
// GFlash homogeneous shower parameterisation.
// Author: Joanna Weng - 02.2004
// ---------------------------------------------------------------
#ifndef GFlashHomoShowerParameterisation_h
#define GFlashHomoShowerParameterisation_h 1
#include "globals.hh"
#include "GVFlashHomoShowerTuning.hh"
#include "GVFlashShowerParameterisation.hh"
class G4Material;
class GFlashHomoShowerParameterisation : public GVFlashShowerParameterisation
{
public: // with description
GFlashHomoShowerParameterisation(G4Material * aMat,
GVFlashHomoShowerTuning * aPar = 0);
~GFlashHomoShowerParameterisation();
void ComputeRadialParameters(G4double y, G4double Tau);
void GenerateLongitudinalProfile(G4double Energy);
void ComputeZAX0EFFetc();
G4double IntegrateEneLongitudinal(G4double LongitudinalStep);
G4double IntegrateNspLongitudinal(G4double LongitudinalStep);
G4double ComputeTau(G4double LongitudinalPosition);
G4double GeneratePhi();
G4double GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition);
G4double GenerateExponential(G4double Energy);
void SetMaterial(G4Material *mat);
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;}
private:
G4Material *material;
//Resolution
G4double ConstantResolution;
G4double NoiseResolution;
G4double SamplingResolution;
// parametrization parameters
GVFlashHomoShowerTuning * thePar;
// Cashed parameters:
// Longitudinal Coefficients for a homogeneous calo
G4double ParAveT1;
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;
// Spot multiplicity Coefficients
G4double ParSpotT1,ParSpotT2,ParSpotA1, ParSpotA2;
G4double ParSpotN1,ParSpotN2;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// homogeneous
G4double AveLogAlphah,AveLogTmaxh;
G4double SigmaLogAlphah,SigmaLogTmaxh;
G4double Rhoh;
G4double Alphah,Tmaxh,Betah;
// Multiplicity
G4double NSpot,AlphaNSpot,TNSpot,BetaNSpot;
//Radial
G4double RadiusCore, WeightCore,RadiusTail;
};
#endif
source/parameterisations/gflash/include/GFlashHomoShowerParamterisation.hh
-123
View File
@@ -1,123 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// Created by J. Weng 02.2004
#ifndef GFlashHomoShowerParamterisation_h
#define GFlashHomoShowerParamterisation_h 1
#include "globals.hh"
#include "GVFlashHomoShowerTuning.hh"
class G4Material;
class GFlashHomoShowerParamterisation
{
public:
GFlashHomoShowerParamterisation(G4Material * aMat, GVFlashHomoShowerTuning * aPar = 0);
~GFlashHomoShowerParamterisation();
void ComputeRadialParameters(G4double y, G4double Tau);
void GenerateLongitudinalProfile(G4double Energy);
void ComputeZAX0EFFetc();
G4double IntegrateEneLongitudinal(G4double LongitudinalStep);
G4double IntegrateNspLongitudinal(G4double LongitudinalStep);
G4double ComputeTau(G4double LongitudinalPosition);
G4double GeneratePhi();
G4double GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition);
G4double GenerateExponential(G4double Energy);
//Gets
//R
inline G4double GetAveR99() {return (3.5 * Rm);}
inline G4double GetAveR90() {return (1.5 * Rm);} //ok
//T
inline G4double GetAveTmx() {return (X0 * std::exp(AveLogTmaxh));} //exp ?
inline G4double GetAveT99() {return (X0 * AveLogTmaxh/(AveLogAlphah-1.00));}
inline G4double GetAveT90() {return (2.5 * X0 * std::exp( AveLogTmaxh) );}
//
inline G4double GetNspot(){ return NSpot;}
G4double GetEffZ(const G4Material * material);
G4double GetEffA(const G4Material * material);
G4double gam(G4double x, G4double a) const; // @@@@ gamma function
private:
// medium related quantities
G4double density, A, Z, X0, Ec, Rm;
G4Material *material;
public:
inline G4double GetX0(){return X0;}
inline G4double GetEc(){return Ec;}
inline G4double GetRm(){return Rm;}
void SetMaterial (G4Material *mat);
void PrintMaterial();
private:
//Resolution
G4double ConstantResolution;
G4double NoiseResolution;
G4double SamplingResolution;
// parametrization parameters
GVFlashHomoShowerTuning * thePar;
// Cashed parameters:
// Longitudinal Coefficients for a homogenious calo
G4double ParAveT1;
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;
//Spot multiplicity Coefficients
G4double ParSpotT1,ParSpotT2,ParSpotA1, ParSpotA2;
G4double ParSpotN1,ParSpotN2;
//PARAMETRISATION variables (Energy & position dependent)
//Longitudinal
//homogenous
G4double AveLogAlphah,AveLogTmaxh;
G4double SigmaLogAlphah,SigmaLogTmaxh;
G4double Rhoh;
G4double Alphah,Tmaxh,Betah;
//MMultiplicity
G4double NSpot,AlphaNSpot,TNSpot,BetaNSpot;
//Radial
G4double RadiusCore, WeightCore,RadiusTail;
};
#endif
source/parameterisations/gflash/include/GFlashParticleBounds.hh
+40 -19
View File
@@ -20,8 +20,23 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng 9.11.2004
//
// $Id: GFlashParticleBounds.hh,v 1.3 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashParticleBounds
//
// Class description:
//
// GFlash parameterisation particle bounds.
//
// Author: Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashParticleBounds_h
#define GFlashParticleBounds_h
@@ -29,24 +44,30 @@
class GFlashParticleBounds
{
public:
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);
private:
// electron and positron
G4double EMinEneToParametrise;
G4double EMaxEneToParametrise;
G4double EEneToKill;
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);
private:
// electron and positron
G4double EMinEneToParametrise;
G4double EMaxEneToParametrise;
G4double EEneToKill;
};
#endif
source/parameterisations/gflash/include/GFlashSamplingShowerParameterisation.hh
+171
View File
@@ -0,0 +1,171 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: GFlashSamplingShowerParameterisation.hh,v 1.3 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashSamplingShowerParameterisation
//
// Class description:
//
// GFlash concrete sampling shower parameterisation
// Author: Joanna Weng - 02.2004
//---------------------------------------------------------------
#ifndef GFlashSamplingShowerParameterisation_h
#define GFlashSamplingShowerParameterisation_h 1
#include "globals.hh"
#include "GFlashSamplingShowerTuning.hh"
#include "GVFlashShowerParameterisation.hh"
class G4Material;
class GFlashSamplingShowerParameterisation
: public GVFlashShowerParameterisation
{
public:
GFlashSamplingShowerParameterisation(G4Material* aMat1, G4Material* aMat2,
G4double d1, G4double d2,
GFlashSamplingShowerTuning * aPar = 0);
~GFlashSamplingShowerParameterisation();
void ComputeRadialParameters(G4double y, G4double Tau);
void GenerateLongitudinalProfile(G4double Energy);
void ComputeZAX0EFFetc();
G4double IntegrateEneLongitudinal(G4double LongitudinalStep);
G4double IntegrateNspLongitudinal(G4double LongitudinalStep);
G4double ComputeTau(G4double LongitudinalPosition);
void SetMaterial(G4Material *mat1, G4Material *mat2);
G4double GeneratePhi();
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 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;}
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;
// Resolution
//
G4double ConstantResolution;
G4double NoiseResolution;
G4double SamplingResolution;
// parametrization parameters
//
GFlashSamplingShowerTuning * thePar;
// Cashed parameters:
// Longitudinal Coefficients for a homogenious calo
//
G4double ParAveT1, ParAveT2;
G4double ParAveA1,ParAveA2, ParAveA3;
G4double ParSigLogT1,ParSigLogT2;
G4double ParSigLogA1,ParSigLogA2;
G4double ParRho1,ParRho2;
//Cashed parameters:
// Longitudinal Coefficients for a sampling calo
//
G4double ParsAveT1, ParsAveT2;
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;
// Radial Coefficients sampling
//
G4double ParsRC1,ParsRC2;
G4double ParsWC1,ParsWC2;
G4double ParsRT1,ParsRT2;
// Spot multiplicity Coefficients
//
G4double ParsSpotT1,ParsSpotT2,ParsSpotA1, ParsSpotA2;
G4double ParsSpotN1,ParsSpotN2;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// homogeneous
//
G4double AveLogAlphah,AveLogTmaxh;
G4double SigmaLogAlphah,SigmaLogTmaxh;
G4double Rhoh;
G4double Alphah,Tmaxh,Betah;
// PARAMETRISATION variables (Energy & position dependent)
// Longitudinal
// sampling
//
G4double AveLogAlpha,AveLogTmax;
G4double SigmaLogAlpha,SigmaLogTmax;
G4double Rho;
G4double Alpha,Tmax,Beta;
// Multiplicity
//
G4double NSpot,AlphaNSpot,TNSpot,BetaNSpot;
//Radial
//
G4double RadiusCore, WeightCore,RadiusTail;
};
#endif
source/parameterisations/gflash/include/GFlashSamplingShowerTuning.hh
+123
View File
@@ -0,0 +1,123 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: GFlashSamplingShowerTuning.hh,v 1.2 2005/11/30 19:17:08 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashSamplingShowerTuning
//
// Class description:
//
// Tuning class for GFlash homogeneous shower parameterisation.
// Definitions:
// <t>: shower center of gravity
// T: Depth at shower maximum
// Ec: Critical energy
// X0: Radiation length
// y = E/Ec
//
// Please, see hep-ex/0001020 for details.
// Author: Joanna Weng - 11.2005
//---------------------------------------------------------------
#ifndef GFlashSamplingShowerTuning_hh
#define GFlashSamplingShowerTuning_hh
#include "GVFlashHomoShowerTuning.hh"
class GFlashSamplingShowerTuning : public GVFlashHomoShowerTuning
{
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
// alpha_sam = log(exp(log alphah_hom) +(a1*Fs-1))
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
// std::sqrt(var(ln(alpha_sam))) = 1/(a1+a2*ln(y))
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
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
// Rt_sam = Rc_hom + t1 * (1-ehat) + t2 *Fs-1*exp (-tau)
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
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)
G4double ParsSpotT1(){ return 0.813; } // t1
G4double ParsSpotT2(){ return 0.0019;} // t2
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
};
#endif
source/parameterisations/gflash/include/GFlashShowerModel.hh
+79 -48
View File
@@ -20,8 +20,22 @@
// * statement, and all its terms. *
// ********************************************************************
//
/// Created by E.Barberio, Joanna Weng 9.11.2004
//
// $Id: GFlashShowerModel.hh,v 1.8 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashShowerModel
//
// Class description:
//
// GFlash parameterisation shower model.
// Authors: E.Barberio & Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashShowerModel_h
#define GFlashShowerModel_h 1
@@ -37,55 +51,72 @@
#include "GFlashHitMaker.hh"
#include <vector>
class GFlashHomoShowerParamterisation;
class GVFlashShowerParameterisation;
class GFlashHomoShowerParameterisation;
class GFlashSamplingShowerParameterisation;
class GFlashShowerModel : public G4VFastSimulationModel
{
public:
/// Constructor, destructor
GFlashShowerModel (G4String, G4LogicalVolume*);
GFlashShowerModel (G4String);
~GFlashShowerModel ();
/// Checks whether conditions of fast
/// parametrisation are fullfilled
G4bool ModelTrigger(const G4FastTrack &);
G4bool IsApplicable(const G4ParticleDefinition&);
void DoIt(const G4FastTrack&, G4FastStep&);
// setting
inline void SetFlagParamType(G4int I) { FlagParamType = I; }
inline void SetFlagParticleContainment(G4int I) { FlagParticleContainment = I; }
inline void SetStepInX0(G4double Lenght) { StepInX0=Lenght; }
inline void SetParametrisation(GFlashHomoShowerParamterisation &DetectorParametrisation){ Parametrisation=&DetectorParametrisation;}
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; }
// Gets ?
GFlashParticleBounds *PBound;
private:
GFlashHomoShowerParamterisation *Parametrisation;
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 EnergyStop;
// private methods
void ElectronDoIt(const G4FastTrack&, G4FastStep&);
// void GammaDoIt(const G4FastTrack&, G4FastStep&);
// void NeutrinoDoIt(const G4FastTrack&, G4FastStep&);
G4bool CheckParticleDefAndContainment(const G4FastTrack &fastTrack);
G4bool CheckContainment(const G4FastTrack &fastTrack);
public: // with description
GFlashShowerModel (G4String, G4Envelope*);
GFlashShowerModel (G4String);
~GFlashShowerModel ();
// Constructors, destructor
G4bool ModelTrigger(const G4FastTrack &);
G4bool IsApplicable(const G4ParticleDefinition&);
void DoIt(const G4FastTrack&, G4FastStep&);
// 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; }
// getting
inline G4int GetFlagParamType()
{ return FlagParamType; }
inline G4int GetFlagParticleContainment()
{ return FlagParticleContainment; }
inline G4double GetStepInX0()
{ return StepInX0; }
public: // without description
// Gets ?
GFlashParticleBounds *PBound;
GVFlashShowerParameterisation *Parameterisation;
private:
void ElectronDoIt(const G4FastTrack&, G4FastStep&);
// void GammaDoIt(const G4FastTrack&, G4FastStep&);
// void NeutrinoDoIt(const G4FastTrack&, G4FastStep&);
G4bool CheckParticleDefAndContainment(const G4FastTrack &fastTrack);
G4bool CheckContainment(const G4FastTrack &fastTrack);
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 EnergyStop;
};
#endif
source/parameterisations/gflash/include/GFlashShowerModelMessenger.hh
+36 -32
View File
@@ -20,7 +20,23 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng, 9.11.04
//
// $Id: GFlashShowerModelMessenger.hh,v 1.3 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GFlashShowerModelMessenger
//
// Class description:
//
// Messenger for the GFlash parameterisation shower model control.
//
// Author: Joanna Weng - 9.11.04
//---------------------------------------------------------------
#ifndef GFlashShowerModelMessenger_h
#define GFlashShowerModelMessenger_h 1
@@ -37,37 +53,25 @@ class G4UIcmdWithADouble;
class GFlashShowerModelMessenger: public G4UImessenger
{
public:
GFlashShowerModelMessenger(GFlashShowerModel * myModel);
~GFlashShowerModelMessenger();
void SetNewValue(G4UIcommand * command,G4String newValues);
G4String GetCurrentValue(G4UIcommand * command);
private:
GFlashShowerModel* myModel;
G4UIdirectory* myParaDir;
G4UIcmdWithAString* SwitchCmd;
G4UIcmdWithAnInteger* FlagCmd;
G4UIcmdWithAnInteger* ContCmd; // Containment Check
G4UIcmdWithADouble* StepInX0Cmd;
G4UIcmdWithADoubleAndUnit* EmaxCmd;
G4UIcmdWithADoubleAndUnit* EminCmd;
G4UIcmdWithADoubleAndUnit* EkillCmd;
public:
GFlashShowerModelMessenger(GFlashShowerModel * myModel);
~GFlashShowerModelMessenger();
void SetNewValue(G4UIcommand * command,G4String newValues);
G4String GetCurrentValue(G4UIcommand * command);
private:
GFlashShowerModel* myModel;
G4UIdirectory* myParaDir;
G4UIcmdWithAString* SwitchCmd;
G4UIcmdWithAnInteger* FlagCmd;
G4UIcmdWithAnInteger* ContCmd; // Containment Check
G4UIcmdWithADouble* StepInX0Cmd;
G4UIcmdWithADoubleAndUnit* EmaxCmd;
G4UIcmdWithADoubleAndUnit* EminCmd;
G4UIcmdWithADoubleAndUnit* EkillCmd;
};
#endif
source/parameterisations/gflash/include/GVFlashHomoShowerTuning.hh
+109 -92
View File
@@ -20,103 +20,120 @@
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: GVFlashHomoShowerTuning.hh,v 1.6 2005/11/30 19:17:08 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ---------------------------------------------------------------
// GEANT 4 class header file
//
// GVFlashHomoShowerTuning
//
// Class description:
//
// Tuning class for GFlash homogeneous shower parameterisation.
// Definitions:
// <t>: shower center of gravity
// T: Depth at shower maximum
// Ec: Critical energy
// X0: Radiation length
// y = E/Ec
//
// Homogeneous media:
// Average shower profile
// (1/E)(dE(t)/dt) = f(t)
// = (beta*t)**(alpha-1)*beta*std::exp(-beta*t)/Gamma(alpha)
// where Gamma is the Gamma function
//
// <t> = alpha/beta
// T = (alpha-1)/beta
// and
// T = ln(y) + t1
// alpha = a1+(a2+a3/Z)ln(y)
// Author: J.P. Wellisch - October 2004
//---------------------------------------------------------------
#ifndef GVFlashHomoShowerTuning_hh
#define GVFlashHomoShowerTuning_hh
// J.P. Wellisch, Oct. 2004
class GVFlashHomoShowerTuning
{
public:
// Definitions:
// <t>: shower center of gravity
// T: Depth at shower maximum
// Ec: Critical energy
// y = E/Ec
// X0: Radiation length
// Homogeneous media:
// Avarage shower profile
// (1/E)(dE(t)/dt) = f(t) = (beta*t)**(alpha-1)*beta*std::exp(-beta*t)/Gamma(alpha)
// where Gamma: The Gamma function
//
// <t> = alpha/beta
// T = (alpha-1)/beta
// and
// T = ln(y) + t1
// alpha = a1+(a2+a3/Z)ln(y)
virtual G4double ParAveT1(){ return -0.858;} // t1
virtual G4double ParAveA1(){ return 0.21; } // a1
virtual G4double ParAveA2(){ return 0.492; } // a2
virtual G4double ParAveA3(){ return 2.38; } // a3
// std::sqrt(var(ln(T))) = 1/(t+t2*ln(y))
virtual G4double ParSigLogT1(){ return -1.4;} // t1
virtual G4double ParSigLogT2(){ return 1.26;} // t2
// std::sqrt(var(ln(alpha))) = 1/(a1+a2*ln(y))
virtual G4double ParSigLogA1(){ return -0.58;} // a1
virtual G4double ParSigLogA2(){ return 0.86; } // a2
// Correlation(ln(T),ln(alpha))=r1+r2*ln(y)
virtual G4double ParRho1(){ return 0.705; } // r1
virtual G4double ParRho2(){ return -0.023;} // r2
// 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
//
// Rc (t/T)= z1 +z2*t/T
// z1 = c1+c2*ln(E/GeV)
// z2 = c3+c4*Z
virtual G4double ParRC1(){ return 0.0251; } // c1
virtual G4double ParRC2(){ return 0.00319; } // c2
virtual G4double ParRC3(){ return 0.1162; } // c3
virtual G4double ParRC4(){ return -0.000381;} // c4
// 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 ParRT1(){ return 0.659; } // t1
virtual G4double ParRT2(){ return -0.00309;} // t2
virtual G4double ParRT3(){ return 0.645; } // k2
virtual G4double ParRT4(){ return -2.59; } // k3
virtual G4double ParRT5(){ return 0.3585; } // t5
virtual G4double ParRT6(){ return 0.0412; } // t6
// p(t/T) = p1*std::exp((p2-t/T)/p3 - std::exp((p2-t/T)/p3))
// p1 = c1+c2*Z
// p2 = c3+c4*Z
// p3 = c5 + c6*ln(E/GeV)
virtual G4double ParWC1(){ return 2.632; } // c1
virtual G4double ParWC2(){ return -0.00094;} // c2
virtual G4double ParWC3(){ return 0.401; } // c3
virtual G4double ParWC4(){ return 0.00187; } // c4
virtual G4double ParWC5(){ return 1.313; } // c5
virtual G4double ParWC6(){ return -0.0686; } // c6
// Fluctuations on radial profiles through number of spots
// The total number of spots needed for a shower is
// Ns = n1*ln(Z)(E/GeV)**n2
virtual G4double ParSpotN1(){ return 93.; } // n1
virtual G4double ParSpotN2(){ return 0.876;} // 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)
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
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 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)
// 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
virtual G4double ParRC1(){ return 0.0251; } // c1
virtual G4double ParRC2(){ return 0.00319; } // c2
virtual G4double ParRC3(){ return 0.1162; } // c3
virtual G4double ParRC4(){ return -0.000381;} // c4
// 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
virtual G4double ParRT4(){ return -2.59; } // k3
virtual G4double ParRT5(){ return 0.3585; } // t5
virtual G4double ParRT6(){ return 0.0412; } // t6
// 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
virtual G4double ParWC4(){ return 0.00187; } // c4
virtual G4double ParWC5(){ return 1.313; } // c5
virtual G4double ParWC6(){ return -0.0686; } // c6
// p(t/T) = p1*std::exp((p2-t/T)/p3 - std::exp((p2-t/T)/p3))
// p1 = c1+c2*Z
// p2 = c3+c4*Z
// p3 = c5 + c6*ln(E/GeV)
virtual G4double ParSpotN1(){ return 93.; } // n1
virtual G4double ParSpotN2(){ return 0.876;} // n2
// Fluctuations on radial profiles through number of spots
// The total number of spots needed for a shower is
// 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)
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
};
#endif
source/parameterisations/gflash/include/GVFlashShowerParameterisation.hh
+93
View File
@@ -0,0 +1,93 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//
// $Id: GVFlashShowerParameterisation.hh,v 1.1 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// GVFlashShowerParameterisation
//
// Class description:
//
// Base class for GFlash shower parameterisation.
// Author: Joanna Weng - 11.2005
//---------------------------------------------------------------
#ifndef GVFlashShowerParameterisation_h
#define GVFlashShowerParameterisation_h 1
#include "globals.hh"
#include "GVFlashHomoShowerTuning.hh"
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;
};
#endif
source/parameterisations/gflash/include/Gamma.hh
+40 -22
View File
@@ -20,33 +20,51 @@
// * statement, and all its terms. *
// ********************************************************************
//
//
//
// $Id: Gamma.hh,v 1.5 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
//---------------------------------------------------------------
// GEANT 4 class header file
//
// Gamma
//
// Class description:
//
// Gamma function.
//---------------------------------------------------------------
#ifndef MYGAMMA_H
#define MYGAMMA_H
#include <cmath>
class MyGamma {
public:
MyGamma ();
~MyGamma();
double Gamma(double z);
double Gamma(double a,double x);
private:
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 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 Log(double x){ return std::log(x); }
static double Exp(double x){ return std::exp(x); }
class MyGamma
{
public:
MyGamma ();
~MyGamma();
double Gamma(double z);
double Gamma(double a,double x);
private:
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 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 Log(double x) { return std::log(x); }
static double Exp(double x) { return std::exp(x); }
};
#endif
source/parameterisations/gflash/src/GFlashEnergySpot.cc
+14 -5
View File
@@ -20,23 +20,32 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng, 9.11.04
// $Id: GFlashEnergySpot.cc,v 1.4 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ---------------- GFlashEnergySpot ----------------
//
// Author: Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include "G4VisAttributes.hh"
#include "G4Colour.hh"
#include "G4Polyline.hh"
#include "G4VVisManager.hh"
#include "G4Step.hh"
//GFlash
#include "GFlashEnergySpot.hh"
GFlashEnergySpot::GFlashEnergySpot() {}
GFlashEnergySpot::GFlashEnergySpot(const G4ThreeVector& point, G4double E)
{
Point = point;
Energy = E;
// initialize shower start @@@@@
Point = point;
Energy = E;
// initialize shower start @@@@@
}
GFlashEnergySpot::~GFlashEnergySpot() {}
source/parameterisations/gflash/src/GFlashHitMaker.cc
+79 -64
View File
@@ -20,7 +20,17 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by E.Barberio & Joanna Weng 9.11.2004
// $Id: GFlashHitMaker.cc,v 1.6 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ---------------- GFlashHitMaker ----------------
//
// Authors: E.Barberio & Joanna Weng
// ------------------------------------------------------------
#include "G4ios.hh"
#include "G4TransportationManager.hh"
@@ -33,75 +43,80 @@
GFlashHitMaker::GFlashHitMaker()
{
fTouchableHandle = new G4TouchableHistory(); // talk to ?@@@
fpNavigator = new G4Navigator();
fNaviSetup = false;
fTouchableHandle = new G4TouchableHistory(); // talk to ?@@@
fpNavigator = new G4Navigator();
fNaviSetup = false;
}
GFlashHitMaker::~GFlashHitMaker()
{
delete fpNavigator;
delete fpNavigator;
}
void GFlashHitMaker::make(GFlashEnergySpot * aSpot, const G4FastTrack * aT)
{
// Locate the spot
if (!fNaviSetup)
{
fpNavigator->
SetWorldVolume(G4TransportationManager::GetTransportationManager()->
GetNavigatorForTracking()->GetWorldVolume() );
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(), fTouchableHandle(), false);
fNaviSetup = true;
}
else
{
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(), fTouchableHandle());
}
//--------------------------------------
// Fills attribute of the G4Step needed
// by our sensitive detector:
//-------------------------------------
// set spot information:
G4GFlashSpot theSpot(aSpot, aT, fTouchableHandle);
///Navigator
//--------------------------------------
// 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();
G4VSensitiveDetector* pSensitive;
if( pCurrentVolume != 0 )
{
pSensitive = pCurrentVolume->GetLogicalVolume()->GetSensitiveDetector();
G4VGFlashSensitiveDetector * gflashSensitive =
dynamic_cast<G4VGFlashSensitiveDetector * > (pSensitive);
if( gflashSensitive )
{
gflashSensitive->Hit(&theSpot);
}
else if ( (!gflashSensitive ) &&
( pSensitive ) &&
( pCurrentVolume->GetLogicalVolume()->GetFastSimulationManager() )
) // Using gflash without implementing the
// gflashSensitive detector interface -> not allowed!
{
std::cout<<"When using GFlash in geant4, please implement the "<<std::endl;
std::cout<<"G4VGFlashSensitiveDetector interface in addition to the"<<std::endl;
std::cout<<"G4VSensitiveDetector interface in the relevant sensitive detector."<<std::endl;
G4Exception("GFlashHitMaker: G4VGFlashSensitiveDetector interface not implemented");
}
}
else
{
#ifdef GFLASH_DEBUG
std::cout << "GFlashHitMaker::Out of volume "<<endl;
#endif
}
// Locate the spot
if (!fNaviSetup)
{
fpNavigator->
SetWorldVolume(G4TransportationManager::GetTransportationManager()->
GetNavigatorForTracking()->GetWorldVolume() );
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(),
fTouchableHandle(), false);
fNaviSetup = true;
}
else
{
fpNavigator->
LocateGlobalPointAndUpdateTouchable(aSpot->GetPosition(),
fTouchableHandle());
}
//--------------------------------------
// Fills attribute of the G4Step needed
// by our sensitive detector:
//-------------------------------------
// set spot information:
G4GFlashSpot theSpot(aSpot, aT, fTouchableHandle);
///Navigator
//--------------------------------------
// 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();
G4VSensitiveDetector* pSensitive;
if( pCurrentVolume != 0 )
{
pSensitive = pCurrentVolume->GetLogicalVolume()->GetSensitiveDetector();
G4VGFlashSensitiveDetector * gflashSensitive =
dynamic_cast<G4VGFlashSensitiveDetector * > (pSensitive);
if( gflashSensitive )
{
gflashSensitive->Hit(&theSpot);
}
else if ( (!gflashSensitive ) &&
( pSensitive ) &&
( pCurrentVolume->GetLogicalVolume()->GetFastSimulationManager() )
) // Using gflash without implementing the
// gflashSensitive detector interface -> not allowed!
{
G4cerr << "ERROR - GFlashHitMaker::make()" << G4endl
<< " It is required to implement the "<< G4endl
<< " G4VGFlashSensitiveDetector interface in "<< G4endl
<< " addition to the usual SensitiveDetector class."
<< G4endl;
G4Exception("GFlashHitMaker::make()", "InvalidSetup", FatalException,
"G4VGFlashSensitiveDetector interface not implemented.");
}
}
else
{
#ifdef GFLASH_DEBUG
G4cout << "GFlashHitMaker::Out of volume "<< G4endl;
#endif
}
}
source/parameterisations/gflash/src/GFlashHomoShowerParameterisation.cc
+289
View File
@@ -0,0 +1,289 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: GFlashHomoShowerParameterisation.cc,v 1.4 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ------- GFlashHomoShowerParameterisation -------
//
// Authors: E.Barberio & Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include "GVFlashShowerParameterisation.hh"
#include "GFlashHomoShowerParameterisation.hh"
#include <cmath>
#include "Randomize.hh"
#include "G4ios.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
GFlashHomoShowerParameterisation::
GFlashHomoShowerParameterisation(G4Material * aMat,
GVFlashHomoShowerTuning * aPar)
: GVFlashShowerParameterisation()
{
if(!aPar) { thePar = new GVFlashHomoShowerTuning; }
else { thePar = aPar; }
SetMaterial(aMat);
PrintMaterial(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();
// Variance of shower max
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
ParSigLogA2 = thePar->ParSigLogA2();
// correlation alpha%T
//
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();
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();
ParWC6 = thePar->ParWC6();
ParRT1 = thePar->ParRT1();
ParRT2 = thePar->ParRT2();
ParRT3 = thePar->ParRT3();
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();
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();
// Inits
NSpot = 0.00;
AlphaNSpot = 0.00;
TNSpot = 0.00;
BetaNSpot = 0.00;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
G4cout << "/********************************************/ " << G4endl;
G4cout << " - GFlashHomoShowerParameterisation::Constructor - " << G4endl;
G4cout << "/********************************************/ " << G4endl;
}
void GFlashHomoShowerParameterisation::SetMaterial(G4Material *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();
}
GFlashHomoShowerParameterisation::~GFlashHomoShowerParameterisation()
{}
void GFlashHomoShowerParameterisation::
GenerateLongitudinalProfile(G4double Energy)
{
if (material==0)
{
G4Exception("GFlashHomoShowerParameterisation::GenerateLongitudinalProfile()",
"InvalidSetup", FatalException, "No material initialized!");
}
G4double y = Energy/Ec;
ComputeLongitudinalParameters(y);
GenerateEnergyProfile(y);
GenerateNSpotProfile(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>
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 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;
}
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
}
G4double GFlashHomoShowerParameterisation::
IntegrateEneLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1= Betah*LongitudinalStepInX0;
G4float x2= Alphah;
float x3 = gam(x1,x2);
G4double DEne=x3;
return DEne;
}
G4double GFlashHomoShowerParameterisation::
IntegrateNspLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1 = BetaNSpot*LongitudinalStepInX0;
G4float x2 = AlphaNSpot;
G4float x3 = gam(x1,x2);
G4double DNsp = x3;
return DNsp;
}
G4double GFlashHomoShowerParameterisation::
GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition)
{
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);
}
G4double Radius;
G4double Random1 = G4UniformRand();
G4double Random2 = G4UniformRand();
if(Random1 <WeightCore) //WeightCore = p < w_i
{
Radius = Rm * RadiusCore * std::sqrt( Random2/(1. - Random2) );
}
else
{
Radius = Rm * RadiusTail * std::sqrt( Random2/(1. - Random2) );
}
Radius = std::min(Radius,DBL_MAX);
return Radius;
}
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
return 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 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
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
}
G4double GFlashHomoShowerParameterisation::
GenerateExponential(const G4double /* Energy */ )
{
G4double ParExp1 = 9./7.*X0;
G4double random = -ParExp1*CLHEP::RandExponential::shoot() ;
return random;
}
source/parameterisations/gflash/src/GFlashHomoShowerParamterisation.cc
-339
View File
@@ -1,339 +0,0 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
//E.Barberio + Joanna Weng 9.11.2004
#include "GFlashHomoShowerParamterisation.hh"
#include <cmath>
#include <CLHEP/Random/Randomize.h>
#include "G4ios.hh"
#include "G4Material.hh"
#include "Gamma.hh" // @@@@
#include "G4MaterialTable.hh"
#include "Randomize.hh"
GFlashHomoShowerParamterisation::
GFlashHomoShowerParamterisation(G4Material * aMat, GVFlashHomoShowerTuning * aPar)
{
if(!aPar) thePar = new GVFlashHomoShowerTuning;
else thePar = aPar;
SetMaterial(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();
// Variance of shower max
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
ParSigLogA2 = thePar->ParSigLogA2();
// correlation alpha%T
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();
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();
ParWC6 = thePar->ParWC6();
ParRT1 = thePar->ParRT1();
ParRT2 = thePar->ParRT2();
ParRT3 = thePar->ParRT3();
ParRT4 = thePar->ParRT4();
ParRT5 = thePar->ParRT5();
ParRT6 = thePar->ParRT6();
// Coeff for fluctuedted radial profiles for a uniform media
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();
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;
RadiusCore = 0.00;
WeightCore = 0.00;
RadiusTail = 0.00;
std::cout<<"/********************************************/ " <<std::endl;
std::cout<<" - GFlashHomoShowerParamterisation::Constructor - " <<std::endl;
std::cout<<"/********************************************/ " <<std::endl;
}
void GFlashHomoShowerParamterisation::SetMaterial(G4Material *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();
}
G4double GFlashHomoShowerParamterisation::GetEffZ(const G4Material * mat )
{
// Returns Z or effective Z=sum(pi*Zi) (if compound/mixture)
// of given material.
// ---
G4double z = 0.;
G4int nofElements = mat->GetNumberOfElements();
if (nofElements > 1)
{
// G4String text = "Effective Z for material mixture (";
// text = text + mat->GetName();
// text = text + ") is used.";
// cout << text <<endl;
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;
}
}
else {
z = mat->GetZ();
}
return z;
}
G4double GFlashHomoShowerParamterisation::GetEffA (const G4Material * mat )
{
// Returns A or effective A=sum(pi*Ai) (if compound/mixture)
// of given material.
// ---
G4double a = 0.;
G4int nofElements = mat->GetNumberOfElements();
if (nofElements > 1)
{
// G4String text = "Effective A for material mixture (";
// text = text + mat->GetName();
// text = text + ") is used."
// cout << text <<endl;
for (G4int i=0; i<nofElements; i++)
{
G4double aOfElement = mat->GetElement(i)->GetA()/(g/mole);
G4double massFraction = mat->GetFractionVector()[i];
// cout << mat->GetElement(i)->GetName() <<" A= "<<aOfElement << " g/mole, Fraction= "<< massFraction <<endl;
a += aOfElement*massFraction;
}
}
else
{
a = mat->GetA()/(g/mole);
}
return a;
}
void GFlashHomoShowerParamterisation::PrintMaterial()
{
std::cout<<"/********************************************/ " <<std::endl;
std::cout<<" - GFlashHomoShowerParamterisation::Material - " <<std::endl;
std::cout<<" Material : " << material->GetName() << std::endl;
std::cout<<" Z = "<< Z << std::endl;
std::cout<<" A = "<< A << std::endl;
std::cout<<" X0 = "<<X0/cm <<" cm" <<std::endl;
std::cout<<" Rm= "<<Rm/cm <<" cm" <<std::endl;
std::cout<<" Ec = "<<Ec/MeV << " MeV"<<std::endl;
std::cout<<"/********************************************/ " <<std::endl;
}
GFlashHomoShowerParamterisation::~GFlashHomoShowerParamterisation()
{}
void GFlashHomoShowerParamterisation::GenerateLongitudinalProfile(G4double Energy)
{
if (material==NULL)
{
G4Exception("GFlashHomoShowerParamterisation: no material initialized");
}
G4double y = Energy/Ec;
ComputeLongitudinalParameters(y);
GenerateEnergyProfile(y);
GenerateNSpotProfile(y);
}
void GFlashHomoShowerParamterisation::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>
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 GFlashHomoShowerParamterisation::GenerateEnergyProfile(G4double /* y */)
{
G4double Correlation1h = std::sqrt((1+Rhoh)/2);
G4double Correlation2h = std::sqrt((1-Rhoh)/2);
G4double Random1 = RandGauss::shoot();
G4double Random2 = RandGauss::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;
}
void GFlashHomoShowerParamterisation::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
}
G4double GFlashHomoShowerParamterisation::IntegrateEneLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1= Betah*LongitudinalStepInX0;
G4float x2= Alphah;
float x3 = gam(x1,x2);
G4double DEne=x3;
return DEne;
}
G4double GFlashHomoShowerParamterisation::IntegrateNspLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0;
G4float x1 = BetaNSpot*LongitudinalStepInX0;
G4float x2 = AlphaNSpot;
float x3 = gam(x1,x2);
G4double DNsp = x3;
return DNsp;
}
G4double GFlashHomoShowerParamterisation::GeneratePhi()
{
G4double Phi = twopi*G4UniformRand() ;
return Phi;
}
G4double GFlashHomoShowerParamterisation::GenerateRadius(G4int ispot, G4double Energy,
G4double LongitudinalPosition)
{
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);
}
G4double Radius;
G4double Random1 = RandFlat::shoot();
G4double Random2 = RandFlat::shoot();
if(Random1 <WeightCore) //WeightCore = p < w_i
{
Radius = Rm * RadiusCore * std::sqrt( Random2/(1. - Random2) );
}
else
{
Radius = Rm * RadiusTail * std::sqrt( Random2/(1. - Random2) );
}
return Radius;
}
G4double GFlashHomoShowerParamterisation::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
return tau;
}
void GFlashHomoShowerParamterisation::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 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
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
}
G4double GFlashHomoShowerParamterisation::GenerateExponential(const G4double /* Energy */ )
{
G4double ParExp1 = 9./7.*X0;
G4double random = -ParExp1*RandExponential::shoot() ;
return random;
}
double GFlashHomoShowerParamterisation::gam(double x, double a) const
{
static MyGamma theG;
return theG.Gamma(a, x);
}
source/parameterisations/gflash/src/GFlashParticleBounds.cc
+54 -43
View File
@@ -20,7 +20,17 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng 9.11.2004
// $Id: GFlashParticleBounds.cc,v 1.3 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ---------------- GFlashParticleBounds ----------------
//
// Author: Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include "G4Electron.hh"
#include "G4Positron.hh"
@@ -29,68 +39,69 @@
GFlashParticleBounds::GFlashParticleBounds()
{
// e+e- defaults
EMinEneToParametrise = 0.10*GeV;
EMaxEneToParametrise = 10000.00*GeV;
EEneToKill = 0.1*GeV; // Energie at which electrons are killed
// e+e- defaults
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)
void GFlashParticleBounds::
SetMinEneToParametrise(G4ParticleDefinition &particleType, G4double enemin)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMinEneToParametrise = enemin;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMinEneToParametrise = enemin;
}
void GFlashParticleBounds::SetMaxEneToParametrise(G4ParticleDefinition &particleType,G4double enemax)
void GFlashParticleBounds::
SetMaxEneToParametrise(G4ParticleDefinition &particleType, G4double enemax)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMaxEneToParametrise = enemax;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMaxEneToParametrise = enemax;
}
void GFlashParticleBounds::SetEneToKill(G4ParticleDefinition &particleType,G4double enekill)
void GFlashParticleBounds::
SetEneToKill(G4ParticleDefinition &particleType, G4double enekill)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EEneToKill = enekill;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EEneToKill = enekill;
}
G4double GFlashParticleBounds::GetMinEneToParametrise(G4ParticleDefinition &particleType)
G4double GFlashParticleBounds::
GetMinEneToParametrise(G4ParticleDefinition &particleType)
{
G4double result = DBL_MAX;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMinEneToParametrise;
}
return result;
G4double result = DBL_MAX;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMinEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::GetMaxEneToParametrise(G4ParticleDefinition &particleType)
G4double GFlashParticleBounds::
GetMaxEneToParametrise(G4ParticleDefinition &particleType)
{
G4double result = 0;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMaxEneToParametrise;
}
return result;
G4double result = 0;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMaxEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::GetEneToKill(G4ParticleDefinition & particleType)
G4double GFlashParticleBounds::
GetEneToKill(G4ParticleDefinition & particleType)
{
if (&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition())
return EEneToKill;
else return (-DBL_MAX);
if (&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition())
return EEneToKill;
else return (-DBL_MAX);
}
source/parameterisations/gflash/src/GFlashSamplingShowerParameterisation.cc
+406
View File
@@ -0,0 +1,406 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: GFlashSamplingShowerParameterisation.cc,v 1.3 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ------- GFlashSamplingShowerParameterisation -------
//
// Authors: E.Barberio & Joanna Weng - 11.2005
// ------------------------------------------------------------
#include "GVFlashShowerParameterisation.hh"
#include "GFlashSamplingShowerParameterisation.hh"
#include <cmath>
#include "Randomize.hh"
#include "G4ios.hh"
#include "G4Material.hh"
#include "G4MaterialTable.hh"
GFlashSamplingShowerParameterisation::
GFlashSamplingShowerParameterisation(G4Material* aMat1, G4Material* aMat2,
G4double d1, G4double d2,
GFlashSamplingShowerTuning* aPar)
: GVFlashShowerParameterisation()
{
if(!aPar) { thePar = new GFlashSamplingShowerTuning; }
else { thePar = aPar; }
SetMaterial(aMat1,aMat2 );
this->d1=d1;
this->d2=d2;
// 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();
// Sampling
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->ParSigLogT1(); // Sigma T1 (-2.5 + 1.25 ln y)**-1
ParsSigLogT2 = thePar->ParSigLogT2();
// variance of 'alpha'
ParsSigLogA1 = thePar->ParSigLogA1(); // Sigma a (-0.82 + 0.79 ln y)**-1
ParsSigLogA2 = thePar->ParSigLogA2();
// correlation alpha%T
ParsRho1 = thePar->ParRho1(); // Rho = 0.784 -0.023 ln y
ParsRho2 = 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();
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();
ParWC6 = thePar->ParWC6();
ParRT1 = thePar->ParRT1();
ParRT2 = thePar->ParRT2();
ParRT3 = thePar->ParRT3();
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();
// 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();
// Inits
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;
}
// ------------------------------------------------------------
GFlashSamplingShowerParameterisation::~GFlashSamplingShowerParameterisation()
{}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::
SetMaterial(G4Material *mat1, G4Material *mat2)
{
G4double Es = 21*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;
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();
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::ComputeZAX0EFFetc()
{
G4cout << "/************ ComputeZAX0EFFetc ************/" << G4endl;
G4cout << " - GFlashSamplingShowerParameterisation::Material - " << G4endl;
G4double Es = 21*MeV; //constant
// 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*Z2 ) + (W2*Z1); //X0*Es/Ec;
Aeff = ( W1*A1 ) + (W2*A2);
X0eff =(1/ (( W1 / X01) +( W2 / X02)));
Rhoeff = ( (d1 *density1 ) + (d2 * density2 ))/G4double (d2 + d1 );
Rmeff = 1/ ((((W1*Ec1)/ X01) + ((W2* Ec2)/ X02) ) / Es ) ;
Eceff = X0eff *((W1*Ec1)/ X01 + (W2* Ec2)/ X02 );
Fs = X0eff/G4double ((d1/mm )+(d2/mm) );
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;
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;
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::
GenerateLongitudinalProfile(G4double Energy)
{
if ((material1==0) || (material2 ==0))
{
G4Exception("GFlashSamplingShowerParameterisation::GenerateLongitudinalProfile()",
"InvalidSetup", FatalException, "No material initialized!");
}
G4double y = Energy/Eceff;
ComputeLongitudinalParameters(y);
GenerateEnergyProfile(y);
GenerateNSpotProfile(y);
}
// ------------------------------------------------------------
void
GFlashSamplingShowerParameterisation::ComputeLongitudinalParameters(G4double y)
{
AveLogTmaxh = log(std::max(ParAveT1 +log(y),0.1)); //ok
AveLogAlphah = log(std::max(ParAveA1 + (ParAveA2+ParAveA3/Zeff)*log(y),.1)); //ok
//hom
SigmaLogTmaxh = std::min(0.5,1.00/( ParSigLogT1 + ParSigLogT2*log(y)) ); //ok
SigmaLogAlphah = std::min(0.5,1.00/( ParSigLogA1 + ParSigLogA2*log(y))); //ok
Rhoh = ParRho1+ParRho2*log(y);//ok
// if sampling
AveLogTmax = std::max(0.1,log(exp(AveLogTmaxh)
+ ParsAveT1/Fs + ParsAveT2*(1-ehat))); //ok
AveLogAlpha = std::max(0.1,log(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
}
// ------------------------------------------------------------
void GFlashSamplingShowerParameterisation::GenerateEnergyProfile(G4double /* y */)
{
G4double Correlation1 = std::sqrt((1+Rho)/2);
G4double Correlation2 = std::sqrt((1-Rho)/2);
G4double Correlation1h = sqrt((1+Rhoh)/2);
G4double Correlation2h = sqrt((1-Rhoh)/2);
G4double Random1 = G4RandGauss::shoot();
G4double Random2 = G4RandGauss::shoot();
Tmax = std::max(1.,exp( AveLogTmax + SigmaLogTmax *
(Correlation1*Random1 + Correlation2*Random2) ));
Alpha = std::max(1.1,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 );
}
// ------------------------------------------------------------
G4double
GFlashSamplingShowerParameterisation::
ApplySampling(const G4double DEne, const G4double )
{
G4double DEneFluctuated = DEne;
G4double Resolution = pow(SamplingResolution,2);
// +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 = CLHEP::RandGamma::shoot(x1, 1.0)*Resolution;
DEneFluctuated=x2;
}
return DEneFluctuated;
}
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
IntegrateEneLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0eff;
G4float x1= Betah*LongitudinalStepInX0;
G4float x2= Alphah;
float x3 = gam(x1,x2);
G4double DEne=x3;
return DEne;
}
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
IntegrateNspLongitudinal(G4double LongitudinalStep)
{
G4double LongitudinalStepInX0 = LongitudinalStep / X0eff;
G4float x1 = BetaNSpot*LongitudinalStepInX0;
G4float x2 = AlphaNSpot;
G4float x3 = gam(x1,x2);
G4double DNsp = x3;
return DNsp;
}
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
GenerateRadius(G4int ispot, G4double Energy, G4double LongitudinalPosition)
{
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);
}
G4double Radius;
G4double Random1 = G4UniformRand();
G4double Random2 = G4UniformRand();
if(Random1 <WeightCore) //WeightCore = p < w_i
{
Radius = Rmeff * RadiusCore * std::sqrt( Random2/(1. - Random2) );
}
else
{
Radius = Rmeff * RadiusTail * std::sqrt( Random2/(1. - Random2) );
}
Radius = std::min(Radius,DBL_MAX);
return Radius;
}
// ------------------------------------------------------------
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
return 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
// sampling calorimeter
RadiusCore = RadiusCore + ParsRC1*(1-ehat) + ParsRC2/Fs*exp(-Tau); //ok
WeightCore = WeightCore + (1-ehat)
* (ParsWC1+ParsWC2/Fs * exp(-pow((Tau-1.),2))); //ok
RadiusTail = RadiusTail + (1-ehat)* ParsRT1+ ParsRT2/Fs *exp(-Tau); //ok
}
// ------------------------------------------------------------
G4double GFlashSamplingShowerParameterisation::
GenerateExponential(const G4double /* Energy */ )
{
G4double ParExp1 = 9./7.*X0eff;
G4double random = -ParExp1*CLHEP::RandExponential::shoot() ;
return random;
}
source/parameterisations/gflash/src/GFlashShowerModel.cc
+305 -265
View File
@@ -20,11 +20,20 @@
// * statement, and all its terms. *
// ********************************************************************
//
//E.Barberio & Joanna Weng
// $Id: GFlashShowerModel.cc,v 1.12 2005/12/01 18:20:28 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ---------------- GFlashShowerModel ----------------
//
// Authors: E.Barberio & Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4Gamma.hh"
#include "G4NeutrinoE.hh"
#include "G4NeutrinoMu.hh"
#include "G4NeutrinoTau.hh"
@@ -38,309 +47,340 @@
#include "geomdefs.hh"
#include "GFlashShowerModel.hh"
#include "GFlashHomoShowerParamterisation.hh"
#include "GFlashHomoShowerParameterisation.hh"
#include "GFlashSamplingShowerParameterisation.hh"
#include "GFlashEnergySpot.hh"
GFlashShowerModel::GFlashShowerModel(G4String modelName, G4LogicalVolume* envelope)
: G4VFastSimulationModel(modelName, envelope)
GFlashShowerModel::GFlashShowerModel(G4String modelName,
G4Envelope* envelope)
: G4VFastSimulationModel(modelName, envelope),
PBound(0), Parameterisation(0), HMaker(0)
{
FlagParamType = 0;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
FlagParamType = 0;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::GFlashShowerModel(G4String modelName)
: G4VFastSimulationModel(modelName)
: G4VFastSimulationModel(modelName),
PBound(0), Parameterisation(0), HMaker(0)
{
FlagParamType =1;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
FlagParamType =1;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::~GFlashShowerModel()
{
Messenger = new GFlashShowerModelMessenger(this);
delete Messenger;
}
G4bool GFlashShowerModel::IsApplicable(const G4ParticleDefinition& particleType)
G4bool
GFlashShowerModel::IsApplicable(const G4ParticleDefinition& particleType)
{
return
&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition();
return
&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition();
}
/*********************************************************************/
/* Checks whether conditions of fast parametrisation are fullfilled */
/**********************************************************************/
/* Checks whether conditions of fast parameterisation are fullfilled */
/**********************************************************************/
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) )
{
///check conditions depending on particle flavour
Parametrisation->GenerateLongitudinalProfile(ParticleEnergy); // performance to be optimized @@@@@@@
select = CheckParticleDefAndContainment(fastTrack);
if (select) EnergyStop= PBound->GetEneToKill(ParticleType);
}
}
return select;
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) )
{
// check conditions depending on particle flavour
// performance to be optimized @@@@@@@
Parameterisation->GenerateLongitudinalProfile(ParticleEnergy);
select = CheckParticleDefAndContainment(fastTrack);
if (select) EnergyStop= PBound->GetEneToKill(ParticleType);
}
}
return select;
}
G4bool GFlashShowerModel::CheckParticleDefAndContainment(const G4FastTrack& fastTrack)
G4bool
GFlashShowerModel::CheckParticleDefAndContainment(const G4FastTrack& fastTrack)
{
G4bool filter=false;
G4ParticleDefinition * ParticleType = fastTrack.GetPrimaryTrack()->GetDefinition();
if( ParticleType == G4Electron::ElectronDefinition() ||
ParticleType == G4Positron::PositronDefinition() )
{
filter=true;
if(FlagParticleContainment == 1)
{
filter=CheckContainment(fastTrack);
}
}
return filter;
G4bool filter=false;
G4ParticleDefinition * ParticleType =
fastTrack.GetPrimaryTrack()->GetDefinition();
if( ParticleType == G4Electron::ElectronDefinition() ||
ParticleType == G4Positron::PositronDefinition() )
{
filter=true;
if(FlagParticleContainment == 1)
{
filter=CheckContainment(fastTrack);
}
}
return filter;
}
G4bool GFlashShowerModel::CheckContainment(const G4FastTrack& fastTrack)
{
//Note: typedef Hep3Vector G4ThreeVector;
G4bool filter=false;
//track informations
G4ThreeVector DirectionShower = fastTrack.GetPrimaryTrackLocalDirection();
G4ThreeVector InitialPositionShower = fastTrack.GetPrimaryTrackLocalPosition();
G4ThreeVector OrthoShower, CrossShower;
//Returns orthogonal vector
OrthoShower = DirectionShower.orthogonal();
// Shower in direction perpendicular to OrthoShower and DirectionShower
CrossShower = DirectionShower.cross(OrthoShower);
G4double R = Parametrisation->GetAveR90();
G4double Z = Parametrisation->GetAveT90();
G4int CosPhi[4] = {1,0,-1,0};
G4int SinPhi[4] = {0,1,0,-1};
G4ThreeVector Position;
G4int NlateralInside=0;
//pointer to soild we're in
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++;
}
//chose to parametrise or flag when all inetc...
if(NlateralInside==4) filter=true;
// std::cout << " points = " <<NlateralInside << std::endl;
return filter;
G4bool filter=false;
// track informations
G4ThreeVector DirectionShower=fastTrack.GetPrimaryTrackLocalDirection();
G4ThreeVector InitialPositionShower=fastTrack.GetPrimaryTrackLocalPosition();
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};
G4ThreeVector Position;
G4int NlateralInside=0;
// pointer to solid we're in
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++;
}
// choose to parameterise or flag when all inetc...
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);
// parametrise electrons
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.SetPrimaryTrackPathLength(0.0);
fastStep.SetTotalEnergyDeposited(fastTrack.GetPrimaryTrack()->GetKineticEnergy());
//-----------------------------
// 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 OrthoShower, CrossShower;
OrthoShower = DirectionShower.orthogonal();
CrossShower = DirectionShower.cross(OrthoShower);
//--------------------------------
///Generate longitudinal profile
//--------------------------------
Parametrisation->GenerateLongitudinalProfile(Energy); // performane 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;
// starting point of the shower:
G4ThreeVector PositionShower = fastTrack.GetPrimaryTrack()->GetPosition();
G4ThreeVector NewPositionShower = PositionShower;
G4double StepLenght = 0.00;
G4int NSpotDeposited =0;
//--------------------------
/// Begin Longitudinal Loop
//-------------------------
do
{
//determine step size=min(1Xo,next boundary)
G4double stepLength = StepInX0*Parametrisation->GetX0();
if(Bound < stepLength)
{
Dz = Bound;
Bound = 0.00;
}
else
{
Dz = stepLength;
Bound = Bound-Dz;
}
ZEndStep=ZEndStep+Dz;
// Determine Energy Release in Step
if(EnergyNow > EnergyStop)
{
LastEneIntegral = EneIntegral;
EneIntegral = Parametrisation->IntegrateEneLongitudinal(ZEndStep);
DEne = std::min( EnergyNow, (EneIntegral-LastEneIntegral)*Energy);
LastNspIntegral = NspIntegral;
NspIntegral = Parametrisation->IntegrateNspLongitudinal(ZEndStep);
DNsp = std::max(1., std::floor( (NspIntegral-LastNspIntegral)*Parametrisation->GetNspot() ) );
}
// end of the shower
else
{
DEne = EnergyNow;
DNsp = std::max(1., std::floor( (1.- NspIntegral)*Parametrisation->GetNspot() ));
}
EnergyNow = EnergyNow - DEne;
// apply sampling fluctuation
// G4double DEneSampling = Parametrisation->ApplySampling(DEne,Energy);
//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 (int i = 0; i < DNsp; i++)
{
NSpotDeposited++;
GFlashEnergySpot Spot;
//Spot energy: the same for all spots
Spot.SetEnergy( DEne / DNsp );
G4double PhiSpot = Parametrisation->GeneratePhi(); // phi of spot
G4double RSpot = Parametrisation->GenerateRadius(i,Energy,ZEndStep-Dz/2.); // radius of spot
///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;
Spot.SetPosition(SpotPosition);
//Generate Hits of this spot
HMaker->make(&Spot, &fastTrack);
}
}
while(EnergyNow > 0.0 && Bound> 0.0);
//---------------
/// End Loop
//-------------
// std::cout<<"--- ElectronDoit --- "<<std::endl;
fastStep.KillPrimaryTrack();
fastStep.SetPrimaryTrackPathLength(0.0);
fastStep.SetTotalEnergyDeposited(fastTrack.GetPrimaryTrack()->
GetKineticEnergy());
//-----------------------------
// 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 OrthoShower, CrossShower;
OrthoShower = DirectionShower.orthogonal();
CrossShower = DirectionShower.cross(OrthoShower);
//--------------------------------
///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;
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;
// starting point of the shower:
G4ThreeVector PositionShower = fastTrack.GetPrimaryTrack()->GetPosition();
G4ThreeVector NewPositionShower = PositionShower;
G4double StepLenght = 0.00;
G4int NSpotDeposited =0;
//--------------------------
/// Begin Longitudinal Loop
//-------------------------
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;
}
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() ));
}
// end of the shower
else
{
DEne = EnergyNow;
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);
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 (int i = 0; i < DNsp; i++)
{
NSpotDeposited++;
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;
Spot.SetPosition(SpotPosition);
//Generate Hits of this spot
HMaker->make(&Spot, &fastTrack);
}
}
while(EnergyNow > 0.0 && Bound> 0.0);
//---------------
/// End Loop
//---------------
}
/* void GFlashShowerModel::GammaDoIt(const G4FastTrack& fastTrack, G4FastStep& fastStep)
/*
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.
// Kill the particle to be parametrised
fastStep.KillPrimaryTrack();
fastStep.SetPrimaryTrackPathLength(0.0);
fastStep.SetTotalEnergyDeposited(fastTrack.GetPrimaryTrack()->GetKineticEnergy());
//other settings????
feSpotList.clear();
//-----------------------------
// 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();
// starting point of the shower:
G4ThreeVector PositionShower
= fastTrack.GetPrimaryTrack()->GetPosition();
//G4double DEneSampling = Parametrisation->ApplySampling(Energy,Energy);
//if(DEneSampling <= 0.00) DEneSampling=Energy;
if(Energy > 0.0)
{
G4double dist = Parametrisation->GenerateExponential(Energy);
GFlashEnergySpot Spot;
Spot.SetEnergy( Energy );
G4ThreeVector SpotPosition = PositionShower + dist*DirectionShower;
Spot.SetPosition(SpotPosition);
// Record the Spot:
feSpotList.push_back(Spot);
//Generate Hits of this spot
HMaker->make(Spot);
}
if( fastTrack.GetPrimaryTrack()->GetKineticEnergy() > EnergyStop )
return;
//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();
//-----------------------------
// 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();
// starting point of the shower:
G4ThreeVector PositionShower =
fastTrack.GetPrimaryTrack()->GetPosition();
//G4double DEneSampling = Parameterisation->ApplySampling(Energy,Energy);
//if(DEneSampling <= 0.00) DEneSampling=Energy;
if(Energy > 0.0)
{
G4double dist = Parameterisation->GenerateExponential(Energy);
GFlashEnergySpot Spot;
Spot.SetEnergy( Energy );
G4ThreeVector SpotPosition = PositionShower + dist*DirectionShower;
Spot.SetPosition(SpotPosition);
// Record the Spot:
feSpotList.push_back(Spot);
//Generate Hits of this spot
HMaker->make(Spot);
}
}
*/
source/parameterisations/gflash/src/GFlashShowerModelMessenger.cc
+120 -103
View File
@@ -20,7 +20,17 @@
// * statement, and all its terms. *
// ********************************************************************
//
// Created by Joanna Weng, 9.11.04
// $Id: GFlashShowerModelMessenger.cc,v 1.5 2005/11/28 18:09:26 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ------------- GFlashShowerModelMessenger -------------
//
// Author: Joanna Weng - 9.11.2004
// ------------------------------------------------------------
#include "GFlashShowerModelMessenger.hh"
#include "GFlashShowerModel.hh"
@@ -35,122 +45,129 @@
#include "globals.hh"
#include <iomanip>
#include <strstream>
#include <sstream>
GFlashShowerModelMessenger::GFlashShowerModelMessenger(GFlashShowerModel * aModel)
GFlashShowerModelMessenger::
GFlashShowerModelMessenger(GFlashShowerModel * aModel)
{
myParaDir = new G4UIdirectory("/GFlash/");
myParaDir->SetGuidance("Parametrisation control.");
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);
ContCmd->SetGuidance("Defines if Containment is checked");
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);
EminCmd->SetGuidance("Set minimum kinetic energy to trigger parametrisation");
EminCmd->SetParameterName("Emin",false,false);
EminCmd->SetDefaultUnit("GeV");
EminCmd->SetUnitCategory("Energy");
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->SetDefaultUnit("GeV");
EmaxCmd->SetUnitCategory("Energy");
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->SetDefaultUnit("GeV");
EkillCmd->SetUnitCategory("Energy");
EkillCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
myParaDir = new G4UIdirectory("/GFlash/");
myParaDir->SetGuidance("Parametrisation control.");
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);
ContCmd->SetGuidance("Defines if Containment is checked");
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);
EminCmd->SetGuidance("Set minimum kinetic energy to trigger parametrisation");
EminCmd->SetParameterName("Emin",false,false);
EminCmd->SetDefaultUnit("GeV");
EminCmd->SetUnitCategory("Energy");
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->SetDefaultUnit("GeV");
EmaxCmd->SetUnitCategory("Energy");
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->SetDefaultUnit("GeV");
EkillCmd->SetUnitCategory("Energy");
EkillCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
}
GFlashShowerModelMessenger::~GFlashShowerModelMessenger()
{
delete ContCmd;
delete FlagCmd;
delete StepInX0Cmd;
delete EminCmd;
delete EmaxCmd;
delete EkillCmd;
delete ContCmd;
delete FlagCmd;
delete StepInX0Cmd;
delete EminCmd;
delete EmaxCmd;
delete EkillCmd;
}
void GFlashShowerModelMessenger::SetNewValue(G4UIcommand * command,G4String newValues)
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 ) {
myModel->PBound->SetMinEneToParametrise(*G4Electron::ElectronDefinition() ,EminCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EmaxCmd ) {
myModel->PBound->SetMaxEneToParametrise(*G4Electron::ElectronDefinition(), EmaxCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EkillCmd ) {
myModel->PBound->SetEneToKill(*G4Electron::ElectronDefinition(), EkillCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
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 ) {
myModel->PBound->SetMinEneToParametrise(*G4Electron::ElectronDefinition(),
EminCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EmaxCmd ) {
myModel->PBound->SetMaxEneToParametrise(*G4Electron::ElectronDefinition(),
EmaxCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
else if( command == EkillCmd ) {
myModel->PBound->SetEneToKill(*G4Electron::ElectronDefinition(),
EkillCmd->GetNewDoubleValue(newValues));
this->GetCurrentValue(command);
}
}
G4String GFlashShowerModelMessenger::GetCurrentValue(G4UIcommand * command)
{
G4String returnValue('\0');
char line[255];
std::ostrstream os(line,255);
if( command == FlagCmd ) {
os <<"/GFlash/flag " << myModel->GetFlagParamType() << '\0';
returnValue = G4String(line);
}
else if( command == EkillCmd ) {
os <<"/GFlash/Ekill "<< myModel->PBound->GetEneToKill(*G4Electron::ElectronDefinition())/GeV << " GeV" << '\0';
returnValue = G4String(line);
}
else if( command == EminCmd ) {
os <<"/GFlash/Emin "<< myModel->PBound->GetMinEneToParametrise(*G4Electron::ElectronDefinition())/GeV << " GeV" << '\0';
returnValue = G4String(line);
}
else if( command == EmaxCmd ) {
os <<"/GFlash/Emax " <<myModel->PBound->GetMaxEneToParametrise(*G4Electron::ElectronDefinition())/GeV << " GeV" << '\0';
returnValue = G4String(line);
}
return returnValue;
G4String returnValue('\0');
std::ostringstream os;
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
<< " GeV" << '\0';
returnValue = G4String(os.str());
}
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';
returnValue = G4String(os.str());
}
return returnValue;
}
source/parameterisations/gflash/src/GVFlashShowerParameterisation.cc
+118
View File
@@ -0,0 +1,118 @@
//
// ********************************************************************
// * DISCLAIMER *
// * *
// * The following disclaimer summarizes all the specific disclaimers *
// * of contributors to this software. The specific disclaimers,which *
// * govern, are listed with their locations in: *
// * http://cern.ch/geant4/license *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. *
// * *
// * This code implementation is the intellectual property of the *
// * GEANT4 collaboration. *
// * By copying, distributing or modifying the Program (or any work *
// * based on the Program) you indicate your acceptance of this *
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: GVFlashShowerParameterisation.cc,v 1.1 2005/11/30 19:29:44 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
//
// ------- GVFlashShowerParameterisation -------
//
// Authors: Joanna Weng - 11.2005
// ------------------------------------------------------------
#include "GVFlashShowerParameterisation.hh"
#include <cmath>
#include "Randomize.hh"
#include "G4ios.hh"
#include "G4Material.hh"
#include "Gamma.hh" // @@@@
#include "G4MaterialTable.hh"
GVFlashShowerParameterisation::GVFlashShowerParameterisation()
: thePar(0)
{
}
GVFlashShowerParameterisation::~GVFlashShowerParameterisation()
{
}
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 = mat->GetNumberOfElements();
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;
}
}
else {
z = mat->GetZ();
}
return z;
}
G4double GVFlashShowerParameterisation::GetEffA (const G4Material * mat )
{
// Returns A or effective A=sum(pi*Ai) (if compound/mixture)
// of given material
//
G4double a = 0.;
G4int nofElements = 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;
}
}
else {
a = mat->GetA()/(g/mole);
}
return a;
}
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;
}
G4double GVFlashShowerParameterisation::GeneratePhi()
{
G4double Phi = twopi*G4UniformRand() ;
return Phi;
}
G4double GVFlashShowerParameterisation::gam(G4double x, G4double a) const
{
static MyGamma theG;
return theG.Gamma(a, x);
}
source/parameterisations/gflash/src/Gamma.cc
+126 -120
View File
@@ -20,6 +20,13 @@
// * statement, and all its terms. *
// ********************************************************************
//
// $Id: Gamma.cc,v 1.5 2005/10/04 09:08:33 gcosmo Exp $
// GEANT4 tag $Name: geant4-08-00 $
//
//
// ------------------------------------------------------------
// GEANT 4 class implementation
// ------------------------------------------------------------
#include <cmath>
#include <string.h>
@@ -29,142 +36,141 @@ MyGamma::MyGamma(){}
MyGamma::~MyGamma(){}
//______________________________________________________________________________
//____________________________________________________________________________
double MyGamma::Gamma(double z)
{
// Computation of gamma(z) for all z>0.
//
// The algorithm is based on the article by C.Lanczos [1] as denoted in
// Numerical Recipes 2nd ed. on p. 207 (W.H.Press et al.).
//
// [1] C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
if (z<=0) return 0;
double v = LnGamma(z);
return std::exp(v);
// Computation of gamma(z) for all z>0.
//
// The algorithm is based on the article by C.Lanczos [1] as denoted in
// Numerical Recipes 2nd ed. on p. 207 (W.H.Press et al.).
//
// [1] C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
if (z<=0) return 0;
double v = LnGamma(z);
return std::exp(v);
}
//______________________________________________________________________________
//____________________________________________________________________________
double MyGamma::Gamma(double a,double x)
{ // Computation of the incomplete gamma function P(a,x)
//
// The algorithm is based on the formulas and code as denoted in
// 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);
{
// Computation of the incomplete gamma function P(a,x)
//
// The algorithm is based on the formulas and code as denoted in
// 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);
}
//______________________________________________________________________________
//____________________________________________________________________________
double MyGamma::GamCf(double a,double x)
{
// Computation of the incomplete gamma function P(a,x)
// via its continued fraction representation.
//
// The algorithm is based on the formulas and code as denoted in
// 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
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);
b += 2;
d = an*d+b;
if (Abs(d) < fpmin) d = fpmin;
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;
}
double v = Exp(-x+a*Log(x)-gln)*h;
return (1-v);
// Computation of the incomplete gamma function P(a,x)
// via its continued fraction representation.
//
// The algorithm is based on the formulas and code as denoted in
// 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
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);
b += 2;
d = an*d+b;
if (Abs(d) < fpmin) d = fpmin;
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;
}
double v = Exp(-x+a*Log(x)-gln)*h;
return (1-v);
}
//______________________________________________________________________________
//____________________________________________________________________________
double MyGamma::GamSer(double a,double x)
{
// Computation of the incomplete gamma function P(a,x)
// via its series representation.
//
// The algorithm is based on the formulas and code as denoted in
// 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
if (a <= 0 || x <= 0) return 0;
double gln = LnGamma(a);
double ap = a;
double sum = 1/a;
double del = sum;
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;
}
double v = sum*Exp(-x+a*Log(x)-gln);
return v;
// Computation of the incomplete gamma function P(a,x)
// via its series representation.
//
// The algorithm is based on the formulas and code as denoted in
// 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
if (a <= 0 || x <= 0) return 0;
double gln = LnGamma(a);
double ap = a;
double sum = 1/a;
double del = sum;
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;
}
double v = sum*Exp(-x+a*Log(x)-gln);
return v;
}
double MyGamma::LnGamma(double z)
{
// Computation of ln[gamma(z)] for all z>0.
//
// The algorithm is based on the article by C.Lanczos [1] as denoted in
// Numerical Recipes 2nd ed. on p. 207 (W.H.Press et al.).
//
// [1] C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
//
// The accuracy of the result is better than 2e-10.
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
if (z<=0) return 0;
// Coefficients for the series expansion
double c[7] = { 2.5066282746310005, 76.18009172947146, -86.50532032941677
,24.01409824083091, -1.231739572450155, 0.1208650973866179e-2
,-0.5395239384953e-5};
double x = z;
double y = x;
double tmp = x+5.5;
tmp = (x+0.5)*Log(tmp)-tmp;
double ser = 1.000000000190015;
for (int i=1; i<7; i++) {
y += 1;
ser += c[i]/y;
}
double v = tmp+Log(c[0]*ser/x);
return v;
// Computation of ln[gamma(z)] for all z>0.
//
// The algorithm is based on the article by C.Lanczos [1] as denoted in
// Numerical Recipes 2nd ed. on p. 207 (W.H.Press et al.).
//
// [1] C.Lanczos, SIAM Journal of Numerical Analysis B1 (1964), 86.
//
// The accuracy of the result is better than 2e-10.
//
//--- Nve 14-nov-1998 UU-SAP Utrecht
if (z<=0) return 0;
// Coefficients for the series expansion
double c[7] = { 2.5066282746310005, 76.18009172947146, -86.50532032941677
,24.01409824083091, -1.231739572450155, 0.1208650973866179e-2
,-0.5395239384953e-5};
double x = z;
double y = x;
double tmp = x+5.5;
tmp = (x+0.5)*Log(tmp)-tmp;
double ser = 1.000000000190015;
for (int i=1; i<7; i++) {
y += 1;
ser += c[i]/y;
}
double v = tmp+Log(c[0]*ser/x);
return v;
}