PixelHistoConverter Class Reference

#include <PixelHistoConverter.h>

Collaboration diagram for PixelHistoConverter:

Classes
struct	Axis

Public Member Functions
	PixelHistoConverter ()
virtual	~PixelHistoConverter ()=default
StatusCode	setHisto1D (const TH1 *histo)
StatusCode	setHisto2D (const TH2 *histo)
StatusCode	setHisto3D (const TH3 *histo)
float	getContent (std::size_t x) const
float	getContent (std::size_t x, std::size_t y) const
float	getContent (std::size_t x, std::size_t y, std::size_t z) const
bool	isOverflowZ (const float value) const
bool	isFirstZ (const float value) const
template<typename... Args>
std::size_t	getBinX (Args &&...args) const
template<typename... Args>
std::size_t	getBinY (Args &&...args) const
template<typename... Args>
std::size_t	getBinZ (Args &&...args) const

Private Member Functions
std::size_t	findBin (const Axis &axis, const float value) const

Static Private Member Functions
static bool	setAxis (Axis &axis, const TAxis *rootAxis)

Private Attributes
Axis	m_xAxis {}
Axis	m_yAxis {}
Axis	m_zAxis {}
std::vector< float >	m_content

Detailed Description

Definition at line 25 of file PixelHistoConverter.h.

Constructor & Destructor Documentation

PixelHistoConverter()

PixelHistoConverter::PixelHistoConverter ( )

default

~PixelHistoConverter()

virtual PixelHistoConverter::~PixelHistoConverter ( )

virtualdefault

Member Function Documentation

findBin()

std::size_t PixelHistoConverter::findBin ( const Axis & axis, const float value ) const

inlineprivate

Definition at line 65 of file PixelHistoConverter.h.

                                                                      {
    if (value <= axis.min) return 0;
    if (value >= axis.max) return (axis.nBins - 1);
    return ((value - axis.min) * axis.width);
  }

getBinX()

template<typename... Args>

std::size_t PixelHistoConverter::getBinX ( Args &&... args ) const

inline

Definition at line 74 of file PixelHistoConverter.h.

                                          {
    return findBin(m_xAxis, std::forward<Args>(args)...);
  }

getBinY()

template<typename... Args>

std::size_t PixelHistoConverter::getBinY ( Args &&... args ) const

inline

Definition at line 79 of file PixelHistoConverter.h.

                                          {
    return findBin(m_yAxis, std::forward<Args>(args)...);
  }

getBinZ()

template<typename... Args>

std::size_t PixelHistoConverter::getBinZ ( Args &&... args ) const

inline

Definition at line 84 of file PixelHistoConverter.h.

                                          {
    return findBin(m_zAxis, std::forward<Args>(args)...);
  }

getContent() [1/3]

float PixelHistoConverter::getContent ( std::size_t x ) const

inline

Definition at line 34 of file PixelHistoConverter.h.

                                             {
    return m_content[x];
  }

getContent() [2/3]

float PixelHistoConverter::getContent ( std::size_t x, std::size_t y ) const

inline

Definition at line 37 of file PixelHistoConverter.h.

                                                          {
    return m_content[x + y*(m_xAxis.nBins)];
  }

getContent() [3/3]

float PixelHistoConverter::getContent ( std::size_t x, std::size_t y, std::size_t z ) const

inline

Definition at line 40 of file PixelHistoConverter.h.

                                                                       {
    return m_content[x + m_xAxis.nBins*(y + (m_yAxis.nBins * z))];
  }

isFirstZ()

bool PixelHistoConverter::isFirstZ

(

const float

value

)

const

Definition at line 101 of file PixelHistoConverter.cxx.

                                                          {
  return (getBinZ(value) == 0);
}

isOverflowZ()

bool PixelHistoConverter::isOverflowZ ( const float value ) const

inline

Definition at line 44 of file PixelHistoConverter.h.

                                                   {
    return (value >= m_zAxis.max);
  }

setAxis()

bool PixelHistoConverter::setAxis ( Axis & axis, const TAxis * rootAxis )

staticprivate

check if the histogram has equidistant bins

use a threshold for imperfect binning

storing as 1/width to avoid (slow) division in retrieving

Definition at line 105 of file PixelHistoConverter.cxx.

                                                                   {
 
  if (!rootAxis) {
    return false;
  }
 
  axis.nBins = rootAxis->GetNbins();
  axis.min   = rootAxis->GetXmin();
  axis.max   = rootAxis->GetXmax();
 
  if (axis.nBins < 1) {
    return false;
  }

  const float width = rootAxis->GetBinWidth(1);
  for (std::size_t ibin = 2; ibin <= axis.nBins; ++ibin) {
    if (std::abs(rootAxis->GetBinWidth(ibin) - width) > 0.01*width) {
      return false;
    }
  }

  axis.width = 1.*axis.nBins/(axis.max - axis.min);
 
  return true;
}

setHisto1D()

StatusCode PixelHistoConverter::setHisto1D

(

const TH1 *

histo

)

fill the content

Definition at line 20 of file PixelHistoConverter.cxx.

                                                           {
 
  if (!histo) {
    return StatusCode::FAILURE;
  }
 
  if (!setAxis(m_xAxis, histo->GetXaxis())) {
    return StatusCode::FAILURE;
  }

  const std::size_t xSize = m_xAxis.nBins;
  m_content.resize(xSize);
 
  for (std::size_t x = 0; x < xSize; ++x) {
    m_content.at(x) = histo->GetBinContent(x+1);
  }
 
  return StatusCode::SUCCESS;
}

setHisto2D()

StatusCode PixelHistoConverter::setHisto2D

(

const TH2 *

histo

)

fill the content use linearized version for performance reasons

Definition at line 41 of file PixelHistoConverter.cxx.

                                                           {
  if (!histo) {
    return StatusCode::FAILURE;
  }
 
  if (!setAxis(m_xAxis, histo->GetXaxis())) {
    return StatusCode::FAILURE;
  }
  if (!setAxis(m_yAxis, histo->GetYaxis())) {
    return StatusCode::FAILURE;
  }

  const std::size_t xSize = m_xAxis.nBins;
  const std::size_t ySize = m_yAxis.nBins;
  m_content.resize(xSize*ySize);
 
  for (std::size_t x = 0; x < xSize; ++x) {
    for (std::size_t y = 0; y < ySize; ++y) {
      const std::size_t position = x + y*xSize;
      m_content.at(position) = histo->GetBinContent(x+1,y+1);
    }
  }
 
  return StatusCode::SUCCESS;
}

setHisto3D()

StatusCode PixelHistoConverter::setHisto3D

(

const TH3 *

histo

)

fill the content use linearized version for performance reasons

Definition at line 68 of file PixelHistoConverter.cxx.

                                                           {
  if (!histo) {
    return StatusCode::FAILURE;
  }
 
  if (!setAxis(m_xAxis, histo->GetXaxis())) {
    return StatusCode::FAILURE;
  }
  if (!setAxis(m_yAxis, histo->GetYaxis())) {
    return StatusCode::FAILURE;
  }
  if (!setAxis(m_zAxis, histo->GetZaxis())) {
    return StatusCode::FAILURE;
  }

  const std::size_t xSize = m_xAxis.nBins;
  const std::size_t ySize = m_yAxis.nBins;
  const std::size_t zSize = m_zAxis.nBins;
  m_content.resize(xSize*ySize*zSize);
 
  for (std::size_t x = 0; x < xSize; ++x) {
    for (std::size_t y = 0; y < ySize; ++y) {
      for (std::size_t z = 0; z < zSize; ++z) {
        const std::size_t position = x + xSize*(y + (ySize * z));
        m_content.at(position) = histo->GetBinContent(x+1,y+1,z+1);
      }
    }
  }
 
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_content

std::vector<float> PixelHistoConverter::m_content

private

Definition at line 61 of file PixelHistoConverter.h.

m_xAxis

Axis PixelHistoConverter::m_xAxis {}

private

Definition at line 57 of file PixelHistoConverter.h.

{};

m_yAxis

Axis PixelHistoConverter::m_yAxis {}

private

Definition at line 58 of file PixelHistoConverter.h.

{};

m_zAxis

Axis PixelHistoConverter::m_zAxis {}

private

Definition at line 59 of file PixelHistoConverter.h.

{};

---

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

• PixelHistoConverter.h
• PixelHistoConverter.cxx