CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
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<> edm::stream::EDProducerBase edm::ProducerBase edm::EDConsumerBase edm::ProductRegistryHelper

Public Member Functions

 L3MuonProducer (const edm::ParameterSet &)
 constructor with config More...
 
virtual void produce (edm::Event &, const edm::EventSetup &)
 reconstruct muons More...
 
virtual ~L3MuonProducer ()
 destructor More...
 
- Public Member Functions inherited from edm::stream::EDProducer<>
 EDProducer ()=default
 
- Public Member Functions inherited from edm::stream::EDProducerBase
 EDProducerBase ()
 
ModuleDescription const & moduleDescription () const
 
virtual ~EDProducerBase ()
 
- Public Member Functions inherited from edm::ProducerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 ProducerBase ()
 
void registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
 
std::function< void(BranchDescription
const &)> 		registrationCallback () const
 used by the fwk to register list of products More...
 
virtual ~ProducerBase ()
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
 EDConsumerBase ()
 
ProductHolderIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
 
std::vector
< ProductHolderIndexAndSkipBit >
const & 		itemsToGetFromEvent () const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
bool registeredToConsume (ProductHolderIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
void updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
 
virtual ~EDConsumerBase ()
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (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...
 
MuonServiceProxy * theService
 the event setup proxy, it takes care the services update More...
 
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
 
- Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase ModuleType
 
- Public Types inherited from edm::ProducerBase
typedef
ProductRegistryHelper::TypeLabelList 		TypeLabelList
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 

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 31 of file L3MuonProducer.h.

Constructor & Destructor Documentation

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

constructor with config

Definition at line 35 of file L3MuonProducer.cc.

References edm::ParameterSet::getParameter(), LogTrace, MuonServiceProxy_cff::MuonServiceProxy, and AlCaHLTBitMon_QueryRunRegistry::string.

35  {
36 
37  LogTrace("L3MuonProducer") << "constructor called" << endl;
38 
39  // Parameter set for the Builder
40  ParameterSet trajectoryBuilderParameters = parameterSet.getParameter<ParameterSet>("L3TrajBuilderParameters");
41 
42  // L2 Muon Collection Label
43  theL2CollectionLabel = parameterSet.getParameter<InputTag>("MuonCollectionLabel");
44  l2MuonToken_ = consumes<reco::TrackCollection>(theL2CollectionLabel);
45  l2MuonTrajToken_ = consumes<std::vector<Trajectory> >(theL2CollectionLabel.label());
46  l2AssoMapToken_ = consumes<TrajTrackAssociationCollection>(theL2CollectionLabel.label());
47  updatedL2AssoMapToken_ = consumes<reco::TrackToTrackMap>(theL2CollectionLabel.label());
48 
49  // service parameters
50  ParameterSet serviceParameters = parameterSet.getParameter<ParameterSet>("ServiceParameters");
51 
52  // TrackLoader parameters
53  ParameterSet trackLoaderParameters = parameterSet.getParameter<ParameterSet>("TrackLoaderParameters");
54 
55  // the services
56  theService = new MuonServiceProxy(serviceParameters);
57  ConsumesCollector iC = consumesCollector();
58 
59  // instantiate the concrete trajectory builder in the Track Finder
60  MuonTrackLoader* mtl = new MuonTrackLoader(trackLoaderParameters,iC,theService);
61  L3MuonTrajectoryBuilder* l3mtb = new L3MuonTrajectoryBuilder(trajectoryBuilderParameters, theService,iC);
62  theTrackFinder = new MuonTrackFinder(l3mtb, mtl);
63 
64  theL2SeededTkLabel = 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 
80 }
MuonServiceProxy_cff.MuonServiceProxy
tuple MuonServiceProxy
Definition: MuonServiceProxy_cff.py:15
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
L3MuonProducer::updatedL2AssoMapToken_
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
Definition: L3MuonProducer.h:56
L3MuonProducer::l2MuonToken_
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
Definition: L3MuonProducer.h:53
L3MuonProducer::theService
MuonServiceProxy * theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:61
L3MuonProducer::theTrackFinder
MuonTrackFinder * theTrackFinder
Definition: L3MuonProducer.h:58
L3MuonProducer::l2MuonTrajToken_
edm::EDGetTokenT< std::vector< Trajectory > > l2MuonTrajToken_
Definition: L3MuonProducer.h:54
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:255
edm::EDConsumerBase::consumesCollector
ConsumesCollector consumesCollector()
Use a ConsumesCollector to gather consumes information from helper functions.
Definition: EDConsumerBase.cc:72
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
L3MuonProducer::l2AssoMapToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
Definition: L3MuonProducer.h:55
L3MuonProducer::theL2CollectionLabel
edm::InputTag theL2CollectionLabel
Seed STA Label.
Definition: L3MuonProducer.h:48
L3MuonProducer::theL2SeededTkLabel
std::string theL2SeededTkLabel
Label for L2SeededTracks.
Definition: L3MuonProducer.h:51
L3MuonProducer::~L3MuonProducer ( )
virtual

destructor

Definition at line 86 of file L3MuonProducer.cc.

References LogTrace.

86  {
87 
88  LogTrace("L3MuonProducer") << "destructor called" << endl;
89  if (theService) delete theService;
90  if (theTrackFinder) delete theTrackFinder;
91 
92 }
L3MuonProducer::theService
MuonServiceProxy * theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:61
L3MuonProducer::theTrackFinder
MuonTrackFinder * theTrackFinder
Definition: L3MuonProducer.h:58
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502

Member Function Documentation

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

Definition at line 156 of file L3MuonProducer.cc.

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

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

reconstruct muons

Implements edm::stream::EDProducerBase.

Definition at line 98 of file L3MuonProducer.cc.

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

98  {
99  const string metname = "Muon|RecoMuon|L3MuonProducer";
100  LogTrace(metname)<<endl<<endl<<endl;
101  LogTrace(metname)<<"L3 Muon Reconstruction started"<<endl;
102 
103  typedef vector<Trajectory> TrajColl;
104 
105  // Update the services
106  theService->update(eventSetup);
107 
108  // Take the L2 muon container(s)
109  LogTrace(metname)<<"Taking the L2 Muons "<<theL2CollectionLabel<<endl;
110 
111 
112  Handle<reco::TrackCollection> L2Muons;
113  event.getByToken(l2MuonToken_,L2Muons);
114 
115  Handle<vector<Trajectory> > L2MuonsTraj;
116  vector<MuonTrajectoryBuilder::TrackCand> L2TrackCands;
117 
118 
119  event.getByToken(l2MuonTrajToken_, L2MuonsTraj);
120 
121  edm::Handle<TrajTrackAssociationCollection> L2AssoMap;
122  event.getByToken(l2AssoMapToken_,L2AssoMap);
123 
124  edm::Handle<reco::TrackToTrackMap> updatedL2AssoMap;
125  event.getByToken(updatedL2AssoMapToken_,updatedL2AssoMap);
126 
127 
128 
129  for(TrajTrackAssociationCollection::const_iterator it = L2AssoMap->begin(); it != L2AssoMap->end(); ++it){
130  const Ref<vector<Trajectory> > traj = it->key;
131  const reco::TrackRef tkRegular = it->val;
132  reco::TrackRef tkUpdated;
133  reco::TrackToTrackMap::const_iterator iEnd;
134  reco::TrackToTrackMap::const_iterator iii;
135  if ( theL2CollectionLabel.instance() == "UpdatedAtVtx") {
136  iEnd = updatedL2AssoMap->end();
137  iii = updatedL2AssoMap->find(it->val);
138  if (iii != iEnd ) tkUpdated = (*updatedL2AssoMap)[it->val] ;
139  }
140 
141  const reco::TrackRef tk = ( tkUpdated.isNonnull() ) ? tkUpdated : tkRegular ;
142 
143  MuonTrajectoryBuilder::TrackCand L2Cand = MuonTrajectoryBuilder::TrackCand((Trajectory*)(0),tk);
144  if( traj->isValid() ) L2Cand.first = &*traj ;
145  L2TrackCands.push_back(L2Cand);
146  }
147 
148  theTrackFinder->reconstruct(L2TrackCands, event, eventSetup);
149 
150  LogTrace(metname)<<"Event loaded"
151  <<"================================"
152  <<endl<<endl;
153 
154 }
L3MuonProducer::updatedL2AssoMapToken_
edm::EDGetTokenT< reco::TrackToTrackMap > updatedL2AssoMapToken_
Definition: L3MuonProducer.h:56
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:252
MuonTrajectoryBuilder::TrackCand
std::pair< const Trajectory *, reco::TrackRef > TrackCand
Definition: MuonTrajectoryBuilder.h:25
L3MuonProducer::l2MuonToken_
edm::EDGetTokenT< reco::TrackCollection > l2MuonToken_
Definition: L3MuonProducer.h:53
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:44
L3MuonProducer::theService
MuonServiceProxy * theService
the event setup proxy, it takes care the services update
Definition: L3MuonProducer.h:61
L3MuonProducer::theTrackFinder
MuonTrackFinder * theTrackFinder
Definition: L3MuonProducer.h:58
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:264
L3MuonProducer::l2MuonTrajToken_
edm::EDGetTokenT< std::vector< Trajectory > > l2MuonTrajToken_
Definition: L3MuonProducer.h:54
L2Muons_cfi.L2Muons
tuple L2Muons
Definition: L2Muons_cfi.py:6
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:502
L3MuonProducer::l2AssoMapToken_
edm::EDGetTokenT< TrajTrackAssociationCollection > l2AssoMapToken_
Definition: L3MuonProducer.h:55
L3MuonProducer::theL2CollectionLabel
edm::InputTag theL2CollectionLabel
Seed STA Label.
Definition: L3MuonProducer.h:48
MuonTrackFinder::reconstruct
edm::OrphanHandle< reco::TrackCollection > reconstruct(const edm::Handle< edm::View< TrajectorySeed > > &, edm::Event &, const edm::EventSetup &)
reconstruct standalone tracks starting from a collection of seeds
Definition: MuonTrackFinder.cc:83
edm::InputTag::instance
std::string const & instance() const
Definition: InputTag.h:37

Member Data Documentation

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

Definition at line 55 of file L3MuonProducer.h.

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

Definition at line 53 of file L3MuonProducer.h.

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

Definition at line 54 of file L3MuonProducer.h.

edm::InputTag L3MuonProducer::theL2CollectionLabel
private

Seed STA Label.

Definition at line 48 of file L3MuonProducer.h.

std::string L3MuonProducer::theL2SeededTkLabel
private

Label for L2SeededTracks.

Definition at line 51 of file L3MuonProducer.h.

MuonServiceProxy* L3MuonProducer::theService
private

the event setup proxy, it takes care the services update

Definition at line 61 of file L3MuonProducer.h.

MuonTrackFinder* L3MuonProducer::theTrackFinder
private

Definition at line 58 of file L3MuonProducer.h.

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

Definition at line 56 of file L3MuonProducer.h.

Generated for CMSSW Reference Manual by doxygen 1.8.5