#include <HLTJetCollectionsForElePlusJets.h>

Inheritance diagram for HLTJetCollectionsForElePlusJets< T >:

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

	~HLTJetCollectionsForElePlusJets () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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	minDeltaR_

edm::InputTag	sourceJetTag

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

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

template<typename T>
class HLTJetCollectionsForElePlusJets< 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 HLTJetCollectionsForElePlusJets.h.

Constructor & Destructor Documentation

◆ HLTJetCollectionsForElePlusJets()

template<typename T >

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

explicit

Definition at line 16 of file HLTJetCollectionsForElePlusJets.cc.

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

     : 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<edm::RefVector<std::vector<T>, T, edm::refhelper::FindUsingAdvance<std::vector<T>, T>>>
       TCollectionVector;
   m_theElectronToken = consumes<trigger::TriggerFilterObjectWithRefs>(hltElectronTag);
   m_theJetToken = consumes<std::vector<T>>(sourceJetTag);
   produces<TCollectionVector>();
 }

◆ ~HLTJetCollectionsForElePlusJets()

template<typename T >

HLTJetCollectionsForElePlusJets< T >::~HLTJetCollectionsForElePlusJets ( )

override

Definition at line 35 of file HLTJetCollectionsForElePlusJets.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 HLTJetCollectionsForElePlusJets< T >::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 41 of file HLTJetCollectionsForElePlusJets.cc.

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

                                                                                                     {
   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<HLTJetCollectionsForElePlusJets<T>>(), desc);
 }

◆ produce()

template<typename T >

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

overrideprivate

Definition at line 61 of file HLTJetCollectionsForElePlusJets.cc.

References trigger::TriggerRefsCollections::getObjects(), iEvent, dqmiolumiharvest::j, eostools::move(), multPhiCorr_741_25nsDY_cfi::px, multPhiCorr_741_25nsDY_cfi::py, trigger::TriggerCluster, trigger::TriggerElectron, and trigger::TriggerPhoton.

                                                                                               {
   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 (DR > minDeltaR_)
         refVector.push_back(TRef(theJetCollectionHandle, j));
     }
     allSelections->push_back(refVector);
   }
 
   //iEvent.put(std::move(theFilteredJetCollection));
   iEvent.put(std::move(allSelections));
 
   return;
 }