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 39 of file ElectronEnergyCalibrator.h.

Member Enumeration Documentation

EventType

enum ElectronEnergyCalibrator::EventType

strong

Enumerator
DATA
MC

Definition at line 26 of file ElectronEnergyCalibrator.h.

                       {
    DATA,
    MC,
  };

Constructor & Destructor Documentation

ElectronEnergyCalibrator() [1/3]

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 41 of file ElectronEnergyCalibrator.h.

References init().

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

ElectronEnergyCalibrator() [2/3]

ElectronEnergyCalibrator::ElectronEnergyCalibrator ( )

inline

Definition at line 31 of file ElectronEnergyCalibrator.h.

{}

ElectronEnergyCalibrator() [3/3]

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::~ElectronEnergyCalibrator ( )

inline

Definition at line 33 of file ElectronEnergyCalibrator.h.

{}

Member Function Documentation

calCombinedMom()

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

private

Definition at line 170 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(), pfClustersFromCombinedCaloHF_cfi::scale, reco::GsfElectron::setCorrectedEcalEnergy(), reco::GsfElectron::setCorrectedEcalEnergyError(), setEcalEnergy(), and reco::GsfElectron::trackMomentumError().

Referenced by setEnergyAndSystVarations().

                                                                                          {
  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;
}

calibrate() [1/3]

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 18 of file ElectronEnergyCalibrator.cc.

References calibrate(), QIE11Task_cfi::eventType, gauss(), FastTrackerRecHitMaskProducer_cfi::recHits, and convertSQLiteXML::runNumber.

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

calibrate() [2/3]

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 27 of file ElectronEnergyCalibrator.cc.

References funct::abs(), reco::GsfElectron::Corrections::combinedP4Error, correctionRetriever_, reco::GsfElectron::corrections(), DATA, defaultScaleCorr_, defaultSmearCorr_, reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), reco::LeafCandidate::energy(), EgHLTOffHistBins_cfi::et, QIE11Task_cfi::eventType, 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_, FastTrackerRecHitMaskProducer_cfi::recHits, convertSQLiteXML::runNumber, 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;
}

calibrate() [3/3]

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

Definition at line 145 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_, HPSPFTauProducerPuppi_cfi::electron, PVValHelper::eta, Exception, edm::RandomNumberGenerator::getEngine(), mps_fire::i, edm::Service< T >::isAvailable(), electrons_cff::isEB, isMC_, lumiRatio_, nCorrValRaw, newEnergy_, newEnergyError_, electrons_cff::r9, pfClustersFromCombinedCaloHF_cfi::scale, mathSSE::sqrt(), synchronization_, updateEnergyErrors_, and verbose_.

Referenced by calibrate().

                                                                                              {
  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_);
}

correctLinearity()

void ElectronEnergyCalibrator::correctLinearity

(

SimpleElectron &

electron

)

Definition at line 477 of file ElectronEnergyCalibrator.cc.

References applyLinearityCorrection_, linearityCorrectionValues::corrCat0, linearityCorrectionValues::corrCat1, linearityCorrectionValues::corrCat2, linearityCorrectionValues::corrCat3, linearityCorrectionValues::corrCat4, linearityCorrectionValues::corrCat5, gather_cfg::cout, HPSPFTauProducerPuppi_cfi::electron, PVValHelper::eta, JetChargeProducer_cfi::exp, mps_fire::i, electrons_cff::isEB, isMC_, linCorrValArray, nLinCorrValRaw, AlCaHLTBitMon_ParallelJobs::p, DiDispStaMuonMonitor_cfi::pt, AlignmentTrackSelector_cfi::ptMax, ptMin, 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;
    }
  }
}

gauss()

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 190 of file ElectronEnergyCalibrator.cc.

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

Referenced by calibrate().

                                                                  {
  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();
  }
}

init()

void ElectronEnergyCalibrator::init ( void  )

private

Definition at line 22 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, makeHLTPrescaleTable::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_.

Referenced by ElectronEnergyCalibrator().

                                    {
  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;
    }
  }
}

initPrivateRng()

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 16 of file ElectronEnergyCalibrator.cc.

References rng_.

{ rng_ = rnd; }

setEcalEnergy()

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

private

Definition at line 163 of file ElectronEnergyCalibrator.cc.

References reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), Matriplex::hypot(), pfClustersFromCombinedCaloHF_cfi::scale, reco::GsfElectron::setCorrectedEcalEnergy(), and reco::GsfElectron::setCorrectedEcalEnergyError().

Referenced by calCombinedMom(), and setEnergyAndSystVarations().

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

setEnergyAndSystVarations()

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 92 of file ElectronEnergyCalibrator.cc.

References calCombinedMom(), reco::GsfElectron::Corrections::combinedP4Error, alignCSCRings::corr, reco::GsfElectron::corrections(), reco::GsfElectron::correctMomentum(), reco::GsfElectron::ecalEnergy(), reco::GsfElectron::ecalEnergyError(), reco::LeafCandidate::energy(), EgHLTOffHistBins_cfi::et, 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(), pfClustersFromCombinedCaloHF_cfi::scale, EnergyScaleCorrection::ScaleCorrection::scaleErr(), EnergyScaleCorrection::ScaleCorrection::scaleErrGain(), EnergyScaleCorrection::ScaleCorrection::scaleErrStat(), EnergyScaleCorrection::ScaleCorrection::scaleErrSyst(), setEcalEnergy(), EnergyScaleCorrection::SmearCorrection::sigma(), and reco::GsfElectron::trackMomentumError().

Referenced by calibrate().

                                                                   {
  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();
}

setMinEt()

void ElectronEnergyCalibrator::setMinEt ( float  val )

inline

Definition at line 40 of file ElectronEnergyCalibrator.h.

References minEt_, and heppy_batch::val.

{ minEt_ = val; }

splitString()

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

private

Definition at line 124 of file ElectronEnergyCalibrator.cc.

References makeHLTPrescaleTable::delimiter, and bookConverter::elements.

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);
  }
}

stringToDouble()

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

private

Definition at line 137 of file ElectronEnergyCalibrator.cc.

References str, and heppy_batch::val.

Referenced by init().

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

Member Data Documentation

applyLinearityCorrection_

bool ElectronEnergyCalibrator::applyLinearityCorrection_

private

Definition at line 79 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

correctionRetriever_

EnergyScaleCorrection ElectronEnergyCalibrator::correctionRetriever_

private

Definition at line 74 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

correctionsType_

int ElectronEnergyCalibrator::correctionsType_

private

Definition at line 78 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

corrValArray

correctionValues ElectronEnergyCalibrator::corrValArray[100]

private

Definition at line 86 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and init().

corrValMC

correctionValues ElectronEnergyCalibrator::corrValMC

private

Definition at line 87 of file ElectronEnergyCalibrator.h.

dataset_

std::string ElectronEnergyCalibrator::dataset_

private

Definition at line 77 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

defaultScaleCorr_

const EnergyScaleCorrection::ScaleCorrection ElectronEnergyCalibrator::defaultScaleCorr_

staticprivate

Definition at line 80 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

defaultSmearCorr_

const EnergyScaleCorrection::SmearCorrection ElectronEnergyCalibrator::defaultSmearCorr_

staticprivate

Definition at line 81 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

epCombinationTool_

const EpCombinationTool* ElectronEnergyCalibrator::epCombinationTool_

private

Definition at line 75 of file ElectronEnergyCalibrator.h.

Referenced by calCombinedMom().

isMC_

bool ElectronEnergyCalibrator::isMC_

private

Definition at line 81 of file ElectronEnergyCalibrator.h.

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

linCorrValArray

linearityCorrectionValues ElectronEnergyCalibrator::linCorrValArray[100]

private

Definition at line 88 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

lumiRatio_

double ElectronEnergyCalibrator::lumiRatio_

private

Definition at line 80 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

minEt_

float ElectronEnergyCalibrator::minEt_

private

Definition at line 77 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and setMinEt().

nCorrValRaw

int ElectronEnergyCalibrator::nCorrValRaw

private

Definition at line 89 of file ElectronEnergyCalibrator.h.

Referenced by calibrate(), and init().

newEnergy_

double ElectronEnergyCalibrator::newEnergy_

private

Definition at line 72 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

newEnergyError_

double ElectronEnergyCalibrator::newEnergyError_

private

Definition at line 73 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

nLinCorrValRaw

int ElectronEnergyCalibrator::nLinCorrValRaw

private

Definition at line 89 of file ElectronEnergyCalibrator.h.

Referenced by correctLinearity(), and init().

pathData_

std::string ElectronEnergyCalibrator::pathData_

private

Definition at line 75 of file ElectronEnergyCalibrator.h.

Referenced by init().

pathLinData_

std::string ElectronEnergyCalibrator::pathLinData_

private

Definition at line 76 of file ElectronEnergyCalibrator.h.

Referenced by init().

rng_

TRandom* ElectronEnergyCalibrator::rng_

private

Definition at line 76 of file ElectronEnergyCalibrator.h.

Referenced by gauss(), and initPrivateRng().

synchronization_

bool ElectronEnergyCalibrator::synchronization_

private

Definition at line 84 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

updateEnergyErrors_

bool ElectronEnergyCalibrator::updateEnergyErrors_

private

Definition at line 82 of file ElectronEnergyCalibrator.h.

Referenced by calibrate().

verbose_

bool ElectronEnergyCalibrator::verbose_

private

Definition at line 83 of file ElectronEnergyCalibrator.h.

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