TRGGDLDQMModule.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.                  *
 **************************************************************************/
#ifndef TRCGDLDQMMODULE_h
#define TRCGDLDQMMODULE_h
 
#include <framework/core/HistoModule.h>
#include <trg/gdl/dataobjects/TRGGDLUnpackerStore.h>
#include <trg/gdl/modules/trggdlUnpacker/trggdlUnpackerModule.h>
#include <trg/gdl/TrgBit.h>
#include <framework/database/DBObjPtr.h>
#include <trg/gdl/dbobjects/TRGGDLDBUnpacker.h>
#include <mdst/dbobjects/TRGGDLDBInputBits.h>
#include <mdst/dbobjects/TRGGDLDBFTDLBits.h>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include <TH2I.h>
#include <TH1I.h>
#include "trg/ecl/TrgEclMapping.h"
#include <ecl/dataobjects/ECLDigit.h>
#include <ecl/dataobjects/ECLCalDigit.h>
#include <mdst/dataobjects/SoftwareTriggerResult.h>
#include <mdst/dataobjects/Track.h>
#include <mdst/dataobjects/HitPatternCDC.h>
#include <mdst/dataobjects/ECLCluster.h>
#include "trg/ecl/dataobjects/TRGECLCluster.h"
 
 
namespace Belle2 {
 
 
  class TRGGDLDQMModule : public HistoModule {
 
  public:
    TRGGDLDQMModule();
    virtual ~TRGGDLDQMModule() {}
 
  public:
    virtual void initialize() override;
    virtual void beginRun() override;
    virtual void event() override;
    virtual void endRun() override;
    virtual void terminate() override {}
    virtual void defineHisto() override;
 
  protected:
    static const int nskim_gdldqm = 11;
    int start_skim_gdldqm = 0;
    int end_skim_gdldqm = 0;
    int m_skim = -1;

    TH1I* h_c8_gdlL1TocomL1[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_topTogdlL1[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_eclTogdlL1[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_cdcTogdlL1[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_ecl8mToGDL[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_topToGDL[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_eclToGDL[nskim_gdldqm] = {nullptr};
    TH1I* h_c8_cdcToGDL[nskim_gdldqm] = {nullptr};
    TH1I* h_c2_cdcTocomL1[nskim_gdldqm] = {nullptr};
    TH1D* h_ns_cdcTocomL1[nskim_gdldqm] = {nullptr};
    TH1D* h_ns_cdcTogdlL1[nskim_gdldqm] = {nullptr};
    TH1D* h_ns_topToecl[nskim_gdldqm] = {nullptr};
    TH1D* h_ns_topTocdc[nskim_gdldqm] = {nullptr};
    TH1I* h_c2_cdcToecl[nskim_gdldqm] = {nullptr};
    TH1D* h_ns_cdcToecl[nskim_gdldqm] = {nullptr};

    // TH1I* h_inp;
    // TH1I* h_inp_rise[N_BITS_RESERVED][nskim_gdldqm];
    // TH1I* h_inp_fall[N_BITS_RESERVED][nskim_gdldqm];
    TH1I* h_itd[nskim_gdldqm] = {nullptr};
    TH1I* h_itd_rise[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_itd_fall[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_ftd[nskim_gdldqm] = {nullptr};
    TH1I* h_ftd_rise[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_ftd_fall[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_psn[nskim_gdldqm] = {nullptr};
    TH1I* h_psn_rise[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_psn_fall[N_BITS_RESERVED][nskim_gdldqm] = {{nullptr}};
    TH1I* h_psn_extra[nskim_gdldqm] = {nullptr};
    TH1I* h_psn_extra_fast[nskim_gdldqm] = {nullptr};
    TH1I* h_psn_effect_to_l1[nskim_gdldqm] = {nullptr};
    TH1I* h_psn_raw_rate[nskim_gdldqm] = {nullptr};
    TH1I* h_psn_pure_extra[nskim_gdldqm] = {nullptr};
    TH1I* h_timtype[nskim_gdldqm] = {nullptr};
    std::vector<int> h_0_vec;
    std::vector<int> h_p_vec;
    std::vector<int> h_f_vec;
    std::vector<int> h_i_vec;
 
    TDirectory* oldDir = nullptr;
    TDirectory* dirDQM = nullptr;
 
    bool m_eventByEventTimingHistRecord;
    bool m_dumpVcdFile;
    bool m_bitNameOnBinLabel;
    bool m_generatePostscript;
    unsigned m_vcdEventStart = 0;
    unsigned m_vcdNumberOfEvents = 0;
    std::string m_bitConditionToDumpVcd;
    std::string m_postScriptName;
    void fillRiseFallTimings(void);
    void fillOutputExtra(void);
    void fillOutputOverlap(void);
    void fillOutputPureExtra(void);
 
    void genVcd(void);
    bool anaBitCondition(void);
    bool isFired(std::string bitname);
    bool isFired_quick(const std::string& bitname, const bool& isPsnm);
    int getinbitnum(const char* c) const;
    int getoutbitnum(const char* c) const;

    std::unordered_map<std::string, int> m_inbitIndex;
    std::unordered_map<std::string, int> m_outbitIndex;
    std::vector<char> m_firedPsnm;
    std::vector<char> m_firedFtdl;
    std::vector<char> m_firedInput;
    unsigned n_clocks = 0;
    unsigned evtno = 0;
    unsigned _exp = 0;
    unsigned _run = 0;
    std::vector<int> skim;
 
    static const int n_output_extra = 105;
    static const char* output_extra[n_output_extra];
    static const int n_output_overlap = 130;
    static const char* output_overlap[n_output_overlap];
    static const int n_output_pure_extra = 13;
    static const char* output_pure_extra[n_output_pure_extra];
    static const int nsample_fast = 500; 
    int array_psn_extra_fast[nskim_gdldqm][nsample_fast][n_output_extra] = {{{0}}}; 
    int m_fastPos[nskim_gdldqm] = {0}; 
    int m_fastSum[nskim_gdldqm][n_output_extra] = {{0}}; 
    bool m_leavesResolved = false; 
    int m_evtLeaf = -1; 
    int m_clkLeaf = 0; 
    std::vector<std::pair<int, int>> m_leafMap; 

    DBObjPtr<TRGGDLDBUnpacker> m_unpacker;
    int LeafBitMap[320] = {0};
    char LeafNames[320][100] = {{0}};
    int _e_timtype = 0;
    int _e_gdll1rvc = 0;
    int _e_coml1rvc = 0;
    int _e_toptiming = 0;
    int _e_ecltiming = 0;
    int _e_cdctiming = 0;
    int _e_toprvc = 0;
    int _e_eclrvc = 0;
    int _e_cdcrvc = 0;
    int ee_psn[10] = {0};
    int ee_ftd[10] = {0};
    int ee_itd[10] = {0};
    int n_leafs = 0;
    int n_leafsExtra = 0;
    int nconf = 0;
    int nword_input  = 0;
    int nword_output = 0;

    DBObjPtr<TRGGDLDBInputBits>m_dbinput;
    unsigned  n_inbit = 0;
    char inbitname[320][100] = {""};

    DBObjPtr<TRGGDLDBFTDLBits> m_dbftdl;
    unsigned  n_outbit = 0;
    char outbitname[320][100]  = {""};
 

    std::string skim_menu[nskim_gdldqm] = {
      "all",
      "software_trigger_cut&skim&accept_hadron",
      "software_trigger_cut&skim&accept_tau_tau",
      "software_trigger_cut&skim&accept_mumu_1trk",
      "software_trigger_cut&skim&accept_mumu_2trk",
      "software_trigger_cut&skim&accept_gamma_gamma",
      "software_trigger_cut&skim&accept_bhabha",
      "software_trigger_cut&skim&accept_hadronb",
      "software_trigger_cut&skim&accept_hadronb1",
      "software_trigger_cut&skim&accept_hadronb2",
      "software_trigger_cut&skim&accept_mumutight"
    };

    std::string skim_smap[nskim_gdldqm] = {
      "all",
      "hadron",
      "tautau",
      "mumu1trk",
      "mumu2trk",
      "gammagamma",
      "bhabha",
      "hadronb",
      "hadronb1",
      "hadronb2",
      "mumutight"
    };
 
  private:

    TrgEclMapping* trgeclmap = nullptr;

    StoreArray<TRGGDLUnpackerStore> entAry;

    StoreObjPtr<EventMetaData> bevt;

    StoreObjPtr<SoftwareTriggerResult> result_soft;

    StoreArray<Track> Tracks;
 
    //Input store array of ECL
    //StoreArray<ECLCluster> ECLClusters;
    StoreArray<ECLCalDigit> m_ECLCalDigitData;
    StoreArray<ECLDigit>    m_ECLDigitData;
 
  };

}
 
#endif