NonlinearityHandler.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 ALICEO2_EMCAL_NONLINEARITYHANDLER__H
#define ALICEO2_EMCAL_NONLINEARITYHANDLER__H
 
#include <exception>
#include <iosfwd>
#include <unordered_map>
#include <string>
#include <Rtypes.h>
#include "DataFormatsEMCAL/AnalysisCluster.h"
 
namespace o2::emcal
{
 
class NonlinearityHandler
{
 public:
  class UninitException : public std::exception
  {
   public:
    UninitException() = default;
 
    ~UninitException() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return "Nonlinearity handler not initialized";
    }
  };
 
  enum class NonlinType_t {
    DATA_TESTBEAM_SHAPER,         
    DATA_TESTBEAM_SHAPER_WOSCALE, 
    DATA_TESTBEAM_CORRECTED,      
    DATA_TESTBEAM_CORRECTED_V2,   
    DATA_TESTBEAM_CORRECTED_V3,   
    DATA_TESTBEAM_CORRECTED_V4,   
    MC_TESTBEAM_FINAL,            
    MC_PI0,                       
    MC_PI0_V2,                    
    MC_PI0_V3,                    
    MC_PI0_V5,                    
    MC_PI0_V6,                    
    UNKNOWN                       
  };
 
  static NonlinType_t getNonlinType(const std::string_view name);
 
  static const char* getNonlinName(NonlinType_t nonlin);
 
  NonlinearityHandler() = default;
 
  NonlinearityHandler(NonlinType_t nonlintype);
 
  ~NonlinearityHandler() = default;
 
  void setNonlinType(NonlinType_t nonlintype)
  {
    mNonlinearyFunction = nonlintype;
    initParams();
  }
 
  double getCorrectedClusterEnergy(double energy) const;
 
  double getCorrectedClusterEnergy(const AnalysisCluster& cluster) const { return getCorrectedClusterEnergy(cluster.E()); }
 
  static double evaluateShaperCorrectionCellEnergy(double energy, double ecalibHG = 1);
 
  void printStream(std::ostream& stream) const;
 
 private:
  NonlinType_t mNonlinearyFunction = NonlinType_t::UNKNOWN; 
  bool mApplyScaleCorrection = false;                       
  std::array<double, 11> mNonlinearityParam;                
 
  double evaluateTestbeamCorrected(double energy) const;
 
  double evaluateTestbeamShaper(double energy) const;
 
  double evaluatePi0MC(double energy) const;
 
  double evaluatePi0MCv2(double energy) const;
 
  void initParams();
 
  ClassDefNV(NonlinearityHandler, 1)
};
 
class NonlinearityFactory
{
 public:
  class FunctionNotFoundExcpetion : public std::exception
  {
   public:
    FunctionNotFoundExcpetion(const std::string_view name) : mName(name), mMessage()
    {
      mMessage = "Nonlinearity funciton " + mName + " not found";
    }
 
    ~FunctionNotFoundExcpetion() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return mMessage.data();
    }
 
    const std::string_view getNonlinName() const noexcept { return mName.data(); }
 
   private:
    std::string mName;    
    std::string mMessage; 
  };
 
  class NonlinInitError : public std::exception
  {
   public:
    NonlinInitError() {}
 
    ~NonlinInitError() noexcept final = default;
 
    const char* what() const noexcept final
    {
      return "Failed constructing nonlinearity handler";
    }
  };
 
  static NonlinearityFactory& getInstance()
  {
    static NonlinearityFactory currentInstance;
    return currentInstance;
  }
 
  NonlinearityHandler& getNonlinearity(NonlinearityHandler::NonlinType_t nonlintype);
 
  NonlinearityHandler& getNonlinearity(const std::string_view nonlintype);
 
 private:
  NonlinearityFactory() { initNonlinNames(); }
 
  ~NonlinearityFactory() = default;
 
  void initNonlinNames();
 
  NonlinearityHandler::NonlinType_t getNonlinType(const std::string_view nonlinName) const;
 
  std::unordered_map<NonlinearityHandler::NonlinType_t, NonlinearityHandler> mHandlers; 
  std::unordered_map<std::string, NonlinearityHandler::NonlinType_t> mNonlinNames;      
 
  ClassDefNV(NonlinearityFactory, 1)
};
 
std::ostream& operator<<(std::ostream& in, const NonlinearityHandler& handler);
 
} // namespace o2::emcal
 
#endif // ALICEO2_EMCAL_NONLINEARITYHANDLER__H