CSCDetId.h

Go to the documentation of this file.

#ifndef MuonDetId_CSCDetId_h
#define MuonDetId_CSCDetId_h

#include <iosfwd>
#include <DataFormats/DetId/interface/DetId.h>
#include <DataFormats/MuonDetId/interface/MuonSubdetId.h>

class CSCDetId;

std::ostream& operator<<( std::ostream& os, const CSCDetId& id );

class CSCDetId : public DetId {

public:

  CSCDetId();

  CSCDetId(uint32_t id);
  CSCDetId(DetId id);

  CSCDetId( int iendcap, int istation, 
        int iring, int ichamber, 
        int ilayer = 0 );

  CSCDetId( const CSCDetId& id )
     : DetId(id.id_) { }  

  CSCDetId chamberId() const {
    // build chamber id by removing layer bits
    return CSCDetId( id_ - layer() ) ; }

  int layer() const {
    return (id_ & MASK_LAYER); } 

   int chamber() const {
     return (  (id_>>START_CHAMBER) & MASK_CHAMBER ); }

   int ring() const {
     if (((id_>>START_STATION) & MASK_STATION) == 1)
       return (  detIdToInt((id_>>START_RING) & MASK_RING )); 
     else
       return (((id_>>START_RING) & MASK_RING )); 
   }

   int station() const {
     return (  (id_>>START_STATION) & MASK_STATION ); }

   int endcap() const {
     return (  (id_>>START_ENDCAP) & MASK_ENDCAP ); }

   short int zendcap() const {
     return ( endcap()!=1 ? -1 : +1 );
   }

   unsigned short iChamberType() {
     return iChamberType( station(), ring() );
   }

   int channel( int istrip ) { 
     if ( ring()== 4 ) 
       // strips 1-48 mapped to channels 1-16:
       // 1+17+33->1, 2+18+34->2, .... 16+32+48->16
       return 1 + (istrip-1)%16; 
     else 
       return istrip; 
   }

  // static methods
  // Used when we need information about subdetector labels.

   static int rawIdMaker( int iendcap, int istation, int iring, 
               int ichamber, int ilayer ) {
     return ( (DetId::Muon&0xF)<<(DetId::kDetOffset) ) |            // set Muon flag
            ( (MuonSubdetId::CSC&0x7)<<(DetId::kSubdetOffset) ) |   // set CSC flag
               init(iendcap, istation, iring, ichamber, ilayer) ; } // set CSC id

   static int layer( int index ) {
     return (index & MASK_LAYER); }

   static int chamber( int index ) {
     return (  (index>>START_CHAMBER) & MASK_CHAMBER ); }

   static int ring( int index ) {
     if (((index>>START_STATION) & MASK_STATION) == 1)
       return (  detIdToInt((index>>START_RING) & MASK_RING )); 
     else
       return (( index>>START_RING) & MASK_RING ); 
   }

   static int station( int index ) {
     return (  (index>>START_STATION) & MASK_STATION ); }

   static int endcap( int index ) {
     return (  (index>>START_ENDCAP) & MASK_ENDCAP ); }

   static unsigned short iChamberType( unsigned short istation, unsigned short iring );

   int triggerSector() const;

   int triggerCscId() const;

   static int minEndcapId()  { return MIN_ENDCAP; }
   static int maxEndcapId()  { return MAX_ENDCAP; }
   static int minStationId() { return MIN_STATION; }
   static int maxStationId() { return MAX_STATION; }
   static int minRingId()    { return MIN_RING; }
   static int maxRingId()    { return MAX_RING; }
   static int minChamberId() { return MIN_CHAMBER; }
   static int maxChamberId() { return MAX_CHAMBER; }
   static int minLayerId()   { return MIN_LAYER; }
   static int maxLayerId()   { return MAX_LAYER; }

private:
 
  static uint32_t init( int iendcap, int istation, 
            int iring, int ichamber, int ilayer ) {
    
    if (istation == 1)
      iring = intToDetId(iring);

     return
         (ilayer   & MASK_LAYER)                      |
       ( (ichamber & MASK_CHAMBER) << START_CHAMBER ) |
       ( (iring    & MASK_RING)    << START_RING )    |
       ( (istation & MASK_STATION) << START_STATION ) | 
       ( (iendcap  & MASK_ENDCAP)  << START_ENDCAP ) ; }

  static int intToDetId(int iring) {
    // change iring = 1, 2, 3, 4 input to 2, 3, 4, 1 for use inside the DetId
    // i.e. ME1b, ME12, ME13, ME1a externally become stored internally in order ME1a, ME1b, ME12, ME13
    int i = (iring+1)%4;
    if (i == 0)
      i = 4;
    return i;
  }

  static int detIdToInt(int iring) {
    // reverse intToDetId: change 1, 2, 3, 4 inside the DetId to 4, 1, 2, 3 for external use
    // i.e. output ring # 1, 2, 3, 4 in ME1 means ME1b, ME12, ME13, ME1a as usual in the offline software.
    int i = (iring-1);
    if (i == 0)
      i = 4;
    return i;
  }
 
  // The following define the bit-packing implementation...

  // The maximum numbers of various parts
  enum eMaxNum{ MAX_ENDCAP=2, MAX_STATION=4, MAX_RING=4, MAX_CHAMBER=36, MAX_LAYER=6 };
  // We count from 1 
  enum eMinNum{ MIN_ENDCAP=1, MIN_STATION=1, MIN_RING=1, MIN_CHAMBER=1, MIN_LAYER=1 };

  // BITS_det is no. of binary bits required to label 'det' but allow 0 as a wild-card character
  // Keep as multiples of 3 so that number can be easily decodable from octal
  enum eNumBitDet{ BITS_ENDCAP=3, BITS_STATION=3,  BITS_RING=3, BITS_CHAMBER=6, BITS_LAYER=3 };

  // MASK_det is binary bits set to pick off the bits for 'det' (defined as octal)
  enum eMaskBitDet{ MASK_ENDCAP=07, MASK_STATION=07, MASK_RING=07, MASK_CHAMBER=077, MASK_LAYER=07 };

  // START_det is bit position (counting from zero) at which bits for 'det' start in 'rawId' word
  enum eStartBitDet{ START_CHAMBER=BITS_LAYER, START_RING=START_CHAMBER+BITS_CHAMBER,
          START_STATION=START_RING+BITS_RING, START_ENDCAP=START_STATION+BITS_STATION };
};

#endif