LArRawSC.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef LARRAWSC_H
#define LARRAWSC_H
#include <vector>
#include <utility> //for std::move
 
#include "Identifier/HWIdentifier.h"
 
class LArRawSC  final{
 
 private:
 
  HWIdentifier m_hardwareID{};
 
  short m_chan = 0;
 
  unsigned int m_sourceId = 0U;
 
  std::vector < int > m_energies;
 
  std::vector < unsigned short > m_BCId;
 
  std::vector < bool > m_satur;
 
  std::vector < bool > m_passTauSelection;
 
  std::vector< int > m_tauEnergies;
 
  bool m_ofcaOverflow{};
 
  bool m_ofcbOverflow{};
 
  bool m_pedOverflow{};
 
 public:
  LArRawSC(const HWIdentifier& channel_value, const short chan,
           const unsigned int sourceId, const std::vector<int>& energies,
           const std::vector<unsigned short>& bcids, std::vector<bool>& satur)
      : m_hardwareID(channel_value),
        m_chan(chan),
        m_sourceId(sourceId),
        m_energies(energies),
        m_BCId(bcids),
        m_satur(satur),
        m_ofcaOverflow(false),
        m_ofcbOverflow(false),
        m_pedOverflow(false) {}
 
  LArRawSC(const HWIdentifier& channel_value, const short chan,
           const unsigned int sourceId, std::vector<int>&& energies,
           std::vector<unsigned short>&& bcids, std::vector<bool>&& satur)
      : m_hardwareID(channel_value),
        m_chan(chan),
        m_sourceId(sourceId),
        m_energies(std::move(energies)),
        m_BCId(std::move(bcids)),
        m_satur(std::move(satur)),
        m_ofcaOverflow(false),
        m_ofcbOverflow(false),
        m_pedOverflow(false) {}
 
  const HWIdentifier& hardwareID() const { return m_hardwareID; }
 
  short chan() const { return m_chan; }
 
  unsigned int SourceId() const { return m_sourceId; }
 
  int nsamples() const { return m_energies.size(); }
 
  const std::vector<int>& energies() const { return m_energies; }
 
  const std::vector<unsigned short>& bcids() const { return m_BCId; }
 
  const std::vector<bool>& satur() const { return m_satur; }
 
  const std::vector<int>& tauEnergies() const { return m_tauEnergies; }
 
  const std::vector<bool>& passTauSelection() const {
    return m_passTauSelection; }
 
    bool ofcaOverflow() const { return m_ofcaOverflow; }
 
    bool ofcbOverflow() const { return m_ofcbOverflow; }
 
    bool pedOverflow() const { return m_pedOverflow; }
 
 
    void setHardwareId(const HWIdentifier id);
 
    void setChannel(const unsigned chan);
 
    void setSourceId(const unsigned sourceId);
 
    void setEnergies( const std::vector < int >&& energies);
 
    void setBCIds( const std::vector < unsigned short >&& bcids);
 
    void setTauEnergies( const std::vector < int >&& tauEnergies);
 
    void setPassTauSelection( const std::vector < bool >&& pass);
 
 
    void setSaturation( const std::vector < bool >&& satur);
 
    void setOFCaOverflow(bool overflow){ m_ofcaOverflow=overflow; }
 
    void setOFCbOverflow(bool overflow){ m_ofcbOverflow=overflow; }
 
    void setPedOverflow(bool overflow){ m_pedOverflow=overflow; }
 
    LArRawSC() = default;
    LArRawSC(const LArRawSC&) = default;
    LArRawSC(LArRawSC&&) = default;
    LArRawSC& operator=(const LArRawSC&) = default;
    LArRawSC& operator=(LArRawSC&&) = default;
    ~LArRawSC() = default;
 
 
};
 
#endif //LArRawSC_H