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 (size_t size, size_t bins_x, size_t bins_y, Range x, Range y, size_t zones, const std::vector< double > &max)
	DD4hep_XHistogram (void)
	default CTOR 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...
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...
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.

      : 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
  }

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

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.

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

References m_size.

Referenced by fill().

colormap()

ColorMap* DD4hep_XHistogram::colormap ( void  ) const

inline

access the colormap

Definition at line 98 of file DD4hep_XHistogram.h.

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

References m_colormap.

Referenced by DD4hep_TrackingMaterialPlotter::draw().

fill() [1/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.

                                                                                                         {
  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);
  }
}

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

fill() [2/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.

                                                                                                       {
  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);
  }
}

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

fill() [3/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.

                                                                                             {
  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);
}

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

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

fill() [4/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.

                                                                                                                  {
  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);
}

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

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.

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

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().

normalization()

Histogram* DD4hep_XHistogram::normalization ( void  ) const

inline

access the normalization

Definition at line 95 of file DD4hep_XHistogram.h.

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

References m_normalization.

normalize()

void DD4hep_XHistogram::normalize

(

void

)

normalize the histograms

Definition at line 115 of file DD4hep_XHistogram.cc.

                                      {
  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.;
    }
  }
}

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

Referenced by DD4hep_TrackingMaterialPlotter::normalize().

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.

{ m_minDl = dl; }

References m_minDl.

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.

                                                                                                     {
  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;
}

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().

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().