PedestalProcessorDevice.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 EMCAL_PEDESTAL_PROCESSOR_DEVICE_H_
#define EMCAL_PEDESTAL_PROCESSOR_DEVICE_H_
 
#include <memory>
#include <vector>
 
#include "Framework/DataProcessorSpec.h"
#include "Framework/Task.h"
#include "EMCALBase/Mapper.h"
#include "EMCALCalibration/PedestalProcessorData.h"
 
namespace o2::emcal
{
 
class Geometry;
 
class PedestalProcessorDevice : o2::framework::Task
{
 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) : mModuleType(ModuleType_t::CELL_MODULE),
                                                                                                    mIndex(moduleIndex),
                                                                                                    mColumn(column),
                                                                                                    mRow(row),
                                                                                                    mColumnShifted(columnshifted),
                                                                                                    mRowShifted(rowshifted) {}
 
    ModuleIndexException(int moduleIndex) : mModuleType(ModuleType_t::LEDMON_MODULE), mIndex(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;     
  };
 
  Geometry* mGeometry = nullptr;
  std::unique_ptr<MappingHandler> mMapper = nullptr;
  PedestalProcessorData mPedestalData;
 
 protected:
  int getCellAbsID(int supermoduleID, int column, int row) const;
  int geLEDMONAbsID(int supermoduleID, int moduleID) const;
 
 public:
  PedestalProcessorDevice() = default;
  ~PedestalProcessorDevice() final = default;
 
  void init(framework::InitContext& ctx) final;
 
  void run(framework::ProcessingContext& ctx) final;
 
  bool isLostTimeframe(framework::ProcessingContext& ctx) const;
 
  void sendData(framework::ProcessingContext& ctx, const PedestalProcessorData& data) const;
};
 
framework::DataProcessorSpec getPedestalProcessorDevice(bool askDistSTF);
 
} // namespace o2::emcal
 
#endif