PXDClusterPositionErrorPar.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 <TObject.h>
#include <unordered_map>
#include <vector>
 
namespace Belle2 {
  class PXDClusterPositionErrorPar: public TObject {
  public:
 
    PXDClusterPositionErrorPar(unsigned short nBinsU = 1, unsigned short nBinsV = 3, unsigned short maxSize = 8,
                               float defaultValue = 0.0, float defaultFactor = 1.0):
      m_nBinsU(nBinsU), m_nBinsV(nBinsV), m_maxSize(maxSize), m_defaultValue(defaultValue), m_defaultFactor(defaultFactor),
      m_factorSensorUEdgeMap(), m_factorSensorVEdgeMap(), m_factorDeadNeighbourMap(), m_clusterPositionErrorMap() { }
 
    unsigned short getBinsU() const { return m_nBinsU; }
 
    unsigned short getBinsV() const { return m_nBinsV; }
 
    unsigned short getMaxClusterSize() const { return m_maxSize; }
 
 
 
    unsigned short getGlobalID(unsigned short uBin, unsigned short vBin, unsigned short size) const
    {
      if (size > m_maxSize) size = m_maxSize;
      return uBin * (m_nBinsV * m_maxSize) + vBin * m_maxSize + size - 1;
    }
 
    void setContent(unsigned short sensorID, unsigned short globalID, float value)
    {
      auto mapIter = m_clusterPositionErrorMap.find(sensorID);
      if (mapIter != m_clusterPositionErrorMap.end()) {
        // Already some values stored
        auto& errVec = mapIter->second;
        // Set the value
        errVec[globalID] = value;
      } else {
        // Create a fresh position error vector
        std::vector<float> errVec(m_nBinsU * m_nBinsV * m_maxSize, m_defaultValue);
        // Set the value
        errVec[globalID] = value;
        // Add vector to map
        m_clusterPositionErrorMap[sensorID] = errVec;
      }
    }
 
    void setContent(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size, float value)
    {
      setContent(sensorID, getGlobalID(uBin, vBin, size), value);
    }
 
    float getContent(unsigned short sensorID, unsigned short globalID) const
    {
      auto mapIter = m_clusterPositionErrorMap.find(sensorID);
      if (mapIter != m_clusterPositionErrorMap.end()) {
        // Found sensor, return position error value
        auto& errVec = mapIter->second;
        return errVec[globalID];
      }
      // Sensor not found, keep low profile and return default position error value
      return m_defaultValue;
    }
 
    float getContent(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size) const
    {
      return getContent(sensorID, getGlobalID(uBin, vBin, size));
    }
 
    void setSensorUEdgeFactor(unsigned short sensorID, unsigned short globalID, float factor)
    {
      auto mapIter = m_factorSensorUEdgeMap.find(sensorID);
      if (mapIter != m_factorSensorUEdgeMap.end()) {
        // Already some values stored
        auto& facVec = mapIter->second;
        // Set the value
        facVec[globalID] = factor;
      } else {
        // Create a fresh scale factor vector
        std::vector<float> facVec(m_nBinsU * m_nBinsV * m_maxSize, m_defaultFactor);
        // Set the value
        facVec[globalID] = factor;
        // Add vector to map
        m_factorSensorUEdgeMap[sensorID] = facVec;
      }
    }
    void setSensorUEdgeFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size, float factor)
    {
      setSensorUEdgeFactor(sensorID, getGlobalID(uBin, vBin, size), factor);
    }
 
    void setSensorVEdgeFactor(unsigned short sensorID, unsigned short globalID, float factor)
    {
      auto mapIter = m_factorSensorVEdgeMap.find(sensorID);
      if (mapIter != m_factorSensorVEdgeMap.end()) {
        // Already some values stored
        auto& facVec = mapIter->second;
        // Set the value
        facVec[globalID] = factor;
      } else {
        // Create a fresh scale factor vector
        std::vector<float> facVec(m_nBinsU * m_nBinsV * m_maxSize, m_defaultFactor);
        // Set the value
        facVec[globalID] = factor;
        // Add vector to map
        m_factorSensorVEdgeMap[sensorID] = facVec;
      }
    }
    void setSensorVEdgeFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size, float factor)
    {
      setSensorVEdgeFactor(sensorID, getGlobalID(uBin, vBin, size), factor);
    }
 
    void setDeadNeighbourFactor(unsigned short sensorID, unsigned short globalID, float factor)
    {
      auto mapIter = m_factorDeadNeighbourMap.find(sensorID);
      if (mapIter != m_factorDeadNeighbourMap.end()) {
        // Already some values stored
        auto& facVec = mapIter->second;
        // Set the value
        facVec[globalID] = factor;
      } else {
        // Create a fresh scale factor vector
        std::vector<float> facVec(m_nBinsU * m_nBinsV * m_maxSize, m_defaultFactor);
        // Set the value
        facVec[globalID] = factor;
        // Add vector to map
        m_factorDeadNeighbourMap[sensorID] = facVec;
      }
    }
    void setDeadNeighbourFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size, float factor)
    {
      setDeadNeighbourFactor(sensorID, getGlobalID(uBin, vBin, size), factor);
    }
 
    float getSensorUEdgeFactor(unsigned short sensorID, unsigned short globalID) const
    {
      auto mapIter = m_factorSensorUEdgeMap.find(sensorID);
      if (mapIter != m_factorSensorUEdgeMap.end()) {
        // Found sensor, return scale factor value
        auto& facVec = mapIter->second;
        return facVec[globalID];
      }
      // Sensor not found, keep low profile and return default scale factor value
      return m_defaultFactor;
    }
    float getSensorUEdgeFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size) const
    {
      return getSensorUEdgeFactor(sensorID, getGlobalID(uBin, vBin, size));
    }
 
    float getSensorVEdgeFactor(unsigned short sensorID, unsigned short globalID) const
    {
      auto mapIter = m_factorSensorVEdgeMap.find(sensorID);
      if (mapIter != m_factorSensorVEdgeMap.end()) {
        // Found sensor, return scale factor value
        auto& facVec = mapIter->second;
        return facVec[globalID];
      }
      // Sensor not found, keep low profile and return default scale factor value
      return m_defaultFactor;
    }
    float getSensorVEdgeFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size) const
    {
      return getSensorVEdgeFactor(sensorID, getGlobalID(uBin, vBin, size));
    }
 
    float getDeadNeighbourFactor(unsigned short sensorID, unsigned short globalID) const
    {
      auto mapIter = m_factorDeadNeighbourMap.find(sensorID);
      if (mapIter != m_factorDeadNeighbourMap.end()) {
        // Found sensor, return scale factor value
        auto& facVec = mapIter->second;
        return facVec[globalID];
      }
      // Sensor not found, keep low profile and return default scale factor value
      return m_defaultFactor;
    }
    float getDeadNeighbourFactor(unsigned short sensorID, unsigned short uBin, unsigned short vBin, unsigned short size) const
    {
      return getDeadNeighbourFactor(sensorID, getGlobalID(uBin, vBin, size));
    }
 
    const std::unordered_map<unsigned short, std::vector<float> >& getClusterPositionErrorMap() const {return m_clusterPositionErrorMap;}
 
  private:
 
    unsigned short m_nBinsU;
 
    unsigned short m_nBinsV;
 
    unsigned short m_maxSize;
 
    float m_defaultValue;
 
    float m_defaultFactor;
 
    std::unordered_map<unsigned short, std::vector<float> > m_factorSensorUEdgeMap;
 
    std::unordered_map<unsigned short, std::vector<float> > m_factorSensorVEdgeMap;
 
    std::unordered_map<unsigned short, std::vector<float> > m_factorDeadNeighbourMap;
 
    std::unordered_map<unsigned short, std::vector<float> > m_clusterPositionErrorMap;
 
    ClassDef(PXDClusterPositionErrorPar, 8);  
  };
} // end of namespace Belle2