JetIRCSafeLabelTool.cxx File Reference

#include "ParticleJetTools/JetIRCSafeLabelTool.h"
#include "ParticleJetTools/ParticleJetLabelCommon.h"
#include "xAODJet/Jet.h"
#include "xAODJet/JetContainer.h"
#include "xAODJet/JetAuxContainer.h"
#include "xAODTruth/TruthParticle.h"
#include "xAODTruth/TruthParticleContainer.h"
#include "xAODTruth/TruthParticleAuxContainer.h"
#include "AsgDataHandles/ReadHandle.h"
#include "AsgMessaging/Check.h"
#include "AsgTools/ToolHandle.h"
#include "fastjet/ClusterSequence.hh"
#include "fastjet/PseudoJet.hh"
#include "fastjet/JetDefinition.hh"
#include "fastjet/contrib/FlavInfo.hh"
#include "fastjet/contrib/IFNPlugin.hh"
#include "fastjet/contrib/CMPPlugin.hh"
#include "fastjet/contrib/GHSAlgo.hh"
#include "fastjet/contrib/SDFPlugin.hh"
#include <iostream>
#include <fstream>
#include <numbers>
#include <array>
#include <algorithm>
#include <cctype>
#include <unordered_set>
#include <cmath>

Go to the source code of this file.

Functions
static std::string	toLower (const std::string &s)
template<size_t N>
constexpr std::array< int, N >	negateID (const std::array< int, N > &in)
template<typename Container>
bool	hit (const Container &ids, int pdgId)
template<typename PluginT, typename... Args>
std::unique_ptr< fastjet::JetDefinition >	makeJetDefWithPlugin (Args &&... args)
static void	extractTaggedJets (const std::vector< fastjet::PseudoJet > &pseudojets, std::vector< fastjet::PseudoJet > &btagged, std::vector< fastjet::PseudoJet > &ctagged)
FlavInfo	HeavyFlavourContent (int pdgId)
void	setJetIRCSafeLabels (const xAOD::Jet &jet, const ParticleJetTools::Tag_PseudoJets &tag_pjets, const ParticleJetTools::IRCSafeLabelDecorators &decs, bool doIFN, bool doCMP, bool doGHS, bool doSDF, bool doAKT)

Variables
static constexpr std::array< const char *, JetIRCSafeLabelTool::N_ALGOS >	ALGO_NAMES

Function Documentation

extractTaggedJets()

void extractTaggedJets ( const std::vector< fastjet::PseudoJet > & pseudojets, std::vector< fastjet::PseudoJet > & btagged, std::vector< fastjet::PseudoJet > & ctagged )

static

Definition at line 81 of file JetIRCSafeLabelTool.cxx.

                                                              {
    for (const auto& p : pseudojets) {
        if (p.user_info<fastjet::contrib::FlavHistory>().current_flavour()[5] != 0)
            btagged.push_back(p);
        if (p.user_info<fastjet::contrib::FlavHistory>().current_flavour()[4] != 0)
            ctagged.push_back(p);
    }
}

HeavyFlavourContent()

FlavInfo HeavyFlavourContent

(

int

pdgId

)

Definition at line 92 of file JetIRCSafeLabelTool.cxx.

                                        {
  // Simply using the default FlavInfo-from-pdg_code constructor doesn't seem
  // right as it gives way too many +c flavours. It might be because we remove the children
  // and we might be left with quite exotic D hadrons with pdg codes of length larger than 4
  // and that default constructor is unpredictable then.
 
  // I'm tired of trying to be clever about this. The lists below should contain all
  // hadrons containing a non-zero net b or c flavour, split into groups. The FlavInfo
  // is then decided by checking whether the pdgId belongs to one of these groups.
  // The codes are taken from https://pdg.lbl.gov/2007/reviews/montecarlorpp.pdf
 
  static constexpr std::array<int, 33> one_b_Ids = {
    // BOTTOM MESONS WITH NO C
    -511, -521, -10511, -10521, -513, -523, -10513, -10523, -20513, -20523,
    -515, -525, -531, -10531, -533, -10533, -20533, 
    -535,
    // BOTTOM BARYONS WITH NO C
    5122, 5112, 5212, 5222, 5114, 5214, 5224, 5132, 5232, 5312, 5322, 5314,
    5324, 5332, 5334
  };
  static constexpr std::array<int,33> one_antib_Ids = negateID(one_b_Ids);
  static constexpr std::array<int,6> one_b_one_antic_Ids = {
    // BOTTOM MESONS WITH ONE B ONE ANTIC
    -541, -10541, -543, -10543, -20543, -545
  };
  static constexpr std::array<int,6> one_antib_one_c_Ids = negateID(one_b_one_antic_Ids);
  static constexpr std::array<int,9> one_b_one_c_Ids = {
    // BOTTOM BARYONS WITH ONE B ONE C
    5142, 5242, 5412, 5422, 5414, 5424, 5342, 5432, 5434
  };
  static constexpr std::array<int,9> one_antib_one_antic_Ids = negateID(one_b_one_c_Ids);
  static constexpr std::array<int,2> one_b_two_cs_Ids = {
    // BOTTOM BARYONS WITH ONE B TWO CS
    5442, 5444
  };
  static constexpr std::array<int,2> one_antib_two_antics_Ids = negateID(one_b_two_cs_Ids);
  static constexpr std::array<int,6> two_bs_Ids = {
    // BOTTOM BARYONS WITH TWO BS AND NO C
    5512, 5522, 5514, 5524, 5532, 5534
  };
  static constexpr std::array<int,6> two_antibs_Ids = negateID(two_bs_Ids);
  static constexpr std::array<int,2> two_bs_one_c_Ids = {
    // BOTTOM BARYONS WITH TWO BS AND ONE C
    5542, 5544
  };
  static constexpr std::array<int,2> two_antibs_one_antic_Ids = negateID(two_bs_one_c_Ids); 
  static constexpr std::array<int,1> three_bs = {
    // BOTTOM BARYON WITH THREE BS (OMEGA-)
    5554
  };
  static constexpr std::array<int,1> three_antibs = negateID(three_bs);
 
  static constexpr std::array<int,33> one_c_Ids = {
    // CHARMED MESONS WITH NO B (all of them; if they have B they become bottom hadrons)
    411, 421, 10411, 10421, 413, 423, 10413, 10423, 20413, 20423,
    415, 425, 431, 10431, 433, 10433, 20433, 435,
    // CHARMED BARYONS WITH ONE C AND NO B (all of them)
    4122, 4222, 4212, 4112, 4224, 4214, 4114, 4232, 4132, 4322, 4312, 4324,
    4314, 4332, 4334
  };
  static constexpr std::array<int,33> one_antic_Ids = negateID(one_c_Ids);
  static constexpr std::array<int,6> two_c_Ids = {
    // CHARMED BARYONS WITH TWO Cs
    4412, 4422, 4414, 4424, 4432, 4434
  };
  static constexpr std::array<int,6> two_antic_Ids = negateID(two_c_Ids);
  static constexpr std::array<int,1> three_c_Ids = {
    4444
  };
  static constexpr std::array<int,1> three_antic_Ids = negateID(three_c_Ids);
  
 
  int nb = 0, nc = 0;
 
  // Check most specific categories first
  if      (hit(three_bs, pdgId))                      { nb =  3; }
  else if (hit(three_antibs, pdgId))                  { nb = -3; }
  else if (hit(two_bs_one_c_Ids, pdgId))              { nb =  2; nc =  1; }
  else if (hit(two_antibs_one_antic_Ids, pdgId))      { nb = -2; nc = -1; }
  else if (hit(two_bs_Ids, pdgId))                    { nb =  2; }
  else if (hit(two_antibs_Ids, pdgId))                { nb = -2; }
  else if (hit(one_b_two_cs_Ids, pdgId))              { nb =  1; nc =  2; }
  else if (hit(one_antib_two_antics_Ids, pdgId))      { nb = -1; nc = -2; }
  else if (hit(one_b_one_c_Ids, pdgId))               { nb =  1; nc =  1; }
  else if (hit(one_antib_one_antic_Ids, pdgId))       { nb = -1; nc = -1; }
  else if (hit(one_b_one_antic_Ids, pdgId))           { nb =  1; nc = -1; }
  else if (hit(one_antib_one_c_Ids, pdgId))           { nb = -1; nc =  1; }
  // Then check more general categories
  else if (hit(one_b_Ids, pdgId))                     { nb =  1; }
  else if (hit(one_antib_Ids, pdgId))                 { nb = -1; }
  else if (hit(three_c_Ids, pdgId))                   { nc =  3; }
  else if (hit(three_antic_Ids, pdgId))               { nc = -3; }
  else if (hit(two_c_Ids, pdgId))                     { nc =  2; }
  else if (hit(two_antic_Ids, pdgId))                 { nc = -2; }
  else if (hit(one_c_Ids, pdgId))                     { nc =  1; }
  else if (hit(one_antic_Ids, pdgId))                 { nc = -1; }
 
  return FlavInfo(0,0,0,nc,nb,0,0);
}

hit()

template<typename Container>

bool hit ( const Container & ids, int pdgId )

inline

Definition at line 64 of file JetIRCSafeLabelTool.cxx.

                                                 {
    return std::ranges::any_of(ids, [pdgId](int id) {
        return id == pdgId;
    });
}

makeJetDefWithPlugin()

template<typename PluginT, typename... Args>

std::unique_ptr< fastjet::JetDefinition > makeJetDefWithPlugin

(

Args &&...

args

)

Definition at line 72 of file JetIRCSafeLabelTool.cxx.

                                                                         {
  auto plugin = std::make_unique<PluginT>(std::forward<Args>(args)...);
  auto jetDef = std::make_unique<fastjet::JetDefinition>(plugin.get());
  jetDef->delete_plugin_when_unused();
  plugin.release(); 
  return jetDef;
}

negateID()

template<size_t N>

std::array< int, N > negateID ( const std::array< int, N > & in )

constexpr

Definition at line 54 of file JetIRCSafeLabelTool.cxx.

                                                                {
  std::array<int, N> out{};
  for (size_t i = 0; i < N; ++i) {
    out[i] = -in[i];
  }
  return out;
}

setJetIRCSafeLabels()

void setJetIRCSafeLabels	(	const xAOD::Jet &	jet,
		const ParticleJetTools::Tag_PseudoJets &	tag_pjets,
		const ParticleJetTools::IRCSafeLabelDecorators &	decs,
		bool	doIFN,
		bool	doCMP,
		bool	doGHS,
		bool	doSDF,
		bool	doAKT )

Definition at line 293 of file JetIRCSafeLabelTool.cxx.

                                                                                     {
 
  int IFN_label = doIFN ? (tag_pjets.IFN_b.size() ? JetIRCSafeLabelTool::LABEL_B :
                           tag_pjets.IFN_c.size() ? JetIRCSafeLabelTool::LABEL_C : JetIRCSafeLabelTool::LABEL_LIGHT) : JetIRCSafeLabelTool::LABEL_DISABLED;
  int CMP_label = doCMP ? (tag_pjets.CMP_b.size() ? JetIRCSafeLabelTool::LABEL_B :
                           tag_pjets.CMP_c.size() ? JetIRCSafeLabelTool::LABEL_C : JetIRCSafeLabelTool::LABEL_LIGHT) : JetIRCSafeLabelTool::LABEL_DISABLED;
  int GHS_label = doGHS ? (tag_pjets.GHS_b.size() ? JetIRCSafeLabelTool::LABEL_B :
                           tag_pjets.GHS_c.size() ? JetIRCSafeLabelTool::LABEL_C : JetIRCSafeLabelTool::LABEL_LIGHT) : JetIRCSafeLabelTool::LABEL_DISABLED;
  int SDF_label = doSDF ? (tag_pjets.SDF_b.size() ? JetIRCSafeLabelTool::LABEL_B :
                           tag_pjets.SDF_c.size() ? JetIRCSafeLabelTool::LABEL_C : JetIRCSafeLabelTool::LABEL_LIGHT) : JetIRCSafeLabelTool::LABEL_DISABLED;
  int AKT_label = doAKT ? (tag_pjets.AKT_b.size() ? JetIRCSafeLabelTool::LABEL_B :
                           tag_pjets.AKT_c.size() ? JetIRCSafeLabelTool::LABEL_C : JetIRCSafeLabelTool::LABEL_LIGHT) : JetIRCSafeLabelTool::LABEL_DISABLED;
 
  decs.IFNsingleint(jet) = IFN_label;
  decs.CMPsingleint(jet) = CMP_label;
  decs.GHSsingleint(jet) = GHS_label;
  decs.SDFsingleint(jet) = SDF_label;
  decs.AKTsingleint(jet) = AKT_label;
}

toLower()

std::string toLower ( const std::string & s )

static

Definition at line 44 of file JetIRCSafeLabelTool.cxx.

                                             {
  std::string result;
  result.reserve(s.size());
  std::transform(s.begin(), s.end(), std::back_inserter(result),
                 [](unsigned char c){ return std::tolower(c); });
  return result;
}

Variable Documentation

ALGO_NAMES

std::array<const char*, JetIRCSafeLabelTool::N_ALGOS> ALGO_NAMES

staticconstexpr

Initial value:

                                       = {
  "IFN", "CMP", "GHS", "SDF", "AKT"
}

Definition at line 39 of file JetIRCSafeLabelTool.cxx.

                                                                              {
  "IFN", "CMP", "GHS", "SDF", "AKT"
};