DAS::MissingET Namespace Reference

Classes
struct	Filters
struct	FractionCut

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

Function Documentation

applyMETfilters()

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

Apply MET filters, both for MC and Data following the official recommendations

Note

In case the MET fraction based cut would be used, the description of the MET class should be changed!!

Parameters

inputs	input ROOT file (n-tuple)
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, inputs);
    auto tIn = flow.GetInputTree(slice);
    auto [fOut, tOut] = flow.GetOutput(output);
 
    DT::MetaInfo metainfo(tOut);
    auto isMC = metainfo.Get<bool>("flags", "isMC");
    auto year = metainfo.Get<int>("flags", "year");
 
    auto gEv = isMC ? flow.GetBranchReadOnly<GenEvent>("genEvent") : nullptr;
    auto rEv = flow.GetBranchReadOnly<RecEvent>("recEvent");
    auto met = flow.GetBranchReadOnly<MET     >("met"     );
    auto recJets = flow.GetBranchReadOnly<vector<RecJet>>("recJets");
 
    if (!metainfo.Find("corrections", "METfilters"))
        BOOST_THROW_EXCEPTION( DE::BadInput("No MET filters in this tree", tOut) );
 
    fs::path p_METfilters = config.get<fs::path>("corrections.METfilters");
    if (metainfo.Get<fs::path>("corrections", "METfilters") != p_METfilters) {
        cerr << orange << "You are now using a different list of MET filters w.r.t. n-tuplisation.\n" << def;
        metainfo.Set<bool>("git", "reproducible", false);
    }
    MissingET::Filters metfilters(p_METfilters);
 
    /**** declaring a few histograms to control effect of filters ****/
 
    MissingET::FractionCut beforeCut("beforeMETcut"),
                           afterCut("afterMETcut");
 
    ControlPlots METbefore("METbefore"),
                 METafterAllMETfilters("METafterAllMETfilters"),
                 METafterMETfraction("METafterMETfraction"),
                 METafterAllMETfiltersAndMETfraction("METafterAllMETfiltersAndMETfraction");
 
    vector<ControlPlots> METfilters;
    for (const string& METname: metfilters.names)
        METfilters.emplace_back(METname);
 
    auto totRecWgt = [&](size_t i) {
        return (isMC ? gEv->weights.front().v : 1) * rEv->weights.at(i).v;
    };
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
        beforeCut.Fill(met, recJets, totRecWgt(0));
        METbefore(*recJets, totRecWgt(0));
 
        if (met->Et < 0.3 * met->SumEt){
            afterCut.Fill(met, recJets, totRecWgt(0));
            METafterMETfraction(*recJets, totRecWgt(0));
        }
 
 
        metfilters(*met, *rEv);
 
        METafterAllMETfilters(*recJets, totRecWgt(0));
 
        if (met->Et < 0.3 * met->SumEt)
            METafterAllMETfiltersAndMETfraction(*recJets, totRecWgt(0));
 
        if (steering & DT::fill) tOut->Fill();
    }
 
    cout << "Saving MET variables before and after the MET fraction cut" << endl;
    auto dMETcut = fOut->mkdir("METfraction");
    beforeCut.Write(dMETcut);
    afterCut.Write(dMETcut);
 
    cout << "Saving control observables before and after the MET fraction cut and/or MET filters" << endl;
    auto dCP = fOut->mkdir("controlplots");
    METbefore.Write(dCP);
    METafterMETfraction.Write(dCP);
    METafterAllMETfilters.Write(dCP);
    METafterAllMETfiltersAndMETfraction.Write(dCP);
 
    cout << "Saving control observables for each MET filter individually" << endl;
    auto dMETfilters = fOut->mkdir("METfilters");
    for (auto& filt: METfilters)
        filt.Write(dMETfilters);
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " end" << endl;
}