FPGATrackSimConstGenAlgo.h

Go to the documentation of this file.

// Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
 
#ifndef FPGATrackSimConstGenAlgo_h
#define FPGATrackSimConstGenAlgo_h

 
#include "GaudiKernel/ITHistSvc.h"
#include "AthenaBaseComps/AthAlgorithm.h"
#include "FPGATrackSimObjects/FPGATrackSimTypes.h" //module_t typedef
#include "FPGATrackSimObjects/FPGATrackSimTrackPars.h" //member
#include "FPGATrackSimObjects/FPGATrackSimVectors.h" //vector2D
#include "FPGATrackSimMaps/IFPGATrackSimMappingSvc.h"
#include "FPGATrackSimConfTools/IFPGATrackSimEventSelectionSvc.h"
 
#include "TMatrixDfwd.h"
#include <string>
#include <vector>
#include <memory>
 
struct FPGATrackSimMatrixAccumulator;
class FPGATrackSimPlaneMap;
class TTree;
class TH1F;
class TFile;
 
// data structure that contain definition of geometrical constants for linear fits
struct geo_constants
{
    //these are the matrices themselves
    std::vector<double> Vd0; // impact paramers coefs
    std::vector<double> Vcurvature; // curvature coefs
    std::vector<double> Vphi; // phi coefs
    std::vector<double> Vz0; // z0 coefs
    std::vector<double> Veta; // eta coefs
    vector2D<double>    kernel; // kernel (covariance matrix). Size (ndim - npar, ndim)
    std::vector<double> kaverages; // averages, useful to keep track of
 
    // these are the constant/offset values
    FPGATrackSimTrackPars pars;
 
    int real{}; // this value is greater than 0 if these constants are correctly evaulated
 
    geo_constants(size_t nCoords) :
        Vd0(nCoords),
        Vcurvature(nCoords),
        Vphi(nCoords),
        Vz0(nCoords),
        Veta(nCoords),
        kernel(nCoords - FPGATrackSimTrackPars::NPARS, nCoords),
        kaverages(nCoords - FPGATrackSimTrackPars::NPARS),
        pars(0),
        real(0)
    {
    }
};
 
 
class FPGATrackSimConstGenAlgo : public AthAlgorithm
{
    public:
 
        FPGATrackSimConstGenAlgo(const std::string& name, ISvcLocator* pSvcLocator);
        virtual ~FPGATrackSimConstGenAlgo() = default;
        StatusCode initialize() override;
        StatusCode finalize() override;
 
    // Execute does not do anything for this alg. This class does not process events, everything is done in initalize
    StatusCode execute() override;
 
        StatusCode bookHistograms();
 
    private:

        // Handles
 
        ServiceHandle<IFPGATrackSimMappingSvc> m_FPGATrackSimMapping{this, "FPGATrackSimMappingSvc","FPGATrackSimMappingSvc"};
        ServiceHandle<IFPGATrackSimEventSelectionSvc> m_EvtSel{this,"FPGATrackSimEventSelectionSvc","FPGATrackSimEventSelectionSvc"};
        ServiceHandle<ITHistSvc> m_tHistSvc{this, "THistSvc","THistSvc"};
 
        const FPGATrackSimPlaneMap* m_pmap = nullptr;
 
 
    
        // Configuration
    Gaudi::Property<std::string> m_cfpath{this, "merged_file_path", "", "merged file"};
    Gaudi::Property<std::string> m_skipFile{this, "skip_sectors", "File with list of sectors to skip"};
    Gaudi::Property<bool> m_Monitor{this,"Monitor",false,"flag to enable the monitor"};
    Gaudi::Property<int> m_region{this, "region",0,"region to run"};
    Gaudi::Property<bool> m_CheckGood2ndStage{this,"CheckGood2ndStage",true,"Check goodness of 2nd stage fit constants?"};    
    Gaudi::Property<bool> m_useHitScaleFactor{this,"UseHitScaleFactor",false,"Scale factor for hits"};
    Gaudi::Property<bool> m_isSecondStage{this,"IsSecondStage",false,"If false, we're doing a 1st stage fit, otherwise 2nd stage"};
    Gaudi::Property<bool> m_dumpMissingHitsConstants{this, "missHitsConsts", false, "if this is true we dump constants assuming a missing hit in each layer, too"};

        // ROOT Objects
 
        TFile *m_mafile = nullptr;
        TTree *m_ctree = nullptr;
        TTree *m_matrix_tree = nullptr;
        TTree *m_good_tree = nullptr;
 

        // Slice Info
 
        FPGATrackSimTrackParsI m_sliceNBins;
        FPGATrackSimTrackPars m_sliceMin;
        FPGATrackSimTrackPars m_sliceMax;

        // Sizes
 
        int m_nLayers = 0;
        int m_nKernel = 0;
        int m_nKAverages = 0;
        int m_nCoords = 0;
        int m_nCoords_2 = 0; // m_nCoords^2
 

        // Main Storage Objects
 
        // These have size = # of good sectors.
        std::vector<geo_constants> m_geo_consts;
 
        // These are the constants for missing hits, first index is missing hit
        // The second index is the same as above (good sector number)
        std::vector<std::vector<geo_constants>> m_geo_consts_with_missinghit;
 
        // Size = # of sectors. Which sectors to skip for generating constants.
        std::vector<bool> m_skipList;

        // Helper Functions
 
        StatusCode copySliceTree(TFile *file);
        StatusCode prepareOutputTree();
        void readSkipList(size_t nEntries);
        void generate_constants();
        void fillConstTree(std::vector<module_t> & modules, FPGATrackSimMatrixAccumulator & acc, geo_constants & geo);
        bool isNAN(double value, const char* name);
        bool failedConstants(geo_constants const & geo, std::vector<bool> const & usable);
        StatusCode DumpConstants(std::vector<geo_constants> &geo_consts, std::string & filename);
        StatusCode writeSectors();
        bool GetConstants(FPGATrackSimMatrixAccumulator const &acc_norm, geo_constants &geo, int entryNumber); // use values in acc_norm
        bool GetConstants(FPGATrackSimMatrixAccumulator const &acc_norm, geo_constants &geo, int entryNumber, std::vector<bool> const &coordsToUse, unsigned int nusable); // full method with different number of usable coordinates
        void createMissingHitsConstants(FPGATrackSimMatrixAccumulator const & acc_norm, size_t entry);
    FPGATrackSimMatrixAccumulator normalize(FPGATrackSimMatrixAccumulator const & acc_raw);
    geo_constants makeConsts(FPGATrackSimMatrixAccumulator const & acc, std::vector<bool> const & usable,
                 std::vector<double> const & inv_covariance,
                 std::vector<double> const & eigvals, vector2D<double> const & eigvecs);
    std::vector<double> matrix_multiply(std::vector<double> const & A, std::vector<double> const & b);
    void eigen(size_t n_redu, size_t n_full, TMatrixD &mtx, std::vector<bool> const & usable, std::vector<double> & eigvals_v, vector2D<double> & eigvecs_v);
    std::vector<double> invert(size_t n_full, TMatrixD mtx, std::vector<bool> const & usable);
    TMatrixD getReducedMatrix(size_t n, std::vector<double> const & mtx_v, std::vector<bool> const & usable, size_t nDimToUse);
    bool isSingular(TMatrixD mtx);
    double dot(const double* vec1, const double* vec2, size_t size);
    geo_constants calculate_gcorth(geo_constants geo, int nCoords, std::vector<bool> const & usable);
 
 
 
};
 
#endif // FPGATrackSimConstGenAlgo_h