FileUtils.h

Go to the documentation of this file.

#pragma once
 
#include "exceptions.h"
#include "FriendUtils.h"
#include "Looper.h"
 
#include <TChain.h>
#include <TFile.h>
#include <TH1.h>
#include <TTree.h>
 
#include <filesystem>
#include <string>
#include <memory>
#include <vector>
 
namespace Darwin::Tools {
 
std::unique_ptr<TFile> GetOutput (std::filesystem::path output,
                                  const std::string& name);
 
void StandardInit ();
 
std::vector<std::filesystem::path> GetROOTfiles
        (std::vector<std::filesystem::path> inputs); 
 
std::unique_ptr<ChainSlice> GetChain
                (std::vector<std::filesystem::path> inputs, 
                 const Slice slice = {1, 0}, 
                 const std::string& name = "events"); 
 
[[deprecated("Pass a slice as second parameter.")]]
inline std::unique_ptr<ChainSlice> GetChain
                (std::vector<std::filesystem::path> inputs, 
                 const char * name) 
{
    return GetChain(inputs, {1, 0}, name);
}
 
template<typename THX = TH1>
inline std::unique_ptr<THX> GetHist
                (std::vector<std::filesystem::path> inputs, 
                 const std::string& name = "h") 
{
    using namespace std;
    namespace fs = filesystem;
 
    unique_ptr<THX> sum;
    inputs = GetROOTfiles(inputs);
    for (auto const& input: inputs) {
        auto fIn = make_unique<TFile>(input.c_str(), "READ");
        unique_ptr<THX> h(fIn->Get<THX>(name.c_str()));
        if (!h) {
            namespace DE = Darwin::Exceptions;
            BOOST_THROW_EXCEPTION(DE::BadInput(Form("`%s` cannot be found in (one of) the "
                                                    " file(s).", name.c_str()), fIn));
        }
        if (sum)
            sum->Add(h.get());
        else {
            sum = std::move(h);
            sum->SetDirectory(nullptr);
        }
    }
    return sum;
}
 
std::string GetFirstTreeLocation
                (const std::filesystem::path& input); 
 
std::unique_ptr<TTree> NewTree (const std::unique_ptr<ChainSlice>& chain, 
                                const bool makeFriend, 
                                const std::string& thisFunc); 
 
template<typename T, 
    typename TTreePtr> 
T * GetBranchReadOnly (
            const TTreePtr& tIn, 
            const std::string& name, 
            T ** t, 
            const int steering = 0, 
            bool raise_exception = true) 
{
    using namespace std;
    namespace DE = Darwin::Exceptions;
 
    if (steering & verbose)
        cout << "Loading branch `" << name << "`" << endl;
 
    if (tIn->GetBranch(name.c_str()) == nullptr) {
        if (raise_exception) {
            string what = name + " branch could not be found";
            BOOST_THROW_EXCEPTION( DE::BadInput(what.c_str(), *tIn));
        }
        else
            return nullptr;
    }
 
    *t = nullptr;
    if (int err = tIn->SetBranchAddress(name.c_str(), t); err < 0) {
        string what = name + " branch could not be set "
                      "(`SetBranchAddress()` returned " + to_string(err) + ")";
        BOOST_THROW_EXCEPTION( DE::BadInput(what.c_str(), *tIn));
    }
 
    return *t;
}
 
template<typename T, 
    typename TTreePtr> 
T * GetBranchWriteOnly (
            TTreePtr& tOut, 
            const std::string& name, 
            T ** t, 
            const int steering = 0) 
{
    using namespace std;
 
    *t = new T;
    if (steering & verbose)
        cout << "Setting up new branch for `" << name << "`" << endl;
 
    namespace DE = Darwin::Exceptions;
    if (tOut->Branch(name.c_str(), t) == nullptr) {
        namespace DE = Darwin::Exceptions;
        string what = name + " branch could not be set up";
        BOOST_THROW_EXCEPTION( DE::BadInput(what.c_str(), *tOut) );
    }
 
    return *t;
}
 
template<typename T, 
    typename TTreePtrIn, 
    typename TTreePtrOut> 
T * GetBranchReadWrite (
            const TTreePtrIn& tIn, 
            TTreePtrOut& tOut, 
            const std::string& name, 
            T ** t, 
            const int steering = 0, 
            bool raise_exception = true)
{
    using namespace std;
 
    GetBranchReadOnly<T>(tIn, name, t, steering, raise_exception);
 
    if (steering & Friend) {
        if (steering & verbose)
            cout << "Setting up new branch for `" << name << "`" << endl;
        if (tOut->Branch(name.c_str(), t) == nullptr) {
            namespace DE = Darwin::Exceptions;
            string what = name + " branch could not be set up";
            BOOST_THROW_EXCEPTION( DE::BadInput(what.c_str(), *tOut) );
        }
    }
 
    return *t;
}
 
} // namespace Darwin::Tools
 
#define DT_GetOutput(output) Darwin::Tools::GetOutput(output, __func__)
#define DT_NewTree(input,makeFriend) Darwin::Tools::NewTree(input, makeFriend, __func__)