DDASHit.h

/* DDASHit class definition header file */

#ifndef DAQ_DDAS_DDASHIT_H
#define DAQ_DDAS_DDASHIT_H

#include <vector>
#include <cstdint>


namespace DAQ {
  namespace DDAS {
    class DDASHit { 

      private:
        /********** Variables **********/

        /* Channel events always have the following info. */
        double time;              
        uint64_t coarsetime;        

        uint32_t energy;              
        uint32_t timehigh;            
        uint32_t timelow;             
        uint32_t timecfd;             

        uint32_t finishcode;           
        uint32_t channellength;        
        uint32_t channelheaderlength;  
        uint32_t headerlength;  
        uint32_t overflowcode;         
        uint32_t chanid;               
        uint32_t slotid;               
        uint32_t crateid;              

        uint32_t cfdtrigsourcebit;     
        uint32_t cfdfailbit;           

        uint32_t tracelength;          

        uint32_t ModMSPS;              

        /* A channel may have extra information... */
        std::vector<uint32_t> energySums;  
        std::vector<uint32_t> qdcSums;     

        /* A waveform (trace) may be stored too. */
        std::vector<uint16_t> trace;     

        uint64_t externalTimestamp;    

      public:
        // Canonicals

        DDASHit();

        DDASHit(const DDASHit& obj) = default;

        DDASHit& operator=(const DDASHit& obj);

        ~DDASHit(); 

        void Reset();


        uint32_t GetEnergy() const {return energy;}

        uint32_t GetTimeHigh() const {return timehigh;}

        uint32_t GetTimeLow() const {return timelow;}

        uint32_t GetTimeCFD() const {return timecfd;}

        double GetTime() const {return time;}

        uint64_t GetCoarseTime() const {return coarsetime;}

        uint32_t GetFinishCode() const {return finishcode;}

        uint32_t GetChannelLength() const {return channellength;}

        uint32_t GetChannelLengthHeader() const {return channelheaderlength;}

        uint32_t GetOverflowCode() const {return overflowcode;}

        uint32_t GetSlotID() const {return slotid;}

        uint32_t GetCrateID() const {return crateid;}

        uint32_t GetChannelID() const {return chanid;}

        uint32_t GetHeaderLength() const { return headerlength; }

        uint32_t GetModMSPS() const {return ModMSPS;}

        uint32_t GetCFDTrigSource() const { return cfdtrigsourcebit; }

        uint32_t GetCFDFailBit() const { return cfdfailbit; }

        uint32_t GetTraceLength() const { return tracelength; }

        std::vector<uint16_t>& GetTrace() {return trace;}
        const std::vector<uint16_t>& GetTrace() const {return trace;}

        std::vector<uint32_t>& GetEnergySums() { return energySums; }
        const std::vector<uint32_t>& GetEnergySums() const { return energySums; }

        std::vector<uint32_t>& GetQDCSums() { return qdcSums; }
        const std::vector<uint32_t>& GetQDCSums() const { return qdcSums; }

        uint64_t GetExternalTimestamp() const {return externalTimestamp; }

        void setChannel(uint32_t channel);
        void setSlot(uint32_t slot);
        void setCrate(uint32_t crate);
        void setChannelHeaderLength(uint32_t channelHeaderLength);
        void setChannelLength(uint32_t channelLength);
        void setOverflowCode(uint32_t overflow);
        void setFinishCode(bool finishCode);
        void setCoarseTime(uint64_t time);
        void setRawCFDTime(uint32_t data);
        void setCFDTrigSourceBit(uint32_t bit);
        void setCFDFailBit(uint32_t bit);

        void setTimeLow(uint32_t datum);
        void setTimeHigh(uint32_t datum);

        void setTime(double time);
        void setEnergy(uint32_t value);
        void setTraceLength(uint32_t trace);
        void setADCFrequency(uint32_t value);
        void appendEnergySum(uint32_t value);
        void appendQDCSum(uint32_t value);
        void appendTraceSample(uint16_t value);
        void setExternalTimestamp(uint64_t tstamp);
    };
  } // end DDAS namespace
} // end DAQ namespace
#endif