lumi::fPoly Class Reference

Inheritance diagram for lumi::fPoly:

Public Member Functions
	fPoly ()
float	getCorrection (float luminonorm, float intglumi, unsigned int nBXs) const override
void	initialize (const std::map< std::string, float > &coeffmap, const std::map< unsigned int, float > &afterglowmap)
	~fPoly () override
Public Member Functions inherited from lumi::NormFunctor
void	initialize (const std::map< std::string, float > &coeffmap, const std::map< unsigned int, float > &afterglowmap)
	NormFunctor ()
	NormFunctor (const NormFunctor &)=delete
const NormFunctor &	operator= (const NormFunctor &)=delete
virtual	~NormFunctor ()

Additional Inherited Members
Protected Attributes inherited from lumi::NormFunctor
std::map< unsigned int, float >	m_afterglowmap
std::map< std::string, float >	m_coeffmap

Detailed Description

Definition at line 6 of file fPoly.cc.

Constructor & Destructor Documentation

lumi::fPoly::fPoly ( )

inline

Definition at line 8 of file fPoly.cc.

{}

lumi::fPoly::~fPoly ( )

inlineoverride

Definition at line 9 of file fPoly.cc.

{}

Member Function Documentation

float lumi::fPoly::getCorrection ( float  luminonorm, float  intglumi, unsigned int  nBXs  ) const

overridevirtual

Implements lumi::NormFunctor.

Definition at line 20 of file fPoly.cc.

References a0, isotrackTrainRegressor::a1, isotrackTrainRegressor::a2, alignmentValidation::c1, mps_fire::result, and edm::second().

                                                                                        {
  float result = 1.0;
  float avglumi = 0.;
  float c1 = 0.;
  std::map<std::string, float>::const_iterator coeffIt = m_coeffmap.find("C1");
  if (coeffIt != m_coeffmap.end()) {
    c1 = coeffIt->second;
  }
  if (c1 != 0. && nBXs > 0) {
    avglumi = c1 * luminonorm / nBXs;
  }
  float Afterglow = 1.0;
  if (!m_afterglowmap.empty()) {
    std::map<unsigned int, float>::const_iterator afterglowit = m_afterglowmap.lower_bound(nBXs + 1);
    if (afterglowit != m_afterglowmap.begin()) {
      Afterglow = (--afterglowit)->second;
    }
  }
  float driftterm = 1.0;
  coeffIt = m_coeffmap.find("DRIFT");
  if (coeffIt != m_coeffmap.end()) {
    driftterm = 1.0 + coeffIt->second * intglumi;
  }
  float a0 = 1.0;
  coeffIt = m_coeffmap.find("A0");
  if (coeffIt != m_coeffmap.end()) {
    a0 = coeffIt->second;
  }
  float a1 = 0.;
  coeffIt = m_coeffmap.find("A1");
  if (coeffIt != m_coeffmap.end()) {
    a1 = coeffIt->second;
  }
  float a2 = 0.;
  coeffIt = m_coeffmap.find("A2");
  if (coeffIt != m_coeffmap.end()) {
    a2 = coeffIt->second;
  }
  result = a0 * Afterglow / (1. + a1 * avglumi + a2 * avglumi * avglumi) * driftterm;
  return result;
}

void lumi::fPoly::initialize	(	const std::map< std::string, float > &	coeffmap,
		const std::map< unsigned int, float > &	afterglowmap
	)

Definition at line 15 of file fPoly.cc.

References lumi::NormFunctor::m_afterglowmap, and lumi::NormFunctor::m_coeffmap.

                                                                              {
  m_coeffmap = coeffmap;
  m_afterglowmap = afterglowmap;
}