#include <L2MuonIsolationProducer.h>

Inheritance diagram for L2MuonIsolationProducer:

Public Member Functions
	L2MuonIsolationProducer (const edm::ParameterSet &)
	constructor with config More...

void	produce (edm::Event &, const edm::EventSetup &) override
	Produce isolation maps. More...

	~L2MuonIsolationProducer () override
	destructor 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 &descriptions)
	ParameterSet descriptions. More...

Private Attributes
bool	optOutputDecision

bool	optOutputIsolatorFloat

std::unique_ptr < muonisolation::MuIsoBaseIsolator >	theDepositIsolator

std::unique_ptr < reco::isodeposit::IsoDepositExtractor >	theExtractor

edm::InputTag	theSACollectionLabel

edm::EDGetTokenT < reco::RecoChargedCandidateCollection >	theSACollectionToken

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

Author: J. Alcaraz

L2 HLT muon isolation producer

Author: J.Alcaraz

Definition at line 22 of file L2MuonIsolationProducer.h.

Constructor & Destructor Documentation

L2MuonIsolationProducer::L2MuonIsolationProducer ( const edm::ParameterSet & par )

constructor with config

Definition at line 36 of file L2MuonIsolationProducer.cc.

References edm::ParameterSet::empty(), get, edm::ParameterSet::getParameter(), LogDebug, optOutputDecision, optOutputIsolatorFloat, AlCaHLTBitMon_QueryRunRegistry::string, theDepositIsolator, theExtractor, theSACollectionLabel, and theSACollectionToken.

     : theSACollectionLabel(par.getParameter<edm::InputTag>("StandAloneCollectionLabel")) {
   LogDebug("Muon|RecoMuon|L2MuonIsolationProducer") << " L2MuonIsolationProducer constructor called";
 
   theSACollectionToken = consumes<RecoChargedCandidateCollection>(theSACollectionLabel);
 
   //
   // Extractor
   //
   edm::ParameterSet extractorPSet = par.getParameter<edm::ParameterSet>("ExtractorPSet");
   std::string extractorName = extractorPSet.getParameter<std::string>("ComponentName");
   theExtractor = std::unique_ptr<reco::isodeposit::IsoDepositExtractor>{
       IsoDepositExtractorFactory::get()->create(extractorName, extractorPSet, consumesCollector())};
 
   edm::ParameterSet isolatorPSet = par.getParameter<edm::ParameterSet>("IsolatorPSet");
   bool haveIsolator = !isolatorPSet.empty();
   optOutputDecision = haveIsolator;
   if (optOutputDecision) {
     std::string type = isolatorPSet.getParameter<std::string>("ComponentName");
     theDepositIsolator = std::unique_ptr<muonisolation::MuIsoBaseIsolator>{
         MuonIsolatorFactory::get()->create(type, isolatorPSet, consumesCollector())};
   }
   if (optOutputDecision)
     produces<edm::ValueMap<bool>>();
   produces<reco::IsoDepositMap>();
 
   optOutputIsolatorFloat = par.getParameter<bool>("WriteIsolatorFloat");
   if (optOutputIsolatorFloat && haveIsolator) {
     produces<edm::ValueMap<float>>();
   }
 }

L2MuonIsolationProducer::~L2MuonIsolationProducer ( )

override

destructor

Definition at line 69 of file L2MuonIsolationProducer.cc.

References LogDebug.

                                                   {
   LogDebug("Muon|RecoMuon|L2MuonIsolationProducer") << " L2MuonIsolationProducer destructor called";
 }

Member Function Documentation

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

static

ParameterSet descriptions.

Definition at line 74 of file L2MuonIsolationProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, AlCaHLTBitMon_QueryRunRegistry::string, and groupFilesInBlocks::temp.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>("StandAloneCollectionLabel", edm::InputTag("hltL2MuonCandidates"));
   edm::ParameterSetDescription extractorPSet;
   {
     extractorPSet.add<double>("DR_Veto_H", 0.1);
     extractorPSet.add<bool>("Vertex_Constraint_Z", false);
     extractorPSet.add<double>("Threshold_H", 0.5);
     extractorPSet.add<std::string>("ComponentName", "CaloExtractor");
     extractorPSet.add<double>("Threshold_E", 0.2);
     extractorPSet.add<double>("DR_Max", 1.0);
     extractorPSet.add<double>("DR_Veto_E", 0.07);
     extractorPSet.add<double>("Weight_E", 1.5);
     extractorPSet.add<bool>("Vertex_Constraint_XY", false);
     extractorPSet.addUntracked<std::string>("DepositLabel", "EcalPlusHcal");
     extractorPSet.add<edm::InputTag>("CaloTowerCollectionLabel", edm::InputTag("towerMaker"));
     extractorPSet.add<double>("Weight_H", 1.0);
   }
   desc.add<edm::ParameterSetDescription>("ExtractorPSet", extractorPSet);
   edm::ParameterSetDescription isolatorPSet;
   {
     std::vector<double> temp;
     isolatorPSet.add<std::vector<double>>("ConeSizesRel", std::vector<double>(1, 0.3));
     isolatorPSet.add<double>("EffAreaSFEndcap", 1.0);
     isolatorPSet.add<bool>("CutAbsoluteIso", true);
     isolatorPSet.add<bool>("AndOrCuts", true);
     isolatorPSet.add<edm::InputTag>("RhoSrc", edm::InputTag("hltKT6CaloJetsForMuons", "rho"));
     isolatorPSet.add<std::vector<double>>("ConeSizes", std::vector<double>(1, 0.3));
     isolatorPSet.add<std::string>("ComponentName", "CutsIsolatorWithCorrection");
     isolatorPSet.add<bool>("ReturnRelativeSum", false);
     isolatorPSet.add<double>("RhoScaleBarrel", 1.0);
     isolatorPSet.add<double>("EffAreaSFBarrel", 1.0);
     isolatorPSet.add<bool>("CutRelativeIso", false);
     isolatorPSet.add<std::vector<double>>("EtaBounds", std::vector<double>(1, 2.411));
     isolatorPSet.add<std::vector<double>>("Thresholds", std::vector<double>(1, 9.9999999E7));
     isolatorPSet.add<bool>("ReturnAbsoluteSum", true);
     isolatorPSet.add<std::vector<double>>("EtaBoundsRel", std::vector<double>(1, 2.411));
     isolatorPSet.add<std::vector<double>>("ThresholdsRel", std::vector<double>(1, 9.9999999E7));
     isolatorPSet.add<double>("RhoScaleEndcap", 1.0);
     isolatorPSet.add<double>("RhoMax", 9.9999999E7);
     isolatorPSet.add<bool>("UseRhoCorrection", true);
   }
   desc.add<edm::ParameterSetDescription>("IsolatorPSet", isolatorPSet);
   desc.add<bool>("WriteIsolatorFloat", false);
   descriptions.add("hltL2MuonIsolations", desc);
 }

void L2MuonIsolationProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	eventSetup
	)

override

Produce isolation maps.

build deposits

do the business of filling iso map

annoying – I will forget it at some point

Definition at line 122 of file L2MuonIsolationProducer.cc.

References symbols::deps, edm::helper::Filler< Map >::fill(), mps_fire::i, edm::helper::Filler< Map >::insert(), LogDebug, metname, eostools::move(), patZpeak::muons, optOutputDecision, optOutputIsolatorFloat, AlCaHLTBitMon_QueryRunRegistry::string, theDepositIsolator, theExtractor, theSACollectionLabel, theSACollectionToken, muonisolation::MuIsoBaseIsolator::Result::valBool, and muonisolation::MuIsoBaseIsolator::Result::valFloat.

                                                                                 {
   std::string metname = "Muon|RecoMuon|L2MuonIsolationProducer";
 
   LogDebug(metname) << " L2 Muon Isolation producing...";
 
   // Take the SA container
   LogDebug(metname) << " Taking the StandAlone muons: " << theSACollectionLabel;
   Handle<RecoChargedCandidateCollection> muons;
   event.getByToken(theSACollectionToken, muons);
 
   // Find deposits and load into event
   LogDebug(metname) << " Get energy around";
   auto depMap = std::make_unique<reco::IsoDepositMap>();
   auto isoMap = std::make_unique<edm::ValueMap<bool>>();
   auto isoFloatMap = std::make_unique<edm::ValueMap<float>>();
 
   unsigned int nMuons = muons->size();
   std::vector<IsoDeposit> deps(nMuons);
   std::vector<bool> isos(nMuons, false);
   std::vector<float> isoFloats(nMuons, 0);
 
   // fill track collection to use for vetos calculation
   TrackCollection muonTracks;
   for (unsigned int i = 0; i < nMuons; i++) {
     TrackRef tk = (*muons)[i].track();
     muonTracks.push_back(*tk);
   }
 
   theExtractor->fillVetos(event, eventSetup, muonTracks);
 
   for (unsigned int i = 0; i < nMuons; i++) {
     TrackRef tk = (*muons)[i].track();
 
     deps[i] = theExtractor->deposit(event, eventSetup, *tk);
 
     if (optOutputDecision) {
       muonisolation::MuIsoBaseIsolator::DepositContainer isoContainer(
           1, muonisolation::MuIsoBaseIsolator::DepositAndVetos(&deps[i]));
       muonisolation::MuIsoBaseIsolator::Result isoResult = theDepositIsolator->result(isoContainer, *tk, &event);
       isos[i] = isoResult.valBool;
       isoFloats[i] = isoResult.valFloat;
     }
   }
 
   reco::IsoDepositMap::Filler depFiller(*depMap);
   depFiller.insert(muons, deps.begin(), deps.end());
   depFiller.fill();
   event.put(std::move(depMap));
 
   if (optOutputDecision) {
     edm::ValueMap<bool>::Filler isoFiller(*isoMap);
     isoFiller.insert(muons, isos.begin(), isos.end());
     isoFiller.fill();  
     event.put(std::move(isoMap));
 
     if (optOutputIsolatorFloat) {
       edm::ValueMap<float>::Filler isoFloatFiller(*isoFloatMap);
       isoFloatFiller.insert(muons, isoFloats.begin(), isoFloats.end());
       isoFloatFiller.fill();  
       event.put(std::move(isoFloatMap));
     }
   }
 
   LogDebug(metname) << " Event loaded"
                     << "================================";
 }