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

Import Geant4 9.4.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-09 16:25:56 +02:00
parent 74cad5e589
commit 89a9605df1
4440 changed files with 379508 additions and 189225 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/xrays/src/G4Cerenkov.cc
+5 -7
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4Cerenkov.cc,v 1.26 2008/11/14 20:16:51 gum Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4Cerenkov.cc,v 1.27 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
////////////////////////////////////////////////////////////////////////
// Cerenkov Radiation Class Implementation
@@ -72,8 +72,6 @@
#include "G4Cerenkov.hh"
using namespace std;
/////////////////////////
// Class Implementation
/////////////////////////
@@ -266,14 +264,14 @@ G4Cerenkov::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
rand = G4UniformRand();
G4double phi = twopi*rand;
G4double sinPhi = sin(phi);
G4double cosPhi = cos(phi);
G4double sinPhi = std::sin(phi);
G4double cosPhi = std::cos(phi);
// calculate x,y, and z components of photon energy
// (in coord system with primary particle direction
// aligned with the z axis)
G4double sinTheta = sqrt(sin2Theta);
G4double sinTheta = std::sqrt(sin2Theta);
G4double px = sinTheta*cosPhi;
G4double py = sinTheta*sinPhi;
G4double pz = cosTheta;
source/processes/electromagnetic/xrays/src/G4ForwardXrayTR.cc
+18 -20
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4ForwardXrayTR.cc,v 1.14 2007/05/11 14:23:04 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4ForwardXrayTR.cc,v 1.15 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// G4ForwardXrayTR class -- implementation file
@@ -84,8 +84,6 @@ G4double G4ForwardXrayTR::fPlasmaCof = 4.0*pi*fine_structure_const*
G4double G4ForwardXrayTR::fCofTR = fine_structure_const/pi ;
using namespace std;
/* ************************************************************************
@@ -410,7 +408,7 @@ void G4ForwardXrayTR::BuildXrayTRtables()
// charged particle crosses interface between two materials.
// The high energy small theta approximation is applied.
// (matter1 -> matter2)
// varAngle =2* (1 - cos(Theta)) or approximately = Theta*Theta
// varAngle =2* (1 - std::cos(Theta)) or approximately = Theta*Theta
//
G4double
@@ -451,11 +449,11 @@ G4double G4ForwardXrayTR::AngleDensity( G4double energy,
b2 = d*f ;
a4 = a2*a2 ;
b4 = b2*b2 ;
a = sqrt(a2) ;
b = sqrt(b2) ;
cof1 = c*c*(0.5/(a2*(x2 +a2)) +0.5*log(x2/(x2 +a2))/a4) ;
cof3 = d*d*(0.5/(b2*(x2 +b2)) +0.5*log(x2/(x2 +b2))/b4) ;
cof2 = -c*d*(log(x2/(x2 +b2))/b2 - log(x2/(x2 +a2))/a2)/(a2 - b2) ;
a = std::sqrt(a2) ;
b = std::sqrt(b2) ;
cof1 = c*c*(0.5/(a2*(x2 +a2)) +0.5*std::log(x2/(x2 +a2))/a4) ;
cof3 = d*d*(0.5/(b2*(x2 +b2)) +0.5*std::log(x2/(x2 +b2))/b4) ;
cof2 = -c*d*(std::log(x2/(x2 +b2))/b2 - std::log(x2/(x2 +a2))/a2)/(a2 - b2) ;
return -varAngle*(cof1 + cof2 + cof3) ;
}
@@ -502,7 +500,7 @@ G4double G4ForwardXrayTR::AngleSum( G4double varAngle1,
/////////////////////////////////////////////////////////////////////
//
// Analytical Expression for spectral density of Xray TR photons
// x = 2*(1 - cos(Theta)) ~ Theta^2
// x = 2*(1 - std::cos(Theta)) ~ Theta^2
//
G4double G4ForwardXrayTR::SpectralDensity( G4double energy,
@@ -513,7 +511,7 @@ G4double G4ForwardXrayTR::SpectralDensity( G4double energy,
+ fSigma1/(energy*energy) ;
b = 1.0/(fGamma*fGamma)
+ fSigma2/(energy*energy) ;
return ( (a + b)*log((x + b)/(x + a))/(a - b)
return ( (a + b)*std::log((x + b)/(x + a))/(a - b)
+ a/(x + a) + b/(x + b) )/energy ;
}
@@ -687,14 +685,14 @@ G4VParticleChange* G4ForwardXrayTR::PostStepDoIt(const G4Track& aTrack,
{
if(anglePos > (*(*fAngleDistrTable)(iPlace))(iTransfer)) break ;
}
theta = sqrt((*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer-1)) ;
theta = std::sqrt((*fAngleDistrTable)(iPlace)->GetLowEdgeEnergy(iTransfer-1)) ;
// G4cout<<iTransfer<<" : theta = "<<theta<<G4endl ;
phi = twopi*G4UniformRand() ;
dirX = sin(theta)*cos(phi) ;
dirY = sin(theta)*sin(phi) ;
dirZ = cos(theta) ;
dirX = std::sin(theta)*std::cos(phi) ;
dirY = std::sin(theta)*std::sin(phi) ;
dirZ = std::cos(theta) ;
G4ThreeVector directionTR(dirX,dirY,dirZ) ;
directionTR.rotateUz(particleDir) ;
G4DynamicParticle* aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(),
@@ -762,7 +760,7 @@ G4VParticleChange* G4ForwardXrayTR::PostStepDoIt(const G4Track& aTrack,
if(anglePos > ((*(*fAngleDistrTable)(iPlace))(iTransfer)*W1+
(*(*fAngleDistrTable)(iPlace + 1))(iTransfer)*W2)) break ;
}
theta = sqrt(((*fAngleDistrTable)(iPlace)->
theta = std::sqrt(((*fAngleDistrTable)(iPlace)->
GetLowEdgeEnergy(iTransfer-1))*W1+
((*fAngleDistrTable)(iPlace + 1)->
GetLowEdgeEnergy(iTransfer-1))*W2) ;
@@ -770,9 +768,9 @@ G4VParticleChange* G4ForwardXrayTR::PostStepDoIt(const G4Track& aTrack,
// G4cout<<iTransfer<<" : theta = "<<theta<<G4endl ;
phi = twopi*G4UniformRand() ;
dirX = sin(theta)*cos(phi) ;
dirY = sin(theta)*sin(phi) ;
dirZ = cos(theta) ;
dirX = std::sin(theta)*std::cos(phi) ;
dirY = std::sin(theta)*std::sin(phi) ;
dirZ = std::cos(theta) ;
G4ThreeVector directionTR(dirX,dirY,dirZ) ;
directionTR.rotateUz(particleDir) ;
G4DynamicParticle* aPhotonTR = new G4DynamicParticle(G4Gamma::Gamma(),
source/processes/electromagnetic/xrays/src/G4GammaXTRadiator.cc
+6 -8
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4GammaXTRadiator.cc,v 1.5 2006/06/29 19:56:07 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4GammaXTRadiator.cc,v 1.6 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#include <complex>
@@ -35,8 +35,6 @@
#include "G4Gamma.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -94,19 +92,19 @@ G4GammaXTRadiator::GetStackFactor( G4double energy,
G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate) ;
G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas) ;
G4complex Ha = pow(Ca,-fAlphaPlate) ;
G4complex Hb = pow(Cb,-fAlphaGas) ;
G4complex Ha = std::pow(Ca,-fAlphaPlate) ;
G4complex Hb = std::pow(Cb,-fAlphaGas) ;
G4complex H = Ha*Hb ;
G4complex F1 = (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
* G4double(fPlateNumber) ;
G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
* (1.0 - pow(H,fPlateNumber)) ;
* (1.0 - std::pow(H,fPlateNumber)) ;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle) ;
result = 2.0*real(R) ;
result = 2.0*std::real(R) ;
return result ;
}
source/processes/electromagnetic/xrays/src/G4RegularXTRadiator.cc
+16 -18
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4RegularXTRadiator.cc,v 1.9 2006/06/29 19:56:09 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4RegularXTRadiator.cc,v 1.10 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#include <complex>
@@ -35,8 +35,6 @@
#include "G4Gamma.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -95,19 +93,19 @@ G4RegularXTRadiator::GetStackFactor( G4double energy,
G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate);
G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas);
G4complex Ha = pow(Ca,-fAlphaPlate);
G4complex Hb = pow(Cb,-fAlphaGas);
G4complex Ha = std::pow(Ca,-fAlphaPlate);
G4complex Hb = std::pow(Cb,-fAlphaGas);
G4complex H = Ha*Hb;
G4complex F1 = (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
* G4double(fPlateNumber);
G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
* (1.0 - pow(H,fPlateNumber));
* (1.0 - std::pow(H,fPlateNumber));
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
@@ -120,22 +118,22 @@ G4RegularXTRadiator::GetStackFactor( G4double energy,
bZb = fGasThick/GetGasFormationZone(energy,gamma,varAngle);
aMa = fPlateThick*GetPlateLinearPhotoAbs(energy);
bMb = fGasThick*GetGasLinearPhotoAbs(energy);
Qa = exp(-aMa);
Qb = exp(-bMb);
Qa = std::exp(-aMa);
Qb = std::exp(-bMb);
Q = Qa*Qb;
G4complex Ha( exp(-0.5*aMa)*cos(aZa),
-exp(-0.5*aMa)*sin(aZa) );
G4complex Hb( exp(-0.5*bMb)*cos(bZb),
-exp(-0.5*bMb)*sin(bZb) );
G4complex Ha( std::exp(-0.5*aMa)*std::cos(aZa),
-std::exp(-0.5*aMa)*std::sin(aZa) );
G4complex Hb( std::exp(-0.5*bMb)*std::cos(bZb),
-std::exp(-0.5*bMb)*std::sin(bZb) );
G4complex H = Ha*Hb;
G4complex Hs = conj(H);
D = 1.0 /( (1 - sqrt(Q))*(1 - sqrt(Q)) +
4*sqrt(Q)*sin(0.5*(aZa+bZb))*sin(0.5*(aZa+bZb)) );
D = 1.0 /( (1 - std::sqrt(Q))*(1 - std::sqrt(Q)) +
4*std::sqrt(Q)*std::sin(0.5*(aZa+bZb))*std::sin(0.5*(aZa+bZb)) );
G4complex F1 = (1.0 - Ha)*(1.0 - Hb)*(1.0 - Hs)
* G4double(fPlateNumber)*D;
G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb*(1.0-Hs)*(1.0-Hs)
* (1.0 - pow(H,fPlateNumber)) * D*D;
* (1.0 - std::pow(H,fPlateNumber)) * D*D;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
@@ -148,7 +146,7 @@ G4RegularXTRadiator::GetStackFactor( G4double energy,
}
G4complex R = (2.- Ha - 1./Ha)*S + (1. - Ha)*G4double(fPlateNumber);
R *= OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
*/
}
source/processes/electromagnetic/xrays/src/G4Scintillation.cc
+312 -150
View File
@@ -24,19 +24,26 @@
// ********************************************************************
//
//
// $Id: G4Scintillation.cc,v 1.30 2008/10/22 01:19:11 gum Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4Scintillation.cc,v 1.38 2010/12/15 07:39:26 gunter Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
////////////////////////////////////////////////////////////////////////
// Scintillation Light Class Implementation
////////////////////////////////////////////////////////////////////////
//
// File: G4Scintillation.cc
// File: G4Scintillation.cc
// Description: RestDiscrete Process - Generation of Scintillation Photons
// Version: 1.0
// Created: 1998-11-07
// Created: 1998-11-07
// Author: Peter Gumplinger
// Updated: 2005-08-17 by Peter Gumplinger
// Updated: 2010-10-20 Allow the scintillation yield to be a function
// of energy deposited by particle type
// Thanks to Zach Hartwig (Department of Nuclear
// Science and Engineeering - MIT)
// 2010-09-22 by Peter Gumplinger
// > scintillation rise time included, thanks to
// > Martin Goettlich/DESY
// 2005-08-17 by Peter Gumplinger
// > change variable name MeanNumPhotons -> MeanNumberOfPhotons
// 2005-07-28 by Peter Gumplinger
// > add G4ProcessType to constructor
@@ -55,7 +62,7 @@
// 2000-09-18 by Peter Gumplinger
// > change: aSecondaryPosition=x0+rand*aStep.GetDeltaPosition();
// aSecondaryTrack->SetTouchable(0);
// 2001-09-17, migration of Materials to pure STL (mma)
// 2001-09-17, migration of Materials to pure STL (mma)
// 2003-06-03, V.Ivanchenko fix compilation warnings
//
// mail: gum@triumf.ca
@@ -63,14 +70,13 @@
////////////////////////////////////////////////////////////////////////
#include "G4ios.hh"
#include "G4ParticleTypes.hh"
#include "G4EmProcessSubType.hh"
#include "G4Scintillation.hh"
using namespace std;
/////////////////////////
// Class Implementation
// Class Implementation
/////////////////////////
//////////////
@@ -91,19 +97,22 @@ G4Scintillation::G4Scintillation(const G4String& processName,
{
SetProcessSubType(fScintillation);
fTrackSecondariesFirst = false;
fTrackSecondariesFirst = false;
fFiniteRiseTime = false;
YieldFactor = 1.0;
ExcitationRatio = 1.0;
scintillationByParticleType = false;
theFastIntegralTable = NULL;
theSlowIntegralTable = NULL;
if (verboseLevel>0) {
if (verboseLevel>0) {
G4cout << GetProcessName() << " is created " << G4endl;
}
}
BuildThePhysicsTable();
BuildThePhysicsTable();
emSaturation = NULL;
}
@@ -112,12 +121,12 @@ G4Scintillation::G4Scintillation(const G4String& processName,
// Destructors
////////////////
G4Scintillation::~G4Scintillation()
G4Scintillation::~G4Scintillation()
{
if (theFastIntegralTable != NULL) {
theFastIntegralTable->clearAndDestroy();
theFastIntegralTable->clearAndDestroy();
delete theFastIntegralTable;
}
}
if (theSlowIntegralTable != NULL) {
theSlowIntegralTable->clearAndDestroy();
delete theSlowIntegralTable;
@@ -158,12 +167,12 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
const G4DynamicParticle* aParticle = aTrack.GetDynamicParticle();
const G4Material* aMaterial = aTrack.GetMaterial();
G4StepPoint* pPreStepPoint = aStep.GetPreStepPoint();
G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
G4StepPoint* pPreStepPoint = aStep.GetPreStepPoint();
G4StepPoint* pPostStepPoint = aStep.GetPostStepPoint();
G4ThreeVector x0 = pPreStepPoint->GetPosition();
G4ThreeVector x0 = pPreStepPoint->GetPosition();
G4ThreeVector p0 = aStep.GetDeltaPosition().unit();
G4double t0 = pPreStepPoint->GetGlobalTime();
G4double t0 = pPreStepPoint->GetGlobalTime();
G4double TotalEnergyDeposit = aStep.GetTotalEnergyDeposit();
@@ -172,7 +181,7 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
if (!aMaterialPropertiesTable)
return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
const G4MaterialPropertyVector* Fast_Intensity =
const G4MaterialPropertyVector* Fast_Intensity =
aMaterialPropertiesTable->GetProperty("FASTCOMPONENT");
const G4MaterialPropertyVector* Slow_Intensity =
aMaterialPropertiesTable->GetProperty("SLOWCOMPONENT");
@@ -183,9 +192,101 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
G4int nscnt = 1;
if (Fast_Intensity && Slow_Intensity) nscnt = 2;
G4double ScintillationYield = aMaterialPropertiesTable->
G4double ScintillationYield = 0.;
if (scintillationByParticleType) {
// The scintillation response is a function of the energy
// deposited by particle types.
// Get the definition of the current particle
G4ParticleDefinition *pDef = aParticle->GetDefinition();
const G4MaterialPropertyVector *Scint_Yield_Vector = NULL;
// Obtain the G4MaterialPropertyVectory containing the
// scintillation light yield as a function of the deposited
// energy for the current particle type
// Protons
if(pDef==G4Proton::ProtonDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("PROTONSCINTILLATIONYIELD");
// Deuterons
else if(pDef==G4Deuteron::DeuteronDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("DEUTERONSCINTILLATIONYIELD");
// Tritons
else if(pDef==G4Triton::TritonDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("TRITONSCINTILLATIONYIELD");
// Alphas
else if(pDef==G4Alpha::AlphaDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("ALPHASCINTILLATIONYIELD");
// Ions (particles derived from G4VIon and G4Ions)
// and recoil ions below tracking cut from neutrons after hElastic
else if(pDef->GetParticleType()== "nucleus" ||
pDef==G4Neutron::NeutronDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("IONSCINTILLATIONYIELD");
// Electrons (must also account for shell-binding energy
// attributed to gamma from standard PhotoElectricEffect)
else if(pDef==G4Electron::ElectronDefinition() ||
pDef==G4Gamma::GammaDefinition())
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("ELECTRONSCINTILLATIONYIELD");
// Default for particles not enumerated/listed above
else
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("ELECTRONSCINTILLATIONYIELD");
// If the user has not specified yields for (p,d,t,a,carbon)
// then these unspecified particles will default to the
// electron's scintillation yield
if(!Scint_Yield_Vector){
Scint_Yield_Vector = aMaterialPropertiesTable->
GetProperty("ELECTRONSCINTILLATIONYIELD");
}
// Throw an exception if no scintillation yield is found
if (!Scint_Yield_Vector) {
G4cerr << "\nG4Scintillation::PostStepDoIt(): "
<< "Request for scintillation yield for energy deposit and particle type without correct entry in MaterialPropertiesTable\n"
<< "ScintillationByParticleType requires at minimum that ELECTRONSCINTILLATIONYIELD is set by the user\n"
<< G4endl;
G4Exception("G4Scintillation::PostStepDoIt",
"No correct entry in MaterialPropertiesTable",
FatalException,"Missing MaterialPropertiesTable entry.");
}
if (verboseLevel>1) {
G4cout << "\n"
<< "Particle = " << pDef->GetParticleName() << "\n"
<< "Energy Dep. = " << TotalEnergyDeposit/MeV << "\n"
<< "Yield = "
<< Scint_Yield_Vector->GetProperty(TotalEnergyDeposit)
<< "\n" << G4endl;
}
// Obtain the scintillation yield using the total energy
// deposited by the particle in this step.
// Units: [# scintillation photons]
ScintillationYield = Scint_Yield_Vector->
GetProperty(TotalEnergyDeposit);
} else {
// The default linear scintillation process
ScintillationYield = aMaterialPropertiesTable->
GetConstProperty("SCINTILLATIONYIELD");
ScintillationYield *= YieldFactor;
// Units: [# scintillation photons / MeV]
ScintillationYield *= YieldFactor;
}
G4double ResolutionScale = aMaterialPropertiesTable->
GetConstProperty("RESOLUTIONSCALE");
@@ -198,18 +299,22 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
G4double MeanNumberOfPhotons;
if (emSaturation) {
// Birk's correction via emSaturation and specifying scintillation by
// by particle type are physically mutually exclusive
if (scintillationByParticleType)
MeanNumberOfPhotons = ScintillationYield;
else if (emSaturation)
MeanNumberOfPhotons = ScintillationYield*
(emSaturation->VisibleEnergyDeposition(&aStep));
} else {
else
MeanNumberOfPhotons = ScintillationYield*TotalEnergyDeposit;
}
G4int NumPhotons;
if (MeanNumberOfPhotons > 10.)
{
G4double sigma = ResolutionScale * sqrt(MeanNumberOfPhotons);
G4double sigma = ResolutionScale * std::sqrt(MeanNumberOfPhotons);
NumPhotons = G4int(G4RandGauss::shoot(MeanNumberOfPhotons,sigma)+0.5);
}
else
@@ -217,36 +322,37 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
NumPhotons = G4int(G4Poisson(MeanNumberOfPhotons));
}
if (NumPhotons <= 0)
if (NumPhotons <= 0)
{
// return unchanged particle and no secondaries
// return unchanged particle and no secondaries
aParticleChange.SetNumberOfSecondaries(0);
aParticleChange.SetNumberOfSecondaries(0);
return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
}
////////////////////////////////////////////////////////////////
aParticleChange.SetNumberOfSecondaries(NumPhotons);
if (fTrackSecondariesFirst) {
if (aTrack.GetTrackStatus() == fAlive )
aParticleChange.ProposeTrackStatus(fSuspend);
}
////////////////////////////////////////////////////////////////
G4int materialIndex = aMaterial->GetIndex();
////////////////////////////////////////////////////////////////
// Retrieve the Scintillation Integral for this material
// new G4PhysicsOrderedFreeVector allocated to hold CII's
aParticleChange.SetNumberOfSecondaries(NumPhotons);
if (fTrackSecondariesFirst) {
if (aTrack.GetTrackStatus() == fAlive )
aParticleChange.ProposeTrackStatus(fSuspend);
}
////////////////////////////////////////////////////////////////
G4int materialIndex = aMaterial->GetIndex();
// Retrieve the Scintillation Integral for this material
// new G4PhysicsOrderedFreeVector allocated to hold CII's
G4int Num = NumPhotons;
for (G4int scnt = 1; scnt <= nscnt; scnt++) {
G4double ScintillationTime = 0.*ns;
G4double ScintillationRiseTime = 0.*ns;
G4PhysicsOrderedFreeVector* ScintillationIntegral = NULL;
if (scnt == 1) {
@@ -254,12 +360,20 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
if(Fast_Intensity){
ScintillationTime = aMaterialPropertiesTable->
GetConstProperty("FASTTIMECONSTANT");
if (fFiniteRiseTime) {
ScintillationRiseTime = aMaterialPropertiesTable->
GetConstProperty("FASTSCINTILLATIONRISETIME");
}
ScintillationIntegral =
(G4PhysicsOrderedFreeVector*)((*theFastIntegralTable)(materialIndex));
}
if(Slow_Intensity){
ScintillationTime = aMaterialPropertiesTable->
GetConstProperty("SLOWTIMECONSTANT");
if (fFiniteRiseTime) {
ScintillationRiseTime = aMaterialPropertiesTable->
GetConstProperty("SLOWSCINTILLATIONRISETIME");
}
ScintillationIntegral =
(G4PhysicsOrderedFreeVector*)((*theSlowIntegralTable)(materialIndex));
}
@@ -268,13 +382,17 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
G4double YieldRatio = aMaterialPropertiesTable->
GetConstProperty("YIELDRATIO");
if ( ExcitationRatio == 1.0 ) {
Num = G4int (min(YieldRatio,1.0) * NumPhotons);
Num = G4int (std::min(YieldRatio,1.0) * NumPhotons);
}
else {
Num = G4int (min(ExcitationRatio,1.0) * NumPhotons);
Num = G4int (std::min(ExcitationRatio,1.0) * NumPhotons);
}
ScintillationTime = aMaterialPropertiesTable->
GetConstProperty("FASTTIMECONSTANT");
if (fFiniteRiseTime) {
ScintillationRiseTime = aMaterialPropertiesTable->
GetConstProperty("FASTSCINTILLATIONRISETIME");
}
ScintillationIntegral =
(G4PhysicsOrderedFreeVector*)((*theFastIntegralTable)(materialIndex));
}
@@ -283,6 +401,10 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
Num = NumPhotons - Num;
ScintillationTime = aMaterialPropertiesTable->
GetConstProperty("SLOWTIMECONSTANT");
if (fFiniteRiseTime) {
ScintillationRiseTime = aMaterialPropertiesTable->
GetConstProperty("SLOWSCINTILLATIONRISETIME");
}
ScintillationIntegral =
(G4PhysicsOrderedFreeVector*)((*theSlowIntegralTable)(materialIndex));
}
@@ -291,51 +413,51 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
// Max Scintillation Integral
G4double CIImax = ScintillationIntegral->GetMaxValue();
for (G4int i = 0; i < Num; i++) {
G4double CIImax = ScintillationIntegral->GetMaxValue();
// Determine photon energy
for (G4int i = 0; i < Num; i++) {
// Determine photon energy
G4double CIIvalue = G4UniformRand()*CIImax;
G4double sampledEnergy =
G4double sampledEnergy =
ScintillationIntegral->GetEnergy(CIIvalue);
if (verboseLevel>1) {
if (verboseLevel>1) {
G4cout << "sampledEnergy = " << sampledEnergy << G4endl;
G4cout << "CIIvalue = " << CIIvalue << G4endl;
}
G4cout << "CIIvalue = " << CIIvalue << G4endl;
}
// Generate random photon direction
// Generate random photon direction
G4double cost = 1. - 2.*G4UniformRand();
G4double sint = sqrt((1.-cost)*(1.+cost));
G4double sint = std::sqrt((1.-cost)*(1.+cost));
G4double phi = twopi*G4UniformRand();
G4double sinp = sin(phi);
G4double cosp = cos(phi);
G4double phi = twopi*G4UniformRand();
G4double sinp = std::sin(phi);
G4double cosp = std::cos(phi);
G4double px = sint*cosp;
G4double py = sint*sinp;
G4double pz = cost;
G4double px = sint*cosp;
G4double py = sint*sinp;
G4double pz = cost;
// Create photon momentum direction vector
// Create photon momentum direction vector
G4ParticleMomentum photonMomentum(px, py, pz);
G4ParticleMomentum photonMomentum(px, py, pz);
// Determine polarization of new photon
// Determine polarization of new photon
G4double sx = cost*cosp;
G4double sy = cost*sinp;
G4double sz = -sint;
G4double sx = cost*cosp;
G4double sy = cost*sinp;
G4double sz = -sint;
G4ThreeVector photonPolarization(sx, sy, sz);
G4ThreeVector photonPolarization(sx, sy, sz);
G4ThreeVector perp = photonMomentum.cross(photonPolarization);
phi = twopi*G4UniformRand();
sinp = sin(phi);
cosp = cos(phi);
phi = twopi*G4UniformRand();
sinp = std::sin(phi);
cosp = std::cos(phi);
photonPolarization = cosp * photonPolarization + sinp * perp;
@@ -345,13 +467,13 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
G4DynamicParticle* aScintillationPhoton =
new G4DynamicParticle(G4OpticalPhoton::OpticalPhoton(),
photonMomentum);
aScintillationPhoton->SetPolarization
(photonPolarization.x(),
photonPolarization.y(),
photonPolarization.z());
photonMomentum);
aScintillationPhoton->SetPolarization
(photonPolarization.x(),
photonPolarization.y(),
photonPolarization.z());
aScintillationPhoton->SetKineticEnergy(sampledEnergy);
aScintillationPhoton->SetKineticEnergy(sampledEnergy);
// Generate new G4Track object:
@@ -368,16 +490,22 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
((pPreStepPoint->GetVelocity()+
pPostStepPoint->GetVelocity())/2.);
deltaTime = deltaTime -
ScintillationTime * log( G4UniformRand() );
// emission time distribution
if (ScintillationRiseTime==0.0) {
deltaTime = deltaTime -
ScintillationTime * std::log( G4UniformRand() );
} else {
deltaTime = deltaTime +
sample_time(ScintillationRiseTime, ScintillationTime);
}
G4double aSecondaryTime = t0 + deltaTime;
G4ThreeVector aSecondaryPosition =
x0 + rand * aStep.GetDeltaPosition();
G4Track* aSecondaryTrack =
new G4Track(aScintillationPhoton,aSecondaryTime,aSecondaryPosition);
G4Track* aSecondaryTrack =
new G4Track(aScintillationPhoton,aSecondaryTime,aSecondaryPosition);
aSecondaryTrack->SetTouchableHandle(
aStep.GetPreStepPoint()->GetTouchableHandle());
@@ -385,17 +513,17 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
aSecondaryTrack->SetParentID(aTrack.GetTrackID());
aParticleChange.AddSecondary(aSecondaryTrack);
aParticleChange.AddSecondary(aSecondaryTrack);
}
}
}
if (verboseLevel>0) {
G4cout << "\n Exiting from G4Scintillation::DoIt -- NumberOfSecondaries = "
<< aParticleChange.GetNumberOfSecondaries() << G4endl;
}
if (verboseLevel>0) {
G4cout << "\n Exiting from G4Scintillation::DoIt -- NumberOfSecondaries = "
<< aParticleChange.GetNumberOfSecondaries() << G4endl;
}
return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
return G4VRestDiscreteProcess::PostStepDoIt(aTrack, aStep);
}
// BuildThePhysicsTable for the scintillation process
@@ -404,95 +532,95 @@ G4Scintillation::PostStepDoIt(const G4Track& aTrack, const G4Step& aStep)
void G4Scintillation::BuildThePhysicsTable()
{
if (theFastIntegralTable && theSlowIntegralTable) return;
if (theFastIntegralTable && theSlowIntegralTable) return;
const G4MaterialTable* theMaterialTable =
const G4MaterialTable* theMaterialTable =
G4Material::GetMaterialTable();
G4int numOfMaterials = G4Material::GetNumberOfMaterials();
G4int numOfMaterials = G4Material::GetNumberOfMaterials();
// create new physics table
// create new physics table
if(!theFastIntegralTable)theFastIntegralTable = new G4PhysicsTable(numOfMaterials);
if(!theFastIntegralTable)theFastIntegralTable = new G4PhysicsTable(numOfMaterials);
if(!theSlowIntegralTable)theSlowIntegralTable = new G4PhysicsTable(numOfMaterials);
// loop for materials
// loop for materials
for (G4int i=0 ; i < numOfMaterials; i++)
{
G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector =
for (G4int i=0 ; i < numOfMaterials; i++)
{
G4PhysicsOrderedFreeVector* aPhysicsOrderedFreeVector =
new G4PhysicsOrderedFreeVector();
G4PhysicsOrderedFreeVector* bPhysicsOrderedFreeVector =
new G4PhysicsOrderedFreeVector();
// Retrieve vector of scintillation wavelength intensity for
// Retrieve vector of scintillation wavelength intensity for
// the material from the material's optical properties table.
G4Material* aMaterial = (*theMaterialTable)[i];
G4Material* aMaterial = (*theMaterialTable)[i];
G4MaterialPropertiesTable* aMaterialPropertiesTable =
aMaterial->GetMaterialPropertiesTable();
G4MaterialPropertiesTable* aMaterialPropertiesTable =
aMaterial->GetMaterialPropertiesTable();
if (aMaterialPropertiesTable) {
if (aMaterialPropertiesTable) {
G4MaterialPropertyVector* theFastLightVector =
aMaterialPropertiesTable->GetProperty("FASTCOMPONENT");
G4MaterialPropertyVector* theFastLightVector =
aMaterialPropertiesTable->GetProperty("FASTCOMPONENT");
if (theFastLightVector) {
// Retrieve the first intensity point in vector
// of (photon energy, intensity) pairs
if (theFastLightVector) {
theFastLightVector->ResetIterator();
++(*theFastLightVector); // advance to 1st entry
// Retrieve the first intensity point in vector
// of (photon energy, intensity) pairs
G4double currentIN = theFastLightVector->
GetProperty();
theFastLightVector->ResetIterator();
++(*theFastLightVector); // advance to 1st entry
if (currentIN >= 0.0) {
G4double currentIN = theFastLightVector->
GetProperty();
// Create first (photon energy, Scintillation
if (currentIN >= 0.0) {
// Create first (photon energy, Scintillation
// Integral pair
G4double currentPM = theFastLightVector->
GetPhotonEnergy();
G4double currentPM = theFastLightVector->
GetPhotonEnergy();
G4double currentCII = 0.0;
G4double currentCII = 0.0;
aPhysicsOrderedFreeVector->
InsertValues(currentPM , currentCII);
aPhysicsOrderedFreeVector->
InsertValues(currentPM , currentCII);
// Set previous values to current ones prior to loop
// Set previous values to current ones prior to loop
G4double prevPM = currentPM;
G4double prevCII = currentCII;
G4double prevIN = currentIN;
G4double prevPM = currentPM;
G4double prevCII = currentCII;
G4double prevIN = currentIN;
// loop over all (photon energy, intensity)
// pairs stored for this material
// loop over all (photon energy, intensity)
// pairs stored for this material
while(++(*theFastLightVector))
{
currentPM = theFastLightVector->
GetPhotonEnergy();
while(++(*theFastLightVector))
{
currentPM = theFastLightVector->
GetPhotonEnergy();
currentIN=theFastLightVector->
GetProperty();
currentIN = theFastLightVector->
GetProperty();
currentCII = 0.5 * (prevIN + currentIN);
currentCII = 0.5 * (prevIN + currentIN);
currentCII = prevCII +
(currentPM - prevPM) * currentCII;
currentCII = prevCII +
(currentPM - prevPM) * currentCII;
aPhysicsOrderedFreeVector->
InsertValues(currentPM, currentCII);
aPhysicsOrderedFreeVector->
InsertValues(currentPM, currentCII);
prevPM = currentPM;
prevCII = currentCII;
prevIN = currentIN;
}
prevPM = currentPM;
prevCII = currentCII;
prevIN = currentIN;
}
}
}
}
}
G4MaterialPropertyVector* theSlowLightVector =
aMaterialPropertiesTable->GetProperty("SLOWCOMPONENT");
@@ -553,16 +681,29 @@ void G4Scintillation::BuildThePhysicsTable()
}
}
}
}
// The scintillation integral(s) for a given material
// will be inserted in the table(s) according to the
// position of the material in the material table.
// The scintillation integral(s) for a given material
// will be inserted in the table(s) according to the
// position of the material in the material table.
theFastIntegralTable->insertAt(i,aPhysicsOrderedFreeVector);
theFastIntegralTable->insertAt(i,aPhysicsOrderedFreeVector);
theSlowIntegralTable->insertAt(i,bPhysicsOrderedFreeVector);
}
}
}
// Called by the user to set the scintillation yield as a function
// of energy deposited by particle type
void G4Scintillation::SetScintillationByParticleType(const G4bool scintType)
{
if (emSaturation) {
G4Exception("G4Scintillation::SetScintillationByParticleType", "Redefinition",
JustWarning, "Birks Saturation is replaced by ScintillationByParticleType!");
RemoveSaturation();
}
scintillationByParticleType = scintType;
}
// GetMeanFreePath
@@ -575,7 +716,7 @@ G4double G4Scintillation::GetMeanFreePath(const G4Track&,
{
*condition = StronglyForced;
return DBL_MAX;
return DBL_MAX;
}
@@ -591,3 +732,24 @@ G4double G4Scintillation::GetMeanLifeTime(const G4Track&,
return DBL_MAX;
}
G4double G4Scintillation::sample_time(G4double tau1, G4double tau2)
{
// tau1: rise time and tau2: decay time
while(1) {
// two random numbers
G4double ran1 = G4UniformRand();
G4double ran2 = G4UniformRand();
//
// exponential distribution as envelope function: very efficient
//
G4double d = (tau1+tau2)/tau2;
// make sure the envelope function is
// always larger than the bi-exponential
G4double t = -1.0*tau2*std::log(1-ran1);
G4double g = d*single_exp(t,tau2);
if (ran2 <= bi_exp(t,tau1,tau2)/g) return t;
}
return -1.0;
}
source/processes/electromagnetic/xrays/src/G4StrawTubeXTRadiator.cc
+10 -12
View File
@@ -24,16 +24,14 @@
// ********************************************************************
//
//
// $Id: G4StrawTubeXTRadiator.cc,v 1.6 2007/09/29 17:49:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4StrawTubeXTRadiator.cc,v 1.7 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#include "G4StrawTubeXTRadiator.hh"
#include "Randomize.hh"
#include "G4Gamma.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -77,7 +75,7 @@ G4StrawTubeXTRadiator::G4StrawTubeXTRadiator(G4LogicalVolume *anEnvelope,
fSigma3 = fPlasmaCof*mediumMat->GetElectronDensity();
if(verboseLevel > 0)
G4cout<<"medium plasma energy = "<<sqrt(fSigma3)/eV<<" eV"<<G4endl;
G4cout<<"medium plasma energy = "<<std::sqrt(fSigma3)/eV<<" eV"<<G4endl;
// Compute cofs for preparation of linear photo absorption in external medium
@@ -120,8 +118,8 @@ G4StrawTubeXTRadiator::GetStackFactor( G4double energy,
G4complex C2(1.0 + 0.5*fPlateThick*M2/fAlphaPlate, fPlateThick/L2/fAlphaPlate);
G4complex C3(1.0 + 0.5*fGasThick*M3/fAlphaGas, fGasThick/L3/fAlphaGas);
G4complex H2 = pow(C2,-fAlphaPlate);
G4complex H3 = pow(C3,-fAlphaGas);
G4complex H2 = std::pow(C2,-fAlphaPlate);
G4complex H3 = std::pow(C3,-fAlphaGas);
G4complex H = H2*H3;
G4complex Z1 = GetMediumComplexFZ(energy,gamma,varAngle);
@@ -133,7 +131,7 @@ G4StrawTubeXTRadiator::GetStackFactor( G4double energy,
( Z2 - Z3 )*( Z2 - Z3 )*( 1. - H3 ) +
2.*( Z1 - Z2 )*( Z2 - Z3 )*H2*( 1. - H3 ) ;
result = 2.0*real(R)*(varAngle*energy/hbarc/hbarc);
result = 2.0*std::real(R)*(varAngle*energy/hbarc/hbarc);
return result;
@@ -164,16 +162,16 @@ G4complex G4StrawTubeXTRadiator::GetMediumComplexFZ( G4double omega ,
G4double gamma ,
G4double varAngle )
{
G4double cof, length,delta, real, image;
G4double cof, length,delta, real_v, image_v;
length = 0.5*GetMediumFormationZone(omega,gamma,varAngle);
delta = length*GetMediumLinearPhotoAbs(omega);
cof = 1.0/(1.0 + delta*delta);
real = length*cof;
image = real*delta;
real_v = length*cof;
image_v = real_v*delta;
G4complex zone(real,image);
G4complex zone(real_v,image_v);
return zone;
}
source/processes/electromagnetic/xrays/src/G4SynchrotronRadiation.cc
+18 -20
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4SynchrotronRadiation.cc,v 1.5 2006/06/29 19:56:15 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4SynchrotronRadiation.cc,v 1.8 2010/10/14 18:38:21 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// --------------------------------------------------------------
// GEANT 4 class implementation file
@@ -43,10 +43,8 @@
///////////////////////////////////////////////////////////////////////////
#include "G4SynchrotronRadiation.hh"
// #include "G4Integrator.hh"
#include "G4UnitsTable.hh"
using namespace std;
#include "G4EmProcessSubType.hh"
///////////////////////////////////////////////////////////////////////
//
@@ -64,9 +62,11 @@ G4SynchrotronRadiation::G4SynchrotronRadiation(const G4String& processName,
fFieldPropagator = transportMgr->GetPropagatorInField();
fLambdaConst = sqrt(3.0)*electron_mass_c2/
fLambdaConst = std::sqrt(3.0)*electron_mass_c2/
(2.5*fine_structure_const*eplus*c_light) ;
fEnergyConst = 1.5*c_light*c_light*eplus*hbar_Planck/electron_mass_c2 ;
SetProcessSubType(fSynchrotronRadiation);
verboseLevel=1;
}
@@ -76,9 +76,7 @@ G4SynchrotronRadiation::G4SynchrotronRadiation(const G4String& processName,
//
G4SynchrotronRadiation::~G4SynchrotronRadiation()
{
;
}
{}
/////////////////////////////// METHODS /////////////////////////////////
//
@@ -168,7 +166,7 @@ G4SynchrotronRadiation::GetMeanFreePath( const G4Track& trackData,
G4cout
<< " B = " << Btot/tesla << " Tesla"
<< " perpB = " << perpB/tesla << " Tesla"
<< " Theta = " << Theta << " sin(Theta)=" << sin(Theta) << '\n'
<< " Theta = " << Theta << " std::sin(Theta)=" << std::sin(Theta) << '\n'
<< " ptot = " << G4BestUnit(ptot,"Energy")
<< " rho = " << G4BestUnit(rho,"Length")
<< G4endl;
@@ -261,18 +259,18 @@ G4SynchrotronRadiation::PostStepDoIt(const G4Track& trackData,
G4double Phi = twopi * G4UniformRand() ;
G4double dirx = sin(Teta)*cos(Phi) ,
diry = sin(Teta)*sin(Phi) ,
dirz = cos(Teta) ;
G4double dirx = std::sin(Teta)*std::cos(Phi) ,
diry = std::sin(Teta)*std::sin(Phi) ,
dirz = std::cos(Teta) ;
G4ThreeVector gammaDirection ( dirx, diry, dirz);
gammaDirection.rotateUz(particleDirection);
// polarization of new gamma
// G4double sx = cos(Teta)*cos(Phi);
// G4double sy = cos(Teta)*sin(Phi);
// G4double sz = -sin(Teta);
// G4double sx = std::cos(Teta)*std::cos(Phi);
// G4double sy = std::cos(Teta)*std::sin(Phi);
// G4double sz = -std::sin(Teta);
G4ThreeVector gammaPolarization = FieldValue.cross(gammaDirection);
gammaPolarization = gammaPolarization.unit();
@@ -367,11 +365,11 @@ G4double G4SynchrotronRadiation::InvSynFracInt(G4double x)
if(x<aa2) return x*x*x*Chebyshev(aa1,aa2,cheb1,ncheb1,x);
else if(x<aa3) return Chebyshev(aa2,aa3,cheb2,ncheb2,x);
else if(x<1-0.0000841363)
{ G4double y=-log(1-x);
{ G4double y=-std::log(1-x);
return y*Chebyshev(aa4,aa5,cheb3,ncheb3,y);
}
else
{ G4double y=-log(1-x);
{ G4double y=-std::log(1-x);
return y*Chebyshev(aa5,aa6,cheb4,ncheb4,y);
}
}
@@ -383,8 +381,8 @@ G4double G4SynchrotronRadiation::GetRandomEnergySR(G4double gamma, G4double perp
static G4bool FirstTime=true;
if(verboseLevel > 0 && FirstTime)
{ G4double Emean=8./(15.*sqrt(3.))*Ecr; // mean photon energy
G4double E_rms=sqrt(211./675.)*Ecr; // rms of photon energy distribution
{ G4double Emean=8./(15.*std::sqrt(3.))*Ecr; // mean photon energy
G4double E_rms=std::sqrt(211./675.)*Ecr; // rms of photon energy distribution
G4cout << "G4SynchrotronRadiation::GetRandomEnergySR :" << '\n' << std::setprecision(4)
<< " Ecr = " << G4BestUnit(Ecr,"Energy") << '\n'
<< " Emean = " << G4BestUnit(Emean,"Energy") << '\n'
source/processes/electromagnetic/xrays/src/G4SynchrotronRadiationInMat.cc
+12 -14
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4SynchrotronRadiationInMat.cc,v 1.2 2006/06/29 19:56:17 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4SynchrotronRadiationInMat.cc,v 1.5 2010/10/14 18:38:21 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// --------------------------------------------------------------
// GEANT 4 class implementation file
@@ -42,8 +42,7 @@
#include "G4SynchrotronRadiationInMat.hh"
#include "G4Integrator.hh"
using namespace std;
#include "G4EmProcessSubType.hh"
////////////////////////////////////////////////////////////////////
//
@@ -51,7 +50,7 @@ using namespace std;
//
const G4double
G4SynchrotronRadiationInMat::fLambdaConst = sqrt(3.0)*electron_mass_c2/
G4SynchrotronRadiationInMat::fLambdaConst = std::sqrt(3.0)*electron_mass_c2/
(2.5*fine_structure_const*eplus*c_light) ;
/////////////////////////////////////////////////////////////////////
@@ -133,6 +132,7 @@ G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(const G4String& process
G4TransportationManager* transportMgr = G4TransportationManager::GetTransportationManager();
fFieldPropagator = transportMgr->GetPropagatorInField();
SetProcessSubType(fSynchrotronRadiation);
}
@@ -142,9 +142,7 @@ G4SynchrotronRadiationInMat::G4SynchrotronRadiationInMat(const G4String& process
//
G4SynchrotronRadiationInMat::~G4SynchrotronRadiationInMat()
{
;
}
{}
/////////////////////////////// METHODS /////////////////////////////////
@@ -316,18 +314,18 @@ G4SynchrotronRadiationInMat::PostStepDoIt(const G4Track& trackData,
G4double Phi = twopi * G4UniformRand() ;
G4double dirx = sin(Teta)*cos(Phi) ,
diry = sin(Teta)*sin(Phi) ,
dirz = cos(Teta) ;
G4double dirx = std::sin(Teta)*std::cos(Phi) ,
diry = std::sin(Teta)*std::sin(Phi) ,
dirz = std::cos(Teta) ;
G4ThreeVector gammaDirection ( dirx, diry, dirz);
gammaDirection.rotateUz(particleDirection);
// polarization of new gamma
// G4double sx = cos(Teta)*cos(Phi);
// G4double sy = cos(Teta)*sin(Phi);
// G4double sz = -sin(Teta);
// G4double sx = std::cos(Teta)*std::cos(Phi);
// G4double sy = std::cos(Teta)*std::sin(Phi);
// G4double sz = -std::sin(Teta);
G4ThreeVector gammaPolarization = FieldValue.cross(gammaDirection);
gammaPolarization = gammaPolarization.unit();
source/processes/electromagnetic/xrays/src/G4TransitionRadiation.cc
+6 -13
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4TransitionRadiation.cc,v 1.7 2006/06/29 19:56:19 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4TransitionRadiation.cc,v 1.10 2010/10/14 18:38:21 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-04 $
//
// G4TransitionRadiation class -- implementation file
@@ -41,15 +41,10 @@
#include <cmath>
// #include "G4ios.hh"
// #include <fstream.h>
// #include <stdlib.h>
#include "G4TransitionRadiation.hh"
#include "G4Material.hh"
// Init gamma array
#include "G4EmProcessSubType.hh"
// Local constants
@@ -57,7 +52,6 @@ const G4int G4TransitionRadiation::fSympsonNumber = 100 ;
const G4int G4TransitionRadiation::fGammaNumber = 15 ;
const G4int G4TransitionRadiation::fPointNumber = 100 ;
using namespace std;
///////////////////////////////////////////////////////////////////////
//
@@ -68,6 +62,7 @@ G4TransitionRadiation::
G4TransitionRadiation( const G4String& processName, G4ProcessType type )
: G4VDiscreteProcess(processName, type)
{
SetProcessSubType(fTransitionRadiation);
// fMatIndex1 = pMat1->GetIndex() ;
// fMatIndex2 = pMat2->GetIndex() ;
}
@@ -78,15 +73,13 @@ G4TransitionRadiation( const G4String& processName, G4ProcessType type )
//
G4TransitionRadiation::~G4TransitionRadiation()
{
;
}
{}
///////////////////////////////////////////////////////////////////
//
// Sympson integral of TR spectral-angle density over energy between
// the limits energy 1 and energy2 at fixed varAngle = 1 - cos(Theta)
// the limits energy 1 and energy2 at fixed varAngle = 1 - std::cos(Theta)
G4double
G4TransitionRadiation::IntegralOverEnergy( G4double energy1,
source/processes/electromagnetic/xrays/src/G4TransparentRegXTRadiator.cc
+22 -24
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4TransparentRegXTRadiator.cc,v 1.11 2007/09/29 17:49:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4TransparentRegXTRadiator.cc,v 1.12 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
#include <complex>
@@ -35,8 +35,6 @@
#include "G4Integrator.hh"
#include "G4Gamma.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -112,26 +110,26 @@ G4double G4TransparentRegXTRadiator::SpectralXTRdEdx(G4double energy)
{
tmp = pi*fPlateThick*(k + cof2)/(fPlateThick + fGasThick);
result = (k - cof1)*(k - cof1)*(k + cof2)*(k + cof2);
// tmp = sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
// tmp = std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
if( k == kMin && kMin == G4int(cofMin) )
{
sum += 0.5*sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
sum += 0.5*std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
else
{
sum += sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
sum += std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
if(verboseLevel > 2)
{
G4cout<<"k = "<<k<<"; tmp = "<<sin(tmp)*sin(tmp)*abs(k-cofMin)/result
G4cout<<"k = "<<k<<"; tmp = "<<std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result
<<"; sum = "<<sum<<G4endl;
}
}
result = 4*( cof1 + cof2 )*( cof1 + cof2 )*sum/energy;
// result *= ( 1 - exp(-0.5*fPlateNumber*sigma) )/( 1 - exp(-0.5*sigma) );
// result *= ( 1 - std::exp(-0.5*fPlateNumber*sigma) )/( 1 - std::exp(-0.5*sigma) );
// fPlateNumber;
result *= fPlateNumber; // *exp(-0.5*fPlateNumber*sigma);
// +1-exp(-0.5*fPlateNumber*sigma);
result *= fPlateNumber; // *std::exp(-0.5*fPlateNumber*sigma);
// +1-std::exp(-0.5*fPlateNumber*sigma);
/*
fEnergy = energy;
// G4Integrator<G4VXTRenergyLoss,G4double(G4VXTRenergyLoss::*)(G4double)> integral;
@@ -173,17 +171,17 @@ G4TransparentRegXTRadiator::GetStackFactor( G4double energy,
G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate);
G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas);
G4complex Ha = pow(Ca,-fAlphaPlate);
G4complex Hb = pow(Cb,-fAlphaGas);
G4complex Ha = std::pow(Ca,-fAlphaPlate);
G4complex Hb = std::pow(Cb,-fAlphaGas);
G4complex H = Ha*Hb;
G4complex F1 = (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
* G4double(fPlateNumber) ;
G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
* (1.0 - exp(-0.5*fPlateNumber*sigma)) ;
// *(1.0 - pow(H,fPlateNumber)) ;
* (1.0 - std::exp(-0.5*fPlateNumber*sigma)) ;
// *(1.0 - std::pow(H,fPlateNumber)) ;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
// G4complex R = F2*OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
*/
// numerically unstable result
@@ -195,23 +193,23 @@ G4TransparentRegXTRadiator::GetStackFactor( G4double energy,
aMa = fPlateThick*GetPlateLinearPhotoAbs(energy);
bMb = fGasThick*GetGasLinearPhotoAbs(energy);
sigma = aMa*fPlateThick + bMb*fGasThick;
Qa = exp(-0.5*aMa);
Qb = exp(-0.5*bMb);
Qa = std::exp(-0.5*aMa);
Qb = std::exp(-0.5*bMb);
Q = Qa*Qb;
G4complex Ha( Qa*cos(aZa), -Qa*sin(aZa) );
G4complex Hb( Qb*cos(bZb), -Qb*sin(bZb) );
G4complex Ha( Qa*std::cos(aZa), -Qa*std::sin(aZa) );
G4complex Hb( Qb*std::cos(bZb), -Qb*std::sin(bZb) );
G4complex H = Ha*Hb;
G4complex Hs = conj(H);
D = 1.0 /( (1 - Q)*(1 - Q) +
4*Q*sin(0.5*(aZa + bZb))*sin(0.5*(aZa + bZb)) );
4*Q*std::sin(0.5*(aZa + bZb))*std::sin(0.5*(aZa + bZb)) );
G4complex F1 = (1.0 - Ha)*(1.0 - Hb)*(1.0 - Hs)
* G4double(fPlateNumber)*D;
G4complex F2 = (1.0 - Ha)*(1.0 - Ha)*Hb*(1.0 - Hs)*(1.0 - Hs)
// * (1.0 - pow(H,fPlateNumber)) * D*D;
* (1.0 - exp(-0.5*fPlateNumber*sigma)) * D*D;
// * (1.0 - std::pow(H,fPlateNumber)) * D*D;
* (1.0 - std::exp(-0.5*fPlateNumber*sigma)) * D*D;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
}
source/processes/electromagnetic/xrays/src/G4VTransitionRadiation.cc
+3 -5
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VTransitionRadiation.cc,v 1.5 2006/06/29 19:56:23 gunter Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4VTransitionRadiation.cc,v 1.6 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// G4VTransitionRadiation class -- implementation file
@@ -45,14 +45,12 @@
///////////////////////////////////////////////////////////////////////
using namespace std;
G4VTransitionRadiation::G4VTransitionRadiation( const G4String& processName,
G4ProcessType type )
: G4VDiscreteProcess(processName, type),
nSteps(0),
gammaMin(100),
cosDThetaMax(cos(0.1))
cosDThetaMax(std::cos(0.1))
{
Clear();
}
source/processes/electromagnetic/xrays/src/G4VXTRenergyLoss.cc
+44 -46
View File
@@ -24,8 +24,8 @@
// ********************************************************************
//
//
// $Id: G4VXTRenergyLoss.cc,v 1.44 2007/09/29 17:49:34 vnivanch Exp $
// GEANT4 tag $Name: geant4-09-02 $
// $Id: G4VXTRenergyLoss.cc,v 1.45 2010/06/16 15:34:15 gcosmo Exp $
// GEANT4 tag $Name: geant4-09-04-beta-01 $
//
// History:
// 2001-2002 R&D by V.Grichine
@@ -54,8 +54,6 @@
#include "G4PhysicsFreeVector.hh"
#include "G4PhysicsLinearVector.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -141,13 +139,13 @@ G4VXTRenergyLoss::G4VXTRenergyLoss(G4LogicalVolume *anEnvelope,
fSigma1 = fPlasmaCof*foilMat->GetElectronDensity() ;
// fSigma1 = (20.9*eV)*(20.9*eV) ;
if(verboseLevel > 0)
G4cout<<"plate plasma energy = "<<sqrt(fSigma1)/eV<<" eV"<<G4endl ;
G4cout<<"plate plasma energy = "<<std::sqrt(fSigma1)/eV<<" eV"<<G4endl ;
// plasma energy squared for gas material
fSigma2 = fPlasmaCof*gasMat->GetElectronDensity() ;
if(verboseLevel > 0)
G4cout<<"gas plasma energy = "<<sqrt(fSigma2)/eV<<" eV"<<G4endl ;
G4cout<<"gas plasma energy = "<<std::sqrt(fSigma2)/eV<<" eV"<<G4endl ;
// Compute cofs for preparation of linear photo absorption
@@ -202,7 +200,7 @@ G4double G4VXTRenergyLoss::GetMeanFreePath(const G4Track& aTrack,
G4cout<<" gamma = "<<gamma<<"; fGamma = "<<fGamma<<G4endl;
}
if ( fabs( gamma - fGamma ) < 0.05*gamma ) lambda = fLambda;
if ( std::fabs( gamma - fGamma ) < 0.05*gamma ) lambda = fLambda;
else
{
charge = aParticle->GetDefinition()->GetPDGCharge();
@@ -494,22 +492,22 @@ G4PhysicsFreeVector* G4VXTRenergyLoss::GetAngleVector(G4double energy, G4int n)
result = (k - cof1)*(k - cof1)*(k + cof2)*(k + cof2);
tmp = sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
tmp = std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
if( k == kMin && kMin == G4int(cofMin) )
{
angleSum += 0.5*tmp; // 0.5*sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
angleSum += 0.5*tmp; // 0.5*std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
else
{
angleSum += tmp; // sin(tmp)*sin(tmp)*abs(k-cofMin)/result;
angleSum += tmp; // std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
theta = abs(k-cofMin)*cofPHC/energy/(fPlateThick + fGasThick);
theta = std::abs(k-cofMin)*cofPHC/energy/(fPlateThick + fGasThick);
if(verboseLevel > 2)
{
G4cout<<"iTheta = "<<iTheta<<"; k = "<<k<<"; theta = "
<<std::sqrt(theta)*fGamma<<"; tmp = "
<<tmp // sin(tmp)*sin(tmp)*abs(k-cofMin)/result
<<tmp // std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result
<<"; angleSum = "<<angleSum<<G4endl;
}
angleVector->PutValue( iTheta, theta, angleSum );
@@ -696,12 +694,12 @@ G4VParticleChange* G4VXTRenergyLoss::PostStepDoIt( const G4Track& aTrack,
}
if (fAngleRadDistr)
{
// theta = fabs(G4RandGauss::shoot(0.0,pi/gamma));
// theta = std::fabs(G4RandGauss::shoot(0.0,pi/gamma));
theta2 = GetRandomAngle(energyTR,iTkin);
if(theta2 > 0.) theta = std::sqrt(theta2);
else theta = theta2;
}
else theta = fabs(G4RandGauss::shoot(0.0,pi/gamma));
else theta = std::fabs(G4RandGauss::shoot(0.0,pi/gamma));
if( theta >= 0.1 ) theta = 0.1;
@@ -709,9 +707,9 @@ G4VParticleChange* G4VXTRenergyLoss::PostStepDoIt( const G4Track& aTrack,
phi = twopi*G4UniformRand();
dirX = sin(theta)*cos(phi);
dirY = sin(theta)*sin(phi);
dirZ = cos(theta);
dirX = std::sin(theta)*std::cos(phi);
dirY = std::sin(theta)*std::sin(phi);
dirZ = std::cos(theta);
G4ThreeVector directionTR(dirX,dirY,dirZ);
directionTR.rotateUz(direction);
@@ -761,7 +759,7 @@ G4VParticleChange* G4VXTRenergyLoss::PostStepDoIt( const G4Track& aTrack,
// charged particle crosses interface between two materials.
// The high energy small theta approximation is applied.
// (matter1 -> matter2, or 2->1)
// varAngle =2* (1 - cos(theta)) or approximately = theta*theta
// varAngle =2* (1 - std::cos(theta)) or approximately = theta*theta
//
G4complex G4VXTRenergyLoss::OneInterfaceXTRdEdx( G4double energy,
@@ -849,7 +847,7 @@ G4double G4VXTRenergyLoss::AngleXTRdEdx(G4double varAngle)
// G4cout<<"cof1 = "<<cof1<<"; cof2 = "<<cof2<<"; cofPHC = "<<cofPHC<<G4endl;
cofMin = sqrt(cof1*cof2);
cofMin = std::sqrt(cof1*cof2);
cofMin /= cofPHC;
kMin = G4int(cofMin);
@@ -862,7 +860,7 @@ G4double G4VXTRenergyLoss::AngleXTRdEdx(G4double varAngle)
for( k = kMin; k <= kMax; k++ )
{
tmp1 = cofPHC*k;
tmp2 = sqrt(tmp1*tmp1-cof1*cof2);
tmp2 = std::sqrt(tmp1*tmp1-cof1*cof2);
energy1 = (tmp1+tmp2)/cof1;
energy2 = (tmp1-tmp2)/cof1;
@@ -873,13 +871,13 @@ G4double G4VXTRenergyLoss::AngleXTRdEdx(G4double varAngle)
if (energy1 > fTheMaxEnergyTR || energy1 < fTheMinEnergyTR) continue;
tmp1 = ( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma1 )
* fPlateThick/(4*hbarc*energy1);
tmp2 = sin(tmp1);
tmp2 = std::sin(tmp1);
tmp = energy1*tmp2*tmp2;
tmp2 = fPlateThick/(4*tmp1);
tmp1 = hbarc*energy1/( energy1*energy1*(1./fGamma/fGamma + varAngle) + fSigma2 );
tmp *= (tmp1-tmp2)*(tmp1-tmp2);
tmp1 = cof1/(4*hbarc) - cof2/(4*hbarc*energy1*energy1);
tmp2 = abs(tmp1);
tmp2 = std::abs(tmp1);
if(tmp2 > 0.) tmp /= tmp2;
else continue;
}
@@ -888,13 +886,13 @@ G4double G4VXTRenergyLoss::AngleXTRdEdx(G4double varAngle)
if (energy2 > fTheMaxEnergyTR || energy2 < fTheMinEnergyTR) continue;
tmp1 = ( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma1 )
* fPlateThick/(4*hbarc*energy2);
tmp2 = sin(tmp1);
tmp2 = std::sin(tmp1);
tmp = energy2*tmp2*tmp2;
tmp2 = fPlateThick/(4*tmp1);
tmp1 = hbarc*energy2/( energy2*energy2*(1./fGamma/fGamma + varAngle) + fSigma2 );
tmp *= (tmp1-tmp2)*(tmp1-tmp2);
tmp1 = cof1/(4*hbarc) - cof2/(4*hbarc*energy2*energy2);
tmp2 = abs(tmp1);
tmp2 = std::abs(tmp1);
if(tmp2 > 0.) tmp /= tmp2;
else continue;
}
@@ -939,16 +937,16 @@ G4complex G4VXTRenergyLoss::GetPlateComplexFZ( G4double omega ,
G4double gamma ,
G4double varAngle )
{
G4double cof, length,delta, real, image ;
G4double cof, length,delta, real_v, image_v ;
length = 0.5*GetPlateFormationZone(omega,gamma,varAngle) ;
delta = length*GetPlateLinearPhotoAbs(omega) ;
cof = 1.0/(1.0 + delta*delta) ;
real = length*cof ;
image = real*delta ;
real_v = length*cof ;
image_v = real_v*delta ;
G4complex zone(real,image);
G4complex zone(real_v,image_v);
return zone ;
}
@@ -1012,16 +1010,16 @@ G4complex G4VXTRenergyLoss::GetGasComplexFZ( G4double omega ,
G4double gamma ,
G4double varAngle )
{
G4double cof, length,delta, real, image ;
G4double cof, length,delta, real_v, image_v ;
length = 0.5*GetGasFormationZone(omega,gamma,varAngle) ;
delta = length*GetGasLinearPhotoAbs(omega) ;
cof = 1.0/(1.0 + delta*delta) ;
real = length*cof ;
image = real*delta ;
real_v = length*cof ;
image_v = real_v*delta ;
G4complex zone(real,image);
G4complex zone(real_v,image_v);
return zone ;
}
@@ -1079,8 +1077,8 @@ G4double G4VXTRenergyLoss::GetPlateZmuProduct( G4double omega ,
void G4VXTRenergyLoss::GetPlateZmuProduct()
{
ofstream outPlate("plateZmu.dat", ios::out ) ;
outPlate.setf( ios::scientific, ios::floatfield );
std::ofstream outPlate("plateZmu.dat", std::ios::out ) ;
outPlate.setf( std::ios::scientific, std::ios::floatfield );
G4int i ;
G4double omega, varAngle, gamma ;
@@ -1117,8 +1115,8 @@ G4double G4VXTRenergyLoss::GetGasZmuProduct( G4double omega ,
void G4VXTRenergyLoss::GetGasZmuProduct()
{
ofstream outGas("gasZmu.dat", ios::out ) ;
outGas.setf( ios::scientific, ios::floatfield );
std::ofstream outGas("gasZmu.dat", std::ios::out ) ;
outGas.setf( std::ios::scientific, std::ios::floatfield );
G4int i ;
G4double omega, varAngle, gamma ;
gamma = 10000. ;
@@ -1208,7 +1206,7 @@ G4double G4VXTRenergyLoss::GetComptonPerAtom(G4double GammaEnergy, G4double Z)
G4double T0 = 15.0*keV;
if (Z < 1.5) T0 = 40.0*keV;
G4double X = max(GammaEnergy, T0) / electron_mass_c2;
G4double X = std::max(GammaEnergy, T0) / electron_mass_c2;
CrossSection = p1Z*std::log(1.+2.*X)/X
+ (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
@@ -1218,13 +1216,13 @@ G4double G4VXTRenergyLoss::GetComptonPerAtom(G4double GammaEnergy, G4double Z)
{
G4double dT0 = 1.*keV;
X = (T0+dT0) / electron_mass_c2 ;
G4double sigma = p1Z*log(1.+2*X)/X
G4double sigma = p1Z*std::log(1.+2*X)/X
+ (p2Z + p3Z*X + p4Z*X*X)/(1. + a*X + b*X*X + c*X*X*X);
G4double c1 = -T0*(sigma-CrossSection)/(CrossSection*dT0);
G4double c2 = 0.150;
if (Z > 1.5) c2 = 0.375-0.0556*log(Z);
G4double y = log(GammaEnergy/T0);
CrossSection *= exp(-y*(c1+c2*y));
if (Z > 1.5) c2 = 0.375-0.0556*std::log(Z);
G4double y = std::log(GammaEnergy/T0);
CrossSection *= std::exp(-y*(c1+c2*y));
}
// G4cout << "e= " << GammaEnergy << " Z= " << Z << " cross= " << CrossSection << G4endl;
return CrossSection;
@@ -1238,7 +1236,7 @@ G4double G4VXTRenergyLoss::GetComptonPerAtom(G4double GammaEnergy, G4double Z)
// charged particle crosses interface between two materials.
// The high energy small theta approximation is applied.
// (matter1 -> matter2, or 2->1)
// varAngle =2* (1 - cos(theta)) or approximately = theta*theta
// varAngle =2* (1 - std::cos(theta)) or approximately = theta*theta
//
G4double
@@ -1325,11 +1323,11 @@ void G4VXTRenergyLoss::GetNumberOfPhotons()
G4int iTkin ;
G4double gamma, numberE ;
ofstream outEn("numberE.dat", ios::out ) ;
outEn.setf( ios::scientific, ios::floatfield );
std::ofstream outEn("numberE.dat", std::ios::out ) ;
outEn.setf( std::ios::scientific, std::ios::floatfield );
ofstream outAng("numberAng.dat", ios::out ) ;
outAng.setf( ios::scientific, ios::floatfield );
std::ofstream outAng("numberAng.dat", std::ios::out ) ;
outAng.setf( std::ios::scientific, std::ios::floatfield );
for(iTkin=0;iTkin<fTotBin;iTkin++) // Lorentz factor loop
{
source/processes/electromagnetic/xrays/src/G4XTRTransparentRegRadModel.cc
+16 -18
View File
@@ -32,8 +32,6 @@
#include "G4Integrator.hh"
#include "G4Gamma.hh"
using namespace std;
////////////////////////////////////////////////////////////////////////////
//
// Constructor, destructor
@@ -120,16 +118,16 @@ G4double G4XTRTransparentRegRadModel::SpectralXTRdEdx(G4double energy)
if( k == kMin && kMin == G4int(cofMin) )
{
sum += 0.5*sin(tmp)*sin(tmp)*std::abs(k-cofMin)/result;
sum += 0.5*std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
else
{
sum += sin(tmp)*sin(tmp)*std::abs(k-cofMin)/result;
sum += std::sin(tmp)*std::sin(tmp)*std::abs(k-cofMin)/result;
}
// G4cout<<"k = "<<k<<"; sum = "<<sum<<G4endl;
}
result = 4.*( cof1 + cof2 )*( cof1 + cof2 )*sum/energy;
result *= ( 1. - exp(-fPlateNumber*sigma) )/( 1. - exp(-sigma) );
result *= ( 1. - std::exp(-fPlateNumber*sigma) )/( 1. - std::exp(-sigma) );
return result;
}
@@ -158,17 +156,17 @@ G4XTRTransparentRegRadModel::GetStackFactor( G4double energy,
G4complex Ca(1.0+0.5*fPlateThick*Ma/fAlphaPlate,fPlateThick/Za/fAlphaPlate);
G4complex Cb(1.0+0.5*fGasThick*Mb/fAlphaGas,fGasThick/Zb/fAlphaGas);
G4complex Ha = pow(Ca,-fAlphaPlate);
G4complex Hb = pow(Cb,-fAlphaGas);
G4complex Ha = std::pow(Ca,-fAlphaPlate);
G4complex Hb = std::pow(Cb,-fAlphaGas);
G4complex H = Ha*Hb;
G4complex F1 = (1.0 - Ha)*(1.0 - Hb )/(1.0 - H)
* G4double(fPlateNumber) ;
G4complex F2 = (1.0-Ha)*(1.0-Ha)*Hb/(1.0-H)/(1.0-H)
* (1.0 - exp(-0.5*fPlateNumber*sigma)) ;
// *(1.0 - pow(H,fPlateNumber)) ;
* (1.0 - std::exp(-0.5*fPlateNumber*sigma)) ;
// *(1.0 - std::pow(H,fPlateNumber)) ;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
// G4complex R = F2*OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
*/
// numerically unstable result
@@ -180,23 +178,23 @@ G4XTRTransparentRegRadModel::GetStackFactor( G4double energy,
aMa = fPlateThick*GetPlateLinearPhotoAbs(energy);
bMb = fGasThick*GetGasLinearPhotoAbs(energy);
sigma = aMa*fPlateThick + bMb*fGasThick;
Qa = exp(-0.5*aMa);
Qb = exp(-0.5*bMb);
Qa = std::exp(-0.5*aMa);
Qb = std::exp(-0.5*bMb);
Q = Qa*Qb;
G4complex Ha( Qa*cos(aZa), -Qa*sin(aZa) );
G4complex Hb( Qb*cos(bZb), -Qb*sin(bZb) );
G4complex Ha( Qa*std::cos(aZa), -Qa*std::sin(aZa) );
G4complex Hb( Qb*std::cos(bZb), -Qb*std::sin(bZb) );
G4complex H = Ha*Hb;
G4complex Hs = conj(H);
D = 1.0 /( (1 - Q)*(1 - Q) +
4*Q*sin(0.5*(aZa + bZb))*sin(0.5*(aZa + bZb)) );
4*Q*std::sin(0.5*(aZa + bZb))*std::sin(0.5*(aZa + bZb)) );
G4complex F1 = (1.0 - Ha)*(1.0 - Hb)*(1.0 - Hs)
* G4double(fPlateNumber)*D;
G4complex F2 = (1.0 - Ha)*(1.0 - Ha)*Hb*(1.0 - Hs)*(1.0 - Hs)
// * (1.0 - pow(H,fPlateNumber)) * D*D;
* (1.0 - exp(-0.5*fPlateNumber*sigma)) * D*D;
// * (1.0 - std::pow(H,fPlateNumber)) * D*D;
* (1.0 - std::exp(-0.5*fPlateNumber*sigma)) * D*D;
G4complex R = (F1 + F2)*OneInterfaceXTRdEdx(energy,gamma,varAngle);
result = 2.0*real(R);
result = 2.0*std::real(R);
return result;
}