toolbox.h

Go to the documentation of this file.

#pragma once
 
#include <vector>
 
#include <TDirectory.h>
#include <TKey.h>
#include <TString.h>
 
#include "Math/VectorUtil.h"
 
#include "Core/Objects/interface/PhysicsObject.h"
 
#include <boost/exception/all.hpp>
#include <boost/iterator/counting_iterator.hpp>
 
namespace DAS {
 
inline bool pt_sort (const PhysicsObject& j1, const PhysicsObject& j2)
{
    return j1.CorrPt() > j2.CorrPt();
}
 
enum BinningOptions {
    default_def = 0b00, 
    logarithmic = 0b01, 
    step        = 0b10  
};
 
template<typename T = double> std::vector<T> MakeBinning (
    std::pair<T, T> range, 
    double param, 
    int opt = BinningOptions::default_def 
)
{
    using namespace std;
 
    if (range.second <= range.first)
        BOOST_THROW_EXCEPTION(invalid_argument("Invalid binning range"));
    if (param <= 0)
        BOOST_THROW_EXCEPTION(invalid_argument("Invalid binning parameter"));
    if ((opt & BinningOptions::logarithmic) && range.first <= 0)
        BOOST_THROW_EXCEPTION(invalid_argument("Logarithmic binning requires range.first > 0"));
    if ((opt & BinningOptions::logarithmic) && (opt & BinningOptions::step) && param <= 1)
        BOOST_THROW_EXCEPTION(invalid_argument("Log-step binning requires param > 1"));
 
    if (opt & BinningOptions::logarithmic) {
        range.first = log10(range.first);
        range.second = log10(range.second);
        if (opt & BinningOptions::step) param = log10(param);
    }
 
    double w = opt & BinningOptions::step ? param : (range.second-range.first)/param;
    using boost::counting_iterator;
    vector<T> edges(counting_iterator<T>(range.first /w),
                    counting_iterator<T>(range.second/w+1));
    ranges::for_each(edges, [w](T& edge) { edge *= w; });
    if (opt & BinningOptions::logarithmic)
        ranges::for_each(edges, [](T& edge) { edge = pow(10,edge); });
 
    return edges;
}
 
template<typename TTreePtr>
[[ deprecated("Use Darwin::Tools::Flow()") ]]
bool branchExists (const TTreePtr& tree, TString brName)
{
    auto brList = tree->GetListOfBranches();
    bool brFound = false;
    for (auto it = brList->begin(); it != brList->end(); ++it) {
        TString name = (*it)->GetName();
        if (name == brName) brFound = true;
    }
    return brFound;
}
 
template<typename T> std::vector<T*> GetObjects (TDirectory * dir)
{
    if (!dir)
        BOOST_THROW_EXCEPTION( std::runtime_error("Trying to access inexistent `TDirectory`") );
    std::vector<T*> objects;
    for (const auto&& element: *(dir->GetListOfKeys())) {
        auto key = dynamic_cast<TKey*>(element);
        if (auto obj = dynamic_cast<T*>(key->ReadObj()); obj)
            objects.push_back(obj);
    }
    return objects;
}
 
inline TDirectory * GetDirectory (TDirectory * dir, const std::vector<const char *>& names)
{
    for (const char * name: names) {
        TDirectory * subdir = dir->GetDirectory(name);
        if (!subdir)
            BOOST_THROW_EXCEPTION( std::invalid_argument(
                    Form("`%s` could not be found in `%s`", name, dir->GetName())) );
        dir = subdir;
    }
    return dir;
}
 
using ROOT::Math::VectorUtil::DeltaPhi;
using ROOT::Math::VectorUtil::DeltaR;
 
} // end of DAS namespace