DAS::MN Namespace Reference

Classes
struct	Hist
struct	Obs2Jets
struct	ObsMiniJets

Functions
void	getMNobservables (const vector< fs::path > inputs, const fs::path output, const pt::ptree &config, const int steering, const DT::Slice slice={1, 0})
template<typename Jet >
std::optional< std::pair< Jet, Jet > >	GetMNJet (std::vector< Jet > jets, std::function< bool(Jet &)> ptcut=[](Jet &jet) {return jet.p4.Pt()< 35 ;})
template<typename Jet >
std::vector< Jet >	GetMiniJets (std::vector< Jet > jets, const std::pair< Jet, Jet > &MNJets, std::function< bool(Jet &)> ptcut=[](Jet &jet) {return jet.p4.Pt()< 20;})

Variables
static const double	minY = binsY.front()
static const double	maxY = binsY.back()
static const double	maxy = 4.7
static const double	minpt = 32
static const double	maxpt = 1.e10

Detailed Description

The namespace MN_Helper contains the classes that are needed by getMNobservables.cc to build the histograms. Two types of objects are present here: bs2Jets and ObsMiniJets that contains structures to store the observables themselves (they are higher level physics objects) and Hist that contains histograms.

Function Documentation

GetMiniJets()

std::vector< Jet > GetMiniJets	(	std::vector< Jet >	jets,
		const std::pair< Jet, Jet > &	MNJets,
		std::function< bool(Jet &)>	ptcut = [](Jet& jet) {return jet.p4.Pt()<20;}
	)

This function takes as an input a vector of jet, a pair of Mueller-Navelet jets in this event and a selection fuction. All the jet for which the selection function is false are dicarded. Remove all the jets that are at higher-or-equal rapidity than the first member of the pair (considered as the 'leading MN jet') or lower-or-equal rapidity than the second member of the pair (considered a the 'subleading MN jet'). The function is build assuming that the two Mueller-Navelet jets that are provided are also present in the vector of jets of the event. The two Mueller-Navelet jets are removed by the lower-or-equal / higher-or-equal logic of the sample.

Note

there is no consistency check. So if the two MNJets that are given are not present in the vector of jets, it will not throw any error.

if the paire provided is trivial, it will not throw any error. The non-triviallity must be check before hand.

As this function is a template function, it is declared and defined in the common.h. Definitions of template functions are not compiled until they are instantiated with a specific type instance.

Todo:

check the consistency of this condition

Todo:

check the consistency of this condition

{
    jets.erase(std::remove_if(jets.begin(), jets.end(), ptcut), jets.end());
    jets.erase(std::remove_if(jets.begin(), jets.end(),
               [MNJets](Jet& jet){return jet.p4.Eta() >= MNJets.first.p4.Eta();}), jets.end());
 
    jets.erase(std::remove_if(jets.begin(), jets.end(),
               [MNJets](Jet& jet){return jet.p4.Eta() <= MNJets.second.p4.Eta();}), jets.end());
 
    std::sort( jets.begin(), jets.end() , [](Jet& j1, Jet& j2)
            {return j1.p4.Eta() > j2.p4.Eta();} );  
 
    return jets;
}

GetMNJet()

std::optional< std::pair< Jet, Jet > > GetMNJet	(	std::vector< Jet >	jets,
		std::function< bool(Jet &)>	ptcut = [](Jet& jet) {return jet.p4.Pt() < 35 ;}
	)

This function takes as an input a vector of jet and a function<bool(Jet&)>. It finds the two jets that are th most bakward and most forward in the event and satisfies the cut implemented in the function<bool(Jet&)> provided as argument. This function is apllied to all the jets. If it return false, the jets are discarded. The out is an optional. So that if there are no jets satifying the cuts in the event, it returns nullopt.

Note

As this function is a template function, it is declared and defined in the common.h. Definitions of template functions are not compiled until they are instantiated with a specific type instance.

Todo:

check the consistency of this condition

Todo:

check the consistency of this condition

{
    jets.erase(remove_if(jets.begin(), jets.end(), ptcut), jets.end());
    if (jets.size() < 2) return std::nullopt;
    auto result = minmax_element( jets.begin(), jets.end() , [](Jet& j1, Jet& j2)
            {return j1.p4.Eta() > j2.p4.Eta();} );  
 
    if (result.first->p4.Eta() <= 0 || result.second->p4.Eta() >= 0) return std::nullopt;
    return std::make_optional<std::pair<Jet,Jet>>(*result.first, *result.second);
}

getMNobservables()

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

Calculate the observables that can be used to caracterise Mueller-Navelet Jets.

Parameters

inputs	input ROOT files (n-tuples)
output	name of output root file containing the histograms
config	config file from `DTOptions`
steering	steering parameters from `DTOptions`
slice	slices for running

                                   {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);
    metainfo.Check(config);
    auto isMC = metainfo.Get<bool>("flags", "isMC");
 
    auto gEv = flow.GetBranchReadOnly<GenEvent>("genEvent");
    auto rEv = flow.GetBranchReadOnly<RecEvent>("recEvent");
 
    auto recJets = flow.GetBranchReadOnly<vector<RecJet>>("recJets");
    auto genJets = isMC ? flow.GetBranchReadOnly<vector<GenJet>>("genJets") : nullptr;
 
    Hist genHist("gen"), // NOTE: one should only declare the object if (isMC)
         recHist("rec");
 
    for (DT::Looper looper(tIn); looper(); ++looper) {
        [[ maybe_unused ]]
        static auto& cout = (steering & DT::verbose) == DT::verbose ? ::cout : DT::dev_null;
 
        auto MNJets = GetMNJet<RecJet>(*recJets, [](RecJet jet){return jet.CorrPt() < 35;});
        if (MNJets) {
            double recy = std::abs( MNJets->first.p4.Eta() - MNJets->second.p4.Eta() );
            bool LowRecY  = recy < minY,
                 HighRecY  =  recy >= maxY;
            bool goodRec = (!LowRecY) && (!HighRecY)
                && MNJets->first.p4.Eta() < maxy && MNJets->second.p4.Eta() < maxy
                && minpt < MNJets->first.CorrPt() && MNJets->first.CorrPt() < maxpt
                && minpt < MNJets->second.CorrPt() && MNJets->second.CorrPt() < maxpt;
 
            if (goodRec) {
                double evweight = rEv->weights.front();
                if (isMC) evweight *= gEv->weights.front();
                recHist.Fill(*recJets, evweight);
                Obs2Jets obs2jets(MNJets->first, MNJets->second);
                auto minijets = GetMiniJets(*recJets, *MNJets, function<bool(RecJet&)>([](RecJet& jet){return jet.CorrPt() < 20;}));
                ObsMiniJets obsminijets(minijets);
                recHist.Fill(obs2jets, obsminijets, evweight);
            }
        }
 
        if (!isMC) continue;
 
        auto genMNJets = GetMNJet<GenJet>(*genJets, [](GenJet jet){return jet.p4.Pt() < 35;});
        if (genMNJets) {
            double genY = std::abs( genMNJets->first.p4.Eta() - genMNJets->second.p4.Eta() );
            bool LowGenY  = genY < minY,
                 HighGenY = genY >= maxY,
                 goodGen = (!LowGenY) && (!HighGenY)
                     && genMNJets->first.p4.Eta() < maxy && genMNJets->second.p4.Eta() < maxy
                     && minpt < genMNJets->first.p4.Pt() && genMNJets->first.p4.Pt() < maxpt
                     && minpt < genMNJets->second.p4.Pt() && genMNJets->second.p4.Pt() < maxpt;
 
            if (goodGen) {
                double evweight = gEv->weights.front();
                genHist.Fill(*genJets, evweight);
                Obs2Jets obs2jets(genMNJets->first, genMNJets->second);
                auto minijets = GetMiniJets(*genJets, *genMNJets, function<bool(GenJet&)>([](GenJet& jet){return jet.p4.Pt() < 20;}));
                ObsMiniJets obsminijets(minijets);
                genHist.Fill(obs2jets, obsminijets, evweight);
            }
        }
    }
 
    recHist.Write(fOut);
    if (isMC)
        genHist.Write(fOut);
 
    metainfo.Set<bool>("git", "complete", true);
 
    cout << __func__ << ' ' << slice << " end" << endl;
}

Variable Documentation

maxpt

const double maxpt = 1.e10

static

maxY

const double maxY = binsY.back()

static

maxy

const double maxy = 4.7

static

minpt

const double minpt = 32

static

minY

const double minY = binsY.front()

static