PhysicsListSvc Class Reference

#include <PhysicsListSvc.h>

Inheritance diagram for PhysicsListSvc:

Collaboration diagram for PhysicsListSvc:

Public Member Functions
	PhysicsListSvc (const std::string &name, ISvcLocator *pSvcLocator)
virtual	~PhysicsListSvc ()=default
virtual StatusCode	initialize () override
virtual void	CreatePhysicsList () override
virtual G4VUserPhysicsList *	GetPhysicsList () override
virtual void	SetPhysicsList () override
virtual void	SetPhysicsOptions () override

Private Member Functions
void	CommandLog (int returnCode, const std::string &commandString) const
	This command prints a message about a G4Command depending on its returnCode.

Private Attributes
ToolHandle< IPhysicsOptionTool >	m_fastSimulationConstructor {this, "FastSimConstructor", "", "Physics Constructor for fast simulation physics"}
ToolHandleArray< IPhysicsOptionTool >	m_phys_option {this, "PhysOption", {}, "Tool handle array of physics options" }
ToolHandleArray< IPhysicsOptionTool >	m_phys_decay {this, "PhysicsDecay", {}, "Tool handle array of physics decays"}
G4VModularPhysicsList *	m_physicsList {}
Gaudi::Property< std::string >	m_physicsListName {this, "PhysicsList", "FTFP_BERT", "Name for physics list"}
	!< Handle on the physics list
Gaudi::Property< double >	m_neutronTimeCut {this, "NeutronTimeCut", 0, "Time cut for neutron killer"}
	!< Name for the physics list (property to be set in the tool)
Gaudi::Property< double >	m_neutronEnergyCut {this, "NeutronEnergyCut", 0, "Energy cut for neutron killer"}
	!< Time cut for neutrons (in the neutron killer process)
Gaudi::Property< double >	m_generalCut {this, "GeneralCut", 0, "General cut"}
	!< Energy cut for neutrons (in the neutron killer process)
Gaudi::Property< double >	m_emMaxEnergy {this, "EMMaxEnergy", -1., "Maximum energy for EM tables"}
	!< A general cut - this isn't normally used in our simulation
Gaudi::Property< double >	m_emMinEnergy {this, "EMMinEnergy", -1., "Minimum energy for EM tables"}
	!< Maximum energy of the pre-calculated EM cross-section tables
Gaudi::Property< int >	m_emNumberOfBinsPerDecade {this, "EMNumberOfBinsPerDecade", -1, "Number of bins per Energy decade. Used for both DeDx and for the Lambda binning."}
	!< Minimum energy of the pre-calculated EM cross-section tables
Gaudi::Property< bool >	m_applyEMCuts {this, "ApplyEMCuts", true, "Apply cuts EM flag in Geant4"}
	!< Number of bins per Energy decade. Used for both DeDx and for the Lambda binning.
Gaudi::Property< bool >	m_quietMode {this, "QuietMode", false, ""}
	!< Switch for the G4 "apply cuts" EM physics flag
Gaudi::Property< bool >	m_unstableAntiNeutrons {this, "UnstableAntiNeutrons",false,"Bugfix for ATLASSIM-6634 until we switch to using Geant4 11"}

Detailed Description

Definition at line 23 of file PhysicsListSvc.h.

Constructor & Destructor Documentation

PhysicsListSvc()

PhysicsListSvc::PhysicsListSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Definition at line 22 of file PhysicsListSvc.cxx.

  : base_class(name,pSvcLocator)
{
}

~PhysicsListSvc()

virtual PhysicsListSvc::~PhysicsListSvc ( )

virtualdefault

Member Function Documentation

CommandLog()

void PhysicsListSvc::CommandLog ( int returnCode, const std::string & commandString ) const

private

This command prints a message about a G4Command depending on its returnCode.

Definition at line 215 of file PhysicsListSvc.cxx.

{
  switch(returnCode) {
  case 0: { ATH_MSG_DEBUG("G4 Command: " << commandString << " - Command Succeeded"); } break;
  case 100: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Command Not Found!"); } break;
  case 200: {
    auto* stateManager = G4StateManager::GetStateManager();
    ATH_MSG_DEBUG("G4 Command: " << commandString << " - Illegal Application State (" <<
                    stateManager->GetStateString(stateManager->GetCurrentState()) << ")!");
  } break;
  case 300: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Range!"); } break;
  case 400: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Unreadable!"); } break;
  case 500: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Parameter Out of Candidates!"); } break;
  case 600: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Alias Not Found!"); } break;
  default: { ATH_MSG_ERROR("G4 Command: " << commandString << " - Unknown Status!"); } break;
  }
 
}

CreatePhysicsList()

void PhysicsListSvc::CreatePhysicsList ( )

overridevirtual

Definition at line 49 of file PhysicsListSvc.cxx.

{
  ATH_MSG_DEBUG("PhysicsListSvc::CreatePhysicsList()");
  if (m_physicsListName.value() != ""){
    G4PhysListFactory factory;
    if (m_quietMode) { factory.SetVerbose(0); } // HACK
    AtlasPhysListFactory Atlasfactory;
    if (m_quietMode) {
      Atlasfactory.SetVerbose(0); // HACK
      G4HadronicProcessStore::Instance()->SetVerbose(0);
    }
    if (factory.IsReferencePhysList(m_physicsListName.value()))
    {
      ATH_MSG_INFO("Creating Geant4 PhysicsList: " << m_physicsListName.value());
      m_physicsList = factory.GetReferencePhysList(m_physicsListName.value());
    }
    else if (Atlasfactory.IsReferencePhysList(m_physicsListName.value()))
    {
      ATH_MSG_INFO("Creating ATLAS PhysicsList: " << m_physicsListName.value());
      m_physicsList = Atlasfactory.GetReferencePhysList(m_physicsListName.value());
    }
  }
 
  if (!m_physicsList)
    {
      ATH_MSG_ERROR("Unable to initialize physics List: " << m_physicsList);
      throw "PhysicsListInitializationError";
    }
  // Call these as functions.  As this could be used as a base class, having
  //   these as separate functions lets someone who is inheriting from this use
  //   them...
 
  // sort m_phys_option list
  std::vector<IPhysicsOptionTool*> sortedPhysicsOptions;
  sortedPhysicsOptions.reserve(m_phys_option.size());
  // Manually sorting ToolHandleArray
  {
    // BSM Physics
    for (auto& physOptTool: m_phys_option) {
      if (physOptTool->GetOptionType() == G4AtlasPhysicsOption::Type::BSMPhysics) {
        sortedPhysicsOptions.push_back(&*physOptTool);
      }
    }
 
    // Add particles from the PDG Table not currently known to Geant4
    for (auto& physOptTool: m_phys_option) {
      if (physOptTool->GetOptionType() == G4AtlasPhysicsOption::Type::QS_ExtraParticles) {
        sortedPhysicsOptions.push_back(&*physOptTool);
      }
    }
 
    // Add MSC and Ionisation processes for specific particles (possibly merge with the next one?)
    for (auto& physOptTool: m_phys_option) {
      if (physOptTool->GetOptionType() == G4AtlasPhysicsOption::Type::QS_ExtraProc) {
        sortedPhysicsOptions.push_back(&*physOptTool);
      }
    }
 
    // G4StepLimitation, LUCID Op Process, TRT XTR process
    for (auto& physOptTool: m_phys_option) {
      if (physOptTool->GetOptionType() == G4AtlasPhysicsOption::Type::GlobalProcesses) {
        sortedPhysicsOptions.push_back(&*physOptTool);
      }
    }
 
    // Unknown
    for (auto& physOptTool: m_phys_option) {
      if (physOptTool->GetOptionType() == G4AtlasPhysicsOption::Type::UnknownType) {
        ATH_MSG_ERROR(physOptTool->name() << "set as UnknownType. This tool will not be used to modify the physics list of this job.");
      }
    }
  }
 
  //Register physics options to the G4VModularPhysicsList
  for (auto& physOptTool: sortedPhysicsOptions)
    {
      ATH_MSG_DEBUG("Registering " << physOptTool->name());
      m_physicsList->RegisterPhysics(physOptTool->GetPhysicsOption().release());
    }
  //Register decays to the G4VModularPhysicsList
  for (auto& physDecayTool: m_phys_decay)
    {
      ATH_MSG_DEBUG("Registering " << physDecayTool->name());
      m_physicsList->RegisterPhysics(physDecayTool->GetPhysicsOption().release());
    }
 
  m_physicsList->RegisterPhysics(m_fastSimulationConstructor->GetPhysicsOption().release());
 
  //ConstructProcess();
  ATH_MSG_DEBUG("end of PhysicsListSvc::CreatePhysicsList()");
}

GetPhysicsList()

G4VUserPhysicsList * PhysicsListSvc::GetPhysicsList ( )

overridevirtual

Definition at line 142 of file PhysicsListSvc.cxx.

{
  if (!m_physicsList) {
    this->CreatePhysicsList();
  }
  return m_physicsList;
}

initialize()

StatusCode PhysicsListSvc::initialize ( )

overridevirtual

Definition at line 28 of file PhysicsListSvc.cxx.

{
  ATH_MSG_DEBUG("PhysicsListSvc::initialize()");
  if (m_phys_option.size())
    {
      ATH_MSG_INFO( "Initializing list of " <<  m_phys_option.size() << " physics options"  );
      CHECK( m_phys_option.retrieve() );
    }
 
  if (m_phys_decay.size())
    {
      ATH_MSG_INFO( "Initializing list of " <<  m_phys_decay.size() << " Decays "  );
      CHECK( m_phys_decay.retrieve() );
    }
 
  CHECK(m_fastSimulationConstructor.retrieve());
 
  return StatusCode::SUCCESS;
}

SetPhysicsList()

void PhysicsListSvc::SetPhysicsList ( )

overridevirtual

Definition at line 151 of file PhysicsListSvc.cxx.

{
  if(!m_physicsList) {
    this->CreatePhysicsList();
  }
  G4RunManager::GetRunManager()->SetUserInitialization(m_physicsList);
}

SetPhysicsOptions()

void PhysicsListSvc::SetPhysicsOptions ( )

overridevirtual

Definition at line 160 of file PhysicsListSvc.cxx.

{
  if (!m_physicsList)
    {
      ATH_MSG_WARNING("Physics list not initialized before calling ConstructProcess()");
      return;
    }
 
  if(m_generalCut.value() > 0. && std::abs(m_generalCut.value())>std::numeric_limits<double>::epsilon())
    {
      m_physicsList->SetDefaultCutValue(m_generalCut.value());
    }
 
  std::vector<std::string> g4commands;
  if (m_neutronTimeCut.value() > 0. && std::abs(m_neutronTimeCut.value())>std::numeric_limits<double>::epsilon())
    {
      std::ostringstream oss;
      oss<<"/physics_engine/neutron/timeLimit "<<m_neutronTimeCut.value()<<" ns";
      g4commands.push_back(oss.str());
    }
 
  if (m_neutronEnergyCut.value() > 0. && std::abs(m_neutronEnergyCut.value())>std::numeric_limits<double>::epsilon())
    {
      std::ostringstream oss;
      oss<<"/physics_engine/neutron/energyLimit "<<m_neutronEnergyCut.value()<<" MeV";
      g4commands.push_back(oss.str());
    }
 
  if(!g4commands.empty()) {
    // Send UI commands
    ATH_MSG_DEBUG("G4 Command: Trying in SetPhysicsOptions()");
    G4UImanager* ui = G4UImanager::GetUIpointer();
    for (const auto& g4command : g4commands) {
      int returnCode = ui->ApplyCommand( g4command );
      CommandLog(returnCode, g4command);
    }
  }
 
  G4EmParameters* emp = G4EmParameters::Instance();
  if (m_emMaxEnergy.value()>=0) emp->SetMaxEnergy(m_emMaxEnergy.value());
  if (m_emNumberOfBinsPerDecade.value()>=0) emp->SetNumberOfBinsPerDecade(m_emNumberOfBinsPerDecade.value());
  if (m_emMinEnergy.value()>=0) emp->SetMinEnergy(m_emMinEnergy.value());
  if (m_applyEMCuts.value())
    {
      emp->SetApplyCuts(true);
    }
 
  if (m_unstableAntiNeutrons) {
    G4AntiNeutron::Definition()->SetPDGStable(false);
  }
 
  return;
}

Member Data Documentation

m_applyEMCuts

Gaudi::Property<bool> PhysicsListSvc::m_applyEMCuts {this, "ApplyEMCuts", true, "Apply cuts EM flag in Geant4"}

private

!< Number of bins per Energy decade. Used for both DeDx and for the Lambda binning.

Definition at line 61 of file PhysicsListSvc.h.

{this, "ApplyEMCuts", true, "Apply cuts EM flag in Geant4"};                

m_emMaxEnergy

Gaudi::Property<double> PhysicsListSvc::m_emMaxEnergy {this, "EMMaxEnergy", -1., "Maximum energy for EM tables"}

private

!< A general cut - this isn't normally used in our simulation

Definition at line 52 of file PhysicsListSvc.h.

{this, "EMMaxEnergy", -1., "Maximum energy for EM tables"};              

m_emMinEnergy

Gaudi::Property<double> PhysicsListSvc::m_emMinEnergy {this, "EMMinEnergy", -1., "Minimum energy for EM tables"}

private

!< Maximum energy of the pre-calculated EM cross-section tables

Definition at line 53 of file PhysicsListSvc.h.

{this, "EMMinEnergy", -1., "Minimum energy for EM tables"};              

m_emNumberOfBinsPerDecade

Gaudi::Property<int> PhysicsListSvc::m_emNumberOfBinsPerDecade {this, "EMNumberOfBinsPerDecade", -1, "Number of bins per Energy decade. Used for both DeDx and for the Lambda binning."}

private

!< Minimum energy of the pre-calculated EM cross-section tables

Definition at line 60 of file PhysicsListSvc.h.

{this, "EMNumberOfBinsPerDecade", -1, "Number of bins per Energy decade. Used for both DeDx and for the Lambda binning."};     

m_fastSimulationConstructor

ToolHandle<IPhysicsOptionTool> PhysicsListSvc::m_fastSimulationConstructor {this, "FastSimConstructor", "", "Physics Constructor for fast simulation physics"}

private

Definition at line 43 of file PhysicsListSvc.h.

{this, "FastSimConstructor", "", "Physics Constructor for fast simulation physics"};

m_generalCut

Gaudi::Property<double> PhysicsListSvc::m_generalCut {this, "GeneralCut", 0, "General cut"}

private

!< Energy cut for neutrons (in the neutron killer process)

Definition at line 51 of file PhysicsListSvc.h.

{this, "GeneralCut", 0, "General cut"};               

m_neutronEnergyCut

Gaudi::Property<double> PhysicsListSvc::m_neutronEnergyCut {this, "NeutronEnergyCut", 0, "Energy cut for neutron killer"}

private

!< Time cut for neutrons (in the neutron killer process)

Definition at line 50 of file PhysicsListSvc.h.

{this, "NeutronEnergyCut", 0, "Energy cut for neutron killer"};         

m_neutronTimeCut

Gaudi::Property<double> PhysicsListSvc::m_neutronTimeCut {this, "NeutronTimeCut", 0, "Time cut for neutron killer"}

private

!< Name for the physics list (property to be set in the tool)

Definition at line 49 of file PhysicsListSvc.h.

{this, "NeutronTimeCut", 0, "Time cut for neutron killer"};           

m_phys_decay

ToolHandleArray<IPhysicsOptionTool> PhysicsListSvc::m_phys_decay {this, "PhysicsDecay", {}, "Tool handle array of physics decays"}

private

Definition at line 46 of file PhysicsListSvc.h.

{this, "PhysicsDecay", {}, "Tool handle array of physics decays"};

m_phys_option

ToolHandleArray<IPhysicsOptionTool> PhysicsListSvc::m_phys_option {this, "PhysOption", {}, "Tool handle array of physics options" }

private

Definition at line 45 of file PhysicsListSvc.h.

{this, "PhysOption", {}, "Tool handle array of physics options" };

m_physicsList

G4VModularPhysicsList* PhysicsListSvc::m_physicsList {}

private

Definition at line 47 of file PhysicsListSvc.h.

{}; 

m_physicsListName

Gaudi::Property<std::string> PhysicsListSvc::m_physicsListName {this, "PhysicsList", "FTFP_BERT", "Name for physics list"}

private

!< Handle on the physics list

Definition at line 48 of file PhysicsListSvc.h.

{this, "PhysicsList", "FTFP_BERT", "Name for physics list"};     

m_quietMode

Gaudi::Property<bool> PhysicsListSvc::m_quietMode {this, "QuietMode", false, ""}

private

!< Switch for the G4 "apply cuts" EM physics flag

Definition at line 62 of file PhysicsListSvc.h.

{this, "QuietMode", false, ""};

m_unstableAntiNeutrons

Gaudi::Property<bool> PhysicsListSvc::m_unstableAntiNeutrons {this, "UnstableAntiNeutrons",false,"Bugfix for ATLASSIM-6634 until we switch to using Geant4 11"}

private

Definition at line 63 of file PhysicsListSvc.h.

{this, "UnstableAntiNeutrons",false,"Bugfix for ATLASSIM-6634 until we switch to using Geant4 11"};

---

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

• PhysicsListSvc.h
• PhysicsListSvc.cxx