TRUDataHandler.h

Go to the documentation of this file.

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.
#ifndef ALICEO2_EMCAL_TRUDataHandler_H
#define ALICEO2_EMCAL_TRUDataHandler_H
 
#include <array>
#include <bitset>
#include <climits>
#include <cstdint>
#include <exception>
#include <iosfwd>
#include <string>
 
#include "Rtypes.h"
 
#include "EMCALBase/TriggerMappingV2.h"
 
namespace o2::emcal
{
 
class TRUDataHandler
{
 public:
  class PatchIndexException final : public std::exception
  {
   public:
    PatchIndexException(int8_t index);
 
    ~PatchIndexException() noexcept final = default;
 
    int8_t getIndex() const { return mIndex; }
 
    const char* what() const noexcept final
    {
      return mMessage.data();
    }
 
    void printStream(std::ostream& stream) const;
 
   private:
    int8_t mIndex = -1;   
    std::string mMessage; 
  };
 
  TRUDataHandler();
 
  ~TRUDataHandler() = default;
 
  void reset();
 
  void setPatch(unsigned int index, unsigned int time)
  {
    checkPatchIndex(index);
    mPatchTimes[index] = time;
  }
 
  void setFired(bool fired) { mL0Fired = fired; }
 
  void setL0time(int l0time) { mL0Time = l0time; }
 
  void setTRUIndex(int index) { mTRUIndex = index; }
 
  bool isFired() const { return mL0Fired; }
 
  int8_t getL0time() const { return mL0Time; }
 
  bool hasPatch(unsigned int index) const
  {
    checkPatchIndex(index);
    return mPatchTimes[index] < UCHAR_MAX;
  }
 
  uint8_t getPatchTime(unsigned int index) const
  {
    checkPatchIndex(index);
    return mPatchTimes[index];
  }
 
  bool hasAnyPatch() const
  {
    for (int ipatch = 0; ipatch < mPatchTimes.size(); ipatch++) {
      if (hasPatch(ipatch)) {
        return true;
      }
    }
    return false;
  }
 
  int getTRUIndex() const { return mTRUIndex; }
 
  void printStream(std::ostream& stream) const;
 
 private:
  void checkPatchIndex(unsigned int index) const
  {
    if (index >= mPatchTimes.size()) {
      throw PatchIndexException(index);
    }
  }
 
  std::array<uint8_t, o2::emcal::TriggerMappingV2::PATCHESINTRU> mPatchTimes; 
  bool mL0Fired = false;                                                      
  int8_t mL0Time = -1;                                                        
  int8_t mTRUIndex = -1;                                                      
  ClassDefNV(TRUDataHandler, 1);
};
 
std::ostream& operator<<(std::ostream& stream, const TRUDataHandler& data);
 
std::ostream& operator<<(std::ostream& stream, const TRUDataHandler::PatchIndexException& error);
 
} // namespace o2::emcal
#endif