#include <HadronPhysicsQGSPCMS_FTFP_BERT.h>

Inheritance diagram for HadronPhysicsQGSPCMS_FTFP_BERT:

Public Member Functions
virtual void	ConstructParticle ()

virtual void	ConstructProcess ()

	HadronPhysicsQGSPCMS_FTFP_BERT (const G4String &name="hadron", G4bool quasiElastic=true)

void	SetProjectileDiffraction (G4bool value)

void	SetQuasiElastic (G4bool value)

virtual	~HadronPhysicsQGSPCMS_FTFP_BERT ()

Private Member Functions
void	CreateModels ()

Private Attributes
G4bool	ProjectileDiffraction

G4bool	QuasiElastic

G4BertiniNeutronBuilder *	theBertiniNeutron

G4BertiniPiKBuilder *	theBertiniPiK

G4BertiniProtonBuilder *	theBertiniPro

CMSFTFPNeutronBuilder *	theFTFPNeutron

CMSFTFPPiKBuilder *	theFTFPPiK

CMSFTFPProtonBuilder *	theFTFPPro

G4LEPNeutronBuilder *	theLEPNeutron

G4MiscLHEPBuilder *	theMiscLHEP

G4NeutronBuilder *	theNeutrons

G4PiKBuilder *	thePiK

G4ProtonBuilder *	thePro

G4QGSPNeutronBuilder *	theQGSPNeutron

G4QGSPPiKBuilder *	theQGSPPiK

G4QGSPProtonBuilder *	theQGSPPro

Detailed Description

Definition at line 26 of file HadronPhysicsQGSPCMS_FTFP_BERT.h.

Constructor & Destructor Documentation

HadronPhysicsQGSPCMS_FTFP_BERT::HadronPhysicsQGSPCMS_FTFP_BERT	(	const G4String &	name = `"hadron"`,
		G4bool	quasiElastic = `true`
	)

Definition at line 13 of file HadronPhysicsQGSPCMS_FTFP_BERT.cc.

References ProjectileDiffraction.

                     :  G4VPhysicsConstructor(name) , QuasiElastic(quasiElastic)
 {
    ProjectileDiffraction=false;
 }

HadronPhysicsQGSPCMS_FTFP_BERT::~HadronPhysicsQGSPCMS_FTFP_BERT ( )

virtual

Definition at line 80 of file HadronPhysicsQGSPCMS_FTFP_BERT.cc.

References theBertiniNeutron, theBertiniPiK, theBertiniPro, theFTFPNeutron, theFTFPPiK, theFTFPPro, theMiscLHEP, thePiK, thePro, theQGSPNeutron, theQGSPPiK, and theQGSPPro.

 {
    delete theMiscLHEP;
    delete theQGSPNeutron;
    delete theFTFPNeutron;
    delete theBertiniNeutron;
    delete theQGSPPro;
    delete theFTFPPro;
    delete thePro;
    delete theBertiniPro;
    delete theQGSPPiK;
    delete theFTFPPiK;
    delete theBertiniPiK;
    delete thePiK;
 }

Member Function Documentation

void HadronPhysicsQGSPCMS_FTFP_BERT::ConstructParticle ( )

virtual

Definition at line 96 of file HadronPhysicsQGSPCMS_FTFP_BERT.cc.

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

void HadronPhysicsQGSPCMS_FTFP_BERT::ConstructProcess ( )

virtual

Definition at line 109 of file HadronPhysicsQGSPCMS_FTFP_BERT.cc.

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

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

void HadronPhysicsQGSPCMS_FTFP_BERT::CreateModels ( )

private

Definition at line 19 of file HadronPhysicsQGSPCMS_FTFP_BERT.cc.

References ProjectileDiffraction, QuasiElastic, theBertiniNeutron, theBertiniPiK, theBertiniPro, theFTFPNeutron, theFTFPPiK, theFTFPPro, theLEPNeutron, theMiscLHEP, theNeutrons, thePiK, thePro, theQGSPNeutron, theQGSPPiK, and theQGSPPro.

Referenced by ConstructProcess().

 {
   // First transition, between BERT and FTF/P
   G4double minFTFP= 6.0 * GeV;     // Was 9.5 for LEP   (in FTFP_BERT 6.0 * GeV);
   G4double maxBERT= 8.0 * GeV;     // Was 9.9 for LEP   (in FTFP_BERT 8.0 * GeV);
   // Second transition, between FTF/P and QGS/P
   G4double minQGSP= 12.0 * GeV;
   G4double maxFTFP= 25.0 * GeV; 
 
   G4bool   quasiElasFTF= false;   // Use built-in quasi-elastic (not add-on)
   G4bool   quasiElasQGS= true;    // For QGS, it must use it.
 
   G4cout << " New QGSPCMS_FTFP_BERT physics list, replaces LEP with FTF/P for p/n/pi (/K?)";
   G4cout << "  Thresholds: " << G4endl;
   G4cout << "    1) between BERT  and FTF/P over the interval " 
      << minFTFP/GeV << " to " << maxBERT/GeV << " GeV. " << G4endl;
   G4cout << "    2) between FTF/P and QGS/P over the interval " 
      << minQGSP/GeV << " to " << maxFTFP/GeV << " GeV. " << G4endl;
   G4cout << "  -- quasiElastic was asked to be " << QuasiElastic << G4endl
      << "     Changed to " << quasiElasQGS << " for QGS "
      << " and to " << quasiElasFTF << " (must be false) for FTF" << G4endl;
 
   theNeutrons=new G4NeutronBuilder;
   theNeutrons->RegisterMe(theQGSPNeutron=new G4QGSPNeutronBuilder(quasiElasQGS, ProjectileDiffraction));
   theQGSPNeutron->SetMinEnergy(minQGSP);   
   theNeutrons->RegisterMe(theFTFPNeutron=new CMSFTFPNeutronBuilder(quasiElasFTF));
   theFTFPNeutron->SetMinEnergy(minFTFP);   // was (9.5*GeV);
   theFTFPNeutron->SetMaxEnergy(maxFTFP);   // was (25*GeV);  
   // Exclude LEP only from Inelastic 
   //  -- Register it for other processes: Capture, Elastic
   theNeutrons->RegisterMe(theLEPNeutron=new G4LEPNeutronBuilder);
   theLEPNeutron->SetMinInelasticEnergy(0.0*GeV);
   theLEPNeutron->SetMaxInelasticEnergy(0.0*GeV);
 
   theNeutrons->RegisterMe(theBertiniNeutron=new G4BertiniNeutronBuilder);
   theBertiniNeutron->SetMinEnergy(0.0*GeV);
   theBertiniNeutron->SetMaxEnergy(maxBERT);         // was (9.9*GeV);
 
   thePro=new G4ProtonBuilder;
   thePro->RegisterMe(theQGSPPro=new G4QGSPProtonBuilder(quasiElasQGS, ProjectileDiffraction));
   theQGSPPro->SetMinEnergy(minQGSP);   
   thePro->RegisterMe(theFTFPPro=new CMSFTFPProtonBuilder(quasiElasFTF));
   theFTFPPro->SetMinEnergy(minFTFP);   // was (9.5*GeV);
   theFTFPPro->SetMaxEnergy(maxFTFP);   // was (25*GeV); 
 
   thePro->RegisterMe(theBertiniPro=new G4BertiniProtonBuilder);
   theBertiniPro->SetMaxEnergy(maxBERT);  //  was (9.9*GeV);
   
   thePiK=new G4PiKBuilder;
   thePiK->RegisterMe(theQGSPPiK=new G4QGSPPiKBuilder(quasiElasQGS));
   theQGSPPiK->SetMinEnergy(minQGSP);   
   thePiK->RegisterMe(theFTFPPiK=new CMSFTFPPiKBuilder(quasiElasFTF));
   theFTFPPiK->SetMaxEnergy(maxFTFP);   // was (25*GeV); 
   theFTFPPiK->SetMinEnergy(minFTFP);   // was (9.5*GeV);
 
   thePiK->RegisterMe(theBertiniPiK=new G4BertiniPiKBuilder);
   theBertiniPiK->SetMaxEnergy(maxBERT);  //  was (9.9*GeV);
   
   theMiscLHEP=new G4MiscLHEPBuilder;
 }