CaloRawFitter.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 EMCALRAWFITTER_H_
#define EMCALRAWFITTER_H_
 
#include <iosfwd>
#include <array>
#include <optional>
#include <string_view>
#include <Rtypes.h>
#include <gsl/span>
#include "EMCALReconstruction/CaloFitResults.h"
#include "DataFormatsEMCAL/Constants.h"
#include "EMCALReconstruction/Bunch.h"
 
namespace o2
{
 
namespace emcal
{
 
class CaloRawFitter
{
 
 public:
  enum class RawFitterError_t {
    SAMPLE_UNINITIALIZED, 
    FIT_ERROR,            
    CHI2_ERROR,           
    BUNCH_NOT_OK,         
    LOW_SIGNAL            
  };
 
  static std::string createErrorMessage(RawFitterError_t fiterror) { return getErrorTypeDescription(fiterror); }
 
  static int getErrorNumber(RawFitterError_t fiterror);
 
  static RawFitterError_t intToErrorType(unsigned int fiterror);
 
  static constexpr int getNumberOfErrorTypes() noexcept { return 5; }
 
  static const char* getErrorTypeName(RawFitterError_t fiterror);
 
  static const char* getErrorTypeName(unsigned int fiterror)
  {
    return getErrorTypeName(intToErrorType(fiterror));
  }
 
  static const char* getErrorTypeTitle(RawFitterError_t fiterror);
 
  static const char* getErrorTypeTitle(unsigned int fiterror)
  {
    return getErrorTypeTitle(intToErrorType(fiterror));
  }
 
  static const char* getErrorTypeDescription(RawFitterError_t fiterror);
 
  static const char* getErrorTypeDescription(unsigned int fiterror)
  {
    return getErrorTypeDescription(intToErrorType(fiterror));
  }
 
  CaloRawFitter(const char* name, const char* nameshort);
 
  virtual ~CaloRawFitter() = default;
 
  virtual CaloFitResults evaluate(const gsl::span<const Bunch> bunchvector) = 0;
 
  std::tuple<int, int, float, short, short, float, int, int> preFitEvaluateSamples(const gsl::span<const Bunch> bunchvector, int adcThreshold);
 
  void setTimeConstraint(int min, int max);
 
  void setIsZeroSuppressed(bool iszs = true) { mIsZerosupressed = iszs; }
  void setAmpCut(float cut) { mAmpCut = cut; }
  void setNsamplePed(int i) { mNsamplePed = i; }
  void setL1Phase(double phase) { mL1Phase = phase; }
 
  bool getIsZeroSuppressed() const { return mIsZerosupressed; }
  float getAmpCut() const { return mAmpCut; }
  int getNsamplePed() const { return mNsamplePed; }
 
  // access to array info
  double getReversed(const int i) const { return mReversed[i]; }
  const std::string_view getAlgoName() const { return mName.c_str(); }
  const std::string_view getAlgoAbbr() const { return mNameShort.c_str(); }
 
  FitAlgorithm getAlgo() const { return mAlgo; }
 
  std::tuple<short, int> getMaxAmplitudeBunch(const Bunch& bunchx) const;
 
  unsigned short getMaxAmplitudeBunch(const gsl::span<unsigned short> data) const;
 
  bool isMaxADCBunchEdge(const Bunch& bunch) const;
 
  bool isInTimeRange(int indexMaxADC, int maxtime, int mintime) const;
 
  std::tuple<float, std::array<double, constants::EMCAL_MAXTIMEBINS>> reverseAndSubtractPed(const Bunch& bunch) const;
 
  std::tuple<short, short, short> selectMaximumBunch(const gsl::span<const Bunch>& bunchvector);
 
  std::tuple<int, int> findPeakRegion(const gsl::span<double> adcValues, short indexMaxADC, int threshold) const;
 
  double evaluatePedestal(const gsl::span<const uint16_t> data, std::optional<int> length) const;
 
  double calculateChi2(double amp, double time,
                       int first, int last,
                       double adcErr = 1,
                       double tau = 2.35) const;
 
  int getMinTimeIndex() const { return mMinTimeIndex; }
  int getMaxTimeIndex() const { return mMaxTimeIndex; }
 
 protected:
  std::array<double, constants::EMCAL_MAXTIMEBINS> mReversed; 
 
  int mMinTimeIndex; 
  int mMaxTimeIndex; 
 
  float mAmpCut; 
 
  int mNsamplePed; 
 
  bool mIsZerosupressed; 
 
  std::string mName;      
  std::string mNameShort; 
 
  FitAlgorithm mAlgo; 
 
  double mL1Phase; 
 
  double mAmp; 
 
  ClassDefNV(CaloRawFitter, 1);
}; // CaloRawFitter
 
std::ostream& operator<<(std::ostream& stream, const CaloRawFitter::RawFitterError_t error);
 
} // namespace emcal
 
} // namespace o2
#endif