lumi::fPoly Class Reference

Inheritance diagram for lumi::fPoly:

Public Member Functions
	fPoly ()
virtual 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 ()
Public Member Functions inherited from lumi::NormFunctor
void	initialize (const std::map< std::string, float > &coeffmap, const std::map< unsigned int, float > &afterglowmap)
	NormFunctor ()
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 ( )

inline

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 23 of file fPoly.cc.

References alignmentValidation::c1, normFunctors::intglumi, normFunctors::nBXs, and query::result.

                                                                              {
  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.size()!=0){
    std::map< unsigned int, float >::const_iterator afterglowit=--m_afterglowmap.end();
    if(nBXs>=afterglowit->first){
      Afterglow=afterglowit->second;
    }else{
      afterglowit=m_afterglowmap.upper_bound(nBXs);
      --afterglowit;
      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 17 of file fPoly.cc.

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

                                                              {
  m_coeffmap=coeffmap;
  m_afterglowmap=afterglowmap;
}