#include <ShiftedJetProducerByMatchedObject.h>

Inheritance diagram for ShiftedJetProducerByMatchedObjectT< T >:

Classes
struct	objectEntryType

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

	~ShiftedJetProducerByMatchedObjectT () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Types
typedef std::vector< T >	JetCollection

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

Private Attributes
double	dR2match_Jet_

double	dR2match_Object_

double	dRmatch_Jet_

double	dRmatch_Object_

std::string	moduleLabel_

std::vector< objectEntryType >	objects_

edm::EDGetTokenT< JetCollection >	srcJets_

edm::EDGetTokenT< edm::View< reco::Candidate > >	srcShiftedObjects_

edm::EDGetTokenT< edm::View< reco::Candidate > >	srcUnshiftedObjects_

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

template<typename T>
class ShiftedJetProducerByMatchedObjectT< T >

Definition at line 26 of file ShiftedJetProducerByMatchedObject.h.

Member Typedef Documentation

◆ JetCollection

template<typename T >

typedef std::vector<T> ShiftedJetProducerByMatchedObjectT< T >::JetCollection

private

Definition at line 27 of file ShiftedJetProducerByMatchedObject.h.

Constructor & Destructor Documentation

◆ ShiftedJetProducerByMatchedObjectT()

template<typename T >

ShiftedJetProducerByMatchedObjectT< T >::ShiftedJetProducerByMatchedObjectT ( const edm::ParameterSet & cfg )

explicit

Definition at line 10 of file ShiftedJetProducerByMatchedObject.cc.

     : moduleLabel_(cfg.getParameter<std::string>("@module_label")) {
   srcJets_ = consumes<JetCollection>(cfg.getParameter<edm::InputTag>("srcJets"));
   srcUnshiftedObjects_ = consumes<edm::View<reco::Candidate> >(cfg.getParameter<edm::InputTag>("srcUnshiftedObjects"));
   srcShiftedObjects_ = consumes<edm::View<reco::Candidate> >(cfg.getParameter<edm::InputTag>("srcShiftedObjects"));
  
   dRmatch_Jet_ = cfg.getParameter<double>("dRmatch_Jet");
   dRmatch_Object_ = cfg.exists("dRmatch_Object") ? cfg.getParameter<double>("dRmatch_Object") : 0.1;
  
   dR2match_Jet_ = dRmatch_Jet_ * dRmatch_Jet_;
   dR2match_Object_ = dRmatch_Object_ * dRmatch_Object_;
  
   produces<JetCollection>();
 }

References looper::cfg, ShiftedJetProducerByMatchedObjectT< T >::dR2match_Jet_, ShiftedJetProducerByMatchedObjectT< T >::dR2match_Object_, ShiftedJetProducerByMatchedObjectT< T >::dRmatch_Jet_, ShiftedJetProducerByMatchedObjectT< T >::dRmatch_Object_, ShiftedJetProducerByMatchedObjectT< T >::srcJets_, ShiftedJetProducerByMatchedObjectT< T >::srcShiftedObjects_, and ShiftedJetProducerByMatchedObjectT< T >::srcUnshiftedObjects_.

◆ ~ShiftedJetProducerByMatchedObjectT()

template<typename T >

ShiftedJetProducerByMatchedObjectT< T >::~ShiftedJetProducerByMatchedObjectT ( )

override

Definition at line 26 of file ShiftedJetProducerByMatchedObject.cc.

                                                                            {
   // nothing to be done yet...
 }

Member Function Documentation

◆ produce()

template<typename T >

void ShiftedJetProducerByMatchedObjectT< T >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

overrideprivate

Definition at line 31 of file ShiftedJetProducerByMatchedObject.cc.

                                                                                           {
   edm::Handle<JetCollection> originalJets;
   evt.getByToken(srcJets_, originalJets);
  
   edm::Handle<reco::CandidateView> unshiftedObjects;
   evt.getByToken(srcUnshiftedObjects_, unshiftedObjects);
  
   edm::Handle<reco::CandidateView> shiftedObjects;
   evt.getByToken(srcShiftedObjects_, shiftedObjects);
  
   objects_.clear();
  
   std::vector<bool> match(shiftedObjects->size(), false);
   int prevMatch = -1;
   int cnt = 0;
  
   for (reco::CandidateView::const_iterator unshiftedObject = unshiftedObjects->begin();
        unshiftedObject != unshiftedObjects->end();
        ++unshiftedObject) {
     bool isMatched_Object = false;
     double dR2bestMatch_Object = std::numeric_limits<double>::max();
     prevMatch = -1;
     cnt = 0;
  
     reco::Candidate::LorentzVector shiftedObjectP4_matched;
     for (reco::CandidateView::const_iterator shiftedObject = shiftedObjects->begin();
          shiftedObject != shiftedObjects->end();
          ++shiftedObject) {
       if (match[cnt])
         continue;
  
       double dR2 = deltaR2(unshiftedObject->p4(), shiftedObject->p4());
       if (dR2 < dR2match_Object_ && dR2 < dR2bestMatch_Object) {
         shiftedObjectP4_matched = shiftedObject->p4();
         isMatched_Object = true;
         dR2bestMatch_Object = dR2;
  
         prevMatch = cnt;
       }
       cnt++;
     }
     if (isMatched_Object) {
       //Ambiguity removal
       match[prevMatch] = true;
       objects_.push_back(objectEntryType(shiftedObjectP4_matched, unshiftedObject->p4(), sqrt(dR2bestMatch_Object)));
     }
   }
  
   match.assign(objects_.size(), false);
  
   auto shiftedJets = std::make_unique<JetCollection>();
  
   for (typename JetCollection::const_iterator originalJet = originalJets->begin(); originalJet != originalJets->end();
        ++originalJet) {
     double shift = 0.;
     bool applyShift = false;
     double dR2bestMatch_Jet = std::numeric_limits<double>::max();
     prevMatch = -1;
     cnt = 0;
  
     for (typename std::vector<objectEntryType>::const_iterator object = objects_.begin(); object != objects_.end();
          ++object) {
       if (!object->isValidMatch_)
         continue;
       if (match[cnt])
         continue;
  
       double dR2 = deltaR2(originalJet->p4(), object->unshiftedObjectP4_);
       if (dR2 < dR2match_Jet_ && dR2 < dR2bestMatch_Jet) {
         shift = object->shift_;
         applyShift = true;
         dR2bestMatch_Jet = dR2;
  
         prevMatch = cnt;
       }
       cnt++;
     }
  
     reco::Candidate::LorentzVector shiftedJetP4 = originalJet->p4();
     if (applyShift) {
       //Ambiguity removal
       match[prevMatch] = true;
  
       shiftedJetP4 *= (1. + shift);
     }
  
     T shiftedJet(*originalJet);
     shiftedJet.setP4(shiftedJetP4);
  
     shiftedJets->push_back(shiftedJet);
   }
  
   evt.put(std::move(shiftedJets));
 }