CalibTOF.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_GLOBTRACKING_CALIBTOF_
#define ALICEO2_GLOBTRACKING_CALIBTOF_
 
#include <Rtypes.h>
#include <array>
#include <vector>
#include <string>
#include <TStopwatch.h>
#include "DataFormatsTOF/CalibInfoTOFshort.h"
#include "DataFormatsTOF/CalibLHCphaseTOF.h"
#include "DataFormatsTOF/CalibTimeSlewingParamTOF.h"
#include "TOFBase/Geo.h"
#include "TH1F.h"
#include "TH1D.h"
#include "TH2F.h"
#include "TF1.h"
#include "TFile.h"
#include "TGraphErrors.h"
#include "TOFBase/CalibTOFapi.h"
 
class TTree;
 
namespace o2
{
 
namespace globaltracking
{
class CalibTOF
{
  using Geo = o2::tof::Geo;
  using CalibTOFapi = o2::tof::CalibTOFapi;
 
 public:
  static constexpr int NSTRIPSPERSTEP = 13; // we chose this number because we process per sector, and
                                            // each sector has 91 = 13x7 strips
  static constexpr int NPADSPERSTEP = Geo::NPADS * NSTRIPSPERSTEP;
  static constexpr int NSTEPSPERSECTOR = 91 / NSTRIPSPERSTEP;
  enum CalibType : int { kLHCphase = 1,
                         kChannelOffset = 2,
                         kChannelTimeSlewing = 4 }; // enum to define which calibration we will do
 
  CalibTOF();
 
  ~CalibTOF();
 
  void run(int flag, int sector = -1);
  void fillOutput(int flag = kLHCphase | kChannelOffset | kChannelTimeSlewing);
 
  void init();
 
  void setInputTreeTOFCollectedCalibInfo(TTree* tree) { mTreeCollectedCalibInfoTOF = tree; }
 
  void setOutputTree(TTree* tr) { mOutputTree = tr; }
 
  void setCollectedCalibInfoTOFBranchName(const std::string& nm) { mCollectedCalibInfoTOFBranchName = nm; }
  void setOutputBranchName(const std::string& nm) { mOutputBranchName = nm; }
 
  const std::string& getCollectedCalibInfoTOFBranchName() const { return mCollectedCalibInfoTOFBranchName; }
  const std::string& getOutputBranchName() const { return mOutputBranchName; }
 
  void print() const;
 
  TH2F* getLHCphaseHisto() { return mHistoLHCphase; }
  TH2F* getChTimeSlewingHistoAll() { return mHistoChTimeSlewingAll; };
  void setMinTimestamp(int minTimestamp) { mMinTimestamp = minTimestamp; }
  void setMaxTimestamp(int maxTimestamp) { mMaxTimestamp = maxTimestamp; }
 
  TGraphErrors* processSlewing(TH2F* histo, Bool_t forceZero, TF1* fitFunc);
  Int_t FitPeak(TF1* fitFunc, TH1* h, Float_t startSigma, Float_t nSigmaMin, Float_t nSigmaMax, const char* debuginfo = "", TH2* hdbg = nullptr);
 
  void setDebugMode(Int_t flag = kTRUE) { mDebugMode = flag; }
  Int_t getDebugMode() const { return mDebugMode; }
 
  void merge(const char* name);
 
  void flagProblematics(); 
 
  void setNsigmaFractionProblematicCut(float value) { mNsigmaFractionProblematicCut = value; }
  void setNsigmaSigmaProblematicCut(float value) { mNsigmaSigmaProblematicCut = value; }
  float getNsigmaFractionProblematicCut() const { return mNsigmaFractionProblematicCut; }
  float getNsigmaSigmaProblematicCut() const { return mNsigmaSigmaProblematicCut; }
 
  void setFillCCDB(bool flag) { mFillCCDB = flag; }
  bool getFillCCDB() const { return mFillCCDB; }
 
  void setCCDBpath(const std::string path) { mCCDBpath = path; }
  std::string getCCDBpath() const { return mCCDBpath; }
 
 private:
  Int_t mDebugMode = 0; 
 
  float mNsigmaFractionProblematicCut = 5; 
  float mNsigmaSigmaProblematicCut = 5;    
 
  void fillLHCphaseCalibInput(std::vector<o2::dataformats::CalibInfoTOFshort>* calibinfotof);                                                                                                    
  void doLHCPhaseCalib();                                                                                                                                                                        // calibrate with respect LHC phase
  void fillChannelCalibInput(std::vector<o2::dataformats::CalibInfoTOFshort>* calibinfotof, float offset, int ipad, TH1F* histo, std::vector<o2::dataformats::CalibInfoTOFshort>* calibTimePad); // we will fill the input for the channel-level calibration
  void fillChannelTimeSlewingCalib(float offset, int ipad, TH2F* histo, std::vector<o2::dataformats::CalibInfoTOFshort>* calibTimePad);                                                          // we will fill the input for the channel-time-slewing calibration
  float doChannelCalibration(int ipad, TH1F* histo, TF1* func);                                                                                                                                  // calibrate single channel from histos --> return fraction of entries under the peak
  void resetChannelLevelHistos(TH1F* histoOffset[NPADSPERSTEP], TH2F* histoTimeSlewing, std::vector<o2::dataformats::CalibInfoTOFshort>* calibTimePad[NPADSPERSTEP]);                            // reset signle channel histos
 
  // objects needed for calibration
  TH2F* mHistoLHCphase = nullptr;
  TH2F* mHistoChTimeSlewingAll; // time slewing all channels
 
  TH1D* mProjTimeSlewingTemp; // temporary histo for time slewing
 
  void attachInputTrees();
  bool loadTOFCollectedCalibInfo(TTree* localTree, int& currententry, int increment = 1);
 
  //================================================================
 
  // Data members
 
  bool mInitDone = false;                                  
  bool mFillCCDB = false;                                  
  std::string mCCDBpath = "http://alice-ccdb.cern.ch";     
 
 
  // to be done later
 
  TTree* mTreeCollectedCalibInfoTOF = nullptr; 
 
  TTree* mOutputTree = nullptr; 
 
  std::string mCollectedCalibInfoTOFBranchName = "TOFCollectedCalibInfo"; 
  std::string mOutputBranchName = "TOFCalibParam";                        
  // output calibration
  o2::dataformats::CalibLHCphaseTOF* mLHCphaseObj;            
  o2::dataformats::CalibTimeSlewingParamTOF* mTimeSlewingObj; 
  float mCalibChannelOffset[Geo::NCHANNELS];                  
  float mCalibChannelOffsetErr[Geo::NCHANNELS];               
 
  // previous calibration read from CCDB
  float mInitialCalibChannelOffset[Geo::NCHANNELS]; 
 
  TF1* mFuncLHCphase = nullptr;
 
  int mMinTimestamp = 0; 
 
  int mMaxTimestamp = 1; 
 
  CalibTOFapi mCalibTOFapi; 
 
  //  ClassDefNV(CalibTOF, 1);
};
} // namespace globaltracking
} // namespace o2
 
#endif