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

Import Geant4 11.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2024-12-06 11:11:40 +01:00
parent e58e650b32
commit 32390e802b
1984 changed files with 98713 additions and 83996 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/processes/electromagnetic/utils/src/G4EmCalculator.cc
+2 -2
View File
@@ -1106,12 +1106,12 @@ G4EmCalculator::FindDiscreteProcess(const G4ParticleDefinition* part,
auto v = manager->GetEmProcessVector();
std::size_t n = v.size();
for(std::size_t i=0; i<n; ++i) {
auto pName = v[i]->GetProcessName();
const G4String& pName = v[i]->GetProcessName();
if(pName == "GammaGeneralProc") {
proc = v[i]->GetEmProcess(processName);
break;
} else if(pName == processName) {
auto p = static_cast<G4VProcess*>(v[i]);
const auto p = static_cast<G4VProcess*>(v[i]);
if(ActiveForParticle(part, p)) {
proc = v[i];
break;
source/processes/electromagnetic/utils/src/G4EmConfigurator.cc
+77 -69
View File
@@ -168,9 +168,8 @@ void G4EmConfigurator::SetModelForRegion(G4VEmModel* mod,
G4int np = pmanager->GetProcessListLength();
if(1 < verbose) {
G4cout << "Check process <" << processName << "> for "
<< particleName << " in list of " << np << " processes"
<< G4endl;
G4cout << "Check process <" << processName << "> for " << particleName << " in list of "
<< np << " processes" << G4endl;
}
G4VProcess* proc = nullptr;
for(G4int i=0; i<np; ++i) {
@@ -179,68 +178,77 @@ void G4EmConfigurator::SetModelForRegion(G4VEmModel* mod,
break;
}
}
G4bool isCombinedMscTrans = false;
G4TransportationWithMsc* trans = nullptr;
if(nullptr == proc) {
if(processName == "msc") {
for(G4int i=0; i<np; ++i) {
trans = dynamic_cast<G4TransportationWithMsc*>((*plist)[i]);
if(nullptr != trans) {
G4cout << "G4TransportationWithMsc is found out!" << G4endl;
isCombinedMscTrans = true;
for (G4int i = 0; i < np; ++i) {
auto* trans = dynamic_cast<G4TransportationWithMsc*>((*plist)[i]);
if (nullptr != trans) {
G4cout << "G4TransportationWithMsc is found out!" << G4endl;
proc = trans;
break;
}
}
}
if(nullptr == proc) {
if(0 < verbose) {
G4cout << "### G4EmConfigurator WARNING: fails to find a process <"
<< processName << "> for " << particleName << G4endl;
}
return;
}
break;
}
}
}
if (nullptr == proc) {
if (0 < verbose) {
G4cout << "### G4EmConfigurator WARNING: fails to find a process <" << processName
<< "> for " << particleName << G4endl;
}
return;
}
}
if(!UpdateModelEnergyRange(mod, emin, emax)) { return; }
// classify process
G4int ii = proc->GetProcessSubType();
auto msc = dynamic_cast<G4VMscModel*>(mod);
if(isCombinedMscTrans && nullptr != msc) {
trans->AddMscModel(msc, index, reg);
if(1 < verbose) {
G4cout << "### Added msc model order= " << index << " for "
<< particleName << " and " << proc->GetProcessName()
<< G4endl;
}
} else if(10 == ii && nullptr != msc) {
auto p = dynamic_cast<G4VMultipleScattering*>(proc);
if(nullptr != p) {
p->AddEmModel(index, msc, reg);
if(1 < verbose) {
G4cout << "### Added msc model order= " << index << " for "
<< particleName << " and " << processName << G4endl;
}
}
} else if(2 <= ii && 4 >= ii) {
auto p = dynamic_cast<G4VEnergyLossProcess*>(proc);
if(nullptr != p) {
p->AddEmModel(index,mod,fm,reg);
if(1 < verbose) {
G4cout << "### Added eloss model order= " << index << " for "
<< particleName << " and " << processName << G4endl;
}
}
} else {
if (nullptr != msc) {
if (auto* trans = dynamic_cast<G4TransportationWithMsc*>(proc)) {
trans->AddMscModel(msc, index, reg);
if (1 < verbose) {
G4cout << "### Added msc model order= " << index << " for " << particleName << " and "
<< proc->GetProcessName() << G4endl;
}
}
else if (10 == ii) {
auto p = dynamic_cast<G4VMultipleScattering*>(proc);
if (nullptr != p) {
p->AddEmModel(index, msc, reg);
if (1 < verbose) {
G4cout << "### Added msc model order= " << index << " for " << particleName << " and "
<< processName << G4endl;
}
}
}
else {
G4cout << "### Unable to add msc model for " << particleName << " and " << processName
<< G4endl;
}
}
else if (2 <= ii && 4 >= ii) {
auto p = dynamic_cast<G4VEnergyLossProcess*>(proc);
if (nullptr != p) {
p->AddEmModel(index, mod, fm, reg);
if (1 < verbose) {
G4cout << "### Added eloss model order= " << index << " for " << particleName << " and "
<< processName << G4endl;
}
}
}
else {
auto p = dynamic_cast<G4VEmProcess*>(proc);
if(nullptr != p) {
p->AddEmModel(index,mod,reg);
if(1 < verbose) {
G4cout << "### Added em model order= " << index << " for "
<< particleName << " and " << processName << G4endl;
}
}
}
if (nullptr != p) {
p->AddEmModel(index, mod, reg);
if (1 < verbose) {
G4cout << "### Added em model order= " << index << " for " << particleName << " and "
<< processName << G4endl;
}
}
else {
G4cout << "### Unable to add em model for " << particleName << " and " << processName
<< G4endl;
}
}
return;
}
}
@@ -277,9 +285,8 @@ G4EmConfigurator::PrepareModels(const G4ParticleDefinition* aParticle,
if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
p->AddEmModel(index,mod,fm,reg);
if(1 < verbose) {
G4cout << "### Added eloss model order= " << index << " for "
<< particleName << " and " << processName
<< " for " << reg->GetName() << G4endl;
G4cout << "### Added eloss model order= " << index << " for " << particleName
<< " and " << processName << " for " << reg->GetName() << G4endl;
}
}
} else if(nullptr != fm) {
@@ -351,20 +358,21 @@ G4EmConfigurator::PrepareModels(const G4ParticleDefinition* aParticle,
G4String processName = (nullptr == p) ? G4String("msc") : p->GetProcessName();
for(size_t i=0; i<n; ++i) {
if(processName == processes[i]) {
if((particleName == particles[i]) ||
(particles[i] == "all") ||
(particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
const G4Region* reg = G4EmUtility::FindRegion(regions[i]);
if(nullptr != reg) {
--index;
auto mod = dynamic_cast<G4VMscModel*>(models[i]);
if ((particleName == particles[i]) || (particles[i] == "all")
|| (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0))
{
const G4Region* reg = G4EmUtility::FindRegion(regions[i]);
if (nullptr != reg) {
--index;
auto mod = dynamic_cast<G4VMscModel*>(models[i]);
if(nullptr != mod) {
if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
if(nullptr != p) {
p->AddEmModel(index,mod,reg);
} else {
trans->AddMscModel(mod,index,reg);
}
p->AddEmModel(index, mod, reg);
}
else {
trans->AddMscModel(mod, index, reg);
}
//G4cout << "### Added msc model order= " << index << " for "
// << particleName << " and " << processName << G4endl;
}
source/processes/electromagnetic/utils/src/G4EmCorrections.cc
+8 -5
View File
@@ -260,21 +260,23 @@ G4double G4EmCorrections::IonHighOrderCorrections(const G4ParticleDefinition* p,
G4double sum = 0.0;
if(nullptr != ionHEModel) {
if (nullptr != ionHEModel) {
G4int Z = G4lrint(p->GetPDGCharge()*inveplus);
Z = std::max(std::min(Z, 99), 1);
const G4double ethscaled = eth*p->GetPDGMass()/CLHEP::proton_mass_c2;
const G4int ionPDG = p->GetPDGEncoding();
if(thcorr.find(ionPDG)==thcorr.end()) { // Not found: fill the map
auto iter = thcorr.find(ionPDG);
if (iter == thcorr.end()) { // Not found: fill the map
std::vector<G4double> v;
for(std::size_t i=0; i<ncouples; ++i){
v.push_back(ethscaled*ComputeIonCorrections(p,currmat[i],ethscaled));
}
thcorr.insert(std::pair< G4int, std::vector<G4double> >(ionPDG,v));
}
const G4double rest = (thcorr.find(ionPDG)->second)[couple->GetIndex()];
G4double rest = 0.0;
iter = thcorr.find(ionPDG);
if (iter != thcorr.end()) { rest = (iter->second)[couple->GetIndex()]; }
sum = ComputeIonCorrections(p,couple->GetMaterial(),e) - rest/e;
@@ -556,7 +558,8 @@ G4double G4EmCorrections::ShellCorrection(const G4ParticleDefinition* p,
// << " resL= " << res0 << G4endl;
}
if(ntot > nmax) {
eshell /= norm;
if (norm > 0.0) { norm = 1.0/norm; }
eshell *= norm;
static const G4double HM[53] = {
12.0, 12.0, 12.0, 12.0, 11.9, 11.7, 11.5, 11.2, 10.8, 10.4,
source/processes/electromagnetic/utils/src/G4EmElementXS.cc
+110
View File
@@ -0,0 +1,110 @@
//
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * 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. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
//
// -------------------------------------------------------------------
//
// GEANT4 Class file
//
// File name: G4EmElementXS
//
// Author: V. Ivanchenko
//
// Creation date: 22 August 2024
//
// -------------------------------------------------------------------
//
#include "G4EmElementXS.hh"
#include "G4ElementData.hh"
#include "G4ElementDataRegistry.hh"
#include "G4EmParameters.hh"
#include "G4PhysicsVector.hh"
#include "G4PhysicsFreeVector.hh"
#include "G4AutoLock.hh"
#include "G4SystemOfUnits.hh"
namespace
{
G4Mutex elementXSMutex = G4MUTEX_INITIALIZER;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4EmElementXS::G4EmElementXS(G4int zmin, G4int zmax, const G4String& name,
const G4String& subname)
: Zmin(zmin - 1), Zmax(zmax), fSubName(subname)
{
fParameters = G4EmParameters::Instance();
auto reg = G4ElementDataRegistry::Instance();
fData = reg->GetElementDataByName(name);
if (nullptr == fData) {
fData = new G4ElementData(Zmax - Zmin);
fData->SetName(name);
reg->RegisterMe(fData);
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4PhysicsVector* G4EmElementXS::Retrieve(G4int ZZ) const
{
G4int Z = std::min(ZZ, Zmax);
auto v = fData->GetElementData(Z);
if (nullptr == v) {
G4AutoLock l(&elementXSMutex);
v = fData->GetElementData(Z);
if (nullptr == v) {
v = new G4PhysicsFreeVector(false);
std::ostringstream ost;
ost << fParameters->GetDirLEDATA() << fSubName << Z << ".dat";
std::ifstream fin(ost.str().c_str());
if (!fin.is_open()) {
G4ExceptionDescription ed;
ed << "G4EmElementXS: data file <" << ost.str().c_str() << "> for Z=" << Z
<< " is not opened!" << G4endl;
G4Exception("G4EmElementXS::Retrieve()", "em0003", FatalException, ed,
"G4LEDATA version should be checked");
} else {
v->Retrieve(fin, true);
v->ScaleVector(CLHEP::MeV, CLHEP::barn);
}
fData->InitialiseForElement(Z, v);
l.unlock();
}
}
return v;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
G4double G4EmElementXS::GetXS(G4int Z, G4double ekin) const
{
auto v = Retrieve(Z);
return (nullptr != v) ? v->Value(ekin) : 0.0;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/processes/electromagnetic/utils/src/G4EmExtraParameters.cc
+2 -2
View File
@@ -242,7 +242,7 @@ void G4EmExtraParameters::AddPAIModel(const G4String& particle,
}
// new regions and/or particles
m_particlesPAI.push_back(particle);
m_regnamesPAI.push_back(r);
m_regnamesPAI.push_back(std::move(r));
m_typesPAI.push_back(type);
}
@@ -269,7 +269,7 @@ void G4EmExtraParameters::AddPhysics(const G4String& region,
for(std::size_t i=0; i<nreg; ++i) {
if(r == m_regnamesPhys[i]) { return; }
}
m_regnamesPhys.push_back(r);
m_regnamesPhys.push_back(std::move(r));
m_typesPhys.push_back(type);
}
source/processes/electromagnetic/utils/src/G4EmLowEParameters.cc
+3 -3
View File
@@ -257,7 +257,7 @@ void G4EmLowEParameters::AddMicroElec(const G4String& region)
for(std::size_t i=0; i<nreg; ++i) {
if(r == m_regnamesME[i]) { return; }
}
m_regnamesME.push_back(r);
m_regnamesME.push_back(std::move(r));
}
const std::vector<G4String>& G4EmLowEParameters::RegionsMicroElec() const
@@ -272,7 +272,7 @@ void G4EmLowEParameters::AddDNA(const G4String& region, const G4String& type)
for(std::size_t i=0; i<nreg; ++i) {
if(r == m_regnamesDNA[i]) { return; }
}
m_regnamesDNA.push_back(r);
m_regnamesDNA.push_back(std::move(r));
m_typesDNA.push_back(type);
}
@@ -308,7 +308,7 @@ G4EmLowEParameters::SetDeexActiveRegion(const G4String& region, G4bool fdeex,
return;
}
}
m_regnamesDeex.push_back(r);
m_regnamesDeex.push_back(std::move(r));
m_fluo.push_back(fdeex);
m_auger.push_back(fauger);
m_pixe.push_back(fpixe);
source/processes/electromagnetic/utils/src/G4EmParameters.cc
+47 -13
View File
@@ -136,6 +136,9 @@ void G4EmParameters::Initialise()
fMuDataFromFile = false;
fPEKShell = true;
fMscPosiCorr = true;
fUseEPICS2017XS = false;
f3GammaAnnihilationOnFly = false;
fUseRiGePairProductionModel = false;
fDNA = false;
fIsPrinted = false;
@@ -160,7 +163,6 @@ void G4EmParameters::Initialise()
safetyFactor = 0.6;
lambdaLimit = 1.0*CLHEP::mm;
factorScreen = 1.0;
fOrtoPsFraction = 0.0375; // 0.75 * 0.05
nbinsPerDecade = 7;
verbose = 1;
@@ -174,6 +176,7 @@ void G4EmParameters::Initialise()
nucFormfactor = fExponentialNF;
fSStype = fWVI;
fFluct = fUniversalFluctuation;
fPositronium = fSimplePositronium;
const char* data_dir = G4FindDataDir("G4LEDATA");
if (nullptr != data_dir) {
@@ -536,6 +539,39 @@ void G4EmParameters::SetMscPositronCorrection(G4bool v)
fMscPosiCorr = v;
}
G4bool G4EmParameters::UseEPICS2017XS() const
{
return fUseEPICS2017XS;
}
void G4EmParameters::SetUseEPICS2017XS(G4bool v)
{
if(IsLocked()) { return; }
fUseEPICS2017XS = v;
}
G4bool G4EmParameters::Use3GammaAnnihilationOnFly() const
{
return f3GammaAnnihilationOnFly;
}
void G4EmParameters::Set3GammaAnnihilationOnFly(G4bool v)
{
if(IsLocked()) { return; }
f3GammaAnnihilationOnFly = v;
}
G4bool G4EmParameters::UseRiGePairProductionModel() const
{
return fUseRiGePairProductionModel;
}
void G4EmParameters::SetUseRiGePairProductionModel(G4bool v)
{
if (IsLocked()) { return; }
fUseRiGePairProductionModel = v;
}
void G4EmParameters::ActivateDNA()
{
if(IsLocked()) { return; }
@@ -1051,18 +1087,6 @@ G4PositronAtRestModelType G4EmParameters::PositronAtRestModelType() const
return fPositronium;
}
void G4EmParameters::SetOrtoPsFraction(G4double val)
{
if(IsLocked()) { return; }
fOrtoPsFraction = val;
}
G4double G4EmParameters::OrtoPsFraction() const
{
return fOrtoPsFraction;
}
void G4EmParameters::SetMscStepLimitType(G4MscStepLimitType val)
{
if(IsLocked()) { return; }
@@ -1376,6 +1400,14 @@ void G4EmParameters::StreamInfo(std::ostream& os) const
os << "Bremsstrahlung energy threshold above which primary\n"
<< " muon/hadron is added to the list of secondary "
<<G4BestUnit(bremsMuHadTh,"Energy") << "\n";
G4String name3g = "SimplePositronium";
if (fPositronium == fAllisonPositronium) { name3g = "AllisonPositronium"; }
else if (fPositronium == fOrePowell) { name3g = "OrePowell"; }
else if (fPositronium == fOrePowellPolar) { name3g = "OrePowellPolar"; }
os << "Positron annihilation at rest model " << name3g << "\n";
os << "Enable 3 gamma annihilation on fly "
<< f3GammaAnnihilationOnFly << "\n";
os << "Lowest triplet kinetic energy "
<<G4BestUnit(lowestTripletEnergy,"Energy") << "\n";
os << "Enable sampling of gamma linear polarisation " <<fPolarisation << "\n";
@@ -1385,6 +1417,8 @@ void G4EmParameters::StreamInfo(std::ostream& os) const
os << "5D gamma conversion limit for muon pair "
<< max5DEnergyForMuPair/CLHEP::GeV << " GeV\n";
}
os << "Use Ricardo-Gerardo pair production model "
<< fUseRiGePairProductionModel << "\n";
os << "Livermore data directory "
<< fCParameters->LivermoreDataDir() << "\n";
source/processes/electromagnetic/utils/src/G4EmParametersMessenger.cc
+24 -12
View File
@@ -203,6 +203,20 @@ G4EmParametersMessenger::G4EmParametersMessenger(G4EmParameters* ptr)
mscPCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
mscPCmd->SetToBeBroadcasted(false);
pepicsCmd = new G4UIcmdWithABool("/process/em/UseEPICS2017XS",this);
pepicsCmd->SetGuidance("Use EPICS2017 data for gamma x-ections");
pepicsCmd->SetParameterName("pepics",true);
pepicsCmd->SetDefaultValue(false);
pepicsCmd->AvailableForStates(G4State_PreInit);
pepicsCmd->SetToBeBroadcasted(false);
f3gCmd = new G4UIcmdWithABool("/process/em/3GammaAnnihilationOnFly",this);
f3gCmd->SetGuidance("Enable/disable 3 gamma annihilation on fly");
f3gCmd->SetParameterName("f3gamma",true);
f3gCmd->SetDefaultValue(false);
f3gCmd->AvailableForStates(G4State_PreInit);
f3gCmd->SetToBeBroadcasted(false);
minEnCmd = new G4UIcmdWithADoubleAndUnit("/process/eLoss/minKinEnergy",this);
minEnCmd->SetGuidance("Set the min kinetic energy for EM tables");
minEnCmd->SetParameterName("emin",true);
@@ -441,17 +455,10 @@ G4EmParametersMessenger::G4EmParametersMessenger(G4EmParameters* ptr)
posiCmd = new G4UIcmdWithAString("/process/em/setPositronAtRestModel",this);
posiCmd->SetGuidance("Define model of positron annihilation at rest");
posiCmd->SetParameterName("Posi",true);
posiCmd->SetCandidates("Simple Allison");
posiCmd->SetCandidates("Simple Allison OrePawell OrePowellPolar");
posiCmd->AvailableForStates(G4State_PreInit);
posiCmd->SetToBeBroadcasted(false);
ortoCmd = new G4UIcmdWithADouble("/process/em/setOrtoPositronFraction",this);
ortoCmd->SetGuidance("Define model of positron annihilation at rest");
ortoCmd->SetParameterName("frac",false);
ortoCmd->SetRange("frac >= 0.0 && frac <= 1.0");
ortoCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
ortoCmd->SetToBeBroadcasted(false);
tripletCmd = new G4UIcmdWithAnInteger("/process/gconv/conversionType",this);
tripletCmd->SetGuidance("gamma conversion triplet/nuclear generation type:");
tripletCmd->SetGuidance("0 - (default) both triplet and nuclear");
@@ -502,7 +509,9 @@ G4EmParametersMessenger::~G4EmParametersMessenger()
delete icru90Cmd;
delete mudatCmd;
delete peKCmd;
delete f3gCmd;
delete mscPCmd;
delete pepicsCmd;
delete minEnCmd;
delete maxEnCmd;
@@ -541,7 +550,6 @@ G4EmParametersMessenger::~G4EmParametersMessenger()
delete ssCmd;
delete fluc1Cmd;
delete posiCmd;
delete ortoCmd;
delete dumpCmd;
}
@@ -595,8 +603,12 @@ void G4EmParametersMessenger::SetNewValue(G4UIcommand* command,
theParameters->SetRetrieveMuDataFromFile(mudatCmd->GetNewBoolValue(newValue));
} else if (command == peKCmd) {
theParameters->SetPhotoeffectBelowKShell(peKCmd->GetNewBoolValue(newValue));
} else if (command == f3gCmd) {
theParameters->Set3GammaAnnihilationOnFly(f3gCmd->GetNewBoolValue(newValue));
} else if (command == mscPCmd) {
theParameters->SetMscPositronCorrection(mscPCmd->GetNewBoolValue(newValue));
} else if (command == pepicsCmd) {
theParameters->SetUseEPICS2017XS(pepicsCmd->GetNewBoolValue(newValue));
} else if (command == minEnCmd) {
theParameters->SetMinEnergy(minEnCmd->GetNewDoubleValue(newValue));
@@ -733,10 +745,10 @@ void G4EmParametersMessenger::SetNewValue(G4UIcommand* command,
theParameters->SetFluctuationType(x);
} else if (command == posiCmd) {
G4PositronAtRestModelType x = fSimplePositronium;
if(newValue == "Allison") { x = fAllisonPositronium; }
if (newValue == "Allison") { x = fAllisonPositronium; }
else if (newValue == "OrePowell") { x = fOrePowell; }
else if (newValue == "OrePowellPolar") { x = fOrePowellPolar; }
theParameters->SetPositronAtRestModelType(x);
} else if ( command==ortoCmd ) {
theParameters->SetOrtoPsFraction(ortoCmd->GetNewDoubleValue(newValue));
} else if ( command==tripletCmd ) {
theParameters->SetConversionType(tripletCmd->GetNewIntValue(newValue));
} else if ( command==onIsolatedCmd ) {
source/processes/electromagnetic/utils/src/G4EmSaturation.cc
+3 -2
View File
@@ -223,8 +223,9 @@ void G4EmSaturation::InitialiseBirksCoefficient(const G4Material* mat)
curChargeSq += (Z*Z)*w;
norm += w;
}
curRatio *= (CLHEP::proton_mass_c2/norm);
curChargeSq /= norm;
if ( norm > 0.0) { norm = 1.0/norm; }
curRatio *= (CLHEP::proton_mass_c2*norm);
curChargeSq *= norm;
// store results
std::size_t idx = mat->GetIndex();
source/processes/electromagnetic/utils/src/G4TransportationWithMsc.cc
+2
View File
@@ -55,6 +55,7 @@
#include "G4StepPoint.hh"
#include "G4StepStatus.hh"
#include "G4Track.hh"
#include "G4TransportationProcessType.hh"
#include "G4VMscModel.hh"
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
@@ -68,6 +69,7 @@ static constexpr G4double kMinDisplacement2 = kGeomMin * kGeomMin;
G4TransportationWithMsc::G4TransportationWithMsc(ScatteringType type, G4int verbosity)
: G4Transportation(verbosity, "TransportationWithMsc"), fType(type)
{
SetProcessSubType(static_cast<G4int>(TRANSPORTATION_WITH_MSC));
SetVerboseLevel(1);
fEmManager = G4LossTableManager::Instance();