BmnHistHgnd.cxx

Go to the documentation of this file.

#include "BmnHistHgnd.h"
 
#include "BmnHgndDigi.h"
#include "TGaxis.h"
 
BmnHistHgnd::BmnHistHgnd(TString title, TString path, Int_t PeriodID, BmnSetup stp)
    : BmnHist(PeriodID, stp)
{
    fTitle = title;
    fName = title + "_cl";
    SetGeometry(Form("Hgnd_geo_period%d.root", PeriodID));
    TGaxis::SetMaxDigits(2);
    InitializeAddresses();
    CreateHistos();
}
 
BmnHistHgnd::~BmnHistHgnd()
{
    if (fDir) {
        LOG(info) << "BmnHistHgnd::~BmnHistHgnd: fDir return";
        return;
    }
    for (auto& canvasInfo : m_canvases) {
        if (canvasInfo) {
            for (auto*& pad : canvasInfo->pads) {
                if (pad) {
                    delete pad;
                    pad = nullptr;
                }
            }
            canvasInfo->pads.clear();
        }
        delete canvasInfo->canvas;
    }
}
 
void BmnHistHgnd::SetGeometry(const std::string& path)
{
    LOG(debug) << "BmnHistHgnd::SetGeometry " << path;
    fGeoHandler = std::make_unique<BmnNdetGeo>();
    fGeoHandler->ReadGeometryFromFile(path);
}
 
void BmnHistHgnd::InitializeAddresses()
{
    fAddresses.clear();
 
    // Detectors (1 and 2 for Hgnd)
    std::vector<int> detectors = {1, 2};
 
    for (int det : detectors) {
        for (uint32_t lay = 1; lay <= kLAYRS; ++lay) {
            for (uint32_t row = 1; row <= kROWS; ++row) {
                for (uint32_t col = 1; col <= kCOLS; ++col) {
                    uint32_t address = BmnNdetAddress::GetAddress(det, row, col, lay);
                    fAddresses.insert(address);
                }
            }
        }
    }
 
    LOG(info) << "BmnHistHgnd: initialized " << fAddresses.size() << " addresses";
}
 
void BmnHistHgnd::setupAxis(TH1* hist, const std::string& xTitle, const std::string& yTitle)
{
    if (!xTitle.empty()) {
        hist->GetXaxis()->SetTitle(xTitle.c_str());
        hist->GetXaxis()->SetTitleColor(kOrange + 10);
    }
    if (!yTitle.empty()) {
        hist->GetYaxis()->SetTitle(yTitle.c_str());
        hist->GetYaxis()->SetTitleColor(kOrange + 10);
    }
}
 
void BmnHistHgnd::CreateHistos()
{
    // Helper lambdas
    auto createH1 = [this](const std::string& name, const std::string& title, int nbins, double xmin, double xmax,
                           const std::string& xTitle = "", const std::string& yTitle = "") -> TH1F* {
        TString fullName = fTitle + "_" + name;
        auto* hist = new TH1F(fullName, title.c_str(), nbins, xmin, xmax);
        setupAxis(hist, xTitle, yTitle);
        m_allHistograms.push_back(hist);
        return hist;
    };
 
    auto createH2 = [this](const std::string& name, const std::string& title, int nbinsx, double xmin, double xmax,
                           int nbinsy, double ymin, double ymax, const std::string& xTitle = "",
                           const std::string& yTitle = "") -> TH2F* {
        TString fullName = fTitle + "_" + name;
        auto* hist = new TH2F(fullName, title.c_str(), nbinsx, xmin, xmax, nbinsy, ymin, ymax);
        setupAxis(hist, xTitle, yTitle);
        hist->GetZaxis()->SetNoExponent(kFALSE);
        hist->SetOption("colz");
        hist->SetStats(0);
        m_allHistograms.push_back(hist);
        return hist;
    };
 
    auto addCanvas = [this](const std::string& name, int w, int h, int rows = 1, int cols = 1) -> CanvasInfo* {
        TString fullName = fTitle + name;
        auto* canvas = new TCanvas(fullName, fullName, w, h);
        if (rows > 1 || cols > 1)
            canvas->Divide(rows, cols);
 
        auto info = std::make_unique<CanvasInfo>(canvas);
        CanvasInfo* ptr = info.get();
        m_canvases.push_back(std::move(info));
        return ptr;
    };
 
    auto addPad = [](CanvasInfo* cinfo, TH1* hist, const std::string& opt, const std::string& name = "") {
        auto* pad = new PadInfo(hist);
        pad->opt = opt;
        if (!name.empty()) {
            pad->name = name;
        } else {
            pad->name = hist->GetName();
        }
        cinfo->pads.push_back(pad);
    };
 
    // 1D histograms
    h1_ECells =
        createH1("h1_ECells", "Hgnd signal in cells", kROWS * kCOLS, 0, kROWS * kCOLS, "Cell id", "Average Signal");
    h1_ProfileSlice =
        createH1("h1_ProfileSlice", "Energy in detector slice", kLAYRS, 1, kLAYRS + 1, "Layer id", "Events");
 
    // 2D histograms
    h2_grid =
        createH2("h2_grid", "Hgnd_Grid", kROWS + 2, 0, kROWS + 2, kCOLS + 2, 0, kCOLS + 2, "X position", "Y position");
    h2_Layer_Cell = createH2("h2_Layer_Cell", "h2_Layer_Cell", kLAYRS + 2, 0, kLAYRS + 2, kROWS * kCOLS + 2, 0,
                             kROWS * kCOLS + 2, "Layer number", "Cell number");
 
    for (uint32_t layer = 1; layer <= kLAYRS; ++layer) {
        TString ampName = fTitle + TString::Format("_hLayer%d_Amp", layer);
        hLayerAmps[layer] =
            new TH2F(ampName, TString::Format("Layer %d Amplitudes", layer), kROWS, 0, kROWS, kCOLS, 0, kCOLS);
        setupAxis(hLayerAmps[layer], "Column", "Row");
        m_allHistograms.push_back(hLayerAmps[layer]);
    }
 
    // Address-indexed histograms
    for (uint32_t address : fAddresses) {
        int arm = BmnNdetAddress::GetArmId(address);
        int lay = BmnNdetAddress::GetLayerId(address);
        int row = BmnNdetAddress::GetRowId(address);
        int col = BmnNdetAddress::GetColumnId(address);
 
        // Profile histogram (signal vs lay for this cell)
        if (lay == 1) {
            TString profName = fTitle + TString::Format("_hProfCell_%08X", address);
            hProfCell[address] =
                new TH1F(profName, TString::Format("D%d R%d C%d Profile", arm, row, col), kLAYRS, 1, kLAYRS + 1);
            setupAxis(hProfCell[address], "Layer id", "Average Signal");
            m_allHistograms.push_back(hProfCell[address]);
        }
 
        // Amplitude histogram
        TString ampTimeName = fTitle + TString::Format("_hCellAmpTime_%08X", address);
        hCellAmpTime[address] = new TH2F(ampTimeName, TString::Format("D%d L%d R%d C%d Amplitude", arm, lay, row, col),
                                         100, 0, 100, 100, -300, 300);
        setupAxis(hCellAmpTime[address], "Signal", "");
        m_allHistograms.push_back(hCellAmpTime[address]);
    }
 
    // Canvases
    auto* canAmpsInfo = addCanvas("CanvasAmplitudes", PAD_WIDTH, PAD_HEIGHT, 2, 1);
    addPad(canAmpsInfo, h2_grid, "colz", "h2_grid");
    addPad(canAmpsInfo, h1_ECells, "hist", "h1_ECells");
 
    auto* canvSliceInfo = addCanvas("CanvasSlice", PAD_WIDTH, PAD_HEIGHT, 2, 1);
    addPad(canvSliceInfo, h2_Layer_Cell, "colz", "h2_Layer_Cell");
    addPad(canvSliceInfo, h1_ProfileSlice, "hist", "h1_ProfileSlice");
 
    // Profile canvas - show first lay only (original behavior)
    auto* canvProfInfo = addCanvas("CanvasProfiles", PAD_WIDTH, PAD_HEIGHT, kROWS, kCOLS);
    for (uint32_t address : fAddresses) {
        int lay = BmnNdetAddress::GetLayerId(address);
        if (lay == 1) {
            int row = BmnNdetAddress::GetRowId(address);
            int col = BmnNdetAddress::GetColumnId(address);
            addPad(canvProfInfo, hProfCell[address], "hist", TString::Format("R%dC%d", row, col).Data());
        }
    }
 
    // Cell amplitude canvas - show all addresses
    auto* canvCellAmpInfo = addCanvas("CanvasCellAmp", PAD_WIDTH, PAD_HEIGHT, kROWS, kCOLS);
    for (uint32_t address : fAddresses) {
        int lay = BmnNdetAddress::GetLayerId(address);
        int row = BmnNdetAddress::GetRowId(address);
        int col = BmnNdetAddress::GetColumnId(address);
        addPad(canvCellAmpInfo, hCellAmpTime[address], "hist", TString::Format("L%d_R%dC%d", lay, row, col).Data());
    }
}
 
void BmnHistHgnd::Register(THttpServer* serv)
{
    fServer = serv;
    fServer->Register("/", this);
    TString path = "/" + fTitle + "/";
 
    for (auto& cinfo_ptr : m_canvases) {
        fServer->Register(path, cinfo_ptr->canvas);
    }
 
    TString cmd = "/" + fName + "/->Reset()";
    fServer->SetItemField(path.Data(), "_monitoring", "2000");
    fServer->SetItemField(path.Data(), "_layout", "grid11x11");
    TString cmdTitle = path + "Reset";
    fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
    fServer->Restrict(cmdTitle, "visible=shift");
    fServer->Restrict(cmdTitle, "allow=shift");
    cmd = "/" + fName + "/->SetRefRun(%arg1%)";
    cmdTitle = path + "SetRefRun";
    fServer->RegisterCommand(cmdTitle.Data(), cmd.Data(), "button;");
    cmdTitle = path + "ChangeSelection";
    fServer->RegisterCommand(cmdTitle, TString("/") + fName.Data() + "/->SetSelection(%arg1%)", "button;");
    fServer->Restrict(cmdTitle, "visible=shift");
    fServer->Restrict(cmdTitle, "allow=shift");
    fServer->Restrict(cmdTitle.Data(), "deny=guest");
}
 
void BmnHistHgnd::SetDir(TFile* outFile, TTree* recoTree)
{
    frecoTree = recoTree;
    fDir = nullptr;
    if (outFile) {
        fDir = outFile->mkdir(fTitle + "_hists");
    }
 
    for (auto* hist : m_allHistograms) {
        hist->SetDirectory(fDir);
    }
}
 
void BmnHistHgnd::SetSelection(Int_t Trigger)
{
    fSelection = true;
    fSelectedTrigger = Trigger;
    Reset();
}
 
void BmnHistHgnd::DrawBoth()
{
    for (auto& cinfo_ptr : m_canvases) {
        BmnHist::DrawRef(cinfo_ptr->canvas, &cinfo_ptr->pads);
    }
}
 
void BmnHistHgnd::FillFromDigi(DigiArrays* fDigiArrays)
{
    BmnEventHeader* head = fDigiArrays->header;
    TClonesArray* digits = fDigiArrays->hgnd;
    if (!digits)
        return;
 
    if (fSelection && ((head->GetInputSignalsAR() >> fSelectedTrigger) & 1)) {
        // Scale by event counter
        double scale = 1.0 / fEventCounter;
        h1_ECells->Scale(scale);
        h1_ProfileSlice->Scale(scale);
        h2_grid->Scale(scale);
        h2_Layer_Cell->Scale(scale);
 
        // Scale address-indexed histograms
        for (auto& [address, hist] : hProfCell) {
            if (hist)
                hist->Scale(scale);
        }
 
        for (Int_t iDig = 0; iDig < digits->GetEntriesFast(); iDig++) {
            auto* digi = static_cast<BmnHgndDigi*>(digits->At(iDig));
 
            uint32_t address = digi->GetAddress();
            double signal = digi->GetSignal();
            double time = digi->GetTime();
            auto arm = digi->GetArmId();
            auto row = digi->GetRowId();
            auto col = digi->GetColumnId();
            auto cell = (row - 1) * kCOLS + col;
            auto lay = digi->GetLayerId();
 
            // Verify address is known
            if (fAddresses.find(address) == fAddresses.end()) {
                LOG(debug) << "Unknown Hgnd address: " << address;
                continue;
            }
 
            // Fill histograms
            h1_ECells->Fill(cell, signal);
            h1_ProfileSlice->Fill(lay, signal);
            h2_grid->Fill(col, row, signal);
            h2_Layer_Cell->Fill(lay, cell, signal);
 
            // Fill per-cell histograms
            if (hCellAmpTime.find(address) != hCellAmpTime.end()) {
                hCellAmpTime[address]->Fill(signal, time);
            }
            if (hProfCell.find(BmnNdetAddress::GetAddress(arm, row, col, 1)) != hProfCell.end()) {
                hProfCell[BmnNdetAddress::GetAddress(arm, row, col, 1)]->Fill(lay, signal);
            }
            if (hLayerAmps.find(lay) != hLayerAmps.end()) {
                hLayerAmps[lay]->Fill(row, col, signal);
            }
        }
 
        fEventCounter++;
    }
}
 
BmnStatus BmnHistHgnd::SetRefRun(Int_t id)
{
    TString FileName = Form("bmn_run%04d_hist.root", id);
    printf("SetRefRun: %s\n", FileName.Data());
    if (refRunName != FileName) {
        refRunName = FileName;
        refID = id;
 
        for (auto& cinfo_ptr : m_canvases) {
            BmnHist::LoadRefRun(refID, refPath + FileName, fTitle, cinfo_ptr->pads);
        }
 
        DrawBoth();
    }
    return kBMNSUCCESS;
}
 
void BmnHistHgnd::ClearRefRun()
{
    for (auto& cinfo_ptr : m_canvases) {
        for (auto* pad : cinfo_ptr->pads) {
            if (pad->ref) {
                delete pad->ref;
                pad->ref = nullptr;
            }
        }
    }
    refID = 0;
}
 
void BmnHistHgnd::Reset()
{
    printf("BmnHistHgnd : Reset histos\n");
    fEventCounter = 1;
 
    for (auto* hist : m_allHistograms) {
        hist->Reset();
    }
}