CellRecalibrator.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 ALCEO2_EMCAL_CELLRECALIBRATOR_H
#define ALCEO2_EMCAL_CELLRECALIBRATOR_H
 
#include <exception>
#include <iosfwd>
#include <optional>
#include <vector>
#include <tuple>
#include <gsl/span>
 
#include "Rtypes.h"
 
#include <DataFormatsEMCAL/Constants.h>
#include <EMCALCalib/BadChannelMap.h>
#include <EMCALCalib/TimeCalibrationParams.h>
#include <EMCALCalib/GainCalibrationFactors.h>
 
namespace o2
{
 
namespace emcal
{
 
class CellRecalibrator
{
 public:
  class CellTypeException : public std::exception
  {
   public:
    CellTypeException() = default;
 
    ~CellTypeException() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return "Only possible to calibrate cells of type high gain or low gain";
    }
  };
 
  CellRecalibrator() = default;
 
  ~CellRecalibrator() = default;
 
  void setBadChannelMap(const BadChannelMap* bcm) { mBadChannelMap = bcm; }
 
  void setTimeCalibration(const TimeCalibrationParams* tcp) { mTimeCalibration = tcp; }
 
  void setGainCalibration(const GainCalibrationFactors* gcf) { mGainCalibration = gcf; }
 
  bool hasBadChannelMap() const { return mBadChannelMap != nullptr; }
 
  bool hasTimeCalibration() const { return mTimeCalibration != nullptr; }
 
  bool hasGainCalibration() const { return mGainCalibration != nullptr; }
 
  const BadChannelMap* getBadChannelMap() const { return mBadChannelMap; }
 
  const TimeCalibrationParams* getTimeCalibration() const { return mTimeCalibration; }
 
  const GainCalibrationFactors* getGainCalibration() const { return mGainCalibration; }
 
  template <typename T>
  std::optional<T> getCalibratedCell(const T& inputcell) const
  {
    if (!(inputcell.getHighGain() || inputcell.getLowGain())) {
      throw CellTypeException();
    }
    if (hasBadChannelMap()) {
      if (mBadChannelMap->getChannelStatus(inputcell.getTower()) != BadChannelMap::MaskType_t::GOOD_CELL) {
        return std::optional<T>();
      }
    }
 
    float calibratedEnergy = inputcell.getEnergy();
    float calibratedTime = inputcell.getTimeStamp();
 
    if (hasTimeCalibration()) {
      calibratedTime -= mTimeCalibration->getTimeCalibParam(inputcell.getTower(), inputcell.getLowGain());
    }
 
    if (hasGainCalibration()) {
      calibratedEnergy *= mGainCalibration->getGainCalibFactors(inputcell.getTower());
    }
    return std::make_optional<T>(inputcell.getTower(), calibratedEnergy, calibratedTime, inputcell.getHighGain() ? ChannelType_t::HIGH_GAIN : ChannelType_t::LOW_GAIN);
  }
 
  template <typename T>
  std::tuple<std::vector<T>, std::vector<int>> getCalibratedCells(const gsl::span<const T> inputcells)
  {
    std::vector<T> result;
    std::vector<int> indices;
    int currentindex = 0;
    for (const auto& cellToCalibrate : inputcells) {
      if (!(cellToCalibrate.getHighGain() || cellToCalibrate.getLowGain())) {
        currentindex++;
        continue;
      }
      auto calibrated = getCalibratedCell(cellToCalibrate);
      if (calibrated) {
        result.push_back(calibrated.value());
        indices.emplace_back(currentindex);
      }
      currentindex++;
    }
    return std::make_tuple(result, indices);
  }
 
  void printStream(std::ostream& stream) const;
 
 private:
  const BadChannelMap* mBadChannelMap = nullptr;            
  const TimeCalibrationParams* mTimeCalibration = nullptr;  
  const GainCalibrationFactors* mGainCalibration = nullptr; 
 
  ClassDefNV(CellRecalibrator, 1);
};
 
std::ostream& operator<<(std::ostream& in, const CellRecalibrator& calib);
 
} // namespace emcal
 
} // namespace o2
 
#endif // !ALCEO2_EMCAL_CELLRECALIBRATOR_H