CompactSecIDs.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include "tracking/dataobjects/FullSecID.h"
#include <tracking/trackFindingVXD/filterMap/map/SectorsOnSensor.h>
#include <framework/core/FrameworkExceptions.h>
#include <framework/logging/Logger.h>
#include <cstdint>
#include <vector>
 
namespace Belle2 {
  class CompactSecIDs {
 
  public:
 
    // uint_16_t upper limit is UINT16_MAX
 
    typedef uint16_t sectorID_t       ;
 
    typedef uint32_t secPairID_t      ;
 
    typedef uint64_t secTripletID_t   ;
 
    typedef uint64_t secQuadrupletID_t;
 
    CompactSecIDs(): m_sectorCounter(0) { }
 
    ~CompactSecIDs() {}
 
    int getSize() const {return (int)m_sectorCounter ; }
 
    unsigned int getAvailableSlots() const
    {
      return  UINT16_MAX - (getSize());
    }
 
 
    int addSectors(const std::vector< double>&   normalizedUsup,
                   const std::vector< double>&   normalizedVsup,
                   const std::vector< std::vector< FullSecID >>& fullSecIDs)
    {
      // 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);
 
    }
 
 
    sectorID_t getCompactID(const FullSecID& fullID) const
    {
 
      return privateGetCompactID(m_compactSectorsIDMap,
                                 fullID.getLayerID(),
                                 fullID.getLadderID(),
                                 fullID.getVxdID().getSensorNumber(),
                                 fullID.getSecID());
    }
 
    SectorsOnSensor<sectorID_t>
    getSectorsOnSensor(unsigned layer, unsigned ladder, unsigned sensor)
    const
    {
      try {
        return m_compactSectorsIDMap.at(layer).at(ladder).at(sensor);
      } catch (...)
      { return SectorsOnSensor<sectorID_t>(); }
 
    }
 
    BELLE2_DEFINE_EXCEPTION(unboundedNormalizedU,
                            "On layer:%1% ladder:%2% sensor:%3% abnormal U=%4$");
 
    BELLE2_DEFINE_EXCEPTION(unboundedNormalizedV,
                            "On layer:%1% ladder:%2% sensor:%3% abnormal V=%4$");
 
    FullSecID getFullSecID(VxdID aSensorID,
                           double normalizedU, double normalizedV) const
    {
 
      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);
 
 
    }
 
    sectorID_t operator [](const FullSecID& fullID) const
    {
      return getCompactID(fullID);
    }
 
    secPairID_t getCompactID(const FullSecID& id1, const FullSecID& id2) const
    {
 
      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);
 
    }
 
    static void extractCompactID(secPairID_t pair_id, sectorID_t& id1, sectorID_t& id2)
    {
      id1 = pair_id & 0xffff;
      id2 = (pair_id >> 16) & 0xffff;
    }
 
 
 
    secTripletID_t getCompactID(const FullSecID& id1, const FullSecID& id2,
                                const FullSecID& id3) const
    {
 
      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);
 
    }
 
    static void extractCompactID(secTripletID_t triplet_id, sectorID_t& id1, sectorID_t& id2, sectorID_t& id3)
    {
      id1 = triplet_id & 0xffff;
      id2 = (triplet_id >> 16) & 0xffff;
      id3 = (triplet_id >> 32) & 0xffff;
    }
 
    secQuadrupletID_t getCompactID(const FullSecID& id1, const FullSecID& id2,
                                   const FullSecID& id3, const FullSecID& id4)
    const
    {
 
      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) ;
 
    }
 
    sectorID_t getCompactIDFastAndDangerous(const FullSecID& fullID) const
    {
 
      auto layer = fullID.getLayerID();
      auto ladder = fullID.getLadderID();
      auto sensor = fullID.getVxdID().getSensorNumber();
      auto sector = fullID.getSecID();
 
      return m_compactSectorsIDMap[layer][ladder][sensor][sector];
 
    }
 
 
 
    bool areCoordinatesValid(VxdID aSensorID, double normalizedU, double normalizedV) const
    {
      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);
    }
 
    typedef std::vector<SectorsOnSensor<sectorID_t> > SensorsOnLadder_t;
    typedef std::vector<SensorsOnLadder_t> LaddersOnLayer_t;
    typedef std::vector<LaddersOnLayer_t> LayersLookUpTable_t;
 
 
    const LayersLookUpTable_t& getCompactSectorsIDMap() const { return m_compactSectorsIDMap; }
 
    int nOfLayers(void) const
    { return m_compactSectorsIDMap.size(); }
 
    int nOfLadders(int layer) const
    {
      if (layer < 0 || layer >= nOfLayers())
        return 0;
      return m_compactSectorsIDMap[layer].size();
    }
 
    int nOfSensors(int layer, int ladder) const
    {
      if (ladder < 0 || ladder >= nOfLadders(layer))
        return 0; // Note: the check on the layer is implicitly made
 
      return m_compactSectorsIDMap[layer][ladder].size();
    }
 
    bool setSubLayerID(FullSecID& sector, int sublayer)
    {
      // 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);
    }
 
 
  private:
    sectorID_t m_sectorCounter;
 
    LayersLookUpTable_t m_compactSectorsIDMap;
 
    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)
    {
      try {
        if ((int) container.size() < (int)index + 1)
          container.resize(index + 1);
      } catch (...) { return 0; }
      return privateAddSectors(container[ index ],
                               normalizedUsup, normalizedVsup,
                               fullSecIDs, indexes...);
    }
 
 
    int privateAddSectors(SectorsOnSensor<sectorID_t>&            sectors,
                          const std::vector< double>&                  normalizedUsup,
                          const std::vector< double>&                  normalizedVsup,
                          const std::vector< std::vector< FullSecID > >&    fullSecIDs)
    {
      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;
 
    }
 
    template<  class TContainer,
               class ... Indexes >
    sectorID_t privateGetCompactID(const TContainer& container,
                                   short unsigned int index, Indexes ... indexes) const
    {
      if ((int) container.size() < (int) index + 1)
        return 0;
 
      return privateGetCompactID(container[ index ], indexes...);
    }
 
 
    template<  class TContainer >
    sectorID_t privateGetCompactID(const TContainer& container,
                                   short unsigned int index) const
    {
      if ((int) container.size() < (int) index + 1)
        return 0;
 
      return container[ index ];
    }
 
  };
 
}