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