CbmCaInputQaBase.h

Go to the documentation of this file.

/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */

 
 
#pragma once
 
#include "CaMonitor.h"
#include "CbmCaHitQaData.h"
#include "CbmCaInputQaBase.h"
#include "CbmL1DetectorID.h"
#include "CbmMCDataManager.h"
#include "CbmPixelHit.h"
#include "CbmQaTask.h"
#include "CbmRecoSetupManager.h"
 
#include <TMath.h>
 
#include <set>
#include <unordered_map>
#include <vector>
 
class CbmMatch;
class CbmMCEventList;
class CbmMCDataArray;
class CbmMCDataManager;
class CbmMCTrack;
class CbmStsHit;
class CbmStsPoint;
class CbmTimeSlice;
class FairMCPoint;
class TClonesArray;
class TH1F;
class TH2F;
class TProfile;
class TProfile2D;
class CbmDigiManager;
 
namespace
{
  using cbm::algo::ca::EDetectorID;
  using cbm::algo::ca::Monitor;
  using cbm::algo::yaml::Property;
}  // namespace

template<EDetectorID DetID>
class CbmCaInputQaBase : public CbmQaTask {
 protected:
  using Point_t = cbm::ca::PointTypes_t::at<DetID>;  
  using Hit_t   = cbm::ca::HitTypes_t::at<DetID>;    

  struct Config {
    struct McTrackCuts {
      double fMinMom   = 0.1;   
      double fMaxTheta = 60.;   
      bool fbPrimary   = true;  
      /* clang-format off */
      CBM_YAML_PROPERTIES(
        Property(&McTrackCuts::fMinMom, "MinMom", "Minimal momentum at the exit of the station [GeV/c]"),
        Property(&McTrackCuts::fMaxTheta, "MaxTheta", "Maximal theta at the exit of the station [grad]"),
        Property(&McTrackCuts::fbPrimary, "IsPrimary", "Is track primary")
      );
      /* clang-format on */
    };
 
    McTrackCuts fMcTrackCuts;      
    double fPullMeanThrsh  = 0.1;  
    double fPullWidthThrsh = 2.0;  
    double fEffThrsh       = 0.5;  
    double fMaxDiffZStHit  = 1.0;  
    /* clang-format off */
    CBM_YAML_PROPERTIES(
      Property(&Config::fMcTrackCuts, "McTrackCuts", "MC track cuts"),
      Property(&Config::fPullMeanThrsh, "PullMeanThrsh", "Pull mean threshold"),
      Property(&Config::fPullWidthThrsh, "PullWidthThrsh", "Pull width threshold"),
      Property(&Config::fEffThrsh, "EffThrsh", "Efficiency threshold"),
      Property(&Config::fMaxDiffZStHit, "MaxDiffZStHit", "Max difference between station and hit z")
    );
    /* clang-format on */
  };
 
 public:
  CbmCaInputQaBase(const char* name, int verbose, bool isMCUsed);

  virtual ~CbmCaInputQaBase() = default;
 
 protected:
  // ********************************************
  // ** Virtual method override from CbmQaTask **
  // ********************************************

  void Check() override;

  void CreateSummary() override;

  virtual void FillHistogramsPerHit() {}

  virtual void FillHistogramsPerPoint() {}

  void DeInit() override;

  virtual void DefineParameters() = 0;

  void ExecQa() override;

  InitStatus InitQa() override;

  std::pair<std::string, bool> CheckRangePull(TH1* h) const;

  const cbm::ca::HitQaData& GetHitQaData() const { return fHitQaData; }

  bool IsTrackSelected(const CbmMCTrack* track, const Point_t* point) const;

  bool IsHitAcceptable(const CbmPixelHit* pHit) const;

  struct ResidualFitResult {
    double mean = 0;  
    double lo   = 0;  
    double hi   = 0;  
  };

  enum class EMonitorKey
  {
    kEvent,
    kHit,
    kHitAccepted,
    kMcPoint,
    kMcPointWrongStation,
    END
  };
  cbm::algo::ca::Monitor<EMonitorKey> fMonitor{};  
 
  Config fConfig;  
 
 
  // ----- Input data branches
 
  const cbm::algo::RecoSetupUnit_t<ToCbmModuleId(DetID)>* fpDetInterface = nullptr;  
 
  static constexpr auto DetName = cbm::algo::RecoSetupUnit_t<ToCbmModuleId(DetID)>::GetDetectorName();
 
  CbmTimeSlice* fpTimeSlice = nullptr;  
 
  TClonesArray* fpHits     = nullptr;  
  TClonesArray* fpClusters = nullptr;  
 
  CbmMCDataManager* fpMCDataManager = nullptr;  
  CbmMCEventList* fpMCEventList     = nullptr;  
  CbmMCDataArray* fpMCTracks        = nullptr;  
  CbmMCDataArray* fpMCPoints        = nullptr;  
 
  TClonesArray* fpHitMatches = nullptr;  
 
  // ******************
  // **  Parameters  **
  // ******************
 
  static constexpr double kNAN = std::numeric_limits<double>::signaling_NaN();
 
  // ----- Histogram binning parameters
  int fNbins  = 200;  
  int fNbinsZ = 800;  
 
  std::array<double, 2> fRHitDx = {kNAN, kNAN};  
  std::array<double, 2> fRHitDy = {kNAN, kNAN};  
  std::array<double, 2> fRHitDu = {kNAN, kNAN};  
  std::array<double, 2> fRHitDv = {kNAN, kNAN};  
  std::array<double, 2> fRHitDt = {kNAN, kNAN};  
 
  std::array<double, 2> fRResX = {kNAN, kNAN};  
  std::array<double, 2> fRResY = {kNAN, kNAN};  
  std::array<double, 2> fRResU = {kNAN, kNAN};  
  std::array<double, 2> fRResV = {kNAN, kNAN};  
  std::array<double, 2> fRResT = {kNAN, kNAN};  
 
  std::array<double, 2> fRangeDzHitPoint = {-0.05, 0.05};  
 
  // NOTE: Pull binning is fixed by convention, since it is used for hit finder calibrations. Please,
  //       do not modify!
  // TODO: 29.05.2024 SZh: Put to a tuple <double, int, int>
  static constexpr int kNbinsPull   = 200;
  static constexpr double kRPull[2] = {-10., 10.};  
 
  std::vector<double> frXmin;  
  std::vector<double> frXmax;  
  std::vector<double> frYmin;  
  std::vector<double> frYmax;  
  std::vector<double> frZmin;  
  std::vector<double> frZmax;  
 
 
  // ----- Histograms
  //
  // Hit occupancy
  std::vector<TH2F*> fvph_hit_xy;  
  std::vector<TH2F*> fvph_hit_zx;  
  std::vector<TH2F*> fvph_hit_zy;  
 
  std::vector<TH1F*> fvph_hit_station_delta_z;  
 
  // Hit errors
  std::vector<TH1F*> fvph_hit_dx;
  std::vector<TH1F*> fvph_hit_dy;
  std::vector<TH1F*> fvph_hit_du;
  std::vector<TH1F*> fvph_hit_dv;
  std::vector<TH1F*> fvph_hit_kuv;
  std::vector<TH1F*> fvph_hit_dt;
 
  // MC points occupancy
  std::vector<TH1F*> fvph_n_points_per_hit;  
 
  std::vector<TH2F*> fvph_point_xy;  
  std::vector<TH2F*> fvph_point_zx;  
  std::vector<TH2F*> fvph_point_zy;  
 
  std::vector<TH1F*> fvph_point_hit_delta_z;  
 
  // Residuals
  std::vector<TH1F*> fvph_res_x;  
  std::vector<TH1F*> fvph_res_y;  
  std::vector<TH1F*> fvph_res_u;  
  std::vector<TH1F*> fvph_res_v;  
  std::vector<TH1F*> fvph_res_t;  
 
  std::vector<TH2F*> fvph_res_x_vs_x;  
  std::vector<TH2F*> fvph_res_y_vs_y;  
  std::vector<TH2F*> fvph_res_u_vs_u;  
  std::vector<TH2F*> fvph_res_v_vs_v;  
  std::vector<TH2F*> fvph_res_t_vs_t;  
 
  // Pulls
  std::vector<TH1F*> fvph_pull_x;  
  std::vector<TH1F*> fvph_pull_y;  
  std::vector<TH1F*> fvph_pull_u;  
  std::vector<TH1F*> fvph_pull_v;  
  std::vector<TH1F*> fvph_pull_t;  
 
  std::vector<TH2F*> fvph_pull_x_vs_x;  
  std::vector<TH2F*> fvph_pull_y_vs_y;  
  std::vector<TH2F*> fvph_pull_u_vs_u;  
  std::vector<TH2F*> fvph_pull_v_vs_v;  
  std::vector<TH2F*> fvph_pull_t_vs_t;  
 
  // Hit efficiencies
  std::vector<TProfile2D*> fvpe_reco_eff_vs_xy;  
  std::vector<TH1F*> fvph_reco_eff;  
 
  CbmDigiManager* fDigiManager = nullptr;  
 
  // FIXME: change to private
 protected:
  cbm::ca::HitQaData fHitQaData{};  
};