RecoContainer.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.
 
 
#include <array>
#include <cstdint>
#include <exception>
#include <iosfwd>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
#include <gsl/span>
#include <Rtypes.h>
#include <CommonDataFormat/InteractionRecord.h>
#include <DataFormatsEMCAL/Cell.h>
#include <EMCALBase/TriggerMappingV2.h>
#include <EMCALReconstruction/FastORTimeSeries.h>
#include <EMCALReconstruction/TRUDataHandler.h>
 
#ifndef ALICEO2_EMCAL_RECOCONTAINER_H
#define ALICEO2_EMCAL_RECOCONTAINER_H
 
namespace o2::emcal
{
struct RecCellInfo {
  o2::emcal::Cell mCellData; 
  bool mIsLGnoHG;            
  bool mHGOutOfRange;        
  int mDDLID;                
  int mHWAddressLG;          
  int mHWAddressHG;          
};
 
class EventContainer
{
 public:
  class TRUIndexException final : public std::exception
  {
   public:
    TRUIndexException(std::size_t index);
 
    ~TRUIndexException() noexcept final = default;
 
    const char* what() const noexcept final { return mMessage.data(); }
 
    std::size_t getIndex() const { return mIndex; }
 
    void printStream(std::ostream& stream) const;
 
   private:
    std::size_t mIndex;   
    std::string mMessage; 
  };
 
  EventContainer() = default;
 
  EventContainer(const o2::InteractionRecord& currentIR);
 
  ~EventContainer() = default;
 
  void setTriggerBits(uint64_t triggerbits) { mTriggerBits = triggerbits; }
 
  void setInteractionRecord(const o2::InteractionRecord& currentIR) { mInteractionRecord = currentIR; }
 
  uint64_t getTriggerBits() const { return mTriggerBits; }
 
  const o2::InteractionRecord& getInteractionRecord() const { return mInteractionRecord; }
 
  const gsl::span<const RecCellInfo> getCells() const { return mCells; }
 
  const gsl::span<const RecCellInfo> getLEDMons() const { return mLEDMons; }
 
  int getNumberOfCells() const { return mCells.size(); }
 
  int getNumberOfLEDMONs() const { return mLEDMons.size(); }
 
  TRUDataHandler& getTRUData(std::size_t truIndex);
 
  const TRUDataHandler& readTRUData(std::size_t truIndex) const;
 
  const std::unordered_map<uint16_t, FastORTimeSeries>& getTimeSeriesContainer() const { return mL0FastORs; }
 
  void setCell(int tower, double energy, double time, ChannelType_t celltype, int hwaddress, int ddlID, bool doMergeHGLG)
  {
    setCellCommon(tower, energy, time, celltype, false, hwaddress, ddlID, doMergeHGLG);
  }
 
  void setLEDMONCell(int tower, double energy, double time, ChannelType_t celltype, int hwaddress, int ddlID, bool doMergeHGLG)
  {
    setCellCommon(tower, energy, time, celltype, true, hwaddress, ddlID, doMergeHGLG);
  }
 
  void setFastOR(uint16_t fastORAbsID, uint8_t starttime, const gsl::span<const uint16_t> timesamples);
 
  void sortCells(bool isLEDmon);
 
 private:
  void setCellCommon(int tower, double energy, double time, ChannelType_t celltype, bool isLEDmon, int hwaddress, int ddlID, bool doMergeHGLG);
 
  bool isCellSaturated(double energy) const;
 
  void initTRUs();
 
  o2::InteractionRecord mInteractionRecord;                       
  uint64_t mTriggerBits = 0;                                      
  std::vector<RecCellInfo> mCells;                                
  std::vector<RecCellInfo> mLEDMons;                              
  std::array<TRUDataHandler, TriggerMappingV2::ALLTRUS> mTRUData; 
  std::unordered_map<uint16_t, FastORTimeSeries> mL0FastORs;      
};
 
class RecoContainer
{
 public:
  class InteractionNotFoundException final : public std::exception
  {
   public:
    InteractionNotFoundException(const o2::InteractionRecord& currentIR) : mCurrentIR(currentIR)
    {
      mMessage = "Interaction record not found: Orbit " + std::to_string(mCurrentIR.orbit) + ", BC " + std::to_string(mCurrentIR.bc);
    }
 
    ~InteractionNotFoundException() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return mMessage.data();
    };
 
    const o2::InteractionRecord& getInteractionRecord() const { return mCurrentIR; }
 
   private:
    o2::InteractionRecord mCurrentIR; 
    std::string mMessage;             
  };
 
  RecoContainer() = default;
 
  ~RecoContainer() = default;
 
  EventContainer& getEventContainer(const o2::InteractionRecord& currentIR);
 
  const EventContainer& getEventContainer(const o2::InteractionRecord& currentIR) const;
 
  std::vector<o2::InteractionRecord> getOrderedInteractions() const;
 
  std::size_t getNumberOfEvents() const { return mEvents.size(); }
 
  void reset() { mEvents.clear(); }
 
 private:
  std::unordered_map<o2::InteractionRecord, EventContainer> mEvents; 
};
 
class RecoContainerReader
{
 public:
  class InvalidAccessException : public std::exception
  {
   public:
    InvalidAccessException() = default;
 
    ~InvalidAccessException() noexcept final = default;
 
    const char* what() const noexcept final { return "Access to invalid element in reco container"; }
  };
 
  RecoContainerReader(RecoContainer& container);
  RecoContainerReader(RecoContainer&& container) = delete;
 
  ~RecoContainerReader() = default;
 
  EventContainer& nextEvent();
 
  bool hasNext() const { return mCurrentEvent < mOrderedInteractions.size(); }
 
  std::size_t getNumberOfEvents() const { return mDataContainer.getNumberOfEvents(); }
 
 private:
  RecoContainer& mDataContainer;                           
  std::vector<o2::InteractionRecord> mOrderedInteractions; 
  std::size_t mCurrentEvent = 0;                           
};
 
} // namespace o2::emcal
 
#endif