EMCALChannelScaleFactors.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_CHANNEL_SCALE_FACTORS_H_
#define EMCAL_CHANNEL_SCALE_FACTORS_H_
 
#include <cfloat>
#include "Framework/Logger.h"
#include "EMCALBase/Geometry.h"
 
namespace o2
{
namespace emcal
{
 
class InvalidEnergyIntervalException final : public std::exception
{
 
 public:
  InvalidEnergyIntervalException(float E, unsigned int cellID) : std::exception(),
                                                                 mE(E),
                                                                 mCellID(cellID),
                                                                 mMessage("Invalid energy " + std::to_string(mE) + "for cell " + std::to_string(mCellID) + "]")
  {
  }
 
  ~InvalidEnergyIntervalException() noexcept final = default;
 
  const char* what() const noexcept final { return mMessage.c_str(); }
 
 private:
  float mE;             
  unsigned int mCellID; 
  std::string mMessage; 
};
 
class EnergyIntervals
{
 public:
  EnergyIntervals() = default;
  EnergyIntervals(float min, float max)
  {
    Elow = min;
    Ehigh = max;
  }
  ~EnergyIntervals() = default;
 
  void setEnergy(float min, float max)
  {
    Elow = min;
    Ehigh = max;
  }
  bool isInInterval(float E) const
  {
    LOG(debug) << "EMCALChannelScaleFactors::EnergyIntervals::IsInInterval: Checking if " << E << " is in the interval " << Elow << " - " << Ehigh;
    if (E >= Elow && E < Ehigh) {
      return true;
    } else {
      return false;
    }
  }
 
  bool operator==(const EnergyIntervals& other) const
  {
    if (std::abs(Elow - other.Elow) < FLT_EPSILON && std::abs(Ehigh - other.Ehigh) < FLT_EPSILON) {
      return true;
    } else {
      return false;
    }
  }
  bool operator!=(const EnergyIntervals& other) const
  {
    if (std::abs(Elow - other.Elow) < FLT_EPSILON && std::abs(Ehigh - other.Ehigh) < FLT_EPSILON) {
      return false;
    } else {
      return true;
    }
  }
  bool operator<(const EnergyIntervals& other) const
  {
    if (Elow < other.Elow) {
      return true;
    } else {
      return false;
    }
  }
  bool operator>(const EnergyIntervals& other) const
  {
    if (Elow > other.Elow) {
      return true;
    } else {
      return false;
    }
  }
 
 private:
  float Elow;
  float Ehigh;
 
  ClassDefNV(EnergyIntervals, 1);
};
 
class EMCALChannelScaleFactors
{
 
 public:
  void insertVal(unsigned int cellID, float E_min, float E_max, float scale);
 
  float getScaleVal(unsigned int cellID, float E) const;
 
 private:
  static constexpr int NCells = 17664;                               
  std::array<std::map<EnergyIntervals, float>, NCells> ScaleFactors; 
 
  ClassDefNV(EMCALChannelScaleFactors, 1);
};
 
} // end namespace emcal
 
} // end namespace o2
 
#endif