TFileHelper.h

Go to the documentation of this file.

//***************************************************************************************
//***************************************************************************************
 
#pragma once
 
#include "NAGASH/Tool.h"
#include "NAGASH/Global.h"
#include "NAGASH/MapTool.h"
 
namespace NAGASH
{
    class TFileHelper : public Tool
    {
    public:
        TFileHelper(std::shared_ptr<MSGTool> msg, const std::string &name)
            : Tool(msg)
        {
            TH1::AddDirectory(kFALSE);
            auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
            infile = new TFile(name.c_str(), "READ");
            if (infile == nullptr)
            {
                MSGUser()->MSG_ERROR("can't open ROOT file ", name);
                return;
            }
 
            if (infile->IsZombie())
            {
                MSGUser()->MSG_ERROR("can't open ROOT file ", name);
                return;
            }
 
            isopen = true;
            if (isopen)
            {
                TIter next(infile->GetListOfKeys());
                TKey *key;
 
                while ((key = (TKey *)next()))
                {
                    if (TString(key->GetClassName()).Contains("TH1") ||
                        TString(key->GetClassName()).Contains("TH2") ||
                        TString(key->GetClassName()).Contains("TH3") ||
                        TString(key->GetClassName()).Contains("THn") ||
                        TString(key->GetClassName()).Contains("TProfile"))
                    {
                        std::unique_ptr<TObject> obj(key->ReadObj());
                        map_name_hist.emplace(std::pair<std::string, TKey *>(obj->GetName(), key));
                    }
 
                    if (TString(key->GetClassName()) == "TTree")
                    {
                        std::unique_ptr<TObject> obj(key->ReadObj());
                        map_name_tree.emplace(std::pair<std::string, TKey *>(obj->GetName(), key));
                    }
 
                    if (TString(key->GetClassName()).Contains("TGraph"))
                    {
                        std::unique_ptr<TObject> obj(key->ReadObj());
                        map_name_graph.emplace(std::pair<std::string, TKey *>(obj->GetName(), key));
                    }
                }
            }
 
            MapTool tool(MSGUser());
            histnames = tool.GetListOfKeys(map_name_hist);
        }
        TFileHelper(std::shared_ptr<MSGTool> msg, const std::string &name) {…}
 
        TH1 *Get(const std::string &name)
        {
            if (!isopen)
            {
                auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                MSGUser()->MSG_ERROR("file not open");
                return nullptr;
            }
            else
            {
                auto findresult = map_name_hist.find(name);
                if (findresult != map_name_hist.end())
                    return (TH1 *)findresult->second->ReadObj();
                else
                {
                    auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                    MSGUser()->MSG_ERROR("hist ", name, " not found");
                    return nullptr;
                }
            }
        }
        TH1 *Get(const std::string &name) {…}
 
        TTree *GetTree(const std::string &name)
        {
 
            if (!isopen)
            {
                auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                MSGUser()->MSG_ERROR("file not open");
                return nullptr;
            }
            else
            {
                auto findresult = map_name_tree.find(name);
                if (findresult != map_name_tree.end())
                    return (TTree *)findresult->second->ReadObj();
                else
                {
                    // auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                    // MSGUser()->MSG_ERROR("tree ", name, " not found");
                    return nullptr;
                }
            }
        }
        TTree *GetTree(const std::string &name) {…}
 
        TGraph *GetTGraph(const std::string &name)
        {
 
            if (!isopen)
            {
                auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                MSGUser()->MSG_ERROR("file not open");
                return nullptr;
            }
            else
            {
                auto findresult = map_name_graph.find(name);
                if (findresult != map_name_graph.end())
                    return (TGraph *)findresult->second->ReadObj();
                else
                {
                    auto titleguard = MSGUser()->StartTitleWithGuard("TFileHelper");
                    MSGUser()->MSG_ERROR("graph ", name, " not found");
                    return nullptr;
                }
            }
        }
        TGraph *GetTGraph(const std::string &name) {…}
 
        void Close()
        {
            if (infile)
            {
                delete infile;
                infile = nullptr;
                isopen = false;
 
                map_name_hist.clear();
                map_name_graph.clear();
                map_name_tree.clear();
                histnames.clear();
            }
        }
        void Close() {…}
 
        const std::vector<std::string> &GetListOfHistNames()
        {
            return histnames;
        }
        const std::vector<std::string> &GetListOfHistNames() {…}
 
        virtual ~TFileHelper()
        {
            Close();
        }
        virtual ~TFileHelper() {…}
 
    private:
        std::map<std::string, TKey *> map_name_hist;
        std::map<std::string, TKey *> map_name_graph;
        std::map<std::string, TKey *> map_name_tree;
        std::vector<std::string> histnames;
        TFile *infile = nullptr;
        bool isopen = false;
    };
    class TFileHelper : public Tool {…};
}