tracks3d.C

Go to the documentation of this file.

/*
    BM@N alignment routine
    BM@N experiment at NICA complex, JINR, 2026
 
    Department: Math & Soft Group of HEP lab
    Author:     Claude (Opus 5)
    Supervisor: Igor Polev, polev@jinr.int
 
    Track sample view: a random set of tracks drawn as 3D polylines through
    their hits, as in the tracks pad of BmnAlignReport::Draw()
*/
 
// headers below are for IDE syntax to work and they will be
// turned off during execution in ROOT macro mode
#ifndef __CLING__
#include "BmnAlignModels.h"   // IWYU pragma: keep
#include "BmnDataFilters.h"
#include "BmnRootIterator.h"
#include "BmnSimpleProgressBar.h"
#include "TAxis3D.h"
#include "TCanvas.h"
#include "TMath.h"
#include "TPolyLine3D.h"
#include "TRandom3.h"
#include "TView.h"
 
#include <algorithm>
#include <array>
#include <vector>
#endif
 
#include "fairlogger/Logger.h"
 
/**
 * @brief Draw a uniformly random sample of tracks as 3D polylines through their hits.
 *
 * Tracks and hits are read through BmnRootIterator with the aligner's default
 * filters, so the sample comes from exactly the tracks the aligner would use.
 * Reservoir sampling makes it exact in size and uniform over all accepted
 * tracks, at the cost of one full pass over the data. As in
 * BmnAlignReport::Draw(), x and z are swapped: the beam runs along the
 * horizontal axis of the view.
 *
 * @param fileListPath text file listing the .root files, '#' lines are ignored
 * @param tracksToDraw size of the sample
 * @param maxTracks    sample among the first maxTracks accepted tracks only, 0 for all
 *
 * @return 0 on success, -1 if nothing could be read
 */
int tracks3d(const char* fileListPath = "/home/igor/data.cache/Run9compare/rc_aln.run_Top_9555_ev0_p0.lst",
             Int_t tracksToDraw = 100,
             Int_t maxTracks = 0)
{
    fair::Logger::SetConsoleColor(true);
    fair::Logger::SetConsoleSeverity("info");
 
    BmnRun9DM detectorModel;
    // the target geometry places the vertex hit the iterator prepends to each track
    if (!detectorModel.Init("/home/igor/bmnroot/geometry/target_Sn.geo") || tracksToDraw <= 0)
        return -1;
 
    BmnSimpleProgressBar progressBar;
    BmnRootIterator iterator{
        fileListPath, detectorModel, BmnDefaultTrackFilter(kTRUE), BmnDefaultHitFilter(detectorModel), &progressBar,
        kFALSE,       maxTracks};
    if (!iterator.Initialized())
        return -1;
 
    using Point_t = std::array<Double_t, 3>;   // z, y, x - the order the view shows them in
    std::vector<std::vector<Point_t>> sample;
    sample.reserve(tracksToDraw);
    TRandom3 rnd{0};
    Long64_t seen{0};
    progressBar.Init();
    for (iterator.ResetAll(); !iterator.EndOfTracks(); iterator.NextTrack(), seen++) {
        // reservoir sampling: once the reservoir is full, track number k (from 0)
        // takes a random slot with probability tracksToDraw / (k + 1)
        const Long64_t slot{seen < tracksToDraw ? seen : rnd.Integer(static_cast<UInt_t>(seen + 1))};
        if (slot >= tracksToDraw)
            continue;
 
        std::vector<Point_t> points;
        points.reserve(iterator.HitsInTrack());
        for (; !iterator.EndOfHits(); iterator.NextHit())
            points.push_back({iterator.HitZ(), iterator.HitY(), iterator.HitX()});
        std::sort(points.begin(), points.end());   // z first, so a polyline never zigzags back
 
        if (seen < tracksToDraw)
            sample.push_back(std::move(points));
        else
            sample[slot] = std::move(points);
    }
    progressBar.Clear();
    LOG(info) << "    " << sample.size() << " of " << seen << " accepted tracks drawn";
    if (sample.empty())
        return -1;
 
    Point_t lo, hi;
    lo.fill(TMath::Infinity());
    hi.fill(-TMath::Infinity());
    for (const std::vector<Point_t>& track : sample)
        for (const Point_t& p : track)
            for (Int_t i{0}; i < 3; i++) {
                lo[i] = std::min(lo[i], p[i]);
                hi[i] = std::max(hi[i], p[i]);
            }
 
    TCanvas* pCnv{new TCanvas(   // RAM not released - acceptable in macro mode
        "tracks3d", Form("%zu random tracks from %s", sample.size(), fileListPath), 1200, 800)};
    pCnv->cd();
    TView* view{TView::CreateView(1)};
    view->SetRange(lo[0], lo[1], lo[2], hi[0], hi[1], hi[2]);
 
    for (const std::vector<Point_t>& track : sample) {
        TPolyLine3D* line{new TPolyLine3D()};
        for (std::size_t i{0}; i < track.size(); i++)
            line->SetPoint(i, track[i][0], track[i][1], track[i][2]);
        line->SetLineColor(kBlue);
        line->Draw();
    }
 
    TAxis3D* axis{TAxis3D::ToggleRulers()};
    axis->GetXaxis()->SetTitle("z, cm");
    axis->GetYaxis()->SetTitle("y, cm");
    axis->GetZaxis()->SetTitle("x, cm");
    return 0;
}