#include <DPGAnalysis/MuonTools/plugins/MuDTMuonExtTableProducer.cc>

Inheritance diagram for MuDTMuonExtTableProducer:

Public Member Functions
	MuDTMuonExtTableProducer (const edm::ParameterSet &)
	Constructor. More...

Public Member Functions inherited from MuBaseFlatTableProducer
void	beginRun (const edm::Run &run, const edm::EventSetup &config) final
	Configure event setup for each run. More...

void	endRun (const edm::Run &, const edm::EventSetup &) final
	Empty, needed by interface. More...

	MuBaseFlatTableProducer (const edm::ParameterSet &)
	Constructor. More...

void	produce (edm::Event &, const edm::EventSetup &) final
	Fill ntuples event by event. More...

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 &)
	Fill descriptors. More...

Protected Member Functions
void	fillTable (edm::Event &) final
	Fill tree branches for a given events. More...

void	getFromES (const edm::Run &, const edm::EventSetup &) final
	Get info from the ES by run. More...

Protected Member Functions inherited from MuBaseFlatTableProducer
template<typename T >
void	addColumn (std::unique_ptr< nanoaod::FlatTable > &table, const std::string name, const std::vector< T > &vec, const std::string descr)

virtual void	getFromES (const edm::EventSetup &environment)
	Get info from the ES for a given event. More...

Private Member Functions
bool	hasTrigger (std::vector< int > &, const trigger::TriggerObjectCollection &, edm::Handle< trigger::TriggerEvent > &, const reco::Muon &)

Private Attributes
nano_mu::ESTokenHandle< DTGeometry, MuonGeometryRecord, edm::Transition::BeginRun >	m_dtGeometry
	DT Geometry. More...

nano_mu::EDTokenHandle< DTRecSegment4DCollection >	m_dtSegmentToken

bool	m_fillMatches
	Fill matches table. More...

HLTConfigProvider	m_hltConfig
	HLT config provider. More...

std::vector< int >	m_isoTrigIndices

std::string	m_isoTrigName

nano_mu::EDTokenHandle< edm::View< reco::Muon > >	m_muToken
	Tokens. More...

nano_mu::EDTokenHandle< trigger::TriggerEvent >	m_trigEventToken

std::vector< int >	m_trigIndices
	Indices of the triggers used by muon filler for trigger matching. More...

std::string	m_trigName
	Name of the triggers used by muon filler for trigger matching. More...

nano_mu::EDTokenHandle< edm::TriggerResults >	m_trigResultsToken

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

Protected Attributes inherited from MuBaseFlatTableProducer
std::string	m_name
	The label name of the FlatTableProducer. More...

Static Protected Attributes inherited from MuBaseFlatTableProducer
static constexpr double	DEFAULT_DOUBLE_VAL {-999.0}
	Definition of default values for float variables. More...

static constexpr double	DEFAULT_DOUBLE_VAL_POS {-1.0}
	Definition of default values for positive float variables. More...

static constexpr int8_t	DEFAULT_INT8_VAL {-99}
	Definition of default values for int8 variables. More...

static constexpr int	DEFAULT_INT_VAL {-999}
	Definition of default values for int variables. More...

static constexpr int	DEFAULT_INT_VAL_POS {-1}
	Definition of default values for positive int variables. More...

Detailed Description

Helper class : the muon filler

Author: L. Lunerti (INFN BO)

Definition at line 47 of file MuDTMuonExtTableProducer.cc.

Constructor & Destructor Documentation

◆ MuDTMuonExtTableProducer()

MuDTMuonExtTableProducer::MuDTMuonExtTableProducer ( const edm::ParameterSet & config )

Constructor.

Definition at line 93 of file MuDTMuonExtTableProducer.cc.

References DMR_cfg::config.

     : MuBaseFlatTableProducer(config),
       m_muToken{config, consumesCollector(), "src"},
       m_dtSegmentToken{config, consumesCollector(), "dtSegmentSrc"},
       m_trigResultsToken{config, consumesCollector(), "trigResultsSrc"},
       m_trigEventToken{config, consumesCollector(), "trigEventSrc"},
       m_fillMatches{config.getParameter<bool>("fillMatches")},
       m_trigName{config.getParameter<std::string>("trigName")},
       m_isoTrigName{config.getParameter<std::string>("isoTrigName")},
       m_dtGeometry{consumesCollector()} {
   produces<nanoaod::FlatTable>();
   if (m_fillMatches) {
     produces<nanoaod::FlatTable>("matches");
     produces<nanoaod::FlatTable>("staMatches");
   }
 }

Member Function Documentation

◆ fillDescriptions()

void MuDTMuonExtTableProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Fill descriptors.

Definition at line 110 of file MuDTMuonExtTableProducer.cc.

References edm::ConfigurationDescriptions::addWithDefaultLabel(), submitPVResolutionJobs::desc, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                           {
   edm::ParameterSetDescription desc;
 
   desc.add<std::string>("name", "muon");
   desc.add<edm::InputTag>("src", edm::InputTag{"patMuons"});
   desc.add<edm::InputTag>("dtSegmentSrc", edm::InputTag{"dt4DSegments"});
   desc.add<edm::InputTag>("trigEventSrc", edm::InputTag{"hltTriggerSummaryAOD::HLT"});
   desc.add<edm::InputTag>("trigResultsSrc", edm::InputTag{"TriggerResults::HLT"});
 
   desc.add<bool>("fillMatches", true);
 
   desc.add<std::string>("trigName", "HLT_Mu55*");
   desc.add<std::string>("isoTrigName", "HLT_IsoMu2*");
 
   descriptions.addWithDefaultLabel(desc);
 }

◆ fillTable()

void MuDTMuonExtTableProducer::fillTable ( edm::Event & ev )

finalprotectedvirtual

Fill tree branches for a given events.

Implements MuBaseFlatTableProducer.

Definition at line 154 of file MuDTMuonExtTableProducer.cc.

References funct::abs(), MuBaseFlatTableProducer::addColumn(), DTGeometry::chamber(), nano_mu::EDTokenHandle< T >::conditionalGet(), hcalRecHitTable_cff::detId, MuonSubdetId::DT, makeMEIFBenchmarkPlots::ev, hasTrigger(), m_dtGeometry, m_dtSegmentToken, m_fillMatches, m_isoTrigIndices, m_muToken, MuBaseFlatTableProducer::m_name, m_trigEventToken, m_trigIndices, m_trigResultsToken, match(), eostools::move(), DetId::Muon, PDWG_BPHSkim_cff::muons, custom_jme_cff::nMuons, TableParser::table, PDWG_DiPhoton_SD_cff::triggerEvent, triggerMatchMonitor_cfi::triggerObjects, triggerResults, and findQualityFiles::v.

                                                      {
   unsigned int nMuons{0};
 
   std::vector<bool> firesIsoTrig;
   std::vector<bool> firesTrig;
 
   std::vector<int> nMatches;
   std::vector<int> staMu_nMatchSeg;
 
   std::vector<uint32_t> matches_begin;
   std::vector<uint32_t> matches_end;
 
   std::vector<uint32_t> staMatches_begin;
   std::vector<uint32_t> staMatches_end;
 
   std::vector<int8_t> matches_wheel;
   std::vector<int8_t> matches_sector;
   std::vector<int8_t> matches_station;
 
   std::vector<float> matches_x;
   std::vector<float> matches_y;
 
   std::vector<float> matches_phi;
   std::vector<float> matches_eta;
   std::vector<float> matches_edgeX;
   std::vector<float> matches_edgeY;
 
   std::vector<float> matches_dXdZ;
   std::vector<float> matches_dYdZ;
 
   std::vector<uint32_t> staMatches_MuSegIdx;
 
   auto muons = m_muToken.conditionalGet(ev);
   auto segments = m_dtSegmentToken.conditionalGet(ev);
 
   auto triggerResults = m_trigResultsToken.conditionalGet(ev);
   auto triggerEvent = m_trigEventToken.conditionalGet(ev);
 
   if (muons.isValid() && segments.isValid()) {
     for (const auto& muon : (*muons)) {
       if (triggerResults.isValid() && triggerEvent.isValid()) {
         const auto& triggerObjects = triggerEvent->getObjects();
 
         bool hasIsoTrig = hasTrigger(m_isoTrigIndices, triggerObjects, triggerEvent, muon);
         bool hasTrig = hasTrigger(m_trigIndices, triggerObjects, triggerEvent, muon);
 
         firesIsoTrig.push_back(hasIsoTrig);
         firesTrig.push_back(hasTrig);
 
       } else {
         firesIsoTrig.push_back(false);
         firesTrig.push_back(false);
       }
 
       size_t iMatches = 0;
       size_t iSegMatches = 0;
 
       if (m_fillMatches) {
         matches_begin.push_back(matches_wheel.size());
 
         if (muon.isMatchesValid()) {
           for (const auto& match : muon.matches()) {
             if (match.id.det() == DetId::Muon && match.id.subdetId() == MuonSubdetId::DT) {
               DTChamberId dtId(match.id.rawId());
               const auto chamb = m_dtGeometry->chamber(static_cast<DTChamberId>(match.id));
 
               matches_wheel.push_back(dtId.wheel());
               matches_sector.push_back(dtId.sector());
               matches_station.push_back(dtId.station());
 
               matches_x.push_back(match.x);
               matches_y.push_back(match.y);
 
               matches_phi.push_back(chamb->toGlobal(LocalPoint(match.x, match.y, 0.)).phi());
               matches_eta.push_back(chamb->toGlobal(LocalPoint(match.x, match.y, 0.)).eta());
 
               matches_edgeX.push_back(match.edgeX);
               matches_edgeY.push_back(match.edgeY);
 
               matches_dXdZ.push_back(match.dXdZ);
               matches_dYdZ.push_back(match.dYdZ);
 
               ++iMatches;
             }
           }
         }
 
         matches_end.push_back(matches_wheel.size());
 
         //SEGMENT MATCHING VARIABLES
 
         staMatches_begin.push_back(staMatches_MuSegIdx.size());
 
         if (!muon.outerTrack().isNull()) {
           reco::TrackRef outerTrackRef = muon.outerTrack();
 
           auto recHitIt = outerTrackRef->recHitsBegin();
           auto recHitEnd = outerTrackRef->recHitsEnd();
 
           for (; recHitIt != recHitEnd; ++recHitIt) {
             DetId detId = (*recHitIt)->geographicalId();
 
             if (detId.det() == DetId::Muon && detId.subdetId() == MuonSubdetId::DT) {
               const auto dtSegmentSta = dynamic_cast<const DTRecSegment4D*>((*recHitIt));
               int iSeg = 0;
 
               for (const auto& segment : (*segments)) {
                 if (dtSegmentSta && dtSegmentSta->chamberId().station() == segment.chamberId().station() &&
                     dtSegmentSta->chamberId().wheel() == segment.chamberId().wheel() &&
                     dtSegmentSta->chamberId().sector() == segment.chamberId().sector() &&
                     std::abs(dtSegmentSta->localPosition().x() - segment.localPosition().x()) < 0.001 &&
                     std::abs(dtSegmentSta->localPosition().y() - segment.localPosition().y()) < 0.001 &&
                     std::abs(dtSegmentSta->localDirection().x() - segment.localDirection().x()) < 0.001 &&
                     std::abs(dtSegmentSta->localDirection().y() - segment.localDirection().y()) < 0.001) {
                   staMatches_MuSegIdx.push_back(iSeg);
                   ++iSegMatches;
                 }
 
                 ++iSeg;
               }  //loop over segments
             }
 
           }  //loop over recHits
         }
 
         staMatches_end.push_back(staMatches_MuSegIdx.size());
       }
 
       nMatches.push_back(iMatches);
       staMu_nMatchSeg.push_back(iSegMatches);
 
       ++nMuons;
     }
   }
 
   auto table = std::make_unique<nanoaod::FlatTable>(nMuons, m_name, false, true);
 
   addColumn(table,
             "firesIsoTrig",
             firesIsoTrig,
             "True if the muon is matched to an isolated trigger"
             "<br />specified in the ntuple config file");
 
   addColumn(table,
             "firesTrig",
             firesTrig,
             "True if the muon is matched to a  (non isolated)trigger"
             "<br />specified in the ntuple config file");
 
   addColumn(table, "nMatches", nMatches, "Number of muon chamber matches (DT only)");
   addColumn(table, "staMu_nMatchSeg", staMu_nMatchSeg, "Number of segments used in the standalone track (DT only)");
 
   addColumn(table,
             "matches_begin",
             matches_begin,
             "begin() of range of quantities for a given muon in the *_matches_* vectors");
   addColumn(
       table, "matches_end", matches_end, "end() of range of quantities for a given muon in the *_matches_* vectors");
 
   addColumn(table,
             "staMatches_begin",
             staMatches_begin,
             "begin() of range of quantities for a given muon in the matches_staMuSegIdx vector");
   addColumn(table,
             "staMatches_end",
             staMatches_end,
             "end() of range of quantities for a given muon in the matches_staMuSegIdx vector");
 
   ev.put(std::move(table));
 
   if (m_fillMatches) {
     auto sum = [](std::vector<int> v) { return std::accumulate(v.begin(), v.end(), 0); };
 
     auto tabMatches = std::make_unique<nanoaod::FlatTable>(sum(nMatches), m_name + "_matches", false, false);
 
     tabMatches->setDoc("RECO muon matches_* vectors");
 
     addColumn(tabMatches, "x", matches_x, "x position of the extrapolated track on the matched DT chamber");
     addColumn(tabMatches, "y", matches_y, "x position of the extrapolated track on the matched DT chamber");
 
     addColumn(tabMatches, "wheel", matches_wheel, "matched DT chamber wheel");
     addColumn(tabMatches, "sector", matches_sector, "matched DT chamber sector");
     addColumn(tabMatches, "station", matches_station, "matched DT chamber station");
 
     addColumn(
         tabMatches, "phi", matches_phi, "phi of the (x,y) position on the matched DT chamber (global reference frame)");
     addColumn(tabMatches,
               "eta",
               matches_eta,
               " eta of the (x,y) position on the matched cDT hamber (global reference frame)");
 
     addColumn(tabMatches, "dXdZ", matches_dXdZ, "dXdZ of the extrapolated track on the matched DT chamber");
     addColumn(tabMatches, "dYdZ", matches_dYdZ, "dYdZ of the extrapolated track on the matched DT chamber");
 
     ev.put(std::move(tabMatches), "matches");
 
     auto tabStaMatches =
         std::make_unique<nanoaod::FlatTable>(sum(staMu_nMatchSeg), m_name + "_staMatches", false, false);
 
     tabStaMatches->setDoc("RECO muon staMatches_* vector");
 
     addColumn(tabStaMatches,
               "MuSegIdx",
               staMatches_MuSegIdx,
               "Index of DT segments used in the standalone track it corresponds"
               "<br />to the index of a given segment in the ntuple seg_* collection");
 
     ev.put(std::move(tabStaMatches), "staMatches");
   }
 }

◆ getFromES()

void MuDTMuonExtTableProducer::getFromES	(	const edm::Run &	run,
		const edm::EventSetup &	environment
	)

finalprotectedvirtual

Get info from the ES by run.

Reimplemented from MuBaseFlatTableProducer.

Definition at line 127 of file MuDTMuonExtTableProducer.cc.

References reco_calib_source_client_cfg::environment, nano_mu::ESTokenHandle< T, R, TR >::getFromES(), HLTConfigProvider::init(), m_dtGeometry, m_hltConfig, m_isoTrigIndices, m_isoTrigName, m_trigIndices, m_trigName, hltMonBTagIPClient_cfi::pathName, writedatasetfile::run, HLTConfigProvider::size(), simpleEdmComparison::tName, and HLTConfigProvider::triggerName().

                                                                                             {
   m_dtGeometry.getFromES(environment);
 
   bool changed{true};
   m_hltConfig.init(run, environment, "HLT", changed);
 
   const bool enableWildcard{true};
 
   TString tName = TString(m_trigName);
   TRegexp tNamePattern = TRegexp(tName, enableWildcard);
 
   for (unsigned iPath = 0; iPath < m_hltConfig.size(); ++iPath) {
     TString pathName = TString(m_hltConfig.triggerName(iPath));
     if (pathName.Contains(tNamePattern))
       m_trigIndices.push_back(static_cast<int>(iPath));
   }
 
   tName = TString(m_isoTrigName);
   tNamePattern = TRegexp(tName, enableWildcard);
 
   for (unsigned iPath = 0; iPath < m_hltConfig.size(); ++iPath) {
     TString pathName = TString(m_hltConfig.triggerName(iPath));
     if (pathName.Contains(tNamePattern))
       m_isoTrigIndices.push_back(static_cast<int>(iPath));
   }
 }

◆ hasTrigger()

bool MuDTMuonExtTableProducer::hasTrigger	(	std::vector< int > &	trigIndices,
		const trigger::TriggerObjectCollection &	trigObjs,
		edm::Handle< trigger::TriggerEvent > &	trigEvent,
		const reco::Muon &	muon
	)

private

Definition at line 365 of file MuDTMuonExtTableProducer.cc.

References PbPb_ZMuSkimMuonDPG_cff::deltaR, HGC3DClusterGenMatchSelector_cfi::dR, METSignificanceParams_cfi::dRMatch, spr::find(), relativeConstraints::keys, m_hltConfig, HLTConfigProvider::moduleLabels(), B2GTnPMonitor_cfi::trigEvent, and TriggerAnalyzer::trigObjs.

Referenced by fillTable().

                                                                 {
   float dRMatch = 999.;
   for (int trigIdx : trigIndices) {
     const std::vector<std::string> trigModuleLabels = m_hltConfig.moduleLabels(trigIdx);
 
     const unsigned trigModuleIndex =
         std::find(trigModuleLabels.begin(), trigModuleLabels.end(), "hltBoolEnd") - trigModuleLabels.begin() - 1;
     const unsigned hltFilterIndex = trigEvent->filterIndex(edm::InputTag(trigModuleLabels[trigModuleIndex], "", "HLT"));
     if (hltFilterIndex < trigEvent->sizeFilters()) {
       const trigger::Keys keys = trigEvent->filterKeys(hltFilterIndex);
       const trigger::Vids vids = trigEvent->filterIds(hltFilterIndex);
       const unsigned nTriggers = vids.size();
 
       for (unsigned iTrig = 0; iTrig < nTriggers; ++iTrig) {
         trigger::TriggerObject trigObj = trigObjs[keys[iTrig]];
         float dR = deltaR(muon, trigObj);
         if (dR < dRMatch)
           dRMatch = dR;
       }
     }
   }
 
   return dRMatch < 0.1;  //CB should become programmable
 }