PFBenchmarkAlgo Class Reference

#include <PFBenchmarkAlgo.h>

Static Public Member Functions
template<typename T , typename Collection >
static Collection	copyCollection (const Collection *)
template<typename T , typename U >
static double	deltaEt (const T *, const U *)
template<typename T , typename U >
static double	deltaEta (const T *, const U *)
template<typename T , typename U >
static double	deltaPhi (const T *, const U *)
template<typename T , typename U >
static double	deltaR (const T *, const U *)
template<typename T , typename Collection >
static Collection	findAllInCone (const T *, const Collection *, double)
template<typename T , typename Collection >
static Collection	findAllInEtWindow (const T *, const Collection *, double)
template<typename T , typename Collection >
static const Collection::value_type *	matchByDeltaEt (const T *, const Collection *)
template<typename T , typename Collection >
static const Collection::value_type *	matchByDeltaR (const T *, const Collection *)
template<typename T , typename Collection >
static void	sortByDeltaEt (const T *, Collection &)
template<typename T , typename Collection >
static void	sortByDeltaR (const T *, Collection &)

Static Private Member Functions
template<typename T >
static void	vector_add (const T *c1, std::vector< T > &candidates)
template<typename T >
static void	vector_add (const T *c1, edm::OwnVector< T > &candidates)
template<typename T , typename U , template< typename, typename > class Sorter>
static void	vector_sort (std::vector< T > &candidates, Sorter< T, U > S)
template<typename T , typename U , template< typename, typename > class Sorter>
static void	vector_sort (edm::OwnVector< T > &candidates, Sorter< T, U > S)

Detailed Description

Definition at line 16 of file PFBenchmarkAlgo.h.

Member Function Documentation

copyCollection()

template<typename T , typename Collection >

Collection PFBenchmarkAlgo::copyCollection ( const Collection *  candidates )

static

Definition at line 247 of file PFBenchmarkAlgo.h.

References HLT_2023v12_cff::candidates, filterCSVwithJSON::copy, Exception, mps_fire::i, mitigatedMETSequence_cff::U, and vector_add().

                                                                       {
  typedef typename Collection::value_type U;

  // Try to verify the validity of the Collection
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to copy invalid Collection";

  Collection copy;

  for (unsigned int i = 0; i < candidates->size(); i++)
    vector_add(&(*candidates)[i], copy);

  return copy;
}

deltaEt()

template<typename T , typename U >

double PFBenchmarkAlgo::deltaEt ( const T *  c1, const U *  c2  )

static

Definition at line 120 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, and Exception.

Referenced by findAllInEtWindow(), matchByDeltaEt(), and deltaEtSorter< T, U >::operator()().

                                                        {
  if (c1 == nullptr || c2 == nullptr)
    throw cms::Exception("Invalid Arg") << "attempted to calculate deltaEt for invalid Candidate(s)";

  return c1->et() - c2->et();
}

deltaEta()

template<typename T , typename U >

double PFBenchmarkAlgo::deltaEta ( const T *  c1, const U *  c2  )

static

Definition at line 129 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, and Exception.

Referenced by deltaR().

                                                         {
  if (c1 == nullptr || c2 == nullptr)
    throw cms::Exception("Invalid Arg") << "attempted to calculate deltaEta for invalid Candidate(s)";

  return c1->eta() - c2->eta();
}

deltaPhi()

template<typename T , typename U >

double PFBenchmarkAlgo::deltaPhi ( const T *  c1, const U *  c2  )

static

Definition at line 138 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, reco::ceil(), Exception, and M_PI.

Referenced by deltaR().

                                                         {
  if (c1 == nullptr || c2 == nullptr)
    throw cms::Exception("Invalid Arg") << "attempted to calculate deltaPhi for invalid Candidate(s)";

  double phi1 = c1->phi();
  if (phi1 > M_PI)
    phi1 -= ceil((phi1 - M_PI) / (2 * M_PI)) * 2 * M_PI;
  if (phi1 <= -M_PI)
    phi1 += ceil((phi1 + M_PI) / (-2. * M_PI)) * 2. * M_PI;

  double phi2 = c2->phi();
  if (phi2 > M_PI)
    phi2 -= ceil((phi2 - M_PI) / (2 * M_PI)) * 2 * M_PI;
  if (phi2 <= -M_PI)
    phi2 += ceil((phi2 + M_PI) / (-2. * M_PI)) * 2 * M_PI;

  // alternative method:
  // while (phi > M_PI) phi -= 2 * M_PI;
  // while (phi <= - M_PI) phi += 2 * M_PI;

  double deltaphi = -999.0;
  if (fabs(phi1 - phi2) < M_PI) {
    deltaphi = (phi1 - phi2);
  } else {
    if ((phi1 - phi2) > 0.0) {
      deltaphi = (2 * M_PI - fabs(phi1 - phi2));
    } else {
      deltaphi = -(2 * M_PI - fabs(phi1 - phi2));
    }
  }
  return deltaphi;
  //return ( (fabs(phi1 - phi2)<M_PI)?(phi1-phi2):(2*M_PI - fabs(phi1 - phi2) ) ); // FL: wrong
}

deltaR()

template<typename T , typename U >

double PFBenchmarkAlgo::deltaR ( const T *  c1, const U *  c2  )

static

Definition at line 174 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, deltaEta(), deltaPhi(), Exception, funct::pow(), and mathSSE::sqrt().

Referenced by TauTagValidation::analyze(), GenericBenchmark::fill(), PFJetFilter::filter(), findAllInCone(), matchByDeltaR(), deltaRSorter< T, U >::operator()(), and PFJetBenchmark::process().

                                                       {
  if (c1 == nullptr || c2 == nullptr)
    throw cms::Exception("Invalid Arg") << "attempted to calculate deltaR for invalid Candidate(s)";

  return sqrt(std::pow(deltaPhi(c1, c2), 2) + std::pow(deltaEta(c1, c2), 2));
}

findAllInCone()

template<typename T , typename Collection >

Collection PFBenchmarkAlgo::findAllInCone ( const T *  c1, const Collection *  candidates, double  ConeSize  )

static

Definition at line 294 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, Exception, mps_fire::i, sortByDeltaR(), mitigatedMETSequence_cff::U, and vector_add().

                                                                                                    {
  typedef typename Collection::value_type U;

  // Try to verify the validity of Candidate and the Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to constrain to invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to constrain invalid Collection";
  if (ConeSize <= 0)
    throw cms::Exception("Invalid Arg") << "zero or negative cone size specified";

  Collection constrained;

  for (unsigned int i = 0; i < candidates->size(); i++) {
    const U *c2 = &(*candidates)[i];

    // Add in-cone Candidates to the new Collection
    double dR = deltaR(c1, c2);
    if (dR < ConeSize)
      vector_add(c2, constrained);
  }

  // Sort and return Collection
  sortByDeltaR(c1, constrained);
  return constrained;
}

findAllInEtWindow()

template<typename T , typename Collection >

Collection PFBenchmarkAlgo::findAllInEtWindow ( const T *  c1, const Collection *  candidates, double  EtWindow  )

static

Definition at line 323 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, deltaEt(), Exception, mps_fire::i, sortByDeltaEt(), mitigatedMETSequence_cff::U, and vector_add().

                                                                                                        {
  typedef typename Collection::value_type U;

  // Try to verify the validity of Candidate and the Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to constrain to invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to constrain invalid Collection";
  if (EtWindow <= 0)
    throw cms::Exception("Invalid Arg") << "zero or negative cone size specified";

  Collection constrained;

  //CandidateCollection::const_iterator candidate;
  //for (candidate = candidates->begin(); candidate != candidates->end(); candidate++) {
  for (unsigned int i = 0; i < candidates->size(); i++) {
    const U *c2 = &(*candidates)[i];

    // Add in-cone Candidates to the new Collection
    double dEt = fabs(deltaEt(c1, c2));
    if (dEt < EtWindow)
      vector_add(c2, constrained);
  }

  // Sort and return Collection
  sortByDeltaEt(c1, constrained);
  return constrained;
}

matchByDeltaEt()

template<typename T , typename Collection >

const Collection::value_type * PFBenchmarkAlgo::matchByDeltaEt ( const T *  c1, const Collection *  candidates  )

static

Definition at line 215 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, deltaEt(), Exception, mps_fire::i, match(), caloJetBenchmarkGeneric_cfi::minDeltaEt, NULL, and mitigatedMETSequence_cff::U.

                                                                                                              {
  typedef typename Collection::value_type U;

  // Try to verify the validity of the Candidate and Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to match invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to match to invalid Collection";

  double minDeltaEt = 9999.;
  const U *match = NULL;

  // Loop Over the Candidates...
  for (unsigned int i = 0; i < candidates->size(); i++) {
    const T *c2 = &(*candidates)[i];
    if (!c2)
      throw cms::Exception("Invalid Arg") << "attempted to match to invalid Candidate";

    // Find Minimal Delta-R
    double dEt = fabs(deltaEt(c1, c2));
    if (dEt <= minDeltaEt) {
      match = c2;
      minDeltaEt = dEt;
    }
  }

  // Return the Candidate with the smallest dR
  return match;
}

matchByDeltaR()

template<typename T , typename Collection >

const Collection::value_type * PFBenchmarkAlgo::matchByDeltaR ( const T *  c1, const Collection *  candidates  )

static

Definition at line 183 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, deltaR(), HGC3DClusterGenMatchSelector_cfi::dR, Exception, mps_fire::i, match(), HLT_2023v12_cff::minDeltaR, and mitigatedMETSequence_cff::U.

Referenced by GenericBenchmark::fill(), PFJetFilter::filter(), and PFJetBenchmark::process().

                                                                                                             {
  typedef typename Collection::value_type U;

  // Try to verify the validity of the Candidate and Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to match invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to match to invalid Collection";

  double minDeltaR = 9999.;
  const U *match = nullptr;

  // Loop Over the Candidates...
  for (unsigned int i = 0; i < candidates->size(); i++) {
    const U *c2 = &(*candidates)[i];
    if (!c2)
      throw cms::Exception("Invalid Arg") << "attempted to match to invalid Candidate";

    // Find Minimal Delta-R
    double dR = deltaR(c1, c2);
    if (dR <= minDeltaR) {
      match = c2;
      minDeltaR = dR;
    }
  }

  // Return the Candidate with the smallest dR
  return match;
}

sortByDeltaEt()

template<typename T , typename Collection >

void PFBenchmarkAlgo::sortByDeltaEt ( const T *  c1, Collection &  candidates  )

static

Definition at line 279 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, Exception, mitigatedMETSequence_cff::U, and vector_sort().

Referenced by findAllInEtWindow().

                                                                       {
  typedef typename Collection::value_type U;

  // Try to verify the validity of Candidate and Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to sort by invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to sort invalid Candidates";

  // Sort the collection
  vector_sort(candidates, deltaEtSorter<T, U>(c1));
}

sortByDeltaR()

template<typename T , typename Collection >

void PFBenchmarkAlgo::sortByDeltaR ( const T *  c1, Collection &  candidates  )

static

Definition at line 264 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, HLT_2023v12_cff::candidates, Exception, mitigatedMETSequence_cff::U, and vector_sort().

Referenced by findAllInCone().

                                                                      {
  typedef typename Collection::value_type U;

  // Try to verify the validity of Candidate and Collection
  if (!c1)
    throw cms::Exception("Invalid Arg") << "attempted to sort by invalid Candidate";
  if (!candidates)
    throw cms::Exception("Invalid Arg") << "attempted to sort invalid Candidates";

  // Sort the collection
  vector_sort(candidates, deltaRSorter<T, U>(c1));
}

vector_add() [1/2]

template<typename T >

static void PFBenchmarkAlgo::vector_add ( const T *  c1, std::vector< T > &  candidates  )

inlinestaticprivate

Definition at line 71 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, and HLT_2023v12_cff::candidates.

Referenced by copyCollection(), findAllInCone(), and findAllInEtWindow().

                                                                {
    candidates.push_back(*c1);
  }

vector_add() [2/2]

template<typename T >

static void PFBenchmarkAlgo::vector_add ( const T *  c1, edm::OwnVector< T > &  candidates  )

inlinestaticprivate

Definition at line 83 of file PFBenchmarkAlgo.h.

References alignmentValidation::c1, and HLT_2023v12_cff::candidates.

                                                                   {
    candidates.push_back((T *const)c1->clone());
  }

vector_sort() [1/2]

template<typename T , typename U , template< typename, typename > class Sorter>

static void PFBenchmarkAlgo::vector_sort ( std::vector< T > &  candidates, Sorter< T, U >  S  )

inlinestaticprivate

Definition at line 65 of file PFBenchmarkAlgo.h.

References HLT_2023v12_cff::candidates, and jetUpdater_cfi::sort.

Referenced by sortByDeltaEt(), and sortByDeltaR().

                                                                    {
    sort(candidates.begin(), candidates.end(), S);
  }

vector_sort() [2/2]

template<typename T , typename U , template< typename, typename > class Sorter>

static void PFBenchmarkAlgo::vector_sort ( edm::OwnVector< T > &  candidates, Sorter< T, U >  S  )

inlinestaticprivate

Definition at line 77 of file PFBenchmarkAlgo.h.

References HLT_2023v12_cff::candidates.

                                                                       {
    candidates.sort(S);
  }