MESet.cc

Go to the documentation of this file.

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

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

#include "FWCore/ServiceRegistry/interface/Service.h"
#include "FWCore/ParameterSet/interface/ParameterSetDescription.h"

#include "TString.h"
#include "TPRegexp.h"

namespace ecaldqm
{
  MESet::MESet() :
    mes_(0),
    path_(""),
    otype_(binning::nObjType),
    btype_(binning::nBinType),
    kind_(MonitorElement::DQM_KIND_INVALID),
    lumiFlag_(false),
    batchMode_(false),
    active_(false)
  {
  }

  MESet::MESet(std::string const& _path, binning::ObjectType _otype, binning::BinningType _btype, MonitorElement::Kind _kind) :
    mes_(0),
    path_(_path),
    otype_(_otype),
    btype_(_btype),
    kind_(_kind),
    lumiFlag_(false),
    batchMode_(false),
    active_(false)
  {
    if(path_.empty() || path_.find("/") == std::string::npos ||
       (otype_ != binning::kChannel && path_.find("/") == path_.size() - 1))
      throw_(_path + " cannot be used for ME path name");

    switch(kind_){
    case MonitorElement::DQM_KIND_REAL:
    case MonitorElement::DQM_KIND_TH1F:
    case MonitorElement::DQM_KIND_TPROFILE:
    case MonitorElement::DQM_KIND_TH2F:
    case MonitorElement::DQM_KIND_TPROFILE2D:
      break;
    default:
      throw_("Unsupported MonitorElement kind");
    }
  }

  MESet::MESet(MESet const& _orig) :
    mes_(_orig.mes_),
    path_(_orig.path_),
    otype_(_orig.otype_),
    btype_(_orig.btype_),
    kind_(_orig.kind_),
    lumiFlag_(_orig.lumiFlag_),
    batchMode_(_orig.batchMode_),
    active_(_orig.active_)
  {
  }

  MESet::~MESet()
  {
  }

  MESet&
  MESet::operator=(MESet const& _rhs)
  {
    mes_ = _rhs.mes_;
    path_ = _rhs.path_;
    otype_ = _rhs.otype_;
    btype_ = _rhs.btype_;
    kind_ = _rhs.kind_;
    active_ = _rhs.active_;

    return *this;
  }

  MESet*
  MESet::clone(std::string const& _path/* = ""*/) const
  {
    std::string path(path_);
    if(_path != "") path_ = _path;
    MESet* copy(new MESet(*this));
    path_ = path;
    return copy;
  }

  void
  MESet::clear() const
  {
    active_ = false;
    mes_.clear();
  }

  void
  MESet::setAxisTitle(std::string const& _title, int _axis/* = 1*/)
  {
    if(!active_) return;

    unsigned nME(mes_.size());
    for(unsigned iME(0); iME < nME; iME++)
      mes_[iME]->setAxisTitle(_title, _axis);
  }

  void
  MESet::reset(double _content/* = 0.*/, double _err/* = 0.*/, double _entries/* = 0.*/)
  {
    if(!active_) return;

    resetAll(_content, _err, _entries);
  }

  void
  MESet::resetAll(double _content/* = 0.*/, double _err/* = 0.*/, double _entries/* = 0.*/)
  {
    if(!active_) return;

    unsigned nME(mes_.size());

    if(kind_ == MonitorElement::DQM_KIND_REAL){
      for(unsigned iME(0); iME < nME; iME++)
        mes_[iME]->Fill(_content);
      return;
    }

    bool simple(true);
    if(_content != 0. || _err != 0. || _entries != 0.) simple = false;

    for(unsigned iME(0); iME < nME; iME++){
      TH1* h(mes_[iME]->getTH1());
      h->Reset();
      if(simple) continue;

      int nbinsX(h->GetNbinsX());
      int nbinsY(h->GetNbinsY());
      double entries(0.);
      for(int ix(1); ix <= nbinsX; ix++){
        for(int iy(1); iy <= nbinsY; iy++){
          int bin(h->GetBin(ix, iy));
          h->SetBinContent(bin, _content);
          h->SetBinError(bin, _err);
          if(kind_ == MonitorElement::DQM_KIND_TPROFILE){
            static_cast<TProfile*>(h)->SetBinEntries(bin, _entries);
            entries += _entries;
          }
          else if(kind_ == MonitorElement::DQM_KIND_TPROFILE2D){
            static_cast<TProfile2D*>(h)->SetBinEntries(bin, _entries);
            entries += _entries;
          }
        }
      }
      if(entries == 0.) entries = _entries;
      h->SetEntries(_entries);
    }
  }


  std::string
  MESet::formPath(std::map<std::string, std::string> const& _replacements) const
  {
    TString path(path_);

    for(typename MESet::PathReplacements::const_iterator repItr(_replacements.begin()); repItr != _replacements.end(); ++repItr){
      TString pattern("\\%\\(");
      pattern += repItr->first;
      pattern += "\\)s";

      TPRegexp re(pattern);

      re.Substitute(path, repItr->second, "g");
    }

    return path.Data();
  }

  bool
  MESet::maskMatches(DetId const& _id, uint32_t _mask, StatusManager const* _statusManager) const
  {
    if(!_statusManager) return false;

    if((_statusManager->getStatus(_id.rawId()) & _mask) != 0) return true;

    int subdet(_id.subdetId());

    bool searchNeighborsInTower(btype_ == binning::kTriggerTower || btype_ == binning::kSuperCrystal);

    // turn off masking for good channel for the time being
    // update the RenderPlugin then enable again

    switch(subdet){
    case EcalBarrel: // this is a DetId for single crystal in barrel
      {
        EBDetId ebId(_id);
        EcalTrigTowerDetId ttId(ebId.tower());
        if((_statusManager->getStatus(ttId.rawId()) & _mask) != 0) return true;

        if(searchNeighborsInTower){
          std::vector<DetId> ids(getTrigTowerMap()->constituentsOf(ttId));
          for(std::vector<DetId>::iterator idItr(ids.begin()); idItr != ids.end(); ++idItr)
            if((_statusManager->getStatus(idItr->rawId()) & _mask) != 0) return true;
        }
      }
      break;

    case EcalEndcap:
      if(isEcalScDetId(_id)){
        EcalScDetId scId(_id);
        for(int ix(1); ix <= 5; ix++){
          for(int iy(1); iy <= 5; iy++){
            int iix((scId.ix() - 1) * 5 + ix);
            int iiy((scId.iy() - 1) * 5 + iy);
            if(!EEDetId::validDetId(iix, iiy, scId.zside())) continue;
            if((_statusManager->getStatus(EEDetId(iix, iiy, scId.zside()).rawId()) & _mask) != 0) return true;
          }
        }
      }
      else{
        EEDetId eeId(_id);
        EcalScDetId scId(eeId.sc());
        if((_statusManager->getStatus(scId.rawId()) & _mask) != 0) return true;

        if(searchNeighborsInTower){
          for(int ix(1); ix <= 5; ix++){
            for(int iy(1); iy <= 5; iy++){
              int iix((scId.ix() - 1) * 5 + ix);
              int iiy((scId.iy() - 1) * 5 + iy);
              if(!EEDetId::validDetId(iix, iiy, scId.zside())) continue;
              if((_statusManager->getStatus(EEDetId(iix, iiy, scId.zside()).rawId()) & _mask) != 0) return true;
            }
          }
        }
      }
      break;

    case EcalTriggerTower:
      {
        EcalTrigTowerDetId ttId(_id);
        std::vector<DetId> ids(getTrigTowerMap()->constituentsOf(ttId));
        for(std::vector<DetId>::iterator idItr(ids.begin()); idItr != ids.end(); ++idItr)
          if((_statusManager->getStatus(idItr->rawId()) & _mask) != 0) return true;
      }
      break;

    default:
      break;
    }

    return false;
  }

  void
  MESet::softReset()
  {
    if(!active_) return;

    DQMStore& store(*edm::Service<DQMStore>());

    for(unsigned iME(0); iME < mes_.size(); ++iME)
      store.softReset(mes_[iME]);
  }

  void
  MESet::recoverStats()
  {
    if(!active_) return;

    DQMStore& store(*edm::Service<DQMStore>());

    for(unsigned iME(0); iME < mes_.size(); ++iME)
      store.disableSoftReset(mes_[iME]);
  }

  void
  MESet::fill_(unsigned _iME, int _bin, double _w)
  {
    if(kind_ == MonitorElement::DQM_KIND_REAL) return;

    MonitorElement* me(mes_[_iME]);
    if(!me) return;

    TH1* h(me->getTH1());

    int nbinsX(h->GetNbinsX());

    double x(h->GetXaxis()->GetBinCenter(_bin % (nbinsX + 2)));

    if(kind_ == MonitorElement::DQM_KIND_TH1F || kind_ == MonitorElement::DQM_KIND_TPROFILE)
      me->Fill(x, _w);
    else{
      double y(h->GetYaxis()->GetBinCenter(_bin / (nbinsX + 2)));
      me->Fill(x, y, _w);
    }
  }

  void
  MESet::fill_(unsigned _iME, int _bin, double _y, double _w)
  {
    if(kind_ != MonitorElement::DQM_KIND_TH2F && kind_ != MonitorElement::DQM_KIND_TPROFILE2D) return;

    MonitorElement* me(mes_[_iME]);
    if(!me) return;

    TH1* h(me->getTH1());

    int nbinsX(h->GetNbinsX());

    double x(h->GetXaxis()->GetBinCenter(_bin % (nbinsX + 2)));
    me->Fill(x, _y, _w);
  }

  void
  MESet::fill_(unsigned _iME, double _x, double _wy, double _w)
  {
    MonitorElement* me(mes_[_iME]);
    if(!me) return;

    if(kind_ == MonitorElement::DQM_KIND_REAL)
      me->Fill(_x);
    else if(kind_ == MonitorElement::DQM_KIND_TH1F || kind_ == MonitorElement::DQM_KIND_TPROFILE)
      me->Fill(_x, _wy);
    else
      me->Fill(_x, _wy, _w);
  }



  MESet::ConstBin::ConstBin(MESet const& _meSet, unsigned _iME/* = 0*/, int _iBin/* = 1*/) :
    meSet_(&_meSet),
    iME(_iME),
    iBin(_iBin),
    otype(binning::nObjType)
  {
    if(iME == unsigned(-1)) return;

    // current internal bin numbering scheme does not allow 1D histograms (overflow & underflow in each y)
    MonitorElement::Kind kind(meSet_->getKind());
    //    if(kind != MonitorElement::DQM_KIND_TH1F && kind != MonitorElement::DQM_KIND_TPROFILE &&
    if(kind != MonitorElement::DQM_KIND_TH2F && kind != MonitorElement::DQM_KIND_TPROFILE2D)
      throw cms::Exception("InvalidOperation") << "MESet::ConstBin::Ctor: const_iterator only available for MESet of 2D histograms";

    MonitorElement const* me(meSet_->getME(iME));

    if(!me)
      throw cms::Exception("InvalidOperation") << "MESet::ConstBin::Ctor: ME " << iME << " does not exist for MESet " << meSet_->getPath();

    if(iBin == 1 && (kind == MonitorElement::DQM_KIND_TH2F || kind == MonitorElement::DQM_KIND_TPROFILE2D))
      iBin = me->getNbinsX() + 3;

    otype = binning::getObject(meSet_->getObjType(), iME);
  }

  MESet::ConstBin&
  MESet::ConstBin::operator=(ConstBin const& _rhs)
  {
    if(meSet_->getObjType() != _rhs.meSet_->getObjType() ||
       meSet_->getBinType() != _rhs.meSet_->getBinType())
      throw cms::Exception("IncompatibleAssignment")
        << "Iterator of otype " << _rhs.meSet_->getObjType() << " and btype " << _rhs.meSet_->getBinType()
        << " to otype " << meSet_->getObjType() << " and btype " << meSet_->getBinType()
        << " (" << _rhs.meSet_->getPath() << " to " << meSet_->getPath() << ")";

    iME = _rhs.iME;
    iBin = _rhs.iBin;
    otype = _rhs.otype;
      
    return *this;
  }



  MESet::const_iterator::const_iterator(MESet const& _meSet, DetId const& _id) :
    bin_()
  {
    binning::ObjectType otype(_meSet.getObjType());
    unsigned iME(binning::findPlotIndex(otype, _id));
    if(iME == unsigned(-1)) return;

    binning::BinningType btype(_meSet.getBinType());
    int bin(binning::findBin2D(otype, btype, _id));
    if(bin == 0) return;

    bin_.setMESet(_meSet);
    bin_.iME = iME;
    bin_.iBin = bin;
    bin_.otype = otype;
  }

  MESet::const_iterator&
  MESet::const_iterator::operator++()
  {
    unsigned& iME(bin_.iME);
    MESet const* meSet(bin_.getMESet());

    if(iME == unsigned(-1)) return *this;

    int& bin(bin_.iBin);
    binning::ObjectType& otype(bin_.otype);

    MonitorElement::Kind kind(meSet->getKind());
    MonitorElement const* me(meSet->getME(iME));

    int nbinsX(me->getNbinsX());
      
    ++bin;
    if(bin == 1){
      iME = 0;
      me = meSet->getME(iME);
      nbinsX = me->getNbinsX();
      if(kind == MonitorElement::DQM_KIND_TH2F || kind == MonitorElement::DQM_KIND_TPROFILE2D)
        bin = nbinsX + 3;
      otype = binning::getObject(meSet->getObjType(), iME);
    }

    if(bin % (nbinsX + 2) == nbinsX + 1){
      if(kind == MonitorElement::DQM_KIND_TH1F || kind == MonitorElement::DQM_KIND_TPROFILE ||
         bin / (nbinsX + 2) == me->getNbinsY()){
        iME += 1;
        me = meSet->getME(iME);
        if(!me){
          iME = unsigned(-1);
          bin = -1;
          otype = binning::nObjType;
        }
        else{
          nbinsX = me->getNbinsX();
          if(kind == MonitorElement::DQM_KIND_TH2F || kind == MonitorElement::DQM_KIND_TPROFILE2D)
            bin = nbinsX + 3;
          else
            bin = 1;
            
          otype = binning::getObject(meSet->getObjType(), iME);
        }
      }
      else 
        bin += 2;
    }

    return *this;
  }

  MESet::const_iterator&
  MESet::const_iterator::toNextChannel()
  {
    if(!bin_.getMESet()) return *this;
    do operator++();
    while(bin_.iME != unsigned(-1) && !bin_.isChannel());

    return *this;
  }

  bool
  MESet::const_iterator::up()
  {
    MESet const* meSet(bin_.getMESet());
    if(bin_.iME == unsigned(-1) || bin_.iBin < 1) return false;

    MonitorElement::Kind kind(meSet->getKind());
    if(kind != MonitorElement::DQM_KIND_TH2F && kind != MonitorElement::DQM_KIND_TPROFILE2D) return false;

    MonitorElement const* me(meSet->getME(bin_.iME));

    if(bin_.iBin / (me->getNbinsX() + 2) >= me->getNbinsY()) return false;

    bin_.iBin += me->getNbinsX() + 2;

    return true;
  }

  bool
  MESet::const_iterator::down()
  {
    MESet const* meSet(bin_.getMESet());
    if(bin_.iME == unsigned(-1) || bin_.iBin < 1) return false;

    MonitorElement::Kind kind(meSet->getKind());
    if(kind != MonitorElement::DQM_KIND_TH2F && kind != MonitorElement::DQM_KIND_TPROFILE2D) return false;

    MonitorElement const* me(meSet->getME(bin_.iME));

    if(bin_.iBin / (me->getNbinsX() + 2) <= 1) return false;

    bin_.iBin -= me->getNbinsX() + 2;

    return true;
  }

  bool
  MESet::const_iterator::left()
  {
    MESet const* meSet(bin_.getMESet());
    if(bin_.iME == unsigned(-1) || bin_.iBin < 1) return false;

    MonitorElement::Kind kind(meSet->getKind());
    if(kind != MonitorElement::DQM_KIND_TH2F && kind != MonitorElement::DQM_KIND_TPROFILE2D) return false;

    MonitorElement const* me(meSet->getME(bin_.iME));

    if(bin_.iBin % (me->getNbinsX() + 2) <= 1) return false;

    bin_.iBin -= 1;

    return true;
  }

  bool
  MESet::const_iterator::right()
  {
    MESet const* meSet(bin_.getMESet());
    if(bin_.iME == unsigned(-1) || bin_.iBin < 1) return false;

    MonitorElement::Kind kind(meSet->getKind());
    if(kind != MonitorElement::DQM_KIND_TH2F && kind != MonitorElement::DQM_KIND_TPROFILE2D) return false;

    MonitorElement const* me(meSet->getME(bin_.iME));

    if(bin_.iBin % (me->getNbinsX() + 2) >= me->getNbinsX()) return false;

    bin_.iBin += 1;

    return true;
  }
}

namespace boost
{
  template<> inline ecaldqm::MESet* new_clone<ecaldqm::MESet>(ecaldqm::MESet const& _s){ return _s.clone(); }
  template<> void delete_clone<ecaldqm::MESet>(ecaldqm::MESet const* _s){ checked_delete(_s); }
}