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/core/HistObject.h>
#include <dqm/core/RefHistObject.h>
#include <dqm/core/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(const std::string& prefix, const std::string& pvname, const 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;};

    // Unused:
    //static const RefList& getRefList() { return s_refList;};

    static const std::string& getRunType(void) { return s_runType;};

    static int getEventProcessed(void) { return s_eventProcessed;};

    static void setRunType(const std::string& t) {s_runType = t;};

    static void setEventProcessed(int e) {s_eventProcessed = e;};

    static 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);

    static double getSigma68(TH1* h);
 
  public:
    static bool addHist(const std::string& dirname,
                        const std::string& histname, TH1* h);

    static void addRefHist(const std::string& dirname, TH1* hist);
 

    static MonitoringObject* getMonitoringObject(const std::string& name);

    static void clearCanvases(void);

    static void initHistListBeforeEvent(void);

    static void clearHistList(void);

    static void clearRefList(void);

    static 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);

    static void addDeltaPar(const std::string& dirname, const std::string& histname,  HistDelta::EDeltaType t, int p,
                            unsigned int a = 1);

    static bool hasDeltaPar(const std::string& dirname, const std::string& histname);

    static void UpdateCanvas(const std::string& name, bool updated = true);

    static void UpdateCanvas(TCanvas* canvas, bool updated = true);

    static void ExtractRunType(std::vector <TH1*>& hs);

    static void ExtractNEvent(std::vector <TH1*>& hs);


    int registerEpicsPV(const std::string& pvname, const std::string& keyname = "");

    int registerExternalEpicsPV(const std::string& pvname, const std::string& keyname = "");

    void setEpicsPV(const std::string& keyname, double value);

    void setEpicsPV(const std::string& keyname, int value);

    void setEpicsStringPV(const std::string& keyname, const std::string& value);

    void setEpicsPV(int index, double value);

    void setEpicsPV(int index, int value);

    void setEpicsStringPV(int index, std::string value);

    double getEpicsPV(const std::string& keyname);

    double getEpicsPV(int index);

    std::string getEpicsStringPV(const std::string& keyname, bool& status);

    std::string getEpicsStringPV(int index, bool& status);

    int updateEpicsPVs(float timeout);

    chid getEpicsPVChID(const std::string& keyname);

    chid getEpicsPVChID(int index);

    bool requestLimitsFromEpicsPVs(chid id, double& lowerAlarm, double& lowerWarn, double& upperWarn, double& upperAlarm);

    bool requestLimitsFromEpicsPVs(const 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;};

    static void setUseEpicsReadOnly(bool flag) {m_epicsReadOnly = flag;};

    static bool getUseEpics(void) {return m_useEpics;};

    static bool getUseEpicsReadOnly(void) {return m_epicsReadOnly;};

    void cleanupEpicsPVs(void);

    static std::string& getPVPrefix(void) {return m_PVPrefix;};

    static void setPVPrefix(const std::string& prefix) { m_PVPrefix = prefix;};

    static EStatus makeStatus(bool enough, bool warn_flag, bool error_flag);

    static void colorizeCanvas(TCanvas* canvas, EStatus status);

    static EStatusColor getStatusColor(EStatus status);

    void checkPVStatus(void);

    static 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() {};

    static std::vector <std::string> StringSplit(const std::string& s, const char delim);
 
    // Data members
  private:
  };

} // end namespace Belle2