#include <HadronPhysicsCMS.h>

Inheritance diagram for HadronPhysicsCMS:

Public Member Functions
void	ConstructParticle () override

void	ConstructProcess () override

	HadronPhysicsCMS (const G4String &name="QGSP", G4bool quasiElastic=true)

	~HadronPhysicsCMS () override

Private Member Functions
void	CreateModels ()

Private Attributes
G4String	modelName

G4bool	QuasiElastic

G4BertiniNeutronBuilder *	theBertiniNeutron

G4BertiniPiKBuilder *	theBertiniPiK

G4BertiniProtonBuilder *	theBertiniPro

G4BinaryNeutronBuilder *	theBinaryNeutron

G4BinaryPiKBuilder *	theBinaryPiK

G4BinaryProtonBuilder *	theBinaryPro

G4FTFBinaryNeutronBuilder *	theFTFNeutron

G4FTFBinaryPiKBuilder *	theFTFPiK

G4FTFPNeutronBuilder *	theFTFPNeutron

G4FTFPPiKBuilder *	theFTFPPiK

G4FTFPProtonBuilder *	theFTFPPro

G4FTFBinaryProtonBuilder *	theFTFPro

G4NeutronBuilder *	theNeutrons

G4PiKBuilder *	thePiK

G4ProtonBuilder *	thePro

G4QGSPNeutronBuilder *	theQGSPNeutron

G4QGSPPiKBuilder *	theQGSPPiK

G4QGSPProtonBuilder *	theQGSPPro

Detailed Description

Definition at line 31 of file HadronPhysicsCMS.h.

Constructor & Destructor Documentation

◆ HadronPhysicsCMS()

HadronPhysicsCMS::HadronPhysicsCMS	(	const G4String &	name = `"QGSP"`,
		G4bool	quasiElastic = `true`
	)

Definition at line 14 of file HadronPhysicsCMS.cc.

     : G4VPhysicsConstructor("hadron"),
       theNeutrons(nullptr),
       theBertiniNeutron(nullptr),
       theBinaryNeutron(nullptr),
       theFTFPNeutron(nullptr),
       theQGSPNeutron(nullptr),
       thePiK(nullptr),
       theBertiniPiK(nullptr),
       theBinaryPiK(nullptr),
       theFTFPPiK(nullptr),
       theQGSPPiK(nullptr),
       thePro(nullptr),
       theBertiniPro(nullptr),
       theBinaryPro(nullptr),
       theFTFPPro(nullptr),
       theQGSPPro(nullptr),
       theFTFNeutron(nullptr),
       theFTFPiK(nullptr),
       theFTFPro(nullptr),
       modelName(name),
       QuasiElastic(quasiElastic) {}

◆ ~HadronPhysicsCMS()

HadronPhysicsCMS::~HadronPhysicsCMS ( )

override

Definition at line 92 of file HadronPhysicsCMS.cc.

                                     {
   if (theBertiniNeutron)
     delete theBertiniNeutron;
   if (theBinaryNeutron)
     delete theBinaryNeutron;
   if (theFTFPNeutron)
     delete theFTFPNeutron;
   if (theQGSPNeutron)
     delete theQGSPNeutron;
   if (theFTFNeutron)
     delete theFTFNeutron;
   delete theNeutrons;
   if (theBertiniPro)
     delete theBertiniPro;
   if (theBinaryPro)
     delete theBinaryPro;
   if (theFTFPPro)
     delete theFTFPPro;
   if (theQGSPPro)
     delete theQGSPPro;
   if (theFTFPro)
     delete theFTFPro;
   delete thePro;
   if (theBertiniPiK)
     delete theBertiniPiK;
   if (theBinaryPiK)
     delete theBinaryPiK;
   if (theFTFPPiK)
     delete theFTFPPiK;
   if (theQGSPPiK)
     delete theQGSPPiK;
   if (theFTFPiK)
     delete theFTFPiK;
   delete thePiK;
 }

References theBertiniNeutron, theBertiniPiK, theBertiniPro, theBinaryNeutron, theBinaryPiK, theBinaryPro, theFTFNeutron, theFTFPiK, theFTFPNeutron, theFTFPPiK, theFTFPPro, theFTFPro, theNeutrons, thePiK, thePro, theQGSPNeutron, theQGSPPiK, and theQGSPPro.

Member Function Documentation

◆ ConstructParticle()

void HadronPhysicsCMS::ConstructParticle ( )

override

Definition at line 128 of file HadronPhysicsCMS.cc.

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

◆ ConstructProcess()

void HadronPhysicsCMS::ConstructProcess ( )

override

Definition at line 140 of file HadronPhysicsCMS.cc.

                                         {
   CreateModels();
   theNeutrons->Build();
   thePro->Build();
   thePiK->Build();
   //  theMiscLHEP->Build();
 }

References CreateModels(), theNeutrons, thePiK, and thePro.

◆ CreateModels()

void HadronPhysicsCMS::CreateModels ( )

private

Definition at line 37 of file HadronPhysicsCMS.cc.

                                     {
   theNeutrons = new G4NeutronBuilder;
   thePro = new G4ProtonBuilder;
   thePiK = new G4PiKBuilder;
  
   if (modelName == "Bertini") {
     theBertiniNeutron = new G4BertiniNeutronBuilder();
     theBertiniNeutron->SetMaxEnergy(30.0 * GeV);
     theNeutrons->RegisterMe(theBertiniNeutron);
     theBertiniPro = new G4BertiniProtonBuilder();
     theBertiniPro->SetMaxEnergy(30.0 * GeV);
     thePro->RegisterMe(theBertiniPro);
     theBertiniPiK = new G4BertiniPiKBuilder();
     theBertiniPiK->SetMaxEnergy(30.0 * GeV);
     thePiK->RegisterMe(theBertiniPiK);
   } else if (modelName == "Binary") {
     theBinaryNeutron = new G4BinaryNeutronBuilder();
     theBinaryNeutron->SetMaxEnergy(30.0 * GeV);
     theNeutrons->RegisterMe(theBinaryNeutron);
     theBinaryPro = new G4BinaryProtonBuilder();
     theBinaryPro->SetMaxEnergy(30.0 * GeV);
     thePro->RegisterMe(theBinaryPro);
     theBinaryPiK = new G4BinaryPiKBuilder();
     theBinaryPiK->SetMaxEnergy(30.0 * GeV);
     thePiK->RegisterMe(theBinaryPiK);
   } else if (modelName == "FTFP") {
     theFTFPNeutron = new G4FTFPNeutronBuilder();
     theFTFPNeutron->SetMinEnergy(0.1 * GeV);
     theNeutrons->RegisterMe(theFTFPNeutron);
     theFTFPPro = new G4FTFPProtonBuilder();
     theFTFPPro->SetMinEnergy(0.1 * GeV);
     thePro->RegisterMe(theFTFPPro);
     theFTFPPiK = new G4FTFPPiKBuilder();
     theFTFPPiK->SetMinEnergy(0.1 * GeV);
     thePiK->RegisterMe(theFTFPPiK);
   } else if (modelName == "FTF") {
     theFTFNeutron = new G4FTFBinaryNeutronBuilder();
     theNeutrons->RegisterMe(theFTFNeutron);
     theFTFPro = new G4FTFBinaryProtonBuilder();
     thePro->RegisterMe(theFTFPro);
     theFTFPiK = new G4FTFBinaryPiKBuilder();
     thePiK->RegisterMe(theFTFPiK);
   } else {
     theQGSPNeutron = new G4QGSPNeutronBuilder(QuasiElastic);
     theQGSPNeutron->SetMinEnergy(0.1 * GeV);
     theNeutrons->RegisterMe(theQGSPNeutron);
     theQGSPPro = new G4QGSPProtonBuilder(QuasiElastic);
     theQGSPPro->SetMinEnergy(0.1 * GeV);
     thePro->RegisterMe(theQGSPPro);
     theQGSPPiK = new G4QGSPPiKBuilder(QuasiElastic);
     theQGSPPiK->SetMinEnergy(0.1 * GeV);
     thePiK->RegisterMe(theQGSPPiK);
   }
 }