CalibratorPadGainTracks.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_CALIBRATORPADGAINTRACKS_H
#define ALICEO2_TPC_CALIBRATORPADGAINTRACKS_H
 
#include "DetectorsCalibration/TimeSlotCalibration.h"
#include "DetectorsCalibration/TimeSlot.h"
#include "TPCCalibration/CalibPadGainTracksBase.h"
 
namespace o2::tpc
{
class CalibratorPadGainTracks : public o2::calibration::TimeSlotCalibration<CalibPadGainTracksBase>
{
  using TFType = o2::calibration::TFType;
  using Slot = o2::calibration::TimeSlot<CalibPadGainTracksBase>;
  using TFinterval = std::vector<std::pair<TFType, TFType>>;
  using CalibVector = std::vector<std::unordered_map<std::string, CalPad>>; // extracted gain map
  using TimeInterval = std::vector<std::pair<long, long>>;
 
 public:
  CalibratorPadGainTracks() = default;
 
  ~CalibratorPadGainTracks() final = default;
 
  void initOutput() final;
 
  bool hasEnoughData(const Slot& slot) const final { return slot.getContainer()->hasEnoughData(mMinEntries); };
 
  void finalizeSlot(Slot& slot) final;
 
  Slot& emplaceNewSlot(bool front, TFType tstart, TFType tend) final;
 
  void setMinEntries(const size_t minEntries) { mMinEntries = minEntries; }
 
  void setNormalizationType(const CalibPadGainTracksBase::NormType type) { mNormType = type; }
 
  size_t getMinEntries() const { return mMinEntries; }
 
  void setTruncationRange(const float low = 0.05f, const float high = 0.6f);
 
  void setRelGainRange(const float minRelgain = 0.1f, const float maxRelgain = 2.f);
 
  void setMinEntriesMean(const int minEntriesMean) { mMinEntriesMean = minEntriesMean; }
 
  void setWriteDebug(const bool writeDebug) { mWriteDebug = writeDebug; }
 
  void setStoreNClCCDB(const bool storeNClCCDB) { mStoreNClCCDB = storeNClCCDB; }
 
  void setStoreRMSCCDB(const bool storeRMSCCDB) { mStoreRMSCCDB = storeRMSCCDB; }
 
  bool setLogTransformQ(const bool logTransformQ) { return mLogTransformQ = logTransformQ; }
 
  void setUseLastExtractedMapAsReference(const bool useLastMap) { mUseLastExtractedMapAsReference = useLastMap; }
 
  bool getWriteDebug() const { return mWriteDebug; }
 
  float getTruncationRangeLow() const { return mLowTruncation; }
 
  float getTruncationRangeUp() const { return mUpTruncation; }
 
  const TFinterval& getTFinterval() const { return mIntervals; }
 
  const TimeInterval& getTimeIntervals() const { return mTimeIntervals; }
 
  auto getCalibs() && { return std::move(mCalibs); }
 
  bool hasCalibrationData() const { return mCalibs.size() > 0; }
 
 private:
  TFinterval mIntervals;                                                      
  TimeInterval mTimeIntervals;                                                
  CalibVector mCalibs;                                                        
  float mLowTruncation{0.05f};                                                
  float mUpTruncation{0.6f};                                                  
  float mMinRelgain{0.1f};                                                    
  float mMaxRelgain{2.f};                                                     
  int mMinEntriesMean{10};                                                    
  size_t mMinEntries{30};                                                     
  bool mWriteDebug = false;                                                   
  CalibPadGainTracksBase::NormType mNormType{CalibPadGainTracksBase::region}; 
  bool mUseLastExtractedMapAsReference{false};                                
  std::unique_ptr<CalPad> mGainMapLastIteration;                              
  bool mStoreNClCCDB{false};                                                  
  bool mStoreRMSCCDB{false};                                                  
  bool mLogTransformQ{true};                                                  
 
  ClassDefOverride(CalibratorPadGainTracks, 1);
};
} // namespace o2::tpc
 
#endif