#include <PerformancePayloadFromTable.h>

Inheritance diagram for PerformancePayloadFromTable:

Public Member Functions
float	getResult (PerformanceResult::ResultType, const BinningPointByMap &) const override

bool	isInPayload (PerformanceResult::ResultType, const BinningPointByMap &) const override

virtual bool	isParametrizedInVariable (const BinningVariables::BinningVariablesType p) const

const PhysicsPerformancePayload &	payLoad () const

	PerformancePayloadFromTable ()

	PerformancePayloadFromTable (const std::vector< PerformanceResult::ResultType > &r, const std::vector< BinningVariables::BinningVariablesType > &b, int stride_, const std::vector< float > &table)

	~PerformancePayloadFromTable () override

Public Member Functions inherited from PerformancePayload
virtual void	initialize ()

	PerformancePayload ()

virtual	~PerformancePayload ()

Static Public Attributes
static const int	InvalidPos = -1

Static Public Attributes inherited from PerformancePayload
static const float	InvalidResult = -100.

Protected Member Functions
bool	matches (const BinningPointByMap &, PhysicsPerformancePayload::Row &) const

virtual int	maxPos (const BinningVariables::BinningVariablesType b) const

virtual int	minPos (const BinningVariables::BinningVariablesType b) const

virtual std::vector< BinningVariables::BinningVariablesType >	myBinning () const

virtual int	resultPos (PerformanceResult::ResultType r) const

Protected Attributes
std::vector< BinningVariables::BinningVariablesType >	binning_

PhysicsPerformancePayload	pl

std::vector< PerformanceResult::ResultType >	results_

Private Member Functions
template<class Archive >
void	serialize (Archive &ar, const unsigned int version)

Friends
class	boost::serialization::access

template<typename CondSerializationT , typename Enabled >
struct	cond::serialization::access

Detailed Description

Definition at line 15 of file PerformancePayloadFromTable.h.

Constructor & Destructor Documentation

◆ PerformancePayloadFromTable() [1/2]

PerformancePayloadFromTable::PerformancePayloadFromTable	(	const std::vector< PerformanceResult::ResultType > &	r,
		const std::vector< BinningVariables::BinningVariablesType > &	b,
		int	stride_,
		const std::vector< float > &	table
	)

inline

Definition at line 22 of file PerformancePayloadFromTable.h.

26 : pl(stride_, table), results_(r), binning_(b) {}

◆ PerformancePayloadFromTable() [2/2]

PerformancePayloadFromTable::PerformancePayloadFromTable ( )

inline

Definition at line 28 of file PerformancePayloadFromTable.h.

28 {}

◆ ~PerformancePayloadFromTable()

PerformancePayloadFromTable::~PerformancePayloadFromTable ( )

inlineoverride

Definition at line 29 of file PerformancePayloadFromTable.h.

29 {}

Member Function Documentation

◆ getResult()

float PerformancePayloadFromTable::getResult	(	PerformanceResult::ResultType	r,
		const BinningPointByMap &	p
	)		const

overridevirtual

Implements PerformancePayload.

Definition at line 7 of file PerformancePayloadFromTable.cc.

                                                                                                             {
   if (!isInPayload(r, p))
     return PerformancePayload::InvalidResult;
  
   // loop on the table rows and search for a match
   for (int i = 0; i < pl.nRows(); i++) {
     PhysicsPerformancePayload::Row row = pl.getRow(i);
  
     if (matches(p, row)) {
       int pos = resultPos(r);
       return row[pos];
     }
   }
   return PerformancePayload::InvalidResult;
 }

References PhysicsPerformancePayload::getRow(), mps_fire::i, PerformancePayload::InvalidResult, isInPayload(), matches(), PhysicsPerformancePayload::nRows(), AlCaHLTBitMon_ParallelJobs::p, pl, alignCSCRings::r, and resultPos().

◆ isInPayload()

bool PerformancePayloadFromTable::isInPayload	(	PerformanceResult::ResultType	res,
		const BinningPointByMap &	_point
	)		const

overridevirtual

Implements PerformancePayload.

Definition at line 44 of file PerformancePayloadFromTable.cc.

                                                                                      {
   BinningPointByMap point = _point;
   // first, let's see if it is available at all
   if (resultPos(res) == PerformancePayloadFromTable::InvalidPos)
     return false;
   // now look whther the binning point contains all the info
   std::vector<BinningVariables::BinningVariablesType> t = myBinning();
   for (std::vector<BinningVariables::BinningVariablesType>::const_iterator it = t.begin(); it != t.end(); ++it) {
     if (!point.isKeyAvailable(*it))
       return false;
   }
   // then, look if there is a matching row
   for (int i = 0; i < pl.nRows(); i++) {
     PhysicsPerformancePayload::Row row = pl.getRow(i);
     if (matches(point, row)) {
       return true;
     }
   }
   return false;
 }

References PhysicsPerformancePayload::getRow(), mps_fire::i, InvalidPos, matches(), myBinning(), PhysicsPerformancePayload::nRows(), pl, point, resultPos(), and OrderedSet::t.

Referenced by getResult().

◆ isParametrizedInVariable()

virtual bool PerformancePayloadFromTable::isParametrizedInVariable ( const BinningVariables::BinningVariablesType p ) const

inlinevirtual

Definition at line 34 of file PerformancePayloadFromTable.h.

                                                                                             {
     return (minPos(p) != PerformancePayloadFromTable::InvalidPos);
   }

References InvalidPos, minPos(), and AlCaHLTBitMon_ParallelJobs::p.

◆ matches()

bool PerformancePayloadFromTable::matches	(	const BinningPointByMap &	_p,
		PhysicsPerformancePayload::Row &	row
	)		const

protected

Definition at line 23 of file PerformancePayloadFromTable.cc.

                                                                                                               {
   //
   // this is the smart function which does not take into account the fields not present
   //
  
   // I can do it via a loop!
   BinningPointByMap p = _p;
   std::vector<BinningVariables::BinningVariablesType> t = myBinning();
  
   for (std::vector<BinningVariables::BinningVariablesType>::const_iterator it = t.begin(); it != t.end(); ++it) {
     //
     // first the binning point map must contain ALL the quantities here
     //
     //    if (! p.isKeyAvailable(*it) ) return false;
     float v = p.value(*it);
     if (!(v >= row[minPos(*it)] && v < row[maxPos(*it)]))
       return false;
   }
   return true;
 }

References maxPos(), minPos(), myBinning(), AlCaHLTBitMon_ParallelJobs::p, OrderedSet::t, and findQualityFiles::v.

Referenced by getResult(), and isInPayload().

◆ maxPos()

virtual int PerformancePayloadFromTable::maxPos ( const BinningVariables::BinningVariablesType b ) const

inlineprotectedvirtual

Definition at line 52 of file PerformancePayloadFromTable.h.

                                                                          {
     std::vector<BinningVariables::BinningVariablesType>::const_iterator p;
     p = find(binning_.begin(), binning_.end(), b);
     if (p == binning_.end())
       return PerformancePayloadFromTable::InvalidPos;
     return ((p - binning_.begin()) * 2 + 1);
   }

References b, binning_, spr::find(), InvalidPos, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by matches().

◆ minPos()

virtual int PerformancePayloadFromTable::minPos ( const BinningVariables::BinningVariablesType b ) const

inlineprotectedvirtual

Definition at line 45 of file PerformancePayloadFromTable.h.

                                                                          {
     std::vector<BinningVariables::BinningVariablesType>::const_iterator p;
     p = find(binning_.begin(), binning_.end(), b);
     if (p == binning_.end())
       return PerformancePayloadFromTable::InvalidPos;
     return ((p - binning_.begin()) * 2);
   }

References b, binning_, spr::find(), InvalidPos, and AlCaHLTBitMon_ParallelJobs::p.

Referenced by isParametrizedInVariable(), and matches().

◆ myBinning()

virtual std::vector<BinningVariables::BinningVariablesType> PerformancePayloadFromTable::myBinning ( ) const

inlineprotectedvirtual

Definition at line 43 of file PerformancePayloadFromTable.h.

43 { return binning_; }

References binning_.

Referenced by isInPayload(), and matches().

◆ payLoad()

const PhysicsPerformancePayload& PerformancePayloadFromTable::payLoad ( ) const

inline

Definition at line 40 of file PerformancePayloadFromTable.h.

40 { return pl; }

References pl.

◆ resultPos()

virtual int PerformancePayloadFromTable::resultPos ( PerformanceResult::ResultType r ) const

inlineprotectedvirtual

Definition at line 59 of file PerformancePayloadFromTable.h.

                                                              {
     // result should be: # of binning variables *2 + position of result
     std::vector<PerformanceResult::ResultType>::const_iterator p;
     p = find(results_.begin(), results_.end(), r);
     if (p == results_.end())
       return PerformancePayloadFromTable::InvalidPos;
     return (binning_.size() * 2 + (p - results_.begin()));
   }