DAS::Muons Namespace Reference

Functions
template<class Muon >
bool	keepEvent (const vector< Muon > &muons, float pt1, float pt2)
void	applyDimuonSkim (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})

Function Documentation

applyDimuonSkim()

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

Skims the input tree to keep only events with at least two muons, with configurable pT thresholds.

Parameters

inputs	input ROOT files (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);
    auto tIn = flow.GetInputTree(inputs, slice);
    auto [fOut, tOut] = flow.GetOutput(output);
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
    const bool isMC = metainfo.Get<bool>("flags", "isMC");
 
    const auto pt1 = config.get<float>("skims.dimuon.pt1");
    metainfo.Set<float>("skims", "dimuon", "pt1", pt1);
 
    const auto pt2 = config.get<float>("skims.dimuon.pt2");
    metainfo.Set<float>("skims", "dimuon", "pt2", pt2);
 
    cout << "Skimming events: pt(mu1) > " << pt1 << "\t pt(mu2) > " << pt2 << endl;
 
    // event information
    auto genEvt = flow.GetBranchReadOnly<GenEvent>("genEvent", DT::facultative);
 
    auto recMuons = flow.GetBranchReadOnly<vector<RecMuon>>("recMuons", DT::facultative);
    RecDimuon * recDimuon = nullptr;
    if (recMuons != nullptr)
        recDimuon = flow.GetBranchWriteOnly<RecDimuon>("recDimuon");
 
    auto genMuons = flow.GetBranchReadOnly<vector<GenMuon>>("genMuons", DT::facultative);
    GenDimuon * genDimuon = nullptr;
    if (genMuons != nullptr)
        genDimuon = flow.GetBranchWriteOnly<GenDimuon>("genDimuon");
 
    if (!recMuons && !genMuons)
        BOOST_THROW_EXCEPTION( DE::BadInput("No muons in input tree", tIn) );
 
    // histogram used in MC for normalisation
    TH1 * hSumWgt = nullptr;
    if (isMC) hSumWgt = new TH1F("hSumWgt",";;#sum_{i} w_{i}", 1, -0.5, 0.5);
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = steering & DT::verbose ? ::cout : DT::dev_null;
 
        bool passesRec = true, passesGen = true;
 
        if (recMuons) {
            passesRec = keepEvent(*recMuons, pt1, pt2);
            if (passesRec) *recDimuon = recMuons->at(0) + recMuons->at(1);
            else            recDimuon->clear();
        }
        if (genMuons) {
            passesGen = keepEvent(*genMuons, pt1, pt2);
            if (passesGen) *genDimuon = genMuons->at(0) + genMuons->at(1);
            else            genDimuon->clear();
        }
 
        if ((steering & DT::fill) && (passesRec || passesGen)) tOut->Fill();
 
        if (!isMC) continue;
        auto w = genEvt->weights.front();
        hSumWgt->Fill(0.0, w);
    }
 
    metainfo.Set<bool>("git", "complete", true);
    fOut->cd();
    if (hSumWgt) hSumWgt->Write();
 
    cout << __func__ << ' ' << slice << " stop" << endl;
}

keepEvent()

bool DAS::Muons::keepEvent	(	const vector< Muon > &	muons,
		float	pt1,
		float	pt2
	)

Checks whether an event should be kept.

{
    return muons.size() >= 2 && muons[0].p4.Pt() > pt1 && muons[1].p4.Pt() > pt2;
}