development/doxygen/TRGGRLUnpackerStore_8h_source.html

/**************************************************************************

 * 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 TRGGRLUNPACKERSTORE_H

#define TRGGRLUNPACKERSTORE_H


#include <TObject.h>

#include <vector>


namespace Belle2 {

  class TRGGRLUnpackerStore : public TObject {

  public:

    int get_dddd() const {return m_dddd;}

    int get_unamed() const {return m_unamed;}

    int get_revoclk() const {return m_revoclk;}

    int get_ECL_trg() const {return m_ECL_trg;}

    int get_ECL_trg_delay() const {return m_ECL_trg_delay;}

    int get_CDCECL_jitter() const {return m_CDCECL_jitter;}

    int get_phi_CDC_int(int i) const {return  m_phi_CDC_int[i];}

    bool get_phi_CDC(int i) const {return m_phi_CDC[i];}

    int get_phi_i_int(int i) const {return m_phi_i_int[i];}

    bool get_phi_i(int i) const {return m_phi_i[i];}

    int get_N_track() const {return m_N_track;}

    int get_N_track_cut() const {return m_N_track_cut;}

    int get_N_track_3D() const {return m_N_track_3D;}

    int get_N_track_NN() const {return m_N_track_NN;}

    int get_N_ST() const {return m_N_ST;}

    int get_b2b_1to3() const {return m_b2b_1to3;}

    int get_b2b_1to5() const {return m_b2b_1to5;}

    int get_b2b_1to7() const {return m_b2b_1to7;}

    int get_b2b_1to9() const {return m_b2b_1to9;}

    int get_opening() const {return m_opening;}

    int get_cc() const {return m_cc;}

    int get_unamed0() const {return m_unamed0;}

    int get_KLM_trg() const {return m_KLM_trg;}

    int get_matched_2DKLM() const {return m_matched_2DKLM;}

    int get_CDCKLM_jitter() const {return m_CDCKLM_jitter;}

    int get_KLMCDC_jitter() const {return m_KLMCDC_jitter;}

    int get_sector_KLM_int() const {return m_sector_KLM_int;}

    bool get_sector_KLM(int i) const {return m_sector_KLM[i];}

    int get_sector_CDC_int() const {return m_sector_CDC_int;}

    bool get_sector_CDC(int i) const {return m_sector_CDC[i];}

    int get_N_KLMmatch() const {return m_N_KLMmatch;}

    int get_samehem(int i) const {return  m_samehem[i];}

    int get_opphem(int i) const {return m_opphem[i];}

    int get_N_match_2GeV(int i) const {return m_N_match_2GeV[i];}

    int get_N_match(int i) const {return  m_N_match[i];}

    int get_N_g_1GeV(int i) const {return m_N_g_1GeV[i];}

    int get_N_g_2GeV(int i) const {return m_N_g_2GeV[i];}

    int get_CDCTOP_jitter() const {return m_CDCTOP_jitter;}

    int get_c_b2b_1to9(int i) const {return m_c_b2b_1to9[i];}

    int get_c_b2b_1to7(int i) const {return m_c_b2b_1to7[i];}

    int get_c_b2b_1to5(int i) const {return  m_c_b2b_1to5[i];}

    int get_c_b2b_1to3(int i) const {return m_c_b2b_1to3[i];}

    int get_tc_b2b_1to9(int i) const {return m_tc_b2b_1to9[i];}

    int get_tc_b2b_1to7(int i) const {return m_tc_b2b_1to7[i];}

    int get_tc_b2b_1to5(int i) const {return  m_tc_b2b_1to5[i];}

    int get_tc_b2b_1to3(int i) const {return  m_tc_b2b_1to3[i];}

    int get_CDC3D_jitter() const {return  m_CDC3D_jitter;}

    int get_CDCNN_jitter() const {return  m_CDCNN_jitter;}


    int get_slot_CDC_int() const {return  m_slot_CDC_int;}

    bool get_slot_CDC(int i) const {return m_slot_CDC[i];}

    int get_slot_TOP_int() const {return m_slot_TOP_int;}

    bool get_slot_TOP(int i) const {return m_slot_TOP[i];}

    int get_N_TOPmatch() const {return  m_N_TOPmatch;}


    int get_unamed1() const {return m_unamed1;}

    int get_unamed2() const {return m_unamed2;}

    int get_concidence_2DECL() const {return m_coincidence_2DECL;}

    int get_matched_2DECL() const {return m_matched_2DECL;}


    int get_theta_ECL(int i) const {return m_theta_ECL[i];}

    int get_phi_ECL(int i) const {return m_phi_ECL[i];}

    int get_t_ECL(int i) const {return m_t_ECL[i];}

    int get_E_ECL(int i) const {return m_E_ECL[i];}

    int get_clk_ECL(int i) const {return m_clk_ECL[i];}

    int get_1GeV_ECL(int i) const {return m_1GeV_ECL[i];}

    int get_2GeV_ECL(int i) const {return m_2GeV_ECL[i];}


    int get_wirecnt_tsf0() const {return m_wirecnt_tsf0;}

    int get_wirecnt_tsf1() const {return m_wirecnt_tsf1;}

    int get_wirecnt_tsf2() const {return m_wirecnt_tsf2;}

    int get_wirecnt_tsf3() const {return m_wirecnt_tsf3;}

    int get_wirecnt_tsf4() const {return m_wirecnt_tsf4;}

    int get_wirecnt_tsf5() const {return m_wirecnt_tsf5;}

    int get_wirecnt_tsf6() const {return m_wirecnt_tsf6;}

    int get_wirecnt_tsf7() const {return m_wirecnt_tsf7;}

    int get_wirecnt_tsf8() const {return m_wirecnt_tsf8;}


    int get_map_TSF0_int(int i) const {return m_map_TSF0_int[i];}

    int get_map_TSF2_int(int i) const {return m_map_TSF2_int[i];}

    int get_map_TSF4_int(int i) const {return m_map_TSF4_int[i];}

    int get_map_TSF1_int(int i) const {return m_map_TSF1_int[i];}

    int get_map_TSF3_int(int i) const {return m_map_TSF3_int[i];}

    int get_map_veto_int(int i) const {return m_map_veto_int[i];}

    int get_map_ST_int(int i) const {return m_map_ST_int[i];}

    int get_map_ST2_int(int i) const {return m_map_ST2_int[i];}

    bool get_map_TSF0(int i) const {return m_map_TSF0[i];}

    bool get_map_TSF2(int i) const {return m_map_TSF2[i];}

    bool get_map_TSF4(int i) const {return m_map_TSF4[i];}

    bool get_map_TSF1(int i) const {return m_map_TSF1[i];}

    bool get_map_TSF3(int i) const {return m_map_TSF3[i];}

    bool get_map_veto(int i) const {return m_map_veto[i];}

    bool get_map_ST(int i) const {return m_map_ST[i];}

    bool get_map_ST2(int i) const {return m_map_ST2[i];}


    int get_X() const {return  m_X;}

    int get_X_0() const {return m_X_0;}

    int get_X_1() const {return m_X_1;}

    int get_X_2() const {return m_X_2;}

    int get_N_cluster() const {return m_N_cluster;}

    int get_N_cluster_0() const {return m_N_cluster_0;}

    int get_N_cluster_1() const {return m_N_cluster_1;}

    int get_N_cluster_2() const {return m_N_cluster_2;}

    int get_revo_fam() const {return m_revo_fam;}

    int get_ECL_timing() const {return m_ECL_timing;}

    int get_ECL_trg_0() const {return m_ECL_trg_0;}

    int get_ECL_trg_1() const {return m_ECL_trg_1;}

    int get_ECL_trg_2() const {return m_ECL_trg_2;}

    int get_TOP_trg() const {return m_TOP_trg;}

    int get_TSFL1_count() const {return m_TSFL1_count;}

    int get_slot64b_TOP_int_1() const {return m_slot64b_TOP_int_1;}

    int get_slot64b_TOP_int_0() const {return m_slot64b_TOP_int_0;}

    int get_ECLL1_count() const {return m_ECLL1_count;}

    int get_CDCL1_count() const {return m_CDCL1_count;}

    int get_TOPL1_count() const {return m_TOPL1_count;}

    int get_KLML1_count() const {return m_KLML1_count;}

    int get_CDC3DL1_count() const {return m_CDC3DL1_count;}

    int get_CDCNNL1_count() const {return m_CDCNNL1_count;}

    int get_unamed3() const {return m_unamed3;}

    int get_revoclk1() const {return m_revoclk1;}

    int get_aaaa() const {return m_aaaa;}

    int get_charge_flag() const {return m_charge_flag;}

    int get_charge_sum() const {return m_charge_sum;}

    int get_firmid() const {return m_firmid;}

    int get_firmver() const {return m_firmver;}

    int get_evt() const {return m_evt;}

    int get_clk() const {return m_clk;}

    int get_coml1() const {return m_coml1;}

    int get_b2ldly() const {return m_b2ldly;}

    int get_maxrvc() const {return m_maxrvc;}

    //end get


    //set

    void set_dddd(int dddd) {m_dddd = dddd;}

    void set_unamed(int unamed) {m_unamed = unamed;}

    void set_revoclk(int revoclk) {m_revoclk = revoclk;}

    void set_ECL_trg(int ECLtrg) {m_ECL_trg = ECLtrg; }

    void set_ECL_trg_delay(int ECL_trg_delay) {m_ECL_trg_delay = ECL_trg_delay; }

    void set_CDCECL_jitter(int CDCECL_jitter)  {m_CDCECL_jitter = CDCECL_jitter;}

    void set_phi_CDC_int(int i, int phi_CDC_int)  {m_phi_CDC_int[i] = phi_CDC_int;}

    void set_phi_CDC(int i, bool phi_CDC) {m_phi_CDC[i] = phi_CDC;}

    void set_phi_i_int(int i, int phi_i_int) { m_phi_i_int[i] = phi_i_int; }

    void set_phi_i(int i, bool phi_i) { m_phi_i[i] = phi_i; }

    void set_N_track(int N_track) { m_N_track = N_track;}

    void set_N_track_cut(int N_track_cut) { m_N_track_cut = N_track_cut;}

    void set_N_track_3D(int N_track_3D)  { m_N_track_3D = N_track_3D; }

    void set_N_track_NN(int N_track_NN)  { m_N_track_NN = N_track_NN ;}

    void set_N_ST(int N_ST) { m_N_ST = N_ST; }

    void set_b2b_1to3(int b2b_1to3) { m_b2b_1to3 = b2b_1to3; }

    void set_b2b_1to5(int b2b_1to5) { m_b2b_1to5 = b2b_1to5; }

    void set_b2b_1to7(int b2b_1to7)  { m_b2b_1to7 = b2b_1to7; }

    void set_b2b_1to9(int b2b_1to9)  { m_b2b_1to9 = b2b_1to9; }

    void set_opening(int opening) { m_opening = opening; }

    void set_cc(int cc) {m_cc = cc;}

    void set_unamed0(int unamed0)  { m_unamed0 = unamed0; }

    void set_KLM_trg(int KLM_trg) { m_KLM_trg = KLM_trg; }

    void set_matched_2DKLM(int matched_2DKLM) { m_matched_2DKLM = matched_2DKLM; }

    void set_CDCKLM_jitter(int CDCKLM_jitter) {m_CDCKLM_jitter = CDCKLM_jitter;}

    void set_KLMCDC_jitter(int KLMCDC_jitter) { m_KLMCDC_jitter = KLMCDC_jitter;}

    void set_sector_KLM_int(int sector_KLM_int)  { m_sector_KLM_int = sector_KLM_int;}

    void set_sector_KLM(int i, bool sector_KLM)  { m_sector_KLM[i] = sector_KLM;}

    void set_sector_CDC_int(int sector_CDC_int)  { m_sector_CDC_int = sector_CDC_int;}

    void set_sector_CDC(int i, bool sector_CDC) { m_sector_CDC[i] = sector_CDC ;}

    void set_N_KLMmatch(int N_KLMmatch) { m_N_KLMmatch = N_KLMmatch; }

    void set_samehem(int i, int samehem)  {  m_samehem[i] = samehem; }

    void set_opphem(int i, int opphem)  { m_opphem[i] = opphem; }

    void set_N_match_2GeV(int i, int N_match_2GeV)  { m_N_match_2GeV[i] = N_match_2GeV; }

    void set_N_match(int i, int N_match) { m_N_match[i] = N_match; }

    void set_N_g_1GeV(int i, int N_g_1GeV) { m_N_g_1GeV[i] = N_g_1GeV; }

    void set_N_g_2GeV(int i, int N_g_2GeV) { m_N_g_2GeV[i] = N_g_2GeV; }

    void set_CDCTOP_jitter(int CDCTOP_jitter)  { m_CDCTOP_jitter = CDCTOP_jitter; }

    void set_c_b2b_1to9(int i, int c_b2b_1to9)  { m_c_b2b_1to9[i] = c_b2b_1to9; }

    void set_c_b2b_1to7(int i, int c_b2b_1to7)  { m_c_b2b_1to7[i] = c_b2b_1to7; }

    void set_c_b2b_1to5(int i, int c_b2b_1to5)  { m_c_b2b_1to5[i] = c_b2b_1to5; }

    void set_c_b2b_1to3(int i, int c_b2b_1to3)  { m_c_b2b_1to3[i] = c_b2b_1to3; }

    void set_tc_b2b_1to9(int i, int tc_b2b_1to9)  { m_tc_b2b_1to9[i] = tc_b2b_1to9; }

    void set_tc_b2b_1to7(int i, int tc_b2b_1to7) {m_tc_b2b_1to7[i] = tc_b2b_1to7; }

    void set_tc_b2b_1to5(int i, int tc_b2b_1to5)  { m_tc_b2b_1to5[i] = tc_b2b_1to5; }

    void set_tc_b2b_1to3(int i, int tc_b2b_1to3)  { m_tc_b2b_1to3[i] = tc_b2b_1to3; }

    void set_CDC3D_jitter(int CDC3D_jitter)  { m_CDC3D_jitter = CDC3D_jitter; }

    void set_CDCNN_jitter(int CDCNN_jitter) { m_CDCNN_jitter = CDCNN_jitter; }


    void set_slot_CDC_int(int slot_CDC_int) { m_slot_CDC_int = slot_CDC_int; }

    void set_slot_CDC(int i, bool slot_CDC) { m_slot_CDC[i] = slot_CDC; }

    void set_slot_TOP_int(int slot_TOP_int) { m_slot_TOP_int = slot_TOP_int; }

    void set_slot_TOP(int i, bool slot_TOP)  { m_slot_TOP[i] = slot_TOP; }

    void set_N_TOPmatch(int N_TOPmatch)  { m_N_TOPmatch = N_TOPmatch; }


    void set_unamed1(int unamed1) { m_unamed1 = unamed1; }

    void set_unamed2(int unamed2) { m_unamed2 = unamed2; }

    void set_concidence_2DECL(int coincidence_2DECL) { m_coincidence_2DECL = coincidence_2DECL; }

    void set_matched_2DECL(int matched_2DECL) { m_matched_2DECL = matched_2DECL; }


    void set_theta_ECL(int i, int theta_ECL)  { m_theta_ECL[i] = theta_ECL;}

    void Addto_theta_ECL(int theta_ECL)  { m_theta_ECL.push_back(theta_ECL);}

    void set_phi_ECL(int i, int phi_ECL) { m_phi_ECL[i] = phi_ECL;}

    void Addto_phi_ECL(int phi_ECL) { m_phi_ECL.push_back(phi_ECL) ;}

    void set_t_ECL(int i, int t_ECL)  { m_t_ECL[i] = t_ECL;}

    void Addto_t_ECL(int t_ECL)  { m_t_ECL.push_back(t_ECL) ;}

    void set_E_ECL(int i, int E_ECL)  { m_E_ECL[i] = E_ECL;}

    void Addto_E_ECL(int E_ECL)  { m_E_ECL.push_back(E_ECL) ;}

    void set_clk_ECL(int i, int clk_ECL) { m_clk_ECL[i] = clk_ECL; }

    void Addto_clk_ECL(int clk_ECL) { m_clk_ECL.push_back(clk_ECL); }

    void set_1GeV_ECL(int i, int c1GeV_ECL)  { m_1GeV_ECL[i] = c1GeV_ECL; }

    void Addto_1GeV_ECL(int c1GeV_ECL)  { m_1GeV_ECL.push_back(c1GeV_ECL); }

    void set_2GeV_ECL(int i, int c2GeV_ECL)  { m_2GeV_ECL[i] = c2GeV_ECL; }

    void Addto_2GeV_ECL(int c2GeV_ECL)  { m_2GeV_ECL.push_back(c2GeV_ECL) ; }


    void set_wirecnt_tsf0(int wirecnt_tsf0) { m_wirecnt_tsf0 = wirecnt_tsf0; }

    void set_wirecnt_tsf1(int wirecnt_tsf1) { m_wirecnt_tsf1 = wirecnt_tsf1; }

    void set_wirecnt_tsf2(int wirecnt_tsf2) { m_wirecnt_tsf2 = wirecnt_tsf2; }

    void set_wirecnt_tsf3(int wirecnt_tsf3) { m_wirecnt_tsf3 = wirecnt_tsf3; }

    void set_wirecnt_tsf4(int wirecnt_tsf4) { m_wirecnt_tsf4 = wirecnt_tsf4; }

    void set_wirecnt_tsf5(int wirecnt_tsf5) { m_wirecnt_tsf5 = wirecnt_tsf5; }

    void set_wirecnt_tsf6(int wirecnt_tsf6) { m_wirecnt_tsf6 = wirecnt_tsf6; }

    void set_wirecnt_tsf7(int wirecnt_tsf7) { m_wirecnt_tsf7 = wirecnt_tsf7; }

    void set_wirecnt_tsf8(int wirecnt_tsf8) { m_wirecnt_tsf8 = wirecnt_tsf8; }


    void set_map_TSF0_int(int i, int map_TSF0_int)  { m_map_TSF0_int[i] = map_TSF0_int; }

    void set_map_TSF2_int(int i, int map_TSF2_int)  { m_map_TSF2_int[i] = map_TSF2_int; }

    void set_map_TSF4_int(int i, int map_TSF4_int)  { m_map_TSF4_int[i] = map_TSF4_int; }

    void set_map_TSF1_int(int i, int map_TSF1_int)  { m_map_TSF1_int[i] = map_TSF1_int; }

    void set_map_TSF3_int(int i, int map_TSF3_int)  { m_map_TSF3_int[i] = map_TSF3_int; }

    void set_map_veto_int(int i, int map_veto_int)  { m_map_veto_int[i] = map_veto_int; }

    void set_map_ST_int(int i, int map_ST_int)   { m_map_ST_int[i] = map_ST_int; }

    void set_map_ST2_int(int i, int map_ST2_int)  { m_map_ST2_int[i] = map_ST2_int; }

    void set_map_TSF0(int i, bool map_TSF0)  { m_map_TSF0[i] = map_TSF0; }

    void set_map_TSF2(int i, bool map_TSF2)  { m_map_TSF2[i] = map_TSF2; }

    void set_map_TSF4(int i, bool map_TSF4)  { m_map_TSF4[i] = map_TSF4; }

    void set_map_TSF1(int i, bool map_TSF1)  { m_map_TSF1[i] = map_TSF1; }

    void set_map_TSF3(int i, bool map_TSF3)  { m_map_TSF3[i] = map_TSF3; }

    void set_map_veto(int i, bool map_veto)  { m_map_veto[i] = map_veto; }

    void set_map_ST(int i, bool map_ST)  { m_map_ST[i] = map_ST; }

    void set_map_ST2(int i, bool map_ST2)  { m_map_ST2[i] = map_ST2; }


    void set_X(int X)  { m_X = X; }

    void set_X_0(int X_0)  { m_X_0 = X_0; }

    void set_X_1(int X_1)  { m_X_1 = X_1; }

    void set_X_2(int X_2)  { m_X_2 = X_2; }

    void set_N_cluster(int N_cluster)  { m_N_cluster = N_cluster; }

    void set_N_cluster_0(int N_cluster_0)  { m_N_cluster_0 = N_cluster_0; }

    void set_N_cluster_1(int N_cluster_1)  { m_N_cluster_1 = N_cluster_1; }

    void set_N_cluster_2(int N_cluster_2)  { m_N_cluster_2 = N_cluster_2; }

    void set_revo_fam(int revo_fam)  { m_revo_fam = revo_fam; }

    void set_ECL_timing(int ECL_timing)  { m_ECL_timing = ECL_timing; }

    void set_ECL_trg_0(int ECL_trg_0)  { m_ECL_trg_0 = ECL_trg_0; }

    void set_ECL_trg_1(int ECL_trg_1)  { m_ECL_trg_1 = ECL_trg_1; }

    void set_ECL_trg_2(int ECL_trg_2)  { m_ECL_trg_2 = ECL_trg_2;}

    void set_TOP_trg(int TOP_trg)  { m_TOP_trg = TOP_trg;}

    void set_TSFL1_count(int TSFL1_count)  { m_TSFL1_count = TSFL1_count;}

    void set_slot64b_TOP_int_1(int slot64b_TOP_int_1)  { m_slot64b_TOP_int_1 = slot64b_TOP_int_1;}

    void set_slot64b_TOP_int_0(int slot64b_TOP_int_0)  { m_slot64b_TOP_int_0 = slot64b_TOP_int_0;}

    void set_ECLL1_count(int ECLL1_count)  { m_ECLL1_count = ECLL1_count;}

    void set_CDCL1_count(int CDCL1_count)  { m_CDCL1_count = CDCL1_count ;}

    void set_TOPL1_count(int TOPL1_count)  { m_TOPL1_count = TOPL1_count;}

    void set_KLML1_count(int KLML1_count)  { m_KLML1_count = KLML1_count;}

    void set_CDC3DL1_count(int CDC3DL1_count)  { m_CDC3DL1_count = CDC3DL1_count;}

    void set_CDCNNL1_count(int CDCNNL1_count)  { m_CDCNNL1_count = CDCNNL1_count;}

    void set_unamed3(int unamed3)  { m_unamed3 = unamed3;}

    void set_revoclk1(int revoclk1)  { m_revoclk1 = revoclk1;}

    void set_aaaa(int aaaa)  { m_aaaa = aaaa;}

    void set_charge_flag(int charge_flag)  { m_charge_flag = charge_flag;}

    void set_charge_sum(int charge_sum) { m_charge_sum = charge_sum;}

    void set_firmid(int firmid)  { m_firmid = firmid;}

    void set_firmver(int firmver)  { m_firmver = firmver;}

    void set_evt(int evt)  { m_evt = evt;}

    void set_clk(int clk)  { m_clk = clk;}

    void set_coml1(int coml1)  { m_coml1 = coml1;}

    void set_b2ldly(int b2ldly)  { m_b2ldly = b2ldly;}

    void set_maxrvc(int maxrvc)  { m_maxrvc = maxrvc;}

    void ClearVectors()

    {

      m_E_ECL.clear();

      m_t_ECL.clear();

      m_clk_ECL.clear();

      m_theta_ECL.clear();

      m_phi_ECL.clear();

      m_1GeV_ECL.clear();

      m_2GeV_ECL.clear();

    }


  private:

    int m_dddd;

    int m_unamed;

    int m_revoclk;

    int m_ECL_trg;

    int m_ECL_trg_delay;

    int m_CDCECL_jitter;

    int m_phi_CDC_int[2];

    std::vector<bool> m_phi_CDC = std::vector<bool>(36, 0);

    int m_phi_i_int[2];

    std::vector<bool> m_phi_i = std::vector<bool>(36, 0);

    int m_N_track;

    int m_N_track_cut;

    int m_N_track_3D;

    int m_N_track_NN;

    int m_N_ST;

    int m_b2b_1to3;

    int m_b2b_1to5;

    int m_b2b_1to7;

    int m_b2b_1to9;

    int m_opening;

    int m_cc;

    int m_unamed0;

    int m_KLM_trg;

    int m_matched_2DKLM;

    int m_CDCKLM_jitter;

    int m_KLMCDC_jitter;

    int m_sector_KLM_int;

    std::vector<bool> m_sector_KLM = std::vector<bool>(8, 0);

    int m_sector_CDC_int;

    std::vector<bool> m_sector_CDC = std::vector<bool>(8, 0);

    int m_N_KLMmatch;

    std::vector<int> m_samehem = std::vector<int>(2, 0);

    std::vector<int> m_opphem = std::vector<int>(2, 0);

    std::vector<int> m_N_match_2GeV = std::vector<int>(2, 0);

    std::vector<int> m_N_match = std::vector<int>(2, 0);

    std::vector<int> m_N_g_1GeV = std::vector<int>(2, 0);

    std::vector<int> m_N_g_2GeV = std::vector<int>(2, 0);

    int m_CDCTOP_jitter;

    std::vector<int> m_c_b2b_1to9 = std::vector<int>(2, 0);

    std::vector<int> m_c_b2b_1to7 = std::vector<int>(2, 0);

    std::vector<int> m_c_b2b_1to5 = std::vector<int>(2, 0);

    std::vector<int> m_c_b2b_1to3 = std::vector<int>(2, 0);

    std::vector<int> m_tc_b2b_1to9 = std::vector<int>(2, 0);

    std::vector<int> m_tc_b2b_1to7 = std::vector<int>(2, 0);

    std::vector<int> m_tc_b2b_1to5 = std::vector<int>(2, 0);

    std::vector<int> m_tc_b2b_1to3 = std::vector<int>(2, 0);

    int m_CDC3D_jitter;

    int m_CDCNN_jitter;


    int m_slot_CDC_int;

    std::vector<bool> m_slot_CDC = std::vector<bool>(15, 0);

    int m_slot_TOP_int;

    std::vector<bool> m_slot_TOP = std::vector<bool>(15, 0);

    int m_N_TOPmatch;


    int m_unamed1;

    int m_unamed2;

    int m_coincidence_2DECL;

    int m_matched_2DECL;


    std::vector<int> m_theta_ECL = std::vector<int>(30, 0);

    std::vector<int> m_phi_ECL = std::vector<int>(30, 0);

    std::vector<int> m_t_ECL = std::vector<int>(30, 0);

    std::vector<int> m_E_ECL = std::vector<int>(30, 0);

    std::vector<int> m_clk_ECL = std::vector<int>(30, 0);

    std::vector<int> m_1GeV_ECL = std::vector<int>(30, 0);

    std::vector<int> m_2GeV_ECL = std::vector<int>(30, 0);


    int m_wirecnt_tsf0;

    int m_wirecnt_tsf1;

    int m_wirecnt_tsf2;

    int m_wirecnt_tsf3;

    int m_wirecnt_tsf4;

    int m_wirecnt_tsf5;

    int m_wirecnt_tsf6;

    int m_wirecnt_tsf7;

    int m_wirecnt_tsf8;


    int m_map_TSF0_int[2];

    int m_map_TSF2_int[2];

    int m_map_TSF4_int[2];

    int m_map_TSF1_int[2];

    int m_map_TSF3_int[2];

    int m_map_veto_int[2];

    int m_map_ST_int[2];

    int m_map_ST2_int[2];

    std::vector<bool> m_map_TSF0 = std::vector<bool>(64, 0);

    std::vector<bool> m_map_TSF2 = std::vector<bool>(64, 0);

    std::vector<bool> m_map_TSF4 = std::vector<bool>(64, 0);

    std::vector<bool> m_map_TSF1 = std::vector<bool>(64, 0);

    std::vector<bool> m_map_TSF3 = std::vector<bool>(64, 0);

    std::vector<bool> m_map_veto = std::vector<bool>(64, 0);

    std::vector<bool> m_map_ST = std::vector<bool>(64, 0);

    std::vector<bool> m_map_ST2 = std::vector<bool>(64, 0);


    int m_X;

    int m_X_0;

    int m_X_1;

    int m_X_2;

    int m_N_cluster;

    int m_N_cluster_0;

    int m_N_cluster_1;

    int m_N_cluster_2;

    int m_revo_fam;

    int m_ECL_timing;

    int m_ECL_trg_0;

    int m_ECL_trg_1;

    int m_ECL_trg_2;

    int m_TOP_trg;

    int m_TSFL1_count;

    int m_slot64b_TOP_int_1;

    int m_slot64b_TOP_int_0;

    int m_ECLL1_count;

    int m_CDCL1_count;

    int m_TOPL1_count;

    int m_KLML1_count;

    int m_CDC3DL1_count;

    int m_CDCNNL1_count;

    int m_unamed3;

    int m_revoclk1;

    int m_aaaa;

    int m_charge_flag;

    int m_charge_sum;

    int m_firmid;

    int m_firmver;

    int m_evt;

    int m_clk;

    int m_coml1;

    int m_b2ldly;

    int m_maxrvc;

    ClassDef(TRGGRLUnpackerStore, 3);


  };


} // end namespace Belle2


#endif

Belle2::TRGGRLUnpackerStore
Example Detector.
Definition: TRGGRLUnpackerStore.h:22

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf3
int m_wirecnt_tsf3
#wire hit in SL3
Definition: TRGGRLUnpackerStore.h:695

Belle2::TRGGRLUnpackerStore::set_CDCNNL1_count
void set_CDCNNL1_count(int CDCNNL1_count)
m_CDCNNL1_count leaf
Definition: TRGGRLUnpackerStore.h:517

Belle2::TRGGRLUnpackerStore::set_theta_ECL
void set_theta_ECL(int i, int theta_ECL)
m_theta_ECL leaf
Definition: TRGGRLUnpackerStore.h:399

Belle2::TRGGRLUnpackerStore::get_N_TOPmatch
int get_N_TOPmatch() const
m_N_TOPmatch leaf
Definition: TRGGRLUnpackerStore.h:130

Belle2::TRGGRLUnpackerStore::get_firmver
int get_firmver() const
m_firmver leafs
Definition: TRGGRLUnpackerStore.h:267

Belle2::TRGGRLUnpackerStore::m_ECL_timing
int m_ECL_timing
m_ECL_timing leaf
Definition: TRGGRLUnpackerStore.h:759

Belle2::TRGGRLUnpackerStore::get_phi_i
bool get_phi_i(int i) const
m_phi_i map leaf
Definition: TRGGRLUnpackerStore.h:43

Belle2::TRGGRLUnpackerStore::get_charge_flag
int get_charge_flag() const
m_charge_flag leaf
Definition: TRGGRLUnpackerStore.h:261

Belle2::TRGGRLUnpackerStore::set_sector_KLM_int
void set_sector_KLM_int(int sector_KLM_int)
m_sector_KLM integer leaf
Definition: TRGGRLUnpackerStore.h:334

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf2
int m_wirecnt_tsf2
#wire hit in SL2
Definition: TRGGRLUnpackerStore.h:693

Belle2::TRGGRLUnpackerStore::get_map_TSF3
bool get_map_TSF3(int i) const
m_map_TSF3 map leaf
Definition: TRGGRLUnpackerStore.h:200

Belle2::TRGGRLUnpackerStore::m_slot_CDC_int
int m_slot_CDC_int
m_slot_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:654

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf7
void set_wirecnt_tsf7(int wirecnt_tsf7)
#wire hit in SL7
Definition: TRGGRLUnpackerStore.h:435

Belle2::TRGGRLUnpackerStore::m_N_match_2GeV
std::vector< int > m_N_match_2GeV
m_N_match_2GeV leaf
Definition: TRGGRLUnpackerStore.h:623

Belle2::TRGGRLUnpackerStore::get_ECLL1_count
int get_ECLL1_count() const
m_ECLL1_count leaf
Definition: TRGGRLUnpackerStore.h:243

Belle2::TRGGRLUnpackerStore::get_CDCL1_count
int get_CDCL1_count() const
m_CDCL1_count leaf
Definition: TRGGRLUnpackerStore.h:245

Belle2::TRGGRLUnpackerStore::m_phi_i
std::vector< bool > m_phi_i
m_phi_i map leaf
Definition: TRGGRLUnpackerStore.h:575

Belle2::TRGGRLUnpackerStore::m_unamed0
int m_unamed0
m_unamed0 leaf
Definition: TRGGRLUnpackerStore.h:599

Belle2::TRGGRLUnpackerStore::set_b2ldly
void set_b2ldly(int b2ldly)
m_b2ldly leafs
Definition: TRGGRLUnpackerStore.h:539

Belle2::TRGGRLUnpackerStore::set_ECL_trg_0
void set_ECL_trg_0(int ECL_trg_0)
m_ECL_trg_0 leaf
Definition: TRGGRLUnpackerStore.h:493

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf3
void set_wirecnt_tsf3(int wirecnt_tsf3)
#wire hit in SL3
Definition: TRGGRLUnpackerStore.h:427

Belle2::TRGGRLUnpackerStore::get_N_KLMmatch
int get_N_KLMmatch() const
m_N_KLMmatch leaf
Definition: TRGGRLUnpackerStore.h:85

Belle2::TRGGRLUnpackerStore::set_CDC3D_jitter
void set_CDC3D_jitter(int CDC3D_jitter)
m_CDC3D_jitter leaf
Definition: TRGGRLUnpackerStore.h:374

Belle2::TRGGRLUnpackerStore::m_N_g_2GeV
std::vector< int > m_N_g_2GeV
m_N_g_2GeV leaf
Definition: TRGGRLUnpackerStore.h:629

Belle2::TRGGRLUnpackerStore::get_N_cluster_0
int get_N_cluster_0() const
m_N_cluster_0 leaf
Definition: TRGGRLUnpackerStore.h:219

Belle2::TRGGRLUnpackerStore::set_unamed
void set_unamed(int unamed)
m_unamed leaf
Definition: TRGGRLUnpackerStore.h:284

Belle2::TRGGRLUnpackerStore::get_unamed2
int get_unamed2() const
m_unamed2 leaf
Definition: TRGGRLUnpackerStore.h:135

Belle2::TRGGRLUnpackerStore::get_c_b2b_1to9
int get_c_b2b_1to9(int i) const
m_c_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:101

Belle2::TRGGRLUnpackerStore::set_map_TSF1
void set_map_TSF1(int i, bool map_TSF1)
m_map_TSF1 map leaf
Definition: TRGGRLUnpackerStore.h:462

Belle2::TRGGRLUnpackerStore::get_b2b_1to3
int get_b2b_1to3() const
m_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:55

Belle2::TRGGRLUnpackerStore::ClearVectors
void ClearVectors()
clear vectors
Definition: TRGGRLUnpackerStore.h:543

Belle2::TRGGRLUnpackerStore::set_cc
void set_cc(int cc)
m_cc leaf
Definition: TRGGRLUnpackerStore.h:322

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf7
int m_wirecnt_tsf7
#wire hit in SL7
Definition: TRGGRLUnpackerStore.h:703

Belle2::TRGGRLUnpackerStore::set_sector_CDC
void set_sector_CDC(int i, bool sector_CDC)
m_sector_CDC map
Definition: TRGGRLUnpackerStore.h:340

Belle2::TRGGRLUnpackerStore::set_ECL_trg_1
void set_ECL_trg_1(int ECL_trg_1)
m_ECL_trg_1 leaf
Definition: TRGGRLUnpackerStore.h:495

Belle2::TRGGRLUnpackerStore::get_N_track_3D
int get_N_track_3D() const
m_N_track_3D leaf
Definition: TRGGRLUnpackerStore.h:49

Belle2::TRGGRLUnpackerStore::set_slot_CDC
void set_slot_CDC(int i, bool slot_CDC)
m_slot_CDC map leaf
Definition: TRGGRLUnpackerStore.h:381

Belle2::TRGGRLUnpackerStore::set_map_ST_int
void set_map_ST_int(int i, int map_ST_int)
m_map_ST integer leaf
Definition: TRGGRLUnpackerStore.h:452

Belle2::TRGGRLUnpackerStore::set_CDCL1_count
void set_CDCL1_count(int CDCL1_count)
m_CDCL1_count leaf
Definition: TRGGRLUnpackerStore.h:509

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf2
int get_wirecnt_tsf2() const
#wire hit in SL2
Definition: TRGGRLUnpackerStore.h:161

Belle2::TRGGRLUnpackerStore::get_phi_CDC_int
int get_phi_CDC_int(int i) const
m_phi_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:37

Belle2::TRGGRLUnpackerStore::get_ECL_trg_1
int get_ECL_trg_1() const
m_ECL_trg_1 leaf
Definition: TRGGRLUnpackerStore.h:231

Belle2::TRGGRLUnpackerStore::get_N_track
int get_N_track() const
m_N_track leaf
Definition: TRGGRLUnpackerStore.h:45

Belle2::TRGGRLUnpackerStore::m_ECL_trg_0
int m_ECL_trg_0
m_ECL_trg_0 leaf
Definition: TRGGRLUnpackerStore.h:761

Belle2::TRGGRLUnpackerStore::set_ECL_trg_delay
void set_ECL_trg_delay(int ECL_trg_delay)
m_ECL_trg_delay leaf
Definition: TRGGRLUnpackerStore.h:290

Belle2::TRGGRLUnpackerStore::set_X_0
void set_X_0(int X_0)
m_X_0 leaf
Definition: TRGGRLUnpackerStore.h:475

Belle2::TRGGRLUnpackerStore::set_unamed3
void set_unamed3(int unamed3)
m_unamed3 leaf
Definition: TRGGRLUnpackerStore.h:519

Belle2::TRGGRLUnpackerStore::m_phi_i_int
int m_phi_i_int[2]
m_phi_i integer leaf
Definition: TRGGRLUnpackerStore.h:573

Belle2::TRGGRLUnpackerStore::get_2GeV_ECL
int get_2GeV_ECL(int i) const
m_2GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:154

Belle2::TRGGRLUnpackerStore::get_samehem
int get_samehem(int i) const
m_samehem leaf
Definition: TRGGRLUnpackerStore.h:87

Belle2::TRGGRLUnpackerStore::m_KLMCDC_jitter
int m_KLMCDC_jitter
m_KLMCDC_jitter leaf
Definition: TRGGRLUnpackerStore.h:607

Belle2::TRGGRLUnpackerStore::m_maxrvc
int m_maxrvc
m_maxrvc leafs
Definition: TRGGRLUnpackerStore.h:809

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf6
int get_wirecnt_tsf6() const
#wire hit in SL6
Definition: TRGGRLUnpackerStore.h:169

Belle2::TRGGRLUnpackerStore::get_ECL_trg_delay
int get_ECL_trg_delay() const
m_ECL_trg_delay leaf
Definition: TRGGRLUnpackerStore.h:33

Belle2::TRGGRLUnpackerStore::m_clk
int m_clk
m_clk leafs
Definition: TRGGRLUnpackerStore.h:803

Belle2::TRGGRLUnpackerStore::get_TOP_trg
int get_TOP_trg() const
m_TOP_trg leaf
Definition: TRGGRLUnpackerStore.h:235

Belle2::TRGGRLUnpackerStore::set_N_cluster_0
void set_N_cluster_0(int N_cluster_0)
m_N_cluster_0 leaf
Definition: TRGGRLUnpackerStore.h:483

Belle2::TRGGRLUnpackerStore::m_ECL_trg_delay
int m_ECL_trg_delay
m_ECL_trg_delay leaf
Definition: TRGGRLUnpackerStore.h:565

Belle2::TRGGRLUnpackerStore::set_KLM_trg
void set_KLM_trg(int KLM_trg)
m_KLM_trg leaf
Definition: TRGGRLUnpackerStore.h:326

Belle2::TRGGRLUnpackerStore::m_b2b_1to3
int m_b2b_1to3
m_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:587

Belle2::TRGGRLUnpackerStore::set_tc_b2b_1to9
void set_tc_b2b_1to9(int i, int tc_b2b_1to9)
m_tc_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:366

Belle2::TRGGRLUnpackerStore::m_c_b2b_1to7
std::vector< int > m_c_b2b_1to7
m_c_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:635

Belle2::TRGGRLUnpackerStore::get_phi_CDC
bool get_phi_CDC(int i) const
m_phi_CDC map leaf
Definition: TRGGRLUnpackerStore.h:39

Belle2::TRGGRLUnpackerStore::get_map_TSF2_int
int get_map_TSF2_int(int i) const
m_map_TSF2 integer leaf
Definition: TRGGRLUnpackerStore.h:178

Belle2::TRGGRLUnpackerStore::set_slot_TOP
void set_slot_TOP(int i, bool slot_TOP)
m_slot_TOP map leaf
Definition: TRGGRLUnpackerStore.h:385

Belle2::TRGGRLUnpackerStore::get_unamed0
int get_unamed0() const
m_unamed0 leaf
Definition: TRGGRLUnpackerStore.h:67

Belle2::TRGGRLUnpackerStore::get_tc_b2b_1to9
int get_tc_b2b_1to9(int i) const
m_tc_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:109

Belle2::TRGGRLUnpackerStore::m_tc_b2b_1to5
std::vector< int > m_tc_b2b_1to5
m_tc_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:645

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf4
int m_wirecnt_tsf4
#wire hit in SL4
Definition: TRGGRLUnpackerStore.h:697

Belle2::TRGGRLUnpackerStore::m_N_track
int m_N_track
m_N_track leaf
Definition: TRGGRLUnpackerStore.h:577

Belle2::TRGGRLUnpackerStore::set_phi_CDC
void set_phi_CDC(int i, bool phi_CDC)
m_phi_CDC map leaf
Definition: TRGGRLUnpackerStore.h:296

Belle2::TRGGRLUnpackerStore::m_c_b2b_1to3
std::vector< int > m_c_b2b_1to3
m_c_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:639

Belle2::TRGGRLUnpackerStore::m_revoclk
int m_revoclk
m_revoclk leaf
Definition: TRGGRLUnpackerStore.h:561

Belle2::TRGGRLUnpackerStore::m_E_ECL
std::vector< int > m_E_ECL
m_E_ECL leaf
Definition: TRGGRLUnpackerStore.h:680

Belle2::TRGGRLUnpackerStore::get_c_b2b_1to3
int get_c_b2b_1to3(int i) const
m_c_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:107

Belle2::TRGGRLUnpackerStore::m_sector_KLM
std::vector< bool > m_sector_KLM
m_sector_KLM map leaf
Definition: TRGGRLUnpackerStore.h:611

Belle2::TRGGRLUnpackerStore::m_N_KLMmatch
int m_N_KLMmatch
m_N_KLMmatch leaf
Definition: TRGGRLUnpackerStore.h:617

Belle2::TRGGRLUnpackerStore::set_map_ST2
void set_map_ST2(int i, bool map_ST2)
m_map_ST2 map leaf
Definition: TRGGRLUnpackerStore.h:470

Belle2::TRGGRLUnpackerStore::set_phi_ECL
void set_phi_ECL(int i, int phi_ECL)
m_phi_ECL leaf
Definition: TRGGRLUnpackerStore.h:402

Belle2::TRGGRLUnpackerStore::get_ECL_trg_0
int get_ECL_trg_0() const
m_ECL_trg_0 leaf
Definition: TRGGRLUnpackerStore.h:229

Belle2::TRGGRLUnpackerStore::m_CDCNNL1_count
int m_CDCNNL1_count
m_CDCNNL1_count leaf
Definition: TRGGRLUnpackerStore.h:785

Belle2::TRGGRLUnpackerStore::get_map_TSF4
bool get_map_TSF4(int i) const
m_map_TSF4 map leaf
Definition: TRGGRLUnpackerStore.h:196

Belle2::TRGGRLUnpackerStore::m_evt
int m_evt
m_evt leafs
Definition: TRGGRLUnpackerStore.h:801

Belle2::TRGGRLUnpackerStore::get_X_1
int get_X_1() const
m_X_1 leaf
Definition: TRGGRLUnpackerStore.h:213

Belle2::TRGGRLUnpackerStore::set_concidence_2DECL
void set_concidence_2DECL(int coincidence_2DECL)
m_coincidence_2DECL leaf
Definition: TRGGRLUnpackerStore.h:394

Belle2::TRGGRLUnpackerStore::get_charge_sum
int get_charge_sum() const
m_charge_sum leaf
Definition: TRGGRLUnpackerStore.h:263

Belle2::TRGGRLUnpackerStore::m_map_ST
std::vector< bool > m_map_ST
m_map_ST map leaf
Definition: TRGGRLUnpackerStore.h:736

Belle2::TRGGRLUnpackerStore::m_CDCTOP_jitter
int m_CDCTOP_jitter
m_CDCTOP_jitter leaf
Definition: TRGGRLUnpackerStore.h:631

Belle2::TRGGRLUnpackerStore::m_phi_CDC_int
int m_phi_CDC_int[2]
m_phi_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:569

Belle2::TRGGRLUnpackerStore::get_b2b_1to5
int get_b2b_1to5() const
m_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:57

Belle2::TRGGRLUnpackerStore::get_KLMCDC_jitter
int get_KLMCDC_jitter() const
m_KLMCDC_jitter leaf
Definition: TRGGRLUnpackerStore.h:75

Belle2::TRGGRLUnpackerStore::set_KLML1_count
void set_KLML1_count(int KLML1_count)
m_KLML1_count leaf
Definition: TRGGRLUnpackerStore.h:513

Belle2::TRGGRLUnpackerStore::set_map_TSF1_int
void set_map_TSF1_int(int i, int map_TSF1_int)
m_map_TSF1 integer leaf
Definition: TRGGRLUnpackerStore.h:446

Belle2::TRGGRLUnpackerStore::get_TSFL1_count
int get_TSFL1_count() const
m_TSFL1_count leaf
Definition: TRGGRLUnpackerStore.h:237

Belle2::TRGGRLUnpackerStore::m_map_TSF3_int
int m_map_TSF3_int[2]
m_map_TSF3 integer leaf
Definition: TRGGRLUnpackerStore.h:716

Belle2::TRGGRLUnpackerStore::m_sector_CDC
std::vector< bool > m_sector_CDC
m_sector_CDC map
Definition: TRGGRLUnpackerStore.h:615

Belle2::TRGGRLUnpackerStore::set_revo_fam
void set_revo_fam(int revo_fam)
m_revo_fam leaf
Definition: TRGGRLUnpackerStore.h:489

Belle2::TRGGRLUnpackerStore::m_N_track_3D
int m_N_track_3D
m_N_track_3D leaf
Definition: TRGGRLUnpackerStore.h:581

Belle2::TRGGRLUnpackerStore::set_N_match_2GeV
void set_N_match_2GeV(int i, int N_match_2GeV)
m_N_match_2GeV leaf
Definition: TRGGRLUnpackerStore.h:348

Belle2::TRGGRLUnpackerStore::set_E_ECL
void set_E_ECL(int i, int E_ECL)
m_E_ECL leaf
Definition: TRGGRLUnpackerStore.h:408

Belle2::TRGGRLUnpackerStore::set_N_match
void set_N_match(int i, int N_match)
m_N_match leaf
Definition: TRGGRLUnpackerStore.h:350

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf8
void set_wirecnt_tsf8(int wirecnt_tsf8)
#wire hit in SL8
Definition: TRGGRLUnpackerStore.h:437

Belle2::TRGGRLUnpackerStore::m_coml1
int m_coml1
m_coml1 leafs
Definition: TRGGRLUnpackerStore.h:805

Belle2::TRGGRLUnpackerStore::m_TOP_trg
int m_TOP_trg
m_TOP_trg leaf
Definition: TRGGRLUnpackerStore.h:767

Belle2::TRGGRLUnpackerStore::m_c_b2b_1to9
std::vector< int > m_c_b2b_1to9
m_c_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:633

Belle2::TRGGRLUnpackerStore::get_map_veto
bool get_map_veto(int i) const
m_map_veto map leaf
Definition: TRGGRLUnpackerStore.h:202

Belle2::TRGGRLUnpackerStore::m_CDC3DL1_count
int m_CDC3DL1_count
m_CDC3DL1_count leaf
Definition: TRGGRLUnpackerStore.h:783

Belle2::TRGGRLUnpackerStore::get_map_TSF2
bool get_map_TSF2(int i) const
m_map_TSF2 map leaf
Definition: TRGGRLUnpackerStore.h:194

Belle2::TRGGRLUnpackerStore::get_opphem
int get_opphem(int i) const
m_opphem leaf
Definition: TRGGRLUnpackerStore.h:89

Belle2::TRGGRLUnpackerStore::get_CDCNN_jitter
int get_CDCNN_jitter() const
m_CDCNN_jitter leaf
Definition: TRGGRLUnpackerStore.h:119

Belle2::TRGGRLUnpackerStore::set_X
void set_X(int X)
m_X leaf
Definition: TRGGRLUnpackerStore.h:473

Belle2::TRGGRLUnpackerStore::get_clk
int get_clk() const
m_clk leafs
Definition: TRGGRLUnpackerStore.h:271

Belle2::TRGGRLUnpackerStore::m_N_TOPmatch
int m_N_TOPmatch
m_N_TOPmatch leaf
Definition: TRGGRLUnpackerStore.h:662

Belle2::TRGGRLUnpackerStore::set_samehem
void set_samehem(int i, int samehem)
m_samehem leaf
Definition: TRGGRLUnpackerStore.h:344

Belle2::TRGGRLUnpackerStore::m_unamed2
int m_unamed2
m_unamed2 leaf
Definition: TRGGRLUnpackerStore.h:667

Belle2::TRGGRLUnpackerStore::set_map_TSF2
void set_map_TSF2(int i, bool map_TSF2)
m_map_TSF2 map leaf
Definition: TRGGRLUnpackerStore.h:458

Belle2::TRGGRLUnpackerStore::get_matched_2DECL
int get_matched_2DECL() const
m_matched_2DECL leaf
Definition: TRGGRLUnpackerStore.h:139

Belle2::TRGGRLUnpackerStore::get_coml1
int get_coml1() const
m_coml1 leafs
Definition: TRGGRLUnpackerStore.h:273

Belle2::TRGGRLUnpackerStore::set_map_ST
void set_map_ST(int i, bool map_ST)
m_map_ST map leaf
Definition: TRGGRLUnpackerStore.h:468

Belle2::TRGGRLUnpackerStore::get_b2b_1to9
int get_b2b_1to9() const
m_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:61

Belle2::TRGGRLUnpackerStore::get_slot_TOP
bool get_slot_TOP(int i) const
m_slot_TOP map leaf
Definition: TRGGRLUnpackerStore.h:128

Belle2::TRGGRLUnpackerStore::m_tc_b2b_1to3
std::vector< int > m_tc_b2b_1to3
m_tc_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:647

Belle2::TRGGRLUnpackerStore::m_unamed3
int m_unamed3
m_unamed3 leaf
Definition: TRGGRLUnpackerStore.h:787

Belle2::TRGGRLUnpackerStore::set_revoclk1
void set_revoclk1(int revoclk1)
m_revoclk1 leaf
Definition: TRGGRLUnpackerStore.h:521

Belle2::TRGGRLUnpackerStore::get_map_TSF0_int
int get_map_TSF0_int(int i) const
m_map_TSF0 integer leaf
Definition: TRGGRLUnpackerStore.h:176

Belle2::TRGGRLUnpackerStore::m_unamed1
int m_unamed1
m_unamed1 leaf
Definition: TRGGRLUnpackerStore.h:665

Belle2::TRGGRLUnpackerStore::get_t_ECL
int get_t_ECL(int i) const
m_t_ECL leaf
Definition: TRGGRLUnpackerStore.h:146

Belle2::TRGGRLUnpackerStore::m_t_ECL
std::vector< int > m_t_ECL
m_t_ECL leaf
Definition: TRGGRLUnpackerStore.h:678

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf6
void set_wirecnt_tsf6(int wirecnt_tsf6)
#wire hit in SL6
Definition: TRGGRLUnpackerStore.h:433

Belle2::TRGGRLUnpackerStore::set_firmid
void set_firmid(int firmid)
m_firmid leafs
Definition: TRGGRLUnpackerStore.h:529

Belle2::TRGGRLUnpackerStore::set_map_TSF4
void set_map_TSF4(int i, bool map_TSF4)
m_map_TSF4 map leaf
Definition: TRGGRLUnpackerStore.h:460

Belle2::TRGGRLUnpackerStore::m_CDCKLM_jitter
int m_CDCKLM_jitter
m_CDCKLM_jitter leaf
Definition: TRGGRLUnpackerStore.h:605

Belle2::TRGGRLUnpackerStore::get_sector_CDC_int
int get_sector_CDC_int() const
m_sector_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:81

Belle2::TRGGRLUnpackerStore::m_map_ST_int
int m_map_ST_int[2]
m_map_ST integer leaf
Definition: TRGGRLUnpackerStore.h:720

Belle2::TRGGRLUnpackerStore::m_map_TSF2
std::vector< bool > m_map_TSF2
m_map_TSF2 map leaf
Definition: TRGGRLUnpackerStore.h:726

Belle2::TRGGRLUnpackerStore::get_phi_i_int
int get_phi_i_int(int i) const
m_phi_i integer leaf
Definition: TRGGRLUnpackerStore.h:41

Belle2::TRGGRLUnpackerStore::get_map_TSF0
bool get_map_TSF0(int i) const
m_map_TSF0 map leaf
Definition: TRGGRLUnpackerStore.h:192

Belle2::TRGGRLUnpackerStore::get_slot64b_TOP_int_1
int get_slot64b_TOP_int_1() const
m_slot64b_TOP_int_1 leaf
Definition: TRGGRLUnpackerStore.h:239

Belle2::TRGGRLUnpackerStore::m_map_TSF1
std::vector< bool > m_map_TSF1
m_map_TSF1 map leaf
Definition: TRGGRLUnpackerStore.h:730

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf8
int get_wirecnt_tsf8() const
#wire hit in SL8
Definition: TRGGRLUnpackerStore.h:173

Belle2::TRGGRLUnpackerStore::get_N_g_2GeV
int get_N_g_2GeV(int i) const
m_N_g_2GeV leaf
Definition: TRGGRLUnpackerStore.h:97

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf4
int get_wirecnt_tsf4() const
#wire hit in SL4
Definition: TRGGRLUnpackerStore.h:165

Belle2::TRGGRLUnpackerStore::set_evt
void set_evt(int evt)
m_evt leafs
Definition: TRGGRLUnpackerStore.h:533

Belle2::TRGGRLUnpackerStore::m_phi_ECL
std::vector< int > m_phi_ECL
m_phi_ECL leaf
Definition: TRGGRLUnpackerStore.h:676

Belle2::TRGGRLUnpackerStore::m_unamed
int m_unamed
m_unamed leaf
Definition: TRGGRLUnpackerStore.h:559

Belle2::TRGGRLUnpackerStore::get_dddd
int get_dddd() const
m_dddd leaf
Definition: TRGGRLUnpackerStore.h:25

Belle2::TRGGRLUnpackerStore::get_map_TSF3_int
int get_map_TSF3_int(int i) const
m_map_TSF3 integer leaf
Definition: TRGGRLUnpackerStore.h:184

Belle2::TRGGRLUnpackerStore::m_b2b_1to9
int m_b2b_1to9
m_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:593

Belle2::TRGGRLUnpackerStore::m_slot_CDC
std::vector< bool > m_slot_CDC
m_slot_CDC map leaf
Definition: TRGGRLUnpackerStore.h:656

Belle2::TRGGRLUnpackerStore::m_tc_b2b_1to9
std::vector< int > m_tc_b2b_1to9
m_tc_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:641

Belle2::TRGGRLUnpackerStore::get_N_g_1GeV
int get_N_g_1GeV(int i) const
m_N_g_1GeV leaf
Definition: TRGGRLUnpackerStore.h:95

Belle2::TRGGRLUnpackerStore::m_KLML1_count
int m_KLML1_count
m_KLML1_count leaf
Definition: TRGGRLUnpackerStore.h:781

Belle2::TRGGRLUnpackerStore::set_N_track_NN
void set_N_track_NN(int N_track_NN)
m_N_track_NN leaf
Definition: TRGGRLUnpackerStore.h:308

Belle2::TRGGRLUnpackerStore::m_c_b2b_1to5
std::vector< int > m_c_b2b_1to5
m_c_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:637

Belle2::TRGGRLUnpackerStore::m_sector_KLM_int
int m_sector_KLM_int
m_sector_KLM integer leaf
Definition: TRGGRLUnpackerStore.h:609

Belle2::TRGGRLUnpackerStore::get_X
int get_X() const
m_X leaf
Definition: TRGGRLUnpackerStore.h:209

Belle2::TRGGRLUnpackerStore::set_map_TSF3_int
void set_map_TSF3_int(int i, int map_TSF3_int)
m_map_TSF3 integer leaf
Definition: TRGGRLUnpackerStore.h:448

Belle2::TRGGRLUnpackerStore::get_matched_2DKLM
int get_matched_2DKLM() const
m_matched_2DKLM leaf
Definition: TRGGRLUnpackerStore.h:71

Belle2::TRGGRLUnpackerStore::set_map_TSF4_int
void set_map_TSF4_int(int i, int map_TSF4_int)
m_map_TSF4 integer leaf
Definition: TRGGRLUnpackerStore.h:444

Belle2::TRGGRLUnpackerStore::m_slot_TOP_int
int m_slot_TOP_int
m_slot_TOP integer leaf
Definition: TRGGRLUnpackerStore.h:658

Belle2::TRGGRLUnpackerStore::m_b2b_1to7
int m_b2b_1to7
m_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:591

Belle2::TRGGRLUnpackerStore::get_slot_TOP_int
int get_slot_TOP_int() const
m_slot_TOP integer leaf
Definition: TRGGRLUnpackerStore.h:126

Belle2::TRGGRLUnpackerStore::get_CDCNNL1_count
int get_CDCNNL1_count() const
m_CDCNNL1_count leaf
Definition: TRGGRLUnpackerStore.h:253

Belle2::TRGGRLUnpackerStore::m_phi_CDC
std::vector< bool > m_phi_CDC
m_phi_CDC map leaf
Definition: TRGGRLUnpackerStore.h:571

Belle2::TRGGRLUnpackerStore::set_b2b_1to3
void set_b2b_1to3(int b2b_1to3)
m_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:312

Belle2::TRGGRLUnpackerStore::m_b2b_1to5
int m_b2b_1to5
m_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:589

Belle2::TRGGRLUnpackerStore::set_slot64b_TOP_int_0
void set_slot64b_TOP_int_0(int slot64b_TOP_int_0)
m_slot64b_TOP_int_0 leaf
Definition: TRGGRLUnpackerStore.h:505

Belle2::TRGGRLUnpackerStore::set_N_track
void set_N_track(int N_track)
m_N_track leaf
Definition: TRGGRLUnpackerStore.h:302

Belle2::TRGGRLUnpackerStore::get_map_ST_int
int get_map_ST_int(int i) const
m_map_ST integer leaf
Definition: TRGGRLUnpackerStore.h:188

Belle2::TRGGRLUnpackerStore::get_revo_fam
int get_revo_fam() const
m_revo_fam leaf
Definition: TRGGRLUnpackerStore.h:225

Belle2::TRGGRLUnpackerStore::m_cc
int m_cc
m_cc leaf
Definition: TRGGRLUnpackerStore.h:597

Belle2::TRGGRLUnpackerStore::set_phi_i
void set_phi_i(int i, bool phi_i)
m_phi_i map leaf
Definition: TRGGRLUnpackerStore.h:300

Belle2::TRGGRLUnpackerStore::get_unamed
int get_unamed() const
m_unamed leaf
Definition: TRGGRLUnpackerStore.h:27

Belle2::TRGGRLUnpackerStore::set_TOPL1_count
void set_TOPL1_count(int TOPL1_count)
m_TOPL1_count leaf
Definition: TRGGRLUnpackerStore.h:511

Belle2::TRGGRLUnpackerStore::set_map_TSF0_int
void set_map_TSF0_int(int i, int map_TSF0_int)
m_map_TSF0 integer leaf
Definition: TRGGRLUnpackerStore.h:440

Belle2::TRGGRLUnpackerStore::set_map_TSF0
void set_map_TSF0(int i, bool map_TSF0)
m_map_TSF0 map leaf
Definition: TRGGRLUnpackerStore.h:456

Belle2::TRGGRLUnpackerStore::set_N_KLMmatch
void set_N_KLMmatch(int N_KLMmatch)
m_N_KLMmatch leaf
Definition: TRGGRLUnpackerStore.h:342

Belle2::TRGGRLUnpackerStore::set_N_g_1GeV
void set_N_g_1GeV(int i, int N_g_1GeV)
m_N_g_1GeV leaf
Definition: TRGGRLUnpackerStore.h:352

Belle2::TRGGRLUnpackerStore::set_t_ECL
void set_t_ECL(int i, int t_ECL)
m_t_ECL leaf
Definition: TRGGRLUnpackerStore.h:405

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf7
int get_wirecnt_tsf7() const
#wire hit in SL7
Definition: TRGGRLUnpackerStore.h:171

Belle2::TRGGRLUnpackerStore::get_map_TSF1_int
int get_map_TSF1_int(int i) const
m_map_TSF1 integer leaf
Definition: TRGGRLUnpackerStore.h:182

Belle2::TRGGRLUnpackerStore::m_opphem
std::vector< int > m_opphem
m_opphem leaf
Definition: TRGGRLUnpackerStore.h:621

Belle2::TRGGRLUnpackerStore::m_map_ST2_int
int m_map_ST2_int[2]
m_map_ST2 integer leaf
Definition: TRGGRLUnpackerStore.h:722

Belle2::TRGGRLUnpackerStore::get_TOPL1_count
int get_TOPL1_count() const
m_TOPL1_count leaf
Definition: TRGGRLUnpackerStore.h:247

Belle2::TRGGRLUnpackerStore::get_X_2
int get_X_2() const
m_X_2 leaf
Definition: TRGGRLUnpackerStore.h:215

Belle2::TRGGRLUnpackerStore::m_CDCL1_count
int m_CDCL1_count
m_CDCL1_count leaf
Definition: TRGGRLUnpackerStore.h:777

Belle2::TRGGRLUnpackerStore::set_CDCTOP_jitter
void set_CDCTOP_jitter(int CDCTOP_jitter)
m_CDCTOP_jitter leaf
Definition: TRGGRLUnpackerStore.h:356

Belle2::TRGGRLUnpackerStore::set_CDCECL_jitter
void set_CDCECL_jitter(int CDCECL_jitter)
m_CDCECL_jitter leaf
Definition: TRGGRLUnpackerStore.h:292

Belle2::TRGGRLUnpackerStore::m_N_g_1GeV
std::vector< int > m_N_g_1GeV
m_N_g_1GeV leaf
Definition: TRGGRLUnpackerStore.h:627

Belle2::TRGGRLUnpackerStore::m_X
int m_X
m_X leaf
Definition: TRGGRLUnpackerStore.h:741

Belle2::TRGGRLUnpackerStore::get_clk_ECL
int get_clk_ECL(int i) const
m_clk_ECL leaf
Definition: TRGGRLUnpackerStore.h:150

Belle2::TRGGRLUnpackerStore::m_CDC3D_jitter
int m_CDC3D_jitter
m_CDC3D_jitter leaf
Definition: TRGGRLUnpackerStore.h:649

Belle2::TRGGRLUnpackerStore::m_1GeV_ECL
std::vector< int > m_1GeV_ECL
m_1GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:684

Belle2::TRGGRLUnpackerStore::get_slot_CDC
bool get_slot_CDC(int i) const
m_slot_CDC map leaf
Definition: TRGGRLUnpackerStore.h:124

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf5
void set_wirecnt_tsf5(int wirecnt_tsf5)
#wire hit in SL5
Definition: TRGGRLUnpackerStore.h:431

Belle2::TRGGRLUnpackerStore::set_N_g_2GeV
void set_N_g_2GeV(int i, int N_g_2GeV)
m_N_g_2GeV leaf
Definition: TRGGRLUnpackerStore.h:354

Belle2::TRGGRLUnpackerStore::get_N_ST
int get_N_ST() const
m_N_ST leaf
Definition: TRGGRLUnpackerStore.h:53

Belle2::TRGGRLUnpackerStore::set_map_ST2_int
void set_map_ST2_int(int i, int map_ST2_int)
m_map_ST2 integer leaf
Definition: TRGGRLUnpackerStore.h:454

Belle2::TRGGRLUnpackerStore::get_evt
int get_evt() const
m_evt leafs
Definition: TRGGRLUnpackerStore.h:269

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf2
void set_wirecnt_tsf2(int wirecnt_tsf2)
#wire hit in SL2
Definition: TRGGRLUnpackerStore.h:425

Belle2::TRGGRLUnpackerStore::set_N_track_3D
void set_N_track_3D(int N_track_3D)
m_N_track_3D leaf
Definition: TRGGRLUnpackerStore.h:306

Belle2::TRGGRLUnpackerStore::get_map_TSF4_int
int get_map_TSF4_int(int i) const
m_map_TSF4 integer leaf
Definition: TRGGRLUnpackerStore.h:180

Belle2::TRGGRLUnpackerStore::m_coincidence_2DECL
int m_coincidence_2DECL
m_coincidence_2DECL leaf
Definition: TRGGRLUnpackerStore.h:669

Belle2::TRGGRLUnpackerStore::set_N_TOPmatch
void set_N_TOPmatch(int N_TOPmatch)
m_N_TOPmatch leaf
Definition: TRGGRLUnpackerStore.h:387

Belle2::TRGGRLUnpackerStore::m_CDCNN_jitter
int m_CDCNN_jitter
m_CDCNN_jitter leaf
Definition: TRGGRLUnpackerStore.h:651

Belle2::TRGGRLUnpackerStore::set_ECL_trg
void set_ECL_trg(int ECLtrg)
m_ECL_trg leaf
Definition: TRGGRLUnpackerStore.h:288

Belle2::TRGGRLUnpackerStore::m_charge_flag
int m_charge_flag
m_charge_flag leaf
Definition: TRGGRLUnpackerStore.h:793

Belle2::TRGGRLUnpackerStore::set_TOP_trg
void set_TOP_trg(int TOP_trg)
m_TOP_trg leaf
Definition: TRGGRLUnpackerStore.h:499

Belle2::TRGGRLUnpackerStore::set_b2b_1to7
void set_b2b_1to7(int b2b_1to7)
m_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:316

Belle2::TRGGRLUnpackerStore::m_sector_CDC_int
int m_sector_CDC_int
m_sector_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:613

Belle2::TRGGRLUnpackerStore::m_KLM_trg
int m_KLM_trg
m_KLM_trg leaf
Definition: TRGGRLUnpackerStore.h:601

Belle2::TRGGRLUnpackerStore::get_aaaa
int get_aaaa() const
m_aaaa leaf
Definition: TRGGRLUnpackerStore.h:259

Belle2::TRGGRLUnpackerStore::set_unamed2
void set_unamed2(int unamed2)
m_unamed2 leaf
Definition: TRGGRLUnpackerStore.h:392

Belle2::TRGGRLUnpackerStore::set_clk_ECL
void set_clk_ECL(int i, int clk_ECL)
m_clk_ECL leaf
Definition: TRGGRLUnpackerStore.h:411

Belle2::TRGGRLUnpackerStore::m_matched_2DECL
int m_matched_2DECL
m_matched_2DECL leaf
Definition: TRGGRLUnpackerStore.h:671

Belle2::TRGGRLUnpackerStore::set_CDCKLM_jitter
void set_CDCKLM_jitter(int CDCKLM_jitter)
m_CDCKLM_jitter leaf
Definition: TRGGRLUnpackerStore.h:330

Belle2::TRGGRLUnpackerStore::set_TSFL1_count
void set_TSFL1_count(int TSFL1_count)
m_TSFL1_count leaf
Definition: TRGGRLUnpackerStore.h:501

Belle2::TRGGRLUnpackerStore::set_ECL_trg_2
void set_ECL_trg_2(int ECL_trg_2)
m_ECL_trg_2 leaf
Definition: TRGGRLUnpackerStore.h:497

Belle2::TRGGRLUnpackerStore::get_map_ST2_int
int get_map_ST2_int(int i) const
m_map_ST2 integer leaf
Definition: TRGGRLUnpackerStore.h:190

Belle2::TRGGRLUnpackerStore::m_revoclk1
int m_revoclk1
m_revoclk1 leaf
Definition: TRGGRLUnpackerStore.h:789

Belle2::TRGGRLUnpackerStore::m_map_TSF0_int
int m_map_TSF0_int[2]
m_map_TSF0 integer leaf
Definition: TRGGRLUnpackerStore.h:708

Belle2::TRGGRLUnpackerStore::get_ECL_trg
int get_ECL_trg() const
m_ECL_trg leaf
Definition: TRGGRLUnpackerStore.h:31

Belle2::TRGGRLUnpackerStore::m_ECLL1_count
int m_ECLL1_count
m_ECLL1_count leaf
Definition: TRGGRLUnpackerStore.h:775

Belle2::TRGGRLUnpackerStore::m_tc_b2b_1to7
std::vector< int > m_tc_b2b_1to7
m_tc_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:643

Belle2::TRGGRLUnpackerStore::get_tc_b2b_1to3
int get_tc_b2b_1to3(int i) const
m_tc_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:115

Belle2::TRGGRLUnpackerStore::m_ECL_trg_1
int m_ECL_trg_1
m_ECL_trg_1 leaf
Definition: TRGGRLUnpackerStore.h:763

Belle2::TRGGRLUnpackerStore::m_map_TSF0
std::vector< bool > m_map_TSF0
m_map_TSF0 map leaf
Definition: TRGGRLUnpackerStore.h:724

Belle2::TRGGRLUnpackerStore::set_firmver
void set_firmver(int firmver)
m_firmver leafs
Definition: TRGGRLUnpackerStore.h:531

Belle2::TRGGRLUnpackerStore::set_sector_KLM
void set_sector_KLM(int i, bool sector_KLM)
m_sector_KLM map leaf
Definition: TRGGRLUnpackerStore.h:336

Belle2::TRGGRLUnpackerStore::set_N_track_cut
void set_N_track_cut(int N_track_cut)
m_N_track_cut leaf
Definition: TRGGRLUnpackerStore.h:304

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf4
void set_wirecnt_tsf4(int wirecnt_tsf4)
#wire hit in SL4
Definition: TRGGRLUnpackerStore.h:429

Belle2::TRGGRLUnpackerStore::set_sector_CDC_int
void set_sector_CDC_int(int sector_CDC_int)
m_sector_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:338

Belle2::TRGGRLUnpackerStore::set_c_b2b_1to3
void set_c_b2b_1to3(int i, int c_b2b_1to3)
m_c_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:364

Belle2::TRGGRLUnpackerStore::get_N_cluster_1
int get_N_cluster_1() const
m_N_cluster_1 leaf
Definition: TRGGRLUnpackerStore.h:221

Belle2::TRGGRLUnpackerStore::set_KLMCDC_jitter
void set_KLMCDC_jitter(int KLMCDC_jitter)
m_KLMCDC_jitter leaf
Definition: TRGGRLUnpackerStore.h:332

Belle2::TRGGRLUnpackerStore::get_tc_b2b_1to7
int get_tc_b2b_1to7(int i) const
m_tc_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:111

Belle2::TRGGRLUnpackerStore::m_theta_ECL
std::vector< int > m_theta_ECL
m_theta_ECL leaf
Definition: TRGGRLUnpackerStore.h:674

Belle2::TRGGRLUnpackerStore::set_charge_sum
void set_charge_sum(int charge_sum)
m_charge_sum leaf
Definition: TRGGRLUnpackerStore.h:527

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf1
int m_wirecnt_tsf1
#wire hit in SL1
Definition: TRGGRLUnpackerStore.h:691

Belle2::TRGGRLUnpackerStore::get_N_track_cut
int get_N_track_cut() const
m_N_track_cut leaf
Definition: TRGGRLUnpackerStore.h:47

Belle2::TRGGRLUnpackerStore::m_X_2
int m_X_2
m_X_2 leaf
Definition: TRGGRLUnpackerStore.h:747

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf3
int get_wirecnt_tsf3() const
#wire hit in SL3
Definition: TRGGRLUnpackerStore.h:163

Belle2::TRGGRLUnpackerStore::m_firmid
int m_firmid
m_firmid leafs
Definition: TRGGRLUnpackerStore.h:797

Belle2::TRGGRLUnpackerStore::get_b2ldly
int get_b2ldly() const
m_b2ldly leafs
Definition: TRGGRLUnpackerStore.h:275

Belle2::TRGGRLUnpackerStore::get_map_TSF1
bool get_map_TSF1(int i) const
m_map_TSF1 map leaf
Definition: TRGGRLUnpackerStore.h:198

Belle2::TRGGRLUnpackerStore::set_unamed0
void set_unamed0(int unamed0)
m_unamed0 leaf
Definition: TRGGRLUnpackerStore.h:324

Belle2::TRGGRLUnpackerStore::set_X_2
void set_X_2(int X_2)
m_X_2 leaf
Definition: TRGGRLUnpackerStore.h:479

Belle2::TRGGRLUnpackerStore::set_charge_flag
void set_charge_flag(int charge_flag)
m_charge_flag leaf
Definition: TRGGRLUnpackerStore.h:525

Belle2::TRGGRLUnpackerStore::set_CDC3DL1_count
void set_CDC3DL1_count(int CDC3DL1_count)
m_CDC3DL1_count leaf
Definition: TRGGRLUnpackerStore.h:515

Belle2::TRGGRLUnpackerStore::get_opening
int get_opening() const
m_opening leaf
Definition: TRGGRLUnpackerStore.h:63

Belle2::TRGGRLUnpackerStore::get_N_match_2GeV
int get_N_match_2GeV(int i) const
m_N_match_2GeV leaf
Definition: TRGGRLUnpackerStore.h:91

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf8
int m_wirecnt_tsf8
#wire hit in SL8
Definition: TRGGRLUnpackerStore.h:705

Belle2::TRGGRLUnpackerStore::get_X_0
int get_X_0() const
m_X_0 leaf
Definition: TRGGRLUnpackerStore.h:211

Belle2::TRGGRLUnpackerStore::m_2GeV_ECL
std::vector< int > m_2GeV_ECL
m_2GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:686

Belle2::TRGGRLUnpackerStore::m_map_ST2
std::vector< bool > m_map_ST2
m_map_ST2 map leaf
Definition: TRGGRLUnpackerStore.h:738

Belle2::TRGGRLUnpackerStore::get_KLM_trg
int get_KLM_trg() const
m_KLM_trg leaf
Definition: TRGGRLUnpackerStore.h:69

Belle2::TRGGRLUnpackerStore::m_CDCECL_jitter
int m_CDCECL_jitter
m_CDCECL_jitter leaf
Definition: TRGGRLUnpackerStore.h:567

Belle2::TRGGRLUnpackerStore::set_slot64b_TOP_int_1
void set_slot64b_TOP_int_1(int slot64b_TOP_int_1)
m_slot64b_TOP_int_1 leaf
Definition: TRGGRLUnpackerStore.h:503

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf6
int m_wirecnt_tsf6
#wire hit in SL6
Definition: TRGGRLUnpackerStore.h:701

Belle2::TRGGRLUnpackerStore::m_slot64b_TOP_int_1
int m_slot64b_TOP_int_1
m_slot64b_TOP_int_1 leaf
Definition: TRGGRLUnpackerStore.h:771

Belle2::TRGGRLUnpackerStore::get_maxrvc
int get_maxrvc() const
m_maxrvc leafs
Definition: TRGGRLUnpackerStore.h:277

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf0
void set_wirecnt_tsf0(int wirecnt_tsf0)
#wire hit in SL0
Definition: TRGGRLUnpackerStore.h:421

Belle2::TRGGRLUnpackerStore::set_map_TSF3
void set_map_TSF3(int i, bool map_TSF3)
m_map_TSF3 map leaf
Definition: TRGGRLUnpackerStore.h:464

Belle2::TRGGRLUnpackerStore::get_phi_ECL
int get_phi_ECL(int i) const
m_phi_ECL leaf
Definition: TRGGRLUnpackerStore.h:144

Belle2::TRGGRLUnpackerStore::m_aaaa
int m_aaaa
m_aaaa leaf
Definition: TRGGRLUnpackerStore.h:791

Belle2::TRGGRLUnpackerStore::set_1GeV_ECL
void set_1GeV_ECL(int i, int c1GeV_ECL)
m_1GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:414

Belle2::TRGGRLUnpackerStore::set_tc_b2b_1to7
void set_tc_b2b_1to7(int i, int tc_b2b_1to7)
m_tc_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:368

Belle2::TRGGRLUnpackerStore::set_unamed1
void set_unamed1(int unamed1)
m_unamed1 leaf
Definition: TRGGRLUnpackerStore.h:390

Belle2::TRGGRLUnpackerStore::get_unamed3
int get_unamed3() const
m_unamed3 leaf
Definition: TRGGRLUnpackerStore.h:255

Belle2::TRGGRLUnpackerStore::m_map_veto_int
int m_map_veto_int[2]
m_map_veto integer leaf
Definition: TRGGRLUnpackerStore.h:718

Belle2::TRGGRLUnpackerStore::get_slot64b_TOP_int_0
int get_slot64b_TOP_int_0() const
m_slot64b_TOP_int_0 leaf
Definition: TRGGRLUnpackerStore.h:241

Belle2::TRGGRLUnpackerStore::m_N_cluster_0
int m_N_cluster_0
m_N_cluster_0 leaf
Definition: TRGGRLUnpackerStore.h:751

Belle2::TRGGRLUnpackerStore::set_phi_i_int
void set_phi_i_int(int i, int phi_i_int)
m_phi_i integer leaf
Definition: TRGGRLUnpackerStore.h:298

Belle2::TRGGRLUnpackerStore::get_sector_KLM_int
int get_sector_KLM_int() const
m_sector_KLM integer leaf
Definition: TRGGRLUnpackerStore.h:77

Belle2::TRGGRLUnpackerStore::get_map_ST2
bool get_map_ST2(int i) const
m_map_ST2 map leaf
Definition: TRGGRLUnpackerStore.h:206

Belle2::TRGGRLUnpackerStore::m_matched_2DKLM
int m_matched_2DKLM
m_matched_2DKLM leaf
Definition: TRGGRLUnpackerStore.h:603

Belle2::TRGGRLUnpackerStore::set_tc_b2b_1to5
void set_tc_b2b_1to5(int i, int tc_b2b_1to5)
m_tc_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:370

Belle2::TRGGRLUnpackerStore::get_CDCKLM_jitter
int get_CDCKLM_jitter() const
m_CDCKLM_jitter leaf
Definition: TRGGRLUnpackerStore.h:73

Belle2::TRGGRLUnpackerStore::get_c_b2b_1to5
int get_c_b2b_1to5(int i) const
m_c_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:105

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf5
int m_wirecnt_tsf5
#wire hit in SL5
Definition: TRGGRLUnpackerStore.h:699

Belle2::TRGGRLUnpackerStore::get_CDCECL_jitter
int get_CDCECL_jitter() const
m_CDCECL_jitter leaf
Definition: TRGGRLUnpackerStore.h:35

Belle2::TRGGRLUnpackerStore::get_unamed1
int get_unamed1() const
m_unamed1 leaf
Definition: TRGGRLUnpackerStore.h:133

Belle2::TRGGRLUnpackerStore::set_ECL_timing
void set_ECL_timing(int ECL_timing)
m_ECL_timing leaf
Definition: TRGGRLUnpackerStore.h:491

Belle2::TRGGRLUnpackerStore::m_N_ST
int m_N_ST
m_N_ST leaf
Definition: TRGGRLUnpackerStore.h:585

Belle2::TRGGRLUnpackerStore::set_c_b2b_1to7
void set_c_b2b_1to7(int i, int c_b2b_1to7)
m_c_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:360

Belle2::TRGGRLUnpackerStore::m_map_TSF2_int
int m_map_TSF2_int[2]
m_map_TSF2 integer leaf
Definition: TRGGRLUnpackerStore.h:710

Belle2::TRGGRLUnpackerStore::set_slot_TOP_int
void set_slot_TOP_int(int slot_TOP_int)
m_slot_TOP integer leaf
Definition: TRGGRLUnpackerStore.h:383

Belle2::TRGGRLUnpackerStore::get_CDC3D_jitter
int get_CDC3D_jitter() const
m_CDC3D_jitter leaf
Definition: TRGGRLUnpackerStore.h:117

Belle2::TRGGRLUnpackerStore::m_N_track_cut
int m_N_track_cut
m_N_track_cut leaf
Definition: TRGGRLUnpackerStore.h:579

Belle2::TRGGRLUnpackerStore::set_wirecnt_tsf1
void set_wirecnt_tsf1(int wirecnt_tsf1)
#wire hit in SL1
Definition: TRGGRLUnpackerStore.h:423

Belle2::TRGGRLUnpackerStore::get_map_veto_int
int get_map_veto_int(int i) const
m_map_veto integer leaf
Definition: TRGGRLUnpackerStore.h:186

Belle2::TRGGRLUnpackerStore::m_slot_TOP
std::vector< bool > m_slot_TOP
m_slot_TOP map leaf
Definition: TRGGRLUnpackerStore.h:660

Belle2::TRGGRLUnpackerStore::get_map_ST
bool get_map_ST(int i) const
m_map_ST map leaf
Definition: TRGGRLUnpackerStore.h:204

Belle2::TRGGRLUnpackerStore::set_N_cluster
void set_N_cluster(int N_cluster)
m_N_cluster leaf
Definition: TRGGRLUnpackerStore.h:481

Belle2::TRGGRLUnpackerStore::set_tc_b2b_1to3
void set_tc_b2b_1to3(int i, int tc_b2b_1to3)
m_tc_b2b_1to3 leaf
Definition: TRGGRLUnpackerStore.h:372

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf1
int get_wirecnt_tsf1() const
#wire hit in SL1
Definition: TRGGRLUnpackerStore.h:159

Belle2::TRGGRLUnpackerStore::set_coml1
void set_coml1(int coml1)
m_coml1 leafs
Definition: TRGGRLUnpackerStore.h:537

Belle2::TRGGRLUnpackerStore::set_map_veto_int
void set_map_veto_int(int i, int map_veto_int)
m_map_veto integer leaf
Definition: TRGGRLUnpackerStore.h:450

Belle2::TRGGRLUnpackerStore::ClassDef
ClassDef(TRGGRLUnpackerStore, 3)
the class title

Belle2::TRGGRLUnpackerStore::set_N_cluster_1
void set_N_cluster_1(int N_cluster_1)
m_N_cluster_1 leaf
Definition: TRGGRLUnpackerStore.h:485

Belle2::TRGGRLUnpackerStore::set_b2b_1to5
void set_b2b_1to5(int b2b_1to5)
m_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:314

Belle2::TRGGRLUnpackerStore::set_X_1
void set_X_1(int X_1)
m_X_1 leaf
Definition: TRGGRLUnpackerStore.h:477

Belle2::TRGGRLUnpackerStore::m_map_veto
std::vector< bool > m_map_veto
m_map_veto map leaf
Definition: TRGGRLUnpackerStore.h:734

Belle2::TRGGRLUnpackerStore::set_N_cluster_2
void set_N_cluster_2(int N_cluster_2)
m_N_cluster_2 leaf
Definition: TRGGRLUnpackerStore.h:487

Belle2::TRGGRLUnpackerStore::get_N_cluster
int get_N_cluster() const
m_N_cluster leaf
Definition: TRGGRLUnpackerStore.h:217

Belle2::TRGGRLUnpackerStore::set_N_ST
void set_N_ST(int N_ST)
m_N_ST leaf
Definition: TRGGRLUnpackerStore.h:310

Belle2::TRGGRLUnpackerStore::get_KLML1_count
int get_KLML1_count() const
m_KLML1_count leaf
Definition: TRGGRLUnpackerStore.h:249

Belle2::TRGGRLUnpackerStore::get_CDC3DL1_count
int get_CDC3DL1_count() const
m_CDC3DL1_count leaf
Definition: TRGGRLUnpackerStore.h:251

Belle2::TRGGRLUnpackerStore::set_slot_CDC_int
void set_slot_CDC_int(int slot_CDC_int)
m_slot_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:379

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf5
int get_wirecnt_tsf5() const
#wire hit in SL5
Definition: TRGGRLUnpackerStore.h:167

Belle2::TRGGRLUnpackerStore::m_clk_ECL
std::vector< int > m_clk_ECL
m_clk_ECL leaf
Definition: TRGGRLUnpackerStore.h:682

Belle2::TRGGRLUnpackerStore::set_map_veto
void set_map_veto(int i, bool map_veto)
m_map_veto map leaf
Definition: TRGGRLUnpackerStore.h:466

Belle2::TRGGRLUnpackerStore::get_cc
int get_cc() const
m_cc leaf
Definition: TRGGRLUnpackerStore.h:65

Belle2::TRGGRLUnpackerStore::m_X_1
int m_X_1
m_X_1 leaf
Definition: TRGGRLUnpackerStore.h:745

Belle2::TRGGRLUnpackerStore::set_maxrvc
void set_maxrvc(int maxrvc)
m_maxrvc leafs
Definition: TRGGRLUnpackerStore.h:541

Belle2::TRGGRLUnpackerStore::set_revoclk
void set_revoclk(int revoclk)
m_revoclk leaf
Definition: TRGGRLUnpackerStore.h:286

Belle2::TRGGRLUnpackerStore::get_sector_CDC
bool get_sector_CDC(int i) const
m_sector_CDC map
Definition: TRGGRLUnpackerStore.h:83

Belle2::TRGGRLUnpackerStore::get_b2b_1to7
int get_b2b_1to7() const
m_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:59

Belle2::TRGGRLUnpackerStore::set_phi_CDC_int
void set_phi_CDC_int(int i, int phi_CDC_int)
m_phi_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:294

Belle2::TRGGRLUnpackerStore::set_matched_2DECL
void set_matched_2DECL(int matched_2DECL)
m_matched_2DECL leaf
Definition: TRGGRLUnpackerStore.h:396

Belle2::TRGGRLUnpackerStore::get_N_match
int get_N_match(int i) const
m_N_match leaf
Definition: TRGGRLUnpackerStore.h:93

Belle2::TRGGRLUnpackerStore::m_N_cluster_1
int m_N_cluster_1
m_N_cluster_1 leaf
Definition: TRGGRLUnpackerStore.h:753

Belle2::TRGGRLUnpackerStore::get_revoclk1
int get_revoclk1() const
m_revoclk1 leaf
Definition: TRGGRLUnpackerStore.h:257

Belle2::TRGGRLUnpackerStore::set_opphem
void set_opphem(int i, int opphem)
m_opphem leaf
Definition: TRGGRLUnpackerStore.h:346

Belle2::TRGGRLUnpackerStore::set_matched_2DKLM
void set_matched_2DKLM(int matched_2DKLM)
m_matched_2DKLM leaf
Definition: TRGGRLUnpackerStore.h:328

Belle2::TRGGRLUnpackerStore::set_CDCNN_jitter
void set_CDCNN_jitter(int CDCNN_jitter)
m_CDCNN_jitter leaf
Definition: TRGGRLUnpackerStore.h:376

Belle2::TRGGRLUnpackerStore::get_revoclk
int get_revoclk() const
m_revoclk leaf
Definition: TRGGRLUnpackerStore.h:29

Belle2::TRGGRLUnpackerStore::get_theta_ECL
int get_theta_ECL(int i) const
m_theta_ECL leaf
Definition: TRGGRLUnpackerStore.h:142

Belle2::TRGGRLUnpackerStore::m_ECL_trg
int m_ECL_trg
m_ECL_trg leaf
Definition: TRGGRLUnpackerStore.h:563

Belle2::TRGGRLUnpackerStore::m_ECL_trg_2
int m_ECL_trg_2
m_ECL_trg_2 leaf
Definition: TRGGRLUnpackerStore.h:765

Belle2::TRGGRLUnpackerStore::m_samehem
std::vector< int > m_samehem
m_samehem leaf
Definition: TRGGRLUnpackerStore.h:619

Belle2::TRGGRLUnpackerStore::set_clk
void set_clk(int clk)
m_clk leafs
Definition: TRGGRLUnpackerStore.h:535

Belle2::TRGGRLUnpackerStore::get_E_ECL
int get_E_ECL(int i) const
m_E_ECL leaf
Definition: TRGGRLUnpackerStore.h:148

Belle2::TRGGRLUnpackerStore::get_ECL_timing
int get_ECL_timing() const
m_ECL_timing leaf
Definition: TRGGRLUnpackerStore.h:227

Belle2::TRGGRLUnpackerStore::get_1GeV_ECL
int get_1GeV_ECL(int i) const
m_1GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:152

Belle2::TRGGRLUnpackerStore::m_map_TSF1_int
int m_map_TSF1_int[2]
m_map_TSF1 integer leaf
Definition: TRGGRLUnpackerStore.h:714

Belle2::TRGGRLUnpackerStore::m_dddd
int m_dddd
m_dddd leaf
Definition: TRGGRLUnpackerStore.h:557

Belle2::TRGGRLUnpackerStore::m_firmver
int m_firmver
m_firmver leafs
Definition: TRGGRLUnpackerStore.h:799

Belle2::TRGGRLUnpackerStore::get_firmid
int get_firmid() const
m_firmid leafs
Definition: TRGGRLUnpackerStore.h:265

Belle2::TRGGRLUnpackerStore::m_TSFL1_count
int m_TSFL1_count
m_TSFL1_count leaf
Definition: TRGGRLUnpackerStore.h:769

Belle2::TRGGRLUnpackerStore::m_charge_sum
int m_charge_sum
m_charge_sum leaf
Definition: TRGGRLUnpackerStore.h:795

Belle2::TRGGRLUnpackerStore::m_b2ldly
int m_b2ldly
m_b2ldly leafs
Definition: TRGGRLUnpackerStore.h:807

Belle2::TRGGRLUnpackerStore::get_c_b2b_1to7
int get_c_b2b_1to7(int i) const
m_c_b2b_1to7 leaf
Definition: TRGGRLUnpackerStore.h:103

Belle2::TRGGRLUnpackerStore::m_slot64b_TOP_int_0
int m_slot64b_TOP_int_0
m_slot64b_TOP_int_0 leaf
Definition: TRGGRLUnpackerStore.h:773

Belle2::TRGGRLUnpackerStore::m_map_TSF3
std::vector< bool > m_map_TSF3
m_map_TSF3 map leaf
Definition: TRGGRLUnpackerStore.h:732

Belle2::TRGGRLUnpackerStore::m_TOPL1_count
int m_TOPL1_count
m_TOPL1_count leaf
Definition: TRGGRLUnpackerStore.h:779

Belle2::TRGGRLUnpackerStore::set_c_b2b_1to9
void set_c_b2b_1to9(int i, int c_b2b_1to9)
m_c_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:358

Belle2::TRGGRLUnpackerStore::set_opening
void set_opening(int opening)
m_opening leaf
Definition: TRGGRLUnpackerStore.h:320

Belle2::TRGGRLUnpackerStore::get_CDCTOP_jitter
int get_CDCTOP_jitter() const
m_CDCTOP_jitter leaf
Definition: TRGGRLUnpackerStore.h:99

Belle2::TRGGRLUnpackerStore::m_N_track_NN
int m_N_track_NN
m_N_track_NN leaf
Definition: TRGGRLUnpackerStore.h:583

Belle2::TRGGRLUnpackerStore::get_slot_CDC_int
int get_slot_CDC_int() const
m_slot_CDC integer leaf
Definition: TRGGRLUnpackerStore.h:122

Belle2::TRGGRLUnpackerStore::get_tc_b2b_1to5
int get_tc_b2b_1to5(int i) const
m_tc_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:113

Belle2::TRGGRLUnpackerStore::set_aaaa
void set_aaaa(int aaaa)
m_aaaa leaf
Definition: TRGGRLUnpackerStore.h:523

Belle2::TRGGRLUnpackerStore::m_opening
int m_opening
m_opening leaf
Definition: TRGGRLUnpackerStore.h:595

Belle2::TRGGRLUnpackerStore::set_b2b_1to9
void set_b2b_1to9(int b2b_1to9)
m_b2b_1to9 leaf
Definition: TRGGRLUnpackerStore.h:318

Belle2::TRGGRLUnpackerStore::m_revo_fam
int m_revo_fam
m_revo_fam leaf
Definition: TRGGRLUnpackerStore.h:757

Belle2::TRGGRLUnpackerStore::get_ECL_trg_2
int get_ECL_trg_2() const
m_ECL_trg_2 leaf
Definition: TRGGRLUnpackerStore.h:233

Belle2::TRGGRLUnpackerStore::m_X_0
int m_X_0
m_X_0 leaf
Definition: TRGGRLUnpackerStore.h:743

Belle2::TRGGRLUnpackerStore::set_ECLL1_count
void set_ECLL1_count(int ECLL1_count)
m_ECLL1_count leaf
Definition: TRGGRLUnpackerStore.h:507

Belle2::TRGGRLUnpackerStore::get_wirecnt_tsf0
int get_wirecnt_tsf0() const
#wire hit in SL0
Definition: TRGGRLUnpackerStore.h:157

Belle2::TRGGRLUnpackerStore::get_N_track_NN
int get_N_track_NN() const
m_N_track_NN leaf
Definition: TRGGRLUnpackerStore.h:51

Belle2::TRGGRLUnpackerStore::set_map_TSF2_int
void set_map_TSF2_int(int i, int map_TSF2_int)
m_map_TSF2 integer leaf
Definition: TRGGRLUnpackerStore.h:442

Belle2::TRGGRLUnpackerStore::m_map_TSF4_int
int m_map_TSF4_int[2]
m_map_TSF4 integer leaf
Definition: TRGGRLUnpackerStore.h:712

Belle2::TRGGRLUnpackerStore::set_c_b2b_1to5
void set_c_b2b_1to5(int i, int c_b2b_1to5)
m_c_b2b_1to5 leaf
Definition: TRGGRLUnpackerStore.h:362

Belle2::TRGGRLUnpackerStore::m_map_TSF4
std::vector< bool > m_map_TSF4
m_map_TSF4 map leaf
Definition: TRGGRLUnpackerStore.h:728

Belle2::TRGGRLUnpackerStore::get_concidence_2DECL
int get_concidence_2DECL() const
m_coincidence_2DECL leaf
Definition: TRGGRLUnpackerStore.h:137

Belle2::TRGGRLUnpackerStore::m_N_cluster
int m_N_cluster
m_N_cluster leaf
Definition: TRGGRLUnpackerStore.h:749

Belle2::TRGGRLUnpackerStore::m_N_cluster_2
int m_N_cluster_2
m_N_cluster_2 leaf
Definition: TRGGRLUnpackerStore.h:755

Belle2::TRGGRLUnpackerStore::set_2GeV_ECL
void set_2GeV_ECL(int i, int c2GeV_ECL)
m_2GeV_flag_ECL leaf
Definition: TRGGRLUnpackerStore.h:417

Belle2::TRGGRLUnpackerStore::set_dddd
void set_dddd(int dddd)
m_dddd leaf
Definition: TRGGRLUnpackerStore.h:282

Belle2::TRGGRLUnpackerStore::get_N_cluster_2
int get_N_cluster_2() const
m_N_cluster_2 leaf
Definition: TRGGRLUnpackerStore.h:223

Belle2::TRGGRLUnpackerStore::m_N_match
std::vector< int > m_N_match
m_N_match leaf
Definition: TRGGRLUnpackerStore.h:625

Belle2::TRGGRLUnpackerStore::get_sector_KLM
bool get_sector_KLM(int i) const
m_sector_KLM map leaf
Definition: TRGGRLUnpackerStore.h:79

Belle2::TRGGRLUnpackerStore::m_wirecnt_tsf0
int m_wirecnt_tsf0
#wire hit in SL0
Definition: TRGGRLUnpackerStore.h:689

Belle2
Abstract base class for different kinds of events.
Definition: MillepedeAlgorithm.h:17