#include <PerformancePayloadFromTFormula.h>

Inheritance diagram for PerformancePayloadFromTFormula:

Public Member Functions
const PhysicsTFormulaPayload &	formulaPayload () const

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

void	initialize () override

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

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

	PerformancePayloadFromTFormula ()

	PerformancePayloadFromTFormula (const PerformancePayloadFromTFormula &b)

	PerformancePayloadFromTFormula (const std::vector< PerformanceResult::ResultType > &r, const std::vector< BinningVariables::BinningVariablesType > &b, PhysicsTFormulaPayload &in)

void	printFormula (PerformanceResult::ResultType res) const

	~PerformancePayloadFromTFormula () override

Public Member Functions inherited from PerformancePayload
	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	isOk (const BinningPointByMap &p) const

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

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

virtual int	resultPos (PerformanceResult::ResultType r) const

Protected Attributes
std::vector< std::shared_ptr< const TFormula > >	compiledFormulas_

PhysicsTFormulaPayload	pl

std::vector< PerformanceResult::ResultType >	results_

std::vector< BinningVariables::BinningVariablesType >	variables_

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 17 of file PerformancePayloadFromTFormula.h.

Constructor & Destructor Documentation

◆ PerformancePayloadFromTFormula() [1/3]

PerformancePayloadFromTFormula::PerformancePayloadFromTFormula	(	const std::vector< PerformanceResult::ResultType > &	r,
		const std::vector< BinningVariables::BinningVariablesType > &	b,
		PhysicsTFormulaPayload &	in
	)

inline

Definition at line 22 of file PerformancePayloadFromTFormula.h.

       : pl(in), results_(r), variables_(b) {
     initialize();
   }

References initialize().

◆ PerformancePayloadFromTFormula() [2/3]

PerformancePayloadFromTFormula::PerformancePayloadFromTFormula ( )

inline

Definition at line 29 of file PerformancePayloadFromTFormula.h.

29 {}

◆ PerformancePayloadFromTFormula() [3/3]

PerformancePayloadFromTFormula::PerformancePayloadFromTFormula ( const PerformancePayloadFromTFormula & b )

inline

Definition at line 33 of file PerformancePayloadFromTFormula.h.

34 : pl(b.pl), results_(b.results_), variables_(b.variables_), compiledFormulas_(b.compiledFormulas_) {}

◆ ~PerformancePayloadFromTFormula()

PerformancePayloadFromTFormula::~PerformancePayloadFromTFormula ( )

inlineoverride

Definition at line 36 of file PerformancePayloadFromTFormula.h.

36 { compiledFormulas_.clear(); }

References compiledFormulas_.

Member Function Documentation

◆ formulaPayload()

const PhysicsTFormulaPayload& PerformancePayloadFromTFormula::formulaPayload ( ) const

inline

Definition at line 47 of file PerformancePayloadFromTFormula.h.

47 { return pl; }

References pl.

◆ getResult()

float PerformancePayloadFromTFormula::getResult	(	PerformanceResult::ResultType	r,
		const BinningPointByMap &	_p
	)		const

overridevirtual

Implements PerformancePayload.

Definition at line 21 of file PerformancePayloadFromTFormula.cc.

                                                                                                                 {
   BinningPointByMap p = _p;
   //
   // which formula to use?
   //
   if (!isInPayload(r, p)) {
     edm::LogError("PerformancePayloadFromTFormula")
         << "Missing formula in conditions. Maybe code/conditions are inconsistent" << std::endl;
     assert(false);
   }
  
   const TFormula* formula = compiledFormulas_[resultPos(r)].get();
   //
   // prepare the vector to pass, order counts!!!
   //
   std::vector<BinningVariables::BinningVariablesType> t = myBinning();
  
   // sorry, TFormulas just work up to dimension==4
   Double_t values[4];
   int i = 0;
   for (std::vector<BinningVariables::BinningVariablesType>::const_iterator it = t.begin(); it != t.end(); ++it, ++i) {
     values[i] = p.value(*it);
   }
   //
   return formula->EvalPar(values);
 }

References cms::cuda::assert(), pfMETCorrectionType0_cfi::formula, mps_fire::i, AlCaHLTBitMon_ParallelJobs::p, alignCSCRings::r, submitPVValidationJobs::t, and contentValuesCheck::values.

◆ initialize()

void PerformancePayloadFromTFormula::initialize ( )

overridevirtual

Reimplemented from PerformancePayload.

Definition at line 10 of file PerformancePayloadFromTFormula.cc.

                                                 {
   for (std::vector<std::string>::const_iterator formula = pl.formulas().begin(); formula != pl.formulas().end();
        ++formula) {
     const auto formulaUniqueName = edm::createGlobalIdentifier();
     //be sure not to add TFormula to ROOT's global list
     auto temp = std::make_shared<TFormula>(formulaUniqueName.c_str(), formula->c_str(), false);
     temp->Compile();
     compiledFormulas_.emplace_back(std::move(temp));
   }
 }

References edm::createGlobalIdentifier(), pfMETCorrectionType0_cfi::formula, eostools::move(), and groupFilesInBlocks::temp.

Referenced by PerformancePayloadFromTFormula().

◆ isInPayload()

bool PerformancePayloadFromTFormula::isInPayload	(	PerformanceResult::ResultType	res,
		const BinningPointByMap &	point
	)		const

overridevirtual

Implements PerformancePayload.

Definition at line 64 of file PerformancePayloadFromTFormula.cc.

                                                                                        {
   // first, let's see if it is available at all
   if (resultPos(res) == PerformancePayloadFromTFormula::InvalidPos)
     return false;
  
   if (!isOk(point))
     return false;
   return true;
 }

References InvalidPos, and point.

◆ isOk()

bool PerformancePayloadFromTFormula::isOk ( const BinningPointByMap & p ) const

protected

Definition at line 48 of file PerformancePayloadFromTFormula.cc.

                                                                            {
   BinningPointByMap p = _p;
   std::vector<BinningVariables::BinningVariablesType> t = myBinning();
  
   for (std::vector<BinningVariables::BinningVariablesType>::const_iterator it = t.begin(); it != t.end(); ++it) {
     if (!p.isKeyAvailable(*it))
       return false;
     float v = p.value(*it);
     int pos = limitPos(*it);
     std::pair<float, float> limits = (pl.limits())[pos];
     if (v < limits.first || v > limits.second)
       return false;
   }
   return true;
 }

References TH2PolyOfflineMaps::limits, AlCaHLTBitMon_ParallelJobs::p, submitPVValidationJobs::t, and findQualityFiles::v.

◆ isParametrizedInVariable()

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

inlinevirtual

Definition at line 41 of file PerformancePayloadFromTFormula.h.

                                                                                             {
     return (limitPos(p) != PerformancePayloadFromTFormula::InvalidPos);
   }

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

◆ limitPos()

virtual int PerformancePayloadFromTFormula::limitPos ( const BinningVariables::BinningVariablesType b ) const

inlineprotectedvirtual

Definition at line 54 of file PerformancePayloadFromTFormula.h.

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

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

Referenced by isParametrizedInVariable().

◆ myBinning()

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

inlineprotectedvirtual

Definition at line 52 of file PerformancePayloadFromTFormula.h.

52 { return variables_; }

References variables_.

◆ printFormula()

void PerformancePayloadFromTFormula::printFormula ( PerformanceResult::ResultType res ) const

Definition at line 75 of file PerformancePayloadFromTFormula.cc.

                                                                                        {
   //
   // which formula to use?
   //
   if (resultPos(res) == PerformancePayloadFromTFormula::InvalidPos) {
     cout << "Warning: result not available!" << endl;
     return;
   }
  
   const TFormula* formula = compiledFormulas_[resultPos(res)].get();
   cout << "-- Formula: " << formula->GetExpFormula("p") << endl;
   // prepare the vector to pass, order counts!!!
   //
   std::vector<BinningVariables::BinningVariablesType> t = myBinning();
  
   for (std::vector<BinningVariables::BinningVariablesType>::const_iterator it = t.begin(); it != t.end(); ++it) {
     int pos = limitPos(*it);
     std::pair<float, float> limits = (pl.limits())[pos];
     cout << "      Variable: " << *it << " with limits: "
          << "from: " << limits.first << " to: " << limits.second << endl;
   }
 }

References gather_cfg::cout, pfMETCorrectionType0_cfi::formula, InvalidPos, TH2PolyOfflineMaps::limits, and submitPVValidationJobs::t.

◆ resultPos()

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

inlineprotectedvirtual

Definition at line 62 of file PerformancePayloadFromTFormula.h.

                                                              {
     std::vector<PerformanceResult::ResultType>::const_iterator p;
     p = find(results_.begin(), results_.end(), r);
     if (p == results_.end())
       return PerformancePayloadFromTFormula::InvalidPos;
     return ((p - results_.begin()));
   }