#include <JetAnalyzer_HeavyIons_matching.h>

Inheritance diagram for JetAnalyzer_HeavyIons_matching:

Classes
struct	CompareMatchedJets

struct	MyJet

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

	JetAnalyzer_HeavyIons_matching (const edm::ParameterSet &)

	~JetAnalyzer_HeavyIons_matching () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

void	beginStream (edm::StreamID id) final

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

void	endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	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 Types
typedef std::multiset< ABJetPair >::iterator	ABItr

typedef std::pair< MyJet, MyJet >	ABJetPair

typedef std::multiset< ABJetPair, CompareMatchedJets >	ABMatchedJets

Static Private Member Functions
static float	deltaRR (float eta1, float phi1, float eta2, float phi2)

Private Attributes
edm::EDGetTokenT< reco::BasicJetCollection >	basicJetsToken_

edm::EDGetTokenT< reco::CaloJetCollection >	caloJet1Token_

edm::EDGetTokenT< reco::CaloJetCollection >	caloJet2Token_

std::string	JetType1

std::string	JetType2

edm::EDGetTokenT< reco::JPTJetCollection >	jptJetsToken_

MonitorElement *	mChargedEmEnergy_Jet1_unmatched

MonitorElement *	mChargedEmEnergy_Jet2_unmatched

MonitorElement *	mChargedHadEnergyFraction_Jet1_unmatched

MonitorElement *	mChargedHadEnergyFraction_Jet2_unmatched

MonitorElement *	mChargedHadronEnergy_Jet1_unmatched

MonitorElement *	mChargedHadronEnergy_Jet2_unmatched

MonitorElement *	mChargedMuEnergy_Jet1_unmatched

MonitorElement *	mChargedMuEnergy_Jet2_unmatched

MonitorElement *	mElectronEnergyFraction_Jet1_unmatched

MonitorElement *	mElectronEnergyFraction_Jet2_unmatched

MonitorElement *	mEmEnergy_Jet1_unmatched

MonitorElement *	mEmEnergy_Jet2_unmatched

MonitorElement *	mHadEnergy_Jet1_unmatched

MonitorElement *	mHadEnergy_Jet2_unmatched

edm::InputTag	mInputJet1Collection

edm::InputTag	mInputJet2Collection

MonitorElement *	mMuonEnergyFraction_Jet1_unmatched

MonitorElement *	mMuonEnergyFraction_Jet2_unmatched

MonitorElement *	mNeutralEmEnergy_Jet1_unmatched

MonitorElement *	mNeutralEmEnergy_Jet2_unmatched

MonitorElement *	mNeutralHadEnergyFraction_Jet1_unmatched

MonitorElement *	mNeutralHadEnergyFraction_Jet2_unmatched

MonitorElement *	mNeutralHadronEnergy_Jet1_unmatched

MonitorElement *	mNeutralHadronEnergy_Jet2_unmatched

std::string	mOutputFile

MonitorElement *	mPhotonEnergyFraction_Jet1_unmatched

MonitorElement *	mPhotonEnergyFraction_Jet2_unmatched

MonitorElement *	mpT_Jet1_matched

MonitorElement *	mpT_Jet1_unmatched

MonitorElement *	mpT_Jet2_matched

MonitorElement *	mpT_Jet2_unmatched

MonitorElement *	mpT_ratio_Jet1Jet2

double	mRecoDelRMatch

double	mRecoJetEtaCut

double	mRecoJetPtThreshold

edm::EDGetTokenT< reco::PFJetCollection >	pfJetsToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 74 of file JetAnalyzer_HeavyIons_matching.h.

Member Typedef Documentation

◆ ABItr

typedef std::multiset<ABJetPair>::iterator JetAnalyzer_HeavyIons_matching::ABItr

private

Definition at line 161 of file JetAnalyzer_HeavyIons_matching.h.

◆ ABJetPair

typedef std::pair<MyJet, MyJet> JetAnalyzer_HeavyIons_matching::ABJetPair

private

Definition at line 144 of file JetAnalyzer_HeavyIons_matching.h.

◆ ABMatchedJets

typedef std::multiset<ABJetPair, CompareMatchedJets> JetAnalyzer_HeavyIons_matching::ABMatchedJets

private

Definition at line 160 of file JetAnalyzer_HeavyIons_matching.h.

Constructor & Destructor Documentation

◆ JetAnalyzer_HeavyIons_matching()

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

explicit

Definition at line 17 of file JetAnalyzer_HeavyIons_matching.cc.

References basicJetsToken_, caloJet1Token_, caloJet2Token_, JetType1, JetType2, edm::InputTag::label(), mChargedEmEnergy_Jet1_unmatched, mChargedEmEnergy_Jet2_unmatched, mChargedHadEnergyFraction_Jet1_unmatched, mChargedHadEnergyFraction_Jet2_unmatched, mChargedHadronEnergy_Jet1_unmatched, mChargedHadronEnergy_Jet2_unmatched, mChargedMuEnergy_Jet1_unmatched, mChargedMuEnergy_Jet2_unmatched, mElectronEnergyFraction_Jet1_unmatched, mElectronEnergyFraction_Jet2_unmatched, mEmEnergy_Jet1_unmatched, mEmEnergy_Jet2_unmatched, mHadEnergy_Jet1_unmatched, mHadEnergy_Jet2_unmatched, mInputJet1Collection, mInputJet2Collection, mMuonEnergyFraction_Jet1_unmatched, mMuonEnergyFraction_Jet2_unmatched, mNeutralEmEnergy_Jet1_unmatched, mNeutralEmEnergy_Jet2_unmatched, mNeutralHadEnergyFraction_Jet1_unmatched, mNeutralHadEnergyFraction_Jet2_unmatched, mNeutralHadronEnergy_Jet1_unmatched, mNeutralHadronEnergy_Jet2_unmatched, mPhotonEnergyFraction_Jet1_unmatched, mPhotonEnergyFraction_Jet2_unmatched, mpT_Jet1_matched, mpT_Jet1_unmatched, mpT_Jet2_matched, mpT_Jet2_unmatched, mpT_ratio_Jet1Jet2, pfJetsToken_, and AlCaHLTBitMon_QueryRunRegistry::string.

     : mInputJet1Collection(iConfig.getParameter<edm::InputTag>("src_Jet1")),
       mInputJet2Collection(iConfig.getParameter<edm::InputTag>("src_Jet2")),
       JetType1(iConfig.getUntrackedParameter<std::string>("Jet1")),
       JetType2(iConfig.getUntrackedParameter<std::string>("Jet2")),
       mRecoJetPtThreshold(iConfig.getParameter<double>("recoJetPtThreshold")),
       mRecoDelRMatch(iConfig.getParameter<double>("recoDelRMatch")),
       mRecoJetEtaCut(iConfig.getParameter<double>("recoJetEtaCut")) {
   std::string inputCollectionLabelJet1(mInputJet1Collection.label());
   std::string inputCollectionLabelJet2(mInputJet2Collection.label());
 
   //consumes
 
   if (std::string("VsCalo") == JetType1)
     caloJet1Token_ = consumes<reco::CaloJetCollection>(mInputJet1Collection);
   if (std::string("VsPF") == JetType1)
     pfJetsToken_ = consumes<reco::PFJetCollection>(mInputJet1Collection);
   if (std::string("PuCalo") == JetType1)
     caloJet2Token_ = consumes<reco::CaloJetCollection>(mInputJet1Collection);
   if (std::string("PuPF") == JetType1)
     basicJetsToken_ = consumes<reco::BasicJetCollection>(mInputJet1Collection);
 
   if (std::string("VsCalo") == JetType2)
     caloJet1Token_ = consumes<reco::CaloJetCollection>(mInputJet2Collection);
   if (std::string("VsPF") == JetType2)
     pfJetsToken_ = consumes<reco::PFJetCollection>(mInputJet2Collection);
   if (std::string("PuCalo") == JetType2)
     caloJet2Token_ = consumes<reco::CaloJetCollection>(mInputJet2Collection);
   if (std::string("PuPF") == JetType2)
     basicJetsToken_ = consumes<reco::BasicJetCollection>(mInputJet2Collection);
 
   // initialize the Jet matching histograms
 
   mpT_ratio_Jet1Jet2 = nullptr;
   mpT_Jet1_matched = nullptr;
   mpT_Jet2_matched = nullptr;
   mpT_Jet1_unmatched = nullptr;
   mpT_Jet2_unmatched = nullptr;
 
   // we need to add histograms which will hold the hadronic and electromagnetic energy content for the unmatched Jets.
   if (std::string("VsCalo") == JetType1 || std::string("PuCalo") == JetType1) {
     mHadEnergy_Jet1_unmatched = nullptr;
     mEmEnergy_Jet1_unmatched = nullptr;
   }
   if (std::string("VsCalo") == JetType2 || std::string("PuCalo") == JetType2) {
     mHadEnergy_Jet2_unmatched = nullptr;
     mEmEnergy_Jet2_unmatched = nullptr;
   }
 
   if (std::string("VsPF") == JetType1) {
     mChargedHadronEnergy_Jet1_unmatched = nullptr;
     mNeutralHadronEnergy_Jet1_unmatched = nullptr;
     mChargedEmEnergy_Jet1_unmatched = nullptr;
     mNeutralEmEnergy_Jet1_unmatched = nullptr;
     mChargedMuEnergy_Jet1_unmatched = nullptr;
     mChargedHadEnergyFraction_Jet1_unmatched = nullptr;
     mNeutralHadEnergyFraction_Jet1_unmatched = nullptr;
     mPhotonEnergyFraction_Jet1_unmatched = nullptr;
     mElectronEnergyFraction_Jet1_unmatched = nullptr;
     mMuonEnergyFraction_Jet1_unmatched = nullptr;
   }
 
   if (std::string("VsPF") == JetType2) {
     mChargedHadronEnergy_Jet2_unmatched = nullptr;
     mNeutralHadronEnergy_Jet2_unmatched = nullptr;
     mChargedEmEnergy_Jet2_unmatched = nullptr;
     mNeutralEmEnergy_Jet2_unmatched = nullptr;
     mChargedMuEnergy_Jet2_unmatched = nullptr;
     mChargedHadEnergyFraction_Jet2_unmatched = nullptr;
     mNeutralHadEnergyFraction_Jet2_unmatched = nullptr;
     mPhotonEnergyFraction_Jet2_unmatched = nullptr;
     mElectronEnergyFraction_Jet2_unmatched = nullptr;
     mMuonEnergyFraction_Jet2_unmatched = nullptr;
   }
 }

◆ ~JetAnalyzer_HeavyIons_matching()

JetAnalyzer_HeavyIons_matching::~JetAnalyzer_HeavyIons_matching ( )

override

Definition at line 189 of file JetAnalyzer_HeavyIons_matching.cc.

189 {}

Member Function Documentation

◆ analyze()

void JetAnalyzer_HeavyIons_matching::analyze	(	const edm::Event &	mEvent,
		const edm::EventSetup &	mSetup
	)

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 194 of file JetAnalyzer_HeavyIons_matching.cc.

References basicJetsToken_, caloJet1Token_, caloJet2Token_, deltaRR(), PVValHelper::eta, JetAnalyzer_HeavyIons_matching::MyJet::eta, dqm::impl::MonitorElement::Fill(), edm::Event::getByToken(), JetAnalyzer_HeavyIons_matching::MyJet::id, JetType1, JetType2, mChargedEmEnergy_Jet1_unmatched, mChargedEmEnergy_Jet2_unmatched, mChargedHadEnergyFraction_Jet1_unmatched, mChargedHadEnergyFraction_Jet2_unmatched, mChargedHadronEnergy_Jet1_unmatched, mChargedHadronEnergy_Jet2_unmatched, mChargedMuEnergy_Jet1_unmatched, mChargedMuEnergy_Jet2_unmatched, mElectronEnergyFraction_Jet1_unmatched, mElectronEnergyFraction_Jet2_unmatched, mEmEnergy_Jet1_unmatched, mEmEnergy_Jet2_unmatched, mHadEnergy_Jet1_unmatched, mHadEnergy_Jet2_unmatched, mMuonEnergyFraction_Jet1_unmatched, mMuonEnergyFraction_Jet2_unmatched, mNeutralEmEnergy_Jet1_unmatched, mNeutralEmEnergy_Jet2_unmatched, mNeutralHadEnergyFraction_Jet1_unmatched, mNeutralHadEnergyFraction_Jet2_unmatched, mNeutralHadronEnergy_Jet1_unmatched, mNeutralHadronEnergy_Jet2_unmatched, mPhotonEnergyFraction_Jet1_unmatched, mPhotonEnergyFraction_Jet2_unmatched, mpT_Jet1_matched, mpT_Jet1_unmatched, mpT_Jet2_matched, mpT_Jet2_unmatched, mpT_ratio_Jet1Jet2, mRecoDelRMatch, mRecoJetEtaCut, mRecoJetPtThreshold, pfJetBenchmark_cfi::pfJets, pfJetsToken_, JetAnalyzer_HeavyIons_matching::MyJet::phi, DiDispStaMuonMonitor_cfi::pt, JetAnalyzer_HeavyIons_matching::MyJet::pt, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                 {
   // Get the Jet collection
   //----------------------------------------------------------------------------
 
   std::vector<const Jet*> recoJet1;
   recoJet1.clear();
   std::vector<const Jet*> recoJet2;
   recoJet2.clear();
 
   edm::Handle<CaloJetCollection> caloJet1;
   edm::Handle<CaloJetCollection> caloJet2;
   edm::Handle<JPTJetCollection> jptJets;
   edm::Handle<PFJetCollection> pfJets;
   edm::Handle<BasicJetCollection> basicJets;
 
   if (std::string("VsCalo") == JetType1) {
     mEvent.getByToken(caloJet1Token_, caloJet1);
     for (unsigned ijet = 0; ijet < caloJet1->size(); ++ijet)
       recoJet1.push_back(&(*caloJet1)[ijet]);
   }
   if (std::string("PuCalo") == JetType1) {
     mEvent.getByToken(caloJet2Token_, caloJet1);
     for (unsigned ijet = 0; ijet < caloJet1->size(); ++ijet)
       recoJet1.push_back(&(*caloJet1)[ijet]);
   }
   if (std::string("VsPF") == JetType1) {
     mEvent.getByToken(pfJetsToken_, pfJets);
     for (unsigned ijet = 0; ijet < pfJets->size(); ++ijet)
       recoJet1.push_back(&(*pfJets)[ijet]);
   }
   if (std::string("PuPF") == JetType1) {
     mEvent.getByToken(basicJetsToken_, basicJets);
     for (unsigned ijet = 0; ijet < basicJets->size(); ++ijet)
       recoJet1.push_back(&(*basicJets)[ijet]);
   }
 
   if (std::string("VsCalo") == JetType2) {
     mEvent.getByToken(caloJet1Token_, caloJet2);
     for (unsigned ijet = 0; ijet < caloJet2->size(); ++ijet)
       recoJet2.push_back(&(*caloJet2)[ijet]);
   }
   if (std::string("PuCalo") == JetType2) {
     mEvent.getByToken(caloJet2Token_, caloJet2);
     for (unsigned ijet = 0; ijet < caloJet2->size(); ++ijet)
       recoJet2.push_back(&(*caloJet2)[ijet]);
   }
   if (std::string("VsPF") == JetType2) {
     mEvent.getByToken(pfJetsToken_, pfJets);
     for (unsigned ijet = 0; ijet < pfJets->size(); ++ijet)
       recoJet2.push_back(&(*pfJets)[ijet]);
   }
   if (std::string("PuPF") == JetType2) {
     mEvent.getByToken(basicJetsToken_, basicJets);
     for (unsigned ijet = 0; ijet < basicJets->size(); ++ijet)
       recoJet2.push_back(&(*basicJets)[ijet]);
   }
 
   // start to perform the matching - between recoJet1 and recoJet2.
 
   Int_t Jet1_nref = recoJet1.size();
   Int_t Jet2_nref = recoJet2.size();
 
   int jet1 = 0;
   int jet2 = 0;
 
   std::vector<MyJet> vJet1, vJet2;
   std::vector<int> Jet1_ID(Jet1_nref), Jet2_ID(Jet2_nref);
 
   if (Jet1_nref == 0 || Jet2_nref == 0)
     return;
 
   for (unsigned ijet1 = 0; ijet1 < recoJet1.size(); ++ijet1) {
     if (recoJet1[ijet1]->pt() < mRecoJetPtThreshold)
       continue;
     if (fabs(recoJet1[ijet1]->eta()) < mRecoJetEtaCut)
       continue;
 
     MyJet JET1;
     JET1.eta = recoJet1[ijet1]->eta();
     JET1.phi = recoJet1[ijet1]->phi();
     JET1.pt = recoJet1[ijet1]->pt();
     JET1.id = ijet1;
 
     vJet1.push_back(JET1);
     jet1++;
 
   }  // first jet loop
 
   for (unsigned ijet2 = 0; ijet2 < recoJet2.size(); ++ijet2) {
     if (recoJet2[ijet2]->pt() < mRecoJetPtThreshold)
       continue;
     if (fabs(recoJet2[ijet2]->eta()) < mRecoJetEtaCut)
       continue;
 
     MyJet JET2;
     JET2.eta = recoJet2[ijet2]->eta();
     JET2.phi = recoJet2[ijet2]->phi();
     JET2.pt = recoJet2[ijet2]->pt();
     JET2.id = ijet2;
 
     vJet2.push_back(JET2);
     jet2++;
 
   }  // second jet loop
 
   bool onlyJet1 = (jet1 > 0 && jet2 == 0) ? true : false;
   bool onlyJet2 = (jet1 == 0 && jet2 > 0) ? true : false;
   bool bothJet1Jet2 = (jet1 > 0 && jet2 > 0) ? true : false;
 
   int matchedJets = 0;
   int unmatchedJet1 = 0;
   int unmatchedJet2 = 0;
 
   std::vector<MyJet>::const_iterator iJet, jJet;
 
   if (onlyJet1) {
     for (iJet = vJet1.begin(); iJet != vJet1.end(); ++iJet) {
       int pj = (*iJet).id;
 
       mpT_Jet1_unmatched->Fill(recoJet1[pj]->pt());
     }
 
   } else if (onlyJet2) {
     for (iJet = vJet2.begin(); iJet != vJet2.end(); ++iJet) {
       int cj = (*iJet).id;
 
       mpT_Jet2_unmatched->Fill(recoJet2[cj]->pt());
     }
 
   } else if (bothJet1Jet2) {
     ABMatchedJets mABMatchedJets;
 
     for (iJet = vJet1.begin(); iJet != vJet1.end(); ++iJet) {
       for (jJet = vJet2.begin(); jJet != vJet2.end(); ++jJet) {
         mABMatchedJets.insert(std::make_pair(*iJet, *jJet));
       }
     }
 
     ABItr itr;
     // matched Jets matching Jet 1 to Jet 2
     for (itr = mABMatchedJets.begin(); itr != mABMatchedJets.end(); ++itr) {
       ABJetPair jetpair = (*itr);
       MyJet Aj = jetpair.first;
       MyJet Bj = jetpair.second;
 
       float delr = JetAnalyzer_HeavyIons_matching::deltaRR(Bj.eta, Bj.phi, Aj.eta, Aj.phi);
 
       if (delr < mRecoDelRMatch && Jet1_ID[Aj.id] == 0) {
         mpT_ratio_Jet1Jet2->Fill((Float_t)recoJet2[Bj.id]->pt() / recoJet1[Aj.id]->pt());
 
         mpT_Jet1_matched->Fill(recoJet1[Aj.id]->pt());
         mpT_Jet2_matched->Fill(recoJet2[Bj.id]->pt());
 
         Jet1_ID[Aj.id] = 1;
         Jet2_ID[Bj.id] = 1;
 
         matchedJets++;
       }
     }
 
     // for unmatched Jets
     for (itr = mABMatchedJets.begin(); itr != mABMatchedJets.end(); ++itr) {
       ABJetPair jetpair = (*itr);
 
       MyJet Aj = jetpair.first;
       MyJet Bj = jetpair.second;
 
       if (Jet1_ID[Aj.id] == 0) {
         mpT_Jet1_unmatched->Fill(recoJet1[Aj.id]->pt());
         unmatchedJet1++;
         Jet1_ID[Aj.id] = 1;
 
         if (std::string("VsCalo") == JetType1 || std::string("PuCalo") == JetType1) {
           mHadEnergy_Jet1_unmatched->Fill((*caloJet1)[Aj.id].hadEnergyInHO() + (*caloJet1)[Aj.id].hadEnergyInHB() +
                                           (*caloJet1)[Aj.id].hadEnergyInHF() + (*caloJet1)[Aj.id].hadEnergyInHE());
           mEmEnergy_Jet1_unmatched->Fill((*caloJet1)[Aj.id].emEnergyInEB() + (*caloJet1)[Aj.id].emEnergyInEE() +
                                          (*caloJet1)[Aj.id].emEnergyInHF());
         }
 
         if (std::string("VsPF") == JetType1) {
           mChargedHadronEnergy_Jet1_unmatched->Fill((*pfJets)[Aj.id].chargedHadronEnergy());
           mNeutralHadronEnergy_Jet1_unmatched->Fill((*pfJets)[Aj.id].neutralHadronEnergy());
           mChargedEmEnergy_Jet1_unmatched->Fill((*pfJets)[Aj.id].chargedEmEnergy());
           mNeutralEmEnergy_Jet1_unmatched->Fill((*pfJets)[Aj.id].neutralEmEnergy());
           mChargedMuEnergy_Jet1_unmatched->Fill((*pfJets)[Aj.id].chargedMuEnergy());
 
           mChargedHadEnergyFraction_Jet1_unmatched->Fill((*pfJets)[Aj.id].chargedHadronEnergyFraction());
           mNeutralHadEnergyFraction_Jet1_unmatched->Fill((*pfJets)[Aj.id].neutralHadronEnergyFraction());
           mPhotonEnergyFraction_Jet1_unmatched->Fill((*pfJets)[Aj.id].photonEnergyFraction());
           mElectronEnergyFraction_Jet1_unmatched->Fill((*pfJets)[Aj.id].electronEnergyFraction());
           mMuonEnergyFraction_Jet1_unmatched->Fill((*pfJets)[Aj.id].muonEnergyFraction());
         }
       }
 
       if (Jet2_ID[Bj.id] == 0) {
         mpT_Jet2_unmatched->Fill(recoJet2[Bj.id]->pt());
         unmatchedJet2++;
         Jet2_ID[Bj.id] = 2;
         if (std::string("VsCalo") == JetType2 || std::string("PuCalo") == JetType2) {
           mHadEnergy_Jet2_unmatched->Fill((*caloJet2)[Bj.id].hadEnergyInHO() + (*caloJet2)[Bj.id].hadEnergyInHB() +
                                           (*caloJet2)[Bj.id].hadEnergyInHF() + (*caloJet2)[Bj.id].hadEnergyInHE());
           mEmEnergy_Jet2_unmatched->Fill((*caloJet2)[Bj.id].emEnergyInEB() + (*caloJet2)[Bj.id].emEnergyInEE() +
                                          (*caloJet2)[Bj.id].emEnergyInHF());
         }
 
         if (std::string("VsPF") == JetType2) {
           mChargedHadronEnergy_Jet2_unmatched->Fill((*pfJets)[Bj.id].chargedHadronEnergy());
           mNeutralHadronEnergy_Jet2_unmatched->Fill((*pfJets)[Bj.id].neutralHadronEnergy());
           mChargedEmEnergy_Jet2_unmatched->Fill((*pfJets)[Bj.id].chargedEmEnergy());
           mNeutralEmEnergy_Jet2_unmatched->Fill((*pfJets)[Bj.id].neutralEmEnergy());
           mChargedMuEnergy_Jet2_unmatched->Fill((*pfJets)[Bj.id].chargedMuEnergy());
 
           mChargedHadEnergyFraction_Jet2_unmatched->Fill((*pfJets)[Bj.id].chargedHadronEnergyFraction());
           mNeutralHadEnergyFraction_Jet2_unmatched->Fill((*pfJets)[Bj.id].neutralHadronEnergyFraction());
           mPhotonEnergyFraction_Jet2_unmatched->Fill((*pfJets)[Bj.id].photonEnergyFraction());
           mElectronEnergyFraction_Jet2_unmatched->Fill((*pfJets)[Bj.id].electronEnergyFraction());
           mMuonEnergyFraction_Jet2_unmatched->Fill((*pfJets)[Bj.id].muonEnergyFraction());
         }
       }
     }
 
   }  // both Jet1 and Jet2 in the event.
 }

◆ bookHistograms()

void JetAnalyzer_HeavyIons_matching::bookHistograms	(	DQMStore::IBooker &	ibooker,
		edm::Run const &	iRun,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 93 of file JetAnalyzer_HeavyIons_matching.cc.

References dqm::implementation::IBooker::book1D(), JetType1, JetType2, edm::InputTag::label(), mChargedEmEnergy_Jet1_unmatched, mChargedEmEnergy_Jet2_unmatched, mChargedHadEnergyFraction_Jet1_unmatched, mChargedHadEnergyFraction_Jet2_unmatched, mChargedHadronEnergy_Jet1_unmatched, mChargedHadronEnergy_Jet2_unmatched, mChargedMuEnergy_Jet1_unmatched, mChargedMuEnergy_Jet2_unmatched, mElectronEnergyFraction_Jet1_unmatched, mElectronEnergyFraction_Jet2_unmatched, mEmEnergy_Jet1_unmatched, mEmEnergy_Jet2_unmatched, mHadEnergy_Jet1_unmatched, mHadEnergy_Jet2_unmatched, mInputJet1Collection, mInputJet2Collection, mMuonEnergyFraction_Jet1_unmatched, mMuonEnergyFraction_Jet2_unmatched, mNeutralEmEnergy_Jet1_unmatched, mNeutralEmEnergy_Jet2_unmatched, mNeutralHadEnergyFraction_Jet1_unmatched, mNeutralHadEnergyFraction_Jet2_unmatched, mNeutralHadronEnergy_Jet1_unmatched, mNeutralHadronEnergy_Jet2_unmatched, mOutputFile, mPhotonEnergyFraction_Jet1_unmatched, mPhotonEnergyFraction_Jet2_unmatched, mpT_Jet1_matched, mpT_Jet1_unmatched, mpT_Jet2_matched, mpT_Jet2_unmatched, mpT_ratio_Jet1Jet2, dqm::implementation::NavigatorBase::setCurrentFolder(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                           {
   ibooker.setCurrentFolder("JetMET/HIJetValidation/" + mInputJet1Collection.label() + "_DeltaRMatched_" +
                            mInputJet2Collection.label());
 
   mpT_ratio_Jet1Jet2 = ibooker.book1D(
       "Ratio_Jet1pT_vs_Jet2pT", Form(";Matched %s Jet pT / %s Jet pT;Counts", "JetType1", "JetType2"), 100, 0, 10);
   mpT_Jet1_matched =
       ibooker.book1D("Jet1_matched_jet_Spectra", Form(";Matched %s Spectra; counts", "JetType1"), 100, 0, 1000);
   mpT_Jet2_matched =
       ibooker.book1D("Jet2_matched_jet_Spectra", Form(";Matched %s Spectra; counts", "JetType2"), 100, 0, 1000);
   mpT_Jet1_unmatched =
       ibooker.book1D("Jet1_unmatched_jet_Spectra", Form(";Unmatched %s spectra;counts", "JetType1"), 100, 0, 1000);
   mpT_Jet2_unmatched =
       ibooker.book1D("Jet2_unmatched_jet_Spectra", Form(";Unmatched %s spectra;counts", "JetType2"), 100, 0, 1000);
 
   if (std::string("VsCalo") == JetType1 || std::string("PuCalo") == JetType1) {
     mHadEnergy_Jet1_unmatched =
         ibooker.book1D("HadEnergy_Jet1_unmatched",
                        Form("HadEnergy_Jet1_unmatched;HadEnergy unmatched %s;counts", "JetType1"),
                        50,
                        0,
                        200);
     mEmEnergy_Jet1_unmatched = ibooker.book1D(
         "EmEnergy_Jet1_unmatched", Form("EmEnergy_Jet1_unmatched;EMEnergy unmatched %s;counts", "JetType1"), 50, 0, 200);
   }
 
   if (std::string("VsCalo") == JetType2 || std::string("PuCalo") == JetType2) {
     mHadEnergy_Jet2_unmatched =
         ibooker.book1D("HadEnergy_Jet2_unmatched",
                        Form("HadEnergy_Jet2_unmatched;HadEnergy unmatched %s;counts", "JetType2"),
                        50,
                        0,
                        200);
     mEmEnergy_Jet2_unmatched = ibooker.book1D(
         "EmEnergy_Jet2_unmatched", Form("EmEnergy_Jet2_unmatched;EMEnergy unmatched %s;counts", "JetType2"), 50, 0, 200);
   }
 
   if (std::string("VsPF") == JetType1) {
     mChargedHadronEnergy_Jet1_unmatched = ibooker.book1D(
         "ChargedHadronEnergy_Jet1_unmatched", Form(";charged HAD energy unmatched %s;counts", "JetType1"), 100, 0, 300);
     mNeutralHadronEnergy_Jet1_unmatched = ibooker.book1D(
         "neutralHadronEnergy_Jet1_unmatched", Form(";neutral HAD energy unmatched %s;counts", "JetType1"), 100, 0, 300);
     mChargedEmEnergy_Jet1_unmatched = ibooker.book1D(
         "ChargedEmEnergy_Jet1_unmatched", Form(";charged EM energy unmatched %s;counts", "JetType1"), 100, 0, 300);
     mNeutralEmEnergy_Jet1_unmatched = ibooker.book1D(
         "neutralEmEnergy_Jet1_unmatched", Form(";neutral EM energy unmatched %s;counts", "JetType1"), 100, 0, 300);
     mChargedMuEnergy_Jet1_unmatched = ibooker.book1D(
         "ChargedMuEnergy_Jet1_unmatched", Form(";charged Mu energy unmatched %s;counts", "JetType1"), 100, 0, 300);
 
     mChargedHadEnergyFraction_Jet1_unmatched = ibooker.book1D(
         "ChargedHadEnergyFraction_Jet1_unmatched", Form(";h^{+/-} Energy Fraction %s;counts", "JetType1"), 50, 0, 1);
     mNeutralHadEnergyFraction_Jet1_unmatched = ibooker.book1D(
         "NeutralHadEnergyFraction_Jet1_unmatched", Form(";h^{0} Energy Fraction %s;counts", "JetType1"), 50, 0, 1);
     mPhotonEnergyFraction_Jet1_unmatched = ibooker.book1D(
         "PhotonEnergyFraction_Jet1_unmatched", Form(";#gamma Energy Fraction %s;counts", "JetType1"), 50, 0, 1);
     mElectronEnergyFraction_Jet1_unmatched = ibooker.book1D(
         "ElectronEnergyFraction_Jet1_unmatched", Form(";e Energy Fraction %s;counts", "JetType1"), 50, 0, 1);
     mMuonEnergyFraction_Jet1_unmatched = ibooker.book1D(
         "MuonoEnergyFraction_Jet1_unmatched", Form(";#mu Energy Fraction %s;counts", "JetType1"), 50, 0, 1);
   }
 
   if (std::string("VsPF") == JetType2) {
     mChargedHadronEnergy_Jet2_unmatched = ibooker.book1D(
         "ChargedHadronEnergy_Jet2_unmatched", Form(";charged HAD energy unmatched %s;counts", "JetType2"), 100, 0, 300);
     mNeutralHadronEnergy_Jet2_unmatched = ibooker.book1D(
         "neutralHadronEnergy_Jet2_unmatched", Form(";neutral HAD energy unmatched %s;counts", "JetType2"), 100, 0, 300);
     mChargedEmEnergy_Jet2_unmatched = ibooker.book1D(
         "ChargedEmEnergy_Jet2_unmatched", Form(";charged EM energy unmatched %s;counts", "JetType2"), 100, 0, 300);
     mNeutralEmEnergy_Jet2_unmatched = ibooker.book1D(
         "neutralEmEnergy_Jet2_unmatched", Form(";neutral EM energy unmatched %s;counts", "JetType2"), 100, 0, 300);
     mChargedMuEnergy_Jet2_unmatched = ibooker.book1D(
         "ChargedMuEnergy_Jet2_unmatched", Form(";charged Mu energy unmatched %s;counts", "JetType2"), 100, 0, 300);
 
     mChargedHadEnergyFraction_Jet2_unmatched = ibooker.book1D(
         "ChargedHadEnergyFraction_Jet2_unmatched", Form(";h^{+/-} Energy Fraction %s;counts", "JetType2"), 50, 0, 1);
     mNeutralHadEnergyFraction_Jet2_unmatched = ibooker.book1D(
         "NeutralHadEnergyFraction_Jet2_unmatched", Form(";h^{0} Energy Fraction %s;counts", "JetType2"), 50, 0, 1);
     mPhotonEnergyFraction_Jet2_unmatched = ibooker.book1D(
         "PhotonEnergyFraction_Jet2_unmatched", Form(";#gamma Energy Fraction %s;counts", "JetType2"), 50, 0, 1);
     mElectronEnergyFraction_Jet2_unmatched = ibooker.book1D(
         "ElectronEnergyFraction_Jet2_unmatched", Form(";e Energy Fraction %s;counts", "JetType2"), 50, 0, 1);
     mMuonEnergyFraction_Jet2_unmatched = ibooker.book1D(
         "MuonoEnergyFraction_Jet2_unmatched", Form(";#mu Energy Fraction %s;counts", "JetType2"), 50, 0, 1);
   }
 
   if (mOutputFile.empty())
     LogInfo("OutputInfo") << " Histograms will NOT be saved";
   else
     LogInfo("OutputInfo") << " Histograms will be saved to file:" << mOutputFile;
 }

◆ deltaRR()

static float JetAnalyzer_HeavyIons_matching::deltaRR	(	float	eta1,
		float	phi1,
		float	eta2,
		float	phi2
	)

inlinestaticprivate

Definition at line 163 of file JetAnalyzer_HeavyIons_matching.h.

References l1ctLayer1_cff::dr, HLT_2023v12_cff::eta1, HLT_2023v12_cff::eta2, M_PI, and mathSSE::sqrt().

Referenced by analyze(), and JetAnalyzer_HeavyIons_matching::CompareMatchedJets::operator()().

                                                                        {
     float deta = eta1 - eta2;
     float dphi = fabs(phi1 - phi2);
     if (dphi > M_PI)
       dphi -= 2 * M_PI;
     float dr = sqrt(deta * deta + dphi * dphi);
     return dr;
   }