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