#ifndef TMCMBank_hxx_seen
#define TMCMBank_hxx_seen
// $Id: IMCMBank.hxx,v 1.4 2010/01/16 13:42:59 mcgrew Exp $
//


#include <IMidasBank.hxx>

#define TMCM_BANK_TITLE "Master and slave clock module (MCM, SCM) event blocks"

namespace COMET {
    class IMCMBank;
};

/// This is the simple <em>Access Class</em> for the master clock 
/// module and the slave clock module (both have exactly the same 
/// format).  It provides getters for the data.
///
/// For an introduction to this and other <em>Access Classes</em> please see 
/// \ref oaRawEvent

class COMET::IMCMBank: public COMET::IMidasBank {

public:
    IMCMBank();
    explicit IMCMBank(const ULong64_t *bank,
         const char* title = TMCM_BANK_TITLE);
    virtual ~IMCMBank();

    /// Print contents to COMETLog
    void Print(const Option_t* opt = "") const;

    /// The sets fields in the raw data header.
    virtual Bool_t IsContextSetter() const  {return true;}

    /// Fill fields in the raw data header.
    virtual void SetContext(COMET::IRawDataHeader& header) const;

    /// Getters for each word in the MCM block by name
    /// quix_packet(0)<=mcm_trigger_word(31 downto 0);
    /// quix_packet(1)<=mcm_trigger_word(63 downto 32);
    ULong64_t GetTriggerWord() const {
        if (1 < this->GetSize32()) return *(this->GetData() + 0);
        else return 0;                                           
    }

    /// quix_packet(2)<=unix_time_trig;
    UInt_t GetUnixTimeTrig() const {
        if (2 < this->GetSize32()) return *(this->GetData32() + 2);
        else return 0;                                           
    }

    /// quix_packet(3)<=unix_time_ssec_trig;   (10ns cycles)
    UInt_t GetUnixTimeSSecTrig() const {
        if (3 < this->GetSize32()) return *(this->GetData32() + 3);
        else return 0;                                           
    }

    /// quix_packet(4)<=event_time;
    UInt_t GetEventTime() const {
        if (4 < this->GetSize32()) return *(this->GetData32() + 4);
        else return 0;                                           }

    /// quix_packet(5)<=trigger_sep;
    UInt_t GetTriggerSep() const {
        if (5 < this->GetSize32()) return *(this->GetData32() + 5);
        else return 0;                                           }

    /// quix_packet(6)<=time_betw_events;
    UInt_t GetTimeBetwEvent() const {
        if (6 < this->GetSize32()) return *(this->GetData32() + 6);
        else return 0;                                           }

    /// quix_packet(7)<=x"00000" & "000" & addrb;  --ignore
    UInt_t GetAddrBIgnore() const {
        if (7 < this->GetSize32()) return *(this->GetData32() + 7);
        else return 0;                                           }

    /// quix_packet(8)<=trigger_selected;  plot this one
    UInt_t GetTriggerSelected() const {
        if (8 < this->GetSize32()) return *(this->GetData32() + 8);
        else return 0;                                           }

    /// quix_packet(9)<=seq_switch_time_sec;  --ignore
    UInt_t GetSeqSwitchTimeSec() const {
        if (9 < this->GetSize32()) return *(this->GetData32() + 9);
        else return 0;                                           }

    /// quix_packet(10)<=seq_switch_time_ssec; --ignore
    UInt_t GetSeqSwitchTimeSSec() const {
        if (10 < this->GetSize32()) return *(this->GetData32() + 10);
        else return 0;                                           }

    /// quix_packet(11)<=x"0000000" & seq_changes_since_last_event; --ignore
    UInt_t GetSeqLastEv() const {
        if (11 < this->GetSize32()) return *(this->GetData32() + 11);
        else return 0;                                           }

    /// quix_packet(12)<=time_since_system_busy; --ignore
    UInt_t GetTimeSinceBusy() const {
        if (12 < this->GetSize32()) return *(this->GetData32() + 12);
        else return 0;                                           }

    /// quix_packet(13)<=total_time_live; --plot 1000ns*32
    UInt_t GetTotalTimeLive() const {
        if (13 < this->GetSize32()) return *(this->GetData32() + 13);
        else return 0;                                           }

    /// quix_packet(14)<=total_run_time; --plot 1000ns*32
    UInt_t GetTotalRunTime() const {
        if (14 < this->GetSize32()) return *(this->GetData32() + 14);
        else return 0;                                           }

    /// quix_packet(15)<=std_logic_vector(beam_spill_trigger_trig_accepted);
    UInt_t GetSpillAccepted() const {
        if (15 < this->GetSize32()) return *(this->GetData32() + 15);
        else return 0;                                           }

    /// quix_packet(16)<=spill_live;
    UInt_t GetSpillLive() const {
        if (16 < this->GetSize32()) return *(this->GetData32() + 16);
        else return 0;                                           }

    /// quix_packet(17)<=spill_alloc;
    UInt_t GetSpillAlloc() const {
        if (17 < this->GetSize32()) return *(this->GetData32() + 17);
        else return 0;                                           }

    /// quix_packet(18)<=std_logic_vector(pedestal_noise_trig_accepted);
    UInt_t GetPedAccepted() const {
        if (18 < this->GetSize32()) return *(this->GetData32() + 18);
        else return 0;                                           }

    /// quix_packet(19)<=pedestal_noise_live;
    UInt_t GetPedLive() const {
        if (19 < this->GetSize32()) return *(this->GetData32() + 19);
        else return 0;                                           }

    /// quix_packet(20)<=pedestal_noise_alloc;
    UInt_t GetPedAlloc() const {
        if (20 < this->GetSize32()) return *(this->GetData32() + 20);
        else return 0;                                           }

    /// quix_packet(21)<=std_logic_vector(tpc_laser_trig_accepted);
    UInt_t GetTPCLaserAccepted() const {
        if (21 < this->GetSize32()) return *(this->GetData32() + 21);
        else return 0;                                           }

    /// quix_packet(22)<=tpc_laser_live;
    UInt_t GetTPCLaserLive() const {
        if (22 < this->GetSize32()) return *(this->GetData32() + 22);
        else return 0;                                           }

    /// quix_packet(23)<=tpc_laser_alloc;
    UInt_t GetTPCLaserAlloc() const {
        if (23 < this->GetSize32()) return *(this->GetData32() + 23);
        else return 0;                                           }

    /// quix_packet(24)<=std_logic_vector(POD_LED_trig_accepted);
    UInt_t GetP0DLEDAccepted() const {
        if (24 < this->GetSize32()) return *(this->GetData32() + 24);
        else return 0;                                           }

    /// quix_packet(25)<=POD_LED_live;
    UInt_t GetP0DLEDLive() const {
        if (25 < this->GetSize32()) return *(this->GetData32() + 25);
        else return 0;                                           }

    /// quix_packet(26)<=POD_LED_alloc;
    UInt_t GetP0DLEDAlloc() const {
        if (26 < this->GetSize32()) return *(this->GetData32() + 26);
        else return 0;                                           }

    /// quix_packet(27)<=std_logic_vector(ECAL_LED_trig_accepted);
    UInt_t GetECALLEDAccepted() const {
        if (27 < this->GetSize32()) return *(this->GetData32() + 27);
        else return 0;                                           }

    /// quix_packet(28)<=ECAL_LED_live;
    UInt_t GetECALLEDLive() const {
        if (28 < this->GetSize32()) return *(this->GetData32() + 28);
        else return 0;                                           }

    /// quix_packet(29)<=ECAL_LED_alloc;
    UInt_t GetECALLEDAlloc() const {
        if (29 < this->GetSize32()) return *(this->GetData32() + 29);
        else return 0;                                           }

    /// quix_packet(30)<=std_logic_vector(FGD_LED_trig_accepted);
    UInt_t GetFGDLEDAccepted() const {
        if (30 < this->GetSize32()) return *(this->GetData32() + 30);
        else return 0;                                           }

    /// quix_packet(31)<=FGD_LED_live;
    UInt_t GetFGDLEDLive() const {
        if (31 < this->GetSize32()) return *(this->GetData32() + 31);
        else return 0;                                           }

    /// quix_packet(32)<=FGD_LED_alloc;
    UInt_t GetFGDLEDAlloc() const {
        if (32 < this->GetSize32()) return *(this->GetData32() + 32);
        else return 0;                                           }

    /// quix_packet(33)<=std_logic_vector(FEE_calibration_trig_accepted);
    UInt_t GetFEECalAccepted() const {
        if (33 < this->GetSize32()) return *(this->GetData32() + 33);
        else return 0;                                           }

    /// quix_packet(34)<=FEE_calibration_live;
    UInt_t GetFEECalLive() const {
        if (34 < this->GetSize32()) return *(this->GetData32() + 34);
        else return 0;                                           }

    /// quix_packet(35)<=FEE_calibration_alloc;
    UInt_t GetFEECalAlloc() const {
        if (35 < this->GetSize32()) return *(this->GetData32() + 35);
        else return 0;                                           }

    /// quix_packet(36)<=std_logic_vector(trip_t_cosmic_trig_accepted);
    UInt_t GetTripTCosmicAccepted() const {
        if (36 < this->GetSize32()) return *(this->GetData32() + 36);
        else return 0;                                           }

    /// quix_packet(37)<=trip_t_cosmic_live;
    UInt_t GetTripTCosmicLive() const {
        if (37 < this->GetSize32()) return *(this->GetData32() + 37);
        else return 0;                                           }

    /// quix_packet(38)<=trip_t_cosmic_alloc;
    UInt_t GetTripTCosmicAlloc() const {
        if (38 < this->GetSize32()) return *(this->GetData32() + 38);
        else return 0;                                           }

    /// quix_packet(39)<=std_logic_vector(FGD_cosmic_trig_accepted);
    UInt_t GetFGDCosmicAccepted() const {
        if (39 < this->GetSize32()) return *(this->GetData32() + 39);
        else return 0;                                           }

    /// quix_packet(40)<=FGD_cosmic_live;
    UInt_t GetFGDCosmicLive() const {
        if (40 < this->GetSize32()) return *(this->GetData32() + 40);
        else return 0;                                           }

    /// quix_packet(41)<=FGD_cosmic_alloc;
    UInt_t GetFGDCosmicAlloc() const {
        if (41 < this->GetSize32()) return *(this->GetData32() + 41);
        else return 0;                                           }

};
#endif