#include <HadronPhysicsCMS.h>

Public Member Functions
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
	HadronPhysicsCMS (const G4String &name="QGSP", G4bool quasiElastic=true)
virtual	~HadronPhysicsCMS ()
Private Member Functions
void	CreateModels ()
Private Attributes
G4String	modelName
G4bool	QuasiElastic
G4BertiniNeutronBuilder *	theBertiniNeutron
G4BertiniPiKBuilder *	theBertiniPiK
G4BertiniProtonBuilder *	theBertiniPro
G4BinaryNeutronBuilder *	theBinaryNeutron
G4BinaryPiKBuilder *	theBinaryPiK
G4BinaryProtonBuilder *	theBinaryPro
G4FTFCNeutronBuilder *	theFTFCNeutron
G4FTFCPiKBuilder *	theFTFCPiK
G4FTFCProtonBuilder *	theFTFCPro
G4FTFBinaryNeutronBuilder *	theFTFNeutron
G4FTFBinaryPiKBuilder *	theFTFPiK
G4FTFPNeutronBuilder *	theFTFPNeutron
G4FTFPPiKBuilder *	theFTFPPiK
G4FTFPProtonBuilder *	theFTFPPro
G4FTFBinaryProtonBuilder *	theFTFPro
G4LEPNeutronBuilder *	theLEPNeutron
G4LEPPiKBuilder *	theLEPPiK
G4LEPProtonBuilder *	theLEPPro
G4LHEPNeutronBuilder *	theLHEPNeutron
G4LHEPPiKBuilder *	theLHEPPiK
G4LHEPProtonBuilder *	theLHEPPro
G4MiscLHEPBuilder *	theMiscLHEP
G4NeutronBuilder *	theNeutrons
G4PiKBuilder *	thePiK
G4PrecoNeutronBuilder *	thePrecoNeutron
G4PrecoProtonBuilder *	thePrecoPro
G4ProtonBuilder *	thePro
G4QGSCEflowNeutronBuilder *	theQGSCEflowNeutron
G4QGSCEflowPiKBuilder *	theQGSCEflowPiK
G4QGSCEflowProtonBuilder *	theQGSCEflowPro
G4QGSCNeutronBuilder *	theQGSCNeutron
G4QGSCPiKBuilder *	theQGSCPiK
G4QGSCProtonBuilder *	theQGSCPro
G4QGSPNeutronBuilder *	theQGSPNeutron
G4QGSPPiKBuilder *	theQGSPPiK
G4QGSPProtonBuilder *	theQGSPPro
G4RPGNeutronBuilder *	theRPGNeutron
G4RPGPiKBuilder *	theRPGPiK
G4RPGProtonBuilder *	theRPGPro

Detailed Description

Definition at line 53 of file HadronPhysicsCMS.h.

Constructor & Destructor Documentation

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

Definition at line 13 of file HadronPhysicsCMS.cc.

                                                                            :
  G4VPhysicsConstructor("hadron"), theNeutrons(0), theBertiniNeutron(0),
  theBinaryNeutron(0), theFTFCNeutron(0), theFTFPNeutron(0), theLEPNeutron(0),
  theLHEPNeutron(0), thePrecoNeutron(0), theQGSCEflowNeutron(0),
  theQGSCNeutron(0), theQGSPNeutron(0), thePiK(0), theBertiniPiK(0),
  theBinaryPiK(0), theFTFCPiK(0), theFTFPPiK(0), theLEPPiK(0), theLHEPPiK(0),
  theQGSCEflowPiK(0), theQGSCPiK(0), theQGSPPiK(0), thePro(0),theBertiniPro(0),
  theBinaryPro(0), theFTFCPro(0), theFTFPPro(0), theLEPPro(0), theLHEPPro(0),
  thePrecoPro(0),  theQGSCEflowPro(0), theQGSCPro(0), theQGSPPro(0),
  theMiscLHEP(), theFTFNeutron(0), theFTFPiK(0), theFTFPro(0), 
  theRPGNeutron(0), theRPGPiK(0), theRPGPro(0), modelName(name), 
  QuasiElastic(quasiElastic) {}

HadronPhysicsCMS::~HadronPhysicsCMS ( ) [virtual]

Definition at line 142 of file HadronPhysicsCMS.cc.

References theBertiniNeutron, theBertiniPiK, theBertiniPro, theBinaryNeutron, theBinaryPiK, theBinaryPro, theFTFCNeutron, theFTFCPiK, theFTFCPro, theFTFNeutron, theFTFPiK, theFTFPNeutron, theFTFPPiK, theFTFPPro, theFTFPro, theLEPNeutron, theLEPPiK, theLEPPro, theLHEPNeutron, theLHEPPiK, theLHEPPro, theMiscLHEP, theNeutrons, thePiK, thePrecoNeutron, thePrecoPro, thePro, theQGSCEflowNeutron, theQGSCEflowPiK, theQGSCEflowPro, theQGSCNeutron, theQGSCPro, theQGSPNeutron, theQGSPPiK, theQGSPPro, theRPGNeutron, theRPGPiK, and theRPGPro.

                                    {
  delete theMiscLHEP;
  if (theBertiniNeutron)   delete theBertiniNeutron;
  if (theBinaryNeutron)    delete theBinaryNeutron;
  if (theFTFCNeutron)      delete theFTFCNeutron;
  if (theFTFPNeutron)      delete theFTFPNeutron;
  if (theLEPNeutron)       delete theLEPNeutron;
  if (theLHEPNeutron)      delete theLHEPNeutron;
  if (thePrecoNeutron)     delete thePrecoNeutron;
  if (theQGSCEflowNeutron) delete theQGSCEflowNeutron;
  if (theQGSCNeutron)      delete theQGSCNeutron;
  if (theQGSPNeutron)      delete theQGSPNeutron;
  if (theFTFNeutron)       delete theFTFNeutron;
  if (theRPGNeutron)       delete theRPGNeutron;
  delete theNeutrons;
  if (theBertiniPro)       delete theBertiniPro;
  if (theBinaryPro)        delete theBinaryPro;
  if (theFTFCPro)          delete theFTFCPro;
  if (theFTFPPro)          delete theFTFPPro;
  if (theLEPPro)           delete theLEPPro;
  if (theLHEPPro)          delete theLHEPPro;
  if (thePrecoPro)         delete thePrecoPro;
  if (theQGSCEflowPro)     delete theQGSCEflowPro;
  if (theQGSCPro)          delete theQGSCPro;
  if (theQGSPPro)          delete theQGSPPro; 
  if (theFTFPro)           delete theFTFPro;
  if (theRPGPro)           delete theRPGPro;
  delete thePro;
  if (theBertiniPiK)       delete theBertiniPiK;
  if (theBinaryPiK)        delete theBinaryPiK;
  if (theFTFCPiK)          delete theFTFCPiK;
  if (theFTFPPiK)          delete theFTFPPiK;
  if (theLEPPiK)           delete theLEPPiK;
  if (theLHEPPiK)          delete theLHEPPiK;
  if (theQGSCEflowPiK)     delete theQGSCEflowPiK;
  if (theQGSPPiK)          delete theQGSPPiK;
  if (theFTFPiK)           delete theFTFPiK;
  if (theRPGPiK)           delete theRPGPiK;
  delete thePiK;
}

Member Function Documentation

void HadronPhysicsCMS::ConstructParticle ( ) [virtual]

Definition at line 184 of file HadronPhysicsCMS.cc.

                                         {

  G4MesonConstructor pMesonConstructor;
  pMesonConstructor.ConstructParticle();

  G4BaryonConstructor pBaryonConstructor;
  pBaryonConstructor.ConstructParticle();

  G4ShortLivedConstructor pShortLivedConstructor;
  pShortLivedConstructor.ConstructParticle();  
}

void HadronPhysicsCMS::ConstructProcess ( ) [virtual]

Definition at line 197 of file HadronPhysicsCMS.cc.

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

                                        {

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

void HadronPhysicsCMS::CreateModels ( ) [private]

Definition at line 26 of file HadronPhysicsCMS.cc.

References modelName, QuasiElastic, theBertiniNeutron, theBertiniPiK, theBertiniPro, theBinaryNeutron, theBinaryPiK, theBinaryPro, theFTFCNeutron, theFTFCPiK, theFTFCPro, theFTFNeutron, theFTFPiK, theFTFPNeutron, theFTFPPiK, theFTFPPro, theFTFPro, theLEPNeutron, theLEPPiK, theLEPPro, theLHEPNeutron, theLHEPPiK, theLHEPPro, theMiscLHEP, theNeutrons, thePiK, thePrecoNeutron, thePrecoPro, thePro, theQGSCEflowNeutron, theQGSCEflowPiK, theQGSCEflowPro, theQGSCNeutron, theQGSCPiK, theQGSCPro, theQGSPNeutron, theQGSPPiK, theQGSPPro, theRPGNeutron, theRPGPiK, and theRPGPro.

Referenced by ConstructProcess().

                                    {

  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 == "FTFC") {
    theFTFCNeutron = new G4FTFCNeutronBuilder();
    theFTFCNeutron->SetMinEnergy(0.1*GeV);
    theNeutrons->RegisterMe(theFTFCNeutron);
    theFTFCPro     = new G4FTFCProtonBuilder();
    theFTFCPro->SetMinEnergy(0.1*GeV);
    thePro->RegisterMe(theFTFCPro);
    theFTFCPiK     = new G4FTFCPiKBuilder();
    theFTFCPiK->SetMinEnergy(0.1*GeV);
    thePiK->RegisterMe(theFTFCPiK);
  } 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 == "LEP") {
    theLEPNeutron = new G4LEPNeutronBuilder();
    theNeutrons->RegisterMe(theLEPNeutron);
    theLEPPro     = new G4LEPProtonBuilder();
    thePro->RegisterMe(theLEPPro);
    theLEPPiK     = new G4LEPPiKBuilder();
    thePiK->RegisterMe(theLEPPiK);
  }  else if (modelName == "LHEP") {
    theLHEPNeutron = new G4LHEPNeutronBuilder();
    theNeutrons->RegisterMe(theLHEPNeutron);
    theLHEPPro     = new G4LHEPProtonBuilder();
    thePro->RegisterMe(theLHEPPro);
    theLHEPPiK     = new G4LHEPPiKBuilder();
    thePiK->RegisterMe(theLHEPPiK);
  }  else if (modelName == "Preco") {
    thePrecoNeutron = new G4PrecoNeutronBuilder();
    theNeutrons->RegisterMe(thePrecoNeutron);
    thePrecoPro     = new G4PrecoProtonBuilder();
    thePro->RegisterMe(thePrecoPro);
    theLHEPPiK      = new G4LHEPPiKBuilder();
    thePiK->RegisterMe(theLHEPPiK);
  }  else if (modelName == "QGSCEflow") {
    theQGSCEflowNeutron = new G4QGSCEflowNeutronBuilder();
    theQGSCEflowNeutron->SetMinEnergy(0.1*GeV);
    theNeutrons->RegisterMe(theQGSCEflowNeutron);
    theQGSCEflowPro     = new G4QGSCEflowProtonBuilder();
    theQGSCEflowPro->SetMinEnergy(0.1*GeV);
    thePro->RegisterMe(theQGSCEflowPro);
    theQGSCEflowPiK     = new G4QGSCEflowPiKBuilder();
    theQGSCEflowPiK->SetMinEnergy(0.1*GeV);
    thePiK->RegisterMe(theQGSCEflowPiK);
  }  else if (modelName == "QGSC") {
    theQGSCNeutron = new G4QGSCNeutronBuilder();
    theQGSCNeutron->SetMinEnergy(0.1*GeV);
    theNeutrons->RegisterMe(theQGSCNeutron);
    theQGSCPro     = new G4QGSCProtonBuilder();
    theQGSCPro->SetMinEnergy(0.1*GeV);
    thePro->RegisterMe(theQGSCPro);
    theQGSCPiK     = new G4QGSCPiKBuilder();
    theQGSCPiK->SetMinEnergy(0.1*GeV);
    thePiK->RegisterMe(theQGSCPiK);
  } else if (modelName == "RPG") {
    theRPGNeutron  = new G4RPGNeutronBuilder();
    theNeutrons->RegisterMe(theRPGNeutron);
    theRPGPro      = new G4RPGProtonBuilder();
    thePro->RegisterMe(theRPGPro);
    theRPGPiK      = new G4RPGPiKBuilder();
    thePiK->RegisterMe(theRPGPiK);
  } 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);
  }
  
  theMiscLHEP=new G4MiscLHEPBuilder;
}