CaFramework.h

Go to the documentation of this file.

/* Copyright (C) 2007-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Maksym Zyzak, Valentina Akishina, Igor Kulakov [committer], Sergei Zharko */
 
#pragma once  // include this header only once per compilation unit
 
#include "CaBranch.h"
#include "CaCloneMerger.h"
#include "CaDefs.h"
#include "CaGrid.h"
#include "CaGridEntry.h"
#include "CaHit.h"
#include "CaInputData.h"
#include "CaMcData.h"
#include "CaMcMatch.h"
#include "CaParameters.h"
#include "CaSimd.h"
#include "CaTimer.h"
#include "CaTimesliceHeader.h"
#include "CaTrack.h"
#include "CaTrackFinder.h"
#include "CaTrackingMonitor.h"
#include "CaTriplet.h"
#include "CaVector.h"
#include "CaWindowData.h"
#include "KfFramework.h"
 
#include <array>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
 
namespace cbm::algo::ca
{
  class TripletConstructor;
  class Track;
 
  //namespace
  //{
  //  using cbm::algo::ca::Track;      // TMP
  //  using cbm::algo::ca::Vector;     // TMP
  //  using cbm::algo::ca::Iteration;  // TMP
  //}  // namespace
 
  // *******************************
  // ** Types definition (global) **
  // *******************************
 
  using Tindex            = int;  // TODO: Replace with ca::HitIndex_t, if suitable

  class Framework {
   public:
    // **********************************
    // ** Member functions declaration **
    // **********************************
 
    // ** Constructors and destructor

    Framework(){};

    Framework(const Framework&) = delete;

    Framework(Framework&&) = delete;

    Framework& operator=(const Framework&) = delete;

    Framework& operator=(Framework&&) = delete;

    ~Framework() = default;

    void SetParameters(const Parameters<fvec>& other) { fParameters = other; }
    // TODO: remove it (S.Zharko)

    const Parameters<fvec>& GetParameters() const { return fParameters; }

    void ReceiveInputData(InputData&& inputData);

    void ReceiveParameters(Parameters<fvec>&& parameters);

    const InputData& GetInputData() const { return fInputData; }
 
    int PackIndex(const int& a, const int& b, const int& c);
 
    int UnPackIndex(const int& i, int& a, int& b, int& c);

    void SetDefaultParticleMass(fscal mass) { fDefaultMass = mass; }

    fscal GetDefaultParticleMass() const { return fDefaultMass; }

    fscal GetDefaultParticleMass2() const { return fDefaultMass * fDefaultMass; }

    const TimesliceHeader& GetTsHeader() const { return fTsHeader; }
 
    /*********************************************************************************************/ 
 
 
    void Init(const TrackingMode mode);
 
    void Finish();
 
    void PrintHits();

    const TrackingMonitorData& GetMonitorData() const { return fMonitorData; }

    void SetMonitorData(const TrackingMonitorData& monitorData) { fMonitorData = monitorData; }
 
    TrackingMode GetTrackingMode() { return fpTrackFinder->GetTrackingMode(); }
 
    const std::vector<ca::WindowData>& GetWData() { return fpTrackFinder->GetWData(); }
 
   public:
    void FindTracks()
    {
      std::tie(fRecoTracks, fRecoHits) = fpTrackFinder->FindTracks(fInputData, fTsHeader);
      return;
    };

    // int GetNstationsBeforePipe() const { return fNstationsBeforePipe; }

    int GetBestMcTrackIdForCaHit(int iHit) const;
 
    McMatch GetMcMatchForCaHit(int iHit) const;

    void SetNofThreads(int nThreads)
    {
      fNofThreads = nThreads;
      assert(nThreads > 0);
      LOG(info) << "ca::Framework: number of threads is set to " << fNofThreads;
    }

    int GetNofThreads() const { return fNofThreads; }
 
    void SetMcData(const ca::McData* pMCData) { fpMcData = pMCData; }
 
    const ca::McData* GetMcData() const { return fpMcData; }
 
   private:
    int fNstationsBeforePipe{0};                    
    fscal fDefaultMass{constants::phys::MuonMass};  
    TimesliceHeader fTsHeader;                      
 
    // ***************************
    // ** Member variables list **
    // ***************************
 
    Parameters<fvec> fParameters;  
    InputData fInputData;          
 
    Vector<unsigned char> fvHitKeyFlags{
      "Framework::fvHitKeyFlags"};  
 
    TrackingMonitorData fMonitorData{};  
 
    int fNofThreads = 1;  
    bool checkTripletMatch(const ca::Triplet& l, const ca::Triplet& r, fscal& dchi2) const;
 
    std::unique_ptr<ca::TrackFinder> fpTrackFinder;  
 
    const ca::McData* fpMcData;  
 
   public:
    //   Vector<CaHitTimeInfo> fHitTimeInfo;
 
    double fCaRecoTime{0.};  // time of the track finder + fitter
 
    Vector<Track> fRecoTracks{"Framework::fRecoTracks"};       
    Vector<ca::HitIndex_t> fRecoHits{"Framework::fRecoHits"};  
 
    fvec EventTime{0.f};
    fvec Err{0.f};
 
   public:
  } _fvecalignment;
 
}  // namespace cbm::algo::ca