TRestAnalysisPlot.cxx

 
 
#include "TRestAnalysisPlot.h"
 
#include <TLegend.h>
#include <TStyle.h>
 
#include <ctime>
 
#include "TRestManager.h"
#include "TRestTools.h"
 
using namespace std;
 
ClassImp(TRestAnalysisPlot);
 
TRestAnalysisPlot::TRestAnalysisPlot() { Initialize(); }
 
TRestAnalysisPlot::TRestAnalysisPlot(const char* configFilename, const char* name)
    : TRestMetadata(configFilename) {
    Initialize();
 
    LoadConfigFromFile(fConfigFileName, name);
}
 
void TRestAnalysisPlot::Initialize() {
    SetSectionName(this->ClassName());
 
    fRun = nullptr;
    fNFiles = 0;
    fCombinedCanvas = nullptr;
    fPlotNamesCheck.clear();
    fDrawNEntries = TTree::kMaxEntries;
    fDrawFirstEntry = 0;
}
 
TRestAnalysisPlot::~TRestAnalysisPlot() { delete fRun; }
 
void TRestAnalysisPlot::InitFromConfigFile() {
    if (fHostmgr->GetRunInfo() != nullptr) {
        fRun = fHostmgr->GetRunInfo();
    }
    if (fRun == nullptr) {
        fRun = new TRestRun();
        fRun->SetHistoricMetadataSaving(false);
        string defaultFileName = REST_TMP_PATH + "restplot_" + REST_USER + ".root";
        string outputname = GetParameter("outputFile", defaultFileName);
        if (outputname != "null" && outputname != "/dev/null") {
            fRun->SetOutputFileName(outputname);
            fRun->FormOutputFile();
        }
    }
 
    TiXmlElement* ele = GetElement("addFile");
    while (ele != nullptr) {
        std::string inputfile = GetParameter("name", ele);
        if (inputfile.find("http") == 0)
            this->AddFile(inputfile);
        else {
            std::vector<std::string> infiles = TRestTools::GetFilesMatchingPattern(inputfile);
            for (const auto& f : infiles) this->AddFile(f);
        }
        ele = GetNextElement(ele);
    }
    // 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) {
        RESTWarning << "TRestAnalysisPlot: No input files are added!" << RESTendl;
        // exit(1);
    }
 
    RESTDebug << "TRestAnalysisPlot: 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();
        }
    }
 
    TiXmlElement* canvasdef = fElement->FirstChildElement("canvas");
    if (canvasdef == nullptr) {
        canvasdef = fElement;
    }
 
    fCanvasSize = StringTo2DVector(GetParameter("size", canvasdef, "(800,600)"));
    fCanvasDivisions = StringTo2DVector(GetParameter("divide", canvasdef, "(1,1)"));
    fCanvasDivisionMargins = StringTo2DVector(GetParameter("divideMargin", canvasdef, "(0.01, 0.01)"));
 
    string save = (string)GetParameter("save", canvasdef, "rest_AnalysisPlot.pdf");
    if (save.rfind("/", 0) == 0)
        fCanvasSave = (TString)save;
    else
        fCanvasSave = GetDataPath() + save;
 
    fPaletteStyle = StringToInteger(GetParameter("paletteStyle", canvasdef, "57"));
 
    RESTDebug << "TRestAnalysisPlot: Reading global cuts" << RESTendl;
    vector<string> globalCuts;
    TiXmlElement* gCutele = GetElement("globalCut");
    while (gCutele != nullptr)  // general cuts
    {
        string cutActive = GetParameter("value", gCutele, "ON");
 
        if (ToUpper(cutActive) == "ON") {
            string obsName = GetParameter("variable", gCutele, "");
            if (obsName == "") {
                obsName = GetParameter("name", gCutele, "");
                if (obsName != "") {
                    RESTWarning << "<globalCut name=\"var\" is now obsolete." << RESTendl;
                    RESTWarning << "Please, replace by : <globalCut variable=\"var\" " << RESTendl;
                    cout << endl;
                }
            }
 
            if (obsName == "") continue;
 
            string cutCondition = GetParameter("condition", gCutele);
            string cutString = obsName + cutCondition;
 
            globalCuts.push_back(cutString);
        }
 
        gCutele = GetNextElement(gCutele);
    }
 
    RESTDebug << "TRestAnalysisPlot: Reading global cut strings" << RESTendl;
    TiXmlElement* gCutStrele = GetElement("globalCutString");
    while (gCutStrele != nullptr)  // general cuts
    {
        string cutActive = GetParameter("value", gCutStrele, "ON");
 
        if (ToUpper(cutActive) == "ON") {
            string cutString = GetParameter("string", gCutStrele, "");
            cutString = "(" + cutString + ")";
            if (cutString == "") continue;
 
            globalCuts.push_back(cutString);
        }
 
        gCutStrele = GetNextElement(gCutStrele);
    }
 
    RESTDebug << "TRestAnalysisPlot: Reading plot sections" << RESTendl;
    Int_t maxPlots = (Int_t)fCanvasDivisions.X() * (Int_t)fCanvasDivisions.Y();
    TiXmlElement* plotele = GetElement("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);
            }
            PlotInfoSet plot;
            plot.name = RemoveWhiteSpaces(GetParameter("name", plotele, "plot_" + ToString(N)));
            plot.title = GetParameter("title", plotele, plot.name);
            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.logZ = StringToBool(GetParameter("logZ", plotele, "false"));
            plot.gridY = StringToBool(GetParameter("gridY", plotele, "false"));
            plot.gridX = StringToBool(GetParameter("gridX", plotele, "false"));
            plot.normalize = StringToDouble(GetParameter("norm", plotele, ""));
            plot.scale = GetParameter("scale", plotele, "");
            plot.labelX = GetParameter("xlabel", plotele, "");
            plot.labelY = GetParameter("ylabel", plotele, "");
            plot.ticksX = StringToInteger(GetParameter("xticks", plotele, "510"));
            plot.ticksY = StringToInteger(GetParameter("yticks", plotele, "510"));
            plot.marginBottom = StringToDouble(GetParameter("marginBottom", plotele, "0.15"));
            plot.marginTop = StringToDouble(GetParameter("marginTop", plotele, "0.07"));
            plot.marginLeft = StringToDouble(GetParameter("marginLeft", plotele, "0.25"));
            plot.marginRight = StringToDouble(GetParameter("marginRight", plotele, "0.1"));
            plot.legendOn = StringToBool(GetParameter("legend", plotele, "OFF"));
            plot.staticsOn = StringToBool(GetParameter("stats", plotele, "OFF"));
            plot.annotationOn = StringToBool(GetParameter("annotation", plotele, "OFF"));
            plot.xOffset = StringToDouble(GetParameter("xOffset", plotele, "0"));
            plot.yOffset = StringToDouble(GetParameter("yOffset", plotele, "0"));
            plot.timeDisplay = StringToBool(GetParameter("timeDisplay", plotele, "OFF"));
            plot.save = RemoveWhiteSpaces(GetParameter("save", plotele, ""));
 
            TiXmlElement* histele = GetElement("histo", plotele);
            if (histele == nullptr) {
                // in case for single-hist plot, variables are added directly inside the <plot section
                histele = plotele;
            }
            while (histele != nullptr) {
                HistoInfoSet hist = SetupHistogramFromConfigFile(histele, plot);
                // add global cut
                for (unsigned int i = 0; i < globalCuts.size(); i++) {
                    if (i > 0 || hist.cutString != "") hist.cutString += " && ";
                    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug)
                        cout << "Adding global cut : " << globalCuts[i] << endl;
                    hist.cutString += globalCuts[i];
                }
                hist.weight = GetParameter("weight", histele, "");
 
                if (hist.plotString == "") {
                    RESTWarning << "No variables or histograms defined in the plot, skipping!" << RESTendl;
                } else {
                    plot.histos.push_back(hist);
                }
 
                if (histele == plotele) {
                    break;
                }
                histele = GetNextElement(histele);
            }
 
            fPlots.push_back(plot);
            plotele = GetNextElement(plotele);
        }
    }
 
    RESTDebug << "TRestAnalysisPlot: Reading panel sections" << RESTendl;
    maxPlots -= fPlots.size();  // remaining spaces on canvas
    TiXmlElement* panelele = GetElement("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);
            }
 
            PanelInfo panel;
            panel.font_size = StringToDouble(GetParameter("font_size", panelele, "0.1"));
            panel.precision = StringToInteger(GetParameter("precision", panelele, "2"));
 
            TiXmlElement* labelele = GetElement("label", panelele);
            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 = GetNextElement(labelele);
            }
 
            fPanels.push_back(panel);
            panelele = GetNextElement(panelele);
        }
    }
 
    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;
        }
    }
}
 
TRestAnalysisPlot::HistoInfoSet TRestAnalysisPlot::SetupHistogramFromConfigFile(TiXmlElement* histele,
                                                                                PlotInfoSet plot) {
    HistoInfoSet hist;
    hist.name = RemoveWhiteSpaces(GetParameter("name", histele, plot.name));
    hist.drawOption = GetParameter("option", histele, "colz");
 
    for (const auto& n : fPlotNamesCheck)
        if (hist.name == n) {
            RESTError
                << "Repeated plot/histo names were found! Please, use different names for different plots!"
                << RESTendl;
            RESTError << "<plot/histo name=\"" << hist.name << "\" already defined!" << RESTendl;
            exit(1);
        }
 
    fPlotNamesCheck.push_back(hist.name);
 
    // 1. construct plot variables for the hist
    // read variables
    vector<string> varNames;
    vector<TVector2> ranges;
    vector<Int_t> bins;
    TiXmlElement* varele = GetElement("variable", histele);
    while (varele != nullptr) {
        varNames.push_back(GetParameter("name", varele));
 
        string rangeStr = GetParameter("range", varele);
        rangeStr = Replace(rangeStr, "unixTime", std::to_string(std::time(nullptr)));
        rangeStr = Replace(rangeStr, "days", "24*3600");
        ranges.push_back(StringTo2DVector(rangeStr));
 
        bins.push_back(StringToInteger(GetParameter("nbins", varele)));
        varele = GetNextElement(varele);
    }
    if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
        for (unsigned int n = 0; n < bins.size(); n++) {
            cout << "Variable " << varNames[n] << endl;
            cout << "------------------------------------------" << endl;
            cout << "Plot range : ( " << ranges.back().X() << " , " << ranges.back().Y() << " ) " << endl;
            cout << "bins : " << bins.back() << endl;
            cout << endl;
        }
    }
 
    string pltString = "";
    for (int i = varNames.size() - 1; i >= 0; i--) {
        // The draw branches are in reversed ordered in TTree::Draw()
        pltString += varNames[i];
        if (i > 0) pltString += ":";
    }
    hist.plotString = pltString;
 
    // 2. construct plot name for the hist
    string rangestr = "";
    for (unsigned int i = 0; i < bins.size(); i++) {
        string binsStr = ToString(bins[i]);
        if (bins[i] == -1) binsStr = " ";
 
        string rXStr = ToString(ranges[i].X());
        if (ranges[i].X() == -1) {
            rXStr = " ";
            if (varNames[i] == "timeStamp" || plot.timeDisplay) rXStr = "MIN_TIME";
        }
 
        string rYStr = ToString(ranges[i].Y());
        if (ranges[i].Y() == -1) {
            rYStr = " ";
            if (varNames[i] == "timeStamp" || plot.timeDisplay) rYStr = "MAX_TIME";
        }
 
        if (i == 0) rangestr += "(";
        rangestr += binsStr + " , " + rXStr + " , " + rYStr;
        if (i < bins.size() - 1) rangestr += ",";
        if (i == bins.size() - 1) rangestr += ")";
    }
    hist.range = rangestr;
 
    // 3. read cuts
    string cutString = "";
 
    TiXmlElement* cutele = GetElement("cut", histele);
    while (cutele != nullptr) {
        string cutActive = GetParameter("value", cutele, "ON");
        if (ToUpper(cutActive) == "ON") {
            string cutVariable = GetParameter("variable", cutele);
            if (cutVariable == PARAMETER_NOT_FOUND_STR) {
                RESTError << "Variable was not found! There is a problem inside <cut definition. Check it."
                          << RESTendl;
                cout << "Contents of entire <histo definition : " << ElementToString(histele) << endl;
                cout << endl;
            }
 
            string cutCondition = GetParameter("condition", cutele);
            if (cutCondition == PARAMETER_NOT_FOUND_STR) {
                RESTError << "Condition was not found! There is a problem inside <cut definition. Check it."
                          << RESTendl;
                cout << "Contents of entire <histo definition : " << ElementToString(histele) << endl;
                cout << endl;
            }
 
            if (cutString.length() > 0) cutString += " && ";
            RESTDebug << "Adding local cut : " << cutVariable << cutCondition << RESTendl;
 
            cutCondition = RemoveWhiteSpaces(cutCondition);
            if (cutCondition.find("==") == 0) {
                string condValue = cutCondition.substr(2);
                if (!isANumber(condValue)) cutCondition = "==\"" + condValue + "\"";
            }
 
            cutString += cutVariable + cutCondition;
        }
        cutele = GetNextElement(cutele);
    }
 
    TiXmlElement* cutstrele = GetElement("cutString", histele);
    while (cutstrele != nullptr) {
        string cutActive = GetParameter("value", cutstrele, "ON");
        if (ToUpper(cutActive) == "ON") {
            string cutStr = GetParameter("string", cutstrele);
            if (cutStr == PARAMETER_NOT_FOUND_STR) {
                RESTError
                    << "Cut string was not found! There is a problem inside <cutString definition. Check it."
                    << RESTendl;
                cout << "Contents of entire <histo definition : " << ElementToString(histele) << endl;
                cout << endl;
            }
 
            if (cutString.length() > 0) cutString += " && ";
            RESTDebug << "Adding local cut : " << cutStr << RESTendl;
 
            cutString += "(" + cutStr + ")";
        }
        cutstrele = GetNextElement(cutstrele);
    }
    hist.cutString = cutString;
 
    // 4. read classify condition
    hist.classifyMap.clear();
    TiXmlElement* classifyele = GetElement("classify", histele);
    while (classifyele != nullptr) {
        string Active = GetParameter("value", classifyele, "ON");
        if (ToUpper(Active) == "ON") {
            TiXmlAttribute* attr = classifyele->FirstAttribute();
            while (attr != nullptr) {
                if (attr->Value() != nullptr && !string(attr->Value()).empty()) {
                    hist.classifyMap[attr->Name()] = attr->Value();
                }
                attr = attr->Next();
            }
        }
        classifyele = GetNextElement(classifyele);
    }
 
    // 5. read draw style(line color, width, fill style, etc.)
    hist.lineColor = GetColorIDFromString(GetParameter("lineColor", histele, "602"));
    hist.lineWidth = StringToInteger(GetParameter("lineWidth", histele, "1"));
    hist.lineStyle = GetLineStyleIDFromString(GetParameter("lineStyle", histele, "1"));
    hist.fillStyle = GetFillStyleIDFromString(GetParameter("fillStyle", histele, "1001"));
    hist.fillColor = GetColorIDFromString(GetParameter("fillColor", histele, "0"));
 
    return hist;
}
 
void TRestAnalysisPlot::AddFile(const TString& fileName) {
    RESTInfo << "TRestAnalysisPlot::AddFile. Adding file. " << RESTendl;
    RESTInfo << "File name: " << fileName << RESTendl;
    fRunInputFileName.emplace_back(fileName.Data());
    fNFiles++;
}
 
void TRestAnalysisPlot::SetFile(const TString& fileName) {
    fRunInputFileName.clear();
    fRunInputFileName = Vector_cast<string, TString>(TRestTools::GetFilesMatchingPattern((string)fileName));
    fNFiles = fRunInputFileName.size();
}
 
// we can add input file from process's output file
void TRestAnalysisPlot::AddFileFromExternalRun() {
    if (fRun != nullptr && fNFiles == 0) {
        if (fHostmgr->GetProcessRunner() != nullptr && fRun->GetOutputFileName() != "") {
            // if we have a TRestProcessRunner before head, we use its output file
            AddFile(fRun->GetOutputFileName());
            return;
        }
    }
}
 
// we can add input file from parameter "inputFile"
void TRestAnalysisPlot::AddFileFromEnv() {
    if (fNFiles == 0) {
        string filepattern = GetParameter("inputFileName", "");
        auto files = TRestTools::GetFilesMatchingPattern(filepattern);
 
        for (const auto& file : files) {
            RESTEssential << "Adding file : " << file << RESTendl;
            AddFile(file);
        }
    }
}
 
Int_t TRestAnalysisPlot::GetPlotIndex(const TString& plotName) {
    for (unsigned int n = 0; n < fPlots.size(); n++)
        if (fPlots[n].name == plotName) return n;
 
    RESTWarning << "TRestAnalysisPlot::GetPlotIndex. Plot name " << plotName << " not found" << RESTendl;
    return -1;
}
 
TRestAnalysisTree* TRestAnalysisPlot::GetTree(const TString& fileName) {
    if (fRun->GetInputFile() != nullptr && fRun->GetInputFile()->GetName() == fileName) {
        // this means the file is already opened by TRestRun
        return fRun->GetAnalysisTree();
    }
    if (fileName == fRun->GetOutputFileName() && fRun->GetOutputFile() != nullptr) {
        // this means the process is finished and the chain's output file is transferred to TRestRun
        return (TRestAnalysisTree*)fRun->GetOutputFile()->Get("AnalysisTree");
    }
    if (fHostmgr != nullptr && fHostmgr->GetProcessRunner() != nullptr &&
        fHostmgr->GetProcessRunner()->GetStatus() != kFinished) {
        // this means the process is still ongoing
        return fHostmgr->GetProcessRunner()->GetOutputAnalysisTree();
    }
    fRun->OpenInputFile(fileName);
    return fRun->GetAnalysisTree();
}
 
TRestRun* TRestAnalysisPlot::GetRunInfo(const TString& fileName) {
    // in any case we directly return fRun. No need to reopen the given file
    if (fRun->GetInputFile() != nullptr && fRun->GetInputFile()->GetName() == fileName) {
        return fRun;
    }
    if (fileName == fRun->GetOutputFileName() && fRun->GetOutputFile() != nullptr) {
        return fRun;
    }
    if (fHostmgr != nullptr && fHostmgr->GetProcessRunner() != nullptr &&
        fHostmgr->GetProcessRunner()->GetStatus() != kFinished) {
        return fRun;
    }
    fRun->OpenInputFile(fileName);
    return fRun;
}
 
bool TRestAnalysisPlot::IsDynamicRange(const TString& rangeString) {
    return (string(rangeString)).find(",  ") != string::npos;
}
 
Int_t TRestAnalysisPlot::GetColorIDFromString(const string& in) {
    if (in.find_first_not_of("0123456789") == string::npos) {
        return StringToInteger(in);
    } else if (ColorIdMap.count(in) != 0) {
        return ColorIdMap.at(in);
    } else {
        RESTWarning << "cannot find color with name \"" << in << "\"" << RESTendl;
    }
    return -1;
}
 
Int_t TRestAnalysisPlot::GetFillStyleIDFromString(const string& in) {
    if (in.find_first_not_of("0123456789") == string::npos) {
        return StringToInteger(in);
    } else if (FillStyleMap.count(in) != 0) {
        return FillStyleMap.at(in);
    } else {
        RESTWarning << "cannot find fill style with name \"" << in << "\"" << RESTendl;
    }
    return -1;
}
 
Int_t TRestAnalysisPlot::GetLineStyleIDFromString(const string& in) {
    if (in.find_first_not_of("0123456789") == string::npos) {
        return StringToInteger(in);
    } else if (LineStyleMap.count(in) != 0) {
        return LineStyleMap.at(in);
    } else {
        RESTWarning << "cannot find line style with name \"" << in << "\"" << RESTendl;
    }
    return -1;
}
 
void TRestAnalysisPlot::PlotCombinedCanvas() {
    // Initializing canvas window
    if (fCombinedCanvas != nullptr) {
        delete fCombinedCanvas;
        fCombinedCanvas = nullptr;
    }
    fCombinedCanvas = new TCanvas(this->GetName(), this->GetName(), 0, 0, fCanvasSize.X(), fCanvasSize.Y());
    fCombinedCanvas->Divide((Int_t)fCanvasDivisions.X(), (Int_t)fCanvasDivisions.Y(),
                            fCanvasDivisionMargins.X(), fCanvasDivisionMargins.Y());
 
    // Setting up TStyle
    TStyle* st = new TStyle();
    st->SetPalette(fPaletteStyle);
 
    Double_t startTime = 0;
    Double_t endTime = 0;
    Double_t runLength = 0;
    Int_t totalEntries = 0;
    for (const auto& inputFilename : fRunInputFileName) {
        auto run = GetRunInfo(inputFilename);
 
        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();
        }
    }
 
    Double_t meanRate = totalEntries / runLength;
 
    runLength /= 3600.;
 
    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);
 
            auto run = GetRunInfo(fRunInputFileName[0]);
            label = run->ReplaceMetadataMembers(label, fPanels[n].precision);
 
            TLatex* textLatex = new TLatex(fPanels[n].posX[m], fPanels[n].posY[m], label.c_str());
            textLatex->SetTextColor(1);
            textLatex->SetTextSize(fPanels[n].font_size);
            textLatex->Draw("same");
        }
    }
 
    // start drawing plots
    vector<TH3F*> histCollectionAll;
    for (unsigned int n = 0; n < fPlots.size(); n++) {
        PlotInfoSet& plot = fPlots[n];
 
        TPad* targetPad = (TPad*)fCombinedCanvas->cd(n + 1 + fPanels.size());
        targetPad->SetLogx(plot.logX);
        targetPad->SetLogy(plot.logY);
        targetPad->SetLogz(plot.logZ);
        targetPad->SetGridx(plot.gridX);
        targetPad->SetGridy(plot.gridY);
        targetPad->SetLeftMargin(plot.marginLeft);
        targetPad->SetRightMargin(plot.marginRight);
        targetPad->SetBottomMargin(plot.marginBottom);
        targetPad->SetTopMargin(plot.marginTop);
 
        // draw each histogram in the pad
        for (unsigned int i = 0; i < plot.histos.size(); i++) {
            HistoInfoSet& hist = plot.histos[i];
 
            TString plotString = hist.plotString;
            TString nameString = hist.name;
            TString rangeString = hist.range;
            TString cutString = hist.cutString;
            TString optString = hist.drawOption;
 
            size_t pos = 0;
            rangeString = Replace((string)rangeString, "MIN_TIME", (string)Form("%9f", startTime), pos);
            rangeString = Replace((string)rangeString, "MAX_TIME", (string)Form("%9f", endTime), pos);
 
            if (cutString == "")
                cutString = hist.weight;
            else if (!hist.weight.empty())
                cutString = "(" + cutString + ") * " + hist.weight;
 
            if (GetVerboseLevel() >= TRestStringOutput::REST_Verbose_Level::REST_Debug) {
                cout << endl;
                cout << "--------------------------------------" << endl;
                cout << "Plot string : " << plotString << endl;
                cout << "Plot name : " << nameString << endl;
                cout << "Plot range : " << rangeString << endl;
                cout << "Cut : " << cutString << endl;
                cout << "Plot option : " << optString << endl;
                cout << "++++++++++++++++++++++++++++++++++++++" << endl;
            }
 
            // draw single histo from different file
            bool firstdraw = false;
            TH3F* hTotal = hist.ptr;
            for (unsigned int j = 0; j < fRunInputFileName.size(); j++) {
                auto run = GetRunInfo(fRunInputFileName[j]);
                // apply "classify" condition
                bool flag = true;
                for (const auto& [inputFile, info] : hist.classifyMap) {
                    if (run->GetRunInformation(inputFile).find(info) == string::npos) {
                        flag = false;
                        break;
                    }
                }
                if (!flag) continue;
 
                TTree* tree = GetTree(fRunInputFileName[j]);
 
                // call Draw() from analysis tree
                int outVal;
                TString reducedHistoName = nameString + "_" + std::to_string(j);
                TString histoName = nameString + "_" + std::to_string(j) + rangeString;
                RESTInfo << "AnalysisTree->Draw(\"" << plotString << ">>" << histoName << "\", \""
                         << cutString << "\", \"" << optString << "\", " << fDrawNEntries << ", "
                         << fDrawFirstEntry << ")" << RESTendl;
                outVal = tree->Draw(plotString + ">>" + histoName, cutString, optString, fDrawNEntries,
                                    fDrawFirstEntry);
                TH3F* hh = (TH3F*)gPad->GetPrimitive(reducedHistoName);
                if (outVal == 0) {
                    RESTInfo << "File: " << fRunInputFileName[j] << ": No entries are drawn" << RESTendl;
                    RESTInfo << "AnalysisTree is empty? cut is too hard?" << RESTendl;
                } else if (outVal == -1) {
                    RESTError << RESTendl;
                    RESTError
                        << "TRestAnalysisPlot::PlotCombinedCanvas. Plot string not properly constructed. "
                           "Does the analysis observable exist inside the file?"
                        << RESTendl;
                    RESTError << "Use \" restManager PrintTrees FILE.ROOT\" to get a list of "
                                 "existing observables."
                              << RESTendl;
                    RESTError << RESTendl;
                    exit(1);
                }
 
                // add to histogram
                if (hTotal == nullptr) {
                    if (hh != nullptr) {
                        hTotal = (TH3F*)hh->Clone(nameString);
                        hist.ptr = hTotal;
                        firstdraw = true;
                        // This is important so that the histogram is not erased when we delete TRestRun!
                        hTotal->SetDirectory(0);
                    }
                } else {
                    if (outVal > 0) {
                        if (IsDynamicRange(rangeString)) {
                            hTotal->SetDirectory(gDirectory);
                            hTotal->SetCanExtend(TH1::kAllAxes);
                            tree->Draw(plotString + ">>+" + hTotal->GetName(), cutString, optString,
                                       fDrawNEntries, fDrawFirstEntry);
                            RESTInfo << "AnalysisTree->Draw(\"" << plotString << ">>+" << hTotal->GetName()
                                     << "\", \"" << cutString << "\", \"" << optString << "\", "
                                     << fDrawNEntries << ", " << fDrawFirstEntry << ")" << RESTendl;
                            hTotal->SetDirectory(0);
                        } else {
                            hTotal->Add(hh);
                        }
                    }
                }
            }
 
            if (hTotal == nullptr) {
                RESTWarning << "Histogram \"" << nameString << "\" is nullptr" << RESTendl;
            } else if (firstdraw) {
                // adjust the histogram
                hTotal->SetTitle(plot.title.c_str());
                hTotal->SetStats(plot.staticsOn);
 
                hTotal->GetXaxis()->SetTitle(plot.labelX.c_str());
                hTotal->GetYaxis()->SetTitle(plot.labelY.c_str());
 
                hTotal->GetXaxis()->SetLabelSize(1.1 * hTotal->GetXaxis()->GetLabelSize());
                hTotal->GetYaxis()->SetLabelSize(1.1 * hTotal->GetYaxis()->GetLabelSize());
                hTotal->GetXaxis()->SetTitleSize(1.1 * hTotal->GetXaxis()->GetTitleSize());
                hTotal->GetYaxis()->SetTitleSize(1.1 * hTotal->GetYaxis()->GetTitleSize());
                hTotal->GetXaxis()->SetTitleOffset(1 * hTotal->GetXaxis()->GetTitleOffset());
                hTotal->GetYaxis()->SetTitleOffset(1 * hTotal->GetYaxis()->GetTitleOffset());
                hTotal->GetXaxis()->SetNdivisions(plot.ticksX);
                hTotal->GetYaxis()->SetNdivisions(plot.ticksY);
 
                hTotal->SetLineColor(hist.lineColor);
                hTotal->SetLineWidth(hist.lineWidth);
                hTotal->SetLineStyle(hist.lineStyle);
                hTotal->SetFillColor(hist.fillColor);
                hTotal->SetFillStyle(hist.fillStyle);
 
                hTotal->SetDrawOption(hist.drawOption.c_str());
 
                if (plot.timeDisplay) hTotal->GetXaxis()->SetTimeDisplay(1);
 
                histCollectionAll.push_back(hTotal);
            }
        }
 
        bool allEmpty = true;
        for (unsigned int i = 0; i < plot.histos.size(); i++) {
            if (plot.histos[i].ptr == nullptr)
                continue;
            else {
                allEmpty = false;
                break;
            }
        }
        if (allEmpty) {
            RESTWarning << "TRestAnalysisPlot: pad empty for the plot: " << plot.name << RESTendl;
            continue;
        }
 
        // normalize the histograms
        if (plot.normalize > 0) {
            for (unsigned int i = 0; i < plot.histos.size(); i++) {
                if (plot.histos[i].ptr == nullptr) continue;
                Double_t scale = 1.;
                if (plot.histos[i].ptr->Integral() > 0) {
                    scale = plot.normalize / plot.histos[i].ptr->Integral();
                    plot.histos[i].ptr->Scale(scale);
                }
            }
        }
 
        // scale the histograms
        if (plot.scale != "") {
            for (unsigned int i = 0; i < plot.histos.size(); i++) {
                if (plot.histos[i].ptr == nullptr) continue;
                Double_t scale = 1.;
                if (plot.scale == "binSize")
                    scale = 1. / plot.histos[i].ptr->GetXaxis()->GetBinWidth(1);
                else
                    scale = StringToDouble(plot.scale);
 
                plot.histos[i].ptr->Scale(scale);
            }
        }
 
        // draw to the pad
        targetPad = (TPad*)fCombinedCanvas->cd(n + 1 + fPanels.size());
        Double_t maxValue_Pad = 0;
        unsigned int maxID = 0;
        for (unsigned int i = 0; i < plot.histos.size(); i++) {
            // need to draw the max histogram first, in order to prevent peak hidden problem
            if (plot.histos[i].ptr == nullptr) continue;
            Double_t value = plot.histos[i]->GetBinContent(plot.histos[i].ptr->GetMaximumBin());
            if (i == 0) {
                maxValue_Pad = value;
            } else if (value > maxValue_Pad) {
                maxValue_Pad = value;
                maxID = i;
            }
        }
        plot.histos[maxID]->Draw(plot.histos[maxID].drawOption.c_str());
        // if (((string)plot.histos[maxID]->ClassName()).find("TH1") != -1) {
        //    plot.histos[maxID]->GetYaxis()->SetRangeUser(plot.logY, maxValue_Pad * 1.2);
        //}
 
        for (unsigned int i = 0; i < plot.histos.size(); i++) {
            // draw the remaining histo
            if (plot.histos[i].ptr == nullptr) continue;
            if (i != maxID) {
                plot.histos[i]->Draw((plot.histos[i].drawOption + "same").c_str());
            }
        }
 
        // save histogram to root file
        if (fRun->GetOutputFile() != nullptr) {
            fRun->GetOutputFile()->cd();
            for (auto& histo : plot.histos) {
                if (histo.ptr == nullptr) continue;
                histo->Write();
            }
        }
 
        // draw legend
        if (plot.legendOn) {
            TLegend* legend = new TLegend(fLegendX1, fLegendY1, fLegendX2, fLegendY2);
            for (auto& histo : plot.histos) {
                if (histo.ptr == nullptr) continue;
                legend->AddEntry(histo.ptr, histo->GetName(), "lf");
            }
            legend->Draw("same");
        }
 
        // save pad
        targetPad->SetRightMargin(plot.marginRight);
        targetPad->SetLeftMargin(plot.marginLeft);
        targetPad->SetBottomMargin(plot.marginBottom);
        targetPad->Update();
        if (!plot.save.empty()) targetPad->Print(plot.save.c_str());
 
        fCombinedCanvas->Update();
    }
 
    // Preview plot. User can make some changed before saving
    if (!REST_Display_CompatibilityMode && StringToBool(GetParameter("previewPlot", "TRUE"))) {
        GetChar();
    }
 
    // Save canvas to a PDF file
    fCanvasSave = fRun->FormFormat(fCanvasSave);
    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)) {
        TRestRun* run = new TRestRun();
        run->SetOutputFileName((string)fCanvasSave);
        run->FormOutputFile();
        for (auto& h : histCollectionAll) {
            h->Write();
        }
        delete run;
    }
 
    // Save this class to the root file
    if (fRun->GetOutputFile() != nullptr) {
        fRun->GetOutputFile()->cd();
        this->Write();
    }
 
    delete st;
}
 
void TRestAnalysisPlot::SaveCanvasToPDF(const TString& fileName) { fCombinedCanvas->Print(fileName); }
 
void TRestAnalysisPlot::SavePlotToPDF(const 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);
    pad->SetRightMargin(fPlots[n - 1].marginRight);
    pad->SetLeftMargin(fPlots[n - 1].marginLeft);
    pad->SetBottomMargin(fPlots[n - 1].marginBottom);
 
    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);
}
 
void TRestAnalysisPlot::SaveHistoToPDF(const TString& fileName, Int_t nPlot, Int_t nHisto) {
    string name = fPlots[nPlot].histos[nHisto].name;
    TH3F* hist = (TH3F*)gPad->GetPrimitive(name.c_str());
 
    TCanvas* c = new TCanvas(name.c_str(), name.c_str(), 800, 600);
 
    hist->Draw();
 
    c->Print(fileName);
 
    delete c;
}