MuonStationIndex.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef MUONSTATIONINDEX_MUONSTATIONINDEX_H
#define MUONSTATIONINDEX_MUONSTATIONINDEX_H
 
#include <string>
#include <vector>
#include <stdint.h>
#include <iosfwd>
 
namespace Muon {
  namespace MuonStationIndex {
    enum class ChIndex: int8_t {
      ChUnknown = -1,
      BIS, BIL, BMS, BML, BOS, BOL, BEE,
      EIS, EIL, EMS, EML, EOS, EOL, EES, EEL, CSS, CSL,
      ChIndexMax
    };

    enum class StIndex: int8_t {
      StUnknown = -1,
      BI, BM, BO, BE,
      EI, EM, EO, EE,
      StIndexMax
    };

    enum class PhiIndex: int8_t {
      PhiUnknown = -1,
      BI1, BI2, BM1, BM2, BO1, BO2, T1, T2, T3, T4, CSC, STGC1, STGC2,
      PhiIndexMax
    };

    enum class LayerIndex: int8_t {
      LayerUnknown = -1,
      Inner, Middle, Outer, 
      Extended,       
      BarrelExtended, 
      LayerIndexMax
    };
    
    enum class DetectorRegionIndex: int8_t {
      DetectorRegionUnknown = -1,
      EndcapA, Barrel, EndcapC,
      DetectorRegionIndexMax 
    };    

    enum class TechnologyIndex: int8_t {
      TechnologyUnknown = -1,
      MDT, CSC, RPC, TGC, STGC, MM,
      TechnologyIndexMax  
    };    
    /*** Convert the strong enum to an integer */
    template <typename EnumType>
    constexpr int toInt(const EnumType enumVal) {
      return static_cast<int>(enumVal);
    }

    StIndex toStationIndex( ChIndex index );

    LayerIndex toLayerIndex( ChIndex index );

    LayerIndex toLayerIndex( StIndex index );

    StIndex toStationIndex( DetectorRegionIndex region, LayerIndex layer );

    DetectorRegionIndex toDetectorRegionIndex( ChIndex index, int8_t etaSign );

    ChIndex toChamberIndex( DetectorRegionIndex region, LayerIndex layer, bool isSmall ) ;

    bool isBarrel(const ChIndex index);
    bool isBarrel(const StIndex index);
    bool isSmall(const ChIndex index);
    ChIndex toChamberIndex( StIndex stIndex, bool isSmall ) ;

    const std::string& phiName( PhiIndex index ) ;

    const std::string& stName( StIndex index ) ;

    const std::string& chName( ChIndex index ) ;

    const std::string& regionName( DetectorRegionIndex index ) ;

    const std::string& layerName( LayerIndex index ) ;

    const std::string& technologyName( TechnologyIndex index ) ;

    unsigned int sectorLayerHash( DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex );

    unsigned int regionChambernHash( DetectorRegionIndex regionIdx, ChIndex chamberIdx );

    constexpr unsigned int sectorLayerHashMax() {
       return toInt(DetectorRegionIndex::DetectorRegionIndexMax)*toInt(LayerIndex::LayerIndexMax);
    }

    constexpr unsigned int regionChamberHashMax() {
      return toInt(DetectorRegionIndex::DetectorRegionIndexMax)*toInt(ChIndex::ChIndexMax);
 
    }

    std::pair<DetectorRegionIndex,LayerIndex> decomposeSectorLayerHash( unsigned int hash );

    std::pair<DetectorRegionIndex, ChIndex> decomposeRegionChamberHash( unsigned int hash );

    constexpr unsigned numberOfSectors() { return 16; }
    
    ChIndex chIndex( const std::string& index );
 
    std::ostream& operator<<(std::ostream& ostr, const StIndex stIdx);
    std::ostream& operator<<(std::ostream& ostr, const ChIndex chIdx);
    std::ostream& operator<<(std::ostream& ostr, const PhiIndex phiIdx);
    std::ostream& operator<<(std::ostream& ostr, const DetectorRegionIndex detIdx);
    std::ostream& operator<<(std::ostream& ostr, const LayerIndex layIdx);
    std::ostream& operator<<(std::ostream& ostr, const TechnologyIndex techIdx);
 
  }
}
#include "MuonStationIndex/MuonStationIndex.icc"
#endif