#include <DataBin.h>

Collaboration diagram for MuonCalib::DataBin:

Public Member Functions
	DataBin ()
	Default constructor. Give a bin with 0 content and no extensions.
	DataBin (const std::vector< DataPoint > &points, const double epsilon)
	Constructor.
	DataBin (const Amg::VectorX &lower_boundaries, const Amg::VectorX &upper_boundaries)
	Constructor.
double	density () const
	get the data point density in the bin
const Amg::VectorX &	centreOfBin () const
	get the centre of the bin
const Amg::VectorX &	lowerBinBoundaries () const
	get the lower boundaries of the bin
const Amg::VectorX &	upperbinBoundaries () const
	get the upper boundaries of the bin
const Amg::VectorX &	centreOfGravity () const
	get the centre of gravity of the data points
const Amg::VectorX &	standardDeviations () const
	get the standard deviations of the data points from the centre of gravity in all dimensions
unsigned int	numberOfDataPoints () const
	get the number of data points
const std::vector< DataPoint > &	dataPoints () const
	get the data points filling this bin
DataBin *	splitBin (const unsigned int &ref_coord)
	divide the bin into two of equal content; splitting is done along the coordinate ref_coord; the method resize the current bin and return the other half (at least 4 points are required for splitting)
bool	addPoint (const DataPoint &point)
	add the data point to the bin if possible; returns true if the point can be added, false otherwise
void	addPointAndResize (const DataPoint &point, const double epsilon)
	add the data point to the bin; the bin will be resized if the point does not fit into the bin; the upper bin boundaries are shifted by epsilon to create a half-open intervall containing all data points
void	setPoints (const std::vector< DataPoint > &points)
	fill the bin with the given points; the use of this method is highly discouraged, it is needed for the splitting whithout changing the bin boundaries

Private Attributes
std::vector< DataPoint >	m_points
Amg::VectorX	m_bin_centre
Amg::VectorX	m_lower_boundaries
Amg::VectorX	m_upper_boundaries
Amg::VectorX	m_centre_of_gravity
Amg::VectorX	m_standard_deviations

Detailed Description

Definition at line 37 of file DataBin.h.

Constructor & Destructor Documentation

◆ DataBin() [1/3]

DataBin::DataBin ( )

Default constructor. Give a bin with 0 content and no extensions.

Definition at line 23 of file DataBin.cxx.

23 {

24}

◆ DataBin() [2/3]

DataBin::DataBin	(	const std::vector< DataPoint > &	points,
		const double	epsilon )

Constructor.

Parameters

points	Data points occupying the bin.
epsilon	The upper bin boundaries are shifted by epsilon to create a half-open intervall containing all data points.

Definition at line 32 of file DataBin.cxx.

                                                                          {
 
    for (unsigned int k=0; k<points.size(); k++) {
        addPointAndResize(points[k], epsilon);
    }
 
}

◆ DataBin() [3/3]

DataBin::DataBin	(	const Amg::VectorX &	lower_boundaries,
		const Amg::VectorX &	upper_boundaries )

Constructor.

Create an empty bin with the given boundaries.

Parameters

lower_boundaries	Lower boundaries of the bin.
upper_boundaries	Upper boundaries of the bin.

Definition at line 46 of file DataBin.cxx.

                                                                             {
// CHECK WHETHER BOUNDARIES DIMENSIONS ARE CONSISTENT //
 
    if (lower_boundaries.rows()!=upper_boundaries.rows()) {
        throw std::runtime_error(Form("File: %s, Line: %d\nDataBin::DataBin - Dimensions of lower and upper bin boundaries disagree.", __FILE__, __LINE__));
    }
// COPY THE BOUNDARIES AND CALCULATE THE BIN CENTRE //
 
    m_lower_boundaries = lower_boundaries;
    m_upper_boundaries = upper_boundaries;
 
    m_bin_centre = 0.5*(m_lower_boundaries+m_upper_boundaries);
 
}

Member Function Documentation

◆ addPoint()

bool DataBin::addPoint ( const DataPoint & point )

add the data point to the bin if possible; returns true if the point can be added, false otherwise

Definition at line 246 of file DataBin.cxx.

                                              {
 
// check whether the point can be added //
    for (int k=0; k<point.dataVector().rows(); k++) {
        if (point.dataVector()[k]<m_lower_boundaries[k] ||
                                point.dataVector()[k]>=m_upper_boundaries[k]) {
            return false;
        }
    }
 
// add the point //
    m_points.push_back(point);
 
// recalculate the centre of gravity and the standard deviations //
    m_centre_of_gravity = point.dataVector();
    m_standard_deviations = point.dataVector();
    for (int k=0; k<m_centre_of_gravity.rows(); k++) {
        m_centre_of_gravity[k] = 0.0;
        m_standard_deviations[k] = 0.0;
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_centre_of_gravity[k] = m_centre_of_gravity[k]+
                                              m_points[l].dataVector()[k];
        }
        m_centre_of_gravity[k] = m_centre_of_gravity[k]/
                                        static_cast<double>(m_points.size());
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_standard_deviations[k] = m_standard_deviations[k]+
                    std::pow(m_points[l].dataVector()[k]-m_centre_of_gravity[k], 2);
        }
        if (m_points.size()>2) {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size()-1);
        } else {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size());
        }
        m_standard_deviations[k] = std::sqrt(m_standard_deviations[k]);
    }
 
    return true;
 
}

◆ addPointAndResize()

void DataBin::addPointAndResize	(	const DataPoint &	point,
		const double	epsilon )

add the data point to the bin; the bin will be resized if the point does not fit into the bin; the upper bin boundaries are shifted by epsilon to create a half-open intervall containing all data points

Definition at line 295 of file DataBin.cxx.

                                                                              {
 
// add the point //
    m_points.push_back(point);
 
// recalculate the centre of gravity and the standard deviations //
    m_centre_of_gravity = point.dataVector();
    m_standard_deviations = point.dataVector();
    for (int k=0; k<m_centre_of_gravity.rows(); k++) {
        m_centre_of_gravity[k] = 0.0;
        m_standard_deviations[k] = 0.0;
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_centre_of_gravity[k] = m_centre_of_gravity[k]+
                                              m_points[l].dataVector()[k];
        }
        m_centre_of_gravity[k] = m_centre_of_gravity[k]/
                                        static_cast<double>(m_points.size());
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_standard_deviations[k] = m_standard_deviations[k]+
                    std::pow(m_points[l].dataVector()[k]-m_centre_of_gravity[k], 2);
        }
        if (m_points.size()>2) {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size()-1);
        } else {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size());
        }
        m_standard_deviations[k] = std::sqrt(m_standard_deviations[k]);
    }
 
// determine the bin boundaries //
    if (m_points.size()==1) {
        m_lower_boundaries = point.dataVector();
        m_upper_boundaries = point.dataVector();
        for (int k=0; k<m_lower_boundaries.rows(); k++) {
            m_lower_boundaries[k]=point.dataVector()[k];
            m_upper_boundaries[k]=point.dataVector()[k]+epsilon;
        }
    } else {
        for (int k=0; k<m_lower_boundaries.rows(); k++) {
            if (m_lower_boundaries[k]<point.dataVector()[k]) {
                m_lower_boundaries[k]=point.dataVector()[k];
            }
            if (m_upper_boundaries[k]>=point.dataVector()[k]) {
                m_upper_boundaries[k]=point.dataVector()[k]+epsilon;
            }
        }
    }
 
// calculate bin centre //
    m_bin_centre = 0.5*(m_lower_boundaries+m_upper_boundaries);
 
    return;
 
}

◆ centreOfBin()

const Amg::VectorX & DataBin::centreOfBin ( ) const

get the centre of the bin

Definition at line 90 of file DataBin.cxx.

                                              {
 
    return m_bin_centre;
 
}

◆ centreOfGravity()

const Amg::VectorX & DataBin::centreOfGravity ( ) const

get the centre of gravity of the data points

Definition at line 126 of file DataBin.cxx.

                                                  {
 
    return m_centre_of_gravity;
 
}

◆ dataPoints()

const std::vector< DataPoint > & DataBin::dataPoints ( ) const

get the data points filling this bin

Definition at line 162 of file DataBin.cxx.

                                                       {
 
    return m_points;
 
}

◆ density()

double DataBin::density ( ) const

get the data point density in the bin

Definition at line 74 of file DataBin.cxx.

                              {
 
    double volume(1.0);
    for (int k=0; k<m_lower_boundaries.cols(); k++) {
        volume = volume*(m_upper_boundaries[k]-m_lower_boundaries[k]);
    }
    return m_points.size()/volume;
 
}

◆ lowerBinBoundaries()

const Amg::VectorX & DataBin::lowerBinBoundaries ( ) const

get the lower boundaries of the bin

Definition at line 102 of file DataBin.cxx.

                                                     {
 
    return m_lower_boundaries;
 
}

◆ numberOfDataPoints()

unsigned int DataBin::numberOfDataPoints ( ) const

get the number of data points

Definition at line 150 of file DataBin.cxx.

                                               {
 
    return m_points.size();
 
}

◆ setPoints()

void DataBin::setPoints ( const std::vector< DataPoint > & points )

fill the bin with the given points; the use of this method is highly discouraged, it is needed for the splitting whithout changing the bin boundaries

Definition at line 358 of file DataBin.cxx.

                                                           {
 
    m_points = points;
 
    if (m_points.empty()) {
        return;
    }
 
// recalculate the centre of gravity and the standard deviations //
    m_centre_of_gravity = m_points[0].dataVector();
    m_standard_deviations = m_points[0].dataVector();
    for (int k=0; k<m_centre_of_gravity.rows(); k++) {
        m_centre_of_gravity[k] = 0.0;
        m_standard_deviations[k] = 0.0;
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_centre_of_gravity[k] = m_centre_of_gravity[k]+
                                              m_points[l].dataVector()[k];
        }
        m_centre_of_gravity[k] = m_centre_of_gravity[k]/
                                        static_cast<double>(m_points.size());
        for (unsigned int l=0; l<m_points.size(); l++) {
            m_standard_deviations[k] = m_standard_deviations[k]+
                    std::pow(m_points[l].dataVector()[k]-m_centre_of_gravity[k], 2);
        }
        if (m_points.size()>2) {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size()-1);
        } else {
            m_standard_deviations[k] = m_standard_deviations[k]/
                                        static_cast<double>(m_points.size());
        }
        m_standard_deviations[k] = std::sqrt(m_standard_deviations[k]);
    }
 
    return;
 
}

◆ splitBin()

DataBin * DataBin::splitBin ( const unsigned int & ref_coord )

divide the bin into two of equal content; splitting is done along the coordinate ref_coord; the method resize the current bin and return the other half (at least 4 points are required for splitting)

Definition at line 174 of file DataBin.cxx.

                                                          {
// CHECK WHETHER THE REFERENCE COORDINATE IS IN THE ALLOWED RANGE //
 
    if (ref_coord>=static_cast<unsigned int >(m_bin_centre.rows())) {
        throw std::runtime_error(Form("File: %s, Line: %d\nDataBin::splitBin - Reference coordinate out of range!", __FILE__, __LINE__));
    }
// CHECK WHETHER THERE ARE AT LEAST 4 DATA POINTS //
 
    if (m_points.size()<4) {
        throw std::runtime_error(Form("File: %s, Line: %d\nDataBin::splitBin - Less than 4 points in the bin!", __FILE__, __LINE__));
    }
// SORT THE DATA POINTS ALONG THE SELECTED COORDINATE AXIS //
 
    for (unsigned int k=0; k<m_points.size(); k++) {
        m_points[k].setReferenceComponent(ref_coord);
    }
 
   sort(m_points.begin(), m_points.end());
// MAKE TWO NEW BINS //
 
// event dividing the splitting position //
    unsigned int k_split((m_points.size()/2)+m_points.size()%2);
 
// bin 1 data //
    Amg::VectorX bin_1_low = m_lower_boundaries;
    Amg::VectorX bin_1_up = m_upper_boundaries;
    bin_1_up[ref_coord] = (m_points[k_split]).dataVector()[ref_coord];
    std::vector<DataPoint> bin_1_points(k_split);
    for (unsigned k=0; k<k_split; k++) {
        bin_1_points[k] = m_points[k];
    }
 
// bin 2 data //
    Amg::VectorX bin_2_low = m_lower_boundaries;
    bin_2_low[ref_coord] = (m_points[k_split]).dataVector()[ref_coord];
    Amg::VectorX bin_2_up = m_upper_boundaries;
    std::vector<DataPoint> bin_2_points(m_points.size()-k_split);
    for (unsigned int k=k_split; k<m_points.size(); k++) {
        bin_2_points[k-k_split] = m_points[k];
    }
 
// create the second bin //
    DataBin *bin_2 = new DataBin(bin_2_low, bin_2_up);
    bin_2->setPoints(bin_2_points);
 
// resize the current bin //
    m_lower_boundaries = std::move(bin_1_low);
    m_upper_boundaries = std::move(bin_2_up);
    setPoints(bin_1_points);
 
    return bin_2;
 
}

◆ standardDeviations()

const Amg::VectorX & DataBin::standardDeviations ( ) const

get the standard deviations of the data points from the centre of gravity in all dimensions

Definition at line 138 of file DataBin.cxx.

                                                     {
 
    return m_standard_deviations;
 
}

◆ upperbinBoundaries()

const Amg::VectorX & DataBin::upperbinBoundaries ( ) const

get the upper boundaries of the bin

Definition at line 114 of file DataBin.cxx.

                                                     {
 
    return m_upper_boundaries;
 
}

Member Data Documentation

◆ m_bin_centre

Amg::VectorX MuonCalib::DataBin::m_bin_centre

private

Definition at line 108 of file DataBin.h.

◆ m_centre_of_gravity

Amg::VectorX MuonCalib::DataBin::m_centre_of_gravity

private

Definition at line 111 of file DataBin.h.

◆ m_lower_boundaries

Amg::VectorX MuonCalib::DataBin::m_lower_boundaries

private

Definition at line 109 of file DataBin.h.

◆ m_points

std::vector<DataPoint> MuonCalib::DataBin::m_points

private

Definition at line 107 of file DataBin.h.

◆ m_standard_deviations

Amg::VectorX MuonCalib::DataBin::m_standard_deviations

private

Definition at line 113 of file DataBin.h.

◆ m_upper_boundaries

Amg::VectorX MuonCalib::DataBin::m_upper_boundaries

private

Definition at line 110 of file DataBin.h.

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

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ DataBin() [1/3]

◆ DataBin() [2/3]

◆ DataBin() [3/3]

Member Function Documentation

◆ addPoint()

◆ addPointAndResize()

◆ centreOfBin()

◆ centreOfGravity()

◆ dataPoints()

◆ density()

◆ lowerBinBoundaries()

◆ numberOfDataPoints()

◆ setPoints()

◆ splitBin()

◆ standardDeviations()

◆ upperbinBoundaries()

Member Data Documentation

◆ m_bin_centre

◆ m_centre_of_gravity

◆ m_lower_boundaries

◆ m_points

◆ m_standard_deviations

◆ m_upper_boundaries