DDASHit.h

Go to the documentation of this file.

/*
    This software is Copyright by the Board of Trustees of Michigan
    State University (c) Copyright 2016.
 
    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
 
     Author:
             Ron Fox
             Jeromy Tompkins
             Aaron Chester
             Facility for Rare Isotope Beams
             Michigan State University
             East Lansing, MI 48824-1321
*/
 
#ifndef DDASHIT_H
#define DDASHIT_H
 
#include <stdint.h>
 
#include <vector>
 
namespace ddasfmt {
 
class DDASHit {
 
private:
  // Channel events always have the following info:
 
  double m_time;                  
  uint64_t m_coarseTime;          
  uint64_t m_externalTimestamp;   
  uint32_t m_timeHigh;            
  uint32_t m_timeLow;             
  uint32_t m_timeCFD;             
  uint32_t m_energy;              
  uint32_t m_finishCode;          
  uint32_t m_channelLength;       
  uint32_t m_channelHeaderLength; 
  uint32_t m_chanID;              
  uint32_t m_slotID;              
  uint32_t m_crateID;             
  uint32_t m_cfdTrigSourceBit;    
  uint32_t m_cfdFailBit;          
  uint32_t m_traceLength;         
  uint32_t m_modMSPS;             
  uint16_t m_hdwrRevision;        
  uint16_t m_adcResolution;       
  bool m_adcOverflowUnderflow;    
 
  // Storage for extra data which may be present in a hit:
 
  std::vector<uint32_t> m_energySums; 
  std::vector<uint32_t> m_qdcSums;    
  std::vector<uint16_t> m_trace;      
 
public:
  DDASHit();
 
  virtual ~DDASHit() {};
  void Reset();
 
  double getTime() const { return m_time; }
  uint64_t getCoarseTime() const { return m_coarseTime; }
  uint32_t getEnergy() const { return m_energy; }
  uint32_t getTimeHigh() const { return m_timeHigh; }
  uint32_t getTimeLow() const { return m_timeLow; }
  uint32_t getTimeCFD() const { return m_timeCFD; }
  uint32_t getFinishCode() const { return m_finishCode; }
  uint32_t getChannelLength() const { return m_channelLength; }
  uint32_t getChannelHeaderLength() const { return m_channelHeaderLength; }
  uint32_t getSlotID() const { return m_slotID; }
  uint32_t getCrateID() const { return m_crateID; }
  uint32_t getChannelID() const { return m_chanID; }
  uint32_t getModMSPS() const { return m_modMSPS; }
  uint16_t getHardwareRevision() const { return m_hdwrRevision; }
  uint16_t getADCResolution() const { return m_adcResolution; }
  uint32_t getCFDTrigSource() const { return m_cfdTrigSourceBit; }
  uint32_t getCFDFailBit() const { return m_cfdFailBit; }
  uint32_t getTraceLength() const { return m_traceLength; }
  std::vector<uint16_t> &getTrace() { return m_trace; }
  const std::vector<uint16_t> &getTrace() const { return m_trace; }
  std::vector<uint32_t> &getEnergySums() { return m_energySums; }
  const std::vector<uint32_t> &getEnergySums() const { return m_energySums; }
  std::vector<uint32_t> &getQDCSums() { return m_qdcSums; }
  const std::vector<uint32_t> &getQDCSums() const { return m_qdcSums; }
  uint64_t getExternalTimestamp() const { return m_externalTimestamp; }
  bool getADCOverflowUnderflow() const { return m_adcOverflowUnderflow; }
 
  void setChannelID(uint32_t channel) { m_chanID = channel; }
  void setSlotID(uint32_t slot) { m_slotID = slot; }
  void setCrateID(uint32_t crate) { m_crateID = crate; }
  void setChannelHeaderLength(uint32_t channelHeaderLength) {
    m_channelHeaderLength = channelHeaderLength;
  }
  void setChannelLength(uint32_t channelLength) {
    m_channelLength = channelLength;
  }
  void setFinishCode(bool finishCode) { m_finishCode = finishCode; }
  void setCoarseTime(uint64_t time) { m_coarseTime = time; }
  void setRawCFDTime(uint32_t data) { m_timeCFD = data; }
 
  void setCFDTrigSourceBit(uint32_t bit) { m_cfdTrigSourceBit = bit; }
 
  void setCFDFailBit(uint32_t bit) { m_cfdFailBit = bit; }
  void setTimeLow(uint32_t datum) { m_timeLow = datum; }
  void setTimeHigh(uint32_t datum);
  void setTime(double compTime) { m_time = compTime; }
  void setEnergy(uint32_t energy) { m_energy = energy; }
  void setTraceLength(uint32_t length) { m_traceLength = length; }
  void setModMSPS(uint32_t msps) { m_modMSPS = msps; }
  void setADCResolution(uint16_t value) { m_adcResolution = value; }
  void setHardwareRevision(uint16_t value) { m_hdwrRevision = value; }
  void appendEnergySum(uint32_t value) { m_energySums.push_back(value); }
  void setEnergySums(std::vector<uint32_t> eneSums);
  void appendQDCSum(uint32_t value) { m_qdcSums.push_back(value); }
  void setQDCSums(std::vector<uint32_t> qdcSums);
  void appendTraceSample(uint16_t value) { m_trace.push_back(value); }
  void setTrace(std::vector<uint16_t> trace) {
    m_trace = std::move(trace);
    setTraceLength(m_trace.size());
  }
  void setExternalTimestamp(uint64_t value) { m_externalTimestamp = value; }
  void setADCOverflowUnderflow(bool state) { m_adcOverflowUnderflow = state; }
};
 
} // namespace ddasfmt
 
#endif