CSCIndexer.h

Go to the documentation of this file.

#ifndef MuonDetId_CSCIndexer_h
#define MuonDetId_CSCIndexer_h
 
#include <DataFormats/MuonDetId/interface/CSCDetId.h>
#include <vector>
#include <iosfwd>
#include <utility>  // for pair
 
class CSCIndexer {
public:
  //  typedef unsigned short int IndexType;
  //  typedef unsigned       int LongIndexType;
  typedef uint16_t IndexType;
  typedef uint32_t LongIndexType;
 
  CSCIndexer(){};
  ~CSCIndexer(){};
 
  IndexType chamberIndex(const CSCDetId& id) const {
    return chamberIndex(id.endcap(), id.station(), id.ring(), id.chamber());
  }
 
  IndexType layerIndex(const CSCDetId& id) const {
    return layerIndex(id.endcap(), id.station(), id.ring(), id.chamber(), id.layer());
  }
 
  IndexType startChamberIndexInEndcap(IndexType ie, IndexType is, IndexType ir) const {
    const IndexType nschin[24] = {1,   37,  73,  109, 127, 0, 163, 181, 0, 217, 469, 0,
                                  235, 271, 307, 343, 361, 0, 397, 415, 0, 451, 505, 0};
    return nschin[(ie - 1) * 12 + (is - 1) * 3 + ir - 1];
  }
 
  IndexType chamberIndex(IndexType ie, IndexType is, IndexType ir, IndexType ic) const {
    return startChamberIndexInEndcap(ie, is, ir) + ic - 1;  // -1 so start index _is_ ic=1
  }
 
  IndexType layerIndex(IndexType ie, IndexType is, IndexType ir, IndexType ic, IndexType il) const {
    const IndexType layersInChamber = 6;
    return (chamberIndex(ie, is, ir, ic) - 1) * layersInChamber + il;
  }
 
  IndexType ringsInStation(IndexType is) const {
    const IndexType nrins[5] = {0, 3, 2, 2, 2};  // rings per station
    return nrins[is];
  }
 
  IndexType chambersInRingOfStation(IndexType is, IndexType ir) const {
    IndexType nc = 36;  // most rings have 36 chambers
    if (is > 1 && ir < 2)
      nc = 18;  // but 21, 31, 41 have 18
    return nc;
  }
 
  IndexType stripChannelsPerLayer(IndexType is, IndexType ir) const {
    const IndexType nSCinC[12] = {80, 80, 64, 80, 80, 0, 80, 80, 0, 80, 80, 0};
    return nSCinC[(is - 1) * 3 + ir - 1];
  }
 
  LongIndexType stripChannelStart(IndexType ie, IndexType is, IndexType ir) const {
    // These are in the ranges 1-217728 (CSCs 2008) and 217729-252288 (ME42).
    // There are 1-108884 channels per endcap (CSCs 2008) and 17280 channels per endcap (ME42).
    // Start of -z channels (CSCs 2008) is 108864 + 1 = 108865
    // Start of +z (ME42) is 217728 + 1 = 217729
    // Start of -z (ME42) is 217728 + 1 + 17280 = 235009
    const LongIndexType nStart[24] = {1,      17281,  34561,  48385,  57025,  0, 74305,  82945,  0, 100225, 217729, 0,
                                      108865, 126145, 143425, 157249, 165889, 0, 183169, 191809, 0, 209089, 235009, 0};
    return nStart[(ie - 1) * 12 + (is - 1) * 3 + ir - 1];
  }
 
  LongIndexType stripChannelIndex(
      IndexType ie, IndexType is, IndexType ir, IndexType ic, IndexType il, IndexType istrip) const {
    return stripChannelStart(ie, is, ir) + ((ic - 1) * 6 + il - 1) * stripChannelsPerLayer(is, ir) + (istrip - 1);
  }
 
  LongIndexType stripChannelIndex(const CSCDetId& id, IndexType istrip) const {
    return stripChannelIndex(id.endcap(), id.station(), id.ring(), id.chamber(), id.layer(), istrip);
  }
 
  IndexType chipsPerLayer(IndexType is, IndexType ir) const {
    const IndexType nCinL[12] = {5, 5, 4, 5, 5, 0, 5, 5, 0, 5, 5, 0};
    return nCinL[(is - 1) * 3 + ir - 1];
  }
 
  IndexType chipStart(IndexType ie, IndexType is, IndexType ir) const {
    // These are in the ranges 1-13608 (CSCs 2008) and 13609-15768 (ME42).
    // There are 1-6804 chips per endcap (CSCs 2008) and 1080 channels per endcap (ME42).
    // Start of -z channels (CSCs 2008) is 6804 + 1 = 6805
    // Start of +z (ME42) is 13608 + 1 = 13609
    // Start of -z (ME42) is 13608 + 1 + 1080 = 14689
    const IndexType nStart[24] = {1,    1081, 2161, 3025, 3565,  0, 4645,  5185,  0, 6265,  13609, 0,
                                  6805, 7885, 8965, 9829, 10369, 0, 11449, 11989, 0, 13069, 14689, 0};
 
    return nStart[(ie - 1) * 12 + (is - 1) * 3 + ir - 1];
  }
 
  IndexType chipIndex(IndexType ie, IndexType is, IndexType ir, IndexType ic, IndexType il, IndexType ichip) const {
    //printf("ME%d/%d/%d/%d layer %d  chip %d chipindex %d\n",ie,is,ir,ic,il,ichip,chipStart(ie,is,ir)+( (ic-1)*6 + il - 1 )*chipsPerLayer(is,ir) + (ichip-1));
    return chipStart(ie, is, ir) + ((ic - 1) * 6 + il - 1) * chipsPerLayer(is, ir) + (ichip - 1);
  }
 
  IndexType chipIndex(const CSCDetId& id, IndexType ichip) const {
    return chipIndex(id.endcap(), id.station(), id.ring(), id.chamber(), id.layer(), ichip);
  }
 
  IndexType chipIndex(IndexType istrip) const { return (istrip - 1) / 16 + 1; }
 
  IndexType hvSegmentsPerLayer(IndexType is, IndexType ir) const {
    const IndexType nSinL[12] = {1, 3, 3, 3, 5, 0, 3, 5, 0, 3, 5, 0};
    return nSinL[(is - 1) * 3 + ir - 1];
  }
 
  IndexType sectorsPerLayer(IndexType is, IndexType ir) const {
    return chipsPerLayer(is, ir) * hvSegmentsPerLayer(is, ir);
  }
 
  IndexType hvSegmentIndex(IndexType is, IndexType ir, IndexType iwire) const {
    IndexType hvSegment = 1;  // There is only one HV segment in ME1/1
 
    if (is > 2 && ir == 1) {  // HV segments are the same in ME3/1 and ME4/1
      if (iwire >= 33 && iwire <= 64) {
        hvSegment = 2;
      } else if (iwire >= 65 && iwire <= 96) {
        hvSegment = 3;
      }
 
    } else if (is > 1 && ir == 2) {  // HV segments are the same in ME2/2, ME3/2, and ME4/2
      if (iwire >= 17 && iwire <= 28) {
        hvSegment = 2;
      } else if (iwire >= 29 && iwire <= 40) {
        hvSegment = 3;
      } else if (iwire >= 41 && iwire <= 52) {
        hvSegment = 4;
      } else if (iwire >= 53 && iwire <= 64) {
        hvSegment = 5;
      }
 
    } else if (is == 1 && ir == 2) {
      if (iwire >= 25 && iwire <= 48) {
        hvSegment = 2;
      } else if (iwire >= 49 && iwire <= 64) {
        hvSegment = 3;
      }
 
    } else if (is == 1 && ir == 3) {
      if (iwire >= 13 && iwire <= 22) {
        hvSegment = 2;
      } else if (iwire >= 23 && iwire <= 32) {
        hvSegment = 3;
      }
 
    } else if (is == 2 && ir == 1) {
      if (iwire >= 45 && iwire <= 80) {
        hvSegment = 2;
      } else if (iwire >= 81 && iwire <= 112) {
        hvSegment = 3;
      }
    }
 
    return hvSegment;
  }
 
  IndexType sectorStart(IndexType ie, IndexType is, IndexType ir) const {
    // There are 36 chambers * 6 layers * 5 CFEB's * 1 HV segment = 1080 gas-gain sectors in ME1/1
    // There are 36*6*5*3 = 3240 gas-gain sectors in ME1/2
    // There are 36*6*4*3 = 2592 gas-gain sectors in ME1/3
    // There are 18*6*5*3 = 1620 gas-gain sectors in ME[2-4]/1
    // There are 36*6*5*5 = 5400 gas-gain sectors in ME[2-4]/2
    // Start of -z channels (CSCs 2008) is 22572 + 1 = 22573
    // Start of +z (ME42) is 45144 + 1 = 45145
    // Start of -z (ME42) is 45144 + 1 + 5400 = 50545
    const IndexType nStart[24] = {1,     1081,  4321,   //ME+1/1,ME+1/2,ME+1/3
                                  6913,  8533,  0,      //ME+2/1,ME+2/2,ME+2/3
                                  13933, 15553, 0,      //ME+3/1,ME+3/2,ME+3/3
                                  20953, 45145, 0,      //ME+4/1,ME+4/2,ME+4/3 (note, ME+4/2 index follows ME-4/1...)
                                  22573, 23653, 26893,  //ME-1/1,ME-1/2,ME-1/3
                                  29485, 31105, 0,      //ME-2/1,ME-2/2,ME-2/3
                                  36505, 38125, 0,      //ME-3/1,ME-3/2,ME-3/3
                                  43525, 50545, 0};     //ME-4/1,ME-4/2,ME-4/3 (note, ME-4/2 index follows ME+4/2...)
    return nStart[(ie - 1) * 12 + (is - 1) * 3 + ir - 1];
  }
 
  IndexType gasGainIndex(const CSCDetId& id, IndexType istrip, IndexType iwire) const {
    return gasGainIndex(id.endcap(), id.station(), id.ring(), id.chamber(), id.layer(), istrip, iwire);
  }
 
  IndexType gasGainIndex(
      IndexType ie, IndexType is, IndexType ir, IndexType ic, IndexType il, IndexType istrip, IndexType iwire) const {
    IndexType ichip = this->chipIndex(istrip);
    IndexType ihvsegment = this->hvSegmentIndex(is, ir, iwire);
    return sectorStart(ie, is, ir) + ((ic - 1) * 6 + il - 1) * sectorsPerLayer(is, ir) +
           (ihvsegment - 1) * chipsPerLayer(is, ir) + (ichip - 1);
  }
 
  CSCDetId detIdFromLayerIndex(IndexType ili) const;
  CSCDetId detIdFromChamberIndex(IndexType ici) const;
  CSCDetId detIdFromChamberIndex_OLD(IndexType ici) const;
  CSCDetId detIdFromChamberLabel(IndexType ie, IndexType icl) const;
  std::pair<CSCDetId, IndexType> detIdFromStripChannelIndex(LongIndexType ichi) const;
  std::pair<CSCDetId, IndexType> detIdFromChipIndex(IndexType ichi) const;
 
  IndexType chamberLabelFromChamberIndex(IndexType) const;  // just for cross-checks
 
  int dbIndex(const CSCDetId& id, int& channel);
 
private:
  void fillChamberLabel() const;  // const so it can be called in const function detIdFromChamberIndex
 
  mutable std::vector<IndexType> chamberLabel;  // mutable so can be filled by fillChamberLabel
};
 
#endif