ISF::FastCaloSimV2Tool Class Reference

#include <FastCaloSimV2Tool.h>

Inheritance diagram for ISF::FastCaloSimV2Tool:

Collaboration diagram for ISF::FastCaloSimV2Tool:

Public Member Functions
	FastCaloSimV2Tool (const std::string &type, const std::string &name, const IInterface *parent)
	Constructor with parameters.
virtual	~FastCaloSimV2Tool ()=default
	Destructor.
virtual StatusCode	initialize () override final
	Athena algorithm's interface methods.
virtual StatusCode	simulate (const EventContext &ctx, ISFParticle &isp, ISFParticleContainer &, McEventCollection *mcEventCollection) override final
	Simulation Call.
virtual StatusCode	setupEvent (const EventContext &) override final
	Setup Event chain - in case of a begin-of event action is needed.
virtual StatusCode	setupEventST () override final
	Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc)
virtual StatusCode	releaseEvent (const EventContext &) override final
	Release Event chain - in case of an end-of event action is needed.
virtual StatusCode	releaseEventST () override final
	Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc)
virtual SimulationFlavor	simFlavor () const override final
virtual StatusCode	sysInitialize () override
	Gaudi sysInitialize() methods.
virtual StatusCode	simulateVector (const EventContext &ctx, const ISFParticleVector &particles, ISFParticleContainer &secondaries, McEventCollection *mcEventCollection, McEventCollection *) override
	Simulation call for vectors of particles.
const ChronoEntity *	chronoStart (const IChronoSvc::ChronoTag &tag)
	wrapper call to start chrono with given tag
const ChronoEntity *	chronoStop (const IChronoSvc::ChronoTag &tag)
	wrapper call to stop chrono with given tag

Protected Attributes
ServiceHandle< IChronoStatSvc >	m_chrono {this, "ChronoStatService", "ChronoStatSvc"}
	The timing service for general usage.

Private Member Functions
StatusCode	commonSetup (const EventContext &ctx)

Private Attributes
ServiceHandle< IFastCaloSimParamSvc >	m_paramSvc {this, "ParamSvc", "ISF_FastCaloSimV2ParamSvc"}
bool	m_doPunchThrough {true}
ToolHandle< IPunchThroughTool >	m_punchThroughTool {this, "PunchThroughTool", ""}
PublicToolHandleArray< ICaloCellMakerTool >	m_caloCellMakerToolsSetup {this, "CaloCellMakerTools_setup", {}, ""}
PublicToolHandleArray< ICaloCellMakerTool >	m_caloCellMakerToolsRelease {this, "CaloCellMakerTools_release", {}, ""}
PublicToolHandle< IFastCaloSimCaloExtrapolation >	m_FastCaloSimCaloExtrapolation {this, "FastCaloSimCaloExtrapolation", "", ""}
std::unique_ptr< CaloCellContainer >	m_theContainer {}
CaloCellContainer *	m_theContainerPtr {}
SG::WriteHandleKey< CaloCellContainer >	m_caloCellKey { this, "CaloCells", "DefaultCaloCellContainer", "The name of the output CaloCellContainer" }
ServiceHandle< IAthRNGSvc >	m_rndmGenSvc {this, "RandomSvc", "AthRNGSvc", ""}
Gaudi::Property< std::string >	m_randomEngineName {this, "RandomStream", ""}
Gaudi::Property< std::string >	m_caloCellsOutputName {this, "CaloCellsOutputName", "AllCalo"}
ServiceHandle< ISF::ITruthSvc >	m_truthRecordSvc {this,"ParticleTruthSvc", "ISF_TruthRecordSvc", "ISF Particle Truth Svc"}

Detailed Description

Author

Elmar.Ritsch -at- cern.ch, Geraldine.Conti -at- cern.ch, Flavia.Dias -at- cern.ch

Definition at line 42 of file FastCaloSimV2Tool.h.

Constructor & Destructor Documentation

FastCaloSimV2Tool()

ISF::FastCaloSimV2Tool::FastCaloSimV2Tool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Constructor with parameters.

Constructor.

Definition at line 46 of file FastCaloSimV2Tool.cxx.

  : BaseSimulatorTool(type, name, parent)
{
}

~FastCaloSimV2Tool()

virtual ISF::FastCaloSimV2Tool::~FastCaloSimV2Tool ( )

virtualdefault

Destructor.

Member Function Documentation

chronoStart()

const ChronoEntity * ISF::BaseSimulatorTool::chronoStart ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to start chrono with given tag

Definition at line 98 of file BaseSimulatorTool.h.

                                                                     {
      if (m_chrono) return m_chrono->chronoStart( tag);
      return nullptr;
    }

chronoStop()

const ChronoEntity * ISF::BaseSimulatorTool::chronoStop ( const IChronoSvc::ChronoTag & tag )

inlineinherited

wrapper call to stop chrono with given tag

Definition at line 104 of file BaseSimulatorTool.h.

                                                                    {
      if (m_chrono) return m_chrono->chronoStop( tag);
      return nullptr;
    }

commonSetup()

StatusCode ISF::FastCaloSimV2Tool::commonSetup ( const EventContext & ctx )

private

Definition at line 103 of file FastCaloSimV2Tool.cxx.

{
  // Set the RNGs to use for this event. We need to reset it for MT jobs
  // because of the mismatch between Gaudi slot-local and G4 thread-local RNG.
  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomEngineName);
  rngWrapper->setSeed( m_randomEngineName, ctx );
 
  for (const ToolHandle<ICaloCellMakerTool>& tool : m_caloCellMakerToolsSetup)
    {
      std::string chronoName=this->name()+"_"+ tool.name();
      if (m_chrono) m_chrono->chronoStart(chronoName);
      StatusCode sc = tool->process(m_theContainerPtr, ctx);
      if (m_chrono) {
        m_chrono->chronoStop(chronoName);
        ATH_MSG_DEBUG( "Chrono stop : delta " << m_chrono->chronoDelta (chronoName,IChronoStatSvc::USER) * CLHEP::microsecond / CLHEP::second << " second " );
      }
 
      if (sc.isFailure())
        {
          ATH_MSG_ERROR( "Error executing tool " << tool.name() );
          return StatusCode::FAILURE;
        }
    }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode ISF::FastCaloSimV2Tool::initialize ( )

finaloverridevirtual

Athena algorithm's interface methods.

framework methods

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 52 of file FastCaloSimV2Tool.cxx.

{
  ATH_CHECK( BaseSimulatorTool::initialize() );
 
  ATH_CHECK( m_caloCellMakerToolsSetup.retrieve() );
  ATH_MSG_DEBUG( "Successfully retrieve CaloCellMakerTools: " << m_caloCellMakerToolsSetup );
  ATH_CHECK( m_caloCellMakerToolsRelease.retrieve() );
 
  ATH_CHECK(m_rndmGenSvc.retrieve());
 
  ATH_CHECK(m_paramSvc.retrieve());
 
  // m_paramSvc->setLevel(MSG::VERBOSE);
 
  m_doPunchThrough = not m_punchThroughTool.empty();
  if (m_doPunchThrough) {
    ATH_CHECK(m_punchThroughTool.retrieve());
  }
 
  ATH_CHECK(m_truthRecordSvc.retrieve());
 
  // Get FastCaloSimCaloExtrapolation
  ATH_CHECK(m_FastCaloSimCaloExtrapolation.retrieve());
 
  // Output data handle
  ATH_CHECK( m_caloCellKey.initialize() );
 
  return StatusCode::SUCCESS;
}

releaseEvent()

StatusCode ISF::FastCaloSimV2Tool::releaseEvent ( const EventContext & ctx )

finaloverridevirtual

Release Event chain - in case of an end-of event action is needed.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 130 of file FastCaloSimV2Tool.cxx.

{
  ATH_MSG_VERBOSE( "FastCaloSimV2Tool " << name() << " releaseEvent() " );
  // Run the version of releaseEvent that returns the output collection
  // Run the normal method
  ATH_CHECK(this->releaseEventST());
  if ( m_theContainer ) {
 
    // Record with WriteHandle
    SG::WriteHandle< CaloCellContainer > caloCellHandle( m_caloCellKey, ctx );
    ATH_CHECK( caloCellHandle.record( std::move( m_theContainer ) ) );
    return StatusCode::SUCCESS;
  }
  return StatusCode::FAILURE;
}

releaseEventST()

StatusCode ISF::FastCaloSimV2Tool::releaseEventST ( )

finaloverridevirtual

Release Event chain - in case of an end-of event action is needed (called by ISimulationSvc)

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 146 of file FastCaloSimV2Tool.cxx.

{
  ATH_MSG_VERBOSE("release Event");
  const EventContext& ctx = Gaudi::Hive::currentContext();
 
  //run release tools in a loop
  for (const ToolHandle<ICaloCellMakerTool>& tool : m_caloCellMakerToolsRelease)
    {
      ATH_MSG_VERBOSE( "Calling tool " << tool.name() );
 
      ATH_CHECK(tool->process(m_theContainerPtr, ctx));
    }
 
  return StatusCode::SUCCESS;
 
}

setupEvent()

StatusCode ISF::FastCaloSimV2Tool::setupEvent ( const EventContext & ctx )

finaloverridevirtual

Setup Event chain - in case of a begin-of event action is needed.

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 94 of file FastCaloSimV2Tool.cxx.

{
  ATH_MSG_DEBUG ("setupEvent");
 
  m_theContainer = std::make_unique<CaloCellContainer>(SG::VIEW_ELEMENTS);
  m_theContainerPtr = m_theContainer.get();
  return this->commonSetup(ctx);
}

setupEventST()

StatusCode ISF::FastCaloSimV2Tool::setupEventST ( )

finaloverridevirtual

Setup Event chain - in case of a begin-of event action is needed (called by ISimulationSvc)

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 82 of file FastCaloSimV2Tool.cxx.

{
  ATH_MSG_DEBUG ("setupEventST");
 
  m_theContainer = std::make_unique<CaloCellContainer>(SG::VIEW_ELEMENTS);
  m_theContainerPtr = m_theContainer.get();
  ATH_CHECK(evtStore()->record(std::move(m_theContainer), m_caloCellsOutputName));
  // NB: m_theContainer is now nullptr
  const EventContext& ctx = Gaudi::Hive::currentContext();
  return this->commonSetup(ctx);
}

simFlavor()

virtual SimulationFlavor ISF::FastCaloSimV2Tool::simFlavor ( ) const

inlinefinaloverridevirtual

Definition at line 68 of file FastCaloSimV2Tool.h.

{ return ISF::FastCaloSimV2; };

simulate()

StatusCode ISF::FastCaloSimV2Tool::simulate ( const EventContext & ctx, ISF::ISFParticle & isfp, ISFParticleContainer & secondaries, McEventCollection * mcEventCollection )

finaloverridevirtual

Simulation Call.

for anti protons and anti neutrons the kinetic energy should be calculated as Ekin = E() + M() instead of E() - M() this is achieved by setting an Ekin offset of 2*M() to the truth state

Reimplemented from ISF::BaseSimulatorTool.

Definition at line 164 of file FastCaloSimV2Tool.cxx.

{
 
  ATH_MSG_VERBOSE("NEW PARTICLE! FastCaloSimV2Tool called with ISFParticle: " << isfp);
 
  Amg::Vector3D particle_position =  isfp.position();
  Amg::Vector3D particle_direction(isfp.momentum().x(),isfp.momentum().y(),isfp.momentum().z());
 
  ATHRNG::RNGWrapper* rngWrapper = m_rndmGenSvc->getEngine(this, m_randomEngineName);
 
  //Don't simulate particles with total energy below 10 MeV
  if(isfp.ekin() < 10) {
    ATH_MSG_VERBOSE("Skipping particle with Ekin: " << isfp.ekin() <<" MeV. Below the 10 MeV threshold.");
    return StatusCode::SUCCESS;
  }
 
  TFCSTruthState truth;
  truth.SetPtEtaPhiM(particle_direction.perp(), particle_direction.eta(), particle_direction.phi(), isfp.mass());
  truth.set_pdgid(isfp.pdgCode());
  truth.set_vertex(particle_position[Amg::x], particle_position[Amg::y], particle_position[Amg::z]);

  if(isfp.pdgCode() == -2212 || isfp.pdgCode() == -2112) {
    truth.set_Ekin_off(2*isfp.mass());
    ATH_MSG_VERBOSE("Found anti-proton/neutron, setting Ekin offset in TFCSTruthState.");
  }
 
  TFCSExtrapolationState extrapol;
  m_FastCaloSimCaloExtrapolation->extrapolate(extrapol, &truth);
 
  ATH_MSG_DEBUG(" particle: " << isfp.pdgCode() << " Ekin: " << isfp.ekin() << " position eta: " << particle_position.eta() << " direction eta: " << particle_direction.eta() << " position phi: " << particle_position.phi() << " direction phi: " << particle_direction.phi());
 
  //only simulate if extrapolation to calo surface succeeded
  if(extrapol.IDCaloBoundary_eta() != -999){
    CLHEP::HepRandomEngine *rndmEngine = rngWrapper->getEngine(ctx);
    TFCSSimulationState simulstate(rndmEngine);
 
    // ATH_MSG_WARNING("Event number for this event: " << ctx.evt());
    simulstate.setAuxInfo<int>("EventNr"_FCShash, ctx.evt() );
    
    ATH_CHECK(m_paramSvc->simulate(simulstate, &truth, &extrapol));
 
    ATH_MSG_DEBUG("Energy returned: " << simulstate.E());
    ATH_MSG_VERBOSE("Energy fraction for layer: ");
    for (int s = 0; s < CaloCell_ID_FCS::MaxSample; s++)
    ATH_MSG_VERBOSE(" Sampling " << s << " energy " << simulstate.E(s));
 
    //Now deposit all cell energies into the CaloCellContainer
    for(const auto& iter : simulstate.cells()) {
      CaloCell* theCell = (CaloCell*)m_theContainerPtr->findCell(iter.first->calo_hash());
      theCell->addEnergy(iter.second);
    }
 
    //now perform punch through
    if (m_doPunchThrough) {
      int process = 201;
      // call punch-through simulation
      const ISF::ISFParticleVector *someSecondaries = m_punchThroughTool->computePunchThroughParticles(isfp, simulstate, rndmEngine);
 
      if (someSecondaries && !someSecondaries->empty()) {
        //Record truth incident for created punch through particles
        ISF::ISFTruthIncident truth( const_cast<ISF::ISFParticle&>(isfp),
                                     *someSecondaries,
                                     process,
                                     isfp.nextGeoID(),  // inherits from the parent
                                     ISF::fKillsPrimary);
 
        m_truthRecordSvc->registerTruthIncident( truth, true );
        // At this point we need to update the properties of the
        // ISFParticles produced in the interaction
        truth.updateChildParticleProperties();
 
        for (auto *secondary : *someSecondaries) {
          if (secondary->getTruthBinding()) {
            secondaries.push_back(secondary);
          }
          else {
            ATH_MSG_WARNING("Secondary particle created by PunchThroughTool not written out to truth.\n Parent (" << isfp << ")\n Secondary (" << *secondary <<")");
            delete secondary;
          }
        }
        delete someSecondaries;
      }
    }
    simulstate.DoAuxInfoCleanup();
  }
  else ATH_MSG_DEBUG("Skipping simulation as extrapolation to ID-Calo boundary failed.");
 
 
  return StatusCode::SUCCESS;
 
}

simulateVector()

virtual StatusCode ISF::BaseSimulatorTool::simulateVector ( const EventContext & ctx, const ISFParticleVector & particles, ISFParticleContainer & secondaries, McEventCollection * mcEventCollection, McEventCollection *  )

inlineoverridevirtualinherited

Simulation call for vectors of particles.

Reimplemented in ISF::ActsFatrasSimTool, ISF::BaseSimulatorG4Tool, and ISF::ParticleKillerSimTool.

Definition at line 75 of file BaseSimulatorTool.h.

    {
      // this implementation is a wrapper in case the simulator does
      // implement particle-vector input
 
      // simulate each particle individually
      for (auto* cisp : particles) {
        ATH_MSG_VERBOSE( "Starting simulation of particle: " << (*cisp) );
        ATH_CHECK(this->simulate(ctx, *cisp, secondaries, mcEventCollection));
      }
      return StatusCode::SUCCESS;
 
    }

sysInitialize()

virtual StatusCode ISF::BaseSimulatorTool::sysInitialize ( )

inlineoverridevirtualinherited

Gaudi sysInitialize() methods.

Definition at line 49 of file BaseSimulatorTool.h.

    {
      ATH_CHECK( AthAlgTool::sysInitialize() );
      ATH_CHECK( m_chrono.retrieve() );
      return StatusCode::SUCCESS;
    }

Member Data Documentation

m_caloCellKey

SG::WriteHandleKey< CaloCellContainer > ISF::FastCaloSimV2Tool::m_caloCellKey { this, "CaloCells", "DefaultCaloCellContainer", "The name of the output CaloCellContainer" }

private

Definition at line 82 of file FastCaloSimV2Tool.h.

{ this, "CaloCells", "DefaultCaloCellContainer", "The name of the output CaloCellContainer" };

m_caloCellMakerToolsRelease

PublicToolHandleArray<ICaloCellMakerTool> ISF::FastCaloSimV2Tool::m_caloCellMakerToolsRelease {this, "CaloCellMakerTools_release", {}, ""}

private

Definition at line 76 of file FastCaloSimV2Tool.h.

{this, "CaloCellMakerTools_release", {}, ""};

m_caloCellMakerToolsSetup

PublicToolHandleArray<ICaloCellMakerTool> ISF::FastCaloSimV2Tool::m_caloCellMakerToolsSetup {this, "CaloCellMakerTools_setup", {}, ""}

private

Definition at line 75 of file FastCaloSimV2Tool.h.

{this, "CaloCellMakerTools_setup", {}, ""};

m_caloCellsOutputName

Gaudi::Property<std::string> ISF::FastCaloSimV2Tool::m_caloCellsOutputName {this, "CaloCellsOutputName", "AllCalo"}

private

Definition at line 86 of file FastCaloSimV2Tool.h.

{this, "CaloCellsOutputName", "AllCalo"};

m_chrono

ServiceHandle<IChronoStatSvc> ISF::BaseSimulatorTool::m_chrono {this, "ChronoStatService", "ChronoStatSvc"}

protectedinherited

The timing service for general usage.

Definition at line 115 of file BaseSimulatorTool.h.

{this, "ChronoStatService", "ChronoStatSvc"};

m_doPunchThrough

bool ISF::FastCaloSimV2Tool::m_doPunchThrough {true}

private

Definition at line 73 of file FastCaloSimV2Tool.h.

{true};

m_FastCaloSimCaloExtrapolation

PublicToolHandle<IFastCaloSimCaloExtrapolation> ISF::FastCaloSimV2Tool::m_FastCaloSimCaloExtrapolation {this, "FastCaloSimCaloExtrapolation", "", ""}

private

Definition at line 78 of file FastCaloSimV2Tool.h.

{this, "FastCaloSimCaloExtrapolation", "", ""};

m_paramSvc

ServiceHandle<IFastCaloSimParamSvc> ISF::FastCaloSimV2Tool::m_paramSvc {this, "ParamSvc", "ISF_FastCaloSimV2ParamSvc"}

private

Definition at line 72 of file FastCaloSimV2Tool.h.

{this, "ParamSvc", "ISF_FastCaloSimV2ParamSvc"};

m_punchThroughTool

ToolHandle< IPunchThroughTool > ISF::FastCaloSimV2Tool::m_punchThroughTool {this, "PunchThroughTool", ""}

private

Definition at line 74 of file FastCaloSimV2Tool.h.

{this, "PunchThroughTool", ""};

m_randomEngineName

Gaudi::Property<std::string> ISF::FastCaloSimV2Tool::m_randomEngineName {this, "RandomStream", ""}

private

Definition at line 85 of file FastCaloSimV2Tool.h.

{this, "RandomStream", ""};

m_rndmGenSvc

ServiceHandle<IAthRNGSvc> ISF::FastCaloSimV2Tool::m_rndmGenSvc {this, "RandomSvc", "AthRNGSvc", ""}

private

Definition at line 84 of file FastCaloSimV2Tool.h.

{this, "RandomSvc", "AthRNGSvc", ""};

m_theContainer

std::unique_ptr<CaloCellContainer> ISF::FastCaloSimV2Tool::m_theContainer {}

private

Definition at line 80 of file FastCaloSimV2Tool.h.

{};

m_theContainerPtr

CaloCellContainer* ISF::FastCaloSimV2Tool::m_theContainerPtr {}

private

Definition at line 81 of file FastCaloSimV2Tool.h.

{};

m_truthRecordSvc

ServiceHandle<ISF::ITruthSvc> ISF::FastCaloSimV2Tool::m_truthRecordSvc {this,"ParticleTruthSvc", "ISF_TruthRecordSvc", "ISF Particle Truth Svc"}

private

Definition at line 87 of file FastCaloSimV2Tool.h.

{this,"ParticleTruthSvc", "ISF_TruthRecordSvc", "ISF Particle Truth Svc"};

---

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

• FastCaloSimV2Tool.h
• FastCaloSimV2Tool.cxx