#include <BinningData.h>

Collaboration diagram for Trk::BinningData:

Public Member Functions
	BinningData (const BinningData &)=default

	BinningData (BinningData &&)=default

BinningData &	operator= (const BinningData &)=default

BinningData &	operator= (BinningData &&)=default

	~BinningData ()=default

	BinningData (BinningType bType, BinningOption bOption, BinningValue bValue, size_t bBins, float bMin, float bMax, float bStep, float bSubStep=0, std::vector< float > bBoundaries=std::vector< float >())
	Constructor with arguments. More...

	BinningData (BinningOption bOption, float bRefPhi, const std::vector< std::pair< int, float >> &bBoundaries)
	Constructor for binH type : non-equidistant binning assumed. More...

float	value (const Amg::Vector2D &lposition) const
	take the right float value - assumes the correct local position expression More...

float	value (const Amg::Vector3D &position) const
	take the right float value More...

float	gaugePhi (float phi) const
	gauge phi More...

std::pair< float, float >	valueH (const Amg::Vector2D &lposition) const
	take float values for binH More...

std::pair< float, float >	valueH (const Amg::Vector3D &position) const
	take float values for binH More...

bool	inside (const Amg::Vector3D &position) const
	Check if bin is inside from Vector3D. More...

bool	inside (const Amg::Vector2D &lp) const
	Check if bin is inside from Vector2D. More...

size_t	searchLocal (const Amg::Vector2D &lposition) const
	generic search from a 2D position — corresponds to local coordinate schema More...

size_t	searchGlobal (const Amg::Vector3D &position) const
	generic search from a 3D position More...

size_t	search (float value) const
	generic search - forwards to correct function pointer More...

size_t	searchH (std::pair< double, double > value) const
	generic search - forwards to correct function pointer More...

size_t	entry (const Amg::Vector3D &position) const
	the entry bin More...

size_t	next (const Amg::Vector3D &position, const Amg::Vector3D &dir) const
	the next bin : gives -1 if the next one is outside More...

std::pair< size_t, float >	distanceToNext (const Amg::Vector3D &position, const Amg::Vector3D &dir) const
	distance to the next bin : gives -1 if the next one is outside More...

LayerOrder	orderDirection (const Amg::Vector3D &position, const Amg::Vector3D &dir) const
	layer order is needed for value H binning More...

float	binPosition (size_t bin, float pos) const
	bin->BinningValue navigation : pos=+-1. More...

Public Attributes
BinningType	type
	holding all the data for binning calculatuion More...

BinningOption	option

BinningValue	binvalue

size_t	bins

float	min

float	max

float	step

float	subStep

float	refphi

std::vector< float >	boundaries

std::vector< std::pair< int, float > >	hbounds

Static Private Member Functions
static size_t	searchEaquidstantWithBoundary (float value, const BinningData &bData)
	Equidistant search : equidist 0. More...

static size_t	searchBiequidistantWithBoundary (float value, const BinningData &bData)
	Biequidistant search : biequidist 1. More...

static size_t	searchInVectorWithBoundary (float value, const BinningData &bData)
	Linear search in vector - superior in O(10) searches: arbitraty 2. More...

static size_t	binarySearchWithBoundary (float value, const BinningData &bData)
	A binary search with underflow/overflow - faster than vector search for O(50) objects. More...

static size_t	searchInVectorWithMixedBoundary (std::pair< float, float > val, const BinningData &bData)
	Search in mixed vector - linear in O-10 bins, otherwise binary. More...

Private Attributes
size_t(*	m_functionPtr )(float, const BinningData &)
	the pointer to the function to be used More...

size_t(*	m_mixPtr )(std::pair< float, float >, const BinningData &)

Detailed Description

This class holds all the data necessary for the bin calculation

phi has a very particular behaviour:

there's the change around +/- PI

Author: Andreas.Salzburger @ cern.ch, Sharka.Todorova @ cern.ch

Definition at line 46 of file BinningData.h.

Constructor & Destructor Documentation

◆ BinningData() [1/4]

Trk::BinningData::BinningData ( const BinningData & )

default

◆ BinningData() [2/4]

Trk::BinningData::BinningData ( BinningData && )

default

◆ ~BinningData()

Trk::BinningData::~BinningData ( )

default

◆ BinningData() [3/4]

Trk::BinningData::BinningData	(	BinningType	bType,
		BinningOption	bOption,
		BinningValue	bValue,
		size_t	bBins,
		float	bMin,
		float	bMax,
		float	bStep,
		float	bSubStep = `0`,
		std::vector< float >	bBoundaries = `std::vector<float>()`
	)

inline

Constructor with arguments.

Definition at line 70 of file BinningData.h.

     : type(bType)
     , option(bOption)
     , binvalue(bValue)
     , bins(bBins)
     , min(bMin)
     , max(bMax)
     , step(bStep != 0. ? bStep : 1.)
     , subStep(bSubStep)
     , refphi(0.)
     , boundaries(std::move(bBoundaries))
     , hbounds(std::vector<std::pair<int, float>>())
     , m_mixPtr(nullptr)
   {
     if (bType == Trk::equidistant)
       m_functionPtr = &searchEaquidstantWithBoundary;
     else if (bType == Trk::biequidistant)
       m_functionPtr = &searchBiequidistantWithBoundary;
     else
       m_functionPtr = bins < 50 ? &searchInVectorWithBoundary : &binarySearchWithBoundary;
   }

◆ BinningData() [4/4]

Trk::BinningData::BinningData	(	BinningOption	bOption,
		float	bRefPhi,
		const std::vector< std::pair< int, float >> &	bBoundaries
	)

inline

Constructor for binH type : non-equidistant binning assumed.

Definition at line 101 of file BinningData.h.

     : type(Trk::arbitrary)
     , option(bOption)
     , binvalue(Trk::binH)
     , bins(bOption == Trk::open ? bBoundaries.size() - 1 : bBoundaries.size())
     , min(bBoundaries.front().second)
     , max(bBoundaries.back().second)
     , step(1.)
     , subStep(0.) // non-zero value needed for next()
     , refphi(bRefPhi)
     , boundaries(std::vector<float>())
     , hbounds(bBoundaries)
     , m_functionPtr(nullptr)
     , m_mixPtr(&searchInVectorWithMixedBoundary)
   {}

Member Function Documentation

◆ binarySearchWithBoundary()

static size_t Trk::BinningData::binarySearchWithBoundary	(	float	value,
		const BinningData &	bData
	)

inlinestaticprivate

A binary search with underflow/overflow - faster than vector search for O(50) objects.

Definition at line 384 of file BinningData.h.

   {
     // Binary search in an array of n values to locate value
     if (bData.binvalue == binPhi)
       while (value < bData.boundaries[0])
         value += 2 * acos(-1.);
     if (bData.binvalue == binPhi)
       while (value > bData.max)
         value -= 2 * acos(-1.);
     // underflow
     if (value <= bData.boundaries[0])
       return (bData.option == closed) ? (bData.bins - 1) : 0;
     size_t nabove;
     size_t nbelow;
     size_t middle;
     // overflow
     nabove = bData.boundaries.size() + 1;
     if (value >= bData.max)
       return (bData.option == closed) ? 0 : nabove - 2;
     // binary search
     nbelow = 0;
     while (nabove - nbelow > 1) {
       middle = (nabove + nbelow) / 2;
       if (value == bData.boundaries[middle - 1])
         return middle - 1;
       if (value < bData.boundaries[middle - 1])
         nabove = middle;
       else
         nbelow = middle;
     }
     return nbelow - 1;
   }

◆ binPosition()

float Trk::BinningData::binPosition	(	size_t	bin,
		float	pos
	)		const

inline

bin->BinningValue navigation : pos=+-1.

edges/ 0. bin center

Definition at line 305 of file BinningData.h.

   {
  
     if (type == Trk::equidistant)
       return (min + (2. * bin + pos + 1.) * step / 2.);
  
     float bmin = (binvalue == Trk::binH) ? hbounds[bin].second : boundaries[bin];
     float bmax = (binvalue == Trk::binH) ? hbounds[bin + 1].second
                                          : bin + 1 < boundaries.size() ? boundaries[bin + 1] : boundaries[bin] + step;
  
     return (bmin + 0.5 * (pos + 1.) * (bmax - bmin));
   }

◆ distanceToNext()

std::pair<size_t, float> Trk::BinningData::distanceToNext	(	const Amg::Vector3D &	position,
		const Amg::Vector3D &	dir
	)		const

inline

distance to the next bin : gives -1 if the next one is outside

Definition at line 250 of file BinningData.h.

   {
     // current value
     float val = (binvalue == Trk::binH) ? valueH(position).first : value(position);
     // probe value
     Amg::Vector3D probe = position + 0.5 * step * dir.normalized();
     float nextval = (binvalue == Trk::binH) ? valueH(probe).first : value(probe);
     // current bin
     int bin0 = (binvalue == Trk::binH) ? searchH(valueH(position)) : search(val);
     // next bin
     int bin = (nextval - val) > 0. ? bin0 + 1 : bin0 - 1;
     if (bin > int(bins) - 1)
       bin = (option == closed) ? 0 : bin0;
     if (bin < 0)
       bin = (option == closed) ? bins - 1 : 0;
  
     // boundary value
     float bval = 0.;
     if (binvalue == Trk::binH) {
       bval = (nextval > val) ? hbounds[bin0 + 1].second : hbounds[bin0].second; // non-equidistant
  
       // may need to recalculate current value and probe
       if (nextval > val) {
         if (hbounds[bin0 + 1].first > 0) {
           val = valueH(position).second;
           nextval = valueH(probe).second;
         }
       } else {
         if (hbounds[bin0].first > 0) {
           val = valueH(position).second;
           nextval = valueH(probe).second;
         }
       }
     } else {
       bval = (nextval > val) ? boundaries[bin0 + 1] : boundaries[bin0]; // non-equidistant
       if (type == Trk::equidistant)
         bval = min + bin0 * step;
     }
     // differential
     float dd = 2 * (nextval - val) / step;
     // distance estimate
     float dist = std::fabs(dd) > 1.e-06 ? (bval - val) / dd : 1.e06;
     return std::pair<size_t, float>(bin, dist);
   }

◆ entry()

size_t Trk::BinningData::entry ( const Amg::Vector3D & position ) const

inline

the entry bin

Definition at line 228 of file BinningData.h.

   {
     size_t bin = (binvalue == Trk::binH) ? searchH(valueH(position)) : search(value(position));
     return (bin < bins - bin) ? bin : bins - 1;
   }

◆ gaugePhi()

float Trk::BinningData::gaugePhi ( float phi ) const

inline

gauge phi

Definition at line 147 of file BinningData.h.

   {
     if (max > M_PI && phi < min && phi < 0.) {
       phi = M_PI + phi;
       phi += M_PI;
     }
     return phi;
   }

◆ inside() [1/2]

bool Trk::BinningData::inside ( const Amg::Vector2D & lp ) const

inline

Check if bin is inside from Vector2D.

Definition at line 187 of file BinningData.h.

   {
     if (option == Trk::closed)
       return true;
     if (binvalue != Trk::binH) {
       float val = value(lp);
       return (val > min - 0.001 && val < max + 0.001);
     }
     std::pair<double, double> valH = valueH(lp);
     float valmin = hbounds.front().first == 0 ? valH.first : valH.second;
     float valmax = hbounds.back().first == 0 ? valH.first : valH.second;
     return (valmin > min - 0.001 && valmax < max + 0.001);
   }

◆ inside() [2/2]

bool Trk::BinningData::inside ( const Amg::Vector3D & position ) const

inline

Check if bin is inside from Vector3D.

Definition at line 169 of file BinningData.h.

   {
     // closed one is always inside
     if (option == Trk::closed)
       return true;
     // all other options except value H
     if (binvalue != Trk::binH) {
       float val = value(position);
       return (val > min - 0.001 && val < max + 0.001);
     }
     // value H case
     std::pair<double, double> valH = valueH(position);
     float valmin = hbounds.front().first == 0 ? valH.first : valH.second;
     float valmax = hbounds.back().first == 0 ? valH.first : valH.second;
     return (valmin > min - 0.001 && valmax < max + 0.001);
   }

◆ next()

size_t Trk::BinningData::next	(	const Amg::Vector3D &	position,
		const Amg::Vector3D &	dir
	)		const

inline

the next bin : gives -1 if the next one is outside

Definition at line 235 of file BinningData.h.

   {
     float val = value(position);
     Amg::Vector3D probe = position + 0.5 * step * dir.normalized();
     float nextval = value(probe);
     int bin = (binvalue == Trk::binH) ? searchH(valueH(position)) : search(val);
     bin = (nextval > val && bin != int(bins - 1)) ? bin + 1 : (bin) ? bin - 1 : 0;
     // closed setup
     if (option == closed)
       return (bin < 0 || bin + 1 > int(bins)) ? ((bin < 0) ? bins - 1 : 0) : bin;
     // open setup
     return bin;
   }

◆ operator=() [1/2]

BinningData& Trk::BinningData::operator= ( BinningData && )

default

◆ operator=() [2/2]

BinningData& Trk::BinningData::operator= ( const BinningData & )

default

◆ orderDirection()

LayerOrder Trk::BinningData::orderDirection	(	const Amg::Vector3D &	position,
		const Amg::Vector3D &	dir
	)		const

inline

layer order is needed for value H binning

Definition at line 296 of file BinningData.h.

   {
     float val = (binvalue == Trk::binH) ? valueH(position).first : value(position);
     Amg::Vector3D probe = position + 0.5 * step * dir.normalized();
     float nextval = (binvalue == Trk::binH) ? valueH(probe).first : value(probe);
     return (nextval > val) ? Trk::next : Trk::previous;
   }

◆ search()

size_t Trk::BinningData::search ( float value ) const

inline

generic search - forwards to correct function pointer

Definition at line 214 of file BinningData.h.

   {
     assert(m_functionPtr != nullptr);
     return (*m_functionPtr)(value, *this);
   }

◆ searchBiequidistantWithBoundary()

static size_t Trk::BinningData::searchBiequidistantWithBoundary	(	float	value,
		const BinningData &	bData
	)

inlinestaticprivate

Biequidistant search : biequidist 1.

Definition at line 340 of file BinningData.h.

   {
     // the easy exits (first / last)
     if (value < bData.min)
       return (bData.option == closed) ? (bData.bins - 1) : 0;
     if (value > bData.max)
       return (bData.option == closed) ? 0 : (bData.bins - 1);
     // special treatment for first and last bin
     if (value > bData.max - bData.step)
       return bData.bins - 1;
     // decide the leading bin number (low leading bin)
     size_t leadbin = int((value - bData.min) / bData.step);
     float bDist = value - (bData.min + (leadbin + 1) * bData.step);
     int addon = int(bDist / bData.subStep) ? 0 : 1;
     // return the bin
     return leadbin * 2 + addon;
   }

◆ searchEaquidstantWithBoundary()

static size_t Trk::BinningData::searchEaquidstantWithBoundary	(	float	value,
		const BinningData &	bData
	)

inlinestaticprivate

Equidistant search : equidist 0.

Definition at line 324 of file BinningData.h.

   {
     int bin = ((value - bData.min) / bData.step);
     // special treatment of the 0 bin for closed
     if (bData.option == closed) {
       if (value < bData.min)
         return (bData.bins - 1);
       if (value > bData.max)
         return 0;
     }
     // if outside boundary : return boundary for open, opposite bin for closed
     bin = bin < 0 ? ((bData.option == Trk::open) ? 0 : (bData.bins - 1)) : bin;
     return size_t((bin <= int(bData.bins - 1)) ? bin : ((bData.option == open) ? (bData.bins - 1) : 0));
   }

◆ searchGlobal()

size_t Trk::BinningData::searchGlobal ( const Amg::Vector3D & position ) const

inline

generic search from a 3D position

Definition at line 208 of file BinningData.h.

   {
     return (binvalue == Trk::binH) ? searchH(valueH(position)) : search(value(position));
   }

◆ searchH()

size_t Trk::BinningData::searchH ( std::pair< double, double > value ) const

inline

generic search - forwards to correct function pointer

Definition at line 221 of file BinningData.h.

   {
     assert(m_mixPtr != nullptr);
     return (*m_mixPtr)(value, *this);
   }

◆ searchInVectorWithBoundary()

static size_t Trk::BinningData::searchInVectorWithBoundary	(	float	value,
		const BinningData &	bData
	)

inlinestaticprivate

Linear search in vector - superior in O(10) searches: arbitraty 2.

Definition at line 359 of file BinningData.h.

   {
     if (bData.binvalue == binPhi)
       while (value < bData.boundaries[0])
         value += 2 * M_PI;
     if (bData.binvalue == binPhi)
       while (value > bData.max)
         value -= 2 * M_PI;
     // lower boundary
     if (value <= bData.boundaries[0]) {
       return (bData.option == closed) ? (bData.bins - 1) : 0;
     }
     // higher boundary
     if (value >= bData.max)
       return (bData.option == closed) ? 0 : (bData.bins - 1);
     // search
     std::vector<float>::const_iterator vIter = bData.boundaries.begin();
     size_t bin = 0;
     for (; vIter != bData.boundaries.end(); ++vIter, ++bin)
       if ((*vIter) > value)
         break;
     return (bin - 1);
   }

◆ searchInVectorWithMixedBoundary()

static size_t Trk::BinningData::searchInVectorWithMixedBoundary	(	std::pair< float, float >	val,
		const BinningData &	bData
	)

inlinestaticprivate

Search in mixed vector - linear in O-10 bins, otherwise binary.

Definition at line 418 of file BinningData.h.

   {
     if ((bData.hbounds[0].first == 0 ? val.first : val.second) < bData.hbounds[0].second)
       return (bData.option == closed) ? (bData.bins - 1) : 0;
     if ((bData.hbounds.back().first == 0 ? val.first : val.second) >= bData.max)
       return (bData.option == closed) ? 0 : (bData.bins - 1);
  
     if (bData.hbounds.size() < 10) {
       std::vector<std::pair<int, float>>::const_iterator vBeg = bData.hbounds.begin();
       std::vector<std::pair<int, float>>::const_iterator vIter = vBeg + 1;
       for (; vIter != bData.hbounds.end(); ++vIter)
         if ((*vIter).second > ((*vIter).first == 0 ? val.first : val.second))
           break;
       return (vIter != bData.hbounds.end() ? vIter - vBeg - 1 : bData.bins - 1);
     }
  
     // Binary search in an array of n values to locate value
     size_t nabove;
     size_t nbelow;
     size_t middle;
     nabove = bData.hbounds.size();
     // binary search
     nbelow = 0;
     while (nabove - nbelow > 1) {
       middle = (nabove + nbelow) / 2;
       float valm = bData.hbounds[middle].first == 0 ? val.first : val.second;
       if (valm == bData.hbounds[middle].second) {
         nbelow = middle;
         break;
       }
       if (valm < bData.hbounds[middle].second)
         nabove = middle;
       else
         nbelow = middle;
     }
  
     if (nbelow > bData.bins - 1)
       return bData.bins - 1;
     return nbelow;
   }

◆ searchLocal()

size_t Trk::BinningData::searchLocal ( const Amg::Vector2D & lposition ) const

inline

generic search from a 2D position — corresponds to local coordinate schema

Definition at line 202 of file BinningData.h.

   {
     return (binvalue == Trk::binH) ? searchH(valueH(lposition)) : search(value(lposition));
   }

◆ value() [1/2]

float Trk::BinningData::value ( const Amg::Vector2D & lposition ) const

inline

take the right float value - assumes the correct local position expression

Definition at line 120 of file BinningData.h.

   {
     // ordered after occurence
     if (binvalue == Trk::binR || binvalue == Trk::binRPhi || binvalue == Trk::binX || binvalue == Trk::binH)
       return lposition[0];
     if (binvalue == Trk::binPhi)
       return gaugePhi(lposition[1]);
     return lposition[1];
   }

◆ value() [2/2]

float Trk::BinningData::value ( const Amg::Vector3D & position ) const

inline

take the right float value

Definition at line 131 of file BinningData.h.

   {
     // ordered after occurence
     if (binvalue == Trk::binR || binvalue == Trk::binH)
       return (position.perp());
     if (binvalue == Trk::binRPhi)
       return (position.perp() * position.phi());
     if (binvalue == Trk::binEta)
       return (position.eta());
     if (binvalue < 3)
       return (position[binvalue]);
     // phi gauging
     return gaugePhi(position.phi());
   }

◆ valueH() [1/2]

std::pair<float, float> Trk::BinningData::valueH ( const Amg::Vector2D & lposition ) const

inline

take float values for binH

Definition at line 157 of file BinningData.h.

   {
     return (std::pair<double, double>(lposition[0], lposition[0] * cos(fabs(refphi - lposition[1]))));
   }

◆ valueH() [2/2]

std::pair<float, float> Trk::BinningData::valueH ( const Amg::Vector3D & position ) const

inline

take float values for binH

Definition at line 163 of file BinningData.h.

   {
     return (std::pair<double, double>(position.perp(), position.perp() * cos(fabs(position.phi() - refphi))));
   }

Member Data Documentation

◆ bins

size_t Trk::BinningData::bins

Definition at line 53 of file BinningData.h.

◆ binvalue

BinningValue Trk::BinningData::binvalue

Definition at line 52 of file BinningData.h.

◆ boundaries

std::vector<float> Trk::BinningData::boundaries

Definition at line 59 of file BinningData.h.

◆ hbounds

std::vector<std::pair<int, float> > Trk::BinningData::hbounds

Definition at line 60 of file BinningData.h.

◆ m_functionPtr

size_t(* Trk::BinningData::m_functionPtr) (float, const BinningData &)

private

the pointer to the function to be used

Definition at line 320 of file BinningData.h.

◆ m_mixPtr

size_t(* Trk::BinningData::m_mixPtr) (std::pair< float, float >, const BinningData &)

private

Definition at line 321 of file BinningData.h.

◆ max

float Trk::BinningData::max

Definition at line 55 of file BinningData.h.

◆ min

float Trk::BinningData::min

Definition at line 54 of file BinningData.h.

◆ option

BinningOption Trk::BinningData::option

Definition at line 51 of file BinningData.h.

◆ refphi

float Trk::BinningData::refphi

Definition at line 58 of file BinningData.h.

◆ step

float Trk::BinningData::step

Definition at line 56 of file BinningData.h.

◆ subStep

float Trk::BinningData::subStep

Definition at line 57 of file BinningData.h.

◆ type

BinningType Trk::BinningData::type

holding all the data for binning calculatuion

Definition at line 50 of file BinningData.h.

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

BinningData.h

Public Member Functions

Public Attributes

Static Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ BinningData() [1/4]

◆ BinningData() [2/4]

◆ ~BinningData()

◆ BinningData() [3/4]

◆ BinningData() [4/4]

Member Function Documentation

◆ binarySearchWithBoundary()

◆ binPosition()

◆ distanceToNext()

◆ entry()

◆ gaugePhi()

◆ inside() [1/2]

◆ inside() [2/2]

◆ next()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ orderDirection()

◆ search()

◆ searchBiequidistantWithBoundary()

◆ searchEaquidstantWithBoundary()

◆ searchGlobal()

◆ searchH()

◆ searchInVectorWithBoundary()

◆ searchInVectorWithMixedBoundary()

◆ searchLocal()

◆ value() [1/2]

◆ value() [2/2]

◆ valueH() [1/2]

◆ valueH() [2/2]

Member Data Documentation

◆ bins

◆ binvalue

◆ boundaries

◆ hbounds

◆ m_functionPtr

◆ m_mixPtr

◆ max

◆ min

◆ option

◆ refphi

◆ step

◆ subStep

◆ type