DQMHistAnalysisTOP.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 <dqm/core/DQMHistAnalysis.h>
 
#include <TCanvas.h>
#include <TH1.h>
#include <TH2.h>
#include <TLine.h>
#include <TPaveText.h>
#include <THStack.h>
#include <TLegend.h>
#include <vector>
#include <string>
#include <map>
 
namespace Belle2 {
 
  class DQMHistAnalysisTOPModule final : public DQMHistAnalysisModule {
 
  public:

    DQMHistAnalysisTOPModule();

    void initialize() override final;

    void beginRun() override final;

    void event() override final;

    void endRun() override final;

    void terminate() override final;
 
 
  private:

    enum EAlarmStates {
      c_Gray = 0,    // undefined
      c_Green = 1,   // good
      c_Yellow = 2,  // warning
      c_Red = 3      // alarm
    };

    void updateWindowVsSlotCanvas();

    void updateWindowMedianCanvas();

    void updateEventMonitorCanvas();

    void updateUnpackerErrCanvas();

    void updateNGoodHitsCanvas();

    void updateEventT0Canvas();

    void updateBunchOffsetCanvas();

    void updateTimingCanvas();

    static bool sameHistDefinition(TH1* h1, TH1* h2);

    const TH1F* makeDeadAndHotFractionsPlot();

    void makePhotonYieldsAndBGRatePlots(const TH1F* activeFraction);

    void makeJunkFractionPlot();

    static void setZAxisRange(const std::string& name, double scale);

    static void makeBGSubtractedTimingPlot(const std::string& name, const TH2F* trackHits, int slot);

    void makePMTHitRatesPlots();

    void makeInjectionBGPlots();

    static void makeFlagFractPlot(const std::string& hname, TH1* histogram, TCanvas* canvas);

    void setMiraBelleVariables(const std::string& variableName, const TH1* histogram);

    int getAlarmState(double value, const std::vector<double>& alarmLevels, bool bigRed = true) const;

    int getAlarmColor(unsigned alarmState) const
    {
      if (alarmState < m_alarmColors.size()) return m_alarmColors[alarmState];
      return m_alarmColors[c_Gray];
    }

    int getOffcialAlarmStatus(unsigned alarmState) const
    {
      if (alarmState < m_officialStates.size()) return m_officialStates[alarmState];
      return c_StatusDefault;
    }

    static void setAlarmLines(const std::vector<double>& alarmLevels, double xmin, double xmax, std::vector<TLine*>& alarmLines,
                              bool bigRed = true);

    void setAlarmLines();

    static std::pair<double, double> getDeadAndHotCuts(const TH1* h);

    void setEpicsVariables();

    void updateLimits();

    void setIncludedBoardstacks(const std::vector<std::string>& excludedBoardstacks);

    static void setGridX(const std::string& canvasName);
 
    // module parameters
 
    std::vector<int> m_asicWindowsBand = {215, 235}; 
    std::vector<double> m_asicWindowsAlarmLevels = {0.002, 0.02}; 
    std::vector<double> m_windowMedianAlarmLevels = {50, 100}; 
    std::vector<double> m_eventMonitorAlarmLevels = {1e-4, 2e-3}; 
    std::vector<double> m_unpackerErrAlarmLevels = {0.01, 0.10}; 
    std::vector<double> m_junkHitsAlarmLevels = {0.05, 0.25}; 
    std::vector<double> m_deadChannelsAlarmLevels = {0.1, 0.35}; 
    std::vector<double> m_backgroundAlarmLevels = {5.0, 10.0}; 
    std::vector<double> m_photonYieldsAlarmLevels = {15.0, 25.0}; 
    std::vector<std::string> m_excludedBoardstacks; 
    std::string  m_pvPrefix;  
 
    std::vector<double> m_injectionBGAlarmLevels = {5, 10}; 
    std::vector<double> m_timingAlarmLevels = {0.15, 0.30}; 
    std::vector<double> m_eventT0MeanAlarmLevels = {8, 20}; 
    std::vector<double> m_eventT0RmsAlarmLevels = {10, 20}; 
    std::vector<double> m_offsetMeanAlarmLevels = {0.2, 0.5}; 
    std::vector<double> m_offsetRmsAlarmLevels = {0.25, 0.50}; 
 
    // alarms etc.
 
    std::vector<int> m_alarmColors = {c_ColorTooFew, c_ColorGood, c_ColorWarning, c_ColorError}; 
    std::vector<int> m_officialStates = {c_StatusTooFew, c_StatusGood, c_StatusWarning, c_StatusError}; 
    std::vector<bool> m_includedBoardstacks; 
    std::map<std::string, int> m_bsmap;  
    int m_alarmStateOverall = 0; 
    double m_averageRate = 0; 
 
    bool m_IsNullRun = false; 
    std::string m_runType; 
    double m_numEvents = 0; 
 
    // new histogram and canvases
 
    TH1D* m_evtMonitorFract = nullptr; 
    TCanvas* m_c_evtMonitorFract = nullptr; 
 
    TH1F* m_windowMedian = nullptr; 
    TCanvas* m_c_windowMedian = nullptr; 
 
    TH1D* m_photonYields = nullptr; 
    TH1D* m_backgroundRates = nullptr; 
    TCanvas* m_c_photonYields = nullptr; 
    TCanvas* m_c_backgroundRates = nullptr; 
 
    TH1F* m_hotFraction = nullptr; 
    TH1F* m_deadFraction = nullptr; 
    TH1F* m_excludedFraction = nullptr; 
    TH1F* m_activeFraction = nullptr; 
    THStack* m_stack = nullptr;  
    TLegend* m_legend = nullptr; 
    TCanvas* m_c_deadAndHot = nullptr; 
 
    TH1F* m_junkFraction = nullptr; 
    TH1F* m_excludedBSHisto = nullptr; 
    TCanvas* m_c_junkFraction = nullptr; 
 
    std::vector<TH1F*> m_pmtHitRates; 
    std::vector<TCanvas*> m_c_pmtHitRates; 
 
    std::map<std::string, TCanvas*> m_c_injBGs; 
    std::map<std::string, TProfile*> m_profiles; 
    std::map<std::string, TH1D*> m_projections; 
 
    TH1D* m_skipProcFlagFract = nullptr; 
    TH1D* m_injVetoFlagFract = nullptr;  
    TCanvas* m_c_skipProcFlagFract = nullptr; 
    TCanvas* m_c_injVetoFlagFract = nullptr;  
 
    // graphic primitives
 
    std::vector<TLine*> m_asicWindowsBandLines; 
    std::vector<TLine*> m_junkHitsAlarmLines; 
    std::vector<TLine*> m_deadChannelsAlarmLines; 
    std::vector<TLine*> m_backgroundAlarmLines; 
    std::vector<TLine*> m_photonYieldsAlarmLines; 
    TLine* m_injBGCutLine = nullptr; 
 
    TPaveText* m_text1 = nullptr; 
    TPaveText* m_text2 = nullptr; 
    TPaveText* m_text3 = nullptr; 
    TPaveText* m_text4 = nullptr; 
 
    // MiraBelle
 
    std::map<std::string, double> m_mirabelleVariables; 
    MonitoringObject* m_monObj = nullptr; 
 
  };

} // end namespace Belle2