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

Import Geant4 11.2.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2023-12-08 10:43:34 +01:00
parent dd1f179cda
commit 860a2b92bf
3962 changed files with 139318 additions and 164259 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/builders/History
+6
View File
@@ -6,6 +6,12 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-10-19 Jean-Christophe David (phys-builders-V11-01-03)
- G4HadronicBuilder: added two methods - BuildINCLXX and BuildAntiLightIonsINCLXX.
## 2023-07-12 Alberto Ribon (phys-builders-V11-01-02)
- Removed the no longer used file OrderingParameterTable.
## 2023-03-17 Alberto Ribon (phys-builders-V11-01-01)
- G4HadronicBuilder : fixed bug in the method BuildKaonsFTFQGSP_BERT().
Thanks to Dmitri Konstantinov for reporting it.
source/physics_lists/builders/OrderingParameterTable
-65
View File
@@ -1,65 +0,0 @@
Transportation 1 91 -1 0 0 0
CoupleTrans 1 92 -1 0 0 0
CoulombScat 2 1 -1 -1 1000 0
Ionisation 2 2 -1 2 2 0
Brems 2 3 -1 -1 3 0
PairProdCharged 2 4 -1 -1 4 0
Annih 2 5 5 -1 5 0
AnnihToMuMu 2 6 -1 -1 6 0
AnnihToHad 2 7 -1 -1 7 0
NuclearStopping 2 8 -1 8 -1 0
ElectronGeneral 2 9 -1 1 1 0
Msc 2 10 -1 1 -1 0
Rayleigh 2 11 -1 -1 1000 0
PhotoElectric 2 12 -1 -1 1000 0
Compton 2 13 -1 -1 1000 0
Conv 2 14 -1 -1 1000 0
ConvToMuMu 2 15 -1 -1 1000 0
GammaGeneral 2 16 -1 -1 1000 0
PositronGeneral 2 17 1 1 1 0
Cerenkov 2 21 -1 -1 1000 0
Scintillation 2 22 9999 -1 9999 0
SynchRad 2 23 -1 -1 1000 0
TransRad 2 24 -1 -1 1000 0
SurfaceRefl 2 25 -1 -1 1000 0
OpAbsorp 3 31 -1 -1 1000 0
OpBoundary 3 32 -1 -1 1000 0
OpRayleigh 3 33 -1 -1 1000 0
OpWLS 3 34 -1 -1 1000 0
OpMieHG 3 35 -1 -1 1000 0
OpWLS2 3 36 -1 -1 1000 0
MuPairByMuon 2 49 -1 -1 10 0
DNAElastic 2 51 -1 -1 1000 0
DNAExcit 2 52 -1 -1 1000 0
DNAIonisation 2 53 -1 -1 1000 0
DNAVibExcit 2 54 -1 -1 1000 0
DNAAttachment 2 55 -1 -1 1000 0
DNAChargeDec 2 56 -1 -1 1000 0
DNAChargeInc 2 57 -1 -1 1000 0
DNAElecSolv 2 58 -1 -1 1000 0
DNAMolecDecay 2 59 1000 -1 -1 0
ITTransport 1 60 -1 0 0 0
DNABrownTrans 1 61 -1 0 0 0
DNADoubleIoni 2 62 -1 -1 1000 0
DNADoubleCap 2 63 -1 -1 1000 0
DNAIoniTransfer 2 64 -1 -1 1000 0
HadElastic 4 111 -1 -1 1000 0
NeutronGeneral 4 116 -1 -1 1000 0
HadInelastic 4 121 -1 -1 1000 0
HadCapture 4 131 -1 -1 1000 0
MuAtomCapture 4 132 -1 -1 1000 0
HadFission 4 141 -1 -1 1000 0
HadAtRest 4 151 1000 -1 -1 0
HadCEX 4 161 -1 -1 1000 0
Decay 6 201 1000 -1 1000 0
DecayWSpin 6 202 1000 -1 1000 0
DecayPiWSpin 6 203 1000 -1 1000 0
DecayRadio 6 210 1000 -1 1000 0
DecayUnKnown 6 211 1000 -1 1000 0
DecayMuAtom 6 221 1000 -1 1000 0
DecayExt 6 231 1000 -1 1000 0
StepLimiter 7 401 -1 -1 1000 0
UsrSpecCuts 7 402 -1 -1 1000 0
NeutronKiller 7 403 -1 -1 1000 0
ParallelWorld 10 491 9900 1 9900 1
source/physics_lists/builders/include/G4HadronicBuilder.hh
+9
View File
@@ -37,6 +37,9 @@
#include "globals.hh"
#include <vector>
#include "G4VComponentCrossSection.hh"
#include "G4VCrossSectionDataSet.hh"
class G4HadronicBuilder
{
private:
@@ -55,6 +58,10 @@ private:
G4bool bert, G4bool quasiElastic,
const G4String& xsName);
static void BuildINCLXX(const std::vector<G4int>& particleList,
G4bool bert, const G4String& xsName);
public:
// methods to build elastic and inelastic physics per particle category
@@ -74,6 +81,8 @@ public:
static void BuildAntiLightIonsFTFP();
static void BuildAntiLightIonsINCLXX();
//static void BuildAntiLightIonsQGSP_FTFP(G4bool quasiElastic);
static void BuildBCHadronsFTFP_BERT();
source/physics_lists/builders/src/G4HadronicBuilder.cc
+58
View File
@@ -36,6 +36,7 @@
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4PhysicsListHelper.hh"
#include "G4SystemOfUnits.hh"
#include "G4HadronicParameters.hh"
@@ -65,6 +66,8 @@
#include "G4PreCompoundModel.hh"
#include "G4INCLXXInterface.hh"
#include "G4ComponentAntiNuclNuclearXS.hh"
void G4HadronicBuilder::BuildFTFP_BERT(const std::vector<G4int>& partList,
@@ -193,6 +196,57 @@ void G4HadronicBuilder::BuildQGSP_FTFP_BERT(const std::vector<G4int>& partList,
}
}
void G4HadronicBuilder::BuildINCLXX(const std::vector<G4int>& partList,
G4bool bert, const G4String& xsName) {
// FTF
G4HadronicParameters* param = G4HadronicParameters::Instance();
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
auto theModel = new G4TheoFSGenerator("FTFP");
auto theStringModel = new G4FTFModel();
theStringModel->SetFragmentationModel(new G4ExcitedStringDecay());
theModel->SetHighEnergyGenerator( theStringModel );
theModel->SetTransport( new G4GeneratorPrecompoundInterface() );
theModel->SetMaxEnergy( param->GetMaxEnergy() );
G4CascadeInterface* theCascade = nullptr;
if(bert) {
theCascade = new G4CascadeInterface();
theCascade->SetMaxEnergy( param->GetMaxEnergyTransitionFTF_Cascade() );
theModel->SetMinEnergy( param->GetMinEnergyTransitionFTF_Cascade() );
}
// INCLXX
auto theModelINCLXX = new G4INCLXXInterface();
theModelINCLXX->SetMinEnergy( param->GetMinEnergyINCLXX_Pbar() );
theModelINCLXX->SetMaxEnergy( param->GetMaxEnergyINCLXX_Pbar() );
//
auto xsinel = G4HadProcesses::InelasticXS( xsName );
G4ParticleTable* table = G4ParticleTable::GetParticleTable();
for( auto & pdg : partList ) {
auto part = table->FindParticle( pdg );
if ( part == nullptr ) { continue; }
auto hadi = new G4HadronInelasticProcess( part->GetParticleName()+"Inelastic", part );
if( pdg == -2212 ) { // pbar use INCLXX
hadi->AddDataSet( xsinel );
hadi->RegisterMe( theModelINCLXX );
if( param->ApplyFactorXS() ) hadi->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() );
ph->RegisterProcess(hadi, part);
} else { // other anti-X use FTF
hadi->AddDataSet( xsinel );
hadi->RegisterMe( theModel );
if( theCascade != nullptr ) hadi->RegisterMe( theCascade );
if( param->ApplyFactorXS() ) hadi->MultiplyCrossSectionBy( param->XSFactorHadronInelastic() );
ph->RegisterProcess(hadi, part);
}
}
}
void G4HadronicBuilder::BuildElastic(const std::vector<G4int>& partList) {
G4HadronicParameters* param = G4HadronicParameters::Instance();
@@ -260,6 +314,10 @@ void G4HadronicBuilder::BuildAntiLightIonsFTFP() {
// BuildQGSP_FTFP_BERT(G4HadParticles::GetLightAntiIons(), false, qElastic, "AntiAGlauber");
//}
void G4HadronicBuilder::BuildAntiLightIonsINCLXX() {
BuildINCLXX(G4HadParticles::GetLightAntiIons(), false, "AntiAGlauber");
}
void G4HadronicBuilder::BuildBCHadronsFTFP_BERT() {
if( G4HadronicParameters::Instance()->EnableBCParticles() ) {
// Bertini is not applicable for charm and bottom hadrons, therefore FTFP is used
source/physics_lists/constructors/decay/History
+5
View File
@@ -4,6 +4,11 @@ See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
which **must** added in reverse chronological order (newest at the top). It must **not**
be used as a substitute for writing good git commit messages!
## 2023-11-07 Alberto Ribon (phys-ctor-decay-V11-01-01)
- G4RadioactiveDecayPhysics : replaced G4RadioactiveDecay with
G4Radioactivation to be able to run in biasing mode (not only in
analogue mode, as before with G4RadioactiveDecay).
## 2023-01-11 Alberto Ribon (phys-ctor-decay-V11-01-00)
- G4RadioactiveDecayPhysics : assigned the RadioactiveDecay process
to G4Triton (which is the only light ion that decays).
source/physics_lists/constructors/decay/src/G4RadioactiveDecayPhysics.cc
+3 -3
View File
@@ -28,7 +28,7 @@
#include "G4RadioactiveDecayPhysics.hh"
#include "G4RadioactiveDecay.hh"
#include "G4Radioactivation.hh"
#include "G4GenericIon.hh"
#include "globals.hh"
#include "G4PhysicsListHelper.hh"
@@ -99,7 +99,7 @@ void G4RadioactiveDecayPhysics::ConstructProcess()
}
G4PhysicsListHelper::GetPhysicsListHelper()->
RegisterProcess(new G4RadioactiveDecay(), G4GenericIon::GenericIon());
RegisterProcess(new G4Radioactivation, G4GenericIon::GenericIon());
// Triton (which is not a generic ion) is the only light ion that decays.
// Note that the anti_triton does not have beta decay, because RadioactiveDecay,
@@ -108,7 +108,7 @@ void G4RadioactiveDecayPhysics::ConstructProcess()
// long lifetime and the fact that annihilation and nuclear capture
// are more likely to happen before decay.
G4PhysicsListHelper::GetPhysicsListHelper()->
RegisterProcess(new G4RadioactiveDecay(), G4Triton::Triton());
RegisterProcess(new G4Radioactivation, G4Triton::Triton());
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/History
+21
View File
@@ -6,6 +6,27 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-11-09 Hoang Tran (phys-ctor-em-V11-01-13)
- Correct subtype process of G4LowECapture in G4EmDNABuilder .
## 2023-11-04 Hoang Tran (phys-ctor-em-V11-01-12)
- Correct G4EmDNABuilder for proton constructors.
## 2023-11-03 Jonas Hahnfeld (phys-ctor-em-V11-01-11)
- `G4EmStandardPhysicsSS`: Remove unused includes.
## 2023-10-23 Jonas Hahnfeld (phys-ctor-em-V11-01-10)
- `G4EmStandardPhysicsSS`: Allow to use `G4TransportationWithMsc`.
## 2023-10-11 Vladimir Ivanchenko (phys-ctor-em-V11-01-09)
- G4EmDNABuilder - for DNA Opt4 and Opt6 restored configuration of Geant4 11.1.2
for protons in order to have under control results of various tests.
## 2023-07-19 Vladimir Ivanchenko (phys-ctor-em-V11-01-08)
- G4EmDNABuilder - for Opt2, 4, 6 use for protons and ions
G4DNARuddIonisationExtendedModel from zero to 100 MeV; ion capture
limit is set to 0.1 keV.
## 2023-04-06 Hoang Tran (phys-ctor-em-V11-01-07)
- Introduced G4ChemDissociationChannels and G4ChemDissociationChannels_option1
source/physics_lists/constructors/electromagnetic/include/G4EmBuilder.hh
+3
View File
@@ -40,6 +40,7 @@
class G4hMultipleScattering;
class G4ParticleDefinition;
class G4NuclearStopping;
class G4VEmModel;
class G4VMscModel;
class G4EmBuilder
@@ -80,6 +81,8 @@ public:
static void ConstructElectronMscProcess(G4VMscModel* msc1, G4VMscModel* msc2,
G4ParticleDefinition* particle);
static void ConstructElectronSSProcess(G4VEmModel* ss, G4ParticleDefinition* particle);
};
#endif
source/physics_lists/constructors/electromagnetic/src/G4EmBuilder.cc
+26
View File
@@ -438,3 +438,29 @@ void G4EmBuilder::ConstructElectronMscProcess(G4VMscModel* msc1, G4VMscModel* ms
ph->RegisterProcess(msc, particle);
}
}
void G4EmBuilder::ConstructElectronSSProcess(G4VEmModel* ss, G4ParticleDefinition* particle)
{
G4TransportationWithMscType type = G4EmParameters::Instance()->TransportationWithMsc();
G4ProcessManager* procManager = particle->GetProcessManager();
auto plist = procManager->GetProcessList();
G4int ptype = (0 < plist->size()) ? (*plist)[0]->GetProcessSubType() : 0;
if (type != G4TransportationWithMscType::fDisabled && ptype == TRANSPORTATION) {
// Remove default G4Transportation and replace with G4TransportationWithMsc.
procManager->RemoveProcess(0);
G4TransportationWithMsc* transportWithMsc =
new G4TransportationWithMsc(G4TransportationWithMsc::ScatteringType::SingleScattering);
if (type == G4TransportationWithMscType::fMultipleSteps) {
transportWithMsc->SetMultipleSteps(true);
}
transportWithMsc->AddSSModel(ss);
procManager->AddProcess(transportWithMsc, -1, 0, 0);
}
else {
// Register as a separate process.
G4CoulombScattering* ssProc = new G4CoulombScattering(false);
ssProc->SetEmModel(ss);
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(ssProc, particle);
}
}
source/physics_lists/constructors/electromagnetic/src/G4EmDNABuilder.cc
+2 -2
View File
@@ -536,7 +536,7 @@ G4EmDNABuilder::ConstructDNAIonPhysics(const G4double emaxIonDNA,
mod->SetHighEnergyLimit(emaxIonDNA);
theDNAIoni->AddEmModel(-1, mod, reg);
FindOrBuildCapture(25.0*CLHEP::keV, part);
FindOrBuildCapture(0.1*CLHEP::keV, part);
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -748,7 +748,7 @@ G4EmDNABuilder::FindOrBuildChargeIncrease(G4ParticleDefinition* part,
G4LowECapture*
G4EmDNABuilder::FindOrBuildCapture(const G4double elim, G4ParticleDefinition* part)
{
auto p = G4PhysListUtil::FindProcess(part, 66);
auto p = G4PhysListUtil::FindProcess(part, -1);
G4LowECapture* ptr = dynamic_cast<G4LowECapture*>(p);
if(nullptr == ptr) {
ptr = new G4LowECapture(elim);
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsSS.cc
+8 -10
View File
@@ -182,33 +182,32 @@ void G4EmStandardPhysicsSS::ConstructProcess()
// e-
particle = G4Electron::Electron();
G4CoulombScattering* ss = new G4CoulombScattering(false);
G4VEmModel* ss = nullptr;
if(param->UseMottCorrection()) {
ss->SetEmModel(new G4eDPWACoulombScatteringModel());
ss = new G4eDPWACoulombScatteringModel();
} else {
ss->SetEmModel(new G4eCoulombScatteringModel(false));
ss = new G4eCoulombScatteringModel(false);
}
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
G4ePairProduction* ee = new G4ePairProduction();
ph->RegisterProcess(ee, particle);
ph->RegisterProcess(ss, particle);
G4EmBuilder::ConstructElectronSSProcess(ss, particle);
// e+
particle = G4Positron::Positron();
ss = new G4CoulombScattering(false);
if(param->UseMottCorrection()) {
ss->SetEmModel(new G4eDPWACoulombScatteringModel());
ss = new G4eDPWACoulombScatteringModel();
} else {
ss->SetEmModel(new G4eCoulombScatteringModel(false));
ss = new G4eCoulombScatteringModel(false);
}
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(ee, particle);
ph->RegisterProcess(ss, particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
G4EmBuilder::ConstructElectronSSProcess(ss, particle);
// generic ion
particle = G4GenericIon::GenericIon();
@@ -217,8 +216,7 @@ void G4EmStandardPhysicsSS::ConstructProcess()
ionIoni->SetFluctModel(fluc);
ionIoni->SetEmModel(new G4LindhardSorensenIonModel());
ph->RegisterProcess(ionIoni, particle);
ss = new G4CoulombScattering(false);
ph->RegisterProcess(ss, particle);
ph->RegisterProcess(new G4CoulombScattering(false), particle);
// muons, hadrons, ions
G4EmBuilder::ConstructChargedSS(hmsc);
source/physics_lists/constructors/gamma_lepto_nuclear/History
+17
View File
@@ -6,6 +6,23 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-11-10 Vladimir Ivanchenko (phys-ctor-glnuclear-V11-01-04)
- G4EmMessenger, G4NeutrinoPhysicsMessenger - fixed typos
## 2023-11-06 Vladimir Ivanchenko (phys-ctor-glnuclear-V11-01-03)
- G4EmExtraPhysics - fixed instantiation of e+- nuclear processes
- G4NeutrinoPhysics - improved neutrino physics
## 2023-10-30 Vladimir Ivanchenko (phys-ctor-glnuclear-V11-01-02)
- G4EmExtraPhysics, G4EmMessenger - removed neutrino physics
- G4NeutrinoPhysics, G4NeutrinoPhysicsMessenger - added new physics constructor
for neutrino physics and its messenger
- Clean-up all classes of sub-library
## 2023-10-09 Vladimir Grichine (phys-ctor-glnuclear-V11-01-01)
- G4EmExtraPhysics, G4EmMessenger - activation of neutrino oscillation
and oscillation distance biasing
## 2023-02-12 Vladimir Grichine (phys-ctor-glnuclear-V11-01-00)
- G4EmExtraPhysics - biasing is activated in processes, not XS
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4BertiniElectroNuclearBuilder.hh
+14 -34
View File
@@ -27,47 +27,27 @@
#define G4BertiniElectroNuclearBuilder_h 1
#include "globals.hh"
#include "G4ios.hh"
#include "G4TheoFSGenerator.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4GammaParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4CascadeInterface.hh"
#include "G4ElectroVDNuclearModel.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4ElectronNuclearProcess.hh"
#include "G4PositronNuclearProcess.hh"
//A. Dotti (June2013): No need to change this class for MT
// Since each thread owns its own instance (created by G4EmExtraPhysics)
class G4BertiniElectroNuclearBuilder
{
public:
G4BertiniElectroNuclearBuilder(G4bool eNucl);
virtual ~G4BertiniElectroNuclearBuilder();
public:
explicit G4BertiniElectroNuclearBuilder(G4bool eNucl);
virtual ~G4BertiniElectroNuclearBuilder() = default;
public:
virtual void Build();
virtual void Build();
protected:
G4HadronInelasticProcess * thePhotoNuclearProcess;
G4ElectronNuclearProcess * theElectronNuclearProcess;
G4PositronNuclearProcess * thePositronNuclearProcess;
G4ElectroVDNuclearModel * theElectroReaction;
G4CascadeInterface * theGammaReaction;
G4TheoFSGenerator * theModel;
G4GeneratorPrecompoundInterface * theCascade;
G4QGSModel< G4GammaParticipants > * theStringModel;
G4QGSMFragmentation * theFragmentation;
G4ExcitedStringDecay * theStringDecay;
G4bool wasActivated;
G4bool eActivated;
G4BertiniElectroNuclearBuilder& operator=
(const G4BertiniElectroNuclearBuilder& right) = delete;
G4BertiniElectroNuclearBuilder(const G4BertiniElectroNuclearBuilder&) = delete;
protected:
G4HadronInelasticProcess* thePhotoNuclearProcess{nullptr};
G4CascadeInterface* theGammaReaction{nullptr};
G4bool eActivated;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4EmExtraPhysics.hh
+17 -33
View File
@@ -78,15 +78,11 @@ public:
void PositronToMuMuFactor(G4double val);
void PositronToHadronsFactor(G4double val);
void GammaNuclearLEModelLimit(G4double val);
void NeutrinoActivated(G4bool val);
void NuETotXscActivated(G4bool val);
void SetUseGammaNuclearXS(G4bool val);
void SetNuEleCcBias(G4double bf);
void SetNuEleNcBias(G4double bf);
void SetNuNucleusBias(G4double bf);
void SetNuDetectorName(const G4String& dn);
G4EmExtraPhysics& operator=(const G4EmExtraPhysics& right) = delete;
G4EmExtraPhysics(const G4EmExtraPhysics&) = delete;
private:
void ConstructGammaElectroNuclear();
@@ -94,37 +90,25 @@ private:
void ConstructLENDGammaNuclear(G4CascadeInterface* cascade,
G4HadronInelasticProcess* gnuc);
G4bool gnActivated = true;
G4bool eActivated = true;
G4bool gLENDActivated = false;
G4bool munActivated = true;
G4bool synActivated = false;
G4bool synActivatedForAll = false;
G4bool gmumuActivated = false;
G4bool mmumuActivated = false;
G4bool pmumuActivated = false;
G4bool phadActivated = false;
G4bool fNuActivated = false;
G4bool fNuETotXscActivated = false;
G4bool fUseGammaNuclearXS = true;
G4bool gnActivated{true};
G4bool eActivated{true};
G4bool gLENDActivated{false};
G4bool munActivated{true};
G4bool synActivated{false};
G4bool synActivatedForAll{false};
G4bool gmumuActivated{false};
G4bool mmumuActivated{false};
G4bool pmumuActivated{false};
G4bool phadActivated{false};
G4bool fUseGammaNuclearXS{true};
G4double gmumuFactor = 1.0;
G4double pmumuFactor = 1.0;
G4double phadFactor = 1.0;
G4double fNuEleCcBias = 1.0;
G4double fNuEleNcBias = 1.0;
G4double fNuNucleusBias = 1.0;
G4double gmumuFactor{1.0};
G4double pmumuFactor{1.0};
G4double phadFactor{1.0};
G4double fGNLowEnergyLimit;
G4String fNuDetectorName = "0";
G4EmMessenger* theMessenger;
G4int verbose;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4EmMessenger.hh
+14 -21
View File
@@ -61,34 +61,27 @@ public:
void SetNewValue(G4UIcommand* aComm, G4String aS) override;
private:
G4EmExtraPhysics* theB;
G4EmExtraPhysics* theB;
G4UIcmdWithABool* theSynch;
G4UIcmdWithABool* theSynchAll;
G4UIcmdWithABool* theGN;
G4UIcmdWithABool* theGLENDN;
G4UIcmdWithABool* theEN;
G4UIcmdWithABool* theMUN;
G4UIcmdWithABool* theGMM;
G4UIcmdWithABool* theMMM;
G4UIcmdWithABool* thePMM;
G4UIcmdWithABool* thePH;
G4UIcmdWithABool* theNu;
G4UIcmdWithABool* theNuETX;
G4UIcmdWithABool* theXS;
G4UIcmdWithABool* theSynch;
G4UIcmdWithABool* theSynchAll;
G4UIcmdWithABool* theGN;
G4UIcmdWithABool* theGLENDN;
G4UIcmdWithABool* theEN;
G4UIcmdWithABool* theMUN;
G4UIcmdWithABool* theGMM;
G4UIcmdWithABool* theMMM;
G4UIcmdWithABool* thePMM;
G4UIcmdWithABool* thePH;
G4UIcmdWithABool* theXS;
G4UIcmdWithADouble* theGMM1;
G4UIcmdWithADouble* thePMM1;
G4UIcmdWithADouble* thePH1;
G4UIcmdWithADouble* theNuEleCcBF;
G4UIcmdWithADouble* theNuEleNcBF;
G4UIcmdWithADouble* theNuNucleusBF;
G4UIcmdWithADoubleAndUnit* theGNlowe;
G4UIcmdWithAString* theNuDN;
G4UIdirectory* aDir1;
G4UIdirectory* aDir2;
G4UIdirectory* aDir1;
G4UIdirectory* aDir2;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4LENDBertiniGammaElectroNuclearBuilder.hh
+9 -10
View File
@@ -28,20 +28,19 @@
#include "G4BertiniElectroNuclearBuilder.hh"
//A. Dotti (June2013): No need to change this class for MT
// Since each thread owns its own instance (created by G4EmExtraPhysics)
class G4LENDBertiniGammaElectroNuclearBuilder
:public G4BertiniElectroNuclearBuilder
: public G4BertiniElectroNuclearBuilder
{
using base = G4BertiniElectroNuclearBuilder;
public:
G4LENDBertiniGammaElectroNuclearBuilder(G4bool eNucl);
virtual ~G4LENDBertiniGammaElectroNuclearBuilder();
public:
explicit G4LENDBertiniGammaElectroNuclearBuilder(G4bool eNucl);
~G4LENDBertiniGammaElectroNuclearBuilder() override = default;
public:
virtual void Build();
void Build() override;
G4LENDBertiniGammaElectroNuclearBuilder& operator=
(const G4LENDBertiniGammaElectroNuclearBuilder& right) = delete;
G4LENDBertiniGammaElectroNuclearBuilder(const G4LENDBertiniGammaElectroNuclearBuilder&) = delete;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4NeutrinoPhysics.hh
+90
View File
@@ -0,0 +1,90 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutrinoPhysics
//
// Author: 2023 V. Ivanchenko extracted from G4EmExtraPhysics
//
// Modified:
//
//----------------------------------------------------------------------------
//
#ifndef G4NeutrinoPhysics_h
#define G4NeutrinoPhysics_h 1
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include "G4NeutrinoPhysicsMessenger.hh"
class G4NeutrinoPhysics : public G4VPhysicsConstructor
{
public:
G4NeutrinoPhysics(G4int ver = 1);
~G4NeutrinoPhysics() override;
void ConstructParticle() override;
void ConstructProcess() override;
void NuETotXscActivated(G4bool val);
void SetNuOscillation(G4bool val);
void SetNuEleCcBias(G4double bf);
void SetNuEleNcBias(G4double bf);
void SetNuNucleusBias(G4double bf);
void SetNuOscDistanceBias(G4double bf);
void SetNuDetectorName(const G4String& dn);
void SetNuOscDistanceName(const G4String& dn);
G4NeutrinoPhysics& operator=(const G4NeutrinoPhysics& right) = delete;
G4NeutrinoPhysics(const G4NeutrinoPhysics&) = delete;
private:
G4bool fNuETotXscActivated = false;
G4bool fNuOscillation = true;
G4double fNuEleCcBias = 1.0;
G4double fNuEleNcBias = 1.0;
G4double fNuNucleusBias = 1.0;
G4double fNuOscDistanceBias = 1.0;
G4String fNuDetectorName = "0";
G4String fNuOscDistanceName = "0";
G4NeutrinoPhysicsMessenger* theMessenger;
G4int verbose;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/include/G4NeutrinoPhysicsMessenger.hh
+79
View File
@@ -0,0 +1,79 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutrinoPhysicsMessenger
//
// Author: 2023 V. Ivanchenko created using G4EmMessenger
//
// Modified:
//
//----------------------------------------------------------------------------
//
#ifndef G4NeutrinoPhysicsMessenger_h
#define G4NeutrinoPhysicsMessenger_h 1
#include "G4UImessenger.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithABool.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithAString.hh"
class G4NeutrinoPhysics;
class G4NeutrinoPhysicsMessenger: public G4UImessenger
{
public:
explicit G4NeutrinoPhysicsMessenger(G4NeutrinoPhysics* af);
~G4NeutrinoPhysicsMessenger() override;
void SetNewValue(G4UIcommand* aComm, G4String aS) override;
G4NeutrinoPhysicsMessenger& operator=
(const G4NeutrinoPhysicsMessenger& right) = delete;
G4NeutrinoPhysicsMessenger(const G4NeutrinoPhysicsMessenger&) = delete;
private:
G4NeutrinoPhysics* theB;
G4UIcmdWithABool* theNu;
G4UIcmdWithABool* theNuETX;
G4UIcmdWithADouble* theNuEleCcBF;
G4UIcmdWithADouble* theNuEleNcBF;
G4UIcmdWithADouble* theNuNucleusBF;
G4UIcmdWithADouble* theNuOscDistanceBF;
G4UIcmdWithAString* theNuDN;
G4UIcmdWithAString* theNuODN;
G4UIdirectory* aDir;
};
#endif
source/physics_lists/constructors/gamma_lepto_nuclear/sources.cmake
+10 -6
View File
@@ -7,22 +7,21 @@ geant4_add_module(G4phys_ctor_glnuclear
G4EmExtraPhysics.hh
G4EmMessenger.hh
G4LENDBertiniGammaElectroNuclearBuilder.hh
G4NeutrinoPhysics.hh
G4NeutrinoPhysicsMessenger.hh
SOURCES
G4BertiniElectroNuclearBuilder.cc
G4EmExtraPhysics.cc
G4EmMessenger.cc
G4LENDBertiniGammaElectroNuclearBuilder.cc)
G4LENDBertiniGammaElectroNuclearBuilder.cc
G4NeutrinoPhysics.cc
G4NeutrinoPhysicsMessenger.cc)
geant4_module_link_libraries(G4phys_ctor_glnuclear
PUBLIC
G4globman
G4had_lept_nuclear
G4had_string_frag
G4had_theo_max
G4hadronic_bert_cascade
G4hadronic_binary
G4hadronic_proc
G4hadronic_qgstring
G4intercoms
G4run
PRIVATE
@@ -32,8 +31,13 @@ geant4_module_link_libraries(G4phys_ctor_glnuclear
G4emutils
G4had_gamma_nuclear
G4had_lend
G4had_lept_nuclear
G4had_preequ_exciton
G4had_string_frag
G4had_theo_max
G4hadronic_binary
G4hadronic_coherent_elastic
G4hadronic_qgstring
G4hadronic_util
G4hadronic_xsect
G4ions
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4BertiniElectroNuclearBuilder.cc
+32 -33
View File
@@ -51,53 +51,46 @@
#include "G4GammaGeneralProcess.hh"
#include "G4LossTableManager.hh"
#include "G4ElectroVDNuclearModel.hh"
#include "G4ElectronNuclearProcess.hh"
#include "G4PositronNuclearProcess.hh"
#include "G4PhotoNuclearCrossSection.hh"
#include "G4ios.hh"
#include "G4TheoFSGenerator.hh"
#include "G4GeneratorPrecompoundInterface.hh"
#include "G4QGSModel.hh"
#include "G4GammaParticipants.hh"
#include "G4QGSMFragmentation.hh"
#include "G4ExcitedStringDecay.hh"
#include "G4HadronicParameters.hh"
G4BertiniElectroNuclearBuilder::G4BertiniElectroNuclearBuilder(G4bool eNucl) :
thePhotoNuclearProcess(nullptr), theElectronNuclearProcess(nullptr),
thePositronNuclearProcess(nullptr), theElectroReaction(nullptr),
theGammaReaction(nullptr), theModel(nullptr), theCascade(nullptr),
theStringModel(nullptr), theFragmentation(nullptr), theStringDecay(nullptr),
wasActivated(false), eActivated(eNucl)
G4BertiniElectroNuclearBuilder::G4BertiniElectroNuclearBuilder(G4bool eNucl)
: eActivated(eNucl)
{}
G4BertiniElectroNuclearBuilder::~G4BertiniElectroNuclearBuilder()
{
if(wasActivated) {
delete theFragmentation;
delete theStringDecay;
}
}
void G4BertiniElectroNuclearBuilder::Build()
{
if(wasActivated) return;
wasActivated=true;
// gamma
thePhotoNuclearProcess = new G4HadronInelasticProcess( "photonNuclear", G4Gamma::Definition() );
thePhotoNuclearProcess->AddDataSet( new G4PhotoNuclearCrossSection );
thePhotoNuclearProcess->AddDataSet( new G4PhotoNuclearCrossSection() );
theGammaReaction = new G4CascadeInterface();
if(eActivated) {
theElectronNuclearProcess = new G4ElectronNuclearProcess;
thePositronNuclearProcess = new G4PositronNuclearProcess;
theElectroReaction = new G4ElectroVDNuclearModel;
}
theGammaReaction = new G4CascadeInterface;
auto theModel = new G4TheoFSGenerator;
theModel = new G4TheoFSGenerator;
theStringModel = new G4QGSModel< G4GammaParticipants >;
theStringDecay = new G4ExcitedStringDecay(theFragmentation=new G4QGSMFragmentation);
auto theStringModel = new G4QGSModel< G4GammaParticipants >;
auto theStringDecay = new G4ExcitedStringDecay( new G4QGSMFragmentation() );
theStringModel->SetFragmentationModel(theStringDecay);
theCascade = new G4GeneratorPrecompoundInterface;
auto theCascade = new G4GeneratorPrecompoundInterface();
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
G4ProcessManager * aProcMan = nullptr;
G4ProcessManager* aProcMan = nullptr;
theGammaReaction->SetMaxEnergy(3.5*GeV);
thePhotoNuclearProcess->RegisterMe(theGammaReaction);
@@ -106,15 +99,21 @@ void G4BertiniElectroNuclearBuilder::Build()
thePhotoNuclearProcess->RegisterMe(theModel);
G4GammaGeneralProcess* sp =
(G4GammaGeneralProcess*)G4LossTableManager::Instance()->GetGammaGeneralProcess();
if(sp) {
dynamic_cast<G4GammaGeneralProcess*>(G4LossTableManager::Instance()->GetGammaGeneralProcess());
if ( nullptr != sp ) {
sp->AddHadProcess(thePhotoNuclearProcess);
} else {
aProcMan = G4Gamma::Gamma()->GetProcessManager();
aProcMan->AddDiscreteProcess(thePhotoNuclearProcess);
}
if(eActivated) {
// e+, e-
if (eActivated) {
auto theElectronNuclearProcess = new G4ElectronNuclearProcess();
auto thePositronNuclearProcess = new G4PositronNuclearProcess();
auto theElectroReaction = new G4ElectroVDNuclearModel();
aProcMan = G4Electron::Electron()->GetProcessManager();
theElectronNuclearProcess->RegisterMe(theElectroReaction);
aProcMan->AddDiscreteProcess(theElectronNuclearProcess);
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4EmExtraPhysics.cc
+47 -245
View File
@@ -54,12 +54,6 @@
#include "G4Positron.hh"
#include "G4MuonPlus.hh"
#include "G4MuonMinus.hh"
#include "G4AntiNeutrinoE.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoTau.hh"
#include "G4NeutrinoTau.hh"
#include "G4Proton.hh"
#include "G4AntiProton.hh"
@@ -92,34 +86,6 @@
#include "G4ElectronNuclearProcess.hh"
#include "G4PositronNuclearProcess.hh"
#include "G4NeutrinoElectronProcess.hh"
#include "G4NeutrinoElectronTotXsc.hh"
#include "G4NeutrinoElectronCcModel.hh"
#include "G4NeutrinoElectronNcModel.hh"
#include "G4MuNeutrinoNucleusProcess.hh"
#include "G4TauNeutrinoNucleusProcess.hh"
#include "G4ElNeutrinoNucleusProcess.hh"
#include "G4MuNeutrinoNucleusTotXsc.hh"
#include "G4TauNeutrinoNucleusTotXsc.hh"
#include "G4ElNeutrinoNucleusTotXsc.hh"
#include "G4NuMuNucleusCcModel.hh"
#include "G4NuMuNucleusNcModel.hh"
#include "G4ANuMuNucleusCcModel.hh"
#include "G4ANuMuNucleusNcModel.hh"
#include "G4NuTauNucleusCcModel.hh"
#include "G4NuTauNucleusNcModel.hh"
#include "G4ANuTauNucleusCcModel.hh"
#include "G4ANuTauNucleusNcModel.hh"
#include "G4NuElNucleusCcModel.hh"
#include "G4NuElNucleusNcModel.hh"
#include "G4ANuElNucleusCcModel.hh"
#include "G4ANuElNucleusNcModel.hh"
#include "G4GammaGeneralProcess.hh"
#include "G4LossTableManager.hh"
#include "G4PhotoNuclearCrossSection.hh"
@@ -144,7 +110,7 @@ G4EmExtraPhysics::G4EmExtraPhysics(G4int ver):
{
theMessenger = new G4EmMessenger(this);
SetPhysicsType(bEmExtra);
if(verbose > 1) G4cout << "### G4EmExtraPhysics" << G4endl;
if (verbose > 1) G4cout << "### G4EmExtraPhysics" << G4endl;
}
G4EmExtraPhysics::G4EmExtraPhysics(const G4String&)
@@ -154,7 +120,6 @@ G4EmExtraPhysics::G4EmExtraPhysics(const G4String&)
G4EmExtraPhysics::~G4EmExtraPhysics()
{
delete theMessenger;
theMessenger = nullptr;
}
void G4EmExtraPhysics::Synch(G4bool val)
@@ -165,7 +130,7 @@ void G4EmExtraPhysics::Synch(G4bool val)
void G4EmExtraPhysics::SynchAll(G4bool val)
{
synActivatedForAll = val;
if(synActivatedForAll) { synActivated = true; }
if (synActivatedForAll) { synActivated = true; }
}
void G4EmExtraPhysics::GammaNuclear(G4bool val)
@@ -177,7 +142,7 @@ void G4EmExtraPhysics::LENDGammaNuclear(G4bool val)
{
gLENDActivated = val;
// LEND cannot be used with low-energy model
if(val) { fGNLowEnergyLimit = 0.0; }
if (val) { fGNLowEnergyLimit = 0.0; }
}
void G4EmExtraPhysics::ElectroNuclear(G4bool val)
@@ -225,55 +190,24 @@ void G4EmExtraPhysics::PositronToHadronsFactor(G4double val)
if(val > 0.0) phadFactor = val;
}
////////////////////////////////////////////////////
void G4EmExtraPhysics::NeutrinoActivated(G4bool val)
{
fNuActivated = val;
}
void G4EmExtraPhysics::NuETotXscActivated(G4bool val)
{
fNuETotXscActivated = val;
}
void G4EmExtraPhysics::SetUseGammaNuclearXS(G4bool val)
{
fUseGammaNuclearXS = val;
}
void G4EmExtraPhysics::SetNuEleCcBias(G4double bf)
{
if(bf > 0.0) fNuEleCcBias = bf;
}
void G4EmExtraPhysics::SetNuEleNcBias(G4double bf)
{
if(bf > 0.0) fNuEleNcBias = bf;
}
void G4EmExtraPhysics::SetNuNucleusBias(G4double bf)
{
if(bf > 0.0) fNuNucleusBias = bf;
}
void G4EmExtraPhysics::GammaNuclearLEModelLimit(G4double val)
{
if(val <= CLHEP::MeV) {
// lowenergy model should not be applied at high energy
// no sense set this low limit below 1 MeV
if (val <= CLHEP::MeV) {
fGNLowEnergyLimit = 0.0;
// lowenergy model should not be applied at high energy
} else if(val <= CLHEP::GeV) {
} else if (val <= CLHEP::GeV) {
fGNLowEnergyLimit = val;
gLENDActivated = false;
}
}
void G4EmExtraPhysics::SetNuDetectorName(const G4String& dn)
{
fNuDetectorName = dn;
}
/////////////////////////////////////////////////
void G4EmExtraPhysics::ConstructParticle()
@@ -283,13 +217,6 @@ void G4EmExtraPhysics::ConstructParticle()
G4Positron::Positron();
G4MuonPlus::MuonPlus();
G4MuonMinus::MuonMinus();
G4AntiNeutrinoE::AntiNeutrinoE();
G4NeutrinoE::NeutrinoE();
G4AntiNeutrinoMu::AntiNeutrinoMu();
G4NeutrinoMu::NeutrinoMu();
G4AntiNeutrinoTau::AntiNeutrinoTau();
G4NeutrinoTau::NeutrinoTau();
}
void G4EmExtraPhysics::ConstructProcess()
@@ -303,32 +230,32 @@ void G4EmExtraPhysics::ConstructProcess()
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4LossTableManager* emManager = G4LossTableManager::Instance();
if(gnActivated) { ConstructGammaElectroNuclear(); }
if (gnActivated) { ConstructGammaElectroNuclear(); }
if(munActivated) {
if (munActivated) {
G4MuonNuclearProcess* muNucProcess = new G4MuonNuclearProcess();
G4MuonVDNuclearModel* muNucModel = new G4MuonVDNuclearModel();
muNucProcess->RegisterMe(muNucModel);
ph->RegisterProcess( muNucProcess, muonplus);
ph->RegisterProcess( muNucProcess, muonminus);
}
if(gmumuActivated) {
if (gmumuActivated) {
G4GammaConversionToMuons* theGammaToMuMu = new G4GammaConversionToMuons();
theGammaToMuMu->SetCrossSecFactor(gmumuFactor);
G4GammaGeneralProcess* sp =
static_cast<G4GammaGeneralProcess*>(emManager->GetGammaGeneralProcess());
if(nullptr != sp) {
dynamic_cast<G4GammaGeneralProcess*>(emManager->GetGammaGeneralProcess());
if (nullptr != sp) {
sp->AddMMProcess(theGammaToMuMu);
} else {
ph->RegisterProcess(theGammaToMuMu, gamma);
}
}
if(mmumuActivated) {
if (mmumuActivated) {
auto proc = new G4MuonToMuonPairProduction();
ph->RegisterProcess(proc, muonplus);
ph->RegisterProcess(proc, muonminus);
}
if(pmumuActivated) {
if (pmumuActivated) {
G4AnnihiToMuPair* thePosiToMuMu = new G4AnnihiToMuPair();
thePosiToMuMu->SetCrossSecFactor(pmumuFactor);
ph->RegisterProcess(thePosiToMuMu, positron);
@@ -336,16 +263,16 @@ void G4EmExtraPhysics::ConstructProcess()
thePosiToTauTau->SetCrossSecFactor(pmumuFactor);
ph->RegisterProcess(thePosiToTauTau, positron);
}
if(phadActivated) {
if (phadActivated) {
G4eeToHadrons* thePosiToHadrons = new G4eeToHadrons();
thePosiToHadrons->SetCrossSecFactor(phadFactor);
ph->RegisterProcess(thePosiToHadrons, positron);
}
if(synActivated) {
if (synActivated) {
G4SynchrotronRadiation* theSynchRad = new G4SynchrotronRadiation();
ph->RegisterProcess( theSynchRad, electron);
ph->RegisterProcess( theSynchRad, positron);
if(synActivatedForAll) {
if (synActivatedForAll) {
ph->RegisterProcess( theSynchRad, muonplus);
ph->RegisterProcess( theSynchRad, muonminus);
@@ -356,151 +283,41 @@ void G4EmExtraPhysics::ConstructProcess()
ph->RegisterProcess( theSynchRad, G4GenericIon::GenericIon());
}
}
if( fNuActivated )
{
G4ParticleDefinition* anuelectron = G4AntiNeutrinoE::AntiNeutrinoE();
G4ParticleDefinition* nuelectron = G4NeutrinoE::NeutrinoE();
G4ParticleDefinition* anumuon = G4AntiNeutrinoMu::AntiNeutrinoMu();
G4ParticleDefinition* numuon = G4NeutrinoMu::NeutrinoMu();
G4ParticleDefinition* anutau = G4AntiNeutrinoTau::AntiNeutrinoTau();
G4ParticleDefinition* nutau = G4NeutrinoTau::NeutrinoTau();
G4NeutrinoElectronProcess* theNuEleProcess =
new G4NeutrinoElectronProcess(fNuDetectorName);
G4NeutrinoElectronTotXsc* theNuEleTotXsc = new G4NeutrinoElectronTotXsc();
if(fNuETotXscActivated)
{
G4double bftot = std::max(fNuEleCcBias,fNuEleNcBias);
theNuEleProcess->SetBiasingFactor(bftot);
}
else
{
theNuEleProcess->SetBiasingFactors(fNuEleCcBias,fNuEleNcBias);
}
theNuEleProcess->AddDataSet(theNuEleTotXsc);
G4NeutrinoElectronCcModel* ccModel = new G4NeutrinoElectronCcModel();
G4NeutrinoElectronNcModel* ncModel = new G4NeutrinoElectronNcModel();
theNuEleProcess->RegisterMe(ccModel);
theNuEleProcess->RegisterMe(ncModel);
ph->RegisterProcess(theNuEleProcess, anuelectron);
ph->RegisterProcess(theNuEleProcess, nuelectron);
ph->RegisterProcess(theNuEleProcess, anumuon);
ph->RegisterProcess(theNuEleProcess, numuon);
ph->RegisterProcess(theNuEleProcess, anutau);
ph->RegisterProcess(theNuEleProcess, nutau);
// nu_mu nucleus interactions
G4MuNeutrinoNucleusProcess* theNuMuNucleusProcess = new G4MuNeutrinoNucleusProcess(fNuDetectorName);
G4MuNeutrinoNucleusTotXsc* theNuMuNucleusTotXsc = new G4MuNeutrinoNucleusTotXsc();
if(fNuETotXscActivated)
{
theNuMuNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuMuNucleusProcess->AddDataSet(theNuMuNucleusTotXsc);
G4NuMuNucleusCcModel* numunuclcc = new G4NuMuNucleusCcModel();
G4NuMuNucleusNcModel* numunuclnc = new G4NuMuNucleusNcModel();
G4ANuMuNucleusCcModel* anumunuclcc = new G4ANuMuNucleusCcModel();
G4ANuMuNucleusNcModel* anumunuclnc = new G4ANuMuNucleusNcModel();
theNuMuNucleusProcess->RegisterMe(numunuclcc);
theNuMuNucleusProcess->RegisterMe(numunuclnc);
theNuMuNucleusProcess->RegisterMe(anumunuclcc);
theNuMuNucleusProcess->RegisterMe(anumunuclnc);
ph->RegisterProcess(theNuMuNucleusProcess, anumuon);
ph->RegisterProcess(theNuMuNucleusProcess, numuon);
// nu_tau nucleus interactions
G4TauNeutrinoNucleusProcess* theNuTauNucleusProcess = new G4TauNeutrinoNucleusProcess(fNuDetectorName);
G4TauNeutrinoNucleusTotXsc* theNuTauNucleusTotXsc = new G4TauNeutrinoNucleusTotXsc();
if(fNuETotXscActivated)
{
theNuTauNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuTauNucleusProcess->AddDataSet(theNuTauNucleusTotXsc);
G4NuTauNucleusCcModel* nutaunuclcc = new G4NuTauNucleusCcModel();
G4NuTauNucleusNcModel* nutaunuclnc = new G4NuTauNucleusNcModel();
G4ANuTauNucleusCcModel* anutaunuclcc = new G4ANuTauNucleusCcModel();
G4ANuTauNucleusNcModel* anutaunuclnc = new G4ANuTauNucleusNcModel();
theNuTauNucleusProcess->RegisterMe(nutaunuclcc);
theNuTauNucleusProcess->RegisterMe(nutaunuclnc);
theNuTauNucleusProcess->RegisterMe(anutaunuclcc);
theNuTauNucleusProcess->RegisterMe(anutaunuclnc);
ph->RegisterProcess(theNuTauNucleusProcess, anutau);
ph->RegisterProcess(theNuTauNucleusProcess, nutau);
// nu_e nucleus interactions
G4ElNeutrinoNucleusProcess* theNuElNucleusProcess = new G4ElNeutrinoNucleusProcess(fNuDetectorName);
G4ElNeutrinoNucleusTotXsc* theNuElNucleusTotXsc = new G4ElNeutrinoNucleusTotXsc();
if(fNuETotXscActivated)
{
theNuElNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuElNucleusProcess->AddDataSet(theNuElNucleusTotXsc);
G4NuElNucleusCcModel* nuelnuclcc = new G4NuElNucleusCcModel();
G4NuElNucleusNcModel* nuelnuclnc = new G4NuElNucleusNcModel();
G4ANuElNucleusCcModel* anuelnuclcc = new G4ANuElNucleusCcModel();
G4ANuElNucleusNcModel* anuelnuclnc = new G4ANuElNucleusNcModel();
theNuElNucleusProcess->RegisterMe(nuelnuclcc);
theNuElNucleusProcess->RegisterMe(nuelnuclnc);
theNuElNucleusProcess->RegisterMe(anuelnuclcc);
theNuElNucleusProcess->RegisterMe(anuelnuclnc);
ph->RegisterProcess(theNuElNucleusProcess, anuelectron);
ph->RegisterProcess(theNuElNucleusProcess, nuelectron);
}
}
void G4EmExtraPhysics::ConstructGammaElectroNuclear()
{
G4HadronicParameters* param = G4HadronicParameters::Instance();
G4LossTableManager* emManager = G4LossTableManager::Instance();
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
G4HadronInelasticProcess* gnuc = new G4HadronInelasticProcess( "photonNuclear", G4Gamma::Gamma() );
G4HadronInelasticProcess* gnuc =
new G4HadronInelasticProcess( "photonNuclear", G4Gamma::Gamma() );
auto xsreg = G4CrossSectionDataSetRegistry::Instance();
G4VCrossSectionDataSet* xs = nullptr;
if(fUseGammaNuclearXS) {
if (fUseGammaNuclearXS) {
xs = xsreg->GetCrossSectionDataSet("GammaNuclearXS");
if(nullptr == xs) xs = new G4GammaNuclearXS();
if (nullptr == xs) xs = new G4GammaNuclearXS();
} else {
xs = xsreg->GetCrossSectionDataSet("PhotoNuclearXS");
if(nullptr == xs) xs = new G4PhotoNuclearCrossSection();
if (nullptr == xs) xs = new G4PhotoNuclearCrossSection();
}
gnuc->AddDataSet(xs);
G4QGSModel< G4GammaParticipants >* theStringModel =
new G4QGSModel< G4GammaParticipants >;
G4QGSMFragmentation* theFrag = new G4QGSMFragmentation();
G4ExcitedStringDecay* theStringDecay = new G4ExcitedStringDecay(theFrag);
auto theStringDecay = new G4ExcitedStringDecay(new G4QGSMFragmentation());
theStringModel->SetFragmentationModel(theStringDecay);
G4GeneratorPrecompoundInterface* theCascade =
new G4GeneratorPrecompoundInterface;
G4TheoFSGenerator* theModel = new G4TheoFSGenerator();
auto theCascade = new G4GeneratorPrecompoundInterface();
auto theModel = new G4TheoFSGenerator();
theModel->SetTransport(theCascade);
theModel->SetHighEnergyGenerator(theStringModel);
G4HadronicParameters* param = G4HadronicParameters::Instance();
// Bertini cascade for moderate energies
auto cascade = new G4CascadeInterface();
G4CascadeInterface* cascade = new G4CascadeInterface;
// added low-energy model LEND disabled
// added low-energy gamma nuclear model LEND disabled
if (fGNLowEnergyLimit > 0.0) {
G4LowEGammaNuclearModel* lemod = new G4LowEGammaNuclearModel();
lemod->SetMaxEnergy(fGNLowEnergyLimit);
@@ -513,39 +330,26 @@ void G4EmExtraPhysics::ConstructGammaElectroNuclear()
theModel->SetMaxEnergy(param->GetMaxEnergy());
gnuc->RegisterMe(theModel);
G4GammaGeneralProcess* gproc =
(G4GammaGeneralProcess*)emManager->GetGammaGeneralProcess();
if(gproc != nullptr) {
auto gproc =
dynamic_cast<G4GammaGeneralProcess*>(emManager->GetGammaGeneralProcess());
// LEND may be activated if the general process is not activated
if (gproc != nullptr) {
gproc->AddHadProcess(gnuc);
} else {
// LEND may be activated if the general process is not activated
ph->RegisterProcess(gnuc, G4Gamma::Gamma());
if(gLENDActivated) { ConstructLENDGammaNuclear(cascade, gnuc); }
if (gLENDActivated) { ConstructLENDGammaNuclear(cascade, gnuc); }
}
if(eActivated) {
G4ElectronNuclearProcess* enuc = new G4ElectronNuclearProcess;
G4PositronNuclearProcess* pnuc = new G4PositronNuclearProcess;
G4ElectroVDNuclearModel* eModel = new G4ElectroVDNuclearModel;
if (eActivated) {
auto enuc = new G4ElectronNuclearProcess();
auto pnuc = new G4PositronNuclearProcess();
auto eModel = new G4ElectroVDNuclearModel();
enuc->RegisterMe(eModel);
pnuc->RegisterMe(eModel);
G4GammaGeneralProcess* eproc =
(G4GammaGeneralProcess*)emManager->GetElectronGeneralProcess();
if(eproc != nullptr) {
eproc->AddHadProcess(enuc);
} else {
ph->RegisterProcess(enuc, G4Electron::Electron());
}
G4GammaGeneralProcess* pproc =
(G4GammaGeneralProcess*)emManager->GetPositronGeneralProcess();
if(pproc != nullptr) {
pproc->AddHadProcess(pnuc);
} else {
ph->RegisterProcess(pnuc, G4Positron::Positron());
}
ph->RegisterProcess(enuc, G4Electron::Electron());
ph->RegisterProcess(pnuc, G4Positron::Positron());
}
}
@@ -561,12 +365,10 @@ void G4EmExtraPhysics::ConstructLENDGammaNuclear(
}
cascade->SetMinEnergy(19.9*MeV);
G4LENDorBERTModel* theGammaReactionLowE =
new G4LENDorBERTModel( G4Gamma::Gamma() );
theGammaReactionLowE->DumpLENDTargetInfo(true);
G4LENDCombinedCrossSection* theGammaCrossSectionLowE =
new G4LENDCombinedCrossSection( G4Gamma::Gamma() );
theGammaReactionLowE->SetMaxEnergy(20*MeV);
gnuc->RegisterMe(theGammaReactionLowE);
gnuc->AddDataSet(theGammaCrossSectionLowE);
auto theLowE = new G4LENDorBERTModel( G4Gamma::Gamma() );
theLowE->DumpLENDTargetInfo(true);
theLowE->SetMaxEnergy(20*MeV);
gnuc->RegisterMe(theLowE);
auto theXSLowE = new G4LENDCombinedCrossSection( G4Gamma::Gamma() );
gnuc->AddDataSet(theXSLowE);
}
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4EmMessenger.cc
+33 -70
View File
@@ -40,22 +40,15 @@
#include "G4EmMessenger.hh"
#include "G4EmExtraPhysics.hh"
//A. Dotti (8Jun2013): This class does not need changes for MT
// Note that in general "physics" realated commands should not
// be executed by threads, but this is a special case. Actually the command
// executes a building of processes if it was not build before, thus we need
// all threads to process commands.
// The logic of thread-private objects is in G4EmExtraPhysics class
G4EmMessenger::G4EmMessenger(G4EmExtraPhysics* ab)
{
theB = ab;
aDir1 = new G4UIdirectory("/physics_lists/", false);
aDir1->SetGuidance("commands related to the physics simulation engine.");
aDir1->SetGuidance("commands for physics list configuration.");
// general stuff.
aDir2 = new G4UIdirectory("/physics_lists/em/", false);
aDir2->SetGuidance("tailoring the processes");
aDir2->SetGuidance("Extra EM processes configuration.");
// command for synchrotron radiation.
theSynch = new G4UIcmdWithABool("/physics_lists/em/SyncRadiation",this);
@@ -118,16 +111,6 @@ G4EmMessenger::G4EmMessenger(G4EmExtraPhysics* ab)
thePH->AvailableForStates(G4State_PreInit);
thePH->SetToBeBroadcasted(false);
theNu = new G4UIcmdWithABool("/physics_lists/em/NeutrinoActivation",this);
theNu->SetGuidance("Activation of neutrino processes");
theNu->AvailableForStates(G4State_PreInit);
theNu->SetToBeBroadcasted(false);
theNuETX = new G4UIcmdWithABool("/physics_lists/em/NuETotXscActivation",this);
theNuETX->SetGuidance("Activation of neutrino processes");
theNuETX->AvailableForStates(G4State_PreInit);
theNuETX->SetToBeBroadcasted(false);
theGMM1 = new G4UIcmdWithADouble("/physics_lists/em/GammaToMuonsFactor",this);
theGMM1->SetGuidance("Factor for gamma conversion to muon pair.");
theGMM1->AvailableForStates(G4State_PreInit);
@@ -143,32 +126,12 @@ G4EmMessenger::G4EmMessenger(G4EmExtraPhysics* ab)
thePH1->AvailableForStates(G4State_PreInit);
thePH1->SetToBeBroadcasted(false);
theNuEleCcBF = new G4UIcmdWithADouble("/physics_lists/em/NuEleCcBias",this);
theNuEleCcBF->SetGuidance("Neutrino-electron cc-current bias factor");
theNuEleCcBF->AvailableForStates(G4State_PreInit);
theNuEleCcBF->SetToBeBroadcasted(false);
theNuEleNcBF = new G4UIcmdWithADouble("/physics_lists/em/NuEleNcBias",this);
theNuEleNcBF->SetGuidance("Neutrino-electron nc-current bias factor");
theNuEleNcBF->AvailableForStates(G4State_PreInit);
theNuEleNcBF->SetToBeBroadcasted(false);
theNuNucleusBF = new G4UIcmdWithADouble("/physics_lists/em/NuNucleusBias",this);
theNuNucleusBF->SetGuidance("Neutrino-nucleus bias factor");
theNuNucleusBF->AvailableForStates(G4State_PreInit);
theNuNucleusBF->SetToBeBroadcasted(false);
theGNlowe = new G4UIcmdWithADoubleAndUnit("/physics_lists/em/GammaNuclearLEModelLimit",this);
theGNlowe->SetGuidance("Upper energy limit for low-energy model");
theGNlowe->SetGuidance("Upper energy limit for low-energy gamma-nuclear model");
theGNlowe->SetParameterName("emin",true);
theGNlowe->SetUnitCategory("Energy");
theGNlowe->AvailableForStates(G4State_PreInit);
theGNlowe->SetToBeBroadcasted(false);
theNuDN = new G4UIcmdWithAString("/physics_lists/em/NuDetectorName",this);
theNuDN->SetGuidance("Set neutrino detector name");
theNuDN->AvailableForStates(G4State_PreInit);
theNuDN->SetToBeBroadcasted(false);
}
G4EmMessenger::~G4EmMessenger()
@@ -183,16 +146,10 @@ G4EmMessenger::~G4EmMessenger()
delete theMMM;
delete thePMM;
delete thePH;
delete theNu;
delete theNuETX;
delete theGMM1;
delete thePMM1;
delete thePH1;
delete theNuEleCcBF;
delete theNuEleNcBF;
delete theNuNucleusBF;
delete theNuDN;
delete theGNlowe;
delete theXS;
@@ -202,28 +159,34 @@ G4EmMessenger::~G4EmMessenger()
void G4EmMessenger::SetNewValue(G4UIcommand* aComm, G4String aS)
{
if(aComm==theSynch) theB->Synch(theSynch->GetNewBoolValue(aS));
if(aComm==theSynchAll) theB->SynchAll(theSynchAll->GetNewBoolValue(aS));
if(aComm==theGN) theB->GammaNuclear(theGN->GetNewBoolValue(aS));
if(aComm==theGLENDN) theB->LENDGammaNuclear(theGLENDN->GetNewBoolValue(aS));
if(aComm==theEN) theB->ElectroNuclear(theEN->GetNewBoolValue(aS));
if(aComm==theMUN) theB->MuonNuclear(theMUN->GetNewBoolValue(aS));
if(aComm==theGMM) theB->GammaToMuMu(theGMM->GetNewBoolValue(aS));
if(aComm==theMMM) theB->MuonToMuMu(theMMM->GetNewBoolValue(aS));
if(aComm==thePMM) theB->PositronToMuMu(thePMM->GetNewBoolValue(aS));
if(aComm==thePH) theB->PositronToHadrons(thePH->GetNewBoolValue(aS));
if(aComm==theNu) theB->NeutrinoActivated(theNu->GetNewBoolValue(aS));
if(aComm==theNuETX) theB->NuETotXscActivated(theNuETX->GetNewBoolValue(aS));
if(aComm==theXS) theB->SetUseGammaNuclearXS(theXS->GetNewBoolValue(aS));
if(aComm==theGMM1) theB->GammaToMuMuFactor(theGMM1->GetNewDoubleValue(aS));
if(aComm==thePMM1) theB->PositronToMuMuFactor(thePMM1->GetNewDoubleValue(aS));
if(aComm==thePH1) theB->PositronToHadronsFactor(thePH1->GetNewDoubleValue(aS));
if(aComm==theNuEleCcBF) theB->SetNuEleCcBias(theNuEleCcBF->GetNewDoubleValue(aS));
if(aComm==theNuEleNcBF) theB->SetNuEleNcBias(theNuEleNcBF->GetNewDoubleValue(aS));
if(aComm==theNuNucleusBF) theB->SetNuNucleusBias(theNuNucleusBF->GetNewDoubleValue(aS));
if(aComm==theGNlowe) theB->GammaNuclearLEModelLimit(theGNlowe->GetNewDoubleValue(aS));
if(aComm==theNuDN) theB->SetNuDetectorName(aS);
if (aComm==theSynch)
theB->Synch(theSynch->GetNewBoolValue(aS));
else if (aComm==theSynchAll)
theB->SynchAll(theSynchAll->GetNewBoolValue(aS));
else if (aComm==theGN)
theB->GammaNuclear(theGN->GetNewBoolValue(aS));
else if (aComm==theGLENDN)
theB->LENDGammaNuclear(theGLENDN->GetNewBoolValue(aS));
else if (aComm==theEN)
theB->ElectroNuclear(theEN->GetNewBoolValue(aS));
else if (aComm==theMUN)
theB->MuonNuclear(theMUN->GetNewBoolValue(aS));
else if (aComm==theGMM)
theB->GammaToMuMu(theGMM->GetNewBoolValue(aS));
else if (aComm==theMMM)
theB->MuonToMuMu(theMMM->GetNewBoolValue(aS));
else if (aComm==thePMM)
theB->PositronToMuMu(thePMM->GetNewBoolValue(aS));
else if (aComm==thePH)
theB->PositronToHadrons(thePH->GetNewBoolValue(aS));
else if (aComm==theXS)
theB->SetUseGammaNuclearXS(theXS->GetNewBoolValue(aS));
else if (aComm==theGMM1)
theB->GammaToMuMuFactor(theGMM1->GetNewDoubleValue(aS));
else if (aComm==thePMM1)
theB->PositronToMuMuFactor(thePMM1->GetNewDoubleValue(aS));
else if (aComm==thePH1)
theB->PositronToHadronsFactor(thePH1->GetNewDoubleValue(aS));
else if (aComm==theGNlowe)
theB->GammaNuclearLEModelLimit(theGNlowe->GetNewDoubleValue(aS));
}
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4LENDBertiniGammaElectroNuclearBuilder.cc
+15 -31
View File
@@ -45,47 +45,31 @@
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
#include "G4Electron.hh"
#include "G4Positron.hh"
#include "G4ProcessManager.hh"
G4LENDBertiniGammaElectroNuclearBuilder::G4LENDBertiniGammaElectroNuclearBuilder(G4bool eNucl) :
G4BertiniElectroNuclearBuilder( eNucl )
{
}
G4LENDBertiniGammaElectroNuclearBuilder::~G4LENDBertiniGammaElectroNuclearBuilder()
{
/*
DHW 13 Jan 2020 - fix double deletion error; these deletes are already done in the base class dtor
(Coverity bugs 101609 and 101727)
if ( wasActivated ) {
delete theFragmentation;
delete theStringDecay;
}
*/
}
{}
void G4LENDBertiniGammaElectroNuclearBuilder::Build()
{
//G4cout << "G4LENDBertiniGammaElectroNuclearBuilder::Build()" << G4endl;
//G4cout << "G4LENDBertiniGammaElectroNuclearBuilder::Build()" << G4endl;
base::Build();
G4BertiniElectroNuclearBuilder::Build();
if ( !G4FindDataDir("G4LENDDATA") ) {
G4String message = "\n Skipping activation of Low Energy Nuclear Data (LEND) model for gamma nuclear interactions.\n The LEND model needs data files and they are available from ftp://gdo-nuclear.ucllnl.org/GND_after2013/GND_v1.3.tar.gz.\n Please set the environment variable G4LENDDATA to point to the directory named v1.3 extracted from the archive file.\n";
G4Exception( "G4LENDBertiniGammaElectroNuclearBuilder::Build()"
if ( !G4FindDataDir("G4LENDDATA") ) {
G4String message = "\n Skipping activation of Low Energy Nuclear Data (LEND) model for gamma nuclear interactions.\n The LEND model needs data files and they are available from ftp://gdo-nuclear.ucllnl.org/GND_after2013/GND_v1.3.tar.gz.\n Please set the environment variable G4LENDDATA to point to the directory named v1.3 extracted from the archive file.\n";
G4Exception( "G4LENDBertiniGammaElectroNuclearBuilder::Build()"
, "G4LENDBertiniGammaElectroNuclearBuilder001"
, JustWarning , message);
return;
}
theGammaReaction->SetMinEnergy(20*MeV);
G4LENDorBERTModel* theGammaReactionLowE = new G4LENDorBERTModel( G4Gamma::Gamma() );
theGammaReactionLowE->DumpLENDTargetInfo(true);
G4LENDCombinedCrossSection* theGammaCrossSectionLowE = new G4LENDCombinedCrossSection( G4Gamma::Gamma() );
theGammaReactionLowE->SetMaxEnergy(20*MeV);
thePhotoNuclearProcess->RegisterMe(theGammaReactionLowE);
thePhotoNuclearProcess->AddDataSet(theGammaCrossSectionLowE);
return;
}
theGammaReaction->SetMinEnergy(20*MeV);
G4LENDorBERTModel* theGammaReactionLowE = new G4LENDorBERTModel( G4Gamma::Gamma() );
theGammaReactionLowE->DumpLENDTargetInfo(true);
G4LENDCombinedCrossSection* theGammaCrossSectionLowE = new G4LENDCombinedCrossSection( G4Gamma::Gamma() );
theGammaReactionLowE->SetMaxEnergy(20*MeV);
thePhotoNuclearProcess->RegisterMe(theGammaReactionLowE);
thePhotoNuclearProcess->AddDataSet(theGammaCrossSectionLowE);
}
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4NeutrinoPhysics.cc
+267
View File
@@ -0,0 +1,267 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutrinoPhysics
//
// Author: 2023 V. Ivanchenko extracted from G4EmExtraPhysics
//
// Modified:
//
//
///////////////////////////////////////////////////////////////
#include "G4NeutrinoPhysics.hh"
#include "G4SystemOfUnits.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4Electron.hh"
#include "G4AntiNeutrinoE.hh"
#include "G4NeutrinoE.hh"
#include "G4AntiNeutrinoMu.hh"
#include "G4NeutrinoMu.hh"
#include "G4AntiNeutrinoTau.hh"
#include "G4NeutrinoTau.hh"
#include "G4NeutrinoElectronProcess.hh"
#include "G4NeutrinoElectronTotXsc.hh"
#include "G4NeutrinoElectronCcModel.hh"
#include "G4NeutrinoElectronNcModel.hh"
#include "G4MuNeutrinoNucleusProcess.hh"
#include "G4TauNeutrinoNucleusProcess.hh"
#include "G4ElNeutrinoNucleusProcess.hh"
#include "G4NuVacOscProcess.hh"
#include "G4MuNeutrinoNucleusTotXsc.hh"
#include "G4TauNeutrinoNucleusTotXsc.hh"
#include "G4ElNeutrinoNucleusTotXsc.hh"
#include "G4NuMuNucleusCcModel.hh"
#include "G4NuMuNucleusNcModel.hh"
#include "G4ANuMuNucleusCcModel.hh"
#include "G4ANuMuNucleusNcModel.hh"
#include "G4NuTauNucleusCcModel.hh"
#include "G4NuTauNucleusNcModel.hh"
#include "G4ANuTauNucleusCcModel.hh"
#include "G4ANuTauNucleusNcModel.hh"
#include "G4NuElNucleusCcModel.hh"
#include "G4NuElNucleusNcModel.hh"
#include "G4ANuElNucleusCcModel.hh"
#include "G4ANuElNucleusNcModel.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4NeutrinoPhysics);
//////////////////////////////////////
G4NeutrinoPhysics::G4NeutrinoPhysics(G4int ver):
G4VPhysicsConstructor("NeutrinoPhys"),
verbose(ver)
{
theMessenger = new G4NeutrinoPhysicsMessenger(this);
if(verbose > 1) G4cout << "### G4NeutrinoPhysics" << G4endl;
}
G4NeutrinoPhysics::~G4NeutrinoPhysics()
{
delete theMessenger;
}
void G4NeutrinoPhysics::NuETotXscActivated(G4bool val)
{
fNuETotXscActivated = val;
}
void G4NeutrinoPhysics::SetNuOscillation(G4bool val)
{
fNuOscillation = val;
}
void G4NeutrinoPhysics::SetNuEleCcBias(G4double bf)
{
if(bf > 0.0) fNuEleCcBias = bf;
}
void G4NeutrinoPhysics::SetNuEleNcBias(G4double bf)
{
if(bf > 0.0) fNuEleNcBias = bf;
}
void G4NeutrinoPhysics::SetNuNucleusBias(G4double bf)
{
if(bf > 0.0) fNuNucleusBias = bf;
}
void G4NeutrinoPhysics::SetNuOscDistanceBias(G4double bf)
{
if(bf > 0.0) fNuOscDistanceBias = bf;
}
void G4NeutrinoPhysics::SetNuDetectorName(const G4String& dn)
{
fNuDetectorName = dn;
}
void G4NeutrinoPhysics::SetNuOscDistanceName(const G4String& dn)
{
fNuOscDistanceName = dn;
}
/////////////////////////////////////////////////
void G4NeutrinoPhysics::ConstructParticle()
{
G4Electron::Electron();
G4AntiNeutrinoE::AntiNeutrinoE();
G4NeutrinoE::NeutrinoE();
G4AntiNeutrinoMu::AntiNeutrinoMu();
G4NeutrinoMu::NeutrinoMu();
G4AntiNeutrinoTau::AntiNeutrinoTau();
G4NeutrinoTau::NeutrinoTau();
}
void G4NeutrinoPhysics::ConstructProcess()
{
const G4ParticleDefinition* p[6] = {
G4AntiNeutrinoE::AntiNeutrinoE(),
G4NeutrinoE::NeutrinoE(),
G4AntiNeutrinoMu::AntiNeutrinoMu(),
G4NeutrinoMu::NeutrinoMu(),
G4AntiNeutrinoTau::AntiNeutrinoTau(),
G4NeutrinoTau::NeutrinoTau()
};
// neutrino vacuum oscillation process
if (fNuOscillation) {
auto theNuVacOscProcess = new G4NuVacOscProcess(fNuOscDistanceName);
theNuVacOscProcess->SetBiasingFactor(fNuOscDistanceBias);
for (G4int i=0; i<6; ++i) {
p[i]->GetProcessManager()->AddDiscreteProcess(theNuVacOscProcess);
}
}
// neutrino-electron process
auto theNuEleProcess = new G4NeutrinoElectronProcess(fNuDetectorName);
G4NeutrinoElectronTotXsc* theNuEleTotXsc = new G4NeutrinoElectronTotXsc();
if (fNuETotXscActivated) {
G4double bftot = std::max(fNuEleCcBias, fNuEleNcBias);
theNuEleProcess->SetBiasingFactor(bftot);
}
else {
theNuEleProcess->SetBiasingFactors(fNuEleCcBias, fNuEleNcBias);
theNuEleTotXsc->SetBiasingFactors(fNuEleCcBias, fNuEleNcBias);
}
theNuEleProcess->AddDataSet(theNuEleTotXsc);
G4NeutrinoElectronCcModel* ccModel = new G4NeutrinoElectronCcModel();
G4NeutrinoElectronNcModel* ncModel = new G4NeutrinoElectronNcModel();
theNuEleProcess->RegisterMe(ccModel);
theNuEleProcess->RegisterMe(ncModel);
for (G4int i=0; i<6; ++i) {
p[i]->GetProcessManager()->AddDiscreteProcess(theNuEleProcess);
}
// nu_mu nucleus interactions
auto theNuMuNucleusProcess = new G4MuNeutrinoNucleusProcess(fNuDetectorName);
auto theNuMuNucleusTotXsc = new G4MuNeutrinoNucleusTotXsc();
if (fNuETotXscActivated) {
theNuMuNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuMuNucleusProcess->AddDataSet(theNuMuNucleusTotXsc);
G4NuMuNucleusCcModel* numunuclcc = new G4NuMuNucleusCcModel();
G4NuMuNucleusNcModel* numunuclnc = new G4NuMuNucleusNcModel();
G4ANuMuNucleusCcModel* anumunuclcc = new G4ANuMuNucleusCcModel();
G4ANuMuNucleusNcModel* anumunuclnc = new G4ANuMuNucleusNcModel();
theNuMuNucleusProcess->RegisterMe(numunuclcc);
theNuMuNucleusProcess->RegisterMe(numunuclnc);
theNuMuNucleusProcess->RegisterMe(anumunuclcc);
theNuMuNucleusProcess->RegisterMe(anumunuclnc);
for (G4int i=2; i<=3; ++i) {
p[i]->GetProcessManager()->AddDiscreteProcess(theNuMuNucleusProcess);
}
// nu_tau nucleus interactions
auto theNuTauNucleusProcess = new G4TauNeutrinoNucleusProcess(fNuDetectorName);
auto theNuTauNucleusTotXsc = new G4TauNeutrinoNucleusTotXsc();
if(fNuETotXscActivated) {
theNuTauNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuTauNucleusProcess->AddDataSet(theNuTauNucleusTotXsc);
G4NuTauNucleusCcModel* nutaunuclcc = new G4NuTauNucleusCcModel();
G4NuTauNucleusNcModel* nutaunuclnc = new G4NuTauNucleusNcModel();
G4ANuTauNucleusCcModel* anutaunuclcc = new G4ANuTauNucleusCcModel();
G4ANuTauNucleusNcModel* anutaunuclnc = new G4ANuTauNucleusNcModel();
theNuTauNucleusProcess->RegisterMe(nutaunuclcc);
theNuTauNucleusProcess->RegisterMe(nutaunuclnc);
theNuTauNucleusProcess->RegisterMe(anutaunuclcc);
theNuTauNucleusProcess->RegisterMe(anutaunuclnc);
for (G4int i=4; i<=5; ++i) {
p[i]->GetProcessManager()->AddDiscreteProcess(theNuMuNucleusProcess);
}
// nu_e nucleus interactions
auto theNuElNucleusProcess = new G4ElNeutrinoNucleusProcess(fNuDetectorName);
auto theNuElNucleusTotXsc = new G4ElNeutrinoNucleusTotXsc();
if (fNuETotXscActivated) {
theNuElNucleusProcess->SetBiasingFactor(fNuNucleusBias);
}
theNuElNucleusProcess->AddDataSet(theNuElNucleusTotXsc);
G4NuElNucleusCcModel* nuelnuclcc = new G4NuElNucleusCcModel();
G4NuElNucleusNcModel* nuelnuclnc = new G4NuElNucleusNcModel();
G4ANuElNucleusCcModel* anuelnuclcc = new G4ANuElNucleusCcModel();
G4ANuElNucleusNcModel* anuelnuclnc = new G4ANuElNucleusNcModel();
theNuElNucleusProcess->RegisterMe(nuelnuclcc);
theNuElNucleusProcess->RegisterMe(nuelnuclnc);
theNuElNucleusProcess->RegisterMe(anuelnuclcc);
theNuElNucleusProcess->RegisterMe(anuelnuclnc);
for (G4int i=0; i<=1; ++i) {
p[i]->GetProcessManager()->AddDiscreteProcess(theNuElNucleusProcess);
}
}
source/physics_lists/constructors/gamma_lepto_nuclear/src/G4NeutrinoPhysicsMessenger.cc
+121
View File
@@ -0,0 +1,121 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4NeutrinoPhysicsMessenger
//
// Author: 2023 V. Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4NeutrinoPhysicsMessenger.hh"
#include "G4NeutrinoPhysics.hh"
G4NeutrinoPhysicsMessenger::G4NeutrinoPhysicsMessenger(G4NeutrinoPhysics* ab)
: theB(ab)
{
// general stuff.
aDir = new G4UIdirectory("/physics_lists/nu/", false);
aDir->SetGuidance("tailoring the neutrino processes.");
theNu = new G4UIcmdWithABool("/physics_lists/nu/NeutrinoActivation",this);
theNu->SetGuidance("Activation of neutrino-nucleus processes");
theNu->AvailableForStates(G4State_PreInit);
theNu->SetToBeBroadcasted(false);
theNuETX = new G4UIcmdWithABool("/physics_lists/nu/NuETotXscActivation",this);
theNuETX->SetGuidance("Activation of neutrino-electron processes");
theNuETX->AvailableForStates(G4State_PreInit);
theNuETX->SetToBeBroadcasted(false);
theNuEleCcBF = new G4UIcmdWithADouble("/physics_lists/nu/NuEleCcBias",this);
theNuEleCcBF->SetGuidance("Neutrino-electron charge current bias factor");
theNuEleCcBF->AvailableForStates(G4State_PreInit);
theNuEleCcBF->SetToBeBroadcasted(false);
theNuEleNcBF = new G4UIcmdWithADouble("/physics_lists/nu/NuEleNcBias",this);
theNuEleNcBF->SetGuidance("Neutrino-electron neutral current bias factor");
theNuEleNcBF->AvailableForStates(G4State_PreInit);
theNuEleNcBF->SetToBeBroadcasted(false);
theNuNucleusBF = new G4UIcmdWithADouble("/physics_lists/nu/NuNucleusBias",this);
theNuNucleusBF->SetGuidance("Neutrino-nucleus cross section bias factor");
theNuNucleusBF->AvailableForStates(G4State_PreInit);
theNuNucleusBF->SetToBeBroadcasted(false);
theNuOscDistanceBF = new G4UIcmdWithADouble("/physics_lists/nu/NuOscDistanceBias",this);
theNuOscDistanceBF->SetGuidance("Neutrino-oscillation distance bias factor");
theNuOscDistanceBF->AvailableForStates(G4State_PreInit);
theNuOscDistanceBF->SetToBeBroadcasted(false);
theNuDN = new G4UIcmdWithAString("/physics_lists/nu/NuDetectorName",this);
theNuDN->SetGuidance("Set neutrino detector name");
theNuDN->AvailableForStates(G4State_PreInit);
theNuDN->SetToBeBroadcasted(false);
theNuODN = new G4UIcmdWithAString("/physics_lists/nu/NuOscDistanceName",this);
theNuODN->SetGuidance("Set neutrino oscillation distance region name");
theNuODN->AvailableForStates(G4State_PreInit);
theNuODN->SetToBeBroadcasted(false);
}
G4NeutrinoPhysicsMessenger::~G4NeutrinoPhysicsMessenger()
{
delete theNu;
delete theNuETX;
delete theNuEleCcBF;
delete theNuEleNcBF;
delete theNuNucleusBF;
delete theNuOscDistanceBF;
delete theNuDN;
delete theNuODN;
delete aDir;
}
void G4NeutrinoPhysicsMessenger::SetNewValue(G4UIcommand* aComm, G4String aS)
{
if (aComm==theNuETX)
theB->NuETotXscActivated(theNuETX->GetNewBoolValue(aS));
else if (aComm==theNuEleCcBF)
theB->SetNuEleCcBias(theNuEleCcBF->GetNewDoubleValue(aS));
else if (aComm==theNuEleNcBF)
theB->SetNuEleNcBias(theNuEleNcBF->GetNewDoubleValue(aS));
else if (aComm==theNuNucleusBF)
theB->SetNuNucleusBias(theNuNucleusBF->GetNewDoubleValue(aS));
else if (aComm==theNuOscDistanceBF)
theB->SetNuOscDistanceBias(theNuOscDistanceBF->GetNewDoubleValue(aS));
else if(aComm==theNuDN)
theB->SetNuDetectorName(aS);
else if(aComm==theNuODN)
theB->SetNuOscDistanceName(aS);
}
source/physics_lists/constructors/hadron_elastic/History
+25
View File
@@ -6,6 +6,31 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-10-31 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-06)
- G4ChargeExchangePhysics, G4ChargeExchangeMessenger - added UI commands
## 2023-10-25 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-05)
- G4ChargeExchangePhysics - added Set method for the factor multiplying
the cross section (NA64 request).
## 2023-10-23 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-04)
- G4ChargeExchangePhysics - added low energy limit to cross section of the
charge exchange process allowing use of it on top of any physics without
any cross section correction
## 2023-10-15 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-03)
- G4HadronElasticPhysics, G4HadronElasticPhysicsXS, G4HadronElasticPhysicsHP,
G4HadronElasticPhysicsPHP - more accurate instantiation of models, cross
sections, and the neutron general process
- G4HadronElasticPhysicsVI - used alternative HP model and cross section
## 2023-08-25 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-02)
- G4ChargeExchangePhysics - do not use G4PhysicsListHelper, because
charge exchange process is an addition to the main hadron process
## 2023-07-21 Vladimir Ivanchenko (phys-ctor-helastic-V11-01-01)
- G4ChargeExchangePhysics - updated constructor according to a new conception
## 2023-04-13 Alberto Ribon (phys-ctor-helastic-V11-01-00)
- Created new class G4HadronElasticPhysicsHPT, which inherits from
G4HadronElasticPhysicsHP and activates the special treatment of elastic
source/physics_lists/constructors/hadron_elastic/include/G4ChargeExchangeMessenger.hh
+69
View File
@@ -0,0 +1,69 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4ChargeExchangeMessenger
//
// Author: 2023 V. Ivanchenko created using G4EmMessenger
//
// Modified:
//
//----------------------------------------------------------------------------
//
#ifndef G4ChargeExchangeMessenger_h
#define G4ChargeExchangeMessenger_h 1
#include "G4UImessenger.hh"
#include "G4UIdirectory.hh"
#include "G4UIcmdWithADouble.hh"
#include "G4UIcmdWithADoubleAndUnit.hh"
class G4ChargeExchangePhysics;
class G4ChargeExchangeMessenger: public G4UImessenger
{
public:
explicit G4ChargeExchangeMessenger(G4ChargeExchangePhysics* af);
~G4ChargeExchangeMessenger() override;
void SetNewValue(G4UIcommand* aComm, G4String aS) override;
G4ChargeExchangeMessenger& operator=
(const G4ChargeExchangeMessenger& right) = delete;
G4ChargeExchangeMessenger(const G4ChargeExchangeMessenger&) = delete;
private:
G4ChargeExchangePhysics* theB;
G4UIcmdWithADouble* fCmd;
G4UIcmdWithADoubleAndUnit* lCmd;
G4UIdirectory* aDir;
};
#endif
source/physics_lists/constructors/hadron_elastic/include/G4ChargeExchangePhysics.hh
+13 -1
View File
@@ -45,12 +45,24 @@ class G4ChargeExchangePhysics : public G4VPhysicsConstructor
{
public:
explicit G4ChargeExchangePhysics(G4int ver = 1);
virtual ~G4ChargeExchangePhysics();
~G4ChargeExchangePhysics() override = default;
void ConstructParticle() override;
void ConstructProcess() override;
void SetLowEnergyLimit(G4double val) { fLowEnergyLimit = val; }
void SetCrossSectionFactor(G4double val) { fXSFactor = val; }
G4ChargeExchangePhysics& operator=
(const G4ChargeExchangePhysics& right) = delete;
G4ChargeExchangePhysics(const G4ChargeExchangePhysics&) = delete;
private:
G4double fLowEnergyLimit;
G4double fXSFactor{1.0};
};
source/physics_lists/constructors/hadron_elastic/include/G4HadronElasticPhysics.hh
+1 -1
View File
@@ -58,7 +58,7 @@ public:
explicit G4HadronElasticPhysics(G4int ver = 1,
const G4String& nam = "hElasticWEL_CHIPS_XS");
virtual ~G4HadronElasticPhysics();
~G4HadronElasticPhysics() override = default;
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
source/physics_lists/constructors/hadron_elastic/include/G4HadronElasticPhysicsHP.hh
+1 -1
View File
@@ -46,7 +46,7 @@ public:
explicit G4HadronElasticPhysicsHP(G4int ver = 1);
virtual ~G4HadronElasticPhysicsHP();
~G4HadronElasticPhysicsHP() override = default;
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
source/physics_lists/constructors/hadron_elastic/include/G4HadronElasticPhysicsPHP.hh
+3 -2
View File
@@ -29,7 +29,8 @@
//
// Author: 2013, P. Arce
//
// Modified:
// Modified: 12.10.2023 V.Ivanchenko use this class to define alternative
// HP physics
//
//----------------------------------------------------------------------------
//
@@ -45,7 +46,7 @@ public:
explicit G4HadronElasticPhysicsPHP(G4int ver = 1);
virtual ~G4HadronElasticPhysicsPHP();
~G4HadronElasticPhysicsPHP() override = default;
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
source/physics_lists/constructors/hadron_elastic/include/G4HadronElasticPhysicsVI.hh
+57
View File
@@ -0,0 +1,57 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//---------------------------------------------------------------------------
//
// ClassName: G4HadronElasticPhysicsVI
//
// Author: 17.10.2023 V.Ivanchenko
//
//----------------------------------------------------------------------------
//
#ifndef G4HadronElasticPhysicsVI_h
#define G4HadronElasticPhysicsVI_h 1
#include "G4HadronElasticPhysics.hh"
class G4HadronElasticPhysicsVI : public G4HadronElasticPhysics
{
public:
explicit G4HadronElasticPhysicsVI(G4int ver = 1);
~G4HadronElasticPhysicsVI() override = default;
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
// registered to the process manager of each particle type
void ConstructProcess() final;
G4HadronElasticPhysicsVI(const G4HadronElasticPhysicsVI&) = delete;
G4HadronElasticPhysicsVI& operator=(const G4HadronElasticPhysicsVI&) = delete;
};
#endif
source/physics_lists/constructors/hadron_elastic/include/G4HadronElasticPhysicsXS.hh
+1 -6
View File
@@ -46,12 +46,7 @@ public:
explicit G4HadronElasticPhysicsXS(G4int ver = 1);
virtual ~G4HadronElasticPhysicsXS();
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
// registered to the process manager of each particle type
void ConstructProcess() final;
~G4HadronElasticPhysicsXS() override = default;
G4HadronElasticPhysicsXS(G4HadronElasticPhysicsXS &) = delete;
G4HadronElasticPhysicsXS & operator=(const G4HadronElasticPhysicsXS &right) = delete;
source/physics_lists/constructors/hadron_elastic/sources.cmake
+6
View File
@@ -3,6 +3,7 @@
# Define the Geant4 Module.
geant4_add_module(G4phys_ctor_helastic
PUBLIC_HEADERS
G4ChargeExchangeMessenger.hh
G4ChargeExchangePhysics.hh
G4HadronDElasticPhysics.hh
G4HadronElasticPhysics.hh
@@ -13,8 +14,10 @@ geant4_add_module(G4phys_ctor_helastic
G4HadronHElasticPhysics.hh
G4IonElasticPhysics.hh
G4HadronElasticPhysicsPHP.hh
G4HadronElasticPhysicsVI.hh
G4ThermalNeutrons.hh
SOURCES
G4ChargeExchangeMessenger.cc
G4ChargeExchangePhysics.cc
G4HadronDElasticPhysics.cc
G4HadronElasticPhysics.cc
@@ -25,6 +28,7 @@ geant4_add_module(G4phys_ctor_helastic
G4HadronHElasticPhysics.cc
G4IonElasticPhysics.cc
G4HadronElasticPhysicsPHP.cc
G4HadronElasticPhysicsVI.cc
G4ThermalNeutrons.cc)
geant4_module_link_libraries(G4phys_ctor_helastic
@@ -32,6 +36,7 @@ geant4_module_link_libraries(G4phys_ctor_helastic
G4globman
G4hadronic_coherent_elastic
G4hadronic_mgt
G4intercoms
G4phys_ctor_hinelastic
G4run
PRIVATE
@@ -48,4 +53,5 @@ geant4_module_link_libraries(G4phys_ctor_helastic
G4phys_ctor_factory
G4physlist_util
G4procman
G4shortlived
)
source/physics_lists/constructors/hadron_elastic/src/G4ChargeExchangeMessenger.cc
+74
View File
@@ -0,0 +1,74 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4ChargeExchangeMessenger
//
// Author: 2023 V. Ivanchenko
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4ChargeExchangeMessenger.hh"
#include "G4ChargeExchangePhysics.hh"
G4ChargeExchangeMessenger::G4ChargeExchangeMessenger(G4ChargeExchangePhysics* a)
: theB(a)
{
// general stuff.
aDir = new G4UIdirectory("/physics_lists/cex/", false);
aDir->SetGuidance("tailoring the hadronic charge exchange processes.");
fCmd = new G4UIcmdWithADouble("/physics_lists/cex/BiasFactor",this);
fCmd->SetGuidance("Charge exchange cross section factor");
fCmd->AvailableForStates(G4State_PreInit);
fCmd->SetToBeBroadcasted(false);
lCmd = new G4UIcmdWithADoubleAndUnit("/process/cex/LowEnergyLimit",this);
lCmd->SetGuidance("Low-energy energy limit for charge exchange process");
lCmd->SetParameterName("cexLowE",true);
lCmd->SetUnitCategory("Energy");
lCmd->AvailableForStates(G4State_PreInit);
lCmd->SetToBeBroadcasted(false);
}
G4ChargeExchangeMessenger::~G4ChargeExchangeMessenger()
{
delete fCmd;
delete lCmd;
delete aDir;
}
void G4ChargeExchangeMessenger::SetNewValue(G4UIcommand* aComm, G4String aS)
{
if (aComm == fCmd)
theB->SetCrossSectionFactor(fCmd->GetNewDoubleValue(aS));
else if (aComm == lCmd)
theB->SetLowEnergyLimit(lCmd->GetNewDoubleValue(aS));
}
source/physics_lists/constructors/hadron_elastic/src/G4ChargeExchangePhysics.cc
+68 -46
View File
@@ -37,20 +37,24 @@
#include "G4ChargeExchangePhysics.hh"
#include "G4ChargeExchangeProcess.hh"
#include "G4ChargeExchangeXS.hh"
#include "G4ChargeExchange.hh"
#include "G4ParticleDefinition.hh"
#include "G4PhysicsListHelper.hh"
#include "G4ProcessManager.hh"
#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4Neutron.hh"
#include "G4BGGPionElasticXS.hh"
#include "G4BGGNucleonElasticXS.hh"
#include "G4NeutronElasticXS.hh"
#include "G4ShortLivedConstructor.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4KaonPlus.hh"
#include "G4KaonMinus.hh"
#include "G4KaonZeroLong.hh"
#include "G4HadronicParameters.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4SystemOfUnits.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -58,65 +62,83 @@
G4_DECLARE_PHYSCONSTR_FACTORY(G4ChargeExchangePhysics);
G4ChargeExchangePhysics::G4ChargeExchangePhysics(G4int ver)
: G4VPhysicsConstructor("chargeExchange")
: G4VPhysicsConstructor("chargeExchange"),
fLowEnergyLimit(12*CLHEP::GeV)
{
// because it is an addition, the type of this constructor is 0
G4HadronicParameters::Instance()->SetVerboseLevel(ver);
if(ver > 1) G4cout << "### ChargeExchangePhysics" << G4endl;
if (ver > 1) {
G4cout << "### ChargeExchangePhysics above "
<< fLowEnergyLimit/CLHEP::GeV << " GeV." << G4endl;
}
}
G4ChargeExchangePhysics::~G4ChargeExchangePhysics()
{}
void G4ChargeExchangePhysics::ConstructParticle()
{
// G4cout << "G4ChargeExchangePhysics::ConstructParticle" << G4endl;
G4MesonConstructor pMesonConstructor;
pMesonConstructor.ConstructParticle();
G4BaryonConstructor pBaryonConstructor;
pBaryonConstructor.ConstructParticle();
G4ShortLivedConstructor pShortLivedConstructor;
pShortLivedConstructor.ConstructParticle();
}
void G4ChargeExchangePhysics::ConstructProcess()
{
G4ChargeExchange* model = new G4ChargeExchange();
auto xs = new G4ChargeExchangeXS();
xs->SetEnergyLimit(fLowEnergyLimit);
xs->SetCrossSectionFactor(fXSFactor);
if(G4HadronicParameters::Instance()->GetVerboseLevel() > 1) {
auto model = new G4ChargeExchange(xs);
if (G4HadronicParameters::Instance()->GetVerboseLevel() > 1) {
G4cout << "### ChargeExchangePhysics Construct Processes with the model <"
<< model->GetModelName() << ">" << G4endl;
<< model->GetModelName() << "> and x-section <"
<< xs->GetName() << "> XSFactor=" << fXSFactor
<< G4endl;
}
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
while( (*myParticleIterator)() )
{
G4ParticleDefinition* particle = myParticleIterator->value();
if( particle == G4Neutron::Definition() ||
particle == G4PionMinus::Definition() ||
particle == G4PionPlus::Definition() ||
particle == G4Proton::Definition()
) {
G4ProcessManager* pmanager = particle->GetProcessManager();
G4ChargeExchangeProcess* p = new G4ChargeExchangeProcess();
p->RegisterMe(model);
if( particle == G4PionMinus::Definition() || particle == G4PionPlus::Definition() ) {
p->AddDataSet( new G4BGGPionElasticXS( particle ) );
} else if( particle == G4Proton::Definition() ) {
p->AddDataSet( new G4BGGNucleonElasticXS( particle ) );
} else if( particle == G4Neutron::Definition() ) {
p->AddDataSet( new G4NeutronElasticXS );
}
pmanager->AddDiscreteProcess(p);
// pi-
G4ParticleDefinition* part = G4PionMinus::PionMinus();
auto proc =
new G4HadronInelasticProcess(part->GetParticleName()+"ChargeEx", part);
proc->AddDataSet( xs );
proc->RegisterMe( model );
G4ProcessManager* pman = part->GetProcessManager();
pman->AddDiscreteProcess(proc);
if(G4HadronicParameters::Instance()->GetVerboseLevel() > 1)
G4cout << "### ChargeExchangePhysics added for "
<< particle->GetParticleName() << G4endl;
}
}
// pi+
part = G4PionPlus::PionPlus();
proc = new G4HadronInelasticProcess(part->GetParticleName()+"ChargeEx", part);
proc->AddDataSet( xs );
proc->RegisterMe( model );
pman = part->GetProcessManager();
pman->AddDiscreteProcess(proc);
// kaon-
part = G4KaonMinus::KaonMinus();
proc = new G4HadronInelasticProcess(part->GetParticleName()+"ChargeEx", part);
proc->AddDataSet( xs );
proc->RegisterMe( model );
pman = part->GetProcessManager();
pman->AddDiscreteProcess(proc);
// kaon+
part = G4KaonPlus::KaonPlus();
proc = new G4HadronInelasticProcess(part->GetParticleName()+"ChargeEx", part);
proc->AddDataSet( xs );
proc->RegisterMe( model );
pman = part->GetProcessManager();
pman->AddDiscreteProcess(proc);
// KL
part = G4KaonZeroLong::KaonZeroLong();
proc = new G4HadronInelasticProcess(part->GetParticleName()+"ChargeEx", part);
proc->AddDataSet( xs );
proc->RegisterMe( model );
pman = part->GetProcessManager();
pman->AddDiscreteProcess(proc);
}
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysics.cc
+17 -13
View File
@@ -87,12 +87,8 @@ G4HadronElasticPhysics::G4HadronElasticPhysics(G4int ver, const G4String& nam)
SetPhysicsType(bHadronElastic);
}
G4HadronElasticPhysics::~G4HadronElasticPhysics()
{}
void G4HadronElasticPhysics::ConstructParticle()
{
// G4cout << "G4HadronElasticPhysics::ConstructParticle" << G4endl;
G4MesonConstructor pMesonConstructor;
pMesonConstructor.ConstructParticle();
@@ -113,7 +109,7 @@ void G4HadronElasticPhysics::ConstructProcess()
const G4double elimitAntiNuc = 100.*MeV;
const G4double delta = 0.1*MeV;
G4double emax = std::max(param->GetMaxEnergy(), elimitAntiNuc+delta);
if(param->GetVerboseLevel() > 1) {
if ( param->GetVerboseLevel() > 1 ) {
G4cout << "### HadronElasticPhysics::ConstructProcess: "
<< "Elimit for for anti-neuclei " << elimitAntiNuc/CLHEP::GeV << " GeV"
<< " for all hadrons Emax(GeV)= " << emax/CLHEP::GeV
@@ -140,7 +136,7 @@ void G4HadronElasticPhysics::ConstructProcess()
G4HadronElasticProcess* hel = new G4HadronElasticProcess();
hel->AddDataSet(new G4BGGNucleonElasticXS(particle));
hel->RegisterMe(new G4ChipsElasticModel());
if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
if ( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
ph->RegisterProcess(hel, particle);
// n
@@ -153,7 +149,7 @@ void G4HadronElasticPhysics::ConstructProcess()
hel = new G4HadronElasticProcess();
hel->AddDataSet(new G4BGGPionElasticXS(particle));
hel->RegisterMe(he);
if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
if ( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
ph->RegisterProcess(hel, particle);
// pi-
@@ -161,14 +157,14 @@ void G4HadronElasticPhysics::ConstructProcess()
hel = new G4HadronElasticProcess();
hel->AddDataSet(new G4BGGPionElasticXS(particle));
hel->RegisterMe(he);
if( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
if ( useFactorXS ) hel->MultiplyCrossSectionBy( param->XSFactorPionElastic() );
ph->RegisterProcess(hel, particle);
// kaons
G4HadronicBuilder::BuildElastic( G4HadParticles::GetKaons() );
// d, t, He3, alpha
for( auto & pdg : G4HadParticles::GetLightIons() ) {
for ( auto & pdg : G4HadParticles::GetLightIons() ) {
particle = table->FindParticle( pdg );
if ( particle == nullptr ) { continue; }
@@ -233,9 +229,17 @@ G4HadronElasticPhysics::GetElasticModel(const G4ParticleDefinition* part) const
{
G4HadronElastic* mod = nullptr;
G4HadronicProcess* hel = GetElasticProcess(part);
if(hel) {
std::vector<G4HadronicInteraction*>& hi = hel->GetHadronicInteractionList();
if( !hi.empty() ) { mod = static_cast<G4HadronElastic*>(hi[0]); }
if ( nullptr != hel ) {
const std::vector<G4HadronicInteraction*>& hi = hel->GetHadronicInteractionList();
if ( !hi.empty() ) {
for (auto const & p : hi) {
auto ptr = dynamic_cast<G4HadronElastic*>(p);
if ( nullptr != ptr ) {
mod = ptr;
break;
}
}
}
}
return mod;
}
@@ -254,7 +258,7 @@ void G4HadronElasticPhysics::AddXSection(const G4ParticleDefinition* part,
G4VCrossSectionDataSet* cross) const
{
G4HadronicProcess* hel = GetElasticProcess(part);
if(hel) { hel->AddDataSet(cross); }
if ( nullptr != hel ) { hel->AddDataSet(cross); }
}
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysicsHP.cc
+7 -7
View File
@@ -55,15 +55,15 @@ G4_DECLARE_PHYSCONSTR_FACTORY(G4HadronElasticPhysicsHP);
G4HadronElasticPhysicsHP::G4HadronElasticPhysicsHP(G4int ver)
: G4HadronElasticPhysics(ver, "hElasticWEL_CHIPS_HP")
{
if(ver > 1) {
if ( ver > 1 ) {
G4cout << "### G4HadronElasticPhysicsHP: " << GetPhysicsName()
<< G4endl;
}
auto param = G4HadronicParameters::Instance();
// HP is inconsistent with the neutron general process
param->SetEnableNeutronGeneralProcess(false);
}
G4HadronElasticPhysicsHP::~G4HadronElasticPhysicsHP()
{}
void G4HadronElasticPhysicsHP::ConstructProcess()
{
G4HadronElasticPhysics::ConstructProcess();
@@ -71,13 +71,13 @@ void G4HadronElasticPhysicsHP::ConstructProcess()
const G4ParticleDefinition* neutron = G4Neutron::Neutron();
G4HadronElastic* he = GetElasticModel(neutron);
G4HadronicProcess* hel = GetElasticProcess(neutron);
if(he && hel) {
he->SetMinEnergy(19.5*MeV);
if ( nullptr != he && nullptr != hel ) {
he->SetMinEnergy(19.5*CLHEP::MeV);
hel->RegisterMe(new G4ParticleHPElastic());
hel->AddDataSet(new G4ParticleHPElasticData());
}
if(G4HadronicParameters::Instance()->GetVerboseLevel() > 1) {
if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 1 ) {
G4cout << "### HadronElasticPhysicsHP is constructed "
<< G4endl;
}
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysicsPHP.cc
+25 -12
View File
@@ -29,18 +29,23 @@
//
// Author: 2012, P. Arce
//
// Modified: 12.10.2023 V.Ivanchenko added usage of alternative neutron
// HP model and cross section
//
//----------------------------------------------------------------------------
//
// particle HP model for n with E < 20 MeV
// neutron HP model for E < 20 MeV
#include "G4HadronElasticPhysicsPHP.hh"
#include "G4Neutron.hh"
#include "G4HadronicProcess.hh"
#include "G4ProcessManager.hh"
#include "G4HadronElastic.hh"
#include "G4ParticleHPElastic.hh"
#include "G4ParticleHPElasticData.hh"
#include "G4SystemOfUnits.hh"
#include "G4HadronicParameters.hh"
#include "G4PhysListUtil.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -55,26 +60,34 @@ G4HadronElasticPhysicsPHP::G4HadronElasticPhysicsPHP(G4int ver)
G4cout << "### G4HadronElasticPhysicsPHP: " << GetPhysicsName()
<< G4endl;
}
auto param = G4HadronicParameters::Instance();
// HP is inconsistent with the neutron general process
param->SetEnableNeutronGeneralProcess(false);
}
G4HadronElasticPhysicsPHP::~G4HadronElasticPhysicsPHP()
{}
void G4HadronElasticPhysicsPHP::ConstructProcess()
{
G4HadronElasticPhysics::ConstructProcess();
const G4ParticleDefinition* neutron = G4Neutron::Neutron();
G4HadronElastic* he = GetElasticModel(neutron);
G4HadronicProcess* hel = GetElasticProcess(neutron);
if(he && hel) {
he->SetMinEnergy(19.5*MeV);
hel->RegisterMe(new G4ParticleHPElastic());
hel->AddDataSet(new G4ParticleHPElasticData());
G4HadronicProcess* hel = G4PhysListUtil::FindElasticProcess( neutron );
if ( nullptr == hel ) {
hel = new G4HadronicProcess();
neutron->GetProcessManager()->AddDiscreteProcess(hel);
} else {
G4HadronElastic* he = GetElasticModel(neutron);
he->SetMinEnergy(19.5*CLHEP::MeV);
}
// apply alternative cross section
hel->AddDataSet( new G4ParticleHPElasticData() );
if(G4HadronicParameters::Instance()->GetVerboseLevel() > 1) {
G4cout << "### HadronElasticPhysicsHP is constructed "
// add HP elastic
auto he = new G4ParticleHPElastic();
he->SetMaxEnergy(20*CLHEP::MeV);
hel->RegisterMe( he );
if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 1 ) {
G4cout << "### HadronElasticPhysicsPHP is constructed "
<< G4endl;
}
}
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysicsVI.cc
+93
View File
@@ -0,0 +1,93 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//---------------------------------------------------------------------------
//
// ClassName: G4HadronElasticPhysicsVI
//
// Author: 17.10.2023 V.Ivanchenko
//
//----------------------------------------------------------------------------
//
// neutron HP model for E < 20 MeV
#include "G4HadronElasticPhysicsVI.hh"
#include "G4Neutron.hh"
#include "G4HadronicProcess.hh"
#include "G4ProcessManager.hh"
#include "G4HadronElastic.hh"
#include "G4NeutronHPElasticVI.hh"
#include "G4ParticleHPElastic.hh"
#include "G4NeutronHPElasticXS.hh"
#include "G4SystemOfUnits.hh"
#include "G4HadronicParameters.hh"
#include "G4PhysListUtil.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4HadronElasticPhysicsVI);
//
G4HadronElasticPhysicsVI::G4HadronElasticPhysicsVI(G4int ver)
: G4HadronElasticPhysics(ver, "nElasticPhysics_HP")
{
if(ver > 1) {
G4cout << "### G4HadronElasticPhysicsVI: " << GetPhysicsName()
<< G4endl;
}
auto param = G4HadronicParameters::Instance();
// HP is inconsistent with the neutron general process
param->SetEnableNeutronGeneralProcess(false);
}
void G4HadronElasticPhysicsVI::ConstructProcess()
{
G4HadronElasticPhysics::ConstructProcess();
const G4ParticleDefinition* neutron = G4Neutron::Neutron();
G4HadronicProcess* hel = G4PhysListUtil::FindElasticProcess( neutron );
if ( nullptr == hel ) {
hel = new G4HadronicProcess();
neutron->GetProcessManager()->AddDiscreteProcess(hel);
} else {
G4HadronElastic* he = GetElasticModel(neutron);
he->SetMinEnergy(19.5*CLHEP::MeV);
}
// apply alternative cross section
hel->AddDataSet( new G4NeutronHPElasticXS() );
// add HP elastic
auto he = new G4NeutronHPElasticVI();
he->SetMaxEnergy(20*CLHEP::MeV);
hel->RegisterMe( he );
if ( G4HadronicParameters::Instance()->GetVerboseLevel() > 1 ) {
G4cout << "### HadronElasticPhysicsVI is constructed "
<< G4endl;
}
}
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysicsXS.cc
+1 -17
View File
@@ -38,14 +38,6 @@
// XS cross sections for neutrons
#include "G4HadronElasticPhysicsXS.hh"
#include "G4VCrossSectionDataSet.hh"
#include "G4Neutron.hh"
#include "G4Proton.hh"
#include "G4PionPlus.hh"
#include "G4PionMinus.hh"
#include "G4BGGNucleonElasticXS.hh"
#include "G4BGGPionElasticXS.hh"
#include "G4NeutronElasticXS.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
@@ -56,16 +48,8 @@ G4HadronElasticPhysicsXS::G4HadronElasticPhysicsXS(G4int ver)
: G4HadronElasticPhysics(ver, "hElasticWEL_CHIPS_XS")
{
if(ver > 1) {
G4cout << "### G4HadronElasticPhysicsHP: " << GetPhysicsName()
G4cout << "### G4HadronElasticPhysicsXS: " << GetPhysicsName()
<< G4endl;
}
}
G4HadronElasticPhysicsXS::~G4HadronElasticPhysicsXS()
{}
void G4HadronElasticPhysicsXS::ConstructProcess()
{
G4HadronElasticPhysics::ConstructProcess();
}
source/physics_lists/constructors/hadron_inelastic/History
+7
View File
@@ -4,6 +4,13 @@ See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
which **must** added in reverse chronological order (newest at the top). It must **not**
be used as a substitute for writing good git commit messages!
## 2023-10-20 Jean-Christophe David (phys-ctor-hinelastic-V11-01-02)
- Call G4HadronicBuilder::BuildAntiLightIonsINCLXX() to treat antiproton with INCLXX
## 2023-10-15 Vladimir Ivanchenko (phys-ctor-hinelastic-V11-01-01)
- G4HadronInelasticQBBC - more accurate instantiation of the neutron general process
- G4HadrocPhysicsQGSP_BERT_HP - used alternative HP models and cross sections
## 2023-04-19 Alberto Ribon (phys-ctor-hinelastic-V11-01-00)
- Created the new class G4HadronInelasticQBBC_ABLA, which is similar to
G4HadronInelasticQBBC_ABLA, except that, for the final-state of nuclear
source/physics_lists/constructors/hadron_inelastic/src/G4HadronInelasticQBBC.cc
+1
View File
@@ -31,6 +31,7 @@
// Author: 2 October 2009 V. Ivanchenko
//
// Modified:
// 12.10.2023 V.Ivanchenko added usage of the neutron general process
//
//----------------------------------------------------------------------------
//
source/physics_lists/constructors/hadron_inelastic/src/G4HadronPhysicsINCLXX.cc
+1 -1
View File
@@ -284,7 +284,7 @@ void G4HadronPhysicsINCLXX::Others()
if( param->GetMaxEnergy() > param->EnergyThresholdForHeavyHadrons() ) {
// anti light ions
G4HadronicBuilder::BuildAntiLightIonsFTFP();
G4HadronicBuilder::BuildAntiLightIonsINCLXX();
if ( param->EnableHyperNuclei() ) {
// INCLXX is currently capable of handling light hypernuclei projectiles,
source/physics_lists/constructors/hadron_inelastic/src/G4HadronPhysicsQGSP_BERT_HP.cc
+54 -47
View File
@@ -33,10 +33,13 @@
// Modified:
// 15.12.2005 G.Folger: migration to non static particles
// 08.06.2006 V.Ivanchenko: remove stopping
// 20.06.2006 G.Folger: Bertini applies to Kaons, i.e. use SetMinEnergy instead of SetMinPionEnergy
// 20.06.2006 G.Folger: Bertini applies to Kaons, i.e. use SetMinEnergy
// instead of SetMinPionEnergy
// 25.04.2007 G.Folger: Add code for quasielastic
// 31.10.2012 A.Ribon: Use G4MiscBuilder
// 19.03.2013 A.Ribon: Replace LEP with FTFP
// 12.10.2023 V.Ivanchenko added usage of alternative neutron
// HP model and cross section
//
//----------------------------------------------------------------------------
//
@@ -56,17 +59,21 @@
#include "G4BertiniNeutronBuilder.hh"
#include "G4NeutronPHPBuilder.hh"
#include "G4NeutronRadCapture.hh"
#include "G4NeutronCaptureXS.hh"
#include "G4ParticleHPCaptureData.hh"
#include "G4LFission.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4NeutronCaptureProcess.hh"
#include "G4NeutronFissionProcess.hh"
#include "G4NeutronRadCaptureHP.hh"
#include "G4NeutronHPCaptureXS.hh"
#include "G4NeutronHPFissionXS.hh"
#include "G4NeutronHPInelasticXS.hh"
#include "G4NeutronHPInelasticVI.hh"
#include "G4NeutronInelasticXS.hh"
#include "G4ParticleHPInelastic.hh"
#include "G4NeutronFissionVI.hh"
#include "G4ProcessVector.hh"
#include "G4ProcessManager.hh"
#include "G4CrossSectionDataSetRegistry.hh"
#include "G4PhysListUtil.hh"
#include "G4HadronicParameters.hh"
// factory
@@ -84,6 +91,9 @@ G4HadronPhysicsQGSP_BERT_HP::G4HadronPhysicsQGSP_BERT_HP(const G4String& name, G
: G4HadronPhysicsQGSP_BERT(name)
{
minBERT_neutron = 19.9*MeV;
auto param = G4HadronicParameters::Instance();
// HP is inconsistent with the neutron general process
param->SetEnableNeutronGeneralProcess(false);
}
void G4HadronPhysicsQGSP_BERT_HP::Neutron()
@@ -91,43 +101,40 @@ void G4HadronPhysicsQGSP_BERT_HP::Neutron()
G4HadronicParameters* param = G4HadronicParameters::Instance();
G4bool useFactorXS = param->ApplyFactorXS();
auto neu = new G4NeutronBuilder( true ); // Fission on
AddBuilder(neu);
auto qgs = new G4QGSPNeutronBuilder(QuasiElasticQGS);
AddBuilder(qgs);
qgs->SetMinEnergy(minQGSP_neutron);
neu->RegisterMe(qgs);
auto ftf = new G4FTFPNeutronBuilder(QuasiElasticFTF);
AddBuilder(ftf);
ftf->SetMinEnergy(minFTFP_neutron);
ftf->SetMaxEnergy(maxFTFP_neutron);
neu->RegisterMe(ftf);
auto bert = new G4BertiniNeutronBuilder;
AddBuilder(bert);
bert->SetMinEnergy(minBERT_neutron);
bert->SetMaxEnergy(maxBERT_neutron);
neu->RegisterMe(bert);
auto hp = new G4NeutronPHPBuilder;
AddBuilder(hp);
neu->RegisterMe(hp);
neu->Build();
const G4ParticleDefinition* neutron = G4Neutron::Neutron();
G4HadronicProcess* inel = G4PhysListUtil::FindInelasticProcess( neutron );
if(nullptr != inel) {
if( useFactorXS ) inel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
}
G4HadronicProcess* capture = G4PhysListUtil::FindCaptureProcess( neutron );
if ( nullptr != capture ) {
G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture;
theNeutronRadCapture->SetMinEnergy( minBERT_neutron );
capture->RegisterMe( theNeutronRadCapture );
}
G4HadronicProcess* fission = G4PhysListUtil::FindFissionProcess( neutron );
if ( nullptr != fission ) {
G4LFission* theNeutronLEPFission = new G4LFission;
theNeutronLEPFission->SetMinEnergy( minBERT_neutron );
theNeutronLEPFission->SetMaxEnergy( G4HadronicParameters::Instance()->GetMaxEnergy() );
fission->RegisterMe( theNeutronLEPFission );
}
auto inel = new G4HadronInelasticProcess( "neutronInelastic", neutron );
neutron->GetProcessManager()->AddDiscreteProcess(inel);
G4QGSPNeutronBuilder qgs(QuasiElasticQGS);
qgs.SetMinEnergy(minQGSP_neutron);
qgs.Build(inel);
G4FTFPNeutronBuilder ftf(QuasiElasticFTF);
ftf.SetMinEnergy(minFTFP_neutron);
ftf.SetMaxEnergy(maxFTFP_neutron);
ftf.Build(inel);
G4BertiniNeutronBuilder bert;
bert.SetMinEnergy(minBERT_neutron);
bert.SetMaxEnergy(maxBERT_neutron);
bert.Build(inel);
auto xsinel = new G4NeutronInelasticXS();
inel->AddDataSet( xsinel );
inel->AddDataSet( new G4NeutronHPInelasticXS() );
auto mod = new G4NeutronHPInelasticVI();
mod->SetMaxEnergy( 20*CLHEP::MeV );
inel->RegisterMe( mod );
if ( useFactorXS )
inel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
auto capture = new G4NeutronCaptureProcess( "nCaptureHP" );
neutron->GetProcessManager()->AddDiscreteProcess(capture);
capture->AddDataSet( new G4NeutronHPCaptureXS() );
capture->RegisterMe( new G4NeutronRadCaptureHP() );
auto fission = new G4NeutronFissionProcess( "nFissionHP" );
neutron->GetProcessManager()->AddDiscreteProcess(fission);
fission->AddDataSet( new G4NeutronHPFissionXS() );
fission->RegisterMe( new G4NeutronFissionVI() );
}
source/physics_lists/constructors/ions/History
+2
View File
@@ -4,6 +4,8 @@ See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
which **must** added in reverse chronological order (newest at the top). It must **not**
be used as a substitute for writing good git commit messages!
## 2023-11-09 Yoshihide Sato (phys-ctor-ions-V11-11-01)
- Add a physics constructor, G4LightIonQMDPhsysics for light ion qmd.
## 2021-12-10 Ben Morgan (phys-ctor-ions-V11-00-00)
- Change to new Markdown History format
source/physics_lists/constructors/ions/include/G4LightIonQMDPhysics.hh
+90
View File
@@ -0,0 +1,90 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4IonBinaryCascadeBuilder
// Created from G4IonBinaryCascadePhysics
//
// Author: G.Folger
//
// Modified:
//
//----------------------------------------------------------------------------
//
#ifndef G4LightIonQMDPhysics_h
#define G4LightIonQMDPhysics_h 1
#include "globals.hh"
#include "G4VPhysicsConstructor.hh"
#include <vector>
class G4HadronicInteraction;
class G4BinaryLightIonReaction;
class G4QMDReaction;
class G4LightIonQMDReaction;
class G4VCrossSectionDataSet;
class G4LightIonQMDPhysics : public G4VPhysicsConstructor
{
public:
G4LightIonQMDPhysics(G4int verb = 0);
G4LightIonQMDPhysics(const G4String& name, G4int ver = 0);
~G4LightIonQMDPhysics() override;
// This method will be invoked in the Construct() method.
// each particle type will be instantiated
void ConstructParticle() override;
// This method will be invoked in the Construct() method.
// each physics process will be instantiated and
// registered to the process manager of each particle type
void ConstructProcess() override;
private:
void AddProcess(const G4String&,
G4ParticleDefinition*,
G4BinaryLightIonReaction*,
G4QMDReaction*,
G4LightIonQMDReaction*,
G4HadronicInteraction*,
G4VCrossSectionDataSet*);
G4double eminQMD;
G4double emaxQMD;
G4double eminLIQMD;
G4double emaxLIQMD;
G4double overlap;
G4int verbose;
};
#endif
source/physics_lists/constructors/ions/sources.cmake
+3 -1
View File
@@ -9,13 +9,15 @@ geant4_add_module(G4phys_ctor_ions
G4IonPhysicsPHP.hh
G4IonPhysicsXS.hh
G4IonQMDPhysics.hh
G4LightIonQMDPhysics.hh
SOURCES
G4IonBinaryCascadePhysics.cc
G4IonINCLXXPhysics.cc
G4IonPhysics.cc
G4IonPhysicsPHP.cc
G4IonPhysicsXS.cc
G4IonQMDPhysics.cc)
G4IonQMDPhysics.cc
G4LightIonQMDPhysics.cc)
geant4_module_link_libraries(G4phys_ctor_ions
PUBLIC
source/physics_lists/constructors/ions/src/G4LightIonQMDPhysics.cc
+181
View File
@@ -0,0 +1,181 @@
//
// ********************************************************************
// * 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. *
// ********************************************************************
//
//
//---------------------------------------------------------------------------
//
// ClassName: G4LightIonQMDPhysics
// Created from G4IonBinaryCascadePhysics
//
// Author: G.Folger
//
// Modified:
//
//----------------------------------------------------------------------------
//
#include "G4LightIonQMDPhysics.hh"
#include "G4SystemOfUnits.hh"
#include "G4Deuteron.hh"
#include "G4Triton.hh"
#include "G4He3.hh"
#include "G4Alpha.hh"
#include "G4GenericIon.hh"
#include "G4IonConstructor.hh"
#include "G4HadronInelasticProcess.hh"
#include "G4BinaryLightIonReaction.hh"
#include "G4LightIonQMDReaction.hh"
#include "G4QMDReaction.hh"
#include "G4PreCompoundModel.hh"
#include "G4ExcitationHandler.hh"
#include "G4FTFBuilder.hh"
#include "G4HadronicInteraction.hh"
#include "G4BuilderType.hh"
#include "G4ComponentGGNuclNuclXsc.hh"
#include "G4CrossSectionInelastic.hh"
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
// Nuclei
#include "G4IonConstructor.hh"
#include "G4BuilderType.hh"
#include "G4HadronicInteractionRegistry.hh"
#include "G4HadronicParameters.hh"
#include "G4DeexPrecoParameters.hh"
#include "G4NuclearLevelData.hh"
#include "G4HadronicParameters.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4LightIonQMDPhysics);
G4LightIonQMDPhysics::G4LightIonQMDPhysics(G4int ver)
: G4LightIonQMDPhysics("LightIonQMD", ver)
{}
G4LightIonQMDPhysics::G4LightIonQMDPhysics(const G4String& nname, G4int ver)
: G4VPhysicsConstructor(nname), verbose(ver)
{
eminLIQMD = 30.*MeV;
emaxLIQMD = 500.*MeV;
eminQMD = 500.*MeV;
emaxQMD = 10.*GeV;
overlap = 10*MeV;
SetPhysicsType(bIons);
G4DeexPrecoParameters* param = G4NuclearLevelData::GetInstance()->GetParameters();
param->SetDeexChannelsType(fCombined);
if(verbose > 1) { G4cout << "### IonPhysics: " << nname << G4endl; }
}
G4LightIonQMDPhysics::~G4LightIonQMDPhysics()
{}
void G4LightIonQMDPhysics::ConstructProcess()
{
G4HadronicInteraction* p =
G4HadronicInteractionRegistry::Instance()->FindModel("PRECO");
G4PreCompoundModel* thePreCompound = static_cast<G4PreCompoundModel*>(p);
if(!thePreCompound) { thePreCompound = new G4PreCompoundModel; }
G4BinaryLightIonReaction* theIonBC = new G4BinaryLightIonReaction(thePreCompound);
theIonBC->SetMaxEnergy(eminLIQMD + overlap);
G4LightIonQMDReaction* theLIQMD = new G4LightIonQMDReaction();
theLIQMD->SetMinEnergy(eminLIQMD);
theLIQMD->SetMaxEnergy(emaxLIQMD + overlap);
G4double emax = G4HadronicParameters::Instance()->GetMaxEnergy();
emaxQMD = G4HadronicParameters::Instance()->GetMaxEnergyTransitionFTF_Cascade();
G4HadronicInteraction* theFTFP = nullptr;
if(emax > emaxQMD) {
G4FTFBuilder theFTFPBuilder("FTFP",thePreCompound);
theFTFP = theFTFPBuilder.GetModel();
theFTFP->SetMinEnergy(emaxQMD - overlap);
theFTFP->SetMaxEnergy(emax);
}
G4QMDReaction* theQMD = new G4QMDReaction();
theQMD->SetMinEnergy(eminQMD);
theQMD->SetMaxEnergy(emaxQMD);
G4VCrossSectionDataSet* theNuclNuclData =
new G4CrossSectionInelastic( new G4ComponentGGNuclNuclXsc() );
AddProcess("protonInelastic", G4Proton::Proton(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
AddProcess("dInelastic", G4Deuteron::Deuteron(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
AddProcess("tInelastic", G4Triton::Triton(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
AddProcess("He3Inelastic", G4He3::He3(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
AddProcess("alphaInelastic", G4Alpha::Alpha(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
AddProcess("ionInelastic", G4GenericIon::GenericIon(), theIonBC, theQMD, theLIQMD, theFTFP, theNuclNuclData);
}
void G4LightIonQMDPhysics::AddProcess(const G4String& name,
G4ParticleDefinition* p,
G4BinaryLightIonReaction* BIC,
G4QMDReaction* QMD,
G4LightIonQMDReaction* LIQMD,
G4HadronicInteraction* FTFP,
G4VCrossSectionDataSet* theNuclNuclData)
{
G4HadronInelasticProcess* hadi = new G4HadronInelasticProcess(name, p);
G4ProcessManager* pManager = p->GetProcessManager();
pManager->AddDiscreteProcess(hadi);
hadi->AddDataSet(theNuclNuclData);
hadi->RegisterMe(BIC);
hadi->RegisterMe(LIQMD);
hadi->RegisterMe(QMD);
if(FTFP) { hadi->RegisterMe(FTFP); }
if(verbose > 1) {
G4cout << "Register " << hadi->GetProcessName()
<< " for " << p->GetParticleName() << G4endl
<< " Binary Cascade for E(MeV)= 0 - "
<< eminLIQMD+overlap;
G4cout << " LIQMD for E(MeV)= " << eminLIQMD << " - " << emaxLIQMD+overlap;
G4cout << " QMD for E(MeV)= " << eminQMD << " - " << emaxQMD;
if(FTFP) {
G4cout << " FTFP for E(MeV)= " << emaxQMD-overlap << " - " << FTFP->GetMaxEnergy();
}
G4cout << G4endl;
}
}
void G4LightIonQMDPhysics::ConstructParticle()
{
// Construct light ions
G4IonConstructor pConstructor;
pConstructor.ConstructParticle();
}
source/physics_lists/constructors/limiters/History
+3
View File
@@ -6,6 +6,9 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-08-29 Ben Morgan (phys-ctor-limiters-V11-01-00)
- Fix Coverity unreachable code warning
## 2022-11-24 Gabriele Cosmo (phys-ctor-limiters-V11-00-08)
- Fixed compilation warnings for implicit type conversions on macOS/XCode 14.1.
source/physics_lists/constructors/limiters/src/G4FastSimulationPhysics.cc
+4 -17
View File
@@ -116,7 +116,6 @@ void G4FastSimulationPhysics::ConstructProcess()
G4bool isUnderFastSimulation(false);
G4String processAndGeometryNames;
G4int icount(0);
G4ProcessVector* vprocess = pmanager->GetProcessList();
for (G4int ip = 0 ; ip < (G4int)vprocess->size() ; ++ip)
@@ -126,22 +125,10 @@ void G4FastSimulationPhysics::ConstructProcess()
if ( pb != nullptr )
{
isUnderFastSimulation = true;
if ( icount < 3 )
{
processAndGeometryNames += pb->GetProcessName();
processAndGeometryNames += "[geom:";
processAndGeometryNames += pb->GetWorldVolume()->GetName();
processAndGeometryNames += "] ";
}
else
{
processAndGeometryNames += "\n ";
processAndGeometryNames += pb->GetProcessName();
processAndGeometryNames += "[geom:";
processAndGeometryNames += pb->GetWorldVolume()->GetName();
processAndGeometryNames += "] ";
icount = 0;
}
processAndGeometryNames += pb->GetProcessName();
processAndGeometryNames += "[geom:";
processAndGeometryNames += pb->GetWorldVolume()->GetName();
processAndGeometryNames += "] ";
}
}
if ( isUnderFastSimulation ) G4cout << std::setw(14) << particleName << " : " << processAndGeometryNames << G4endl;
source/physics_lists/lists/History
+18
View File
@@ -4,6 +4,24 @@ See `CONTRIBUTING.rst` for details of **required** info/format for each entry,
which **must** added in reverse chronological order (newest at the top). It must **not**
be used as a substitute for writing good git commit messages!
## 2023-11-09 Yoshihide Sato (phys-lists-V11-01-07)
- Add a option for `Shielding` to use G4LightIonQMDPhysics,
which is the constructor of light ion qmd.
## 2023-11-06 Vladimir Ivantchenko (phys-lists-V11-01-06)
- G4PhysListFactoryMessenger - added UI commands to enable neutrino and
charge exchange physics
## 2023-10-26 Alberto Ribon (phys-lists-V11-01-05)
- FTFP_BERT_ATL : use a specific FTF tune meant to overcome the problem of
too optimistic (i.e. narrow) pion shower energy resolutions in ATLAS
calorimeters with respect to test-beam data.
## 2023-10-15 Vladimir Ivantchenko (phys-lists-V11-01-04)
- QGSP_BERT_HP - use alternative HP models and cross sections
- QGSP_BERT_AllHP - use default HP elastic builder
## 2023-05-15 Alberto Ribon (phys-lists-V11-01-03)
- Use the new class G4StoppingPhysicsWithINCLXX (instead of G4StoppingPhysics)
in INCLXXPhysicsListHelper : all the INCLXX-based physics lists use INCLXX
source/physics_lists/lists/include/FTFP_BERT_ATL.hh
+1 -1
View File
@@ -32,7 +32,7 @@
// This is a modified version of the FTFP_BERT physics list for ATLAS.
// The physics list FTFP_BERT_ATL has the transition between Bertini (BERT)
// intra-nuclear cascade model and Fritiof (FTF) string model in the
// energy region [9, 12] GeV (instead of [4, 5] GeV as in FTFP_BERT).
// energy region [9, 12] GeV (instead of [3, 6] GeV as in FTFP_BERT).
//----------------------------------------------------------------------------
//
#ifndef FTFP_BERT_ATL_h
source/physics_lists/lists/include/G4PhysListFactoryMessenger.hh
+2
View File
@@ -56,6 +56,8 @@ private:
G4UIcommand* theRadDecay;
G4UIcommand* theOptical;
G4UIcommand* theThermal;
G4UIcommand* theNeutrino;
G4UIcommand* theChargeEx;
G4UIdirectory* theDir;
};
source/physics_lists/lists/include/Shielding.hh
+1 -1
View File
@@ -47,7 +47,7 @@ class Shielding : public G4VModularPhysicsList
{
public:
explicit Shielding(G4int verb = 1 , const G4String& n_model = "HP",
const G4String& HadrPhysVariant = "");
const G4String& HadrPhysVariant = "", G4bool useLightIonQMD = false);
virtual ~Shielding()=default;
//delete copy constructor and assignment operator
source/physics_lists/lists/src/FTFP_BERT_ATL.cc
+7 -1
View File
@@ -32,7 +32,7 @@
// This is a modified version of the FTFP_BERT physics list for ATLAS.
// The physics list FTFP_BERT_ATL has the transition between Bertini (BERT)
// intra-nuclear cascade model and Fritiof (FTF) string model in the
// energy region [9, 12] GeV (instead of [4, 5] GeV as in FTFP_BERT).
// energy region [9, 12] GeV (instead of [3, 6] GeV as in FTFP_BERT).
//----------------------------------------------------------------------------
//
#include <iomanip>
@@ -52,6 +52,7 @@
#include "G4HadronPhysicsFTFP_BERT_ATL.hh"
#include "G4WarnPLStatus.hh"
#include "G4FTFTunings.hh"
FTFP_BERT_ATL::FTFP_BERT_ATL(G4int ver)
{
@@ -64,6 +65,11 @@ FTFP_BERT_ATL::FTFP_BERT_ATL(G4int ver)
defaultCutValue = 0.7*CLHEP::mm;
SetVerboseLevel(ver);
// Use the 4th tunes of Fritiof (FTF) string model, meant to to overcome
// the problem of too optimistic (i.e. narrow) pion shower energy resolutions
// in ATLAS calorimeters with respect to test-beam data.
G4FTFTunings::Instance()->SetTuneApplicabilityState( 4, 1 );
// EM Physics
RegisterPhysics( new G4EmStandardPhysics(ver));
source/physics_lists/lists/src/G4PhysListFactoryMessenger.cc
+19 -4
View File
@@ -38,7 +38,8 @@
#include "G4RadioactiveDecayPhysics.hh"
#include "G4OpticalPhysics.hh"
#include "G4ThermalNeutrons.hh"
#include "G4NeutrinoPhysics.hh"
#include "G4ChargeExchangePhysics.hh"
G4PhysListFactoryMessenger::G4PhysListFactoryMessenger(G4VModularPhysicsList* pl)
{
@@ -60,6 +61,14 @@ G4PhysListFactoryMessenger::G4PhysListFactoryMessenger(G4VModularPhysicsList* pl
theThermal->SetGuidance("Enable special elastic scattering of thermal neutrons (Ekin < 4 eV).");
theThermal->SetGuidance("Important note: to be used only with HP-based physics lists!");
theThermal->AvailableForStates(G4State_PreInit);
theNeutrino = new G4UIcommand("/physics_lists/factory/addNeutrino",this);
theNeutrino->SetGuidance("Enable physics processes for neutrino.");
theNeutrino->AvailableForStates(G4State_PreInit);
theChargeEx = new G4UIcommand("/physics_lists/factory/addChargeExchange",this);
theChargeEx->SetGuidance("Enable charge exchange hadronic processes.");
theChargeEx->AvailableForStates(G4State_PreInit);
}
G4PhysListFactoryMessenger::~G4PhysListFactoryMessenger()
@@ -67,17 +76,23 @@ G4PhysListFactoryMessenger::~G4PhysListFactoryMessenger()
delete theThermal;
delete theOptical;
delete theRadDecay;
delete theNeutrino;
delete theChargeEx;
delete theDir;
}
void G4PhysListFactoryMessenger::SetNewValue(G4UIcommand* aComm, G4String)
{
G4int ver = thePhysList->GetVerboseLevel();
if(aComm == theRadDecay) {
if (aComm == theRadDecay) {
thePhysList->RegisterPhysics(new G4RadioactiveDecayPhysics(ver));
} else if(aComm == theOptical) {
} else if (aComm == theOptical) {
thePhysList->RegisterPhysics(new G4OpticalPhysics(ver));
} else if(aComm == theThermal) {
} else if (aComm == theThermal) {
thePhysList->RegisterPhysics(new G4ThermalNeutrons(ver));
} else if (aComm == theNeutrino) {
thePhysList->RegisterPhysics(new G4NeutrinoPhysics(ver));
} else if(aComm == theChargeEx) {
thePhysList->RegisterPhysics(new G4ChargeExchangePhysics(ver));
}
}
source/physics_lists/lists/src/QGSP_BERT_HP.cc
+7 -3
View File
@@ -40,13 +40,15 @@
// 04.06.2010 G.Folger: Use new ctor for builders
// 16.08.2010 H.Kurashige: Remove inclusion of G4ParticleWithCuts
// 16.10.2012 A.Ribon: Use new default stopping
// 12.10.2023 V.Ivanchenko added usage of alternative neutron HP models and
// processes
//
//----------------------------------------------------------------------------
//
#include <iomanip>
#include <CLHEP/Units/SystemOfUnits.h>
#include "G4SystemOfUnits.hh"
#include "globals.hh"
#include "G4ios.hh"
@@ -56,8 +58,9 @@
#include "G4EmStandardPhysics.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonPhysics.hh"
#include "G4IonElasticPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysicsHP.hh"
#include "G4HadronElasticPhysicsVI.hh"
#include "QGSP_BERT_HP.hh"
#include "G4HadronPhysicsQGSP_BERT_HP.hh"
@@ -83,7 +86,7 @@ QGSP_BERT_HP::QGSP_BERT_HP(G4int ver)
RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
// Hadron Elastic scattering
RegisterPhysics( new G4HadronElasticPhysicsHP(ver) );
RegisterPhysics( new G4HadronElasticPhysicsVI(ver) );
// Hadron Physics
RegisterPhysics( new G4HadronPhysicsQGSP_BERT_HP(ver));
@@ -93,6 +96,7 @@ QGSP_BERT_HP::QGSP_BERT_HP(G4int ver)
// Ion Physics
RegisterPhysics( new G4IonPhysics(ver));
RegisterPhysics( new G4IonElasticPhysics(ver) );
}
source/physics_lists/lists/src/Shielding.cc
+7 -2
View File
@@ -55,6 +55,7 @@
#include "G4EmStandardPhysics_option4.hh"
#include "G4EmExtraPhysics.hh"
#include "G4IonQMDPhysics.hh"
#include "G4LightIonQMDPhysics.hh"
#include "G4IonElasticPhysics.hh"
#include "G4StoppingPhysics.hh"
#include "G4HadronElasticPhysicsHP.hh"
@@ -67,7 +68,7 @@
#include <CLHEP/Units/SystemOfUnits.h>
Shielding::Shielding(G4int verbose, const G4String& n_model,
const G4String& HadrPhysVariant )
const G4String& HadrPhysVariant, G4bool useLightIonQMD)
{
G4String LEN_model = n_model;
size_t find = LEN_model.find("LEND__");
@@ -173,5 +174,9 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
// Ion Physics
RegisterPhysics( new G4IonElasticPhysics(verbose) );
RegisterPhysics( new G4IonQMDPhysics(verbose) );
if (useLightIonQMD){
RegisterPhysics( new G4LightIonQMDPhysics(verbose) );
} else {
RegisterPhysics( new G4IonQMDPhysics(verbose) );
}
}
source/physics_lists/util/History
+2
View File
@@ -6,6 +6,8 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-10-15 Vladimir Ivanchenko (phys-util-V11-01-01)
- G4HadProcesses - more accurate implementation for the neutron genelal process
## 2022-12-30 Vladimir Ivanchenko (phys-util-V11-01-00)
- G4HadProcesses - avoid double instantiation of capture cross section
source/physics_lists/util/src/G4HadProcesses.cc
+8 -8
View File
@@ -186,7 +186,7 @@ void G4HadProcesses::BuildNeutronInelasticAndCapture(G4HadronicProcess* nInel)
G4HadronicProcess* nCap = new G4NeutronCaptureProcess("nCapture");
nCap->RegisterMe(new G4NeutronRadCapture());
if(useNeutronGeneral) {
if ( useNeutronGeneral ) {
auto nGen = G4PhysListUtil::FindNeutronGeneralProcess();
nGen->SetInelasticProcess(nInel);
nGen->SetCaptureProcess(nCap);
@@ -196,9 +196,9 @@ void G4HadProcesses::BuildNeutronInelasticAndCapture(G4HadronicProcess* nInel)
nInel->AddDataSet(new G4NeutronInelasticXS());
ph->RegisterProcess(nInel, neutron);
ph->RegisterProcess(nCap, neutron);
if( param->ApplyFactorXS() ) {
nInel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
}
}
if ( param->ApplyFactorXS() ) {
nInel->MultiplyCrossSectionBy( param->XSFactorNucleonInelastic() );
}
}
@@ -207,7 +207,7 @@ void G4HadProcesses::BuildNeutronElastic(G4HadronicProcess* nEl)
G4HadronicParameters* param = G4HadronicParameters::Instance();
G4bool useNeutronGeneral = param->EnableNeutronGeneralProcess();
if(useNeutronGeneral) {
if ( useNeutronGeneral ) {
auto nGen = G4PhysListUtil::FindNeutronGeneralProcess();
nGen->SetElasticProcess(nEl);
} else {
@@ -215,8 +215,8 @@ void G4HadProcesses::BuildNeutronElastic(G4HadronicProcess* nEl)
nEl->AddDataSet(new G4NeutronElasticXS());
G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
ph->RegisterProcess(nEl, neutron);
if( param->ApplyFactorXS() ) {
nEl->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
}
}
if ( param->ApplyFactorXS() ) {
nEl->MultiplyCrossSectionBy( param->XSFactorNucleonElastic() );
}
}