#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_

std::unique_ptr< TF1 >	faBarrel

std::unique_ptr< TF1 >	faEndcap

std::unique_ptr< TF1 >	faEtaBarrelEH

std::unique_ptr< TF1 >	faEtaBarrelH

std::unique_ptr< TF1 >	faEtaEndcapEH

std::unique_ptr< TF1 >	faEtaEndcapH

std::unique_ptr< TF1 >	fbBarrel

std::unique_ptr< TF1 >	fbEndcap

std::unique_ptr< TF1 >	fbEtaBarrelEH

std::unique_ptr< TF1 >	fbEtaBarrelH

std::unique_ptr< TF1 >	fbEtaEndcapEH

std::unique_ptr< TF1 >	fbEtaEndcapH

std::unique_ptr< TF1 >	fcBarrel

std::unique_ptr< TF1 >	fcEndcap

const PerformancePayloadFromTFormula *	pfCalibrations

Private Member Functions
double	aBarrel (double x) const

double	aEndcap (double x) const

double	aEtaBarrelEH (double x) const

double	aEtaBarrelH (double x) const

double	aEtaEndcapEH (double x) const

double	aEtaEndcapH (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	bEtaBarrelEH (double x) const

double	bEtaBarrelH (double x) const

double	bEtaEndcapEH (double x) const

double	bEtaEndcapH (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 16 of file PFEnergyCalibration.cc.

References initializeCalibrationFunctions().

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

PFEnergyCalibration::~PFEnergyCalibration ( )

Definition at line 21 of file PFEnergyCalibration.cc.

 {
 
 }

Member Function Documentation

double PFEnergyCalibration::aBarrel ( double x ) const

private

Definition at line 236 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 347 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::aEtaBarrelEH ( double x ) const

private

Definition at line 283 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::aEtaBarrelH ( double x ) const

private

Definition at line 315 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::aEtaEndcapEH ( double x ) const

private

Definition at line 395 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::aEtaEndcapH ( double x ) const

private

Definition at line 427 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::Alpha ( double eta ) const

private

Definition at line 755 of file PFEnergyCalibration.cc.

References constexpr, PVValHelper::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 251 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 363 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 773 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::bEtaBarrelEH ( double x ) const

private

Definition at line 299 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::bEtaBarrelH ( double x ) const

private

Definition at line 331 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::bEtaEndcapEH ( double x ) const

private

Definition at line 411 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::bEtaEndcapH ( double x ) const

private

Definition at line 443 of file PFEnergyCalibration.cc.

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

Referenced by energyEmHad().

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

double PFEnergyCalibration::cBarrel ( double x ) const

private

Definition at line 267 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 379 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 709 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 691 of file PFEnergyCalibration.cc.

References a, Abs(), constexpr, mps_fire::i, funct::m, mps_fire::result, alignCSCRings::s, and Sign().

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 665 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 623 of file PFEnergyCalibration.cc.

References constexpr, gather_cfg::cout, mps_fire::i, funct::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 988 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 1018 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 823 of file PFEnergyCalibration.cc.

References CorrBarrel(), CorrEta(), CorrPhi(), SiStripPI::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 862 of file PFEnergyCalibration.cc.

References Alpha(), Beta(), constexpr, MillePedeFileConverter_cfg::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 882 of file PFEnergyCalibration.cc.

References Alpha(), Beta(), constexpr, MillePedeFileConverter_cfg::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_ != nullptr){
     // 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_ != nullptr){
     // ESP1 only working
     double corrTotES = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0() * esEEInterCalib_->getGammaLow1();
     outputPS1 = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0();
     outputPS2 = corrTotES - outputPS1;
   }
   else if(outputPS1 == -1 && outputPS2 == 0 && esEEInterCalib_ != nullptr){
     // ESP2 only working
     double corrTotES = gammaprime*Alpha(etaEcal)*ePS2 * esEEInterCalib_->getGammaLow3() * esEEInterCalib_->getGammaLow2();
     outputPS2 = gammaprime*Alpha(etaEcal)*ePS2 * esEEInterCalib_->getGammaLow3();
     outputPS1 = corrTotES - outputPS2;
   }
   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 932 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 955 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 836 of file PFEnergyCalibration.cc.

References constexpr, PVValHelper::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 460 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 470 of file PFEnergyCalibration.cc.

References reco::PFCluster::calculatePositionREP(), Ecorr(), reco::PFCluster::energy(), PVValHelper::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 486 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 495 of file PFEnergyCalibration.cc.

References reco::PFCluster::calculatePositionREP(), Ecorr(), reco::PFCluster::energy(), PVValHelper::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 125 of file PFEnergyCalibration.cc.

References a, aBarrel(), funct::abs(), aEndcap(), aEtaBarrelEH(), aEtaBarrelH(), aEtaEndcapEH(), aEtaEndcapH(), b, bBarrel(), bEndcap(), bEtaBarrelEH(), bEtaBarrelH(), bEtaEndcapEH(), bEtaEndcapH(), cBarrel(), cEndcap(), particleFlow_cfi::dEta, MillePedeFileConverter_cfg::e, h, SiStripPI::max, min(), lumiQTWidget::t, scrapingFilter_cfi::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.;
   auto absEta = std::abs(eta);
   t = min(999.9,max(tt,e+h));
   if ( t < 1. ) return;
 
   // Barrel calibration
   if ( absEta < 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
     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 
     if ( e > 0. && thresh > 0. ) {
       etaCorrE = 1.0 + aEtaBarrelEH(t) + 1.3*bEtaBarrelEH(t)*absEta*absEta;
       etaCorrH = 1.0;
     } else {
       etaCorrE = 1.0 + aEtaBarrelH(t) + 1.3*bEtaBarrelH(t)*absEta*absEta; 
       etaCorrH = 1.0 + aEtaBarrelH(t) + bEtaBarrelH(t)*absEta*absEta;
     }
     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;
 
     // Protection against negative calibration
     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( absEta - 1.5 );
     double etaPow = dEta * dEta * dEta * dEta;
 
 
     if ( e > 0. && thresh > 0. ) {
       if(absEta<2.5) {
         etaCorrE = 1. + aEtaEndcapEH(t) ;
       }
       else {
         etaPow = dEta * dEta;
         etaCorrE = 1. + aEtaEndcapEH(t) + 1.3*bEtaEndcapEH(t)*(0.6 + etaPow);
       }
       etaPow = dEta * dEta * dEta * dEta;
       etaCorrH = 1. + aEtaEndcapEH(t) + bEtaEndcapEH(t)*(0.04 + etaPow);
     } else {
       etaCorrE = 1. + aEtaEndcapH(t) + 1.3*bEtaEndcapH(t)*(0.04 + etaPow);
       if(absEta<2.5) {
         etaCorrH = 1. + aEtaEndcapH(t) + 0.05*bEtaEndcapH(t);
       }
       else {
         etaCorrH = 1. + aEtaEndcapH(t) + bEtaEndcapH(t)*(etaPow - 1.1);
       }
     }
 
     //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 + etaCorrH * b * 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 794 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_, operator<<, and MillePedeFileConverter_cfg::out.

                                                                                     {
     esEEInterCalib_ = esEEInterCalib;
   }

void PFEnergyCalibration::initializeCalibrationFunctions ( )

Definition at line 27 of file PFEnergyCalibration.cc.

References MillePedeFileConverter_cfg::e, faBarrel, faEndcap, faEtaBarrelEH, faEtaBarrelH, faEtaEndcapEH, faEtaEndcapH, fbBarrel, fbEndcap, fbEtaBarrelEH, fbEtaBarrelH, fbEtaEndcapEH, fbEtaEndcapH, fcBarrel, fcEndcap, threshE, and threshH.

Referenced by PFEnergyCalibration().

                                                     {
 
   threshE = 3.5;
   threshH = 2.5;
 
   //calibChrisClean.C calibration parameters shubham May 01, 2017
   faBarrel = std::make_unique<TF1>("faBarrel","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   faBarrel->SetParameter(0,-13.9219);
   faBarrel->SetParameter(1,14.9124);
   faBarrel->SetParameter(2,5.38578);
   faBarrel->SetParameter(3,0.861981);
   faBarrel->SetParameter(4,-0.00759275);
   faBarrel->SetParameter(5,0.00373563);
   faBarrel->SetParameter(6,-1.17946);
   faBarrel->SetParameter(7,-1.69561);
   fbBarrel = std::make_unique<TF1>("fbBarrel","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fbBarrel->SetParameter(0,2.25366);
   fbBarrel->SetParameter(1,0.537715);
   fbBarrel->SetParameter(2,-4.81375);
   fbBarrel->SetParameter(3,12.109);
   fbBarrel->SetParameter(4,1.80577);
   fbBarrel->SetParameter(5,0.187919);
   fbBarrel->SetParameter(6,-6.26234);
   fbBarrel->SetParameter(7,-0.607392);
   fcBarrel = std::make_unique<TF1>("fcBarrel","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fcBarrel->SetParameter(1,0.855057);
   fcBarrel->SetParameter(2,-6.04199);
   fcBarrel->SetParameter(3,2.08229);
   fcBarrel->SetParameter(4,0.592266);
   fcBarrel->SetParameter(5,0.0291232);
   fcBarrel->SetParameter(6,0.364802);
   fcBarrel->SetParameter(7,-1.50142);
   faEtaBarrelEH = std::make_unique<TF1>("faEtaBarrelEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   faEtaBarrelEH->SetParameter(0,0.0185555);
   faEtaBarrelEH->SetParameter(1,-0.0470674);
   faEtaBarrelEH->SetParameter(2,396.959);
   fbEtaBarrelEH = std::make_unique<TF1>("fbEtaBarrelEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   fbEtaBarrelEH->SetParameter(0,0.0396458);
   fbEtaBarrelEH->SetParameter(1,0.114128);
   fbEtaBarrelEH->SetParameter(2,251.405);
   faEtaBarrelH = std::make_unique<TF1>("faEtaBarrelH","[0]+[1]*x",1.,1000.);
   faEtaBarrelH->SetParameter(0,0.00434994);
   faEtaBarrelH->SetParameter(1,-5.16564e-06);
   fbEtaBarrelH = std::make_unique<TF1>("fbEtaBarrelH","[0]+[1]*exp(-x/[2])",1.,1000.);
   fbEtaBarrelH->SetParameter(0,-0.0232604);
   fbEtaBarrelH->SetParameter(1,0.0937525);
   fbEtaBarrelH->SetParameter(2,34.9935);
 
   faEndcap = std::make_unique<TF1>("faEndcap","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   faEndcap->SetParameter(0,0.962468);
   faEndcap->SetParameter(1,11.9536);
   faEndcap->SetParameter(2,-27.7088);
   faEndcap->SetParameter(3,0.755474);
   faEndcap->SetParameter(4,0.0791012);
   faEndcap->SetParameter(5,0.0011082);
   faEndcap->SetParameter(6,0.158734);
   faEndcap->SetParameter(7,-2.1);
   fbEndcap = std::make_unique<TF1>("fbEndcap","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fbEndcap->SetParameter(0,-0.629923);
   fbEndcap->SetParameter(1,2.59634);
   fbEndcap->SetParameter(2,-2.27786);
   fbEndcap->SetParameter(3,1.20771);
   fbEndcap->SetParameter(4,-1.59129);
   fbEndcap->SetParameter(5,0.0189607);
   fbEndcap->SetParameter(6,0.270027);
   fbEndcap->SetParameter(7,-2.30372);
   fcEndcap = std::make_unique<TF1>("fcEndcap","[0]+((([1]+([2]/sqrt(x)))*exp(-(x^[6]/[3])))-([4]*exp(-(x^[7]/[5]))))",1.,1000.);
   fcEndcap->SetParameter(0,1.83168);
   fcEndcap->SetParameter(1,1.41883);
   fcEndcap->SetParameter(2,-5.50085);
   fcEndcap->SetParameter(3,29.2208);
   fcEndcap->SetParameter(4,0.923959);
   fcEndcap->SetParameter(5,0.268974);
   fcEndcap->SetParameter(6,1.37756);
   fcEndcap->SetParameter(7,-0.901421);
   faEtaEndcapEH = std::make_unique<TF1>("faEtaEndcapEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   faEtaEndcapEH->SetParameter(0,384.307);
   faEtaEndcapEH->SetParameter(1,-384.305);
   faEtaEndcapEH->SetParameter(2,2.16374e+08);
   fbEtaEndcapEH = std::make_unique<TF1>("fbEtaEndcapEH","[0]+[1]*exp(-x/[2])",1.,1000.);
   fbEtaEndcapEH->SetParameter(0,0.0120097);
   fbEtaEndcapEH->SetParameter(1,-0.131464);
   fbEtaEndcapEH->SetParameter(2,57.1104);
   faEtaEndcapH = std::make_unique<TF1>("faEtaEndcapH","[0]+[1]*exp(-x/[2])+[3]*[3]*exp(-x*x/([4]*[4]))",1.,1000.);
   faEtaEndcapH->SetParameter(0,-0.0106029);
   faEtaEndcapH->SetParameter(1,-0.692207);
   faEtaEndcapH->SetParameter(2,0.0542991);
   faEtaEndcapH->SetParameter(3,-0.171435);
   faEtaEndcapH->SetParameter(4,-61.2277);
   fbEtaEndcapH = std::make_unique<TF1>("fbEtaEndcapH","[0]+[1]*exp(-x/[2])+[3]*[3]*exp(-x*x/([4]*[4]))",1.,1000.);
   fbEtaEndcapH->SetParameter(0,0.0214894);
   fbEtaEndcapH->SetParameter(1,-0.266704);
   fbEtaEndcapH->SetParameter(2,5.2112);
   fbEtaEndcapH->SetParameter(3,0.303578);
   fbEtaEndcapH->SetParameter(4,-104.367);
 }

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

private

Definition at line 599 of file PFEnergyCalibration.cc.

References a, Abs(), b, constexpr, mps_fire::i, M_PI, and pi.

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 512 of file PFEnergyCalibration.cc.

Referenced by initAlphaGamma_ESplanes_fromDB().

                                                {
 
   if(!out ) return out;
 
   out<<"PFEnergyCalibration -- "<<endl;
 
   if ( calib.pfCalibrations ) { 
 
     static const std::map<std::string, PerformanceResult::ResultType> functType = {
       {"PFfa_BARREL", PerformanceResult::PFfa_BARREL},
       {"PFfa_ENDCAP", PerformanceResult::PFfa_ENDCAP},
       {"PFfb_BARREL", PerformanceResult::PFfb_BARREL},
       {"PFfb_ENDCAP", PerformanceResult::PFfb_ENDCAP},
       {"PFfc_BARREL", PerformanceResult::PFfc_BARREL},
       {"PFfc_ENDCAP", PerformanceResult::PFfc_ENDCAP},
       {"PFfaEta_BARRELH", PerformanceResult::PFfaEta_BARRELH},
       {"PFfaEta_ENDCAPH", PerformanceResult::PFfaEta_ENDCAPH},
       {"PFfbEta_BARRELH", PerformanceResult::PFfbEta_BARRELH},
       {"PFfbEta_ENDCAPH", PerformanceResult::PFfbEta_ENDCAPH},
       {"PFfaEta_BARRELEH", PerformanceResult::PFfaEta_BARRELEH},
       {"PFfaEta_ENDCAPEH", PerformanceResult::PFfaEta_ENDCAPEH},
       {"PFfbEta_BARRELEH", PerformanceResult::PFfbEta_BARRELEH},
       {"PFfbEta_ENDCAPEH", PerformanceResult::PFfbEta_ENDCAPEH}
     };
     
     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.faEtaBarrelEH->Print();
     calib.fbEtaBarrelEH->Print();
     calib.faEtaBarrelH->Print();
     calib.fbEtaBarrelH->Print();
     calib.faEndcap->Print();
     calib.fbEndcap->Print();
     calib.fcEndcap->Print();
     calib.faEtaEndcapEH->Print();
     calib.fbEtaEndcapEH->Print();
     calib.faEtaEndcapH->Print();
     calib.fbEtaEndcapH->Print();
 
   }
     
   return out;
 }