PIDDetectorWeights Class Reference

Class for handling the PID weights per detector, used to calculate the track helix isolation score per particle. More...

#include <PIDDetectorWeights.h>

Inheritance diagram for PIDDetectorWeights:

Collaboration diagram for PIDDetectorWeights:

Classes
class	WeightsTable
	Nested class acting as a container the per-detector weights. More...

Public Member Functions
	PIDDetectorWeights ()
	Default constructor, necessary for ROOT to stream the object.
	~PIDDetectorWeights ()
	Destructor.
	PIDDetectorWeights (const std::string &weightsCSVFileName)
	Constructor from CSV file of weights.
	PIDDetectorWeights (const std::string &treeName, const std::string &weightsROOTFileName)
	Constructor from ROOT file w/ TTree of weights.
ROOT::RDataFrame	getWeightsRDF () const
	Get the RDataFrame of detector weights.
double	getWeight (Const::ChargedStable hypo, Const::EDetector det, double p, double theta) const
	Lookup the weight from the internal map structures.

Private Member Functions
void	fillWeightsTablePerHypoFromRDF ()
	Fill the internal weights container class per particle hypo, based on the content of the RDataFrame.
	ClassDef (PIDDetectorWeights, 4)
	ClassDef as this is a TObject.

Private Attributes
std::map< int, WeightsTable >	m_weightsTablePerHypo
	Map containing a WeightsTable object per particle hypo.
ROOT::RDataFrame	m_weightsRDataFrame = ROOT::RDataFrame(1)
	The RDataFrame containing the detector weights per particle hypo, per phase space bin.
std::map< std::string, std::string >	m_weightNames
	The names of the per-detector weight columns in the RDataFrame.

Detailed Description

Class for handling the PID weights per detector, used to calculate the track helix isolation score per particle.

Definition at line 31 of file PIDDetectorWeights.h.

Constructor & Destructor Documentation

PIDDetectorWeights() [1/3]

PIDDetectorWeights ( )

inline

Default constructor, necessary for ROOT to stream the object.

Definition at line 75 of file PIDDetectorWeights.h.

{};

~PIDDetectorWeights()

~PIDDetectorWeights ( )

inline

Destructor.

Definition at line 80 of file PIDDetectorWeights.h.

{};

PIDDetectorWeights() [2/3]

PIDDetectorWeights ( const std::string &  weightsCSVFileName )

inline

Constructor from CSV file of weights.

NB: please ensure all numeric types are stored as double in the CSV!

Parameters

weightsCSVFileName

the path to the CSV file containing the detector weights per std charged particle hypothesis, in bins of p and theta.

Definition at line 88 of file PIDDetectorWeights.h.

    {
      m_weightsRDataFrame = ROOT::RDF::MakeCsvDataFrame(weightsCSVFileName);
      fillWeightsTablePerHypoFromRDF();
    };

PIDDetectorWeights() [3/3]

PIDDetectorWeights ( const std::string &  treeName, const std::string &  weightsROOTFileName  )

inline

Constructor from ROOT file w/ TTree of weights.

Parameters

treeName	the name of the TTree with detector weights per std charged particle hypothesis, in bins of p and theta.
weightsROOTFileName	the path to the ROOT file containing the TTree.

Definition at line 99 of file PIDDetectorWeights.h.

                                                                                        :
      m_weightsRDataFrame(treeName, weightsROOTFileName)
    {
      fillWeightsTablePerHypoFromRDF();
    };

Member Function Documentation

fillWeightsTablePerHypoFromRDF()

void fillWeightsTablePerHypoFromRDF ( )

private

Fill the internal weights container class per particle hypo, based on the content of the RDataFrame.

Definition at line 15 of file PIDDetectorWeights.cc.

{
 
  auto dummyBinEdges = std::set<double>();
 
  // Flatten the RDataFrame content into the tabular structure for each std charged hypothesis.
  for (const auto& hypo : Const::chargedStableSet) {
 
    WeightsTable weightsTable;
 
    auto cut_pdgId = [&](double pdg) { return (pdg == hypo.getPDGCode()); };
    auto filteredRDF = m_weightsRDataFrame.Filter(cut_pdgId, {"pdgId"});
 
    if (*filteredRDF.Count()) {
 
      // Get the lower and upper bin edges from the RDF as C++ vectors
      auto pMinEdges = filteredRDF.Take<double>("p_min").GetValue();
      auto pMaxEdges = filteredRDF.Take<double>("p_max").GetValue();
      // Get the bin indexes.
      auto pBinIdxs = filteredRDF.Take<double>("p_bin_idx").GetValue();
      // Convert to a set and take the union. This way duplicates are removed.
      std::set<double> pMinEdges_set(std::begin(pMinEdges), std::end(pMinEdges));
      std::set<double> pMaxEdges_set(std::begin(pMaxEdges), std::end(pMaxEdges));
      std::set<double> pBinEdges;
      std::set_union(std::begin(pMinEdges_set), std::end(pMinEdges_set),
                     std::begin(pMaxEdges_set), std::end(pMaxEdges_set),
                     std::inserter(pBinEdges, std::begin(pBinEdges)));
      // Store the set of bin edges into the internal tabular structure for this particle hypothesis.
      weightsTable.m_pBinEdges = pBinEdges;
      // Store the nr. of p bins. Used for bin idx linearisation.
      weightsTable.m_nPBins = pBinEdges.size() - 1;
      // Check thqt the min, max bin edges have no gaps.
      // Revert to a std::vector for easy index-based iteration.
      std::vector<double> pMinEdgesVec(std::begin(pMinEdges_set), std::end(pMinEdges_set));
      std::vector<double> pMaxEdgesVec(std::begin(pMaxEdges_set), std::end(pMaxEdges_set));
      for (unsigned int iEdgeIdx(0); iEdgeIdx < pMaxEdgesVec.size() - 1; ++iEdgeIdx) {
        if (pMaxEdgesVec[iEdgeIdx] != pMinEdgesVec[iEdgeIdx + 1]) {
          B2FATAL("The p bins in the weights table are not contiguous. Please check the input CSV file.");
        }
      }
 
      auto thetaMinEdges = filteredRDF.Take<double>("theta_min").GetValue();
      auto thetaMaxEdges = filteredRDF.Take<double>("theta_max").GetValue();
      auto thetaBinIdxs = filteredRDF.Take<double>("theta_bin_idx").GetValue();
      std::set<double> thetaMinEdges_set(std::begin(thetaMinEdges), std::end(thetaMinEdges));
      std::set<double> thetaMaxEdges_set(std::begin(thetaMaxEdges), std::end(thetaMaxEdges));
      std::set<double> thetaBinEdges;
      std::set_union(std::begin(thetaMinEdges_set), std::end(thetaMinEdges_set),
                     std::begin(thetaMaxEdges_set), std::end(thetaMaxEdges_set),
                     std::inserter(thetaBinEdges, std::begin(thetaBinEdges)));
      weightsTable.m_thetaBinEdges = thetaBinEdges;
      weightsTable.m_nThetaBins = thetaBinEdges.size() - 1;
      std::vector<double> thetaMinEdgesVec(std::begin(thetaMinEdges_set), std::end(thetaMinEdges_set));
      std::vector<double> thetaMaxEdgesVec(std::begin(thetaMaxEdges_set), std::end(thetaMaxEdges_set));
      for (unsigned int iEdge(0); iEdge < thetaMaxEdgesVec.size() - 1; ++iEdge) {
        if (thetaMaxEdgesVec[iEdge] != thetaMinEdgesVec[iEdge + 1]) {
          B2FATAL("The theta bins in the weights table are not contiguous. Please check the input CSV file.");
        }
      }
 
      // Get the p, theta bin index columns and zip them together.
      std::vector<std::tuple<double, double>> pAndThetaIdxs;
      std::transform(std::begin(pBinIdxs), std::end(pBinIdxs),
                     std::begin(thetaBinIdxs),
      std::back_inserter(pAndThetaIdxs), [](const auto & pIdx, const auto & thetaIdx) { return std::make_tuple(pIdx, thetaIdx); });
 
      // Fill a std::unordered_map with the linearised (p, theta) bin index as key and the vector index
      // (i.e. the filtered RDataFrame row idx) as value for fast lookup.
      unsigned int iRow(0);
      for (const auto& tup : pAndThetaIdxs) {
        double linBinIdx = (std::get<0>(tup) - 1.0) + (std::get<1>(tup) - 1.0) * weightsTable.m_nPBins;
        weightsTable.m_linBinIdxsToRowIdxs.insert(std::make_pair(linBinIdx, iRow));
        ++iRow;
      }
 
      // Store the vector (column) of weights per detector.
      for (const Const::EDetector& det : Const::PIDDetectorSet::set()) {
        auto detName = Const::parseDetectors(det);
        auto colName = "ablat_s_" + detName;
        auto weights = filteredRDF.Take<double>(colName.c_str()).GetValue();
        weightsTable.m_weightsPerDet.insert(std::make_pair(detName, weights));
      }
 
    } else {
 
      B2WARNING("Couldn't find detector weights in input ROOT::RDataFrame for std charged particle hypothesis: " << hypo.getPDGCode());
      weightsTable.m_isEmpty = true;
 
    }
 
    m_weightsTablePerHypo.insert(std::make_pair(hypo.getPDGCode(), weightsTable));
 
  };
 
}

getWeight()

double getWeight	(	Const::ChargedStable	hypo,
		Const::EDetector	det,
		double	p,
		double	theta
	)		const

Lookup the weight from the internal map structures.

Parameters

hypo	the input std charged particle.
det	the input PID detector.
p	the particle momentum in [GeV/c].
theta	the particle polar angle in [rad].

Definition at line 112 of file PIDDetectorWeights.cc.

{
 
  const auto weightsTable = &m_weightsTablePerHypo.at(hypo.getPDGCode());
 
  if (weightsTable->m_isEmpty) {
    // Weights not available for this pdgId.
    return std::numeric_limits<float>::quiet_NaN();
  }
 
  // Get the bin index of the input p value.
  auto pBinUpperEdge_it = std::lower_bound(std::begin(weightsTable->m_pBinEdges),
                                           std::end(weightsTable->m_pBinEdges),
                                           p);
  auto pBinIdx = std::distance(std::begin(weightsTable->m_pBinEdges), pBinUpperEdge_it);
  // Get the bin index of the input theta value.
  auto thetaBinUpperEdge_it = std::lower_bound(std::begin(weightsTable->m_thetaBinEdges),
                                               std::end(weightsTable->m_thetaBinEdges),
                                               theta);
  auto thetaBinIdx = std::distance(std::begin(weightsTable->m_thetaBinEdges), thetaBinUpperEdge_it);
 
  // Get the linearised bin index to look up.
  double linBinIdx = (pBinIdx - 1.0) + (thetaBinIdx - 1.0) * weightsTable->m_nPBins;
 
  if (!weightsTable->m_linBinIdxsToRowIdxs.count(linBinIdx)) {
    // Out-of-bin range p or theta
    B2DEBUG(11, "\n"
            << "p = " << p << " [GeV/c], theta = " << theta << " [rad].\n"
            << "Bin indexes: (" <<  pBinIdx << ", " << thetaBinIdx << ").\n"
            << "Either input value is outside of bin range for PID detector weights:\n"
            << "p : [" << *weightsTable->m_pBinEdges.begin() << ", " << *weightsTable->m_pBinEdges.rbegin() << "],\n"
            << "theta: [" << *weightsTable->m_thetaBinEdges.begin() << ", " << *weightsTable->m_thetaBinEdges.rbegin() << "]");
    return std::numeric_limits<float>::quiet_NaN();
  }
 
  auto rowIdx = weightsTable->m_linBinIdxsToRowIdxs.at(linBinIdx);
 
  return weightsTable->m_weightsPerDet.at(Const::parseDetectors(det)).at(rowIdx);
 
};

getWeightsRDF()

ROOT::RDataFrame getWeightsRDF ( ) const

inline

Get the RDataFrame of detector weights.

To be used for testing/debugging only when creating the payload.

Definition at line 109 of file PIDDetectorWeights.h.

    {
      return m_weightsRDataFrame;
    };

Member Data Documentation

m_weightNames

std::map<std::string, std::string> m_weightNames

private

Initial value:

= {
      {Const::parseDetectors(Const::CDC), "ablat_s_CDC"},
      {Const::parseDetectors(Const::TOP), "ablat_s_TOP"},
      {Const::parseDetectors(Const::ARICH), "ablat_s_ARICH"},
      {Const::parseDetectors(Const::ECL), "ablat_s_ECL"},
      {Const::parseDetectors(Const::KLM), "ablat_s_KLM"}
    }

The names of the per-detector weight columns in the RDataFrame.

Definition at line 141 of file PIDDetectorWeights.h.

m_weightsRDataFrame

ROOT::RDataFrame m_weightsRDataFrame = ROOT::RDataFrame(1)

private

The RDataFrame containing the detector weights per particle hypo, per phase space bin.

Using an RDataFrame is convenient when creating the payload from an input CSV file. However, an RDataFrame cannot be streamed in the persistent ROOT file, thus we must prevent this from happening.

Definition at line 136 of file PIDDetectorWeights.h.

m_weightsTablePerHypo

std::map<int, WeightsTable> m_weightsTablePerHypo

private

Map containing a WeightsTable object per particle hypo.

Use to lookup the index corresponding to a (p, theta) pair.

Definition at line 129 of file PIDDetectorWeights.h.

---

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

• analysis/dbobjects/include/PIDDetectorWeights.h
• analysis/dbobjects/src/PIDDetectorWeights.cc