JZCombineWeight Class Reference

This class provides the weight used to combine JZ sliced samples by querying JSON. More...

#include <JZCombineWeight.h>

Inheritance diagram for JZCombineWeight:

Collaboration diagram for JZCombineWeight:

Public Member Functions
virtual StatusCode	initialize () override
	This class provides the weight used to combine JZ sliced samples by querying JSON.
virtual StatusCode	getValue (double &value) const override

Private Member Functions
std::size_t	getIndex (double value) const

Private Attributes
Gaudi::Property< std::string >	m_jetCollectionHS
Gaudi::Property< std::string >	m_jetCollectionPU
Gaudi::Property< std::string >	m_weightsFile
Gaudi::Property< std::vector< double > >	m_binning
Gaudi::Property< std::vector< std::string > >	m_weightsName
nlohmann::json	m_weightsMap

Detailed Description

This class provides the weight used to combine JZ sliced samples by querying JSON.

Definition at line 19 of file JZCombineWeight.h.

Member Function Documentation

getIndex()

std::size_t JZCombineWeight::getIndex ( double value ) const

private

Definition at line 116 of file JZCombineWeight.cxx.

                                                      {
    auto it = std::upper_bound(m_binning.begin(), m_binning.end(), value);
    return std::distance(m_binning.begin(), it) - 1;
}

getValue()

StatusCode JZCombineWeight::getValue ( double & value ) const

overridevirtual

Definition at line 31 of file JZCombineWeight.cxx.

                                                        {
  const xAOD::EventInfo* evt {nullptr};
  ATH_CHECK(evtStore()->retrieve(evt, "EventInfo"));
 
  // Truth jets are only valid for MC
  bool isMC = evt->eventTypeBitmask() & xAOD::EventInfo::IS_SIMULATION;
  if (!isMC) { return StatusCode::SUCCESS; }
 
  auto mu_actual = static_cast<std::size_t>(std::ceil(evt->actualInteractionsPerCrossing()));
 
 
  // categories
  std::vector<std::size_t> categories(m_binning.size() - 1, 0);
 
  // HS jets
  double pt_j0_AK4HS {5.0};
  std::size_t idx_HS {0};
  const xAOD::JetContainer* hs_jets {nullptr};
  ATH_CHECK(evtStore()->retrieve(hs_jets, m_jetCollectionHS));
  if (hs_jets->size()) {
    auto iter_jet = std::max_element(hs_jets->begin(), hs_jets->end(), 
          [](const xAOD::Jet* j0, const xAOD::Jet* j1){ return j0->pt() < j1->pt(); });
    pt_j0_AK4HS = (*iter_jet)->pt() / GeV;
    idx_HS = getIndex(pt_j0_AK4HS);
  }
 
  ++categories[idx_HS];
 
  // PU jets
  std::vector<double> pt_j0_AK4PU;
  const xAOD::JetContainer* pu_jets {nullptr};
  ATH_CHECK(evtStore()->retrieve(pu_jets, m_jetCollectionPU));
  std::unordered_map<int, double> leading_pts;
  if (pu_jets->size()) {
    for (const xAOD::Jet* pu_jet : *pu_jets) {
      SG::ConstAccessor<int> pu_enum_acc("pileupEventNumber");
      const uint32_t pu_enum = static_cast<uint32_t>(pu_enum_acc.withDefault(*pu_jet, 0));
      double pu_jet_pt = pu_jet->pt() / GeV;
      if (!leading_pts.contains(pu_enum) || leading_pts.at(pu_enum) < pu_jet_pt) {
        leading_pts[pu_enum] = pu_jet_pt;
      } 
    }
  }
  auto n_pileup_records = leading_pts.size();
 
  for (const auto& pair : leading_pts) {
    double pt = pair.second;
    pt_j0_AK4PU.push_back(pt);
    std::size_t idx_PU = getIndex(pt);
    ++categories[idx_PU];
  }
 
  // Remining low pT pileups
  categories[0] += mu_actual - n_pileup_records - 1;
 
  // Convert to string
  std::stringstream key_ss;
  std::string delim {"_"};
  for (std::size_t i = 0; i < categories.size(); ++i) {
    if (i != 0) key_ss << delim;
    key_ss << categories.at(i);
  }
  key_ss << "," << idx_HS;
 
  const std::string& key = key_ss.str();
 
  // categories that are not included in the weight mapping will be skipped
  if (m_weightsMap.find(key) == m_weightsMap.end()) {
    value = 0.0;
    return StatusCode::SUCCESS;
  }
 
  for (const auto& weightName : m_weightsName) {
    try {
      auto wt = m_weightsMap.at(key).at(weightName).get<double>();
      value *= wt;
    } catch (const std::exception&) {
      ATH_MSG_ERROR("Failed to get weight [" << weightName << "] in [" << key << "]!");
      return StatusCode::FAILURE;
    }
  }
 
  return StatusCode::SUCCESS;
}

initialize()

StatusCode JZCombineWeight::initialize ( )

overridevirtual

This class provides the weight used to combine JZ sliced samples by querying JSON.

Definition at line 20 of file JZCombineWeight.cxx.

                                       {
  std::ifstream fs(m_weightsFile);
  try {
    m_weightsMap = nlohmann::json::parse(fs);
  } catch (const std::exception&) {
    ATH_MSG_ERROR("Failed to parse input " << m_weightsFile);
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}

Member Data Documentation

m_binning

Gaudi::Property<std::vector<double> > JZCombineWeight::m_binning

private

Initial value:

{
    this, "Binning", {}, "Pt binning used to define categories"}

Definition at line 36 of file JZCombineWeight.h.

                                             {
    this, "Binning", {}, "Pt binning used to define categories"};

m_jetCollectionHS

Gaudi::Property<std::string> JZCombineWeight::m_jetCollectionHS

private

Initial value:

{
    this, "JetCollectionHS", "AntiKt4TruthJets", "Name of the hard-scatter jet collection"}

Definition at line 30 of file JZCombineWeight.h.

                                             {
    this, "JetCollectionHS", "AntiKt4TruthJets", "Name of the hard-scatter jet collection"};

m_jetCollectionPU

Gaudi::Property<std::string> JZCombineWeight::m_jetCollectionPU

private

Initial value:

{
    this, "JetCollectionPU", "InTimeAntiKt4TruthJets", "Name of the pile-up jet collection"}

Definition at line 32 of file JZCombineWeight.h.

                                             {
    this, "JetCollectionPU", "InTimeAntiKt4TruthJets", "Name of the pile-up jet collection"};

m_weightsFile

Gaudi::Property<std::string> JZCombineWeight::m_weightsFile

private

Initial value:

{ 
    this, "WeightsFile", "", "Path to the weights file"}

Definition at line 34 of file JZCombineWeight.h.

                                         { 
    this, "WeightsFile", "", "Path to the weights file"};

m_weightsMap

nlohmann::json JZCombineWeight::m_weightsMap

private

Definition at line 41 of file JZCombineWeight.h.

m_weightsName

Gaudi::Property<std::vector<std::string> > JZCombineWeight::m_weightsName

private

Initial value:

{
    this, "WeightsName", {}, "Weights to be calculated - their product is used"}

Definition at line 38 of file JZCombineWeight.h.

                                                    {
    this, "WeightsName", {}, "Weights to be calculated - their product is used"};

---

The documentation for this class was generated from the following files:

• JZCombineWeight.h
• JZCombineWeight.cxx