eclDQMExtended.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
 
/* ECL headers. */
#include <ecl/dataobjects/ECLDigit.h>
#include <ecl/dataobjects/ECLDsp.h>
#include <ecl/dataobjects/ECLTrig.h>
#include <ecl/dbobjects/ECLCrystalCalib.h>
#include <ecl/dbobjects/ECLDspData.h>
#include <ecl/mapper/ECLChannelMapper.h>
 
/* Basf2 headers. */
#include <framework/core/HistoModule.h>
#include <framework/database/DBArray.h>
#include <framework/database/DBObjPtr.h>
#include <framework/datastore/StoreArray.h>
#include <framework/datastore/StoreObjPtr.h>
#include <mdst/dataobjects/TRGSummary.h>
 
/* C++ headers. */
#include <map>
#include <string>
#include <vector>
 
class TH1F;
class TH2F;
 
namespace Belle2 {
  class ECLDQMEXTENDEDModule : public HistoModule {  
  public:
 
    ECLDQMEXTENDEDModule();
 
    virtual ~ECLDQMEXTENDEDModule() override;
 
    virtual void initialize() override;
    virtual void beginRun() override;
    virtual void event() override;
    virtual void endRun() override;
    virtual void terminate() override;
 
    virtual void defineHisto() override;
 
  private:
    std::string m_histogramDirectoryName;
    std::string m_InitKey;
    std::string m_DSPDirectoryName;
    std::string m_RunName;
    bool m_SaveDetailedFitData;
    bool m_adjusted_timing;
 
    std::vector<int> m_skipEvents = {};
 
    DBArray<ECLDspData> m_ECLDspDataArray0;
    DBArray<ECLDspData> m_ECLDspDataArray1;
    DBArray<ECLDspData> m_ECLDspDataArray2;
 
    StoreArray<ECLDigit> m_ECLDigits;
 
    StoreArray<ECLTrig> m_ECLTrigs;
 
    StoreArray<ECLDsp> m_ECLDsps;
 
    StoreObjPtr<TRGSummary> m_TRGSummary;
 
    DBObjPtr<ECLCrystalCalib> m_calibrationThrA0;
    DBObjPtr<ECLCrystalCalib> m_calibrationThrAhard;
    DBObjPtr<ECLCrystalCalib> m_calibrationThrAskip;
 
    ECL::ECLChannelMapper mapper;
 
    std::map<int, std::map<std::string, std::vector<short int>>> map_container_vec;
    std::map<int, std::map<std::string, short int>> map_container_coef;
 
    std::vector<short int>  v_totalthrA0 = {};
    std::vector<short int>  v_totalthrAhard = {};
    std::vector<short int>  v_totalthrAskip = {};
 
    int m_AmpFit{0};
    int m_TimeFit{0};
    int m_QualityFit{0};
 
    int m_AmpData{0};
    int m_TimeData{0};
    int m_QualityData{0};
 
    int m_CellId{0};
    int m_TrigTime{0};
 
    std::vector<TH1F*> h_amp_timefail = {};
    std::vector<TH1F*> h_time_ampfail = {};
    std::vector<std::vector<TH1F*>> h_amp_qualityfail = {};
    std::vector<std::vector<TH1F*>> h_time_qualityfail = {};
 
    TH1F* h_ampfail_quality{nullptr};
    TH1F* h_timefail_quality{nullptr};
 
    TH1F* h_ampfail_cellid{nullptr};
    TH1F* h_timefail_cellid{nullptr};
    TH1F* h_amptimefail_cellid{nullptr};
    TH1F* h_qualityfail_cellid{nullptr};
    TH1F* h_ampfail_shaperid{nullptr};
    TH1F* h_timefail_shaperid{nullptr};
    TH1F* h_amptimefail_shaperid{nullptr};
    TH1F* h_qualityfail_shaperid{nullptr};
    TH1F* h_fail_shaperid{nullptr};
    TH1F* h_ampfail_crateid{nullptr};
    TH1F* h_timefail_crateid{nullptr};
    TH1F* h_amptimefail_crateid{nullptr};
    TH1F* h_qualityfail_crateid{nullptr};
    TH1F* h_fail_crateid{nullptr};
 
    TH2F* h_ampdiff_cellid{nullptr};
    TH2F* h_timediff_cellid{nullptr};
    TH2F* h_ampdiff_shaperid{nullptr};
    TH2F* h_timediff_shaperid{nullptr};
    TH2F* h_ampdiff_quality{nullptr};
    TH2F* h_timediff_quality{nullptr};
    TH2F* h_quality_fit_data{nullptr};
    TH2F* h_ampflag_qualityfail{nullptr};
    TH2F* h_timeflag_qualityfail{nullptr};
    TH1F* h_missing_ecldigits{nullptr};
 
    int conversion(int);
    const short int* vectorsplit(const std::vector<short int>&, int);
    void callbackCalibration(DBObjPtr<ECLCrystalCalib>&, std::vector<short int>&);
    void callbackCalibration(const ECLDspData*, std::map<std::string, std::vector<short int>>&, std::map<std::string, short int>&);
    void initDspfromDB();
    void initDspfromFile();
    void emulator(int, int, std::vector<int>);
  };
}; // end Belle2 namespace