PlotGroup.cxx

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#include "NAGASH/PlotGroup.h"
 
using namespace NAGASH;
 
PlotGroup::PlotGroup(std::shared_ptr<MSGTool> MSG, std::shared_ptr<ConfigTool> c, const TString &rname, const TString &fname) : Result(MSG, c, rname, fname), maptool(MSG)
{
}
 
void PlotGroup::Combine(std::shared_ptr<Result> result)
{
    MSGUser()->StartTitle("PlotGroup::Combine");
    auto subPlotGroup = std::dynamic_pointer_cast<std::remove_pointer<decltype(this)>::type>(result);
    if (subPlotGroup != nullptr)
    {
        for (auto &sub : subPlotGroup->PlotMap)
        {
            auto findresult = this->PlotMap.find(sub.first);
            if (findresult != this->PlotMap.end())
            {
                findresult->second->Combine(sub.second);
            }
            else
            {
                auto subname = sub.first;
                auto newPlot = sub.second->CloneVirtual(this->GetResultName() + " " + subname);
                this->PlotMap.emplace(std::pair<TString, std::shared_ptr<HistBase>>(subname, newPlot));
            }
        }
    }
    MSGUser()->EndTitle();
}
 
void PlotGroup::Process()
{
    for (auto &t : PlotVector)
        t->Process();
}
 
void PlotGroup::ForEachPlot(std::function<void(std::shared_ptr<HistBase>)> func)
{
    for (auto &t : PlotVector)
        func(t);
}
 
void PlotGroup::SetUnprocessed()
{
    for (auto &t : PlotVector)
        t->SetUnprocessed();
}
 
void PlotGroup::Scale(double sf)
{
    for (auto &t : PlotVector)
        t->Scale(sf);
}
 
void PlotGroup::ScaleVariation(const TString &varname, double sf)
{
    auto titleguard = MSGUser()->StartTitleWithGuard("PlotGroup::ScaleVariation");
    for (auto &t : PlotVector)
    {
        if (auto h = t->GetVariationVirtual(varname); h)
            h->Scale(sf);
        else
            MSGUser()->MSG_WARNING("plot ", t->GetResultName(), " does not have variation ", varname, ", will not scale this variation");
    }
}
 
void PlotGroup::SetLinkType(std::function<double(const std::vector<double> &)> cf, std::function<double(const std::vector<double> &, const std::vector<double> &)> ef)
{
    for (auto &t : PlotVector)
        t->SetLinkType(cf, ef);
}
 
void PlotGroup::SetLinkType(const TString &type)
{
    for (auto &t : PlotVector)
        t->SetLinkType(type);
}
 
void PlotGroup::SetLinkType(std::function<void(const std::vector<TH1 *> &, TH1 *)> hf)
{
    for (auto &t : PlotVector)
        t->SetLinkType(hf);
}
 
void PlotGroup::SetLinkPlotGroup(uint64_t index, std::shared_ptr<PlotGroup> pg)
{
    for (auto &t : pg->PlotMap)
    {
        auto findresult = this->PlotMap.find(t.first);
        if (findresult != this->PlotMap.end())
            findresult->second->SetLinkPlot(index, t.second);
    }
}
 
void PlotGroup::ClearLinkPlotGroup()
{
    for (auto &t : PlotVector)
    {
        t->ClearLinkPlot();
    }
}
 
void PlotGroup::WriteToFile()
{
    auto titleguard = MSGUser()->StartTitleWithGuard("Plot1D::WriteToFile");
    Process();
    if (GetOutputFileName() == "")
    {
        MSGUser()->MSG(MSGLevel::WARNING, "input an empty output file name, will be ignored");
        return;
    }
 
    TFile *file = new TFile(GetOutputFileName(), "UPDATE");
    file->cd();
    for (auto &t : PlotVector)
        t->Write();
 
    file->Close();
}
 
void PlotGroup::Reset()
{
    auto titlegurad = MSGUser()->StartTitleWithGuard("PlotGroup::Reset");
    for (auto &t : PlotVector)
        t->Reset();
}
 
void PlotGroup::Recover(const TString &filename)
{
    auto titlegurad = MSGUser()->StartTitleWithGuard("PlotGroup::Recover");
    TFile *file = new TFile(filename.TString::Data());
    if (file == nullptr)
    {
        MSGUser()->MSG_ERROR("ROOT file ", filename, " does not exist");
        return;
    }
 
    MSGUser()->MSG_DEBUG("Recover ", GetResultName(), " from file ", filename);
    Recover(file);
    file->Close();
}
 
void PlotGroup::Recover(TFile *file)
{
    auto titlegurad = MSGUser()->StartTitleWithGuard("PlotGroup::Recover");
    if (file == nullptr)
    {
        MSGUser()->MSG_ERROR("ROOT file does not exist");
        return;
    }
 
    for (auto &t : PlotVector)
        t->Recover(file);
}
 
void PlotGroup::Recover(std::shared_ptr<TFileHelper> file)
{
    auto titlegurad = MSGUser()->StartTitleWithGuard("PlotGroup::Recover");
    for (auto &t : PlotVector)
        t->Recover(file);
}
 
std::shared_ptr<PlotGroup> PlotGroup::Clone(const TString &name)
{
    std::shared_ptr<PlotGroup> newPlotGroup = std::make_shared<PlotGroup>(MSGUser(), ConfigUser(), name, GetOutputFileName());
    for (auto &t : PlotMap)
    {
        auto newplot = t.second->CloneVirtual(name + "_" + t.first);
        newPlotGroup->PlotMap.insert(std::pair<TString, std::shared_ptr<HistBase>>(t.first, newplot));
        PlotVector.emplace_back(newplot);
    }
 
    return newPlotGroup;
}
 
int PlotGroup::GetNPlots()
{
    return PlotVector.size();
}
 
void PlotGroup::BookSystematicVariation(const TString &name, double corr_factor, HistBase::SystPolicy policy)
{
    for (auto &t : PlotVector)
        t->BookSystematicVariation(name, corr_factor, policy);
}
 
void PlotGroup::BookSystematicVariation(const TString &name1, const TString &name2, double corr_factor, HistBase::SystPolicy policy)
{
    for (auto &t : PlotVector)
        t->BookSystematicVariation(name1, name2, corr_factor, policy);
}
 
void PlotGroup::BookSystematicVariation(const std::vector<TString> &names, double corr_factor, HistBase::SystPolicy policy)
{
    for (auto &t : PlotVector)
        t->BookSystematicVariation(names, corr_factor, policy);
}
 
void PlotGroup::RegroupSystematicVariation(const std::vector<TString> &names, HistBase::SystPolicy policy)
{
    for (auto &t : PlotVector)
        t->RegroupSystematicVariation(names, policy);
}
 
void PlotGroup::RemoveSystematicVariation(const TString &name)
{
    for (auto &t : PlotVector)
        t->RemoveSystematicVariation(name);
}
 
void PlotGroup::RenameSystematicVariation(const TString &name_old, const TString &name_new)
{
    for (auto &t : PlotVector)
        t->RenameSystematicVariation(name_old, name_new);
}
 
void PlotGroup::SetSystematicVariation(const TString &name)
{
    for (auto &t : PlotVector)
        t->SetSystematicVariation(name);
}
 
void PlotGroup::SetSystematicVariation(int index)
{
    for (auto &t : PlotVector)
        t->SetSystematicVariation(index);
}