#include <HLTJetCollForElePlusJets.h>

Inheritance diagram for HLTJetCollForElePlusJets< T >:

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

	~HLTJetCollForElePlusJets () 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

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

Private Attributes
edm::InputTag	hltElectronTag

edm::EDGetTokenT< trigger::TriggerFilterObjectWithRefs >	m_theElectronToken

edm::EDGetTokenT< std::vector< T > >	m_theJetToken

double	maxAbsJetEta_

double	minDeltaEta_

double	minDeltaR_

double	minJetPt_

unsigned int	minNJets_

double	minSoftJetPt_

edm::InputTag	sourceJetTag

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 HLTJetCollForElePlusJets< T >

This class is an EDProducer implementing an HLT trigger for electron and jet objects, cutting on variables relating to the jet 4-momentum representation. The producer checks for overlaps between electrons and jets and if a combination of one electron + jets cleaned against this electrons satisfy the cuts. These jets are then added to a cleaned jet collection which is put into the event.

Author: Lukasz Kreczko

Definition at line 40 of file HLTJetCollForElePlusJets.h.

Constructor & Destructor Documentation

◆ HLTJetCollForElePlusJets()

template<typename T >

HLTJetCollForElePlusJets< T >::HLTJetCollForElePlusJets ( const edm::ParameterSet & iConfig )

explicit

Definition at line 15 of file HLTJetCollForElePlusJets.cc.

     : hltElectronTag(iConfig.getParameter<edm::InputTag>("HltElectronTag")),
       sourceJetTag(iConfig.getParameter<edm::InputTag>("SourceJetTag")),
       minJetPt_(iConfig.getParameter<double>("MinJetPt")),
       maxAbsJetEta_(iConfig.getParameter<double>("MaxAbsJetEta")),
       minNJets_(iConfig.getParameter<unsigned int>("MinNJets")),
       minDeltaR_(iConfig.getParameter<double>("minDeltaR")),
       //Only for VBF
       minSoftJetPt_(iConfig.getParameter<double>("MinSoftJetPt")),
       minDeltaEta_(iConfig.getParameter<double>("MinDeltaEta")) {
   typedef std::vector<T> TCollection;
   m_theElectronToken = consumes<trigger::TriggerFilterObjectWithRefs>(hltElectronTag);
   m_theJetToken = consumes<TCollection>(sourceJetTag);
   produces<TCollection>();
 }

References HLTJetCollForElePlusJets< T >::hltElectronTag, HLTJetCollForElePlusJets< T >::m_theElectronToken, HLTJetCollForElePlusJets< T >::m_theJetToken, and HLTJetCollForElePlusJets< T >::sourceJetTag.

◆ ~HLTJetCollForElePlusJets()

template<typename T >

HLTJetCollForElePlusJets< T >::~HLTJetCollForElePlusJets ( )

override

Definition at line 32 of file HLTJetCollForElePlusJets.cc.

                                                        {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

◆ fillDescriptions()

template<typename T >

void HLTJetCollForElePlusJets< T >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 38 of file HLTJetCollForElePlusJets.cc.

                                                                                              {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("HltElectronTag", edm::InputTag("triggerFilterObjectWithRefs"));
   desc.add<edm::InputTag>("SourceJetTag", edm::InputTag("jetCollection"));
   desc.add<double>("MinJetPt", 30.);
   desc.add<double>("MaxAbsJetEta", 2.6);
   desc.add<unsigned int>("MinNJets", 1);
   desc.add<double>("minDeltaR", 0.5);
   //Only for VBF
   desc.add<double>("MinSoftJetPt", 25.);
   desc.add<double>("MinDeltaEta", -1.);
   descriptions.add(defaultModuleLabel<HLTJetCollForElePlusJets<T>>(), desc);
 }

References edm::ConfigurationDescriptions::add(), defaultModuleLabel(), submitPVResolutionJobs::desc, and HLT_FULL_cff::InputTag.

◆ produce()

template<typename T >

void HLTJetCollForElePlusJets< T >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 58 of file HLTJetCollForElePlusJets.cc.

                                                                                        {
   using namespace edm;
   using namespace std;
  
   typedef vector<T> TCollection;
   typedef Ref<TCollection> TRef;
   typedef edm::RefVector<TCollection> TRefVector;
   typedef std::vector<edm::RefVector<std::vector<T>, T, edm::refhelper::FindUsingAdvance<std::vector<T>, T>>>
       TCollectionVector;
  
   edm::Handle<trigger::TriggerFilterObjectWithRefs> PrevFilterOutput;
   iEvent.getByToken(m_theElectronToken, PrevFilterOutput);
  
   //its easier on the if statement flow if I try everything at once, shouldnt add to timing
   // Electrons can be stored as objects of types TriggerCluster, TriggerElectron, or TriggerPhoton
   std::vector<edm::Ref<reco::RecoEcalCandidateCollection>> clusCands;
   PrevFilterOutput->getObjects(trigger::TriggerCluster, clusCands);
  
   std::vector<edm::Ref<reco::ElectronCollection>> eleCands;
   PrevFilterOutput->getObjects(trigger::TriggerElectron, eleCands);
  
   trigger::VRphoton photonCands;
   PrevFilterOutput->getObjects(trigger::TriggerPhoton, photonCands);
  
   //prepare the collection of 3-D vector for electron momenta
   std::vector<TVector3> ElePs;
  
   if (!clusCands.empty()) {  //try trigger cluster
     for (auto& clusCand : clusCands) {
       TVector3 positionVector(clusCand->superCluster()->position().x(),
                               clusCand->superCluster()->position().y(),
                               clusCand->superCluster()->position().z());
       ElePs.push_back(positionVector);
     }
   } else if (!eleCands.empty()) {  // try trigger electrons
     for (auto& eleCand : eleCands) {
       TVector3 positionVector(eleCand->superCluster()->position().x(),
                               eleCand->superCluster()->position().y(),
                               eleCand->superCluster()->position().z());
       ElePs.push_back(positionVector);
     }
   } else if (!photonCands.empty()) {  // try trigger photons
     for (auto& photonCand : photonCands) {
       TVector3 positionVector(photonCand->superCluster()->position().x(),
                               photonCand->superCluster()->position().y(),
                               photonCand->superCluster()->position().z());
       ElePs.push_back(positionVector);
     }
   }
  
   edm::Handle<TCollection> theJetCollectionHandle;
   iEvent.getByToken(m_theJetToken, theJetCollectionHandle);
  
   const TCollection& theJetCollection = *theJetCollectionHandle;
  
   std::unique_ptr<TCollection> theFilteredJetCollection(new TCollection);
  
   std::unique_ptr<TCollectionVector> allSelections(new TCollectionVector());
  
   bool foundSolution(false);
  
   for (auto& EleP : ElePs) {
     bool VBFJetPair = false;
     std::vector<int> store_jet;
     TRefVector refVector;
  
     for (unsigned int j = 0; j < theJetCollection.size(); j++) {
       TVector3 JetP(theJetCollection[j].px(), theJetCollection[j].py(), theJetCollection[j].pz());
       double DR = EleP.DeltaR(JetP);
  
       if (JetP.Pt() > minJetPt_ && std::abs(JetP.Eta()) < maxAbsJetEta_ && DR > minDeltaR_) {
         store_jet.push_back(j);
         // The VBF part of the filter
         if (minDeltaEta_ > 0) {
           for (unsigned int k = j + 1; k < theJetCollection.size(); k++) {
             TVector3 SoftJetP(theJetCollection[k].px(), theJetCollection[k].py(), theJetCollection[k].pz());
             double softDR = EleP.DeltaR(SoftJetP);
  
             if (SoftJetP.Pt() > minSoftJetPt_ && std::abs(SoftJetP.Eta()) < maxAbsJetEta_ && softDR > minDeltaR_)
               if (std::abs(SoftJetP.Eta() - JetP.Eta()) > minDeltaEta_) {
                 store_jet.push_back(k);
                 VBFJetPair = true;
               }
           }
         }
       }
     }
  
     // Now remove duplicates from the jet collection to store
     std::sort(store_jet.begin(), store_jet.end());
     store_jet.erase(unique(store_jet.begin(), store_jet.end()), store_jet.end());
  
     // Now save the cleaned jets
     for (int& ijet : store_jet) {
       //store all selections
       refVector.push_back(TRef(theJetCollectionHandle, ijet));
       //store first selection which matches the criteria
       if (!foundSolution)
         theFilteredJetCollection->push_back(theJetCollection[ijet]);
     }
     //store all selections
     allSelections->push_back(refVector);
  
     if (theFilteredJetCollection->size() >= minNJets_ && minDeltaEta_ < 0)
       foundSolution = true;
     else if (VBFJetPair && minDeltaEta_ > 0)
       foundSolution = true;
     else if (!foundSolution)
       theFilteredJetCollection->clear();
   }
  
   iEvent.put(std::move(theFilteredJetCollection));
  
   return;
 }