ElectronEnergyCalibrator Class Reference

#include <ElectronEnergyCalibrator.h>

Public Types
enum	EventType { EventType::DATA, EventType::MC }

Public Member Functions
std::array< float, EGEnergySysIndex::kNrSysErrs >	calibrate (reco::GsfElectron &ele, const unsigned int runNumber, const EcalRecHitCollection *recHits, edm::StreamID const &id, const EventType eventType) const
std::array< float, EGEnergySysIndex::kNrSysErrs >	calibrate (reco::GsfElectron &ele, const unsigned int runNumber, const EcalRecHitCollection *recHits, const float smearNrSigma, const EventType eventType) const
void	calibrate (SimpleElectron &electron, edm::StreamID const &)
void	correctLinearity (SimpleElectron &electron)
	ElectronEnergyCalibrator ()
	ElectronEnergyCalibrator (const EpCombinationTool &combinator, const std::string &correctionFile)
	ElectronEnergyCalibrator (const std::string pathData, const std::string pathLinData, const std::string dataset, int correctionsType, bool applyLinearityCorrection, double lumiRatio, bool isMC, bool updateEnergyErrors, bool verbose, bool synchronization)
void	initPrivateRng (TRandom *rnd)
void	setMinEt (float val)
	~ElectronEnergyCalibrator ()

Private Member Functions
std::pair< float, float >	calCombinedMom (reco::GsfElectron &ele, const float scale, const float smear) const
double	gauss (edm::StreamID const &id) const
void	init ()
void	setEcalEnergy (reco::GsfElectron &ele, const float scale, const float smear) const
void	setEnergyAndSystVarations (const float scale, const float smearNrSigma, const float et, const EnergyScaleCorrection::ScaleCorrection &scaleCorr, const EnergyScaleCorrection::SmearCorrection &smearCorr, reco::GsfElectron &ele, std::array< float, EGEnergySysIndex::kNrSysErrs > &energyData) const
void	splitString (const std::string &fullstr, std::vector< std::string > &elements, const std::string &delimiter)
double	stringToDouble (const std::string &str)

Private Attributes
bool	applyLinearityCorrection_
EnergyScaleCorrection	correctionRetriever_
int	correctionsType_
correctionValues	corrValArray [100]
correctionValues	corrValMC
std::string	dataset_
const EpCombinationTool *	epCombinationTool_
bool	isMC_
linearityCorrectionValues	linCorrValArray [100]
double	lumiRatio_
float	minEt_
int	nCorrValRaw
double	newEnergy_
double	newEnergyError_
int	nLinCorrValRaw
std::string	pathData_
std::string	pathLinData_
TRandom *	rng_
bool	synchronization_
bool	updateEnergyErrors_
bool	verbose_

Static Private Attributes
static const EnergyScaleCorrection::ScaleCorrection	defaultScaleCorr_
static const EnergyScaleCorrection::SmearCorrection	defaultSmearCorr_

Detailed Description

Definition at line 41 of file ElectronEnergyCalibrator.h.

Member Enumeration Documentation

enum ElectronEnergyCalibrator::EventType

strong

Enumerator
DATA
MC

Definition at line 27 of file ElectronEnergyCalibrator.h.

                      {
    DATA,
    MC,
  };

Constructor & Destructor Documentation

ElectronEnergyCalibrator::ElectronEnergyCalibrator ( const std::string  pathData, const std::string  pathLinData, const std::string  dataset, int  correctionsType, bool  applyLinearityCorrection, double  lumiRatio, bool  isMC, bool  updateEnergyErrors, bool  verbose, bool  synchronization  )

inline

Definition at line 44 of file ElectronEnergyCalibrator.h.

References csvReporter::delimiter, metsig::electron, allElectronIsolations_cfi::elements, init, splitString(), str, and AlCaHLTBitMon_QueryRunRegistry::string.

                : 
    pathData_(pathData), 
    pathLinData_(pathLinData), 
    dataset_(dataset), 
    correctionsType_(correctionsType), 
    applyLinearityCorrection_(applyLinearityCorrection),
    lumiRatio_(lumiRatio), 
    isMC_(isMC), 
    updateEnergyErrors_(updateEnergyErrors), 
    verbose_(verbose), 
    synchronization_(synchronization) {
      init();
    }

ElectronEnergyCalibrator::ElectronEnergyCalibrator ( )

inline

Definition at line 32 of file ElectronEnergyCalibrator.h.

References electrons_cff::correctionFile, and AlCaHLTBitMon_QueryRunRegistry::string.

{}

ElectronEnergyCalibrator::ElectronEnergyCalibrator	(	const EpCombinationTool &	combinator,
		const std::string &	correctionFile
	)

Definition at line 12 of file ElectronEnergyCalibrator.cc.

                                                            :
  correctionRetriever_(correctionFile), 
  epCombinationTool_(&combinator), 
  rng_(nullptr),
  minEt_(1.0)
{
  
}

ElectronEnergyCalibrator::~ElectronEnergyCalibrator ( )

inline

Definition at line 34 of file ElectronEnergyCalibrator.h.

References initPrivateRng().

{}

Member Function Documentation

std::pair< float, float > ElectronEnergyCalibrator::calCombinedMom ( reco::GsfElectron &  ele, const float  scale, const float  smear  ) const

private

Definition at line 181 of file ElectronEnergyCalibrator.cc.

References EpCombinationTool::combine(), reco::GsfElectron::correctMomentum(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), epCombinationTool_, reco::GsfElectron::p4(), reco::GsfElectron::P4_COMBINATION, reco::GsfElectron::p4Error(), reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::setCorrectedEcalEnergyError(), setEcalEnergy(), and reco::GsfElectron::trackMomentumError().

Referenced by setEnergyAndSystVarations(), and setMinEt().

{ 
  const float oldEcalEnergy = ele.ecalEnergy();
  const float oldEcalEnergyErr = ele.ecalEnergyError();

  const auto oldP4 = ele.p4();
  const float oldP4Err = ele.p4Error(reco::GsfElectron::P4_COMBINATION);
  const float oldTrkMomErr = ele.trackMomentumError();
 
  setEcalEnergy(ele,scale,smear);
  const auto& combinedMomentum = epCombinationTool_->combine(ele,oldEcalEnergyErr*scale);
  
  ele.setCorrectedEcalEnergy(oldEcalEnergy);
  ele.setCorrectedEcalEnergyError(oldEcalEnergyErr);
  ele.correctMomentum(oldP4,oldTrkMomErr,oldP4Err);
  
  return combinedMomentum;
}

std::array< float, EGEnergySysIndex::kNrSysErrs > ElectronEnergyCalibrator::calibrate	(	reco::GsfElectron &	ele,
		const unsigned int	runNumber,
		const EcalRecHitCollection *	recHits,
		edm::StreamID const &	id,
		const EventType	eventType
	)		const

Correct this electron. StreamID is needed when used with CMSSW Random Number Generator

Definition at line 28 of file ElectronEnergyCalibrator.cc.

References calibrate(), and gauss().

{
  return calibrate(ele,runNumber,recHits,gauss(id),eventType);
}

std::array< float, EGEnergySysIndex::kNrSysErrs > ElectronEnergyCalibrator::calibrate	(	reco::GsfElectron &	ele,
		const unsigned int	runNumber,
		const EcalRecHitCollection *	recHits,
		const float	smearNrSigma,
		const EventType	eventType
	)		const

Definition at line 38 of file ElectronEnergyCalibrator.cc.

References funct::abs(), reco::GsfElectron::Corrections::combinedP4Error, correctionRetriever_, reco::GsfElectron::corrections(), DATA, defaultScaleCorr_, defaultSmearCorr_, reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), edm::SortedCollection< T, SORT >::end(), reco::LeafCandidate::energy(), stringResolutionProvider_cfi::et, edm::SortedCollection< T, SORT >::find(), reco::GsfElectron::full5x5_r9(), EnergyScaleCorrection::getScaleCorr(), EnergyScaleCorrection::getSmearCorr(), edm::isNotFinite(), EGEnergySysIndex::kEcalErrPostCorr, EGEnergySysIndex::kEcalErrPreCorr, EGEnergySysIndex::kEcalPostCorr, EGEnergySysIndex::kEcalPreCorr, EGEnergySysIndex::kEcalTrkErrPostCorr, EGEnergySysIndex::kEcalTrkErrPreCorr, EGEnergySysIndex::kEcalTrkPostCorr, EGEnergySysIndex::kEcalTrkPreCorr, EcalRecHit::kHasSwitchToGain1, EcalRecHit::kHasSwitchToGain6, EGEnergySysIndex::kScaleValue, EGEnergySysIndex::kSmearNrSigma, EGEnergySysIndex::kSmearValue, MC, minEt_, EnergyScaleCorrection::ScaleCorrection::scale(), setEnergyAndSystVarations(), EnergyScaleCorrection::SmearCorrection::sigma(), and reco::GsfElectron::superCluster().

{
  const float scEtaAbs = std::abs(ele.superCluster()->eta());
  const float et = ele.ecalEnergy() / cosh(scEtaAbs);

  if (et < minEt_ || edm::isNotFinite(et) ) {
    std::array<float,EGEnergySysIndex::kNrSysErrs> retVal;
    retVal.fill(ele.energy());
    retVal[EGEnergySysIndex::kScaleValue]  = 1.0;
    retVal[EGEnergySysIndex::kSmearValue]  = 0.0;
    retVal[EGEnergySysIndex::kSmearNrSigma] = smearNrSigma;
    retVal[EGEnergySysIndex::kEcalPreCorr] = ele.ecalEnergy();
    retVal[EGEnergySysIndex::kEcalErrPreCorr] = ele.ecalEnergyError();
    retVal[EGEnergySysIndex::kEcalPostCorr] = ele.ecalEnergy();
    retVal[EGEnergySysIndex::kEcalErrPostCorr] = ele.ecalEnergyError();
    retVal[EGEnergySysIndex::kEcalTrkPreCorr] = ele.energy();
    retVal[EGEnergySysIndex::kEcalTrkErrPreCorr] = ele.corrections().combinedP4Error;
    retVal[EGEnergySysIndex::kEcalTrkPostCorr] = ele.energy();
    retVal[EGEnergySysIndex::kEcalTrkErrPostCorr] = ele.corrections().combinedP4Error;
    return retVal;
  }

  const DetId seedDetId = ele.superCluster()->seed()->seed();
  EcalRecHitCollection::const_iterator seedRecHit = recHits->find(seedDetId);
  unsigned int gainSeedSC = 12;
  if (seedRecHit != recHits->end()) { 
    if(seedRecHit->checkFlag(EcalRecHit::kHasSwitchToGain6)) gainSeedSC = 6;
    if(seedRecHit->checkFlag(EcalRecHit::kHasSwitchToGain1)) gainSeedSC = 1;
  }

  const EnergyScaleCorrection::ScaleCorrection* scaleCorr = correctionRetriever_.getScaleCorr(runNumber, et, scEtaAbs, ele.full5x5_r9(), gainSeedSC);  
  const EnergyScaleCorrection::SmearCorrection* smearCorr = correctionRetriever_.getSmearCorr(runNumber, et, scEtaAbs, ele.full5x5_r9(), gainSeedSC);  
  if(scaleCorr==nullptr) scaleCorr=&defaultScaleCorr_;
  if(smearCorr==nullptr) smearCorr=&defaultSmearCorr_;
  
  std::array<float,EGEnergySysIndex::kNrSysErrs> uncertainties{};
  
  uncertainties[EGEnergySysIndex::kScaleValue]  = scaleCorr->scale();
  uncertainties[EGEnergySysIndex::kSmearValue]  = smearCorr->sigma(et); //even though we use scale = 1.0, we still store the value returned for MC
  uncertainties[EGEnergySysIndex::kSmearNrSigma]  = smearNrSigma;
  //MC central values are not scaled (scale = 1.0), data is not smeared (smearNrSigma = 0)
  //the smearing (or resolution extra parameter as it might better be called)
  //still has a second order effect on data as it enters the E/p combination as an adjustment
  //to the estimate of the resolution contained in caloEnergyError
  //MC gets all the scale systematics
  if(eventType == EventType::DATA){ 
    setEnergyAndSystVarations(scaleCorr->scale(),0.,et,*scaleCorr,*smearCorr,ele,uncertainties);
  }else if(eventType == EventType::MC){
    setEnergyAndSystVarations(1.0,smearNrSigma,et,*scaleCorr,*smearCorr,ele,uncertainties);
  }
 
  return uncertainties;
  
}

void ElectronEnergyCalibrator::calibrate	(	SimpleElectron &	electron,
		edm::StreamID const &	streamID
	)

Definition at line 164 of file ElectronEnergyCalibrator.cc.

References correctionValues::corrCat0, correctionValues::corrCat1, correctionValues::corrCat2, correctionValues::corrCat3, correctionValues::corrCat4, correctionValues::corrCat5, correctionValues::corrCat6, correctionValues::corrCat7, correctionsType_, corrValArray, gather_cfg::cout, dataset_, PVValHelper::eta, Exception, edm::RandomNumberGenerator::getEngine(), SimpleElectron::getEta(), SimpleElectron::getR9(), SimpleElectron::getRegEnergy(), SimpleElectron::getRegEnergyError(), SimpleElectron::getRunNumber(), SimpleElectron::getSCEnergy(), SimpleElectron::getSCEnergyError(), mps_fire::i, edm::Service< T >::isAvailable(), SimpleElectron::isEB(), isMC_, lumiRatio_, nCorrValRaw, newEnergy_, newEnergyError_, electrons_cff::r9, Scenarios_cff::scale, SimpleElectron::setNewEnergy(), SimpleElectron::setNewEnergyError(), mathSSE::sqrt(), synchronization_, updateEnergyErrors_, and verbose_.

Referenced by calibrate(), initPrivateRng(), CalibratedElectronProducerT< T >::produce(), and setMinEt().

{
    double scale = 1.0;
    double dsigMC=0.; 
    double corrMC=0.;
    double run_ = electron.getRunNumber();
    bool isEB = electron.isEB();
    double eta = electron.getEta();
    double r9 = electron.getR9();
    
    switch ( correctionsType_ )
    {
        case 1: 
            if ( verbose_ ) 
            {
                std::cout << "[ElectronEnergyCalibrator] Using regression energy for calibration" << std::endl;
            }
            newEnergy_ = electron.getRegEnergy();
            newEnergyError_ = electron.getRegEnergyError();
            break;
        case 2: 
            if( verbose_ ) 
            {
                std::cout << "[ElectronEnergyCalibrator] Using scale corrections for new regression" << std::endl;
            }
            newEnergy_ = electron.getRegEnergy();
            newEnergyError_ = electron.getRegEnergyError();
            break;
        case 3: 
            if ( verbose_ ) 
            {
                std::cout << "[ElectronEnergyCalibrator] Using standard ecal energy for calibration" << std::endl;
            }
            newEnergy_ = electron.getSCEnergy();
            newEnergyError_ = electron.getSCEnergyError();
            break;
    }

    edm::Service<edm::RandomNumberGenerator> rng;
    if ( !rng.isAvailable() ) 
    {
        throw cms::Exception("Configuration")
        << "XXXXXXX requires the RandomNumberGeneratorService\n"
           "which is not present in the configuration file.  You must add the service\n"
           "in the configuration file or remove the modules that require it.";
    }
    
    if (!isMC_ )
    {
        for ( int i=0; i < nCorrValRaw; i++ )
        {
            if ( (run_ >= corrValArray[i].nRunMin ) && ( run_ <= corrValArray[i].nRunMax ) )
            {
                if ( isEB ) 
                {
                    if ( fabs(eta) < 1 ) 
                    {
                        if ( r9<0.94 ) 
                        {
                            scale = corrValArray[i].corrCat0;
                        } else 
                        {
                            scale = corrValArray[i].corrCat1;
                        }
                    } else 
                    {
                        if ( r9<0.94 ) 
                        {
                            scale = corrValArray[i].corrCat2;
                        } else 
                        {
                            scale = corrValArray[i].corrCat3;
                        }
                    }
                } else 
                {
                    if ( fabs(eta) < 2 ) 
                    {
                        if ( r9<0.94 ) 
                        {
                            scale = corrValArray[i].corrCat4;
                        } else 
                        {
                            scale = corrValArray[i].corrCat5;
                        }
                    } else 
                    {
                        if ( r9<0.94 ) 
                        {
                            scale = corrValArray[i].corrCat6;
                        } else 
                        {
                            scale = corrValArray[i].corrCat7;
                        }
                    }
                }
            }
        }
        newEnergy_ = newEnergy_*scale;
    }
  
    switch ( correctionsType_ )
    {
        case 1:
            // Implementation of the MC smearing for regression energy type 1
            if ( dataset_ == "Summer12_DR53X_HCP2012" || dataset_ == "Moriond2013" ) 
            { 
                if ( !isMC_ )
                {
                    if ( run_ <= 203002 ) 
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0103;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0090;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0190;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0156;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0269;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0287;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0364;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0321;   
                    } else 
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0109;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0099;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0182;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0200;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0282;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0309;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0386;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0359;   
                    }
                } else 
                {
                    CLHEP::RandFlat flatRandom(rng->getEngine(streamID));
                    double rn = flatRandom.fire();
                    if ( rn > lumiRatio_ ) 
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0109;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0099;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0182;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0200;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0282;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0309;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0386;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0359;  
                    } else 
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0103;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0090;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0190;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0156;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0269;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0287;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0364;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0321;  
                    }
                    if ( lumiRatio_ == 0.0 )
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0103;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0090;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0190;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0156;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0269;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0287;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0364;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0321; 
                    }
                    if ( lumiRatio_ == 1.0 )
                    {
                        if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0109;
                        if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0099;
                        if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0182;
                        if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0200;
                        if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0282;
                        if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0309;
                        if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0386;
                        if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0359; 
                    }
                }
            }
        break;

        case 2: 
            // Implementation of the MC smearing for regression energy type 2
            if ( dataset_ == "Summer12_LegacyPaper" || dataset_ == "22Jan2013ReReco" ) 
            { 
                if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0094;
                if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0092;
                if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0182;
                if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0139;
                if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0220;
                if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0229;
                if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0290;
                if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0234;   
            }
        break;

        case 3: 
            // standard SC energy scale corrections implementation
            if ( dataset_ == "Summer11" || dataset_ == "ReReco" ) 
            { // values from https://indico.cern.ch/conferenceDisplay.py?confId=146386
                if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.01;
                if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0099;
                if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0217;
                if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0157;
                if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0326;
                if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0330;
                if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0331;
                if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0378;
            } else if ( dataset_ == "Fall11" || dataset_ == "Jan16ReReco" ) 
            { // values from https://hypernews.cern.ch/HyperNews/CMS/get/higgs2g/634.html, consistant with Jan16ReReco corrections
                if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0096;
                if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0074;
                if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0196;
                if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0141;
                if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0279;
                if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0268;
                if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0301;
                if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0293;   
            } else if ( dataset_ == "Summer12" || dataset_ == "ICHEP2012" ) 
            { // new values from https://twiki.cern.ch/twiki/pub/CMS/EcalEnergyResolutionWithZee/oriented-ICHEP-scales_resolution.pdf
                if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0119;
                if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0107;
                if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0240;
                if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0149;
                if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0330;
                if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0375;
                if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0602;
                if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0607;   
            }  else if ( dataset_ == "Summer12_DR53X_HCP2012" || dataset_ == "Moriond2013" ) 
            { 
                if ( isEB  && fabs(eta) <  1 && r9 <  0.94 ) dsigMC = 0.0099;
                if ( isEB  && fabs(eta) <  1 && r9 >= 0.94 ) dsigMC = 0.0103;
                if ( isEB  && fabs(eta) >= 1 && r9 <  0.94 ) dsigMC = 0.0219;
                if ( isEB  && fabs(eta) >= 1 && r9 >= 0.94 ) dsigMC = 0.0158;
                if ( !isEB && fabs(eta) <  2 && r9 <  0.94 ) dsigMC = 0.0222;
                if ( !isEB && fabs(eta) <  2 && r9 >= 0.94 ) dsigMC = 0.0298;
                if ( !isEB && fabs(eta) >= 2 && r9 <  0.94 ) dsigMC = 0.0318;
                if ( !isEB && fabs(eta) >= 2 && r9 >= 0.94 ) dsigMC = 0.0302;   
            }      
        break;
    }

    if ( isMC_ ) 
    {
        CLHEP::RandGaussQ gaussDistribution(rng->getEngine(streamID), 1.,dsigMC);
        corrMC = gaussDistribution.fire();
        if ( verbose_ ) 
        {
            std::cout << "[ElectronEnergyCalibrator] unsmeared energy " << newEnergy_ << std::endl;
        }
        if ( synchronization_ ) 
        {
            std::cout << "[ElectronEnergyCalibrator] "
            << "======================= SYNCRONIZATION MODE! ======================="
            << std::endl;
            newEnergy_ = newEnergy_*(1+dsigMC);
        } else 
        {
            newEnergy_ = newEnergy_*corrMC; 
        }
        if ( verbose_ ) 
        {
            std::cout << "[ElectronEnergyCalibrator] smeared energy " << newEnergy_ << std::endl;
        }
    }  
    
    // correct energy error for MC and for data as error is obtained from (ideal) MC parametrisation
    if ( updateEnergyErrors_ ) 
    {
        newEnergyError_ = sqrt(newEnergyError_*newEnergyError_ + dsigMC*dsigMC*newEnergy_*newEnergy_);
    }
    if ( verbose_ ) 
    {
        std::cout << "[ElectronEnergyCalibrator] initial energy " 
        << electron.getRegEnergy() << " recalibrated  energy " << newEnergy_ << std::endl;
    }
    if ( verbose_ ) 
    {
        std::cout << "[ElectronEnergyCalibrator] initial energy error " 
            << electron.getRegEnergyError() << " recalibrated energy error " 
            << newEnergyError_ << std::endl;
    }
    
    electron.setNewEnergy(newEnergy_);
    electron.setNewEnergyError(newEnergyError_);
}

void ElectronEnergyCalibrator::correctLinearity

(

SimpleElectron &

electron

)

Definition at line 451 of file ElectronEnergyCalibrator.cc.

References applyLinearityCorrection_, linearityCorrectionValues::corrCat0, linearityCorrectionValues::corrCat1, linearityCorrectionValues::corrCat2, linearityCorrectionValues::corrCat3, linearityCorrectionValues::corrCat4, linearityCorrectionValues::corrCat5, gather_cfg::cout, PVValHelper::eta, JetChargeProducer_cfi::exp, SimpleElectron::getCombinedMomentum(), SimpleElectron::getElClass(), SimpleElectron::getEta(), mps_fire::i, SimpleElectron::isEB(), isMC_, linCorrValArray, nLinCorrValRaw, AlCaHLTBitMon_ParallelJobs::p, EnergyCorrector::pt, AlignmentTrackSelector_cfi::ptMax, ptMin, SimpleElectron::setCombinedMomentum(), funct::sin(), theta(), and verbose_.

{
    if(!isMC_ && applyLinearityCorrection_) 
    {
        bool   isEB           = electron.isEB();
        double eta            = electron.getEta();
        double theta          = 2*atan(exp(-eta));
        double p              = electron.getCombinedMomentum();
        double pt             = p * fabs(sin(theta));
        int    classification = electron.getElClass();
        double linscale       = 0.;

        for (int i=0; i < nLinCorrValRaw; i++)
        {
            if ((pt >= linCorrValArray[i].ptMin) && (pt <= linCorrValArray[i].ptMax))
            {
                if (isEB) 
                {
                    if (fabs(eta) < 1) 
                    {
                        if (classification<2) 
                        {
                            linscale = linCorrValArray[i].corrCat0;
                        } else 
                        {
                            linscale = linCorrValArray[i].corrCat3;
                        }
                    } else 
                    {
                        if (classification<2) 
                        {
                            linscale = linCorrValArray[i].corrCat1;
                        } else 
                        {
                            linscale = linCorrValArray[i].corrCat4;
                        }
                    }
                } else // !isEB
                {
                    if (classification<2) 
                    {
                        linscale = linCorrValArray[i].corrCat2;
                    } else 
                    {
                        linscale = linCorrValArray[i].corrCat5;
                    }
                }
            }
        }
        double newP = p/(1.+linscale);          
        if (verbose_) 
        {
            std::cout << "[ElectronEnergyCalibrator] Applying a linearity correction of " << 1./(1.+linscale) << "   to   " << pt << " GeV in pt" << std::endl; 
        }
        electron.setCombinedMomentum(newP);
        if (verbose_) 
        {
            std::cout << "[ElectronEnergyCalibrator] calibrated transverse momentum " << pt << " GeV recalibrated for linearity to momentum " << electron.getCombinedMomentum()*fabs(sin(theta)) << " GeV" << std::endl;
        }
    }
}

double ElectronEnergyCalibrator::gauss ( edm::StreamID const &  id ) const

private

Return a number distributed as a unit gaussian, drawn from the private RNG if initPrivateRng was called, or from the CMSSW RandomNumberGenerator service If synchronization is set to true, it returns a fixed number (1.0)

Definition at line 203 of file ElectronEnergyCalibrator.cc.

References Exception, edm::RandomNumberGenerator::getEngine(), edm::Service< T >::isAvailable(), and rng_.

Referenced by calibrate(), and setMinEt().

{
  if (rng_) {
    return rng_->Gaus();
  } else {
    edm::Service<edm::RandomNumberGenerator> rng;
    if ( !rng.isAvailable() ) {
      throw cms::Exception("Configuration")
    << "XXXXXXX requires the RandomNumberGeneratorService\n"
    "which is not present in the configuration file.  You must add the service\n"
    "in the configuration file or remove the modules that require it.";
    }
    CLHEP::RandGaussQ gaussDistribution(rng->getEngine(id), 0.0, 1.0);
    return gaussDistribution.fire();
  }
}

void ElectronEnergyCalibrator::init ( void  )

private

Definition at line 23 of file ElectronEnergyCalibrator.cc.

References applyLinearityCorrection_, correctionValues::corrCat0, linearityCorrectionValues::corrCat0, correctionValues::corrCat1, linearityCorrectionValues::corrCat1, correctionValues::corrCat2, linearityCorrectionValues::corrCat2, correctionValues::corrCat3, linearityCorrectionValues::corrCat3, correctionValues::corrCat4, linearityCorrectionValues::corrCat4, correctionValues::corrCat5, linearityCorrectionValues::corrCat5, correctionValues::corrCat6, correctionValues::corrCat7, corrValArray, gather_cfg::cout, csvReporter::delimiter, Exception, groupFilesInBlocks::fin, isMC_, linCorrValArray, nCorrValRaw, nLinCorrValRaw, correctionValues::nRunMax, correctionValues::nRunMin, pathData_, pathLinData_, linearityCorrectionValues::ptMax, linearityCorrectionValues::ptMin, alignCSCRings::s, splitString(), AlCaHLTBitMon_QueryRunRegistry::string, stringToDouble(), and verbose_.

{
    if ( !isMC_ ) // DATA
    {
        if ( verbose_ ) 
        { 
            std::cout << "[ElectronEnergyCalibrator] Initialization in DATA mode" << std::endl;
        }

        std::ifstream fin(pathData_.c_str());
    
        if (!fin){
                 throw cms::Exception("Configuration")
                 << "[ElectronEnergyCalibrator] Cannot open the file " 
                 << pathData_ << "\n It is not found, missed or corrupted" ;
        } else
        {
            if ( verbose_ ) 
            {
                std::cout << "[ElectronEnergyCalibrator] File " 
                    << pathData_ << " succesfully opened" << std::endl;
            }
    
        std::string s;
        std::vector<std::string> selements;
        std::string delimiter = ",";
            nCorrValRaw = 0;    
        
            while ( !fin.eof() ) 
            {
                getline(fin, s);
                if ( !s.empty() ) 
                {
                    splitString(s, selements, delimiter);
                    corrValArray[nCorrValRaw].nRunMin = stringToDouble(selements[0]);
                    corrValArray[nCorrValRaw].nRunMax = stringToDouble(selements[1]);
                    corrValArray[nCorrValRaw].corrCat0 = stringToDouble(selements[2]);
                    corrValArray[nCorrValRaw].corrCat1 = stringToDouble(selements[3]);
                    corrValArray[nCorrValRaw].corrCat2 = stringToDouble(selements[4]);
                    corrValArray[nCorrValRaw].corrCat3 = stringToDouble(selements[5]);
                    corrValArray[nCorrValRaw].corrCat4 = stringToDouble(selements[6]);
                    corrValArray[nCorrValRaw].corrCat5 = stringToDouble(selements[7]);
                    corrValArray[nCorrValRaw].corrCat6 = stringToDouble(selements[8]);
                    corrValArray[nCorrValRaw].corrCat7 = stringToDouble(selements[9]);
    
                    nCorrValRaw++;
        
                    selements.clear();
                }
            }
        
            fin.close();
    
            if ( verbose_ ) 
            {
                std::cout << "[ElectronEnergyCalibrator] File closed" << std::endl;
            }

        }
        // linearity corrections data
        if(applyLinearityCorrection_) 
        {
      std::ifstream finlin(pathLinData_.c_str());

            if (!finlin)
            {
                throw cms::Exception("Configuration")
                    << "[ElectronEnergyCalibrator] Cannot open the file "<< pathLinData_ << "\n It is not found, missed or corrupted" ;
            } else
            {
                if (verbose_) 
                {
                    std::cout<<"[ElectronEnergyCalibrator] File with Linearity Corrections "<<pathLinData_<<" succesfully opened"<<std::endl;
                }

                std::string s;
                std::vector<std::string> selements;
                std::string delimiter = ",";
                nLinCorrValRaw = 0; 

                while ( !finlin.eof() ) 
                {
                    getline(finlin, s);
                    if ( !s.empty() ) 
                    {
                        splitString(s, selements, delimiter);

                        linCorrValArray[nLinCorrValRaw].ptMin    = stringToDouble(selements[0]);
                        linCorrValArray[nLinCorrValRaw].ptMax    = stringToDouble(selements[1]);
                        linCorrValArray[nLinCorrValRaw].corrCat0 = stringToDouble(selements[2]);
                        linCorrValArray[nLinCorrValRaw].corrCat1 = stringToDouble(selements[3]);
                        linCorrValArray[nLinCorrValRaw].corrCat2 = stringToDouble(selements[4]);
                        linCorrValArray[nLinCorrValRaw].corrCat3 = stringToDouble(selements[5]);
                        linCorrValArray[nLinCorrValRaw].corrCat4 = stringToDouble(selements[6]);
                        linCorrValArray[nLinCorrValRaw].corrCat5 = stringToDouble(selements[7]);

                        nLinCorrValRaw++;

                        selements.clear();
                    }
                }

                finlin.close();

                if (verbose_) 
                {
                    std::cout<<"[ElectronEnergyCalibrator] File closed"<<std::endl;
                }
            }
        }
    } else // MC
    {
        if ( verbose_ ) 
        {
            std::cout << "[ElectronEnergyCalibrator] Initialization in MC mode" << std::endl;
        }
    }
}

void ElectronEnergyCalibrator::initPrivateRng

(

TRandom *

rnd

)

Initialize with a random number generator (if not done, it will use the CMSSW service) Caller code owns the TRandom.

Definition at line 22 of file ElectronEnergyCalibrator.cc.

References calibrate(), and rng_.

Referenced by CalibratedElectronProducerT< T >::CalibratedElectronProducerT(), and ~ElectronEnergyCalibrator().

{
  rng_ = rnd;
}

void ElectronEnergyCalibrator::setEcalEnergy ( reco::GsfElectron &  ele, const float  scale, const float  smear  ) const

private

Definition at line 171 of file ElectronEnergyCalibrator.cc.

References reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), reco::GsfElectron::setCorrectedEcalEnergy(), and reco::GsfElectron::setCorrectedEcalEnergyError().

Referenced by calCombinedMom(), setEnergyAndSystVarations(), and setMinEt().

{
  const float oldEcalEnergy = ele.ecalEnergy();
  const float oldEcalEnergyErr = ele.ecalEnergyError();
  ele.setCorrectedEcalEnergy( oldEcalEnergy*scale );
  ele.setCorrectedEcalEnergyError(std::hypot( oldEcalEnergyErr*scale, oldEcalEnergy*smear*scale ) );
}

void ElectronEnergyCalibrator::setEnergyAndSystVarations ( const float  scale, const float  smearNrSigma, const float  et, const EnergyScaleCorrection::ScaleCorrection &  scaleCorr, const EnergyScaleCorrection::SmearCorrection &  smearCorr, reco::GsfElectron &  ele, std::array< float, EGEnergySysIndex::kNrSysErrs > &  energyData  ) const

private

Definition at line 97 of file ElectronEnergyCalibrator.cc.

References calCombinedMom(), reco::GsfElectron::Corrections::combinedP4Error, corr, reco::GsfElectron::corrections(), reco::GsfElectron::correctMomentum(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), reco::LeafCandidate::energy(), EGEnergySysIndex::kEcalErrPostCorr, EGEnergySysIndex::kEcalErrPreCorr, EGEnergySysIndex::kEcalPostCorr, EGEnergySysIndex::kEcalPreCorr, EGEnergySysIndex::kEcalTrkErrPostCorr, EGEnergySysIndex::kEcalTrkErrPreCorr, EGEnergySysIndex::kEcalTrkPostCorr, EGEnergySysIndex::kEcalTrkPreCorr, EnergyScaleCorrection::kErrStatSystGain, EGEnergySysIndex::kScaleDown, EGEnergySysIndex::kScaleGainDown, EGEnergySysIndex::kScaleGainUp, EGEnergySysIndex::kScaleStatDown, EGEnergySysIndex::kScaleStatUp, EGEnergySysIndex::kScaleSystDown, EGEnergySysIndex::kScaleSystUp, EGEnergySysIndex::kScaleUp, EGEnergySysIndex::kSmearDown, EGEnergySysIndex::kSmearPhiDown, EGEnergySysIndex::kSmearPhiUp, EGEnergySysIndex::kSmearRhoDown, EGEnergySysIndex::kSmearRhoUp, EGEnergySysIndex::kSmearUp, reco::GsfElectron::p4(), EnergyScaleCorrection::ScaleCorrection::scaleErr(), EnergyScaleCorrection::ScaleCorrection::scaleErrGain(), EnergyScaleCorrection::ScaleCorrection::scaleErrStat(), EnergyScaleCorrection::ScaleCorrection::scaleErrSyst(), setEcalEnergy(), EnergyScaleCorrection::SmearCorrection::sigma(), and reco::GsfElectron::trackMomentumError().

Referenced by calibrate(), and setMinEt().

{
 
  const float smear = smearCorr.sigma(et);   
  const float smearRhoUp = smearCorr.sigma(et,1,0);
  const float smearRhoDn = smearCorr.sigma(et,-1,0);
  const float smearPhiUp = smearCorr.sigma(et,0,1);
  const float smearPhiDn = smearCorr.sigma(et,0,-1);
  const float smearUp = smearRhoUp;
  const float smearDn = smearRhoDn;

  const float corr = scale + smear * smearNrSigma;
  const float corrRhoUp = scale + smearRhoUp * smearNrSigma;
  const float corrRhoDn = scale + smearRhoDn * smearNrSigma;
  const float corrPhiUp = scale + smearPhiUp * smearNrSigma;
  const float corrPhiDn = scale + smearPhiDn * smearNrSigma;
  const float corrUp = corrRhoUp;
  const float corrDn = corrRhoDn;

  const float corrScaleStatUp = corr+scaleCorr.scaleErrStat();
  const float corrScaleStatDn = corr-scaleCorr.scaleErrStat();
  const float corrScaleSystUp = corr+scaleCorr.scaleErrSyst();
  const float corrScaleSystDn = corr-scaleCorr.scaleErrSyst();
  const float corrScaleGainUp = corr+scaleCorr.scaleErrGain();
  const float corrScaleGainDn = corr-scaleCorr.scaleErrGain();
  const float corrScaleUp = corr+scaleCorr.scaleErr(EnergyScaleCorrection::kErrStatSystGain);
  const float corrScaleDn = corr-scaleCorr.scaleErr(EnergyScaleCorrection::kErrStatSystGain);
  
  const math::XYZTLorentzVector oldP4 = ele.p4();
  energyData[EGEnergySysIndex::kEcalTrkPreCorr] = ele.energy();
  energyData[EGEnergySysIndex::kEcalTrkErrPreCorr] = ele.corrections().combinedP4Error;
  energyData[EGEnergySysIndex::kEcalPreCorr] = ele.ecalEnergy();
  energyData[EGEnergySysIndex::kEcalErrPreCorr] = ele.ecalEnergyError();
  
  energyData[EGEnergySysIndex::kScaleStatUp]   = calCombinedMom(ele,corrScaleStatUp,smear).first;
  energyData[EGEnergySysIndex::kScaleStatDown] = calCombinedMom(ele,corrScaleStatDn,smear).first;
  energyData[EGEnergySysIndex::kScaleSystUp]   = calCombinedMom(ele,corrScaleSystUp,smear).first;
  energyData[EGEnergySysIndex::kScaleSystDown] = calCombinedMom(ele,corrScaleSystDn,smear).first;
  energyData[EGEnergySysIndex::kScaleGainUp]   = calCombinedMom(ele,corrScaleGainUp,smear).first;
  energyData[EGEnergySysIndex::kScaleGainDown] = calCombinedMom(ele,corrScaleGainDn,smear).first;
  
  energyData[EGEnergySysIndex::kSmearRhoUp]   = calCombinedMom(ele,corrRhoUp,smearRhoUp).first;
  energyData[EGEnergySysIndex::kSmearRhoDown] = calCombinedMom(ele,corrRhoDn,smearRhoDn).first;
  energyData[EGEnergySysIndex::kSmearPhiUp]   = calCombinedMom(ele,corrPhiUp,smearPhiUp).first;
  energyData[EGEnergySysIndex::kSmearPhiDown] = calCombinedMom(ele,corrPhiDn,smearPhiDn).first;
  
  energyData[EGEnergySysIndex::kScaleUp]   = calCombinedMom(ele,corrScaleUp,smear).first;
  energyData[EGEnergySysIndex::kScaleDown] = calCombinedMom(ele,corrScaleDn,smear).first;
  energyData[EGEnergySysIndex::kSmearUp]   = calCombinedMom(ele,corrUp,smearUp).first;
  energyData[EGEnergySysIndex::kSmearDown] = calCombinedMom(ele,corrDn,smearDn).first;
  
  const std::pair<float, float> combinedMomentum = calCombinedMom(ele,corr,smear);
  setEcalEnergy(ele,corr,smear);
  const float energyCorr =  combinedMomentum.first / oldP4.t();

  const math::XYZTLorentzVector newP4(oldP4.x() * energyCorr,
                      oldP4.y() * energyCorr,
                      oldP4.z() * energyCorr,
                      combinedMomentum.first);
  
  ele.correctMomentum(newP4, ele.trackMomentumError(), combinedMomentum.second); 
  energyData[EGEnergySysIndex::kEcalTrkPostCorr] = ele.energy();
  energyData[EGEnergySysIndex::kEcalTrkErrPostCorr] = ele.corrections().combinedP4Error;
  
  energyData[EGEnergySysIndex::kEcalPostCorr] = ele.ecalEnergy();
  energyData[EGEnergySysIndex::kEcalErrPostCorr] = ele.ecalEnergyError();
  
}

void ElectronEnergyCalibrator::setMinEt ( float  val )

inline

Definition at line 41 of file ElectronEnergyCalibrator.h.

References calCombinedMom(), calibrate(), stringResolutionProvider_cfi::et, gauss(), minEt_, convertSQLiteXML::runNumber, Scenarios_cff::scale, setEcalEnergy(), setEnergyAndSystVarations(), and heppy_batch::val.

Referenced by CalibratedElectronProducerT< T >::CalibratedElectronProducerT().

{minEt_=val;}

void ElectronEnergyCalibrator::splitString ( const std::string &  fullstr, std::vector< std::string > &  elements, const std::string &  delimiter  )

private

Definition at line 142 of file ElectronEnergyCalibrator.cc.

Referenced by init().

{
    std::string::size_type lastpos = fullstr.find_first_not_of(delimiter, 0);
    std::string::size_type pos     = fullstr.find_first_of(delimiter, lastpos);
    
    while ( ( std::string::npos != pos ) || ( std::string::npos != lastpos ) ) 
    {
        elements.push_back(fullstr.substr(lastpos, pos-lastpos));
        lastpos = fullstr.find_first_not_of(delimiter, pos);
        pos = fullstr.find_first_of(delimiter, lastpos);
    }
}

double ElectronEnergyCalibrator::stringToDouble ( const std::string &  str )

private

Definition at line 155 of file ElectronEnergyCalibrator.cc.

References heppy_batch::val.

Referenced by init().

{
  std::istringstream stm;
    double val = 0;
    stm.str(str);
    stm >> val;
    return val;
}

Member Data Documentation

bool ElectronEnergyCalibrator::applyLinearityCorrection_

private

Definition at line 86 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

EnergyScaleCorrection ElectronEnergyCalibrator::correctionRetriever_

private

Definition at line 71 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

int ElectronEnergyCalibrator::correctionsType_

private

Definition at line 85 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

correctionValues ElectronEnergyCalibrator::corrValArray[100]

private

Definition at line 93 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and init().

correctionValues ElectronEnergyCalibrator::corrValMC

private

Definition at line 94 of file ElectronEnergyCalibrator.h.

std::string ElectronEnergyCalibrator::dataset_

private

Definition at line 84 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

const EnergyScaleCorrection::ScaleCorrection ElectronEnergyCalibrator::defaultScaleCorr_

staticprivate

Definition at line 77 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

const EnergyScaleCorrection::SmearCorrection ElectronEnergyCalibrator::defaultSmearCorr_

staticprivate

Definition at line 78 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

const EpCombinationTool* ElectronEnergyCalibrator::epCombinationTool_

private

Definition at line 72 of file ElectronEnergyCalibrator.h.

Referenced by calCombinedMom().

bool ElectronEnergyCalibrator::isMC_

private

Definition at line 88 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), correctLinearity(), and init().

linearityCorrectionValues ElectronEnergyCalibrator::linCorrValArray[100]

private

Definition at line 95 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

double ElectronEnergyCalibrator::lumiRatio_

private

Definition at line 87 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

float ElectronEnergyCalibrator::minEt_

private

Definition at line 74 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and setMinEt().

int ElectronEnergyCalibrator::nCorrValRaw

private

Definition at line 96 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and init().

double ElectronEnergyCalibrator::newEnergy_

private

Definition at line 79 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

double ElectronEnergyCalibrator::newEnergyError_

private

Definition at line 80 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

int ElectronEnergyCalibrator::nLinCorrValRaw

private

Definition at line 96 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

std::string ElectronEnergyCalibrator::pathData_

private

Definition at line 82 of file ElectronEnergyCalibrator.h.

Referenced by init().

std::string ElectronEnergyCalibrator::pathLinData_

private

Definition at line 83 of file ElectronEnergyCalibrator.h.

Referenced by init().

TRandom* ElectronEnergyCalibrator::rng_

private

Definition at line 73 of file ElectronEnergyCalibrator.h.

Referenced by gauss(), and initPrivateRng().

bool ElectronEnergyCalibrator::synchronization_

private

Definition at line 91 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

bool ElectronEnergyCalibrator::updateEnergyErrors_

private

Definition at line 89 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

bool ElectronEnergyCalibrator::verbose_

private

Definition at line 90 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), correctLinearity(), and init().