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 <TFile.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();
 
    ~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 updateEventMonitorCanvas();
 
    void updateNGoodHitsCanvas();
 
    void updateEventT0Canvas();
 
    void updateBunchOffsetCanvas();
 
    void updateTimingCanvas();
 
    bool sameHistDefinition(TH1* h1, TH1* h2);
 
    const TH1F* makeDeadAndHotFractionsPlot();
 
    void makePhotonYieldsAndBGRatePlots(const TH1F* activeFraction);
 
    void makeJunkFractionPlot();
 
    void setZAxisRange(const std::string& name, double scale);
 
    void makeBGSubtractedTimingPlot(const std::string& name, const TH2F* trackHits, int slot);
 
    void makePMTHitRatesPlots();
 
    void makeInjectionBGPlots();
 
    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;
    }
 
    void setAlarmLines(const std::vector<double>& alarmLevels, double xmin, double xmax, std::vector<TLine*>& alarmLines,
                       bool bigRed = true);
 
    void setAlarmLines();
 
    std::pair<double, double> getDeadAndHotCuts(const TH1* h);
 
    void setEpicsVariables();
 
    void updateLimits();
 
    void setIncludedBoardstacks(const std::vector<std::string>& excludedBoardstacks);
 
    // module parameters
 
    std::vector<int> m_asicWindowsBand = {215, 235}; 
    std::vector<double> m_asicWindowsAlarmLevels = {0.002, 0.02}; 
    std::vector<double> m_eventMonitorAlarmLevels = {1e-4, 2e-3}; 
    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}; 
    // other
 
    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; 
    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; 
    std::vector<TLine*> m_asicWindowsBandLines; 
    std::vector<TLine*> m_verticalLines; 
    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; 
    std::map<std::string, double> m_mirabelleVariables; 
    MonitoringObject* m_monObj = nullptr; 
  };
} // end namespace Belle2