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/processes/hadronic/processes/History
+6
View File
@@ -6,6 +6,12 @@ It must **not** be used as a substitute for writing good git commit messages!
-------------------------------------------------------------------------------
## 2023-11-06 Vladimir Ivanchenko (hadr-proc-V11-01-12)
- G4NuVacOscProcess, G4TauNeutrinoNucleusProcess, G4MuNeutrinoNucleusProcess,
G4ElNeutrinoNucleusProcess, G4NeutrinoElectronProcess - use sub-types of
neutrino interactions, avoid destruction of internal cross section,
removed unused class members and methods.
## 2023-06-17 Vladimir Ivanchenko (hadr-proc-V11-01-11)
- G4NuVacOscProcess - clean-up to resolve Coverity report, removed unused class
memebrs
source/processes/hadronic/processes/include/G4ElNeutrinoNucleusProcess.hh
+20 -22
View File
@@ -45,7 +45,6 @@
class G4ParticleDefinition;
class G4CrossSectionDataStore;
class G4LogicalVolume;
class G4ElNeutrinoNucleusTotXsc;
class G4SafetyHelper;
@@ -53,45 +52,44 @@ class G4ElNeutrinoNucleusProcess : public G4HadronicProcess
{
public:
G4ElNeutrinoNucleusProcess(G4String anEnvelopeName , const G4String& procName = "el-neutrino-nucleus");
G4ElNeutrinoNucleusProcess(const G4String& anEnvelopeName,
const G4String& procName = "elNuNucleus");
~G4ElNeutrinoNucleusProcess() override = default;
virtual ~G4ElNeutrinoNucleusProcess();
G4double PostStepGetPhysicalInteractionLength(
const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition
) override;
G4double GetMeanFreePath(const G4Track &aTrack,
G4double, G4ForceCondition*) override;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// initialise thresholds
void PreparePhysicsTable(const G4ParticleDefinition&) override;
// set internal limit
virtual void SetLowestEnergy(G4double);
const G4Step& aStep) override;
void ProcessDescription(std::ostream& outFile) const override;
// set internal parameters
void SetLowestEnergy(G4double);
void SetBiasingFactors(G4double bfCc, G4double bfNc);
void SetBiasingFactor(G4double bf);
G4double GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *) override;
private:
// hide assignment operator as private
G4ElNeutrinoNucleusProcess& operator=(const G4ElNeutrinoNucleusProcess &right);
G4ElNeutrinoNucleusProcess(const G4ElNeutrinoNucleusProcess& );
G4ElNeutrinoNucleusProcess& operator=
(const G4ElNeutrinoNucleusProcess &right) = delete;
G4ElNeutrinoNucleusProcess(const G4ElNeutrinoNucleusProcess&) = delete;
private:
G4double lowestEnergy;
G4bool isInitialised, fBiased;
G4LogicalVolume* fEnvelope;
G4String fEnvelopeName;
G4ElNeutrinoNucleusTotXsc* fTotXsc;
G4double fNuNuclCcBias, fNuNuclNcBias, fNuNuclTotXscBias;
G4double fXsc;
G4SafetyHelper* safetyHelper;
G4double lowestEnergy;
G4double fNuNuclCcBias{1.0};
G4double fNuNuclNcBias{1.0};
G4double fNuNuclTotXscBias{1.0};
G4String fEnvelopeName;
};
#endif
source/processes/hadronic/processes/include/G4MuNeutrinoNucleusProcess.hh
+20 -23
View File
@@ -44,8 +44,6 @@
#include "G4HadronicProcess.hh"
class G4ParticleDefinition;
class G4CrossSectionDataStore;
class G4LogicalVolume;
class G4MuNeutrinoNucleusTotXsc;
class G4SafetyHelper;
@@ -53,45 +51,44 @@ class G4MuNeutrinoNucleusProcess : public G4HadronicProcess
{
public:
G4MuNeutrinoNucleusProcess(G4String anEnvelopeName , const G4String& procName = "mu-neutrino-nucleus");
G4MuNeutrinoNucleusProcess(const G4String& anEnvelopeName,
const G4String& procName = "muNuNucleus");
~G4MuNeutrinoNucleusProcess() override = default;
virtual ~G4MuNeutrinoNucleusProcess();
G4double PostStepGetPhysicalInteractionLength(
const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition
) override;
G4double GetMeanFreePath(const G4Track &aTrack,
G4double, G4ForceCondition*) override;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// initialise thresholds
void PreparePhysicsTable(const G4ParticleDefinition&) override;
// set internal limit
virtual void SetLowestEnergy(G4double);
const G4Step& aStep) override;
void ProcessDescription(std::ostream& outFile) const override;
// set internal parameters
void SetLowestEnergy(G4double);
void SetBiasingFactors(G4double bfCc, G4double bfNc);
void SetBiasingFactor(G4double bf);
G4double GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *) override;
// hide assignment operator as private
G4MuNeutrinoNucleusProcess& operator=
(const G4MuNeutrinoNucleusProcess &right) = delete;
G4MuNeutrinoNucleusProcess(const G4MuNeutrinoNucleusProcess&) = delete;
private:
// hide assignment operator as private
G4MuNeutrinoNucleusProcess& operator=(const G4MuNeutrinoNucleusProcess &right);
G4MuNeutrinoNucleusProcess(const G4MuNeutrinoNucleusProcess& );
G4double lowestEnergy;
G4bool isInitialised, fBiased;
G4LogicalVolume* fEnvelope;
G4String fEnvelopeName;
G4MuNeutrinoNucleusTotXsc* fTotXsc;
G4double fNuNuclCcBias, fNuNuclNcBias, fNuNuclTotXscBias;
G4double fXsc;
G4SafetyHelper* safetyHelper;
G4double lowestEnergy;
G4double fNuNuclCcBias{1.0};
G4double fNuNuclNcBias{1.0};
G4double fNuNuclTotXscBias{1.0};
G4String fEnvelopeName;
};
#endif
source/processes/hadronic/processes/include/G4NeutrinoElectronProcess.hh
+23 -25
View File
@@ -24,14 +24,13 @@
// ********************************************************************
//
//
//
// Geant4 Neutrino Electron Scattering Process -- header file
//
// Created from G4HadronElasticProcess 15.12.17 V. Grichine
//
// Modified:
//
// 2.2.18 V.Grichine PostStepDoIt implementation
// 02.02.18 V.Grichine PostStepDoIt implementation
// Class Description
// General process for neutrino electron 2->2 scattering
@@ -45,7 +44,6 @@
class G4ParticleDefinition;
class G4CrossSectionDataStore;
class G4LogicalVolume;
class G4NeutrinoElectronTotXsc;
class G4SafetyHelper;
@@ -53,44 +51,44 @@ class G4NeutrinoElectronProcess : public G4HadronicProcess
{
public:
G4NeutrinoElectronProcess(G4String anEnvelopeName , const G4String& procName = "neutrino-electron");
G4NeutrinoElectronProcess(const G4String& anEnvelopeName,
const G4String& procName = "nuElectron");
virtual ~G4NeutrinoElectronProcess();
~G4NeutrinoElectronProcess() override = default;
virtual G4double PostStepGetPhysicalInteractionLength(
G4double PostStepGetPhysicalInteractionLength(
const G4Track& track,
G4double previousStepSize,
G4ForceCondition* condition
) override;
G4double GetMeanFreePath(const G4Track &aTrack,
G4double, G4ForceCondition*) override;
virtual G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// initialise thresholds
virtual void PreparePhysicsTable(const G4ParticleDefinition&) override;
// set internal limit
virtual void SetLowestEnergy(G4double);
virtual void ProcessDescription(std::ostream& outFile) const override;
void ProcessDescription(std::ostream& outFile) const override;
// set internal parameters
void SetLowestEnergy(G4double);
void SetBiasingFactors(G4double bfCc, G4double bfNc);
void SetBiasingFactor(G4double bf);
G4double GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *) override;
// hide assignment operator as private
G4NeutrinoElectronProcess& operator=
(const G4NeutrinoElectronProcess &right) = delete;
G4NeutrinoElectronProcess(const G4NeutrinoElectronProcess&) = delete;
private:
// hide assignment operator as private
G4NeutrinoElectronProcess& operator=(const G4NeutrinoElectronProcess &right);
G4NeutrinoElectronProcess(const G4NeutrinoElectronProcess& );
G4double lowestEnergy;
G4bool isInitialised, fBiased;
G4LogicalVolume* fEnvelope;
G4String fEnvelopeName;
G4NeutrinoElectronTotXsc* fTotXsc;
G4double fNuEleCcBias, fNuEleNcBias, fNuEleTotXscBias;
G4SafetyHelper* safetyHelper;
G4double lowestEnergy;
G4double fNuEleCcBias{1.0};
G4double fNuEleNcBias{1.0};
G4double fNuEleTotXscBias{1.0};
G4String fEnvelopeName;
};
#endif
source/processes/hadronic/processes/include/G4NuVacOscProcess.hh
+6 -5
View File
@@ -27,11 +27,12 @@
//
// Geant4 muon neutrino nucleus scattering Process -- header file
//
// Created from G4HadronElasticProcess 1.3.19 V. Grichine
// Created from G4HadronElasticProcess 01.03.19 V. Grichine
//
// Modified:
//
// 5.4.23 V.Grichine first implementation
// 05.04.23 V.Grichine first implementation
// 06.11.23 V.Ivantchenko - make inheritence from G4VDiscreteProcess
// Class Description
// General process for neutrino nucleus 2->X scattering
@@ -41,16 +42,16 @@
#define G4NuVacOscProcess_h 1
#include "globals.hh"
#include "G4HadronicProcess.hh"
#include "G4VDiscreteProcess.hh"
class G4ParticleDefinition;
class G4NuVacOscProcess : public G4HadronicProcess
class G4NuVacOscProcess : public G4VDiscreteProcess
{
public:
G4NuVacOscProcess(const G4String& anEnvelopeName,
const G4String& procName = "nu-vacuum-oscillation");
const G4String& procName = "nuVacOscillation");
~G4NuVacOscProcess() override = default;
source/processes/hadronic/processes/include/G4TauNeutrinoNucleusProcess.hh
+10 -12
View File
@@ -42,7 +42,6 @@
class G4ParticleDefinition;
class G4CrossSectionDataStore;
class G4LogicalVolume;
class G4TauNeutrinoNucleusTotXsc;
class G4SafetyHelper;
@@ -59,21 +58,20 @@ public:
G4double previousStepSize,
G4ForceCondition* condition
) override;
G4double GetMeanFreePath(const G4Track &aTrack,
G4double, G4ForceCondition*) override;
G4VParticleChange* PostStepDoIt(const G4Track& aTrack,
const G4Step& aStep) override;
// initialise thresholds
void PreparePhysicsTable(const G4ParticleDefinition&) override;
const G4Step& aStep) override;
// set internal limit
virtual void SetLowestEnergy(G4double);
void SetLowestEnergy(G4double);
void ProcessDescription(std::ostream& outFile) const override;
void SetBiasingFactors(G4double bfCc, G4double bfNc);
void SetBiasingFactor(G4double bf);
G4double GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *) override;
// hide assignment operator as private
G4TauNeutrinoNucleusProcess& operator=
@@ -82,13 +80,13 @@ public:
private:
G4double lowestEnergy;
G4bool isInitialised{false};
G4String fEnvelopeName;
G4TauNeutrinoNucleusTotXsc* fTotXsc;
G4double fNuNuclCcBias{1.0}, fNuNuclNcBias{1.0}, fNuNuclTotXscBias{1.0};
G4double fXsc{0.0};
G4SafetyHelper* safetyHelper;
G4double lowestEnergy;
G4double fNuNuclCcBias{1.0};
G4double fNuNuclNcBias{1.0};
G4double fNuNuclTotXscBias{1.0};
G4String fEnvelopeName;
};
#endif
source/processes/hadronic/processes/src/G4ElNeutrinoNucleusProcess.cc
+20 -47
View File
@@ -48,8 +48,6 @@
#include "G4VDiscreteProcess.hh"
#include "G4ElNeutrinoNucleusTotXsc.hh"
//#include "G4NuMuNucleusCcModel.hh"
//#include "G4NuMuNucleusNcModel.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
@@ -64,26 +62,16 @@
///////////////////////////////////////////////////////////////////////////////
G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess( G4String anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fHadronInelastic ), isInitialised(false), fBiased(true) // fHadronElastic???
G4ElNeutrinoNucleusProcess::G4ElNeutrinoNucleusProcess(const G4String& anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fNuNucleus )
{
lowestEnergy = 1.*keV;
fEnvelope = nullptr;
fEnvelopeName = anEnvelopeName;
fTotXsc = new G4ElNeutrinoNucleusTotXsc();
fNuNuclCcBias = 1.;
fNuNuclNcBias = 1.;
fNuNuclTotXscBias = 1.;
fXsc = 0.;
safetyHelper = G4TransportationManager::GetTransportationManager()->GetSafetyHelper();
safetyHelper->InitialiseHelper();
}
G4ElNeutrinoNucleusProcess::~G4ElNeutrinoNucleusProcess()
{
if( fTotXsc ) delete fTotXsc;
}
///////////////////////////////////////////////////////
void G4ElNeutrinoNucleusProcess::SetBiasingFactor(G4double bf)
@@ -118,18 +106,13 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
//G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
// << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
G4String rName = aTrack.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
G4double totxsc(0.);
G4double totxsc =
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
if( rName == fEnvelopeName && fNuNuclTotXscBias > 1.)
if ( rName == fEnvelopeName )
{
totxsc = fNuNuclTotXscBias*
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
}
else
{
totxsc = GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
totxsc *= fNuNuclTotXscBias;
}
G4double res = (totxsc>0.0) ? 1.0/totxsc : DBL_MAX;
//G4cout << " xsection= " << totxsc << G4endl;
@@ -140,10 +123,9 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
void G4ElNeutrinoNucleusProcess::ProcessDescription(std::ostream& outFile) const
{
outFile << "G4ElNeutrinoNucleusProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
outFile << "G4ElNeutrinoNucleusProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
}
@@ -248,10 +230,11 @@ G4ElNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
G4HadProjectile theProj( track );
G4HadronicInteraction* hadi = nullptr;
G4HadFinalState* result = nullptr;
const G4Element* elm = GetCrossSectionDataStore()->SampleZandA(dynParticle, material,
*targNucleus);
const G4Element* elm =
GetCrossSectionDataStore()->SampleZandA(dynParticle, material,
*targNucleus);
G4int ZZ = elm->GetZasInt();
fXsc = fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
G4double ccTotRatio = fTotXsc->GetCcTotRatio();
if( G4UniformRand() < ccTotRatio ) // Cc-model
@@ -273,10 +256,10 @@ G4ElNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
else // Nc-model
{
if (pName == "nu_e" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
if (pName == "nu_e" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
size_t idx = track.GetMaterialCutsCouple()->GetIndex();
std::size_t idx = track.GetMaterialCutsCouple()->GetIndex();
G4double tcut = (*(G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(3)))[idx];
@@ -346,9 +329,9 @@ G4ElNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
if(efinal > 0.0)
{
outdir.rotate(phi, it);
outdir.rotateUz(indir);
theTotalResult->ProposeMomentumDirection(outdir);
outdir.rotate(phi, it);
outdir.rotateUz(indir);
theTotalResult->ProposeMomentumDirection(outdir);
}
else
{
@@ -408,16 +391,6 @@ G4ElNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
return theTotalResult;
}
void
G4ElNeutrinoNucleusProcess::PreparePhysicsTable(const G4ParticleDefinition& part)
{
if(!isInitialised) {
isInitialised = true;
// if(G4Neutron::Neutron() == &part) { lowestEnergy = 1.e-6*eV; }
}
G4HadronicProcess::PreparePhysicsTable(part);
}
void
G4ElNeutrinoNucleusProcess::SetLowestEnergy(G4double val)
{
source/processes/hadronic/processes/src/G4MuNeutrinoNucleusProcess.cc
+22 -56
View File
@@ -39,17 +39,15 @@
#include "G4MuNeutrinoNucleusProcess.hh"
#include "G4SystemOfUnits.hh"
#include "G4Nucleus.hh"
#include "G4HadronicException.hh"
#include "G4ProcessManager.hh"
#include "G4CrossSectionDataStore.hh"
#include "G4ProductionCutsTable.hh"
#include "G4HadronicException.hh"
#include "G4HadronicInteraction.hh"
#include "G4VCrossSectionRatio.hh"
#include "G4VDiscreteProcess.hh"
#include "G4MuNeutrinoNucleusTotXsc.hh"
//#include "G4NuMuNucleusCcModel.hh"
//#include "G4NuMuNucleusNcModel.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
@@ -64,26 +62,16 @@
///////////////////////////////////////////////////////////////////////////////
G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess( G4String anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fHadronInelastic ), isInitialised(false), fBiased(true) // fHadronElastic???
G4MuNeutrinoNucleusProcess::G4MuNeutrinoNucleusProcess(const G4String& anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fNuNucleus )
{
lowestEnergy = 1.*keV;
fEnvelope = nullptr;
fEnvelopeName = anEnvelopeName;
fTotXsc = new G4MuNeutrinoNucleusTotXsc();
fNuNuclCcBias=1.;
fNuNuclNcBias=1.;
fNuNuclTotXscBias=1.;
fXsc = 0.;
safetyHelper = G4TransportationManager::GetTransportationManager()->GetSafetyHelper();
safetyHelper = G4TransportationManager::GetTransportationManager()->GetSafetyHelper();
safetyHelper->InitialiseHelper();
}
G4MuNeutrinoNucleusProcess::~G4MuNeutrinoNucleusProcess()
{
if( fTotXsc ) delete fTotXsc;
}
///////////////////////////////////////////////////////
void G4MuNeutrinoNucleusProcess::SetBiasingFactor(G4double bf)
@@ -118,18 +106,12 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
//G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
// << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
G4String rName = aTrack.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
G4double totxsc(0.);
G4double totxsc = GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
if( rName == fEnvelopeName && fNuNuclTotXscBias > 1.)
if( rName == fEnvelopeName && fNuNuclTotXscBias > 1.)
{
totxsc = fNuNuclTotXscBias*
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
}
else
{
totxsc = GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
totxsc *= fNuNuclTotXscBias;
}
G4double res = (totxsc>0.0) ? 1.0/totxsc : DBL_MAX;
//G4cout << " xsection= " << totxsc << G4endl;
@@ -140,11 +122,9 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
void G4MuNeutrinoNucleusProcess::ProcessDescription(std::ostream& outFile) const
{
outFile << "G4MuNeutrinoNucleusProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
outFile << "G4MuNeutrinoNucleusProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
}
///////////////////////////////////////////////////////////////////////
@@ -152,9 +132,6 @@ void G4MuNeutrinoNucleusProcess::ProcessDescription(std::ostream& outFile) const
G4VParticleChange*
G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& step)
{
// track.GetVolume()->GetLogicalVolume()->GetName()
// if( track.GetVolume()->GetLogicalVolume() != fEnvelope )
G4String rName = track.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
if( rName != fEnvelopeName )
@@ -205,12 +182,12 @@ G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
// NOTE: Very low energy scatters were causing numerical (FPE) errors
// in earlier releases; these limits have not been changed since.
if ( kineticEnergy <= lowestEnergy ) return theTotalResult;
if ( kineticEnergy <= lowestEnergy ) return theTotalResult;
const G4Material* material = track.GetMaterial();
G4Nucleus* targNucleus = GetTargetNucleusPointer();
//////////////// uniform random spread of the neutrino interaction point ////////////
///// uniform random spread of the neutrino interaction point ////////////
const G4StepPoint* pPostStepPoint = step.GetPostStepPoint();
const G4DynamicParticle* aParticle = track.GetDynamicParticle();
@@ -248,10 +225,10 @@ G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
G4HadProjectile theProj( track );
G4HadronicInteraction* hadi = nullptr;
G4HadFinalState* result = nullptr;
const G4Element* elm = GetCrossSectionDataStore()->SampleZandA(dynParticle, material,
*targNucleus);
const G4Element* elm =
GetCrossSectionDataStore()->SampleZandA(dynParticle, material, *targNucleus);
G4int ZZ = elm->GetZasInt();
fXsc = fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
G4double ccTotRatio = fTotXsc->GetCcTotRatio();
if( G4UniformRand() < ccTotRatio ) // Cc-model
@@ -272,11 +249,10 @@ G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
}
else // Nc-model
{
if (pName == "nu_mu" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
if (pName == "nu_mu" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
size_t idx = track.GetMaterialCutsCouple()->GetIndex();
std::size_t idx = track.GetMaterialCutsCouple()->GetIndex();
G4double tcut = (*(G4ProductionCutsTable::GetProductionCutsTable()->GetEnergyCutsVector(3)))[idx];
@@ -346,9 +322,9 @@ G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
if(efinal > 0.0)
{
outdir.rotate(phi, it);
outdir.rotateUz(indir);
theTotalResult->ProposeMomentumDirection(outdir);
outdir.rotate(phi, it);
outdir.rotateUz(indir);
theTotalResult->ProposeMomentumDirection(outdir);
}
else
{
@@ -408,16 +384,6 @@ G4MuNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& ste
return theTotalResult;
}
void
G4MuNeutrinoNucleusProcess::PreparePhysicsTable(const G4ParticleDefinition& part)
{
if(!isInitialised) {
isInitialised = true;
// if(G4Neutron::Neutron() == &part) { lowestEnergy = 1.e-6*eV; }
}
G4HadronicProcess::PreparePhysicsTable(part);
}
void
G4MuNeutrinoNucleusProcess::SetLowestEnergy(G4double val)
{
source/processes/hadronic/processes/src/G4NeutrinoElectronProcess.cc
+10 -52
View File
@@ -47,8 +47,6 @@
#include "G4VDiscreteProcess.hh"
#include "G4NeutrinoElectronTotXsc.hh"
//#include "G4NeutrinoElectronCcModel.hh"
//#include "G4NeutrinoElectronNcModel.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
@@ -63,25 +61,16 @@
///////////////////////////////////////////////////////////////////////////////
G4NeutrinoElectronProcess::G4NeutrinoElectronProcess( G4String anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fHadronElastic ), isInitialised(false), fBiased(true) // fHadronElastic???
G4NeutrinoElectronProcess::G4NeutrinoElectronProcess(const G4String& anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fNuElectron )
{
lowestEnergy = 1.*keV;
fEnvelope = nullptr;
fEnvelopeName = anEnvelopeName;
fTotXsc = new G4NeutrinoElectronTotXsc();
fNuEleCcBias = 1.;
fNuEleNcBias = 1.;
fNuEleTotXscBias = 1.;
safetyHelper = G4TransportationManager::GetTransportationManager()->GetSafetyHelper();
safetyHelper->InitialiseHelper();
}
G4NeutrinoElectronProcess::~G4NeutrinoElectronProcess()
{
if( fTotXsc ) delete fTotXsc;
}
///////////////////////////////////////////////////////
void G4NeutrinoElectronProcess::SetBiasingFactor(G4double bf)
@@ -116,29 +105,13 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
//G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
// << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
G4String rName = aTrack.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
G4double totxsc(0.);
try
{
if( rName == fEnvelopeName && fNuEleTotXscBias > 1.)
{
totxsc = fNuEleTotXscBias*
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
G4double totxsc =
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
}
else
{
totxsc = GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
}
}
catch(G4HadronicException & aR)
if ( rName == fEnvelopeName )
{
G4ExceptionDescription ed;
aR.Report(ed);
DumpState(aTrack,"GetMeanFreePath",ed);
ed << " Cross section is not available" << G4endl;
G4Exception("G4NeutrinoElectronProcess::GetMeanFreePath", "had002", FatalException,
ed);
totxsc *= fNuEleTotXscBias;
}
G4double res = (totxsc>0.0) ? 1.0/totxsc : DBL_MAX;
//G4cout << " xsection= " << totxsc << G4endl;
@@ -149,11 +122,9 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
void G4NeutrinoElectronProcess::ProcessDescription(std::ostream& outFile) const
{
outFile << "G4NeutrinoElectronProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
outFile << "G4NeutrinoElectronProcess handles the scattering of \n"
<< "neutrino on electrons by invoking the following model(s) and \n"
<< "cross section(s).\n";
}
///////////////////////////////////////////////////////////////////////
@@ -161,9 +132,6 @@ void G4NeutrinoElectronProcess::ProcessDescription(std::ostream& outFile) const
G4VParticleChange*
G4NeutrinoElectronProcess::PostStepDoIt(const G4Track& track, const G4Step& step)
{
// track.GetVolume()->GetLogicalVolume()->GetName()
// if( track.GetVolume()->GetLogicalVolume() != fEnvelope )
G4String rName = track.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
if( rName != fEnvelopeName )
@@ -429,16 +397,6 @@ G4NeutrinoElectronProcess::PostStepDoIt(const G4Track& track, const G4Step& step
return theTotalResult;
}
void
G4NeutrinoElectronProcess::PreparePhysicsTable(const G4ParticleDefinition& part)
{
if(!isInitialised) {
isInitialised = true;
if(G4Neutron::Neutron() == &part) { lowestEnergy = 1.e-6*eV; }
}
G4HadronicProcess::PreparePhysicsTable(part);
}
void
G4NeutrinoElectronProcess::SetLowestEnergy(G4double val)
{
source/processes/hadronic/processes/src/G4NuVacOscProcess.cc
+25 -35
View File
@@ -30,7 +30,7 @@
//
// Modified:
//
// 5.4.23 V.Grichine - first implementation
// 05.04.23 V.Grichine - first implementation
//
#include <iostream>
@@ -38,14 +38,7 @@
#include "G4NuVacOscProcess.hh"
#include "G4SystemOfUnits.hh"
#include "G4Nucleus.hh"
#include "G4ProcessManager.hh"
#include "G4CrossSectionDataStore.hh"
#include "G4ProductionCutsTable.hh"
#include "G4HadronicException.hh"
#include "G4HadronicInteraction.hh"
#include "G4VCrossSectionRatio.hh"
#include "G4VDiscreteProcess.hh"
#include "G4MuNeutrinoNucleusTotXsc.hh"
#include "G4HadronicProcessType.hh"
#include "G4RotationMatrix.hh"
#include "G4ThreeVector.hh"
#include "G4AffineTransform.hh"
@@ -67,8 +60,9 @@
G4NuVacOscProcess::G4NuVacOscProcess(const G4String& eName, const G4String& pName)
: G4HadronicProcess( pName, fHadronInelastic )
: G4VDiscreteProcess( pName, fHadronic )
{
SetProcessSubType(fNuOscillation);
fLowestEnergy = 1.*eV;
fEnvelopeName = eName;
theNuE = G4NeutrinoE::NeutrinoE();
@@ -181,44 +175,40 @@ void G4NuVacOscProcess::ProcessDescription(std::ostream& outFile) const
G4VParticleChange*
G4NuVacOscProcess::PostStepDoIt(const G4Track& track, const G4Step& step)
{
if( track.GetTrackStatus() != fAlive )
{
return theTotalResult;
aParticleChange.Clear();
aParticleChange.Initialize(track);
if ( track.GetTrackStatus() != fAlive )
{
return &aParticleChange;
}
theTotalResult->Clear();
theTotalResult->Initialize(track);
G4double weight = track.GetWeight();
theTotalResult->ProposeWeight(weight);
aParticleChange.ProposeWeight(weight);
G4double kineticEnergy = track.GetKineticEnergy();
if ( kineticEnergy <= fLowestEnergy ) return theTotalResult;
if ( kineticEnergy <= fLowestEnergy )
{
return &aParticleChange;
}
const G4DynamicParticle* dynParticle = track.GetDynamicParticle();
const G4ParticleDefinition* part = dynParticle->GetDefinition();
G4LorentzVector lv1 = dynParticle->Get4Momentum();
G4int aa(0), bb(0); // neutrino flavors
G4double ll = track.GetTrackLength(); // total track length
const G4String rName =
step.GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
if(rName == fEnvelopeName && fNuNuclTotXscBias > 1.) ll *= fNuNuclTotXscBias;
G4DynamicParticle* aLept = nullptr;
G4DynamicParticle* aLept = nullptr;
if( part == theAntiNuE ||
part == theAntiNuMu ||
part == theAntiNuTau ) fAnti = true;
else fAnti = false;
fAnti = (part == theAntiNuE || part == theAntiNuMu || part == theAntiNuTau);
if( part == theNuE || part == theAntiNuE ) aa = 0;
else if( part == theNuMu || part == theAntiNuMu ) aa = 1;
else aa = 2;
bb = NuVacProbability( aa, kineticEnergy, ll); // oscillation engine
// neutrino flavors aa and bb
G4int aa = 2;
if (part == theNuE || part == theAntiNuE) { aa = 0; }
else if(part == theNuMu || part == theAntiNuMu ) { aa = 1; }
G4int bb = NuVacProbability( aa, kineticEnergy, ll); // oscillation engine
if( bb == aa ) // no change
{
return theTotalResult;
return &aParticleChange;
}
else if( bb == 0 ) // new flavor (anti)neutrino - kill initial & add new
{
@@ -235,10 +225,10 @@ G4NuVacOscProcess::PostStepDoIt(const G4Track& track, const G4Step& step)
if( !fAnti ) aLept = new G4DynamicParticle( theNuTau, lv1 );
else aLept = new G4DynamicParticle( theAntiNuTau, lv1 );
}
theTotalResult->ProposeTrackStatus( fStopAndKill );
theTotalResult->AddSecondary( aLept );
aParticleChange.ProposeTrackStatus( fStopAndKill );
aParticleChange.AddSecondary( aLept );
return theTotalResult;
return &aParticleChange;
}
/////////////////////////////////////////////////////
source/processes/hadronic/processes/src/G4TauNeutrinoNucleusProcess.cc
+9 -24
View File
@@ -60,7 +60,7 @@
G4TauNeutrinoNucleusProcess::G4TauNeutrinoNucleusProcess(const G4String& anEnvelopeName, const G4String& pName)
: G4HadronicProcess( pName, fHadronInelastic )
: G4HadronicProcess( pName, fNuNucleus )
{
lowestEnergy = 1.*keV;
fEnvelopeName = anEnvelopeName;
@@ -103,18 +103,13 @@ GetMeanFreePath(const G4Track &aTrack, G4double, G4ForceCondition *)
//G4cout << "GetMeanFreePath " << aTrack.GetDefinition()->GetParticleName()
// << " Ekin= " << aTrack.GetKineticEnergy() << G4endl;
G4String rName = aTrack.GetStep()->GetPreStepPoint()->GetPhysicalVolume()->GetLogicalVolume()->GetRegion()->GetName();
G4double totxsc(0.);
G4double totxsc =
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
if( rName == fEnvelopeName && fNuNuclTotXscBias > 1.)
if( rName == fEnvelopeName )
{
totxsc = fNuNuclTotXscBias*
GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
}
else
{
totxsc = GetCrossSectionDataStore()->ComputeCrossSection(aTrack.GetDynamicParticle(),
aTrack.GetMaterial());
totxsc *= fNuNuclTotXscBias;
}
G4double res = (totxsc>0.0) ? 1.0/totxsc : DBL_MAX;
//G4cout << " xsection= " << totxsc << G4endl;
@@ -236,7 +231,7 @@ G4TauNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& st
const G4Element* elm = GetCrossSectionDataStore()->SampleZandA(dynParticle, material,
*targNucleus);
G4int ZZ = elm->GetZasInt();
fXsc = fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
fTotXsc->GetElementCrossSection(dynParticle, ZZ, material);
G4double ccTotRatio = fTotXsc->GetCcTotRatio();
if( G4UniformRand() < ccTotRatio ) // Cc-model
@@ -258,8 +253,8 @@ G4TauNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& st
else // Nc-model
{
if (pName == "nu_tau" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
if (pName == "nu_tau" ) hadi = (GetHadronicInteractionList())[1];
else hadi = (GetHadronicInteractionList())[3];
size_t idx = track.GetMaterialCutsCouple()->GetIndex();
@@ -393,16 +388,6 @@ G4TauNeutrinoNucleusProcess::PostStepDoIt(const G4Track& track, const G4Step& st
return theTotalResult;
}
void
G4TauNeutrinoNucleusProcess::PreparePhysicsTable(const G4ParticleDefinition& part)
{
if(!isInitialised) {
isInitialised = true;
// if(G4Neutron::Neutron() == &part) { lowestEnergy = 1.e-6*eV; }
}
G4HadronicProcess::PreparePhysicsTable(part);
}
void
G4TauNeutrinoNucleusProcess::SetLowestEnergy(G4double val)
{