#include <G4HadronPhysicsShielding.hh>

Inheritance diagram for G4HadronPhysicsShielding:

Collaboration diagram for G4HadronPhysicsShielding:

Classes
struct	ThreadPrivate

Public Member Functions
	G4HadronPhysicsShielding (G4int verbose=1)

	G4HadronPhysicsShielding (const G4String &name, G4bool)

	G4HadronPhysicsShielding (const G4String &name, G4int verbose=1, G4double minFTFPEnergy=9.5 GeV, G4double maxBertiniEnergy=9.9 GeV)

virtual	~G4HadronPhysicsShielding ()

virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

void	UseLEND (G4String ss="")

void	UnuseLEND ()

Public Member Functions inherited from G4VPhysicsConstructor
	G4VPhysicsConstructor (const G4String &="")

	G4VPhysicsConstructor (const G4String &name, G4int physics_type)

virtual	~G4VPhysicsConstructor ()

void	SetPhysicsName (const G4String &="")

const G4String &	GetPhysicsName () const

void	SetPhysicsType (G4int)

G4int	GetPhysicsType () const

void	SetVerboseLevel (G4int value)

G4int	GetVerboseLevel () const

G4int	GetInstanceID () const

Private Member Functions
void	CreateModels ()

Private Attributes
G4bool	useLEND_

G4String	evaluation_

const G4double	minFTFPEnergy_

const G4double	maxBertiniEnergy_

const G4double	minNonHPNeutronEnergy_

Static Private Attributes
static G4ThreadLocal ThreadPrivate *	tpdata = 0

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager &	GetSubInstanceManager ()

Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess process, G4ParticleDefinition particle)

G4ParticleTable::G4PTblDicIterator *	GetParticleIterator () const

Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel

G4String	namePhysics

G4int	typePhysics

G4ParticleTable *	theParticleTable

G4int	g4vpcInstanceID

Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager	subInstanceManager

Detailed Description

Definition at line 69 of file G4HadronPhysicsShielding.hh.

Constructor & Destructor Documentation

◆ G4HadronPhysicsShielding() [1/3]

G4HadronPhysicsShielding::G4HadronPhysicsShielding ( G4int verbose = 1 )

explicit

Definition at line 85 of file G4HadronPhysicsShielding.cc.

     :  G4VPhysicsConstructor("hInelastic Shielding")
     , useLEND_(false)
     , evaluation_()
     , minFTFPEnergy_(9.5*GeV)
     , maxBertiniEnergy_(9.9*GeV)
     , minNonHPNeutronEnergy_(19.9*MeV)
 {}

◆ G4HadronPhysicsShielding() [2/3]

G4HadronPhysicsShielding::G4HadronPhysicsShielding	(	const G4String &	name,
		G4bool
	)

explicit

Definition at line 94 of file G4HadronPhysicsShielding.cc.

     :  G4VPhysicsConstructor(name) 
     , useLEND_(false)
     , evaluation_()
     , minFTFPEnergy_(9.5*GeV)
     , maxBertiniEnergy_(9.9*GeV)
     , minNonHPNeutronEnergy_(19.9*MeV)
 {}

◆ G4HadronPhysicsShielding() [3/3]

G4HadronPhysicsShielding::G4HadronPhysicsShielding	(	const G4String &	name,
		G4int	verbose = `1`,
		G4double	minFTFPEnergy = `9.5*GeV`,
		G4double	maxBertiniEnergy = `9.9*GeV`
	)

explicit

Definition at line 103 of file G4HadronPhysicsShielding.cc.

     :  G4VPhysicsConstructor(name)
     , useLEND_(false)
     , evaluation_()
     , minFTFPEnergy_(minFTFPEnergy)
     , maxBertiniEnergy_(maxBertiniEnergy)
     , minNonHPNeutronEnergy_(19.9*MeV)
 {}

◆ ~G4HadronPhysicsShielding()

G4HadronPhysicsShielding::~G4HadronPhysicsShielding ( )

virtual

Definition at line 154 of file G4HadronPhysicsShielding.cc.

 {
   if (!tpdata) return;
 
   delete tpdata->theNeutrons;
   delete tpdata->theBertiniNeutron;
   delete tpdata->theFTFPNeutron;
   //delete tpdata->theHPNeutron;
   delete tpdata->theLENeutron;
     
   delete tpdata->thePiK;
   delete tpdata->theBertiniPiK;
   delete tpdata->theFTFPPiK;
     
   delete tpdata->thePro;
   delete tpdata->theBertiniPro;
   delete tpdata->theFTFPPro;    
     
   delete tpdata->theHyperon;
   delete tpdata->theAntiBaryon;
   delete tpdata->theFTFPAntiBaryon;
 
   delete tpdata->theBGGxsNeutron;
   delete tpdata->theNeutronHPJENDLHEInelastic;
   delete tpdata->theBGGxsProton;
 
   delete tpdata; tpdata=0;
 }

Member Function Documentation

◆ ConstructParticle()

void G4HadronPhysicsShielding::ConstructParticle ( void )

virtual

Implements G4VPhysicsConstructor.

Definition at line 183 of file G4HadronPhysicsShielding.cc.

 {
   G4MesonConstructor pMesonConstructor;
   pMesonConstructor.ConstructParticle();
 
   G4BaryonConstructor pBaryonConstructor;
   pBaryonConstructor.ConstructParticle();
 
   G4ShortLivedConstructor pShortLivedConstructor;
   pShortLivedConstructor.ConstructParticle();  
 
   G4IonConstructor pIonConstructor;
   pIonConstructor.ConstructParticle();
 }

Here is the call graph for this function:

◆ ConstructProcess()

void G4HadronPhysicsShielding::ConstructProcess ( void )

virtual

Implements G4VPhysicsConstructor.

Definition at line 199 of file G4HadronPhysicsShielding.cc.

 {
   if ( tpdata == 0 ) tpdata = new ThreadPrivate;
   CreateModels();
 
   //tpdata->theBGGxsNeutron=new  G4BGGNucleonInelasticXS(G4Neutron::Neutron()); 
   tpdata->thePro->Build();
   tpdata->theNeutrons->Build();
     
   tpdata->theBGGxsNeutron = 0; //set explictly to zero or destructor may fail
 //  tpdata->theBGGxsNeutron=new  G4ParticleHPBGGNucleonInelasticXS(G4Neutron::Neutron());
 //  FindInelasticProcess(G4Neutron::Neutron())->AddDataSet(tpdata->theBGGxsNeutron);
 //
 
   G4PhysListUtil::FindInelasticProcess(G4Neutron::Neutron())->AddDataSet(new  G4BGGNucleonInelasticXS(G4Neutron::Neutron()));
   tpdata->theNeutronHPJENDLHEInelastic=new G4ParticleHPJENDLHEInelasticData;
   G4PhysListUtil::FindInelasticProcess(G4Neutron::Neutron())->AddDataSet(tpdata->theNeutronHPJENDLHEInelastic);
   G4PhysListUtil::FindInelasticProcess(G4Neutron::Neutron())->AddDataSet(new G4ParticleHPInelasticData);
     
   tpdata->theBGGxsProton=0;
 //  tpdata->theBGGxsProton=new G4BGGNucleonInelasticXS(G4Proton::Proton());
 //  G4PhysListUtil::FindInelasticProcess(G4Proton::Proton())->AddDataSet(tpdata->theBGGxsProton);
 
   tpdata->thePiK->Build();
 
   // --- Kaons ---
   tpdata->xsKaon = new G4ComponentGGHadronNucleusXsc();
   G4VCrossSectionDataSet * kaonxs = new G4CrossSectionInelastic(tpdata->xsKaon);
   G4PhysListUtil::FindInelasticProcess(G4KaonMinus::KaonMinus())->AddDataSet(kaonxs);
   G4PhysListUtil::FindInelasticProcess(G4KaonPlus::KaonPlus())->AddDataSet(kaonxs);
   G4PhysListUtil::FindInelasticProcess(G4KaonZeroShort::KaonZeroShort())->AddDataSet(kaonxs);
   G4PhysListUtil::FindInelasticProcess(G4KaonZeroLong::KaonZeroLong())->AddDataSet(kaonxs);
 
   tpdata->theHyperon->Build();
   tpdata->theAntiBaryon->Build();
 
   // --- Neutrons ---
   G4HadronicProcess* capture = 0;
   G4HadronicProcess* fission = 0;
   G4ProcessManager* pmanager = G4Neutron::Neutron()->GetProcessManager();
   G4ProcessVector*  pv = pmanager->GetProcessList();
   for ( size_t i=0; i < static_cast<size_t>(pv->size()); ++i ) {
     if ( fCapture == ((*pv)[i])->GetProcessSubType() ) {
       capture = static_cast<G4HadronicProcess*>((*pv)[i]);
     } else if ( fFission == ((*pv)[i])->GetProcessSubType() ) {
       fission = static_cast<G4HadronicProcess*>((*pv)[i]);
     }
   }
   if ( ! capture ) {
     capture = new G4HadronCaptureProcess("nCapture");
     pmanager->AddDiscreteProcess(capture);
   }
   tpdata->xsNeutronCaptureXS = (G4NeutronCaptureXS*)G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4NeutronCaptureXS::Default_Name());
   capture->AddDataSet(tpdata->xsNeutronCaptureXS);
   capture->AddDataSet( new G4ParticleHPCaptureData );
   G4NeutronRadCapture* theNeutronRadCapture = new G4NeutronRadCapture(); 
   theNeutronRadCapture->SetMinEnergy( minNonHPNeutronEnergy_ ); 
   capture->RegisterMe( theNeutronRadCapture );
   if ( ! fission ) {
     fission = new G4HadronFissionProcess("nFission");
     pmanager->AddDiscreteProcess(fission);
   }
   G4LFission* theNeutronLEPFission = new G4LFission();
   theNeutronLEPFission->SetMinEnergy( minNonHPNeutronEnergy_ );
   fission->RegisterMe( theNeutronLEPFission );
 }

Here is the call graph for this function:

◆ CreateModels()

void G4HadronPhysicsShielding::CreateModels ( )

private

Definition at line 114 of file G4HadronPhysicsShielding.cc.

 {
   G4bool quasiElasticFTF= false;   // Use built-in quasi-elastic (not add-on)
 
   tpdata->theNeutrons=new G4NeutronBuilder( true ); // Fission on
   tpdata->theFTFPNeutron=new G4FTFPNeutronBuilder(quasiElasticFTF);
   tpdata->theFTFPNeutron->SetMinEnergy(minFTFPEnergy_);
   tpdata->theNeutrons->RegisterMe(tpdata->theFTFPNeutron);
   tpdata->theNeutrons->RegisterMe(tpdata->theBertiniNeutron=new G4BertiniNeutronBuilder);
   tpdata->theBertiniNeutron->SetMinEnergy(minNonHPNeutronEnergy_);
   tpdata->theBertiniNeutron->SetMaxEnergy(maxBertiniEnergy_);
   //tpdata->theNeutrons->RegisterMe(tpdata->theHPNeutron=new G4NeutronPHPBuilder);
 
   if ( useLEND_ != true )
      tpdata->theNeutrons->RegisterMe(tpdata->theLENeutron=new G4NeutronPHPBuilder);
   else
   {
      tpdata->theNeutrons->RegisterMe(tpdata->theLENeutron=new G4NeutronLENDBuilder(evaluation_));
   }
 
   tpdata->thePro=new G4ProtonBuilder;
   tpdata->theFTFPPro=new G4FTFPProtonBuilder(quasiElasticFTF);
   tpdata->theFTFPPro->SetMinEnergy(minFTFPEnergy_);
   tpdata->thePro->RegisterMe(tpdata->theFTFPPro);
   tpdata->thePro->RegisterMe(tpdata->theBertiniPro=new G4BertiniProtonBuilder);
   tpdata->theBertiniPro->SetMaxEnergy(maxBertiniEnergy_);
 
   tpdata->thePiK=new G4PiKBuilder;
   tpdata->theFTFPPiK=new G4FTFPPiKBuilder(quasiElasticFTF);
   tpdata->theFTFPPiK->SetMinEnergy(minFTFPEnergy_);
   tpdata->thePiK->RegisterMe(tpdata->theFTFPPiK);
   tpdata->thePiK->RegisterMe(tpdata->theBertiniPiK=new G4BertiniPiKBuilder);
   tpdata->theBertiniPiK->SetMaxEnergy(maxBertiniEnergy_);
 
   tpdata->theHyperon=new G4HyperonFTFPBuilder;
     
   tpdata->theAntiBaryon=new G4AntiBarionBuilder;
   tpdata->theAntiBaryon->RegisterMe(tpdata->theFTFPAntiBaryon=new G4FTFPAntiBarionBuilder(quasiElasticFTF));
 }