Trk::BinningData Class Reference

This class holds all the data necessary for the bin calculation. More...

#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.
	BinningData (BinningOption bOption, float bRefPhi, const std::vector< std::pair< int, float > > &bBoundaries)
	Constructor for binH type : non-equidistant binning assumed.
float	value (const Amg::Vector2D &lposition) const
	take the right float value - assumes the correct local position expression
float	value (const Amg::Vector3D &position) const
	take the right float value
float	gaugePhi (float phi) const
	gauge phi
std::pair< float, float >	valueH (const Amg::Vector2D &lposition) const
	take float values for binH
std::pair< float, float >	valueH (const Amg::Vector3D &position) const
	take float values for binH
bool	inside (const Amg::Vector3D &position) const
	Check if bin is inside from Vector3D.
bool	inside (const Amg::Vector2D &lp) const
	Check if bin is inside from Vector2D.
size_t	searchLocal (const Amg::Vector2D &lposition) const
	generic search from a 2D position — corresponds to local coordinate schema
size_t	searchGlobal (const Amg::Vector3D &position) const
	generic search from a 3D position
size_t	search (float value) const
	generic search - forwards to correct function pointer
size_t	searchH (std::pair< double, double > value) const
	generic search - forwards to correct function pointer
size_t	entry (const Amg::Vector3D &position) const
	the entry bin
size_t	next (const Amg::Vector3D &position, const Amg::Vector3D &dir) const
	the next bin : gives -1 if the next one is outside
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
LayerOrder	orderDirection (const Amg::Vector3D &position, const Amg::Vector3D &dir) const
	layer order is needed for value H binning
float	binPosition (size_t bin, float pos) const
	bin->BinningValue navigation : pos=+-1.

Public Attributes
BinningType	type
	holding all the data for binning calculatuion
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.
static size_t	searchBiequidistantWithBoundary (float value, const BinningData &bData)
	Biequidistant search : biequidist 1.
static size_t	searchInVectorWithBoundary (float value, const BinningData &bData)
	Linear search in vector - superior in O(10) searches: arbitraty 2.
static size_t	binarySearchWithBoundary (float value, const BinningData &bData)
	A binary search with underflow/overflow - faster than vector search for O(50) objects.
static size_t	searchInVectorWithMixedBoundary (std::pair< float, float > val, const BinningData &bData)
	Search in mixed vector - linear in O-10 bins, otherwise binary.

Private Attributes
size_t(*	m_functionPtr )(float, const BinningData &)
	the pointer to the function to be used
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 48 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 72 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 103 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()

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 394 of file BinningData.h.

  {
    if (bData.boundaries.empty())[[unlikely]]{
      throw std::runtime_error("binarySearchWithBoundary: boundaries vector is empty.");
    }
    // Binary search in an array of n values to locate value
    if (bData.binvalue == binPhi)
      while (value < bData.boundaries[0])
        value += 2.f * std::numbers::pi_v<float>;
    if (bData.binvalue == binPhi)
      while (value > bData.max)
        value -= 2.f * std::numbers::pi_v<float>;
    // underflow
    if (value <= bData.boundaries[0])
      return (bData.option == closed) ? (bData.bins - 1) : 0;
    // overflow
    if (value >= bData.max)
      return (bData.option == closed) ? 0 : bData.boundaries.size() - 1; 
    const auto it = std::ranges::upper_bound(bData.boundaries, value);
    return std::distance(bData.boundaries.begin(), it) - 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 307 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 252 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 230 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 149 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 189 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 171 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 237 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 298 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 216 of file BinningData.h.

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

searchBiequidistantWithBoundary()

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

inlinestaticprivate

Biequidistant search : biequidist 1.

Definition at line 342 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()

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

inlinestaticprivate

Equidistant search : equidist 0.

Definition at line 326 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 210 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 223 of file BinningData.h.

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

searchInVectorWithBoundary()

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 361 of file BinningData.h.

  {
    if (bData.boundaries.empty())[[unlikely]]{
      throw std::runtime_error("searchInVectorWithBoundary: boundaries vector is empty.");
    }
    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;
      }
    }
    //overflow (i.e. bin == 0) can only happen if the boundaries vector is empty, 
    //which is already checked
    //coverity[INTEGER_OVERFLOW]
    return (bin - 1);
  }

searchInVectorWithMixedBoundary()

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 417 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 204 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 122 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 133 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 159 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 165 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 55 of file BinningData.h.

binvalue

BinningValue Trk::BinningData::binvalue

Definition at line 54 of file BinningData.h.

boundaries

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

Definition at line 61 of file BinningData.h.

hbounds

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

Definition at line 62 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 322 of file BinningData.h.

m_mixPtr

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

private

Definition at line 323 of file BinningData.h.

max

float Trk::BinningData::max

Definition at line 57 of file BinningData.h.

min

float Trk::BinningData::min

Definition at line 56 of file BinningData.h.

option

BinningOption Trk::BinningData::option

Definition at line 53 of file BinningData.h.

refphi

float Trk::BinningData::refphi

Definition at line 60 of file BinningData.h.

step

float Trk::BinningData::step

Definition at line 58 of file BinningData.h.

subStep

float Trk::BinningData::subStep

Definition at line 59 of file BinningData.h.

type

BinningType Trk::BinningData::type

holding all the data for binning calculatuion

Definition at line 52 of file BinningData.h.

---

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

• BinningData.h