CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass Class Reference

Collaboration diagram for CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass:

Public Member Functions
	EfficiencyMethodBhadronPtEtaBasedClass (const nlohmann::json &jsonConfig)
double	getPIneff (const std::vector< const xAOD::TruthParticle * > &accepted_truthBh, const std::vector< bool > &truthBh_to_SSV_matched, double SF_eff) const

Private Attributes
std::vector< double >	m_ptbins {}
std::map< std::string, std::map< std::string, std::vector< double > > >	m_BhadronPtEtaEfficiencyMap {}
double	m_upperboundpT = -999
std::string	m_overflowPtBinKey {}

Detailed Description

Definition at line 110 of file SSVWeightsAlg.h.

Constructor & Destructor Documentation

EfficiencyMethodBhadronPtEtaBasedClass()

CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::EfficiencyMethodBhadronPtEtaBasedClass

(

const nlohmann::json &

jsonConfig

)

Definition at line 524 of file SSVWeightsAlg.cxx.

    : m_ptbins(jsonConfig["efficiency_Bhadron_pT_eta_based"]["pt_bins"].get<std::vector<double>>())
  {
    // Extract information from JSON file for EfficiencyMethod EfficiencyMethodBhadronPtEtaBased
    for (size_t i = 0; i < m_ptbins.size() - 1; ++i) {
      std::string pT_bin_key = "pt_bin_" + std::to_string((int)m_ptbins[i]) + "_" + std::to_string((int)m_ptbins[i+1]);
      m_BhadronPtEtaEfficiencyMap[pT_bin_key] = jsonConfig["efficiency_Bhadron_pT_eta_based"][pT_bin_key];
    }
    m_upperboundpT = m_ptbins[m_ptbins.size()-1];
    // load the pT overflow bin if it is provided by the calibration
    m_overflowPtBinKey = "pt_bin_" + std::to_string((int)m_upperboundpT) + "plus";
    if (jsonConfig["efficiency_Bhadron_pT_eta_based"].contains(m_overflowPtBinKey)) {
      m_BhadronPtEtaEfficiencyMap[m_overflowPtBinKey] = jsonConfig["efficiency_Bhadron_pT_eta_based"][m_overflowPtBinKey];
    }
  }

Member Function Documentation

getPIneff()

double CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::getPIneff	(	const std::vector< const xAOD::TruthParticle * > &	accepted_truthBh,
		const std::vector< bool > &	truthBh_to_SSV_matched,
		double	SF_eff ) const

Definition at line 541 of file SSVWeightsAlg.cxx.

                        {
    //construct missed truthBhs
    const std::vector<const xAOD::TruthParticle*> missed_truthBhs = construct_not_matched_vectors(accepted_truthBhs, truthBh_to_SSV_matched);
 
    //read off pt bins from JSON file
    const std::vector<double> &ptbins = m_ptbins;
 
    double P_ineff = 1;
    const std::string etaStr{"eta"};
    const std::string effStr{"efficiency"};
    for (size_t i = 0; i < missed_truthBhs.size(); ++i) { 
      //retrieve pt,eta of missed truthBh
      double pt = missed_truthBhs[i]->pt();
      double eta = std::abs(missed_truthBhs[i]->eta());
      std::string pt_bin_of_truthBh = "";
      if (pt >= m_upperboundpT){
        if (!m_BhadronPtEtaEfficiencyMap.contains(m_overflowPtBinKey)){
          throw std::runtime_error("EfficiencyMethodBhadronPtEtaBasedClass::getPIneff: B-hadron pT above the last pT bin edge, but no '" + m_overflowPtBinKey + "' entry in the calibration JSON file");
        }
        pt_bin_of_truthBh = m_overflowPtBinKey;
      }
      else {
        // iterate pt bins to find appropriate efficiency bin for the truthBh pT
        for (size_t j = 0; j < ptbins.size() - 1; ++j) {
          if (pt >= ptbins[j] && pt < ptbins[j+1]) {
            //construct pt bin name
            pt_bin_of_truthBh = "pt_bin_" + std::to_string((int)ptbins[j]) + "_" + std::to_string((int)ptbins[j+1]);
          }
        }
      }
      if (pt_bin_of_truthBh == ""){
        //no pt bin found or no missed truthBh"
        continue;
      }
      //retrieve eta and efficiency bins for the pT bin
      const std::vector<double>& eta_bins = m_BhadronPtEtaEfficiencyMap.at(pt_bin_of_truthBh).at(etaStr);
      const std::vector<double>& efficiencies = m_BhadronPtEtaEfficiencyMap.at(pt_bin_of_truthBh).at(effStr);
 
      std::optional<double> efficiency;
 
      //iterate eta bins to find appropriate eta bin for truthBh eta
      for (size_t k = 0; k < eta_bins.size() - 1; ++k) {
        double eta_low = eta_bins[k];
        double eta_up = eta_bins[k+1];
        if (eta >= eta_low && eta < eta_up) {
          //eta bin found -> read off corresponding efficiency
          efficiency = efficiencies[k];
        }
      }
      if (!efficiency){
        //no eta bin found -> skip the truthBh, as done for truthBhs without pt bin
        continue;
      }
      //calculate P_ineff using the found efficiency
      P_ineff = P_ineff*(1-SF_eff*(*efficiency))/(1-(*efficiency));
    }
    return P_ineff;
  }

Member Data Documentation

m_BhadronPtEtaEfficiencyMap

std::map<std::string, std::map<std::string, std::vector<double> > > CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::m_BhadronPtEtaEfficiencyMap {}

private

Definition at line 119 of file SSVWeightsAlg.h.

{};

m_overflowPtBinKey

std::string CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::m_overflowPtBinKey {}

private

Definition at line 121 of file SSVWeightsAlg.h.

{};

m_ptbins

std::vector<double> CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::m_ptbins {}

private

Definition at line 118 of file SSVWeightsAlg.h.

{};

m_upperboundpT

double CP::SSVWeightsAlg::EfficiencyMethodBhadronPtEtaBasedClass::m_upperboundpT = -999

private

Definition at line 120 of file SSVWeightsAlg.h.

---

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

• SSVWeightsAlg.h
• SSVWeightsAlg.cxx