TRestMetadataPlot.cxx

/*************************************************************************
 * This file is part of the REST software framework.                     *
 *                                                                       *
 * Copyright (C) 2016 GIFNA/TREX (University of Zaragoza)                *
 * For more information see http://gifna.unizar.es/trex                  *
 *                                                                       *
 * REST is free software: you can redistribute it and/or modify          *
 * it under the terms of the GNU General Public License as published by  *
 * the Free Software Foundation, either version 3 of the License, or     *
 * (at your option) any later version.                                   *
 *                                                                       *
 * REST is distributed in the hope that it will be useful,               *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the          *
 * GNU General Public License for more details.                          *
 *                                                                       *
 * You should have a copy of the GNU General Public License along with   *
 * REST in $REST_PATH/LICENSE.                                           *
 * If not, see http://www.gnu.org/licenses/.                             *
 * For the list of contributors see $REST_PATH/CREDITS.                  *
 *************************************************************************/
 
 
#include "TRestMetadataPlot.h"
 
#include "TRestManager.h"
#include "TRestTools.h"
 
using namespace std;
 
#include <TGraph.h>
#include <TLegend.h>
#include <TStyle.h>
 
#include <ctime>
 
ClassImp(TRestMetadataPlot);
 
TRestMetadataPlot::TRestMetadataPlot() { Initialize(); }
 
TRestMetadataPlot::TRestMetadataPlot(const char* configFilename, const char* name)
    : TRestMetadata(configFilename) {
    Initialize();
 
    LoadConfigFromFile(fConfigFileName, name);
}
 
TRestMetadataPlot::~TRestMetadataPlot() {
    if (fRun != nullptr) delete fRun;
}
 
void TRestMetadataPlot::Initialize() {
    SetSectionName(this->ClassName());
 
    fRun = nullptr;
 
    fNFiles = 0;
 
    fCombinedCanvas = nullptr;
 
    fPlotNamesCheck.clear();
}
 
void TRestMetadataPlot::InitFromConfigFile() {
    if (fHostmgr->GetRunInfo() != nullptr) {
        fRun = fHostmgr->GetRunInfo();
    }
 
    RESTDebug << "TRestMetadataPlot: Reading canvas settings" << RESTendl;
    TiXmlElement* formatDefinition = GetElement("labels");
    if (formatDefinition != nullptr) {
        if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
            cout << formatDefinition << endl;
            cout << "Reading format definition : " << endl;
            cout << "---------------------------" << endl;
        }
 
        fTicksScaleX = StringToDouble(GetFieldValue("ticksScaleX", formatDefinition));
        fTicksScaleY = StringToDouble(GetFieldValue("ticksScaleY", formatDefinition));
 
        fLabelScaleX = StringToDouble(GetFieldValue("labelScaleX", formatDefinition));
        fLabelScaleY = StringToDouble(GetFieldValue("labelScaleY", formatDefinition));
 
        fLabelOffsetX = StringToDouble(GetFieldValue("labelOffsetX", formatDefinition));
        fLabelOffsetY = StringToDouble(GetFieldValue("labelOffsetY", formatDefinition));
 
        if (fLabelOffsetX == -1) fLabelOffsetX = 1.1;
        if (fLabelOffsetY == -1) fLabelOffsetY = 1.3;
 
        if (fTicksScaleX == -1) fTicksScaleX = 1.5;
        if (fTicksScaleY == -1) fTicksScaleY = 1.5;
 
        if (fLabelScaleX == -1) fLabelScaleX = 1.3;
        if (fLabelScaleY == -1) fLabelScaleY = 1.3;
 
        if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
            cout << "ticks scale X : " << fTicksScaleX << endl;
            cout << "ticks scale Y : " << fTicksScaleY << endl;
            cout << "label scale X : " << fLabelScaleX << endl;
            cout << "label scale Y : " << fLabelScaleY << endl;
            cout << "label offset X : " << fLabelOffsetX << endl;
            cout << "label offset Y : " << fLabelOffsetY << endl;
 
            if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) GetChar();
        }
    }
 
    TiXmlElement* legendDefinition = GetElement("legendPosition");
    if (legendDefinition != nullptr) {
        if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
            cout << legendDefinition << endl;
            cout << "Reading legend definition : " << endl;
            cout << "---------------------------" << endl;
        }
 
        fLegendX1 = StringToDouble(GetFieldValue("x1", legendDefinition));
        fLegendY1 = StringToDouble(GetFieldValue("y1", legendDefinition));
 
        fLegendX2 = StringToDouble(GetFieldValue("x2", legendDefinition));
        fLegendY2 = StringToDouble(GetFieldValue("y2", legendDefinition));
 
        if (fLegendX1 == -1) fLegendX1 = 0.7;
        if (fLegendY1 == -1) fLegendY1 = 0.75;
 
        if (fLegendX2 == -1) fLegendX2 = 0.88;
        if (fLegendY2 == -1) fLegendY2 = 0.88;
 
        if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
            cout << "x1 : " << fLegendX1 << " y1 : " << fLegendY1 << endl;
            cout << "x2 : " << fLegendX2 << " y2 : " << fLegendY2 << endl;
 
            if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Extreme) GetChar();
        }
 
        fLegendOption = GetFieldValue("option", legendDefinition);
        if (fLegendOption == "Not defined") fLegendOption = "lp";
    }
 
    TiXmlElement* canvasDefinition = GetElement("canvas");
    if (canvasDefinition != nullptr) {
        fCanvasSize = StringTo2DVector(GetFieldValue("size", canvasDefinition));
        fCanvasDivisions = StringTo2DVector(GetFieldValue("divide", canvasDefinition));
        fCanvasSave = GetFieldValue("save", canvasDefinition);
        if (fCanvasSave == "Not defined") {
            fCanvasSave = GetParameter("pdfFilename", REST_TMP_PATH + "restplot.pdf");
        }
    }
 
    RESTDebug << "TRestMetadataPlot: Reading plot sections" << RESTendl;
    Int_t maxPlots = (Int_t)fCanvasDivisions.X() * (Int_t)fCanvasDivisions.Y();
    TiXmlElement* plotele = fElement->FirstChildElement("plot");
    while (plotele != nullptr) {
        string active = GetParameter("value", plotele, "ON");
        if (ToUpper(active) == "ON") {
            int N = fPlots.size();
            if (N >= maxPlots) {
                RESTError << "Your canvas divisions (" << fCanvasDivisions.X() << " , "
                          << fCanvasDivisions.Y() << ") are not enough to show " << N + 1 << " plots"
                          << RESTendl;
                exit(1);
            }
 
            Plot_Info_Set plot;
            plot.name = RemoveWhiteSpaces(GetParameter("name", plotele, "plot_" + ToString(N)));
            plot.title = GetParameter("title", plotele, "");
            plot.xVariable = RemoveWhiteSpaces(GetParameter("xVariable", plotele, "timestamp"));
            plot.logY = StringToBool(GetParameter("logscale", plotele, "false"));
            plot.logY = plot.logY ? plot.logY : StringToBool(GetParameter("logY", plotele, "false"));
            plot.logX = StringToBool(GetParameter("logX", plotele, "false"));
            plot.labelX = GetParameter("xlabel", plotele, "");
            plot.labelY = GetParameter("ylabel", plotele, "");
            plot.legendOn = StringToBool(GetParameter("legend", plotele, "OFF"));
            plot.timeDisplay = StringToBool(GetParameter("timeDisplay", plotele, "OFF"));
            plot.save = RemoveWhiteSpaces(GetParameter("save", plotele, ""));
 
            plot.yRange = StringTo2DVector(GetParameter("yRange", plotele, "(-1,-1)"));
            plot.xRange = StringTo2DVector(GetParameter("xRange", plotele, "(-1,-1)"));
 
            RESTDebug << " Plot parameters read from <plot section " << RESTendl;
            RESTDebug << " --------------------------------------- " << RESTendl;
            RESTDebug << "- name: " << plot.name << RESTendl;
            RESTDebug << "- title: " << plot.title << RESTendl;
            RESTDebug << "- xVariable: " << plot.xVariable << RESTendl;
            RESTDebug << "- logX: " << plot.logX << RESTendl;
            RESTDebug << "- logY: " << plot.logY << RESTendl;
            RESTDebug << "- X-label : " << plot.labelX << RESTendl;
            RESTDebug << "- Y-label : " << plot.labelY << RESTendl;
            RESTDebug << "- legendOn: " << plot.legendOn << RESTendl;
            RESTDebug << "- timeDisplay: " << plot.timeDisplay << RESTendl;
            RESTDebug << "- save : " << plot.save << RESTendl;
 
            TiXmlElement* graphele = plotele->FirstChildElement("graph");
            if (graphele == nullptr) {
                // in case for single-graph plot, variables might be added directly inside the <plot section
                graphele = plotele;
            }
 
            while (graphele != nullptr) {
                Graph_Info_Set graph = SetupGraphFromConfigFile(graphele, plot);
 
                RESTDebug << "Graph name : " << graph.name << RESTendl;
                RESTDebug << "Graph variable : " << graph.yVariable << RESTendl;
 
                plot.graphs.push_back(graph);
 
                graphele = graphele->NextSiblingElement("graph");
            }
 
            fPlots.push_back(plot);
            plotele = plotele->NextSiblingElement("plot");
        }
    }
 
    RESTDebug << "TRestMetadataPlot: Reading panel sections" << RESTendl;
    maxPlots -= fPlots.size();  // remaining spaces on canvas
    TiXmlElement* panelele = fElement->FirstChildElement("panel");
    while (panelele != nullptr) {
        string active = GetParameter("value", panelele, "ON");
        if (ToUpper(active) == "ON") {
            int N = fPanels.size();
            if (N >= maxPlots) {
                RESTError << "Your canvas divisions (" << fCanvasDivisions.X() << " , "
                          << fCanvasDivisions.Y() << ") are not enough to show " << fPlots.size()
                          << " plots, and " << N + 1 << " info panels" << RESTendl;
                exit(1);
            }
 
            Panel_Info panel;
            panel.font_size = StringToDouble(GetParameter("font_size", panelele, "0.1"));
 
            TiXmlElement* labelele = panelele->FirstChildElement("label");
            while (labelele != nullptr) {
                panel.label.push_back(GetParameter("value", labelele, "Error. Label value not defined"));
                panel.posX.push_back(StringToDouble(GetParameter("x", labelele, "0.1")));
                panel.posY.push_back(StringToDouble(GetParameter("y", labelele, "0.1")));
 
                labelele = labelele->NextSiblingElement("label");
            }
 
            fPanels.push_back(panel);
            panelele = panelele->NextSiblingElement("panel");
        }
    }
 
    for (unsigned int n = 0; n < fPanels.size(); n++) {
        RESTExtreme << "Panel " << n << " with font size : " << fPanels[n].font_size << RESTendl;
        for (unsigned int m = 0; m < fPanels[n].posX.size(); m++) {
            RESTExtreme << "Label : " << fPanels[n].label[m] << RESTendl;
            RESTExtreme << "Pos X : " << fPanels[n].posX[m] << RESTendl;
            RESTExtreme << "Pos Y : " << fPanels[n].posY[m] << RESTendl;
        }
    }
}
 
TRestMetadataPlot::Graph_Info_Set TRestMetadataPlot::SetupGraphFromConfigFile(TiXmlElement* graphele,
                                                                              Plot_Info_Set plot) {
    Graph_Info_Set graph;
    graph.name = RemoveWhiteSpaces(GetParameter("name", graphele, plot.name));
    graph.title = GetParameter("title", graphele, plot.title);
    graph.yVariable = RemoveWhiteSpaces(GetParameter("yVariable", graphele, ""));
    graph.drawOption = RemoveWhiteSpaces(GetParameter("option", graphele, ""));
    graph.metadataRule = RemoveWhiteSpaces(GetParameter("metadataRule", graphele, ""));
 
    for (unsigned int n = 0; n < fPlotNamesCheck.size(); n++)
        if (graph.name == fPlotNamesCheck[n]) {
            RESTError
                << "Repeated plot/graph names were found! Please, use different names for different plots!"
                << RESTendl;
            RESTError << "<plot/graph name=\"" << graph.name << "\" already defined!" << RESTendl;
            exit(1);
        }
 
    if (graph.yVariable == "") {
        RESTError << "Problem reading yVariable from graph with name : " << graph.name << RESTendl;
        exit(2);
    }
 
    fPlotNamesCheck.push_back(graph.name);
 
    // 5. read draw style(line color, width, marker style, size, etc.)
    graph.markerStyle = StringToInteger(GetParameter("markerStyle", graphele));
    graph.markerSize = StringToInteger(GetParameter("markerSize", graphele));
    graph.markerColor = StringToInteger(GetParameter("markerColor", graphele));
    graph.lineColor = StringToInteger(GetParameter("lineColor", graphele));
    graph.lineWidth = StringToInteger(GetParameter("lineWidth", graphele));
    graph.lineStyle = StringToInteger(GetParameter("lineStyle", graphele));
 
    return graph;
}
 
void TRestMetadataPlot::AddFile(TString fileName) {
    RESTDebug << "TRestMetadataPlot::AddFile. Adding file. " << RESTendl;
    RESTDebug << "File name: " << fileName << RESTendl;
 
    // TODO: How do we check here that the run is valid?
    fRunInputFileName.push_back((string)fileName);
    fNFiles++;
}
 
void TRestMetadataPlot::AddFileFromExternalRun() {
    if (fRun != nullptr) {
        if (fHostmgr->GetProcessRunner() != nullptr && fRun->GetOutputFileName() != "") {
            // if we have a TRestProcessRunner before head, we use its output file
            AddFile(fRun->GetOutputFileName());
            return;
        } else if (fRun->GetInputFileNames().size() != 0) {
            // if we have only TRestRun, we ask for its input file list
            auto names = fRun->GetInputFileNames();
            for (unsigned int i = 0; i < names.size(); i++) {
                this->AddFile(names[i]);
            }
            return;
        }
    }
}
 
void TRestMetadataPlot::AddFileFromEnv() {
    string filepattern = GetParameter("inputFileName", "");
    auto files = TRestTools::GetFilesMatchingPattern(filepattern);
 
    for (unsigned int n = 0; n < files.size(); n++) {
        RESTEssential << "Adding file : " << files[n] << RESTendl;
        AddFile(files[n]);
    }
}
 
Int_t TRestMetadataPlot::GetPlotIndex(TString plotName) {
    for (unsigned int n = 0; n < fPlots.size(); n++)
        if (fPlots[n].name == plotName) return n;
 
    RESTWarning << "TRestMetadataPlot::GetPlotIndex. Plot name " << plotName << " not found" << RESTendl;
    return -1;
}
 
void TRestMetadataPlot::GenerateCanvas() {
    RESTInfo << "--------------------------" << RESTendl;
    RESTInfo << "Starting to GenerateCanvas" << RESTendl;
    RESTInfo << "--------------------------" << RESTendl;
    // Add files, first use <addFile section definition
    TiXmlElement* ele = fElement->FirstChildElement("addFile");
    while (ele != nullptr) {
        TString inputfile = GetParameter("name", ele);
        this->AddFile(inputfile);
        ele = ele->NextSiblingElement("addFile");
    }
    // try to add files from external TRestRun handler
    if (fNFiles == 0) AddFileFromExternalRun();
    // try to add files from env "inputFile", which is set by --i argument
    if (fNFiles == 0) AddFileFromEnv();
 
    if (fNFiles == 0) {
        RESTError << "TRestMetadataPlot: No input files are added!" << RESTendl;
        exit(1);
    }
 
    // initialize output root file if we have TRestRun running
    TFile* fOutputRootFile = nullptr;
    if (fRun != nullptr) {
        fOutputRootFile = fRun->GetOutputFile();
        if (fOutputRootFile == nullptr) {
            fRun->SetHistoricMetadataSaving(false);
            fOutputRootFile = fRun->FormOutputFile();
        }
    }
 
    // Initializing canvas window
    if (fCombinedCanvas != nullptr) {
        delete fCombinedCanvas;
        fCombinedCanvas = nullptr;
    }
    fCombinedCanvas = new TCanvas("combined", "combined", 0, 0, fCanvasSize.X(), fCanvasSize.Y());
    fCombinedCanvas->Divide((Int_t)fCanvasDivisions.X(), (Int_t)fCanvasDivisions.Y());
 
    // Setting up TStyle
    TStyle* st = new TStyle();
    st->SetPalette(1);
 
    if (fPanels.size() > 0) {
        Double_t startTime = 0;
        Double_t endTime = 0;
        Double_t runLength = 0;
        Int_t totalEntries = 0;
        for (unsigned int n = 0; n < fRunInputFileName.size(); n++) {
            TRestRun* run = new TRestRun();
            run->SetHistoricMetadataSaving(false);
            run->OpenInputFile(fRunInputFileName[n]);
 
            RESTInfo << "Loading timestamps from file : " << fRunInputFileName[n] << RESTendl;
 
            Double_t endTimeStamp = run->GetEndTimestamp();
            Double_t startTimeStamp = run->GetStartTimestamp();
 
            // We get the lowest/highest run time stamps.
            if (!startTime || startTime > endTimeStamp) startTime = endTimeStamp;
            if (!startTime || startTime > startTimeStamp) startTime = startTimeStamp;
 
            if (!endTime || endTime < startTimeStamp) endTime = startTimeStamp;
            if (!endTime || endTime < endTimeStamp) endTime = endTimeStamp;
 
            if (endTimeStamp - startTimeStamp > 0) {
                runLength += endTimeStamp - startTimeStamp;
                totalEntries += run->GetEntries();
            }
            delete run;
        }
 
        Double_t meanRate = totalEntries / runLength;
 
        runLength /= 3600.;
 
        TRestRun* panelRun = new TRestRun();
        panelRun->SetHistoricMetadataSaving(false);
        panelRun->OpenInputFile(fRunInputFileName[0]);
        for (unsigned int n = 0; n < fPanels.size(); n++) {
            fCombinedCanvas->cd(n + 1);
            for (unsigned int m = 0; m < fPanels[n].posX.size(); m++) {
                string label = fPanels[n].label[m];
 
                size_t pos = 0;
                label = Replace(label, "<<startTime>>", ToDateTimeString(startTime), pos);
                pos = 0;
                label = Replace(label, "<<endTime>>", ToDateTimeString(endTime), pos);
                pos = 0;
                label = Replace(label, "<<entries>>", Form("%d", totalEntries), pos);
                pos = 0;
                label = Replace(label, "<<runLength>>", Form("%5.2lf", runLength), pos);
                pos = 0;
                label = Replace(label, "<<meanRate>>", Form("%5.2lf", meanRate), pos);
 
                label = panelRun->ReplaceMetadataMembers(label);
 
                TLatex* texxt = new TLatex(fPanels[n].posX[m], fPanels[n].posY[m], label.c_str());
                texxt->SetTextColor(1);
                texxt->SetTextSize(fPanels[n].font_size);
                texxt->Draw("same");
            }
        }
        delete panelRun;
    }
 
    // start drawing plots
    vector<TGraph*> graphCollectionAll;
    for (unsigned int n = 0; n < fPlots.size(); n++) {
        Plot_Info_Set plot = fPlots[n];
 
        TPad* targetPad = (TPad*)fCombinedCanvas->cd(n + 1 + fPanels.size());
        targetPad->SetLogx(plot.logX);
        targetPad->SetLogy(plot.logY);
        targetPad->SetLeftMargin(0.18);
        targetPad->SetRightMargin(0.1);
        targetPad->SetBottomMargin(0.15);
        targetPad->SetTopMargin(0.07);
 
        // If the first graph does not contain the axis option we must add it manually
        if (plot.graphs[0].drawOption.find("A") == string::npos)
            plot.graphs[0].drawOption = plot.graphs[0].drawOption + "A";
 
        // draw to a new graph
        vector<TGraph*> graphCollectionPlot;
        for (unsigned int i = 0; i < plot.graphs.size(); i++) {
            Graph_Info_Set graph = plot.graphs[i];
 
            TString graphName = graph.name;
            TString graphVariable = graph.yVariable;
 
            if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
                cout << endl;
                cout << "--------------------------------------" << endl;
                cout << "Graph name : " << graphName << endl;
                cout << "Graph variable : " << graphVariable << endl;
                cout << "++++++++++++++++++++++++++++++++++++++" << endl;
            }
 
            // Perhaps an RML option?
            Bool_t skipZeroData = true;
 
            std::vector<Double_t> xData;
            std::vector<Double_t> yData;
            std::map<Double_t, Double_t> dataMap;
            std::map<Double_t, Int_t> dataMapN;
 
            // TODO Here we open the file for each graph construction. This might slowdown these
            // drawing routines when we load thousands of files and we have many graphs. It could be
            // optimized for the case of many graphs by preloading TGraph data into a dedicated
            // structure at Graph_Info_Set
 
            // We build the corresponding TGraph extracting the points from each file
            for (unsigned int j = 0; j < fRunInputFileName.size(); j++) {
                RESTInfo << "Loading file : " << fRunInputFileName[j] << RESTendl;
 
                TRestRun* run = new TRestRun();
                run->SetHistoricMetadataSaving(false);
                run->OpenInputFile(fRunInputFileName[j]);
 
                // Checking if the run satisfies the metadata rule defined (if any)
                // If it doesnt we skip this run
                if (!run->EvaluateMetadataMember(graph.metadataRule)) {
                    delete run;
                    continue;
                }
 
                // We reject runs with unexpected zero y-data
                Double_t yVal = StringToDouble(run->GetMetadataMember(graph.yVariable));
                if (yVal == 0 && skipZeroData) {
                    RESTWarning
                        << "Ignoring zero data. This message could be disabled with variable skipZeroData"
                        << RESTendl;
                    delete run;
                    continue;
                }
 
                // Populating map/vector data
                if (plot.xVariable == "timestamp") {
                    Double_t startTimeStamp = run->GetStartTimestamp();
                    Double_t endTimeStamp = run->GetEndTimestamp();
 
                    Double_t meanTime = (endTimeStamp + startTimeStamp) / 2.;
                    xData.push_back(meanTime);
                    yData.push_back(yVal);
                } else {
                    Double_t xVal = StringToDouble(run->GetMetadataMember(plot.xVariable));
                    if (dataMap.find(xVal) == dataMap.end()) {
                        dataMap[xVal] = yVal;
                        dataMapN[xVal] = 1;
                    } else {
                        dataMap[xVal] += yVal;
                        dataMapN[xVal]++;
                    }
                }
                delete run;
            }
 
            // dataMap will contain data only in case is not "timestamp"
            for (auto const& x : dataMap) {
                xData.push_back(x.first);
                yData.push_back(dataMap[x.first] / dataMapN[x.first]);
            }
 
            // In case of problems we output this
            if (xData.size() == 0) {
                RESTWarning << "TRestMetadataPlot: no input file matches condition for graph: " << graph.name
                            << RESTendl;
                RESTWarning << "This graph is empty and it will not be plotted" << RESTendl;
                plot.graphs.erase(plot.graphs.begin() + i);
                i--;
            }
 
            if (xData.size() == 1) {
                RESTWarning << "TRestMetadataPlot: Only 1-point for graph: " << graph.name << RESTendl;
                RESTWarning << "X: " << xData[0] << " Y: " << yData[0] << RESTendl;
            }
 
            for (unsigned int nn = 0; nn < xData.size(); nn++)
                RESTDebug << "X: " << xData[nn] << " Y: " << yData[nn] << RESTendl;
 
            // adjust the graph
            TGraph* gr_temp = new TGraph(xData.size(), &xData[0], &yData[0]);
            gr_temp->SetName(graph.name.c_str());
            gr_temp->SetTitle(plot.title.c_str());
 
            gr_temp->GetXaxis()->SetTitle(plot.labelX.c_str());
            gr_temp->GetYaxis()->SetTitle(plot.labelY.c_str());
            // Removed to avoid Gitlab SJTU pipeline failing.
            // Probably due to ROOT version?
            // gr_temp->GetXaxis()->SetMaxDigits(4);
 
            gr_temp->GetXaxis()->SetLabelSize(fTicksScaleX * gr_temp->GetXaxis()->GetLabelSize());
            gr_temp->GetYaxis()->SetLabelSize(fTicksScaleY * gr_temp->GetYaxis()->GetLabelSize());
            gr_temp->GetXaxis()->SetTitleSize(fLabelScaleX * gr_temp->GetXaxis()->GetTitleSize());
            gr_temp->GetYaxis()->SetTitleSize(fLabelScaleY * gr_temp->GetYaxis()->GetTitleSize());
            gr_temp->GetXaxis()->SetTitleOffset(fLabelOffsetX * gr_temp->GetXaxis()->GetTitleOffset());
            gr_temp->GetYaxis()->SetTitleOffset(fLabelOffsetY * gr_temp->GetYaxis()->GetTitleOffset());
            // gr_temp->GetXaxis()->SetNdivisions(-5);
 
            gr_temp->SetLineColor(graph.lineColor);
            gr_temp->SetLineWidth(graph.lineWidth);
            gr_temp->SetLineStyle(graph.lineStyle);
            gr_temp->SetFillColor(graph.fillColor);
            gr_temp->SetFillStyle(graph.fillStyle);
 
            gr_temp->SetDrawOption(graph.drawOption.c_str());
            gr_temp->SetMarkerStyle(graph.markerStyle);
            gr_temp->SetMarkerSize(graph.markerSize);
            gr_temp->SetMarkerColor(graph.markerColor);
 
            if (plot.timeDisplay) gr_temp->GetXaxis()->SetTimeDisplay(1);
 
            graphCollectionPlot.push_back(gr_temp);
            graphCollectionAll.push_back(gr_temp);
        }
 
        if (graphCollectionPlot.size() == 0) {
            RESTWarning << "TRestMetadataPlot: pad empty for the plot: " << plot.name << RESTendl;
            continue;
        }
 
        // draw to the pad
        Double_t minValue_Pad = 0;
        Double_t maxValue_Pad = 0;
        for (unsigned int i = 0; i < graphCollectionPlot.size(); i++) {
            TGraph* gr = graphCollectionPlot[i];
            // need to draw the max graph first, in order to prevent data hidden problem
            Double_t maxValue = TMath::MaxElement(gr->GetN(), gr->GetY());
            Double_t minValue = TMath::MinElement(gr->GetN(), gr->GetY());
            if (i == 0) {
                maxValue_Pad = maxValue;
                minValue_Pad = minValue;
            } else {
                if (maxValue > maxValue_Pad) maxValue_Pad = maxValue;
                if (minValue < minValue_Pad) minValue_Pad = minValue;
            }
        }
 
        // We add some margin to the automatically identified ranges
        if (minValue_Pad > 0)
            minValue_Pad *= 0.8;
        else
            minValue_Pad *= 1.2;
 
        if (maxValue_Pad > 0)
            maxValue_Pad *= 1.2;
        else
            maxValue_Pad *= 0.8;
 
        // If ranges have beend defined we override the automatic ranges
        if (!(plot.yRange.X() == -1 && plot.yRange.Y() == -1)) {
            minValue_Pad = plot.yRange.X();
            maxValue_Pad = plot.yRange.Y();
        }
 
        for (unsigned int i = 0; i < graphCollectionPlot.size(); i++) {
            // draw the remaining histo
            if (!(plot.xRange.X() == -1 && plot.xRange.Y() == -1))
                graphCollectionPlot[i]->GetXaxis()->SetLimits(plot.xRange.X(), plot.xRange.Y());
            graphCollectionPlot[i]->GetHistogram()->SetMinimum(minValue_Pad);
            graphCollectionPlot[i]->GetHistogram()->SetMaximum(maxValue_Pad);
 
            graphCollectionPlot[i]->Draw(plot.graphs[i].drawOption.c_str());
        }
 
        // save histogram to root file
        for (unsigned int i = 0; i < graphCollectionPlot.size(); i++) {
            if (fRun != nullptr) {
                fOutputRootFile->cd();
                graphCollectionPlot[i]->Write();
            }
        }
 
        // draw legend
        if (plot.legendOn) {
            TLegend* legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
            for (unsigned int i = 0; i < graphCollectionPlot.size(); i++)
                legend->AddEntry(graphCollectionPlot[i], (TString)plot.graphs[i].title, fLegendOption);
            legend->Draw("same");
        }
 
        // save pad
        targetPad->Update();
        if (plot.save != "") {
            SavePlotToPDF(plot.save, n + 1);
        }
 
        fCombinedCanvas->Update();
    }
 
    // Preview plot. User can make some changes before saving
    if (StringToBool(GetParameter("previewPlot", "TRUE"))) {
        GetChar();
    }
 
    // Save canvas to a PDF file
    TRestRun* run = new TRestRun();
    run->SetHistoricMetadataSaving(false);
    run->OpenInputFile(fRunInputFileName[0]);
 
    fCanvasSave = run->FormFormat(fCanvasSave);
    delete run;
    if (fCanvasSave != "") fCombinedCanvas->Print(fCanvasSave);
 
    // If the extension of the canvas save file is ROOT we store also the histograms
    if (TRestTools::isRootFile((string)fCanvasSave)) {
        TFile* f = new TFile(fCanvasSave, "UPDATE");
        f->cd();
        for (unsigned int n = 0; n < graphCollectionAll.size(); n++) graphCollectionAll[n]->Write();
        f->Close();
    }
 
    // Save this class to the root file
    if (fRun != nullptr && fOutputRootFile != nullptr) {
        fOutputRootFile->cd();
        this->Write();
        fRun->CloseFile();
    }
}
 
void TRestMetadataPlot::SaveCanvasToPDF(TString fileName) { fCombinedCanvas->Print(fileName); }
 
void TRestMetadataPlot::SavePlotToPDF(TString fileName, Int_t n) {
    // gErrorIgnoreLevel = 10;
    fCombinedCanvas->SetBatch(kTRUE);
 
    if (n == 0) {
        fCombinedCanvas->Print(fileName);
        fCombinedCanvas->SetBatch(kFALSE);
        return;
    }
 
    TPad* pad = (TPad*)fCombinedCanvas->GetPad(n);
 
    TCanvas* c = new TCanvas(fPlots[n - 1].name.c_str(), fPlots[n - 1].name.c_str(), 800, 600);
    pad->DrawClone();
 
    c->Print(fileName);
 
    delete c;
 
    fCombinedCanvas->SetBatch(kFALSE);
 
    return;
}
 
void TRestMetadataPlot::SaveGraphToPDF(TString fileName, Int_t nPlot, Int_t nGraph) {
    string name = fPlots[nPlot].graphs[nGraph].name;
    TGraph* graph = (TGraph*)gPad->GetPrimitive(name.c_str());
 
    TCanvas* c = new TCanvas(name.c_str(), name.c_str(), 800, 600);
 
    graph->Draw();
 
    c->Print(fileName);
 
    delete c;
    return;
}