release-05-01-25/doxygen/TRGTOPUnpackerStore_8h_source.html

//-----------------------------------------------------------

// $Id$

//-----------------------------------------------------------

// Filename : TRGTOPUnpackerStore.h

// Section  : TRG TOP

// Owner    : Tong Pang  Vladimir Savinov

// Email    : top16@pitt.edu

//-----------------------------------------------------------

// Description : A class to represent TOP L1 combined timing decision

//-----------------------------------------------------------

// $Log$

//-----------------------------------------------------------

#ifndef TRGTOPUNPACKERSTORE_H

#define TRGTOPUNPACKERSTORE_H


#include <TObject.h>


#include <vector>


#include <trg/top/dataobjects/TRGTOPSlotTiming.h>


namespace Belle2 {

  class TRGTOPUnpackerStore : public TObject {


  public:


    // Empty constructor

    // Recommended for ROOT IO

    TRGTOPUnpackerStore()

    {

    }


    explicit TRGTOPUnpackerStore(

      int eventIdL1

    )

    {

      m_eventIdL1                       = eventIdL1;

    }


    TRGTOPUnpackerStore(

      int eventIdL1,

      int eventIdTOP,

      int windowIdTOP,

      int rvcB2L,

      int rvcWindow,

      int rvcTopTimingDecisionPrev,

      int rvcTopTimingDecisionNow,

      int rvcTopTimingDecisionNowGdl,

      int combinedTimingTop,

      int nSlotsCombinedTimingTop,

      int combinedTimingTopResidual,

      int nErrorsMinor,

      int nErrorsMajor,

      int trigType,

      int nHitSum,

      int logLSum,

      int logLVar,

      int timingVar

    )

    {

      m_eventIdL1                       = eventIdL1;

      m_eventIdTOP                      = eventIdTOP;

      m_windowIdTOP                     = windowIdTOP;

      m_rvcB2L                          = rvcB2L;

      m_rvcWindow                       = rvcWindow;

      m_rvcTopTimingDecisionPrev        = rvcTopTimingDecisionPrev;

      m_rvcTopTimingDecisionNow         = rvcTopTimingDecisionNow;

      m_rvcTopTimingDecisionNowGdl            = rvcTopTimingDecisionNowGdl;

      m_combinedTimingTop               = combinedTimingTop;

      m_nSlotsCombinedTimingTop         = nSlotsCombinedTimingTop;

      m_combinedTimingTopResidual       = combinedTimingTopResidual;

      m_nErrorsMinor                    = nErrorsMinor;

      m_nErrorsMajor                    = nErrorsMajor;

      m_trigType                        = trigType;

      m_nHitSum                         = nHitSum;

      m_logLSum                         = logLSum;

      m_logLVar                         = logLVar;

      m_timingVar                         = timingVar;

    }


    ~TRGTOPUnpackerStore() {}


    int getEventIdL1() const { return m_eventIdL1;}

    int getEventIdTOP() const { return m_eventIdTOP;}

    int getWindowIdTOP() const { return m_windowIdTOP;}

    int getRvcB2L() const { return m_rvcB2L;}

    int getRvcWindow() const { return m_rvcWindow;}

    int getRvcTopTimingDecisionPrev() const { return m_rvcTopTimingDecisionPrev;}

    int getRvcTopTimingDecisionNow() const { return m_rvcTopTimingDecisionNow;}

    int getRvcTopTimingDecisionNowGdl() const { return m_rvcTopTimingDecisionNowGdl;}

    int getCombinedTimingTop() const { return m_combinedTimingTop;}

    int getNSlotsCombinedTimingTop() const { return m_nSlotsCombinedTimingTop;}

    int getCombinedTimingTopResidual() const { return m_combinedTimingTopResidual;}

    int getNErrorsMinor() const { return m_nErrorsMinor;}

    int getNErrorsMajor() const { return m_nErrorsMajor;}

    int getTrigType() const { return m_trigType;}

    int getNHitSum() const { return m_nHitSum;}

    int getLogLSum() const { return m_logLSum;}

    int getLogLVar() const { return m_logLVar;}

    int getTimingVar() const { return m_timingVar;}

    //int get() const { return m_;}


    //Need namespace qualifier because ROOT CINT has troubles otherwise

    const std::vector<Belle2::TRGTOPSlotTiming> getSlotTimingDecisions() { return m_slotTimingDecisions; }


    void setEventIdL1(int eventIdL1);

    void setEventIdTOP(int eventIdTOP);

    void setWindowIdTOP(int windowIdTOP);

    void setRvcB2L(int rvcB2L);

    void setRvcWindow(int rvcWindow);

    void setRvcTopTimingDecisionPrev(int rvcTopTimingDecisionPrev);

    void setRvcTopTimingDecisionNow(int rvcTopTimingDecisionNow);

    void setRvcTopTimingDecisionNowGdl(int rvcTopTimingDecisionNowGdl);

    void setCombinedTimingTop(int combinedTimingTop);

    void setNSlotsCombinedTimingTop(int nSlotsCombinedTimingTop);

    void setCombinedTimingTopResidual(int combinedTimingTopResidual);

    void setNErrorsMinor(int nErrorsMinor);

    void setNErrorsMajor(int nErrorsMajor);

    void setTrigType(int trigType);

    void setNHitSum(int nHitSum);

    void setLogLSum(int logLSum);

    void setLogLVar(int logLVar);

    void setTimingVar(int timingVar);

    //void set(int );


    void setSlotTimingDecision(TRGTOPSlotTiming slotTiming);


  private:


    int m_eventIdL1;

    int m_eventIdTOP;

    int m_windowIdTOP;

    int m_rvcB2L;

    int m_rvcWindow;

    int m_rvcTopTimingDecisionPrev;

    int m_rvcTopTimingDecisionNow;

    int m_rvcTopTimingDecisionNowGdl;

    int m_combinedTimingTop;

    int m_nSlotsCombinedTimingTop;

    int m_combinedTimingTopResidual;

    int m_nErrorsMinor;

    int m_nErrorsMajor;

    int m_trigType;

    int m_nHitSum;

    int m_logLSum;

    int m_logLVar;

    int m_timingVar;


    std::vector<TRGTOPSlotTiming> m_slotTimingDecisions;

    ClassDef(TRGTOPUnpackerStore, 2);


  };


} //end namespace Belle2


#endif