toolbox.h

Go to the documentation of this file.

#include <exception>
#include <string>
 
#include <boost/algorithm/string.hpp>
#include <boost/assert/source_location.hpp>
 
#include <correction.h>
#include <darwin.h>
 
namespace DAS::JetEnergy {
 
inline std::string GetAlgo (const Darwin::Tools::UserInfo& metainfo)
{
    if (metainfo.Find("flags", "labels", "CHS"  )) return "chs";
    if (metainfo.Find("flags", "labels", "PUPPI")) return "Puppi";
 
    std::cerr << orange << "Couldn't identify CHS or PUPPI. Running default "
                           "CHS for Run 2 (PUPPI foir Run 3)\n" << def;
 
    auto year = metainfo.Get<int>("flags", "year");
    if (year > 2019) return "Puppi"; // run 3
    if (year > 2014) return "chs"; // run 2
                     return ""; // run 1
}
 
std::string GetShortCampaign (const std::string& campaign)
{
    using namespace std;
    regex r("^(Summer|Fall|Autumn|Winter|Spring)[0-9]{2}[A-Za-z0-9]*");
    smatch campaign_short;
    if (!regex_search(campaign, campaign_short, r))
        BOOST_THROW_EXCEPTION( invalid_argument("The campaign could not be identified"));
    return campaign_short.str();
}
 
std::string ScanCorrections (const auto& corrections, 
                             const std::string& key = "") 
{
    std::stringstream s;
    s << "Available corrections:";
    for (const auto& correction: corrections) {
        bool found = correction.first == key;
        if (found) s << bold << green;
        s << ' ' << correction.first;
        if (found) s << def;
    }
    return s.str();
}
 
template<typename CorrectionType> 
CorrectionType GetCorrection (const auto& corrections, 
                              const std::string& campaign, 
                              const std::string& type, 
                              const std::string& level, 
                              const std::string& suffix) 
{
    namespace al = boost::algorithm;
    for (const auto& correction: corrections) {
        if (!al::starts_with(correction.first, campaign) ||
            !al::contains   (correction.first, type) ||
            !al::contains   (correction.first, level) ||
            !al::ends_with  (correction.first, suffix))
            continue;
 
        return correction.second;
    }
    using namespace std;
    BOOST_THROW_EXCEPTION(
            invalid_argument(
                "No `"s + campaign + "*"s + type + "*" + level + "*"s + suffix
                + "` correction can be found in the given tables. "s
                + ScanCorrections(corrections)
            )
        );
}
 
float Evaluate (const auto& correction, 
                std::ostream& cout, 
                const RecJet& recJet, 
                const std::optional<float>& rho = {}, 
                const std::optional<GenJet>& genJet = {}, 
                const std::optional<RecEvent>& recEvt = {}, 
                const std::optional<std::string>& systematic = {}, 
                const std::optional<float>& JER = {}, 
                const std::optional<float>& JERSF = {}  
               )
try {
    using namespace std;
 
    cout << correction->name();
    vector<correction::Variable::Type> inputs;
    inputs.reserve(10);
 
    auto push_back = [&cout,&inputs](const auto& v) {
        inputs.push_back(v);
        cout << '=' << v;
    };
 
    for (const correction::Variable& input: correction->inputs()) {
        const string& n = input.name();
        cout << ' ' << n;
        if      (n == "JetPt"     ) push_back(recJet.CorrPt());
        else if (n == "JetEta"    ) push_back(recJet.p4.Eta());
        else if (n == "JetPhi"    ) push_back(recJet.p4.Phi());
        else if (n == "JetEta"    ) push_back(recJet.p4.Phi());
        else if (n == "JetA"      ) push_back(recJet.area);
        else if (n == "Rho"       ) push_back(*rho);
        else if (n == "systematic") push_back(*systematic);
        else if (n == "GenPt"     ) push_back(genJet ? genJet->CorrPt() : -1);
        else if (n == "EventID"   ) push_back((int) recEvt->evtNo);
        else if (n == "run"       ) push_back((float) recEvt->runNo);
        else if (n == "JER"       ) push_back(*JER);
        else if (n == "JERSF"     ) push_back(*JERSF);
        else BOOST_THROW_EXCEPTION( invalid_argument("`"s + n + "` is needed by "s
                                    + correction->name() + " but not recognized."s) );
    }
    auto corr = correction->evaluate(inputs);
    cout << " -> " << corr << endl;
    return corr;
}
catch (std::runtime_error& e) {
    const char * name = typeid(*correction).name();
    auto location = boost::source_location(__FILE__, __LINE__, name);
    boost::throw_exception(e, location);
}
 
int GetR (const Darwin::Tools::UserInfo& metainfo)
{
    auto year = metainfo.Get<int>("flags", "year"),
         R = metainfo.Get<int>("flags", "R");
 
    std::string warning = "Not a standard jet size.\n";
    if (year > 2014) { // run 2 and run 3
        if (R != 4 && R != 8)
            std::cerr << orange << warning << def;
        return R < 6 ? 4 : 8;
    }
    else { // run 1
        if (R != 5 && R != 7)
            std::cerr << orange << warning << def;
        return R < 6 ? 5 : 7;
    }
}
 
} // end of DAS::JetEnergy namespace