DAS::BTagging Namespace Reference

Classes
struct	JetWeight

Functions
void	applyBTagSF (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
vector< double >	GetDeepJetEdges (int year, bool HIPM=false)
void	getBTagBinnedDiscriminant (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
void	getBTagFraction (const vector< fs::path > &inputs, const fs::path &output, const int steering)
void	getBTagPerformance (const vector< fs::path > &inputs, const fs::path &output, const int steering)

Function Documentation

applyBTagSF()

void DAS::BTagging::applyBTagSF	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

Apply the multi-WP calibration with fix-WPs tables.

Parameters

inputs	input ROOT files (n-tuples)
output	output ROOT file (n-tuple)
config	config handled with `Darwin::Tools::options`
steering	parameters obtained from explicit options
slice	number and index of slice

                                  {1,0} 
            )
{
    cout << __func__ << ' ' << slice << " start" << endl;
 
    DT::Flow flow(steering);
    auto tIn = flow.GetInputTree(inputs, slice);
    auto tOut = flow.GetOutputTree(output);
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
    auto isMC = metainfo.Get<bool>("flags", "isMC");
    if (!isMC) BOOST_THROW_EXCEPTION( DE::BadInput("Only MC may be used as input.",
                                      make_unique<TFile>(inputs.front().c_str() )) );
    auto R = metainfo.Get<int>("flags", "R");
    if (R != 4) BOOST_THROW_EXCEPTION( DE::BadInput("Only AK4 jets may be used.",
                                       make_unique<TFile>(inputs.front().c_str() )) );
 
    auto recJets = flow.GetBranchReadWrite<vector<RecJet>>("recJets");
 
    if (steering & DT::syst)
        BOOST_THROW_EXCEPTION( logic_error("B-tagging variations not yet implemented\n") );
 
    auto discriminant = config.get<fs::path>("corrections.btagging.discriminant"),
         SFtables     = config.get<fs::path>("corrections.btagging.SFtables");
    JetWeight w(SFtables, discriminant);
 
    metainfo.Set<fs::path>("corrections", "btagging", "discriminant", discriminant);
    metainfo.Set<fs::path>("corrections", "btagging", "SFtables"    , SFtables    );
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused]]
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
        for (auto& jet: *recJets)
            jet.weights *= w(jet);
 
        if (steering & DT::fill) tOut->Fill();
    }
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " stop" << endl;
}

getBTagBinnedDiscriminant()

void DAS::BTagging::getBTagBinnedDiscriminant	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering,
		const DT::Slice	slice = {1,0}
	)

Get B-tagged binned discriminant in bins of pt, true flavour, and discriminant value. Works for both data and MC (although in the case of data, the true flavour is always trivial).

Todo:

GSP?

Todo:

loop over variations

Todo:

gen event weight

Parameters

inputs	input ROOT files (n-tuples)
output	output ROOT file (n-tuple)
config	config handled with `Darwin::Tools::options`
steering	parameters obtained from explicit options
slice	number and index of slice

                              {1,0} 
        )
{
    cout << __func__ << ' ' << slice << " start" << endl;
 
    DT::Flow flow(steering);
    auto tIn = flow.GetInputTree(inputs, slice);
    auto [fOut, tOut] = flow.GetOutput(output);
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
    //auto isMC = metainfo.Get<bool>("flags", "isMC");
    auto year = metainfo.Get<int>("flags", "year");
    bool HIPM = metainfo.Find("flags", "labels");
    if (HIPM && year != 2016)
        cerr << orange << "The HIPM label may only be used for 2016 samples. It will be just ignored for other years.\n" << def;
 
    const vector<double> flavour_edges = {0.5, 1.5, 2.5, 3.5, 4.5, 5.5}, 
                         disc_edges = GetDeepJetEdges(year, HIPM);
    const int nFlBins = flavour_edges.size()-1,
              nDiscBins = disc_edges.size()-1;
    auto discriminant = make_unique<TH3D>("discriminant", "B-tag discriminant",
                                            nPtBins, pt_edges.data(),
                                            nFlBins, flavour_edges.data(),
                                            nDiscBins, disc_edges.data());
 
    if (steering & DT::syst)
        BOOST_THROW_EXCEPTION( logic_error("B-tagging variations not yet implemented\n") );
 
    //GenEvent * genEvent = nullptr; /// \todo genEvent??
    auto recEvent = flow.GetBranchReadOnly<RecEvent>("recEvent");
    auto recJets = flow.GetBranchReadOnly<vector<RecJet>>("recJets");
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused]]
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
 
        auto evWgt = recEvent->weights.front();
        //if (isMC) evWgt *= genEvt->weights.front();
 
        for (const RecJet& jet: *recJets) {
            auto jWgt = jet.weights.front();
            discriminant->Fill(jet.CorrPt(), jet.hadronFlavour(), jet.DeepJet.B(), jWgt*evWgt);
        }
    }
 
    fOut->cd();
    discriminant->SetDirectory(fOut);
    discriminant->Write();
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " stop" << endl;
}

getBTagFraction()

void DAS::BTagging::getBTagFraction	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const int	steering
	)

Extract the B-tagged fraction from the output of getBTagDiscriminant. Works for both data and MC.

Parameters

inputs	input ROOT files (histograms)
output	output ROOT file (histograms)
steering	parameters obtained from explicit options

{
    [[ maybe_unused]]
    static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
    cout << __func__ << " start" << endl;
 
    unique_ptr<TH3> hIn = DT::GetHist<TH3>(inputs, "discriminant");
    if (hIn->GetNbinsZ() != 4) {
        const char * what = Form("Found %d working points (expecting 4)", hIn->GetNbinsZ());
        BOOST_THROW_EXCEPTION( DE::BadInput(what, hIn) );
    }
 
    auto fOut = DT::GetOutputFile(output);
 
    auto project = [&hIn](const char * name, int bin) {
        return unique_ptr<TH1>( hIn->ProjectionX(name, 0, -1, bin, 4) );
    };
 
    auto hIncl = project("inclusive", 1);
    int im = hIncl->FindBin(22), // because the btagging calib starts with pt > 20 GeV
        iM = hIncl->GetNbinsX();
    auto integrate = [im,iM](const unique_ptr<TH1>& h) {
        return h->Integral(im, iM);
    };
    double sum = integrate(hIncl);
 
    map<TString, int> WPs { {"loose", 2}, {"medium", 3}, {"tight", 4} };
    for (const auto& WP: WPs) {
        auto h = project(WP.first, WP.second);
        h->SetTitle("B-tagged jet fraction for " + WP.first + " working point");
        cout << h->GetTitle() << ": " << integrate(h)/sum << endl;
        h->Divide(h.get(), hIncl.get(), 1, 1, "b");
        h->Write();
    }
 
    cout << __func__ << " stop" << endl;
}

getBTagPerformance()

void DAS::BTagging::getBTagPerformance	(	const vector< fs::path > &	inputs,
		const fs::path &	output,
		const int	steering
	)

Extract the B-tagged performance from the output of getBTagBinnedDiscriminant. The B-tagging efficiency and mistag rates are calculated.

Todo:

crash if under- or overflow non-empty

Parameters

inputs	input ROOT files (histograms)
output	output ROOT file (histograms)
steering	parameters obtained from explicit options

{
    [[ maybe_unused]]
    static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
    cout << __func__ << " start" << endl;
 
    unique_ptr<TH3> hIn = DT::GetHist<TH3>(inputs, "discriminant");
    if (hIn->GetNbinsZ() != 4) {
        const char * what = Form("Found %d working points (expecting 4)", hIn->GetNbinsZ());
        BOOST_THROW_EXCEPTION( DE::BadInput(what, hIn) );
    }
 
    auto fOut = DT::GetOutputFile(output);
 
    map<TString, int> flavours { {"light" , 0}, {"charm" , 4}, {"bottom", 5} };
    map<TString, int> WPs { {"loose", 2}, {"medium", 3}, {"tight", 4} };
    for (const auto& WP: WPs) {
 
        int tagBin = WP.second;
 
        auto hIncl = unique_ptr<TH1>( hIn->ProjectionX("inclusive", 0, -1, tagBin, 4) );
 
        for (const auto& flavour: flavours) {
 
            TString name = WP.first + '_' + flavour.first;
 
            int flBin = flavour.second;
 
            auto h = unique_ptr<TH1>( hIn->ProjectionX(name, flBin, flBin, tagBin, 4) );
            TString title = flavour.first + " for " + WP.first + " working point";
            cout << title << endl;
            h->SetTitle(title);
            h->Divide(h.get(), hIncl.get(), 1, 1, "b");
            h->Write();
        }
    }
 
 
    cout << __func__ << " stop" << endl;
}

GetDeepJetEdges()

vector<double> DAS::BTagging::GetDeepJetEdges	(	int	year,
		bool	HIPM = false
	)

Working points provided by BTV for Full-Run-2 Ultra-Legacy samples.

Reference: Wiki

{
    switch (year) {
        case 2016:
            if (HIPM) return { 0., 0.0508, 0.2598, 0.6502, 1. };
            else      return { 0., 0.0480, 0.2489, 0.6377, 1. };
        case 2017:
            return {0., 0.0532, 0.3040, 0.7476, 1.};
        case 2018:
            return {0., 0.0490, 0.2783, 0.7100, 1.};
        default:
            const char * what = Form("The year %d is currently not supported", year);
            BOOST_THROW_EXCEPTION( invalid_argument(what) );
    }
}