EcalDQMCommonUtils.cc

Go to the documentation of this file.

#include "DQM/EcalCommon/interface/EcalDQMCommonUtils.h"

#include "DataFormats/EcalDetId/interface/EcalPnDiodeDetId.h"

#include <mutex>

namespace ecaldqm {
  unsigned memarr[] = {kEEm07, kEEm08, kEEm02, kEEm03, kEBm01, kEBm02, kEBm03, kEBm04, kEBm05, kEBm06, kEBm07,
                       kEBm08, kEBm09, kEBm10, kEBm11, kEBm12, kEBm13, kEBm14, kEBm15, kEBm16, kEBm17, kEBm18,
                       kEBp01, kEBp02, kEBp03, kEBp04, kEBp05, kEBp06, kEBp07, kEBp08, kEBp09, kEBp10, kEBp11,
                       kEBp12, kEBp13, kEBp14, kEBp15, kEBp16, kEBp17, kEBp18, kEEp07, kEEp08, kEEp02, kEEp03};
  const std::vector<unsigned> memDCC(memarr, memarr + 44);

  const double etaBound(1.479);

  unsigned dccId(const DetId &_id) {
    EcalElectronicsMapping const *map(getElectronicsMap());

    unsigned subdet(_id.subdetId());

    if (subdet == EcalBarrel)
      return map->DCCid(EBDetId(_id));
    else if (subdet == EcalTriggerTower)
      return map->DCCid(EcalTrigTowerDetId(_id));
    else if (subdet == EcalEndcap) {
      if (isEcalScDetId(_id))
        return map->getDCCandSC(EcalScDetId(_id)).first;
      else
        return map->getElectronicsId(EEDetId(_id)).dccId();
    } else if (subdet == EcalLaserPnDiode)
      return EcalPnDiodeDetId(_id).iDCCId();

    throw cms::Exception("InvalidDetId") << "EcalDQMCommonUtils::dccId(" << _id.rawId() << ")" << std::endl;

    return 0;
  }

  unsigned dccId(const EcalElectronicsId &_id) { return _id.dccId(); }

  unsigned memDCCId(unsigned _index) {
    // for DCCs with no MEM - map the index in an array of DCCs with no MEM to the
    // DCC ID
    if (_index >= memDCC.size())
      return 0;
    return memDCC.at(_index) + 1;
  }

  unsigned memDCCIndex(unsigned _dccid) {
    std::vector<unsigned>::const_iterator itr(std::find(memDCC.begin(), memDCC.end(), _dccid - 1));
    if (itr == memDCC.end())
      return -1;

    return (itr - memDCC.begin());
  }

  unsigned tccId(const DetId &_id) {
    EcalElectronicsMapping const *map(getElectronicsMap());

    unsigned subdet(_id.subdetId());

    if (subdet == EcalBarrel)
      return map->TCCid(EBDetId(_id));
    else if (subdet == EcalTriggerTower)
      return map->TCCid(EcalTrigTowerDetId(_id));
    else if (subdet == EcalEndcap) {
      if (isEcalScDetId(_id))
        return 0;  // incompatible
      else
        return map->getTriggerElectronicsId(EEDetId(_id)).tccId();
    }

    throw cms::Exception("InvalidDetId") << "EcalDQMCommonUtils::tccId(" << uint32_t(_id) << ")" << std::endl;

    return 0;
  }

  unsigned tccId(const EcalElectronicsId &_id) { return getElectronicsMap()->getTriggerElectronicsId(_id).tccId(); }

  unsigned towerId(const DetId &_id) {
    unsigned subdet(_id.subdetId());

    if (subdet == EcalBarrel)
      return EBDetId(_id).tower().iTT();
    else if (subdet == EcalTriggerTower)
      return EcalTrigTowerDetId(_id).iTT();
    else if (subdet == EcalEndcap) {
      if (isEcalScDetId(_id))
        return getElectronicsMap()->getDCCandSC(EcalScDetId(_id)).second;
      else
        return getElectronicsMap()->getElectronicsId(EEDetId(_id)).towerId();
    }

    throw cms::Exception("InvalidDetId") << "EcalDQMCommonUtils::towerId(" << std::hex << uint32_t(_id) << ")"
                                         << std::endl;

    return 0;
  }

  unsigned towerId(const EcalElectronicsId &_id) { return _id.towerId(); }

  unsigned ttId(const DetId &_id) {
    unsigned subdet(_id.subdetId());

    if (subdet == EcalBarrel)
      return EBDetId(_id).tower().iTT();
    else if (subdet == EcalTriggerTower)
      return getElectronicsMap()->iTT(EcalTrigTowerDetId(_id));
    else if (subdet == EcalEndcap && !isEcalScDetId(_id))
      return getElectronicsMap()->getTriggerElectronicsId(_id).ttId();

    throw cms::Exception("InvalidDetId") << "EcalDQMCommonUtils::ttId(" << std::hex << uint32_t(_id) << ")"
                                         << std::endl;

    return 0;
  }

  unsigned ttId(const EcalElectronicsId &_id) { return getElectronicsMap()->getTriggerElectronicsId(_id).ttId(); }

  unsigned rtHalf(DetId const &_id) {
    if (_id.subdetId() == EcalBarrel) {
      int ic(EBDetId(_id).ic());
      if ((ic - 1) / 20 > 4 && (ic - 1) % 20 < 10)
        return 1;
    } else {
      unsigned iDCC(dccId(_id) - 1);
      if ((iDCC == kEEm05 || iDCC == kEEp05) && EEDetId(_id).ix() > 50)
        return 1;
    }

    return 0;
  }

  std::pair<unsigned, unsigned> innerTCCs(unsigned _dccId) {
    int iDCC(_dccId - 1);
    std::pair<unsigned, unsigned> res;
    if (iDCC <= kEEmHigh) {
      res.first = (iDCC - kEEmLow) * 2;
      if (res.first == 0)
        res.first = 18;
      res.second = (iDCC - kEEmLow) * 2 + 1;
    } else if (iDCC < -kEBpHigh)
      res.first = res.second = _dccId + 27;
    else {
      res.first = (iDCC - kEEpLow) * 2 + 90;
      if (res.first == 90)
        res.first = 108;
      res.second = (iDCC - kEEpLow) * 2 + 91;
    }

    return res;
  }

  std::pair<unsigned, unsigned> outerTCCs(unsigned _dccId) {
    int iDCC(_dccId - 1);
    std::pair<unsigned, unsigned> res;
    if (iDCC <= kEEmHigh) {
      res.first = (iDCC - kEEmLow) * 2 + 18;
      if (res.first == 18)
        res.first = 36;
      res.second = (iDCC - kEEmLow) * 2 + 19;
    } else if (iDCC <= kEBpHigh)
      res.first = res.second = _dccId + 27;
    else {
      res.first = (iDCC - kEEpLow) * 2 + 72;
      if (res.first == 72)
        res.first = 90;
      res.second = (iDCC - kEEpLow) * 2 + 73;
    }

    return res;
  }

  std::vector<DetId> scConstituents(EcalScDetId const &_scid) {
    std::vector<DetId> res;

    int ixbase((_scid.ix() - 1) * 5);
    int iybase((_scid.iy() - 1) * 5);

    for (int ix(1); ix <= 5; ++ix) {
      for (int iy(1); iy <= 5; ++iy) {
        if (EEDetId::validDetId(ixbase + ix, iybase + iy, _scid.zside()))
          res.push_back(EEDetId(ixbase + ix, iybase + iy, _scid.zside()));
      }
    }

    return res;
  }

  int zside(const DetId &_id) {
    uint32_t rawId(_id);

    switch (_id.subdetId()) {
      case EcalBarrel:
        return (((rawId >> 16) & 0x1) == 1 ? 1 : -1);
      case EcalEndcap:
        return (((rawId >> 14) & 0x1) == 1 ? 1 : -1);
      case EcalTriggerTower:
        return (((rawId >> 15) & 0x1) == 1 ? 1 : -1);
      case EcalLaserPnDiode:
        return (((rawId >> 4) & 0x7f) > kEBpLow ? 1 : -1);
      default:
        throw cms::Exception("InvalidDetId")
            << "EcalDQMCommonUtils::zside(" << std::hex << uint32_t(_id) << ")" << std::endl;
    }

    return 0;
  }

  double eta(const EBDetId &_ebid) {
    return _ebid.approxEta() + (_ebid.zside() < 0 ? 0.5 : -0.5) * EBDetId::crystalUnitToEta;
  }

  double eta(const EEDetId &_id) { return getGeometry()->getPosition(_id).eta(); }

  double phi(EBDetId const &_ebid) {
    const double degToRad(0.0174533);
    return (_ebid.iphi() - 10.5) * degToRad;
  }

  double phi(EEDetId const &_eeid) {
    const double degToRad(0.0174533);
    double p(std::atan2(_eeid.ix() - 50.5, _eeid.iy() - 50.5));
    if (p < -10. * degToRad)
      p += 360. * degToRad;
    return p;
  }

  double phi(EcalTrigTowerDetId const &_ttid) {
    const double degToRad(0.0174533);
    double p((_ttid.iphi() - 0.5) * 5. * degToRad);
    if (p > 350. * degToRad)
      p -= 360. * degToRad;
    return p;
  }

  double phi(double _phi) {
    const double degToRad(0.0174533);
    if (_phi < -10. * degToRad)
      _phi += 360. * degToRad;
    return _phi;
  }

  bool isForward(DetId const &_id) {
    // the numbers here roughly corresponds to a cut at |eta| > 2.2
    // cf hepwww.rl.ac.uk/CMSecal/Dee-layout.html
    if (_id.subdetId() != EcalEndcap)
      return false;
    if (isEcalScDetId(_id)) {
      EcalScDetId scid(_id);
      return (scid.ix() - 10) * (scid.ix() - 10) + (scid.iy() - 10) * (scid.iy() - 10) < 25.;
    } else {
      EEDetId eeid(_id);
      return (eeid.ix() - 50) * (eeid.ix() - 50) + (eeid.iy() - 50) * (eeid.iy() - 50) < 625.;
    }
  }

  bool isCrystalId(const DetId &_id) {
    return (_id.det() == DetId::Ecal) &&
           ((_id.subdetId() == EcalBarrel) || ((_id.subdetId() == EcalEndcap) && (((_id.rawId() >> 15) & 0x1) == 0)));
  }

  bool isSingleChannelId(const DetId &_id) {
    return (_id.det() == DetId::Ecal) && (isCrystalId(_id) || (_id.subdetId() == EcalLaserPnDiode));
  }

  bool isEcalScDetId(const DetId &_id) {
    return (_id.det() == DetId::Ecal) && ((_id.subdetId() == EcalEndcap) && ((_id.rawId() >> 15) & 0x1));
  }

  bool isEndcapTTId(const DetId &_id) {
    return (_id.det() == DetId::Ecal) && ((_id.subdetId() == EcalTriggerTower) && (((_id.rawId() >> 7) & 0x7f) > 17));
  }

  unsigned dccId(std::string const &_smName) {
    unsigned smNumber(std::atoi(_smName.substr(3).c_str()));

    if (_smName.find("EE-") == 0)
      return kEEmLow + 1 + ((smNumber + 2) % 9);
    else if (_smName.find("EB-") == 0)
      return kEBmLow + 1 + smNumber;
    else if (_smName.find("EB+") == 0)
      return kEBpLow + 1 + smNumber;
    else if (_smName.find("EE+") == 0)
      return kEEpLow + 1 + ((smNumber + 2) % 9);
    else
      return 0;
  }

  std::string smName(unsigned _dccId) {
    std::stringstream ss;

    unsigned iSM(_dccId - 1);

    if (iSM <= kEEmHigh)
      ss << "EE-" << std::setw(2) << std::setfill('0') << (((iSM - kEEmLow + 6) % 9) + 1);
    else if (iSM <= kEBmHigh)
      ss << "EB-" << std::setw(2) << std::setfill('0') << (iSM - kEBmLow + 1);
    else if (iSM <= kEBpHigh)
      ss << "EB+" << std::setw(2) << std::setfill('0') << (iSM - kEBpLow + 1);
    else if (iSM <= kEEpHigh)
      ss << "EE+" << std::setw(2) << std::setfill('0') << (((iSM - kEEpLow + 6) % 9) + 1);

    return ss.str();
  }

  // numbers from CalibCalorimetry/EcalLaserAnalyzer/src/MEEEGeom.cc
  unsigned EEPnDCC(unsigned _dee, unsigned _ab) {
    switch (_dee) {
      case 1:  // EE+F -> FEDs 649-653/0
        if (_ab == 0)
          return 50;
        else
          return 51;
      case 2:  // EE+N -> FEDs 646-648, 653/1, 654
        if (_ab == 0)
          return 47;
        else
          return 46;
      case 3:  // EE-N -> FEDs 601-603, 608/1, 609
        if (_ab == 0)
          return 1;
        else
          return 2;
      case 4:  // EE-F -> FEDs 604-608/0
        if (_ab == 0)
          return 5;
        else
          return 6;
      default:
        return 0;
    }
  }

  unsigned nCrystals(unsigned _dccId) {
    unsigned iSM(_dccId - 1);

    if (iSM >= kEBmLow && iSM <= kEBpHigh)
      return 1700;

    switch (iSM) {
      case kEEm05:
      case kEEp05:
        return 810;
      case kEEm07:
      case kEEm03:
      case kEEp07:
      case kEEp03:
        return 830;
      case kEEm09:
      case kEEm01:
      case kEEp09:
      case kEEp01:
        return 815;
      case kEEm08:
      case kEEm02:
      case kEEp08:
      case kEEp02:
        return 791;
      case kEEm04:
      case kEEm06:
      case kEEp04:
      case kEEp06:
        return 821;
      default:
        return 0;
    }
  }

  unsigned nSuperCrystals(unsigned _dccId) {
    unsigned iSM(_dccId - 1);

    if (iSM >= kEBmLow && iSM <= kEBpHigh)
      return 68;

    switch (iSM) {
      case kEEm05:
      case kEEp05:
        return 41;
      case kEEm07:
      case kEEm03:
      case kEEp07:
      case kEEp03:
        return 34;
      case kEEm09:
      case kEEm01:
      case kEEm04:
      case kEEm06:
      case kEEp09:
      case kEEp01:
      case kEEp04:
      case kEEp06:
        return 33;
      case kEEm08:
      case kEEm02:
      case kEEp08:
      case kEEp02:
        return 32;
      default:
        return 0;
    }
  }

  bool ccuExists(unsigned _dccId, unsigned _towerId) {
    if (_towerId == 69 || _towerId == 70)
      return true;
    else if ((_dccId == 8 || _dccId == 53) && _towerId >= 18 && _towerId <= 24)
      return false;
    else if (_dccId <= kEEmHigh + 1 || _dccId >= kEEpLow + 1)
      return _towerId <= nSuperCrystals(_dccId);
    else
      return _towerId <= 68;
  }

  /*
  Note on concurrency compatibility:
  Call to getters bellow must always happen after
  EcalDQMonitor::ecaldqmGetSetupObjects or equivalent.
  As long as check-set-get are executed in this order
  within each thread, the following functions are
  thread-safe.
*/

  std::mutex mapMutex;
  EcalElectronicsMapping const *electronicsMap(nullptr);
  EcalTrigTowerConstituentsMap const *trigtowerMap(nullptr);
  CaloGeometry const *geometry(nullptr);
  CaloTopology const *topology(nullptr);

  bool checkElectronicsMap(bool _throw /* = true*/) {
    std::lock_guard<std::mutex> lock(mapMutex);
    if (electronicsMap)
      return true;
    if (_throw)
      throw cms::Exception("InvalidCall") << "ElectronicsMapping not initialized";
    return false;
  }

  EcalElectronicsMapping const *getElectronicsMap() {
    if (!electronicsMap)
      checkElectronicsMap();
    return electronicsMap;
  }

  void setElectronicsMap(EcalElectronicsMapping const *_map) {
    std::lock_guard<std::mutex> lock(mapMutex);
    electronicsMap = _map;
  }

  bool checkTrigTowerMap(bool _throw /* = true*/) {
    std::lock_guard<std::mutex> lock(mapMutex);
    if (trigtowerMap)
      return true;
    if (_throw)
      throw cms::Exception("InvalidCall") << "TrigTowerConstituentsMap not initialized";
    return false;
  }

  EcalTrigTowerConstituentsMap const *getTrigTowerMap() {
    if (!trigtowerMap)
      checkTrigTowerMap();
    return trigtowerMap;
  }

  void setTrigTowerMap(EcalTrigTowerConstituentsMap const *_map) {
    std::lock_guard<std::mutex> lock(mapMutex);
    trigtowerMap = _map;
  }

  bool checkGeometry(bool _throw /* = true*/) {
    std::lock_guard<std::mutex> lock(mapMutex);
    if (geometry)
      return true;
    if (_throw)
      throw cms::Exception("InvalidCall") << "CaloGeometry not initialized";
    return false;
  }

  CaloGeometry const *getGeometry() {
    if (!geometry)
      checkGeometry();
    return geometry;
  }

  void setGeometry(CaloGeometry const *_geom) {
    std::lock_guard<std::mutex> lock(mapMutex);
    geometry = _geom;
  }

  bool checkTopology(bool _throw /* = true*/) {
    std::lock_guard<std::mutex> lock(mapMutex);
    if (topology)
      return true;
    if (_throw)
      throw cms::Exception("InvalidCall") << "CaloTopology not initialized";
    return false;
  }

  CaloTopology const *getTopology() {
    if (!topology)
      checkTopology();
    return topology;
  }

  void setTopology(CaloTopology const *_geom) {
    std::lock_guard<std::mutex> lock(mapMutex);
    topology = _geom;
  }
}  // namespace ecaldqm