Muon::MuonStationIndex Namespace Reference

Enumerations
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 to classify the different chamber layers in the muon spectrometer More...
enum class	StIndex : int8_t {   StUnknown = -1 , BI , BM , BO ,   BE , EI , EM , EO ,   EE , StIndexMax }
	enum to classify the different station layers in the muon spectrometer More...
enum class	PhiIndex : int8_t {   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 class	LayerIndex : int8_t {   LayerUnknown = -1 , Inner , Middle , Outer ,   Extended , BarrelExtended , LayerIndexMax }
	enum to classify the different layers in the muon spectrometer More...
enum class	DetectorRegionIndex : int8_t {   DetectorRegionUnknown = -1 , EndcapA , Barrel , EndcapC ,   DetectorRegionIndexMax }
	enum to classify the different layers in the muon spectrometer More...
enum class	TechnologyIndex : int8_t {   TechnologyUnknown = -1 , MDT , CSC , RPC ,   TGC , STGC , MM , TechnologyIndexMax }
	enum to classify the different layers in the muon spectrometer More...

Functions
template<typename EnumType>
constexpr int	toInt (const EnumType enumVal)
StIndex	toStationIndex (ChIndex index)
	convert ChIndex into StIndex
LayerIndex	toLayerIndex (ChIndex index)
	convert ChIndex into LayerIndex
LayerIndex	toLayerIndex (StIndex index)
	convert StIndex into LayerIndex
StIndex	toStationIndex (DetectorRegionIndex region, LayerIndex layer)
	convert DetectorRegionIndex + LayerIndex into StIndex
DetectorRegionIndex	toDetectorRegionIndex (ChIndex index, int8_t etaSign)
	convert ChamberIndex + etaSign into DetectorRegionIndex
ChIndex	toChamberIndex (DetectorRegionIndex region, LayerIndex layer, bool isSmall)
	convert DetectorRegionIndex + LayerIndex + isSmall into ChIndex
bool	isBarrel (const ChIndex index)
	Returns true if the chamber index points to a barrel chamber.
bool	isBarrel (const StIndex index)
	Returns true if the station index points to a barrel chamber.
bool	isSmall (const ChIndex index)
	Returns true if the chamber index is in a small sector.
ChIndex	toChamberIndex (StIndex stIndex, bool isSmall)
	convert StIndex + isSmall into ChIndex
const std::string &	phiName (PhiIndex index)
	convert PhiIndex into a string
const std::string &	stName (StIndex index)
	convert StIndex into a string
const std::string &	chName (ChIndex index)
	convert ChIndex into a string
const std::string &	regionName (DetectorRegionIndex index)
	convert DetectorRegionIndex into a string
const std::string &	layerName (LayerIndex index)
	convert LayerIndex into a string
const std::string &	technologyName (TechnologyIndex index)
	convert LayerIndex into a string
unsigned int	sectorLayerHash (DetectorRegionIndex detectorRegionIndex, LayerIndex layerIndex)
	create a hash out of region and layer
unsigned int	regionChambernHash (DetectorRegionIndex regionIdx, ChIndex chamberIdx)
	create a hash out of chamber index and detector region
constexpr unsigned int	sectorLayerHashMax ()
	maximum create a hash out of region and layer
constexpr unsigned int	regionChamberHashMax ()
	maximum create a hash out of chamber and region index
std::pair< DetectorRegionIndex, LayerIndex >	decomposeSectorLayerHash (unsigned int hash)
	decompose the hash into Region and Layer
std::pair< DetectorRegionIndex, ChIndex >	decomposeRegionChamberHash (unsigned int hash)
	decompose the hash into Region and Chamber
constexpr unsigned	numberOfSectors ()
	return total number of sectors
ChIndex	chIndex (const std::string &index)
	convert ChIndex name string to enum
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)

Enumeration Type Documentation

ChIndex

enum class Muon::MuonStationIndex::ChIndex : int8_t

strong

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 16 of file MuonStationIndex.h.

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

DetectorRegionIndex

enum class Muon::MuonStationIndex::DetectorRegionIndex : int8_t

strong

enum to classify the different layers in the muon spectrometer

Enumerator
DetectorRegionUnknown
EndcapA
Barrel
EndcapC
DetectorRegionIndexMax

Definition at line 48 of file MuonStationIndex.h.

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

LayerIndex

enum class typedef HitSummary::LayerIndex MuonR4::LayerIndex = HitSummary::LayerIndex

strong

enum to classify the different layers in the muon spectrometer

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

Definition at line 39 of file MuonStationIndex.h.

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

PhiIndex

enum class Muon::MuonStationIndex::PhiIndex : int8_t

strong

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 32 of file MuonStationIndex.h.

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

StIndex

enum class Muon::MuonStationIndex::StIndex : int8_t

strong

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 24 of file MuonStationIndex.h.

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

TechnologyIndex

enum class Muon::MuonStationIndex::TechnologyIndex : int8_t

strong

enum to classify the different layers in the muon spectrometer

Enumerator
TechnologyUnknown
MDT
CSC
RPC
TGC
STGC
MM
TechnologyIndexMax

Definition at line 55 of file MuonStationIndex.h.

                              : int8_t {
      TechnologyUnknown = -1,
      MDT, CSC, RPC, TGC, STGC, MM,
      TechnologyIndexMax  
    };    

Function Documentation

chIndex()

ChIndex Muon::MuonStationIndex::chIndex

(

const std::string &

index

)

convert ChIndex name string to enum

Definition at line 12 of file MuonStationIndex.cxx.

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

chName()

const std::string & Muon::MuonStationIndex::chName

(

ChIndex

index

)

convert ChIndex into a string

Definition at line 120 of file MuonStationIndex.cxx.

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

decomposeRegionChamberHash()

std::pair< DetectorRegionIndex, ChIndex > Muon::MuonStationIndex::decomposeRegionChamberHash

(

unsigned int

hash

)

decompose the hash into Region and Chamber

decomposeSectorLayerHash()

std::pair< DetectorRegionIndex, LayerIndex > Muon::MuonStationIndex::decomposeSectorLayerHash

(

unsigned int

hash

)

decompose the hash into Region and Layer

isBarrel() [1/2]

bool Muon::MuonStationIndex::isBarrel

(

const ChIndex

index

)

Returns true if the chamber index points to a barrel chamber.

isBarrel() [2/2]

bool Muon::MuonStationIndex::isBarrel

(

const StIndex

index

)

Returns true if the station index points to a barrel chamber.

isSmall()

bool Muon::MuonStationIndex::isSmall

(

const ChIndex

index

)

Returns true if the chamber index is in a small sector.

layerName()

const std::string & Muon::MuonStationIndex::layerName

(

LayerIndex

index

)

convert LayerIndex into a string

Definition at line 154 of file MuonStationIndex.cxx.

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

numberOfSectors()

unsigned Muon::MuonStationIndex::numberOfSectors ( )

constexpr

return total number of sectors

Definition at line 132 of file MuonStationIndex.h.

{ return 16; }

operator<<() [1/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const ChIndex	chIdx )

Definition at line 189 of file MuonStationIndex.cxx.

                                                                 {
         return (ostr<<chName(chIdx));
    }

operator<<() [2/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const DetectorRegionIndex	detIdx )

Definition at line 195 of file MuonStationIndex.cxx.

                                                                              {
         return (ostr<<regionName(detIdx));
    }

operator<<() [3/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const LayerIndex	layIdx )

Definition at line 198 of file MuonStationIndex.cxx.

                                                                     {
         return (ostr<<layerName(layIdx));
    }

operator<<() [4/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const PhiIndex	phiIdx )

Definition at line 192 of file MuonStationIndex.cxx.

                                                                   {
         return (ostr<<phiName(phiIdx));
    }

operator<<() [5/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const StIndex	stIdx )

Definition at line 186 of file MuonStationIndex.cxx.

                                                                 {
         return (ostr<<stName(stIdx));
    }

operator<<() [6/6]

std::ostream & Muon::MuonStationIndex::operator<<	(	std::ostream &	ostr,
		const TechnologyIndex	techIdx )

Definition at line 201 of file MuonStationIndex.cxx.

                                                                           {
         return (ostr<<technologyName(techIdx));
    }

phiName()

const std::string & Muon::MuonStationIndex::phiName

(

PhiIndex

index

)

convert PhiIndex into a string

Definition at line 88 of file MuonStationIndex.cxx.

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

regionChamberHashMax()

unsigned int Muon::MuonStationIndex::regionChamberHashMax ( )

constexpr

maximum create a hash out of chamber and region index

Definition at line 121 of file MuonStationIndex.h.

                                                  {
      return toInt(DetectorRegionIndex::DetectorRegionIndexMax)*toInt(ChIndex::ChIndexMax);
 
    }

regionChambernHash()

unsigned int Muon::MuonStationIndex::regionChambernHash	(	DetectorRegionIndex	regionIdx,
		ChIndex	chamberIdx )

create a hash out of chamber index and detector region

regionName()

const std::string & Muon::MuonStationIndex::regionName

(

DetectorRegionIndex

index

)

convert DetectorRegionIndex into a string

Definition at line 139 of file MuonStationIndex.cxx.

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

sectorLayerHash()

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

create a hash out of region and layer

sectorLayerHashMax()

unsigned int Muon::MuonStationIndex::sectorLayerHashMax ( )

constexpr

maximum create a hash out of region and layer

Definition at line 117 of file MuonStationIndex.h.

                                                {
       return toInt(DetectorRegionIndex::DetectorRegionIndexMax)*toInt(LayerIndex::LayerIndexMax);
    }

stName()

const std::string & Muon::MuonStationIndex::stName

(

StIndex

index

)

convert StIndex into a string

Definition at line 105 of file MuonStationIndex.cxx.

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

technologyName()

const std::string & Muon::MuonStationIndex::technologyName

(

TechnologyIndex

index

)

convert LayerIndex into a string

Definition at line 170 of file MuonStationIndex.cxx.

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

toChamberIndex() [1/2]

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

convert DetectorRegionIndex + LayerIndex + isSmall into ChIndex

EndCapA hash

Barrel hash column BEE is not counted for the small sectors

EndCapC hash

EndCapA hash

Barrel hash column BEE is not counted for the large sectors

EndCapC hash

Definition at line 64 of file MuonStationIndex.cxx.

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

toChamberIndex() [2/2]

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

convert StIndex + isSmall into ChIndex

toDetectorRegionIndex()

DetectorRegionIndex Muon::MuonStationIndex::toDetectorRegionIndex	(	ChIndex	index,
		int8_t	etaSign )

convert ChamberIndex + etaSign into DetectorRegionIndex

toInt()

template<typename EnumType>

int Muon::MuonStationIndex::toInt ( const EnumType enumVal )

constexpr

Definition at line 62 of file MuonStationIndex.h.

                                                {
      return static_cast<int>(enumVal);
    }

toLayerIndex() [1/2]

LayerIndex Muon::MuonStationIndex::toLayerIndex

(

ChIndex

index

)

convert ChIndex into LayerIndex

toLayerIndex() [2/2]

LayerIndex Muon::MuonStationIndex::toLayerIndex

(

StIndex

index

)

convert StIndex into LayerIndex

toStationIndex() [1/2]

StIndex Muon::MuonStationIndex::toStationIndex

(

ChIndex

index

)

convert ChIndex into StIndex

toStationIndex() [2/2]

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

convert DetectorRegionIndex + LayerIndex into StIndex

Definition at line 50 of file MuonStationIndex.cxx.

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