FPGATrackSimMatrixIO.h

Go to the documentation of this file.

// Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
 
#ifndef FPGATrackSimMATRIXREADER_H
#define FPGATrackSimMATRIXREADER_H
 
#include "FPGATrackSimMatrixAccumulator.h"
#include "FPGATrackSimObjects/FPGATrackSimTypes.h"
 
#include <vector>
 
#include "TTree.h"
 
 
// Reader
 
 
/*
 * Use nextEntry() or readEntry() to read the entry in the tree,
 * then use getModules() or getAccumulator() to get a reference to the data.
 *
 * Example:
 *      FPGATrackSimMatrixReader reader(tree, nLayers, nCoords);
 *      while (reader.nextEntry())
 *      {
 *          std::vector<module_t> & modules = reader.getModules();
 *          FPGATrackSimMatrixAccumulator & acc = reader.getAccumulator();
 *      }
 */
class FPGATrackSimMatrixReader
{
    public:
 
        FPGATrackSimMatrixReader(TTree *tree, size_t nLayers, size_t nCoords);
        ~FPGATrackSimMatrixReader() { m_tree->ResetBranchAddresses(); }
 
        void setEntry(size_t entry) { m_entry = entry; }
        size_t getEntry() const { return m_entry - 1; } // last read entry number
 
        // Read the next entry. Returns true on success.
        bool nextEntry();
        // Read a specific entry.
        void readEntry(size_t entry);
 
        std::vector<module_t> & getModules() { return m_modules; }
        FPGATrackSimMatrixAccumulator & getAccumulator() { return m_acc; }
 
    private:
 
        TTree* m_tree;
 
        size_t m_entry;
        size_t m_nEntries;
 
        std::vector<module_t> m_modules;
        FPGATrackSimMatrixAccumulator m_acc;
 
        std::vector<short> m_bins_QoP;
        std::vector<short> m_bins_phi;
        std::vector<short> m_bins_d0;
        std::vector<short> m_bins_z0;
        std::vector<short> m_bins_eta;
 
        // These point to the variables above because ROOT expects a vector**.
        std::vector<short>* m_pQoP;
        std::vector<short>* m_pphi;
        std::vector<short>* m_pd0;
        std::vector<short>* m_pz0;
        std::vector<short>* m_peta;
};
 
// Writer
 
class FPGATrackSimMatrixWriter
{
    public:
 
        FPGATrackSimMatrixWriter(TTree *tree, int nLayers, int nCoords);
 
        // Returns entry filled
        size_t fill(std::vector<module_t> modules, FPGATrackSimMatrixAccumulator & acc); // copying, necessary since root writing is not const but map keys are
 
    private:
 
        TTree* m_tree;
 
        size_t m_nEntries;
        int m_nLayers;
        int m_nCoords;
        int m_nCoords2;
        float m_coverage = 0.0F;
 
        std::vector<short> m_bins_QoP;
        std::vector<short> m_bins_phi;
        std::vector<short> m_bins_d0;
        std::vector<short> m_bins_z0;
        std::vector<short> m_bins_eta;
 
        // These point to the variables above because ROOT expects a vector**.
        std::vector<short>* m_pQoP;
        std::vector<short>* m_pphi;
        std::vector<short>* m_pd0;
        std::vector<short>* m_pz0;
        std::vector<short>* m_peta;
};
 
 
// Utility functions
 
void readTree(AccumulateMap & map, TTree *tree, size_t nLayers, size_t nCoords);
 
 
std::vector<std::pair<std::vector<module_t>, FPGATrackSimMatrixAccumulator>> readTree(TTree *tree, size_t nLayers, size_t nCoords);
 
 
template<typename Iter>
void fillTree(Iter begin, Iter end, TTree *tree, int nLayers, int nCoords)
{
    // Sort sectors by decreasing coverage
    std::vector<Iter> sorted_sectors;
    sorted_sectors.reserve(std::distance(begin, end));
    for (Iter i = begin; i != end; i++) sorted_sectors.push_back(i);
 
    std::sort(sorted_sectors.begin(), sorted_sectors.end(), [](Iter const & a, Iter const & b)
        { return a->second.track_bins.size() > b->second.track_bins.size(); }
    );
 
    // Create the writer
    FPGATrackSimMatrixWriter writer(tree, nLayers, nCoords);
 
    // Fill the tree
    for (Iter & sector_info : sorted_sectors)
        writer.fill(sector_info->first, sector_info->second);
}
 
 
// Specialization to AccumulateMap
void fillTree(AccumulateMap & map, TTree *tree, int nLayers, int nCoords);
 
 
 
#endif