DAS::JetVeto Namespace Reference

Classes
struct	Conservative

Functions
void	applyConservativeVetoMap (const vector< fs::path > inputs, const fs::path output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
void	getConservativeMap (const fs::path &input, const fs::path &output, const pt::ptree &config, const int steering)

Function Documentation

applyConservativeVetoMap()

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

Remove regions that are not properly simulated both in data and simulation (fixed via unfolding at the end).

Maps are derived by Hannu (Helsinki), and should be downloaded and adapted.

Parameters

inputs	input ROOT files (n-tuples)
output	name of output root file containing the histograms
config	config file from `DTOptions`
steering	steering parameters from `DTOptions`
slice	slices for running

                                   {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");
 
    const auto& jetveto_file = config.get<fs::path>("corrections.jetvetomap.filename");
    JetVeto::Conservative jetveto(jetveto_file);
    metainfo.Set<fs::path>("corrections", "jetvetomap", "filename", jetveto_file);
 
    auto genEvt = isMC ? flow.GetBranchReadOnly<GenEvent>("genEvent") : nullptr;
    auto recEvt = flow.GetBranchReadOnly<RecEvent>("recEvent");
 
    auto recJets = flow.GetBranchReadWrite<vector<RecJet>>("recJets");
 
    ControlPlots raw("raw");
    ControlPlots nominal("HotKillers");
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
        auto ev_w = (isMC ? genEvt->weights.front().v : 1) * recEvt->weights.front().v;
 
        raw(*recJets, ev_w);
 
        for (auto& recJet: *recJets)
            jetveto(recJet);
 
        nominal(*recJets, ev_w);
 
        if (steering & DT::fill) tOut->Fill();
    }
 
    fOut->cd();
    jetveto.Write(fOut);
    raw.Write(fOut);
    nominal.Write(fOut);
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " end" << endl;
}

getConservativeMap()

void DAS::JetVeto::getConservativeMap	(	const fs::path &	input,
		const fs::path &	output,
		const pt::ptree &	config,
		const int	steering
	)

Maps the JetMET veto maps onto maps containing weights.

Todo:

make smart pointer? (last attempts led to seg)

Parameters

input	name of input root file
output	name of output root file
config	config handled with `Darwin::Tools::Options`
steering	parameters obtained from explicit options

{
    cout << __func__ << " start" << endl;
 
    if (!fs::exists(input))
        BOOST_THROW_EXCEPTION( fs::filesystem_error("Jet veta map file does not exists.",
                               input, make_error_code(errc::no_such_file_or_directory)) );
    auto fIn = make_unique<TFile>(input.c_str(), "READ");
    auto histname = config.get<string>("corrections.jetvetomap.histname");
    auto h = fIn->Get<TH2>(histname.c_str()); 
    if (h == nullptr)
        BOOST_THROW_EXCEPTION( DE::BadInput("Can't find the efficiency map", fIn) );
    h->SetDirectory(0);
    fIn->Close();
 
    auto fOut = make_unique<TFile>(output.c_str(), "RECREATE"); // TODO
 
    for (int x = 1; x <= h->GetNbinsX(); ++x)
    for (int y = 1; y <= h->GetNbinsY(); ++y) {
        auto content = h->GetBinContent(x,y);
        static const auto deps = numeric_limits<float>::epsilon();
        content = (content < deps); // 0 or 1, can then be used as an efficiency
        h->SetBinContent(x,y,content);
    }
    h->GetXaxis()->SetTitle("#eta");
    h->GetYaxis()->SetTitle("#phi");
    h->GetZaxis()->SetRangeUser(0,1);
 
    h->SetDirectory(fOut.get());
    h->Write("h2hot2");
 
    cout << __func__ << " end" << endl;
}