DAS::Jets Namespace Reference

Functions
template<class Jet >
bool	keepEvent (const vector< Jet > &jets, float pt1, float pt2)
void	applyDijetSkim (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
template<class Jet , class Dimuon >
bool	keepEvent (const vector< Jet > &jets, const Dimuon &dimuon, float zpt, float jpt)
void	applyZJetSkim (const vector< fs::path > &inputs, const fs::path &output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})

Function Documentation

applyDijetSkim()

void DAS::Jets::applyDijetSkim	(	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 jets, with configurable pT thresholds.

Parameters

inputs	input ROOT files (n-tuples)
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 tOut = flow.GetOutputTree(output);
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
 
    const auto pt1 = config.get<float>("skims.dijet.pt1");
    metainfo.Set<float>("skims", "dijet", "pt1", pt1);
 
    const auto pt2 = config.get<float>("skims.dijet.pt2");
    metainfo.Set<float>("skims", "dijet", "pt2", pt2);
 
    cout << "Skimming events: pt(jet1) > " << pt1 << "\t pt(jet2) > " << pt2 << endl;
 
    auto recJets = flow.GetBranchReadOnly<vector<RecJet>>("recJets", DT::facultative);
    RecDijet * recDijet = nullptr;
    if (recJets != nullptr)
        recDijet = flow.GetBranchWriteOnly<RecDijet>("recDijet");
 
    auto genJets = flow.GetBranchReadOnly<vector<GenJet>>("genJets", DT::facultative);
    GenDijet * genDijet = nullptr;
    if (genJets != nullptr)
        genDijet = flow.GetBranchWriteOnly<GenDijet>("genDijet");
 
    if (!recJets && !genJets)
        BOOST_THROW_EXCEPTION( DE::BadInput("No jets in input tree", tIn) );
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = (steering & DT::verbose) == DT::verbose ? ::cout : DT::dev_null;
 
        bool passesRec = true, passesGen = true;
 
        if (recJets) {
            passesRec = keepEvent(*recJets, pt1, pt2);
            if (passesRec) *recDijet = recJets->at(0) + recJets->at(1);
            else            recDijet->clear();
        }
        if (genJets) {
            passesGen = keepEvent(*genJets, pt1, pt2);
            if (passesGen) *genDijet = genJets->at(0) + genJets->at(1);
            else            genDijet->clear();
        }
 
        if ((steering & DT::fill) && (passesRec || passesGen)) tOut->Fill();
    }
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " stop" << endl;
}

applyZJetSkim()

void DAS::Jets::applyZJetSkim	(	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 jets, with configurable pT thresholds.

Parameters

inputs	input ROOT files (n-tuples)
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 tOut = flow.GetOutputTree(output);
 
    DT::MetaInfo metainfo(tOut);
    metainfo.Check(config);
 
    const auto zpt = config.get<float>("skims.ZJet.zpt");
    metainfo.Set<float>("skims", "ZJet", "zpt", zpt);
 
    const auto jpt = config.get<float>("skims.ZJet.jpt");
    metainfo.Set<float>("skims", "ZJet", "jpt", jpt);
 
    cout << "Skimming events: pt(Z) > " << zpt << "\t pt(jet) > " << jpt << endl;
 
    auto recJets = flow.GetBranchReadOnly<vector<RecJet>>("recJets", DT::facultative);
    auto genJets = flow.GetBranchReadOnly<vector<GenJet>>("genJets", DT::facultative);
    if (!recJets && !genJets)
        BOOST_THROW_EXCEPTION( DE::BadInput("No jets in input tree", tIn) );
 
    auto recDimuon = flow.GetBranchReadOnly<RecDimuon>("recDimuon", DT::facultative);
    auto genDimuon = flow.GetBranchReadOnly<GenDimuon>("genDimuon", DT::facultative);
    if (!recDimuon && !genDimuon)
        BOOST_THROW_EXCEPTION( DE::BadInput("No dimuon in input tree", tIn) );
 
    RecZJet * recZJet = nullptr;
    if (recJets && recDimuon)
        recZJet = flow.GetBranchWriteOnly<RecZJet>("recZJet");
    GenZJet * genZJet = nullptr;
    if (genJets && genDimuon)
        genZJet = flow.GetBranchWriteOnly<GenZJet>("genZJet");
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = (steering & DT::verbose) == DT::verbose ? ::cout : DT::dev_null;
 
        bool passesRec = true, passesGen = true;
 
        if (recJets) {
            passesRec = keepEvent(*recJets, *recDimuon, zpt, jpt);
            if (passesRec) *recZJet = *recDimuon + recJets->at(0);
            else            recZJet->clear();
        }
        if (genJets) {
            passesGen = keepEvent(*genJets, *genDimuon, zpt, jpt);
            if (passesGen) *genZJet = *genDimuon + genJets->at(0);
            else            genZJet->clear();
        }
 
        if ((steering & DT::fill) && (passesRec || passesGen)) tOut->Fill();
    }
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " stop" << endl;
}

keepEvent() [1/2]

bool DAS::Jets::keepEvent	(	const vector< Jet > &	jets,
		const Dimuon &	dimuon,
		float	zpt,
		float	jpt
	)

Checks whether an event should be kept.

{
    return jets.size() >= 2 && jets[0].p4.Pt() > jpt &&
            dimuon && dimuon.CorrP4().Pt() > zpt;
}

keepEvent() [2/2]

bool DAS::Jets::keepEvent	(	const vector< Jet > &	jets,
		float	pt1,
		float	pt2
	)

Checks whether an event should be kept.

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