#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(0), esEEInterCalib_(0)
 {
   initializeCalibrationFunctions();
 }

PFEnergyCalibration::~PFEnergyCalibration ( )

Definition at line 21 of file PFEnergyCalibration.cc.

 {
 
 }

Member Function Documentation

double PFEnergyCalibration::aBarrel ( double x ) const

private

Definition at line 228 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 339 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 275 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 307 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 387 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 419 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 747 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 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 355 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 765 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 291 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 323 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 403 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 435 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 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 371 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 701 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 683 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 657 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 615 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 980 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 1010 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 815 of file PFEnergyCalibration.cc.

References CorrBarrel(), CorrEta(), CorrPhi(), hpstanc_transforms::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 854 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 874 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_ != 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
     double corrTotES = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0() * esEEInterCalib_->getGammaLow1();
     outputPS1 = gammaprime*ePS1 * esEEInterCalib_->getGammaLow0();
     outputPS2 = corrTotES - outputPS1;
   }
   else if(outputPS1 == -1 && outputPS2 == 0 && esEEInterCalib_ != 0){
     // 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 924 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 947 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 828 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 452 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 462 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 478 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 487 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(), MillePedeFileConverter_cfg::e, h, hpstanc_transforms::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. ) {
       etaCorrE = 1. + aEtaEndcapEH(t) + 1.3*bEtaEndcapEH(t)*(0.04 + etaPow);
       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)*(0.04 + 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 + 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 786 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 591 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 504 of file PFEnergyCalibration.cc.

Referenced by initAlphaGamma_ESplanes_fromDB().

                                                {
 
   if(!out ) return out;
 
   out<<"PFEnergyCalibration -- "<<endl;
 
   if ( calib.pfCalibrations ) { 
 
     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_BARRELH"] = PerformanceResult::PFfaEta_BARRELH;
     functType["PFfaEta_ENDCAPH"] = PerformanceResult::PFfaEta_ENDCAPH;
     functType["PFfbEta_BARRELH"] = PerformanceResult::PFfbEta_BARRELH;
     functType["PFfbEta_ENDCAPH"] = PerformanceResult::PFfbEta_ENDCAPH;
     functType["PFfaEta_BARRELEH"] = PerformanceResult::PFfaEta_BARRELEH;
     functType["PFfaEta_ENDCAPEH"] = PerformanceResult::PFfaEta_ENDCAPEH;
     functType["PFfbEta_BARRELEH"] = PerformanceResult::PFfbEta_BARRELEH;
     functType["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;
 }