SectorsOnSensor.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 <map>
#include <vector>
#include <cfloat>
 
namespace Belle2 {
  template< class sectorID  >
  class SectorsOnSensor {
 
    typedef unsigned char index_t;
 
    std::map<double, index_t> m_normalizedUsup;
 
    std::map<double, index_t> m_normalizedVsup;
 
    std::vector< std::vector < FullSecID > > m_fullSecIDs;
 
    std::vector< sectorID > m_compactSecIDs;
 
  public:
 
    SectorsOnSensor() {}
 
    SectorsOnSensor(
      const std::vector< double >&      normalizedUsup,
      const std::vector< double >&      normalizedVsup,
      const std::vector< std::vector< FullSecID > >& fullSecIDs)
    {
      index_t index = 0;
 
      for (auto Vsup : normalizedVsup)
        m_normalizedVsup.insert({Vsup, index++});
      m_normalizedVsup.insert({FLT_MAX, index++});
 
      index = 0;
      for (auto Usup : normalizedUsup)
        m_normalizedUsup.insert({Usup, index++});
      // cppcheck-suppress unreadVariable
      m_normalizedUsup.insert({FLT_MAX, index++});
 
      m_fullSecIDs = fullSecIDs;
 
    }
 
    ~SectorsOnSensor() {};
 
    FullSecID operator()(double normalizedU, double normalizedV) const
    {
 
      if (normalizedU < 0. or normalizedU > 1.)
        return FullSecID(0);
      if (normalizedV < 0. or normalizedV > 1.)
        return FullSecID(0);
 
      auto uKeyVal = m_normalizedUsup.upper_bound(normalizedU);
      if (uKeyVal == m_normalizedUsup.end())
        return FullSecID(0);
 
      auto vKeyVal = m_normalizedVsup.upper_bound(normalizedV);
      if (vKeyVal == m_normalizedVsup.end())
        return FullSecID(0);
 
 
      auto uIndex = uKeyVal->second;
      auto vIndex = vKeyVal->second;
 
      return m_fullSecIDs[ uIndex ][ vIndex ];
    }
 
 
 
 
    void get(std::vector< double >* normalizedUsup,
             std::vector< double >* normalizedVsup,
             std::vector< std::vector< unsigned int > >* secID) const
    {
      // let us copy the sorted map Usup
      for (auto uIndexPair : m_normalizedUsup)
        if (uIndexPair.first != FLT_MAX)
          normalizedUsup->push_back(uIndexPair.first);
 
      // let us copy the sorted map Vsup
      for (auto vIndexPair : m_normalizedVsup)
        if (vIndexPair.first != FLT_MAX)
          normalizedVsup->push_back(vIndexPair.first);
 
      // and finally we copy the array of full sec ids
      for (auto col : m_fullSecIDs) {
        std::vector< unsigned int > tmp_col;
        for (auto id : col)
          tmp_col.push_back(id);
        secID->push_back(tmp_col);
      }
    }
 
    bool areCoordinatesValid(double normalizedU, double normalizedV) const
    {
      // check u and v
      if ((normalizedU < 0.) or (normalizedU > 1.)) return false;
      if ((normalizedV < 0.) or (normalizedV > 1.)) return false;
      // check internal map for problems:
      if (m_normalizedUsup.upper_bound(normalizedU) == m_normalizedUsup.end())
        return false;
 
      if (m_normalizedVsup.upper_bound(normalizedV) == m_normalizedVsup.end())
        return false;
 
      return true;
    }
 
 
    sectorID& operator[](int index) { return m_compactSecIDs[index] ;};
 
    const sectorID& operator[](int index) const { return m_compactSecIDs[index] ;};
 
    size_t size() const { return m_compactSecIDs.size(); };
 
    void resize(size_t n) { m_compactSecIDs.resize(n); };
 
 
    bool updateSubLayerID(FullSecID sector, int sublayer)
    {
      for (auto& v : m_fullSecIDs) {
        for (FullSecID& thisSecID : v) {
          if (sector.equalIgnoreSubLayerID(thisSecID)) {
            thisSecID = FullSecID(thisSecID.getVxdID(), (bool)sublayer, thisSecID.getSecID());
            return true;
          }
        }
      }
      return false;
    }
 
    const std::vector< sectorID >& getCompactSecIDs() const { return m_compactSecIDs; }
 
  };
 
}