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
double	Ht () const
float	SpT () const
float	Sphi () const

Public Attributes
std::vector< Jet >	jets
Di< const Jet, const Jet >	dijet

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){
            dijet = jets.at(0) + jets.at(1);
        }
    }

Member Function Documentation

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;
    }

Ht()

double Ht ( ) const

inline

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

jetswgt()

double jetswgt ( ) const

inline

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

operator bool()

operator bool ( ) const

inlineexplicit

                                   {
        return jets.size() > 1;
    }

Sphi()

float Sphi ( ) const

inline

expected phi balance correlation sensitive observable $S_{\phi, TPS}^{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. This can only be observed in events with 6 jets.

    {
        using namespace std;
        if (jets.size() < 6)
            BOOST_THROW_EXCEPTION( invalid_argument("insufficient jetMultiplicity for Sphi calculation") );
 
        float sumS = 0.0f;
        for (const auto& triple : jetCombinations) {
            float S2 = 0.0f;
            for (auto& pr : triple) {
                FourVector jet1 = jets[pr.first ].CorrP4();
                FourVector jet2 = jets[pr.second].CorrP4();
                S2 += pow(DeltaPhi(jet1, jet2), 2);
            }
            sumS += sqrt(S2 / 3.0f);
        }
        return sumS / static_cast<float>(jetCombinations.size());
    }

SpT()

float SpT ( ) const

inline

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. This can only be observed in events with 6 jets.

    {
        using namespace std;
        if (jets.size() < 6)
            BOOST_THROW_EXCEPTION( invalid_argument("insufficient jetMultiplicity for SpT calculation") );
        
        float sumS = 0.0f;
        for (const auto& triple : jetCombinations) {
            float S2 = 0.0f;
            // triple.size() == 3, each triple[i] is a pair<int,int>
            for (auto& pr : triple) {
                FourVector jet1 = jets[pr.first ].CorrP4();
                FourVector jet2 = jets[pr.second].CorrP4();
                ROOT::Math::XYVector pTsum(jet1.Px() + jet2.Px(), jet1.Py() + jet2.Py());
                S2 += pow( pTsum.R() / (jets[pr.first].CorrPt() + jets[pr.second].CorrPt()), 2 );
            }
            sumS += sqrt(S2 / 3.0f);
        }
        return sumS / static_cast<float>(jetCombinations.size());
    }

Member Data Documentation

dijet

Di<const Jet, const Jet> dijet

jetCombinations

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

private

jets

std::vector<Jet> jets

---

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

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