CalibratordEdx.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_CALIBRATORDEDX_H_
#define ALICEO2_TPC_CALIBRATORDEDX_H_
 
#include <array>
#include <cstdint>
#include <string_view>
#include <utility>
 
// o2 includes
#include "DataFormatsTPC/TrackTPC.h"
#include "DataFormatsTPC/TrackCuts.h"
#include "CCDB/CcdbObjectInfo.h"
#include "DetectorsCalibration/TimeSlotCalibration.h"
#include "DetectorsCalibration/TimeSlot.h"
#include "TPCCalibration/CalibdEdx.h"
#include "CommonUtils/TreeStreamRedirector.h"
#include "DetectorsBase/Propagator.h"
 
namespace o2::tpc
{
 
class CalibratordEdx final : public o2::calibration::TimeSlotCalibration<o2::tpc::CalibdEdx>
{
  using TFType = o2::calibration::TFType;
  using Slot = o2::calibration::TimeSlot<CalibdEdx>;
  using TFinterval = std::vector<std::pair<TFType, TFType>>;
  using TimeInterval = std::vector<std::pair<long, long>>;
  using CalibVector = std::vector<CalibdEdxCorrection>;
 
 public:
  CalibratordEdx() = default;
 
  void setHistParams(int dEdxBins, float mindEdx, float maxdEdx, int angularBins, bool fitSnp)
  {
    mdEdxBins = dEdxBins;
    mMindEdx = mindEdx;
    mMaxdEdx = maxdEdx;
    mAngularBins = angularBins;
    mFitSnp = fitSnp;
  }
  void setCuts(const TrackCuts& cuts) { mCuts = cuts; }
  void setMinEntries(int minEntries) { mMinEntries = minEntries; }
  void setFitThresholds(int minEntriesSector, int minEntries1D, int minEntries2D) { mFitThreshold = {minEntriesSector, minEntries1D, minEntriesSector}; }
  void setApplyCuts(bool apply) { mApplyCuts = apply; }
  void setElectronCut(std::tuple<float, int, float> values) { mElectronCut = values; }
  void setMaterialType(o2::base::Propagator::MatCorrType materialType) { mMatType = materialType; }
  void setMakeGaussianFits(const bool makeGaussianFits) { mMakeGaussianFits = makeGaussianFits; }
 
  bool hasEnoughData(const Slot& slot) const final { return slot.getContainer()->hasEnoughData(mMinEntries); };
 
  void initOutput() final;
 
  void finalizeSlot(Slot&) final;
 
  Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) final;
 
  const CalibVector& getCalibs() const { return mCalibs; }
 
  const TFinterval& getTFinterval() const { return mTFIntervals; }
 
  const TimeInterval& getTimeIntervals() const { return mTimeIntervals; }
 
  void enableDebugOutput(std::string_view fileName);
 
  void disableDebugOutput();
 
  bool hasDebugOutput() const { return static_cast<bool>(mDebugOutputStreamer); }
 
  void finalizeDebugOutput() const;
 
  void setTrackDebug(bool debug) { mEnableTrackDebug = debug; }
 
  void setDumpHistograms(uint32_t flags) { mDumpHistograms = flags; }
 
  uint32_t getDumpHistograms() const { return mDumpHistograms; }
 
 private:
  int mdEdxBins{};                              
  float mMindEdx{};                             
  float mMaxdEdx{};                             
  int mAngularBins{};                           
  bool mFitSnp{};                               
  bool mEnableTrackDebug{false};                
  int mMinEntries{};                            
  uint32_t mDumpHistograms{0};                  
  std::array<int, 3> mFitThreshold{};           
  bool mApplyCuts{true};                        
  std::tuple<float, int, float> mElectronCut{}; 
  TrackCuts mCuts;                              
  o2::base::Propagator::MatCorrType mMatType{}; 
  bool mMakeGaussianFits{};                     
 
  TFinterval mTFIntervals;     
  TimeInterval mTimeIntervals; 
  CalibVector mCalibs;         
 
  std::unique_ptr<o2::utils::TreeStreamRedirector> mDebugOutputStreamer; 
 
  ClassDefOverride(CalibratordEdx, 3);
};
 
} // namespace o2::tpc
#endif