Inheritance diagram for pat::HLTL1MuonMatcher:

Public Member Functions
	HLTL1MuonMatcher (const edm::ParameterSet &iConfig)

bool	operator() (const pat::TriggerObjectStandAlone &l1) const
	select L1s with patName_ and filterLabel_ (public, so it can be used by L1MuonMatcherAlgo) More...

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

	~HLTL1MuonMatcher () 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 Types
typedef pat::TriggerObjectStandAlone	PATPrimitive

typedef pat::TriggerObjectStandAloneCollection	PATPrimitiveCollection

typedef pat::TriggerObjectStandAloneMatch	PATTriggerAssociation

Private Member Functions
template<typename Hand , typename T >
void	storeExtraInfo (edm::Event &iEvent, const Hand &handle, const std::vector< T > &values, const std::string &label) const
	Store extra information in a ValueMap. More...

Private Attributes
edm::EDGetTokenT < PATPrimitiveCollection >	l1Token_

std::string	labelProp_
	Labels to set as filter names in the output. More...

std::vector< const pat::TriggerObjectStandAlone * >	lockedItems_

L1MuonMatcherAlgo	matcher_

edm::EDGetTokenT< edm::View < reco::Candidate > >	recoToken_
	Tokens for input collections. More...

bool	resolveAmbiguities_

StringCutObjectSelector < PATPrimitive >	selector_
	Select HLT objects. More...

bool	writeExtraInfo_
	Write out additional info as ValueMaps. More...

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 33 of file HLTL1MuonMatcher.cc.

Member Typedef Documentation

typedef pat::TriggerObjectStandAlone pat::HLTL1MuonMatcher::PATPrimitive

private

Definition at line 48 of file HLTL1MuonMatcher.cc.

typedef pat::TriggerObjectStandAloneCollection pat::HLTL1MuonMatcher::PATPrimitiveCollection

private

Definition at line 49 of file HLTL1MuonMatcher.cc.

typedef pat::TriggerObjectStandAloneMatch pat::HLTL1MuonMatcher::PATTriggerAssociation

private

Definition at line 50 of file HLTL1MuonMatcher.cc.

Constructor & Destructor Documentation

pat::HLTL1MuonMatcher::HLTL1MuonMatcher ( const edm::ParameterSet & iConfig )

explicit

Definition at line 81 of file HLTL1MuonMatcher.cc.

References edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), labelProp_, resolveAmbiguities_, AlCaHLTBitMon_QueryRunRegistry::string, and writeExtraInfo_.

     : matcher_(iConfig, consumesCollector()),
       recoToken_(consumes<edm::View<reco::Candidate> >(iConfig.getParameter<edm::InputTag>("src"))),
       l1Token_(consumes<PATPrimitiveCollection>(iConfig.getParameter<edm::InputTag>("matched"))),
       selector_{iConfig.getParameter<std::string>("matchedCuts")},
       resolveAmbiguities_(iConfig.getParameter<bool>("resolveAmbiguities")),
       labelProp_(iConfig.getParameter<std::string>("setPropLabel")),
       writeExtraInfo_(iConfig.existsAs<bool>("writeExtraInfo") ? iConfig.getParameter<bool>("writeExtraInfo") : false) {
   produces<PATPrimitiveCollection>("propagatedReco");  // reco to muon station 2
   produces<PATTriggerAssociation>("propagatedReco");   // asso reco to propagated reco
   produces<PATTriggerAssociation>();                   // asso reco to l1
   if (writeExtraInfo_) {
     produces<edm::ValueMap<float> >("deltaR");
     produces<edm::ValueMap<float> >("deltaPhi");
   }
 }

pat::HLTL1MuonMatcher::~HLTL1MuonMatcher ( )

inlineoverride

Definition at line 36 of file HLTL1MuonMatcher.cc.

36 {}

Member Function Documentation

bool pat::HLTL1MuonMatcher::operator() ( const pat::TriggerObjectStandAlone & l1 ) const

inline

select L1s with patName_ and filterLabel_ (public, so it can be used by L1MuonMatcherAlgo)

Definition at line 41 of file HLTL1MuonMatcher.cc.

References spr::find(), lockedItems_, resolveAmbiguities_, and selector_.

                                                                 {
       if (resolveAmbiguities_ && (std::find(lockedItems_.begin(), lockedItems_.end(), &l1) != lockedItems_.end()))
         return false;
       return selector_(l1);
     }

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

override

Definition at line 98 of file HLTL1MuonMatcher.cc.

References reco::Candidate::charge(), HLT_FULL_cff::deltaPhis, PV3DBase< T, PVType, FrameType >::eta(), edm::helper::Filler< Map >::fill(), edm::Event::getByToken(), TrajectoryStateOnSurface::globalPosition(), mps_fire::i, L1MuonMatcherAlgo::init(), edm::helper::Filler< Map >::insert(), TrajectoryStateOnSurface::isValid(), L1Scalers_cfi::l1s, l1Token_, labelProp_, lockedItems_, reco::Candidate::mass(), match(), matcher_, L1MuonMatcherAlgo::matchGeneric(), eostools::move(), RPCpg::mu, dqmiodumpmetadata::n, PV3DBase< T, PVType, FrameType >::phi(), reco::Candidate::pt(), edm::Event::put(), dt_dqm_sourceclient_common_cff::reco, recoToken_, storeExtraInfo(), and writeExtraInfo_.

                                                                                {
   using namespace edm;
   using namespace std;
 
   matcher_.init(iSetup);
 
   Handle<View<reco::Candidate> > reco;
   Handle<PATPrimitiveCollection> l1s;
 
   iEvent.getByToken(recoToken_, reco);
   iEvent.getByToken(l1Token_, l1s);
 
   unique_ptr<PATPrimitiveCollection> propOut(new PATPrimitiveCollection());
   vector<int> propMatches(reco->size(), -1);
   vector<int> fullMatches(reco->size(), -1);
   vector<float> deltaRs(reco->size(), 999), deltaPhis(reco->size(), 999);
   lockedItems_.clear();
   for (int i = 0, n = reco->size(); i < n; ++i) {
     TrajectoryStateOnSurface propagated;
     const reco::Candidate &mu = (*reco)[i];
     int match = matcher_.matchGeneric(mu, *l1s, *this, deltaRs[i], deltaPhis[i], propagated);
     if (propagated.isValid()) {
       GlobalPoint pos = propagated.globalPosition();
       propMatches[i] = propOut->size();
       propOut->push_back(PATPrimitive(math::PtEtaPhiMLorentzVector(mu.pt(), pos.eta(), pos.phi(), mu.mass())));
       propOut->back().addFilterLabel(labelProp_);
       propOut->back().setCharge(mu.charge());
     }
     fullMatches[i] = match;
     if (match != -1) {
       lockedItems_.push_back(&(*l1s)[match]);
     }
   }
   lockedItems_.clear();
 
   OrphanHandle<PATPrimitiveCollection> propDone = iEvent.put(std::move(propOut), "propagatedReco");
 
   unique_ptr<PATTriggerAssociation> propAss(new PATTriggerAssociation(propDone));
   PATTriggerAssociation::Filler propFiller(*propAss);
   propFiller.insert(reco, propMatches.begin(), propMatches.end());
   propFiller.fill();
   iEvent.put(std::move(propAss), "propagatedReco");
 
   unique_ptr<PATTriggerAssociation> fullAss(new PATTriggerAssociation(l1s));
   PATTriggerAssociation::Filler fullFiller(*fullAss);
   fullFiller.insert(reco, fullMatches.begin(), fullMatches.end());
   fullFiller.fill();
   iEvent.put(std::move(fullAss));
 
   if (writeExtraInfo_) {
     storeExtraInfo(iEvent, reco, deltaRs, "deltaR");
     storeExtraInfo(iEvent, reco, deltaPhis, "deltaPhi");
   }
 }

template<typename Hand , typename T >

void pat::HLTL1MuonMatcher::storeExtraInfo	(	edm::Event &	iEvent,
		const Hand &	handle,
		const std::vector< T > &	values,
		const std::string &	label
	)		const

private

Store extra information in a ValueMap.

Definition at line 154 of file HLTL1MuonMatcher.cc.

References edm::helper::Filler< Map >::fill(), edm::helper::Filler< Map >::insert(), eostools::move(), and edm::Event::put().

Referenced by produce().

                                                                          {
   using namespace edm;
   using namespace std;
   unique_ptr<ValueMap<T> > valMap(new ValueMap<T>());
   typename edm::ValueMap<T>::Filler filler(*valMap);
   filler.insert(handle, values.begin(), values.end());
   filler.fill();
   iEvent.put(std::move(valMap), label);
 }