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;
 
    unique_ptr<TChain> tIn = DT::GetChain(inputs);
    unique_ptr<TFile> fOut(DT_GetOutput(output));
    auto tOut = unique_ptr<TTree>(tIn->CloneTree(0));
 
    DT::MetaInfo metainfo(tOut);
    auto isMC = metainfo.Get<bool>("flags", "isMC");
    auto year = metainfo.Get<int>("flags", "year");
 
    MET * met = nullptr;
    RecEvent * recEvt = nullptr;
    GenEvent * genEvt = nullptr;
    vector<RecJet> * recJets = nullptr;
    tIn->SetBranchAddress("recEvent", &recEvt);
    if (isMC)
        tIn->SetBranchAddress("genEvent", &genEvt);
    tIn->SetBranchAddress("met", &met);
    tIn->SetBranchAddress("recJets", &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 ? genEvt->weights.front().v : 1) * recEvt->weights.at(i).v;
    };
 
    for (DT::Looper looper(tIn, slice); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = (steering & DT::verbose) == 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, recEvt);
 
        METafterAllMETfilters(*recJets, totRecWgt(0));
 
        if (met->Et < 0.3 * met->SumEt)
            METafterAllMETfiltersAndMETfraction(*recJets, totRecWgt(0));
 
        if ((steering & DT::fill) == DT::fill) tOut->Fill();
    }
 
    beforeCut.Write(fOut.get());
    afterCut.Write(fOut.get());
    METbefore.Write(fOut.get());
    METafterMETfraction.Write(fOut.get());
    METafterAllMETfilters.Write(fOut.get());
    METafterAllMETfiltersAndMETfraction.Write(fOut.get());
 
    for (auto& filt: METfilters)
        filt.Write(fOut.get());
 
    metainfo.Set<bool>("git", "complete", true);
    fOut->cd();
    tOut->Write();
 
    cout << __func__ << ' ' << slice << " end" << endl;
}