MuonValR4::RootVisualizationService Class Reference

Implementation of the IRootVisualization service. More...

#include <RootVisualizationService.h>

Inheritance diagram for MuonValR4::RootVisualizationService:

Collaboration diagram for MuonValR4::RootVisualizationService:

Classes
struct	PlotsPerClient
	Helper struct to group all plots that are belonging to a client of the service. More...

Public Types
using	PlotPtr_t = std::shared_ptr< detail::DrawCanvasObject >
using	PlotVec_t = std::vector< PlotPtr_t >

Public Member Functions
virtual StatusCode	registerClient (const ClientToken &token) override final
virtual std::shared_ptr< ICanvasObject >	prepareCanvas (const EventContext &ctx, const ClientToken &token, const std::string &canvasName) override final
virtual StatusCode	finalize () override final
virtual StatusCode	initialize () override final

Private Types
using	StorageMap_t = std::map< ClientToken, PlotsPerClient >

Private Member Functions
void	paintObjects (const ClientToken &token, PlotVec_t &&toDraw)

Private Attributes
Gaudi::Property< double >	m_canvasExtraScale {this, "CanvasExtraScale" , 1.5}
	Extra safety margin to zoom out from the Canvas. More...
Gaudi::Property< bool >	m_quadCanvas {this, "QuadraticCanas", true}
	Ensure that the canvas has the same interval sizes in x & y. More...
Gaudi::Property< std::string >	m_AtlasLabel {this, "AtlasLabel", "Internal"}
	ATLAS label (Internal / Prelimnary / Simulation) More...
Gaudi::Property< std::string >	m_sqrtSLabel {this, "SqrtSLabel", "14"}
	Centre of mass energy label. More...
Gaudi::Property< std::string >	m_lumiLabel {this, "LumiLabel", ""}
	Luminosity label. More...
Gaudi::Property< unsigned >	m_canvasWidth {this, "CanvasWidth", 800}
	Width of all drawn Canvases. More...
Gaudi::Property< unsigned >	m_canvasHeight {this, "CanvasHeight", 600}
	Height of all drawn Canvases. More...
Gaudi::Property< std::string >	m_outDir {this, "outputDir" , "./Displays/"}
	Directory into which all plots are written to More...
Gaudi::Property< std::string >	m_outRootFileName {this, "outputROOTFile", "AllDisplays.root"}
	Name of the ROOT file into which the output Canvases are written (needs root to be in the list of outputFormats of the client tokens) More...
StorageMap_t	m_storage {}
std::unique_ptr< TFile >	m_outFile {}
	File into which all Canvases are saved if root is defined as extension. More...
std::mutex	m_storageMutex {}
std::mutex	m_canvasMutex {}

Detailed Description

Implementation of the IRootVisualization service.

Definition at line 18 of file RootVisualizationService.h.

Member Typedef Documentation

PlotPtr_t

using MuonValR4::RootVisualizationService::PlotPtr_t = std::shared_ptr<detail::DrawCanvasObject>

Definition at line 31 of file RootVisualizationService.h.

PlotVec_t

using MuonValR4::RootVisualizationService::PlotVec_t = std::vector<PlotPtr_t>

Definition at line 32 of file RootVisualizationService.h.

StorageMap_t

using MuonValR4::RootVisualizationService::StorageMap_t = std::map<ClientToken, PlotsPerClient>

private

Definition at line 69 of file RootVisualizationService.h.

Member Function Documentation

finalize()

StatusCode MuonValR4::RootVisualizationService::finalize ( )

finaloverridevirtual

Definition at line 184 of file RootVisualizationService.cxx.

                                                  {
        ATH_MSG_DEBUG("Finalize the visualization service. Dump all canvases that not have yet been drawn");
        for (auto& [token, dataHolder] : m_storage) {
            if (!dataHolder.elementsDrawn) {
                paintObjects(token, std::move(dataHolder.toDraw));
            }
            dataHolder.toDraw.clear();
        }
        m_outFile.reset();
        return StatusCode::SUCCESS;
    }

initialize()

StatusCode MuonValR4::RootVisualizationService::initialize ( )

finaloverridevirtual

Definition at line 34 of file RootVisualizationService.cxx.

                                                    {
        gROOT->SetStyle("ATLAS");
        TStyle* plotStyle = gROOT->GetStyle("ATLAS");
        plotStyle->SetOptTitle(0);
        plotStyle->SetHistLineWidth(1.);
        plotStyle->SetPalette(kViridis);
 
        return StatusCode::SUCCESS;
    }

paintObjects()

void MuonValR4::RootVisualizationService::paintObjects ( const ClientToken &  token, PlotVec_t &&  toDraw  )

private

First sort the plots by the event number

The client still holds the pointer to the plot

Number the plots per event

Setup the frame

Draw the primitives

Save the single plots

Definition at line 90 of file RootVisualizationService.cxx.

                                                                    {
        if (toDraw.empty()){
            return;
        }
        std::ranges::stable_sort(toDraw, [](const PlotPtr_t& a, const PlotPtr_t& b){
            return a->event() < b->event();
        });
        std::unique_lock guard{m_canvasMutex};
        std::unique_ptr<TCanvas> summaryCan{};
        const std::string summaryPdfName =  std::format("{:}/All{}.pdf", 
                                                        m_outDir.value(), token.preFixName);
        if (token.saveSummaryPlot) {
            ATH_MSG_DEBUG("Open "<<summaryPdfName<<" to dump all canvases in a common file");
            ensureDirectory(summaryPdfName);
            summaryCan = std::make_unique<TCanvas>("allCan","allCan", m_canvasWidth, m_canvasHeight);
            summaryCan->SaveAs(std::format("{:}[", summaryPdfName).c_str());
        }
        if (token.fileFormats.count("root") && !m_outFile) {
            std::string outFile = std::format("{:}/{:}", m_outDir.value(), 
                                              m_outRootFileName.value());
            ensureDirectory(m_outDir);
            m_outFile.reset(TFile::Open(outFile.c_str(), "RECREATE"));
            if (!m_outFile || m_outFile->IsZombie()) {
                THROW_EXCEPTION("Failed to create "<<outFile<<".");
            }
            ATH_MSG_DEBUG("Open "<<outFile<<" to save the plots in root format");
        }
        std::size_t currEvt{toDraw.back()->event()}, plotCount{0};
        for (const PlotPtr_t& drawMe : toDraw) {
            while (!drawMe.unique()) {
                using namespace std::chrono_literals;
                ATH_MSG_DEBUG("Wait until "<<drawMe->name()<<" is finished.");
                std::this_thread::sleep_for(10ms);
            }
            if (currEvt != drawMe->event()) {
                currEvt = drawMe->event();
                plotCount = 0;
            }
            std::string plotName = std::format("{:}/{:}/{:}_{:}_{:}_{:}", m_outDir.value(),
                                                token.subDirectory, token.preFixName,
                                                drawMe->event(), ++plotCount,
                                                removeNonAlphaNum(drawMe->name()));
                      
            auto singleCan = std::make_unique<TCanvas>("can", "can" , m_canvasWidth, m_canvasHeight);
            singleCan->cd();
            using enum ICanvasObject::AxisRanges;
            ATH_MSG_VERBOSE("Crate new canvas: "<<plotName<<" ["<<drawMe->corner(xLow)<<";"<<drawMe->corner(xHigh)
                        <<"], ["<<drawMe->corner(yLow)<<";"<<drawMe->corner(yHigh)<<"].");
            auto frameH = std::make_unique<TH2F>("frameH", 
                    std::format("frame;{:};{:};{:}", drawMe->xTitle(), drawMe->yTitle(), drawMe->zTitle()).c_str(),
                    1, drawMe->corner(xLow), drawMe->corner(xHigh), 
                    1, drawMe->corner(yLow), drawMe->corner(yHigh));
            frameH->Draw("AXIS");
            drawMe->add(drawAtlasLabel(0.65, 0.26, m_AtlasLabel));
            drawMe->add(drawLumiSqrtS(0.65,0.21, m_sqrtSLabel, m_lumiLabel));
            for (auto& [primitive, opt] : drawMe->primitives()) {
                primitive->Draw(opt.c_str());
            }
            if (token.saveSinglePlots){
                for (const std::string& fileExt : token.fileFormats) {
                    if (fileExt != "root") {
                        ensureDirectory(plotName);
                        singleCan->SaveAs(std::format("{:}.{:}", plotName, fileExt).c_str());
                    } 
                }
            }
            if (token.fileFormats.count("root")) {
                TDirectory* writeTo = m_outFile.get();
                if (!token.subDirectory.empty()) {
                    writeTo = m_outFile->GetDirectory(token.subDirectory.c_str());
                    if (!writeTo) {
                        writeTo = m_outFile->mkdir(token.subDirectory.c_str());
                    }
                }
                writeTo->WriteObject(singleCan.get(),
                        std::format("{:}_{:}_{:}_{:}",token.preFixName,
                                    drawMe->event(), plotCount,
                                    removeNonAlphaNum(drawMe->name())).c_str());
            }
            if (summaryCan) {
                singleCan->SaveAs(summaryPdfName.c_str());
            }
        }
        if (summaryCan) {
            summaryCan->SaveAs(std::format("{:}]", summaryPdfName).c_str());
        }
    }

prepareCanvas()

std::shared_ptr< ICanvasObject > MuonValR4::RootVisualizationService::prepareCanvas ( const EventContext &  ctx, const ClientToken &  token, const std::string &  canvasName  )

finaloverridevirtual

Definition at line 63 of file RootVisualizationService.cxx.

                                                                        {
        if (canvasName.empty()) {
            THROW_EXCEPTION("The canvas name must not be empty");
        }
        std::unique_lock lock_guard{m_storageMutex};
        StorageMap_t::iterator store_itr = m_storage.find(token);
        if (store_itr == m_storage.end()) {
            THROW_EXCEPTION("The token "<<token.preFixName<<" is unknown.");
        }
        PlotsPerClient& dataHolder = store_itr->second;
        if (!dataHolder.elementsDrawn &&
            cleanTrashed(dataHolder.toDraw) < store_itr->first.canvasLimit){
            const std::size_t evt = ctx.eventID().event_number();
            ATH_MSG_VERBOSE("Provide new canvas "<<canvasName<<" for stream "<<token.preFixName
                            <<" in "<<ctx.eventID());
            auto newCanvas = dataHolder.toDraw.emplace_back(std::make_shared<detail::DrawCanvasObject>(canvasName, evt));
            newCanvas->setRangeScale(m_canvasExtraScale, m_quadCanvas);
            return newCanvas;
        } else if (!dataHolder.elementsDrawn) {
            paintObjects(store_itr->first, std::move(dataHolder.toDraw));
            dataHolder.elementsDrawn = true;
        }
        ATH_MSG_VERBOSE("Maximum elements for "<<token.preFixName
                        <<" reached. Don't provide any new canvas");
        return nullptr;
    }

registerClient()

StatusCode MuonValR4::RootVisualizationService::registerClient ( const ClientToken &  token )

finaloverridevirtual

Definition at line 43 of file RootVisualizationService.cxx.

                                                                                {
        if (token.preFixName.empty()){
            ATH_MSG_FATAL("Prefix name must not be empty");
            return StatusCode::FAILURE;
        }
        std::unique_lock guard{m_storageMutex};
        auto insert_itr = m_storage.insert(std::make_pair(token, PlotsPerClient{}));
        if (!insert_itr.second) {
            ATH_MSG_FATAL("The token "<<token.preFixName<<" is already registered");
            return StatusCode::FAILURE;
        }
        ATH_MSG_INFO("Registered new client "<<token.preFixName
                    <<", maximum number of plots "<<token.canvasLimit
                    <<", formats: "<<token.fileFormats<<", save single: "
                    <<(token.saveSinglePlots ? "yay" : "nay")
                   <<", save summary: "<<(token.saveSummaryPlot ? "yay" : "nay"));
        return StatusCode::SUCCESS;
    }

Member Data Documentation

m_AtlasLabel

Gaudi::Property<std::string> MuonValR4::RootVisualizationService::m_AtlasLabel {this, "AtlasLabel", "Internal"}

private

ATLAS label (Internal / Prelimnary / Simulation)

Definition at line 44 of file RootVisualizationService.h.

m_canvasExtraScale

Gaudi::Property<double> MuonValR4::RootVisualizationService::m_canvasExtraScale {this, "CanvasExtraScale" , 1.5}

private

Extra safety margin to zoom out from the Canvas.

Definition at line 40 of file RootVisualizationService.h.

m_canvasHeight

Gaudi::Property<unsigned> MuonValR4::RootVisualizationService::m_canvasHeight {this, "CanvasHeight", 600}

private

Height of all drawn Canvases.

Definition at line 52 of file RootVisualizationService.h.

m_canvasMutex

std::mutex MuonValR4::RootVisualizationService::m_canvasMutex {}

private

Definition at line 75 of file RootVisualizationService.h.

m_canvasWidth

Gaudi::Property<unsigned> MuonValR4::RootVisualizationService::m_canvasWidth {this, "CanvasWidth", 800}

private

Width of all drawn Canvases.

Definition at line 50 of file RootVisualizationService.h.

m_lumiLabel

Gaudi::Property<std::string> MuonValR4::RootVisualizationService::m_lumiLabel {this, "LumiLabel", ""}

private

Luminosity label.

Definition at line 48 of file RootVisualizationService.h.

m_outDir

Gaudi::Property<std::string> MuonValR4::RootVisualizationService::m_outDir {this, "outputDir" , "./Displays/"}

private

Directory into which all plots are written to

Definition at line 54 of file RootVisualizationService.h.

m_outFile

std::unique_ptr<TFile> MuonValR4::RootVisualizationService::m_outFile {}

private

File into which all Canvases are saved if root is defined as extension.

Definition at line 72 of file RootVisualizationService.h.

m_outRootFileName

Gaudi::Property<std::string> MuonValR4::RootVisualizationService::m_outRootFileName {this, "outputROOTFile", "AllDisplays.root"}

private

Name of the ROOT file into which the output Canvases are written (needs root to be in the list of outputFormats of the client tokens)

Definition at line 57 of file RootVisualizationService.h.

m_quadCanvas

Gaudi::Property<bool> MuonValR4::RootVisualizationService::m_quadCanvas {this, "QuadraticCanas", true}

private

Ensure that the canvas has the same interval sizes in x & y.

Definition at line 42 of file RootVisualizationService.h.

m_sqrtSLabel

Gaudi::Property<std::string> MuonValR4::RootVisualizationService::m_sqrtSLabel {this, "SqrtSLabel", "14"}

private

Centre of mass energy label.

Definition at line 46 of file RootVisualizationService.h.

m_storage

StorageMap_t MuonValR4::RootVisualizationService::m_storage {}

private

Definition at line 70 of file RootVisualizationService.h.

m_storageMutex

std::mutex MuonValR4::RootVisualizationService::m_storageMutex {}

private

Definition at line 74 of file RootVisualizationService.h.

---

The documentation for this class was generated from the following files:

• RootVisualizationService.h
• RootVisualizationService.cxx