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

Import Geant4 7.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 11:11:55 +02:00
parent e083ffb441
commit 516dbf1a58
5914 changed files with 202605 additions and 71141 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/parameterisations/gflash/src/GFlashEnergySpot.cc
+42
View File
@@ -0,0 +1,42 @@
//
// ********************************************************************
// * 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 Joanna Weng, 9.11.04
#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 @@@@@
}
GFlashEnergySpot::~GFlashEnergySpot() {}
source/parameterisations/gflash/src/GFlashHitMaker.cc
+104
View File
@@ -0,0 +1,104 @@
//
// ********************************************************************
// * 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 E.Barberio & Joanna Weng 9.11.2004
#include "G4ios.hh"
#include "G4TransportationManager.hh"
#include "G4VSensitiveDetector.hh"
#include "G4TouchableHandle.hh"
#include "G4VGFlashSensitiveDetector.hh"
#include "GFlashHitMaker.hh"
#include "G4GFlashSpot.hh"
GFlashHitMaker::GFlashHitMaker()
{
fTouchableHandle = new G4TouchableHistory(); // talk to ?@@@
fpNavigator = new G4Navigator();
fNaviSetup = false;
}
GFlashHitMaker::~GFlashHitMaker()
{
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) && ( 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
}
}
source/parameterisations/gflash/src/GFlashHomoShowerParamterisation.cc
+339
View File
@@ -0,0 +1,339 @@
//
// ********************************************************************
// * 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 * material )
{
// Returns Z or effective Z=sum(pi*Zi) (if compound/mixture)
// of given material.
// ---
G4double z = 0.;
G4int nofElements = material->GetNumberOfElements();
if (nofElements > 1)
{
// G4String text = "Effective Z for material mixture (";
// text = text + material->GetName();
// text = text + ") is used.";
// cout << text <<endl;
for (G4int i=0; i<nofElements; i++) {
G4double zOfElement = material->GetElement(i)->GetZ();
G4double massFraction = material->GetFractionVector()[i];
// cout << material->GetElement(i)->GetName() <<" Z= "<<zOfElement << " , Fraction= "<<massFraction <<endl;
z += zOfElement*massFraction;
}
}
else {
z = material->GetZ();
}
return z;
}
G4double GFlashHomoShowerParamterisation::GetEffA (const G4Material * material )
{
// Returns A or effective A=sum(pi*Ai) (if compound/mixture)
// of given material.
// ---
G4double a = 0.;
G4int nofElements = material->GetNumberOfElements();
if (nofElements > 1)
{
// G4String text = "Effective A for material mixture (";
// text = text + material->GetName();
// text = text + ") is used."
// cout << text <<endl;
for (G4int i=0; i<nofElements; i++)
{
G4double aOfElement = material->GetElement(i)->GetA()/(g/mole);
G4double massFraction = material->GetFractionVector()[i];
// cout << material->GetElement(i)->GetName() <<" A= "<<aOfElement << " g/mole, Fraction= "<< massFraction <<endl;
a += aOfElement*massFraction;
}
}
else
{
a = material->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(const 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
+96
View File
@@ -0,0 +1,96 @@
//
// ********************************************************************
// * 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 Joanna Weng 9.11.2004
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "GFlashParticleBounds.hh"
GFlashParticleBounds::GFlashParticleBounds()
{
// 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)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMinEneToParametrise = enemin;
}
void GFlashParticleBounds::SetMaxEneToParametrise(G4ParticleDefinition &particleType,G4double enemax)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EMaxEneToParametrise = enemax;
}
void GFlashParticleBounds::SetEneToKill(G4ParticleDefinition &particleType,G4double enekill)
{
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
EEneToKill = enekill;
}
G4double GFlashParticleBounds::GetMinEneToParametrise(G4ParticleDefinition &particleType)
{
G4double result = DBL_MAX;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMinEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::GetMaxEneToParametrise(G4ParticleDefinition &particleType)
{
G4double result = 0;
if( &particleType == G4Electron::ElectronDefinition()||
&particleType == G4Positron::PositronDefinition())
{
result = EMaxEneToParametrise;
}
return result;
}
G4double GFlashParticleBounds::GetEneToKill(G4ParticleDefinition & particleType)
{
if (&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition())
return EEneToKill;
else return (-DBL_MAX);
}
source/parameterisations/gflash/src/GFlashShowerModel.cc
+346
View File
@@ -0,0 +1,346 @@
//
// ********************************************************************
// * 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
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4Gamma.hh"
#include "G4NeutrinoE.hh"
#include "G4NeutrinoMu.hh"
#include "G4NeutrinoTau.hh"
#include "G4AntiNeutrinoE.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4AntiNeutrinoTau.hh"
#include "G4PionZero.hh"
#include "G4VProcess.hh"
#include "G4ios.hh"
#include "G4LogicalVolume.hh"
#include "geomdefs.hh"
#include "GFlashShowerModel.hh"
#include "GFlashHomoShowerParamterisation.hh"
#include "GFlashEnergySpot.hh"
GFlashShowerModel::GFlashShowerModel(G4String modelName, G4LogicalVolume* envelope)
: G4VFastSimulationModel(modelName, envelope)
{
FlagParamType = 0;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::GFlashShowerModel(G4String modelName)
: G4VFastSimulationModel(modelName)
{
FlagParamType =1;
FlagParticleContainment = 1;
StepInX0 = 0.1;
Messenger = new GFlashShowerModelMessenger(this);
}
GFlashShowerModel::~GFlashShowerModel()
{
Messenger = new GFlashShowerModelMessenger(this);
}
G4bool GFlashShowerModel::IsApplicable(const G4ParticleDefinition& particleType)
{
return
&particleType == G4Electron::ElectronDefinition() ||
&particleType == G4Positron::PositronDefinition();
}
/*********************************************************************/
/* Checks whether conditions of fast parametrisation 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 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 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=NlateralInside++;
}
//chose to parametrise 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)
{
// parametrise electrons
if(fastTrack.GetPrimaryTrack()->GetDefinition() == G4Electron::ElectronDefinition() ||
fastTrack.GetPrimaryTrack()->GetDefinition() == G4Positron::PositronDefinition() )
ElectronDoIt(fastTrack,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=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
//-------------
}
/* 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);
}
}
*/
source/parameterisations/gflash/src/GFlashShowerModelMessenger.cc
+156
View File
@@ -0,0 +1,156 @@
//
// ********************************************************************
// * 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 Joanna Weng, 9.11.04
#include "GFlashShowerModelMessenger.hh"
#include "GFlashShowerModel.hh"
#include "GFlashParticleBounds.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithAString.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAnInteger.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "globals.hh"
#include <iomanip>
#include <strstream>
GFlashShowerModelMessenger::GFlashShowerModelMessenger(GFlashShowerModel * myModel)
{
myParaDir = new G4UIdirectory("/GFlash/");
myParaDir->SetGuidance("Parametrisation control.");
this->myModel= myModel;
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;
}
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);
}
}
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;
}
source/parameterisations/gflash/src/Gamma.cc
+170
View File
@@ -0,0 +1,170 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
#include <math.h>
#include <string.h>
#include "Gamma.hh"
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);
}
//______________________________________________________________________________
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);
}
//______________________________________________________________________________
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);
}
//______________________________________________________________________________
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;
}
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;
}