#include <PFEnergyCalibration.h>

Public Member Functions
double	energyEm (const reco::PFCluster &clusterEcal, std::vector< double > &EclustersPS1, std::vector< double > &EclustersPS2, bool crackCorrection=true) const

double	energyEm (const reco::PFCluster &clusterEcal, double ePS1, double ePS2, bool crackCorrection=true) const

double	energyEm (const reco::PFCluster &clusterEcal, std::vector< double > &EclustersPS1, std::vector< double > &EclustersPS2, double &ps1, double &ps2, bool crackCorrection=true) const

double	energyEm (const reco::PFCluster &clusterEcal, double ePS1, double ePS2, double &ps1, double &ps2, bool crackCorrection=true) const

void	energyEmHad (double t, double &e, double &h, double eta, double phi) const

void	initAlphaGamma_ESplanes_fromDB (const ESEEIntercalibConstants *esEEInterCalib)

void	initializeCalibrationFunctions ()

	PFEnergyCalibration ()

void	setCalibrationFunctions (const PerformancePayloadFromTFormula *thePFCal)

	~PFEnergyCalibration ()

Protected Attributes
const ESEEIntercalibConstants *	esEEInterCalib_

TF1 *	faBarrel

TF1 *	faEndcap

TF1 *	faEtaBarrel

TF1 *	faEtaEndcap

TF1 *	fbBarrel

TF1 *	fbEndcap

TF1 *	fbEtaBarrel

TF1 *	fbEtaEndcap

TF1 *	fcBarrel

TF1 *	fcEndcap

const PerformancePayloadFromTFormula *	pfCalibrations

Private Member Functions
double	aBarrel (double x) const

double	aEndcap (double x) const

double	aEtaBarrel (double x) const

double	aEtaEndcap (double x) const

double	Alpha (double eta) const

double	bBarrel (double x) const

double	bEndcap (double x) const

double	Beta (double E, double eta) const

double	bEtaBarrel (double x) const

double	bEtaEndcap (double x) const

double	cBarrel (double x) const

double	cEndcap (double x) const

double	CorrBarrel (double E, double eta) const

double	CorrEta (double eta) const

double	CorrPhi (double phi, double eta) const

double	dCrackPhi (double phi, double eta) const

double	Ecorr (double eEcal, double ePS1, double ePS2, double eta, double phi, bool crackCorrection=true) const

double	Ecorr (double eEcal, double ePS1, double ePS2, double eta, double phi, double &, double &, bool crackCorrection=true) const

double	EcorrBarrel (double E, double eta, double phi, bool crackCorrection=true) const

double	EcorrPS (double eEcal, double ePS1, double ePS2, double etaEcal) const

double	EcorrPS (double eEcal, double ePS1, double ePS2, double etaEcal, double &, double &) const

double	EcorrPS_ePSNil (double eEcal, double eta) const

double	EcorrZoneAfterPS (double E, double eta) const

double	EcorrZoneBeforePS (double E, double eta) const

double	Gamma (double etaEcal) const

double	minimum (double a, double b) const

Private Attributes
double	threshE

double	threshH

Friends
std::ostream &	operator<< (std::ostream &out, const PFEnergyCalibration &calib)

Detailed Description

Definition at line 41 of file PFEnergyCalibration.h.

Constructor & Destructor Documentation

PFEnergyCalibration::PFEnergyCalibration ( )

Definition at line 15 of file PFEnergyCalibration.cc.

References initializeCalibrationFunctions().

                                          : pfCalibrations(0), esEEInterCalib_(0)
 {
   initializeCalibrationFunctions();
 }

PFEnergyCalibration::~PFEnergyCalibration ( )

Definition at line 20 of file PFEnergyCalibration.cc.

References faBarrel, faEndcap, faEtaBarrel, faEtaEndcap, fbBarrel, fbEndcap, fbEtaBarrel, fbEtaEndcap, fcBarrel, and fcEndcap.

 {
 
   delete faBarrel;
   delete fbBarrel;
   delete fcBarrel;
   delete faEtaBarrel;
   delete fbEtaBarrel;
   delete faEndcap;
   delete fbEndcap;
   delete fcEndcap;
   delete faEtaEndcap;
   delete fbEtaEndcap;
 
 }

Member Function Documentation

double PFEnergyCalibration::aBarrel ( double x ) const

private

Definition at line 227 of file PFEnergyCalibration.cc.

References faBarrel, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfa_BARREL, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfa_BARREL,point); 
 
   } else { 
 
     return faBarrel->Eval(x); 
 
   }
 }

double PFEnergyCalibration::aEndcap ( double x ) const

private

Definition at line 307 of file PFEnergyCalibration.cc.

References faEndcap, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfa_ENDCAP, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfa_ENDCAP,point); 
 
   } else { 
 
     return faEndcap->Eval(x); 
 
   }
 }

double PFEnergyCalibration::aEtaBarrel ( double x ) const

private

Definition at line 275 of file PFEnergyCalibration.cc.

References faEtaBarrel, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfaEta_BARREL, and point.

Referenced by energyEmHad().

                                               { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfaEta_BARREL,point); 
 
   } else { 
 
     return faEtaBarrel->Eval(x); 
 
   }
 }

double PFEnergyCalibration::aEtaEndcap ( double x ) const

private

Definition at line 355 of file PFEnergyCalibration.cc.

References faEtaEndcap, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfaEta_ENDCAP, and point.

Referenced by energyEmHad().

                                               { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfaEta_ENDCAP,point); 
 
   } else { 
 
     return faEtaEndcap->Eval(x); 
 
   }
 }

double PFEnergyCalibration::Alpha ( double eta ) const

private

Definition at line 676 of file PFEnergyCalibration.cc.

References constexpr, eta, p1, p2, and mps_fire::result.

Referenced by EcorrPS().

                                            {
 
   //Energy dependency
   constexpr double p0 = 5.97621e-01;
 
   //Eta dependency
   constexpr double p1 =-1.86407e-01;
   constexpr double p2 = 3.85197e-01; 
 
   //so that <feta()> = 1
   constexpr double norm = (p1+p2*(2.6+1.656)/2);
 
   double result = p0*(p1+p2*eta)/norm;
 
   return result;
 }

double PFEnergyCalibration::bBarrel ( double x ) const

private

Definition at line 243 of file PFEnergyCalibration.cc.

References fbBarrel, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfb_BARREL, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfb_BARREL,point); 
 
   } else { 
 
     return fbBarrel->Eval(x); 
 
   }
 }

double PFEnergyCalibration::bEndcap ( double x ) const

private

Definition at line 323 of file PFEnergyCalibration.cc.

References fbEndcap, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfb_ENDCAP, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfb_ENDCAP,point); 
 
   } else { 
 
     return fbEndcap->Eval(x); 
 
   }
 }

double PFEnergyCalibration::Beta	(	double	E,
		double	eta
	)		const

private

Definition at line 694 of file PFEnergyCalibration.cc.

References constexpr, p1, p2, p3, p4, and mps_fire::result.

Referenced by EcorrPS().

                                                     {
 
  //Energy dependency
   constexpr double p0 = 0.032;
   constexpr double p1 = 9.70394e-02;
   constexpr double p2 = 2.23072e+01;
   constexpr double p3 = 100;
 
   //Eta dependency
   constexpr double p4 = 1.02496e+00 ;
   constexpr double p5 = -4.40176e-03 ;
 
   //so that <feta()> = 1
   constexpr double norm = (p4+p5*(2.6+1.656)/2);
 
   double result = (1.0012+p0*TMath::Exp(-E/p3)+p1*TMath::Exp(-E/p2))*(p4+p5*eta)/norm;            
   return result;
 }

double PFEnergyCalibration::bEtaBarrel ( double x ) const

private

Definition at line 291 of file PFEnergyCalibration.cc.

References fbEtaBarrel, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfbEta_BARREL, and point.

Referenced by energyEmHad().

                                               { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfbEta_BARREL,point); 
 
   } else { 
 
     return fbEtaBarrel->Eval(x); 
 
   }
 }

double PFEnergyCalibration::bEtaEndcap ( double x ) const

private

Definition at line 371 of file PFEnergyCalibration.cc.

References fbEtaEndcap, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfbEta_ENDCAP, and point.

Referenced by energyEmHad().

                                               { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfbEta_ENDCAP,point); 
 
   } else { 
 
     return fbEtaEndcap->Eval(x); 
 
   }
 }

double PFEnergyCalibration::cBarrel ( double x ) const

private

Definition at line 259 of file PFEnergyCalibration.cc.

References fcBarrel, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfc_BARREL, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfc_BARREL,point); 
 
   } else { 
 
     return fcBarrel->Eval(x); 
 
   }
 }

double PFEnergyCalibration::cEndcap ( double x ) const

private

Definition at line 339 of file PFEnergyCalibration.cc.

References fcEndcap, PerformancePayloadFromTFormula::getResult(), BinningPointByMap::insert(), BinningVariables::JetEt, pfCalibrations, PerformanceResult::PFfc_ENDCAP, and point.

Referenced by energyEmHad().

                                            { 
 
   if ( pfCalibrations ) { 
 
     BinningPointByMap point;
     point.insert(BinningVariables::JetEt, x);
     return pfCalibrations->getResult(PerformanceResult::PFfc_ENDCAP,point); 
 
   } else { 
 
     return fcEndcap->Eval(x); 
 
   }
 }

double PFEnergyCalibration::CorrBarrel	(	double	E,
		double	eta
	)		const

private

Definition at line 630 of file PFEnergyCalibration.cc.

References constexpr, p1, p2, p3, p4, and mps_fire::result.

Referenced by EcorrBarrel().

                                                           {
 
   //Energy dependency
   /*
   //YM Parameters 52XX:
   constexpr double p0=1.00000e+00;
   constexpr double p1=3.27753e+01;
   constexpr double p2=2.28552e-02;
   constexpr double p3=3.06139e+00;
   constexpr double p4=2.25135e-01;
   constexpr double p5=1.47824e+00;
   constexpr double p6=1.09e-02;
   constexpr double p7=4.19343e+01;
   */
   constexpr double p0 = 0.9944;
   constexpr double p1 = 9.827;
   constexpr double p2 = 1.503;
   constexpr double p3 = 1.196;
   constexpr double p4 = 0.3349;
   constexpr double p5 = 0.89;
   constexpr double p6 = 0.004361;
   constexpr double p7 = 51.51;
   //Eta dependency
   constexpr double p8=2.705593e-03;
   
   double result = (p0+1/(p1+p2*TMath::Power(E,p3))+p4*TMath::Exp(-E/p5)+p6*TMath::Exp(-E*E/(p7*p7)))*(1+p8*eta*eta);
 
   return result;
 }

double PFEnergyCalibration::CorrEta ( double eta ) const

private

Definition at line 612 of file PFEnergyCalibration.cc.

References a, Abs(), constexpr, i, visualization-live-secondInstance_cfg::m, mps_fire::result, alignCSCRings::s, Sign(), and contentValuesCheck::ss.

Referenced by EcorrBarrel().

                                              {
   
   // we use a gaussian with a screwness for each of the 5 |eta|-cracks
   constexpr double a[] = {6.13349e-01, 5.08146e-01, 4.44480e-01, 3.3487e-01, 7.65627e-01}; // amplitude
   constexpr double m[] = {-1.79514e-02, 4.44747e-01, 7.92824e-01, 1.14090e+00, 1.47464e+00}; // mean
   constexpr double s[] = {7.92382e-03, 3.06028e-03, 3.36139e-03, 3.94521e-03, 8.63950e-04}; // sigma
   constexpr double sa[] = {1.27228e+01, 3.81517e-02, 1.63507e-01, -6.56480e-02, 1.87160e-01}; // screwness amplitude
   constexpr double ss[] = {5.48753e-02, -1.00223e-02, 2.22866e-03, 4.26288e-04, 2.67937e-03}; // screwness sigma
   double result = 1;
 
   for(unsigned i=0;i<=4;i++) result+=a[i]*TMath::Gaus(eta,m[i],s[i])*(1+sa[i]*TMath::Sign(1.,eta-m[i])*TMath::Exp(-TMath::Abs(eta-m[i])/ss[i]));
 
   return result;
 }

double PFEnergyCalibration::CorrPhi	(	double	phi,
		double	eta
	)		const

private

Definition at line 586 of file PFEnergyCalibration.cc.

References constexpr, dCrackPhi(), p1, p2, p3, p4, and mps_fire::result.

Referenced by EcorrBarrel().

                                                          {
 
   // we use 3 gaussians to correct the phi-cracks effect
   constexpr double p1=   5.59379e-01;
   constexpr double p2=   -1.26607e-03;
   constexpr double p3=  9.61133e-04;
 
   constexpr double p4=   1.81691e-01;
   constexpr double p5=   -4.97535e-03;
   constexpr double p6=   1.31006e-03;
 
   constexpr double p7=   1.38498e-01;
   constexpr double p8=   1.18599e-04;
   constexpr double p9= 2.01858e-03;
   
 
   double dminphi = dCrackPhi(phi,eta);
   
   double result = (1+p1*TMath::Gaus(dminphi,p2,p3)+p4*TMath::Gaus(dminphi,p5,p6)+p7*TMath::Gaus(dminphi,p8,p9));
 
   return result;
 }   

double PFEnergyCalibration::dCrackPhi	(	double	phi,
		double	eta
	)		const

private

Definition at line 544 of file PFEnergyCalibration.cc.

References constexpr, gather_cfg::cout, i, visualization-live-secondInstance_cfg::m, minimum(), and pi.

Referenced by CorrPhi().

                                                            {
 
   
   //Shift of this location if eta<0
   constexpr double delta_cPhi=0.00638;
 
   double m; //the result
 
   //the location is shifted
   if(eta<0) phi +=delta_cPhi;
 
   if (phi>=-pi && phi<=pi){
 
     //the problem of the extrema
     if (phi<cPhi[17] || phi>=cPhi[0]){
       if (phi<0) phi+= 2*pi;
       m = minimum(phi -cPhi[0],phi-cPhi[17]-2*pi);          
     }
 
     //between these extrema...
     else{
       bool OK = false;
       unsigned i=16;
       while(!OK){
     if (phi<cPhi[i]){
       m=minimum(phi-cPhi[i+1],phi-cPhi[i]);
       OK=true;
     }
     else i-=1;
       }
     }
   }
   else{
     m=0.;        //if there is a problem, we assum that we are in a crack
     std::cout<<"Problem in dminphi"<<std::endl;
   }
   if(eta<0) m=-m;   //because of the disymetry
   return m;
 }

double PFEnergyCalibration::Ecorr	(	double	eEcal,
		double	ePS1,
		double	ePS2,
		double	eta,
		double	phi,
		bool	crackCorrection = `true`
	)		const

private

Definition at line 907 of file PFEnergyCalibration.cc.

References Abs(), constexpr, EcorrBarrel(), EcorrPS(), EcorrPS_ePSNil(), EcorrZoneAfterPS(), EcorrZoneBeforePS(), and mps_fire::result.

Referenced by energyEm().

                                             {
 
   constexpr double endBarrel=1.48;
   constexpr double beginingPS=1.65;
   constexpr double endPS=2.6;
   constexpr double endEndCap=2.98;
  
   double result=0;
 
   eta=TMath::Abs(eta);
 
   if(eEcal>0){
     if(eta <= endBarrel)                         result = EcorrBarrel(eEcal,eta,phi,crackCorrection);
     else if(eta <= beginingPS)                   result = EcorrZoneBeforePS(eEcal,eta);
     else if((eta < endPS) && ePS1==0 && ePS2==0) result = EcorrPS_ePSNil(eEcal,eta);
     else if(eta < endPS)                         result = EcorrPS(eEcal,ePS1,ePS2,eta);
     else if(eta < endEndCap)                     result = EcorrZoneAfterPS(eEcal,eta); 
     else result =eEcal;
   }
   else result = eEcal;// useful if eEcal=0 or eta>2.98
   //protection
   if(result<eEcal) result=eEcal;
   return result;
 }

double PFEnergyCalibration::Ecorr	(	double	eEcal,
		double	ePS1,
		double	ePS2,
		double	eta,
		double	phi,
		double &	ps1,
		double &	ps2,
		bool	crackCorrection = `true`
	)		const

private

Definition at line 937 of file PFEnergyCalibration.cc.

References Abs(), constexpr, EcorrBarrel(), EcorrPS(), EcorrPS_ePSNil(), EcorrZoneAfterPS(), EcorrZoneBeforePS(), and mps_fire::result.

                                                                                                                                         {
 
   constexpr double endBarrel=1.48;
   constexpr double beginingPS=1.65;
   constexpr double endPS=2.6;
   constexpr double endEndCap=2.98;
  
   double result=0;
 
   eta=TMath::Abs(eta);
 
   if(eEcal>0){
     if(eta <= endBarrel)                         result = EcorrBarrel(eEcal,eta,phi,crackCorrection);
     else if(eta <= beginingPS)                   result = EcorrZoneBeforePS(eEcal,eta);
     else if((eta < endPS) && ePS1==0 && ePS2==0) result = EcorrPS_ePSNil(eEcal,eta);
     else if(eta < endPS)                         result = EcorrPS(eEcal,ePS1,ePS2,eta,ps1,ps2);
     else if(eta < endEndCap)                     result = EcorrZoneAfterPS(eEcal,eta); 
     else result =eEcal;
   }
   else result = eEcal;// useful if eEcal=0 or eta>2.98
   // protection
   if(result<eEcal) result=eEcal;
   return result;
 }

double PFEnergyCalibration::EcorrBarrel	(	double	E,
		double	eta,
		double	phi,
		bool	crackCorrection = `true`
	)		const

private

Definition at line 744 of file PFEnergyCalibration.cc.

References CorrBarrel(), CorrEta(), CorrPhi(), bookConverter::max, and mps_fire::result.

Referenced by Ecorr().

                                               {
 
   // double result = E*CorrBarrel(E,eta)*CorrEta(eta)*CorrPhi(phi,eta);
   double correction = crackCorrection ? std::max(CorrEta(eta),CorrPhi(phi,eta)) : 1.;
   double result = E * CorrBarrel(E,eta) * correction;
 
   return result;
 }

double PFEnergyCalibration::EcorrPS	(	double	eEcal,
		double	ePS1,
		double	ePS2,
		double	etaEcal
	)		const

private

Definition at line 783 of file PFEnergyCalibration.cc.

References Alpha(), Beta(), constexpr, alignCSCRings::e, Gamma(), p1, p2, p3, p4, and mps_fire::result.

Referenced by Ecorr().

                                                                                       {
 
   // gives the good weights to each subdetector
   double E = Beta(1.0155*eEcal+0.025*(ePS1+0.5976*ePS2)/9e-5,etaEcal)*eEcal+Gamma(etaEcal)*(ePS1+Alpha(etaEcal)*ePS2)/9e-5 ;
 
   //Correction of the residual energy dependency
   constexpr double p0 = 1.00;
   constexpr double p1 = 2.18;
   constexpr double p2 =1.94;
   constexpr double p3 =4.13;
   constexpr double p4 =1.127;
 
   double result = E*(p0+p1*TMath::Exp(-E/p2)-p3*TMath::Exp(-E/p4));
 
   return result;
 } 

double PFEnergyCalibration::EcorrPS	(	double	eEcal,
		double	ePS1,
		double	ePS2,
		double	etaEcal,
		double &	outputPS1,
		double &	outputPS2
	)		const

private

Definition at line 803 of file PFEnergyCalibration.cc.

References Alpha(), Beta(), constexpr, alignCSCRings::e, esEEInterCalib_, Gamma(), ESEEIntercalibConstants::getGammaLow0(), ESEEIntercalibConstants::getGammaLow1(), ESEEIntercalibConstants::getGammaLow2(), ESEEIntercalibConstants::getGammaLow3(), p1, p2, p3, p4, and mps_fire::result.

                                                                                                                              {
 
   // gives the good weights to each subdetector
   double gammaprime=Gamma(etaEcal)/9e-5;
 
   if(outputPS1 == 0 && outputPS2 == 0 && esEEInterCalib_ != 0){
     // both ES planes working
     // scaling factor accounting for data-mc                                                                                 
     outputPS1=gammaprime*ePS1 * esEEInterCalib_->getGammaLow0();
     outputPS2=gammaprime*Alpha(etaEcal)*ePS2 * esEEInterCalib_->getGammaLow3();
   }
   else if(outputPS1 == 0 && outputPS2 == -1 && esEEInterCalib_ != 0){
     // ESP1 only working
     outputPS1 = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0() * esEEInterCalib_->getGammaLow1();
     outputPS2 = gammaprime*Alpha(etaEcal)*ePS2 * esEEInterCalib_->getGammaLow3() * esEEInterCalib_->getGammaLow1();
   }
   else if(outputPS1 == -1 && outputPS2 == 0 && esEEInterCalib_ != 0){
     // ESP2 only working
     outputPS1 = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0() * esEEInterCalib_->getGammaLow2();
     outputPS2 = gammaprime*Alpha(etaEcal)*ePS2 * esEEInterCalib_->getGammaLow3() * esEEInterCalib_->getGammaLow2();
   }
   else{
     // none working
     outputPS1 = gammaprime*ePS1;
     outputPS2 = gammaprime*Alpha(etaEcal)*ePS2;
   }
 
   double E = Beta(1.0155*eEcal+0.025*(ePS1+0.5976*ePS2)/9e-5,etaEcal)*eEcal+outputPS1+outputPS2;
 
   //Correction of the residual energy dependency
   constexpr double p0 = 1.00;
   constexpr double p1 = 2.18;
   constexpr double p2 =1.94;
   constexpr double p3 =4.13;
   constexpr double p4 =1.127;
   
   double corrfac=(p0+p1*TMath::Exp(-E/p2)-p3*TMath::Exp(-E/p4));
   outputPS1*=corrfac;
   outputPS2*=corrfac;
   double result = E*corrfac;
 
   return result;
 } 

double PFEnergyCalibration::EcorrPS_ePSNil	(	double	eEcal,
		double	eta
	)		const

private

Definition at line 851 of file PFEnergyCalibration.cc.

References Abs(), constexpr, p1, p2, p3, p4, and mps_fire::result.

Referenced by Ecorr().

                                                                  {
 
   //Energy dependency
   constexpr double p0= 1.02;
   constexpr double p1= 0.165;
   constexpr double p2= 6.5 ;
   constexpr double p3=  2.1 ;
 
   //Eta dependency
   constexpr double p4 = 1.02496e+00 ;
   constexpr double p5 = -4.40176e-03 ;
 
   //so that <feta()> = 1
   constexpr double norm = (p4+p5*(2.6+1.656)/2);
 
   double result = eEcal*(p0+p1*TMath::Exp(-TMath::Abs(eEcal-p3)/p2))*(p4+p5*eta)/norm;
           
   return result;
 }

double PFEnergyCalibration::EcorrZoneAfterPS	(	double	E,
		double	eta
	)		const

private

Definition at line 874 of file PFEnergyCalibration.cc.

References constexpr, p1, p2, p3, p4, and mps_fire::result.

Referenced by Ecorr().

                                                                 {
 
   //Energy dependency
   constexpr double p0 =1; 
   constexpr double p1 = 0.058;
   constexpr double p2 =12.5;
   constexpr double p3 =-1.05444e+00;
   constexpr double p4 =-5.39557e+00;
   constexpr double p5 =8.38444e+00;
   constexpr double p6 = 6.10998e-01  ;
 
   //Eta dependency
   constexpr double p7 =1.06161e+00;
   constexpr double p8 = 0.41;
   constexpr double p9 =2.918;
   constexpr double p10 =0.0181;
   constexpr double p11= 2.05;
   constexpr double p12 =2.99;
   constexpr double p13=0.0287;
 
   //so that <feta()> = 1
   constexpr double norm=1.045;
 
   double result = E*(p0+p1*TMath::Exp(-(E-p3)/p2)+1/(p4+p5*TMath::Power(E,p6)))*(p7+p8*TMath::Gaus(eta,p9,p10)+p11*TMath::Gaus(eta,p12,p13))/norm;
   return result;
 }

double PFEnergyCalibration::EcorrZoneBeforePS	(	double	E,
		double	eta
	)		const

private

Definition at line 757 of file PFEnergyCalibration.cc.

References constexpr, eta, p1, p2, p3, p4, and mps_fire::result.

Referenced by Ecorr().

                                                                  {
 
  //Energy dependency
   constexpr double p0 =1; 
   constexpr double p1 =0.18;
   constexpr double p2 =8.;
 
   //Eta dependency
   constexpr double p3 =0.3;
   constexpr double p4 =1.11;
   constexpr double p5 =0.025;
   constexpr double p6 =1.49;
   constexpr double p7 =0.6;
 
   //so that <feta()> = 1
   constexpr double norm = 1.21;
 
   double result = E*(p0+p1*TMath::Exp(-E/p2))*(p3+p4*TMath::Gaus(eta,p6,p5)+p7*eta)/norm;
 
   return result;
 }

double PFEnergyCalibration::energyEm	(	const reco::PFCluster &	clusterEcal,
		std::vector< double > &	EclustersPS1,
		std::vector< double > &	EclustersPS2,
		bool	crackCorrection = `true`
	)		const

Definition at line 388 of file PFEnergyCalibration.cc.

Referenced by energyEm().

                                                {
   double ePS1(std::accumulate(EclustersPS1.begin(), EclustersPS1.end(), 0.0));
   double ePS2(std::accumulate(EclustersPS2.begin(), EclustersPS2.end(), 0.0));
   return energyEm(clusterEcal, ePS1, ePS2, crackCorrection);
 }

double PFEnergyCalibration::energyEm	(	const reco::PFCluster &	clusterEcal,
		double	ePS1,
		double	ePS2,
		bool	crackCorrection = `true`
	)		const

Definition at line 398 of file PFEnergyCalibration.cc.

References reco::PFCluster::calculatePositionREP(), Ecorr(), reco::PFCluster::energy(), eta, phi, and reco::PFCluster::positionREP().

                                                {
   double eEcal = clusterEcal.energy();
   //temporaty ugly fix
   reco::PFCluster myPFCluster=clusterEcal;
   myPFCluster.calculatePositionREP();
   double eta = myPFCluster.positionREP().eta();
   double phi = myPFCluster.positionREP().phi();
 
   double calibrated = Ecorr(eEcal,ePS1,ePS2,eta,phi, crackCorrection);
   // if(eEcal!=0 && calibrated==0) std::cout<<"Eecal = "<<eEcal<<"  eta = "<<eta<<"  phi = "<<phi<<std::endl; 
   return calibrated; 
 }

double PFEnergyCalibration::energyEm	(	const reco::PFCluster &	clusterEcal,
		std::vector< double > &	EclustersPS1,
		std::vector< double > &	EclustersPS2,
		double &	ps1,
		double &	ps2,
		bool	crackCorrection = `true`
	)		const

Definition at line 414 of file PFEnergyCalibration.cc.

References energyEm().

                                                  {
   double ePS1(std::accumulate(EclustersPS1.begin(), EclustersPS1.end(), 0.0));
   double ePS2(std::accumulate(EclustersPS2.begin(), EclustersPS2.end(), 0.0));
   return energyEm(clusterEcal, ePS1, ePS2, ps1, ps2, crackCorrection);
 }

double PFEnergyCalibration::energyEm	(	const reco::PFCluster &	clusterEcal,
		double	ePS1,
		double	ePS2,
		double &	ps1,
		double &	ps2,
		bool	crackCorrection = `true`
	)		const

Definition at line 423 of file PFEnergyCalibration.cc.

References reco::PFCluster::calculatePositionREP(), Ecorr(), reco::PFCluster::energy(), eta, phi, and reco::PFCluster::positionREP().

                                                  {
   double eEcal = clusterEcal.energy();
   //temporaty ugly fix
   reco::PFCluster myPFCluster=clusterEcal;
   myPFCluster.calculatePositionREP();
   double eta = myPFCluster.positionREP().eta();
   double phi = myPFCluster.positionREP().phi();
 
   double calibrated = Ecorr(eEcal,ePS1,ePS2,eta,phi,ps1,ps2,crackCorrection);
   // if(eEcal!=0 && calibrated==0) std::cout<<"Eecal = "<<eEcal<<"  eta = "<<eta<<"  phi = "<<phi<<std::endl; 
   return calibrated; 
 }

void PFEnergyCalibration::energyEmHad	(	double	t,
		double &	e,
		double &	h,
		double	eta,
		double	phi
	)		const

Definition at line 134 of file PFEnergyCalibration.cc.

References a, aBarrel(), funct::abs(), aEndcap(), aEtaBarrel(), aEtaEndcap(), b, bBarrel(), bEndcap(), bEtaBarrel(), bEtaEndcap(), cBarrel(), cEndcap(), alignCSCRings::e, h, bookConverter::max, min(), lumiQTWidget::t, GOODCOLL_filter_cfg::thresh, threshE, threshH, and groupFilesInBlocks::tt.

                                                                                             { 
  
   
   // Use calorimetric energy as true energy for neutral particles
   double tt = t;
   double ee = e;
   double hh = h;
   double a = 1.;
   double b = 1.;
   double etaCorrE = 1.;
   double etaCorrH = 1.;
   t = min(999.9,max(tt,e+h));
   if ( t < 1. ) return;
 
   // Barrel calibration
   if ( std::abs(eta) < 1.48 ) { 
 
     // The energy correction
     a = e>0. ? aBarrel(t) : 1.;
     b = e>0. ? bBarrel(t) : cBarrel(t);
     double thresh = e > 0. ? threshE : threshH;
 
     // Protection against negative calibration - to be tuned
     if ( a < -0.25 || b < -0.25 ) { 
       a = 1.;
       b = 1.;
       thresh = 0.;
     }
 
     // The new estimate of the true energy
     t = min(999.9,max(tt, thresh+a*e+b*h));
 
     // The angular correction for ECAL hadronic deposits
     etaCorrE = 1. + aEtaBarrel(t) + 2.2*bEtaBarrel(t)*std::abs(eta)*std::abs(eta);
     etaCorrH = 1.;
     // etaCorr = 1.;
     //t = max(tt, thresh+etaCorrE*a*e+etaCorrH*b*h);
 
     if ( e > 0. && thresh > 0. ) 
       e = h > 0. ? threshE-threshH + etaCorrE * a * e : threshE + etaCorrE * a * e;
     if ( h > 0. && thresh > 0. ) 
       h = threshH + etaCorrH * b * h;
 
   // Endcap calibration   
   } else {
 
     // The energy correction
     a = e>0. ? aEndcap(t) : 1.;
     b = e>0. ? bEndcap(t) : cEndcap(t);
     double thresh = e > 0. ? threshE : threshH;
 
     if ( a < -0.25 || b < -0.25 ) { 
       a = 1.;
       b = 1.;
       thresh = 0.;
     }
 
     // The new estimate of the true energy
     t = min(999.9,max(tt, thresh+a*e+b*h));
     
     // The angular correction 
  
     double dEta = std::abs( std::abs(eta) - 1.5 );
     double etaPow = dEta * dEta * dEta * dEta;
     //MM: 0.1 factor helps the parametrization
     etaCorrE = 1. + aEtaEndcap(t) + 0.1*bEtaEndcap(t)*etaPow;
     etaCorrH = 1. + aEtaEndcap(t) + bEtaEndcap(t)*etaPow;
     
     //t = min(999.9,max(tt, thresh + etaCorrE*a*e + etaCorrH*b*h));
 
     if ( e > 0. && thresh > 0. ) 
       e = h > 0. ? threshE-threshH + etaCorrE * a * e : threshE + etaCorrE * a * e;
     if ( h > 0. && thresh > 0. ) 
       h = threshH + b * etaCorrH * h;
 
 
   }
 
   // Protection
   if ( e < 0. || h < 0. ) {
   
     // Some protection against crazy calibration
     if ( e < 0. ) e = ee;
     if ( h < 0. ) h = hh;
   }
 
   // And that's it !
 
   
 }

double PFEnergyCalibration::Gamma ( double etaEcal ) const

private

Definition at line 715 of file PFEnergyCalibration.cc.

References constexpr, p1, p2, and mps_fire::result.

Referenced by EcorrPS().

                                                {
 
  //Energy dependency
   constexpr double p0 = 2.49752e-02;
 
   //Eta dependency
   constexpr double p1 = 6.48816e-02;
   constexpr double p2 = -1.59517e-02; 
  
   //so that <feta()> = 1
   constexpr double norm = (p1+p2*(2.6+1.656)/2);
 
   double result = p0*(p1+p2*etaEcal)/norm;                    
 
   return result;
 }

void PFEnergyCalibration::initAlphaGamma_ESplanes_fromDB ( const ESEEIntercalibConstants * esEEInterCalib )

inline

Definition at line 78 of file PFEnergyCalibration.h.

References esEEInterCalib_.

                                                                                     {
     esEEInterCalib_ = esEEInterCalib;
   }

void PFEnergyCalibration::initializeCalibrationFunctions ( )

Definition at line 37 of file PFEnergyCalibration.cc.

References alignCSCRings::e, faBarrel, faEndcap, faEtaBarrel, faEtaEndcap, fbBarrel, fbEndcap, fbEtaBarrel, fbEtaEndcap, fcBarrel, fcEndcap, threshE, and threshH.

Referenced by PFEnergyCalibration().

                                                     {
 
   // NEW NEW with HCAL pre-calibration
 
   threshE = 3.5;
   threshH = 2.5;
 
   // Barrel (fit made with |eta| < 1.2)
   faBarrel = new TF1("faBarrel","(x<190)?([0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))):([9]+[10]*exp(-x/[11]))",1.,1000.);
   faBarrel->SetParameter(0,-18.7813);
   faBarrel->SetParameter(1,2.49368);
   faBarrel->SetParameter(2,10.3321);
   faBarrel->SetParameter(3,0.074916);
   faBarrel->SetParameter(4,-17.5757);
   faBarrel->SetParameter(5,-7.94004e+06);
   faBarrel->SetParameter(6,-1.66603);
   faBarrel->SetParameter(7,-1464.26);
   faBarrel->SetParameter(8,0.881126);
   faBarrel->SetParameter(9,1.09984);
   faBarrel->SetParameter(10,0.394544);
   faBarrel->SetParameter(11,562.407);
   fbBarrel = new TF1("fbBarrel","(x<190)?([0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))):([9]+[10]*exp(-x/[11]))",1.,1000.);
   fbBarrel->SetParameter(0,3.44547);
   fbBarrel->SetParameter(1,0.812146);
   fbBarrel->SetParameter(2,-7.41084);
   fbBarrel->SetParameter(3,1.82401);
   fbBarrel->SetParameter(4,2.70183);
   fbBarrel->SetParameter(5,0.0397483);
   fbBarrel->SetParameter(6,0.44918);
   fbBarrel->SetParameter(7,-1.04172);
   fbBarrel->SetParameter(8,-0.205864);
   fbBarrel->SetParameter(9,0.930077);
   fbBarrel->SetParameter(10,0.666935);
   fbBarrel->SetParameter(11,56.9643);
   fcBarrel = new TF1("fcBarrel","[0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fcBarrel->SetParameter(0,1.35401);
   fcBarrel->SetParameter(1,0.121855);
   fcBarrel->SetParameter(2,-3.51745);
   fcBarrel->SetParameter(3,382655);
   fcBarrel->SetParameter(4,0.464902);
   fcBarrel->SetParameter(5,0.0229584);
   fcBarrel->SetParameter(6,2.62871);
   fcBarrel->SetParameter(7,-1.46264);
   fcBarrel->SetParameter(8,0.983422);
   faEtaBarrel = new TF1("faEtaBarrelEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   faEtaBarrel->SetParameter(0,-0.03);
   faEtaBarrel->SetParameter(1,0.0443975);
   faEtaBarrel->SetParameter(2,62.3599);
   fbEtaBarrel = new TF1("fbEtaBarrelEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   fbEtaBarrel->SetParameter(0,0.0266189);
   fbEtaBarrel->SetParameter(1,0.0828236);
   fbEtaBarrel->SetParameter(2,68.0159);
 
   // End-caps (fit made with eta 
    faEndcap = new TF1("faEndcap","[0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   faEndcap->SetParameter(0,3.10102);
   faEndcap->SetParameter(1,37.0556);
   faEndcap->SetParameter(2,-42.0353);
   faEndcap->SetParameter(3,29.7847);
   faEndcap->SetParameter(4,1.83545);
   faEndcap->SetParameter(5,0.00670624);
   faEndcap->SetParameter(6,0.89783);
   faEndcap->SetParameter(7,-1.73037);
   faEndcap->SetParameter(8,0.0329707);
   fbEndcap = new TF1("fbEndcap","[0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fbEndcap->SetParameter(0,-1.07747);
   fbEndcap->SetParameter(1,10.9055);
   fbEndcap->SetParameter(2,-8.88263);
   fbEndcap->SetParameter(3,0.0963555);
   fbEndcap->SetParameter(4,-0.627371);
   fbEndcap->SetParameter(5,0.0023847);
   fbEndcap->SetParameter(6,-2.17868);
   fbEndcap->SetParameter(7,-2.67134);
   fbEndcap->SetParameter(8,-0.0108459);
   fcEndcap = new TF1("fcEndcap","[0]+((([1]+([2]/x^[8]))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fcEndcap->SetParameter(0,1.13795);
   fcEndcap->SetParameter(1,1.21698);
   fcEndcap->SetParameter(2,-3.81192);
   fcEndcap->SetParameter(3,115.409);
   fcEndcap->SetParameter(4,0.673456);
   fcEndcap->SetParameter(5,0.217077);
   fcEndcap->SetParameter(6,1.95596);
   fcEndcap->SetParameter(7,-0.252215);
   fcEndcap->SetParameter(8,0.506146);
   faEtaEndcap = new TF1("faEtaEndcapEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   faEtaEndcap->SetParameter(0,0.0135773);
   faEtaEndcap->SetParameter(1,-0.0276094);
   faEtaEndcap->SetParameter(2,103.144);
   fbEtaEndcap = new TF1("fbEtaEndcapEH","[0]+[1]*x*exp(x*[2])",1.,1000.);
   fbEtaEndcap->SetParameter(0,0.181798);
   fbEtaEndcap->SetParameter(1,-0.00087979);
   fbEtaEndcap->SetParameter(2,-0.00231785);
  
   
 }

double PFEnergyCalibration::minimum	(	double	a,
		double	b
	)		const

private

Definition at line 520 of file PFEnergyCalibration.cc.

References a, Abs(), and b.

Referenced by dCrackPhi().

                                                     {
   if(TMath::Abs(b)<TMath::Abs(a)) a=b;
   return a;
 }

void PFEnergyCalibration::setCalibrationFunctions ( const PerformancePayloadFromTFormula * thePFCal )

inline

Definition at line 74 of file PFEnergyCalibration.h.

References pfCalibrations.

                                                                                {
     pfCalibrations = thePFCal;
   }

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	out,
		const PFEnergyCalibration &	calib
	)

friend

Definition at line 440 of file PFEnergyCalibration.cc.

                                                {
 
   if(!out ) return out;
 
   out<<"PFEnergyCalibration -- "<<endl;
 
   if ( calib.pfCalibrations ) { 
 
     std::cout << "Functions taken from the global tags : " << std::endl;
 
     static std::map<std::string, PerformanceResult::ResultType> functType;
 
     functType["PFfa_BARREL"] = PerformanceResult::PFfa_BARREL;
     functType["PFfa_ENDCAP"] = PerformanceResult::PFfa_ENDCAP;
     functType["PFfb_BARREL"] = PerformanceResult::PFfb_BARREL;
     functType["PFfb_ENDCAP"] = PerformanceResult::PFfb_ENDCAP;
     functType["PFfc_BARREL"] = PerformanceResult::PFfc_BARREL;
     functType["PFfc_ENDCAP"] = PerformanceResult::PFfc_ENDCAP;
     functType["PFfaEta_BARREL"] = PerformanceResult::PFfaEta_BARREL;
     functType["PFfaEta_ENDCAP"] = PerformanceResult::PFfaEta_ENDCAP;
     functType["PFfbEta_BARREL"] = PerformanceResult::PFfbEta_BARREL;
     functType["PFfbEta_ENDCAP"] = PerformanceResult::PFfbEta_ENDCAP;
     
     for(std::map<std::string,PerformanceResult::ResultType>::const_iterator 
       func = functType.begin(); 
         func != functType.end(); 
         ++func) {    
       
       cout << "Function: " << func->first << endl;
       PerformanceResult::ResultType fType = func->second;
       calib.pfCalibrations->printFormula(fType);
     }
 
   } else { 
     
     std::cout << "Default calibration functions : " << std::endl;
     
     calib.faBarrel->Print();
     calib.fbBarrel->Print();
     calib.fcBarrel->Print();
     calib.faEtaBarrel->Print();
     calib.fbEtaBarrel->Print();
     calib.faEndcap->Print();
     calib.fbEndcap->Print();
     calib.fcEndcap->Print();
     calib.faEtaEndcap->Print();
     calib.fbEtaEndcap->Print();
   }
     
   return out;
 }