Simulation::LRAVertexPositioner Class Reference

Generates vertex positions based on a LRA histogram. More...

#include <LRAVertexPositioner.h>

Inheritance diagram for Simulation::LRAVertexPositioner:

Collaboration diagram for Simulation::LRAVertexPositioner:

Public Member Functions
	LRAVertexPositioner (const std::string &t, const std::string &n, const IInterface *p)
	Constructor.
virtual	~LRAVertexPositioner ()=default
	Destructor.
virtual StatusCode	initialize () override final
	AthAlgTool initialization.
virtual StatusCode	finalize () override final
	AthAlgTool finalization.
virtual CLHEP::HepLorentzVector *	generate (const EventContext &ctx) const override final
	Generate a vertex position from the LRA input.

Private Types
using	IntegralTuple = std::tuple<Int_t, Int_t, Int_t, Double_t>
	Tuple for [xBin, yBin, zBin, Integral].

Private Attributes
Gaudi::Property< std::string >	m_FileName {this, "FileName", "<<Unset>>", "LRA input file name."}
	LRA input file name.
Gaudi::Property< std::string >	m_HistName {this, "HistName", "<<Unset>>", "LRA input histogram name."}
	LRA input histogram name.
std::unique_ptr< TFile >	m_LRAFile
	Owning TFile * to the LRA file.
const TH3F *	m_LRAHist = nullptr
	Non-owning TH3F * to the LRA histogram.
ServiceHandle< IAthRNGSvc >	m_RNGService {this, "RNGService", "AthRNGSvc"}
	Handle to the Athena RNG service.
Gaudi::Property< std::string >	m_RNGStream {this, "RNGStream", "LRAVertexPositioner", "Stream name for the RNG service."}
	Stream name for the RNG service.
ATHRNG::RNGWrapper *m_RNGEngine	ATLAS_THREAD_SAFE {}
	Non-owning RNGWrapper * to the RNG engine.
std::vector< IntegralTuple >	m_Integral
	Vector to hold the running integral over bins.
const TAxis *	m_xAxis = nullptr
	Non-owning TAxis * to the histograms x-Axis.
const TAxis *	m_yAxis = nullptr
	Non-owning TAxis * to the histograms y-Axis.
const TAxis *	m_zAxis = nullptr
	Non-owning TAxis * to the histograms z-Axis.

Detailed Description

Generates vertex positions based on a LRA histogram.

Definition at line 26 of file LRAVertexPositioner.h.

Member Typedef Documentation

IntegralTuple

using Simulation::LRAVertexPositioner::IntegralTuple = std::tuple<Int_t, Int_t, Int_t, Double_t>

private

Tuple for [xBin, yBin, zBin, Integral].

Definition at line 62 of file LRAVertexPositioner.h.

Constructor & Destructor Documentation

LRAVertexPositioner()

Simulation::LRAVertexPositioner::LRAVertexPositioner	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

Constructor.

Definition at line 19 of file LRAVertexPositioner.cxx.

    : base_class(t,n,p)
  {
  };

~LRAVertexPositioner()

virtual Simulation::LRAVertexPositioner::~LRAVertexPositioner ( )

virtualdefault

Destructor.

Member Function Documentation

finalize()

StatusCode Simulation::LRAVertexPositioner::finalize ( )

finaloverridevirtual

AthAlgTool finalization.

Definition at line 121 of file LRAVertexPositioner.cxx.

  {
    return StatusCode::SUCCESS;
  };

generate()

CLHEP::HepLorentzVector * Simulation::LRAVertexPositioner::generate ( const EventContext & ctx ) const

finaloverridevirtual

Generate a vertex position from the LRA input.

Definition at line 128 of file LRAVertexPositioner.cxx.

  {
    // Set the RNG seed and get the engine for this event.
    m_RNGEngine->setSeed(name(), ctx);
    CLHEP::HepRandomEngine *LRAEngine(m_RNGEngine->getEngine(ctx));
 
    //---
 
    // Compare the integral of two IntegralTuples.
    auto Comparison = [](const auto &LHS, const auto &RHS)
    {
      // No language place-holders... Yet...
      auto [lx, ly, lz, i] = LHS;
      auto [rx, ry, rz, t] = RHS;
 
      return(i < t);
    };
 
    // Get the point a V'th between the bin edges.
    auto GetCoordinate = [](const auto Axis, const auto Bin, const auto V)
    {
      return(Axis->GetBinLowEdge(Bin) + (V * Axis->GetBinWidth(Bin)));
    };
 
    // Find the x/y/z bin numbers of the interesting bin.
    auto [xBin, yBin, zBin, Integral] = *(std::lower_bound(m_Integral.cbegin(),
                               m_Integral.cend(),
                               std::make_tuple(0, 0, 0, CLHEP::RandFlat::shoot(LRAEngine)),
                               Comparison));
 
    // Return a point in the bin, caller deletes.
    CLHEP::HepLorentzVector *vertexPosition = new CLHEP::HepLorentzVector(GetCoordinate(m_xAxis, xBin, CLHEP::RandFlat::shoot(LRAEngine)),
                                      GetCoordinate(m_yAxis, yBin, CLHEP::RandFlat::shoot(LRAEngine)),
                                      GetCoordinate(m_zAxis, zBin, CLHEP::RandFlat::shoot(LRAEngine)),
                                      0.0);
 
    // ToDo: This uses only the TH3 PDF to position the vertex, this should be expanded to include:
    //         x/y/z translations.
    //         Slant angles.
    //         Euler angle/quaternion/something for arbiraty rotations (for non-factorisable PDFs)?
 
    //---
 
    return(vertexPosition);
  };

initialize()

StatusCode Simulation::LRAVertexPositioner::initialize ( )

finaloverridevirtual

AthAlgTool initialization.

Definition at line 26 of file LRAVertexPositioner.cxx.

  {
    // Resolve the LRA file name.
    const auto FilePath = PathResolverFindDataFile(m_FileName);
    if(FilePath.empty())
      {
    ATH_MSG_ERROR("Unable to resolve LRAFile: m_FileName = " << (std::string)m_FileName);
 
    return StatusCode::FAILURE;
      };
 
    // Open the file...
    m_LRAFile = std::unique_ptr<TFile>(TFile::Open(FilePath.c_str(), "READ"));
    if(!m_LRAFile)
      {
    ATH_MSG_ERROR("Unable to open LRAFile: FilePath = " << FilePath);
 
    return StatusCode::FAILURE;
      };
 
    // ... and get the histogram.
    // ToDo: We should re-evaluate holding open the TFile, compared to cloaning out the bits of interest.
    //       Requires access to a real LRA file.
    m_LRAHist = m_LRAFile->Get<TH3F>(((std::string)m_HistName).c_str());
    if(!m_LRAHist)
      {
    ATH_MSG_ERROR("Unable to get LRAHist: FilePath = " << FilePath << ", m_HistName = " << (std::string)m_HistName);
 
    return StatusCode::FAILURE;
      };
 
    // ToDo: In the medium term we should look at cleaning up the Lumi groups code, adding whatever the
    //       BS group needs it to do, and getting that into Athena(_externals). The code above could then
    //       be changed to generate the TH3 dynamicaly (maybe simplyfing the configuration of all the tools),
    //       and the future vdM BSFinder could use the unbinned PDF.
 
    //---
 
    // Retrieve the tool handle to the RNG service...
    ATH_CHECK(m_RNGService.retrieve());
 
    // ... and get the RNG engine.
    m_RNGEngine = m_RNGService->getEngine(this, m_RNGStream);
    if (!m_RNGEngine)
      {
    ATH_MSG_ERROR("Unable to get RNGEngine: m_RNGStream = " << (std::string) m_RNGStream);
 
    return StatusCode::FAILURE;
      };
 
    //---
 
    // Cache the bin counts.
    const auto nBinsX = m_LRAHist->GetNbinsX();
    const auto nBinsY = m_LRAHist->GetNbinsY();
    const auto nBinsZ = m_LRAHist->GetNbinsZ();
 
    // Pre-allocate the space in the vector.
    m_Integral.reserve(nBinsX * nBinsY * nBinsZ);
 
    /*
      Loop over the bins in the histogram, and store the bin numbers and the running integral into m_Integral.
 
      Assumes the LRA histograms are "well-formed" PDFs:
        Unit integral.
        No probability in under/over-flow bins
        No negative bins.
 
      Is ugly, better would be ranges, iota * 3 -> cartesian_product -> for_each, but needs C++23 (No Stinking Loops!!!)
    */
    Double_t Integral = 0.0;
    for(Int_t x = 1; x <= nBinsX; x++)
      {
    for(Int_t y = 1; y <= nBinsY; y++)
      {
        for(Int_t z = 1; z <= nBinsZ; z++)
          {
        Integral += m_LRAHist->GetBinContent(x, y, z);
 
        m_Integral.emplace_back(std::forward_as_tuple(x, y, z, Integral));
          };
      };
      };
 
    // Cache the axes.
    m_xAxis = m_LRAHist->GetXaxis();
    m_yAxis = m_LRAHist->GetYaxis();
    m_zAxis = m_LRAHist->GetZaxis();
 
    //---
 
    // Happy path...
    return StatusCode::SUCCESS;
  };

Member Data Documentation

ATLAS_THREAD_SAFE

ATHRNG::RNGWrapper* m_RNGEngine Simulation::LRAVertexPositioner::ATLAS_THREAD_SAFE {}

private

Non-owning RNGWrapper * to the RNG engine.

Definition at line 58 of file LRAVertexPositioner.h.

{};                                                                    

m_FileName

Gaudi::Property<std::string> Simulation::LRAVertexPositioner::m_FileName {this, "FileName", "<<Unset>>", "LRA input file name."}

private

LRA input file name.

Definition at line 48 of file LRAVertexPositioner.h.

{this, "FileName", "<<Unset>>", "LRA input file name."};      

m_HistName

Gaudi::Property<std::string> Simulation::LRAVertexPositioner::m_HistName {this, "HistName", "<<Unset>>", "LRA input histogram name."}

private

LRA input histogram name.

Definition at line 49 of file LRAVertexPositioner.h.

{this, "HistName", "<<Unset>>", "LRA input histogram name."}; 

m_Integral

std::vector<IntegralTuple> Simulation::LRAVertexPositioner::m_Integral

private

Vector to hold the running integral over bins.

Definition at line 63 of file LRAVertexPositioner.h.

m_LRAFile

std::unique_ptr<TFile> Simulation::LRAVertexPositioner::m_LRAFile

private

Owning TFile * to the LRA file.

Definition at line 51 of file LRAVertexPositioner.h.

m_LRAHist

const TH3F* Simulation::LRAVertexPositioner::m_LRAHist = nullptr

private

Non-owning TH3F * to the LRA histogram.

Definition at line 52 of file LRAVertexPositioner.h.

m_RNGService

ServiceHandle<IAthRNGSvc> Simulation::LRAVertexPositioner::m_RNGService {this, "RNGService", "AthRNGSvc"}

private

Handle to the Athena RNG service.

Definition at line 56 of file LRAVertexPositioner.h.

{this, "RNGService", "AthRNGSvc"};                                                

m_RNGStream

Gaudi::Property<std::string> Simulation::LRAVertexPositioner::m_RNGStream {this, "RNGStream", "LRAVertexPositioner", "Stream name for the RNG service."}

private

Stream name for the RNG service.

Definition at line 57 of file LRAVertexPositioner.h.

{this, "RNGStream", "LRAVertexPositioner", "Stream name for the RNG service."}; 

m_xAxis

const TAxis* Simulation::LRAVertexPositioner::m_xAxis = nullptr

private

Non-owning TAxis * to the histograms x-Axis.

Definition at line 65 of file LRAVertexPositioner.h.

m_yAxis

const TAxis* Simulation::LRAVertexPositioner::m_yAxis = nullptr

private

Non-owning TAxis * to the histograms y-Axis.

Definition at line 66 of file LRAVertexPositioner.h.

m_zAxis

const TAxis* Simulation::LRAVertexPositioner::m_zAxis = nullptr

private

Non-owning TAxis * to the histograms z-Axis.

Definition at line 67 of file LRAVertexPositioner.h.

---

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

• LRAVertexPositioner.h
• LRAVertexPositioner.cxx