CaWindowData.h

Go to the documentation of this file.

/* Copyright (C) 2024 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergei Zharko [committer] */
 
 
#pragma once
 
#include "CaDefs.h"
#include "CaGrid.h"
#include "CaHit.h"
#include "CaIteration.h"
#include "CaTrack.h"
#include "KfFieldRegion.h"
#include "KfMeasurementXy.h"
 
#include <array>
 
namespace cbm::algo::ca
{
  class WindowData {
   public:
    WindowData() = default;
 
    ~WindowData() = default;
 
    [[gnu::always_inline]] ca::Grid& Grid(int iStation) { return fvGrid[iStation]; }
 
    [[gnu::always_inline]] const ca::Grid& Grid(int iStation) const { return fvGrid[iStation]; }
 
    [[gnu::always_inline]] ca::Hit& Hit(int iHit) { return fvHits[iHit]; }
 
    [[gnu::always_inline]] const ca::Hit& Hit(int iHit) const { return fvHits[iHit]; }
 
    [[gnu::always_inline]] Vector<ca::Hit>& Hits() { return fvHits; }
 
    [[gnu::always_inline]] const Vector<ca::Hit>& Hits() const { return fvHits; }
 
    [[gnu::always_inline]] uint8_t IsHitSuppressed(int iHit) const { return fvbHitSuppressed[iHit]; }
 
    void ResetHitData(int nHits);
 
    [[gnu::always_inline]] void ResetHitSuppressionFlags() { fvbHitSuppressed.reset(fvHits.size(), 0); }
 
    [[gnu::always_inline]] void SuppressHit(int iHit) { fvbHitSuppressed[iHit] = 1; }
 
    [[gnu::always_inline]] HitIndex_t& HitStartIndexOnStation(int iStation)
    {
      return fvHitStartIndexOnStation[iStation];
    }
 
    [[gnu::always_inline]] unsigned char IsHitKeyUsed(HitKeyIndex_t iKey) const { return fvbHitKeyFlags[iKey]; }
 
    [[gnu::always_inline]] unsigned char& IsHitKeyUsed(HitKeyIndex_t iKey) { return fvbHitKeyFlags[iKey]; }
 
    [[gnu::always_inline]] Vector<unsigned char>& HitKeyFlags() { return fvbHitKeyFlags; }
 
    [[gnu::always_inline]] HitIndex_t HitStartIndexOnStation(int iStation) const
    {
      return fvHitStartIndexOnStation[iStation];
    }
 
    [[gnu::always_inline]] HitIndex_t& NofHitsOnStation(int iStation) { return fvNofHitsOnStation[iStation]; }
 
    [[gnu::always_inline]] HitIndex_t NofHitsOnStation(int iStation) const { return fvNofHitsOnStation[iStation]; }
 
    [[gnu::always_inline]] Vector<HitIndex_t>& RecoHitIndices() { return fvRecoHitIndices; }
 
    [[gnu::always_inline]] const Vector<HitIndex_t>& RecoHitIndices() const { return fvRecoHitIndices; }
 
    [[gnu::always_inline]] HitIndex_t& RecoHitIndex(int iHit) { return fvRecoHitIndices[iHit]; }
 
    [[gnu::always_inline]] HitIndex_t RecoHitIndex(int iHit) const { return fvRecoHitIndices[iHit]; }
 
    [[gnu::always_inline]] Track& RecoTrack(int iTrack) { return fvRecoTracks[iTrack]; }
 
    [[gnu::always_inline]] const Track& RecoTrack(int iTrack) const { return fvRecoTracks[iTrack]; }
 
    [[gnu::always_inline]] Vector<Track>& RecoTracks() { return fvRecoTracks; }
 
    [[gnu::always_inline]] const Vector<Track>& RecoTracks() const { return fvRecoTracks; }
 
    [[gnu::always_inline]] HitIndex_t TsHitIndex(int iSt, int iHit) const { return fvTsHitIndices[iSt][iHit]; }
 
    [[gnu::always_inline]] Vector<HitIndex_t>& TsHitIndices(int iSt) { return fvTsHitIndices[iSt]; }
 
    [[gnu::always_inline]] const Vector<HitIndex_t>& TsHitIndices(int iSt) const { return fvTsHitIndices[iSt]; }
 
    [[gnu::always_inline]] void SetCurrentIteration(const Iteration* ptr) { fpCurrentIteration = ptr; }
 
    [[gnu::always_inline]] const Iteration* CurrentIteration() const { return fpCurrentIteration; }
 
    [[gnu::always_inline]] kf::FieldValue<fvec>& TargB() { return fTargB; }
 
    [[gnu::always_inline]] const kf::FieldValue<fvec>& TargB() const { return fTargB; }
 
    [[gnu::always_inline]] kf::MeasurementXy<fvec>& TargetMeasurement() { return fTargetMeasurement; }
 
    [[gnu::always_inline]] const kf::MeasurementXy<fvec>& TargetMeasurement() const { return fTargetMeasurement; }
 
   private:
    static constexpr int kMaxNofStations = constants::size::MaxNstations;  
 
    std::array<ca::Grid, kMaxNofStations> fvGrid;
 
    Vector<ca::Hit> fvHits{"WindowData::fHits"};
 
    Vector<unsigned char> fvbHitKeyFlags{"WindowData::fvbHitKeyFlags"};
 
    Vector<unsigned char> fvbHitSuppressed{"WindowData::fvbHitSuppressed"};
 
    std::array<HitIndex_t, kMaxNofStations + 1> fvHitStartIndexOnStation = {0};
 
    std::array<HitIndex_t, kMaxNofStations + 1> fvNofHitsOnStation = {0};
 
    Vector<Track> fvRecoTracks{"WindowData::fvRecoTracks"};
 
    Vector<HitIndex_t> fvRecoHitIndices{"WindowData::fvRecoHitIndices"};
 
    std::array<Vector<HitIndex_t>, kMaxNofStations> fvTsHitIndices{"WindowData::fvFullDSHitIndex"};
 
    const Iteration* fpCurrentIteration = nullptr;
 
    kf::FieldValue<fvec> fTargB{};                 
    kf::MeasurementXy<fvec> fTargetMeasurement{};  
 
  } _fvecalignment;
}  // namespace cbm::algo::ca