MESetNonObject.cc

Go to the documentation of this file.

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

namespace ecaldqm
{
  MESetNonObject::MESetNonObject(std::string const& _fullPath, binning::ObjectType _otype, binning::BinningType _btype, MonitorElement::Kind _kind, binning::AxisSpecs const* _xaxis/* = 0*/, binning::AxisSpecs const* _yaxis/* = 0*/, binning::AxisSpecs const* _zaxis/* = 0*/) :
    MESet(_fullPath, _otype, _btype, _kind),
    xaxis_(_xaxis ? new binning::AxisSpecs(*_xaxis) : nullptr),
    yaxis_(_yaxis ? new binning::AxisSpecs(*_yaxis) : nullptr),
    zaxis_(_zaxis ? new binning::AxisSpecs(*_zaxis) : nullptr)
  {
  }

  MESetNonObject::MESetNonObject(MESetNonObject const& _orig) :
    MESet(_orig),
    xaxis_(_orig.xaxis_ ? new binning::AxisSpecs(*_orig.xaxis_) : nullptr),
    yaxis_(_orig.yaxis_ ? new binning::AxisSpecs(*_orig.yaxis_) : nullptr),
    zaxis_(_orig.zaxis_ ? new binning::AxisSpecs(*_orig.zaxis_) : nullptr)
  {
  }

  MESetNonObject::~MESetNonObject()
  {
    delete xaxis_;
    delete yaxis_;
    delete zaxis_;
  }

  MESet&
  MESetNonObject::operator=(MESet const& _rhs)
  {
    delete xaxis_;
    delete yaxis_;
    delete zaxis_;
    xaxis_ = nullptr;
    yaxis_ = nullptr;
    zaxis_ = nullptr;

    MESetNonObject const* pRhs(dynamic_cast<MESetNonObject const*>(&_rhs));
    if(pRhs){
      if(pRhs->xaxis_) xaxis_ = new binning::AxisSpecs(*pRhs->xaxis_);
      if(pRhs->yaxis_) yaxis_ = new binning::AxisSpecs(*pRhs->yaxis_);
      if(pRhs->zaxis_) zaxis_ = new binning::AxisSpecs(*pRhs->zaxis_);
    }
    return MESet::operator=(_rhs);
  }

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

  void
  MESetNonObject::book(DQMStore::IBooker& _ibooker)
  {
    using namespace std;

    clear();

    if(path_.find('%') != string::npos)
      throw_("book() called with incompletely formed path");

    size_t slashPos(path_.find_last_of('/'));
    string name(path_.substr(slashPos + 1));
    _ibooker.setCurrentFolder(path_.substr(0, slashPos));

    MonitorElement* me(nullptr);

    switch(kind_) {
    case MonitorElement::DQM_KIND_REAL :
      me = _ibooker.bookFloat(name);
      break;

    case MonitorElement::DQM_KIND_TH1F :
      {
        if(!xaxis_)
          throw_("No xaxis found for MESetNonObject");

        if(xaxis_->edges)
          me = _ibooker.book1D(name, name, xaxis_->nbins, xaxis_->edges);
        else
          me = _ibooker.book1D(name, name, xaxis_->nbins, xaxis_->low, xaxis_->high);
      }
      break;

    case MonitorElement::DQM_KIND_TPROFILE :
      {
        if(!xaxis_)
          throw_("No xaxis found for MESetNonObject");

        double ylow, yhigh;
        if(!yaxis_){
          ylow = -numeric_limits<double>::max();
          yhigh = numeric_limits<double>::max();
        }
        else{
          ylow = yaxis_->low;
          yhigh = yaxis_->high;
        }
        if(xaxis_->edges){
          // DQMStore bookProfile interface uses double* for bin edges
          double* edges(new double[xaxis_->nbins + 1]);
          std::copy(xaxis_->edges, xaxis_->edges + xaxis_->nbins + 1, edges);
          me = _ibooker.bookProfile(name, name, xaxis_->nbins, edges, ylow, yhigh, "");
          delete edges;
        }
        else
          me = _ibooker.bookProfile(name, name, xaxis_->nbins, xaxis_->low, xaxis_->high, ylow, yhigh, "");
      }
      break;

    case MonitorElement::DQM_KIND_TH2F :
      {
        if(!xaxis_ || !yaxis_)
          throw_("No x/yaxis found for MESetNonObject");

        if(!xaxis_->edges || !yaxis_->edges) // unlike MESetEcal, if either of X or Y is not set as variable, binning will be fixed
          me = _ibooker.book2D(name, name, xaxis_->nbins, xaxis_->low, xaxis_->high, yaxis_->nbins, yaxis_->low, yaxis_->high);
        else
          me = _ibooker.book2D(name, name, xaxis_->nbins, xaxis_->edges, yaxis_->nbins, yaxis_->edges);
      }
      break;

    case MonitorElement::DQM_KIND_TPROFILE2D :
      {
        if(!xaxis_ || !yaxis_)
          throw_("No x/yaxis found for MESetNonObject");
        if(xaxis_->edges || yaxis_->edges)
          throw_("Variable bin size for 2D profile not implemented");

        double high(0.), low(0.);
        if(zaxis_){
          low = zaxis_->low;
          high = zaxis_->high;
        }
        else{
          low = -numeric_limits<double>::max();
          high = numeric_limits<double>::max();
        }

        me = _ibooker.bookProfile2D(name, name, xaxis_->nbins, xaxis_->low, xaxis_->high, yaxis_->nbins, yaxis_->low, yaxis_->high, low, high, "");
      }
      break;

    default :
      throw_("Unsupported MonitorElement kind");
    }

    if(xaxis_){
      me->setAxisTitle(xaxis_->title, 1);
      if(xaxis_->labels){
        for(int iBin(1); iBin <= xaxis_->nbins; ++iBin)
          me->setBinLabel(iBin, xaxis_->labels[iBin - 1], 1);
      }
    }
    if(yaxis_){
      me->setAxisTitle(yaxis_->title, 2);
      if(yaxis_->labels){
        for(int iBin(1); iBin <= yaxis_->nbins; ++iBin)
          me->setBinLabel(iBin, yaxis_->labels[iBin - 1], 2);
      }
    }
    if(zaxis_){
      me->setAxisTitle(zaxis_->title, 3);
      if(zaxis_->labels){
        for(int iBin(1); iBin <= zaxis_->nbins; ++iBin)
          me->setBinLabel(iBin, zaxis_->labels[iBin - 1], 3);
      }
    }

    if(lumiFlag_) me->setLumiFlag();

    mes_.push_back(me);

    active_ = true;
  }

  bool
  MESetNonObject::retrieve(DQMStore::IGetter& _igetter, std::string* _failedPath/* = 0*/) const
  {
    mes_.clear();

    MonitorElement* me(_igetter.get(path_));
    if(!me){
      if(_failedPath) *_failedPath = path_;
      return false;
    }

    mes_.push_back(me);

    active_ = true;
    return true;
  }

  void
  MESetNonObject::fill(double _x, double _wy/* = 1.*/, double _w/* = 1.*/)
  {
    if(!active_) return;

    if(mes_.empty() || !mes_[0]) return;

    switch(kind_) {
    case MonitorElement::DQM_KIND_REAL :
      mes_[0]->Fill(_x);
      break;
    case MonitorElement::DQM_KIND_TH1F :
    case MonitorElement::DQM_KIND_TPROFILE :
      mes_[0]->Fill(_x, _wy);
      break;
    case MonitorElement::DQM_KIND_TH2F :
    case MonitorElement::DQM_KIND_TPROFILE2D :
      mes_[0]->Fill(_x, _wy, _w);
      break;
    default :
      break;
    }
  }

  void
  MESetNonObject::setBinContent(int _bin, double _content)
  {
    if(!active_) return;
    if(kind_ == MonitorElement::DQM_KIND_REAL) return;

    if(mes_.empty() || !mes_[0]) return;

    mes_[0]->setBinContent(_bin, _content);
  }

  void
  MESetNonObject::setBinError(int _bin, double _error)
  {
    if(!active_) return;
    if(kind_ == MonitorElement::DQM_KIND_REAL) return;

    if(mes_.empty() || !mes_[0]) return;

    mes_[0]->setBinError(_bin, _error);
  }

  void
  MESetNonObject::setBinEntries(int _bin, double _entries)
  {
    if(!active_) return;
    if(kind_ != MonitorElement::DQM_KIND_TPROFILE && kind_ != MonitorElement::DQM_KIND_TPROFILE2D) return;

    if(mes_.empty() || !mes_[0]) return;

    mes_[0]->setBinEntries(_bin, _entries);
  }

  double
  MESetNonObject::getBinContent(int _bin, int) const
  {
    if(!active_) return 0.;
    if(kind_ == MonitorElement::DQM_KIND_REAL) return 0.;

    if(mes_.empty() || !mes_[0]) return 0.;

    return mes_[0]->getBinContent(_bin);
  }

  double
  MESetNonObject::getFloatValue() const
  {
    if(kind_ == MonitorElement::DQM_KIND_REAL) return mes_[0]->getFloatValue();
    else return 0.;
  }

  double
  MESetNonObject::getBinError(int _bin, int) const
  {
    if(!active_) return 0.;
    if(kind_ == MonitorElement::DQM_KIND_REAL) return 0.;

    if(mes_.empty() || !mes_[0]) return 0.;

    return mes_[0]->getBinError(_bin);
  }

  double
  MESetNonObject::getBinEntries(int _bin, int) const
  {
    if(!active_) return 0.;
    if(kind_ != MonitorElement::DQM_KIND_TPROFILE && kind_ != MonitorElement::DQM_KIND_TPROFILE2D) return 0.;

    if(mes_.empty() || !mes_[0]) return 0.;

    return mes_[0]->getBinEntries(_bin);
  }

  int
  MESetNonObject::findBin(double _x, double _y/* = 0.*/) const
  {
    if(!active_) return 0;

    if(mes_.empty() || !mes_[0]) return 0;

    if(kind_ == MonitorElement::DQM_KIND_TH1F || kind_ == MonitorElement::DQM_KIND_TPROFILE)
      return mes_[0]->getTH1()->FindBin(_x);
    else if(kind_ == MonitorElement::DQM_KIND_TH2F || kind_ == MonitorElement::DQM_KIND_TPROFILE2D)
      return mes_[0]->getTH1()->FindBin(_x, _y);
    else
      return 0;
  }

  bool
  MESetNonObject::isVariableBinning() const
  {
    return (xaxis_ && xaxis_->edges) || (yaxis_ && yaxis_->edges) || (zaxis_ && zaxis_->edges);
  }
}