CSCDetId.h

Go to the documentation of this file.

#ifndef MuonDetId_CSCDetId_h
#define MuonDetId_CSCDetId_h

#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() : DetId(DetId::Muon, MuonSubdetId::CSC) {}

  CSCDetId(uint32_t id) : DetId(id) {}
  CSCDetId(DetId id) : DetId(id) {}

  CSCDetId(int iendcap, int istation, int iring, int ichamber, int ilayer = 0) : DetId(DetId::Muon, MuonSubdetId::CSC) {
    id_ |= init(iendcap, istation, iring, ichamber, ilayer);
  }

  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() const { 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; }

  static std::string chamberName(int endcap, int station, int ring, int chamber);
  std::string chamberName() const;

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