MuonFixedLongId.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
/***************************************************************************
 * Muon Calibration Utilities
 * -----------------------------------------
 *
 * Authors       : Martin Woudstra, Zdenko van Kesteren, Peter Kluit
 * Creation Date: 21 March 2005
 * Updated : 03 December 2007
 * Updated : 16 January  2015 E. Diehl Add BME/BOE/BMG chambers 
 *   Note: BOE=BOL in offline, so do not need to explicitly add BOE, it will be handled as BOL
 ***************************************************************************/
 
 
#ifndef MUONCALIBIDENTIFIER_MUONFIXEDLONGID_H
#define MUONCALIBIDENTIFIER_MUONFIXEDLONGID_H
 
#include "MuonCalibIdentifier/MuonFixedId.h"
 
// std
#include <iostream>
#include <iomanip>
#include <string>
 
#include <cstdlib>
#include <limits>
#include <cstdint>
 
namespace MuonCalib {
 
class MuonFixedLongId {
public:
 
   enum Technology {
     technologyMDT = 0,
     technologyCSC = 1,
     technologyTGC = 2,
     technologyRPC = 3,
     technologyMMG = 4,
     technologySTG = 5,
   };
   
   enum StationName {
     BIL =  1,
     BIS =  2,
     BML =  3,
     BMS =  4,
     BOL =  5,
     BOS =  6,
     BEE =  7,
     BIR =  8,
     BMF =  9,
     BOF = 10,
     BOG = 11,
     BME = 12,
     BIM = 13,
     EIC = 14,
     EIL = 15,
     EEL = 16,
     EES = 17,
     EMC = 18,
     EML = 19,
     EMS = 20,
     EOC = 21,
     EOL = 22,
     EOS = 23,
     EIS = 24,
     T1F = 25,
     T1E = 26,
     T2F = 27,
     T2E = 28,
     T3F = 29,
     T3E = 30,
     T4F = 31,
     T4E = 32,
     CSS = 33,
     CSL = 34,
     BMG = 35,
     MMS = 36,
     MML = 37,
     STS = 38,
     STL = 39,
     INVALID = -1,
   };
 
   enum StgChannelType {
     stgChannelPad   = 0,
     stgChannelStrip = 1,
     stgChannelWire  = 2,
   };
 
   MuonFixedLongId(); 
   explicit MuonFixedLongId( uint64_t id );
 
   void initFromFixedId(MuonFixedId other);
 
   uint64_t getIdLong() const;
   void clear();
   bool isValid() const;
 
   bool is_mdt() const;
   bool is_tgc() const;
   bool is_csc() const;
   bool is_rpc() const;
   bool is_mmg() const;
   bool is_stg() const;
 
   void set_mdt();
   void set_tgc();
   void set_csc();
   void set_rpc();
   void set_mmg();
   void set_stg();
 
 
   bool operator==( const MuonFixedLongId& rhs ) const;
   bool operator!=( const MuonFixedLongId& rhs ) const;
   bool operator<( const MuonFixedLongId& rhs ) const;
   
   std::ostream& dump(std::ostream& os) const;
 
//   friend std::istream& operator>>( std::istream& is, MuonCalib::MuonFixedLongId& id );
 
// Muon generic code
 
   bool setTechnology( Technology num );
   bool setStationName( StationName num );
   bool setStationEta( int num );
   bool setStationPhi( int num );
 
   Technology technology() const;
   std::string_view technologyString() const;
   StationName stationName() const;
   std::string_view stationNameString() const;
   int eta() const;
   int phi() const;
   
   static int technologyMin();
   static int stationNameMin();
   static int etaMin();
   static int phiMin();
 
   static int technologyMax();
   static int stationNameMax();
   static int etaMax();
   static int phiMax();
 
   static StationName stationStringToFixedStationNumber(std::string_view station);
   static std::string_view stationNumberToFixedStationString(StationName station);
 
 
//  Mdt specific code
 
   bool setMdtTube( int num );
   bool setMdtTubeLayer( int num );
   bool setMdtMultilayer( int num );
 
   int mdtTube() const;
   int mdtTubeLayer() const;
   int mdtMultilayer() const;
   int mdtMezzanine() const;
 
   MuonFixedLongId mdtChamberId() const;
 
   MuonFixedLongId mdtMultilayerId() const;
 
   static int mdtTubeMin();
   static int mdtTubeLayerMin();
   static int mdtMultilayerMin();
 
   static int mdtTubeMax();
   static int mdtTubeLayerMax();
   static int mdtMultilayerMax();
 
   
//  Csc specific code
 
   bool setCscChamberLayer( int num );
   bool setCscWireLayer( int num );
   bool setCscMeasuresPhi( int num );
   bool setCscStrip( int num );  
 
   int cscChamberLayer() const;
   int cscWireLayer() const;
   int cscMeasuresPhi() const;
   int cscStrip() const;
 
   static int cscChamberLayerMin(); 
   static int cscWireLayerMin(); 
   static int cscMeasuresPhiMin(); 
   static int cscStripMin();
   
   static int cscChamberLayerMax(); 
   static int cscWireLayerMax(); 
   static int cscMeasuresPhiMax(); 
   static int cscStripMax();
 
//  Rpc specific code 
 
   bool setRpcDoubletR( int num );
   bool setRpcDoubletZ( int num );
   bool setRpcDoubletPhi( int num );
   bool setRpcGasGap( int num );
   bool setRpcMeasuresPhi( int num );
   bool setRpcStrip( int num );
   
   int rpcDoubletR() const;
   int rpcDoubletZ() const;
   int rpcDoubletPhi() const;
   int rpcGasGap() const;
   int rpcMeasuresPhi() const;
   int rpcStrip() const;
 
//  Tgc specific code
 
   bool setTgcGasGap( int num );
   bool setTgcIsStrip( int num );
   bool setTgcChannel( int num );
 
   int tgcGasGap() const;
   int tgcIsStrip() const;
   int tgcChannel() const;
 
//  Mmg specific code
 
   bool setMmgMultilayer( int num );
   bool setMmgGasGap( int num );
   bool setMmgStrip( int num );  
 
   int mmgMultilayer() const;
   int mmgGasGap() const;
   int mmgStrip() const;
   bool mmgIsStereo() const;
 
// Stg specific code
 
   bool setStgMultilayer( int num );
   bool setStgGasGap( int num );
   bool setStgChannelType( StgChannelType num );
   bool setStgChannel( int num );
 
   int stgMultilayer() const;
   int stgGasGap() const;
   StgChannelType stgChannelType() const;
   int stgChannel() const;
 
 
private:
   // Private member functions
 
// Muon generic code
 
   bool setTechnologyIndex( uint64_t idx );
   bool setStationNameIndex( uint64_t idx );
   bool setStationEtaIndex( uint64_t idx );
   bool setStationPhiIndex( uint64_t idx );
 
   unsigned int technologyIndex() const;
   unsigned int stationNameIndex() const;
   unsigned int etaIndex() const;
   unsigned int phiIndex() const;
 
//  Mdt specific code
 
   bool setMdtTubeIndex( uint64_t idx ) ;
   bool setMdtTubeLayerIndex( uint64_t idx ) ;
   bool setMdtMultilayerIndex( uint64_t idx ) ;
 
   unsigned int mdtTubeIndex() const;
   unsigned int mdtTubeLayerIndex() const;
   unsigned int mdtMultilayerIndex() const;
 
//  Csc specific code
 
   bool setCscChamberLayerIndex( uint64_t idx );
   bool setCscWireLayerIndex( uint64_t idx );
   bool setCscMeasuresPhiIndex( uint64_t idx );
   bool setCscStripIndex( uint64_t idx );
 
   unsigned int cscChamberLayerIndex() const;
   unsigned int cscWireLayerIndex() const;
   unsigned int cscMeasuresPhiIndex() const;
   unsigned int cscStripIndex() const;
 
//  Rpc specific code 
 
   bool setRpcDoubletRIndex( uint64_t idx );
   bool setRpcDoubletZIndex( uint64_t idx );
   bool setRpcDoubletPhiIndex( uint64_t idx );
   bool setRpcGasGapIndex( uint64_t idx );
   bool setRpcMeasuresPhiIndex( uint64_t idx );
   bool setRpcStripIndex( uint64_t idx );
   
   unsigned int rpcDoubletRIndex() const;
   unsigned int rpcDoubletZIndex() const;
   unsigned int rpcDoubletPhiIndex() const;
   unsigned int rpcGasGapIndex() const;
   unsigned int rpcMeasuresPhiIndex() const;
   unsigned int rpcStripIndex() const;
 
//  Tgc specific code
 
   bool setTgcGasGapIndex( uint64_t idx );  
   bool setTgcIsStripIndex( uint64_t idx );
   bool setTgcChannelIndex( uint64_t idx );  
 
   unsigned int tgcGasGapIndex() const;
   unsigned int tgcIsStripIndex() const;
   unsigned int tgcChannelIndex() const;
 
//  Mmg specific code
 
   bool setMmgMultilayerIndex( uint64_t idx ) ;
   bool setMmgGasGapIndex( uint64_t idx );
   bool setMmgStripIndex( uint64_t idx );
 
   unsigned int mmgMultilayerIndex() const;
   unsigned int mmgGasGapIndex() const;
   unsigned int mmgStripIndex() const;
 
// Stg specific code
 
   bool setStgMultilayerIndex( uint64_t idx ) ;
   bool setStgGasGapIndex( uint64_t idx );
   bool setStgChannelTypeIndex( uint64_t idx );  
   bool setStgChannelIndex( uint64_t idx );  
 
   unsigned int stgMultilayerIndex() const;
   unsigned int stgGasGapIndex() const;
   unsigned int stgChannelTypeIndex() const;   
   unsigned int stgChannelIndex() const;   
 
 
 
   // the member holding the packed fields
   uint64_t m_data;
 
   static const uint64_t kInvalidData = 0xFFFFFFFFFFFFFFFF;
 
//   Muon generic
 
   static const uint64_t     kTechnologyMask   = 15;
   static const unsigned int kTechnologyShift  = 60;
   static const int          kTechnologyMin    = 0;
   
   static const int kNumberOfTechnologies = 6;
   static const char kTechnologyStrings[kNumberOfTechnologies][4];
 
   static const uint64_t     kStationNameMask      = 127;
   static const unsigned int kStationNameShift     = 53;
   static const int          kStationNameMin       = 1;
 
   static const uint64_t     kStationEtaMask          = 63;
   static const unsigned int kStationEtaShift         = 47;
   static const int          kStationEtaMin           = -31;
 
   static const uint64_t     kStationPhiMask          = 127;
   static const unsigned int kStationPhiShift         = 40;
   static const int          kStationPhiMin           = 1;
 
   static const int kNumberOfStationNames = 39;
   static const char kStationNameStrings[kNumberOfStationNames][4];
 
   // the full station information for making a station identifier
   static const unsigned int kStationShift = kStationPhiShift; // the smallest shift
   static const uint64_t     kStationMask = 
     ( (kTechnologyMask  << kTechnologyShift)  |
       (kStationNameMask << kStationNameShift) |
       (kStationEtaMask  << kStationEtaShift)  |
       (kStationPhiMask  << kStationPhiShift)    ) >> kStationShift; // kStationShift for consistent meaning
 
//   Mdt specific code 
 
   static const uint64_t     kMdtMultilayerMask    = 7;
   static const unsigned int kMdtMultilayerShift   = 14;
   static const int          kMdtMultilayerMin     = 1;
 
   static const uint64_t     kMdtTubeLayerMask     = 15;
   static const unsigned int kMdtTubeLayerShift    = 10;
   static const int          kMdtTubeLayerMin      = 1;
 
   static const uint64_t     kMdtTubeMask          = 1023;
   static const unsigned int kMdtTubeShift         = 0;
   static const int          kMdtTubeMin           = 1;
 
//  Csc specific code
 
   static const uint64_t     kCscChamberLayerMask  = 7;
   static const unsigned int kCscChamberLayerShift = 15;
   static const int          kCscChamberLayerMin   = 1;
 
   static const uint64_t     kCscWireLayerMask     = 15;
   static const unsigned int kCscWireLayerShift    = 11;
   static const int          kCscWireLayerMin      = 1;
 
   static const uint64_t     kCscMeasuresPhiMask   = 1;
   static const unsigned int kCscMeasuresPhiShift  = 10;
   static const int          kCscMeasuresPhiMin    = 0;
 
   static const uint64_t     kCscStripMask         = 1023;
   static const unsigned int kCscStripShift        = 0;
   static const int          kCscStripMin          = 1;
 
//  Rpc specific code
 
   static const uint64_t     kRpcDoubletRMask      = 3;
   static const unsigned int kRpcDoubletRShift     = 20; 
   static const int          kRpcDoubletRMin       = 1;
 
   static const uint64_t     kRpcDoubletZMask      = 15;
   static const unsigned int kRpcDoubletZShift     = 16; 
   static const int          kRpcDoubletZMin       = 1;
 
   static const uint64_t     kRpcDoubletPhiMask    = 3;
   static const unsigned int kRpcDoubletPhiShift   = 14; 
   static const int          kRpcDoubletPhiMin     = 1;
 
   static const uint64_t     kRpcGasGapMask        = 3;
   static const unsigned int kRpcGasGapShift       = 12;  
   static const int          kRpcGasGapMin         = 1;
 
   static const uint64_t     kRpcMeasuresPhiMask   = 3;
   static const unsigned int kRpcMeasuresPhiShift  = 10;  
   static const int          kRpcMeasuresPhiMin    = 0;
 
   static const uint64_t     kRpcStripMask         = 1023;
   static const unsigned int kRpcStripShift        = 0; 
   static const int          kRpcStripMin          = 1;
 
// Tgc specific code 
   static const uint64_t     kTgcGasGapMask        = 7;
   static const unsigned int kTgcGasGapShift       = 11;
   static const int          kTgcGasGapMin         = 1;
 
   static const uint64_t     kTgcIsStripMask       = 1;
   static const unsigned int kTgcIsStripShift      = 10;
   static const int          kTgcIsStripMin        = 0;
 
   static const uint64_t     kTgcChannelMask       = 1023;
   static const unsigned int kTgcChannelShift      = 0;
   static const int          kTgcChannelMin        = 1;
 
// MM specific code
   static const uint64_t     kMmgMultilayerMask    = 7;
   static const unsigned int kMmgMultilayerShift   = 19;
   static const int          kMmgMultilayerMin     = 1;
 
   static const uint64_t     kMmgGasGapMask        = 15;
   static const unsigned int kMmgGasGapShift       = 15;
   static const int          kMmgGasGapMin         = 1;
 
   static const uint64_t     kMmgStripMask         = 32767;
   static const unsigned int kMmgStripShift        = 0;
   static const int          kMmgStripMin          = 0;
 
// sTGC specific code
   static const uint64_t     kStgMultilayerMask    = 7;
   static const unsigned int kStgMultilayerShift   = 21;
   static const int          kStgMultilayerMin     = 1;
 
   static const uint64_t     kStgGasGapMask        = 15;
   static const unsigned int kStgGasGapShift       = 17;
   static const int          kStgGasGapMin         = 1;
 
   static const uint64_t     kStgChannelTypeMask   = 3;
   static const unsigned int kStgChannelTypeShift  = 15;
   static const int          kStgChannelTypeMin    = 0;
 
   static const uint64_t     kStgChannelMask       = 32767;
   static const unsigned int kStgChannelShift      = 0;
   static const int          kStgChannelMin        = 0;
};
 
// Muon generic methods
 
inline MuonFixedLongId::MuonFixedLongId()
  : m_data(kInvalidData){
  }
 
inline MuonFixedLongId::MuonFixedLongId( uint64_t id ) {
  if (id <= std::numeric_limits<uint32_t>::max()) {
    // we were passed a 32 bit identifier, import values from MuonFixedId
    initFromFixedId(MuonFixedId(static_cast<uint32_t>(id)));
  } else {
    m_data = id;
  }
}
 
inline uint64_t MuonFixedLongId::getIdLong() const{
  return m_data;
}
/* void MuonFixedLongId::setMuonIdentifier( int id ){ */
/*   if( id>-1 || id<kInvalidData ) m_data = id; */
/*   else  m_data = kInvalidData; */
/* } */
 
inline void MuonFixedLongId::clear() {
   m_data = kInvalidData;
}
 
inline bool MuonFixedLongId::isValid() const {
  return m_data != kInvalidData;
}
 
inline bool MuonFixedLongId::is_mdt() const{
  return isValid() && technology() == Technology::technologyMDT;
}
 
inline bool MuonFixedLongId::is_tgc() const{
  return isValid() && technology() == Technology::technologyTGC;
}
 
inline bool MuonFixedLongId::is_csc() const{
  return isValid() && technology() == Technology::technologyCSC;
}
 
inline bool MuonFixedLongId::is_rpc() const{
  return isValid() && technology() == Technology::technologyRPC;
}
 
inline bool MuonFixedLongId::is_mmg() const{
  return isValid() && technology() == Technology::technologyMMG;
}
 
inline bool MuonFixedLongId::is_stg() const{
  return isValid() && technology() == Technology::technologySTG;
}
 
inline void MuonFixedLongId::set_mdt() {
  setTechnology( Technology::technologyMDT );
}
 
inline void MuonFixedLongId::set_csc() {
  setTechnology( Technology::technologyCSC );
}
 
inline void MuonFixedLongId::set_tgc() {
  setTechnology( Technology::technologyTGC );
}
 
inline void MuonFixedLongId::set_rpc() {
  setTechnology( Technology::technologyRPC );
}
 
inline void MuonFixedLongId::set_mmg() {
  setTechnology( Technology::technologyMMG );
}
 
inline void MuonFixedLongId::set_stg() {
  setTechnology( Technology::technologySTG );
}
 
inline bool MuonFixedLongId::operator==( const MuonFixedLongId& rhs ) const {
   return m_data == rhs.m_data;
}
 
inline bool MuonFixedLongId::operator!=( const MuonFixedLongId& rhs ) const {
   return m_data != rhs.m_data;
}
 
inline bool MuonFixedLongId::operator<( const MuonFixedLongId& rhs ) const {
   return m_data < rhs.m_data;
}
 
inline bool MuonFixedLongId::setTechnologyIndex( uint64_t idx ) { 
  if ( idx > kTechnologyMask ) {
      clear();
      return false;
   }
   m_data &= ~(kTechnologyMask << kTechnologyShift);
   m_data |= (idx & kTechnologyMask) << kTechnologyShift;
   return true;
}
 
inline bool MuonFixedLongId::setTechnology( Technology num ) { 
   return setTechnologyIndex( num - kTechnologyMin );
}
 
inline unsigned int MuonFixedLongId::technologyIndex() const { 
   return (m_data >> kTechnologyShift) & kTechnologyMask;
}
 
inline MuonFixedLongId::Technology MuonFixedLongId::technology() const {
   return static_cast<Technology>(technologyIndex() + kTechnologyMin);
}
 
inline std::string_view MuonFixedLongId::technologyString() const {
  int index = technologyIndex();
  if ( index >= 0 && index < kNumberOfTechnologies ) {
    return kTechnologyStrings[index];
  }
  return "???";
}
 
inline bool MuonFixedLongId::setStationNameIndex( uint64_t idx ) {
  if ( idx > kStationNameMask ) {
      clear();
      return false;
   }
   m_data &= ~(kStationNameMask << kStationNameShift);
   m_data |= (idx & kStationNameMask) << kStationNameShift;
   return true;
}
 
inline bool MuonFixedLongId::setStationName( StationName num ) {
   return setStationNameIndex( num - kStationNameMin );
}
 
inline unsigned int MuonFixedLongId::stationNameIndex() const {
   return (m_data >> kStationNameShift) & kStationNameMask;
}
 
inline MuonFixedLongId::StationName MuonFixedLongId::stationName() const {
   return static_cast<StationName>(stationNameIndex() + kStationNameMin);
}
 
inline std::string_view MuonFixedLongId::stationNameString() const {
  int index = stationNameIndex();
  if ( index >= 0 && index < kNumberOfStationNames ) {
    return kStationNameStrings[index];
  } 
  return "XXX";    
}
 
inline bool MuonFixedLongId::setStationEtaIndex( uint64_t idx ) {
  if ( idx > kStationEtaMask ) {
      clear();
      return false;
   }
   m_data &= ~(kStationEtaMask << kStationEtaShift);
   m_data |= (idx & kStationEtaMask) << kStationEtaShift;
   return true;
}
 
inline bool MuonFixedLongId::setStationEta( int num ) {
   return setStationEtaIndex( num - kStationEtaMin );
}
 
inline unsigned int MuonFixedLongId::etaIndex() const {
   return (m_data >> kStationEtaShift) & kStationEtaMask;
}
 
inline int MuonFixedLongId::eta() const {
   return etaIndex() + kStationEtaMin;
}
 
 
inline bool MuonFixedLongId::setStationPhiIndex( uint64_t idx ) {
  if ( idx > kStationPhiMask ) {
      clear();
      return false;
   }
   m_data &= ~(kStationPhiMask << kStationPhiShift);
   m_data |= (idx & kStationPhiMask) << kStationPhiShift;
   return true;
}
 
inline bool MuonFixedLongId::setStationPhi( int num ) {
   return setStationPhiIndex( num - kStationPhiMin );
}
 
inline unsigned int MuonFixedLongId::phiIndex() const {
   return (m_data >> kStationPhiShift) & kStationPhiMask;
}
 
inline int MuonFixedLongId::phi() const {
   return phiIndex() + kStationPhiMin;
}
  
inline int MuonFixedLongId::technologyMin(){
  return kTechnologyMin;
}
 
inline int MuonFixedLongId::stationNameMin(){
  return kStationNameMin;
}
 
inline int MuonFixedLongId::etaMin(){ 
  return kStationEtaMin;
}
 
inline int MuonFixedLongId::phiMin(){
  return kStationPhiMin;
}
 
inline int MuonFixedLongId::technologyMax(){
  return kTechnologyMin + kTechnologyMask;
}
 
inline int MuonFixedLongId::stationNameMax(){ 
  return kStationNameMin + kStationNameMask;
}
 
inline int MuonFixedLongId::etaMax(){ 
  return kStationEtaMin + kStationEtaMask;
}
 
inline int MuonFixedLongId::phiMax(){
   return kStationPhiMin + kStationPhiMask; 
}
 
inline MuonFixedLongId::StationName MuonFixedLongId::stationStringToFixedStationNumber(std::string_view station ) {
  for ( int i = 0; i < kNumberOfStationNames; ++i ) {
    if ( station == kStationNameStrings[i] ) return static_cast<StationName>(i + kStationNameMin);
  }
  return StationName::INVALID;  // signal error if not found
}
 
inline std::string_view MuonFixedLongId::stationNumberToFixedStationString(StationName station) {
  int index = station - kStationNameMin;
  if ( index >= 0 && index < kNumberOfStationNames ) {
    return kStationNameStrings[index];
  }
  return "XXX";   // signal error if not found
}
 
// Mdt specific methods
 
inline bool MuonFixedLongId::setMdtTubeIndex( uint64_t idx ) {
  if ( idx > kMdtTubeMask ) {
      clear();
      return false;
   }
   m_data &= ~(kMdtTubeMask << kMdtTubeShift);
   m_data |= (idx & kMdtTubeMask) << kMdtTubeShift;
   return true;
}
 
inline bool MuonFixedLongId::setMdtTube( int num ) {
   return setMdtTubeIndex( num - kMdtTubeMin );
}
 
inline unsigned int MuonFixedLongId::mdtTubeIndex() const {
   return (m_data >> kMdtTubeShift) & kMdtTubeMask;
}
 
inline int MuonFixedLongId::mdtTube() const {
   return mdtTubeIndex() + kMdtTubeMin;
}
 
inline int MuonFixedLongId::mdtMezzanine() const {
   StationName Ichamber =  stationName() ;
   int Ieta = eta() ;
   int Iphi = phi() ;
   int Iml  = mdtMultilayer() ;
   int Itube = mdtTube() ;
   if (Ieta < 0 ) Ieta = -Ieta*10 ;
   int ImezzTubes = 8 ;
   if (Ichamber==StationName::BIL || Ichamber==StationName::BIS || Ichamber==StationName::BIR
       || Ichamber==StationName::BIM || Ichamber==StationName::BEE || Ichamber==StationName::EIL
       || Ichamber==StationName::EIS) {
     ImezzTubes=6;
   }
//exception BIS eta=8 is a 3-layer chamber
   if(Ichamber==StationName::BIS && std::abs(Ieta)==8) ImezzTubes=8;
   int Imezz = ((Itube-1)/ImezzTubes)*2+(Iml-1) ;
   Imezz = 9*100000000 + Ichamber*1000000 + Ieta*10000 + Iphi*100 + Imezz ;
   return Imezz ;
}
 
inline bool MuonFixedLongId::setMdtTubeLayerIndex( uint64_t idx ) {
  if ( idx > kMdtTubeLayerMask ) {
      clear();
      return false;
   }
   m_data &= ~(kMdtTubeLayerMask << kMdtTubeLayerShift);
   m_data |= (idx & kMdtTubeLayerMask) << kMdtTubeLayerShift;
   return true;
}
 
inline bool MuonFixedLongId::setMdtTubeLayer( int num ) {
   return setMdtTubeLayerIndex( num - kMdtTubeLayerMin );
}
 
inline unsigned int MuonFixedLongId::mdtTubeLayerIndex() const {
   return (m_data >> kMdtTubeLayerShift) & kMdtTubeLayerMask;
}
 
inline int MuonFixedLongId::mdtTubeLayer() const {
   return mdtTubeLayerIndex() + kMdtTubeLayerMin;
}
 
inline bool MuonFixedLongId::setMdtMultilayerIndex( uint64_t idx ) {
  if ( idx > kMdtMultilayerMask ) {
      clear();
      return false;
   }
   m_data &= ~(kMdtMultilayerMask << kMdtMultilayerShift);
   m_data |= (idx & kMdtMultilayerMask) << kMdtMultilayerShift;
   return true;
}
 
inline bool MuonFixedLongId::setMdtMultilayer( int num ) {
   return setMdtMultilayerIndex( num - kMdtMultilayerMin );
}
 
inline unsigned int MuonFixedLongId::mdtMultilayerIndex() const {
   return (m_data >> kMdtMultilayerShift) & kMdtMultilayerMask;
}
 
inline int MuonFixedLongId::mdtMultilayer() const {
   return mdtMultilayerIndex() + kMdtMultilayerMin;
}
 
inline int MuonFixedLongId::mdtTubeMin(){
  return kMdtTubeMin;
}
 
inline int MuonFixedLongId::mdtTubeMax(){
  return kMdtTubeMin + kMdtTubeMask;
}
 
inline int MuonFixedLongId::mdtTubeLayerMin(){
  return kMdtTubeLayerMin;
}
 
inline int MuonFixedLongId::mdtTubeLayerMax(){
  return kMdtTubeLayerMin + kMdtTubeLayerMask;
}
 
inline int MuonFixedLongId::mdtMultilayerMin(){
  return kMdtMultilayerMin;
}
 
inline int MuonFixedLongId::mdtMultilayerMax(){
  return kMdtMultilayerMin + kMdtMultilayerMask;
}
 
inline MuonFixedLongId MuonFixedLongId::mdtChamberId() const {
  // mdt chamber id = muon station id
  return MuonFixedLongId( m_data & (kStationMask << kStationShift) );
}
 
inline MuonFixedLongId MuonFixedLongId::mdtMultilayerId() const {
  // mdt multilayer id = muon station id + multilayer field
  return MuonFixedLongId( m_data & ( (kStationMask << kStationShift) | (kMdtMultilayerMask << kMdtMultilayerShift) ) );
}
 
 
// Csc specific methods
 
inline bool MuonFixedLongId::setCscChamberLayerIndex( uint64_t idx ) {
  if ( idx > kCscChamberLayerMask ) {
      clear();
      return false;
   }
   m_data &= ~( kCscChamberLayerMask <<  kCscChamberLayerShift );
   m_data |= (idx &  kCscChamberLayerMask) << kCscChamberLayerShift;
   return true;
}
 
inline bool MuonFixedLongId::setCscChamberLayer( int num ) {
   return setCscChamberLayerIndex( num -  kCscChamberLayerMin );
}
 
inline unsigned int MuonFixedLongId::cscChamberLayerIndex() const {
   return (m_data >> kCscChamberLayerShift) & kCscChamberLayerMask;
}
 
inline int MuonFixedLongId::cscChamberLayer() const {
   return cscChamberLayerIndex() + kCscChamberLayerMin;
}
 
 
inline bool MuonFixedLongId::setCscWireLayerIndex( uint64_t idx ) {
  if ( idx > kCscWireLayerMask ) {
      clear();
      return false;
   }
   m_data &= ~( kCscWireLayerMask <<  kCscWireLayerShift );
   m_data |= (idx &  kCscWireLayerMask) << kCscWireLayerShift;
   return true;
}
 
inline bool MuonFixedLongId::setCscWireLayer( int num ) {
  return setCscWireLayerIndex( num -  kCscWireLayerMin );
}
 
inline unsigned int MuonFixedLongId::cscWireLayerIndex() const {
   return (m_data >> kCscWireLayerShift) & kCscWireLayerMask;
}
 
inline int MuonFixedLongId::cscWireLayer() const {
   return cscWireLayerIndex() + kCscWireLayerMin;
}
 
inline bool MuonFixedLongId::setCscMeasuresPhiIndex( uint64_t idx ) {
  if ( idx > kCscMeasuresPhiMask ) {
      clear();
      return false;
   }
   m_data &= ~( kCscMeasuresPhiMask <<  kCscMeasuresPhiShift );
   m_data |= (idx &  kCscMeasuresPhiMask) << kCscMeasuresPhiShift;
   return true;
}
 
inline bool MuonFixedLongId::setCscMeasuresPhi( int num ) {
  return setCscMeasuresPhiIndex( num -  kCscMeasuresPhiMin );
}
 
inline unsigned int MuonFixedLongId::cscMeasuresPhiIndex() const {
   return (m_data >> kCscMeasuresPhiShift) & kCscMeasuresPhiMask;
}
 
inline int MuonFixedLongId::cscMeasuresPhi() const {
   return cscMeasuresPhiIndex() + kCscMeasuresPhiMin;
}
 
inline bool MuonFixedLongId::setCscStripIndex( uint64_t idx ) {
  if ( idx > kCscStripMask ) {
      clear();
      return false;
   }
   m_data &= ~( kCscStripMask <<  kCscStripShift );
   m_data |= (idx &  kCscStripMask) << kCscStripShift;
   return true;
}
 
inline bool MuonFixedLongId::setCscStrip( int num ) {
  return setCscStripIndex( num -  kCscStripMin );
}
 
inline unsigned int MuonFixedLongId::cscStripIndex() const {
   return (m_data >> kCscStripShift) & kCscStripMask;
}
 
inline int MuonFixedLongId::cscStrip() const {
   return cscStripIndex() + kCscStripMin;
}
 
inline int MuonFixedLongId::cscChamberLayerMin(){
  return kCscChamberLayerMin;
}
 
inline int MuonFixedLongId::cscChamberLayerMax(){
  return kCscChamberLayerMin + kCscChamberLayerMask;
}
 
inline int MuonFixedLongId::cscWireLayerMin(){
  return kCscWireLayerMin;
}
 
inline int MuonFixedLongId::cscWireLayerMax(){
  return kCscWireLayerMin + kCscWireLayerMask;
}
 
inline int MuonFixedLongId::cscMeasuresPhiMin(){
  return kCscMeasuresPhiMin;
}
 
inline int MuonFixedLongId::cscMeasuresPhiMax(){
  return kCscMeasuresPhiMin + kCscMeasuresPhiMask;
}
 
inline int MuonFixedLongId::cscStripMin(){
  return kCscStripMin;
}
 
inline int MuonFixedLongId::cscStripMax(){
  return kCscStripMin + kCscStripMask;
}
 
// Rpc specific methods
inline bool MuonFixedLongId::setRpcDoubletRIndex( uint64_t idx ) {
  if ( idx > kRpcDoubletRMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcDoubletRMask <<  kRpcDoubletRShift );
   m_data |= (idx &  kRpcDoubletRMask) << kRpcDoubletRShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcDoubletR( int num ) {
  return setRpcDoubletRIndex( num -  kRpcDoubletRMin );
}
 
inline unsigned int MuonFixedLongId::rpcDoubletRIndex() const {
   return (m_data >> kRpcDoubletRShift) & kRpcDoubletRMask;
}
 
inline int MuonFixedLongId::rpcDoubletR() const {
   return rpcDoubletRIndex() + kRpcDoubletRMin;
}
 
inline bool MuonFixedLongId::setRpcDoubletZIndex( uint64_t idx ) {
  if ( idx > kRpcDoubletZMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcDoubletZMask <<  kRpcDoubletZShift );
   m_data |= (idx &  kRpcDoubletZMask) << kRpcDoubletZShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcDoubletZ( int num ) {
  return setRpcDoubletZIndex( num -  kRpcDoubletZMin );
}
 
inline unsigned int MuonFixedLongId::rpcDoubletZIndex() const {
   return (m_data >> kRpcDoubletZShift) & kRpcDoubletZMask;
}
 
inline int MuonFixedLongId::rpcDoubletZ() const {
   return rpcDoubletZIndex() + kRpcDoubletZMin;
}
 
inline bool MuonFixedLongId::setRpcDoubletPhiIndex( uint64_t idx ) {
  if ( idx > kRpcDoubletPhiMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcDoubletPhiMask <<  kRpcDoubletPhiShift );
   m_data |= (idx &  kRpcDoubletPhiMask) << kRpcDoubletPhiShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcDoubletPhi( int num ) {
  return setRpcDoubletPhiIndex( num -  kRpcDoubletPhiMin );
}
 
inline unsigned int MuonFixedLongId::rpcDoubletPhiIndex() const {
   return (m_data >> kRpcDoubletPhiShift) & kRpcDoubletPhiMask;
}
 
inline int MuonFixedLongId::rpcDoubletPhi() const {
   return rpcDoubletPhiIndex() + kRpcDoubletPhiMin;
}
 
inline bool MuonFixedLongId::setRpcGasGapIndex( uint64_t idx ) {
  if ( idx > kRpcGasGapMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcGasGapMask <<  kRpcGasGapShift );
   m_data |= (idx &  kRpcGasGapMask) << kRpcGasGapShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcGasGap( int num ) {
  return setRpcGasGapIndex( num -  kRpcGasGapMin );
}
 
inline unsigned int MuonFixedLongId::rpcGasGapIndex() const {
   return (m_data >> kRpcGasGapShift) & kRpcGasGapMask;
}
 
inline int MuonFixedLongId::rpcGasGap() const {
   return rpcGasGapIndex() + kRpcGasGapMin;
}
 
inline bool MuonFixedLongId::setRpcMeasuresPhiIndex( uint64_t idx ) {
  if ( idx > kRpcMeasuresPhiMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcMeasuresPhiMask <<  kRpcMeasuresPhiShift );
   m_data |= (idx &  kRpcMeasuresPhiMask) << kRpcMeasuresPhiShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcMeasuresPhi( int num ) {
  return setRpcMeasuresPhiIndex( num -  kRpcMeasuresPhiMin );
}
 
inline unsigned int MuonFixedLongId::rpcMeasuresPhiIndex() const {
   return (m_data >> kRpcMeasuresPhiShift) & kRpcMeasuresPhiMask;
}
 
inline int MuonFixedLongId::rpcMeasuresPhi() const {
   return rpcMeasuresPhiIndex() + kRpcMeasuresPhiMin;
}
 
inline bool MuonFixedLongId::setRpcStripIndex( uint64_t idx ) {
  if ( idx > kRpcStripMask ) {
      clear();
      return false;
   }
   m_data &= ~( kRpcStripMask <<  kRpcStripShift );
   m_data |= (idx &  kRpcStripMask) << kRpcStripShift;
   return true;
}
 
inline bool MuonFixedLongId::setRpcStrip( int num ) {
  return setRpcStripIndex( num -  kRpcStripMin );
}
 
inline unsigned int MuonFixedLongId::rpcStripIndex() const {
   return (m_data >> kRpcStripShift) & kRpcStripMask;
}
 
inline int MuonFixedLongId::rpcStrip() const {
   return rpcStripIndex() + kRpcStripMin;
}
 
 
//  Tgc specific methods
inline bool MuonFixedLongId::setTgcGasGapIndex( uint64_t idx ) {
  if ( idx > kTgcGasGapMask ) {
      clear();
      return false;
   }
   m_data &= ~( kTgcGasGapMask <<  kTgcGasGapShift );
   m_data |= (idx &  kTgcGasGapMask) << kTgcGasGapShift;
   return true;
}
 
inline bool MuonFixedLongId::setTgcGasGap( int num ) {
  return setTgcGasGapIndex( num -  kTgcGasGapMin );
}
 
inline unsigned int MuonFixedLongId::tgcGasGapIndex() const {
   return (m_data >> kTgcGasGapShift) & kTgcGasGapMask;
}
 
inline int MuonFixedLongId::tgcGasGap() const {
   return tgcGasGapIndex() + kTgcGasGapMin;
}
 
inline bool MuonFixedLongId::setTgcIsStripIndex( uint64_t idx ) {
  if ( idx > kTgcIsStripMask ) {
      clear();
      return false;
   }
   m_data &= ~( kTgcIsStripMask <<  kTgcIsStripShift );
   m_data |= (idx &  kTgcIsStripMask) << kTgcIsStripShift;
   return true;
}
 
inline bool MuonFixedLongId::setTgcIsStrip( int num ) {
  return setTgcIsStripIndex( num -  kTgcIsStripMin );
}
 
inline unsigned int MuonFixedLongId::tgcIsStripIndex() const {
   return (m_data >> kTgcIsStripShift) & kTgcIsStripMask;
}
 
inline int MuonFixedLongId::tgcIsStrip() const {
   return tgcIsStripIndex() + kTgcIsStripMin;
}
 
 
inline bool MuonFixedLongId::setTgcChannelIndex( uint64_t idx ) {
  if ( idx > kTgcChannelMask ) {
      clear();
      return false;
   }
   m_data &= ~( kTgcChannelMask <<  kTgcChannelShift );
   m_data |= (idx &  kTgcChannelMask) << kTgcChannelShift;
   return true;
}
 
inline bool MuonFixedLongId::setTgcChannel( int num ) {
  return setTgcChannelIndex( num -  kTgcChannelMin );
}
 
inline unsigned int MuonFixedLongId::tgcChannelIndex() const {
   return (m_data >> kTgcChannelShift) & kTgcChannelMask;
}
 
inline int MuonFixedLongId::tgcChannel() const {
   return tgcChannelIndex() + kTgcChannelMin;
}
 
 
// MMG specific methods
inline bool MuonFixedLongId::setMmgMultilayerIndex ( uint64_t idx )  {
  if ( idx > kMmgMultilayerMask ) {
      clear();
      return false;
   }
   m_data &= ~( kMmgMultilayerMask << kMmgMultilayerShift );
   m_data |= (idx & kMmgMultilayerMask) << kMmgMultilayerShift;
   return true;
}
inline bool MuonFixedLongId::setMmgMultilayer ( int num ) {
  return setMmgMultilayerIndex( num -  kMmgMultilayerMin );
}
inline unsigned int MuonFixedLongId::mmgMultilayerIndex () const {
   return (m_data >> kMmgMultilayerShift) & kMmgMultilayerMask;
}
inline int MuonFixedLongId::mmgMultilayer () const {
   return mmgMultilayerIndex() + kMmgMultilayerMin;
}
 
inline bool MuonFixedLongId::setMmgGasGapIndex ( uint64_t idx )  {
  if ( idx > kMmgGasGapMask ) {
      clear();
      return false;
   }
   m_data &= ~( kMmgGasGapMask << kMmgGasGapShift );
   m_data |= (idx & kMmgGasGapMask) << kMmgGasGapShift;
   return true;
}
inline bool MuonFixedLongId::setMmgGasGap ( int num ) {
  return setMmgGasGapIndex( num -  kMmgGasGapMin );
}
inline unsigned int MuonFixedLongId::mmgGasGapIndex () const {
   return (m_data >> kMmgGasGapShift) & kMmgGasGapMask;
}
inline int MuonFixedLongId::mmgGasGap () const {
   return mmgGasGapIndex() + kMmgGasGapMin;
}
 
inline bool MuonFixedLongId::setMmgStripIndex ( uint64_t idx )  {
  if ( idx > kMmgStripMask ) {
      clear();
      return false;
   }
   m_data &= ~( kMmgStripMask << kMmgStripShift );
   m_data |= (idx & kMmgStripMask) << kMmgStripShift;
   return true;
}
inline bool MuonFixedLongId::setMmgStrip ( int num ) {
  return setMmgStripIndex( num -  kMmgStripMin );
}
inline unsigned int MuonFixedLongId::mmgStripIndex () const {
   return (m_data >> kMmgStripShift) & kMmgStripMask;
}
inline int MuonFixedLongId::mmgStrip () const {
   return mmgStripIndex() + kMmgStripMin;
}
inline bool MuonFixedLongId::mmgIsStereo() const {
  if (mmgMultilayer() == 1) {
    return mmgGasGap() > 2;
  } else {
    return mmgGasGap() <= 2;
  }
}
 
// STGC specific code
inline bool MuonFixedLongId::setStgMultilayerIndex ( uint64_t idx )  {
  if ( idx > kStgMultilayerMask ) {
      clear();
      return false;
   }
   m_data &= ~( kStgMultilayerMask << kStgMultilayerShift );
   m_data |= (idx & kStgMultilayerMask) << kStgMultilayerShift;
   return true;
}
inline bool MuonFixedLongId::setStgMultilayer ( int num ) {
  return setStgMultilayerIndex( num -  kStgMultilayerMin );
}
inline unsigned int MuonFixedLongId::stgMultilayerIndex () const {
   return (m_data >> kStgMultilayerShift) & kStgMultilayerMask;
}
inline int MuonFixedLongId::stgMultilayer () const {
   return stgMultilayerIndex() + kStgMultilayerMin;
}
 
inline bool MuonFixedLongId::setStgGasGapIndex ( uint64_t idx )  {
  if ( idx > kStgGasGapMask ) {
      clear();
      return false;
   }
   m_data &= ~( kStgGasGapMask << kStgGasGapShift );
   m_data |= (idx & kStgGasGapMask) << kStgGasGapShift;
   return true;
}
inline bool MuonFixedLongId::setStgGasGap ( int num ) {
  return setStgGasGapIndex( num -  kStgGasGapMin );
}
inline unsigned int MuonFixedLongId::stgGasGapIndex () const {
   return (m_data >> kStgGasGapShift) & kStgGasGapMask;
}
inline int MuonFixedLongId::stgGasGap () const {
   return stgGasGapIndex() + kStgGasGapMin;
}
 
inline bool MuonFixedLongId::setStgChannelTypeIndex ( uint64_t idx )  {
  if ( idx > kStgChannelTypeMask ) {
      clear();
      return false;
   }
   m_data &= ~( kStgChannelTypeMask << kStgChannelTypeShift );
   m_data |= (idx & kStgChannelTypeMask) << kStgChannelTypeShift;
   return true;
}
inline bool MuonFixedLongId::setStgChannelType ( StgChannelType num ) {
  return setStgChannelTypeIndex( num -  kStgChannelTypeMin );
}
inline unsigned int MuonFixedLongId::stgChannelTypeIndex () const {
   return (m_data >> kStgChannelTypeShift) & kStgChannelTypeMask;
}
inline MuonFixedLongId::StgChannelType MuonFixedLongId::stgChannelType () const {
   return static_cast<MuonFixedLongId::StgChannelType>(stgChannelTypeIndex() + kStgChannelTypeMin);
}
 
inline bool MuonFixedLongId::setStgChannelIndex ( uint64_t idx )  {
  if ( idx > kStgChannelMask ) {
      clear();
      return false;
   }
   m_data &= ~( kStgChannelMask << kStgChannelShift );
   m_data |= (idx & kStgChannelMask) << kStgChannelShift;
   return true;
}
inline bool MuonFixedLongId::setStgChannel ( int num ) {
  return setStgChannelIndex( num -  kStgChannelMin );
}
inline unsigned int MuonFixedLongId::stgChannelIndex () const {
   return (m_data >> kStgChannelShift) & kStgChannelMask;
}
inline int MuonFixedLongId::stgChannel () const {
   return stgChannelIndex() + kStgChannelMin;
}
 
inline std::ostream& operator<<( std::ostream& os, const MuonCalib::MuonFixedLongId& id ) {
  return id.dump( os );
}
} //MuonCalib namespace 
 
/*
***** must solve conflicts between MuonCalib namespace and friendship
inline std::istream& operator>>( std::istream& is, MuonCalib::MuonFixedLongId& id){
  is >> id.m_data ;
  return is;
}
*/
#endif // MUONCALIBIDENTIFIER_MUONFIXEDLONGID_H