Inheritance diagram for L1TkHTMissProducer:

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

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

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

Private Attributes
float	deltaZ_

bool	displaced_

bool	doVtxConstrain_

float	jetMaxEta_

float	jetMinPt_

const edm::EDGetTokenT< TkJetCollection >	jetToken_

float	minJetEtHighPt_

float	minJetEtLowPt_

unsigned int	minNtracksHighPt_

unsigned int	minNtracksLowPt_

bool	primaryVtxConstrain_

const edm::EDGetTokenT< TkPrimaryVertexCollection >	pvToken_

bool	useCaloJets_

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

Definition at line 23 of file L1TkHTMissProducer.cc.

Constructor & Destructor Documentation

◆ L1TkHTMissProducer()

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

explicit

Definition at line 49 of file L1TkHTMissProducer.cc.

     : pvToken_(consumes<TkPrimaryVertexCollection>(iConfig.getParameter<edm::InputTag>("L1VertexInputTag"))),
       jetToken_(consumes<TkJetCollection>(iConfig.getParameter<edm::InputTag>("L1TkJetInputTag"))) {
   jetMinPt_ = (float)iConfig.getParameter<double>("jet_minPt");
   jetMaxEta_ = (float)iConfig.getParameter<double>("jet_maxEta");
   doVtxConstrain_ = iConfig.getParameter<bool>("doVtxConstrain");
   useCaloJets_ = iConfig.getParameter<bool>("useCaloJets");
   primaryVtxConstrain_ = iConfig.getParameter<bool>("primaryVtxConstrain");
   deltaZ_ = (float)iConfig.getParameter<double>("deltaZ");
   minNtracksHighPt_ = iConfig.getParameter<int>("jet_minNtracksHighPt");
   minNtracksLowPt_ = iConfig.getParameter<int>("jet_minNtracksLowPt");
   minJetEtLowPt_ = iConfig.getParameter<double>("jet_minJetEtLowPt");
   minJetEtHighPt_ = iConfig.getParameter<double>("jet_minJetEtHighPt");
   displaced_ = iConfig.getParameter<bool>("displaced");
  
   if (useCaloJets_)
     produces<TkHTMissCollection>("TkCaloHTMiss");
   else if (displaced_)
     produces<TkHTMissCollection>("L1TrackerHTMissExtended");
   else
     produces<TkHTMissCollection>("L1TrackerHTMiss");
 }

References deltaZ_, displaced_, doVtxConstrain_, dqmMemoryStats::float, edm::ParameterSet::getParameter(), jetMaxEta_, jetMinPt_, minJetEtHighPt_, minJetEtLowPt_, minNtracksHighPt_, minNtracksLowPt_, primaryVtxConstrain_, and useCaloJets_.

◆ ~L1TkHTMissProducer()

L1TkHTMissProducer::~L1TkHTMissProducer ( )

override

Definition at line 72 of file L1TkHTMissProducer.cc.

72 {}

Member Function Documentation

◆ produce()

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

overrideprivate

Definition at line 74 of file L1TkHTMissProducer.cc.

                                                                               {
   using namespace edm;
   std::unique_ptr<TkHTMissCollection> MHTCollection(new TkHTMissCollection);
  
   // L1 primary vertex
   edm::Handle<TkPrimaryVertexCollection> L1VertexHandle;
   iEvent.getByToken(pvToken_, L1VertexHandle);
  
   // L1 track-trigger jets
   edm::Handle<TkJetCollection> L1TkJetsHandle;
   iEvent.getByToken(jetToken_, L1TkJetsHandle);
   std::vector<TkJet>::const_iterator jetIter;
  
   if (!L1TkJetsHandle.isValid() && !displaced_) {
     LogError("TkHTMissProducer") << "\nWarning: TkJetCollection not found in the event. Exit\n";
     return;
   }
  
   if (!L1TkJetsHandle.isValid() && displaced_) {
     LogError("TkHTMissProducer") << "\nWarning: TkJetExtendedCollection not found in the event. Exit\n";
     return;
   }
  
   // ----------------------------------------------------------------------------------------------
   // if primaryVtxConstrain_, use the primary vertex instead of z position from leading jet
   // ----------------------------------------------------------------------------------------------
   float evtZVtx = 999;
   bool foundVtx = false;
   edm::Ref<TkPrimaryVertexCollection> L1VtxRef;  // null reference
  
   if (useCaloJets_) {
     if (doVtxConstrain_ && primaryVtxConstrain_) {
       if (!L1VertexHandle.isValid()) {
         LogError("L1TkHTMissProducer") << "\nWarning: TkPrimaryVertexCollection not found in the event. Exit\n";
         return;
       } else {
         std::vector<TkPrimaryVertex>::const_iterator vtxIter = L1VertexHandle->begin();
         // by convention, the first vertex in the collection is the one that should
         // be used by default
         evtZVtx = vtxIter->zvertex();
         foundVtx = true;
         int ivtx = 0;
         edm::Ref<TkPrimaryVertexCollection> vtxRef(L1VertexHandle, ivtx);
         L1VtxRef = vtxRef;
       }
     }  //endif primaryVtxConstrain_
  
     // ----------------------------------------------------------------------------------------------
     // using z position of leading jet to define "event vertex"
     // ----------------------------------------------------------------------------------------------
     float zvtx_jetpt = -1.0;  //pt of jet determining the event vertex
     float jetVtxMax = 99.;    //find z position of leading jet that has a z vertex!
  
     if (doVtxConstrain_ && !primaryVtxConstrain_) {
       for (jetIter = L1TkJetsHandle->begin(); jetIter != L1TkJetsHandle->end(); ++jetIter) {
         int ibx = jetIter->bx();  // only consider jets from the central BX
         if (ibx != 0)
           continue;
  
         float tmp_jet_vtx = jetIter->jetVtx();
         float tmp_jet_pt = jetIter->pt();
         float tmp_jet_eta = jetIter->eta();
         if (tmp_jet_pt < jetMinPt_)
           continue;
         if (fabs(tmp_jet_eta) > jetMaxEta_)
           continue;
         if (fabs(tmp_jet_vtx) > jetVtxMax)
           continue;
  
         // find vertex position of leading jet
         if (tmp_jet_pt > zvtx_jetpt) {
           evtZVtx = tmp_jet_vtx;
           zvtx_jetpt = tmp_jet_pt;
           foundVtx = true;
         }
       }  //end loop over jets
     }    //endif z position from leading jet
  
     float sumPx_calo = 0;
     float sumPy_calo = 0;
     float HT_calo = 0;
  
     if (doVtxConstrain_ && !foundVtx)
       LogWarning("L1TkHTMissProducer") << "Didn't find any z vertex (based on jet vertices) for this event!\n";
  
     // loop over jets
     for (jetIter = L1TkJetsHandle->begin(); jetIter != L1TkJetsHandle->end(); ++jetIter) {
       int ibx = jetIter->bx();  // only consider jets from the central BX
       if (ibx != 0)
         continue;
  
       float tmp_jet_px = jetIter->px();
       float tmp_jet_py = jetIter->py();
       float tmp_jet_et = jetIter->et();
       float tmp_jet_vtx = jetIter->jetVtx();
       if (jetIter->pt() < jetMinPt_)
         continue;
       if (fabs(jetIter->eta()) > jetMaxEta_)
         continue;
  
       // vertex consistency requirement
       bool VtxRequirement = false;
       if (foundVtx)
         VtxRequirement = fabs(tmp_jet_vtx - evtZVtx) < deltaZ_;
  
       if (!doVtxConstrain_ || VtxRequirement) {
         sumPx_calo += tmp_jet_px;
         sumPy_calo += tmp_jet_py;
         HT_calo += tmp_jet_et;
       }
     }  //end loop over jets
  
     // define missing HT
     float et = sqrt(sumPx_calo * sumPx_calo + sumPy_calo * sumPy_calo);
     math::XYZTLorentzVector missingEt(-sumPx_calo, -sumPy_calo, 0, et);
     edm::RefProd<TkJetCollection> jetCollRef(L1TkJetsHandle);
     TkHTMiss tkHTM(missingEt, HT_calo, jetCollRef, L1VtxRef);
  
     if (doVtxConstrain_ && !primaryVtxConstrain_) {
       tkHTM.setVtx(evtZVtx);
     }
  
     MHTCollection->push_back(tkHTM);
     iEvent.put(std::move(MHTCollection), "L1TkCaloHTMiss");
   }
  
   else {  // Using standalone jets
     float sumPx = 0;
     float sumPy = 0;
     float HT = 0;
  
     // loop over jets
     for (jetIter = L1TkJetsHandle->begin(); jetIter != L1TkJetsHandle->end(); ++jetIter) {
       float tmp_jet_px = jetIter->px();
       float tmp_jet_py = jetIter->py();
       float tmp_jet_et = jetIter->et();
       float tmp_jet_pt = jetIter->pt();
       if (tmp_jet_pt < jetMinPt_)
         continue;
       if (fabs(jetIter->eta()) > jetMaxEta_)
         continue;
       if (jetIter->ntracks() < minNtracksLowPt_ && tmp_jet_et > minJetEtLowPt_)
         continue;
       if (jetIter->ntracks() < minNtracksHighPt_ && tmp_jet_et > minJetEtHighPt_)
         continue;
       sumPx += tmp_jet_px;
       sumPy += tmp_jet_py;
       HT += tmp_jet_pt;
     }  // end jet loop
  
     // define missing HT
     float et = sqrt(sumPx * sumPx + sumPy * sumPy);
     math::XYZTLorentzVector missingEt(-sumPx, -sumPy, 0, et);
     edm::RefProd<TkJetCollection> jetCollRef(L1TkJetsHandle);
     TkHTMiss tkHTM(missingEt, HT, jetCollRef, L1VtxRef);
  
     MHTCollection->push_back(tkHTM);
     if (displaced_)
       iEvent.put(std::move(MHTCollection), "L1TrackerHTMissExtended");
     else
       iEvent.put(std::move(MHTCollection), "L1TrackerHTMiss");
   }
 }  //end producer