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
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginProcessBlocks () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndProcessBlocks () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

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<>
typedef CacheContexts< T... > CacheTypes
 
typedef CacheTypes::GlobalCache GlobalCache
 
typedef AbilityChecker< T... > HasAbility
 
typedef CacheTypes::LuminosityBlockCache LuminosityBlockCache
 
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache > LuminosityBlockContext
 
typedef CacheTypes::LuminosityBlockSummaryCache LuminosityBlockSummaryCache
 
typedef CacheTypes::RunCache RunCache
 
typedef RunContextT< RunCache, GlobalCache > RunContext
 
typedef CacheTypes::RunSummaryCache 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.

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 }

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

◆ ~L3MuonProducer()

L3MuonProducer::~L3MuonProducer ( )
override

destructor

Definition at line 84 of file L3MuonProducer.cc.

84 { LogTrace("L3MuonProducer") << "destructor called" << endl; }

References LogTrace.

Member Function Documentation

◆ fillDescriptions()

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

Definition at line 144 of file L3MuonProducer.cc.

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<double>("EscapePt", 3.0);
269  psd1.add<bool>("Pt_fixed", false);
270  psd0.add<edm::ParameterSetDescription>("MuonTrackingRegionBuilder", psd1);
271  }
272  psd0.add<bool>("RefitRPCHits", true);
273  psd0.add<double>("PCut", 2.5);
274  {
275  edm::ParameterSetDescription psd1;
276  TrackTransformer::fillPSetDescription(psd1,
277  false, // do predictions only
278  "hltESPL3MuKFTrajectoryFitter", // fitter
279  "hltESPKFTrajectorySmootherForMuonTrackLoader", // smoother
280  "hltESPSmartPropagatorAny", // propagator
281  "insideOut", // refit direction
282  true, // refit rpc hits
283  "hltESPTTRHBWithTrackAngle", // tracker rechit builder
284  "hltESPMuonTransientTrackingRecHitBuilder" // muon rechit builder
285  );
286  psd0.add<edm::ParameterSetDescription>("TrackTransformer", psd1);
287  }
288  {
289  edm::ParameterSetDescription psd1;
290  psd1.add<double>("Quality_3", 7.0);
291  psd1.add<double>("DeltaRCut_1", 0.1);
292  psd1.add<double>("MinP", 2.5);
293  psd1.add<double>("MinPt", 1.0);
294  psd1.add<double>("Quality_2", 15.0);
295  psd1.add<double>("Pt_threshold2", 999999999.0);
296  psd1.add<double>("LocChi2Cut", 0.001);
297  psd1.add<double>("Eta_threshold", 1.2);
298  psd1.add<double>("Pt_threshold1", 0.0);
299  psd1.add<double>("Chi2Cut_1", 50.0);
300  psd1.add<double>("Quality_1", 20.0);
301  psd1.add<double>("Chi2Cut_3", 200.0);
302  psd1.add<double>("DeltaRCut_3", 1.0);
303  psd1.add<double>("DeltaRCut_2", 0.2);
304  psd1.add<double>("DeltaDCut_1", 40.0);
305  psd1.add<double>("DeltaDCut_2", 10.0);
306  psd1.add<double>("DeltaDCut_3", 15.0);
307  psd1.add<double>("Chi2Cut_2", 50.0);
308  psd1.add<std::string>("Propagator", "hltESPSmartPropagator");
309  psd0.add<edm::ParameterSetDescription>("GlobalMuonTrackMatcher", psd1);
310  }
311  psd0.add<double>("PtCut", 1.0);
312  psd0.add<bool>("matchToSeeds", true);
313  psd0.add<edm::InputTag>("tkTrajLabel", edm::InputTag("hltBRSMuonSeededTracksOutIn"));
314  desc.add<edm::ParameterSetDescription>("L3TrajBuilderParameters", psd0);
315  }
316  descriptions.add("L3MuonProducer", desc);
317 }

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

◆ produce()

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

reconstruct muons

Definition at line 89 of file L3MuonProducer.cc.

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 }

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

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.

L3MuonProducer::updatedL2AssoMapToken_
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
Definition: L3MuonProducer.h:58
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:173
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89281
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
edm::Handle< reco::TrackCollection >
L3MuonProducer::l2AssoMapToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
Definition: L3MuonProducer.h:57
edm::Ref
Definition: AssociativeIterator.h:58
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
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:171
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::AssociationMap< edm::OneToOne< std::vector< Trajectory >, reco::TrackCollection, unsigned short > >::const_iterator
friend struct const_iterator
Definition: AssociationMap.h:274
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
edm::ParameterSet
Definition: ParameterSet.h:47
L3MuonProducer::theTrackFinder
std::unique_ptr< MuonTrackFinder > theTrackFinder
Definition: L3MuonProducer.h:60
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
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:58
L3MuonProducer::theL2CollectionLabel
edm::InputTag theL2CollectionLabel
Seed STA Label.
Definition: L3MuonProducer.h:50
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
eostools.move
def move(src, dest)
Definition: eostools.py:511
L3MuonProducer::theService
std::unique_ptr< MuonServiceProxy > theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:63
Trajectory
Definition: Trajectory.h:38
edm::AssociationMap::begin
const_iterator begin() const
first iterator over the map (read only)
Definition: AssociationMap.h:169
L3MuonProducer::theL2SeededTkLabel
std::string theL2SeededTkLabel
Label for L2SeededTracks.
Definition: L3MuonProducer.h:53
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
MuonTrajectoryBuilder::TrackCand
std::pair< const Trajectory *, reco::TrackRef > TrackCand
Definition: MuonTrajectoryBuilder.h:25
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
L2Muons_cfi.L2Muons
L2Muons
Definition: L2Muons_cfi.py:6
event
Definition: event.py:1
edm::AssociationMap::const_iterator
const iterator
Definition: AssociationMap.h:76
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:40
L3MuonProducer::l2MuonToken_
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
Definition: L3MuonProducer.h:55
Generated for CMSSW Reference Manual by doxygen 1.8.16