CompactSecIDs Class Reference

This class provides a computer convenient numbering scheme for the sectors in the sector map and for the N sectors combinations. More...

#include <CompactSecIDs.h>

Public Types
typedef uint16_t	sectorID_t
	Typedef of the compact Id for a single sector.
typedef uint32_t	secPairID_t
	Typedef of the compact Id for a 2 sectors combination.
typedef uint64_t	secTripletID_t
	Typedef of the compact Id for a 3 sectors combination.
typedef uint64_t	secQuadrupletID_t
	Typedef of the compact Id for a 4 sectors combination.
typedef std::vector< SectorsOnSensor< sectorID_t > >	SensorsOnLadder_t
	Typedef for vector of IDs of sectors on a sensors.
typedef std::vector< SensorsOnLadder_t >	LaddersOnLayer_t
	Typedef for vector of vector of IDs of sectors on a Ladder.
typedef std::vector< LaddersOnLayer_t >	LayersLookUpTable_t
	Typedef for vector of vector of vector of IDs of sectors on a layer.

Public Member Functions
	CompactSecIDs ()
	The constructor have just to set the internal counter to 0.
	~CompactSecIDs ()
	The destructor is quite trivial: nothing special to delete.
int	getSize () const
	Returns the number of sectors defined so far.
unsigned int	getAvailableSlots () const
	Returns the available number of sector that can be defined now.
int	addSectors (const std::vector< double > &normalizedUsup, const std::vector< double > &normalizedVsup, const std::vector< std::vector< FullSecID > > &fullSecIDs)
	This method defines all the sectors on a given sensor.
sectorID_t	getCompactID (const FullSecID &fullID) const
	Returns the compact id of the FullSecID It does not throw exceptions (at least it should not).
SectorsOnSensor< sectorID_t >	getSectorsOnSensor (unsigned layer, unsigned ladder, unsigned sensor) const
	Getter for IDs of all sectors on a sensor.
	BELLE2_DEFINE_EXCEPTION (unboundedNormalizedU, "On layer:%1% ladder:%2% sensor:%3% abnormal U=%4$")
	Exception for normalized coordinate U out of bound [0,1].
	BELLE2_DEFINE_EXCEPTION (unboundedNormalizedV, "On layer:%1% ladder:%2% sensor:%3% abnormal V=%4$")
	Exception for normalized coordinate V out of bound [0,1].
FullSecID	getFullSecID (VxdID aSensorID, double normalizedU, double normalizedV) const
	Returns a fullSecID for given sensor and pair of coordinates.
sectorID_t	operator[] (const FullSecID &fullID) const
	Returns the compact id of the FullSecID fullID.
secPairID_t	getCompactID (const FullSecID &id1, const FullSecID &id2) const
	Returns the compact id of the pair of FullSecID id1 id2.
secTripletID_t	getCompactID (const FullSecID &id1, const FullSecID &id2, const FullSecID &id3) const
	Returns the compact id of the triplet of FullSecID id1 id2 id3.
secQuadrupletID_t	getCompactID (const FullSecID &id1, const FullSecID &id2, const FullSecID &id3, const FullSecID &id4) const
	Returns the compact id of the quadruplet of FullSecID id1 id2 id3 id4 If any of the id1, id2, id3 or id4 is undefined 0 is returned.
sectorID_t	getCompactIDFastAndDangerous (const FullSecID &fullID) const
	Fast (and potentially dangerous) equivalent of getCompactID.
bool	areCoordinatesValid (VxdID aSensorID, double normalizedU, double normalizedV) const
	JKL: returns true if operator() will not throw an exception.
const LayersLookUpTable_t &	getCompactSectorsIDMap () const
	Get access to the whole map.
int	nOfLayers (void) const
	get the number of layers in this CompactSecIDs
int	nOfLadders (int layer) const
	get the number of ladders on
int	nOfSensors (int layer, int ladder) const
	get the number of sensors on
bool	setSubLayerID (FullSecID &sector, int sublayer)
	set the SublayerID of the sector

Static Public Member Functions
static void	extractCompactID (secPairID_t pair_id, sectorID_t &id1, sectorID_t &id2)
	Uses the values coded by the Sector Pair ID pair_id and sets the two compact Sector ids id1 and id2.
static void	extractCompactID (secTripletID_t triplet_id, sectorID_t &id1, sectorID_t &id2, sectorID_t &id3)
	Uses the values coded by the Sector Pair ID to set the three compact sector ids.

Private Member Functions
template<class TContainer , class ... Indexes>
int	privateAddSectors (TContainer &container, const std::vector< double > &normalizedUsup, const std::vector< double > &normalizedVsup, const std::vector< std::vector< FullSecID > > &fullSecIDs, short unsigned int index, Indexes ... indexes)
	The hidden private method that recursively manage the size of everything.
int	privateAddSectors (SectorsOnSensor< sectorID_t > &sectors, const std::vector< double > &normalizedUsup, const std::vector< double > &normalizedVsup, const std::vector< std::vector< FullSecID > > &fullSecIDs)
	The hidden private method that end the recursion.
template<class TContainer , class ... Indexes>
sectorID_t	privateGetCompactID (const TContainer &container, short unsigned int index, Indexes ... indexes) const
	The hidden private method that recursively descend the layer, ladder, sensor stack and returns the compactID of a given fullSecID.
template<class TContainer >
sectorID_t	privateGetCompactID (const TContainer &container, short unsigned int index) const
	The hidden private method that close the recursion.

Private Attributes
sectorID_t	m_sectorCounter
	Counter for sectors.
LayersLookUpTable_t	m_compactSectorsIDMap
	Lookup table containing all sectorIDs.

Detailed Description

This class provides a computer convenient numbering scheme for the sectors in the sector map and for the N sectors combinations.

Sectors are labeled with consecutives numbers starting from 1. Methods are provided to convert the fullSecIds (human readable) to compactSecIDs (computer convenient) back and forth.

Definition at line 28 of file CompactSecIDs.h.

Member Typedef Documentation

LaddersOnLayer_t

typedef std::vector<SensorsOnLadder_t> LaddersOnLayer_t

Typedef for vector of vector of IDs of sectors on a Ladder.

Definition at line 315 of file CompactSecIDs.h.

LayersLookUpTable_t

typedef std::vector<LaddersOnLayer_t> LayersLookUpTable_t

Typedef for vector of vector of vector of IDs of sectors on a layer.

Definition at line 317 of file CompactSecIDs.h.

secPairID_t

typedef uint32_t secPairID_t

Typedef of the compact Id for a 2 sectors combination.

Definition at line 38 of file CompactSecIDs.h.

secQuadrupletID_t

typedef uint64_t secQuadrupletID_t

Typedef of the compact Id for a 4 sectors combination.

Definition at line 44 of file CompactSecIDs.h.

sectorID_t

typedef uint16_t sectorID_t

Typedef of the compact Id for a single sector.

Definition at line 35 of file CompactSecIDs.h.

secTripletID_t

typedef uint64_t secTripletID_t

Typedef of the compact Id for a 3 sectors combination.

Definition at line 41 of file CompactSecIDs.h.

SensorsOnLadder_t

typedef std::vector<SectorsOnSensor<sectorID_t> > SensorsOnLadder_t

Typedef for vector of IDs of sectors on a sensors.

Definition at line 313 of file CompactSecIDs.h.

Constructor & Destructor Documentation

CompactSecIDs()

CompactSecIDs ( )

inline

The constructor have just to set the internal counter to 0.

Definition at line 47 of file CompactSecIDs.h.

: m_sectorCounter(0) { }

~CompactSecIDs()

~CompactSecIDs ( )

inline

The destructor is quite trivial: nothing special to delete.

Definition at line 50 of file CompactSecIDs.h.

{}

Member Function Documentation

addSectors()

int addSectors ( const std::vector< double > &  normalizedUsup, const std::vector< double > &  normalizedVsup, const std::vector< std::vector< FullSecID > > &  fullSecIDs  )

inline

This method defines all the sectors on a given sensor.

The two vectors normalizedUsup and normalizedVsup define the sector boundaries in normalized coordinates. (e.g.: if normalizesUsup = { a, 1} two sectors boundary are defined [0,a) and [a,1). ) The returned value is the number of fullSecIDs actually added to this CompacSecIDs.

Definition at line 69 of file CompactSecIDs.h.

    {
      // First let us check that there is space to store all the sectors
      if (getAvailableSlots() < (normalizedUsup.size() + 1) *
          (normalizedVsup.size() + 1))
        return 0;
 
      // Second let us check that the array of fullSecIDs is rectangular
      // and that its size matches the size of the coordinates.
      if (fullSecIDs.size() != normalizedUsup.size() + 1 ||
          fullSecIDs[0].size() != normalizedVsup.size() + 1)
        return 0;
 
      // Further sanity checks
 
      auto layer  = fullSecIDs[0][0].getLayerID();
      auto ladder = fullSecIDs[0][0].getLadderID();
      auto sensor = fullSecIDs[0][0].getVxdID().getSensorNumber();
 
      for (auto fullSecIDrow : fullSecIDs) {
        // Check that the fullSecIDs vector of vector is rectangular
        if (fullSecIDrow.size() != normalizedVsup.size() + 1)
          return 0;
 
        // Check that all the fullSectorIDs are on the same physical sensor
        for (auto fullSecID : fullSecIDrow)
          if (layer  != fullSecID.getLayerID() ||
              ladder != fullSecID.getLadderID() ||
              sensor != fullSecID.getVxdID().getSensorNumber())
            return 0;
      }
 
      return privateAddSectors(m_compactSectorsIDMap,
                               normalizedUsup, normalizedVsup,
                               fullSecIDs,
                               layer, ladder, sensor);
 
    }

areCoordinatesValid()

bool areCoordinatesValid ( VxdID  aSensorID, double  normalizedU, double  normalizedV  ) const

inline

JKL: returns true if operator() will not throw an exception.

Definition at line 297 of file CompactSecIDs.h.

    {
      auto layer = aSensorID.getLayerNumber() ;
      auto ladder = aSensorID.getLadderNumber();
      auto sensor = aSensorID.getSensorNumber();
 
      // check sensor:
      if (!(layer < m_compactSectorsIDMap.size())) return false;
      if (!(ladder < m_compactSectorsIDMap[layer].size())) return false;
      if (!(sensor < m_compactSectorsIDMap[layer][ladder].size())) return false;
 
      // check u and v:
      return m_compactSectorsIDMap[layer][ladder][sensor].areCoordinatesValid(normalizedU, normalizedV);
    }

extractCompactID() [1/2]

static void extractCompactID ( secPairID_t  pair_id, sectorID_t &  id1, sectorID_t &  id2  )

inlinestatic

Uses the values coded by the Sector Pair ID pair_id and sets the two compact Sector ids id1 and id2.

Parameters

pair_id	input sector pair id
id1	reference to first sector id to be set
id2	reference second sector id to be set

Definition at line 208 of file CompactSecIDs.h.

    {
      id1 = pair_id & 0xffff;
      id2 = (pair_id >> 16) & 0xffff;
    }

extractCompactID() [2/2]

static void extractCompactID ( secTripletID_t  triplet_id, sectorID_t &  id1, sectorID_t &  id2, sectorID_t &  id3  )

inlinestatic

Uses the values coded by the Sector Pair ID to set the three compact sector ids.

Parameters

triplet_id	input compact id of the triplet
id1	reference to compact id of first sector to be set
id2	reference to compact id of second sector to be set
id3	reference to compact id of third sector to be set

Definition at line 246 of file CompactSecIDs.h.

    {
      id1 = triplet_id & 0xffff;
      id2 = (triplet_id >> 16) & 0xffff;
      id3 = (triplet_id >> 32) & 0xffff;
    }

getAvailableSlots()

unsigned int getAvailableSlots ( ) const

inline

Returns the available number of sector that can be defined now.

Definition at line 56 of file CompactSecIDs.h.

    {
      return  UINT16_MAX - (getSize());
    }

getCompactID() [1/4]

sectorID_t getCompactID ( const FullSecID &  fullID ) const

inline

Returns the compact id of the FullSecID It does not throw exceptions (at least it should not).

Parameters

fullID

the FullSecID

Returns

0 if fullID is unknown, else the compact sector id

Definition at line 116 of file CompactSecIDs.h.

    {
 
      return privateGetCompactID(m_compactSectorsIDMap,
                                 fullID.getLayerID(),
                                 fullID.getLadderID(),
                                 fullID.getVxdID().getSensorNumber(),
                                 fullID.getSecID());
    }

getCompactID() [2/4]

secPairID_t getCompactID ( const FullSecID &  id1, const FullSecID &  id2  ) const

inline

Returns the compact id of the pair of FullSecID id1 id2.

Parameters

id1	first FullSecID
id2	second FullSecID

Returns

if id1 or id2 are undefined 0 is returned, else the compact sector id

Definition at line 188 of file CompactSecIDs.h.

    {
 
      auto i1 = (secPairID_t)getCompactID(id1);
      if (i1 == 0)
        return 0;
 
      auto i2 = (secPairID_t)getCompactID(id2);
      if (i2 == 0)
        return 0;
 
      return i1 + (i2 << 16);
 
    }

getCompactID() [3/4]

secTripletID_t getCompactID ( const FullSecID &  id1, const FullSecID &  id2, const FullSecID &  id3  ) const

inline

Returns the compact id of the triplet of FullSecID id1 id2 id3.

Parameters

id1	first id
id2	second id
id3	third id

Returns

If any of the id1, id2 or id3 is undefined 0 is returned, else the compact id of the triplet

Definition at line 221 of file CompactSecIDs.h.

    {
 
      auto i1 = (secTripletID_t)getCompactID(id1);
      if (i1 == 0)
        return 0;
 
      auto i2 = (secTripletID_t)getCompactID(id2);
      if (i2 == 0)
        return 0;
 
      auto i3 = (secTripletID_t)getCompactID(id3);
      if (i3 == 0)
        return 0;
 
      return i1 + (i2 << 16) + (i3 << 32);
 
    }

getCompactID() [4/4]

secQuadrupletID_t getCompactID ( const FullSecID &  id1, const FullSecID &  id2, const FullSecID &  id3, const FullSecID &  id4  ) const

inline

Returns the compact id of the quadruplet of FullSecID id1 id2 id3 id4 If any of the id1, id2, id3 or id4 is undefined 0 is returned.

Definition at line 255 of file CompactSecIDs.h.

    {
 
      auto i1 = (secQuadrupletID_t)getCompactID(id1);
      if (i1 == 0)
        return 0;
 
      auto i2 = (secQuadrupletID_t)getCompactID(id2);
      if (i2 == 0)
        return 0;
 
      auto i3 = (secQuadrupletID_t)getCompactID(id3);
      if (i3 == 0)
        return 0;
 
      auto i4 = (secQuadrupletID_t)getCompactID(id4);
      if (i4 == 0)
        return 0;
 
      return i1 + (i2 << 16) + (i3 << 32) + (i4 << 48) ;
 
    }

getCompactIDFastAndDangerous()

sectorID_t getCompactIDFastAndDangerous ( const FullSecID &  fullID ) const

inline

Fast (and potentially dangerous) equivalent of getCompactID.

It will not check for out of boundaries fullID / ill defined

Parameters

fullID

Definition at line 282 of file CompactSecIDs.h.

    {
 
      auto layer = fullID.getLayerID();
      auto ladder = fullID.getLadderID();
      auto sensor = fullID.getVxdID().getSensorNumber();
      auto sector = fullID.getSecID();
 
      return m_compactSectorsIDMap[layer][ladder][sensor][sector];
 
    }

getCompactSectorsIDMap()

const LayersLookUpTable_t & getCompactSectorsIDMap ( ) const

inline

Get access to the whole map.

Definition at line 321 of file CompactSecIDs.h.

{ return m_compactSectorsIDMap; }

getFullSecID()

FullSecID getFullSecID ( VxdID  aSensorID, double  normalizedU, double  normalizedV  ) const

inline

Returns a fullSecID for given sensor and pair of coordinates.

An exception is thrown in case of errors (index/coordinate out of range).

Definition at line 153 of file CompactSecIDs.h.

    {
 
      auto layer = aSensorID.getLayerNumber() ;
      auto ladder = aSensorID.getLadderNumber();
      auto sensor = aSensorID.getSensorNumber();
 
      auto sectorsOnSensor =
        m_compactSectorsIDMap.at(layer).at(ladder).at(sensor);
 
 
      if (normalizedU < 0. || 1. < normalizedU)
        B2WARNING("CompactSecIDs: U not normalized! This may lead to undefined behavior!");
      if (normalizedV < 0. || 1. < normalizedV)
        B2WARNING("CompactSecIDs: V not normalized! This may lead to undefined behavior!");
 
      return sectorsOnSensor(normalizedU, normalizedV);
 
 
    }

getSectorsOnSensor()

SectorsOnSensor< sectorID_t > getSectorsOnSensor ( unsigned  layer, unsigned  ladder, unsigned  sensor  ) const

inline

Getter for IDs of all sectors on a sensor.

Parameters

layer	: layer number of the sensor
ladder	: ladder number of the sensor
sensor	: sensor number

Returns

vector containing the IDs of the sectors on the sensor

Definition at line 133 of file CompactSecIDs.h.

    {
      try {
        return m_compactSectorsIDMap.at(layer).at(ladder).at(sensor);
      } catch (...)
      { return SectorsOnSensor<sectorID_t>(); }
 
    }

getSize()

int getSize ( ) const

inline

Returns the number of sectors defined so far.

Definition at line 53 of file CompactSecIDs.h.

{return (int)m_sectorCounter ; }

nOfLadders()

int nOfLadders ( int  layer ) const

inline

get the number of ladders on

Parameters

layer

the layer

Returns

0 if the the layer is out of bounds

Definition at line 331 of file CompactSecIDs.h.

    {
      if (layer < 0 || layer >= nOfLayers())
        return 0;
      return m_compactSectorsIDMap[layer].size();
    }

nOfLayers()

int nOfLayers ( void  ) const

inline

get the number of layers in this CompactSecIDs

Definition at line 324 of file CompactSecIDs.h.

    { return m_compactSectorsIDMap.size(); }

nOfSensors()

int nOfSensors ( int  layer, int  ladder  ) const

inline

get the number of sensors on

Parameters

layer	the layer
ladder	the ladder

Returns

0 if the layer or ladder is out of bounds.

Definition at line 343 of file CompactSecIDs.h.

    {
      if (ladder < 0 || ladder >= nOfLadders(layer))
        return 0; // Note: the check on the layer is implicitely made
 
      return m_compactSectorsIDMap[layer][ladder].size();
    }

operator[]()

sectorID_t operator[] ( const FullSecID &  fullID ) const

inline

Returns the compact id of the FullSecID fullID.

It will not throw exceptions.

Parameters

fullID

the FullSecID

Returns

if fullID is unknown 0 is returned, else the corresponding compact id

Definition at line 179 of file CompactSecIDs.h.

    {
      return getCompactID(fullID);
    }

privateAddSectors() [1/2]

int privateAddSectors ( SectorsOnSensor< sectorID_t > &  sectors, const std::vector< double > &  normalizedUsup, const std::vector< double > &  normalizedVsup, const std::vector< std::vector< FullSecID > > &  fullSecIDs  )

inlineprivate

The hidden private method that end the recursion.

It returns the number of added sectors. In particular it return 0 if sectors are already defined on the sensor.

Definition at line 398 of file CompactSecIDs.h.

    {
      if (sectors.size() != 0)
        return 0;
 
      sectors = SectorsOnSensor< sectorID_t >(normalizedUsup,
                                              normalizedVsup, fullSecIDs);
 
      int addedSectors = 0;
 
      for (auto sectorRow : fullSecIDs)
        for (auto sector : sectorRow) {
          auto secID = sector.getSecID();
          try {
            if ((int) sectors.size() < (int) secID + 1)
              sectors.resize(secID + 1);
          } catch (...) { return addedSectors; }
 
          sectors[ secID ] = ++m_sectorCounter ;
          addedSectors++;
        }
      return addedSectors;
 
    }

privateAddSectors() [2/2]

int privateAddSectors ( TContainer &  container, const std::vector< double > &  normalizedUsup, const std::vector< double > &  normalizedVsup, const std::vector< std::vector< FullSecID > > &  fullSecIDs, short unsigned int  index, Indexes ...  indexes  )

inlineprivate

The hidden private method that recursively manage the size of everything.

It returns the number of added sectors. It returns 0 in case of errors (memory exausted, or sector redefinition.)

Definition at line 379 of file CompactSecIDs.h.

    {
      try {
        if ((int) container.size() < (int)index + 1)
          container.resize(index + 1);
      } catch (...) { return 0; }
      return privateAddSectors(container[ index ],
                               normalizedUsup, normalizedVsup,
                               fullSecIDs, indexes...);
    }

privateGetCompactID() [1/2]

sectorID_t privateGetCompactID ( const TContainer &  container, short unsigned int  index  ) const

inlineprivate

The hidden private method that close the recursion.

Sanity checks are performed on the last index. 0 is returned in case of errors (i.e. indexes out of bound).

Definition at line 446 of file CompactSecIDs.h.

    {
      if ((int) container.size() < (int) index + 1)
        return 0;
 
      return container[ index ];
    }

privateGetCompactID() [2/2]

sectorID_t privateGetCompactID ( const TContainer &  container, short unsigned int  index, Indexes ...  indexes  ) const

inlineprivate

The hidden private method that recursively descend the layer, ladder, sensor stack and returns the compactID of a given fullSecID.

Sanity checks are performed at each step. 0 is returned in case of errors (i.e. indexes out of bound).

Definition at line 432 of file CompactSecIDs.h.

    {
      if ((int) container.size() < (int) index + 1)
        return 0;
 
      return privateGetCompactID(container[ index ], indexes...);
    }

setSubLayerID()

bool setSubLayerID ( FullSecID &  sector, int  sublayer  )

inline

set the SublayerID of the sector

Parameters

sector	the FullSectorID of the sector, the sublayer id will be ignored during searching for the sector
sublayer	the new sublayer id

Returns

true if successful

Definition at line 355 of file CompactSecIDs.h.

    {
      // cross check if sector is registered in the map, compactID will be 0 if not
      sectorID_t compactID = getCompactID(sector);
      if (compactID == 0) return false;
 
      // now update the SectorsOnSensor object
      return m_compactSectorsIDMap[sector.getLayerID()][sector.getLadderID()]
             [sector.getVxdID().getSensorNumber()].updateSubLayerID(sector, sublayer);
    }

Member Data Documentation

m_compactSectorsIDMap

LayersLookUpTable_t m_compactSectorsIDMap

private

Lookup table containing all sectorIDs.

Definition at line 372 of file CompactSecIDs.h.

m_sectorCounter

sectorID_t m_sectorCounter

private

Counter for sectors.

Definition at line 369 of file CompactSecIDs.h.

---

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

• tracking/trackFindingVXD/filterMap/map/include/CompactSecIDs.h