CaQa.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 "CaEnumArray.h"
#include "CaHit.h"  // for HitIndex_t
#include "CaTimesliceHeader.h"
#include "CaVector.h"
#include "QaData.h"  // QA data
 
namespace cbm::algo
{
  namespace qa
  {
    class H1D;
    class H2D;
  }  // namespace qa
  namespace ca
  {
    template<typename DataT>
    class Parameters;
    class InputData;
    class Track;
  }  // namespace ca
}  // namespace cbm::algo
 
namespace cbm::algo::ca
{
  class Qa {
    enum class EHitSet
    {
      Input,  
      Used,   
      END
    };
 
    template<typename T>
    using HitSetArray_t = EnumArray<EHitSet, T>;
 
    static constexpr HitSetArray_t<EHitSet> kHitSets = {EHitSet::Input, EHitSet::Used};
 
   public:
    Qa(std::shared_ptr<HistogramSender> pSender) : fQaData("CA"), fpSender(pSender) {}
 
    Qa() = default;
 
    Qa(const Qa&) = delete;
 
    Qa(Qa&&) = delete;
 
    ~Qa() = default;
 
    Qa& operator=(const Qa&) = delete;
 
    Qa& operator=(Qa&&) = delete;
 
    void Exec();
 
    void Init();
 
    bool CheckInit() const;
 
    bool IsSenderDefined() const { return static_cast<bool>(fpSender.get()); }
 
    void RegisterInputData(const InputData* pInputData) { fpInputData = pInputData; }
 
    void RegisterTracks(const Vector<Track>* pvTracks) { fpvTracks = pvTracks; }
 
    void RegisterRecoHitIndices(const Vector<HitIndex_t>* pvRecoHits) { fpvRecoHits = pvRecoHits; }
 
    void RegisterParameters(const Parameters<fvec>* pParameters) { fpParameters = pParameters; }
 
   private:
    void FillHitDistributionsForHitSet(EHitSet hitSet, const ca::Hit& hit);
 
    // parameters
    static constexpr double kXYZMargin  = 0.05;   
    static constexpr int knHitSets      = 2;      
    static constexpr int knTrkParPoints = 2;      
    static constexpr int knStaMax       = 16;     
    static constexpr bool kDebug        = false;  
 
    double fMinHitTime = std::numeric_limits<double>::max();
    double fMaxHitTime = std::numeric_limits<double>::lowest();
 
    // utility
    qa::Data fQaData;  
 
    std::shared_ptr<HistogramSender> fpSender = nullptr;  
    const Parameters<fvec>* fpParameters      = nullptr;  
    const InputData* fpInputData              = nullptr;  
    const Vector<Track>* fpvTracks            = nullptr;  
    const Vector<HitIndex_t>* fpvRecoHits     = nullptr;  
 
    // Hit distributions
    using OccupHistContainer_t = std::vector<HitSetArray_t<qa::H2D*>>;
    OccupHistContainer_t fvphHitOccupXY;  
    OccupHistContainer_t fvphHitOccupZX;  
    OccupHistContainer_t fvphHitOccupZY;  
 
    std::vector<qa::Prof2D*> fvphHitUsageXY;  
 
    HitSetArray_t<qa::H1D*> fvphHitFrontKeyIndex = {nullptr, nullptr};  
    HitSetArray_t<qa::H1D*> fvphHitBackKeyIndex  = {nullptr, nullptr};  
 
    std::vector<HitSetArray_t<qa::H1D*>> fvphHitTime;  
 
    // Track distributions
    std::array<qa::H1D*, knTrkParPoints> fvphTrkTheta    = {{0}};  
    std::array<qa::H1D*, knTrkParPoints> fvphTrkPhi      = {{0}};  
    std::array<qa::H1D*, knTrkParPoints> fvphTrkChi2Ndf  = {{0}};  
    std::array<qa::H2D*, knTrkParPoints> fvphTrkPhiTheta = {{0}};  
 
    qa::H2D* fphTrkFstLstSta = nullptr;  
    qa::H1D* fphTrkNofHits   = nullptr;  
  };
}  // namespace cbm::algo::ca