HcalDcsMap.cc

Go to the documentation of this file.

 
#include <iostream>
#include <set>
 
#include "CondFormats/HcalObjects/interface/HcalDcsMap.h"
#include "CondFormats/HcalObjects/interface/HcalObjectAddons.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
 
HcalDcsMap::HcalDcsMap(const HcalDcsMapAddons::Helper& helper) : mItems(helper.mItems.begin(), helper.mItems.end()) {
  initialize();
}
 
HcalDcsMap::~HcalDcsMap() {}
// copy-ctor
HcalDcsMap::HcalDcsMap(const HcalDcsMap& src)
    : mItems(src.mItems), mItemsById(src.mItemsById), mItemsByDcsId(src.mItemsByDcsId) {}
// copy assignment operator
HcalDcsMap& HcalDcsMap::operator=(const HcalDcsMap& rhs) {
  HcalDcsMap temp(rhs);
  temp.swap(*this);
  return *this;
}
// public swap function
void HcalDcsMap::swap(HcalDcsMap& other) {
  std::swap(mItems, other.mItems);
  std::swap(mItemsById, other.mItemsById);
  std::swap(mItemsByDcsId, other.mItemsByDcsId);
}
// move constructor
HcalDcsMap::HcalDcsMap(HcalDcsMap&& other) : HcalDcsMap() { other.swap(*this); }
 
HcalDcsMap::const_iterator HcalDcsMap::beginById(void) const {
  const_iterator _iter;
  _iter.fIter = mItemsById.begin();
  return _iter;
}
 
HcalDcsMap::const_iterator HcalDcsMap::beginByDcsId(void) const {
  const_iterator _iter;
  _iter.fIter = mItemsByDcsId.begin();
  return _iter;
}
 
HcalDcsMap::const_iterator HcalDcsMap::endById(void) const {
  const_iterator _iter;
  _iter.fIter = mItemsById.end();
  return _iter;
}
 
HcalDcsMap::const_iterator HcalDcsMap::endByDcsId(void) const {
  const_iterator _iter;
  _iter.fIter = mItemsByDcsId.end();
  return _iter;
}
 
// iterator methods
bool HcalDcsMap::const_iterator::operator!=(const HcalDcsMap::const_iterator& other) {
  if (fIter != other.fIter)
    return true;
  else
    return false;
}
 
HcalDcsMap::const_iterator HcalDcsMap::const_iterator::operator++() {
  ++fIter;
  return *this;
}
 
HcalDcsMap::const_iterator HcalDcsMap::const_iterator::operator++(int) {
  const_iterator i = *this;
  ++fIter;
  return i;
}
 
void HcalDcsMap::const_iterator::next(void) { ++fIter; }
 
HcalDcsDetId HcalDcsMap::const_iterator::getHcalDcsDetId(void) { return (*fIter)->mDcsId; }
 
HcalDetId HcalDcsMap::const_iterator::getHcalDetId(void) { return (*fIter)->mId; }
 
const HcalDcsMap::Item* HcalDcsMap::findById(unsigned long fId) const {
  Item target(fId, 0);
  return HcalObjectAddons::findByT<Item, HcalDcsMapAddons::LessById>(&target, mItemsById);
}
 
const HcalDcsMap::Item* HcalDcsMap::findByDcsId(unsigned long fDcsId) const {
  Item target(0, fDcsId);
  return HcalObjectAddons::findByT<Item, HcalDcsMapAddons::LessByDcsId>(&target, mItemsByDcsId);
}
 
HcalDetId HcalDcsMap::lookup(HcalDcsDetId fId) const {
  // DCS type is a part of DcsDetId but it does not make sense to keep
  // duplicate records in the map for DCS channels where only type is different.
  // Hence, the type in HcalDcsDetId is always forced to DCSUNKNOWN
  HcalDcsDetId fDcsId_notype(fId.subdet(),
                             fId.ring(),  // side is already included
                             fId.slice(),
                             HcalDcsDetId::DCSUNKNOWN,
                             fId.subchannel());
  auto item = HcalDcsMap::findByDcsId(fDcsId_notype.rawId());
  return item ? item->mId : 0;
}
 
HcalDcsDetId HcalDcsMap::lookup(HcalDetId fId, HcalDcsDetId::DcsType type) const {
  auto item = HcalDcsMap::findById(fId.rawId());
  HcalDcsDetId _id(item ? item->mId : 0);
  return HcalDcsDetId(_id.subdet(), _id.zside() * _id.ring(), _id.slice(), type, _id.subchannel());
}
 
//FIXME: remove duplicates
std::vector<HcalDcsDetId> HcalDcsMap::allHcalDcsDetId() const {
  std::vector<HcalDcsDetId> result;
  for (std::vector<Item>::const_iterator item = mItems.begin(); item != mItems.end(); item++)
    if (item->mDcsId)
      result.push_back(HcalDcsDetId(item->mDcsId));
  return result;
}
 
// FIXME: remove duplicates
std::vector<HcalGenericDetId> HcalDcsMap::allHcalDetId() const {
  std::vector<HcalGenericDetId> result;
  std::set<unsigned long> allIds;
  for (std::vector<Item>::const_iterator item = mItems.begin(); item != mItems.end(); item++)
    if (item->mId)
      allIds.insert(item->mId);
  for (std::set<unsigned long>::const_iterator channel = allIds.begin(); channel != allIds.end(); channel++) {
    result.push_back(HcalGenericDetId(*channel));
  }
  return result;
}
 
HcalDcsMapAddons::Helper::Helper() {}
 
bool HcalDcsMapAddons::Helper::mapGeomId2DcsId(HcalDetId fId, HcalDcsDetId fDcsId) {
  // DCS type is a part of DcsDetId but it does not make sense to keep
  // duplicate records in the map for DCS channels where only type is different.
  // Hence, the type in HcalDcsDetId is always forced to DCSUNKNOWN
  HcalDcsDetId fDcsId_notype(fDcsId.subdet(),
                             fDcsId.ring(),  // side is included
                             fDcsId.slice(),
                             HcalDcsDetId::DCSUNKNOWN,
                             fDcsId.subchannel());
  HcalDcsMap::Item target(fId, fDcsId_notype);
  auto iter = mItems.find(target);
  if (iter != mItems.end() and iter->mId == fId) {
    edm::LogWarning("HCAL") << "HcalDcsMap::mapGeomId2DcsId-> Geom channel " << fId << " already mapped to DCS channel "
                            << fDcsId_notype;
    return false;  // element already exists
  }
  mItems.insert(target);
 
  return true;
}
 
void HcalDcsMap::sortById() { HcalObjectAddons::sortByT<Item, HcalDcsMapAddons::LessById>(mItems, mItemsById); }
void HcalDcsMap::sortByDcsId() {
  HcalObjectAddons::sortByT<Item, HcalDcsMapAddons::LessByDcsId>(mItems, mItemsByDcsId);
}
 
void HcalDcsMap::initialize() {
  sortById();
  sortByDcsId();
}