CMS 3D CMS Logo
List of all members | Public Member Functions | Static Public Member Functions | Private Attributes
L3MuonProducer Class Reference

#include <L3MuonProducer.h>

Inheritance diagram for L3MuonProducer:
edm::stream::EDProducer<>

Public Member Functions

 L3MuonProducer (const edm::ParameterSet &)
 constructor with config More...
 
void produce (edm::Event &, const edm::EventSetup &) override
 reconstruct muons More...
 
 ~L3MuonProducer () 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)
 

Private Attributes

edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
 
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
 
edm::EDGetTokenT< std::vector< Trajectory > > l2MuonTrajToken_
 
edm::InputTag theL2CollectionLabel
 Seed STA Label. More...
 
std::string theL2SeededTkLabel
 Label for L2SeededTracks. More...
 
std::unique_ptr< MuonServiceProxy > theService
 the event setup proxy, it takes care the services update More...
 
std::unique_ptr< MuonTrackFinder > theTrackFinder
 
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
 

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

L3 muon reconstructor: reconstructs muons using DT, CSC, RPC and tracker information,
starting from a L2 reonstructed muon.

Author
A. Everett - Purdue University

Definition at line 36 of file L3MuonProducer.h.

Constructor & Destructor Documentation

◆ L3MuonProducer()

L3MuonProducer::L3MuonProducer ( const edm::ParameterSet &  parameterSet)

constructor with config

Definition at line 35 of file L3MuonProducer.cc.

References edm::ParameterSet::getParameter(), LogTrace, eostools::move(), edm::parameterSet(), and AlCaHLTBitMon_QueryRunRegistry::string.

35  {
36  LogTrace("L3MuonProducer") << "constructor called" << endl;
37 
38  // Parameter set for the Builder
39  ParameterSet trajectoryBuilderParameters = parameterSet.getParameter<ParameterSet>("L3TrajBuilderParameters");
40 
41  // L2 Muon Collection Label
42  theL2CollectionLabel = parameterSet.getParameter<InputTag>("MuonCollectionLabel");
43  l2MuonToken_ = consumes<reco::TrackCollection>(theL2CollectionLabel);
44  l2MuonTrajToken_ = consumes<std::vector<Trajectory>>(theL2CollectionLabel.label());
45  l2AssoMapToken_ = consumes<TrajTrackAssociationCollection>(theL2CollectionLabel.label());
46  updatedL2AssoMapToken_ = consumes<reco::TrackToTrackMap>(theL2CollectionLabel.label());
47 
48  // service parameters
49  ParameterSet serviceParameters = parameterSet.getParameter<ParameterSet>("ServiceParameters");
50 
51  // TrackLoader parameters
52  ParameterSet trackLoaderParameters = parameterSet.getParameter<ParameterSet>("TrackLoaderParameters");
53 
54  // the services
55  theService = std::make_unique<MuonServiceProxy>(serviceParameters, consumesCollector());
56  ConsumesCollector iC = consumesCollector();
57 
58  // instantiate the concrete trajectory builder in the Track Finder
59  auto mtl = std::make_unique<MuonTrackLoader>(trackLoaderParameters, iC, theService.get());
60  auto l3mtb = std::make_unique<L3MuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
61  theTrackFinder = std::make_unique<MuonTrackFinder>(std::move(l3mtb), std::move(mtl), iC);
62 
63  theL2SeededTkLabel =
64  trackLoaderParameters.getUntrackedParameter<std::string>("MuonSeededTracksInstance", std::string());
65 
66  produces<reco::TrackCollection>(theL2SeededTkLabel);
67  produces<TrackingRecHitCollection>(theL2SeededTkLabel);
68  produces<reco::TrackExtraCollection>(theL2SeededTkLabel);
69  produces<vector<Trajectory>>(theL2SeededTkLabel);
70  produces<TrajTrackAssociationCollection>(theL2SeededTkLabel);
71 
72  produces<reco::TrackCollection>();
73  produces<TrackingRecHitCollection>();
74  produces<reco::TrackExtraCollection>();
75  produces<vector<Trajectory>>();
76  produces<TrajTrackAssociationCollection>();
77 
78  produces<reco::MuonTrackLinksCollection>();
79 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
L3MuonProducer::updatedL2AssoMapToken_
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
Definition: L3MuonProducer.h:58
L3MuonProducer::l2MuonToken_
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
Definition: L3MuonProducer.h:55
L3MuonProducer::theService
std::unique_ptr< MuonServiceProxy > theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:63
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
L3MuonProducer::l2MuonTrajToken_
edm::EDGetTokenT< std::vector< Trajectory > > l2MuonTrajToken_
Definition: L3MuonProducer.h:56
edm::parameterSet
ParameterSet const & parameterSet(StableProvenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
L3MuonProducer::theTrackFinder
std::unique_ptr< MuonTrackFinder > theTrackFinder
Definition: L3MuonProducer.h:60
L3MuonProducer::l2AssoMapToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
Definition: L3MuonProducer.h:57
L3MuonProducer::theL2CollectionLabel
edm::InputTag theL2CollectionLabel
Seed STA Label.
Definition: L3MuonProducer.h:50
L3MuonProducer::theL2SeededTkLabel
std::string theL2SeededTkLabel
Label for L2SeededTracks.
Definition: L3MuonProducer.h:53
eostools.move
def move(src, dest)
Definition: eostools.py:511

◆ ~L3MuonProducer()

L3MuonProducer::~L3MuonProducer ( )
override

destructor

Definition at line 84 of file L3MuonProducer.cc.

References LogTrace.

84 { LogTrace("L3MuonProducer") << "destructor called" << endl; }
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234

Member Function Documentation

◆ fillDescriptions()

void L3MuonProducer::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions)
static

Definition at line 144 of file L3MuonProducer.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::add(), edm::ParameterSetDescription::addUntracked(), submitPVResolutionJobs::desc, TrackTransformer::fillPSetDescription(), HLT_2022v11_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

144  {
145  edm::ParameterSetDescription desc;
146  {
147  edm::ParameterSetDescription psd0;
148  psd0.addUntracked<std::vector<std::string>>("Propagators",
149  {
150  "hltESPSmartPropagatorAny",
151  "SteppingHelixPropagatorAny",
152  "hltESPSmartPropagator",
153  "hltESPSteppingHelixPropagatorOpposite",
154  });
155  psd0.add<bool>("RPCLayers", true);
156  psd0.addUntracked<bool>("UseMuonNavigation", true);
157  desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);
158  }
159  desc.add<edm::InputTag>("MuonCollectionLabel", edm::InputTag("hltL2Muons", "UpdatedAtVtx"));
160  {
161  edm::ParameterSetDescription psd0;
162  psd0.addUntracked<bool>("PutTkTrackIntoEvent", false);
163  psd0.add<std::string>("TTRHBuilder", "hltESPTTRHBWithTrackAngle");
164  psd0.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
165  psd0.addUntracked<bool>("SmoothTkTrack", false);
166  psd0.addUntracked<std::string>("MuonSeededTracksInstance", "L2Seeded");
167  psd0.add<std::string>("Smoother", "hltESPKFTrajectorySmootherForMuonTrackLoader");
168  {
169  edm::ParameterSetDescription psd1;
170  psd1.add<double>("MaxChi2", 1000000.0);
171  psd1.add<std::string>("Propagator", "hltESPSteppingHelixPropagatorOpposite");
172  psd1.add<std::vector<double>>("BeamSpotPositionErrors",
173  {
174  0.1,
175  0.1,
176  5.3,
177  });
178  psd0.add<edm::ParameterSetDescription>("MuonUpdatorAtVertexParameters", psd1);
179  }
180  psd0.add<bool>("VertexConstraint", false);
181  psd0.add<bool>("DoSmoothing", false);
182  desc.add<edm::ParameterSetDescription>("TrackLoaderParameters", psd0);
183  }
184  {
185  edm::ParameterSetDescription psd0;
186  psd0.add<double>("ScaleTECyFactor", -1.0);
187  psd0.add<edm::InputTag>("tkTrajVertex", edm::InputTag("hltPixelVertices"));
188  psd0.add<bool>("tkTrajUseVertex", false);
189  {
190  edm::ParameterSetDescription psd1;
191  psd1.add<int>("TrackerSkipSection", -1);
192  psd1.add<bool>("DoPredictionsOnly", false);
193  psd1.add<bool>("PropDirForCosmics", false);
194  psd1.add<int>("HitThreshold", 1);
195  psd1.add<int>("MuonHitsOption", 1);
196  psd1.add<bool>("RefitFlag", true);
197  psd1.add<std::string>("Fitter", "hltESPL3MuKFTrajectoryFitter");
198  psd1.add<int>("SkipStation", -1);
199  psd1.add<std::string>("TrackerRecHitBuilder", "hltESPTTRHBWithTrackAngle");
200  psd1.add<double>("Chi2CutRPC", 1.0);
201  psd1.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
202  psd1.add<std::string>("RefitDirection", "insideOut");
203  psd1.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("hltCscSegments"));
204  psd1.add<edm::InputTag>("GEMRecHitLabel", edm::InputTag("gemRecHits"));
205  psd1.add<edm::InputTag>("ME0RecHitLabel", edm::InputTag("me0Segments"));
206  psd1.add<std::vector<int>>("DYTthrs",
207  {
208  30,
209  15,
210  });
211  psd1.add<int>("DYTselector", 1);
212  psd1.add<bool>("DYTupdator", false);
213  psd1.add<bool>("DYTuseAPE", false);
214  psd1.add<bool>("DYTuseThrsParametrization", true);
215  {
216  edm::ParameterSetDescription psd2;
217  psd2.add<std::vector<double>>("eta0p8", {1, -0.919853, 0.990742});
218  psd2.add<std::vector<double>>("eta1p2", {1, -0.897354, 0.987738});
219  psd2.add<std::vector<double>>("eta2p0", {1, -0.986855, 0.998516});
220  psd2.add<std::vector<double>>("eta2p2", {1, -0.940342, 0.992955});
221  psd2.add<std::vector<double>>("eta2p4", {1, -0.947633, 0.993762});
222  psd1.add<edm::ParameterSetDescription>("DYTthrsParameters", psd2);
223  }
224  psd1.add<double>("Chi2CutCSC", 150.0);
225  psd1.add<double>("Chi2CutDT", 10.0);
226  psd1.add<double>("Chi2CutGEM", 1.0);
227  psd1.add<double>("Chi2CutME0", 1.0);
228  psd1.add<bool>("RefitRPCHits", true);
229  psd1.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("hltDt4DSegments"));
230  psd1.add<std::string>("Propagator", "hltESPSmartPropagatorAny");
231  psd1.add<int>("TrackerSkipSystem", -1);
232  psd0.add<edm::ParameterSetDescription>("GlbRefitterParameters", psd1);
233  }
234  psd0.add<double>("tkTrajMaxChi2", 9999.0);
235  psd0.add<double>("ScaleTECxFactor", -1.0);
236  psd0.add<std::string>("TrackerRecHitBuilder", "hltESPTTRHBWithTrackAngle");
237  psd0.add<edm::InputTag>("tkTrajBeamSpot", edm::InputTag("hltOnlineBeamSpot"));
238  psd0.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
239  psd0.add<double>("tkTrajMaxDXYBeamSpot", 9999.0);
240  psd0.add<std::string>("TrackerPropagator", "SteppingHelixPropagatorAny");
241  {
242  edm::ParameterSetDescription psd1;
243  psd1.add<bool>("precise", true);
244  psd1.add<bool>("Eta_fixed", true);
245  psd1.add<double>("Eta_min", 0.1);
246  psd1.add<bool>("Z_fixed", false);
247  psd1.add<edm::InputTag>("MeasurementTrackerName", edm::InputTag("hltESPMeasurementTracker"));
248  psd1.add<int>("maxRegions", 2);
249  psd1.add<double>("Pt_min", 3.0);
250  psd1.add<double>("Rescale_Dz", 4.0);
251  psd1.add<double>("PhiR_UpperLimit_Par1", 0.6);
252  psd1.add<double>("PhiR_UpperLimit_Par2", 0.2);
253  psd1.add<edm::InputTag>("vertexCollection", edm::InputTag("pixelVertices"));
254  psd1.add<bool>("Phi_fixed", true);
255  psd1.add<edm::InputTag>("input", edm::InputTag("hltL2Muons", "UpdatedAtVtx"));
256  psd1.add<double>("DeltaR", 0.025);
257  psd1.add<int>("OnDemand", -1);
258  psd1.add<double>("DeltaZ", 24.2);
259  psd1.add<double>("Rescale_phi", 3.0);
260  psd1.add<double>("Rescale_eta", 3.0);
261  psd1.add<double>("DeltaEta", 0.04);
262  psd1.add<double>("DeltaPhi", 0.15);
263  psd1.add<double>("Phi_min", 0.1);
264  psd1.add<bool>("UseVertex", false);
265  psd1.add<double>("EtaR_UpperLimit_Par1", 0.25);
266  psd1.add<double>("EtaR_UpperLimit_Par2", 0.15);
267  psd1.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
268  psd1.add<bool>("Pt_fixed", false);
269  psd0.add<edm::ParameterSetDescription>("MuonTrackingRegionBuilder", psd1);
270  }
271  psd0.add<bool>("RefitRPCHits", true);
272  psd0.add<double>("PCut", 2.5);
273  {
274  edm::ParameterSetDescription psd1;
275  TrackTransformer::fillPSetDescription(psd1,
276  false, // do predictions only
277  "hltESPL3MuKFTrajectoryFitter", // fitter
278  "hltESPKFTrajectorySmootherForMuonTrackLoader", // smoother
279  "hltESPSmartPropagatorAny", // propagator
280  "insideOut", // refit direction
281  true, // refit rpc hits
282  "hltESPTTRHBWithTrackAngle", // tracker rechit builder
283  "hltESPMuonTransientTrackingRecHitBuilder" // muon rechit builder
284  );
285  psd0.add<edm::ParameterSetDescription>("TrackTransformer", psd1);
286  }
287  {
288  edm::ParameterSetDescription psd1;
289  psd1.add<double>("Quality_3", 7.0);
290  psd1.add<double>("DeltaRCut_1", 0.1);
291  psd1.add<double>("MinP", 2.5);
292  psd1.add<double>("MinPt", 1.0);
293  psd1.add<double>("Quality_2", 15.0);
294  psd1.add<double>("Pt_threshold2", 999999999.0);
295  psd1.add<double>("LocChi2Cut", 0.001);
296  psd1.add<double>("Eta_threshold", 1.2);
297  psd1.add<double>("Pt_threshold1", 0.0);
298  psd1.add<double>("Chi2Cut_1", 50.0);
299  psd1.add<double>("Quality_1", 20.0);
300  psd1.add<double>("Chi2Cut_3", 200.0);
301  psd1.add<double>("DeltaRCut_3", 1.0);
302  psd1.add<double>("DeltaRCut_2", 0.2);
303  psd1.add<double>("DeltaDCut_1", 40.0);
304  psd1.add<double>("DeltaDCut_2", 10.0);
305  psd1.add<double>("DeltaDCut_3", 15.0);
306  psd1.add<double>("Chi2Cut_2", 50.0);
307  psd1.add<std::string>("Propagator", "hltESPSmartPropagator");
308  psd0.add<edm::ParameterSetDescription>("GlobalMuonTrackMatcher", psd1);
309  }
310  psd0.add<double>("PtCut", 1.0);
311  psd0.add<bool>("matchToSeeds", true);
312  psd0.add<edm::InputTag>("tkTrajLabel", edm::InputTag("hltBRSMuonSeededTracksOutIn"));
313  desc.add<edm::ParameterSetDescription>("L3TrajBuilderParameters", psd0);
314  }
315  descriptions.add("L3MuonProducer", desc);
316 }
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
HLT_2022v11_cff.InputTag
InputTag
Definition: HLT_2022v11_cff.py:64808
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
TrackTransformer::fillPSetDescription
static void fillPSetDescription(edm::ParameterSetDescription &descriptions, bool doPredictionsOnly=false, const std::string &fitter="KFFitterForRefitInsideOut", const std::string &smoother="KFSmootherForRefitInsideOut", const std::string &propagator="SmartPropagatorAnyRK", const std::string &refitDirection="alongMomentum", bool refitRPCHits=true, const std::string &trackerRecHitBuilder="WithTrackAngle", const std::string &muonRecHitBuilder="MuonRecHitBuilder", const std::string &mtdRecHitBuilder="MTDRecHitBuilder")
fillDescriptions
Definition: TrackTransformer.cc:55

◆ produce()

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

reconstruct muons

Definition at line 89 of file L3MuonProducer.cc.

References edm::AssociationMap< Tag >::begin(), edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator, edm::AssociationMap< Tag >::end(), options_cfi::eventSetup, edm::AssociationMap< Tag >::find(), edm::Ref< C, T, F >::isNonnull(), edm::Ref< C, T, F >::key(), L2Muons_cfi::L2Muons, LogTrace, and metname.

89  {
90  const string metname = "Muon|RecoMuon|L3MuonProducer";
91  LogTrace(metname) << endl << endl << endl;
92  LogTrace(metname) << "L3 Muon Reconstruction started" << endl;
93 
94  typedef vector<Trajectory> TrajColl;
95 
96  // Update the services
97  theService->update(eventSetup);
98 
99  // Take the L2 muon container(s)
100  LogTrace(metname) << "Taking the L2 Muons " << theL2CollectionLabel << endl;
101 
102  Handle<reco::TrackCollection> L2Muons;
103  event.getByToken(l2MuonToken_, L2Muons);
104 
105  Handle<vector<Trajectory>> L2MuonsTraj;
106  vector<MuonTrajectoryBuilder::TrackCand> L2TrackCands;
107 
108  event.getByToken(l2MuonTrajToken_, L2MuonsTraj);
109 
110  edm::Handle<TrajTrackAssociationCollection> L2AssoMap;
111  event.getByToken(l2AssoMapToken_, L2AssoMap);
112 
113  edm::Handle<reco::TrackToTrackMap> updatedL2AssoMap;
114  event.getByToken(updatedL2AssoMapToken_, updatedL2AssoMap);
115 
116  for (TrajTrackAssociationCollection::const_iterator it = L2AssoMap->begin(); it != L2AssoMap->end(); ++it) {
117  const Ref<vector<Trajectory>> traj = it->key;
118  const reco::TrackRef tkRegular = it->val;
119  reco::TrackRef tkUpdated;
120  reco::TrackToTrackMap::const_iterator iEnd;
121  reco::TrackToTrackMap::const_iterator iii;
122  if (theL2CollectionLabel.instance() == "UpdatedAtVtx") {
123  iEnd = updatedL2AssoMap->end();
124  iii = updatedL2AssoMap->find(it->val);
125  if (iii != iEnd)
126  tkUpdated = (*updatedL2AssoMap)[it->val];
127  }
128 
129  const reco::TrackRef tk = (tkUpdated.isNonnull()) ? tkUpdated : tkRegular;
130 
131  MuonTrajectoryBuilder::TrackCand L2Cand = MuonTrajectoryBuilder::TrackCand((Trajectory*)nullptr, tk);
132  if (traj->isValid())
133  L2Cand.first = &*traj;
134  L2TrackCands.push_back(L2Cand);
135  }
136 
137  theTrackFinder->reconstruct(L2TrackCands, event, eventSetup);
138 
139  LogTrace(metname) << "Event loaded"
140  << "================================" << endl
141  << endl;
142 }
L3MuonProducer::updatedL2AssoMapToken_
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
Definition: L3MuonProducer.h:58
MuonTrajectoryBuilder::TrackCand
std::pair< const Trajectory *, reco::TrackRef > TrackCand
Definition: MuonTrajectoryBuilder.h:25
L3MuonProducer::l2MuonToken_
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
Definition: L3MuonProducer.h:55
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:40
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37
edm::AssociationMap::const_iterator
const iterator
Definition: AssociationMap.h:78
L3MuonProducer::theService
std::unique_ptr< MuonServiceProxy > theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:63
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
L3MuonProducer::l2MuonTrajToken_
edm::EDGetTokenT< std::vector< Trajectory > > l2MuonTrajToken_
Definition: L3MuonProducer.h:56
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:175
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:173
L3MuonProducer::theTrackFinder
std::unique_ptr< MuonTrackFinder > theTrackFinder
Definition: L3MuonProducer.h:60
L2Muons_cfi.L2Muons
L2Muons
Definition: L2Muons_cfi.py:7
L3MuonProducer::l2AssoMapToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
Definition: L3MuonProducer.h:57
L3MuonProducer::theL2CollectionLabel
edm::InputTag theL2CollectionLabel
Seed STA Label.
Definition: L3MuonProducer.h:50
edm::AssociationMap::begin
const_iterator begin() const
first iterator over the map (read only)
Definition: AssociationMap.h:171
options_cfi.eventSetup
eventSetup
Definition: options_cfi.py:12
event
Definition: event.py:1

Member Data Documentation

◆ l2AssoMapToken_

edm::EDGetTokenT<TrajTrackAssociationCollection> L3MuonProducer::l2AssoMapToken_
private

Definition at line 57 of file L3MuonProducer.h.

◆ l2MuonToken_

edm::EDGetTokenT<reco::TrackCollection> L3MuonProducer::l2MuonToken_
private

Definition at line 55 of file L3MuonProducer.h.

◆ l2MuonTrajToken_

edm::EDGetTokenT<std::vector<Trajectory> > L3MuonProducer::l2MuonTrajToken_
private

Definition at line 56 of file L3MuonProducer.h.

◆ theL2CollectionLabel

edm::InputTag L3MuonProducer::theL2CollectionLabel
private

Seed STA Label.

Definition at line 50 of file L3MuonProducer.h.

◆ theL2SeededTkLabel

std::string L3MuonProducer::theL2SeededTkLabel
private

Label for L2SeededTracks.

Definition at line 53 of file L3MuonProducer.h.

◆ theService

std::unique_ptr<MuonServiceProxy> L3MuonProducer::theService
private

the event setup proxy, it takes care the services update

Definition at line 63 of file L3MuonProducer.h.

◆ theTrackFinder

std::unique_ptr<MuonTrackFinder> L3MuonProducer::theTrackFinder
private

Definition at line 60 of file L3MuonProducer.h.

◆ updatedL2AssoMapToken_

edm::EDGetTokenT<reco::TrackToTrackMap> L3MuonProducer::updatedL2AssoMapToken_
private

Definition at line 58 of file L3MuonProducer.h.

Generated for CMSSW Reference Manual by doxygen 1.8.14