CalibPulser.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_CALIBPULSER_H_
#define ALICEO2_TPC_CALIBPULSER_H_
 
 
#include <vector>
#include <memory>
#include <unordered_map>
 
#include "TH2S.h"
 
#include "DataFormatsTPC/Defs.h"
#include "TPCBase/CalDet.h"
#include "TPCBase/CRU.h"
#include "TPCBase/PadROCPos.h"
#include "TPCCalibration/CalibRawBase.h"
 
namespace o2
{
namespace tpc
{
 
 
class CalibPulser : public CalibRawBase
{
 public:
  using VectorType = std::vector<float>;
  using PtrVectorType = std::vector<std::unique_ptr<TH2S>>;
 
  CalibPulser(PadSubset padSubset = PadSubset::ROC);
 
  ~CalibPulser() override = default;
 
  void init();
 
  Int_t updateROC(const Int_t roc, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final;
 
  Int_t updateCRU(const CRU& cru, const Int_t row, const Int_t pad,
                  const Int_t timeBin, const Float_t signal) final { return 0; }
 
  void resetData();
 
  void setADCRange(int minADC, int maxADC)
  {
    mADCMin = minADC;
    mADCMax = maxADC;
    mNumberOfADCs = mADCMax - mADCMin + 1;
  }
 
  void setTimeBinRange(int first, int last)
  {
    mFirstTimeBin = first;
    mLastTimeBin = last;
    // TODO: until automatic T0 calibration is done we use the same time range
    //       as for the time bin selection
    mXminT0 = mFirstTimeBin;
    mXmaxT0 = mLastTimeBin;
  }
 
  void setPedestalAndNoise(const CalPad* pedestal, const CalPad* noise)
  {
    mPedestal = pedestal;
    mNoise = noise;
  }
 
  void setT0Binning(int nbins, float min, float max)
  {
    mNbinsT0 = nbins;
    mXminT0 = min;
    mXmaxT0 = max;
  }
 
  void setWidthBinning(int nbins, float min, float max)
  {
    mNbinsWidth = nbins;
    mXminWidth = min;
    mXmaxWidth = max;
  }
 
  void setQtotBinning(int nbins, float min, float max)
  {
    mNbinsQtot = nbins;
    mXminQtot = min;
    mXmaxQtot = max;
  }
 
  void setMinQtot(float minQtot) { mMinimumQtot = minQtot; }
 
  void setMinQmax(float minQmax) { mMinimumQmax = minQmax; }
 
  void setMaxTimeBinRange(int max) { mMaxTimeBinRange = max; }
 
  void analyse();
 
  const CalPad& getT0() const { return mCalDets.at("T0"); }
 
  const CalPad& getWidth() const { return mCalDets.at("Width"); }
 
  const CalPad& getQtot() const { return mCalDets.at("Qtot"); }
 
  const auto& getCalDets() const { return mCalDets; }
 
  void dumpToFile(const std::string filename, uint32_t type = 0) final;
 
  void endReader() final;
 
  void endEvent() final{};
 
 private:
  // reference histogram ranges
  int mNbinsT0;     
  float mXminT0;    
  float mXmaxT0;    
  int mNbinsQtot;   
  float mXminQtot;  
  float mXmaxQtot;  
  int mNbinsWidth;  
  float mXminWidth; 
  float mXmaxWidth; 
 
  int mFirstTimeBin;                                
  int mLastTimeBin;                                 
  int mADCMin;                                      
  int mADCMax;                                      
  int mNumberOfADCs;                                
  int mPeakIntMinus;                                
  int mPeakIntPlus;                                 
  float mMinimumQtot;                               
  float mMinimumQmax;                               
  int mMaxTimeBinRange;                             
  std::unordered_map<std::string, CalPad> mCalDets; 
 
  const CalPad* mPedestal; 
  const CalPad* mNoise;    
 
  std::map<PadROCPos, VectorType> mPulserData; 
 
  std::array<std::vector<size_t>, ROC::MaxROC> mTimeBinEntries{}; 
 
  PtrVectorType mT0Histograms;    
  PtrVectorType mWidthHistograms; 
  PtrVectorType mQtotHistograms;  
 
  struct PulserData {
    float mT0{0.f};
    float mWidth{0.f};
    float mQtot{0.f};
 
    bool isValid() const { return (mT0 > 0.f) || (mWidth > 0.f) || (mQtot > 0.f); }
  };
 
  struct ElemPair {
    size_t first{0};
    size_t last{0};
  };
 
  TH2S* getHistogram(ROC roc, CalibPulser::PtrVectorType& rocVector,
                     int nbins, float min, float max,
                     std::string_view type, bool create /*=kFALSE*/);
 
  TH2S* getHistoT0(ROC roc, Bool_t force)
  {
    return getHistogram(roc, mT0Histograms, mNbinsT0, mXminT0, mXmaxT0, "T0", force);
  }
 
  TH2S* getHistoQtot(ROC roc, Bool_t force)
  {
    return getHistogram(roc, mQtotHistograms, mNbinsQtot, mXminQtot, mXmaxQtot, "Qtot", force);
  }
 
  TH2S* getHistoSigma(ROC roc, Bool_t force)
  {
    return getHistogram(roc, mWidthHistograms, mNbinsWidth, mXminWidth, mXmaxWidth, "Width", force);
  }
 
  PulserData processPadData(const PadROCPos& padROCPos, const VectorType& adcData, const ElemPair& range);
 
  std::array<ElemPair, ROC::MaxROC> getTimeRangeROCs();
 
  void resetEvent() final {}
};
 
} // namespace tpc
 
} // namespace o2
#endif