DQMHistAnalysis.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.                  *
 **************************************************************************/
//+
// File : DQMHistAnalysis.h
// Description : Baseclass for histogram analysis module for DQM
//-
 
#pragma once
 
#include <framework/core/Module.h>
#include <dqm/core/MonitoringObject.h>
#include <dqm/analysis/HistObject.h>
#include <dqm/analysis/RefHistObject.h>
#include <dqm/analysis/HistDelta.h>
#include <TFile.h>
#include <TH1.h>
 
#include <string>
#include <map>
 
#ifdef _BELLE2_EPICS
// EPICS
#include "cadef.h"
#endif
 
namespace Belle2 {
  class DQMHistAnalysisModule : public Module {
 
  public:
    enum EStatus {
      c_StatusTooFew = 0, 
      c_StatusDefault = 1, 
      c_StatusGood = 2, 
      c_StatusWarning = 3, 
      c_StatusError = 4 
    };
 
    enum EStatusColor {
      c_ColorTooFew = kGray, 
      c_ColorDefault = kWhite, 
      c_ColorGood = kGreen, 
      c_ColorWarning = kYellow, 
      c_ColorError = kRed 
    };
 
    enum ERefScaling {
      c_RefScaleNone = 0, 
      c_RefScaleEntries = 1, 
      c_RefScaleMax = 2 
    };
 
    typedef std::map<std::string, HistObject> HistList;
    typedef std::map<std::string, MonitoringObject> MonObjList;
 
    typedef std::map<std::string, HistDelta> DeltaList;
 
    typedef std::map<std::string, bool> CanvasUpdatedList;
 
    typedef std::map<std::string, RefHistObject> RefList;
 
    void clearlist(void);
 
 
  private:
    static HistList s_histList;
    static MonObjList s_monObjList;
 
  public:
    static DeltaList s_deltaList;
  private:
 
    static CanvasUpdatedList s_canvasUpdatedList;
 
    static RefList s_refList;
 
    inline static int s_eventProcessed = 0;
 
    inline static std::string s_runType = "";
 
    static bool m_useEpics;
 
    static bool m_epicsReadOnly;
 
    static std::string m_PVPrefix;
 
 
#ifdef _BELLE2_EPICS
    static std::vector <chid>  m_epicsChID;
    std::map <std::string, chid> m_epicsNameToChID;
#endif
 
    int registerEpicsPVwithPrefix(std::string prefix, std::string pvname, std::string keyname = "");
 
  public:
    static /*const*/ HistList& getHistList() { return s_histList;};
 
    static /*const*/ MonObjList& getMonObjList() { return s_monObjList;};
 
    static const DeltaList& getDeltaList() { return s_deltaList;};
 
    static const CanvasUpdatedList& getCanvasUpdatedList() { return s_canvasUpdatedList;};
 
    static /*const*/ RefList& getRefList() { return s_refList;};
 
    static const std::string& getRunType(void) { return s_runType;};
 
    static int getEventProcessed(void) { return s_eventProcessed;};
 
    void setRunType(std::string& t) {s_runType = t;};
 
    void setEventProcessed(int e) {s_eventProcessed = e;};
 
    TCanvas* findCanvas(TString cname);
 
    static TH1* findHist(const std::string& histname, bool onlyIfUpdated = false);
 
    static TH1* findHist(const std::string& dirname,
                         const std::string& histname, bool onlyIfUpdated = false);
 
    static TH1* findRefHist(const std::string& histname, ERefScaling scaling = ERefScaling::c_RefScaleNone, const TH1* hist = nullptr);
 
    static TH1* findRefHist(const std::string& dirname,
                            const std::string& histname, ERefScaling scaling = ERefScaling::c_RefScaleNone, const TH1* hist = nullptr);
 
    static TH1* scaleReference(ERefScaling scaling, const TH1* hist, TH1* ref);
 
    static TH1* findHistInFile(TFile* file, const std::string& histname);
 
    TH1* findHistInCanvas(const std::string& hname, TCanvas** canvas = nullptr);
 
    static MonitoringObject* findMonitoringObject(const std::string& objName);
 
    double getSigma68(TH1* h) const;
 
  public:
    static bool addHist(const std::string& dirname,
                        const std::string& histname, TH1* h);
 
    // /**
    //  * Add reference.
    //  * @param dirname The name of the directory.
    //  * @param histname The name of the histogram.
    //  * @param ref The TH1 pointer for the reference.
    //  */
    // void addRef(const std::string& dirname,
    //             const std::string& histname, TH1* ref);
 
 
    static MonitoringObject* getMonitoringObject(const std::string& name);
 
    void clearCanvases(void);
 
    static void initHistListBeforeEvent(void);
 
    static void clearHistList(void);
 
    static void clearRefList(void);
 
    void resetDeltaList(void);
 
    TH1* getDelta(const std::string& fullname, int n = 0, bool onlyIfUpdated = true);
 
    TH1* getDelta(const std::string& dirname, const std::string& histname, int n = 0, bool onlyIfUpdated = true);
 
    void addDeltaPar(const std::string& dirname, const std::string& histname,  HistDelta::EDeltaType t, int p, unsigned int a = 1);
 
    bool hasDeltaPar(const std::string& dirname, const std::string& histname);
 
    void UpdateCanvas(std::string name, bool updated = true);
 
    void UpdateCanvas(TCanvas* canvas, bool updated = true);
 
    void ExtractRunType(std::vector <TH1*>& hs);
 
    void ExtractEvent(std::vector <TH1*>& hs);
 
 
    int registerEpicsPV(std::string pvname, std::string keyname = "");
 
    int registerExternalEpicsPV(std::string pvname, std::string keyname = "");
 
    void setEpicsPV(std::string keyname, double value);
 
    void setEpicsPV(std::string keyname, int value);
 
    void setEpicsStringPV(std::string keyname, std::string value);
 
    void setEpicsPV(int index, double value);
 
    void setEpicsPV(int index, int value);
 
    void setEpicsStringPV(int index, std::string value);
 
    double getEpicsPV(std::string keyname);
 
    double getEpicsPV(int index);
 
    std::string getEpicsStringPV(std::string keyname, bool& status);
 
    std::string getEpicsStringPV(int index, bool& status);
 
    int updateEpicsPVs(float timeout);
 
    chid getEpicsPVChID(std::string keyname);
 
    chid getEpicsPVChID(int index);
 
    bool requestLimitsFromEpicsPVs(chid id, double& lowerAlarm, double& lowerWarn, double& upperWarn, double& upperAlarm);
 
    bool requestLimitsFromEpicsPVs(std::string keyname, double& lowerAlarm, double& lowerWarn, double& upperWarn, double& upperAlarm);
 
    bool requestLimitsFromEpicsPVs(int index, double& lowerAlarm, double& lowerWarn, double& upperWarn, double& upperAlarm);
 
    void setUseEpics(bool flag) {m_useEpics = flag;};
 
    void setUseEpicsReadOnly(bool flag) {m_epicsReadOnly = flag;};
 
    bool getUseEpics(void) {return m_useEpics;};
 
    bool getUseEpicsReadOnly(void) {return m_epicsReadOnly;};
 
    void cleanupEpicsPVs(void);
 
    std::string& getPVPrefix(void) {return m_PVPrefix;};
 
    void setPVPrefix(std::string& prefix) { m_PVPrefix = prefix;};
 
    EStatus makeStatus(bool enough, bool warn_flag, bool error_flag);
 
    void colorizeCanvas(TCanvas* canvas, EStatus status);
 
    EStatusColor getStatusColor(EStatus status);
 
    void checkPVStatus(void);
 
    void printPVStatus(chid pv, bool onlyError = true);
 
    void CheckEpicsError(int state, const std::string& message, const std::string& name);
 
    void CheckEpicsError(int state, const std::string& message, chid id);
 
 
    // Public functions
  public:
 
    DQMHistAnalysisModule();
    virtual ~DQMHistAnalysisModule() {};
 
    std::vector <std::string> StringSplit(const std::string& s, const char delim);
 
    // Data members
  private:
  };
} // end namespace Belle2