EventHandler.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_EVENTHANDLER_H_
#define ALICEO2_EMCAL_EVENTHANDLER_H_
 
#include <cstdint>
#include <exception>
#include <iterator>
#include <gsl/span>
#include <vector>
#include "Rtypes.h"
#include "fmt/format.h"
#include "DataFormatsEMCAL/Cell.h"
#include "DataFormatsEMCAL/Cluster.h"
#include "DataFormatsEMCAL/Digit.h"
#include "DataFormatsEMCAL/EventData.h"
#include "DataFormatsEMCAL/MCLabel.h"
#include "DataFormatsEMCAL/TriggerRecord.h"
#include "SimulationDataFormat/MCTruthContainer.h"
 
namespace o2
{
namespace emcal
{
 
template <class CellInputType>
class EventHandler
{
 public:
  using TriggerRange = gsl::span<const TriggerRecord>;
  using ClusterRange = gsl::span<const Cluster>;
  using CellIndexRange = gsl::span<const int>;
  using CellRange = gsl::span<const CellInputType>;
 
  class RangeException final : public std::exception
  {
   public:
    RangeException(int eventID, int maxEvents) : std::exception(),
                                                 mEventID(eventID),
                                                 mMaxEvents(maxEvents),
                                                 mErrorMessage()
    {
      mErrorMessage = fmt::format("Exceeding range: %d, max %d", mEventID, mMaxEvents);
    }
 
    ~RangeException() noexcept final = default;
 
    const char* what() const noexcept final { return mErrorMessage.data(); }
 
    int getEventID() const { return mEventID; }
 
    int getMaxNumberOfEvents() const { return mMaxEvents; }
 
   private:
    int mEventID = 0;          
    int mMaxEvents = 0;        
    std::string mErrorMessage; 
  };
 
  class NotInitializedException final : public std::exception
  {
   public:
    NotInitializedException() = default;
 
    ~NotInitializedException() noexcept final = default;
 
    const char* what() const noexcept final { return "EventHandler not initialized"; }
  };
 
  class InteractionRecordInvalidException final : public std::exception
  {
   public:
    InteractionRecordInvalidException(const InteractionRecord& irclusters, const InteractionRecord& ircells) : mInteractionRecordClusters(irclusters),
                                                                                                               mInteractionRecordCells(ircells)
    {
    }
 
    ~InteractionRecordInvalidException() noexcept final = default;
 
    const char* what() const noexcept final { return "Interaction records for clusters and cells not matching"; }
 
    const InteractionRecord& getInteractionRecordClusters() const { return mInteractionRecordClusters; }
 
    const InteractionRecord& getInteractionRecordCells() const { return mInteractionRecordCells; }
 
   private:
    InteractionRecord mInteractionRecordClusters; 
    InteractionRecord mInteractionRecordCells;    
  };
 
  class TriggerBitsInvalidException final : public std::exception
  {
   public:
    TriggerBitsInvalidException(uint64_t bitsclusters, uint64_t bitscells) : mTriggerBitsClusters(bitsclusters),
                                                                             mTriggerBitsCells(bitscells)
    {
    }
 
    ~TriggerBitsInvalidException() noexcept final = default;
 
    const char* what() const noexcept final { return "Tigger bits for clusters and cells not matching"; }
 
    uint64_t getTriggerBitsClusters() const { return mTriggerBitsClusters; }
 
    uint64_t getTriggerBitsCells() const { return mTriggerBitsCells; }
 
   private:
    uint64_t mTriggerBitsClusters; 
    uint64_t mTriggerBitsCells;    
  };
 
  class EventIterator : public std::iterator_traits<EventData<CellInputType>>
  {
   public:
    EventIterator(const EventHandler& handler, int eventID, bool forward);
 
    EventIterator(const EventIterator& other) = default;
 
    EventIterator& operator=(const EventIterator& other) = default;
 
    ~EventIterator() = default;
 
    bool operator==(const EventIterator& rhs) const;
 
    bool operator!=(const EventIterator& rhs) const { return !(*this == rhs); }
 
    EventIterator& operator++();
 
    EventIterator operator++(int);
 
    EventIterator& operator--();
 
    EventIterator operator--(int);
 
    EventData<CellInputType>* operator*() { return &mCurrentEvent; }
 
    EventData<CellInputType>& operator&() { return mCurrentEvent; }
 
    int current_index() const { return mEventID; }
 
   private:
    const EventHandler& mEventHandler;      
    EventData<CellInputType> mCurrentEvent; 
    int mEventID = 0;                       
    bool mForward = true;                   
  };
 
  EventHandler() = default;
 
  EventHandler(CellRange cells, TriggerRange triggers);
 
  EventHandler(ClusterRange clusters, CellIndexRange cellIndices, TriggerRange triggersCluster, TriggerRange triggersCellIndex);
 
  EventHandler(ClusterRange clusters, CellIndexRange cellIndices, CellRange cells, TriggerRange triggersCluster, TriggerRange triggersCellIndex, TriggerRange triggersCell);
 
  ~EventHandler() = default;
 
  EventIterator begin() const { return EventIterator(*this, 0, true); }
 
  EventIterator end() const { return EventIterator(*this, getNumberOfEvents(), true); }
 
  EventIterator rbegin() const { return EventIterator(*this, getNumberOfEvents() - 1, false); };
 
  EventIterator rend() const { return EventIterator(*this, -1, false); };
 
  int getNumberOfEvents() const;
 
  InteractionRecord getInteractionRecordForEvent(int eventID) const;
 
  uint64_t getTriggerBitsForEvent(int eventID) const;
 
  const ClusterRange getClustersForEvent(int eventID) const;
 
  const CellRange getCellsForEvent(int eventID) const;
 
  std::vector<gsl::span<const o2::emcal::MCLabel>> getCellMCLabelForEvent(int eventID) const;
 
  const CellIndexRange getClusterCellIndicesForEvent(int eventID) const;
 
  bool hasClusters() const { return mTriggerRecordsClusters.size() > 0; }
 
  bool hasClusterIndices() const { return mTriggerRecordsCellIndices.size() > 0; }
 
  bool hasCells() const { return mTriggerRecordsCells.size() > 0; }
 
  void setClusterData(ClusterRange clusters, CellIndexRange cellIndices, TriggerRange triggersCluster, TriggerRange triggersCellIndex)
  {
    mClusters = clusters;
    mClusterCellIndices = cellIndices;
    mTriggerRecordsClusters = triggersCluster;
    mTriggerRecordsCellIndices = triggersCellIndex;
  }
 
  void setCellData(CellRange cells, TriggerRange triggers)
  {
    mCells = cells;
    mTriggerRecordsCells = triggers;
  }
 
  void setCellMCTruthContainer(const o2::dataformats::MCTruthContainer<o2::emcal::MCLabel>* mclabels)
  {
    mCellLabels = mclabels;
  }
 
  void reset();
 
  EventData<CellInputType> buildEvent(int eventID) const;
 
 private:
  bool compareInteractionRecords(const InteractionRecord& lhs, const InteractionRecord& rhs) const;
 
  TriggerRange mTriggerRecordsClusters;    
  TriggerRange mTriggerRecordsCellIndices; 
  TriggerRange mTriggerRecordsCells;       
 
  ClusterRange mClusters;                                                             
  CellIndexRange mClusterCellIndices;                                                 
  CellRange mCells;                                                                   
  const o2::dataformats::MCTruthContainer<o2::emcal::MCLabel>* mCellLabels = nullptr; 
 
  ClassDefNV(EventHandler, 1);
};
 
} // namespace emcal
} // namespace o2
 
#endif // ALICEO2_EMCAL_EVENTHANDLER_H__