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 34 of file L3MuonProducer.cc.

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

34  {
35  LogTrace("L3MuonProducer") << "constructor called" << endl;
36 
37  // Parameter set for the Builder
38  ParameterSet trajectoryBuilderParameters = parameterSet.getParameter<ParameterSet>("L3TrajBuilderParameters");
39 
40  // L2 Muon Collection Label
41  theL2CollectionLabel = parameterSet.getParameter<InputTag>("MuonCollectionLabel");
42  l2MuonToken_ = consumes<reco::TrackCollection>(theL2CollectionLabel);
43  l2MuonTrajToken_ = consumes<std::vector<Trajectory>>(theL2CollectionLabel.label());
44  l2AssoMapToken_ = consumes<TrajTrackAssociationCollection>(theL2CollectionLabel.label());
45  updatedL2AssoMapToken_ = consumes<reco::TrackToTrackMap>(theL2CollectionLabel.label());
46 
47  // service parameters
48  ParameterSet serviceParameters = parameterSet.getParameter<ParameterSet>("ServiceParameters");
49 
50  // TrackLoader parameters
51  ParameterSet trackLoaderParameters = parameterSet.getParameter<ParameterSet>("TrackLoaderParameters");
52 
53  // the services
54  theService = std::make_unique<MuonServiceProxy>(serviceParameters, consumesCollector());
55  ConsumesCollector iC = consumesCollector();
56 
57  // instantiate the concrete trajectory builder in the Track Finder
58  auto mtl = std::make_unique<MuonTrackLoader>(trackLoaderParameters, iC, theService.get());
59  auto l3mtb = std::make_unique<L3MuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
60  theTrackFinder = std::make_unique<MuonTrackFinder>(std::move(l3mtb), std::move(mtl), iC);
61 
62  theL2SeededTkLabel =
63  trackLoaderParameters.getUntrackedParameter<std::string>("MuonSeededTracksInstance", std::string());
64 
65  produces<TrackingRecHitCollection>(theL2SeededTkLabel);
66  produces<reco::TrackExtraCollection>(theL2SeededTkLabel);
67  // TrackCollection refers to TrackingRechit and TrackExtra
68  // collections, need to declare its production after them to work
69  // around a rare race condition in framework scheduling
70  produces<reco::TrackCollection>(theL2SeededTkLabel);
71  produces<vector<Trajectory>>(theL2SeededTkLabel);
72  produces<TrajTrackAssociationCollection>(theL2SeededTkLabel);
73 
74  produces<TrackingRecHitCollection>();
75  produces<reco::TrackExtraCollection>();
76  // TrackCollection refers to TrackingRechit and TrackExtra
77  // collections, need to declare its production after them to work
78  // around a rare race condition in framework scheduling
79  produces<reco::TrackCollection>();
80  produces<vector<Trajectory>>();
81  produces<TrajTrackAssociationCollection>();
82 
83  produces<reco::MuonTrackLinksCollection>();
84 }
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:307
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:242
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 89 of file L3MuonProducer.cc.

References LogTrace.

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

Member Function Documentation

◆ fillDescriptions()

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

Definition at line 149 of file L3MuonProducer.cc.

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

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

94  {
95  const string metname = "Muon|RecoMuon|L3MuonProducer";
96  LogTrace(metname) << endl << endl << endl;
97  LogTrace(metname) << "L3 Muon Reconstruction started" << endl;
98 
99  typedef vector<Trajectory> TrajColl;
100 
101  // Update the services
102  theService->update(eventSetup);
103 
104  // Take the L2 muon container(s)
105  LogTrace(metname) << "Taking the L2 Muons " << theL2CollectionLabel << endl;
106 
107  Handle<reco::TrackCollection> L2Muons;
108  event.getByToken(l2MuonToken_, L2Muons);
109 
110  Handle<vector<Trajectory>> L2MuonsTraj;
111  vector<MuonTrajectoryBuilder::TrackCand> L2TrackCands;
112 
113  event.getByToken(l2MuonTrajToken_, L2MuonsTraj);
114 
115  edm::Handle<TrajTrackAssociationCollection> L2AssoMap;
116  event.getByToken(l2AssoMapToken_, L2AssoMap);
117 
118  edm::Handle<reco::TrackToTrackMap> updatedL2AssoMap;
119  event.getByToken(updatedL2AssoMapToken_, updatedL2AssoMap);
120 
121  for (TrajTrackAssociationCollection::const_iterator it = L2AssoMap->begin(); it != L2AssoMap->end(); ++it) {
122  const Ref<vector<Trajectory>> traj = it->key;
123  const reco::TrackRef tkRegular = it->val;
124  reco::TrackRef tkUpdated;
125  reco::TrackToTrackMap::const_iterator iEnd;
126  reco::TrackToTrackMap::const_iterator iii;
127  if (theL2CollectionLabel.instance() == "UpdatedAtVtx") {
128  iEnd = updatedL2AssoMap->end();
129  iii = updatedL2AssoMap->find(it->val);
130  if (iii != iEnd)
131  tkUpdated = (*updatedL2AssoMap)[it->val];
132  }
133 
134  const reco::TrackRef tk = (tkUpdated.isNonnull()) ? tkUpdated : tkRegular;
135 
136  MuonTrajectoryBuilder::TrackCand L2Cand = MuonTrajectoryBuilder::TrackCand((Trajectory*)nullptr, tk);
137  if (traj->isValid())
138  L2Cand.first = &*traj;
139  L2TrackCands.push_back(L2Cand);
140  }
141 
142  theTrackFinder->reconstruct(L2TrackCands, event, eventSetup);
143 
144  LogTrace(metname) << "Event loaded"
145  << "================================" << endl
146  << endl;
147 }
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:242
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:11
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