CMS 3D CMS Logo
L2MuonProducer.cc
Go to the documentation of this file.
1 //-------------------------------------------------
2 //
16 //
17 //--------------------------------------------------
18 
19 #include "RecoMuon/L2MuonProducer/src/L2MuonProducer.h"
20 
21 // Framework
22 #include "FWCore/Framework/interface/ConsumesCollector.h"
23 #include "FWCore/Framework/interface/Event.h"
24 #include "FWCore/Framework/interface/EventSetup.h"
25 #include "FWCore/ParameterSet/interface/ParameterSet.h"
26 #include "FWCore/MessageLogger/interface/MessageLogger.h"
27 
28 // TrackFinder and Specific STA/L2 Trajectory Builder
29 #include "RecoMuon/StandAloneTrackFinder/interface/StandAloneTrajectoryBuilder.h"
30 #include "RecoMuon/StandAloneTrackFinder/interface/ExhaustiveMuonTrajectoryBuilder.h"
31 #include "RecoMuon/TrackingTools/interface/MuonTrackFinder.h"
32 #include "RecoMuon/TrackingTools/interface/MuonTrackLoader.h"
33 #include "RecoMuon/TrackingTools/interface/MuonTrajectoryCleaner.h"
34 #include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"
35 
36 #include "TrackingTools/PatternTools/interface/TrajTrackAssociation.h"
37 
38 #include "DataFormats/Common/interface/Handle.h"
39 #include "DataFormats/Common/interface/View.h"
40 #include "DataFormats/TrackReco/interface/Track.h"
41 #include "DataFormats/TrackReco/interface/TrackToTrackMap.h"
42 #include "DataFormats/MuonSeed/interface/L2MuonTrajectorySeedCollection.h"
43 
44 #include <string>
45 
46 using namespace edm;
47 using namespace std;
48 
50 L2MuonProducer::L2MuonProducer(const ParameterSet& parameterSet) {
51  LogTrace("Muon|RecoMuon|L2MuonProducer") << "constructor called" << endl;
52 
53  // Parameter set for the Builder
54  ParameterSet trajectoryBuilderParameters = parameterSet.getParameter<ParameterSet>("L2TrajBuilderParameters");
55 
56  // MuonSeed Collection Label
57  theSeedCollectionLabel = parameterSet.getParameter<InputTag>("InputObjects");
58  seedsToken = consumes<edm::View<TrajectorySeed>>(theSeedCollectionLabel);
59  // service parameters
60  ParameterSet serviceParameters = parameterSet.getParameter<ParameterSet>("ServiceParameters");
61 
62  // TrackLoader parameters
63  ParameterSet trackLoaderParameters = parameterSet.getParameter<ParameterSet>("TrackLoaderParameters");
64 
65  // the services
66  theService = std::make_unique<MuonServiceProxy>(serviceParameters, consumesCollector());
67 
68  std::unique_ptr<MuonTrajectoryBuilder> trajectoryBuilder = nullptr;
69  // instantiate the concrete trajectory builder in the Track Finder
70 
71  edm::ConsumesCollector iC = consumesCollector();
72  string typeOfBuilder = parameterSet.existsAs<string>("MuonTrajectoryBuilder")
73  ? parameterSet.getParameter<string>("MuonTrajectoryBuilder")
74  : "StandAloneMuonTrajectoryBuilder";
75  if (typeOfBuilder == "StandAloneMuonTrajectoryBuilder" || typeOfBuilder.empty())
76  trajectoryBuilder =
77  std::make_unique<StandAloneMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
78  else if (typeOfBuilder == "Exhaustive")
79  trajectoryBuilder =
80  std::make_unique<ExhaustiveMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
81  else {
82  LogWarning("Muon|RecoMuon|StandAloneMuonProducer")
83  << "No Trajectory builder associated with " << typeOfBuilder
84  << ". Falling down to the default (StandAloneMuonTrajectoryBuilder)";
85  trajectoryBuilder =
86  std::make_unique<StandAloneMuonTrajectoryBuilder>(trajectoryBuilderParameters, theService.get(), iC);
87  }
88  theTrackFinder =
89  std::make_unique<MuonTrackFinder>(std::move(trajectoryBuilder),
90  std::make_unique<MuonTrackLoader>(trackLoaderParameters, iC, theService.get()),
91  std::make_unique<MuonTrajectoryCleaner>(true));
92 
93  produces<reco::TrackCollection>();
94  produces<reco::TrackCollection>("UpdatedAtVtx");
95  produces<TrackingRecHitCollection>();
96  produces<reco::TrackExtraCollection>();
97  produces<reco::TrackToTrackMap>();
98 
99  produces<std::vector<Trajectory>>();
100  produces<TrajTrackAssociationCollection>();
101 
102  produces<edm::AssociationMap<edm::OneToMany<std::vector<L2MuonTrajectorySeed>, std::vector<L2MuonTrajectorySeed>>>>();
103 }
104 
106 L2MuonProducer::~L2MuonProducer() {
107  LogTrace("Muon|RecoMuon|L2eMuonProducer") << "L2MuonProducer destructor called" << endl;
108 }
109 
111 void L2MuonProducer::produce(Event& event, const EventSetup& eventSetup) {
112  const std::string metname = "Muon|RecoMuon|L2MuonProducer";
113 
114  LogTrace(metname) << endl << endl << endl;
115  LogTrace(metname) << "L2 Muon Reconstruction Started" << endl;
116 
117  // Take the seeds container
118  LogTrace(metname) << "Taking the seeds: " << theSeedCollectionLabel.label() << endl;
119  Handle<View<TrajectorySeed>> seeds;
120  event.getByToken(seedsToken, seeds);
121 
122  // Update the services
123  theService->update(eventSetup);
124 
125  // Reconstruct
126  LogTrace(metname) << "Track Reconstruction" << endl;
127  theTrackFinder->reconstruct(seeds, event, eventSetup);
128 
129  LogTrace(metname) << "Event loaded"
130  << "================================" << endl
131  << endl;
132 }
133 
134 void L2MuonProducer::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
135  edm::ParameterSetDescription desc;
136  {
137  edm::ParameterSetDescription psd0;
138  psd0.addUntracked<std::vector<std::string>>("Propagators",
139  {
140  "hltESPFastSteppingHelixPropagatorAny"
141  "hltESPFastSteppingHelixPropagatorOpposite",
142  });
143  psd0.add<bool>("RPCLayers", true);
144  psd0.addUntracked<bool>("UseMuonNavigation", true);
145  desc.add<edm::ParameterSetDescription>("ServiceParameters", psd0);
146  }
147 
148  desc.add<edm::InputTag>("InputObjects", edm::InputTag("hltL2MuonSeeds"));
149  {
150  edm::ParameterSetDescription psd0;
151  psd0.add<std::string>("Fitter", "hltESPKFFittingSmootherForL2Muon");
152  psd0.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
153  psd0.add<unsigned int>("NMinRecHits", 2);
154  psd0.add<bool>("UseSubRecHits", false);
155  psd0.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
156  psd0.add<double>("RescaleError", 100.0);
157  desc.add<edm::ParameterSetDescription>("SeedTransformerParameters", psd0);
158  }
159 
160  {
161  edm::ParameterSetDescription psd0;
162  psd0.add<bool>("DoRefit", false);
163  psd0.add<std::string>("SeedPropagator", "hltESPFastSteppingHelixPropagatorAny");
164  {
165  edm::ParameterSetDescription psd1;
166  psd1.add<double>("NumberOfSigma", 3.0);
167  psd1.add<std::string>("FitDirection", "insideOut");
168  psd1.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("hltDt4DSegments"));
169  psd1.add<double>("MaxChi2", 1000.0);
170  {
171  edm::ParameterSetDescription psd2;
172  psd2.add<double>("MaxChi2", 25.0);
173  psd2.add<double>("RescaleErrorFactor", 100.0);
174  psd2.add<int>("Granularity", 0);
175  psd2.add<bool>("ExcludeRPCFromFit", false);
176  psd2.add<bool>("UseInvalidHits", true);
177  psd2.add<bool>("RescaleError", false);
178  psd1.add<edm::ParameterSetDescription>("MuonTrajectoryUpdatorParameters", psd2);
179  }
180  psd1.add<bool>("EnableRPCMeasurement", true);
181  psd1.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("hltCscSegments"));
182  psd1.add<bool>("EnableDTMeasurement", true);
183  psd1.add<edm::InputTag>("RPCRecSegmentLabel", edm::InputTag("hltRpcRecHits"));
184  psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
185  psd1.add<bool>("EnableGEMMeasurement", false);
186  psd1.add<edm::InputTag>("GEMRecSegmentLabel", edm::InputTag("gemRecHits"));
187  psd1.add<bool>("EnableME0Measurement", false);
188  psd1.add<edm::InputTag>("ME0RecSegmentLabel", edm::InputTag("me0Segments"));
189  psd1.add<bool>("EnableCSCMeasurement", true);
190  psd0.add<edm::ParameterSetDescription>("FilterParameters", psd1);
191  }
192  psd0.add<std::string>("NavigationType", "Standard");
193  {
194  edm::ParameterSetDescription psd1;
195  psd1.add<std::string>("Fitter", "hltESPKFFittingSmootherForL2Muon");
196  psd1.add<std::string>("MuonRecHitBuilder", "hltESPMuonTransientTrackingRecHitBuilder");
197  psd1.add<unsigned int>("NMinRecHits", 2);
198  psd1.add<bool>("UseSubRecHits", false);
199  psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
200  psd1.add<double>("RescaleError", 100.0);
201  psd0.add<edm::ParameterSetDescription>("SeedTransformerParameters", psd1);
202  }
203  psd0.add<bool>("DoBackwardFilter", true);
204  psd0.add<std::string>("SeedPosition", "in");
205  {
206  edm::ParameterSetDescription psd1;
207  psd1.add<double>("NumberOfSigma", 3.0);
208  psd1.add<edm::InputTag>("CSCRecSegmentLabel", edm::InputTag("hltCscSegments"));
209  psd1.add<std::string>("FitDirection", "outsideIn");
210  psd1.add<edm::InputTag>("DTRecSegmentLabel", edm::InputTag("hltDt4DSegments"));
211  psd1.add<double>("MaxChi2", 100.0);
212  {
213  edm::ParameterSetDescription psd2;
214  psd2.add<double>("MaxChi2", 25.0);
215  psd2.add<double>("RescaleErrorFactor", 100.0);
216  psd2.add<int>("Granularity", 0);
217  psd2.add<bool>("ExcludeRPCFromFit", false);
218  psd2.add<bool>("UseInvalidHits", true);
219  psd2.add<bool>("RescaleError", false);
220  psd1.add<edm::ParameterSetDescription>("MuonTrajectoryUpdatorParameters", psd2);
221  }
222  psd1.add<bool>("EnableRPCMeasurement", true);
223  psd1.add<std::string>("BWSeedType", "fromGenerator");
224  psd1.add<bool>("EnableDTMeasurement", true);
225  psd1.add<edm::InputTag>("RPCRecSegmentLabel", edm::InputTag("hltRpcRecHits"));
226  psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorAny");
227  psd1.add<bool>("EnableGEMMeasurement", false);
228  psd1.add<edm::InputTag>("GEMRecSegmentLabel", edm::InputTag("gemRecHits"));
229  psd1.add<bool>("EnableME0Measurement", false);
230  psd1.add<edm::InputTag>("ME0RecSegmentLabel", edm::InputTag("me0Segments"));
231  psd1.add<bool>("EnableCSCMeasurement", true);
232  psd0.add<edm::ParameterSetDescription>("BWFilterParameters", psd1);
233  }
234  psd0.add<bool>("DoSeedRefit", false);
235  desc.add<edm::ParameterSetDescription>("L2TrajBuilderParameters", psd0);
236  }
237  desc.add<bool>("DoSeedRefit", false);
238  {
239  edm::ParameterSetDescription psd0;
240  psd0.add<std::string>("Smoother", "hltESPKFTrajectorySmootherForMuonTrackLoader");
241  psd0.add<bool>("DoSmoothing", false);
242  psd0.add<edm::InputTag>("beamSpot", edm::InputTag("hltOnlineBeamSpot"));
243  {
244  edm::ParameterSetDescription psd1;
245  psd1.add<double>("MaxChi2", 1000000.0);
246  psd1.add<std::vector<double>>("BeamSpotPosition",
247  {
248  0.0,
249  0.0,
250  0.0,
251  });
252  psd1.add<std::string>("Propagator", "hltESPFastSteppingHelixPropagatorOpposite");
253  psd1.add<std::vector<double>>("BeamSpotPositionErrors",
254  {
255  0.1,
256  0.1,
257  5.3,
258  });
259  psd0.add<edm::ParameterSetDescription>("MuonUpdatorAtVertexParameters", psd1);
260  }
261  psd0.add<bool>("VertexConstraint", true);
262  psd0.add<std::string>("TTRHBuilder", "hltESPTTRHBWithTrackAngle");
263  desc.add<edm::ParameterSetDescription>("TrackLoaderParameters", psd0);
264  }
265  desc.add<std::string>("MuonTrajectoryBuilder", "Exhaustive");
266  descriptions.add("L2MuonProducer", desc);
267 }
Handle.h
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
MessageLogger.h
MuonTrajectoryCleaner.h
edm
HLT enums.
Definition: AlignableModifier.h:19
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
edm::ParameterSet::existsAs
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:160
edm::Handle
Definition: AssociativeIterator.h:50
L2MuonTrajectorySeedCollection.h
Track.h
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
MuonTrackLoader.h
L2MuonProducer::produce
void produce(edm::Event &, const edm::EventSetup &) override
reconstruct muons
Definition: L2MuonProducer.cc:111
L2MuonProducer::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: L2MuonProducer.cc:134
TrajTrackAssociation.h
edm::ConfigurationDescriptions
Definition: ConfigurationDescriptions.h:28
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::LogWarning
Definition: MessageLogger.h:141
InitialStep_cff.seeds
seeds
Definition: InitialStep_cff.py:232
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
edm::ParameterSet
Definition: ParameterSet.h:36
Event.h
MuonTrackFinder.h
edm::EventSetup
Definition: EventSetup.h:57
L2MuonProducer::~L2MuonProducer
~L2MuonProducer() override
destructor
Definition: L2MuonProducer.cc:106
ExhaustiveMuonTrajectoryBuilder.h
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
eostools.move
def move(src, dest)
Definition: eostools.py:511
std
Definition: JetResolutionObject.h:76
L2MuonProducer::L2MuonProducer
L2MuonProducer(const edm::ParameterSet &)
constructor with config
Definition: L2MuonProducer.cc:50
MuonServiceProxy.h
edm::parameterSet
ParameterSet const & parameterSet(Provenance const &provenance, ProcessHistory const &history)
Definition: Provenance.cc:11
EventSetup.h
ConsumesCollector.h
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
View.h
ParameterSet.h
event
Definition: event.py:1
edm::Event
Definition: Event.h:73
L2MuonProducer.h
edm::InputTag
Definition: InputTag.h:15
edm::ConsumesCollector
Definition: ConsumesCollector.h:39
TrackToTrackMap.h
StandAloneTrajectoryBuilder.h
metname
const std::string metname
Definition: MuonSeedOrcaPatternRecognition.cc:43
Generated for CMSSW Reference Manual by doxygen 1.8.16