DAS::MissingET Namespace Reference

Classes
struct	Filters
struct	FractionCut

Functions
void	applyMETfilters (const vector< fs::path > &inputs, const fs::path &output, 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 int	steering,
		const DT::Slice	slice = {1,0}
	)

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

Parameters

inputs	input ROOT file (n-tuple)
output	output ROOT file (n-tuple)
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);
    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");
 
    metainfo.Set<bool>("corrections", "METfilters", true);
    MissingET::Filters metfilters(year);
 
    /**** 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 (TString METname: metfilters.METnames)
        METfilters.push_back(ControlPlots(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));
        }
 
        for (size_t ibit = 0; ibit < metfilters.METbitsToApply.size(); ++ibit) {
            bool bit = met->Bit.at(ibit);
            if (!bit) continue;
            METfilters.at(ibit)(*recJets, totRecWgt(0));
        }
 
        // IMPORTANT NOTE:
        // in case the MET fraction based cut would be used,
        // the description of the MET class should be changed!!
 
        metfilters(met, rEv);
 
        METafterAllMETfilters(*recJets, totRecWgt(0));
 
        if (met->Et < 0.3 * met->SumEt)
            METafterAllMETfiltersAndMETfraction(*recJets, totRecWgt(0));
 
        if (steering & DT::fill) tOut->Fill();
    }
 
    beforeCut.Write(fOut);
    afterCut.Write(fOut);
    METbefore.Write(fOut);
    METafterMETfraction.Write(fOut);
    METafterAllMETfilters.Write(fOut);
    METafterAllMETfiltersAndMETfraction.Write(fOut);
 
    for (auto& filt: METfilters)
        filt.Write(fOut);
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " end" << endl;
}