#include <SignAlgoResolutions.h>

Public Member Functions
void	addResolutions (const edm::ParameterSet &iConfig)

double	eval (const resolutionType &type, const resolutionFunc &func, const double &et, const double &phi, const double &eta, const double &p) const

double	eval (const resolutionType &type, const resolutionFunc &func, const double &et, const double &phi, const double &eta) const

metsig::SigInputObj	evalPF (const reco::PFCandidate *candidate) const

metsig::SigInputObj	evalPFJet (const reco::PFJet *jet) const

bool	isFilled () const

	SignAlgoResolutions ()

	SignAlgoResolutions (const edm::ParameterSet &iConfig)

Private Types
typedef std::pair < metsig::resolutionType, metsig::resolutionFunc >	functionCombo

typedef std::vector< double >	functionPars

Private Member Functions
void	addfunction (const resolutionType type, const resolutionFunc func, const std::vector< double > &parameters)

double	ElectronPtResolution (const reco::PFCandidate *c) const

double	EtFunction (const functionPars &x, const functionPars &par) const

double	getfunc (const resolutionType &type, const resolutionFunc &func, std::vector< double > &x) const

void	initializeJetResolutions (const edm::ParameterSet &iConfig)

double	PFunction (const functionPars &x, const functionPars &par) const

double	PhiConstFunction (const functionPars &x, const functionPars &par) const

double	PhiFunction (const functionPars &x, const functionPars &par) const

Private Attributes
std::map< functionCombo, functionPars >	functionmap_

std::vector< double >	jdphi [10]

std::vector< double >	jdpt [10]

PFEnergyResolution *	pfresol_

JetResolution *	phiResol_

JetResolution *	ptResol_

double	ptResolThreshold_

Detailed Description

Definition at line 43 of file SignAlgoResolutions.h.

Member Typedef Documentation

typedef std::pair<metsig::resolutionType, metsig::resolutionFunc> metsig::SignAlgoResolutions::functionCombo

private

Definition at line 61 of file SignAlgoResolutions.h.

typedef std::vector<double> metsig::SignAlgoResolutions::functionPars

private

Definition at line 62 of file SignAlgoResolutions.h.

Constructor & Destructor Documentation

metsig::SignAlgoResolutions::SignAlgoResolutions ( )

inline

Definition at line 46 of file SignAlgoResolutions.h.

46 :functionmap_(){;}

metsig::SignAlgoResolutions::functionmap_

std::map< functionCombo, functionPars > functionmap_

Definition: SignAlgoResolutions.h:63

metsig::SignAlgoResolutions::SignAlgoResolutions ( const edm::ParameterSet & iConfig )

Definition at line 34 of file SignAlgoResolutions.cc.

References addResolutions().

                                                                             :
     functionmap_(),
     ptResol_(0),
     phiResol_(0)
 {
   addResolutions(iConfig);
 }

Member Function Documentation

void metsig::SignAlgoResolutions::addfunction	(	const resolutionType	type,
		const resolutionFunc	func,
		const std::vector< double > &	parameters
	)

private

Definition at line 304 of file SignAlgoResolutions.cc.

References Parameters::parameters.

                                                                                                                    {
 
   functionCombo mypair(type,func);
   functionmap_[mypair]=parameters;
 
 }

void metsig::SignAlgoResolutions::addResolutions ( const edm::ParameterSet & iConfig )

Definition at line 140 of file SignAlgoResolutions.cc.

References metsig::caloEB, metsig::caloEE, metsig::caloHB, metsig::caloHE, metsig::caloHF, metsig::caloHO, metsig::ET, edm::ParameterSet::getParameter(), initializeJetResolutions(), metsig::PFtype1, metsig::PFtype2, metsig::PFtype3, metsig::PFtype4, metsig::PFtype5, metsig::PFtype6, metsig::PFtype7, and metsig::PHI.

Referenced by SignAlgoResolutions().

                                                                             {
     using namespace std;
 
   // Jet Resolutions - for now load from the files. Migrate to EventSetup asap.
   metsig::SignAlgoResolutions::initializeJetResolutions( iConfig );
   
   ptResolThreshold_ = iConfig.getParameter<double>("ptresolthreshold");
 
 
     //get temporary low pT pfjet resolutions
     for (int ieta=0; ieta<10; ieta++){
       jdpt[ieta] = iConfig.getParameter<std::vector<double> >(Form("jdpt%d", ieta));
       jdphi[ieta] = iConfig.getParameter<std::vector<double> >(Form("jdphi%d", ieta));
     }
 
 
   // for now: do this by hand - this can obviously also be done via ESSource etc.
   functionPars etparameters(3,0);
   functionPars phiparameters(1,0);
   // set the parameters per function:
   // ECAL, BARREL:
   std::vector<double> ebet = iConfig.getParameter<std::vector<double> >("EB_EtResPar");
   std::vector<double> ebphi = iConfig.getParameter<std::vector<double> >("EB_PhiResPar");
 
   etparameters[0]=ebet[0];
   etparameters[1]=ebet[1];
   etparameters[2]=ebet[2];
   phiparameters[0]=ebphi[0];
   addfunction(caloEB,ET,etparameters);
   addfunction(caloEB,PHI,phiparameters);
  // ECAL, ENDCAP:
   std::vector<double> eeet = iConfig.getParameter<std::vector<double> >("EE_EtResPar");
   std::vector<double> eephi = iConfig.getParameter<std::vector<double> >("EE_PhiResPar");
 
   etparameters[0]=eeet[0];
   etparameters[1]=eeet[1];
   etparameters[2]=eeet[2];
   phiparameters[0]=eephi[0];
   addfunction(caloEE,ET,etparameters);
   addfunction(caloEE,PHI,phiparameters);
  // HCAL, BARREL:
   std::vector<double> hbet = iConfig.getParameter<std::vector<double> >("HB_EtResPar");
   std::vector<double> hbphi = iConfig.getParameter<std::vector<double> >("HB_PhiResPar");
 
   etparameters[0]=hbet[0];
   etparameters[1]=hbet[1];
   etparameters[2]=hbet[2];
   phiparameters[0]=hbphi[0];
   addfunction(caloHB,ET,etparameters);
   addfunction(caloHB,PHI,phiparameters);
  // HCAL, ENDCAP:
   std::vector<double> heet = iConfig.getParameter<std::vector<double> >("HE_EtResPar");
   std::vector<double> hephi = iConfig.getParameter<std::vector<double> >("HE_PhiResPar");
 
   etparameters[0]=heet[0];
   etparameters[1]=heet[1];
   etparameters[2]=heet[2];
   phiparameters[0]=hephi[0];
   addfunction(caloHE,ET,etparameters);
   addfunction(caloHE,PHI,phiparameters);
  // HCAL, Outer
   std::vector<double> hoet = iConfig.getParameter<std::vector<double> >("HO_EtResPar");
   std::vector<double> hophi = iConfig.getParameter<std::vector<double> >("HO_PhiResPar");
 
 
   etparameters[0]=hoet[0];
   etparameters[1]=hoet[1];
   etparameters[2]=hoet[2];
   phiparameters[0]=hophi[0];
   addfunction(caloHO,ET,etparameters);
   addfunction(caloHO,PHI,phiparameters);
  // HCAL, Forward
   std::vector<double> hfet = iConfig.getParameter<std::vector<double> >("HF_EtResPar");
   std::vector<double> hfphi = iConfig.getParameter<std::vector<double> >("HF_PhiResPar");
 
   etparameters[0]=hfet[0];
   etparameters[1]=hfet[1];
   etparameters[2]=hfet[2];
   phiparameters[0]=hfphi[0];
   addfunction(caloHF,ET,etparameters);
   addfunction(caloHF,PHI,phiparameters);
 
 
   // PF objects:
   // type 1:
   std::vector<double> pf1et = iConfig.getParameter<std::vector<double> >("PF_EtResType1");
   std::vector<double> pf1phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType1");
   etparameters[0]=pf1et[0];
   etparameters[1]=pf1et[1];
   etparameters[2]=pf1et[2];
   phiparameters[0]=pf1phi[0];
   addfunction(PFtype1,ET,etparameters);
   addfunction(PFtype1,PHI,phiparameters);
 
   // PF objects:
   // type 2:
   std::vector<double> pf2et = iConfig.getParameter<std::vector<double> >("PF_EtResType2");
   std::vector<double> pf2phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType2");
   etparameters[0]=pf2et[0];
   etparameters[1]=pf2et[1];
   etparameters[2]=pf2et[2];
   phiparameters[0]=pf2phi[0];
   addfunction(PFtype2,ET,etparameters);
   addfunction(PFtype2,PHI,phiparameters);
 
   // PF objects:
   // type 3:
   std::vector<double> pf3et = iConfig.getParameter<std::vector<double> >("PF_EtResType3");
   std::vector<double> pf3phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType3");
   etparameters[0]=pf3et[0];
   etparameters[1]=pf3et[1];
   etparameters[2]=pf3et[2];
   phiparameters[0]=pf3phi[0];
   addfunction(PFtype3,ET,etparameters);
   addfunction(PFtype3,PHI,phiparameters);
 
   // PF objects:
   // type 4:
   std::vector<double> pf4et = iConfig.getParameter<std::vector<double> >("PF_EtResType4");
   std::vector<double> pf4phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType4");
   etparameters[0]=pf4et[0];
   etparameters[1]=pf4et[1];
   etparameters[2]=pf4et[2];
   //phiparameters[0]=pf4phi[0];
   addfunction(PFtype4,ET,etparameters);
   addfunction(PFtype4,PHI,pf4phi); //use the same functional form for photon phi error as for pT, pass whole vector
 
   // PF objects:
   // type 5:
   std::vector<double> pf5et = iConfig.getParameter<std::vector<double> >("PF_EtResType5");
   std::vector<double> pf5phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType5");
   etparameters[0]=pf5et[0];
   etparameters[1]=pf5et[1];
   etparameters[2]=pf5et[2];
   phiparameters[0]=pf5phi[0];
   addfunction(PFtype5,ET,etparameters);
   addfunction(PFtype5,PHI,pf5phi);
 
   // PF objects:
   // type 6:
   std::vector<double> pf6et = iConfig.getParameter<std::vector<double> >("PF_EtResType6");
   std::vector<double> pf6phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType6");
   etparameters[0]=pf6et[0];
   etparameters[1]=pf6et[1];
   etparameters[2]=pf6et[2];
   phiparameters[0]=pf6phi[0];
   addfunction(PFtype6,ET,etparameters);
   addfunction(PFtype6,PHI,phiparameters);
 
   
   // PF objects:
   // type 7:
   std::vector<double> pf7et = iConfig.getParameter<std::vector<double> >("PF_EtResType7");
   std::vector<double> pf7phi = iConfig.getParameter<std::vector<double> >("PF_PhiResType7");
   etparameters[0]=pf7et[0];
   etparameters[1]=pf7et[1];
   etparameters[2]=pf7et[2];
   phiparameters[0]=pf7phi[0];
   addfunction(PFtype7,ET,etparameters);
   addfunction(PFtype7,PHI,phiparameters);
 
   return;
 }

double metsig::SignAlgoResolutions::ElectronPtResolution ( const reco::PFCandidate * c ) const

private

Definition at line 412 of file SignAlgoResolutions.cc.

References relval_parameters_module::energy, reco::LeafCandidate::energy(), eta(), and reco::LeafCandidate::eta().

                                                                              {
 
     double eta = c->eta();
     double energy = c->energy();
     double dEnergy = pfresol_->getEnergyResolutionEm(energy, eta);
 
     return dEnergy/cosh(eta);
 }

double metsig::SignAlgoResolutions::EtFunction	(	const functionPars &	x,
		const functionPars &	par
	)		const

private

Definition at line 337 of file SignAlgoResolutions.cc.

References query::result, and mathSSE::sqrt().

 {
   if(par.size()<3)
     return 0.;
   if(x.size()<1)
     return 0.;
   double et=x[0];
   if(et<=0.)
     return 0.;
   double result = et*sqrt((par[2]*par[2])+(par[1]*par[1]/et)+(par[0]*par[0]/(et*et)));
   return result;
 }

double metsig::SignAlgoResolutions::eval	(	const resolutionType &	type,
		const resolutionFunc &	func,
		const double &	et,
		const double &	phi,
		const double &	eta,
		const double &	p
	)		const

Definition at line 52 of file SignAlgoResolutions.cc.

References eta(), data-class-funcs::getfunc, AlCaHLTBitMon_ParallelJobs::p, phi, and x.

                                                                                                                                                                                  {
 
   functionPars x(4);
   x[0]=et;
   x[1]=phi;
   x[2]=eta;
   x[3]=p;
   //  std::cout << "getting function of type " << type << " " << func << " " << x[0] << " " << x[1] << " " << x[2] << " " << x[3] << std::endl;
   return getfunc(type,func,x);
 
 }

double metsig::SignAlgoResolutions::eval	(	const resolutionType &	type,
		const resolutionFunc &	func,
		const double &	et,
		const double &	phi,
		const double &	eta
	)		const

Definition at line 44 of file SignAlgoResolutions.cc.

References create_public_lumi_plots::exp, AlCaHLTBitMon_ParallelJobs::p, funct::sin(), and theta().

                                                                                                                                                                 {
   // derive p from et and eta;
   double theta = 2*atan(exp(-eta));
   double p = et / sin(theta); // rough assumption: take e and p equivalent...
   return eval(type,func,et,phi,eta,p);
 
 }

metsig::SigInputObj metsig::SignAlgoResolutions::evalPF ( const reco::PFCandidate * candidate ) const

Definition at line 64 of file SignAlgoResolutions.cc.

References reco::LeafCandidate::energy(), metsig::ET, eta(), reco::LeafCandidate::eta(), edm::Ref< C, T, F >::isNull(), mergeVDriftHistosByStation::name, reco::PFCandidate::particleId(), metsig::PFtype1, metsig::PFtype2, metsig::PFtype3, metsig::PFtype4, metsig::PFtype5, metsig::PFtype6, metsig::PFtype7, phi, metsig::PHI, reco::LeafCandidate::phi(), funct::sin(), AlCaHLTBitMon_QueryRunRegistry::string, reco::LeafCandidate::theta(), and reco::PFCandidate::trackRef().

                                                                                            {
   double eta = candidate->eta();
   double phi = candidate->phi();
   double et = candidate->energy()*sin(candidate->theta());
   resolutionType thetype;
   std::string name;
   int type = candidate->particleId();
   switch (type) 
     {
     case 1: 
       thetype=PFtype1;name="PFChargedHadron"; break;
     case 2: 
       thetype=PFtype2;name="PFChargedEM"; break;
     case 3: 
       thetype=PFtype3;name="PFMuon"; break;
     case 4: 
       thetype=PFtype4;name="PFNeutralEM"; break;
     case 5: 
       thetype=PFtype5;name="PFNeutralHadron"; break;
     case 6: 
       thetype=PFtype6;name="PFtype6"; break;
     case 7:
       thetype=PFtype7;name="PFtype7"; break;
     default:
       thetype=PFtype7;name="PFunknown"; break;
   }
 
   double d_et=0, d_phi=0; //d_phi here is the error on phi component of the et
   reco::TrackRef trackRef = candidate->trackRef();
   if(!trackRef.isNull()){
     d_phi = et*trackRef->phiError();
     d_et  = (type==2) ?  ElectronPtResolution(candidate) : trackRef->ptError();
     //if(type==2) std::cout << eval(thetype,ET,et,phi,eta) << "    " << trackRef->ptError() << "    "<< ElectronPtResolution(candidate) << std::endl;
   }
   else{
     d_et = eval(thetype,ET,et,phi,eta);
     d_phi = eval(thetype,PHI,et,phi,eta);
   }
 
   metsig::SigInputObj resultingobj(name,et,phi,d_et,d_phi);
   return resultingobj;
 }

metsig::SigInputObj metsig::SignAlgoResolutions::evalPFJet ( const reco::PFJet * jet ) const

Definition at line 109 of file SignAlgoResolutions.cc.

References Abs(), reco::LeafCandidate::eta(), reco::LeafCandidate::phi(), reco::LeafCandidate::pt(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                               {
 
     double jpt  = jet->pt();
     double jphi = jet->phi();
     double jeta = jet->eta();
     double jdeltapt = 999.;
     double jdeltapphi = 999.;
 
     if(jpt<ptResolThreshold_ && jpt<20.){ //use temporary fix for low pT jets
     double feta = TMath::Abs(jeta);
     int ieta = feta<5.? int(feta/0.5) : 9; //bin size = 0.5 
     int ipt  = jpt>3. ? int(jpt-3./2) : 0; //bin size =2, starting from ptmin=3GeV
     jdeltapt   = jdpt[ieta][ipt];
     jdeltapphi = jpt*jdphi[ieta][ipt];
     }
     else{
     //use the resolution functions at |eta|=5 to avoid crash for jets with large eta.
     if(jeta>5) jeta=5;
     if(jeta<-5) jeta=-5;
     double jptForEval = jpt>ptResolThreshold_ ? jpt : ptResolThreshold_;
     jdeltapt   = jpt*ptResol_->parameterEtaEval("sigma",jeta,jptForEval);
     jdeltapphi = jpt*phiResol_->parameterEtaEval("sigma",jeta,jptForEval);
     }
 
     std::string inputtype = "jet";
     metsig::SigInputObj obj_jet(inputtype,jpt,jphi,jdeltapt,jdeltapphi);
     //std::cout << "RESOLUTIONS JET: " << jpt << "   " << jphi<< "   " <<jdeltapt << "   " << jdeltapphi << std::endl;
     return obj_jet;
 }

double metsig::SignAlgoResolutions::getfunc	(	const resolutionType &	type,
		const resolutionFunc &	func,
		std::vector< double > &	x
	)		const

private

Definition at line 311 of file SignAlgoResolutions.cc.

References metsig::CONSTPHI, metsig::ET, metsig::PHI, query::result, edm::second(), metsig::TRACKP, and makeHLTPrescaleTable::values.

                                                                                                                                     {
   
   double result=0;
   functionCombo mypair(type,func);
 
   if(functionmap_.count(mypair)==0){
     return result;
   }
   
   functionPars values = (functionmap_.find(mypair))->second;
   switch ( func ){
   case metsig::ET :
     return EtFunction(x,values);
   case metsig::PHI :
     return PhiFunction(x,values);
   case metsig::TRACKP :
     return PFunction(x,values);
   case metsig::CONSTPHI :
     return PhiConstFunction(x,values);
   }
   
   //  std::cout << "returning function " << type << " " << func << " " << result << " " << x[0] << std::endl; 
 
   return result;
 }

void metsig::SignAlgoResolutions::initializeJetResolutions ( const edm::ParameterSet & iConfig )

private

Definition at line 382 of file SignAlgoResolutions.cc.

References dtNoiseDBValidation_cfg::cerr, cmsBenchmark::cmssw_base, cmsBenchmark::cmssw_release_base, edm::ParameterSet::getParameter(), cmsHarvester::path, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by addResolutions().

                                                                                     {
   
   using namespace std;
   
   // only reinitialize the resolutsion if the pointers are zero
   if ( ptResol_ == 0 ) {
     string resolutionsAlgo  = iConfig.getParameter<std::string>("resolutionsAlgo");     
     string resolutionsEra   = iConfig.getParameter<std::string>("resolutionsEra");     
 
     string cmssw_base(getenv("CMSSW_BASE"));
     string cmssw_release_base(getenv("CMSSW_RELEASE_BASE"));
     string path = cmssw_base + "/src/CondFormats/JetMETObjects/data";
     struct stat st;
     if (stat(path.c_str(),&st)!=0) {
       path = cmssw_release_base + "/src/CondFormats/JetMETObjects/data";
     }
     if (stat(path.c_str(),&st)!=0) {
       cerr<<"ERROR: tried to set path but failed, abort."<<endl;
     }    
     string era(resolutionsEra);
     string alg(resolutionsAlgo);
     string ptFileName  = path + "/" + era + "_PtResolution_" +alg+".txt";
     string phiFileName = path + "/" + era + "_PhiResolution_"+alg+".txt";
     
     ptResol_ = new JetResolution(ptFileName,false);
     phiResol_ = new JetResolution(phiFileName,false);
   }
 }

bool metsig::SignAlgoResolutions::isFilled ( ) const

inline

Definition at line 54 of file SignAlgoResolutions.h.

References functionmap_.

54 {return functionmap_.size()>0;}

metsig::SignAlgoResolutions::functionmap_

std::map< functionCombo, functionPars > functionmap_

Definition: SignAlgoResolutions.h:63

double metsig::SignAlgoResolutions::PFunction	(	const functionPars &	x,
		const functionPars &	par
	)		const

private

Definition at line 370 of file SignAlgoResolutions.cc.

 {
   // not currently implemented
   return 0;
 }

double metsig::SignAlgoResolutions::PhiConstFunction	(	const functionPars &	x,
		const functionPars &	par
	)		const

private

Definition at line 376 of file SignAlgoResolutions.cc.

 {
   return par[0];
 }

double metsig::SignAlgoResolutions::PhiFunction	(	const functionPars &	x,
		const functionPars &	par
	)		const

private

Definition at line 351 of file SignAlgoResolutions.cc.

References mathSSE::sqrt().

 {
   double et=x[0];
   if(et<=0.){
     return 0.;
   }
 
   //if 1 parameter is C provided, returns C*pT, if three parameters N, S, C are provided, it returns the usual resolution value, as for sigmaPt
   if(par.size()!=1 && par.size()!=3){//only 1 or 3 parameters supported for phi function
       return 0.;
   }
   else if(par.size()==1){
     return par[0]*et;
   }
   else{
     return et*sqrt((par[2]*par[2])+(par[1]*par[1]/et)+(par[0]*par[0]/(et*et)));
   }
 
 }

Member Data Documentation

std::map<functionCombo,functionPars> metsig::SignAlgoResolutions::functionmap_

private

Definition at line 63 of file SignAlgoResolutions.h.

Referenced by isFilled().

std::vector<double> metsig::SignAlgoResolutions::jdphi[10]

private

Definition at line 76 of file SignAlgoResolutions.h.

std::vector<double> metsig::SignAlgoResolutions::jdpt[10]

private

Definition at line 75 of file SignAlgoResolutions.h.

PFEnergyResolution* metsig::SignAlgoResolutions::pfresol_

private

Definition at line 80 of file SignAlgoResolutions.h.

JetResolution* metsig::SignAlgoResolutions::phiResol_

private

Definition at line 79 of file SignAlgoResolutions.h.

JetResolution* metsig::SignAlgoResolutions::ptResol_

private

Definition at line 78 of file SignAlgoResolutions.h.

double metsig::SignAlgoResolutions::ptResolThreshold_

private

Definition at line 71 of file SignAlgoResolutions.h.

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation