CaTrackFinderWindow.h

Go to the documentation of this file.

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

 
#pragma once  // include this header only once per compilation unit
 
#include "CaBranch.h"
#include "CaCloneMerger.h"
#include "CaGrid.h"
#include "CaHit.h"
#include "CaMcMatch.h"
#include "CaSimd.h"
#include "CaTrackExtender.h"
#include "CaTrackFitter.h"
#include "CaTrackingMonitor.h"
#include "CaVector.h"
#include "CaWindowData.h"
 
namespace cbm::algo::ca
{
 
  class Track;
  class Triplet;
  class Framework;

  class TrackFinderWindow {
   public:
    TrackFinderWindow(const ca::Framework& framework, const ca::Parameters<fvec>& pars, const fscal mass,
                      const ca::TrackingMode& mode, ca::TrackingMonitorData& monitorData);
    ~TrackFinderWindow() = default;

    TrackFinderWindow(const TrackFinderWindow&) = default;

    TrackFinderWindow(TrackFinderWindow&&) = default;

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

    TrackFinderWindow& operator=(TrackFinderWindow&&) = delete;
 
    void CaTrackFinderSlice(const ca::InputData& input, WindowData& wData);

    void InitTimeslice(size_t nHitKeys) { fvHitKeyToTrack.reset(nHitKeys, -1); }
 
   private:
 
    typedef std::array<Vector<ca::Triplet>, constants::size::MaxNstations> TripletArray_t;
 
    // TripletData_t:
    // 1 -> vHitFirstTriplet   /// link hit -> first triplet { hit, *, *}
    // 2 -> vHitNofTriplets    /// link hit ->n triplets { hit, *, *}
    // 3 -> vTriplets;
    typedef std::tuple<Vector<int>, Vector<int>, TripletArray_t> TripletData_t;
 
    void ConstructTriplets(WindowData& wData);
 
    void ReadWindowData(const Vector<Hit>& hits, WindowData& wData);
 
    void PrepareGrid(const Vector<Hit>& hits, WindowData& wData);
 
    void PrepareCAIteration(int iterationIndex, const ca::Iteration& caIteration, WindowData& wData);
 
    void CreateTracks(WindowData& wData, const ca::Iteration& caIteration, TripletArray_t& vTriplets);
 
    void CreateTrackCandidates(WindowData& wData, TripletArray_t& vTriplets, const int min_level,
                               const int firstTripletLevel);
 
    void DoCompetitionLoop(const WindowData& wData);
 
    void SelectTracks(WindowData& wData);
 
    void SearchNeighbors(WindowData& wData);
 
    void CAFindTrack(int ista, ca::Branch& best_tr, const ca::Triplet* curr_trip, ca::Branch& curr_tr,
                     unsigned char min_best_l, ca::Branch* new_tr, WindowData& wData, TripletArray_t& vTriplets);
 
    bool checkTripletMatch(const ca::Triplet& l, const ca::Triplet& r, fscal& dchi2, WindowData& wData) const;
 
    // ** Functions, which pack and unpack indexes of station and triplet **
 
    // TODO: move to ca::Triplet class (S.Zharko)
    static unsigned int PackTripletId(unsigned int iStation, unsigned int iTriplet);

    static unsigned int TripletId2Station(unsigned int id);

    static unsigned int TripletId2Triplet(unsigned int id);
 

    int GetBestMcTrackIdForWindowHit(int iHit) const;
 
    McMatch GetMcMatchForWindowHit(int iHit) const;
 
   private:
 
    static constexpr bool fDebug = false;  // print debug info
 
    const Framework& fFramework;                    
    const Parameters<fvec>& fParameters;            
    const cbm::algo::kf::Setup<fvec>& fSetup;       
    const cbm::algo::kf::Field<fvec>& fField;       
    fscal fDefaultMass{constants::phys::MuonMass};  
    ca::TrackingMode fTrackingMode;
 
    WindowData* pwData{nullptr};  
 
    TrackingMonitorData& frMonitorData;  
    TrackExtender fTrackExtender;        
    CloneMerger fCloneMerger;            
    TrackFitter fTrackFitter;            

    Vector<int> fvHitKeyToTrack{"TrackFinderWindow::fvHitKeyToTrack"};
 
    // Persistent to avoid memory allocations.
    // Only used in CreateTrackCandidates().
    ca::Branch fNewTr[constants::size::MaxNstations];
 
    // Track candidates created out of adjacent triplets before the final track selection.
    // The candidates may share any amount of hits.
    Vector<ca::Branch> fvTrackCandidates{"TrackFinderWindow::fvTrackCandidates"};
 
    // Triplets and related meta data
    TripletData_t fTripletData;
 
    // Triplet temporary storage. Only used in ConstructTriplets().
    Vector<ca::Triplet> fvTriplets;
  };
 
  // ********************************************
  // ** Inline member functions implementation **
  // ********************************************
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  [[gnu::always_inline]] inline unsigned int TrackFinderWindow::PackTripletId(unsigned int iStation,
                                                                              unsigned int iTriplet)
  {
    assert(iStation < constants::size::MaxNstations);
    assert(iTriplet < constants::size::MaxNtriplets);
    constexpr unsigned int kMoveStation = constants::size::TripletBits;
    return (iStation << kMoveStation) + iTriplet;
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  [[gnu::always_inline]] inline unsigned int TrackFinderWindow::TripletId2Station(unsigned int id)
  {
    constexpr unsigned int kMoveStation = constants::size::TripletBits;
    return id >> kMoveStation;
  }
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  [[gnu::always_inline]] inline unsigned int TrackFinderWindow::TripletId2Triplet(unsigned int id)
  {
    constexpr unsigned int kTripletMask = (1u << constants::size::TripletBits) - 1u;
    return id & kTripletMask;
  }
 
 
}  // namespace cbm::algo::ca