DD4hep_XHistogram Class Reference

#include <DD4hep_XHistogram.h>

Classes
struct	position

Public Types
typedef TH2I	ColorMap
typedef TH2F	Histogram
typedef std::pair< double, double >	Range

Public Member Functions
ColorMap *	colormap (void) const
	access the colormap More...
	DD4hep_XHistogram (void)
	default CTOR More...
	DD4hep_XHistogram (size_t size, size_t bins_x, size_t bins_y, Range x, Range y, size_t zones, const std::vector< double > &max)
void	fill (double x, double y, const std::vector< double > &weight, double norm)
	fill one point More...
void	fill (double x, double y, const std::vector< double > &weight, double norm, unsigned int colour)
	fill one point and set its color More...
void	fill (const Range &x, const Range &y, const std::vector< double > &weight, double norm)
	fill one segment, normalizing each bin's weight to the fraction of the segment it contains More...
void	fill (const Range &x, const Range &y, const std::vector< double > &weight, double norm, unsigned int colour)
	fill one segment and set its color, normalizing each bin's weight to the fraction of the segment it contains More...
Histogram *	get (size_t h=0) const
	access one of the histograms More...
Histogram *	normalization (void) const
	access the normalization More...
void	normalize (void)
	normalize the histograms More...
void	setMinDl (double dl)

Protected Member Functions
void	check_weight (const std::vector< double > &weight) noexcept(false)
	check the weights passed as an std::vector have the correct size More...
std::vector< position >	splitSegment (Range x, Range y) const
	split a segment into a vector of points More...

Protected Attributes
std::shared_ptr< ColorMap >	m_colormap
std::shared_ptr< Histogram >	m_dummy
std::vector< std::shared_ptr< Histogram > >	m_histograms
double	m_minDl
std::shared_ptr< Histogram >	m_normalization
size_t	m_size
size_t	m_xBins
Range	m_xRange
size_t	m_yBins
Range	m_yRange

Detailed Description

Definition at line 13 of file DD4hep_XHistogram.h.

Member Typedef Documentation

ColorMap

typedef TH2I DD4hep_XHistogram::ColorMap

Definition at line 15 of file DD4hep_XHistogram.h.

Histogram

typedef TH2F DD4hep_XHistogram::Histogram

Definition at line 16 of file DD4hep_XHistogram.h.

Range

typedef std::pair<double, double> DD4hep_XHistogram::Range

Definition at line 17 of file DD4hep_XHistogram.h.

Constructor & Destructor Documentation

DD4hep_XHistogram() [1/2]

DD4hep_XHistogram::DD4hep_XHistogram ( void  )

inline

default CTOR

Definition at line 34 of file DD4hep_XHistogram.h.

      : m_minDl(0.000001),
        m_xRange(),
        m_yRange(),
        m_xBins(),
        m_yBins(),
        m_size(),
        m_histograms(),
        m_normalization(),
        m_colormap(),
        m_dummy() {}

DD4hep_XHistogram() [2/2]

DD4hep_XHistogram::DD4hep_XHistogram ( size_t  size, size_t  bins_x, size_t  bins_y, Range  x, Range  y, size_t  zones, const std::vector< double > &  max  )

inline

Definition at line 47 of file DD4hep_XHistogram.h.

References mps_fire::i, m_colormap, m_histograms, m_normalization, m_size, SiStripPI::max, x, and y.

      : m_minDl(0.000001),
        m_xRange(x),
        m_yRange(y),
        m_xBins(bins_x),
        m_yBins(bins_y),
        m_size(size),
        m_histograms(m_size),
        m_normalization(),
        m_colormap() {
    // setup unnamed ROOT histograms
    for (size_t i = 0; i < m_size; ++i) {
      m_histograms[i].reset(new Histogram(nullptr, nullptr, bins_x, x.first, x.second, bins_y, y.first, y.second));
      m_histograms[i]->SetMinimum(0.);
      m_histograms[i]->SetMaximum(max[i]);
    }
    m_normalization.reset(new Histogram(nullptr, nullptr, bins_x, x.first, x.second, bins_y, y.first, y.second));
    m_colormap.reset(new ColorMap(nullptr, nullptr, bins_x, x.first, x.second, bins_y, y.first, y.second));
    m_colormap->SetMinimum(0);
    m_colormap->SetMaximum(zones);
    Histogram(nullptr, nullptr, 0, 0., 0., 0, 0., 0.);  // make ROOT "forget" about unnamed histograms
  }

Member Function Documentation

check_weight()

void DD4hep_XHistogram::check_weight ( const std::vector< double > &  weight )

inlineprotectednoexcept

check the weights passed as an std::vector have the correct size

Definition at line 121 of file DD4hep_XHistogram.h.

References m_size.

Referenced by fill().

                                                                     {
    // run time check for vector size
    if (weight.size() != m_size)
      throw std::invalid_argument("weight: wrong number of elements");
  }

colormap()

ColorMap* DD4hep_XHistogram::colormap ( void  ) const

inline

access the colormap

Definition at line 98 of file DD4hep_XHistogram.h.

References m_colormap.

Referenced by DD4hep_TrackingMaterialPlotter::draw().

{ return (ColorMap*)m_colormap->Clone(nullptr); }

fill() [1/4]

void DD4hep_XHistogram::fill	(	double	x,
		double	y,
		const std::vector< double > &	weight,
		double	norm
	)

fill one point

Definition at line 70 of file DD4hep_XHistogram.cc.

References check_weight(), HcalObjRepresent::Fill(), h, m_histograms, m_normalization, m_size, x, and y.

Referenced by DD4hep_TrackingMaterialPlotter::plotSegmentInLayer(), and DD4hep_TrackingMaterialPlotter::plotSegmentUnassigned().

                                                                                             {
  check_weight(weight);

  for (size_t h = 0; h < m_size; ++h)
    m_histograms[h]->Fill(x, y, weight[h]);
  m_normalization->Fill(x, y, norm);
}

fill() [2/4]

void DD4hep_XHistogram::fill	(	double	x,
		double	y,
		const std::vector< double > &	weight,
		double	norm,
		unsigned int	colour
	)

fill one point and set its color

Definition at line 79 of file DD4hep_XHistogram.cc.

References check_weight(), HcalObjRepresent::Fill(), nano_mu_digi_cff::float, h, m_colormap, m_histograms, m_normalization, m_size, x, and y.

                                                                                                                  {
  check_weight(weight);

  for (size_t h = 0; h < m_size; ++h)
    m_histograms[h]->Fill(x, y, weight[h]);
  m_normalization->Fill(x, y, norm);
  m_colormap->SetBinContent(m_colormap->FindBin(x, y), (float)colour);
}

fill() [3/4]

void DD4hep_XHistogram::fill	(	const Range &	x,
		const Range &	y,
		const std::vector< double > &	weight,
		double	norm
	)

fill one segment, normalizing each bin's weight to the fraction of the segment it contains

Definition at line 89 of file DD4hep_XHistogram.cc.

References check_weight(), f, HcalObjRepresent::Fill(), h, mps_fire::i, m_histograms, m_normalization, m_size, alignCSCRings::s, splitSegment(), findQualityFiles::v, x, and y.

                                                                                                         {
  check_weight(weight);

  std::vector<position> v = splitSegment(x, y);
  for (size_t i = 0, s = v.size(); i < s; ++i) {
    for (size_t h = 0; h < m_size; ++h)
      m_histograms[h]->Fill(v[i].x, v[i].y, v[i].f * weight[h]);
    m_normalization->Fill(v[i].x, v[i].y, v[i].f * norm);
  }
}

fill() [4/4]

void DD4hep_XHistogram::fill	(	const Range &	x,
		const Range &	y,
		const std::vector< double > &	weight,
		double	norm,
		unsigned int	colour
	)

fill one segment and set its color, normalizing each bin's weight to the fraction of the segment it contains

Definition at line 101 of file DD4hep_XHistogram.cc.

References check_weight(), f, HcalObjRepresent::Fill(), nano_mu_digi_cff::float, h, mps_fire::i, m_colormap, m_histograms, m_normalization, m_size, alignCSCRings::s, splitSegment(), findQualityFiles::v, x, and y.

                                                                                                       {
  check_weight(weight);

  std::vector<position> v = splitSegment(x, y);
  for (size_t i = 0, s = v.size(); i < s; ++i) {
    for (size_t h = 0; h < m_size; ++h)
      m_histograms[h]->Fill(v[i].x, v[i].y, v[i].f * weight[h]);
    m_normalization->Fill(v[i].x, v[i].y, v[i].f * norm);
    m_colormap->SetBinContent(m_colormap->FindBin(v[i].x, v[i].y), (float)colour);
  }
}

get()

Histogram* DD4hep_XHistogram::get ( size_t  h = 0 ) const

inline

access one of the histograms

Definition at line 87 of file DD4hep_XHistogram.h.

References h, m_histograms, and m_size.

Referenced by Options.Options::__getitem__(), betterConfigParser.BetterConfigParser::__updateDict(), submitPVValidationJobs.BetterConfigParser::__updateDict(), DD4hep_TrackingMaterialPlotter::draw(), betterConfigParser.BetterConfigParser::getCompares(), betterConfigParser.BetterConfigParser::getGeneral(), betterConfigParser.BetterConfigParser::getResultingSection(), and submitPVValidationJobs.BetterConfigParser::getResultingSection().

                                     {
    if (h < m_size)
      return (Histogram*)m_histograms[h]->Clone(nullptr);
    else
      return nullptr;
  }

normalization()

Histogram* DD4hep_XHistogram::normalization ( void  ) const

inline

access the normalization

Definition at line 95 of file DD4hep_XHistogram.h.

References m_normalization.

{ return (Histogram*)m_normalization->Clone(nullptr); }

normalize()

void DD4hep_XHistogram::normalize

(

void

)

normalize the histograms

Definition at line 115 of file DD4hep_XHistogram.cc.

References h, mps_fire::i, m_histograms, m_normalization, and m_size.

Referenced by DD4hep_TrackingMaterialPlotter::normalize().

                                      {
  for (int i = 0; i < m_normalization->GetSize(); ++i) {
    if ((*m_normalization)[i] > 0.) {
      for (size_t h = 0; h < m_size; ++h)
        (*m_histograms[h])[i] /= (*m_normalization)[i];
      (*m_normalization)[i] = 1.;
    }
  }
}

setMinDl()

void DD4hep_XHistogram::setMinDl ( double  dl )

inline

set the minimum length of sub-segment a segment should be split into: when splitting across bin boundaries with splitSegment(...), sub-segments shorter than this are skipped

Definition at line 102 of file DD4hep_XHistogram.h.

References m_minDl.

{ m_minDl = dl; }

splitSegment()

std::vector< DD4hep_XHistogram::position > DD4hep_XHistogram::splitSegment ( Range  x, Range  y  ) const

protected

split a segment into a vector of points

Definition at line 7 of file DD4hep_XHistogram.cc.

References reco::ceil(), hgcalPerformanceValidation::df, f, mps_fire::i, createfilelist::int, m_minDl, m_xBins, m_xRange, m_yBins, m_yRange, position, mps_fire::result, alignCSCRings::s, jetUpdater_cfi::sort, customisers::steps, findQualityFiles::v, x, and y.

Referenced by fill().

                                                                                                     {
  double deltaX = rangeX.second - rangeX.first;
  double deltaY = rangeY.second - rangeY.first;
  double length = hypot(deltaX, deltaY);
  double stepX = (m_xRange.second - m_xRange.first) / m_xBins;
  double stepY = (m_yRange.second - m_yRange.first) / m_yBins;

  int min_i, max_i, min_j, max_j;
  if (rangeX.first < rangeX.second) {
    min_i = (int)ceil(rangeX.first / stepX);        // included
    max_i = (int)floor(rangeX.second / stepX) + 1;  // excluded
  } else {
    min_i = (int)ceil(rangeX.second / stepX);
    max_i = (int)floor(rangeX.first / stepX) + 1;
  }
  if (rangeY.first < rangeY.second) {
    min_j = (int)ceil(rangeY.first / stepY);
    max_j = (int)floor(rangeY.second / stepY) + 1;
  } else {
    min_j = (int)ceil(rangeY.second / stepY);
    max_j = (int)floor(rangeY.first / stepY) + 1;
  }

  int steps = max_i - min_i + max_j - min_j + 2;
  std::vector<position> v;
  v.clear();
  v.reserve(steps);

  v.emplace_back(position(0., rangeX.first, rangeY.first));
  double x, y, f;
  for (int i = min_i; i < max_i; ++i) {
    x = i * stepX;
    y = rangeY.first + (x - rangeX.first) * deltaY / deltaX;
    f = std::fabs((x - rangeX.first) / deltaX);
    v.emplace_back(position(f, x, y));
  }
  for (int i = min_j; i < max_j; ++i) {
    y = i * stepY;
    x = rangeX.first + (y - rangeY.first) * deltaX / deltaY;
    f = std::fabs((y - rangeY.first) / deltaY);
    v.emplace_back(position(f, x, y));
  }
  v.emplace_back(position(1., rangeX.second, rangeY.second));

  // sort by distance from the start of the segment
  std::sort(v.begin(), v.end());

  // filter away the fragments shorter than m_minDl, and save the center of each fragment along with its fractionary length
  std::vector<position> result;
  result.emplace_back(v.front());
  for (int i = 1, s = v.size(); i < s; ++i) {
    double mx = (v[i].x + v[i - 1].x) / 2.;
    double my = (v[i].y + v[i - 1].y) / 2.;
    double df = (v[i].f - v[i - 1].f);
    if (df * length < m_minDl)
      continue;
    result.emplace_back(position(df, mx, my));
  }

  return result;
}

Member Data Documentation

m_colormap

std::shared_ptr<ColorMap> DD4hep_XHistogram::m_colormap

protected

Definition at line 29 of file DD4hep_XHistogram.h.

Referenced by colormap(), DD4hep_XHistogram(), and fill().

m_dummy

std::shared_ptr<Histogram> DD4hep_XHistogram::m_dummy

protected

Definition at line 30 of file DD4hep_XHistogram.h.

m_histograms

std::vector<std::shared_ptr<Histogram> > DD4hep_XHistogram::m_histograms

protected

Definition at line 27 of file DD4hep_XHistogram.h.

Referenced by DD4hep_XHistogram(), fill(), get(), and normalize().

m_minDl

double DD4hep_XHistogram::m_minDl

protected

Definition at line 20 of file DD4hep_XHistogram.h.

Referenced by setMinDl(), and splitSegment().

m_normalization

std::shared_ptr<Histogram> DD4hep_XHistogram::m_normalization

protected

Definition at line 28 of file DD4hep_XHistogram.h.

Referenced by DD4hep_XHistogram(), fill(), normalization(), and normalize().

m_size

size_t DD4hep_XHistogram::m_size

protected

Definition at line 25 of file DD4hep_XHistogram.h.

Referenced by check_weight(), DD4hep_XHistogram(), fill(), get(), and normalize().

m_xBins

size_t DD4hep_XHistogram::m_xBins

protected

Definition at line 23 of file DD4hep_XHistogram.h.

Referenced by splitSegment().

m_xRange

Range DD4hep_XHistogram::m_xRange

protected

Definition at line 21 of file DD4hep_XHistogram.h.

Referenced by splitSegment().

m_yBins

size_t DD4hep_XHistogram::m_yBins

protected

Definition at line 24 of file DD4hep_XHistogram.h.

Referenced by splitSegment().

m_yRange

Range DD4hep_XHistogram::m_yRange

protected

Definition at line 22 of file DD4hep_XHistogram.h.

Referenced by splitSegment().