release-08-00-10/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_wire_tsf0() const {return m_wire_tsf0;}

     int get_wire_tsf1() const {return m_wire_tsf1;}

     int get_wire_tsf2() const {return m_wire_tsf2;}

     int get_wire_tsf3() const {return m_wire_tsf3;}

     int get_wire_tsf4() const {return m_wire_tsf4;}


     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_wire_tsf0(int wire_tsf0) { m_wire_tsf0 = wire_tsf0; }

     void set_wire_tsf1(int wire_tsf1) { m_wire_tsf1 = wire_tsf1; }

     void set_wire_tsf2(int wire_tsf2) { m_wire_tsf2 = wire_tsf2; }

     void set_wire_tsf3(int wire_tsf3) { m_wire_tsf3 = wire_tsf3; }

     void set_wire_tsf4(int wire_tsf4) { m_wire_tsf4 = wire_tsf4; }


     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_wire_tsf0;

     int m_wire_tsf2;

     int m_wire_tsf4;

     int m_wire_tsf1;

     int m_wire_tsf3;


     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, 2);


   };


 } // end namespace Belle2


 #endif

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

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

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

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:259

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

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:253

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

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

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

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

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

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::m_wire_tsf4
int m_wire_tsf4
#wire hit in SL4
Definition: TRGGRLUnpackerStore.h:677

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:366

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

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

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

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:446

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:527

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

Belle2::TRGGRLUnpackerStore::m_wire_tsf0
int m_wire_tsf0
#wire hit in SL0
Definition: TRGGRLUnpackerStore.h:673

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

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

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

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:373

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:436

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

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:223

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:737

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

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

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

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

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:591

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

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:779

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::set_wire_tsf0
void set_wire_tsf0(int wire_tsf0)
#wire hit in SL0
Definition: TRGGRLUnpackerStore.h:413

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:358

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

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:170

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

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:629

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

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

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

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

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

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

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:595

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::m_wire_tsf1
int m_wire_tsf1
#wire hit in SL1
Definition: TRGGRLUnpackerStore.h:679

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:497

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:430

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

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

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

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

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

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:340

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

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

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

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

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

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

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

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

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:457

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

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

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

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

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

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:265

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

Belle2::TRGGRLUnpackerStore::set_wire_tsf4
void set_wire_tsf4(int wire_tsf4)
#wire hit in SL4
Definition: TRGGRLUnpackerStore.h:421

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:631

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

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

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

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

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:662

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

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

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

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

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:696

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

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:184

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

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

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::set_evt
void set_evt(int evt)
m_evt leafs
Definition: TRGGRLUnpackerStore.h:517

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

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

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:176

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

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

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

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:757

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

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

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

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

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:432

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:428

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

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

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:245

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

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

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

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:489

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

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

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

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

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

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:495

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:424

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

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

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:344

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

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

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

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

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

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

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

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

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

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

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

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:633

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

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

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:346

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:438

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::set_wire_tsf2
void set_wire_tsf2(int wire_tsf2)
#wire hit in SL2
Definition: TRGGRLUnpackerStore.h:417

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:751

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

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:739

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::m_wire_tsf2
int m_wire_tsf2
#wire hit in SL2
Definition: TRGGRLUnpackerStore.h:675

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:356

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

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

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:658

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

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:723

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

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

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

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

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

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

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

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

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::get_X_0
int get_X_0() const
m_X_0 leaf
Definition: TRGGRLUnpackerStore.h:203

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

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

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:551

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:487

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

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

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

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:767

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

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:360

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

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

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

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

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

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:290

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:198

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

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:362

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::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:475

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

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:352

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

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

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:563

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

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

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

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

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:364

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

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:434

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

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

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

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

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

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

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

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

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

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

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

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

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:721

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

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

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:286

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

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

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:729

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

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

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

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

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:547

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

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

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

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:219

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:690

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

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

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

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

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

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

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:749

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

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

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:350

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

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:567

Belle2::TRGGRLUnpackerStore::set_wire_tsf3
void set_wire_tsf3(int wire_tsf3)
#wire hit in SL3
Definition: TRGGRLUnpackerStore.h:419

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:507

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

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

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

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

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

Belle2::TRGGRLUnpackerStore::m_wire_tsf3
int m_wire_tsf3
#wire hit in SL3
Definition: TRGGRLUnpackerStore.h:681

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

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:426

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

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:354

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

Belle2::TRGGRLUnpackerStore::set_wire_tsf1
void set_wire_tsf1(int wire_tsf1)
#wire hit in SL1
Definition: TRGGRLUnpackerStore.h:415

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:725

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

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

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

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

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

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

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