RawDataCollectedMinMax Class Reference

takes care of collecting raw data and staying below RAM-threshold. More...

#include <RawDataCollectedMinMax.h>

Public Member Functions
	RawDataCollectedMinMax (unsigned expectedSize, std::pair< double, double > quantiles, unsigned maxSizeThreshold=100000)
	constructor. please use for quantiles [min, max] min ~0 & max ~1 (range 0-1)
void	add (double newVal)
	adds value to collector.
unsigned	getSampleSize () const
	returns current sample size (which is not the actual size of the container).
std::pair< double, double >	getMinMax ()
	returns current best estimates for min and max cuts.

Protected Attributes
unsigned	m_currentSize
	the current size of the data sample.
unsigned	m_fillIntermediateThreshold
	an internal threshold taking care of collecting intermediate results during sample collection
std::pair< double, double >	m_minMaxQuantiles
	the quantiles to be collected in the end (defined in [0;1])
std::vector< std::pair< double, double > >	m_intermediateValues
	collects intermediate threshold if expected size is too big.
MinMaxCollector< double >	m_collector
	collects raw data in an RAM-saving way.

Detailed Description

takes care of collecting raw data and staying below RAM-threshold.

Definition at line 27 of file RawDataCollectedMinMax.h.

Constructor & Destructor Documentation

RawDataCollectedMinMax()

RawDataCollectedMinMax ( unsigned  expectedSize, std::pair< double, double >  quantiles, unsigned  maxSizeThreshold = 100000  )

inline

constructor. please use for quantiles [min, max] min ~0 & max ~1 (range 0-1)

Definition at line 37 of file RawDataCollectedMinMax.h.

                                                               :
      m_currentSize(0),
      m_fillIntermediateThreshold(std::numeric_limits<unsigned>::max()),
      m_minMaxQuantiles(quantiles),
      m_collector((quantiles.first > (1. - quantiles.second) ? quantiles.first * 2. : (1. - quantiles.second) * 2.))
    {
      if (double(expectedSize) / (double(maxSizeThreshold) * 0.05) > double(maxSizeThreshold))
      { B2FATAL("RawDataCollectedMinMax: expected data to big, can not execute!"); }
 
      if (maxSizeThreshold < expectedSize) {
        m_fillIntermediateThreshold = maxSizeThreshold / 10;
      }
    }

Member Function Documentation

add()

void add ( double  newVal )

inline

adds value to collector.

Definition at line 54 of file RawDataCollectedMinMax.h.

    {
      m_collector.append(newVal);
      m_currentSize++;
 
      // if threshold reached, collect results and fill into intermediate value-container:
      if (m_collector.totalSize() > m_fillIntermediateThreshold) {
        std::pair<double, double> results = m_collector.getMinMax(m_minMaxQuantiles.first, m_minMaxQuantiles.second);
        m_intermediateValues.push_back(std::move(results));
        m_collector.clear();
      }
    }

getMinMax()

std::pair< double, double > getMinMax ( )

inline

returns current best estimates for min and max cuts.

Definition at line 71 of file RawDataCollectedMinMax.h.

    {
      if (m_intermediateValues.empty()) {
        return m_collector.getMinMax(m_minMaxQuantiles.first, m_minMaxQuantiles.second);
      }
 
      // issue: m_collector-sample could be too small and therefore distort results for small intermediateValue-samples. Therefore neglect m_collector for that case.
      if (m_intermediateValues.size() == 1) {
        return { m_intermediateValues.at(0).first, m_intermediateValues.at(0).second};
      }
      if (m_intermediateValues.size() == 2) {
        return {
          0.5 * (m_intermediateValues.at(0).first + m_intermediateValues.at(1).first),
          0.5 * (m_intermediateValues.at(0).second + m_intermediateValues.at(1).second) };
      }
 
      if (!m_collector.empty()) {
        std::pair<double, double> results = m_collector.getMinMax(m_minMaxQuantiles.first, m_minMaxQuantiles.second);
        m_intermediateValues.push_back(results);
      }
 
      unsigned index = std::floor(double(m_intermediateValues.size()) * 0.5);
      double min, max;
 
      std::sort(m_intermediateValues.begin(), m_intermediateValues.end(),
                [](const std::pair<double, double>& a, const std::pair<double, double>& b) -> bool { return a.first < b.first; });
      min = m_intermediateValues.at(index).first;
 
      std::sort(m_intermediateValues.begin(), m_intermediateValues.end(),
                [](const std::pair<double, double>& a, const std::pair<double, double>& b) -> bool { return a.second < b.second; });
      max = m_intermediateValues.at(index).second;
 
      return {min, max};
    }

getSampleSize()

unsigned getSampleSize ( ) const

inline

returns current sample size (which is not the actual size of the container).

Definition at line 68 of file RawDataCollectedMinMax.h.

{ return m_currentSize; }

Member Data Documentation

m_collector

MinMaxCollector<double> m_collector

protected

collects raw data in an RAM-saving way.

Definition at line 33 of file RawDataCollectedMinMax.h.

m_currentSize

unsigned m_currentSize

protected

the current size of the data sample.

Definition at line 29 of file RawDataCollectedMinMax.h.

m_fillIntermediateThreshold

unsigned m_fillIntermediateThreshold

protected

an internal threshold taking care of collecting intermediate results during sample collection

Definition at line 30 of file RawDataCollectedMinMax.h.

m_intermediateValues

std::vector<std::pair<double, double> > m_intermediateValues

protected

collects intermediate threshold if expected size is too big.

Definition at line 32 of file RawDataCollectedMinMax.h.

m_minMaxQuantiles

std::pair<double, double> m_minMaxQuantiles

protected

the quantiles to be collected in the end (defined in [0;1])

Definition at line 31 of file RawDataCollectedMinMax.h.

---

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

• tracking/trackFindingVXD/sectorMapTools/include/RawDataCollectedMinMax.h