BKLMElementNumbers.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
 
/* KLM headers. */
#include <klm/dataobjects/KLMElementNumberDefinitions.h>
 
/* C++ headers. */
#include <cstdint>
#include <string>
 
namespace Belle2 {
  class BKLMElementNumbers {
 
  public:
 
    enum Section {
 
      c_BackwardSection = 0,
 
      c_ForwardSection = 1,
 
    };
 
    enum Sector {
 
      c_ChimneySector = 3,
 
    };
 
    enum Layer {
 
      c_FirstRPCLayer = 3,
 
    };
 
    enum Plane {
 
      c_ZPlane = 0,
 
      c_PhiPlane = 1,
 
    };
 
    BKLMElementNumbers();
 
    ~BKLMElementNumbers();
 
    static KLMChannelNumber channelNumber(int section, int sector, int layer,
                                          int plane, int strip);
 
    static void channelNumberToElementNumbers(
      KLMChannelNumber channel, int* section, int* sector, int* layer, int* plane,
      int* strip);
 
    static KLMPlaneNumber planeNumber(int section, int sector, int layer,
                                      int plane);
 
    static void planeNumberToElementNumbers(
      KLMPlaneNumber planeGlobal, int* section, int* sector, int* layer,
      int* plane);
 
    static KLMModuleNumber moduleNumber(int section, int sector, int layer,
                                        bool fatalError = true);
 
    static void moduleNumberToElementNumbers(
      KLMModuleNumber module, int* section, int* sector, int* layer);
 
    static KLMSectorNumber sectorNumber(int section, int sector);
 
    static int layerGlobalNumber(int section, int sector, int layer);
 
    static int getNStrips(int section, int sector, int layer, int plane);
 
    static bool checkSection(int section, bool fatalError = true);
 
    static bool checkSector(int sector, bool fatalError = true);
 
    static bool checkLayer(int layer, bool fatalError = true);
 
    static bool checkPlane(int plane, bool fatalError = true);
 
    static bool checkChannelNumber(
      int section, int sector, int layer, int plane, int strip, bool fatalError = true);
 
    static std::string getHSLBName(int copper, int slot);
 
    static constexpr int getMaximalSectionNumber()
    {
      return m_MaximalSectionNumber;
    }
 
    static constexpr int getMaximalSectorNumber()
    {
      return m_MaximalSectorNumber;
    }
 
    static constexpr int getMaximalLayerNumber()
    {
      return m_MaximalLayerNumber;
    }
 
    static constexpr int getMaximalPlaneNumber()
    {
      return m_MaximalPlaneNumber;
    }
 
    static constexpr int getMaximalSectorGlobalNumber()
    {
      return (m_MaximalSectionNumber + 1) * m_MaximalSectorNumber;
    }
 
    static constexpr int getMaximalLayerGlobalNumber()
    {
      return (m_MaximalSectionNumber + 1) * m_MaximalSectorNumber * m_MaximalLayerNumber;
    }
 
    static constexpr int getTotalChannelNumber()
    {
      return m_TotalChannelNumber;
    }
 
    static void layerGlobalNumberToElementNumbers(int layerGlobal, int* section, int* sector, int* layer);
 
    static int getSectionByModule(int module)
    {
      return (module & BKLM_SECTION_MASK) >> BKLM_SECTION_BIT;
    }
 
    static int getSectorByModule(int module)
    {
      return ((module & BKLM_SECTOR_MASK) >> BKLM_SECTOR_BIT) + 1;
    }
 
    static int getLayerByModule(int module)
    {
      return ((module & BKLM_LAYER_MASK) >> BKLM_LAYER_BIT) + 1;
    }
 
    static int getPlaneByModule(int module)
    {
      return (module & BKLM_PLANE_MASK) >> BKLM_PLANE_BIT;
    }
 
    static int getStripByModule(int module)
    {
      return ((module & BKLM_STRIP_MASK) >> BKLM_STRIP_BIT) + 1;
    }
 
    static void setSectionInModule(int& module, int section)
    {
      module = (module & (~BKLM_SECTION_MASK)) | (section << BKLM_SECTION_BIT);
    }
 
    static void setSectorInModule(int& module, int sector)
    {
      module = (module & (~BKLM_SECTOR_MASK)) | ((sector - 1) << BKLM_SECTOR_BIT);
    }
 
    static void setLayerInModule(int& module, int layer)
    {
      module = (module & (~BKLM_LAYER_MASK)) | ((layer - 1) << BKLM_LAYER_BIT);
    }
 
    static void setPlaneInModule(int& module, int plane)
    {
      module = (module & (~BKLM_PLANE_MASK)) | (plane << BKLM_PLANE_BIT);
    }
 
    static void setStripInModule(int& module, int strip)
    {
      module = (module & (~BKLM_STRIP_MASK)) | ((strip - 1) << BKLM_STRIP_BIT);
    }
 
    static uint16_t getModuleByModule(int module)
    {
      return module & BKLM_MODULEID_MASK;
    }
 
    static uint16_t getChannelByModule(int module)
    {
      return module & BKLM_MODULESTRIPID_MASK;
    }
 
    static bool hitsFromSameModule(int module1, int module2)
    {
      return getModuleByModule(module1) == getModuleByModule(module2);
    }
 
    static bool hitsFromSamePlane(int module1, int module2)
    {
      const int mask = BKLM_MODULEID_MASK | BKLM_PLANE_MASK;
      return (module1 & mask) == (module2 & mask);
    }
 
    static bool hitsFromSameChannel(int module1, int module2)
    {
      return getChannelByModule(module1) == getChannelByModule(module2);
    }
 
  protected:
 
    static constexpr int m_MaximalSectionNumber = 1;
 
    static constexpr int m_MaximalSectorNumber = 8;
 
    static constexpr int m_MaximalLayerNumber = 15;
 
    static constexpr int m_MaximalPlaneNumber = 1;
 
    static constexpr int m_TotalChannelNumber = 21978;
 
    static constexpr int BKLM_STRIP_BIT = 0;
 
    static constexpr int BKLM_PLANE_BIT = 6;
 
    static constexpr int BKLM_LAYER_BIT = 7;
 
    static constexpr int BKLM_SECTOR_BIT = 11;
 
    static constexpr int BKLM_SECTION_BIT = 14;
 
    static constexpr int BKLM_STRIP_MASK = (63 << BKLM_STRIP_BIT);
 
    static constexpr int BKLM_PLANE_MASK = (1 << BKLM_PLANE_BIT);
 
    static constexpr int BKLM_LAYER_MASK = (15 << BKLM_LAYER_BIT);
 
    static constexpr int BKLM_SECTOR_MASK = (7 << BKLM_SECTOR_BIT);
 
    static constexpr int BKLM_SECTION_MASK = (1 << BKLM_SECTION_BIT);
 
    static constexpr int BKLM_MODULEID_MASK =
      BKLM_SECTION_MASK | BKLM_SECTOR_MASK | BKLM_LAYER_MASK;
 
    static constexpr int BKLM_MODULESTRIPID_MASK =
      BKLM_SECTION_MASK | BKLM_SECTOR_MASK | BKLM_LAYER_MASK | BKLM_PLANE_MASK |
      BKLM_STRIP_MASK;
 
  };
 
}