#include <PATMHTProducer.h>

Inheritance diagram for pat::PATMHTProducer:

Classes
class	uncertaintyFunctions

Public Member Functions
	PATMHTProducer (const edm::ParameterSet &)

	~PATMHTProducer () override

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
double	getElectrons (edm::Event &, const edm::EventSetup &)

double	getJets (edm::Event &, const edm::EventSetup &)

double	getMuons (edm::Event &, const edm::EventSetup &)

void	getTowers (edm::Event &, const edm::EventSetup &)

void	produce (edm::Event &, const edm::EventSetup &) override

void	setUncertaintyParameters ()

Private Attributes
edm::InputTag	CaloJetAlgorithmTag_

edm::InputTag	CaloTowerTag_

bool	controlledUncertainty_

edm::InputTag	CorJetAlgorithmTag_

uncertaintyFunctions	ecalEBUncertainty

uncertaintyFunctions	ecalEEUncertainty

edm::InputTag	ElectronTag_

double	eleEtaMax_

double	eleEtUncertaintyParameter0_

double	elePhiUncertaintyParameter0_

double	elePtMin_

edm::EDGetTokenT< edm::View< pat::Electron > >	eleToken_

uncertaintyFunctions	eleUncertainty

uncertaintyFunctions	hcalHBUncertainty

uncertaintyFunctions	hcalHEUncertainty

uncertaintyFunctions	hcalHFUncertainty

uncertaintyFunctions	hcalHOUncertainty

std::string	JetCorrectionService_

uncertaintyFunctions	jetCorrUncertainty

double	jetEMfracMax_

double	jetEtaMax_

double	jetEtUncertaintyParameter0_

double	jetEtUncertaintyParameter1_

double	jetEtUncertaintyParameter2_

double	jetPhiUncertaintyParameter0_

double	jetPhiUncertaintyParameter1_

double	jetPhiUncertaintyParameter2_

double	jetPtMin_

edm::EDGetTokenT< edm::View< pat::Jet > >	jetToken_

uncertaintyFunctions	jetUncertainty

std::string	metCollectionLabel_

edm::InputTag	mhtLabel_

double	muonChiSqMax_

uncertaintyFunctions	muonCorrUncertainty

double	muonDPtMax_

double	muonEtaMax_

double	muonEtUncertaintyParameter0_

int	muonNHitsMin_

double	muonPhiUncertaintyParameter0_

double	muonPtMin_

edm::InputTag	MuonTag_

double	muonTrackD0Max_

double	muonTrackDzMax_

uncertaintyFunctions	muonUncertainty

edm::EDGetTokenT< edm::View< pat::Muon > >	muoToken_

bool	noHF_

edm::EDGetTokenT< edm::View< pat::Photon > >	phoToken_

std::vector< metsig::SigInputObj >	physobjvector_

std::set< CaloTowerDetId >	s_clusteredTowers

std::string	significanceLabel_

edm::EDGetTokenT< edm::View< pat::Tau > >	tauToken_

double	towerEtThreshold_

double	uncertaintyScaleFactor_

bool	useCaloTowers_

bool	useElectrons_

bool	useHO_

bool	useJets_

bool	useMuons_

double	verbose_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T... >	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

Definition at line 60 of file PATMHTProducer.h.

Constructor & Destructor Documentation

PATMHTProducer::PATMHTProducer ( const edm::ParameterSet & iConfig )

explicit

Definition at line 6 of file PATMHTProducer.cc.

References CaloTowerTag_, controlledUncertainty_, eleEtaMax_, eleEtUncertaintyParameter0_, elePhiUncertaintyParameter0_, elePtMin_, eleToken_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), jetEMfracMax_, jetEtaMax_, jetEtUncertaintyParameter0_, jetEtUncertaintyParameter1_, jetEtUncertaintyParameter2_, jetPhiUncertaintyParameter0_, jetPhiUncertaintyParameter1_, jetPhiUncertaintyParameter2_, jetPtMin_, jetToken_, muonEtaMax_, muonEtUncertaintyParameter0_, muonPhiUncertaintyParameter0_, muonPtMin_, muoToken_, noHF_, phoToken_, setUncertaintyParameters(), tauToken_, towerEtThreshold_, uncertaintyScaleFactor_, useHO_, and verbose_.

                                                                 {
   // Initialize the configurables
   verbose_ = iConfig.getParameter<double>("verbose");
 
   jetToken_ = consumes<edm::View<pat::Jet> >(iConfig.getUntrackedParameter<edm::InputTag>("jetTag"));
   eleToken_ = consumes<edm::View<pat::Electron> >(iConfig.getUntrackedParameter<edm::InputTag>("electronTag"));
   muoToken_ = consumes<edm::View<pat::Muon> >(iConfig.getUntrackedParameter<edm::InputTag>("muonTag"));
   tauToken_ = consumes<edm::View<pat::Tau> >(iConfig.getUntrackedParameter<edm::InputTag>("tauTag"));
   phoToken_ = consumes<edm::View<pat::Photon> >(iConfig.getUntrackedParameter<edm::InputTag>("photonTag"));
 
   uncertaintyScaleFactor_ = iConfig.getParameter<double>("uncertaintyScaleFactor");
   controlledUncertainty_ = iConfig.getParameter<bool>("controlledUncertainty");
 
   jetPtMin_ = iConfig.getParameter<double>("jetPtMin");
   jetEtaMax_ = iConfig.getParameter<double>("jetEtaMax");
   jetEMfracMax_ = iConfig.getParameter<double>("jetEMfracMax");
   elePtMin_ = iConfig.getParameter<double>("elePtMin");
   eleEtaMax_ = iConfig.getParameter<double>("eleEtaMax");
   muonPtMin_ = iConfig.getParameter<double>("muonPtMin");
   muonEtaMax_ = iConfig.getParameter<double>("muonEtaMax");
 
   jetEtUncertaintyParameter0_ = iConfig.getParameter<double>("jetEtUncertaintyParameter0");
   jetEtUncertaintyParameter1_ = iConfig.getParameter<double>("jetEtUncertaintyParameter1");
   jetEtUncertaintyParameter2_ = iConfig.getParameter<double>("jetEtUncertaintyParameter2");
   jetPhiUncertaintyParameter0_ = iConfig.getParameter<double>("jetPhiUncertaintyParameter0");
   jetPhiUncertaintyParameter1_ = iConfig.getParameter<double>("jetPhiUncertaintyParameter1");
   jetPhiUncertaintyParameter2_ = iConfig.getParameter<double>("jetPhiUncertaintyParameter2");
 
   eleEtUncertaintyParameter0_ = iConfig.getParameter<double>("eleEtUncertaintyParameter0");
   elePhiUncertaintyParameter0_ = iConfig.getParameter<double>("elePhiUncertaintyParameter0");
 
   muonEtUncertaintyParameter0_ = iConfig.getParameter<double>("muonEtUncertaintyParameter0");
   muonPhiUncertaintyParameter0_ = iConfig.getParameter<double>("muonPhiUncertaintyParameter0");
 
   CaloTowerTag_ = iConfig.getParameter<edm::InputTag>("CaloTowerTag");
   noHF_ = iConfig.getParameter<bool>("noHF");
 
   //  muonCalo_ = iConfig.getParameter<bool>("muonCalo");
   towerEtThreshold_ = iConfig.getParameter<double>("towerEtThreshold");
   useHO_ = iConfig.getParameter<bool>("useHO");
 
   setUncertaintyParameters();
 
   produces<pat::MHTCollection>();
 }

PATMHTProducer::~PATMHTProducer ( )

override

Definition at line 52 of file PATMHTProducer.cc.

52 {}

Member Function Documentation

double PATMHTProducer::getElectrons	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 195 of file PATMHTProducer.cc.

References Abs(), edm::View< T >::begin(), controlledUncertainty_, gather_cfg::cout, pwdgSkimBPark_cfi::electrons, eleEtaMax_, elePtMin_, eleToken_, eleUncertainty, edm::View< T >::end(), pat::PATMHTProducer::uncertaintyFunctions::etUncertainty, edm::Event::getByToken(), pat::PATMHTProducer::uncertaintyFunctions::phiUncertainty, physobjvector_, AlCaHLTBitMon_QueryRunRegistry::string, uncertaintyScaleFactor_, and verbose_.

Referenced by produce().

                                                                                     {
   std::string objectname = "electron";
 
   double number_of_electrons_ = 0.0;
 
   // edm::ESHandle<CaloTowerConstituentsMap> cttopo;
   // iSetup.get<HcalRecNumberingRecord>().get(cttopo);
   // const CaloTowerConstituentsMap* caloTowerMap = cttopo.product();
 
   edm::Handle<edm::View<pat::Electron> > electronHandle;
   iEvent.getByToken(eleToken_, electronHandle);
   edm::View<pat::Electron> electrons = *electronHandle;
 
   // Fill Input Vector with Electrons
   for (edm::View<pat::Electron>::const_iterator electron_iter = electrons.begin(); electron_iter != electrons.end();
        ++electron_iter) {
     // Select electrons
     if (electron_iter->et() < elePtMin_ || TMath::Abs(electron_iter->eta()) > eleEtaMax_)
       continue;
 
     if (verbose_ == 3.) {
       std::cout << "electron pt = " << electron_iter->pt() << " eta : " << electron_iter->eta() << std::endl;
     }
 
     double electron_et = electron_iter->et();
     double electron_phi = electron_iter->phi();
 
     double sigma_et, sigma_phi;
 
     if (controlledUncertainty_) {
       sigma_et = eleUncertainty.etUncertainty->Eval(electron_et);
       sigma_phi = eleUncertainty.phiUncertainty->Eval(electron_et);
     } else {
       sigma_et = 0.0;   //electron_iter->resolutionEt();
       sigma_phi = 0.0;  // electron_iter->resolutionPhi();
     }
 
     if (verbose_ == 3.) {
       std::cout << "electron sigma_et : " << sigma_et << ", electron sigma_phi : " << sigma_phi << std::endl;
     }
 
     if (sigma_et < 0 || sigma_phi < 0)
       edm::LogWarning("PATMHTProducer") << " uncertainties for " << objectname << " are (et, phi): " << sigma_et << ","
                                         << sigma_phi << " (et,phi): " << electron_et << "," << electron_phi;
 
     if (uncertaintyScaleFactor_ != 1.0) {
       sigma_et = sigma_et * uncertaintyScaleFactor_;
       sigma_phi = sigma_phi * uncertaintyScaleFactor_;
     }
 
     metsig::SigInputObj tmp_electron(objectname, electron_et, electron_phi, sigma_et, sigma_phi);
     physobjvector_.push_back(tmp_electron);
     number_of_electrons_++;
 
     //-- Store tower DetId's to be removed from Calo Tower sum later --//
     /*
     const reco::SuperCluster& eleSC = *( electron_iter->superCluster() );
 
     std::vector<DetId> v_eleDetIds = eleSC.getHitsByDetId();
 
     //-- Convert cells to calo towers and add to set --//
     for( std::vector<DetId>::iterator cellId = v_eleDetIds.begin();
          cellId != v_eleDetIds.end();
          cellId++) {
 
       CaloTowerDetId towerId = caloTowerMap->towerOf(*cellId);
       if (towerId != nullDetId) {
     //std::cout << ">>> electron towerId: " << towerId << std::endl;
     std::pair<std::_Rb_tree_const_iterator<CaloTowerDetId>,bool> p1 = s_clusteredTowers.insert(towerId);
       }
       else
     std::cerr<<"No matching tower found for electron cell!\n";
     }
 
     */
   }
 
   return number_of_electrons_;
 }

double PATMHTProducer::getJets	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 115 of file PATMHTProducer.cc.

References Abs(), edm::View< T >::begin(), controlledUncertainty_, gather_cfg::cout, edm::View< T >::end(), pat::PATMHTProducer::uncertaintyFunctions::etUncertainty, edm::Event::getByToken(), cuy::ii, jetEMfracMax_, jetEtaMax_, jetPtMin_, singleTopDQM_cfi::jets, jetToken_, jetUncertainty, pat::PATMHTProducer::uncertaintyFunctions::phiUncertainty, physobjvector_, s_clusteredTowers, AlCaHLTBitMon_QueryRunRegistry::string, uncertaintyScaleFactor_, and verbose_.

Referenced by produce().

                                                                                {
   std::string objectname = "jet";
 
   double number_of_jets_ = 0.0;
 
   edm::Handle<edm::View<pat::Jet> > jetHandle;
   iEvent.getByToken(jetToken_, jetHandle);
   edm::View<pat::Jet> jets = *jetHandle;
 
   // Fill Input Vector with Jets
   for (edm::View<pat::Jet>::const_iterator jet_iter = jets.begin(); jet_iter != jets.end(); ++jet_iter) {
     if ((jet_iter->pt() < jetPtMin_) || (TMath::Abs(jet_iter->eta()) > jetEtaMax_) ||
         (jet_iter->emEnergyFraction() > jetEMfracMax_))
       continue;
 
     double jet_et = jet_iter->et();
     double jet_phi = jet_iter->phi();
 
     if (verbose_ == 3.) {
       std::cout << "jet pt : " << jet_iter->pt() << " eta : " << jet_iter->eta()
                 << " EMF: " << jet_iter->emEnergyFraction() << std::endl;
     }
 
     double sigma_et, sigma_phi;
 
     if (controlledUncertainty_) {
       sigma_et = jetUncertainty.etUncertainty->Eval(jet_et);
       sigma_phi = jetUncertainty.phiUncertainty->Eval(jet_et);
     } else {
       sigma_et = 0.0;   // jet_iter->resolutionEt();
       sigma_phi = 0.0;  //jet_iter->resolutionPhi();
     }
 
     if (verbose_ == 3.) {
       std::cout << "jet sigma_et : " << sigma_et << ", jet sigma_phi : " << sigma_phi << std::endl;
     }
 
     if (sigma_et <= 0 || sigma_phi <= 0)
       edm::LogWarning("PATMHTProducer") << " uncertainties for " << objectname << " are (et, phi): " << sigma_et << ","
                                         << sigma_phi << " (et,phi): " << jet_et << "," << jet_phi;
     // try to read out the jet resolution from the root file at PatUtils
     //-- Store jet for Significance Calculation --//
 
     if (uncertaintyScaleFactor_ != 1.0) {
       sigma_et = sigma_et * uncertaintyScaleFactor_;
       sigma_phi = sigma_phi * uncertaintyScaleFactor_;
       // edm::LogWarning("PATMHTProducer") << " using uncertainty scale factor: " << uncertaintyScaleFactor_ <<
       //" , uncertainties for " << objectname <<" changed to (et, phi): " << sigma_et << "," << sigma_phi;
     }
 
     if (verbose_ == 101.) {  // Study the Jets behavior
 
       std::cout << "v101> " << number_of_jets_ << "  " << jet_et << "  " << sigma_et << "  " << jet_phi << "  "
                 << sigma_phi << std::endl;
     }
 
     metsig::SigInputObj tmp_jet(objectname, jet_et, jet_phi, sigma_et, sigma_phi);
     physobjvector_.push_back(tmp_jet);
     number_of_jets_++;
 
     //-- Store tower DetId's to be removed from Calo Tower sum later --//
     std::vector<CaloTowerPtr> v_towers = jet_iter->getCaloConstituents();
     //std::cout << "tower size = " << v_towers.size() << std::endl;
 
     for (unsigned int ii = 0; ii < v_towers.size(); ii++) {
       s_clusteredTowers.insert((*v_towers.at(ii)).id());
       //std::cout << "tower id = " << (*v_towers.at(ii)).id() << std::endl;
     }
   }
 
   if (verbose_ == 101.) {  // Study the Jets behavior - seperate events
     std::cout << "v101> --------------------------------------------" << std::endl;
   }
 
   return number_of_jets_;
 }

double PATMHTProducer::getMuons	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

private

Definition at line 279 of file PATMHTProducer.cc.

References Abs(), edm::View< T >::begin(), controlledUncertainty_, gather_cfg::cout, edm::View< T >::end(), pat::PATMHTProducer::uncertaintyFunctions::etUncertainty, edm::Event::getByToken(), edm::HandleBase::isValid(), muonEtaMax_, muonPtMin_, PDWG_BPHSkim_cff::muons, muonUncertainty, muoToken_, pat::PATMHTProducer::uncertaintyFunctions::phiUncertainty, physobjvector_, AlCaHLTBitMon_QueryRunRegistry::string, uncertaintyScaleFactor_, and verbose_.

Referenced by produce().

                                                                                 {
   std::string objectname = "muon";
   edm::Handle<edm::View<pat::Muon> > muonHandle;
   iEvent.getByToken(muoToken_, muonHandle);
   edm::View<pat::Muon> muons = *muonHandle;
 
   if (!muonHandle.isValid()) {
     std::cout << ">>> PATMHTSelector not valid muon Handle!" << std::endl;
     return 0.0;
   }
 
   double number_of_muons_ = 0.0;
 
   for (edm::View<pat::Muon>::const_iterator muon_iter = muons.begin(); muon_iter != muons.end(); ++muon_iter) {
     if (muon_iter->pt() < muonPtMin_ || TMath::Abs(muon_iter->eta()) > muonEtaMax_)
       continue;
 
     if (verbose_ == 3.) {
       std::cout << "muon pt = " << muon_iter->pt() << " eta : " << muon_iter->eta() << std::endl;
     }
 
     double muon_pt = muon_iter->pt();
     double muon_phi = muon_iter->phi();
 
     double sigma_et, sigma_phi;
 
     if (controlledUncertainty_) {
       sigma_et = muonUncertainty.etUncertainty->Eval(muon_pt);
       sigma_phi = muonUncertainty.phiUncertainty->Eval(muon_pt);
     } else {
       sigma_et = 0.0;   //muon_iter->resolutionEt();
       sigma_phi = 0.0;  // muon_iter->resolutionPhi();
     }
 
     if (verbose_ == 3.) {
       std::cout << "muon sigma_et : " << sigma_et << ", muon sigma_phi : " << sigma_phi << std::endl;
     }
 
     if (sigma_et < 0 || sigma_phi < 0)
       edm::LogWarning("PATMHTProducer") << " uncertainties for " << objectname << " are (et, phi): " << sigma_et << ","
                                         << sigma_phi << " (pt,phi): " << muon_pt << "," << muon_phi;
 
     if (uncertaintyScaleFactor_ != 1.0) {
       sigma_et = sigma_et * uncertaintyScaleFactor_;
       sigma_phi = sigma_phi * uncertaintyScaleFactor_;
     }
 
     metsig::SigInputObj tmp_muon(objectname, muon_pt, muon_phi, sigma_et, sigma_phi);
     physobjvector_.push_back(tmp_muon);
     number_of_muons_++;
 
   }  // end Muon loop
 
   return number_of_muons_;
 }

void pat::PATMHTProducer::getTowers	(	edm::Event &	,
		const edm::EventSetup &
	)

private

void PATMHTProducer::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 54 of file PATMHTProducer.cc.

References metsig::significanceAlgo::addObjects(), funct::cos(), gather_cfg::cout, getElectrons(), getJets(), getMuons(), eostools::move(), physobjvector_, edm::Event::put(), s_clusteredTowers, pat::MHT::setNumberOfElectrons(), pat::MHT::setNumberOfJets(), pat::MHT::setNumberOfMuons(), met_cff::significance, metsig::significanceAlgo::significance(), funct::sin(), and verbose_.

                                                                              {
   // make sure the SigInputObj container is empty
   while (!physobjvector_.empty()) {
     physobjvector_.erase(physobjvector_.begin(), physobjvector_.end());
   }
 
   // Clean the clustered towers
   s_clusteredTowers.clear();
 
   double number_of_jets = getJets(iEvent, iSetup);
 
   double number_of_electrons = getElectrons(iEvent, iSetup);
 
   double number_of_muons = getMuons(iEvent, iSetup);
 
   if (verbose_ == 1.) {
     std::cout << ">>>---> Number of jets: " << number_of_jets << std::endl;
     std::cout << ">>>---> Number of electrons: " << number_of_jets << std::endl;
     std::cout << ">>>---> Number of muons: " << number_of_muons << std::endl;
   }
 
   double met_x = 0;
   double met_y = 0;
   double met_et = 0;
   double met_phi = 0;
   double met_set = 0;
 
   auto themetsigcoll = std::make_unique<pat::MHTCollection>();
 
   if (!physobjvector_.empty()) {  // Only when the vector is not empty
 
     // calculate the MHT significance
 
     metsig::significanceAlgo signifAlgo;
     signifAlgo.addObjects(physobjvector_);
     double significance = signifAlgo.significance(met_et, met_phi, met_set);
 
     met_x = met_et * cos(met_phi);
     met_y = met_et * sin(met_phi);
 
     if (verbose_ == 1.) {
       std::cout << ">>>----> MHT Sgificance = " << significance << std::endl;
     }
 
     pat::MHT themetsigobj(reco::Particle::LorentzVector(met_x, met_y, 0, met_et), met_set, significance);
 
     // Store the number of jets, electrons, muons
     themetsigobj.setNumberOfJets(number_of_jets);
     themetsigobj.setNumberOfElectrons(number_of_electrons);
     themetsigobj.setNumberOfMuons(number_of_muons);
 
     themetsigcoll->push_back(themetsigobj);
 
   }  // If the vector is empty, just put empty product.
 
   iEvent.put(std::move(themetsigcoll));
 }

void PATMHTProducer::setUncertaintyParameters ( )

private

Definition at line 336 of file PATMHTProducer.cc.

Referenced by PATMHTProducer().

                                                  {
   // set the various functions here:
 
   //-- For Et functions, [0]= par_n, [1]=par_s, [2]= par_c ---//
   //-- Ecal Uncertainty Functions ------------------------------------//
   //-- From: FastSimulation/Calorimetry/data/HcalResponse.cfi --//
   //-- Ecal Barrel --//
   ecalEBUncertainty.etUncertainty.reset(new TF1("ecalEBEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   ecalEBUncertainty.etUncertainty->SetParameter(0, 0.2);
   ecalEBUncertainty.etUncertainty->SetParameter(1, 0.03);
   ecalEBUncertainty.etUncertainty->SetParameter(2, 0.005);
 
   ecalEBUncertainty.phiUncertainty.reset(new TF1("ecalEBphiFunc", "[0]*x", 1));
   ecalEBUncertainty.phiUncertainty->SetParameter(0, 0.0174);
 
   //-- Ecal Endcap --//
   ecalEEUncertainty.etUncertainty.reset(new TF1("ecalEEEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   ecalEEUncertainty.etUncertainty->SetParameter(0, 0.2);
   ecalEEUncertainty.etUncertainty->SetParameter(1, 0.03);
   ecalEEUncertainty.etUncertainty->SetParameter(2, 0.005);
 
   ecalEEUncertainty.phiUncertainty.reset(new TF1("ecalEEphiFunc", "[0]*x", 1));
   ecalEEUncertainty.phiUncertainty->SetParameter(0, 0.087);
 
   //-- Hcal Uncertainty Functions --------------------------------------//
   //-- From: FastSimulation/Calorimetry/data/HcalResponse.cfi --//
   //-- Hcal Barrel --//
   hcalHBUncertainty.etUncertainty.reset(new TF1("hcalHBEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   hcalHBUncertainty.etUncertainty->SetParameter(0, 0.);
   hcalHBUncertainty.etUncertainty->SetParameter(1, 1.22);
   hcalHBUncertainty.etUncertainty->SetParameter(2, 0.05);
 
   hcalHBUncertainty.phiUncertainty.reset(new TF1("ecalHBphiFunc", "[0]*x", 1));
   hcalHBUncertainty.phiUncertainty->SetParameter(0, 0.087);
 
   //-- Hcal Endcap --//
   hcalHEUncertainty.etUncertainty.reset(new TF1("hcalHEEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   hcalHEUncertainty.etUncertainty->SetParameter(0, 0.);
   hcalHEUncertainty.etUncertainty->SetParameter(1, 1.3);
   hcalHEUncertainty.etUncertainty->SetParameter(2, 0.05);
 
   hcalHEUncertainty.phiUncertainty.reset(new TF1("ecalHEphiFunc", "[0]*x", 1));
   hcalHEUncertainty.phiUncertainty->SetParameter(0, 0.087);
 
   //-- Hcal Outer --//
   hcalHOUncertainty.etUncertainty.reset(new TF1("hcalHOEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   hcalHOUncertainty.etUncertainty->SetParameter(0, 0.);
   hcalHOUncertainty.etUncertainty->SetParameter(1, 1.82);
   hcalHOUncertainty.etUncertainty->SetParameter(2, 0.09);
 
   hcalHOUncertainty.phiUncertainty.reset(new TF1("ecalHOphiFunc", "[0]*x", 1));
   hcalHOUncertainty.phiUncertainty->SetParameter(0, 0.087);
 
   //-- Hcal Forward --//
   hcalHFUncertainty.etUncertainty.reset(new TF1("hcalHFEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   hcalHFUncertainty.etUncertainty->SetParameter(0, 0.);
   hcalHFUncertainty.etUncertainty->SetParameter(1, 1.82);
   hcalHFUncertainty.etUncertainty->SetParameter(2, 0.09);
 
   hcalHFUncertainty.phiUncertainty.reset(new TF1("ecalHFphiFunc", "[0]*x", 1));
   hcalHFUncertainty.phiUncertainty->SetParameter(0, 0.174);
 
   //--- Jet Uncertainty Functions --------------------------------------//
   jetUncertainty.etUncertainty.reset(new TF1("jetEtFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   //-- values from PTDR 1, ch 11.4 --//
   jetUncertainty.etUncertainty->SetParameter(0, jetEtUncertaintyParameter0_);
   jetUncertainty.etUncertainty->SetParameter(1, jetEtUncertaintyParameter1_);
   jetUncertainty.etUncertainty->SetParameter(2, jetEtUncertaintyParameter2_);
 
   //-- phi value from our own fits --//
   //jetUncertainty.phiUncertainty.reset( new TF1("jetPhiFunc","[0]*x",1) );
   //jetUncertainty.phiUncertainty->SetParameter(0, jetPhiUncertaintyParameter0_);
 
   //-- phi Functions and values from
   // http://indico.cern.ch/getFile.py/access?contribId=9&sessionId=0&resId=0&materialId=slides&confId=46394
   jetUncertainty.phiUncertainty.reset(new TF1("jetPhiFunc", "x*sqrt(([0]*[0]/(x*x))+([1]*[1]/x)+([2]*[2]))", 3));
   jetUncertainty.phiUncertainty->SetParameter(0, jetPhiUncertaintyParameter0_);
   jetUncertainty.phiUncertainty->SetParameter(1, jetPhiUncertaintyParameter1_);
   jetUncertainty.phiUncertainty->SetParameter(2, jetPhiUncertaintyParameter2_);
 
   //-- Jet corrections are assumed not to have an error --//
   /*jetCorrUncertainty.etUncertainty.reset( new TF1("jetCorrEtFunc","[0]*x",1) );
   jetCorrUncertainty.etUncertainty->SetParameter(0,0.0);
   jetCorrUncertainty.phiUncertainty.reset( new TF1("jetCorrPhiFunc","[0]*x",1) );
   jetCorrUncertainty.phiUncertainty->SetParameter(0,0.0*(3.14159/180.));*/
 
   //--- Electron Uncertainty Functions ---------------------------------//
   // completely ambiguious values for electron-like jets...
   // the egamma group keeps track of these here:
   // https://twiki.cern.ch/twiki/bin/view/CMS/EgammaCMSSWVal
   // electron resolution in energy is around 3.4%, measured for 10 < pT < 50 at realistic events with pile-up.
 
   eleUncertainty.etUncertainty.reset(new TF1("eleEtFunc", "[0] * x", 1));
   //  eleUncertainty.etUncertainty->SetParameter(0,0.034);
   eleUncertainty.etUncertainty->SetParameter(0, eleEtUncertaintyParameter0_);
 
   eleUncertainty.phiUncertainty.reset(new TF1("elePhiFunc", "[0] * x", 1));
   //  eleUncertainty.phiUncertainty->SetParameter(0,1*(3.14159/180.));
   eleUncertainty.phiUncertainty->SetParameter(0, elePhiUncertaintyParameter0_);
 
   //--- Muon Uncertainty Functions ------------------------------------//
   // and ambiguious values for the muons...
 
   muonUncertainty.etUncertainty.reset(new TF1("muonEtFunc", "[0] * x", 1));
   //  muonUncertainty.etUncertainty->SetParameter(0,0.01);
   muonUncertainty.etUncertainty->SetParameter(0, muonEtUncertaintyParameter0_);
   muonUncertainty.phiUncertainty.reset(new TF1("muonPhiFunc", "[0] * x", 1));
   //  muonUncertainty.phiUncertainty->SetParameter(0,1*(3.14159/180.));
   muonUncertainty.phiUncertainty->SetParameter(0, muonPhiUncertaintyParameter0_);
 
   //-- Muon calo deposites are assumed not to have an error --//
   /*muonCorrUncertainty.etUncertainty.reset( new TF1("muonCorrEtFunc","[0] * x",1) );
   muonCorrUncertainty.etUncertainty->SetParameter(0,0.0);
   muonCorrUncertainty.phiUncertainty.reset( new TF1("muonCorrPhiFunc","[0] * x",1) );
   muonCorrUncertainty.phiUncertainty->SetParameter(0,0.0*(3.14159/180.)); */
 }