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

Import Geant4 10.5.1 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2019-04-17 10:39:02 +02:00
parent a7fdc52004
commit 28a70706e0
661 changed files with 55791 additions and 106984 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/physics_lists/constructors/electromagnetic/History
+18
View File
@@ -13,6 +13,24 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
09 April 2019, V.Ivanchenko (phys-ctor-em-V10-04-22)
20 March 2019, D.Sawkey
- G4OpticalPhysics, G4OpticalPhysicsMessenger - put all UI commands
into messenger class; fix bug 2085; deprecate commands with
/default/ in command string
07 March 2019, V.Ivanchenko
- G4EmLivermorePhysics, G4EmPenelopePhysics - make msc configuration
as in Opt4 : RangeFactor=0.08, Skin=3, UserSafetyPlus
- G4EmModelActivator - fixed problem 2106
18 January 2019, V.Ivanchenko
- G4EmStandardPhysicsWVI - use G4eplusTo2GammaOKVIModel with 3-gamma
annihilation for e+
14 January 2019, V.Ivanchenko
- G4EmStandardPhysics_option4 - change RangeFactor to 0.08 in
order to have expected results from fanoCavity test (M.Novak)
19 December 2018, V.Ivanchenko
- G4EmModelActivator - fixed clang7 compilation warning
27 November 2018, V.Ivanchenko (phys-ctor-em-V10-04-21)
- G4EmStandardPhysics_option2 - use the same models and parameters as
in LHCb EM physics constructor
source/physics_lists/constructors/electromagnetic/include/G4OpticalPhysics.hh
+65 -29
View File
@@ -42,19 +42,24 @@
#ifndef G4OpticalPhysics_h
#define G4OpticalPhysics_h 1
#include "globals.hh"
#include "G4VPhysicsConstructor.hh"
#include "G4OpticalProcessIndex.hh"
#include "G4OpticalPhysicsMessenger.hh"
#include "G4OpticalSurface.hh"
#include "G4VPhysicsConstructor.hh"
#include "globals.hh"
#include <vector>
class G4VProcess;
class G4EmSaturation;
class G4Scintillation;
class G4Cerenkov;
class G4OpWLS;
class G4OpRayleigh;
class G4OpMieHG;
class G4OpBoundaryProcess;
class G4OpAbsorption;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -83,24 +88,38 @@ class G4OpticalPhysics : public G4VPhysicsConstructor
// configure G4OpticalPhysics builder
void Configure(G4OpticalProcessIndex, G4bool );
void SetMaxNumPhotonsPerStep(G4int );
void SetMaxBetaChangePerStep(G4double );
void SetTrackSecondariesFirst(G4OpticalProcessIndex, G4bool );
// Cerenkov
void SetMaxNumPhotonsPerStep(G4int);
void SetMaxBetaChangePerStep(G4double);
void SetCerenkovStackPhotons(G4bool);
void SetCerenkovTrackSecondariesFirst(G4bool);
void SetCerenkovVerbosity(G4int);
// Scintillation
void SetScintillationYieldFactor(G4double );
void SetScintillationExcitationRatio(G4double );
void SetWLSTimeProfile(G4String );
void SetScintillationByParticleType(G4bool );
void SetScintillationTrackInfo(G4bool );
void SetScintillationTrackSecondariesFirst(G4bool);
void SetFiniteRiseTime(G4bool );
void SetScintillationStackPhotons(G4bool );
void SetScintillationVerbosity(G4int);
//void AddScintillationSaturation(G4EmSaturation* );
void SetTrackSecondariesFirst(G4OpticalProcessIndex, G4bool );
void SetFiniteRiseTime(G4bool );
void SetCerenkovStackPhotons(G4bool );
void SetScintillationStackPhotons(G4bool );
// WLS
void SetWLSTimeProfile(G4String );
void SetWLSVerbosity(G4int);
//boundary
void SetBoundaryVerbosity(G4int);
void SetInvokeSD(G4bool );
void SetAbsorptionVerbosity(G4int);
void SetRayleighVerbosity(G4int);
void SetMieVerbosity(G4int);
private:
// methods
@@ -116,21 +135,14 @@ class G4OpticalPhysics : public G4VPhysicsConstructor
// the option to track secondaries before finishing their parent track
std::vector<G4bool> fProcessTrackSecondariesFirst;
/// max number of Cerenkov photons per step
G4int fMaxNumPhotons;
/// max change of beta per step
G4double fMaxBetaChange;
// scintillation /////////////////
static G4ThreadLocal G4Scintillation* fScintillationProcess;
/// scintillation yield factor
G4double fYieldFactor;
/// scintillation excitation ratio
G4double fExcitationRatio;
/// the WLS process time profile
G4String fProfile;
/// option to set a finite rise-time; Note: the G4Scintillation
/// process expects the user to have set the constant material
/// property FAST/SLOWSCINTILLATIONRISETIME
@@ -145,15 +157,39 @@ class G4OpticalPhysics : public G4VPhysicsConstructor
/// to be attached to a scintillation photon's track
G4bool fScintillationTrackInfo;
/// option to allow for G4OpBoundaryProcess
/// to call/not call InvokeSD method
G4bool fInvokeSD;
/// option to allow stacking of secondary Cerenkov photons
G4bool fCerenkovStackPhotons;
/// option to allow stacking of secondary Scintillation photons
G4bool fScintillationStackPhotons;
G4int fScintillationVerbosity;
////////////////// Cerenkov
static G4ThreadLocal G4Cerenkov* fCerenkovProcess;
/// max number of Cerenkov photons per step
G4int fMaxNumPhotons;
/// max change of beta per step
G4double fMaxBetaChange;
/// option to allow stacking of secondary Cerenkov photons
G4bool fCerenkovStackPhotons;
G4int fCerenkovVerbosity;
///////////////// WLS
static G4ThreadLocal G4OpWLS* fWLSProcess;
G4String fWLSTimeProfileName;
G4int fWLSVerbosity;
static G4ThreadLocal G4OpAbsorption* fAbsorptionProcess;
G4int fAbsorptionVerbosity;
static G4ThreadLocal G4OpRayleigh* fRayleighProcess;
G4int fRayleighVerbosity;
static G4ThreadLocal G4OpMieHG* fMieProcess;
G4int fMieVerbosity;
static G4ThreadLocal G4OpBoundaryProcess* fBoundaryProcess;
/// G4OpBoundaryProcess to call InvokeSD method
G4bool fInvokeSD;
G4int fBoundaryVerbosity;
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
source/physics_lists/constructors/electromagnetic/include/G4OpticalPhysicsMessenger.hh
+66 -50
View File
@@ -42,11 +42,11 @@
#ifndef G4OpticalPhysicsMessenger_h
#define G4OpticalPhysicsMessenger_h 1
#include "globals.hh"
#include "G4UImessenger.hh"
#include "G4OpticalProcessIndex.hh"
#include "globals.hh"
class G4VProcess;
class G4OpticalPhysics;
@@ -58,20 +58,6 @@ class G4UIcmdWithAnInteger;
class G4UIcommand;
// Messenger class that defines commands for the optical physics
//
// Implements commands:
// - /process/optical/processActivation proc_name flag
// - /process/optical/verbose level
// - /process/optical/setTrackSecondariesFirst proc_name flag
// - /process/optical/defaults/cerenkov/setMaxPhotons val
// - /process/optical/defaults/cerenkov/setMaxBetaChange val
// - /process/optical/defaults/cerenkov/setStackPhotons flag
// - /process/optical/defaults/scintillation/setYieldFactor val
// - /process/optical/defaults/scintillation/setByParticleType val
// - /process/optical/defaults/scintillation/setFiniteRiseTime val
// - /process/optical/defaults/scintillation/setStackPhotons flag
// - /process/optical/defaults/wls/setTimeProfile val
// - /process/optical/defaults/boundary/setInvokeSD flag
class G4OpticalPhysicsMessenger: public G4UImessenger
{
@@ -92,10 +78,12 @@ private:
/// Not implemented
G4OpticalPhysicsMessenger& operator=(const G4OpticalPhysicsMessenger& right);
void Deprecated(void);
// data members
/// associated class
G4OpticalPhysics* fOpticalPhysics;
G4OpticalPhysics* fOpticalPhysics;
/// command directory
G4UIdirectory* fDir;
@@ -105,47 +93,75 @@ private:
G4OpticalProcessIndex fSelectedProcessIndex;
/// selectOpProcess command
G4UIcommand* fActivateProcessCmd;
G4UIcommand* fActivateProcessCmd;
/// setProcessVerbose command
G4UIcmdWithAnInteger* fSetOpProcessVerboseCmd;
/// setCerenkovMaxPhotons command
G4UIcmdWithAnInteger* fSetCerenkovMaxPhotonsCmd;
/// setCerenkovMaxBetaChange command
G4UIcmdWithADouble* fSetCerenkovMaxBetaChangeCmd;
/// setStackPhotons command
G4UIcmdWithABool* fSetCerenkovStackPhotonsCmd;
/// setScintillationYieldFactor command
G4UIcmdWithADouble* fSetScintillationYieldFactorCmd;
/// setScintillationByParticleType command
G4UIcmdWithABool* fSetScintillationByParticleTypeCmd;
/// setScintillationTrackInfo command
G4UIcmdWithABool* fSetScintillationTrackInfoCmd;
/// setStackPhotons command
G4UIcmdWithABool* fSetScintillationStackPhotonsCmd;
// /// setOpticalSurfaceModel command
// G4UIcmdWithAString* fSetOpticalSurfaceModelCmd;
/// setWLSTimeProfile command
G4UIcmdWithAString* fSetWLSTimeProfileCmd;
G4UIcmdWithAnInteger* fVerboseCmd;
/// setTrackSecondariesFirst command
G4UIcommand* fSetTrackSecondariesFirstCmd;
G4UIcommand* fTrackSecondariesFirstCmd;
// Cerenkov
/// setCerenkovMaxPhotons command
G4UIcmdWithAnInteger* fCerenkovMaxPhotonsCmd;
G4UIcmdWithAnInteger* fCerenkovMaxPhotons1Cmd;
/// setCerenkovMaxBetaChange command
G4UIcmdWithADouble* fCerenkovMaxBetaChangeCmd;
G4UIcmdWithADouble* fCerenkovMaxBetaChange1Cmd;
/// setStackPhotons command
G4UIcmdWithABool* fCerenkovStackPhotonsCmd;
G4UIcmdWithABool* fCerenkovStackPhotons1Cmd;
G4UIcmdWithABool* fCerenkovTrackSecondariesFirstCmd;
G4UIcmdWithAnInteger* fCerenkovVerbosityCmd;
// Scintillation
/// setScintillationYieldFactor command
G4UIcmdWithADouble* fScintYieldFactorCmd;
G4UIcmdWithADouble* fScintYieldFactor1Cmd;
/// setScintillationByParticleType command
G4UIcmdWithABool* fScintByParticleTypeCmd;
G4UIcmdWithABool* fScintByParticleType1Cmd;
/// setScintillationTrackInfo command
G4UIcmdWithABool* fScintTrackInfoCmd;
G4UIcmdWithABool* fScintTrackInfo1Cmd;
/// setStackPhotons command
G4UIcmdWithABool* fScintStackPhotonsCmd;
G4UIcmdWithABool* fScintStackPhotons1Cmd;
G4UIcmdWithADouble* fScintExcitationRatioCmd;
G4UIcmdWithABool* fScintTrackSecondariesFirstCmd;
G4UIcmdWithAnInteger* fScintillationVerbosityCmd;
/// setFiniteRiseTime command
G4UIcmdWithABool* fSetFiniteRiseTimeCmd;
G4UIcmdWithABool* fScintFiniteRiseTimeCmd;
G4UIcmdWithABool* fScintFiniteRiseTime1Cmd;
G4UIcmdWithAnInteger* fScintVerbosityCmd;
// WLS
/// setWLSTimeProfile command
G4UIcmdWithAString* fWLSTimeProfileCmd;
G4UIcmdWithAString* fWLSTimeProfile1Cmd;
G4UIcmdWithAnInteger* fWLSVerbosityCmd;
/// setInvokeSD command
G4UIcmdWithABool* fSetInvokeSDCmd;
G4UIcmdWithABool* fBoundaryInvokeSDCmd;
G4UIcmdWithABool* fBoundaryInvokeSD1Cmd;
G4UIcmdWithAnInteger* fBoundaryVerbosityCmd;
G4UIcmdWithAnInteger* fAbsorptionVerbosityCmd;
G4UIcmdWithAnInteger* fRayleighVerbosityCmd;
G4UIcmdWithAnInteger* fMieVerbosityCmd;
};
source/physics_lists/constructors/electromagnetic/src/G4EmLivermorePhysics.cc
+2 -5
View File
@@ -146,7 +146,7 @@ G4EmLivermorePhysics::G4EmLivermorePhysics(G4int ver, const G4String&)
param->SetUseMottCorrection(true);
param->SetMscStepLimitType(fUseSafetyPlus);
param->SetMscSkin(3);
param->SetMscRangeFactor(0.2);
param->SetMscRangeFactor(0.08);
param->SetMuHadLateralDisplacement(true);
//param->SetUseICRU90Data(true);
param->SetFluo(true);
@@ -232,7 +232,6 @@ void G4EmLivermorePhysics::ConstructProcess()
// nuclear stopping
G4NuclearStopping* pnuc = new G4NuclearStopping();
G4NuclearStopping* inuc = new G4NuclearStopping();
// Add Livermore EM Processes
G4ParticleTable* table = G4ParticleTable::GetParticleTable();
@@ -376,7 +375,7 @@ void G4EmLivermorePhysics::ConstructProcess()
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(inuc, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
@@ -412,7 +411,6 @@ void G4EmLivermorePhysics::ConstructProcess()
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
@@ -453,7 +451,6 @@ void G4EmLivermorePhysics::ConstructProcess()
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
inuc->SetMaxKinEnergy(MeV);
// Deexcitation
//
source/physics_lists/constructors/electromagnetic/src/G4EmModelActivator.cc
+28 -19
View File
@@ -185,11 +185,9 @@ void G4EmModelActivator::ActivateEmOptions()
if("G4EmStandard" == typesPhys[i]) {
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetLocked(true);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = new G4UrbanMscModel();
msc->SetLocked(true);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
} else if("G4EmStandard_opt1" == typesPhys[i] ||
@@ -197,13 +195,11 @@ void G4EmModelActivator::ActivateEmOptions()
G4UrbanMscModel* msc = new G4UrbanMscModel();
msc->SetStepLimitType(fMinimal);
msc->SetRangeFactor(0.2);
msc->SetLocked(true);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = new G4UrbanMscModel();
msc->SetStepLimitType(fMinimal);
msc->SetRangeFactor(0.2);
msc->SetLocked(true);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
} else if("G4EmStandard_opt3" == typesPhys[i]) {
@@ -231,6 +227,7 @@ void G4EmModelActivator::ActivateEmOptions()
FindOrAddProcess(prot, "CoulombScat");
em_config->SetExtraEmModel("proton", "CoulombScat", dummy, reg);
theParameters->SetNumberOfBinsPerDecade(20);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(reg, true, false, false);
}
@@ -247,17 +244,24 @@ void G4EmModelActivator::ActivateEmOptions()
} else if("G4EmStandard_opt4" == typesPhys[i]) {
G4VMscModel* msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
theParameters->SetNumberOfBinsPerDecade(20);
theParameters->SetUseMottCorrection(true);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(reg, true, false, false);
//theParameters->SetStepFunction(0.2, 10*um);
//theParameters->SetStepFunctionMuHad(0.1, 10*um);
}
theParameters->DefineRegParamForDeex(adeexc);
FindOrAddProcess(phot, "Rayl");
mod = new G4LivermoreRayleighModel();
em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
@@ -271,30 +275,19 @@ void G4EmModelActivator::ActivateEmOptions()
} else if("G4EmStandardGS" == typesPhys[i]) {
G4GoudsmitSaundersonMscModel* msc = new G4GoudsmitSaundersonMscModel();
msc->SetRangeFactor(0.06);
msc->SetLocked(true);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = new G4GoudsmitSaundersonMscModel();
msc->SetRangeFactor(0.06);
msc->SetLocked(true);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
} else if("G4EmStandardWVI" == typesPhys[i]) {
G4WentzelVIModel* msc = new G4WentzelVIModel();
msc->SetLocked(true);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = new G4WentzelVIModel();
msc->SetLocked(true);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
FindOrAddProcess(elec, "CoulombScat");
FindOrAddProcess(posi, "CoulombScat");
mod = new G4eCoulombScatteringModel();
em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, mscEnergyLimit);
mod = new G4eCoulombScatteringModel();
em_config->SetExtraEmModel("e+", "CoulombScat", mod, reg, 0.0, mscEnergyLimit);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
@@ -328,9 +321,15 @@ void G4EmModelActivator::ActivateEmOptions()
} else if("G4EmLivermore" == typesPhys[i]) {
G4VMscModel* msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
mod = new G4LivermorePhotoElectricModel();
@@ -350,6 +349,8 @@ void G4EmModelActivator::ActivateEmOptions()
mod = new G4LivermoreBremsstrahlungModel();
em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, highEnergyLimit);
theParameters->SetNumberOfBinsPerDecade(20);
theParameters->SetUseMottCorrection(true);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
@@ -358,9 +359,15 @@ void G4EmModelActivator::ActivateEmOptions()
} else if("G4EmPenelope" == typesPhys[i]) {
G4VMscModel* msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy);
msc = GetGSModel();
msc->SetRangeFactor(0.08);
msc->SetSkin(3);
msc->SetStepLimitType(fUseSafetyPlus);
AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy);
mod = new G4PenelopePhotoElectricModel();
@@ -388,6 +395,8 @@ void G4EmModelActivator::ActivateEmOptions()
mod = new G4PenelopeAnnihilationModel();
em_config->SetExtraEmModel("e+", "annihil", mod, reg, 0.0, highEnergyLimit);
theParameters->SetNumberOfBinsPerDecade(20);
theParameters->SetUseMottCorrection(true);
if(G4Threading::IsMasterThread()) {
theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
}
@@ -428,7 +437,7 @@ void G4EmModelActivator::ActivatePAI()
const std::vector<G4VEnergyLossProcess*>& v = G4LossTableManager::Instance()
->GetEnergyLossProcessVector();
std::vector<G4VEnergyLossProcess*>::const_iterator itr;
G4RegionStore* regionStore = G4RegionStore::GetInstance();
const G4ParticleDefinition* elec = G4Electron::Electron();
@@ -462,7 +471,6 @@ void G4EmModelActivator::ActivatePAI()
else if (p == gion)
{ name = "ionIoni"; }
//for(itr = v.begin(); itr != v.end(); ++itr) {
for(auto proc : v) {
if(!proc->IsIonisationProcess()) { continue; }
@@ -711,6 +719,7 @@ void G4EmModelActivator::AddStandardScattering(const G4ParticleDefinition* part,
G4String pname = part->GetParticleName();
// low-energy msc model
mscmod->SetLocked(true);
em_config->SetExtraEmModel(pname, "msc", mscmod, reg, 0.0, e1);
// high energy msc model
source/physics_lists/constructors/electromagnetic/src/G4EmPenelopePhysics.cc
+3 -5
View File
@@ -148,7 +148,7 @@ G4EmPenelopePhysics::G4EmPenelopePhysics(G4int ver, const G4String&)
param->SetUseMottCorrection(true);
param->SetMscStepLimitType(fUseSafetyPlus);
param->SetMscSkin(3);
param->SetMscRangeFactor(0.2);
param->SetMscRangeFactor(0.08);
param->SetMuHadLateralDisplacement(true);
param->SetFluo(true);
//param->SetAugerCascade(true);
@@ -233,7 +233,6 @@ void G4EmPenelopePhysics::ConstructProcess()
// nuclear stopping
G4NuclearStopping* pnuc = new G4NuclearStopping();
G4NuclearStopping* inuc = new G4NuclearStopping();
//Applicability range for Penelope models
//for higher energies, the Standard models are used
@@ -395,7 +394,7 @@ void G4EmPenelopePhysics::ConstructProcess()
ph->RegisterProcess(hmsc, particle);
ph->RegisterProcess(ionIoni, particle);
ph->RegisterProcess(inuc, particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "pi+" ||
particleName == "pi-" ) {
@@ -423,6 +422,7 @@ void G4EmPenelopePhysics::ConstructProcess()
particleName == "anti_proton") {
G4hMultipleScattering* pmsc = new G4hMultipleScattering();
pmsc->SetEmModel(new G4WentzelVIModel());
G4hIonisation* hIoni = new G4hIonisation();
ph->RegisterProcess(pmsc, particle);
@@ -430,7 +430,6 @@ void G4EmPenelopePhysics::ConstructProcess()
ph->RegisterProcess(pb, particle);
ph->RegisterProcess(pp, particle);
ph->RegisterProcess(new G4CoulombScattering(), particle);
ph->RegisterProcess(pnuc, particle);
} else if (particleName == "B+" ||
particleName == "B-" ||
@@ -471,7 +470,6 @@ void G4EmPenelopePhysics::ConstructProcess()
// Nuclear stopping
pnuc->SetMaxKinEnergy(MeV);
inuc->SetMaxKinEnergy(MeV);
// Deexcitation
//
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysicsWVI.cc
+5 -1
View File
@@ -86,6 +86,7 @@
#include "G4IonParametrisedLossModel.hh"
#include "G4BraggIonModel.hh"
#include "G4NuclearStopping.hh"
#include "G4eplusTo2GammaOKVIModel.hh"
#include "G4ParticleTable.hh"
#include "G4Gamma.hh"
@@ -248,10 +249,13 @@ void G4EmStandardPhysicsWVI::ConstructProcess()
msc->SetEmModel(new G4WentzelVIModel());
G4CoulombScattering* ss = new G4CoulombScattering();
G4eplusAnnihilation* ann = new G4eplusAnnihilation();
ann->SetEmModel(new G4eplusTo2GammaOKVIModel());
ph->RegisterProcess(msc, particle);
ph->RegisterProcess(new G4eIonisation(), particle);
ph->RegisterProcess(new G4eBremsstrahlung(), particle);
ph->RegisterProcess(new G4eplusAnnihilation(), particle);
ph->RegisterProcess(ann, particle);
ph->RegisterProcess(ss, particle);
} else if (particleName == "mu+" ||
source/physics_lists/constructors/electromagnetic/src/G4EmStandardPhysics_option4.cc
+4 -4
View File
@@ -139,10 +139,10 @@ G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver,
param->ActivateAngularGeneratorForIonisation(true);
param->SetStepFunction(0.2, 10*um);
param->SetStepFunctionMuHad(0.1, 20*um);
param->SetUseMottCorrection(true); // use Mott-correction for e-/e+ msc gs
param->SetMscStepLimitType(fUseSafetyPlus); // error-free stepping for e-/e+ msc gs
param->SetMscSkin(3); // error-free stepping for e-/e+ msc gs
param->SetMscRangeFactor(0.2); // error-free stepping for e-/e+ msc gs
param->SetUseMottCorrection(true); // use Mott-correction for e-/e+ msc gs
param->SetMscStepLimitType(fUseSafetyPlus); // for e-/e+ msc gs
param->SetMscSkin(3); // error-free stepping for e-/e+ msc gs
param->SetMscRangeFactor(0.08); // error-free stepping for e-/e+ msc gs
param->SetMuHadLateralDisplacement(true);
param->SetFluo(true);
//param->SetAugerCascade(true);
source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysics.cc
+206 -241
View File
@@ -38,12 +38,11 @@
#include "G4OpticalPhysics.hh"
//#include "G4OpticalPhoton.hh"
#include "G4OpAbsorption.hh"
#include "G4OpRayleigh.hh"
#include "G4OpMieHG.hh"
#include "G4OpBoundaryProcess.hh"
#include "G4OpWLS.hh"
#include "G4Scintillation.hh"
#include "G4Cerenkov.hh"
@@ -51,30 +50,45 @@
#include "G4LossTableManager.hh"
#include "G4EmSaturation.hh"
#include "G4GenericMessenger.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
// factory
#include "G4PhysicsConstructorFactory.hh"
//
G4_DECLARE_PHYSCONSTR_FACTORY(G4OpticalPhysics);
G4ThreadLocal G4Scintillation* G4OpticalPhysics::fScintillationProcess = nullptr;
G4ThreadLocal G4Cerenkov* G4OpticalPhysics::fCerenkovProcess = nullptr;
G4ThreadLocal G4OpWLS* G4OpticalPhysics::fWLSProcess = nullptr;
G4ThreadLocal G4OpAbsorption* G4OpticalPhysics::fAbsorptionProcess = nullptr;
G4ThreadLocal G4OpRayleigh* G4OpticalPhysics::fRayleighProcess = nullptr;
G4ThreadLocal G4OpMieHG* G4OpticalPhysics::fMieProcess = nullptr;
G4ThreadLocal G4OpBoundaryProcess* G4OpticalPhysics::fBoundaryProcess = nullptr;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4OpticalPhysics::G4OpticalPhysics(G4int verbose, const G4String& name)
: G4VPhysicsConstructor(name),
fMaxNumPhotons(100),
fMaxBetaChange(10.0),
fYieldFactor(1.),
fExcitationRatio(0.0),
fProfile("delta"),
fFiniteRiseTime(false),
fScintillationByParticleType(false),
fScintillationTrackInfo(false),
fInvokeSD(true),
fScintillationStackPhotons(true),
fScintillationVerbosity(0),
fMaxNumPhotons(100),
fMaxBetaChange(10.0),
fCerenkovStackPhotons(true),
fScintillationStackPhotons(true)
fCerenkovVerbosity(0),
fWLSTimeProfileName("delta"),
fWLSVerbosity(0),
fAbsorptionVerbosity(0),
fRayleighVerbosity(0),
fMieVerbosity(0),
fInvokeSD(true),
fBoundaryVerbosity(0)
{
verboseLevel = verbose;
fMessenger = new G4OpticalPhysicsMessenger(this);
@@ -90,6 +104,7 @@ G4OpticalPhysics::G4OpticalPhysics(G4int verbose, const G4String& name)
G4OpticalPhysics::~G4OpticalPhysics()
{
delete fMessenger;
fMessenger = nullptr;
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -111,7 +126,7 @@ void G4OpticalPhysics::PrintStatistics() const
if ( fProcessTrackSecondariesFirst[kCerenkov] ) {
G4cout << " Track secondaries first: activated" << G4endl;
}
else {
else {
G4cout << " Track secondaries first: inactivated" << G4endl;
}
}
@@ -123,12 +138,12 @@ void G4OpticalPhysics::PrintStatistics() const
if ( fProcessTrackSecondariesFirst[kScintillation] ) {
G4cout << " Track secondaries first: activated" << G4endl;
}
else {
else {
G4cout << " Track secondaries first: inactivated" << G4endl;
}
}
if ( i == kWLS ) {
G4cout << " WLS process time profile: " << fProfile << G4endl;
G4cout << " WLS process time profile: " << fWLSTimeProfileName << G4endl;
}
}
}
@@ -136,179 +151,50 @@ void G4OpticalPhysics::PrintStatistics() const
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4OpticalPhoton.hh"
void G4OpticalPhysics::ConstructParticle()
{
/// Instantiate particles.
// optical photon
G4OpticalPhoton::OpticalPhotonDefinition();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#define DIR_CMDS "/process/optical"
#define GUIDANCE "Commands related to the optical physics simulation engine for "
namespace UIhelpers {
//Helper functions to create UI commands for processes
template<class T>
void buildCommands(T* proc,const char* dir, const char* guidance)
{
//Generic function to add a "verbose" command for a process
G4GenericMessenger* mess = new G4GenericMessenger(proc,dir,guidance);
G4AutoDelete::Register(mess);
G4GenericMessenger::Command& wlscmd4 = mess->DeclareMethod("verbose",&T::SetVerboseLevel,
"Set the verbose level");
wlscmd4.SetParameterName("ver",true);
wlscmd4.SetDefaultValue("1");
wlscmd4.SetStates(G4State_Idle);
}
void buildCommands( G4OpWLS* op )
{
//Build UI commands for WLS
G4GenericMessenger* mess = new G4GenericMessenger(op,DIR_CMDS"/wls/",GUIDANCE"WLS process.");
G4AutoDelete::Register(mess);
//Here, more correctly DeclareProperty should be used, but to do that, I would need public/friend
//access of G4GenericMessenger to private members of G4Scintillation. Thus I use the approach
//of DeclareMethod, that has a draw back: range checking does not work
G4GenericMessenger::Command& wlscmd1 = mess->DeclareMethod("setTimeProfile",&G4OpWLS::UseTimeProfile,
"Set the WLS time profile (delta or exponential)");
wlscmd1.SetParameterName("profile",false);
wlscmd1.SetCandidates("delta exponential");
wlscmd1.SetStates(G4State_Idle);
buildCommands(op,DIR_CMDS"/wls/",GUIDANCE"WLS process.");
}
void buildCommands(G4Scintillation* ScintillationProcess)
{
//Build UI commands for scintillation
G4GenericMessenger* mess = new G4GenericMessenger(ScintillationProcess,DIR_CMDS"/scintillation/",GUIDANCE"scintillation process.");
G4AutoDelete::Register(mess);
G4GenericMessenger::Command& sccmd1 = mess->DeclareMethod("setFiniteRiseTime",
&G4Scintillation::SetFiniteRiseTime,
"Set option of a finite rise-time for G4Scintillation - If set, the G4Scintillation process expects the user to have set the constant material property FAST/SLOWSCINTILLATIONRISETIME");
sccmd1.SetParameterName("time",false);
sccmd1.SetStates(G4State_Idle);
G4GenericMessenger::Command& sccmd2 = mess->DeclareMethod("setYieldFactor",
&G4Scintillation::SetScintillationYieldFactor,
"Set scintillation yield factor");
sccmd2.SetParameterName("factor",false);
//sccmd2.SetRange("factor>=0."); //LIMITATION: w/ DeclareMethod range checking does not work
sccmd2.SetStates(G4State_Idle);
G4GenericMessenger::Command& sccmd3 = mess->DeclareMethod("setExcitationRatio",
&G4Scintillation::SetScintillationExcitationRatio,
"Set scintillation excitation ratio");
sccmd3.SetParameterName("ratio",false);
//sccmd3.SetRange("ratio>=0.&&ratio<=1.");//LIMITATION: w/ DeclareMethod range checking does not work
sccmd3.SetStates(G4State_Idle);
G4GenericMessenger::Command& sccmd4 = mess->DeclareMethod("setByParticleType",
&G4Scintillation::SetScintillationByParticleType,
"Activate/Inactivate scintillation process by particle type");
sccmd4.SetParameterName("flag", false);
sccmd4.SetStates(G4State_Idle);
G4GenericMessenger::Command& sccmd5 = mess->DeclareMethod("setTrackInfo",
&G4Scintillation::SetScintillationTrackInfo,
"Activate/Inactivate scintillation track info");
sccmd5.SetParameterName("flag", false);
sccmd5.SetStates(G4State_Idle);
G4GenericMessenger::Command& sccmd6 = mess->DeclareMethod("setTrackSecondariesFirst",
&G4Scintillation::SetTrackSecondariesFirst,
"Set option to track secondaries before finishing their parent track");
sccmd6.SetParameterName("flag",false);
sccmd6.SetStates(G4State_Idle);
buildCommands(ScintillationProcess,DIR_CMDS"/scintillation/",GUIDANCE"scintillation process.");
}
void buildCommands(G4Cerenkov* CerenkovProcess)
{
//BUild UI commands for cerenkov
G4GenericMessenger* mess = new G4GenericMessenger(CerenkovProcess,DIR_CMDS"/cerenkov/",GUIDANCE"Cerenkov process.");
G4AutoDelete::Register(mess);
G4GenericMessenger::Command& cecmd1 = mess->DeclareMethod("setMaxPhotons",
&G4Cerenkov::SetMaxNumPhotonsPerStep,
"Set maximum number of photons per step");
cecmd1.SetParameterName("max",false);
//cecmd1.SetRange("max>=0");//LIMITATION: w/ DeclareMethod range checking does not work
cecmd1.SetStates(G4State_Idle);
G4GenericMessenger::Command& cecmd2 = mess->DeclareMethod("setMaxBetaChange",
&G4Cerenkov::SetMaxBetaChangePerStep,
"Set maximum change of beta of parent particle per step");
cecmd2.SetParameterName("max",false);
//cecmd2.SetRange("max>=0.");//LIMITATION: w/ DeclareMethod range checking does not work
cecmd2.SetStates(G4State_Idle);
G4GenericMessenger::Command& cecmd3 = mess->DeclareMethod("setTrackSecondariesFirst",
&G4Cerenkov::SetTrackSecondariesFirst,
"Set option to track secondaries before finishing their parent track");
cecmd3.SetParameterName("flag",false);
cecmd3.SetStates(G4State_Idle);
buildCommands(CerenkovProcess,DIR_CMDS"/cerenkov/",GUIDANCE"Cerenkov process.");
}
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
#include "G4Threading.hh"
#include "G4ParticleDefinition.hh"
#include "G4ProcessManager.hh"
#include "G4AutoDelete.hh"
void G4OpticalPhysics::ConstructProcess()
{
// Construct optical processes.
if(verboseLevel>0)
G4cout <<"G4OpticalPhysics:: Add Optical Physics Processes"<< G4endl;
// A vector of optical processes
std::vector<G4VProcess*> OpProcesses;
for ( G4int i=0; i<kNoProcess; i++ ) OpProcesses.push_back(NULL);
for ( G4int i=0; i<kNoProcess; i++ ) OpProcesses.push_back(nullptr);
// Add Optical Processes
G4OpAbsorption* OpAbsorptionProcess = new G4OpAbsorption();
UIhelpers::buildCommands(OpAbsorptionProcess,DIR_CMDS"/absorption/",GUIDANCE"absorption process");
OpProcesses[kAbsorption] = OpAbsorptionProcess;
fAbsorptionProcess = new G4OpAbsorption();
OpProcesses[kAbsorption] = fAbsorptionProcess;
G4OpRayleigh* OpRayleighScatteringProcess = new G4OpRayleigh();
UIhelpers::buildCommands(OpRayleighScatteringProcess,DIR_CMDS"/rayleigh/",GUIDANCE"Rayleigh scattering process");
OpProcesses[kRayleigh] = OpRayleighScatteringProcess;
G4OpMieHG* OpMieHGScatteringProcess = new G4OpMieHG();
UIhelpers::buildCommands(OpMieHGScatteringProcess,DIR_CMDS"/mie/",GUIDANCE"Mie scattering process");
OpProcesses[kMieHG] = OpMieHGScatteringProcess;
fRayleighProcess = new G4OpRayleigh();
OpProcesses[kRayleigh] = fRayleighProcess;
G4OpBoundaryProcess* OpBoundaryProcess = new G4OpBoundaryProcess();
UIhelpers::buildCommands(OpBoundaryProcess,DIR_CMDS"/boundary/",GUIDANCE"boundary process");
OpBoundaryProcess->SetInvokeSD(fInvokeSD);
OpProcesses[kBoundary] = OpBoundaryProcess;
fMieProcess = new G4OpMieHG();
OpProcesses[kMieHG] = fMieProcess;
G4OpWLS* OpWLSProcess = new G4OpWLS();
OpWLSProcess->UseTimeProfile(fProfile);
UIhelpers::buildCommands(OpWLSProcess);
OpProcesses[kWLS] = OpWLSProcess;
fBoundaryProcess = new G4OpBoundaryProcess();
fBoundaryProcess->SetInvokeSD(fInvokeSD);
OpProcesses[kBoundary] = fBoundaryProcess;
G4ProcessManager * pManager = 0;
fWLSProcess = new G4OpWLS();
fWLSProcess->UseTimeProfile(fWLSTimeProfileName);
OpProcesses[kWLS] = fWLSProcess;
G4ProcessManager* pManager = nullptr;
pManager = G4OpticalPhoton::OpticalPhoton()->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Optical Photon without a Process Manager";
G4ExceptionDescription ed;
ed << "Optical Photon without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
FatalException,ed);
return;
}
@@ -318,26 +204,24 @@ void G4OpticalPhysics::ConstructProcess()
}
}
G4Scintillation* ScintillationProcess = new G4Scintillation();
ScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
ScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
ScintillationProcess->SetFiniteRiseTime(fFiniteRiseTime);
ScintillationProcess->SetScintillationByParticleType(fScintillationByParticleType);
ScintillationProcess->SetScintillationTrackInfo(fScintillationTrackInfo);
ScintillationProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
ScintillationProcess->SetStackPhotons(fScintillationStackPhotons);
fScintillationProcess = new G4Scintillation();
fScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
fScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
fScintillationProcess->SetFiniteRiseTime(fFiniteRiseTime);
fScintillationProcess->SetScintillationByParticleType(fScintillationByParticleType);
fScintillationProcess->SetScintillationTrackInfo(fScintillationTrackInfo);
fScintillationProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
fScintillationProcess->SetStackPhotons(fScintillationStackPhotons);
G4EmSaturation* emSaturation = G4LossTableManager::Instance()->EmSaturation();
ScintillationProcess->AddSaturation(emSaturation);
UIhelpers::buildCommands(ScintillationProcess);
OpProcesses[kScintillation] = ScintillationProcess;
G4Cerenkov* CerenkovProcess = new G4Cerenkov();
CerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
CerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
CerenkovProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
CerenkovProcess->SetStackPhotons(fCerenkovStackPhotons);
UIhelpers::buildCommands(CerenkovProcess);
OpProcesses[kCerenkov] = CerenkovProcess;
fScintillationProcess->AddSaturation(emSaturation);
OpProcesses[kScintillation] = fScintillationProcess;
fCerenkovProcess = new G4Cerenkov();
fCerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
fCerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
fCerenkovProcess->SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
fCerenkovProcess->SetStackPhotons(fCerenkovStackPhotons);
OpProcesses[kCerenkov] = fCerenkovProcess;
auto myParticleIterator=GetParticleIterator();
myParticleIterator->reset();
@@ -349,25 +233,24 @@ void G4OpticalPhysics::ConstructProcess()
pManager = particle->GetProcessManager();
if (!pManager) {
std::ostringstream o;
o << "Particle " << particleName << "without a Process Manager";
G4ExceptionDescription ed;
ed << "Particle " << particleName << "without a Process Manager";
G4Exception("G4OpticalPhysics::ConstructProcess()","",
FatalException,o.str().c_str());
return; // else coverity complains for pManager use below
FatalException, ed);
return; // else coverity complains for pManager use below
}
if( CerenkovProcess->IsApplicable(*particle) &&
if( fCerenkovProcess->IsApplicable(*particle) &&
fProcessUse[kCerenkov] ) {
pManager->AddProcess(CerenkovProcess);
pManager->SetProcessOrdering(CerenkovProcess,idxPostStep);
pManager->AddProcess(fCerenkovProcess);
pManager->SetProcessOrdering(fCerenkovProcess,idxPostStep);
}
if( ScintillationProcess->IsApplicable(*particle) &&
fProcessUse[kScintillation] ){
pManager->AddProcess(ScintillationProcess);
pManager->SetProcessOrderingToLast(ScintillationProcess,idxAtRest);
pManager->SetProcessOrderingToLast(ScintillationProcess,idxPostStep);
if( fScintillationProcess->IsApplicable(*particle) &&
fProcessUse[kScintillation] ) {
pManager->AddProcess(fScintillationProcess);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxAtRest);
pManager->SetProcessOrderingToLast(fScintillationProcess,idxPostStep);
}
}
// Add verbose
@@ -380,62 +263,146 @@ void G4OpticalPhysics::ConstructProcess()
G4cout << "### " << namePhysics << " physics constructed." << G4endl;
}
void G4OpticalPhysics::SetScintillationYieldFactor(G4double yieldFactor)
void G4OpticalPhysics::SetScintillationYieldFactor(G4double val)
{
/// Set the scintillation yield factor
fYieldFactor = yieldFactor;
//G4Scintillation::SetScintillationYieldFactor(yieldFactor);
fYieldFactor = val;
if (fScintillationProcess) {
fScintillationProcess->SetScintillationYieldFactor(fYieldFactor);
}
}
void G4OpticalPhysics::SetScintillationExcitationRatio(G4double excitationRatio)
void G4OpticalPhysics::SetScintillationExcitationRatio(G4double val)
{
/// Set the scintillation excitation ratio
fExcitationRatio = excitationRatio;
// G4Scintillation::SetScintillationExcitationRatio(excitationRatio);
fExcitationRatio = val;
if (fScintillationProcess) {
fScintillationProcess->SetScintillationExcitationRatio(fExcitationRatio);
}
}
void G4OpticalPhysics::SetMaxNumPhotonsPerStep(G4int maxNumPhotons)
void G4OpticalPhysics::SetMaxNumPhotonsPerStep(G4int val)
{
/// Limit step to the specified maximum number of Cherenkov photons
fMaxNumPhotons = maxNumPhotons;
// G4Cerenkov::SetMaxNumPhotonsPerStep(maxNumPhotons);
/// Limit step to the specified maximum number of Cerenkov photons
fMaxNumPhotons = val;
if (fCerenkovProcess) {
fCerenkovProcess->SetMaxNumPhotonsPerStep(fMaxNumPhotons);
}
}
void G4OpticalPhysics::SetMaxBetaChangePerStep(G4double maxBetaChange)
void G4OpticalPhysics::SetMaxBetaChangePerStep(G4double val)
{
/// Limit step to the specified maximum change of beta of the parent particle
fMaxBetaChange = maxBetaChange;
// G4Cerenkov::SetMaxBetaChangePerStep(maxBetaChange);
fMaxBetaChange = val;
if (fCerenkovProcess) {
fCerenkovProcess->SetMaxBetaChangePerStep(fMaxBetaChange);
}
}
void G4OpticalPhysics::SetWLSTimeProfile(G4String profile)
void G4OpticalPhysics::SetCerenkovStackPhotons(G4bool val)
{
fCerenkovStackPhotons = val;
if (fCerenkovProcess) {
fCerenkovProcess->SetStackPhotons(fCerenkovStackPhotons);
}
}
void G4OpticalPhysics::SetCerenkovTrackSecondariesFirst(G4bool val)
{
fProcessTrackSecondariesFirst[kCerenkov] = val;
if (fCerenkovProcess) {
fCerenkovProcess->
SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kCerenkov]);
}
}
void G4OpticalPhysics::SetCerenkovVerbosity(G4int ver)
{
fCerenkovVerbosity = ver;
if (fCerenkovProcess) {
fCerenkovProcess->SetVerboseLevel(fCerenkovVerbosity);
}
}
void G4OpticalPhysics::SetWLSTimeProfile(G4String name)
{
/// Set the WLS time profile (delta or exponential)
fProfile = profile;
fWLSTimeProfileName = name;
if (fWLSProcess) {
fWLSProcess->UseTimeProfile(fWLSTimeProfileName);
}
}
//void G4OpticalPhysics::AddScintillationSaturation(G4EmSaturation* saturation)
//{
///// Adds Birks Saturation to the G4Scintillation Process
// G4Scintillation::AddSaturation(saturation);
//}
void G4OpticalPhysics::
SetScintillationByParticleType(G4bool scintillationByParticleType)
void G4OpticalPhysics::SetWLSVerbosity(G4int ver)
{
fScintillationByParticleType = scintillationByParticleType;
//G4Scintillation::SetScintillationByParticleType(scintillationByParticleType);
fWLSVerbosity = ver;
if (fWLSProcess) {
fWLSProcess->SetVerboseLevel(fWLSVerbosity);
}
}
void G4OpticalPhysics::
SetScintillationTrackInfo(G4bool scintillationTrackInfo)
void G4OpticalPhysics::SetScintillationByParticleType(G4bool val)
{
fScintillationTrackInfo = scintillationTrackInfo;
//G4Scintillation::SetScintillationTrackInfo(scintillationTrackInfo);
fScintillationByParticleType = val;
if (fScintillationProcess) {
fScintillationProcess->
SetScintillationByParticleType(fScintillationByParticleType);
}
}
void G4OpticalPhysics::SetScintillationTrackSecondariesFirst(G4bool val)
{
fProcessTrackSecondariesFirst[kScintillation] = val;
if (fScintillationProcess) {
fScintillationProcess->
SetTrackSecondariesFirst(fProcessTrackSecondariesFirst[kScintillation]);
}
}
void G4OpticalPhysics::SetScintillationTrackInfo(G4bool val)
{
fScintillationTrackInfo = val;
if (fScintillationProcess) {
fScintillationProcess->SetScintillationTrackInfo(fScintillationTrackInfo);
}
}
void G4OpticalPhysics::SetScintillationVerbosity(G4int ver)
{
fScintillationVerbosity = ver;
if (fScintillationProcess) {
fScintillationProcess->SetVerboseLevel(fScintillationVerbosity);
}
}
void G4OpticalPhysics::SetAbsorptionVerbosity(G4int ver)
{
fAbsorptionVerbosity = ver;
if (fAbsorptionProcess) {
fAbsorptionProcess->SetVerboseLevel(fAbsorptionVerbosity);
}
}
void G4OpticalPhysics::SetRayleighVerbosity(G4int ver)
{
fRayleighVerbosity = ver;
if (fRayleighProcess) {
fRayleighProcess->SetVerboseLevel(fRayleighVerbosity);
}
}
void G4OpticalPhysics::SetMieVerbosity(G4int ver)
{
fMieVerbosity = ver;
if (fMieProcess) {
fMieProcess->SetVerboseLevel(fMieVerbosity);
}
}
void G4OpticalPhysics::SetBoundaryVerbosity(G4int ver)
{
fBoundaryVerbosity = ver;
if (fBoundaryProcess) {
fBoundaryProcess->SetVerboseLevel(fBoundaryVerbosity);
}
}
void G4OpticalPhysics::SetTrackSecondariesFirst(G4OpticalProcessIndex index,
@@ -444,32 +411,30 @@ void G4OpticalPhysics::SetTrackSecondariesFirst(G4OpticalProcessIndex index,
if ( index >= kNoProcess ) return;
if ( fProcessTrackSecondariesFirst[index] == trackSecondariesFirst ) return;
fProcessTrackSecondariesFirst[index] = trackSecondariesFirst;
// if ( index == kCerenkov )
// G4Cerenkov::SetTrackSecondariesFirst(trackSecondariesFirst);
// if ( index == kScintillation)
// G4Scintillation::SetTrackSecondariesFirst(trackSecondariesFirst);
}
void G4OpticalPhysics::SetFiniteRiseTime(G4bool finiteRiseTime)
void G4OpticalPhysics::SetFiniteRiseTime(G4bool b)
{
fFiniteRiseTime = finiteRiseTime;
//G4Scintillation::SetFiniteRiseTime(finiteRiseTime);
fFiniteRiseTime = b;
if (fScintillationProcess) {
fScintillationProcess->SetFiniteRiseTime(fFiniteRiseTime);
}
}
void G4OpticalPhysics::SetInvokeSD(G4bool invokeSD)
void G4OpticalPhysics::SetInvokeSD(G4bool b)
{
fInvokeSD = invokeSD;
}
void G4OpticalPhysics::SetCerenkovStackPhotons(G4bool stackingFlag)
{
fCerenkovStackPhotons = stackingFlag;
fInvokeSD = b;
if (fBoundaryProcess) {
fBoundaryProcess->SetInvokeSD(fInvokeSD);
}
}
void G4OpticalPhysics::SetScintillationStackPhotons(G4bool stackingFlag)
{
fScintillationStackPhotons = stackingFlag;
if (fScintillationProcess) {
fScintillationProcess->SetStackPhotons(fScintillationStackPhotons);
}
}
void G4OpticalPhysics::Configure(G4OpticalProcessIndex index, G4bool isUse)
source/physics_lists/constructors/electromagnetic/src/G4OpticalPhysicsMessenger.cc
+423 -149
View File
@@ -51,9 +51,10 @@
#include "G4UIcmdWithADoubleAndUnit.hh"
#include "G4UIparameter.hh"
#include "G4ParticleTable.hh"
#include "G4ProcessManager.hh"
#include "G4ParticleDefinition.hh"
// Commands with '/defaults/' are duplicates and will be removed in
// the next major release of Geant4. Use commands with no /defaults/ instead
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
@@ -62,31 +63,65 @@ G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger(
: G4UImessenger(),
fOpticalPhysics(opticalPhysics),
fSelectedProcessIndex(kNoProcess),
fActivateProcessCmd(0),
fSetOpProcessVerboseCmd(0),
fSetCerenkovMaxPhotonsCmd(0),
fSetCerenkovMaxBetaChangeCmd(0),
fSetCerenkovStackPhotonsCmd(0),
fSetScintillationYieldFactorCmd(0),
fSetScintillationByParticleTypeCmd(0),
fSetScintillationTrackInfoCmd(0),
fSetScintillationStackPhotonsCmd(0),
fSetWLSTimeProfileCmd(0),
fSetTrackSecondariesFirstCmd(0),
fSetFiniteRiseTimeCmd(0),
fSetInvokeSDCmd(0)
fActivateProcessCmd(nullptr),
fVerboseCmd(nullptr),
fTrackSecondariesFirstCmd(nullptr),
fCerenkovMaxPhotonsCmd(nullptr),
fCerenkovMaxPhotons1Cmd(nullptr),
fCerenkovMaxBetaChangeCmd(nullptr),
fCerenkovMaxBetaChange1Cmd(nullptr),
fCerenkovStackPhotonsCmd(nullptr),
fCerenkovStackPhotons1Cmd(nullptr),
fCerenkovTrackSecondariesFirstCmd(nullptr),
fCerenkovVerbosityCmd(nullptr),
fScintYieldFactorCmd(nullptr),
fScintYieldFactor1Cmd(nullptr),
fScintByParticleTypeCmd(nullptr),
fScintByParticleType1Cmd(nullptr),
fScintTrackInfoCmd(nullptr),
fScintTrackInfo1Cmd(nullptr),
fScintStackPhotonsCmd(nullptr),
fScintStackPhotons1Cmd(nullptr),
fScintTrackSecondariesFirstCmd(nullptr),
fScintFiniteRiseTimeCmd(nullptr),
fScintFiniteRiseTime1Cmd(nullptr),
fScintVerbosityCmd(nullptr),
fWLSTimeProfileCmd(nullptr),
fWLSTimeProfile1Cmd(nullptr),
fWLSVerbosityCmd(nullptr),
fBoundaryInvokeSDCmd(nullptr),
fBoundaryInvokeSD1Cmd(nullptr),
fBoundaryVerbosityCmd(nullptr),
fAbsorptionVerbosityCmd(nullptr),
fRayleighVerbosityCmd(nullptr),
fMieVerbosityCmd(nullptr)
{
G4bool toBeBroadcasted = false;
fDir = new G4UIdirectory("/process/optical/defaults/",toBeBroadcasted);
fDir->SetGuidance("Commands related to the optical physics simulation engine.");
fDir->SetGuidance("DEPRECATED Commands related to the optical physics simulation engine.");
fDir2 = new G4UIdirectory("/process/optical/",toBeBroadcasted);
fDir2->SetGuidance("Commands related to the optical physics simulation engine.");
CreateDirectory("/process/optical/defaults/cerenkov/", "Cerenkov process commands");
CreateDirectory("/process/optical/defaults/scintillation/", "Scintillation process commands");
CreateDirectory("/process/optical/defaults/wls/", "Wave length shifting process commands");
CreateDirectory("/process/optical/defaults/boundary/", "Boundary scattering commands");
CreateDirectory("/process/optical/defaults/cerenkov/", "DEPRECATED Cerenkov process commands");
CreateDirectory("/process/optical/defaults/scintillation/", "DEPRECATED Scintillation process commands");
CreateDirectory("/process/optical/defaults/wls/", "DEPRECATED Wave length shifting process commands");
CreateDirectory("/process/optical/defaults/boundary/", "DEPRECATED Boundary scattering commands");
CreateDirectory("/process/optical/cerenkov/", "Cerenkov process commands");
CreateDirectory("/process/optical/scintillation/", "Scintillation process commands");
CreateDirectory("/process/optical/wls/", "Wave length shifting process commands");
CreateDirectory("/process/optical/boundary/", "Boundary scattering commands");
CreateDirectory("/process/optical/mie/", "Mie scattering process commands");
CreateDirectory("/process/optical/absorption/", "absorption process commands");
CreateDirectory("/process/optical/rayleigh/", "Rayleigh scattering commands");
// general commands
fActivateProcessCmd= new G4UIcommand("/process/optical/processActivation", this);
fActivateProcessCmd->SetGuidance("Activate/deactivate the specified optical process");
G4UIparameter* par = new G4UIparameter("proc_name",'s',false);
@@ -104,119 +139,275 @@ G4OpticalPhysicsMessenger::G4OpticalPhysicsMessenger(
fActivateProcessCmd->SetParameter(par);
fActivateProcessCmd->AvailableForStates(G4State_PreInit);
fSetOpProcessVerboseCmd = new G4UIcmdWithAnInteger("/process/optical/verbose", this);
fSetOpProcessVerboseCmd->SetGuidance("Set default verbosity level for optical processes");
fSetOpProcessVerboseCmd->SetParameterName("ver", true);
fSetOpProcessVerboseCmd->SetDefaultValue(1);
fSetOpProcessVerboseCmd->SetRange("ver>=0");
fSetOpProcessVerboseCmd->AvailableForStates(G4State_PreInit);
fSetTrackSecondariesFirstCmd = new G4UIcommand("/process/optical/setTrackSecondariesFirst", this);
fSetTrackSecondariesFirstCmd->SetGuidance("Activate/deactivate tracking of secondaries before finishing their parent track");
fTrackSecondariesFirstCmd = new G4UIcommand("/process/optical/setTrackSecondariesFirst", this);
fTrackSecondariesFirstCmd->SetGuidance("Activate/deactivate tracking of secondaries before finishing their parent track");
par = new G4UIparameter("proc_name",'s',false);
par->SetParameterCandidates(candidates);
fSetTrackSecondariesFirstCmd->SetParameter(par);
fTrackSecondariesFirstCmd->SetParameter(par);
par = new G4UIparameter("flag",'b',false);
par->SetDefaultValue(true);
fSetTrackSecondariesFirstCmd->SetParameter(par);
fSetTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit);
fTrackSecondariesFirstCmd->SetParameter(par);
fTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit);
//This are repetition of process specific ui commands needed by ATLICE and VMC
//(UI messages needed to exist in PreInit state before actual processes are instantiated)
fSetCerenkovMaxPhotonsCmd = new G4UIcmdWithAnInteger("/process/optical/defaults/cerenkov/setMaxPhotons", this);
fSetCerenkovMaxPhotonsCmd->SetGuidance("Set default maximum number of photons per step");
fSetCerenkovMaxPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fSetCerenkovMaxPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fSetCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
fSetCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
fSetCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit);
fVerboseCmd = new G4UIcmdWithAnInteger("/process/optical/verbose", this);
fVerboseCmd->SetGuidance("Set default verbosity level for optical processes");
fVerboseCmd->SetParameterName("ver", true);
fVerboseCmd->SetDefaultValue(1);
fVerboseCmd->SetRange("ver>=0");
fVerboseCmd->AvailableForStates(G4State_PreInit);
fSetCerenkovMaxBetaChangeCmd = new G4UIcmdWithADouble("/process/optical/defaults/cerenkov/setMaxBetaChange", this);
fSetCerenkovMaxBetaChangeCmd->SetGuidance("Set default maximum change of beta of parent particle per step");
fSetCerenkovMaxBetaChangeCmd->SetGuidance("Note this command is used to set the default value,");
fSetCerenkovMaxBetaChangeCmd->SetGuidance("if process is not active command will not have effect.");
fSetCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
fSetCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
fSetCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_PreInit);
//// Cerenkov ////////////////////
fCerenkovMaxPhotons1Cmd = new G4UIcmdWithAnInteger("/process/optical/defaults/cerenkov/setMaxPhotons", this);
fCerenkovMaxPhotons1Cmd->SetGuidance("Set default maximum number of photons per step");
fCerenkovMaxPhotons1Cmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovMaxPhotons1Cmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovMaxPhotons1Cmd->SetGuidance("DEPRECATED: use /process/optical/cerenkov/setMaxPhotons instead.");
fCerenkovMaxPhotons1Cmd->SetParameterName("CerenkovMaxPhotons", false);
fCerenkovMaxPhotons1Cmd->SetRange("CerenkovMaxPhotons>=0");
fCerenkovMaxPhotons1Cmd->AvailableForStates(G4State_PreInit);
fSetCerenkovStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/defaults/cerenkov/setStackPhotons", this);
fSetCerenkovStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Cerenkov photons");
fSetCerenkovStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fSetCerenkovStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fSetCerenkovStackPhotonsCmd->SetParameterName("CerenkovStackPhotons", true);
fSetCerenkovStackPhotonsCmd->AvailableForStates(G4State_PreInit);
fCerenkovMaxPhotonsCmd = new G4UIcmdWithAnInteger("/process/optical/cerenkov/setMaxPhotons", this);
fCerenkovMaxPhotonsCmd->SetGuidance("Set default maximum number of photons per step");
fCerenkovMaxPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovMaxPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovMaxPhotonsCmd->SetParameterName("CerenkovMaxPhotons", false);
fCerenkovMaxPhotonsCmd->SetRange("CerenkovMaxPhotons>=0");
fCerenkovMaxPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fSetScintillationYieldFactorCmd = new G4UIcmdWithADouble("/process/optical/defaults/scintillation/setYieldFactor", this);
fSetScintillationYieldFactorCmd->SetGuidance("Set scintillation yield factor");
fSetScintillationYieldFactorCmd->SetGuidance("Note this command is used to set the default value,");
fSetScintillationYieldFactorCmd->SetGuidance("if process is not active command will not have effect.");
fSetScintillationYieldFactorCmd->SetParameterName("ScintillationYieldFactor", false);
fSetScintillationYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
fSetScintillationYieldFactorCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fCerenkovMaxBetaChange1Cmd = new G4UIcmdWithADouble("/process/optical/defaults/cerenkov/setMaxBetaChange", this);
fCerenkovMaxBetaChange1Cmd->SetGuidance("Set default maximum change of beta of parent particle per step");
fCerenkovMaxBetaChange1Cmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovMaxBetaChange1Cmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovMaxBetaChange1Cmd->SetGuidance("DEPRECATED: use /process/optical/cerenkov/setMaxBetaChange instead.");
fCerenkovMaxBetaChange1Cmd->SetParameterName("CerenkovMaxBetaChange", false);
fCerenkovMaxBetaChange1Cmd->SetRange("CerenkovMaxBetaChange>=0");
fCerenkovMaxBetaChange1Cmd->AvailableForStates(G4State_PreInit);
fSetScintillationByParticleTypeCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setByParticleType", this);
fSetScintillationByParticleTypeCmd->SetGuidance("Activate/Inactivate scintillation process by particle type");
fSetScintillationByParticleTypeCmd->SetGuidance("Note this command is used to set the default value,");
fSetScintillationByParticleTypeCmd->SetGuidance("if process is not active command will not have effect.");
fSetScintillationByParticleTypeCmd->SetParameterName("ScintillationByParticleTypeActivation", false);
fSetScintillationByParticleTypeCmd->AvailableForStates(G4State_PreInit);
fCerenkovMaxBetaChangeCmd = new G4UIcmdWithADouble("/process/optical/cerenkov/setMaxBetaChange", this);
fCerenkovMaxBetaChangeCmd->SetGuidance("Set default maximum change of beta of parent particle per step");
fCerenkovMaxBetaChangeCmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovMaxBetaChangeCmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovMaxBetaChangeCmd->SetParameterName("CerenkovMaxBetaChange", false);
fCerenkovMaxBetaChangeCmd->SetRange("CerenkovMaxBetaChange>=0");
fCerenkovMaxBetaChangeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fSetScintillationTrackInfoCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setTrackInfo", this);
fSetScintillationTrackInfoCmd->SetGuidance("Activate/Inactivate scintillation TrackInformation");
fSetScintillationTrackInfoCmd->SetParameterName("ScintillationTrackInfo", false);
fSetScintillationTrackInfoCmd->AvailableForStates(G4State_PreInit);
fCerenkovStackPhotons1Cmd = new G4UIcmdWithABool("/process/optical/defaults/cerenkov/setStackPhotons", this);
fCerenkovStackPhotons1Cmd->SetGuidance("Set default whether or not to stack secondary Cerenkov photons");
fCerenkovStackPhotons1Cmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovStackPhotons1Cmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovStackPhotons1Cmd->SetGuidance("DEPRECATED: use /process/optical/cerenkov/setStackPhotons instead.");
fCerenkovStackPhotons1Cmd->SetParameterName("CerenkovStackPhotons", true);
fCerenkovStackPhotons1Cmd->AvailableForStates(G4State_PreInit);
fSetFiniteRiseTimeCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setFiniteRiseTime", this);
fSetFiniteRiseTimeCmd->SetGuidance("Set option of a finite rise-time for G4Scintillation");
fSetFiniteRiseTimeCmd->SetGuidance("If set, the G4Scintillation process expects the user to have set the constant material property FAST/SLOWSCINTILLATIONRISETIME");
fSetFiniteRiseTimeCmd->SetGuidance("Note this command is used to set the default value,");
fSetFiniteRiseTimeCmd->SetGuidance("if process is not active command will not have effect.");
fSetFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
fSetFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit);
fCerenkovStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/cerenkov/setStackPhotons", this);
fCerenkovStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Cerenkov photons");
fCerenkovStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fCerenkovStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fCerenkovStackPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fSetScintillationStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setStackPhotons", this);
fSetScintillationStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Scintillation photons");
fSetScintillationStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fSetScintillationStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fSetScintillationStackPhotonsCmd->SetParameterName("ScintillationStackPhotons", true);
fSetScintillationStackPhotonsCmd->AvailableForStates(G4State_PreInit);
fCerenkovTrackSecondariesFirstCmd = new G4UIcmdWithABool("/process/optical/cerenkov/setTrackSecondariesFirst", this);
fCerenkovTrackSecondariesFirstCmd->SetGuidance("Whether to track secondary Cerenkov photons before the primary.");
fCerenkovTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fSetWLSTimeProfileCmd = new G4UIcmdWithAString("/process/optical/defaults/wls/setTimeProfile", this);
fSetWLSTimeProfileCmd->SetGuidance("Set the WLS time profile (delta or exponential)");
fSetWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
fSetWLSTimeProfileCmd->SetCandidates("delta exponential");
fSetWLSTimeProfileCmd->AvailableForStates(G4State_PreInit);
fCerenkovVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/cerenkov/verbose", this);
fCerenkovVerbosityCmd->SetGuidance("Verbosity for Cerenkov process.");
fCerenkovVerbosityCmd->SetParameterName("verbosity", true);
fCerenkovVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fCerenkovVerbosityCmd->AvailableForStates(G4State_Idle);
fSetInvokeSDCmd = new G4UIcmdWithABool("/process/optical/defaults/boundary/setInvokeSD", this);
fSetInvokeSDCmd->SetGuidance("Set option for calling InvokeSD in G4OpBoundaryProcess");
fSetInvokeSDCmd->SetParameterName("InvokeSD", false);
fSetInvokeSDCmd->AvailableForStates(G4State_PreInit);
// Scintillation //////////////////////////
fScintYieldFactor1Cmd = new G4UIcmdWithADouble("/process/optical/defaults/scintillation/setYieldFactor", this);
fScintYieldFactor1Cmd->SetGuidance("Set scintillation yield factor");
fScintYieldFactor1Cmd->SetGuidance("Note this command is used to set the default value,");
fScintYieldFactor1Cmd->SetGuidance("if process is not active command will not have effect.");
fScintYieldFactor1Cmd->SetGuidance("DEPRECATED: use /process/optical/scintillation/setYieldFactorinstead.");
fScintYieldFactor1Cmd->SetParameterName("ScintillationYieldFactor", false);
fScintYieldFactor1Cmd->SetRange("ScintillationYieldFactor>=0");
fScintYieldFactor1Cmd->AvailableForStates(G4State_PreInit);
fScintYieldFactorCmd = new G4UIcmdWithADouble("/process/optical/scintillation/setYieldFactor", this);
fScintYieldFactorCmd->SetGuidance("Set scintillation yield factor");
fScintYieldFactorCmd->SetGuidance("Note this command is used to set the default value,");
fScintYieldFactorCmd->SetGuidance("if process is not active command will not have effect.");
fScintYieldFactorCmd->SetParameterName("ScintillationYieldFactor", false);
fScintYieldFactorCmd->SetRange("ScintillationYieldFactor>=0");
fScintYieldFactorCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintExcitationRatioCmd = new G4UIcmdWithADouble("/process/optical/scintillation/setExcitationRatio", this);
fScintExcitationRatioCmd->SetGuidance("Set scintillation excitation ratio");
fScintExcitationRatioCmd->SetGuidance("Note this command is used to set the default value,");
fScintExcitationRatioCmd->SetGuidance("if process is not active command will not have effect.");
fScintExcitationRatioCmd->SetParameterName("ExcitationRatio", false);
fScintExcitationRatioCmd->SetRange("ExcitationRatio >= 0 && ExcitationRatio <=1");
fScintExcitationRatioCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintByParticleType1Cmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setByParticleType", this);
fScintByParticleType1Cmd->SetGuidance("Activate/Inactivate scintillation process by particle type");
fScintByParticleType1Cmd->SetGuidance("Note this command is used to set the default value,");
fScintByParticleType1Cmd->SetGuidance("if process is not active command will not have effect.");
fScintByParticleType1Cmd->SetGuidance("DEPRECATED: use /process/optical/scintillation/setByParticleType instead.");
fScintByParticleType1Cmd->SetParameterName("ScintillationByParticleTypeActivation", false);
fScintByParticleType1Cmd->AvailableForStates(G4State_PreInit);
fScintByParticleTypeCmd = new G4UIcmdWithABool("/process/optical/scintillation/setByParticleType", this);
fScintByParticleTypeCmd->SetGuidance("Activate/Inactivate scintillation process by particle type");
fScintByParticleTypeCmd->SetGuidance("Note this command is used to set the default value,");
fScintByParticleTypeCmd->SetGuidance("if process is not active command will not have effect.");
fScintByParticleTypeCmd->SetParameterName("ScintillationByParticleTypeActivation", false);
fScintByParticleTypeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintTrackInfo1Cmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setTrackInfo", this);
fScintTrackInfo1Cmd->SetGuidance("Activate/Inactivate scintillation TrackInformation");
fScintTrackInfo1Cmd->SetGuidance("DEPRECATED: use /process/optical/scintillation/setTrackInfo instead.");
fScintTrackInfo1Cmd->SetParameterName("ScintillationTrackInfo", false);
fScintTrackInfo1Cmd->AvailableForStates(G4State_PreInit);
fScintTrackInfoCmd = new G4UIcmdWithABool("/process/optical/scintillation/setTrackInfo", this);
fScintTrackInfoCmd->SetGuidance("Activate/Inactivate scintillation TrackInformation");
fScintTrackInfoCmd->SetParameterName("ScintillationTrackInfo", false);
fScintTrackInfoCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintFiniteRiseTime1Cmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setFiniteRiseTime", this);
fScintFiniteRiseTime1Cmd->SetGuidance("Set option of a finite rise-time for G4Scintillation");
fScintFiniteRiseTime1Cmd->SetGuidance("If set, the G4Scintillation process expects the user to have set the");
fScintFiniteRiseTime1Cmd->SetGuidance("constant material property FAST/SLOWSCINTILLATIONRISETIME");
fScintFiniteRiseTime1Cmd->SetGuidance("Note this command is used to set the default value,");
fScintFiniteRiseTime1Cmd->SetGuidance("if process is not active command will not have effect.");
fScintFiniteRiseTime1Cmd->SetGuidance("DEPRECATED: use /process/optical/scintillation/setFiniteRiseTime instead.");
fScintFiniteRiseTime1Cmd->SetParameterName("FiniteRiseTime", false);
fScintFiniteRiseTime1Cmd->AvailableForStates(G4State_PreInit);
fScintFiniteRiseTimeCmd = new G4UIcmdWithABool("/process/optical/scintillation/setFiniteRiseTime", this);
fScintFiniteRiseTimeCmd->SetGuidance("Set option of a finite rise-time for G4Scintillation");
fScintFiniteRiseTimeCmd->SetGuidance("If set, the G4Scintillation process expects the user to have set the");
fScintFiniteRiseTimeCmd->SetGuidance("constant material property FAST/SLOWSCINTILLATIONRISETIME");
fScintFiniteRiseTimeCmd->SetGuidance("Note this command is used to set the default value,");
fScintFiniteRiseTimeCmd->SetGuidance("if process is not active command will not have effect.");
fScintFiniteRiseTimeCmd->SetParameterName("FiniteRiseTime", false);
fScintFiniteRiseTimeCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintStackPhotons1Cmd = new G4UIcmdWithABool("/process/optical/defaults/scintillation/setStackPhotons", this);
fScintStackPhotons1Cmd->SetGuidance("Set default whether or not to stack secondary Scintillation photons");
fScintStackPhotons1Cmd->SetGuidance("Note this command is used to set the default value,");
fScintStackPhotons1Cmd->SetGuidance("if process is not active command will not have effect.");
fScintStackPhotons1Cmd->SetGuidance("DEPRECATED: use /process/optical/scintillation/setStackPhotons instead.");
fScintStackPhotons1Cmd->SetParameterName("ScintillationStackPhotons", true);
fScintStackPhotons1Cmd->AvailableForStates(G4State_PreInit);
fScintStackPhotonsCmd = new G4UIcmdWithABool("/process/optical/scintillation/setStackPhotons", this);
fScintStackPhotonsCmd->SetGuidance("Set default whether or not to stack secondary Scintillation photons");
fScintStackPhotonsCmd->SetGuidance("Note this command is used to set the default value,");
fScintStackPhotonsCmd->SetGuidance("if process is not active command will not have effect.");
fScintStackPhotonsCmd->SetParameterName("ScintillationStackPhotons", true);
fScintStackPhotonsCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintTrackSecondariesFirstCmd = new G4UIcmdWithABool("/process/optical/scintillation/setTrackSecondariesFirst", this);
fScintTrackSecondariesFirstCmd->SetGuidance("Whether to track scintillation secondaries before primary.");
fScintTrackSecondariesFirstCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fScintVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/scintillation/verbose", this);
fScintVerbosityCmd->SetGuidance("Verbosity for scintillation process.");
fScintVerbosityCmd->SetParameterName("verbosity", true);
fScintVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fScintVerbosityCmd->AvailableForStates(G4State_Idle);
// WLS //////////////////////////////////
fWLSTimeProfile1Cmd = new G4UIcmdWithAString("/process/optical/defaults/wls/setTimeProfile", this);
fWLSTimeProfile1Cmd->SetGuidance("Set the WLS time profile (delta or exponential)");
fWLSTimeProfile1Cmd->SetGuidance("DEPRECATED: use /process/optical/wls/setTimeProfile instead.");
fWLSTimeProfile1Cmd->SetParameterName("WLSTimeProfile", false);
fWLSTimeProfile1Cmd->SetCandidates("delta exponential");
fWLSTimeProfile1Cmd->AvailableForStates(G4State_PreInit);
fWLSTimeProfileCmd = new G4UIcmdWithAString("/process/optical/wls/setTimeProfile", this);
fWLSTimeProfileCmd->SetGuidance("Set the WLS time profile (delta or exponential)");
fWLSTimeProfileCmd->SetParameterName("WLSTimeProfile", false);
fWLSTimeProfileCmd->SetCandidates("delta exponential");
fWLSTimeProfileCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fWLSVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/wls/verbose", this);
fWLSVerbosityCmd->SetGuidance("Verbosity for WLS process.");
fWLSVerbosityCmd->SetParameterName("verbosity", true);
fWLSVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fWLSVerbosityCmd->AvailableForStates(G4State_Idle);
// boundary //////////////////////////////////////
fBoundaryInvokeSD1Cmd = new G4UIcmdWithABool("/process/optical/defaults/boundary/setInvokeSD", this);
fBoundaryInvokeSD1Cmd->SetGuidance("Set option for calling InvokeSD in G4OpBoundaryProcess");
fBoundaryInvokeSD1Cmd->SetGuidance("DEPRECATED: use /process/optical/boundary/setInvokeSD instead.");
fBoundaryInvokeSD1Cmd->SetParameterName("InvokeSD", false);
fBoundaryInvokeSD1Cmd->AvailableForStates(G4State_PreInit);
fBoundaryInvokeSDCmd = new G4UIcmdWithABool("/process/optical/boundary/setInvokeSD", this);
fBoundaryInvokeSDCmd->SetGuidance("Set option for calling InvokeSD in G4OpBoundaryProcess");
fBoundaryInvokeSDCmd->SetParameterName("InvokeSD", false);
fBoundaryInvokeSDCmd->AvailableForStates(G4State_PreInit, G4State_Idle);
fBoundaryVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/boundary/verbose", this);
fBoundaryVerbosityCmd->SetGuidance("Verbosity for boundary process.");
fBoundaryVerbosityCmd->SetParameterName("verbosity", true);
fBoundaryVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fBoundaryVerbosityCmd->AvailableForStates(G4State_Idle);
// the others ////////////////////////////////////
fAbsorptionVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/absorption/verbose", this);
fAbsorptionVerbosityCmd->SetGuidance("Verbosity for absorption process.");
fAbsorptionVerbosityCmd->SetParameterName("verbosity", true);
fAbsorptionVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fAbsorptionVerbosityCmd->AvailableForStates(G4State_Idle);
fRayleighVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/rayleigh/verbose", this);
fRayleighVerbosityCmd->SetGuidance("Verbosity for Rayleigh process.");
fRayleighVerbosityCmd->SetParameterName("verbosity", true);
fRayleighVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fRayleighVerbosityCmd->AvailableForStates(G4State_Idle);
fMieVerbosityCmd = new G4UIcmdWithAnInteger("/process/optical/mie/verbose", this);
fMieVerbosityCmd->SetGuidance("Verbosity for Mie process.");
fMieVerbosityCmd->SetParameterName("verbosity", true);
fMieVerbosityCmd->SetRange("verbosity >= 0 && verbosity <= 2");
fMieVerbosityCmd->AvailableForStates(G4State_Idle);
}
G4OpticalPhysicsMessenger::~G4OpticalPhysicsMessenger()
{
// Destructor
delete fDir;
delete fDir2;
delete fActivateProcessCmd;
delete fSetOpProcessVerboseCmd;
delete fSetCerenkovMaxPhotonsCmd;
delete fSetCerenkovMaxBetaChangeCmd;
delete fSetCerenkovStackPhotonsCmd;
delete fSetScintillationYieldFactorCmd;
delete fSetScintillationByParticleTypeCmd;
delete fSetScintillationTrackInfoCmd;
delete fSetScintillationStackPhotonsCmd;
delete fSetWLSTimeProfileCmd;
delete fSetTrackSecondariesFirstCmd;
delete fSetFiniteRiseTimeCmd;
delete fSetInvokeSDCmd;
delete fVerboseCmd;
delete fCerenkovMaxPhotonsCmd;
delete fCerenkovMaxPhotons1Cmd;
delete fCerenkovMaxBetaChangeCmd;
delete fCerenkovMaxBetaChange1Cmd;
delete fCerenkovStackPhotonsCmd;
delete fCerenkovStackPhotons1Cmd;
delete fCerenkovTrackSecondariesFirstCmd;
delete fCerenkovVerbosityCmd;
delete fScintYieldFactorCmd;
delete fScintYieldFactor1Cmd;
delete fScintByParticleTypeCmd;
delete fScintByParticleType1Cmd;
delete fScintTrackInfoCmd;
delete fScintTrackInfo1Cmd;
delete fScintStackPhotonsCmd;
delete fScintStackPhotons1Cmd;
delete fScintExcitationRatioCmd;
delete fScintVerbosityCmd;
delete fScintFiniteRiseTimeCmd;
delete fScintFiniteRiseTime1Cmd;
delete fScintTrackSecondariesFirstCmd;
delete fWLSTimeProfileCmd;
delete fWLSTimeProfile1Cmd;
delete fWLSVerbosityCmd;
delete fAbsorptionVerbosityCmd;
delete fRayleighVerbosityCmd;
delete fMieVerbosityCmd;
delete fBoundaryVerbosityCmd;
delete fTrackSecondariesFirstCmd;
delete fBoundaryInvokeSDCmd;
delete fBoundaryInvokeSD1Cmd;
}
#include <iostream>
void G4OpticalPhysicsMessenger::SetNewValue(G4UIcommand* command,
G4String newValue)
{
@@ -248,7 +439,7 @@ void G4OpticalPhysicsMessenger::SetNewValue(G4UIcommand* command,
G4bool value = G4UIcommand::ConvertToBool(flag);
fOpticalPhysics->Configure(fSelectedProcessIndex,value);
}
else if (command == fSetTrackSecondariesFirstCmd )
else if (command == fTrackSecondariesFirstCmd )
{
std::istringstream is(newValue.data());
G4String pn;
@@ -276,54 +467,137 @@ void G4OpticalPhysicsMessenger::SetNewValue(G4UIcommand* command,
G4bool value = G4UIcommand::ConvertToBool(flag);
fOpticalPhysics->SetTrackSecondariesFirst(fSelectedProcessIndex,value);
}
else if (command == fSetOpProcessVerboseCmd) {
fOpticalPhysics->SetVerboseLevel(fSetOpProcessVerboseCmd->GetNewIntValue(newValue));
else if (command == fVerboseCmd) {
fOpticalPhysics->SetVerboseLevel(fVerboseCmd->GetNewIntValue(newValue));
}
else if (command == fSetCerenkovMaxPhotonsCmd) {
fOpticalPhysics
->SetMaxNumPhotonsPerStep(
fSetCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
else if (command == fCerenkovMaxPhotons1Cmd) {
fOpticalPhysics->SetMaxNumPhotonsPerStep(
fCerenkovMaxPhotons1Cmd->GetNewIntValue(newValue));
Deprecated();
}
else if (command == fSetCerenkovMaxBetaChangeCmd) {
fOpticalPhysics
->SetMaxBetaChangePerStep(
fSetCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
else if (command == fCerenkovMaxPhotonsCmd) {
fOpticalPhysics->SetMaxNumPhotonsPerStep(
fCerenkovMaxPhotonsCmd->GetNewIntValue(newValue));
}
else if (command == fSetCerenkovStackPhotonsCmd) {
fOpticalPhysics
->SetCerenkovStackPhotons(
fSetCerenkovStackPhotonsCmd->GetNewBoolValue(newValue));
else if (command == fCerenkovMaxBetaChange1Cmd) {
fOpticalPhysics->SetMaxBetaChangePerStep(
fCerenkovMaxBetaChange1Cmd->GetNewDoubleValue(newValue));
Deprecated();
}
else if (command == fSetScintillationYieldFactorCmd) {
fOpticalPhysics
->SetScintillationYieldFactor(
fSetScintillationYieldFactorCmd->GetNewDoubleValue(newValue));
else if (command == fCerenkovMaxBetaChangeCmd) {
fOpticalPhysics->SetMaxBetaChangePerStep(
fCerenkovMaxBetaChangeCmd->GetNewDoubleValue(newValue));
}
else if (command == fSetScintillationByParticleTypeCmd) {
fOpticalPhysics
->SetScintillationByParticleType(
fSetScintillationByParticleTypeCmd->GetNewBoolValue(newValue));
else if (command == fCerenkovStackPhotons1Cmd) {
fOpticalPhysics->SetCerenkovStackPhotons(
fCerenkovStackPhotons1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fSetScintillationTrackInfoCmd) {
fOpticalPhysics
->SetScintillationTrackInfo(
fSetScintillationTrackInfoCmd->GetNewBoolValue(newValue));
else if (command == fCerenkovStackPhotonsCmd) {
fOpticalPhysics->SetCerenkovStackPhotons(
fCerenkovStackPhotonsCmd->GetNewBoolValue(newValue));
}
else if (command == fSetFiniteRiseTimeCmd) {
fOpticalPhysics
->SetFiniteRiseTime(
fSetFiniteRiseTimeCmd->GetNewBoolValue(newValue));
else if (command == fCerenkovTrackSecondariesFirstCmd) {
fOpticalPhysics->SetCerenkovTrackSecondariesFirst(
fCerenkovTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
}
else if (command == fSetScintillationStackPhotonsCmd) {
fOpticalPhysics
->SetScintillationStackPhotons(
fSetScintillationStackPhotonsCmd->GetNewBoolValue(newValue));
else if (command == fCerenkovVerbosityCmd) {
fOpticalPhysics->SetCerenkovVerbosity(
fCerenkovVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fSetWLSTimeProfileCmd) {
else if (command == fScintYieldFactor1Cmd) {
fOpticalPhysics->SetScintillationYieldFactor(
fScintYieldFactor1Cmd->GetNewDoubleValue(newValue));
Deprecated();
}
else if (command == fScintYieldFactorCmd) {
fOpticalPhysics->SetScintillationYieldFactor(
fScintYieldFactorCmd->GetNewDoubleValue(newValue));
}
else if (command == fScintByParticleType1Cmd) {
fOpticalPhysics->SetScintillationByParticleType(
fScintByParticleType1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fScintByParticleTypeCmd) {
fOpticalPhysics->SetScintillationByParticleType(
fScintByParticleTypeCmd->GetNewBoolValue(newValue));
}
else if (command == fScintTrackInfo1Cmd) {
fOpticalPhysics->SetScintillationTrackInfo(
fScintTrackInfo1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fScintTrackInfoCmd) {
fOpticalPhysics->SetScintillationTrackInfo(
fScintTrackInfoCmd->GetNewBoolValue(newValue));
}
else if (command == fScintFiniteRiseTime1Cmd) {
fOpticalPhysics->SetFiniteRiseTime(
fScintFiniteRiseTime1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fScintFiniteRiseTimeCmd) {
fOpticalPhysics->SetFiniteRiseTime(
fScintFiniteRiseTimeCmd->GetNewBoolValue(newValue));
}
else if (command == fScintStackPhotons1Cmd) {
fOpticalPhysics->SetScintillationStackPhotons(
fScintStackPhotons1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fScintStackPhotonsCmd) {
fOpticalPhysics->SetScintillationStackPhotons(
fScintStackPhotonsCmd->GetNewBoolValue(newValue));
}
else if (command == fScintExcitationRatioCmd) {
fOpticalPhysics->SetScintillationExcitationRatio(
fScintExcitationRatioCmd->GetNewDoubleValue(newValue));
}
else if (command == fScintTrackSecondariesFirstCmd) {
fOpticalPhysics->SetScintillationTrackSecondariesFirst(
fScintTrackSecondariesFirstCmd->GetNewBoolValue(newValue));
}
else if (command == fScintVerbosityCmd) {
fOpticalPhysics->SetScintillationVerbosity(
fScintVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fWLSTimeProfile1Cmd) {
fOpticalPhysics->SetWLSTimeProfile(newValue);
Deprecated();
}
else if (command == fWLSTimeProfileCmd) {
fOpticalPhysics->SetWLSTimeProfile(newValue);
}
else if (command == fSetInvokeSDCmd) {
else if (command == fWLSVerbosityCmd) {
fOpticalPhysics->SetWLSVerbosity(fWLSVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fAbsorptionVerbosityCmd) {
fOpticalPhysics->SetAbsorptionVerbosity(fAbsorptionVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fRayleighVerbosityCmd) {
fOpticalPhysics->SetRayleighVerbosity(fRayleighVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fMieVerbosityCmd) {
fOpticalPhysics->SetMieVerbosity(fMieVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fBoundaryVerbosityCmd) {
fOpticalPhysics->SetBoundaryVerbosity(fBoundaryVerbosityCmd->GetNewIntValue(newValue));
}
else if (command == fBoundaryInvokeSD1Cmd) {
fOpticalPhysics->SetInvokeSD(fBoundaryInvokeSD1Cmd->GetNewBoolValue(newValue));
Deprecated();
}
else if (command == fBoundaryInvokeSDCmd) {
fOpticalPhysics
->SetInvokeSD(fSetInvokeSDCmd->GetNewBoolValue(newValue));
->SetInvokeSD(fBoundaryInvokeSDCmd->GetNewBoolValue(newValue));
}
}
void G4OpticalPhysicsMessenger::Deprecated()
{
G4ExceptionDescription ed;
ed <<" This command has been deprecated and will be removed in the next" << G4endl
<< "major release. Use the same command without /defaults/ instead.";
G4Exception("G4OpticalPhysicsMessenger", "optical001", JustWarning, ed);
}
source/physics_lists/constructors/hadron_elastic/History
+4
View File
@@ -13,6 +13,10 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
05-Mar-2019, A. Ribon (phys-ctor-helastic-V10-04-06)
- G4HadronElasticPhysics : for deuteron, triton and alpha, use Glauber-Gribov
elastic cross sections (instead of Gheisha ones, which returns zero).
26-Nov-2018, A. Ribon (phys-ctor-helastic-V10-04-05)
- README : updated this file. No changes to anything else.
source/physics_lists/constructors/hadron_elastic/README
+2 -2
View File
@@ -41,10 +41,10 @@
- kaons
- cross section: Glauber-Gribov
- final-state: Gheisha
- hyperons, anti-hyperons, deuteron, triton, alpha
- hyperons, anti-hyperons
- cross section: Gheisha
- final-state: Gheisha
- He3
- deuteron, triton, He3, alpha
- cross section: Glauber-Gribov
- final-state: Gheisha
- anti_proton, anti_deuteron, anti_triton, anti_He3, anti_alpha
source/physics_lists/constructors/hadron_elastic/src/G4HadronElasticPhysics.cc
+6 -11
View File
@@ -40,12 +40,6 @@
//
//----------------------------------------------------------------------------
//
// CHIPS for sampling scattering for p and n
// Glauber model for samplimg of high energy pi+- (E > 1GeV)
// LHEP sampling model for the other particle
// BBG cross sections for p, n and pi+-
// LHEP cross sections for other particles
#include "G4HadronElasticPhysics.hh"
#include "G4SystemOfUnits.hh"
@@ -156,10 +150,7 @@ void G4HadronElasticPhysics::ConstructProcess()
pname == "omega-" ||
pname == "sigma-" ||
pname == "sigma+" ||
pname == "xi-" ||
pname == "alpha" ||
pname == "deuteron" ||
pname == "triton"
pname == "xi-"
) {
hel = new G4HadronElasticProcess();
@@ -170,7 +161,11 @@ void G4HadronElasticPhysics::ConstructProcess()
<< " added for " << particle->GetParticleName() << G4endl;
}
} else if(pname == "He3") {
} else if(pname == "alpha" ||
pname == "deuteron" ||
pname == "triton" ||
pname == "He3"
) {
hel = new G4HadronElasticProcess();
G4VCrossSectionDataSet* theComponentGGNuclNuclData =
new G4CrossSectionElastic(new G4ComponentGGNuclNuclXsc());
source/physics_lists/lists/History
+5
View File
@@ -13,6 +13,11 @@ introduced in the code and keeptrack of all tags.
* Reverse chronological order (last date on top), please *
----------------------------------------------------------
09-April-2019 V.Ivanchenko (phys-lists-V10-04-08)
18-March-2019 V.Ivanchenko
- Shielding, QGSP_BIC_HP, QGSP_BIC_AllHP - cut for proton is set
to zero (problem #2150) and code clean-up
21-November-2018 A. Ribon (phys-lists-V10-04-07)
- Shielding : replaced "putenv" of the environmental variable
G4NEUTRONHP_PRODUCE_FISSION_FRAGMENTS with a call to
source/physics_lists/lists/src/QGSP_BIC.cc
+11 -11
View File
@@ -68,33 +68,33 @@ QGSP_BIC::QGSP_BIC(G4int ver)
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_BIC"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
defaultCutValue = 0.7*CLHEP::mm;
SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(ver) );
RegisterPhysics( new G4EmStandardPhysics(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
RegisterPhysics( new G4DecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysics(ver) );
RegisterPhysics( new G4HadronElasticPhysics(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_BIC(ver));
RegisterPhysics( new G4HadronPhysicsQGSP_BIC(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonElasticPhysics(ver) );
this->RegisterPhysics( new G4IonPhysics(ver));
RegisterPhysics( new G4IonElasticPhysics(ver) );
RegisterPhysics( new G4IonPhysics(ver));
// Neutron tracking cut
this->RegisterPhysics( new G4NeutronTrackingCut(ver));
RegisterPhysics( new G4NeutronTrackingCut(ver));
}
source/physics_lists/lists/src/QGSP_BIC_AllHP.cc
+12 -11
View File
@@ -54,31 +54,32 @@ QGSP_BIC_AllHP::QGSP_BIC_AllHP(G4int ver)
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_BIC_AllHP"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
defaultCutValue = 0.7*CLHEP::mm;
SetCutValue(0, "proton");
SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics_option4(ver) );
RegisterPhysics( new G4EmStandardPhysics_option4(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
this->RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
RegisterPhysics( new G4DecayPhysics(ver) );
RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysicsPHP(ver) );
RegisterPhysics( new G4HadronElasticPhysicsPHP(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_BIC_AllHP(ver));
RegisterPhysics( new G4HadronPhysicsQGSP_BIC_AllHP(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonElasticPhysics(ver) );
this->RegisterPhysics( new G4IonPhysicsPHP(ver));
RegisterPhysics( new G4IonElasticPhysics(ver) );
RegisterPhysics( new G4IonPhysicsPHP(ver));
}
source/physics_lists/lists/src/QGSP_BIC_HP.cc
+12 -11
View File
@@ -60,31 +60,32 @@ QGSP_BIC_HP::QGSP_BIC_HP(G4int ver)
G4cout << "<<< Geant4 Physics List simulation engine: QGSP_BIC_HP"<<G4endl;
G4cout <<G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(ver);
defaultCutValue = 0.7*CLHEP::mm;
SetCutValue(0, "proton");
SetVerboseLevel(ver);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics_option4(ver) );
RegisterPhysics( new G4EmStandardPhysics_option4(ver) );
// Synchroton Radiation & GN Physics
this->RegisterPhysics( new G4EmExtraPhysics(ver) );
RegisterPhysics( new G4EmExtraPhysics(ver) );
// Decays
this->RegisterPhysics( new G4DecayPhysics(ver) );
this->RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
RegisterPhysics( new G4DecayPhysics(ver) );
RegisterPhysics( new G4RadioactiveDecayPhysics(ver) );
// Hadron Elastic scattering
this->RegisterPhysics( new G4HadronElasticPhysicsHP(ver) );
RegisterPhysics( new G4HadronElasticPhysicsHP(ver) );
// Hadron Physics
this->RegisterPhysics( new G4HadronPhysicsQGSP_BIC_HP(ver));
RegisterPhysics( new G4HadronPhysicsQGSP_BIC_HP(ver));
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(ver) );
RegisterPhysics( new G4StoppingPhysics(ver) );
// Ion Physics
this->RegisterPhysics( new G4IonElasticPhysics(ver) );
this->RegisterPhysics( new G4IonPhysics(ver));
RegisterPhysics( new G4IonElasticPhysics(ver) );
RegisterPhysics( new G4IonPhysics(ver));
}
source/physics_lists/lists/src/Shielding.cc
+14 -16
View File
@@ -45,10 +45,7 @@
//
#include "Shielding.hh"
//#include <iomanip>
#include "globals.hh"
//#include "G4ios.hh"
#include "G4DecayPhysics.hh"
#include "G4RadioactiveDecayPhysics.hh"
@@ -88,11 +85,12 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
"<<< LEND will be used for low energy neutron and gamma projectiles"
<< G4endl;
this->defaultCutValue = 0.7*CLHEP::mm;
this->SetVerboseLevel(verbose);
defaultCutValue = 0.7*CLHEP::mm;
SetCutValue(0, "proton");
SetVerboseLevel(verbose);
// EM Physics
this->RegisterPhysics( new G4EmStandardPhysics(verbose));
RegisterPhysics( new G4EmStandardPhysics(verbose));
// Synchroton Radiation & GN Physics
G4EmExtraPhysics* emExtraPhysics = new G4EmExtraPhysics(verbose);
@@ -100,20 +98,20 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
// Use LEND model for Gamma Nuclear
emExtraPhysics->LENDGammaNuclear(true);
}
this->RegisterPhysics( emExtraPhysics );
RegisterPhysics( emExtraPhysics );
// Decays
this->RegisterPhysics( new G4DecayPhysics(verbose) );
this->RegisterPhysics( new G4RadioactiveDecayPhysics(verbose) );
RegisterPhysics( new G4DecayPhysics(verbose) );
RegisterPhysics( new G4RadioactiveDecayPhysics(verbose) );
// Hadron Elastic scattering
if ( LEN_model == "HP" )
{
this->RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
}
else if ( LEN_model == "LEND" )
{
this->RegisterPhysics( new G4HadronElasticPhysicsLEND(verbose,evaluation));
RegisterPhysics( new G4HadronElasticPhysicsLEND(verbose,evaluation));
G4DataQuestionaire itt(lend);
}
else
@@ -122,7 +120,7 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
G4cout << "\"" << LEN_model
<< "\" is not valid for the low energy neutorn model." <<G4endl;
G4cout << "Neutron HP package will be used." <<G4endl;
this->RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
}
G4VPhysicsConstructor* hpc;
@@ -150,7 +148,7 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
// << " is invalid." <<G4endl;
//G4cout << "Will use neutron HP package." <<G4endl;
}
this->RegisterPhysics( hpc );
RegisterPhysics( hpc );
if ( LEN_model == "HP" ) {
//Activate prodcuton of fission fragments in neutronHP
@@ -158,11 +156,11 @@ Shielding::Shielding(G4int verbose, const G4String& n_model,
}
// Stopping Physics
this->RegisterPhysics( new G4StoppingPhysics(verbose) );
RegisterPhysics( new G4StoppingPhysics(verbose) );
// Ion Physics
this->RegisterPhysics( new G4IonElasticPhysics(verbose));
this->RegisterPhysics( new G4IonQMDPhysics(verbose));
RegisterPhysics( new G4IonElasticPhysics(verbose));
RegisterPhysics( new G4IonQMDPhysics(verbose));
}
Shielding::~Shielding()