#include <Shielding.hh>

Inheritance diagram for Shielding:

Public Member Functions
	Shielding (G4int verb=1, const G4String &n_model="HP", const G4String &HadrPhysVariant="", G4bool useLightIonQMD=false)

virtual	~Shielding ()=default

	Shielding (const Shielding &)=delete

Shielding &	operator= (const Shielding &right)=delete

Public Member Functions inherited from G4VModularPhysicsList
	G4VModularPhysicsList ()

	~G4VModularPhysicsList () override

void	ConstructParticle () override

void	ConstructProcess () override

void	RegisterPhysics (G4VPhysicsConstructor *)

const G4VPhysicsConstructor *	GetPhysics (G4int index) const

const G4VPhysicsConstructor *	GetPhysics (const G4String &name) const

const G4VPhysicsConstructor *	GetPhysicsWithType (G4int physics_type) const

void	ReplacePhysics (G4VPhysicsConstructor *)

void	RemovePhysics (G4VPhysicsConstructor *)

void	RemovePhysics (G4int type)

void	RemovePhysics (const G4String &name)

G4int	GetInstanceID () const

void	TerminateWorker () override

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

Public Member Functions inherited from G4VUserPhysicsList
	G4VUserPhysicsList ()

virtual	~G4VUserPhysicsList ()

	G4VUserPhysicsList (const G4VUserPhysicsList &)

G4VUserPhysicsList &	operator= (const G4VUserPhysicsList &)

void	Construct ()

virtual void	SetCuts ()

void	SetDefaultCutValue (G4double newCutValue)

G4double	GetDefaultCutValue () const

void	BuildPhysicsTable ()

void	PreparePhysicsTable (G4ParticleDefinition *)

void	BuildPhysicsTable (G4ParticleDefinition *)

G4bool	StorePhysicsTable (const G4String &directory=".")

G4bool	IsPhysicsTableRetrieved () const

G4bool	IsStoredInAscii () const

const G4String &	GetPhysicsTableDirectory () const

void	SetPhysicsTableRetrieved (const G4String &directory="")

void	SetStoredInAscii ()

void	ResetPhysicsTableRetrieved ()

void	ResetStoredInAscii ()

void	DumpList () const

void	DumpCutValuesTable (G4int flag=1)

void	DumpCutValuesTableIfRequested ()

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

void	UseCoupledTransportation (G4bool vl=true)

void	SetCutsWithDefault ()

void	SetCutValue (G4double aCut, const G4String &pname)

G4double	GetCutValue (const G4String &pname) const

void	SetCutValue (G4double aCut, const G4String &pname, const G4String &rname)

void	SetParticleCuts (G4double cut, G4ParticleDefinition particle, G4Region region=nullptr)

void	SetParticleCuts (G4double cut, const G4String &particleName, G4Region *region=nullptr)

void	SetCutsForRegion (G4double aCut, const G4String &rname)

void	SetApplyCuts (G4bool value, const G4String &name)

G4bool	GetApplyCuts (const G4String &name) const

void	RemoveProcessManager ()

void	RemoveTrackingManager ()

void	AddProcessManager (G4ParticleDefinition newParticle, G4ProcessManager newManager=nullptr)

void	CheckParticleList ()

void	DisableCheckParticleList ()

G4int	GetInstanceID () const

virtual void	InitializeWorker ()

Additional Inherited Members
Static Public Member Functions inherited from G4VModularPhysicsList
static const G4VMPLManager &	GetSubInstanceManager ()

Static Public Member Functions inherited from G4VUserPhysicsList
static const G4VUPLManager &	GetSubInstanceManager ()

Protected Types inherited from G4VModularPhysicsList
using	G4PhysConstVector = G4VMPLData::G4PhysConstVectorData

Protected Member Functions inherited from G4VModularPhysicsList
	G4VModularPhysicsList (const G4VModularPhysicsList &)

G4VModularPhysicsList &	operator= (const G4VModularPhysicsList &)

Protected Member Functions inherited from G4VUserPhysicsList
void	AddTransportation ()

G4bool	RegisterProcess (G4VProcess process, G4ParticleDefinition particle)

void	BuildIntegralPhysicsTable (G4VProcess , G4ParticleDefinition )

virtual void	RetrievePhysicsTable (G4ParticleDefinition *, const G4String &directory, G4bool ascii=false)

void	InitializeProcessManager ()

G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Protected Attributes inherited from G4VModularPhysicsList
G4int	verboseLevel = 0

G4int	g4vmplInstanceID = 0

Protected Attributes inherited from G4VUserPhysicsList
G4ParticleTable *	theParticleTable = nullptr

G4int	verboseLevel = 1

G4double	defaultCutValue = 1.0

G4bool	isSetDefaultCutValue = false

G4ProductionCutsTable *	fCutsTable = nullptr

G4bool	fRetrievePhysicsTable = false

G4bool	fStoredInAscii = true

G4bool	fIsCheckedForRetrievePhysicsTable = false

G4bool	fIsRestoredCutValues = false

G4String	directoryPhysicsTable = "."

G4bool	fDisableCheckParticleList = false

G4int	g4vuplInstanceID = 0

Static Protected Attributes inherited from G4VModularPhysicsList
static G4RUN_DLL G4VMPLManager	G4VMPLsubInstanceManager

Static Protected Attributes inherited from G4VUserPhysicsList
static G4RUN_DLL G4VUPLManager	subInstanceManager

Detailed Description

Definition at line 46 of file Shielding.hh.

Constructor & Destructor Documentation

◆ Shielding() [1/2]

Shielding::Shielding	(	G4int	verb = 1,
		const G4String &	n_model = "HP",
		const G4String &	HadrPhysVariant = "",
		G4bool	useLightIonQMD = false )

explicit

Definition at line 70 of file Shielding.cc.

{
  G4String LEN_model = n_model; 
  size_t find = LEN_model.find("LEND__");
  G4String evaluation;
  if ( find != G4String::npos )
  {
     evaluation=LEN_model;
     evaluation.erase(0,find+6);
     LEN_model="LEND";
  }
 
  if(verbose > 0) {
    G4cout << "<<< Geant4 Physics List simulation engine: Shielding"
       << HadrPhysVariant << G4endl;
    if ( LEN_model=="LEND" ) {
      G4cout << "<<< LEND will be used for low energy neutron and gamma projectiles" << G4endl;
    } else {
      G4cout << "<<< (Note that Shielding" << HadrPhysVariant << " and Shielding"
         << HadrPhysVariant << "_HP are equivalent!)" << G4endl;
    }
  }
  defaultCutValue = 0.7*CLHEP::mm;  
  SetCutValue(0, "proton");  
  SetVerboseLevel(verbose);
 
  // EM Physics
  RegisterPhysics( new G4EmStandardPhysics(verbose));
 
  // Synchroton Radiation & GN Physics
  G4EmExtraPhysics* emExtraPhysics = new G4EmExtraPhysics(verbose);
  if ( LEN_model == "LEND" ) {
     // Use LEND model for Gamma Nuclear 
     emExtraPhysics->LENDGammaNuclear(true);
  }
  RegisterPhysics( emExtraPhysics );
 
  // Decays 
  RegisterPhysics( new G4DecayPhysics(verbose) );
  RegisterPhysics( new G4RadioactiveDecayPhysics(verbose) );
 
  // Hadron Elastic scattering
  if ( LEN_model == "HP" ) 
  {
     RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
  }
  else if ( LEN_model == "LEND" ) 
  {
     RegisterPhysics( new G4HadronElasticPhysicsLEND(verbose,evaluation));
  }
  else 
  {
     if(verbose > 0) {
       G4cout << "Shielding Physics List: Warning!" <<G4endl;
       G4cout << "\"" << LEN_model 
              << "\" is not valid for the low energy neutron model." <<G4endl;
       G4cout << "Neutron HP package will be used." <<G4endl;
     }
     RegisterPhysics( new G4HadronElasticPhysicsHP(verbose) );
  } 
 
  G4VPhysicsConstructor* hpc;
  // Hadron Physics HP or LEND 
  if (HadrPhysVariant == "M") {
     // The variant "M" has a special, dedicated energy transition region
     // between the string model and cascade model, therefore the recommended
     // values from G4HadronicParameters are intentionally not used. 
     hpc = new G4HadronPhysicsShielding("hInelastic Shielding", verbose, 
                                        9.5*CLHEP::GeV, 9.9*CLHEP::GeV);
  } else {
     hpc = new G4HadronPhysicsShielding("hInelastic Shielding", verbose,
                                        G4HadronicParameters::Instance()->GetMinEnergyTransitionFTF_Cascade(),
                                        G4HadronicParameters::Instance()->GetMaxEnergyTransitionFTF_Cascade());
  }
 
  if ( LEN_model == "LEND" ) {
     delete hpc;
     if (HadrPhysVariant == "M") {
        // The variant "M" has a special, dedicated energy transition region
        // between the string model and cascade model, therefore the recommended
        // values from G4HadronicParameters are intentionally not used. 
        hpc = new G4HadronPhysicsShieldingLEND("hInelastic ShieldingLEND", verbose,
                                               9.5*CLHEP::GeV, 9.9*CLHEP::GeV);
     } else {
        hpc = new G4HadronPhysicsShieldingLEND("hInelastic ShieldingLEND", verbose, 
                                               G4HadronicParameters::Instance()->GetMinEnergyTransitionFTF_Cascade(),
                                               G4HadronicParameters::Instance()->GetMaxEnergyTransitionFTF_Cascade());
     }
  } else {
     //G4cout << "Shielding Physics List: Warning." <<G4endl;
     //G4cout << "Name of Low Energy Neutron model " << LEN_model 
     //         << " is invalid." <<G4endl;
     //G4cout << "Will use neutron HP package." <<G4endl;
  }
  RegisterPhysics( hpc );
 
  if ( LEN_model == "HP" ) {
     //Activate prodcuton of fission fragments in neutronHP
     G4ParticleHPManager::GetInstance()->SetProduceFissionFragments( true );
  }
 
  // Stopping Physics
  RegisterPhysics( new G4StoppingPhysics(verbose) );
 
  // Ion Physics
  RegisterPhysics( new G4IonElasticPhysics(verbose) );
  if (useLightIonQMD){
    RegisterPhysics( new G4LightIonQMDPhysics(verbose) );
  } else {
    RegisterPhysics( new G4IonQMDPhysics(verbose) );
  }
}

◆ ~Shielding()

virtual Shielding::~Shielding ( )

virtualdefault

◆ Shielding() [2/2]

Shielding::Shielding ( const Shielding & )

delete

Member Function Documentation

◆ operator=()

Shielding & Shielding::operator= ( const Shielding & right )