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

Import Geant4 5.0.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:57:27 +02:00
parent 330b82b769
commit 37fff30d2e
5733 changed files with 263867 additions and 74574 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/muons/src/G4MuBetheBlochModel.cc
+362
View File
@@ -0,0 +1,362 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class header file
//
//
// File name: G4MuBetheBlochModel
//
// Author: Vladimir Ivanchenko on base of Laszlo Urban code
//
// Creation date: 09.08.2002
//
// Modifications: 04.12.2002 VI Fix problem of G4DynamicParticle constructor
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuBetheBlochModel.hh"
#include "Randomize.hh"
#include "G4Electron.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBetheBlochModel::G4MuBetheBlochModel(const G4ParticleDefinition* p)
: G4VEmModel(),
particle(0),
highKinEnergy(100.*TeV),
lowKinEnergy(2.0*MeV),
twoln10(2.0*log(10.0)),
bg2lim(0.0169),
taulim(8.4146e-3)
{
if(p) SetParticle(p);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBetheBlochModel::~G4MuBetheBlochModel()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuBetheBlochModel::SetParticle(const G4ParticleDefinition* p)
{
particle = p;
mass = particle->GetPDGMass();
G4double q = particle->GetPDGCharge()/eplus;
chargeSquare = q*q;
lowKinEnergy *= mass/proton_mass_c2;
ratio = electron_mass_c2/mass;
qc = mass/ratio;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBetheBlochModel::HighEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
if(!particle) SetParticle(p);
return highKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBetheBlochModel::LowEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
if(!particle) SetParticle(p);
return lowKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBetheBlochModel::MinEnergyCut(const G4ParticleDefinition* p,
const G4Material* material)
{
return material->GetIonisation()->GetMeanExcitationEnergy();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4MuBetheBlochModel::IsInCharge(const G4ParticleDefinition* p,
const G4Material*)
{
return (p->GetPDGCharge() != 0.0 && p->GetPDGMass() > 10.*MeV
&& p->GetPDGSpin() == 0.5);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBetheBlochModel::ComputeDEDX(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy)
{
if(!particle) SetParticle(p);
G4double tmax = MaxSecondaryEnergy(p, kineticEnergy);
G4double tau = kineticEnergy/mass;
G4double x = 1.0;
if(cutEnergy < tmax) x = cutEnergy/tmax;
G4double gam = tau + 1.0;
G4double beta2 = 1. - 1./(gam*gam);
G4double bg2 = tau * (tau+2.0);
G4double eexc = material->GetIonisation()->GetMeanExcitationEnergy();
G4double eexc2 = eexc*eexc;
G4double taul = material->GetIonisation()->GetTaul();
G4double cden = material->GetIonisation()->GetCdensity();
G4double mden = material->GetIonisation()->GetMdensity();
G4double aden = material->GetIonisation()->GetAdensity();
G4double x0den = material->GetIonisation()->GetX0density();
G4double x1den = material->GetIonisation()->GetX1density();
G4double* shellCorrectionVector =
material->GetIonisation()->GetShellCorrectionVector();
G4double eDensity = material->GetElectronDensity();
G4double dedx = log(2.0*electron_mass_c2*bg2*tmax*x/eexc2)-(1.0 + x)*beta2;
G4double totEnergy = kineticEnergy + mass;
G4double del = 0.5*x*tmax/totEnergy;
dedx += del*del;
// density correction
x = log(bg2)/twoln10;
if ( x >= x0den ) {
dedx -= twoln10*x - cden ;
if ( x < x1den ) dedx -= aden*pow((x1den-x),mden) ;
}
// shell correction
G4double sh = 0.0;
x = 1.0;
if ( bg2 > bg2lim ) {
for (G4int k=0; k<3; k++) {
x *= bg2 ;
sh += shellCorrectionVector[k]/x;
}
} else {
for (G4int k=0; k<3; k++) {
x *= bg2lim ;
sh += shellCorrectionVector[k]/x;
}
sh *= log(tau/taul)/log(taulim/taul);
}
dedx -= sh;
// now compute the total ionization loss
if (dedx < 0.0) dedx = 0.0 ;
// correction of R. Kokoulin // has been taken out ***************
// G4double apar = log(2.*(tmax/electron_mass_c2 + 1.0));
// dedx += fine_structure_const*(log(2.*totEnergy/mass)-apar/3.)*apar*apar/twopi;
dedx *= twopi_mc2_rcl2*chargeSquare*eDensity/beta2;
return dedx;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBetheBlochModel::CrossSection(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy)
{
if(!particle) SetParticle(p);
G4double cross = 0.0;
G4double tmaxSecondary = MaxSecondaryEnergy(p, kineticEnergy);
G4double tmax = G4std::min(tmaxSecondary, maxEnergy);
if(cutEnergy < tmax) {
const G4ElementVector* theElementVector = material->GetElementVector();
const G4double* NbOfAtomsPerVolume = material->GetVecNbOfAtomsPerVolume();
G4int NumberOfElements = material->GetNumberOfElements();
for (G4int iel=0; iel<NumberOfElements; iel++ ) {
cross += NbOfAtomsPerVolume[iel]* CrossSectionPerAtom(
(*theElementVector)[iel]->GetZ(),
kineticEnergy, cutEnergy, tmax, tmaxSecondary);
}
}
// G4cout << "tmin= " << cutEnergy << " tmax= " << tmax
// << " cross= " << cross << G4endl;
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double G4MuBetheBlochModel::CrossSectionPerAtom(
G4double Z,
G4double kineticEnergy,
G4double tmin,
G4double tmax,
G4double tmaxSecondary)
{
G4double cross = 0.;
const G4double xgi[] = {0.06943,0.33001,0.66999,0.93057};
const G4double wgi[] = {0.17393,0.32607,0.32607,0.17393};
const G4double ak1 = 4.6;
const G4int k2 = 2;
G4double aaa = log(tmin);
G4double bbb = log(tmax);
G4int kkk = int((bbb-aaa)/ak1)+k2;
G4double hhh = (bbb-aaa)/(float)kkk;
G4double step = exp(hhh);
G4double ymax = 1./tmax;
for (G4int k=0; k<kkk; k++) {
G4double ymin = ymax;
ymax = ymin*step;
G4double hhy = ymax-ymin;
for (G4int i=0; i<4; i++) {
G4double y = ymin+hhy*xgi[i];
G4double ep = 1./y ;
cross += ep*ep*wgi[i]*hhy*DifCrossSectionPerAtom(kineticEnergy, ep, tmaxSecondary);
}
}
cross *= twopi_mc2_rcl2*Z*chargeSquare;
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double G4MuBetheBlochModel::DifCrossSectionPerAtom(G4double kineticEnergy,
G4double knockonEnergy,
G4double tmaxSecondary)
// Calculates the differential cross section per atom
// using the cross section formula of R.P. Kokoulin (10/98)
{
const G4double alphaprime = fine_structure_const/twopi;
G4double totalEnergy = kineticEnergy + mass;
G4double gam = totalEnergy/mass;
G4double beta2 = 1. - 1./(gam*gam);
G4double v = knockonEnergy/totalEnergy;
G4double cross = (1.-beta2*knockonEnergy/tmaxSecondary + 0.5*v*v)/
(beta2*knockonEnergy*knockonEnergy);
G4double a1 = log(1.+2.*knockonEnergy/electron_mass_c2);
G4double a3 = log(4.*totalEnergy*(totalEnergy-knockonEnergy)/(mass*mass));
cross *= (1.+alphaprime*a1*(a3-a1));
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4std::vector<G4DynamicParticle*>* G4MuBetheBlochModel::SampleSecondary(
const G4Material* material,
const G4DynamicParticle* dp,
G4double tmin,
G4double maxEnergy)
{
G4double tmax = MaxSecondaryEnergy(dp);
G4double xmin = tmin/tmax;
G4double xmax = G4std::min(tmax, maxEnergy)/tmax;
if(xmin >= xmax) return 0;
G4ThreeVector momentum = dp->GetMomentumDirection();
G4double kineticEnergy = dp->GetKineticEnergy();
G4double totEnergy = kineticEnergy + mass;
G4double beta2 = 1. - mass*mass/(totEnergy*totEnergy);
G4double x = 0.5*tmax*tmax/(totEnergy*totEnergy);
const G4double alphaprime = fine_structure_const/twopi;
G4double a0=log(2.*totEnergy/mass);
G4double grej = (1.0 - beta2*xmin + xmax*xmax*x)*(1. + alphaprime*a0*a0);
G4double z, f, a1, twoep;
// sampling follows ...
do {
G4double q = G4UniformRand();
z = xmin*xmax/(xmin*(1.0 - q) + xmax*q);
twoep = 2.0*z*tmax;
a1= log(1.0 + twoep/electron_mass_c2);
f = (1.0 - beta2 * z + z*z*x)
* (1. + alphaprime*a1*(a0 + log((2.0*totEnergy-twoep)/mass) - a1));
if(f > grej) {
G4cout << "G4MuBetheBlochModel::SampleSecondary Warning! "
<< "Majorant " << grej << " < "
<< f << " for x= " << z
<< G4endl;
}
} while( grej*G4UniformRand() >= f );
G4double deltaKinEnergy = z * tmax;
G4double deltaMomentum =
sqrt(deltaKinEnergy * (deltaKinEnergy + 2.0*electron_mass_c2));
G4double totMomentum = sqrt(totEnergy*totEnergy - mass*mass);
G4double cost = deltaKinEnergy * (totEnergy + electron_mass_c2) /
(deltaMomentum * totMomentum);
G4double sint = sqrt(1.0 - cost*cost);
G4double phi = twopi * G4UniformRand() ;
G4ThreeVector deltaDirection(sint*cos(phi),sint*sin(phi), cost) ;
deltaDirection.rotateUz(momentum);
// create G4DynamicParticle object for delta ray
G4DynamicParticle* delta = new G4DynamicParticle();
delta->SetDefinition(G4Electron::Electron());
delta->SetKineticEnergy(deltaKinEnergy);
delta->SetMomentumDirection(deltaDirection);
G4std::vector<G4DynamicParticle*>* vdp = new G4std::vector<G4DynamicParticle*>;
vdp->push_back(delta);
return vdp;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/muons/src/G4MuBremsstrahlung.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4MuBremsstrahlung.cc,v 1.22 2001/11/09 13:52:31 maire Exp $
// GEANT4 tag $Name: geant4-04-01 $
// GEANT4 tag $Name: geant4-05-00 $
//
//
//--------------- G4MuBremsstrahlung physics process ---------------------------
source/processes/electromagnetic/muons/src/G4MuBremsstrahlungModel.cc
+578
View File
@@ -0,0 +1,578 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4MuBremsstrahlungModel
//
// Author: Vladimir Ivanchenko on base of Laszlo Urban code
//
// Creation date: 24.06.2002
//
// Modifications: 04.12.02 (VI) Change G4DynamicParticle constructor in PostStepDoIt
//
// Class Description:
//
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuBremsstrahlungModel.hh"
#include "G4Gamma.hh"
#include "G4MuonMinus.hh"
#include "G4MuonPlus.hh"
#include "Randomize.hh"
#include "G4Material.hh"
#include "G4Element.hh"
#include "G4ElementVector.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// static members
//
G4double G4MuBremsstrahlungModel::zdat[]={1.,4.,13.,29.,92.};
G4double G4MuBremsstrahlungModel::adat[]={1.01,9.01,26.98,63.55,238.03};
G4double G4MuBremsstrahlungModel::tdat[]={1.e3,1.e4,1.e5,1.e6,1.e7,1.e8,1.e9,1.e10};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBremsstrahlungModel::G4MuBremsstrahlungModel(const G4ParticleDefinition* p)
: G4VEmModel(),
highKinEnergy(100.*TeV),
lowKinEnergy(1.0*keV),
minThreshold(1.0*keV),
nzdat(5),
ntdat(8),
NBIN(1000),
cutFixed(0.98*keV),
oldMaterial(0),
samplingTablesAreFilled(false)
{
partialSumSigma.clear();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBremsstrahlungModel::~G4MuBremsstrahlungModel()
{
size_t n = partialSumSigma.size();
if(n > 0) {
for(size_t i=0; i<n; i++) {
delete partialSumSigma[i];
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::HighEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
return highKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::LowEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
return lowKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::MinEnergyCut(const G4ParticleDefinition* p,
const G4Material*)
{
return minThreshold;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4MuBremsstrahlungModel::IsInCharge(const G4ParticleDefinition* p,
const G4Material*)
{
return (p == G4MuonMinus::MuonMinus() || p == G4MuonPlus::MuonPlus());
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::ComputeDEDX(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy)
{
if(kineticEnergy < lowKinEnergy) return 0.0;
if(!samplingTablesAreFilled) MakeSamplingTables();
G4double cut = G4std::min(G4std::max(cutEnergy, minThreshold), kineticEnergy);
const G4ElementVector* theElementVector = material->GetElementVector();
const G4double* theAtomicNumDensityVector = material->GetAtomicNumDensityVector();
G4double dedx = 0.0;
// loop for elements in the material
for (size_t i=0; i<material->GetNumberOfElements(); i++) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double A = (*theElementVector)[i]->GetA()/(g/mole) ;
G4double loss = ComputMuBremLoss(Z, A, kineticEnergy, cut);
dedx += loss*theAtomicNumDensityVector[i];
}
if(dedx < 0.) dedx = 0.;
return dedx;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::ComputMuBremLoss(G4double Z, G4double A,
G4double tkin, G4double cut)
{
G4double totalEnergy = (G4MuonPlus::MuonPlus())->GetPDGMass() + tkin;
G4double ak1 = 0.05;
G4int k2=5;
G4double xgi[]={0.03377,0.16940,0.38069,0.61931,0.83060,0.96623};
G4double wgi[]={0.08566,0.18038,0.23396,0.23396,0.18038,0.08566};
G4double loss = 0.;
G4double vcut = cut/totalEnergy;
G4double vmax = tkin/totalEnergy;
G4double aaa = 0.;
G4double bbb = vcut;
if(vcut>vmax) bbb=vmax ;
G4int kkk = (G4int)((bbb-aaa)/ak1)+k2 ;
G4double hhh=(bbb-aaa)/float(kkk) ;
G4double aa = aaa;
for(G4int l=0; l<kkk; l++)
{
for(G4int i=0; i<6; i++)
{
G4double ep = (aa + xgi[i]*hhh)*totalEnergy;
loss += ep*wgi[i]*ComputeDMicroscopicCrossSection(tkin, Z, A, ep);
}
aa += hhh;
}
loss *=hhh*totalEnergy ;
return loss;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::ComputeMicroscopicCrossSection(
G4double tkin,
G4double Z,
G4double A,
G4double cut)
{
G4double totalEnergy = (G4MuonPlus::MuonPlus())->GetPDGMass() + tkin;
G4double ak1 = 2.3;
G4int k2 = 4;
G4double xgi[]={0.03377,0.16940,0.38069,0.61931,0.83060,0.96623};
G4double wgi[]={0.08566,0.18038,0.23396,0.23396,0.18038,0.08566};
G4double cross = 0.;
if(cut >= tkin) return cross;
G4double vcut = cut/totalEnergy;
G4double vmax = tkin/totalEnergy;
G4double aaa = log(vcut);
G4double bbb = log(vmax);
G4int kkk = (G4int)((bbb-aaa)/ak1)+k2 ;
G4double hhh = (bbb-aaa)/float(kkk);
G4double aa = aaa;
for(G4int l=0; l<kkk; l++)
{
for(G4int i=0; i<6; i++)
{
G4double ep = exp(aa + xgi[i]*hhh)*totalEnergy;
cross += ep*wgi[i]*ComputeDMicroscopicCrossSection(tkin, Z, A, ep);
}
aa += hhh;
}
cross *=hhh;
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double G4MuBremsstrahlungModel::ComputeDMicroscopicCrossSection(
G4double tkin,
G4double Z,
G4double A,
G4double gammaEnergy)
// differential cross section
{
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
static const G4double sqrte=sqrt(exp(1.)) ;
static const G4double bh=202.4,bh1=446.,btf=183.,btf1=1429. ;
static const G4double rmass=particleMass/electron_mass_c2 ;
static const G4double cc=classic_electr_radius/rmass ;
static const G4double coeff= 16.*fine_structure_const*cc*cc/3. ;
G4double dxsection = 0.;
if( gammaEnergy > tkin) return dxsection ;
G4double E = tkin + particleMass ;
G4double v = gammaEnergy/E ;
G4double delta = 0.5*particleMass*particleMass*v/(E-gammaEnergy) ;
G4double rab0=delta*sqrte ;
G4double z13 = exp(-log(Z)/3.) ;
G4double dn = 1.54*exp(0.27*log(A)) ;
G4double b,b1,dnstar ;
if(Z<1.5)
{
b=bh;
b1=bh1;
dnstar=dn ;
}
else
{
b=btf;
b1=btf1;
dnstar = exp((1.-1./Z)*log(dn)) ;
}
// nucleus contribution logarithm
G4double rab1=b*z13;
G4double fn=log(rab1/(dnstar*(electron_mass_c2+rab0*rab1))*
(particleMass+delta*(dnstar*sqrte-2.))) ;
if(fn <0.) fn = 0. ;
// electron contribution logarithm
G4double epmax1=E/(1.+0.5*particleMass*rmass/E) ;
G4double fe=0.;
if(gammaEnergy<epmax1)
{
G4double rab2=b1*z13*z13 ;
fe=log(rab2*particleMass/((1.+delta*rmass/(electron_mass_c2*sqrte))*
(electron_mass_c2+rab0*rab2))) ;
if(fe<0.) fe=0. ;
}
dxsection = coeff*(1.-v*(1. - 0.75*v))*Z*(fn*Z + fe)/gammaEnergy;
return dxsection;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuBremsstrahlungModel::CrossSection(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy)
{
G4double cross = 0.0;
G4double tmax = G4std::min(maxEnergy, kineticEnergy);
G4double cut = G4std::max(cutEnergy, minThreshold);
if(cut >= tmax) return cross;
if(!samplingTablesAreFilled) MakeSamplingTables();
const G4ElementVector* theElementVector = material->GetElementVector() ;
const G4double* theAtomNumDensityVector = material->GetAtomicNumDensityVector();
if(material != oldMaterial) {
oldMaterial = material;
G4double fixedEnergy = sqrt(lowKinEnergy*highKinEnergy);
ComputePartialSumSigma(material, fixedEnergy, cutEnergy);
}
for (size_t i=0; i<material->GetNumberOfElements(); i++) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double A = (*theElementVector)[i]->GetA()/(g/mole) ;
G4double cr = ComputeMicroscopicCrossSection(kineticEnergy, Z, A, cut);
if(tmax < kineticEnergy) {
cr -= ComputeMicroscopicCrossSection(kineticEnergy, Z, A, tmax);
}
cross += theAtomNumDensityVector[i] * cr;
}
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuBremsstrahlungModel::ComputePartialSumSigma(const G4Material* material,
G4double kineticEnergy,
G4double cut)
// Build the table of cross section per element. The table is built for MATERIALS.
// This table is used by DoIt to select randomly an element in the material.
{
size_t index = material->GetIndex();
G4int nElements = material->GetNumberOfElements();
const G4ElementVector* theElementVector = material->GetElementVector();
const G4double* theAtomNumDensityVector = material->GetAtomicNumDensityVector();
G4DataVector* dv;
if (index >= partialSumSigma.size()) {
dv = new G4DataVector();
partialSumSigma.push_back(dv);
} else {
dv = partialSumSigma[index];
dv->clear();
if(0 == index) samplingTablesAreFilled = false;
}
G4double cross = 0.0;
for (G4int i=0; i<nElements; i++ ) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double A = (*theElementVector)[i]->GetA()/(g/mole) ;
cross += theAtomNumDensityVector[i] * ComputeMicroscopicCrossSection(kineticEnergy,
Z, A, cut);
dv->push_back(cross);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuBremsstrahlungModel::MakeSamplingTables()
{
G4double AtomicNumber,AtomicWeight,KineticEnergy,
TotalEnergy,Maxep ;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
for (G4int iz=0; iz<nzdat; iz++)
{
AtomicNumber = zdat[iz];
AtomicWeight = adat[iz]*g/mole ;
for (G4int it=0; it<ntdat; it++)
{
KineticEnergy = tdat[it];
TotalEnergy = KineticEnergy + particleMass;
Maxep = KineticEnergy ;
G4double CrossSection = 0.0 ;
// calculate the differential cross section
// numerical integration in
// log ...............
G4double c = log(Maxep/cutFixed) ;
G4double ymin = -5. ;
G4double ymax = 0. ;
G4double dy = (ymax-ymin)/NBIN ;
G4double y = ymin - 0.5*dy ;
G4double yy = ymin - dy ;
G4double x = exp(y);
G4double fac = exp(dy);
G4double dx = exp(yy)*(fac - 1.0);
for (G4int i=0 ; i<NBIN; i++)
{
y += dy ;
x *= fac;
dx*= fac;
G4double ep = cutFixed*exp(c*x) ;
CrossSection += ep*dx*ComputeDMicroscopicCrossSection(
KineticEnergy,AtomicNumber,
AtomicWeight,ep) ;
ya[i]=y ;
proba[iz][it][i] = CrossSection ;
}
proba[iz][it][NBIN] = CrossSection ;
ya[NBIN] = 0. ; // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
if(CrossSection > 0.)
{
for(G4int ib=0; ib<=NBIN; ib++)
{
proba[iz][it][ib] /= CrossSection ;
}
}
}
}
samplingTablesAreFilled = true;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4std::vector<G4DynamicParticle*>* G4MuBremsstrahlungModel::SampleSecondary(
const G4Material* material,
const G4DynamicParticle* dp,
G4double tmin,
G4double maxEnergy)
{
// check against insufficient energy
if(tmin >= maxEnergy) return 0;
static G4double ysmall = -100. ;
static G4double ytablelow = -5. ;
G4double kineticEnergy = dp->GetKineticEnergy();
G4ParticleMomentum ParticleDirection = dp->GetMomentumDirection();
// select randomly one element constituing the material
const G4Element* anElement = SelectRandomAtom(material);
G4double totalEnergy = kineticEnergy + dp->GetMass();
G4double dy = 5./G4float(NBIN);
// This sampling should be checked!!! VI
G4double ymin=log(log(tmin/cutFixed)/log(maxEnergy/cutFixed));
if(ymin < ysmall) return 0;
// sampling using tables
G4double v,x,y ;
G4int iy;
// select sampling table ;
G4double lnZ = log(anElement->GetZ()) ;
G4double delmin = 1.e10 ;
G4double del ;
G4int izz = 0;
G4int itt = 0;
G4int NBINminus1;
NBINminus1 = NBIN-1 ;
for (G4int iz=0; iz<nzdat; iz++)
{
del = abs(lnZ-log(zdat[iz])) ;
if(del<delmin)
{
delmin=del ;
izz=iz ;
}
}
delmin = 1.e10 ;
for (G4int it=0; it<ntdat; it++)
{
del = abs(log(maxEnergy)-log(tdat[it])) ;
if(del<delmin)
{
delmin=del;
itt=it ;
}
}
G4int iymin = G4int((ymin+5.)/dy+0.5) ;
if(ymin < ytablelow)
{
y = ymin + G4UniformRand()*(ytablelow-ymin) ;
}
else
{
G4double r = G4UniformRand() ;
iy = iymin-1 ;
delmin = proba[izz][itt][NBINminus1]-proba[izz][itt][iymin] ;
do {
iy += 1 ;
} while ((r > (proba[izz][itt][iy]-proba[izz][itt][iymin])/delmin)
&&(iy < NBINminus1)) ;
//sampling is Done uniformly in y in the bin
y = ya[iy] + G4UniformRand() * ( ya[iy+1] - ya[iy] ) ;
}
x = exp(y) ;
v = cutFixed*exp(x*log(maxEnergy/cutFixed)) ;
if( v <= 0.) return 0;
// create G4DynamicParticle object for the Gamma
G4double GammaEnergy = v;
// angles of the emitted gamma. ( Z - axis along the parent particle)
// Teta = electron_mass_c2/TotalEnergy for the moment .....
G4double Teta = electron_mass_c2/totalEnergy ;
G4double Phi = twopi * G4UniformRand() ;
G4double dirx = sin(Teta)*cos(Phi) , diry = sin(Teta)*sin(Phi) ,
dirz = cos(Teta) ;
G4ThreeVector GammaDirection ( dirx, diry, dirz);
GammaDirection.rotateUz(ParticleDirection);
G4DynamicParticle* aGamma = new G4DynamicParticle();
aGamma->SetDefinition(G4Gamma::Gamma());
aGamma->SetKineticEnergy(GammaEnergy);
aGamma->SetMomentumDirection(GammaDirection);
G4std::vector<G4DynamicParticle*>* vdp = new G4std::vector<G4DynamicParticle*>;
vdp->push_back(aGamma);
return vdp;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4Element* G4MuBremsstrahlungModel::SelectRandomAtom(
const G4Material* material) const
{
// select randomly 1 element within the material
G4int nElements = material->GetNumberOfElements();
const G4ElementVector* theElementVector = material->GetElementVector();
if(1 == nElements) return (*theElementVector)[0];
else if(1 > nElements) return 0;
G4DataVector* dv = partialSumSigma[material->GetIndex()];
G4double rval = G4UniformRand()*((*dv)[nElements-1]);
for (G4int i=0; i<nElements; i++) {
if (rval <= (*dv)[i]) return (*theElementVector)[i];
}
return (*theElementVector)[nElements-1];
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/processes/electromagnetic/muons/src/G4MuBremsstrahlungSTD.cc
+119
View File
@@ -0,0 +1,119 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4MuBremsstrahlungSTD
//
// Author: Laszlo Urban
//
// Creation date: 30.09.1997
//
// Modifications:
//
// 08-04-98 remove 'tracking cut' of muon in oIt, MMa
// 26/10/98 new cross section of R.Kokoulin,cleanup , L.Urban
// 10/02/00 modifications , new e.m. structure, L.Urban
// 29/05/01 V.Ivanchenko minor changes to provide ANSI -wall compilation
// 09-08-01 new methods Store/Retrieve PhysicsTable (mma)
// 17-09-01 migration of Materials to pure STL (mma)
// 26-09-01 completion of store/retrieve PhysicsTable (mma)
// 28-09-01 suppression of theMuonPlus ..etc..data members (mma)
// 29-10-01 all static functions no more inlined (mma)
// 08-11-01 particleMass becomes a local variable (mma)
// 19-08-02 V.Ivanchenko update to new design
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuBremsstrahlungSTD.hh"
#include "G4Gamma.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4MuBremsstrahlungModel.hh"
#include "G4UniversalFluctuation.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBremsstrahlungSTD::G4MuBremsstrahlungSTD(const G4String& name)
: G4VEnergyLossSTD(name),
theParticle(0),
theBaseParticle(0)
{
InitialiseProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuBremsstrahlungSTD::~G4MuBremsstrahlungSTD()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuBremsstrahlungSTD::InitialiseProcess()
{
SetSecondaryParticle(G4Gamma::Gamma());
SetSubCutoffIsDesired(false);
SetDEDXBinning(120);
SetLambdaBinning(120);
SetMinKinEnergy(0.1*keV);
SetMaxKinEnergy(100.0*TeV);
G4VEmModel* em = new G4MuBremsstrahlungModel();
em->SetLowEnergyLimit(0, 0.1*keV);
em->SetHighEnergyLimit(0, 100.0*TeV);
AddEmModel(em, 0);
G4VEmFluctuationModel* fm = new G4UniversalFluctuation();
AddEmFluctuationModel(fm);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4ParticleDefinition* G4MuBremsstrahlungSTD::DefineBaseParticle(
const G4ParticleDefinition* p)
{
if(!theParticle) theParticle = p;
return theBaseParticle;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuBremsstrahlungSTD::PrintInfoDefinition() const
{
G4VEnergyLossSTD::PrintInfoDefinition();
G4cout << " Parametrised model "
<< G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/muons/src/G4MuIonisation.cc
+4 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4MuIonisation.cc,v 1.24 2001/11/09 13:52:32 maire Exp $
// GEANT4 tag $Name: geant4-04-01 $
// $Id: G4MuIonisation.cc,v 1.26 2002/12/04 15:45:53 vnivanch Exp $
// GEANT4 tag $Name: geant4-05-00 $
//
// --------------- G4MuIonisation physics process ------------------------------
// by Laszlo Urban, September 1997
@@ -40,6 +40,7 @@
// 29-10-01 all static functions no more inlined (mma)
// 07-11-01 correction(Tmax+xsection computation) L.Urban
// 08-11-01 particleMass becomes a local variable (mma)
// 04-12-02 fix misprint in majorant in PostStep (VI)
// -----------------------------------------------------------------------------
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -477,7 +478,7 @@ G4VParticleChange* G4MuIonisation::PostStepDoIt(const G4Track& trackData,
G4double x,twoep,a1,grej;
const G4double alphaprime = fine_structure_const/twopi;
G4double a0=log(2.*TotalEnergy/particleMass);
G4double grejc=(1.-xc*(betasquare*xc-xc*te2))*(1.+ alphaprime*a0*a0);
G4double grejc=(1.-xc*betasquare+te2)*(1.+ alphaprime*a0*a0);
do { x=xc/(1.-(1.-xc)*G4UniformRand());
twoep = 2.*x*MaxKineticEnergyTransfer;
a1 = log(1.+twoep/electron_mass_c2);
source/processes/electromagnetic/muons/src/G4MuIonisationSTD.cc
+138
View File
@@ -0,0 +1,138 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4MuIonisationSTD
//
// Author: Laszlo Urban
//
// Creation date: 30.09.1997
//
// Modifications:
//
// 08-04-98 remove 'tracking cut' of the ionizing particle (mma)
// 26-10-98 new stuff from R.Kokoulin + cleanup , L.Urban
// 10-02-00 modifications , new e.m. structure, L.Urban
// 23-03-01 R.Kokoulin's correction is commented out, L.Urban
// 29-05-01 V.Ivanchenko minor changes to provide ANSI -wall compilation
// 10-08-01 new methods Store/Retrieve PhysicsTable (mma)
// 28-08-01 new function ComputeRestrictedMeandEdx() + 'cleanup' (mma)
// 17-09-01 migration of Materials to pure STL (mma)
// 26-09-01 completion of RetrievePhysicsTable (mma)
// 29-10-01 all static functions no more inlined (mma)
// 07-11-01 correction(Tmax+xsection computation) L.Urban
// 08-11-01 particleMass becomes a local variable (mma)
// 10-05-02 V.Ivanchenko update to new design
// 04-12-02 V.Ivanchenko the low energy limit for Kokoulin model to 10 GeV
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuIonisationSTD.hh"
#include "G4Electron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4BraggModel.hh"
#include "G4BetheBlochModel.hh"
#include "G4MuBetheBlochModel.hh"
#include "G4UniversalFluctuation.hh"
#include "G4UnitsTable.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuIonisationSTD::G4MuIonisationSTD(const G4String& name)
: G4VEnergyLossSTD(name),
theParticle(0),
theBaseParticle(0)
{
InitialiseProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuIonisationSTD::~G4MuIonisationSTD()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuIonisationSTD::InitialiseProcess()
{
SetSecondaryParticle(G4Electron::Electron());
SetSubCutoffIsDesired(true);
SetDEDXBinning(120);
SetLambdaBinning(120);
SetMinKinEnergy(0.1*keV);
SetMaxKinEnergy(100.0*TeV);
G4VEmModel* em = new G4BraggModel();
em->SetLowEnergyLimit(0, 0.1*keV);
em->SetHighEnergyLimit(0, 2.*MeV);
AddEmModel(em, 0);
G4VEmModel* em1 = new G4BetheBlochModel();
em1->SetLowEnergyLimit(0, 2.*MeV);
em1->SetHighEnergyLimit(0, 10.0*GeV);
AddEmModel(em1, 1);
G4VEmModel* em2 = new G4MuBetheBlochModel();
em2->SetLowEnergyLimit(0, 10.0*GeV);
em2->SetHighEnergyLimit(0, 100.0*TeV);
AddEmModel(em2, 2);
G4VEmFluctuationModel* fm = new G4UniversalFluctuation();
AddEmFluctuationModel(fm);
mass = (G4MuonPlus::MuonPlus())->GetPDGMass();
ratio = electron_mass_c2/mass;
SetVerboseLevel(0);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4ParticleDefinition* G4MuIonisationSTD::DefineBaseParticle(
const G4ParticleDefinition* p)
{
if(!theParticle) theParticle = p;
return theBaseParticle;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuIonisationSTD::PrintInfoDefinition() const
{
G4VEnergyLossSTD::PrintInfoDefinition();
G4cout << " Bether-Bloch model for E > 0.2 MeV "
<< "parametrisation of Bragg peak below."
<< G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/muons/src/G4MuPairProduction.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4MuPairProduction.cc,v 1.26 2001/11/09 13:52:32 maire Exp $
// GEANT4 tag $Name: geant4-04-01 $
// GEANT4 tag $Name: geant4-05-00 $
//
//--------------- G4MuPairProduction physics process ---------------------------
// by Laszlo Urban, May 1998
source/processes/electromagnetic/muons/src/G4MuPairProductionModel.cc
+775
View File
@@ -0,0 +1,775 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4MuPairProductionModel
//
// Author: Vladimir Ivanchenko on base of Laszlo Urban code
//
// Creation date: 24.06.2002
//
// Modifications: 04.12.2002 Change G4DynamicParticle constructor in PostStep (VI)
//
// Class Description:
//
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuPairProductionModel.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4MuonMinus.hh"
#include "G4MuonPlus.hh"
#include "Randomize.hh"
#include "G4Material.hh"
#include "G4Element.hh"
#include "G4ElementVector.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
// static members
//
G4double G4MuPairProductionModel::zdat[]={1.,4.,13.,29.,92.};
G4double G4MuPairProductionModel::adat[]={1.01,9.01,26.98,63.55,238.03};
G4double G4MuPairProductionModel::tdat[]={1.e3,1.e4,1.e5,1.e6,1.e7,1.e8,1.e9,1.e10};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuPairProductionModel::G4MuPairProductionModel(const G4ParticleDefinition* p)
: G4VEmModel(),
minPairEnergy(4.*electron_mass_c2),
highKinEnergy(1000000.*TeV),
lowKinEnergy(minPairEnergy),
minThreshold(minPairEnergy),
nzdat(5),
ntdat(8),
NBIN(1000),
oldMaterial(0),
samplingTablesAreFilled(false)
{
partialSumSigma.clear();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuPairProductionModel::~G4MuPairProductionModel()
{
size_t n = partialSumSigma.size();
if(n > 0) {
for(size_t i=0; i<n; i++) {
delete partialSumSigma[i];
}
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::HighEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
return highKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::LowEnergyLimit(const G4ParticleDefinition* p,
const G4Material*)
{
return lowKinEnergy;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::MinEnergyCut(const G4ParticleDefinition* p,
const G4Material* material)
{
G4double eCut = (G4Electron::Electron())->GetEnergyThreshold(material);
G4double pCut = (G4Positron::Positron())->GetEnergyThreshold(material);
G4double x = minPairEnergy;
if(eCut < highKinEnergy && pCut < highKinEnergy) {
x += eCut + pCut;
} else {
x = 0.5*highKinEnergy;
}
return x;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4bool G4MuPairProductionModel::IsInCharge(const G4ParticleDefinition* p,
const G4Material*)
{
return (p == G4MuonMinus::MuonMinus() || p == G4MuonPlus::MuonPlus());
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::ComputeDEDX(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy)
{
G4double dedx = 0.0;
if(!samplingTablesAreFilled) {
minThreshold = MinEnergyCut(p, material);
MakeSamplingTables();
}
if(kineticEnergy < minPairEnergy) return dedx;
const G4ElementVector* theElementVector = material->GetElementVector();
const G4double* theAtomicNumDensityVector = material->GetAtomicNumDensityVector();
// loop for elements in the material
for (size_t i=0; i<material->GetNumberOfElements(); i++) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double loss = ComputMuPairLoss(Z, kineticEnergy, cutEnergy);
dedx += loss*theAtomicNumDensityVector[i];
}
if(dedx < 0.) dedx = 0.;
return dedx;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::ComputMuPairLoss(G4double Z,
G4double tkin, G4double cutEnergy)
{
static const
G4double xgi[] ={ 0.0199,0.1017,0.2372,0.4083,0.5917,0.7628,0.8983,0.9801};
static const
G4double wgi[] ={ 0.0506,0.1112,0.1569,0.1813,0.1813,0.1569,0.1112,0.0506};
static const G4double ak1=6.9;
static const G4double ak2=1.0;
static const G4double sqrte = sqrt(exp(1.));
static const G4double aaa = log(minPairEnergy);
G4double z13 = pow(Z,0.333333333);
G4double loss = 0.0 ;
if (Z < 1. || cutEnergy < minPairEnergy) return loss;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
G4double tmax = tkin + particleMass*(1.-0.75*sqrte*z13);
// G4cout << "###DEDX tkin= " << tkin << " tmax= " << tmax << " tmin= " << minPairEnergy << G4endl;
if(tmax < minPairEnergy) tmax = minPairEnergy;
G4double cut = cutEnergy;
if(cut >= tmax) cut = tmax;
if(cut <= minPairEnergy) return loss;
// calculate the rectricted loss
// numerical integration in log(PairEnergy)
G4double bbb = log(cut) ;
G4int kkk = (G4int)((bbb-aaa)/ak1+ak2);
if(kkk > 8) kkk = 8;
G4double hhh = (bbb-aaa)/(G4double)kkk ;
G4double x = aaa;
// G4cout << "###DEDX tkin= " << tkin << " cut= " << cut << " kkk= " << kkk << G4endl;
for (G4int l=0 ; l<kkk; l++)
{
for (G4int ll=0; ll<8; ll++)
{
G4double ep = exp(x+xgi[ll]*hhh);
// G4cout << "ep= " << ep << G4endl;
loss += wgi[ll]*ep*ep*ComputeDMicroscopicCrossSection(tkin, Z, ep);
}
x += hhh;
}
loss *= hhh ;
// cout << "### tmax= " << tmax << " hhh= " << hhh << " loss= " << loss << endl;
if (loss < 0.) loss = 0.;
return loss ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::ComputeMicroscopicCrossSection(
G4double tkin,
G4double Z,
G4double A,
G4double cut)
{
static const G4double ak1=6.9 ;
static const G4double ak2=1.0 ;
static const G4double sqrte = sqrt(exp(1.)) ;
static const G4double
xgi[]={ 0.0199,0.1017,0.2372,0.4083,0.5917,0.7628,0.8983,0.9801 };
static const G4double
wgi[]={ 0.0506,0.1112,0.1569,0.1813,0.1813,0.1569,0.1112,0.0506 };
G4double z13 = pow(Z,0.333333333);
G4double cross = 0. ;
if(Z < 1.) return cross;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
G4double tmax = tkin + particleMass*(1.-0.75*sqrte*z13);
if(tmax < minPairEnergy) tmax = minPairEnergy;
if(tmax <= cut) return cross;
G4double aaa = log(cut);
G4double bbb = log(tmax);
G4int kkk = (G4int)((bbb-aaa)/ak1 + ak2);
if(kkk > 8) kkk = 8;
G4double hhh = (bbb-aaa)/float(kkk);
G4double x = aaa;
// G4cout << "###Cross tkin= " << tkin << " cut= " << cut << " kkk= " << kkk << G4endl;
for(G4int l=0; l<kkk; l++)
{
for(G4int i=0; i<8; i++)
{
G4double ep = exp(x + xgi[i]*hhh);
cross += ep*wgi[i]*ComputeDMicroscopicCrossSection(tkin, Z, ep);
}
aaa += hhh;
}
cross *=hhh;
if(cross < 0.0) cross = 0.0;
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double G4MuPairProductionModel::ComputeDMicroscopicCrossSection(
G4double tkin,
G4double Z,
G4double pairEnergy)
// Calculates the differential (D) microscopic cross section
// using the cross section formula of R.P. Kokoulin (18/01/98)
{
static const G4double
xgi[] ={ 0.0199,0.1017,0.2372,0.4083,0.5917,0.7628,0.8983,0.9801 };
static const G4double
wgi[] ={ 0.0506,0.1112,0.1569,0.1813,0.1813,0.1569,0.1112,0.0506 };
G4double cross = 0.;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
G4double totalEnergy = tkin + particleMass;
G4double energyLoss = totalEnergy - pairEnergy;
G4double a = 6.*particleMass*particleMass/(totalEnergy*energyLoss) ;
G4double b = 4.*electron_mass_c2/pairEnergy;
G4double tmn = (b+2.*a*(1.-b))/(1.+(1.-a)*sqrt(1.-b));
if(tmn <= 0.) return cross;
// G4cout << "a= " << a << " b= " << b << " tmn= " << tmn << G4endl;
tmn = log(tmn);
// G4cout << "a= " << a << " b= " << b << " tmn= " << tmn << G4endl;
// Gaussian integration in ln(1-ro) ( with 8 points)
for (G4int i=0; i<7; i++)
{
G4double ro = 1.-exp(tmn*xgi[i]) ;
cross += wgi[i]*(1.-ro)*ComputeDDMicroscopicCrossSection(tkin,Z,pairEnergy,ro);
// cout << "ro= " << ro << " cross= " << cross << endl;
}
cross *= -tmn ;
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4double G4MuPairProductionModel::ComputeDDMicroscopicCrossSection(
G4double tkin,
G4double Z,
G4double pairEnergy,
G4double asymmetry)
// Calculates the differential (D) microscopic cross section
// using the cross section formula of R.P. Kokoulin (18/01/98)
{
static const G4double sqrte = sqrt(exp(1.)) ;
G4double bbbtf= 183. ;
G4double bbbh = 202.4 ;
G4double g1tf = 1.95e-5 ;
G4double g2tf = 5.3e-5 ;
G4double g1h = 4.4e-5 ;
G4double g2h = 4.8e-5 ;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
G4double totalEnergy = tkin + particleMass;
G4double energyLoss = totalEnergy - pairEnergy;
G4double massratio = particleMass/electron_mass_c2 ;
G4double massratio2 = massratio*massratio ;
G4double z13 = pow(Z,0.333333333);
G4double z23 = z13*z13 ;
G4double c3 = 3.*sqrte*particleMass/4. ;
G4double DDCrossSection = 0. ;
if(energyLoss <= c3*z13) return DDCrossSection ;
G4double c7 = 4.*electron_mass_c2 ;
G4double c8 = 6.*particleMass*particleMass ;
G4double alf = c7/pairEnergy ;
G4double a3 = 1. - alf ;
if(a3 <= 0.) return DDCrossSection ;
// zeta calculation
G4double bbb,g1,g2,zeta1,zeta2,zeta,z2 ;
if( Z < 1.5 )
{
bbb = bbbh ;
g1 = g1h ;
g2 = g2h ;
}
else
{
bbb = bbbtf ;
g1 = g1tf ;
g2 = g2tf ;
}
zeta1 = 0.073 * log(totalEnergy/(particleMass+g1*z23*totalEnergy))-0.26 ;
if( zeta1 > 0.)
{
zeta2 = 0.058*log(totalEnergy/(particleMass+g2*z13*totalEnergy))-0.14 ;
zeta = zeta1/zeta2 ;
}
else
{
zeta = 0. ;
}
z2 = Z*(Z+zeta) ;
G4double screen0 = 2.*electron_mass_c2*sqrte*bbb/(z13*pairEnergy) ;
G4double a0 = totalEnergy*energyLoss ;
G4double a1 = pairEnergy*pairEnergy/a0 ;
G4double bet = 0.5*a1 ;
G4double xi0 = 0.25*massratio2*a1 ;
G4double del = c8/a0 ;
G4double romin = 0. ;
G4double romax = (1.-del)*sqrt(1.-c7/pairEnergy) ;
if((asymmetry < romin) || (asymmetry > romax)) return DDCrossSection ;
G4double a4 = 1.-asymmetry ;
G4double a5 = a4*(2.-a4) ;
G4double a6 = 1.-a5 ;
G4double a7 = 1.+a6 ;
G4double a9 = 3.+a6 ;
G4double xi = xi0*a5 ;
G4double xii = 1./xi ;
G4double xi1 = 1.+xi ;
G4double screen = screen0*xi1/a5 ;
G4double yeu = 5.-a6+4.*bet*a7 ;
G4double yed = 2.*(1.+3.*bet)*log(3.+xii)-a6-a1*(2.-a6) ;
G4double yel = 1.+yeu/yed ;
G4double ale=log(bbb/z13*sqrt(xi1*yel)/(1.+screen*yel)) ;
G4double cre = 0.5*log(1.+2.25/(massratio2*z23)*xi1*yel) ;
G4double be ;
if(xi <= 1.e3)
be = ((2.+a6)*(1.+bet)+xi*a9)*log(1.+xii)+(a5-bet)/xi1-a9;
else
be = (3.-a6+a1*a7)/(2.+xi) ;
G4double fe = (ale-cre)*be ;
if( fe < 0.)
fe = 0. ;
G4double ymu = 4.+a6 +3.*bet*a7 ;
G4double ymd = a7*(1.5+a1)*log(3.+xi)+1.-1.5*a6 ;
G4double ym1 = 1.+ymu/ymd ;
G4double alm_crm = log(bbb*massratio/(1.5*z23*(1.+screen*ym1))) ;
G4double a10,bm ;
if( xi >= 1.e-3)
{
a10 = (1.+a1)*a5 ;
bm = (a7*(1.+1.5*bet)-a10*xii)*log(xi1)+xi*(a5-bet)/xi1+a10 ;
}
else
bm = (5.-a6+bet*a9)*(xi/2.) ;
G4double fm = alm_crm*bm ;
if( fm < 0.)
fm = 0. ;
DDCrossSection = (fe+fm/massratio2) ;
DDCrossSection *= 4.*fine_structure_const*fine_structure_const
*classic_electr_radius*classic_electr_radius/(3.*pi) ;
DDCrossSection *= z2*energyLoss/(totalEnergy*pairEnergy) ;
return DDCrossSection ;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4MuPairProductionModel::CrossSection(const G4Material* material,
const G4ParticleDefinition* p,
G4double kineticEnergy,
G4double cutEnergy,
G4double maxEnergy)
{
G4double cross = 0.0;
if(!samplingTablesAreFilled) {
minThreshold = MinEnergyCut(p, material);
MakeSamplingTables();
}
G4double tmax = G4std::min(maxEnergy, kineticEnergy);
G4double cut = G4std::max(cutEnergy, minThreshold);
if(cut >= tmax) return cross;
const G4ElementVector* theElementVector = material->GetElementVector() ;
const G4double* theAtomNumDensityVector = material->GetAtomicNumDensityVector();
if(material != oldMaterial) {
oldMaterial = material;
G4double fixedEnergy = sqrt(lowKinEnergy*highKinEnergy);
ComputePartialSumSigma(material, fixedEnergy, cutEnergy);
}
for (size_t i=0; i<material->GetNumberOfElements(); i++) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double A = (*theElementVector)[i]->GetA()/(g/mole) ;
G4double cr = ComputeMicroscopicCrossSection(kineticEnergy, Z, A, cutEnergy);
if(maxEnergy < kineticEnergy) {
cr -= ComputeMicroscopicCrossSection(kineticEnergy, Z, A, maxEnergy);
}
cross += theAtomNumDensityVector[i] * cr;
}
return cross;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuPairProductionModel::ComputePartialSumSigma(const G4Material* material,
G4double kineticEnergy,
G4double cut)
// Build the table of cross section per element. The table is built for MATERIALS.
// This table is used by DoIt to select randomly an element in the material.
{
size_t index = material->GetIndex();
G4int nElements = material->GetNumberOfElements();
const G4ElementVector* theElementVector = material->GetElementVector();
const G4double* theAtomNumDensityVector = material->GetAtomicNumDensityVector();
G4DataVector* dv;
if (index >= partialSumSigma.size()) {
dv = new G4DataVector();
partialSumSigma.push_back(dv);
} else {
dv = partialSumSigma[index];
dv->clear();
if(0 == index) samplingTablesAreFilled = false;
}
G4double cross = 0.0;
for (G4int i=0; i<nElements; i++ ) {
G4double Z = (*theElementVector)[i]->GetZ();
G4double A = (*theElementVector)[i]->GetA()/(g/mole) ;
cross += theAtomNumDensityVector[i] * ComputeMicroscopicCrossSection(kineticEnergy,
Z, A, cut);
dv->push_back(cross);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuPairProductionModel::MakeSamplingTables()
{
static const G4double sqrte = sqrt(exp(1.)) ;
G4double particleMass = (G4MuonPlus::MuonPlus())->GetPDGMass();
for (G4int iz=0; iz<nzdat; iz++)
{
G4double atomicNumber = zdat[iz];
G4double z13 = exp(log(atomicNumber)/3.) ;
for (G4int it=0; it<ntdat; it++)
{
G4double kineticEnergy = tdat[it];
G4double maxPairEnergy = kineticEnergy+particleMass*(1.-0.75*sqrte*z13) ;
G4double CrossSection = 0.0 ;
G4double ymin = -5. ;
G4double ymax = 0. ;
G4double dy = (ymax-ymin)/NBIN ;
G4double y = ymin - 0.5*dy ;
G4double yy = ymin - dy ;
G4double x = exp(y);
G4double fac = exp(dy);
G4double dx = exp(yy)*(fac - 1.0);
if(maxPairEnergy > minThreshold) {
G4double c = log(maxPairEnergy/minThreshold) ;
for (G4int i=0 ; i<NBIN; i++)
{
y += dy ;
x *= fac;
dx*= fac;
G4double ep = minThreshold*exp(c*x) ;
CrossSection += ep*dx*ComputeDMicroscopicCrossSection(
kineticEnergy, atomicNumber, ep);
ya[i]=y ;
proba[iz][it][i] = CrossSection ;
}
} else {
for (G4int i=0 ; i<NBIN; i++)
{
y += dy ;
ya[i]=y ;
proba[iz][it][i] = 0.0 ;
}
}
ya[NBIN]=0. ;
proba[iz][it][NBIN] = CrossSection ;
if(CrossSection > 0.)
{
for(G4int ib=0; ib<=NBIN; ib++)
{
proba[iz][it][ib] /= CrossSection ;
}
}
}
}
samplingTablesAreFilled = true;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4std::vector<G4DynamicParticle*>* G4MuPairProductionModel::SampleSecondary(
const G4Material* aMaterial,
const G4DynamicParticle* aDynamicParticle,
G4double minEnergy,
G4double maxEnergy)
{
static const G4double esq = sqrt(exp(1.));
G4double kineticEnergy = aDynamicParticle->GetKineticEnergy();
G4double particleMass = aDynamicParticle->GetDefinition()->GetPDGMass();
G4ParticleMomentum ParticleDirection =
aDynamicParticle->GetMomentumDirection();
// select randomly one element constituing the material
const G4Element* anElement = SelectRandomAtom(aMaterial);
// limits of the energy sampling
G4double totalEnergy = kineticEnergy + particleMass ;
//G4double TotalMomentum = sqrt(KineticEnergy*(TotalEnergy+particleMass)) ;
G4double Z3 = anElement->GetIonisation()->GetZ3() ;
G4double maxPairEnergy = totalEnergy-0.75*esq*particleMass*Z3 ;
if(maxPairEnergy > maxEnergy) maxPairEnergy = maxEnergy;
// check against insufficient energy
if(minEnergy >= maxPairEnergy) return 0;
// sample e-e+ energy, pair energy first
G4double PairEnergy,x,yc,y ;
// G4int iZ,iT;
G4int iy ;
// select sampling table ;
G4double lnZ = log(anElement->GetZ()) ;
G4double delmin = 1.e10 ;
G4double del ;
G4int izz = 0;
G4int itt = 0;
G4int NBINminus1 = NBIN-1;
for (G4int iz=0; iz<nzdat; iz++)
{
del = abs(lnZ-log(zdat[iz])) ;
if(del<delmin)
{
delmin=del ;
izz=iz ;
}
}
delmin = 1.e10 ;
for (G4int it=0; it<ntdat; it++)
{
del = abs(log(kineticEnergy)-log(tdat[it])) ;
if(del<delmin)
{
delmin=del;
itt=it ;
}
}
if( minEnergy <= minPairEnergy)
iy = 0 ;
else
{
G4double xc = log(minEnergy/minPairEnergy)/log(maxPairEnergy/minPairEnergy) ;
yc = log(xc) ;
iy = -1 ;
do {
iy += 1 ;
} while ((ya[iy] < yc )&&(iy < NBINminus1)) ;
}
G4double norm = proba[izz][itt][iy] ;
G4double r = norm+G4UniformRand()*(1.-norm) ;
iy -= 1 ;
do {
iy += 1 ;
} while ((proba[izz][itt][iy] < r)&&(iy < NBINminus1)) ;
//sampling is uniformly in y in the bin
if( iy < NBIN )
y = ya[iy] + G4UniformRand() * ( ya[iy+1] - ya[iy]) ;
else
y = ya[iy] ;
x = exp(y) ;
PairEnergy = minPairEnergy*exp(x*log(maxPairEnergy/minPairEnergy)) ;
// sample r=(E+-E-)/PairEnergy ( uniformly .....)
G4double rmax = (1.-6.*particleMass*particleMass/(totalEnergy*
(totalEnergy-PairEnergy)))
*sqrt(1.-minPairEnergy/PairEnergy) ;
r = rmax * (-1.+2.*G4UniformRand()) ;
// compute energies from PairEnergy,r
G4double ElectronEnergy=(1.-r)*PairEnergy/2. ;
G4double PositronEnergy=(1.+r)*PairEnergy/2. ;
// angles of the emitted particles ( Z - axis along the parent particle)
// (mean theta for the moment)
G4double Teta = electron_mass_c2/totalEnergy ;
G4double Phi = twopi * G4UniformRand() ;
G4double dirx = sin(Teta)*cos(Phi) , diry = sin(Teta)*sin(Phi) ,
dirz = cos(Teta) ;
G4double ElectronMomentum , PositronMomentum ;
//G4double finalPx,finalPy,finalPz ;
G4double ElectKineEnergy = ElectronEnergy - electron_mass_c2 ;
ElectronMomentum = sqrt(ElectKineEnergy*(ElectronEnergy+electron_mass_c2));
G4ThreeVector ElectDirection ( dirx, diry, dirz );
ElectDirection.rotateUz(ParticleDirection);
// create G4DynamicParticle object for the particle1
G4DynamicParticle* aParticle1= new G4DynamicParticle();
aParticle1->SetDefinition(G4Electron::Electron());
aParticle1->SetMomentumDirection(ElectDirection);
aParticle1->SetKineticEnergy(ElectKineEnergy);
G4double PositKineEnergy = PositronEnergy - electron_mass_c2 ;
PositronMomentum = sqrt(PositKineEnergy*(PositronEnergy+electron_mass_c2));
G4ThreeVector PositDirection ( -dirx, -diry, dirz );
PositDirection.rotateUz(ParticleDirection);
// create G4DynamicParticle object for the particle2
G4DynamicParticle* aParticle2= new G4DynamicParticle();
aParticle2->SetDefinition(G4Positron::Positron());
aParticle2->SetMomentumDirection(PositDirection);
aParticle2->SetKineticEnergy(PositKineEnergy);
G4std::vector<G4DynamicParticle*>* vdp = new G4std::vector<G4DynamicParticle*>;
vdp->push_back(aParticle1);
vdp->push_back(aParticle2);
return vdp;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4Element* G4MuPairProductionModel::SelectRandomAtom(
const G4Material* material) const
{
// select randomly 1 element within the material
G4int nElements = material->GetNumberOfElements();
const G4ElementVector* theElementVector = material->GetElementVector();
if(1 == nElements) return (*theElementVector)[0];
else if(1 > nElements) return 0;
G4DataVector* dv = partialSumSigma[material->GetIndex()];
G4double rval = G4UniformRand()*((*dv)[nElements-1]);
for (G4int i=0; i<nElements; i++) {
if (rval <= (*dv)[i]) return (*theElementVector)[i];
}
return (*theElementVector)[nElements-1];
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/processes/electromagnetic/muons/src/G4MuPairProductionSTD.cc
+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. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
//
// File name: G4MuPairProductionSTD
//
// Author: Laszlo Urban
//
// Creation date: 30.05.1998
//
// Modifications:
//
// 04-06-98 in DoIt,secondary production condition:
// range>G4std::min(threshold,safety)
// 26/10/98 new stuff from R. Kokoulin + cleanup , L.Urban
// 06/05/99 bug fixed , L.Urban
// 10/02/00 modifications+bug fix , new e.m. structure, L.Urban
// 29/05/01 V.Ivanchenko minor changes to provide ANSI -wall compilation
// 10-08-01 new methods Store/Retrieve PhysicsTable (mma)
// 17-09-01 migration of Materials to pure STL (mma)
// 20-09-01 (L.Urban) in ComputeMicroscopicCrossSection, remove:
// if(MaxPairEnergy<CutInPairEnergy) MaxPairEnergy=CutInPairEnergy
// 26-09-01 completion of store/retrieve PhysicsTable
// 28-09-01 suppression of theMuonPlus ..etc..data members (mma)
// 29-10-01 all static functions no more inlined (mma)
// 07-11-01 particleMass becomes a local variable (mma)
// 19-08-02 V.Ivanchenko update to new design
//
// -------------------------------------------------------------------
//
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#include "G4MuPairProductionSTD.hh"
#include "G4Electron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4MuPairProductionModel.hh"
#include "G4UniversalFluctuation.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuPairProductionSTD::G4MuPairProductionSTD(const G4String& name)
: G4VEnergyLossSTD(name),
theParticle(0),
theBaseParticle(0)
{
InitialiseProcess();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4MuPairProductionSTD::~G4MuPairProductionSTD()
{}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuPairProductionSTD::InitialiseProcess()
{
SetSecondaryParticle(G4Electron::Electron());
SetSubCutoffIsDesired(true);
SetDEDXBinning(120);
SetLambdaBinning(120);
SetMinKinEnergy(0.1*keV);
SetMaxKinEnergy(100.0*TeV);
G4VEmModel* em = new G4MuPairProductionModel();
em->SetLowEnergyLimit(0, 0.1*keV);
em->SetHighEnergyLimit(0, 100.0*TeV);
AddEmModel(em, 0);
G4VEmFluctuationModel* fm = new G4UniversalFluctuation();
AddEmFluctuationModel(fm);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
const G4ParticleDefinition* G4MuPairProductionSTD::DefineBaseParticle(
const G4ParticleDefinition* p)
{
if(!theParticle) theParticle = p;
return theBaseParticle;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
void G4MuPairProductionSTD::PrintInfoDefinition() const
{
G4VEnergyLossSTD::PrintInfoDefinition();
G4cout << " Parametrised model "
<< G4endl;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/muons/src/G4VMuEnergyLoss.cc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VMuEnergyLoss.cc,v 1.22 2002/05/29 12:26:29 vnivanch Exp $
// GEANT4 tag $Name: geant4-04-01 $
// GEANT4 tag $Name: geant4-05-00 $
// --------------------------------------------------------------
// GEANT 4 class implementation file
//