HitfinderChain.h

Go to the documentation of this file.

/* Copyright (C) 2022 FIAS Frankfurt Institute for Advanced Studies, Frankfurt / Main
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Felix Weiglhofer [committer], Kilian Hunold */
 
#ifndef CBM_ALGO_STS_HITFINDER_CHAIN_H
#define CBM_ALGO_STS_HITFINDER_CHAIN_H
 
#include "CbmStsDigi.h"
#include "PartitionedSpan.h"
#include "PartitionedVector.h"
#include "SubChain.h"
#include "sts/Hitfinder.h"
#include "sts/HitfinderPars.h"
#include "sts/LandauTable.h"
 
#include <array>
#include <cstdint>
#include <gsl/span>
#include <map>
#include <optional>
#include <vector>
 
#include <xpu/host.h>
 
namespace cbm::algo::sts
{
 
  struct HitfinderMon : HitfinderMonDevice {
    u64 nClusterTotal;
    u64 nHitsTotal;
 
    void SetDeviceMon(const HitfinderMonDevice& devMon) { HitfinderMonDevice::operator=(devMon); }
  };
 
  struct HitfinderChainPars {
    HitfinderPars setup;  // TODO: HitfinderPars should renamed to HitfinderSetup
    RecoParams::STS::Memory memory;
  };
 
  class HitfinderChain : public SubChain {
 
   public:
    struct Result {
      PartitionedSpan<sts::Hit> hits;
      PartitionedVector<sts::Cluster> clusters;
      HitfinderMon monitor;
    };
 
    void SetParameters(const HitfinderChainPars& parameters);
    const HitfinderChainPars& GetParameters() const { return *fPars; }
 
    void Finalize();
 
    Result operator()(gsl::span<const CbmStsDigi>, bool storeClusters = false);
 
   private:
    static constexpr u16 InvalidModule = 0xFFFF;
 
    struct DigiMap {
      //< Map module address to index in digis array. Only works for 17 bit packed addresses.
      std::vector<u16> addrToIndex;
      // Map modules to number of Digis, 2 * NModules entries, first half is front, second half is back
      std::vector<size_t> nDigisPerModule;
      std::vector<std::vector<size_t>> nDigisPerThread;  //< Number of digis per module per thread [thread][module]
      size_t maxNDigisPerModule = 0;                     //< Upper bound on number of digis per module
 
      u16 ModuleIndex(const CbmStsDigi& digi) const
      {
        i32 moduleAddr  = digi.GetAddressPacked();
        u16 moduleIndex = addrToIndex[moduleAddr];
        return moduleIndex;
      }
    };
 
    void EnsureParameters();
 
    void AllocateStatic();
 
    void AllocateDynamic(size_t, size_t);
 
    DigiMap CountDigisPerModules(gsl::span<const CbmStsDigi> digis);
 
    void FlattenDigis(gsl::span<const CbmStsDigi> digis, DigiMap& digiMap);
 
    PartitionedSpan<sts::Hit> FlattenHits(xpu::queue);
 
    PartitionedVector<sts::Cluster> FlattenClusters(xpu::queue);
 
    size_t GetNHits(xpu::h_view<PaddedToCacheLine<int>> nHitsPerModule, int module);
 
    PartitionedSpan<sts::Hit> SplitHitsIntoStreams(PartitionedSpan<sts::Hit> hits, int nstreamsMax);
 
    void SortHitsWithinPartition(PartitionedSpan<sts::Hit> hits);
 
    // Debug functions, ensure reco produces sane results
    void EnsureDigiOffsets(DigiMap&);
    void EnsureDigisSorted();
    void EnsureChannelOffsets(gsl::span<u32>);
    void EnsureClustersSane(gsl::span<ClusterIdx>, gsl::span<PaddedToCacheLine<int>>);
    void EnsureClustersSorted();
    void EnsureHitsSorted(PartitionedSpan<sts::Hit>);
 
    std::optional<sts::HitfinderChainPars> fPars;
 
    Hitfinder fHitfinder;
 
    // Output buffer, used by the returned PartitionedSpan
    std::vector<u32> fAddresses;
    std::vector<size_t> fHitOffsets;
    std::vector<u32> fStreamAddresses;
    std::vector<size_t> fHitStreamOffsets;
  };
 
}  // namespace cbm::algo::sts
 
#endif  // #ifndef CBM_ALGO_STS_HITFINDER_CHAIN_H