#include <ElectronEnergyCorrector.h>

Public Member Functions
void	classBasedParameterizationEnergy (reco::GsfElectron &, const reco::BeamSpot &bs)

void	classBasedParameterizationUncertainty (reco::GsfElectron &)

	ElectronEnergyCorrector (EcalClusterFunctionBaseClass *crackCorrectionFunction)

void	simpleParameterizationUncertainty (reco::GsfElectron &)

Private Member Functions
float	fBremEta (float sigmaPhiSigmaEta, float eta, int algorithm, reco::GsfElectron::Classification cl) const

float	fEnergy (float e, int algorithm, reco::GsfElectron::Classification cl) const

float	fEt (float et, int algorithm, reco::GsfElectron::Classification cl) const

float	fEta (float energy, float eta, int algorithm) const

double	fEtaBarrelBad (double scEta) const

double	fEtaBarrelGood (double scEta) const

double	fEtaEndcapBad (double scEta) const

double	fEtaEndcapGood (double scEta) const

Private Attributes
EcalClusterFunctionBaseClass *	crackCorrectionFunction_

Detailed Description

Definition at line 10 of file ElectronEnergyCorrector.h.

Constructor & Destructor Documentation

ElectronEnergyCorrector::ElectronEnergyCorrector ( EcalClusterFunctionBaseClass * crackCorrectionFunction )

inline

Definition at line 14 of file ElectronEnergyCorrector.h.

15 : crackCorrectionFunction_(crackCorrectionFunction) {}

ElectronEnergyCorrector::crackCorrectionFunction_

EcalClusterFunctionBaseClass * crackCorrectionFunction_

Definition: ElectronEnergyCorrector.h:36

Member Function Documentation

void ElectronEnergyCorrector::classBasedParameterizationEnergy	(	reco::GsfElectron &	electron,
		const reco::BeamSpot &	bs
	)

Definition at line 56 of file ElectronEnergyCorrector.cc.

References reco::GsfElectron::classification(), corr, relval_parameters_module::energy, reco::GsfElectron::GAP, reco::GsfElectron::isEB(), reco::GsfElectron::isEcalEnergyCorrected(), reco::GsfElectron::isEE(), mathSSE::return(), reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::superCluster(), and reco::GsfElectron::UNKNOWN.

Referenced by GsfElectronAlgo::createElectron().

  {
   if (electron.isEcalEnergyCorrected())
    {
       edm::LogWarning("ElectronEnergyCorrector::classBasedParameterizationEnergy")<<"already done" ;
       return ;
    }
 
   reco::GsfElectron::Classification elClass = electron.classification() ;
   if ( (elClass <= reco::GsfElectron::UNKNOWN) ||
          (elClass>reco::GsfElectron::GAP) )
    {
       edm::LogWarning("ElectronEnergyCorrector::classBasedParameterizationEnergy")<<"unexpected classification" ;
       return ;
    }
 
   // new corrections from N. Chanon et al., taken from EcalClusterCorrectionObjectSpecific.cc
   float corr = 1.;
   float corr2 = 1.;
   float energy = electron.superCluster()->energy() ;
   float newEnergy = energy;
 
   //int subdet = electron.superCluster()->seed()->hitsAndFractions()[0].first.subdetId();
 
   if (electron.isEB())
    {
     float cetacorr = fEta(electron.superCluster()->rawEnergy(), electron.superCluster()->eta(), 0)/electron.superCluster()->rawEnergy();
     energy = electron.superCluster()->rawEnergy()*cetacorr; //previously in CMSSW
     //energy = superCluster.rawEnergy()*fEta(e5x5, superCluster.seed()->eta(), 0)/e5x5;
    }
   else if (electron.isEE())
    {
     energy = electron.superCluster()->rawEnergy()+electron.superCluster()->preshowerEnergy();
    }
   else
    { edm::LogWarning("ElectronEnergyCorrector::classBasedParameterizationEnergy")<<"nor barrel neither endcap electron !" ; }
 
   corr = fBremEta(electron.superCluster()->phiWidth()/electron.superCluster()->etaWidth(), electron.superCluster()->eta(), 0,elClass);
 
   float et = energy*TMath::Sin(2*TMath::ATan(TMath::Exp(-electron.superCluster()->eta())))/corr;
 
   if (electron.isEB()) { corr2 = corr * fEt(et, 0,elClass) ; }
   else if (electron.isEE()) { corr2 = corr * fEnergy(energy/corr, 1,elClass) ; }
   else { edm::LogWarning("ElectronEnergyCorrector::classBasedParameterizationEnergy")<<"nor barrel neither endcap electron !" ; }
 
   newEnergy = energy/corr2;
 
   // cracks
   double crackcor = 1. ;
   for ( reco::CaloCluster_iterator
         cIt = electron.superCluster()->clustersBegin() ;
         cIt != electron.superCluster()->clustersEnd() ;
         ++cIt )
    {
     const reco::CaloClusterPtr cc = *cIt ;
     crackcor *=
      ( electron.superCluster()->rawEnergy()
        + cc->energy()*(crackCorrectionFunction_->getValue(*cc)-1.) )
      / electron.superCluster()->rawEnergy() ;
    }
   newEnergy *= crackcor ;
 
   // register final value
   electron.setCorrectedEcalEnergy(newEnergy) ;
 
  }

void ElectronEnergyCorrector::classBasedParameterizationUncertainty ( reco::GsfElectron & electron )

Definition at line 20 of file ElectronEnergyCorrector.cc.

References reco::GsfElectron::classification(), EnergyUncertaintyElectronSpecific::computeElectronEnergyUncertainty(), reco::GsfElectron::correctedEcalEnergy(), energyError(), reco::GsfElectron::setCorrectedEcalEnergyError(), and reco::GsfElectron::superCluster().

Referenced by GsfElectronAlgo::createElectron().

  {
   EnergyUncertaintyElectronSpecific uncertainty ;
   double energyError = 999. ;
   double ecalEnergy = electron.correctedEcalEnergy() ;
   double eleEta = electron.superCluster()->eta() ;
   double brem = electron.superCluster()->etaWidth()/electron.superCluster()->phiWidth() ;
   energyError =  uncertainty.computeElectronEnergyUncertainty(electron.classification(),eleEta,brem,ecalEnergy) ;
   electron.setCorrectedEcalEnergyError(energyError) ;
  }

float ElectronEnergyCorrector::fBremEta	(	float	sigmaPhiSigmaEta,
		float	eta,
		int	algorithm,
		reco::GsfElectron::Classification	cl
	)		const

private

Definition at line 159 of file ElectronEnergyCorrector.cc.

References Abs(), GetRecoTauVFromDQM_MC_cff::cl, reco::GsfElectron::GAP, and fitWZ::par0.

  {
   // corrections for electrons
   if (algorithm!=0)
    {
     edm::LogWarning("ElectronEnergyCorrector::fBremEta")<<"algorithm should be 0 for electrons !" ;
     return 1. ;
    }
 
   const float etaCrackMin = 1.44 ;
   const float etaCrackMax = 1.56 ;
 
   //STD
   const int nBinsEta = 14 ;
   float leftEta[nBinsEta] = { 0.02, 0.25, 0.46, 0.81, 0.91, 1.01, 1.16, etaCrackMax, 1.653, 1.8, 2.0, 2.2, 2.3, 2.4 } ;
   float rightEta[nBinsEta] = { 0.25, 0.42, 0.77, 0.91, 1.01, 1.13, etaCrackMin, 1.653, 1.8, 2.0, 2.2, 2.3, 2.4, 2.5 } ;
 
   // eta = 0
   if ( TMath::Abs(eta) < leftEta[0] ) { eta = 0.02 ; }
 
   // outside acceptance
   if ( TMath::Abs(eta) >= rightEta[nBinsEta-1] ) { eta = 2.49 ; } //if (DBG) std::cout << " WARNING [applyScCorrections]: TMath::Abs(eta)  >=  rightEta[nBinsEta-1] " << std::endl;}
 
   int tmpEta = -1 ;
   for (int iEta = 0; iEta < nBinsEta; ++iEta)
    {
     if ( leftEta[iEta] <= TMath::Abs(eta) && TMath::Abs(eta) <rightEta[iEta] )
      { tmpEta = iEta ; }
    }
 
   float xcorr[nBinsEta][reco::GsfElectron::GAP+1] =
    {
      { 1.00227,  1.00227,  1.00227,  1.00227,  1.00227  },
      { 1.00252,  1.00252,  1.00252,  1.00252,  1.00252  },
      { 1.00225,  1.00225,  1.00225,  1.00225,  1.00225  },
      { 1.00159,  1.00159,  1.00159,  1.00159,  1.00159  },
      { 0.999475, 0.999475, 0.999475, 0.999475, 0.999475 },
      { 0.997203, 0.997203, 0.997203, 0.997203, 0.997203 },
      { 0.993886, 0.993886, 0.993886, 0.993886, 0.993886 },
      { 0.971262, 0.971262, 0.971262, 0.971262, 0.971262 },
      { 0.975922, 0.975922, 0.975922, 0.975922, 0.975922 },
      { 0.979087, 0.979087, 0.979087, 0.979087, 0.979087 },
      { 0.98495,  0.98495,  0.98495,  0.98495,  0.98495  },
      { 0.98781,  0.98781,  0.98781,  0.98781,  0.98781  },
      { 0.989546, 0.989546, 0.989546, 0.989546, 0.989546 },
      { 0.989638, 0.989638, 0.989638, 0.989638, 0.989638 }
    } ;
 
   float par0[nBinsEta][reco::GsfElectron::GAP+1] =
    {
      { 0.994949, 1.00718, 1.00718, 1.00556, 1.00718 },
      { 1.009,  1.00713,  1.00713,  1.00248,  1.00713 },
      { 0.999395, 1.00641,  1.00641,  1.00293,  1.00641 },
      { 0.988662, 1.00761,  1.001,  0.99972,  1.00761 },
      { 0.998443, 1.00682,  1.001,  1.00282, 1.00682 },
      { 1.00285,  1.0073,  1.001,  1.00396,  1.0073 },
      { 0.993053, 1.00462,  1.01341,  1.00184,  1.00462 },
      { 1.10561,  0.972798, 1.02835,  0.995218, 0.972798 },
      { 0.893741, 0.981672, 0.98982,  1.01712,  0.981672 },
      { 0.911123, 0.98251,  1.03466,  1.00824,  0.98251 },
      { 0.981931, 0.986123, 0.954295, 1.0202,  0.986123 },
      { 0.905634, 0.990124, 0.928934, 0.998492, 0.990124 },
      { 0.919343, 0.990187, 0.967526, 0.963923, 0.990187 },
      { 0.844783, 0.99372,  0.923808, 0.953001, 0.99372 }
    } ;
 
   float par1[nBinsEta][reco::GsfElectron::GAP+1] =
    {
      { 0.0111034, -0.00187886, -0.00187886, -0.00289304, -0.00187886 },
      { -0.00969012, -0.00227574, -0.00227574, -0.00182187, -0.00227574 },
      { 0.00389454,  -0.00259935,  -0.00259935, -0.00211059, -0.00259935 },
      { 0.017095, -0.00433692, -0.00302335, -0.00241385, -0.00433692 },
      { -0.00049009, -0.00551324,  -0.00302335, -0.00532352, -0.00551324 },
      { -0.00252723, -0.00799669,  -0.00302335, -0.00823109, -0.00799669 },
      { 0.00332567,  -0.00870057,  -0.0170581,  -0.011482,  -0.00870057 },
      { -0.213285,  -0.000771577, -0.036007,  -0.0187526,  -0.000771577 },
      { 0.1741,  -0.00202028,  -0.0233995,  -0.0302066,  -0.00202028 },
      { 0.152794,  0.00441308,  -0.0468563,  -0.0158817,  0.00441308 },
      { 0.0351465,  0.00832913,  0.0358028,  -0.0233262,  0.00832913 },
      { 0.185781,  0.00742879,  0.08858,  0.00568078,  0.00742879 },
      { 0.153088,  0.0094608,  0.0489979,  0.0491897,  0.0094608 },
      { 0.296681,  0.00560406,  0.106492,  0.0652007,  0.00560406 }
    } ;
 
   float par2[nBinsEta][reco::GsfElectron::GAP+1] =
    {
      { -0.00330844, 0, 0, 5.62441e-05,  0 },
      { 0.00329373,  0,  0,  -0.000113883,  0 },
      { -0.00104661,  0,  0,  -0.000152794,  0 },
      { -0.0060409,  0,  -0.000257724, -0.000202099,  0 },
      { -0.000742866, 0,  -0.000257724, -2.06003e-05,  0 },
      { -0.00205425,  0,  -0.000257724, 3.84179e-05,   0 },
      { -0.00350757,  0,  0.000590483,  0.000323723,   0 },
      { 0.0794596,  -0.00276696, 0.00205854,  0.000356716,   -0.00276696 },
      { -0.092436,  -0.00471028, 0.00062096,  0.00088347,   -0.00471028 },
      { -0.0855029,  -0.00809139, 0.00284102,  -0.00366903,   -0.00809139 },
      { -0.0306209,  -0.00944584, -0.0145892,  -0.00176969,   -0.00944584 },
      { -0.0996414,  -0.00960462, -0.0328264,  -0.00983844,   -0.00960462 },
      { -0.0784107,  -0.010172,  -0.0256722,  -0.0215133,   -0.010172 },
      { -0.145815,  -0.00943169, -0.0414525,  -0.027087,   -0.00943169 }
    } ;
 
   float sigmaPhiSigmaEtaMin[reco::GsfElectron::GAP+1] = { 0.8, 0.8, 0.8, 0.8, 0.8 } ;
   float sigmaPhiSigmaEtaMax[reco::GsfElectron::GAP+1] = { 5., 5., 5., 5., 5. } ;
   float sigmaPhiSigmaEtaFit[reco::GsfElectron::GAP+1] = { 1.2, 1.2, 1.2, 1.2, 1.2 } ;
 
   // extra protections
   // fix sigmaPhiSigmaEta boundaries
   if ( sigmaPhiSigmaEta < sigmaPhiSigmaEtaMin[cl] )
    { sigmaPhiSigmaEta = sigmaPhiSigmaEtaMin[cl] ; }
   if ( sigmaPhiSigmaEta > sigmaPhiSigmaEtaMax[cl]  )
    { sigmaPhiSigmaEta = sigmaPhiSigmaEtaMax[cl] ; }
 
   // In eta cracks/gaps
   if ( tmpEta == -1 ) // need to interpolate
    {
     float tmpInter = 1 ;
     for ( int iEta = 0 ; iEta < nBinsEta-1 ; ++iEta )
      {
       if ( rightEta[iEta] <= TMath::Abs(eta) && TMath::Abs(eta) <leftEta[iEta+1] )
        {
         if ( sigmaPhiSigmaEta >= sigmaPhiSigmaEtaFit[cl] )
          {
             tmpInter =
              ( par0[iEta][cl] +
                sigmaPhiSigmaEta*par1[iEta][cl] +
                sigmaPhiSigmaEta*sigmaPhiSigmaEta*par2[iEta][cl] +
              par0[iEta+1][cl] +
              sigmaPhiSigmaEta*par1[iEta+1][cl] +
              sigmaPhiSigmaEta*sigmaPhiSigmaEta*par2[iEta+1][cl] ) / 2. ;
          }
           else tmpInter = (xcorr[iEta][cl] + xcorr[iEta+1][cl])/2. ;
        }
      }
     return tmpInter ;
    }
 
   if (sigmaPhiSigmaEta >= sigmaPhiSigmaEtaFit[cl])
    { return par0[tmpEta][cl] + sigmaPhiSigmaEta*par1[tmpEta][cl] + sigmaPhiSigmaEta*sigmaPhiSigmaEta*par2[tmpEta][cl] ; }
   else
    { return xcorr[tmpEta][cl] ; }
 
   return 1. ;
  }

float ElectronEnergyCorrector::fEnergy	(	float	e,
		int	algorithm,
		reco::GsfElectron::Classification	cl
	)		const

private

Definition at line 343 of file ElectronEnergyCorrector.cc.

References GetRecoTauVFromDQM_MC_cff::cl, create_public_lumi_plots::exp, reco::GsfElectron::GAP, and fitWZ::par0.

  {
   if (algorithm==0) // Electrons EB
    { return 1. ; }
   else if (algorithm==1) // Electrons EE
    {
     float par0[reco::GsfElectron::GAP+1] = { 400, 400, 400, 400, 400 } ;
     float par1[reco::GsfElectron::GAP+1] = { 0.999545, 0.982475, 0.986217, 0.996763, 0.982475 } ;
     float par2[reco::GsfElectron::GAP+1] = { 1.26568e-05, 4.95413e-05, 5.02161e-05, 2.8485e-06, 4.95413e-05 } ;
     float par3[reco::GsfElectron::GAP+1] = { 0.0696757, 0.16886, 0.115317, 0.12098, 0.16886 } ;
     float par4[reco::GsfElectron::GAP+1] = { -54.3468, -30.1517, -26.3805, -62.0538, -30.1517 } ;
 
     if ( E > par0[cl] ) { E = par0[cl] ; }
     if ( E < 0 ) { return 1. ; }
     if ( 0 <= E && E <= par0[cl] ) { return (par1[cl] + E*par2[cl] )*(1- par3[cl]*exp(E/par4[cl] )) ; }
    }
   else
    { edm::LogWarning("ElectronEnergyCorrector::fEnergy")<<"algorithm should be 0 or 1 for electrons !" ; }
   return 1.;
  }

float ElectronEnergyCorrector::fEt	(	float	et,
		int	algorithm,
		reco::GsfElectron::Classification	cl
	)		const

private

Definition at line 304 of file ElectronEnergyCorrector.cc.

References GetRecoTauVFromDQM_MC_cff::cl, create_public_lumi_plots::exp, and reco::GsfElectron::GAP.

  {
   if (algorithm==0) //Electrons EB
    {
     const float parClassIndep[5] = { 0.97213, 0.999528, 5.61192e-06, 0.0143269, -17.1776 } ;
     const float par[reco::GsfElectron::GAP+1][5] =
      {
        { 0.974327, 0.996127, 5.99401e-05, 0.159813, -3.80392 },
        { 0.97213, 0.999528, 5.61192e-06, 0.0143269, -17.1776 },
        { 0.940666, 0.988894, 0.00017474, 0.25603, -4.58153 },
        { 0.969526, 0.98572, 0.000193842, 4.21548, -1.37159 },
        { parClassIndep[0], parClassIndep[1], parClassIndep[2], parClassIndep[3], parClassIndep[4] }
      } ;
     if ( ET > 200 ) { ET = 200 ; }
     if ( ET > 100 ) { return (parClassIndep[1]+ET*parClassIndep[2]) * (1-parClassIndep[3]*exp(ET/parClassIndep[4])) ; }
     if ( ET >= 10 ) { return (par[cl][1]+ET*par[cl][2]) * (1-par[cl][3]*exp(ET/par[cl][4])) ; }
     if ( ET >=5 ) { return par[cl][0] ; }
     return 1. ;
    }
   else if (algorithm==1) //Electrons EE
    {
     float par[reco::GsfElectron::GAP+1][5] =
      {
        { 0.930081, 0.996683, 3.54079e-05, 0.0460187, -23.2461 },
        { 0.930081, 0.996683, 3.54079e-05, 0.0460187, -23.2461 },
        { 0.930081, 0.996683, 3.54079e-05, 0.0460187, -23.2461 },
        { 0.930081, 0.996683, 3.54079e-05, 0.0460187, -23.2461 },
        { 0.930081, 0.996683, 3.54079e-05, 0.0460187, -23.2461 }
      };
     if ( ET > 200 ) { ET = 200 ; }
     if ( ET < 5 ) { return 1. ; }
     if ( 5 <= ET && ET < 10 ) { return par[cl][0] ; }
     if ( 10 <= ET && ET <= 200 ) { return ( par[cl][1]  + ET*par[cl][2])*(1-par[cl][3]*exp(ET/par[cl][4])) ; }
    }
   else
    { edm::LogWarning("ElectronEnergyCorrector::fEt")<<"algorithm should be 0 or 1 for electrons !" ; }
   return 1. ;
  }

float ElectronEnergyCorrector::fEta	(	float	energy,
		float	eta,
		int	algorithm
	)		const

private

Definition at line 128 of file ElectronEnergyCorrector.cc.

References relval_parameters_module::energy, and p1.

 {
 
   // corrections for electrons
   if (algorithm!=0) {
     edm::LogWarning("ElectronEnergyCorrector::fEta")<<"algorithm should be 0 for electrons !" ;
     return energy;
   }
   //std::cout << "fEta function" << std::endl;
 
   // this correction is setup only for EB
   if ( algorithm != 0 ) return energy;
 
   float ieta = fabs(eta)*(5/0.087);
   // bypass the DB reading for the time being
   //float p0 = (params_->params())[0];  // should be 40.2198
   //float p1 = (params_->params())[1];  // should be -3.03103e-6
   float p0 = 40.2198 ;
   float p1 = -3.03103e-6 ;
 
   //std::cout << "ieta=" << ieta << std::endl;
 
   float correctedEnergy = energy;
   if ( ieta < p0 ) correctedEnergy = energy;
   else             correctedEnergy = energy/(1.0 + p1*(ieta-p0)*(ieta-p0));
   //std::cout << "ECEC fEta = " << correctedEnergy << std::endl;
   return correctedEnergy;
 
  }

double ElectronEnergyCorrector::fEtaBarrelBad ( double scEta ) const

private

Definition at line 382 of file ElectronEnergyCorrector.cc.

References funct::abs(), p1, p2, p3, p4, and x.

  {
   // f(eta) for the class = 30 (estimated from 1Mevt single e sample)
   // Ivica's new corrections 01/06
   float p0 =  9.99063e-01;
   float p1 = -2.63341e-02;
   float p2 =  5.16054e-02;
   float p3 = -4.95976e-02;
   float p4 =  3.62304e-03;
   double x  = (double) std::abs(scEta) ;
   return p0 + p1*x + p2*x*x + p3*x*x*x + p4*x*x*x*x ;
  }

double ElectronEnergyCorrector::fEtaBarrelGood ( double scEta ) const

private

Definition at line 369 of file ElectronEnergyCorrector.cc.

References funct::abs(), p1, p2, p3, p4, and x.

  {
   // f(eta) for the first 3 classes (0, 10 and 20) (estimated from 1Mevt single e sample)
   // Ivica's new corrections 01/06
   float p0 =  1.00149e+00 ;
   float p1 = -2.06622e-03 ;
   float p2 = -1.08793e-02 ;
   float p3 =  1.54392e-02 ;
   float p4 = -1.02056e-02 ;
   double x  = (double) std::abs(scEta) ;
   return p0 + p1*x + p2*x*x + p3*x*x*x + p4*x*x*x*x ;
  }

double ElectronEnergyCorrector::fEtaEndcapBad ( double scEta ) const

private

Definition at line 408 of file ElectronEnergyCorrector.cc.

References funct::abs(), p1, p2, p3, p4, and x.

  {
   // f(eta) for the class = 130-134
   // Ivica's new corrections 01/06
   float p0 =        -4.25221e+00 ;
   float p1 =         1.01936e+01 ;
   float p2 =        -7.48247e+00 ;
   float p3 =         2.45520e+00 ;
   float p4 =        -3.02872e-01 ;
   double x  = (double) std::abs(scEta);
   return p0 + p1*x + p2*x*x + p3*x*x*x + p4*x*x*x*x ;
  }

double ElectronEnergyCorrector::fEtaEndcapGood ( double scEta ) const

private

Definition at line 395 of file ElectronEnergyCorrector.cc.

References funct::abs(), p1, p2, p3, p4, and x.

  {
   // f(eta) for the first 3 classes (100, 110 and 120)
   // Ivica's new corrections 01/06
   float p0 = -8.51093e-01 ;
   float p1 =  3.54266e+00 ;
   float p2 = -2.59288e+00 ;
   float p3 = 8.58945e-01 ;
   float p4 = -1.07844e-01 ;
   double x  = (double) std::abs(scEta) ;
   return p0 + p1*x + p2*x*x + p3*x*x*x + p4*x*x*x*x ;
  }

void ElectronEnergyCorrector::simpleParameterizationUncertainty ( reco::GsfElectron & electron )

Definition at line 34 of file ElectronEnergyCorrector.cc.

References reco::GsfElectron::correctedEcalEnergy(), energyError(), relativeConstraints::error, reco::GsfElectron::isEB(), reco::GsfElectron::isEE(), and reco::GsfElectron::setCorrectedEcalEnergyError().

Referenced by GsfElectronAlgo::createElectron().

  {
   double error = 999. ;
   double ecalEnergy = electron.correctedEcalEnergy() ;
 
   if (electron.isEB())
    {
     float parEB[3] = { 5.24e-02,  2.01e-01, 1.00e-02} ;
     error =  ecalEnergy*energyError(ecalEnergy,parEB) ;
    }
   else if (electron.isEE())
    {
     float parEE[3] = { 1.46e-01, 9.21e-01, 1.94e-03} ;
     error =  ecalEnergy*energyError(ecalEnergy,parEE) ;
    }
   else
    { edm::LogWarning("ElectronEnergyCorrector::simpleParameterizationUncertainty")<<"nor barrel neither endcap electron !" ; }
 
   electron.setCorrectedEcalEnergyError(error) ;
  }

Member Data Documentation

EcalClusterFunctionBaseClass* ElectronEnergyCorrector::crackCorrectionFunction_

private

Definition at line 36 of file ElectronEnergyCorrector.h.

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation