CMS 3D CMS Logo

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
PATMuonProducer.cc
Go to the documentation of this file.
1 //
2 //
3 
5 
9 
12 
14 
17 
20 
22 
25 
28 
33 
34 #include "TMath.h"
35 
37 
38 #include <vector>
39 #include <memory>
40 
41 
42 using namespace pat;
43 using namespace std;
44 
45 
46 PATMuonProducer::PATMuonProducer(const edm::ParameterSet & iConfig) : useUserData_(iConfig.exists("userData")),
47  isolator_(iConfig.exists("userIsolation") ? iConfig.getParameter<edm::ParameterSet>("userIsolation") : edm::ParameterSet(), consumesCollector(), false)
48 {
49  // input source
50  muonToken_ = consumes<edm::View<reco::Muon> >(iConfig.getParameter<edm::InputTag>( "muonSource" ));
51  // embedding of tracks
52  embedBestTrack_ = iConfig.getParameter<bool>( "embedMuonBestTrack" );
53  embedTrack_ = iConfig.getParameter<bool>( "embedTrack" );
54  embedCombinedMuon_ = iConfig.getParameter<bool>( "embedCombinedMuon" );
55  embedStandAloneMuon_ = iConfig.getParameter<bool>( "embedStandAloneMuon" );
56  // embedding of muon MET correction information
57  embedCaloMETMuonCorrs_ = iConfig.getParameter<bool>("embedCaloMETMuonCorrs" );
58  embedTcMETMuonCorrs_ = iConfig.getParameter<bool>("embedTcMETMuonCorrs" );
59  caloMETMuonCorrsToken_ = mayConsume<edm::ValueMap<reco::MuonMETCorrectionData> >(iConfig.getParameter<edm::InputTag>("caloMETMuonCorrs" ));
60  tcMETMuonCorrsToken_ = mayConsume<edm::ValueMap<reco::MuonMETCorrectionData> >(iConfig.getParameter<edm::InputTag>("tcMETMuonCorrs" ));
61  // pflow specific configurables
62  useParticleFlow_ = iConfig.getParameter<bool>( "useParticleFlow" );
63  embedPFCandidate_ = iConfig.getParameter<bool>( "embedPFCandidate" );
64  pfMuonToken_ = mayConsume<reco::PFCandidateCollection>(iConfig.getParameter<edm::InputTag>( "pfMuonSource" ));
65  // embedding of tracks from TeV refit
66  embedPickyMuon_ = iConfig.getParameter<bool>( "embedPickyMuon" );
67  embedTpfmsMuon_ = iConfig.getParameter<bool>( "embedTpfmsMuon" );
68  embedDytMuon_ = iConfig.getParameter<bool>( "embedDytMuon" );
69  // Monte Carlo matching
70  addGenMatch_ = iConfig.getParameter<bool>( "addGenMatch" );
71  if (addGenMatch_) {
72  embedGenMatch_ = iConfig.getParameter<bool>( "embedGenMatch" );
73  if (iConfig.existsAs<edm::InputTag>("genParticleMatch")) {
75  }
76  else {
77  genMatchTokens_ = edm::vector_transform(iConfig.getParameter<std::vector<edm::InputTag> >( "genParticleMatch" ), [this](edm::InputTag const & tag){return consumes<edm::Association<reco::GenParticleCollection> >(tag);});
78  }
79  }
80  // efficiencies
81  addEfficiencies_ = iConfig.getParameter<bool>("addEfficiencies");
82  if(addEfficiencies_){
83  efficiencyLoader_ = pat::helper::EfficiencyLoader(iConfig.getParameter<edm::ParameterSet>("efficiencies"), consumesCollector());
84  }
85  // resolutions
86  addResolutions_ = iConfig.getParameter<bool>("addResolutions");
87  if (addResolutions_) {
88  resolutionLoader_ = pat::helper::KinResolutionsLoader(iConfig.getParameter<edm::ParameterSet>("resolutions"));
89  }
90  // read isoDeposit labels, for direct embedding
91  readIsolationLabels(iConfig, "isoDeposits", isoDepositLabels_, isoDepositTokens_);
92  // read isolation value labels, for direct embedding
93  readIsolationLabels(iConfig, "isolationValues", isolationValueLabels_, isolationValueTokens_);
94  // check to see if the user wants to add user data
95  if( useUserData_ ){
96  userDataHelper_ = PATUserDataHelper<Muon>(iConfig.getParameter<edm::ParameterSet>("userData"), consumesCollector());
97  }
98  // embed high level selection variables
99  usePV_ = true;
100  embedHighLevelSelection_ = iConfig.getParameter<bool>("embedHighLevelSelection");
101  if ( embedHighLevelSelection_ ) {
102  beamLineToken_ = consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamLineSrc"));
103  usePV_ = iConfig.getParameter<bool>("usePV");
104  pvToken_ = consumes<std::vector<reco::Vertex> >(iConfig.getParameter<edm::InputTag>("pvSrc"));
105  }
106  // produces vector of muons
107  produces<std::vector<Muon> >();
108 }
109 
110 
111 PATMuonProducer::~PATMuonProducer()
112 {
113 }
114 
116 {
117  // switch off embedding (in unschedules mode)
118  if (iEvent.isRealData()){
119  addGenMatch_ = false;
120  embedGenMatch_ = false;
121  }
122 
124  iEvent.getByToken(muonToken_, muons);
125 
126  // get the ESHandle for the transient track builder,
127  // if needed for high level selection embedding
129 
130  if(isolator_.enabled()) isolator_.beginEvent(iEvent,iSetup);
132  if(resolutionLoader_.enabled()) resolutionLoader_.newEvent(iEvent, iSetup);
133 
134  IsoDepositMaps deposits(isoDepositTokens_.size());
135  for (size_t j = 0; j<isoDepositTokens_.size(); ++j) {
136  iEvent.getByToken(isoDepositTokens_[j], deposits[j]);
137  }
138 
139  IsolationValueMaps isolationValues(isolationValueTokens_.size());
140  for (size_t j = 0; j<isolationValueTokens_.size(); ++j) {
141  iEvent.getByToken(isolationValueTokens_[j], isolationValues[j]);
142  }
143 
144  // prepare the MC genMatchTokens_
145  GenAssociations genMatches(genMatchTokens_.size());
146  if (addGenMatch_) {
147  for (size_t j = 0, nd = genMatchTokens_.size(); j < nd; ++j) {
148  iEvent.getByToken(genMatchTokens_[j], genMatches[j]);
149  }
150  }
151 
152  // prepare the high level selection: needs beamline
153  // OR primary vertex, depending on user selection
154  reco::TrackBase::Point beamPoint(0,0,0);
155  reco::Vertex primaryVertex;
157  bool beamSpotIsValid = false;
158  bool primaryVertexIsValid = false;
159  if ( embedHighLevelSelection_ ) {
160  // get the beamspot
161  edm::Handle<reco::BeamSpot> beamSpotHandle;
162  iEvent.getByToken(beamLineToken_, beamSpotHandle);
163 
164  // get the primary vertex
166  iEvent.getByToken( pvToken_, pvHandle );
167 
168  if( beamSpotHandle.isValid() ){
169  beamSpot = *beamSpotHandle;
170  beamSpotIsValid = true;
171  } else{
172  edm::LogError("DataNotAvailable")
173  << "No beam spot available from EventSetup, not adding high level selection \n";
174  }
175  beamPoint = reco::TrackBase::Point ( beamSpot.x0(), beamSpot.y0(), beamSpot.z0() );
176  if( pvHandle.isValid() && !pvHandle->empty() ) {
177  primaryVertex = pvHandle->at(0);
178  primaryVertexIsValid = true;
179  } else {
180  edm::LogError("DataNotAvailable")
181  << "No primary vertex available from EventSetup, not adding high level selection \n";
182  }
183  // this is needed by the IPTools methods from the tracking group
184  iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", trackBuilder);
185  }
186 
187  // this will be the new object collection
188  std::vector<Muon> * patMuons = new std::vector<Muon>();
189 
190  if( useParticleFlow_ ){
191  // get the PFCandidates of type muons
193  iEvent.getByToken(pfMuonToken_, pfMuons);
194 
195  unsigned index=0;
196  for( reco::PFCandidateConstIterator i = pfMuons->begin(); i != pfMuons->end(); ++i, ++index) {
197  const reco::PFCandidate& pfmu = *i;
198  //const reco::IsolaPFCandidate& pfmu = *i;
199  const reco::MuonRef& muonRef = pfmu.muonRef();
200  assert( muonRef.isNonnull() );
201 
202  MuonBaseRef muonBaseRef(muonRef);
203  Muon aMuon(muonBaseRef);
204 
205  if ( useUserData_ ) {
206  userDataHelper_.add( aMuon, iEvent, iSetup );
207  }
208 
209  // embed high level selection
210  if ( embedHighLevelSelection_ ) {
211  // get the tracks
212  reco::TrackRef innerTrack = muonBaseRef->innerTrack();
213  reco::TrackRef globalTrack= muonBaseRef->globalTrack();
214  reco::TrackRef bestTrack = muonBaseRef->muonBestTrack();
215  reco::TrackRef chosenTrack = innerTrack;
216  // Make sure the collection it points to is there
217  if ( bestTrack.isNonnull() && bestTrack.isAvailable() )
218  chosenTrack = bestTrack;
219 
220  if ( chosenTrack.isNonnull() && chosenTrack.isAvailable() ) {
221  unsigned int nhits = chosenTrack->numberOfValidHits(); // ????
222  aMuon.setNumberOfValidHits( nhits );
223 
224  reco::TransientTrack tt = trackBuilder->build(chosenTrack);
225  embedHighLevel( aMuon,
226  chosenTrack,
227  tt,
228  primaryVertex,
229  primaryVertexIsValid,
230  beamSpot,
231  beamSpotIsValid );
232 
233  // Correct to PV, or beam spot
234  if ( !usePV_ ) {
235  double corr_d0 = -1.0 * chosenTrack->dxy( beamPoint );
236  aMuon.setDB( corr_d0, -1.0 );
237  } else {
238  std::pair<bool,Measurement1D> result = IPTools::absoluteTransverseImpactParameter(tt, primaryVertex);
239  double d0_corr = result.second.value();
240  double d0_err = result.second.error();
241  aMuon.setDB( d0_corr, d0_err );
242  }
243  }
244 
245  if ( globalTrack.isNonnull() && globalTrack.isAvailable() ) {
246  double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
247  aMuon.setNormChi2( norm_chi2 );
248  }
249  }
250  reco::PFCandidateRef pfRef(pfMuons,index);
251  //reco::PFCandidatePtr ptrToMother(pfMuons,index);
252  reco::CandidateBaseRef pfBaseRef( pfRef );
253 
254  aMuon.setPFCandidateRef( pfRef );
255  if( embedPFCandidate_ ) aMuon.embedPFCandidate();
256  fillMuon( aMuon, muonBaseRef, pfBaseRef, genMatches, deposits, isolationValues );
257  patMuons->push_back(aMuon);
258  }
259  }
260  else {
262  iEvent.getByToken(muonToken_, muons);
263 
264  // embedding of muon MET corrections
266  //edm::ValueMap<reco::MuonMETCorrectionData> caloMETmuCorValueMap;
268  iEvent.getByToken(caloMETMuonCorrsToken_, caloMETMuonCorrs);
269  //caloMETmuCorValueMap = *caloMETmuCorValueMap_h;
270  }
272  //edm::ValueMap<reco::MuonMETCorrectionData> tcMETmuCorValueMap;
274  iEvent.getByToken(tcMETMuonCorrsToken_, tcMETMuonCorrs);
275  //tcMETmuCorValueMap = *tcMETmuCorValueMap_h;
276  }
277  for (edm::View<reco::Muon>::const_iterator itMuon = muons->begin(); itMuon != muons->end(); ++itMuon) {
278  // construct the Muon from the ref -> save ref to original object
279  unsigned int idx = itMuon - muons->begin();
280  MuonBaseRef muonRef = muons->refAt(idx);
281  reco::CandidateBaseRef muonBaseRef( muonRef );
282 
283  Muon aMuon(muonRef);
284  fillMuon( aMuon, muonRef, muonBaseRef, genMatches, deposits, isolationValues);
285 
286  // Isolation
287  if (isolator_.enabled()) {
288  //reco::CandidatePtr mother = ptrToMother->sourceCandidatePtr(0);
289  isolator_.fill(*muons, idx, isolatorTmpStorage_);
290  typedef pat::helper::MultiIsolator::IsolationValuePairs IsolationValuePairs;
291  // better to loop backwards, so the vector is resized less times
292  for (IsolationValuePairs::const_reverse_iterator it = isolatorTmpStorage_.rbegin(), ed = isolatorTmpStorage_.rend(); it != ed; ++it) {
293  aMuon.setIsolation(it->first, it->second);
294  }
295  }
296 
297  // for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
298  // aMuon.setIsoDeposit(isoDepositLabels_[j].first,
299  // (*deposits[j])[muonRef]);
300  // }
301 
302  // add sel to selected
303  edm::Ptr<reco::Muon> muonsPtr = muons->ptrAt(idx);
304  if ( useUserData_ ) {
305  userDataHelper_.add( aMuon, iEvent, iSetup );
306  }
307 
308  // embed high level selection
309  if ( embedHighLevelSelection_ ) {
310  // get the tracks
311  reco::TrackRef innerTrack = itMuon->innerTrack();
312  reco::TrackRef globalTrack= itMuon->globalTrack();
313  reco::TrackRef bestTrack = itMuon->muonBestTrack();
314  reco::TrackRef chosenTrack = innerTrack;
315  // Make sure the collection it points to is there
316  if ( bestTrack.isNonnull() && bestTrack.isAvailable() )
317  chosenTrack = bestTrack;
318  if ( chosenTrack.isNonnull() && chosenTrack.isAvailable() ) {
319  unsigned int nhits = chosenTrack->numberOfValidHits(); // ????
320  aMuon.setNumberOfValidHits( nhits );
321 
322  reco::TransientTrack tt = trackBuilder->build(chosenTrack);
323  embedHighLevel( aMuon,
324  chosenTrack,
325  tt,
326  primaryVertex,
327  primaryVertexIsValid,
328  beamSpot,
329  beamSpotIsValid );
330 
331  // Correct to PV, or beam spot
332  if ( !usePV_ ) {
333  double corr_d0 = -1.0 * chosenTrack->dxy( beamPoint );
334  aMuon.setDB( corr_d0, -1.0 );
335  } else {
336  std::pair<bool,Measurement1D> result = IPTools::absoluteTransverseImpactParameter(tt, primaryVertex);
337  double d0_corr = result.second.value();
338  double d0_err = result.second.error();
339  aMuon.setDB( d0_corr, d0_err );
340  }
341  }
342 
343  if ( globalTrack.isNonnull() && globalTrack.isAvailable() ) {
344  double norm_chi2 = globalTrack->chi2() / globalTrack->ndof();
345  aMuon.setNormChi2( norm_chi2 );
346  }
347  }
348 
349  // embed MET muon corrections
350  if( embedCaloMETMuonCorrs_ ) aMuon.embedCaloMETMuonCorrs((*caloMETMuonCorrs)[muonRef]);
351  if( embedTcMETMuonCorrs_ ) aMuon.embedTcMETMuonCorrs((*tcMETMuonCorrs )[muonRef]);
352 
353  patMuons->push_back(aMuon);
354  }
355  }
356 
357  // sort muons in pt
358  std::sort(patMuons->begin(), patMuons->end(), pTComparator_);
359 
360  // put genEvt object in Event
361  std::auto_ptr<std::vector<Muon> > ptr(patMuons);
362  iEvent.put(ptr);
363 
365 }
366 
367 
368 void PATMuonProducer::fillMuon( Muon& aMuon, const MuonBaseRef& muonRef, const reco::CandidateBaseRef& baseRef, const GenAssociations& genMatches, const IsoDepositMaps& deposits, const IsolationValueMaps& isolationValues ) const
369 {
370  // in the particle flow algorithm,
371  // the muon momentum is recomputed.
372  // the new value is stored as the momentum of the
373  // resulting PFCandidate of type Muon, and choosen
374  // as the pat::Muon momentum
375  if (useParticleFlow_)
376  aMuon.setP4( aMuon.pfCandidateRef()->p4() );
377  if (embedBestTrack_) aMuon.embedMuonBestTrack();
378  if (embedTrack_) aMuon.embedTrack();
381 
382  // embed the TeV refit track refs (only available for globalMuons)
383  if (aMuon.isGlobalMuon()) {
385  aMuon.embedPickyMuon();
387  aMuon.embedTpfmsMuon();
389  aMuon.embedDytMuon();
390  }
391 
392  // store the match to the generated final state muons
393  if (addGenMatch_) {
394  for(size_t i = 0, n = genMatches.size(); i < n; ++i) {
395  reco::GenParticleRef genMuon = (*genMatches[i])[baseRef];
396  aMuon.addGenParticleRef(genMuon);
397  }
398  if (embedGenMatch_) aMuon.embedGenParticle();
399  }
400  if (efficiencyLoader_.enabled()) {
401  efficiencyLoader_.setEfficiencies( aMuon, muonRef );
402  }
403 
404  for (size_t j = 0, nd = deposits.size(); j < nd; ++j) {
405  if(useParticleFlow_) {
406  if (deposits[j]->contains(baseRef.id())) {
407  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[baseRef]);
408  } else if (deposits[j]->contains(muonRef.id())){
409  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
410  } else {
411  reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
412  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[source]);
413  }
414  }
415  else{
416  aMuon.setIsoDeposit(isoDepositLabels_[j].first, (*deposits[j])[muonRef]);
417  }
418  }
419 
420  for (size_t j = 0; j<isolationValues.size(); ++j) {
421  if(useParticleFlow_) {
422  if (isolationValues[j]->contains(baseRef.id())) {
423  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[baseRef]);
424  } else if (isolationValues[j]->contains(muonRef.id())) {
425  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
426  } else {
427  reco::CandidatePtr source = aMuon.pfCandidateRef()->sourceCandidatePtr(0);
428  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[source]);
429  }
430  }
431  else{
432  aMuon.setIsolation(isolationValueLabels_[j].first, (*isolationValues[j])[muonRef]);
433  }
434  }
435 
436  if (resolutionLoader_.enabled()) {
438  }
439 }
440 
441 // ParameterSet description for module
443 {
445  iDesc.setComment("PAT muon producer module");
446 
447  // input source
448  iDesc.add<edm::InputTag>("muonSource", edm::InputTag("no default"))->setComment("input collection");
449 
450  // embedding
451  iDesc.add<bool>("embedMuonBestTrack", true)->setComment("embed muon best track");
452  iDesc.add<bool>("embedTrack", true)->setComment("embed external track");
453  iDesc.add<bool>("embedStandAloneMuon", true)->setComment("embed external stand-alone muon");
454  iDesc.add<bool>("embedCombinedMuon", false)->setComment("embed external combined muon");
455  iDesc.add<bool>("embedPickyMuon", false)->setComment("embed external picky track");
456  iDesc.add<bool>("embedTpfmsMuon", false)->setComment("embed external tpfms track");
457  iDesc.add<bool>("embedDytMuon", false)->setComment("embed external dyt track ");
458 
459  // embedding of MET muon corrections
460  iDesc.add<bool>("embedCaloMETMuonCorrs", true)->setComment("whether to add MET muon correction for caloMET or not");
461  iDesc.add<edm::InputTag>("caloMETMuonCorrs", edm::InputTag("muonMETValueMapProducer" , "muCorrData"))->setComment("source of MET muon corrections for caloMET");
462  iDesc.add<bool>("embedTcMETMuonCorrs", true)->setComment("whether to add MET muon correction for tcMET or not");
463  iDesc.add<edm::InputTag>("tcMETMuonCorrs", edm::InputTag("muonTCMETValueMapProducer" , "muCorrData"))->setComment("source of MET muon corrections for tcMET");
464 
465  // pf specific parameters
466  iDesc.add<edm::InputTag>("pfMuonSource", edm::InputTag("pfMuons"))->setComment("particle flow input collection");
467  iDesc.add<bool>("useParticleFlow", false)->setComment("whether to use particle flow or not");
468  iDesc.add<bool>("embedPFCandidate", false)->setComment("embed external particle flow object");
469 
470  // MC matching configurables
471  iDesc.add<bool>("addGenMatch", true)->setComment("add MC matching");
472  iDesc.add<bool>("embedGenMatch", false)->setComment("embed MC matched MC information");
473  std::vector<edm::InputTag> emptySourceVector;
474  iDesc.addNode( edm::ParameterDescription<edm::InputTag>("genParticleMatch", edm::InputTag(), true) xor
475  edm::ParameterDescription<std::vector<edm::InputTag> >("genParticleMatch", emptySourceVector, true)
476  )->setComment("input with MC match information");
477 
479 
480  // IsoDeposit configurables
481  edm::ParameterSetDescription isoDepositsPSet;
482  isoDepositsPSet.addOptional<edm::InputTag>("tracker");
483  isoDepositsPSet.addOptional<edm::InputTag>("ecal");
484  isoDepositsPSet.addOptional<edm::InputTag>("hcal");
485  isoDepositsPSet.addOptional<edm::InputTag>("particle");
486  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedHadrons");
487  isoDepositsPSet.addOptional<edm::InputTag>("pfChargedAll");
488  isoDepositsPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
489  isoDepositsPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
490  isoDepositsPSet.addOptional<edm::InputTag>("pfPhotons");
491  isoDepositsPSet.addOptional<std::vector<edm::InputTag> >("user");
492  iDesc.addOptional("isoDeposits", isoDepositsPSet);
493 
494  // isolation values configurables
495  edm::ParameterSetDescription isolationValuesPSet;
496  isolationValuesPSet.addOptional<edm::InputTag>("tracker");
497  isolationValuesPSet.addOptional<edm::InputTag>("ecal");
498  isolationValuesPSet.addOptional<edm::InputTag>("hcal");
499  isolationValuesPSet.addOptional<edm::InputTag>("particle");
500  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedHadrons");
501  isolationValuesPSet.addOptional<edm::InputTag>("pfChargedAll");
502  isolationValuesPSet.addOptional<edm::InputTag>("pfPUChargedHadrons");
503  isolationValuesPSet.addOptional<edm::InputTag>("pfNeutralHadrons");
504  isolationValuesPSet.addOptional<edm::InputTag>("pfPhotons");
505  iDesc.addOptional("isolationValues", isolationValuesPSet);
506 
507  // Efficiency configurables
508  edm::ParameterSetDescription efficienciesPSet;
509  efficienciesPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
510  iDesc.add("efficiencies", efficienciesPSet);
511  iDesc.add<bool>("addEfficiencies", false);
512 
513  // Check to see if the user wants to add user data
514  edm::ParameterSetDescription userDataPSet;
516  iDesc.addOptional("userData", userDataPSet);
517 
518  edm::ParameterSetDescription isolationPSet;
519  isolationPSet.setAllowAnything(); // TODO: the pat helper needs to implement a description.
520  iDesc.add("userIsolation", isolationPSet);
521 
522  iDesc.add<bool>("embedHighLevelSelection", true)->setComment("embed high level selection");
523  edm::ParameterSetDescription highLevelPSet;
524  highLevelPSet.setAllowAnything();
525  iDesc.addNode( edm::ParameterDescription<edm::InputTag>("beamLineSrc", edm::InputTag(), true)
526  )->setComment("input with high level selection");
528  )->setComment("input with high level selection");
529  iDesc.addNode( edm::ParameterDescription<bool>("usePV", bool(), true)
530  )->setComment("input with high level selection, use primary vertex (true) or beam line (false)");
531 
532  //descriptions.add("PATMuonProducer", iDesc);
533 }
534 
535 
536 
537 // embed various impact parameters with errors
538 // embed high level selection
540  reco::TrackRef track,
542  reco::Vertex & primaryVertex,
543  bool primaryVertexIsValid,
544  reco::BeamSpot & beamspot,
545  bool beamspotIsValid
546  )
547 {
548  // Correct to PV
549 
550  // PV2D
551  std::pair<bool,Measurement1D> result =
553  GlobalVector(track->px(),
554  track->py(),
555  track->pz()),
556  primaryVertex);
557  double d0_corr = result.second.value();
558  double d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
559  aMuon.setDB( d0_corr, d0_err, pat::Muon::PV2D);
560 
561 
562  // PV3D
563  result =
565  GlobalVector(track->px(),
566  track->py(),
567  track->pz()),
568  primaryVertex);
569  d0_corr = result.second.value();
570  d0_err = primaryVertexIsValid ? result.second.error() : -1.0;
571  aMuon.setDB( d0_corr, d0_err, pat::Muon::PV3D);
572 
573 
574  // Correct to beam spot
575  // make a fake vertex out of beam spot
576  reco::Vertex vBeamspot(beamspot.position(), beamspot.rotatedCovariance3D());
577 
578  // BS2D
579  result =
581  GlobalVector(track->px(),
582  track->py(),
583  track->pz()),
584  vBeamspot);
585  d0_corr = result.second.value();
586  d0_err = beamspotIsValid ? result.second.error() : -1.0;
587  aMuon.setDB( d0_corr, d0_err, pat::Muon::BS2D);
588 
589  // BS3D
590  result =
592  GlobalVector(track->px(),
593  track->py(),
594  track->pz()),
595  vBeamspot);
596  d0_corr = result.second.value();
597  d0_err = beamspotIsValid ? result.second.error() : -1.0;
598  aMuon.setDB( d0_corr, d0_err, pat::Muon::BS3D);
599 }
600 
602 
bool embedTpfmsMuon_
embed track from tpfms muon fit into the muon
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
bool useUserData_
add user data to the muon (this will be data members of th muon even w/o embedding) ...
T getParameter(std::string const &) const
void setComment(std::string const &value)
double z0() const
z coordinate
Definition: BeamSpot.h:68
Assists in assimilating all pat::UserData into pat objects.
bool usePV_
use the primary vertex or the beamspot
int i
Definition: DBlmapReader.cc:9
void embedStandAloneMuon()
set reference to Track reconstructed in the muon detector only (reimplemented from reco::Muon) ...
Definition: Muon.cc:236
boost::indirect_iterator< typename seq_t::const_iterator > const_iterator
Definition: View.h:81
ParameterDescriptionBase * addOptional(U const &iLabel, T const &value)
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > > tcMETMuonCorrsToken_
source of tcMET muon corrections
void setIsolation(IsolationKeys key, float value)
Definition: Lepton.h:98
bool embedTcMETMuonCorrs_
embed muon MET correction info for tcMET into the muon
class definition
bool existsAs(std::string const &parameterName, bool trackiness=true) const
checks if a parameter exists as a given type
Definition: ParameterSet.h:184
edm::EDGetTokenT< std::vector< reco::Vertex > > pvToken_
input source of the primary vertex
bool contains(EventRange const &lh, EventID const &rh)
Definition: EventRange.cc:38
void embedPFCandidate()
embed the IsolatedPFCandidate pointed to by pfCandidateRef_
Definition: Muon.cc:299
edm::EDGetTokenT< edm::View< reco::Muon > > muonToken_
input source
edm::EDGetTokenT< edm::ValueMap< reco::MuonMETCorrectionData > > caloMETMuonCorrsToken_
source of caloMET muon corrections
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:434
void setAllowAnything()
allow any parameter label/value pairs
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:17
bool embedCaloMETMuonCorrs_
embed muon MET correction info for caloMET into the muon
std::pair< bool, Measurement1D > signedTransverseImpactParameter(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:50
bool isGlobalMuon() const
Definition: Muon.h:218
ParameterDescriptionNode * addNode(ParameterDescriptionNode const &node)
bool embedBestTrack_
embed the track from best muon measurement
std::pair< bool, Measurement1D > signedImpactParameter3D(const reco::TransientTrack &track, const GlobalVector &direction, const reco::Vertex &vertex)
Definition: IPTools.cc:71
bool isAvailable() const
Definition: Ref.h:276
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
PFCandidateCollection::const_iterator PFCandidateConstIterator
iterator
ProductID id() const
Definition: RefToBase.h:220
void setResolutions(pat::PATObject< T > &obj) const
Sets the efficiencies for this object, using the reference to the original objects.
void setPFCandidateRef(const reco::PFCandidateRef &ref)
add a reference to the source IsolatedPFCandidate
Definition: Muon.h:122
bool isRealData() const
Definition: EventBase.h:60
void embedHighLevel(pat::Muon &aMuon, reco::TrackRef track, reco::TransientTrack &tt, reco::Vertex &primaryVertex, bool primaryVertexIsValid, reco::BeamSpot &beamspot, bool beamspotIsValid)
void embedPickyMuon()
embed reference to the above picky Track
Definition: Muon.cc:269
PATMuonProducer(const edm::ParameterSet &iConfig)
default constructir
edm::EDGetTokenT< reco::PFCandidateCollection > pfMuonToken_
input source pfCandidates that will be to be transformed into pat::Muons, when using PF2PAT ...
pat::helper::MultiIsolator isolator_
helper class to add userdefined isolation values to the muon
std::vector< edm::EDGetTokenT< edm::ValueMap< IsoDeposit > > > isoDepositTokens_
bool enabled() const
&#39;true&#39; if this there is at least one efficiency configured
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
void setIsoDeposit(IsolationKeys key, const IsoDeposit &dep)
Sets the IsoDeposit associated with some key; if it is already existent, it is overwritten.
Definition: Lepton.h:175
void embedCombinedMuon()
set reference to Track reconstructed in both tracked and muon detector (reimplemented from reco::Muon...
Definition: Muon.cc:246
static void fillDescription(edm::ParameterSetDescription &iDesc)
edm::EDGetTokenT< reco::BeamSpot > beamLineToken_
input source of the primary vertex/beamspot
void embedCaloMETMuonCorrs(const reco::MuonMETCorrectionData &t)
embed the MuonMETCorrectionData for muon corrected caloMET
Definition: Muon.cc:255
bool useParticleFlow_
switch to use particle flow (PF2PAT) or not
pat::PATUserDataHelper< pat::Muon > userDataHelper_
helper class to add userData to the muon
bool isAValidMuonTrack(const MuonTrackType &type) const
Definition: Muon.cc:853
bool enabled() const
True if it has a non null configuration.
Definition: MultiIsolator.h:50
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:250
bool embedStandAloneMuon_
embed track from muon system into the muon
void setComment(std::string const &value)
reco::PFCandidateRef pfCandidateRef() const
reference to the source IsolatedPFCandidates
Definition: Muon.cc:197
int iEvent
Definition: GenABIO.cc:243
void beginEvent(const edm::Event &event, const edm::EventSetup &eventSetup)
GreaterByPt< Muon > pTComparator_
bool embedTrack_
embed the track from inner tracker into the muon
bool addGenMatch_
add generator match information
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
description of config file parameters
OrphanHandle< PROD > put(std::auto_ptr< PROD > product)
Put a new product.
Definition: Event.h:116
void embedGenParticle()
Definition: PATObject.h:673
void embedTrack()
set reference to Track reconstructed in the tracker only (reimplemented from reco::Muon) ...
Definition: Muon.cc:226
void embedTcMETMuonCorrs(const reco::MuonMETCorrectionData &t)
embed the MuonMETCorrectionData for tcMET
Definition: Muon.cc:262
tuple result
Definition: query.py:137
virtual void produce(edm::Event &iEvent, const edm::EventSetup &iSetup) override
everything that needs to be done during the event loop
int j
Definition: DBlmapReader.cc:9
math::XYZPoint Point
point in the space
Definition: TrackBase.h:74
ParameterDescriptionBase * add(U const &iLabel, T const &value)
bool first
Definition: L1TdeRCT.cc:79
bool isValid() const
Definition: HandleBase.h:76
reco::MuonRef muonRef() const
Definition: PFCandidate.cc:446
void embedTpfmsMuon()
embed reference to the above tpfms Track
Definition: Muon.cc:279
void addGenParticleRef(const reco::GenParticleRef &ref)
Definition: PATObject.h:657
void embedDytMuon()
embed reference to the above dyt Track
Definition: Muon.cc:289
static void fillDescription(edm::ParameterSetDescription &iDesc)
Method for documentation and validation of PSet.
void embedMuonBestTrack()
set reference to Track selected to be the best measurement of the muon parameters (reimplemented from...
Definition: Muon.cc:215
tuple idx
DEBUGGING if hasattr(process,&quot;trackMonIterativeTracking2012&quot;): print &quot;trackMonIterativeTracking2012 D...
const T & get() const
Definition: EventSetup.h:55
void setEfficiencies(pat::PATObject< T > &obj, const R &originalRef) const
Sets the efficiencies for this object, using the reference to the original objects.
std::pair< bool, Measurement1D > absoluteTransverseImpactParameter(const reco::TransientTrack &transientTrack, const reco::Vertex &vertex)
Definition: IPTools.cc:43
std::vector< edm::Handle< edm::Association< reco::GenParticleCollection > > > GenAssociations
void fillMuon(Muon &aMuon, const MuonBaseRef &muonRef, const reco::CandidateBaseRef &baseRef, const GenAssociations &genMatches, const IsoDepositMaps &deposits, const IsolationValueMaps &isolationValues) const
common muon filling, for both the standard and PF2PAT case
std::vector< std::pair< pat::IsolationKeys, float > > IsolationValuePairs
Definition: MultiIsolator.h:16
Particle reconstructed by the particle flow algorithm.
Definition: PFCandidate.h:38
pat::helper::EfficiencyLoader efficiencyLoader_
helper class to add efficiencies to the muon
bool embedPickyMuon_
embed track from picky muon fit into the muon
void setNormChi2(double normChi2)
Definition: Muon.h:217
tuple muons
Definition: patZpeak.py:38
bool embedDytMuon_
embed track from DYT muon fit into the muon
virtual void setP4(const LorentzVector &p4) GCC11_FINAL
set 4-momentum
double y0() const
y coordinate
Definition: BeamSpot.h:66
std::vector< edm::Handle< edm::ValueMap< IsoDeposit > > > IsoDepositMaps
pat::helper::MultiIsolator::IsolationValuePairs isolatorTmpStorage_
isolation value pair for temporary storage before being folded into the muon
bool embedGenMatch_
embed the gen match information into the muon
const Point & position() const
position
Definition: BeamSpot.h:62
IsolationLabels isoDepositLabels_
input source for isoDeposits
std::vector< edm::EDGetTokenT< edm::Association< reco::GenParticleCollection > > > genMatchTokens_
input tags for generator match information
volatile std::atomic< bool > shutdown_flag false
Covariance3DMatrix rotatedCovariance3D() const
Definition: BeamSpot.cc:78
IsolationLabels isolationValueLabels_
input source isolation value maps
std::vector< edm::Handle< edm::ValueMap< double > > > IsolationValueMaps
bool embedPFCandidate_
embed pfCandidates into the muon
void newEvent(const edm::Event &event, const edm::EventSetup &setup) const
To be called for each new event, reads in the EventSetup object.
std::vector< edm::EDGetTokenT< edm::ValueMap< double > > > isolationValueTokens_
void setNumberOfValidHits(unsigned int numberOfValidHits)
Definition: Muon.h:212
bool embedCombinedMuon_
embed track of the combined fit into the muon
Analysis-level muon class.
Definition: Muon.h:49
pat::helper::KinResolutionsLoader resolutionLoader_
helper class to add resolutions to the muon
static std::string const source
Definition: EdmProvDump.cc:43
void newEvent(const edm::Event &event) const
To be called for each new event, reads in the ValueMaps for efficiencies.
void setDB(double dB, double edB, IpType type=None)
Definition: Muon.h:202
Global3DVector GlobalVector
Definition: GlobalVector.h:10
void fill(const edm::View< T > &coll, int idx, IsolationValuePairs &isolations) const
Definition: MultiIsolator.h:82
tuple pfMuons
Definition: pfMuons_cff.py:8
double x0() const
x coordinate
Definition: BeamSpot.h:64
bool embedHighLevelSelection_
embed high level selection variables