Muon::MuonStationIndex Class Reference

#include <MuonStationIndex.h>

Collaboration diagram for Muon::MuonStationIndex:

Public Types
enum	ChIndex {   ChUnknown = -1, BIS, BIL, BMS,   BML, BOS, BOL, BEE,   EIS, EIL, EMS, EML,   EOS, EOL, EES, EEL,   CSS, CSL, ChIndexMax }
	enum to classify the different chamber layers in the muon spectrometer More...
enum	StIndex {   StUnknown = -1, BI, BM, BO,   BE, EI, EM, EO,   EE, StIndexMax }
	enum to classify the different station layers in the muon spectrometer More...
enum	PhiIndex {   PhiUnknown = -1, BI1, BI2, BM1,   BM2, BO1, BO2, T1,   T2, T3, T4, CSC,   STGC1, STGC2, PhiIndexMax }
	enum to classify the different phi layers in the muon spectrometer More...
enum	LayerIndex {   LayerUnknown = -1, Inner, Middle, Outer,   Extended, BarrelExtended, LayerIndexMax }
	enum to classify the different layers in the muon spectrometer More...
enum	DetectorRegionIndex {   DetectorRegionUnknown = -1, EndcapA, Barrel, EndcapC,   DetectorRegionIndexMax }
	enum to classify the different layers in the muon spectrometer More...
enum	TechnologyIndex {   TechnologyUnknown = -1, MDT, CSCI, RPC,   TGC, STGC, MM, TechnologyIndexMax }
	enum to classify the different layers in the muon spectrometer More...

Static Public Member Functions
static StIndex	toStationIndex (ChIndex index)
	convert ChIndex into StIndex More...
static LayerIndex	toLayerIndex (ChIndex index)
	convert ChIndex into LayerIndex More...
static LayerIndex	toLayerIndex (StIndex index)
	convert StIndex into LayerIndex More...
static StIndex	toStationIndex (DetectorRegionIndex region, LayerIndex layer)
	convert DetectorRegionIndex + LayerIndex into StIndex More...
static ChIndex	toChamberIndex (DetectorRegionIndex region, LayerIndex layer, bool isSmall)
	convert DetectorRegionIndex + LayerIndex + isSmall into ChIndex More...
static ChIndex	toChamberIndex (StIndex stIndex, bool isSmall)
	convert StIndex + isSmall into ChIndex More...
static const std::string &	phiName (PhiIndex index)
	convert PhiIndex into a string More...
static const std::string &	stName (StIndex index)
	convert StIndex into a string More...
static const std::string &	chName (ChIndex index)
	convert ChIndex into a string More...
static const std::string &	regionName (DetectorRegionIndex index)
	convert DetectorRegionIndex into a string More...
static const std::string &	layerName (LayerIndex index)
	convert LayerIndex into a string More...
static const std::string &	technologyName (TechnologyIndex index)
	convert LayerIndex into a string More...
static unsigned int	sectorLayerHash (DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
	create a hash out of region and layer More...
static unsigned int	sectorLayerHashMax ()
	maximum create a hash out of region and layer More...
static std::pair< DetectorRegionIndex, LayerIndex >	decomposeSectorLayerHash (unsigned int hash)
	decompose the hash into Region and Layer More...
static unsigned int	numberOfSectors ()
	return total number of sectors More...
static ChIndex	chIndex (const std::string &index)
	convert ChIndex name string to enum More...

Detailed Description

Definition at line 12 of file MuonStationIndex.h.

Member Enumeration Documentation

ChIndex

enum Muon::MuonStationIndex::ChIndex

enum to classify the different chamber layers in the muon spectrometer

Enumerator
ChUnknown
BIS
BIL
BMS
BML
BOS
BOL
BEE
EIS
EIL
EMS
EML
EOS
EOL
EES
EEL
CSS
CSL
ChIndexMax

Definition at line 15 of file MuonStationIndex.h.

                 {
      ChUnknown = -1,
      BIS, BIL, BMS, BML, BOS, BOL, BEE,
      EIS, EIL, EMS, EML, EOS, EOL, EES, EEL, CSS, CSL,
      ChIndexMax
    };

DetectorRegionIndex

enum Muon::MuonStationIndex::DetectorRegionIndex

enum to classify the different layers in the muon spectrometer

Enumerator
DetectorRegionUnknown
EndcapA
Barrel
EndcapC
DetectorRegionIndexMax

Definition at line 47 of file MuonStationIndex.h.

                             {
      DetectorRegionUnknown = -1,
      EndcapA, Barrel, EndcapC,
      DetectorRegionIndexMax 
    };    

LayerIndex

enum Muon::MuonStationIndex::LayerIndex

enum to classify the different layers in the muon spectrometer

Enumerator
LayerUnknown
Inner
Middle
Outer
Extended
BarrelExtended	EE.
LayerIndexMax	BEE.

Definition at line 38 of file MuonStationIndex.h.

                    {
      LayerUnknown = -1,
      Inner, Middle, Outer, 
      Extended,       
      BarrelExtended, 
      LayerIndexMax
    };

PhiIndex

enum Muon::MuonStationIndex::PhiIndex

enum to classify the different phi layers in the muon spectrometer

Enumerator
PhiUnknown
BI1
BI2
BM1
BM2
BO1
BO2
T1
T2
T3
T4
CSC
STGC1
STGC2
PhiIndexMax

Definition at line 31 of file MuonStationIndex.h.

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

StIndex

enum Muon::MuonStationIndex::StIndex

enum to classify the different station layers in the muon spectrometer

Enumerator
StUnknown
BI
BM
BO
BE
EI
EM
EO
EE
StIndexMax

Definition at line 23 of file MuonStationIndex.h.

                 {
      StUnknown = -1,
      BI, BM, BO, BE,
      EI, EM, EO, EE,
      StIndexMax
    };

TechnologyIndex

enum Muon::MuonStationIndex::TechnologyIndex

enum to classify the different layers in the muon spectrometer

Enumerator
TechnologyUnknown
MDT
CSCI
RPC
TGC
STGC
MM
TechnologyIndexMax

Definition at line 54 of file MuonStationIndex.h.

                         {
      TechnologyUnknown = -1,
      MDT, CSCI, RPC, TGC, STGC, MM,
      TechnologyIndexMax  
    };    

Member Function Documentation

chIndex()

MuonStationIndex::ChIndex Muon::MuonStationIndex::chIndex ( const std::string &  index )

static

convert ChIndex name string to enum

Definition at line 20 of file MuonStationIndex.cxx.

                                                     {
 
      if( index == "BIS" ) return BIS;
      if( index == "BIL" ) return BIL;
      if( index == "BMS" ) return BMS;
      if( index == "BML" ) return BML;
      if( index == "BOS" ) return BOS;
      if( index == "BOL" ) return BOL;
      if( index == "BEE" ) return BEE;
      if( index == "EIS" ) return EIS;
      if( index == "EIL" ) return EIL;
      if( index == "EMS" ) return EMS;
      if( index == "EML" ) return EML;
      if( index == "EOS" ) return EOS;
      if( index == "EOL" ) return EOL;
      if( index == "EES" ) return EES;
      if( index == "EEL" ) return EEL;
      if( index == "CSS" ) return CSS;
      if( index == "CSL" ) return CSL;
      return ChUnknown; 
   }

chName()

const std::string & Muon::MuonStationIndex::chName ( ChIndex  index )

static

convert ChIndex into a string

Definition at line 157 of file MuonStationIndex.cxx.

                                                            {
      static const std::array<std::string, N_CHAMBER_INDEX> chamberIndexNames {
         "BIS", "BIL", "BMS", "BML", "BOS", "BOL", "BEE",
         "EIS", "EIL", "EMS", "EML", "EOS", "EOL", "EES",
         "EEL", "CSS", "CSL", "ChIndexMax"
      };
 
      if( index == ChUnknown ) {
         static const std::string dummy( "ChUnknown" );
         return dummy;
      }
      if( index >= ChIndexMax ) {
         static const std::string dummy( "ChOutOfRange" );
         return dummy;
      }
      return chamberIndexNames[ index ];
   }

decomposeSectorLayerHash()

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

static

decompose the hash into Region and Layer

Definition at line 237 of file MuonStationIndex.cxx.

                                                                 {
      return std::make_pair( static_cast< DetectorRegionIndex >( hash /
                                                                 LayerIndexMax ),
                             static_cast< LayerIndex >( hash % LayerIndexMax ) );
   }

layerName()

const std::string & Muon::MuonStationIndex::layerName ( LayerIndex  index )

static

convert LayerIndex into a string

Definition at line 192 of file MuonStationIndex.cxx.

                                                                  {
      static const std::array<std::string, 6> layerIndexNames {
         "Inner", "Middle", "Outer", "Extended", "BarrelExtended", "LayerIndexMax"
      };
 
      if( index == LayerUnknown ) {
         static const std::string dummy( "LayerUnknown" );
         return dummy;
      }
      if( index >= LayerIndexMax ) {
         static const std::string dummy ( "LayerOutOfRange" );
         return dummy;
      }
      return layerIndexNames[ index ];
   }

numberOfSectors()

static unsigned int Muon::MuonStationIndex::numberOfSectors ( )

inlinestatic

return total number of sectors

Definition at line 106 of file MuonStationIndex.h.

{ return 16; }

phiName()

const std::string & Muon::MuonStationIndex::phiName ( PhiIndex  index )

static

convert PhiIndex into a string

Definition at line 124 of file MuonStationIndex.cxx.

                                                              { 
      static const std::array<std::string, 14> phiIndexNames = {
         "BI1", "BI2", "BM1", "BM2", "BO1", "BO2", "T1", "T2", "T3", "T4", "CSC", "STGC1",
         "STGC2", "PhiIndexMax"
      };
 
      if( index == PhiUnknown ) {
         static const std::string dummy( "PhiUnknown" );
         return dummy;
      }
      if( index >= PhiIndexMax ) {
         static const std::string dummy( "PhiOutOfRange" );
         return dummy;
      }
      return phiIndexNames[ index ];
   }

regionName()

const std::string & Muon::MuonStationIndex::regionName ( DetectorRegionIndex  index )

static

convert DetectorRegionIndex into a string

Definition at line 176 of file MuonStationIndex.cxx.

                                                           {
      static const std::array<std::string, 4> detectorRegionIndexNames {
         "EndcapA", "Barrel", "EndcapC", "DetectorRegionIndexMax"
      };
 
      if( index == DetectorRegionUnknown ) {
         static const std::string dummy( "DetectorRegionUnknown" );
         return dummy;
      }
      if( index >= DetectorRegionIndexMax ) {
         static const std::string dummy( "DetectorRegionOutOfRange" );
         return dummy;
      }
      return detectorRegionIndexNames[ index ];
   }

sectorLayerHash()

unsigned int Muon::MuonStationIndex::sectorLayerHash ( DetectorRegionIndex  detectorRegionIndex, LayerIndex  layerIndex  )

static

create a hash out of region and layer

Definition at line 226 of file MuonStationIndex.cxx.

                                                             {
      return detectorRegionIndex*LayerIndexMax + layerIndex;
   }

sectorLayerHashMax()

unsigned int Muon::MuonStationIndex::sectorLayerHashMax ( )

static

maximum create a hash out of region and layer

Definition at line 231 of file MuonStationIndex.cxx.

                                                     {
      return DetectorRegionIndexMax*LayerIndexMax;
   }

stName()

const std::string & Muon::MuonStationIndex::stName ( StIndex  index )

static

convert StIndex into a string

Definition at line 141 of file MuonStationIndex.cxx.

                                                            {
      static const std::array<std::string, N_STATION_INDEX> stationIndexNames {
         "BI", "BM", "BO", "BE", "EI", "EM", "EO", "EE", "StIndexMax"
      };
 
      if( index == StUnknown ) {
         static const std::string dummy( "StUnknown" );
         return dummy;
      }
      if( index >= StIndexMax ) {
         static const std::string dummy( "StOutOfRange" );
         return dummy;
      }
      return stationIndexNames[ index ];
   }

technologyName()

const std::string & Muon::MuonStationIndex::technologyName ( TechnologyIndex  index )

static

convert LayerIndex into a string

Definition at line 209 of file MuonStationIndex.cxx.

                                                           {
      static const std::array<std::string, 7> technologyIndexNames {
         "MDT", "CSC", "RPC", "TGC", "STGC", "MM", "TechnologyIndexMax"
      };
 
      if( index == TechnologyUnknown ) {
         static const std::string dummy( "TechnologyUnknown" );
         return dummy;
      }
      if( index >= TechnologyIndexMax ) {
         static const std::string dummy( "TechnologyOutOfRange" );
         return dummy;
      }
      return technologyIndexNames[ index ];
   }

toChamberIndex() [1/2]

MuonStationIndex::ChIndex Muon::MuonStationIndex::toChamberIndex ( DetectorRegionIndex  region, LayerIndex  layer, bool  isSmall  )

static

convert DetectorRegionIndex + LayerIndex + isSmall into ChIndex

Definition at line 98 of file MuonStationIndex.cxx.

                                                                      {
      static constexpr std::array<MuonStationIndex::ChIndex, N_REGIONLAYER_INDEX> regionLayerToChamberIndexSmall {
         MuonStationIndex::EIS, MuonStationIndex::EMS, MuonStationIndex::EOS,
         MuonStationIndex::EES, MuonStationIndex::BEE, MuonStationIndex::BIS,
         MuonStationIndex::BMS, MuonStationIndex::BOS, MuonStationIndex::ChUnknown,
         MuonStationIndex::ChUnknown,
         MuonStationIndex::EIS, MuonStationIndex::EMS, MuonStationIndex::EOS,
         MuonStationIndex::EES, MuonStationIndex::BEE
      };
      static constexpr std::array<MuonStationIndex::ChIndex, N_REGIONLAYER_INDEX> regionLayerToChamberIndexLarge {
         MuonStationIndex::EIL, MuonStationIndex::EML, MuonStationIndex::EOL,
         MuonStationIndex::EEL, MuonStationIndex::ChUnknown, MuonStationIndex::BIL,
         MuonStationIndex::BML, MuonStationIndex::BOL, MuonStationIndex::ChUnknown,
         MuonStationIndex::ChUnknown,
         MuonStationIndex::EIL, MuonStationIndex::EML, MuonStationIndex::EOL,
         MuonStationIndex::EEL,MuonStationIndex::ChUnknown
      };
      if( isSmall ) {
         return regionLayerToChamberIndexSmall[ sectorLayerHash( region,
                                                                   layer ) ];
      }
      return regionLayerToChamberIndexLarge[ sectorLayerHash( region,
                                                                layer ) ];
   }

toChamberIndex() [2/2]

MuonStationIndex::ChIndex Muon::MuonStationIndex::toChamberIndex ( StIndex  stIndex, bool  isSmall  )

static

convert StIndex + isSmall into ChIndex

Definition at line 14 of file MuonStationIndex.cxx.

                                                                                          {
    if( stIndex == BE && isSmall ) return ChUnknown;
    return static_cast<ChIndex>( 2*stIndex + !isSmall );
  }

toLayerIndex() [1/2]

MuonStationIndex::LayerIndex Muon::MuonStationIndex::toLayerIndex ( ChIndex  index )

static

convert ChIndex into LayerIndex

Definition at line 56 of file MuonStationIndex.cxx.

                                                 {
      static constexpr std::array<MuonStationIndex::LayerIndex, N_CHAMBER_INDEX> chamberToLayerIndex {
         MuonStationIndex::Inner, MuonStationIndex::Inner,
         MuonStationIndex::Middle, MuonStationIndex::Middle,
         MuonStationIndex::Outer, MuonStationIndex::Outer,
         MuonStationIndex::BarrelExtended, MuonStationIndex::Inner,
         MuonStationIndex::Inner, MuonStationIndex::Middle,
         MuonStationIndex::Middle, MuonStationIndex::Outer,
         MuonStationIndex::Outer, MuonStationIndex::Extended,
         MuonStationIndex::Extended, MuonStationIndex::Inner,
         MuonStationIndex::Inner, MuonStationIndex::LayerIndexMax
      };
      return chamberToLayerIndex[ index ];
   }

toLayerIndex() [2/2]

MuonStationIndex::LayerIndex Muon::MuonStationIndex::toLayerIndex ( StIndex  index )

static

convert StIndex into LayerIndex

Definition at line 72 of file MuonStationIndex.cxx.

                                                 {
      static constexpr std::array<MuonStationIndex::LayerIndex, N_STATION_INDEX> stationToLayerIndex {
         MuonStationIndex::Inner, MuonStationIndex::Middle,
         MuonStationIndex::Outer, MuonStationIndex::BarrelExtended,
         MuonStationIndex::Inner, MuonStationIndex::Middle,
         MuonStationIndex::Outer, MuonStationIndex::Extended,
         MuonStationIndex::LayerIndexMax
      };
      return stationToLayerIndex[ index ];
   }

toStationIndex() [1/2]

MuonStationIndex::StIndex Muon::MuonStationIndex::toStationIndex ( ChIndex  index )

static

convert ChIndex into StIndex

Definition at line 43 of file MuonStationIndex.cxx.

                                                   {
      static constexpr std::array<MuonStationIndex::StIndex, N_CHAMBER_INDEX> chamberToStationIndex {
         MuonStationIndex::BI, MuonStationIndex::BI, MuonStationIndex::BM,
         MuonStationIndex::BM, MuonStationIndex::BO, MuonStationIndex::BO,
         MuonStationIndex::BE, MuonStationIndex::EI, MuonStationIndex::EI,
         MuonStationIndex::EM, MuonStationIndex::EM, MuonStationIndex::EO,
         MuonStationIndex::EO, MuonStationIndex::EE, MuonStationIndex::EE,
         MuonStationIndex::EI, MuonStationIndex::EI, MuonStationIndex::StIndexMax
      };
      return chamberToStationIndex[ index ];
   }

toStationIndex() [2/2]

MuonStationIndex::StIndex Muon::MuonStationIndex::toStationIndex ( DetectorRegionIndex  region, LayerIndex  layer  )

static

convert DetectorRegionIndex + LayerIndex into StIndex

Definition at line 84 of file MuonStationIndex.cxx.

                                                        {
      static constexpr std::array<MuonStationIndex::StIndex, N_REGIONLAYER_INDEX> regionLayerToStationIndex {
         MuonStationIndex::EI, MuonStationIndex::EM, MuonStationIndex::EO,
         MuonStationIndex::EE, MuonStationIndex::BE, MuonStationIndex::BI,
         MuonStationIndex::BM, MuonStationIndex::BO, MuonStationIndex::StUnknown,
         MuonStationIndex::StUnknown,
         MuonStationIndex::EI, MuonStationIndex::EM, MuonStationIndex::EO,
         MuonStationIndex::EE, MuonStationIndex::BE
      };
      return regionLayerToStationIndex[ sectorLayerHash( region, layer ) ];
   }

---

The documentation for this class was generated from the following files:

• MuonStationIndex.h
• MuonStationIndex.cxx