CbmCaOutputQa.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 "CaMcHitInfo.h"
#include "CaMonitor.h"
#include "CaParameters.h"
#include "CaToolsDebugger.h"
#include "CaVector.h"
#include "CbmCaMCModule.h"
#include "CbmCaTimeSliceReader.h"
#include "CbmCaTrackTypeQa.h"
#include "CbmKfTrackFitter.h"
#include "CbmL1DetectorID.h"
#include "CbmL1HitId.h"
#include "CbmQaCmpDrawer.h"
#include "CbmQaTask.h"
 
#include <array>
#include <memory>
 
namespace cbm::ca
{
  enum ETrackType
  {
    kPrimLongFast,  
    kPrimLong,      
    kAll,           
    kAll2STS1TOF,   
    kPrim2STS1TOF,  
    kSec2STS1TOF,   
    kGhost,         
    kPrim,          
    kPrimFast,      
    kSec,           
    kSecFast,       
    kAllE,          
    kPrimE,         
    kPrimEP,        
    kPrimEM,        
    kSecE,          
    kSecEP,         
    kSecEM,         
    kAllMU,         
    kPrimMU,        
    kPrimMUP,       
    kPrimMUM,       
    kSecMU,         
    kSecMUP,        
    kSecMUM,        
    kAllPI,         
    kPrimPI,        
    kPrimPIP,       
    kPrimPIM,       
    kSecPI,         
    kSecPIP,        
    kSecPIM,        
    kAllK,          
    kPrimK,         
    kPrimKP,        
    kPrimKM,        
    kSecK,          
    kSecKP,         
    kSecKM,         
    kAllPPBAR,      
    kPrimPPBAR,     
    kPrimP,         
    kPrimPBAR,      
    kSecPPBAR,      
    kSecP,          
    kSecPBAR,       
    // kPrimD,
    // kPrimDBAR,
    // kSecD,
    // kSecDBAR,
    // kPrimT,
    // kPrimTBAR,
    // kSecT,
    // kSecTBAR,
    // kPrim3HE,
    // kPrim3HEBAR,
    // kSec3HE,
    // kSec3HEBAR,
    // kPrim4HE,
    // kPrim4HEBAR,
    // kSec4HE,
    // kSec4HEBAR,
    END
  };

  class OutputQa : public CbmQaTask {
    // WIP: Temporary flag to switch between two different approaches of filling track type histograms
    //
    // 1) Experimental approach (kEXPTRACKFILL = true) utilizes unified filling based on defined reco and MC cuts.
    // 2) Feature is to be studied more precisely (descrepancy in primary/secondary track with a standard approach)
    // 3) Experimental approach runs in ~10% slower, then the standard
    static constexpr bool kEXPTRACKFILL = false;

    template<typename T>
    using TTypeArr_t = std::array<T, ETrackType::END>;

    struct DrawAtt {
      Color_t fColor  = 1;  
      Style_t fMarker = 1;  
    };
 
   public:
    OutputQa(int verbose, bool isMCUsed, ECbmRecoMode recoMode = ECbmRecoMode::EventByEvent);

    void AddTrackType(ETrackType type, bool flag = true) { fvbTrackTypeOn[type] = flag; }

    void EnableDebugger(const char* filename)
    {
      if (!fpDebugger.get()) {
        fpDebugger = std::make_shared<tools::Debugger>(filename);
      }
    }

    void SetEventDisplay(bool bDrawEvents, int minNofPoints = 2)
    {
      fbDrawEvents            = bDrawEvents;
      fEvtDisplayMinNofPoints = minNofPoints;
    }

    void SetUseMvd(bool flag = true) { fbUseMvd = flag; }

    void SetUseSts(bool flag = true) { fbUseSts = flag; }

    void SetUseMuch(bool flag = true) { fbUseMuch = flag; }

    void SetUseTrd(bool flag = true) { fbUseTrd = flag; }

    void SetUseTof(bool flag = true) { fbUseTof = flag; }

    void SetStsTrackingMode() { fTrackingMode = ECbmCaTrackingMode::kSTS; }

    void SetMcbmTrackingMode() { fTrackingMode = ECbmCaTrackingMode::kMCBM; }

    void SetPerformanceMode(int mode) { fPerformanceMode = mode; }

    void SetTrackTypeListForSummary(std::set<ETrackType>&& trackTypes)
    {
      fmSummaryTableEntries = std::move(trackTypes);
    }

    void SetNofThreads(int nThreads) { fNthreads = nThreads; }

    void SetMaxExtrapolationStep(double maxStep) { fMaxExtrapolationStep = maxStep; }
 
   protected:
    void Check() override;

    void CreateSummary() override;

    void DeInit() override { fDebugger.Write(); }

    void FillTrackTypeHistograms();

    InitStatus InitQa() override;

    void ExecQa() override;
 
   private:
    void FillMCTrack(ETrackType type, int iTrkMC);

    void DrawEvent();

    template<class TObj>
    void DrawSetOf(const std::vector<ETrackType>& vTypes, std::function<TObj*(ETrackType)> GetObj);
 

    void InitDrawingAttributes();
 
    cbm::ca::TrackTypeQa::FitQaPointSet CreateFitQaPointSet(int iTrkReco) const;
 
    // Flags for detector subsystems being used
    bool fbUseMvd               = false;  
    bool fbUseSts               = false;  
    bool fbUseMuch              = false;  
    bool fbUseTrd               = false;  
    bool fbUseTof               = false;  
    bool fbDrawEvents           = false;  
    int fEvtDisplayMinNofPoints = 2;      
    int fPerformanceMode        = 1;      
 
    ECbmCaTrackingMode fTrackingMode = ECbmCaTrackingMode::kSTS;  
 
    std::string fsParametersFilename                    = "";
    std::unique_ptr<TimeSliceReader> fpTSReader         = nullptr;  
    std::shared_ptr<MCModule> fpMCModule                = nullptr;  
    std::shared_ptr<ca::DataManager> fpDataManager      = nullptr;  
    std::shared_ptr<tools::Debugger> fpDebugger         = nullptr;  
    std::shared_ptr<const ca::Parameters<double>> fpParameters = nullptr;  
 
    ca::Vector<CbmL1HitId> fvHitIds{"CbmCaOutputQa::fvHitIds"};
    ca::Vector<cbm::algo::ca::McHitInfo> fvHits{"CbmCaOutputQa::fvHits"};
    ca::Vector<CbmL1Track> fvRecoTracks{"CbmCaOutputQa::fvRecoTracks"};
    ca::McData fMCData;  

    cbm::ca::tools::Debugger fDebugger{nullptr};
 
    CbmKfTrackFitter<> fTrackFitter;    
    int fNthreads{-1};                  
    double fMaxExtrapolationStep{-1.};  

    enum class EMonitorKey
    {
      kEvent,
      kTrack,
      kHit,
      kMcTrack,
      kMcPoint,
      END
    };
 
    ca::Monitor<EMonitorKey> fMonitor{"Output tracking QA"};
 
    std::set<ETrackType> fmSummaryTableEntries;  
 
    // *************************
    // **  List of histograms **
    // *************************
 
    TTypeArr_t<std::string> fvsTrackTypeName;                     
    TTypeArr_t<std::unique_ptr<TrackTypeQa>> fvpTrackHistograms;  
    TTypeArr_t<bool> fvbTrackTypeOn = {0};                        
    TTypeArr_t<DrawAtt> fvTrackDrawAtts;                          
 
    // ************************************
    // ** Drawing options and properties **
    // ************************************
 
    static constexpr int kCXSIZEPX = 600;  
    static constexpr int kCYSIZEPX = 600;  
 
    ClassDefOverride(OutputQa, 0);
  };
 
}  // namespace cbm::ca
 
 
// **********************
// **  Implementation  **
// **********************
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class TObj>
void cbm::ca::OutputQa::DrawSetOf(const std::vector<ETrackType>& vTypes, std::function<TObj*(ETrackType)> GetObj)
{
  CbmQaCmpDrawer<TObj> drawer;
  for (auto type : vTypes) {
    if (!fvbTrackTypeOn[type] || !fvpTrackHistograms[type]->IsMCUsed()) {
      continue;
    }
    drawer.RegisterObject(GetObj(type), fvpTrackHistograms[type]->GetTitle());
  }
  if constexpr (std::is_same_v<TH1F, TObj>) {
    drawer.SetMinimum(1.e-1);
  }
  drawer.Draw("");
  drawer.Clear();
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
[[gnu::always_inline]] inline void cbm::ca::OutputQa::FillMCTrack(ETrackType type, int iTrkMC)
{
  // Fill histograms and efficiency profiles
  if (fvbTrackTypeOn[type]) {
    fvpTrackHistograms[type]->FillMCTrack(iTrkMC);
  }
}