HyperonPhysics Class Reference

Hyperon hadronic physics constructor for Belle II physics list. More...

#include <HyperonPhysics.h>

Inheritance diagram for HyperonPhysics:

Public Member Functions
virtual void	ConstructParticle () override
	Build processes, models, cross sections used in physics list.
virtual void	ConstructProcess () override
	Build all particle types used in physics list (empty in this class)

Private Attributes
G4TheoFSGenerator *	m_ftfp
	Final state generator for QCD string models.
G4FTFModel *	m_stringModel
	Fritiof string model.
G4ExcitedStringDecay *	m_stringDecay
	Model to decay strings into hadrons.
G4LundStringFragmentation *	m_fragModel
	Lund string fragmentation model.
G4GeneratorPrecompoundInterface *	m_preCompoundModel
	Precompound model to deexcite post-collision nucleus.

Detailed Description

Hyperon hadronic physics constructor for Belle II physics list.

Definition at line 31 of file HyperonPhysics.h.

Constructor & Destructor Documentation

HyperonPhysics()

HyperonPhysics

(

)

Definition at line 32 of file HyperonPhysics.cc.

  : m_ftfp(nullptr), m_stringModel(nullptr), m_stringDecay(nullptr),
    m_fragModel(nullptr), m_preCompoundModel(nullptr)
{}

~HyperonPhysics()

~HyperonPhysics

(

)

Definition at line 38 of file HyperonPhysics.cc.

{
  delete m_stringDecay;
  delete m_stringModel;
  delete m_fragModel;
  delete m_preCompoundModel;
}

Member Function Documentation

ConstructParticle()

void ConstructParticle ( )

overridevirtual

Build processes, models, cross sections used in physics list.

Definition at line 47 of file HyperonPhysics.cc.

{}

ConstructProcess()

void ConstructProcess ( )

overridevirtual

Build all particle types used in physics list (empty in this class)

Definition at line 51 of file HyperonPhysics.cc.

{
  G4ProcessManager* procMan = 0;
 
  // One elastic model for all hyperon energies
  G4HadronElastic* elModel = new G4HadronElastic();
 
  // Use Bertini cascade for low energies
  G4CascadeInterface* loInelModel = new G4CascadeInterface;
  loInelModel->SetMinEnergy(0.0);
  loInelModel->SetMaxEnergy(6.0 * GeV);
 
  // Use FTFP for high energies   ==>>   eventually replace this with new class FTFPInterface
  m_ftfp = new G4TheoFSGenerator("FTFP");
  m_stringModel = new G4FTFModel;
  m_stringDecay =
    new G4ExcitedStringDecay(m_fragModel = new G4LundStringFragmentation);
  m_stringModel->SetFragmentationModel(m_stringDecay);
  m_preCompoundModel = new G4GeneratorPrecompoundInterface();
 
  m_ftfp->SetHighEnergyGenerator(m_stringModel);
  m_ftfp->SetTransport(m_preCompoundModel);
  m_ftfp->SetMinEnergy(4 * GeV);
  m_ftfp->SetMaxEnergy(100 * TeV);
 
  // Cross section sets
  G4ChipsHyperonElasticXS* chipsElastic = new G4ChipsHyperonElasticXS;
  G4ChipsHyperonInelasticXS* chipsInelastic = new G4ChipsHyperonInelasticXS;

  //   Lambda                                                                 //
 
  procMan = G4Lambda::Lambda()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* lamProcEl = new G4HadronElasticProcess;
  lamProcEl->RegisterMe(elModel);
  lamProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(lamProcEl);
 
  // inelastic
  G4HadronInelasticProcess* lamProcInel = new G4HadronInelasticProcess("lambdaInelastic", G4Lambda::Definition());
  lamProcInel->RegisterMe(loInelModel);
  lamProcInel->RegisterMe(m_ftfp);
  lamProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(lamProcInel);

  //   Sigma+                                                                 //
 
  procMan = G4SigmaPlus::SigmaPlus()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* spProcEl = new G4HadronElasticProcess;
  spProcEl->RegisterMe(elModel);
  spProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(spProcEl);
 
  // inelastic
  G4HadronInelasticProcess* spProcInel = new G4HadronInelasticProcess("sigma+Inelastic", G4SigmaPlus::Definition());
  spProcInel->RegisterMe(loInelModel);
  spProcInel->RegisterMe(m_ftfp);
  spProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(spProcInel);

  //   Sigma-                                                                 //
 
  procMan = G4SigmaMinus::SigmaMinus()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* smProcEl = new G4HadronElasticProcess;
  smProcEl->RegisterMe(elModel);
  smProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(smProcEl);
 
  // inelastic
  G4HadronInelasticProcess* smProcInel = new G4HadronInelasticProcess("sigma-Inelastic", G4SigmaMinus::Definition());
  smProcInel->RegisterMe(loInelModel);
  smProcInel->RegisterMe(m_ftfp);
  smProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(smProcInel);
 
  // stopping
  G4HadronicAbsorptionBertini* smAbsorb = new G4HadronicAbsorptionBertini;
  procMan->AddRestProcess(smAbsorb);

  //   Xi0                                                                    //
 
  procMan = G4XiZero::XiZero()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* xzProcEl = new G4HadronElasticProcess;
  xzProcEl->RegisterMe(elModel);
  xzProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(xzProcEl);
 
  // inelastic
  G4HadronInelasticProcess* xzProcInel = new G4HadronInelasticProcess("xi0Inelastic", G4XiZero::Definition());
  xzProcInel->RegisterMe(loInelModel);
  xzProcInel->RegisterMe(m_ftfp);
  xzProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(xzProcInel);

  //   Xi-                                                                    //
 
  procMan = G4XiMinus::XiMinus()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* xmProcEl = new G4HadronElasticProcess;
  xmProcEl->RegisterMe(elModel);
  xmProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(xmProcEl);
 
  // inelastic
  G4HadronInelasticProcess* xmProcInel = new G4HadronInelasticProcess("xi-Inelastic", G4XiMinus::Definition());
  xmProcInel->RegisterMe(loInelModel);
  xmProcInel->RegisterMe(m_ftfp);
  xmProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(xmProcInel);
 
  // stopping
  G4HadronicAbsorptionBertini* xmAbsorb = new G4HadronicAbsorptionBertini;
  procMan->AddRestProcess(xmAbsorb);

  //   Omega-                                                                 //
 
  procMan = G4OmegaMinus::OmegaMinus()->GetProcessManager();
 
  // elastic
  G4HadronElasticProcess* omProcEl = new G4HadronElasticProcess;
  omProcEl->RegisterMe(elModel);
  omProcEl->AddDataSet(chipsElastic);
  procMan->AddDiscreteProcess(omProcEl);
 
  // inelastic
  G4HadronInelasticProcess* omProcInel = new G4HadronInelasticProcess("omega-Inelastic", G4OmegaMinus::Definition());
  omProcInel->RegisterMe(loInelModel);
  omProcInel->RegisterMe(m_ftfp);
  omProcInel->AddDataSet(chipsInelastic);
  procMan->AddDiscreteProcess(omProcInel);
 
  // stopping
  G4HadronicAbsorptionBertini* omAbsorb = new G4HadronicAbsorptionBertini;
  procMan->AddRestProcess(omAbsorb);
}

Member Data Documentation

m_fragModel

G4LundStringFragmentation* m_fragModel

private

Lund string fragmentation model.

Definition at line 53 of file HyperonPhysics.h.

m_ftfp

G4TheoFSGenerator* m_ftfp

private

Final state generator for QCD string models.

Definition at line 44 of file HyperonPhysics.h.

m_preCompoundModel

G4GeneratorPrecompoundInterface* m_preCompoundModel

private

Precompound model to deexcite post-collision nucleus.

Definition at line 56 of file HyperonPhysics.h.

m_stringDecay

G4ExcitedStringDecay* m_stringDecay

private

Model to decay strings into hadrons.

Definition at line 50 of file HyperonPhysics.h.

m_stringModel

G4FTFModel* m_stringModel

private

Fritiof string model.

Definition at line 47 of file HyperonPhysics.h.

---

The documentation for this class was generated from the following files:

• simulation/physicslist/include/HyperonPhysics.h
• simulation/physicslist/src/HyperonPhysics.cc