DDASHit.h

/*
    This software is Copyright by the Board of Trustees of Michigan
    State University (c) Copyright 2014.

    You may use this software under the terms of the GNU public license
    (GPL).  The terms of this license are described at:

     http://www.gnu.org/licenses/gpl.txt

     Authors:
             Ron Fox
             Jeromy Tompkins 
             NSCL
             Michigan State University
             East Lansing, MI 48824-1321
*/


/* 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 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;    

        int      m_hdwrRevision;       
        int      m_adcResolution;      
        bool     m_adcOverflowUnderflow;   

      public:
        // Canonicals

      DDASHit();
    private:
      void copyIn(const DDASHit& rhs);
    public:
      
      DDASHit(const DDASHit& obj) {
        copyIn(obj);
      }
      DDASHit& operator=(const DDASHit& obj) {
        if (this != &obj) {
          copyIn(obj);
        }
        return *this;
      }



        virtual ~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 GetModMSPS() const {return ModMSPS;}

        int GetHardwareRevision() const {return m_hdwrRevision; }

        int GetADCResolution() const {return m_adcResolution; }

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

        bool     GetADCOverflowUnderflow() const { return m_adcOverflowUnderflow; }

        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 setADCResolution(int value);
        void setHardwareRevision(int value);
        void appendEnergySum(uint32_t value);
        void appendQDCSum(uint32_t value);
        void appendTraceSample(uint16_t value);
        void setExternalTimestamp(uint64_t tstamp);
        void setADCOverflowUnderflow(bool state);
    };
  } // end DDAS namespace
} // end DAQ namespace
#endif