GEMeMap Class Reference

#include <GEMeMap.h>

Classes
struct	GEMChamberMap
struct	GEMStripMap
struct	GEMVFatMap

Public Member Functions
void	convert (GEMROMapping &romap)
void	convertDummy (GEMROMapping &romap)
	GEMeMap ()
	GEMeMap (const std::string &version)
const std::string &	version () const
virtual	~GEMeMap ()

Public Attributes
std::vector< GEMChamberMap >	theChamberMap_
std::vector< GEMStripMap >	theStripMap_
std::vector< GEMVFatMap >	theVFatMap_

Static Public Attributes
static const int	chipIdMask_ = 0xfff
static const int	maxAMCs_ = 15
static const int	maxChan_ = 128
static const int	maxGEB1_ = 12
static const int	maxGEB2_ = 12
static const int	maxGEBs_ = 24
static const int	maxiEtaIdGE0_ = 8
static const int	maxiEtaIdGE11_ = 8
static const int	maxiEtaIdGE21_ = 16
static const int	maxVFatGE0_ = 12
static const int	maxVFatGE11_ = 3
static const int	maxVFatGE21_ = 6
static const int	vfatTypeV3_ = 11
static const int	vfatVerV3_ = 3

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Private Attributes
std::string	theVersion

Friends
class	boost::serialization::access
template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Definition at line 10 of file GEMeMap.h.

Constructor & Destructor Documentation

GEMeMap() [1/2]

GEMeMap::GEMeMap

(

)

Definition at line 6 of file GEMeMap.cc.

: theVersion("") {}

GEMeMap() [2/2]

GEMeMap::GEMeMap ( const std::string &  version )

explicit

Definition at line 8 of file GEMeMap.cc.

: theVersion(version) {}

~GEMeMap()

GEMeMap::~GEMeMap ( )

virtual

Definition at line 10 of file GEMeMap.cc.

{}

Member Function Documentation

convert()

void GEMeMap::convert

(

GEMROMapping &

romap

)

Definition at line 14 of file GEMeMap.cc.

References funct::abs(), GEMROMapping::add(), GEMDetId::chamberId(), chipIdMask_, GEMROMapping::channelNum::chNum, GEMROMapping::chamDC::detId, GEMROMapping::vfatEC::detId, GEMROMapping::vfatDC::detId, GEMROMapping::sectorEC::fedId, GEMROMapping::chamEC::fedId, GEMROMapping::isValidAMC(), GEMROMapping::vfatDC::localPhi, GEMROMapping::stripNum::stNum, theChamberMap_, theStripMap_, theVFatMap_, GEMROMapping::vfatEC::vfatAdd, GEMROMapping::vfatDC::vfatType, GEMROMapping::channelNum::vfatType, GEMROMapping::stripNum::vfatType, and GEMROMapping::chamDC::vfatVer.

                                         {
  // fed->amc->geb mapping to GEMDetId
  for (auto imap : theChamberMap_) {
    for (unsigned int ix = 0; ix < imap.fedId.size(); ix++) {
      GEMROMapping::chamEC ec{imap.fedId[ix], imap.amcNum[ix], imap.gebId[ix]};
      GEMROMapping::chamDC dc;
      dc.detId = GEMDetId((imap.gemNum[ix] > 0) ? 1 : -1,
                          1,
                          abs(imap.gemNum[ix] / 1000),
                          abs(imap.gemNum[ix] / 100 % 10),
                          abs(imap.gemNum[ix] % 100),
                          0);
      dc.vfatVer = imap.vfatVer[ix];
      romap.add(ec, dc);
      GEMROMapping::sectorEC amcEC = {imap.fedId[ix], imap.amcNum[ix]};
      if (!romap.isValidAMC(amcEC))
        romap.add(amcEC);
    }
  }

  // chamberType to vfatType
  for (auto imap : theVFatMap_) {
    for (unsigned int ix = 0; ix < imap.vfatAdd.size(); ix++) {
      GEMDetId gemId((imap.gemNum[ix] > 0) ? 1 : -1,
                     1,
                     abs(imap.gemNum[ix] / 1000),
                     abs(imap.gemNum[ix] / 100 % 10),
                     abs(imap.gemNum[ix] % 100),
                     imap.iEta[ix]);

      GEMROMapping::vfatEC ec;
      ec.detId = gemId.chamberId();
      ec.vfatAdd = imap.vfatAdd[ix] & chipIdMask_;

      GEMROMapping::vfatDC dc;
      dc.vfatType = imap.vfatType[ix];
      dc.detId = gemId;
      dc.localPhi = imap.localPhi[ix];

      romap.add(ec, dc);
      romap.add(gemId.chamberId(), ec);
    }
  }
  // channel mapping
  for (auto imap : theStripMap_) {
    for (unsigned int ix = 0; ix < imap.vfatType.size(); ix++) {
      GEMROMapping::channelNum cMap;
      cMap.vfatType = imap.vfatType[ix];
      cMap.chNum = imap.vfatCh[ix];

      GEMROMapping::stripNum sMap;
      sMap.vfatType = imap.vfatType[ix];
      sMap.stNum = imap.vfatStrip[ix];

      romap.add(cMap, sMap);
      romap.add(sMap, cMap);
    }
  }
}

convertDummy()

void GEMeMap::convertDummy

(

GEMROMapping &

romap

)

Definition at line 74 of file GEMeMap.cc.

References GEMROMapping::add(), GEMROMapping::chamEC::amcNum, GEMDetId::chamberId(), GEMROMapping::channelNum::chNum, GEMROMapping::chamDC::detId, GEMROMapping::vfatEC::detId, GEMROMapping::vfatDC::detId, GEMROMapping::chamEC::fedId, l1tstage2_dqm_sourceclient-live_cfg::fedId, GEMROMapping::chamEC::gebId, mps_fire::i, hcalRecHitTable_cff::ieta, GEMROMapping::isValidAMC(), GEMROMapping::vfatDC::localPhi, GEMDetId::maxChamberId, maxChan_, maxGEB1_, maxGEBs_, maxiEtaIdGE0_, maxiEtaIdGE11_, maxiEtaIdGE21_, GEMDetId::maxLayerId, GEMDetId::maxLayerId0, GEMDetId::maxStationId, maxVFatGE0_, maxVFatGE11_, maxVFatGE21_, FEDNumbering::MINGE0FEDID, FEDNumbering::MINGE21FEDID, FEDNumbering::MINGEMFEDID, GEMDetId::minStationId0, GEMROMapping::stripNum::stNum, GEMROMapping::vfatEC::vfatAdd, GEMROMapping::vfatDC::vfatType, GEMROMapping::channelNum::vfatType, GEMROMapping::stripNum::vfatType, vfatTypeV3_, GEMROMapping::chamDC::vfatVer, and vfatVerV3_.

                                              {
  // 12 bits for vfat, 5 bits for geb, 8 bit long GLIB serial number
  unsigned int fedId = 0;

  for (int st = GEMDetId::minStationId0; st <= GEMDetId::maxStationId; ++st) {
    for (int re = -1; re <= 1; re = re + 2) {
      uint8_t amcNum = 1;  //amc
      uint8_t gebId = 0;
      int maxVFat = 0;
      int maxLayerId = GEMDetId::maxLayerId;
      int maxiEtaId = 0;
      if (st == 0) {
        maxVFat = maxVFatGE0_;
        fedId = (re == 1 ? FEDNumbering::MINGE0FEDID + 1 : FEDNumbering::MINGE0FEDID);
        maxLayerId = GEMDetId::maxLayerId0;
        maxiEtaId = maxiEtaIdGE0_;
      } else if (st == 1) {
        maxVFat = maxVFatGE11_;
        fedId = (re == 1 ? FEDNumbering::MINGEMFEDID + 1 : FEDNumbering::MINGEMFEDID);
        maxiEtaId = maxiEtaIdGE11_;
      } else if (st == 2) {
        maxVFat = maxVFatGE21_;
        fedId = (re == 1 ? FEDNumbering::MINGE21FEDID + 1 : FEDNumbering::MINGE21FEDID);
        maxiEtaId = maxiEtaIdGE21_;
      }

      for (int ch = 1; ch <= GEMDetId::maxChamberId; ++ch) {
        for (int ly = 1; ly <= maxLayerId; ++ly) {
          GEMDetId gemId(re, 1, st, ly, ch, 0);

          GEMROMapping::chamEC ec;
          ec.fedId = fedId;
          ec.gebId = gebId;
          ec.amcNum = amcNum;

          GEMROMapping::chamDC dc;
          dc.detId = gemId;
          dc.vfatVer = vfatVerV3_;
          romap.add(ec, dc);

          GEMROMapping::sectorEC amcEC = {fedId, amcNum};
          if (!romap.isValidAMC(amcEC))
            romap.add(amcEC);

          uint16_t chipPos = 0;
          for (int lphi = 0; lphi < maxVFat; ++lphi) {
            for (int ieta = 1; ieta <= maxiEtaId; ++ieta) {
              GEMROMapping::vfatEC vec;
              vec.vfatAdd = chipPos;
              vec.detId = gemId;

              GEMROMapping::vfatDC vdc;
              vdc.vfatType = vfatTypeV3_;  // > 10 is vfat v3
              vdc.detId = GEMDetId(re, 1, st, ly, ch, ieta);
              vdc.localPhi = lphi;

              romap.add(vec, vdc);
              romap.add(gemId.chamberId(), vec);

              chipPos++;
            }
          }

          // 5 bits for gebId
          if (st > 0 && gebId == maxGEB1_) {
            gebId = 0;
            amcNum += 2;  // only odd amc No. is used for GE11
          } else if (st == 0 && gebId == maxGEBs_) {
            gebId = 0;
            amcNum++;
          } else {
            // 1 geb per chamber
            gebId++;
          }
        }
      }
    }
  }

  for (int i = 0; i < maxChan_; ++i) {
    // only 1 vfat type for dummy map
    GEMROMapping::channelNum cMap;
    cMap.vfatType = vfatTypeV3_;
    cMap.chNum = i;

    GEMROMapping::stripNum sMap;
    sMap.vfatType = vfatTypeV3_;
    sMap.stNum = i;

    romap.add(cMap, sMap);
    romap.add(sMap, cMap);
  }
}

serialize()

template<class Archive >

void GEMeMap::serialize ( Archive &  ar, const unsigned int  version  )

private

version()

const std::string & GEMeMap::version

(

)

const

Definition at line 12 of file GEMeMap.cc.

References theVersion.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

{ return theVersion; }

Friends And Related Function Documentation

boost::serialization::access

friend class boost::serialization::access

friend

Definition at line 55 of file GEMeMap.h.

cond::serialization::access

template<typename CondSerializationT , typename Enabled >

friend struct cond::serialization::access

friend

Definition at line 55 of file GEMeMap.h.

Member Data Documentation

chipIdMask_

const int GEMeMap::chipIdMask_ = 0xfff

static

Definition at line 61 of file GEMeMap.h.

Referenced by convert().

maxAMCs_

const int GEMeMap::maxAMCs_ = 15

static

Definition at line 65 of file GEMeMap.h.

maxChan_

const int GEMeMap::maxChan_ = 128

static

Definition at line 72 of file GEMeMap.h.

Referenced by convertDummy(), GEMDQMBase::getVFATNumberByDigi(), and GEMDQMBase::loadChambers().

maxGEB1_

const int GEMeMap::maxGEB1_ = 12

static

Definition at line 63 of file GEMeMap.h.

Referenced by convertDummy().

maxGEB2_

const int GEMeMap::maxGEB2_ = 12

static

Definition at line 64 of file GEMeMap.h.

maxGEBs_

const int GEMeMap::maxGEBs_ = 24

static

Definition at line 62 of file GEMeMap.h.

Referenced by convertDummy().

maxiEtaIdGE0_

const int GEMeMap::maxiEtaIdGE0_ = 8

static

Definition at line 69 of file GEMeMap.h.

Referenced by convertDummy(), and GEMDQMBase::getIEtaFromVFATGE0().

maxiEtaIdGE11_

const int GEMeMap::maxiEtaIdGE11_ = 8

static

Definition at line 70 of file GEMeMap.h.

Referenced by convertDummy(), GEMDQMBase::getIEtaFromVFATGE11(), and GEMDQMBase::getVFATNumberGE11().

maxiEtaIdGE21_

const int GEMeMap::maxiEtaIdGE21_ = 16

static

Definition at line 71 of file GEMeMap.h.

Referenced by convertDummy(), and GEMDQMBase::getIEtaFromVFATGE21().

maxVFatGE0_

const int GEMeMap::maxVFatGE0_ = 12

static

Definition at line 66 of file GEMeMap.h.

Referenced by convertDummy(), and GEMDQMBase::getMaxVFAT().

maxVFatGE11_

const int GEMeMap::maxVFatGE11_ = 3

static

Definition at line 67 of file GEMeMap.h.

Referenced by convertDummy(), and GEMDQMBase::getMaxVFAT().

maxVFatGE21_

const int GEMeMap::maxVFatGE21_ = 6

static

Definition at line 68 of file GEMeMap.h.

Referenced by convertDummy(), and GEMDQMBase::getMaxVFAT().

theChamberMap_

std::vector<GEMChamberMap> GEMeMap::theChamberMap_

Definition at line 48 of file GEMeMap.h.

Referenced by convert().

theStripMap_

std::vector<GEMStripMap> GEMeMap::theStripMap_

Definition at line 50 of file GEMeMap.h.

Referenced by convert().

theVersion

std::string GEMeMap::theVersion

private

Definition at line 53 of file GEMeMap.h.

Referenced by version().

theVFatMap_

std::vector<GEMVFatMap> GEMeMap::theVFatMap_

Definition at line 49 of file GEMeMap.h.

Referenced by convert().

vfatTypeV3_

const int GEMeMap::vfatTypeV3_ = 11

static

Definition at line 60 of file GEMeMap.h.

Referenced by convertDummy().

vfatVerV3_

const int GEMeMap::vfatVerV3_ = 3

static

Definition at line 59 of file GEMeMap.h.

Referenced by convertDummy().