#include <QGTagger.h>

Inheritance diagram for QGTagger:

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

	~QGTagger ()

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducer ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
	Descriptions method. More...

Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
std::tuple< int, float, float >	calcVariables (const reco::Jet *, edm::Handle< reco::VertexCollection > &)
	Calculation of axis2, mult and ptD. More...

bool	isPackedCandidate (const reco::Candidate *candidate)
	Function to tell us if we are using packedCandidates, only test for first candidate. More...

virtual void	produce (edm::Event &, const edm::EventSetup &)
	Produce qgLikelihood using {mult, ptD, -log(axis2)}. More...

template<typename T >
void	putInEvent (std::string, const edm::Handle< edm::View< reco::Jet >> &, std::vector< T > *, edm::Event &)
	Function to put product into event. More...

Private Attributes
edm::EDGetTokenT < reco::JetCorrector >	jetCorrectorToken

std::string	jetsLabel

edm::EDGetTokenT< edm::View < reco::Jet > >	jetsToken

const bool	produceSyst

QGLikelihoodCalculator *	qgLikelihood

edm::EDGetTokenT< double >	rhoToken

std::string	systLabel

const bool	useJetCorr

const bool	useQC

edm::EDGetTokenT < reco::VertexCollection >	vertexToken

bool	weAreUsingPackedCandidates

bool	weStillNeedToCheckJetCandidates

Additional Inherited Members
Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 14 of file QGTagger.h.

Constructor & Destructor Documentation

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

explicit

EDProducer class to produced the qgLikelihood values and related variables If the input jets are uncorrected, the jecService should be provided, so jet are corrected on the fly before the algorithm is applied Authors: andre.nosp@m.a.ca.nosp@m.rlo.m.nosp@m.arin.nosp@m.i@cer.nosp@m.n.ch, tom.c.nosp@m.orne.nosp@m.lis@c.nosp@m.ern..nosp@m.ch, cms-q.nosp@m.g-wo.nosp@m.rking.nosp@m.grou.nosp@m.p@cer.nosp@m.n.ch

Definition at line 29 of file QGTagger.cc.

References produceSyst, qgLikelihood, and weStillNeedToCheckJetCandidates.

                                                  :
   jetsToken(        consumes<edm::View<reco::Jet>>(     iConfig.getParameter<edm::InputTag>("srcJets"))),
   jetCorrectorToken(    consumes<reco::JetCorrector>(       iConfig.getParameter<edm::InputTag>("jec"))),
   vertexToken(      consumes<reco::VertexCollection>(   iConfig.getParameter<edm::InputTag>("srcVertexCollection"))),
   rhoToken(     consumes<double>(           iConfig.getParameter<edm::InputTag>("srcRho"))),
   jetsLabel(                            iConfig.getParameter<std::string>("jetsLabel")),
   systLabel(                            iConfig.getParameter<std::string>("systematicsLabel")),
   useQC(                            iConfig.getParameter<bool>("useQualityCuts")),
   useJetCorr(                           !iConfig.getParameter<edm::InputTag>("jec").label().empty()),
   produceSyst(                          systLabel != "")
 {
   produces<edm::ValueMap<float>>("qgLikelihood");
   produces<edm::ValueMap<float>>("axis2");
   produces<edm::ValueMap<int>>("mult");
   produces<edm::ValueMap<float>>("ptD");
   if(produceSyst){
     produces<edm::ValueMap<float>>("qgLikelihoodSmearedQuark");
     produces<edm::ValueMap<float>>("qgLikelihoodSmearedGluon");
     produces<edm::ValueMap<float>>("qgLikelihoodSmearedAll");
   }
   qgLikelihood = new QGLikelihoodCalculator();
   weStillNeedToCheckJetCandidates = true;
 }

QGTagger::~QGTagger ( )

inline

Definition at line 17 of file QGTagger.h.

References qgLikelihood.

17 { delete qgLikelihood;};

QGTagger::qgLikelihood

QGLikelihoodCalculator * qgLikelihood

Definition: QGTagger.h:33

Member Function Documentation

std::tuple< int, float, float > QGTagger::calcVariables	(	const reco::Jet *	jet,
		edm::Handle< reco::VertexCollection > &	vC
	)

private

Calculation of axis2, mult and ptD.

Definition at line 135 of file QGTagger.cc.

References a, b, EnergyCorrector::c, delta, reco::deltaPhi(), reco::LeafCandidate::eta(), reco::Jet::getJetConstituentsQuick(), edm::Ref< C, T, F >::isNonnull(), isPackedCandidate(), VarParsing::mult, reco::LeafCandidate::phi(), funct::pow(), reco::TrackBase::qualityByName(), mathSSE::sqrt(), useQC, and puppiForMET_cff::weight.

Referenced by produce().

                                                                                                           {
   float sum_weight = 0., sum_deta = 0., sum_dphi = 0., sum_deta2 = 0., sum_dphi2 = 0., sum_detadphi = 0., sum_pt = 0.;
   int mult = 0;
 
   //Loop over the jet constituents
   for(auto daughter : jet->getJetConstituentsQuick()){
     if(isPackedCandidate(daughter)){                                            //packed candidate situation
       auto part = static_cast<const pat::PackedCandidate*>(daughter);
 
       if(part->charge()){
         if(!(part->fromPV() > 1 && part->trackHighPurity())) continue;
         if(useQC){
           if((part->dz()*part->dz())/(part->dzError()*part->dzError()) > 25.) continue;
           if((part->dxy()*part->dxy())/(part->dxyError()*part->dxyError()) < 25.) ++mult;
         } else ++mult;
       } else {
         if(part->pt() < 1.0) continue;
         ++mult;
       }
     } else {
       auto part = static_cast<const reco::PFCandidate*>(daughter);
 
       reco::TrackRef itrk = part->trackRef();
       if(itrk.isNonnull()){                                             //Track exists --> charged particle
         auto vtxLead  = vC->begin();
         auto vtxClose = vC->begin();                                            //Search for closest vertex to track
         for(auto vtx = vC->begin(); vtx != vC->end(); ++vtx){
           if(fabs(itrk->dz(vtx->position())) < fabs(itrk->dz(vtxClose->position()))) vtxClose = vtx;
         }
         if(!(vtxClose == vtxLead && itrk->quality(reco::TrackBase::qualityByName("highPurity")))) continue;
 
         if(useQC){                                                  //If useQC, require dz and d0 cuts
           float dz = itrk->dz(vtxClose->position());
           float d0 = itrk->dxy(vtxClose->position());
           float dz_sigma_square = pow(itrk->dzError(),2) + pow(vtxClose->zError(),2);
           float d0_sigma_square = pow(itrk->d0Error(),2) + pow(vtxClose->xError(),2) + pow(vtxClose->yError(),2);
           if(dz*dz/dz_sigma_square > 25.) continue;
           if(d0*d0/d0_sigma_square < 25.) ++mult;
         } else ++mult;
       } else {                                                      //No track --> neutral particle
         if(part->pt() < 1.0) continue;                                          //Only use neutrals with pt > 1 GeV
         ++mult;
       }
     }
 
     float deta = daughter->eta() - jet->eta();
     float dphi = reco::deltaPhi(daughter->phi(), jet->phi());
     float partPt = daughter->pt();
     float weight = partPt*partPt;
 
     sum_weight += weight;
     sum_pt += partPt;
     sum_deta += deta*weight;
     sum_dphi += dphi*weight;
     sum_deta2 += deta*deta*weight;
     sum_detadphi += deta*dphi*weight;
     sum_dphi2 += dphi*dphi*weight;
   }
 
   //Calculate axis2 and ptD
   float a = 0., b = 0., c = 0.;
   float ave_deta = 0., ave_dphi = 0., ave_deta2 = 0., ave_dphi2 = 0.;
   if(sum_weight > 0){
     ave_deta = sum_deta/sum_weight;
     ave_dphi = sum_dphi/sum_weight;
     ave_deta2 = sum_deta2/sum_weight;
     ave_dphi2 = sum_dphi2/sum_weight;
     a = ave_deta2 - ave_deta*ave_deta;                          
     b = ave_dphi2 - ave_dphi*ave_dphi;                          
     c = -(sum_detadphi/sum_weight - ave_deta*ave_dphi);                
   }
   float delta = sqrt(fabs((a-b)*(a-b)+4*c*c));
   float axis2 = (a+b-delta > 0 ?  sqrt(0.5*(a+b-delta)) : 0);
   float ptD   = (sum_weight > 0 ? sqrt(sum_weight)/sum_pt : 0);
   return std::make_tuple(mult, ptD, axis2);
 }

void QGTagger::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Descriptions method.

Definition at line 214 of file QGTagger.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), HLT_25ns14e33_v1_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("srcJets");
   desc.add<edm::InputTag>("srcRho");
   desc.add<std::string>("jetsLabel");
   desc.add<std::string>("systematicsLabel", "");
   desc.add<bool>("useQualityCuts");
   desc.add<edm::InputTag>("jec", edm::InputTag())->setComment("Jet correction service: only applied when non-empty");
   desc.add<edm::InputTag>("srcVertexCollection")->setComment("Ignored for miniAOD, possible to keep empty");
   descriptions.add("QGTagger",  desc);
 }

bool QGTagger::isPackedCandidate ( const reco::Candidate * candidate )

private

Function to tell us if we are using packedCandidates, only test for first candidate.

Definition at line 123 of file QGTagger.cc.

References Exception, weAreUsingPackedCandidates, and weStillNeedToCheckJetCandidates.

Referenced by calcVariables().

                                                               {
   if(weStillNeedToCheckJetCandidates){
     if(typeid(pat::PackedCandidate)==typeid(*candidate)) weAreUsingPackedCandidates = true;
     else if(typeid(reco::PFCandidate)==typeid(*candidate)) weAreUsingPackedCandidates = false;
     else throw cms::Exception("WrongJetCollection", "Jet constituents are not particle flow candidates");
     weStillNeedToCheckJetCandidates = false;
   }
   return weAreUsingPackedCandidates;
 }

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

privatevirtual

Produce qgLikelihood using {mult, ptD, -log(axis2)}.

Implements edm::EDProducer.

Definition at line 55 of file QGTagger.cc.

References calcVariables(), QGLikelihoodCalculator::computeQGLikelihood(), edm::EventSetup::get(), edm::eventsetup::EventSetupRecord::get(), edm::Event::getByToken(), metsig::jet, jetCorrectorToken, fwrapper::jets, jetsLabel, jetsToken, cmsBatch::log, VarParsing::mult, produceSyst, EnergyCorrector::pt, putInEvent(), qgLikelihood, rho, rhoToken, QGLikelihoodCalculator::systematicSmearing(), systLabel, useJetCorr, GoodVertex_cfg::vertexCollection, and vertexToken.

                                                                    {
   std::vector<float>* qgProduct         = new std::vector<float>;
   std::vector<float>* axis2Product      = new std::vector<float>;
   std::vector<int>*   multProduct       = new std::vector<int>;
   std::vector<float>* ptDProduct        = new std::vector<float>;
   std::vector<float>* smearedQuarkProduct   = new std::vector<float>;
   std::vector<float>* smearedGluonProduct   = new std::vector<float>;
   std::vector<float>* smearedAllProduct     = new std::vector<float>;
 
   edm::Handle<edm::View<reco::Jet>> jets;               iEvent.getByToken(jetsToken,        jets);
   edm::Handle<reco::JetCorrector> jetCorr;      if(useJetCorr)  iEvent.getByToken(jetCorrectorToken,    jetCorr);
   edm::Handle<reco::VertexCollection> vertexCollection;         iEvent.getByToken(vertexToken,      vertexCollection);
   edm::Handle<double> rho;                      iEvent.getByToken(rhoToken,         rho);
 
   edm::ESHandle<QGLikelihoodObject> QGLParamsColl;
   QGLikelihoodRcd const & rcdhandle = iSetup.get<QGLikelihoodRcd>();
   rcdhandle.get(jetsLabel, QGLParamsColl);
 
   edm::ESHandle<QGLikelihoodSystematicsObject> QGLSystColl;
   if(produceSyst){
     QGLikelihoodSystematicsRcd const & systrcdhandle = iSetup.get<QGLikelihoodSystematicsRcd>();
     systrcdhandle.get(systLabel, QGLSystColl);
   }
 
   for(auto jet = jets->begin(); jet != jets->end(); ++jet){
     float pt = (useJetCorr ? jet->pt()*jetCorr->correction(*jet) : jet->pt());
 
     float ptD, axis2; int mult;
     std::tie(mult, ptD, axis2) = calcVariables(&*jet, vertexCollection);
 
     float qgValue;
     if(mult > 2) qgValue = qgLikelihood->computeQGLikelihood(QGLParamsColl, pt, jet->eta(), *rho, {(float) mult, ptD, -std::log(axis2)});
     else         qgValue = -1;
 
     qgProduct->push_back(qgValue);
     if(produceSyst){
       smearedQuarkProduct->push_back(qgLikelihood->systematicSmearing(QGLSystColl, pt, jet->eta(), *rho, qgValue, 0));
       smearedGluonProduct->push_back(qgLikelihood->systematicSmearing(QGLSystColl, pt, jet->eta(), *rho, qgValue, 1));
       smearedAllProduct->push_back(qgLikelihood->systematicSmearing(  QGLSystColl, pt, jet->eta(), *rho, qgValue, 2));
     }
     axis2Product->push_back(axis2);
     multProduct->push_back(mult);
     ptDProduct->push_back(ptD);
   }
 
   putInEvent("qgLikelihood", jets, qgProduct,    iEvent);
   putInEvent("axis2",        jets, axis2Product, iEvent);
   putInEvent("mult",         jets, multProduct,  iEvent);
   putInEvent("ptD",          jets, ptDProduct,   iEvent);
   if(produceSyst){
     putInEvent("qgLikelihoodSmearedQuark", jets, smearedQuarkProduct, iEvent);
     putInEvent("qgLikelihoodSmearedGluon", jets, smearedGluonProduct, iEvent);
     putInEvent("qgLikelihoodSmearedAll",   jets, smearedAllProduct,   iEvent);
   }
 }

template<typename T >

void QGTagger::putInEvent	(	std::string	name,
		const edm::Handle< edm::View< reco::Jet >> &	jets,
		std::vector< T > *	product,
		edm::Event &	iEvent
	)

private

Function to put product into event.

Definition at line 112 of file QGTagger.cc.

References edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), fwrapper::jets, dbtoconf::out, and edm::Event::put().

Referenced by produce().

                                                                                                                                                {
   std::auto_ptr<edm::ValueMap<T>> out(new edm::ValueMap<T>());
   typename edm::ValueMap<T>::Filler filler(*out);
   filler.insert(jets, product->begin(), product->end());
   filler.fill();
   iEvent.put(out, name);
   delete product;
 }

Member Data Documentation

edm::EDGetTokenT<reco::JetCorrector> QGTagger::jetCorrectorToken

private

Definition at line 27 of file QGTagger.h.

Referenced by produce().

std::string QGTagger::jetsLabel

private

Definition at line 30 of file QGTagger.h.

Referenced by produce().

edm::EDGetTokenT<edm::View<reco::Jet> > QGTagger::jetsToken

private

Definition at line 26 of file QGTagger.h.

Referenced by produce().

const bool QGTagger::produceSyst

private

Definition at line 31 of file QGTagger.h.

Referenced by produce(), and QGTagger().

QGLikelihoodCalculator* QGTagger::qgLikelihood

private

Definition at line 33 of file QGTagger.h.

Referenced by produce(), QGTagger(), and ~QGTagger().

edm::EDGetTokenT<double> QGTagger::rhoToken

private

Definition at line 29 of file QGTagger.h.

Referenced by produce().

std::string QGTagger::systLabel

private

Definition at line 30 of file QGTagger.h.

Referenced by produce().

const bool QGTagger::useJetCorr

private

Definition at line 31 of file QGTagger.h.

Referenced by produce().

const bool QGTagger::useQC

private

Definition at line 31 of file QGTagger.h.

Referenced by calcVariables().

edm::EDGetTokenT<reco::VertexCollection> QGTagger::vertexToken

private

Definition at line 28 of file QGTagger.h.

Referenced by produce().

bool QGTagger::weAreUsingPackedCandidates

private

Definition at line 32 of file QGTagger.h.

Referenced by isPackedCandidate().

bool QGTagger::weStillNeedToCheckJetCandidates

private

Definition at line 32 of file QGTagger.h.

Referenced by isPackedCandidate(), and QGTagger().

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation