HadronPhysicsCMS.cc

Go to the documentation of this file.

#include "SimG4Core/PhysicsLists/interface/HadronPhysicsCMS.h"

#include "globals.hh"
#include "G4ios.hh"
#include <iomanip>
#include "G4ParticleDefinition.hh"
#include "G4ParticleTable.hh"

#include "G4MesonConstructor.hh"
#include "G4BaryonConstructor.hh"
#include "G4ShortLivedConstructor.hh"
#include "G4SystemOfUnits.hh"

HadronPhysicsCMS::HadronPhysicsCMS(const G4String& name, G4bool quasiElastic)
    : 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) {}

void HadronPhysicsCMS::CreateModels() {
  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);
  }
}

HadronPhysicsCMS::~HadronPhysicsCMS() {
  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;
}

void HadronPhysicsCMS::ConstructParticle() {
  G4MesonConstructor pMesonConstructor;
  pMesonConstructor.ConstructParticle();

  G4BaryonConstructor pBaryonConstructor;
  pBaryonConstructor.ConstructParticle();

  G4ShortLivedConstructor pShortLivedConstructor;
  pShortLivedConstructor.ConstructParticle();
}

#include "G4ProcessManager.hh"
void HadronPhysicsCMS::ConstructProcess() {
  CreateModels();
  theNeutrons->Build();
  thePro->Build();
  thePiK->Build();
  //  theMiscLHEP->Build();
}