MultiJets< Jet >

Description

template<class Jet>
struct DAS::TPS::MultiJets< Jet >

Implements TPS jets observables depending on the mixed 6jets event. Definition of these observables:

• $p_{T,ave} = \frac{1}{N_{jets}} \sum_{i=1}^{N_{jets}} p_{T,i}$
• $H_{T} = \sum_{i=1}^{N_{jets}} p_{T,i}$
• $\Delta \eta$ is the absolute value of the pseudorapidity distance between the two leading jets
• $\Delta \phi$ is the azimuthal distance between the two leading jets
• $E_{F} = \frac{p_{T,1}}{H_{T}}$ is the energy fraction of the leading jet
• $S_{p_{T}}$ and $S_{\phi}$ are the expected pT balance and phi balance correlation sensitive observables that can only be observed in events with 6 jets. ref: https://arxiv.org/abs/2111.05370

#include <TPS.h>

Collaboration diagram for MultiJets< Jet >:

Public Member Functions
	MultiJets (const std::vector< Jet > &inputJets, int minpt)
	operator bool () const
double	jetswgt () const
float	Ht () const

Public Attributes
std::vector< Jet >	jets
Di< const Jet, const Jet >	leading_dijet
std::array< std::array< float, 6 >, 6 >	pt_pair_asymm_vec
std::array< std::array< float, 6 >, 6 >	pt_pair_asymm_abs
std::array< std::array< float, 6 >, 6 >	Delta_eta_pair
std::array< std::array< float, 6 >, 6 >	Delta_phi_pair
std::array< std::array< float, 6 >, 6 >	m_inv
float	S_pt = 0
float	S_pt_min = 0
std::array< float, 15 >	S_pt_perm {}
std::array< float, 3 >	S_pt_4 {}
std::array< float, 3 >	S_pt_4_min {}
std::array< std::array< float, 3 >, 3 >	S_pt_4_perm
float	S_phi = 0
float	S_phi_min = 0
std::array< float, 15 >	S_phi_perm {}
std::array< float, 3 >	S_phi_4 {}
std::array< float, 3 >	S_phi_4_min {}
std::array< std::array< float, 3 >, 3 >	S_phi_4_perm

Private Member Functions
void	FillFeatures ()
void	LoopOverPairs ()
void	LoopOverTriplets ()
void	LoopOverQuartets ()
std::array< std::pair< std::pair< int, int >, std::pair< int, int > >, 3 >	GetJetQuadPartitions (const std::array< int, 4 > &index)

Static Private Member Functions
static const std::vector< std::vector< std::pair< int, int > > > &	getJetPairings ()

Private Attributes
const std::vector< std::vector< std::pair< int, int > > > &	jetCombinations = getJetPairings()

Constructor & Destructor Documentation

MultiJets()

MultiJets ( const std::vector< Jet > &  inputJets, int  minpt  )

inline

                                                         :
    jets(PhaseSpaceSelection(inputJets, minpt))
    {
        if (jets.size() > 1){
            leading_dijet = make_di(jets.at(0), jets.at(1));
        }
        if (jets.size() >= 6) FillFeatures();
    }

Member Function Documentation

FillFeatures()

void FillFeatures ( )

inlineprivate

Fill 6jet's member variables by calling the appropriate loop methods.

                        {
        LoopOverPairs();
        LoopOverTriplets();
        LoopOverQuartets();
    }

getJetPairings()

static const std::vector<std::vector<std::pair<int, int> > >& getJetPairings ( )

inlinestaticprivate

                                                                           {
        static const auto jetPairs = []() {
            std::vector<int> elements{0, 1, 2, 3, 4, 5};
            std::vector<std::pair<int, int>> current;
            std::vector<std::vector<std::pair<int, int>>> results;
 
            // Helper function that recursively generates all ways to partition 'elements' 
            // into pairs. Each unique partition is pushed into 'allPairs' as a list of
            // (a,b) pairs, stored in current recursion via 'current'.
            auto pairJetsIndices = [](const std::vector<int>& elements,
                                      std::vector<std::pair<int, int>>& current,
                                      std::vector<std::vector<std::pair<int, int>>>& results,
                                      auto&& self) -> void {
                // If no elements remain, we've formed all pairs for this arrangement
                if (elements.empty()) {
                    results.push_back(current);
                    return;
                }
                // Take the first element
                int first = elements.front();
                // Remaining elements
                std::vector<int> rest(elements.begin() + 1, elements.end());
 
                // Try pairing 'first' with each of the others
                for (size_t i = 0; i < rest.size(); ++i) {
                    int partner = rest[i];
                    // Add this pair to 'current'
                    current.emplace_back(first, partner);
 
                    // Build the list for the next recursion by removing 'partner'
                    std::vector<int> next;
                    next.reserve(rest.size() - 1);
                    for (size_t j = 0; j < rest.size(); ++j) {
                        if (j != i)
                            next.push_back(rest[j]);
                    }
 
                    // Recurse with the remaining elements
                    self(next, current, results, self);
                    current.pop_back();
                }
            };
            // Start the recursion
            pairJetsIndices(elements, current, results, pairJetsIndices);
            return results;
        }();
        return jetPairs;
    }

GetJetQuadPartitions()

std::array<std::pair<std::pair<int, int>, std::pair<int, int> >, 3> GetJetQuadPartitions ( const std::array< int, 4 > &  index )

inlineprivate

                                                        {
        return {{
            {{index[0], index[1]}, {index[2], index[3]}},
            {{index[0], index[2]}, {index[1], index[3]}},
            {{index[0], index[3]}, {index[1], index[2]}}
        }};
    }

Ht()

float Ht ( ) const

inline

    {
        return accumulate(jets.begin(), jets.end(), 0.0,
            [](float sum, const auto& jet) {
                return sum + jet.CorrPt();
            });
    }

jetswgt()

double jetswgt ( ) const

inline

                           { 
        return accumulate(jets.begin(), jets.end(), 1.0, 
        [] (float w, const Jet& j) {
            return w * j.weights.front(); 
        }); 
    }

LoopOverPairs()

void LoopOverPairs ( )

inlineprivate

Loops over all pairs of jets and computes the pairwise features.

                         {
        for (size_t i = 0; i < 6; ++i) {
            for (size_t j = 0; j < 6; ++j) {
                pt_pair_asymm_abs[i][j] = abs(jets[i].CorrPt() - jets[j].CorrPt()) / (jets[i].CorrPt() + jets[j].CorrPt());
                auto dijet = make_di(jets[i], jets[j]);
                pt_pair_asymm_vec[i][j] = dijet.CorrPt() / (jets[i].CorrPt() + jets[j].CorrPt());
                Delta_eta_pair[i][j] = dijet.DeltaEta();
                Delta_phi_pair[i][j] = dijet.DeltaPhi();
                m_inv[i][j] = dijet.CorrP4().M();
            }
        }
    }

LoopOverQuartets()

void LoopOverQuartets ( )

inlineprivate

Loops over all quartets of jets and computes the quartet-based balance observables.

                            {
        std::array<std::array<int,4>, 3> group4 = {{
            {{0, 1, 2, 3}},
            {{0, 1, 4, 5}},
            {{2, 3, 4, 5}}
        }};
        for (size_t j = 0; j < group4.size(); ++j) {
            auto partitions = GetJetQuadPartitions(group4[j]);
            for (size_t i = 0; i < partitions.size(); ++i) {
                auto [p1, p2] = partitions[i];
                auto dijet1 = make_di(jets[p1.first], jets[p1.second]);
                auto dijet2 = make_di(jets[p2.first], jets[p2.second]);
                float a = dijet1.CorrPt() / (jets[p1.first].CorrPt() + jets[p1.second].CorrPt());
                float b = dijet2.CorrPt() / (jets[p2.first].CorrPt() + jets[p2.second].CorrPt());
                S_pt_4_perm[j][i]  = std::sqrt(0.5 * (pow(a, 2) + pow(b, 2)));
                S_phi_4_perm[j][i] = std::sqrt(0.5 * (pow(dijet1.DeltaPhi(), 2) + pow(dijet2.DeltaPhi(), 2)));
            }
            S_pt_4[j] = std::accumulate(S_pt_4_perm[j].begin(), S_pt_4_perm[j].end(), 0.0) / static_cast<float>(S_pt_4_perm[j].size());
            S_phi_4[j] = std::accumulate(S_phi_4_perm[j].begin(), S_phi_4_perm[j].end(), 0.0) / static_cast<float>(S_phi_4_perm[j].size());
            S_pt_4_min[j] = *std::min_element(S_pt_4_perm[j].begin(), S_pt_4_perm[j].end());
            S_phi_4_min[j] = *std::min_element(S_phi_4_perm[j].begin(), S_phi_4_perm[j].end());
        }
        
    }

LoopOverTriplets()

void LoopOverTriplets ( )

inlineprivate

Loops over all triplets of jets and computes the triplet-based balance observables.

                            {
        int i = 0;
        for (const auto& triple : jetCombinations) {
            for (auto& pr : triple) {
                auto dijet = make_di(jets[pr.first], jets[pr.second]);
                S_phi_perm[i] += pow(dijet.DeltaPhi(), 2);
                S_pt_perm[i]  += pow(dijet.CorrPt() / (jets[pr.first].CorrPt() + jets[pr.second].CorrPt()), 2);
            }
            S_phi_perm[i] = sqrt(S_phi_perm[i] / 3.0);
            S_pt_perm[i]  = sqrt(S_pt_perm[i]  / 3.0);
            i++;
        }
        S_phi = std::accumulate(S_phi_perm.begin(), S_phi_perm.end(), 0.0) / static_cast<float>(S_phi_perm.size());
        S_pt  = std::accumulate(S_pt_perm.begin(),  S_pt_perm.end(), 0.0)  / static_cast<float>(S_pt_perm.size());
        S_phi_min = *std::min_element(S_phi_perm.begin(), S_phi_perm.end());
        S_pt_min  = *std::min_element( S_pt_perm.begin(),  S_pt_perm.end());
    }

operator bool()

operator bool ( ) const

inlineexplicit

                                   {
        return jets.size() > 1;
    }

Member Data Documentation

Delta_eta_pair

std::array<std::array<float, 6>, 6> Delta_eta_pair

$\Delta \eta_{pair} = \eta_{i}-\eta_{j}$

Delta_phi_pair

std::array<std::array<float, 6>, 6> Delta_phi_pair

$\Delta \phi_{pair} = \phi_{i}-\phi_{j}$

jetCombinations

const std::vector<std::vector<std::pair<int, int> > >& jetCombinations = getJetPairings()

private

jets

std::vector<Jet> jets

leading_dijet

Di<const Jet, const Jet> leading_dijet

m_inv

std::array<std::array<float, 6>, 6> m_inv

$m_{inv} = M_{i} + M_{j}$

pt_pair_asymm_abs

std::array<std::array<float, 6>, 6> pt_pair_asymm_abs

$p_{T,asymm,abs} = \frac{|\vec{p}_{T, i}|-|\vec{p}_{T, j}|}{|\vec{p}_{T, i}|+|\vec{p}_{T, j}|}$

pt_pair_asymm_vec

std::array<std::array<float, 6>, 6> pt_pair_asymm_vec

$p_{T,asymm,vec} = \frac{|\vec{p}_{T, i}+\vec{p}_{T, j}|}{|\vec{p}_{T, i}|+|\vec{p}_{T, j}|}$

S_phi

float S_phi = 0

expected phi balance correlation sensitive observable $S_{\phi}^{2} = \frac{1}{3}[|\phi_{i}-\phi_{j}|^{2} +|\phi_{k}-\phi_{l}|^{2} +|\phi_{m}-\phi_{n}|^{2}]$ for all the possible Combinations of jets. This variable has a 15-fold degeneracy, and the final value is taken as the average.

S_phi_4

std::array<float, 3> S_phi_4 {}

4-jet phi balance observables for three different jet quartets: {0,1,2,3}, {0,1,4,5}, {2,3,4,5} Each element is the average over 3 possible dijet pairings within the quartet $S_{\phi,4}^{2} = \frac{1}{2}[|\phi_{i}-\phi_{j}|^{2}

• |\phi_{k}-\phi_{l}|^{2}]$

S_phi_4_min

std::array<float, 3> S_phi_4_min {}

S_phi_4_perm

std::array<std::array<float, 3>, 3> S_phi_4_perm

Detailed phi balance values for all possible pairings within each 4-jet quartet.

S_phi_min

float S_phi_min = 0

S_phi_perm

std::array<float, 15> S_phi_perm {}

S_pt

float S_pt = 0

expected pT balance correlation sensitive observable $S_{p_{T, TPS}}^{2} = \frac{1}{3}[(\frac{|\vec{p}_{T, i}+\vec{p}_{T, j}|}{|\vec{p}_{T, i}|+|\vec{p}_{T, j}|})^{2} +(\frac{|\vec{p}_{T, k}+\vec{p}_{T, l}|}{|\vec{p}_{T, k}|+|\vec{p}_{T, l}|})^{2} +(\frac{|\vec{p}_{T, m}+\vec{p}_{T, n}|}{|\vec{p}_{T, m}|+|\vec{p}_{T, n}|})^{2}]$ for all the possible Combinations of jets. This variable has a 15-fold degeneracy, and the final value is taken as the average.

S_pt_4

std::array<float, 3> S_pt_4 {}

4-jet pT balance observables for three different jet quartets: {0,1,2,3}, {0,1,4,5}, {2,3,4,5} Each element is the average over 3 possible dijet pairings within the quartet $S_{p_{T,4}}^{2} = \frac{1}{2}[(\frac{|\vec{p}_{T, i}+\vec{p}_{T, j}|}{|\vec{p}_{T, i}|+|\vec{p}_{T, j}|})^{2}

• (\frac{|\vec{p}_{T, k}+\vec{p}_{T, l}|}{|\vec{p}_{T, k}|+|\vec{p}_{T, l}|})^{2}]$

S_pt_4_min

std::array<float, 3> S_pt_4_min {}

S_pt_4_perm

std::array<std::array<float, 3>, 3> S_pt_4_perm

Detailed pT balance values for all possible pairings within each 4-jet quartet.

S_pt_min

float S_pt_min = 0

S_pt_perm

std::array<float, 15> S_pt_perm {}

---

The documentation for this struct was generated from the following file:

• /builds/cms-analysis/general/DasAnalysisSystem/Core/Installer/Core/JetObservables/interface/TPS.h