RawToCellConverterSpec.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 O2_EMCAL_RAWTOCELLCONVERTER_SPEC
#define O2_EMCAL_RAWTOCELLCONVERTER_SPEC
 
#include <chrono>
#include <exception>
#include <vector>
 
#include "Framework/ConcreteDataMatcher.h"
#include "Framework/DataProcessorSpec.h"
#include "Framework/Task.h"
#include "DataFormatsEMCAL/Cell.h"
#include "DataFormatsEMCAL/CompressedTriggerData.h"
#include "DataFormatsEMCAL/TriggerRecord.h"
#include "Headers/DataHeader.h"
#include "EMCALBase/Geometry.h"
#include "EMCALBase/Mapper.h"
#include "EMCALBase/TriggerMappingV2.h"
#include "EMCALReconstruction/CaloRawFitter.h"
#include "EMCALReconstruction/RawReaderMemory.h"
#include "EMCALReconstruction/RecoContainer.h"
#include "EMCALReconstruction/ReconstructionErrors.h"
#include "EMCALReconstruction/TRUDecodingErrors.h"
#include "EMCALWorkflow/CalibLoader.h"
 
namespace o2
{
 
namespace emcal
{
 
class AltroDecoderError;
class Channel;
class MinorAltroDecodingError;
class RawDecodingError;
class FastORIndexException;
class TRUIndexException;
class FastOrStartTimeInvalidException;
 
namespace reco_workflow
{
 
class RawToCellConverterSpec : public framework::Task
{
 public:
  RawToCellConverterSpec(int subspecification, bool hasDecodingErrors, bool hasTriggerReconstruction, std::shared_ptr<CalibLoader> calibhandler) : framework::Task(), mSubspecification(subspecification), mCreateRawDataErrors(hasDecodingErrors), mDoTriggerReconstruction(hasTriggerReconstruction), mCalibHandler(calibhandler){};
 
  ~RawToCellConverterSpec() override;
 
  void init(framework::InitContext& ctx) final;
 
  void run(framework::ProcessingContext& ctx) final;
 
  void finaliseCCDB(framework::ConcreteDataMatcher& matcher, void* obj) final;
 
  void setMaxErrorMessages(int maxMessages)
  {
    mMaxErrorMessages = maxMessages;
  }
 
  void setNoiseThreshold(int threshold) { mNoiseThreshold = threshold; }
 
  int getNoiseThreshold() const { return mNoiseThreshold; }
 
  void setSubspecification(header::DataHeader::SubSpecificationType subspecification) { mSubspecification = subspecification; }
 
  header::DataHeader::SubSpecificationType getSubspecification() const { return mSubspecification; }
 
 private:
  class ModuleIndexException : public std::exception
  {
   public:
    enum class ModuleType_t {
      CELL_MODULE,  
      LEDMON_MODULE 
    };
 
    ModuleIndexException(int moduleIndex, int column, int row, int columnshifted, int rowshifted);
 
    ModuleIndexException(int moduleIndex);
 
    ~ModuleIndexException() noexcept final = default;
 
    const char* what() const noexcept final { return "Invalid cell / LEDMON index"; }
 
    ModuleType_t getModuleType() const { return mModuleType; }
 
    int getIndex() const { return mIndex; }
 
    int getColumn() const { return mColumn; }
 
    int getRow() const { return mRow; }
 
    int getColumnShifted() const { return mColumnShifted; }
 
    int getRowShifted() const { return mRowShifted; }
 
   private:
    ModuleType_t mModuleType; 
    int mIndex = -1;          
    int mColumn = -1;         
    int mRow = -1;            
    int mColumnShifted = -1;  
    int mRowShifted = -1;     
  };
 
  struct CellTimeCorrection {
    double mTimeShift; 
    int mBcMod4;       
 
    double getCorrectedTime(double rawtime) const { return rawtime - mTimeShift - 25. * mBcMod4; }
  };
 
  struct LocalPosition {
    uint16_t mSupermoduleID; 
    uint16_t mFeeID;         
    uint8_t mColumn;         
    uint8_t mRow;            
  };
 
  using TRUContainer = std::vector<o2::emcal::CompressedTRU>;
  using PatchContainer = std::vector<o2::emcal::CompressedTriggerPatch>;
 
  bool isLostTimeframe(framework::ProcessingContext& ctx) const;
 
  void updateCalibrationObjects();
 
  int bookEventCells(const gsl::span<const o2::emcal::RecCellInfo>& cells, bool isLELDMON);
 
  void sendData(framework::ProcessingContext& ctx) const;
 
  int getCellAbsID(int supermoduleID, int column, int row);
 
  int geLEDMONAbsID(int supermoduleID, int module);
 
  void addFEEChannelToEvent(o2::emcal::EventContainer& currentEvent, const o2::emcal::Channel& currentchannel, const CellTimeCorrection& timeCorrector, const LocalPosition& position, ChannelType_t chantype);
 
  void addTRUChannelToEvent(o2::emcal::EventContainer& currentEvent, const o2::emcal::Channel& currentchannel, const LocalPosition& position);
 
  std::tuple<TRUContainer, PatchContainer> buildL0Patches(const EventContainer& currentevent) const;
 
  std::vector<o2::emcal::CompressedL0TimeSum> buildL0Timesums(const o2::emcal::EventContainer& currentevent, uint8_t l0time) const;
 
  std::tuple<uint16_t, uint8_t> reconstructTriggerPatch(const gsl::span<const FastORTimeSeries*> fastors) const;
 
  void handleAddressError(const Mapper::AddressNotFoundException& error, int ddlID, int hwaddress);
 
  void handleAltroError(const o2::emcal::AltroDecoderError& altroerror, int ddlID);
 
  void handleMinorAltroError(const o2::emcal::MinorAltroDecodingError& altroerror, int ddlID);
 
  void handleDDLError(const MappingHandler::DDLInvalid& error, int feeID);
 
  void handleGeometryError(const ModuleIndexException& error, int supermoduleID, int cellID, int hwaddress, ChannelType_t chantype);
 
  void handleFitError(const o2::emcal::CaloRawFitter::RawFitterError_t& fiterror, int ddlID, int cellID, int hwaddress);
 
  void handleGainError(const o2::emcal::reconstructionerrors::GainError_t& errortype, int ddlID, int hwaddress);
 
  void handlePageError(const RawDecodingError& error);
 
  void handleMinorPageError(const RawReaderMemory::MinorError& error);
 
  void handleFastORErrors(const FastORIndexException& error, unsigned int linkID, unsigned int indexTRU);
 
  void handleFastORStartTimeErrors(const FastOrStartTimeInvalidException& e, unsigned int linkID, unsigned int indexTRU);
 
  void handlePatchError(const TRUDataHandler::PatchIndexException& error, unsigned int linkID, unsigned int indexTRU);
 
  void handleTRUIndexError(const TRUIndexException& error, unsigned int linkID, unsigned int hwaddress);
 
  header::DataHeader::SubSpecificationType mSubspecification = 0;    
  int mNoiseThreshold = 0;                                           
  int mNumErrorMessages = 0;                                         
  int mErrorMessagesSuppressed = 0;                                  
  int mMaxErrorMessages = 100;                                       
  bool mMergeLGHG = true;                                            
  bool mActiveLinkCheck = true;                                      
  bool mPrintTrailer = false;                                        
  bool mDisablePedestalEvaluation = false;                           
  bool mCreateRawDataErrors = false;                                 
  bool mDoTriggerReconstruction = false;                             
  std::chrono::time_point<std::chrono::system_clock> mReferenceTime; 
  Geometry* mGeometry = nullptr;                                     
  RecoContainer mCellHandler;                                        
  std::shared_ptr<CalibLoader> mCalibHandler;                        
  std::unique_ptr<MappingHandler> mMapper = nullptr;                 
  std::unique_ptr<TriggerMappingV2> mTriggerMapping;                 
  std::unique_ptr<CaloRawFitter> mRawFitter;                         
  std::vector<Cell> mOutputCells;                                    
  std::vector<TriggerRecord> mOutputTriggerRecords;                  
  std::vector<ErrorTypeFEE> mOutputDecoderErrors;                    
  std::vector<CompressedTRU> mOutputTRUs;                            
  std::vector<TriggerRecord> mOutputTRUTriggerRecords;               
  std::vector<CompressedTriggerPatch> mOutputPatches;                
  std::vector<TriggerRecord> mOutputPatchTriggerRecords;             
  std::vector<CompressedL0TimeSum> mOutputTimesums;                  
  std::vector<TriggerRecord> mOutputTimesumTriggerRecords;           
};
 
framework::DataProcessorSpec getRawToCellConverterSpec(bool askDISTSTF, bool disableDecodingError, bool disableTriggerReconstruction, int subspecification);
 
} // namespace reco_workflow
 
} // namespace emcal
 
} // namespace o2
 
#endif // O2_EMCAL_RAWTOCELLCONVERTER_SPEC