CalibdEdx.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_TPC_CALIBDEDX_H_
#define ALICEO2_TPC_CALIBDEDX_H_
 
#include <cstddef>
#include <gsl/span>
#include <string_view>
 
// o2 includes
#include "CommonDataFormat/TFIDInfo.h"
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTPC/TrackCuts.h"
#include "DataFormatsTPC/Defs.h"
#include "DataFormatsTPC/CalibdEdxCorrection.h"
#include "DetectorsBase/Propagator.h"
#include "CommonUtils/TreeStreamRedirector.h"
 
// boost includes
#include <boost/histogram.hpp>
#include "THn.h"
 
class TLinearFitter;
 
namespace o2::tpc
{
 
class CalibdEdx
{
 public:
  enum Axis {
    dEdx,
    Tgl,
    Snp,
    Sector,
    Stack,
    Charge,
    Size 
  };
 
  // Interger histogram axis identifying the GEM stacks, without under and overflow bins.
  using IntAxis = boost::histogram::axis::integer<int, boost::histogram::use_default, boost::histogram::axis::option::none_t>;
  // Float axis to store data, without under and overflow bins.
  using FloatAxis = boost::histogram::axis::regular<float, boost::histogram::use_default, boost::histogram::use_default, boost::histogram::axis::option::none_t>;
 
  using TFIDInfo = o2::dataformats::TFIDInfo;
 
  // Histogram axes types
  using AxesType = std::tuple<
    FloatAxis, // dEdx
    FloatAxis, // Tgl
    FloatAxis, // Snp
    IntAxis,   // sector
    IntAxis,   // stackType
    IntAxis    // Charge
    >;
 
  using Hist = boost::histogram::histogram<AxesType>;
 
  CalibdEdx(const CalibdEdx& other);
 
  CalibdEdx(int dEdxBins = 70, float mindEdx = 10, float maxdEdx = 90, int angularBins = 36, bool fitSnp = false);
 
  void setCuts(const TrackCuts& cuts) { mCuts = cuts; }
  void setApplyCuts(bool apply) { mApplyCuts = apply; }
  bool getApplyCuts() const { return mApplyCuts; }
 
  void setSectorFitThreshold(int minEntries) { mSectorThreshold = minEntries; }
  void set1DFitThreshold(int minEntries) { m1DThreshold = minEntries; }
  void set2DFitThreshold(int minEntries) { m2DThreshold = minEntries; }
 
  int getSectorFitThreshold() const { return mSectorThreshold; }
  int getTglFitThreshold() const { return m1DThreshold; }
  int getSnpFitThreshold() const { return m2DThreshold; }
 
  void setElectronCut(float cut, int passes = 3, float lowCutFactor = 1.5)
  {
    mFitCut = cut;
    mFitPasses = passes;
    mFitLowCutFactor = lowCutFactor;
  }
 
  void setMaterialType(o2::base::Propagator::MatCorrType materialType) { mMatType = materialType; }
 
  void fill(const TrackTPC& tracks);
  void fill(const gsl::span<const TrackTPC>);
  void fill(const std::vector<TrackTPC>& tracks) { fill(gsl::span(tracks)); }
 
  void fill(const TFIDInfo& tfid, const gsl::span<const TrackTPC> tracks)
  {
    mTFID = tfid;
    fill(tracks);
  }
  void fill(const TFIDInfo& tfid, const std::vector<TrackTPC>& tracks) { fill(tfid, gsl::span(tracks)); }
 
  const TFIDInfo& getTFID() const { return mTFID; }
 
  void merge(const CalibdEdx* other);
 
  void finalize(const bool useGausFits = true, const bool averageSectors = false);
 
  const Hist& getHist() const { return mHist; }
  THnF* getRootHist() const;
 
  const CalibdEdxCorrection& getCalib() const { return mCalib; }
 
  void setCalibrationInput(const CalibdEdxCorrection& calib) { mCalibIn = calib; }
  const CalibdEdxCorrection& getCalibrationInput() const { return mCalibIn; }
 
  int minStackEntries() const;
 
  bool hasEnoughData(float minEntries) const;
 
  static int findTrackSector(const TrackTPC& track, GEMstack, bool& ok);
 
  void print() const;
 
  void writeTTree(std::string_view fileName) const;
 
  void enableDebugOutput(std::string_view fileName);
 
  void disableDebugOutput();
 
  void finalizeDebugOutput() const;
 
  bool hasDebugOutput() const { return static_cast<bool>(mDebugOutputStreamer); }
 
  constexpr static float MipScale = 1.0 / 50.0; 
 
  constexpr static float scaleTgl(float tgl, GEMstack rocType) { return tgl / conf_dedx_corr::TglScale[rocType]; }
  constexpr static float recoverTgl(float scaledTgl, GEMstack rocType) { return scaledTgl * conf_dedx_corr::TglScale[rocType]; }
 
  void dumpToFile(const char* outFile);
 
  static CalibdEdx readFromFile(const char* inFile);
 
  void setSigmaFitRange(const float lowerSigma, const float upperSigma);
 
 private:
  // ATTENTION: Adjust copy constructor
  bool mFitSnp{};
  bool mApplyCuts{true};         
  TrackCuts mCuts{0.3, 0.7, 60}; 
  int mSectorThreshold = 1000;   
  int m1DThreshold = 500;        
  int m2DThreshold = 5000;       
  float mFitCut = 0.2;           
  float mFitLowCutFactor = 1.5;  
  int mFitPasses = 3;            
  TFIDInfo mTFID{};              
  float mSigmaUpper = 1.;        
  float mSigmaLower = 1.5;       
 
  Hist mHist;                     
  CalibdEdxCorrection mCalib{};   
  CalibdEdxCorrection mCalibIn{}; 
 
  o2::base::Propagator::MatCorrType mMatType{}; 
 
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugOutputStreamer; 
 
  THnF* getTHnF() const;
 
  void fitHistGaus(TLinearFitter& fitter, CalibdEdxCorrection& corr, const CalibdEdxCorrection* stackMean = nullptr);
 
  void setFromRootHist(const THnF* hist);
 
  ClassDefNV(CalibdEdx, 5);
};
 
} // namespace o2::tpc
 
#endif