MonitoringObject.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <TNamed.h>
#include <TCanvas.h>
 
#include <vector>
#include <string>
#include <map>
#include <framework/logging/Logger.h>
 
namespace Belle2 {
  class MonitoringObject : public TNamed {
 
  public:
    MonitoringObject() {};
    explicit MonitoringObject(const std::string& name)
    {
      fName = name;
    }
 
    void addCanvas(TCanvas* canv)
    {
      for (auto cc : m_Canvases) {
        if (cc->GetName() == canv->GetName()) {
          B2ERROR("Canvas with name " << canv->GetName() << " already in the " << fName <<
                  " MonitoringObject! Use different name (or call getCanvas(name) to access pointer to the existing TCanvas).");
          return;
        }
      }
      m_Canvases.push_back(canv);
    };
 
    const std::map<std::string, float>& getVariables()
    {
      return m_vars;
    }
 
    const std::map<std::string, float>& getUpError()
    {
      return m_upErr;
    }
 
    const std::map<std::string, float>& getLowError()
    {
      return m_dwErr;
    }
 
    const std::vector<std::pair<std::string, std::string>>& getStringVariables()
    {
      return m_strVars;
    }
 
    TCanvas* getCanvas(const std::string& name)
    {
      for (auto cc : m_Canvases) {
        if (cc->GetName() == name) return cc;
      }
      B2WARNING("TCanvas with name " << name << " not found in MonitoringObject " << fName);
      return NULL;
    };
 
    const std::vector<TCanvas*>& getListOfCanvases()
    {
      return m_Canvases;
    }
 
    void print() const;
 
    void setVariable(const std::string& var, float val, float upErr = -1., float dwErr = -1)
    {
 
      auto vv = m_vars.find(var);
      if (vv != m_vars.end()) vv->second = val;
      else m_vars.insert({var, val});
 
      if (upErr > 0) {
        auto vvE = m_upErr.find(var);
        if (vvE != m_upErr.end()) vvE->second = upErr;
        else m_upErr.insert({var, upErr});
      }
 
      if (dwErr > 0) {
        auto vvE = m_dwErr.find(var);
        if (vvE != m_dwErr.end()) vvE->second = dwErr;
        else m_dwErr.insert({var, dwErr});
      }
 
    }
 
    void setVariable(const std::string& var, const std::string& val)
    {
 
      for (auto& pair : m_strVars) {
        if (pair.first == var) {
          pair.second = val;
          return;
        }
      }
      m_strVars.push_back(std::pair<std::string, std::string>(var, val));
    }
 
 
  private:
 
    std::vector<TCanvas*> m_Canvases; 
    std::map<std::string, float> m_vars;  
    std::map<std::string, float> m_upErr; 
    std::map<std::string, float> m_dwErr; 
    std::vector<std::pair<std::string, std::string>> m_strVars; 
    ClassDefOverride(MonitoringObject, 1); 
  }; //class
 
} // namespace Belle2