CMS 3D CMS Logo
List of all members | Classes | Public Types | Public Member Functions | Static Public Member Functions | Private Member Functions | Private Attributes
MuonIdProducer Class Reference

#include <MuonIdProducer.h>

Inheritance diagram for MuonIdProducer:
edm::stream::EDProducer<>

Classes

struct  ICTypes
 

Public Types

typedef reco::Muon::MuonTrackType TrackType
 
- 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 Member Functions

void beginRun (const edm::Run &, const edm::EventSetup &) override
 
 MuonIdProducer (const edm::ParameterSet &)
 
void produce (edm::Event &, const edm::EventSetup &) override
 
 ~MuonIdProducer () override
 
- 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)
 
static double sectorPhi (const DetId &id)
 

Private Member Functions

bool approxEqual (const double a, const double b, const double tol=1E-3) const
 
void arbitrateMuons (reco::MuonCollection *, reco::CaloMuonCollection *)
 
unsigned int chamberId (const DetId &)
 
bool checkLinks (const reco::MuonTrackLinks *) const
 
void fillArbitrationInfo (reco::MuonCollection *, unsigned int muonType=reco::Muon::TrackerMuon)
 
void fillGlbQuality (edm::Event &, const edm::EventSetup &, reco::Muon &aMuon)
 
void fillMuonId (edm::Event &, const edm::EventSetup &, reco::Muon &, TrackDetectorAssociator::Direction direction=TrackDetectorAssociator::InsideOut)
 
void fillMuonIsolation (edm::Event &, const edm::EventSetup &, reco::Muon &aMuon, reco::IsoDeposit &trackDep, reco::IsoDeposit &ecalDep, reco::IsoDeposit &hcalDep, reco::IsoDeposit &hoDep, reco::IsoDeposit &jetDep)
 
void fillTrackerKink (reco::Muon &aMuon)
 
std::vector< reco::MuonSegmentMatch > * getSegmentMatches (reco::MuonChamberMatch &chamber, unsigned int muonType) const
 get the segment matches of the appropriate type More...
 
void init (edm::Event &, const edm::EventSetup &)
 
bool isGoodCaloMuon (const reco::CaloMuon &muon)
 
bool isGoodGEMMuon (const reco::Muon &muon)
 
bool isGoodME0Muon (const reco::Muon &muon)
 
bool isGoodRPCMuon (const reco::Muon &muon)
 
bool isGoodTrack (const reco::Track &track)
 
bool isGoodTrackerMuon (const reco::Muon &muon)
 
reco::CaloMuon makeCaloMuon (const reco::Muon &)
 
reco::Muon makeMuon (const reco::MuonTrackLinks &links)
 
reco::Muon makeMuon (const reco::Track &track)
 
reco::Muon makeMuon (edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::TrackRef &track, TrackType type)
 
int overlap (const reco::Muon &muon, const reco::Track &track)
 
double phiOfMuonInteractionRegion (const reco::Muon &muon) const
 

Private Attributes

bool addExtraSoftMuons_
 
bool arbClean_
 
bool arbitrateTrackerMuons_
 
double caloCut_
 
bool debugWithTruthMatching_
 
edm::Handle< reco::TrackToTrackMap > dytCollectionHandle_
 
edm::EDGetTokenT< reco::TrackToTrackMap > dytCollectionToken_
 
std::string ecalDepositName_
 
bool fillCaloCompatibility_
 
bool fillEnergy_
 
bool fillGlobalTrackQuality_
 
bool fillGlobalTrackRefits_
 
bool fillIsolation_
 
bool fillMatching_
 
bool fillShowerDigis_
 
bool fillTrackerKink_
 
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > geomTokenRun_
 
edm::Handle< edm::ValueMap< reco::MuonQuality > > glbQualHandle_
 
edm::EDGetTokenT< edm::ValueMap< reco::MuonQuality > > glbQualToken_
 
edm::InputTag globalTrackQualityInputTag_
 
std::string hcalDepositName_
 
std::string hoDepositName_
 
edm::Handle< reco::TrackCollection > innerTrackCollectionHandle_
 
edm::EDGetTokenT< reco::TrackCollection > innerTrackCollectionToken_
 
std::vector< edm::InputTag > inputCollectionLabels_
 
std::vector< ICTypes::ICTypeKey > inputCollectionTypes_
 
std::string jetDepositName_
 
edm::Handle< reco::MuonTrackLinksCollection > linkCollectionHandle_
 
edm::EDGetTokenT< reco::MuonTrackLinksCollection > linkCollectionToken_
 
double maxAbsDx_
 
double maxAbsDy_
 
double maxAbsEta_
 
double maxAbsPullX2_
 
double maxAbsPullY2_
 
std::unique_ptr< MuonMesh > meshAlgo_
 
int minNumberOfMatches_
 
double minP_
 
double minPCaloMuon_
 
double minPt_
 
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorCalo_
 
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorJet_
 
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorTrack_
 
MuonCaloCompatibility muonCaloCompatibility_
 
edm::Handle< reco::MuonCollection > muonCollectionHandle_
 
edm::EDGetTokenT< reco::MuonCollection > muonCollectionToken_
 
edm::Handle< reco::TrackCollection > outerTrackCollectionHandle_
 
edm::EDGetTokenT< reco::TrackCollection > outerTrackCollectionToken_
 
TrackAssociatorParameters parameters_
 
edm::Handle< reco::TrackToTrackMap > pickyCollectionHandle_
 
edm::EDGetTokenT< reco::TrackToTrackMap > pickyCollectionToken_
 
const edm::ESGetToken< Propagator, TrackingComponentsRecord > propagatorToken_
 
double ptThresholdToFillCandidateP4WithGlobalFit_
 
edm::Handle< RPCRecHitCollection > rpcHitHandle_
 
edm::EDGetTokenT< RPCRecHitCollection > rpcHitToken_
 
double sigmaThresholdToFillCandidateP4WithGlobalFit_
 
bool storeCrossedHcalRecHits_
 
std::unique_ptr< MuonShowerDigiFiller > theShowerDigiFiller_
 
std::unique_ptr< MuonTimingFiller > theTimingFiller_
 
edm::Handle< reco::TrackToTrackMap > tpfmsCollectionHandle_
 
edm::EDGetTokenT< reco::TrackToTrackMap > tpfmsCollectionToken_
 
TrackDetectorAssociator trackAssociator_
 
std::string trackDepositName_
 
std::unique_ptr< MuonKinkFinder > trackerKinkFinder_
 
bool writeIsoDeposits_
 

Detailed Description

Definition at line 66 of file MuonIdProducer.h.

Member Typedef Documentation

◆ TrackType

typedef reco::Muon::MuonTrackType MuonIdProducer::TrackType

Definition at line 68 of file MuonIdProducer.h.

Constructor & Destructor Documentation

◆ MuonIdProducer()

MuonIdProducer::MuonIdProducer ( const edm::ParameterSet &  iConfig)
explicit

Definition at line 34 of file MuonIdProducer.cc.

35  : geomTokenRun_(esConsumes<edm::Transition::BeginRun>()),
36  propagatorToken_(esConsumes(edm::ESInputTag("", "SteppingHelixPropagatorAny"))) {
37  LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: Constructor called";
38 
39  produces<reco::MuonCollection>();
40  produces<reco::CaloMuonCollection>();
41  produces<reco::MuonTimeExtraMap>("combined");
42  produces<reco::MuonTimeExtraMap>("dt");
43  produces<reco::MuonTimeExtraMap>("csc");
44 
45  minPt_ = iConfig.getParameter<double>("minPt");
46  minP_ = iConfig.getParameter<double>("minP");
47  minPCaloMuon_ = iConfig.getParameter<double>("minPCaloMuon");
48  minNumberOfMatches_ = iConfig.getParameter<int>("minNumberOfMatches");
49  addExtraSoftMuons_ = iConfig.getParameter<bool>("addExtraSoftMuons");
50  maxAbsEta_ = iConfig.getParameter<double>("maxAbsEta");
51  maxAbsDx_ = iConfig.getParameter<double>("maxAbsDx");
52  maxAbsPullX2_ = iConfig.getParameter<double>("maxAbsPullX");
53  maxAbsPullX2_ *= maxAbsPullX2_;
54  maxAbsDy_ = iConfig.getParameter<double>("maxAbsDy");
55  maxAbsPullY2_ = iConfig.getParameter<double>("maxAbsPullY");
56  maxAbsPullY2_ *= maxAbsPullY2_;
57  fillCaloCompatibility_ = iConfig.getParameter<bool>("fillCaloCompatibility");
58  fillEnergy_ = iConfig.getParameter<bool>("fillEnergy");
59  storeCrossedHcalRecHits_ = iConfig.getParameter<bool>("storeCrossedHcalRecHits");
60  fillMatching_ = iConfig.getParameter<bool>("fillMatching");
61  fillIsolation_ = iConfig.getParameter<bool>("fillIsolation");
62  fillShowerDigis_ = iConfig.getParameter<bool>("fillShowerDigis");
63  writeIsoDeposits_ = iConfig.getParameter<bool>("writeIsoDeposits");
64  fillGlobalTrackQuality_ = iConfig.getParameter<bool>("fillGlobalTrackQuality");
65  fillGlobalTrackRefits_ = iConfig.getParameter<bool>("fillGlobalTrackRefits");
66  arbitrateTrackerMuons_ = iConfig.getParameter<bool>("arbitrateTrackerMuons");
67  //SK: (maybe temporary) run it only if the global is also run
68  fillTrackerKink_ = false;
69  if (fillGlobalTrackQuality_)
70  fillTrackerKink_ = iConfig.getParameter<bool>("fillTrackerKink");
71 
72  ptThresholdToFillCandidateP4WithGlobalFit_ =
73  iConfig.getParameter<double>("ptThresholdToFillCandidateP4WithGlobalFit");
74  sigmaThresholdToFillCandidateP4WithGlobalFit_ =
75  iConfig.getParameter<double>("sigmaThresholdToFillCandidateP4WithGlobalFit");
76  caloCut_ = iConfig.getParameter<double>("minCaloCompatibility"); //CaloMuons
77  arbClean_ = iConfig.getParameter<bool>("runArbitrationCleaner"); // muon mesh
78 
79  // Load TrackDetectorAssociator parameters
80  const edm::ParameterSet parameters = iConfig.getParameter<edm::ParameterSet>("TrackAssociatorParameters");
81  edm::ConsumesCollector iC = consumesCollector();
82  parameters_.loadParameters(parameters, iC);
83 
84  // Load parameters for the TimingFiller
85  edm::ParameterSet timingParameters = iConfig.getParameter<edm::ParameterSet>("TimingFillerParameters");
86  theTimingFiller_ = std::make_unique<MuonTimingFiller>(timingParameters, consumesCollector());
87 
88  // Load parameters for the ShowerDigiFiller
89  if (fillShowerDigis_ && fillMatching_) {
90  edm::ParameterSet showerDigiParameters = iConfig.getParameter<edm::ParameterSet>("ShowerDigiFillerParameters");
91  theShowerDigiFiller_ = std::make_unique<MuonShowerDigiFiller>(showerDigiParameters, consumesCollector());
92  }
93 
94  if (fillCaloCompatibility_) {
95  // Load MuonCaloCompatibility parameters
96  const auto caloParams = iConfig.getParameter<edm::ParameterSet>("MuonCaloCompatibility");
97  muonCaloCompatibility_.configure(caloParams);
98  }
99 
100  if (fillIsolation_) {
101  // Load MuIsoExtractor parameters
102  edm::ParameterSet caloExtractorPSet = iConfig.getParameter<edm::ParameterSet>("CaloExtractorPSet");
103  std::string caloExtractorName = caloExtractorPSet.getParameter<std::string>("ComponentName");
104  muIsoExtractorCalo_ =
105  IsoDepositExtractorFactory::get()->create(caloExtractorName, caloExtractorPSet, consumesCollector());
106 
107  edm::ParameterSet trackExtractorPSet = iConfig.getParameter<edm::ParameterSet>("TrackExtractorPSet");
108  std::string trackExtractorName = trackExtractorPSet.getParameter<std::string>("ComponentName");
109  muIsoExtractorTrack_ =
110  IsoDepositExtractorFactory::get()->create(trackExtractorName, trackExtractorPSet, consumesCollector());
111 
112  edm::ParameterSet jetExtractorPSet = iConfig.getParameter<edm::ParameterSet>("JetExtractorPSet");
113  std::string jetExtractorName = jetExtractorPSet.getParameter<std::string>("ComponentName");
114  muIsoExtractorJet_ =
115  IsoDepositExtractorFactory::get()->create(jetExtractorName, jetExtractorPSet, consumesCollector());
116  }
117  if (fillIsolation_ && writeIsoDeposits_) {
118  trackDepositName_ = iConfig.getParameter<std::string>("trackDepositName");
119  produces<reco::IsoDepositMap>(trackDepositName_);
120  ecalDepositName_ = iConfig.getParameter<std::string>("ecalDepositName");
121  produces<reco::IsoDepositMap>(ecalDepositName_);
122  hcalDepositName_ = iConfig.getParameter<std::string>("hcalDepositName");
123  produces<reco::IsoDepositMap>(hcalDepositName_);
124  hoDepositName_ = iConfig.getParameter<std::string>("hoDepositName");
125  produces<reco::IsoDepositMap>(hoDepositName_);
126  jetDepositName_ = iConfig.getParameter<std::string>("jetDepositName");
127  produces<reco::IsoDepositMap>(jetDepositName_);
128  }
129 
130  inputCollectionLabels_ = iConfig.getParameter<std::vector<edm::InputTag> >("inputCollectionLabels");
131  const auto inputCollectionTypes = iConfig.getParameter<std::vector<std::string> >("inputCollectionTypes");
132  if (inputCollectionLabels_.size() != inputCollectionTypes.size())
133  throw cms::Exception("ConfigurationError")
134  << "Number of input collection labels is different from number of types. "
135  << "For each collection label there should be exactly one collection type specified.";
136  if (inputCollectionLabels_.size() > 7 || inputCollectionLabels_.empty())
137  throw cms::Exception("ConfigurationError") << "Number of input collections should be from 1 to 7.";
138 
139  debugWithTruthMatching_ = iConfig.getParameter<bool>("debugWithTruthMatching");
140  if (debugWithTruthMatching_)
141  edm::LogWarning("MuonIdentification")
142  << "========================================================================\n"
143  << "Debugging mode with truth matching is turned on!!! Make sure you understand what you are doing!\n"
144  << "========================================================================\n";
145  if (fillGlobalTrackQuality_) {
146  const auto& glbQualTag = iConfig.getParameter<edm::InputTag>("globalTrackQualityInputTag");
147  glbQualToken_ = consumes<edm::ValueMap<reco::MuonQuality> >(glbQualTag);
148  }
149 
150  if (fillTrackerKink_) {
151  trackerKinkFinder_ =
152  std::make_unique<MuonKinkFinder>(iConfig.getParameter<edm::ParameterSet>("TrackerKinkFinderParameters"), iC);
153  }
154 
155  //create mesh holder
156  meshAlgo_ = std::make_unique<MuonMesh>(iConfig.getParameter<edm::ParameterSet>("arbitrationCleanerOptions"));
157 
158  edm::InputTag rpcHitTag("rpcRecHits");
159  rpcHitToken_ = consumes<RPCRecHitCollection>(rpcHitTag);
160 
161  //Consumes... UGH
162  inputCollectionTypes_.resize(inputCollectionLabels_.size());
163  for (unsigned int i = 0; i < inputCollectionLabels_.size(); ++i) {
164  const auto inputLabel = inputCollectionLabels_[i];
165  const auto inputType = ICTypes::toKey(inputCollectionTypes[i]); // Note: thorws exception if type is undefined.
166 
167  if (inputType == ICTypes::INNER_TRACKS) {
168  innerTrackCollectionToken_ = consumes<reco::TrackCollection>(inputLabel);
169  } else if (inputType == ICTypes::OUTER_TRACKS) {
170  outerTrackCollectionToken_ = consumes<reco::TrackCollection>(inputLabel);
171  } else if (inputType == ICTypes::LINKS) {
172  linkCollectionToken_ = consumes<reco::MuonTrackLinksCollection>(inputLabel);
173  } else if (inputType == ICTypes::MUONS) {
174  muonCollectionToken_ = consumes<reco::MuonCollection>(inputLabel);
175  } else if (inputType == ICTypes::TEV_FIRSTHIT) {
176  tpfmsCollectionToken_ = consumes<reco::TrackToTrackMap>(inputLabel);
177  } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_PICKY) {
178  pickyCollectionToken_ = consumes<reco::TrackToTrackMap>(inputLabel);
179  } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_DYT) {
180  dytCollectionToken_ = consumes<reco::TrackToTrackMap>(inputCollectionLabels_.at(i));
181  }
182 
183  inputCollectionTypes_[i] = inputType;
184  }
185 }

References addExtraSoftMuons_, arbClean_, arbitrateTrackerMuons_, caloCut_, caloParams_cfi::caloParams, MuonCaloCompatibility::configure(), debugWithTruthMatching_, dytCollectionToken_, ecalDepositName_, fillCaloCompatibility_, fillEnergy_, fillGlobalTrackQuality_, fillGlobalTrackRefits_, fillIsolation_, fillMatching_, fillShowerDigis_, fillTrackerKink_, get, edm::ParameterSet::getParameter(), glbQualToken_, hcalDepositName_, hoDepositName_, mps_fire::i, MuonIdProducer::ICTypes::INNER_TRACKS, innerTrackCollectionToken_, inputCollectionLabels_, HLT_FULL_cff::inputCollectionTypes, inputCollectionTypes_, DataMixerDataOnData_cff::inputLabel, jetDepositName_, linkCollectionToken_, MuonIdProducer::ICTypes::LINKS, TrackAssociatorParameters::loadParameters(), LogTrace, maxAbsDx_, maxAbsDy_, maxAbsEta_, maxAbsPullX2_, maxAbsPullY2_, meshAlgo_, minNumberOfMatches_, minP_, minPCaloMuon_, minPt_, muIsoExtractorCalo_, muIsoExtractorJet_, muIsoExtractorTrack_, muonCaloCompatibility_, muonCollectionToken_, MuonIdProducer::ICTypes::MUONS, MuonIdProducer::ICTypes::OUTER_TRACKS, outerTrackCollectionToken_, parameters_, pickyCollectionToken_, ptThresholdToFillCandidateP4WithGlobalFit_, rpcHitToken_, sigmaThresholdToFillCandidateP4WithGlobalFit_, storeCrossedHcalRecHits_, AlCaHLTBitMon_QueryRunRegistry::string, MuonIdProducer::ICTypes::TEV_DYT, MuonIdProducer::ICTypes::TEV_FIRSTHIT, MuonIdProducer::ICTypes::TEV_PICKY, theShowerDigiFiller_, theTimingFiller_, MuonIdProducer::ICTypes::toKey(), tpfmsCollectionToken_, trackDepositName_, trackerKinkFinder_, and writeIsoDeposits_.

◆ ~MuonIdProducer()

MuonIdProducer::~MuonIdProducer ( )
override

Definition at line 187 of file MuonIdProducer.cc.

187  {
188  // TimingReport::current()->dump(std::cout);
189 }

Member Function Documentation

◆ approxEqual()

bool MuonIdProducer::approxEqual ( const double  a,
const double  b,
const double  tol = 1E-3 
) const
inlineprivate

Definition at line 128 of file MuonIdProducer.h.

128  {
129  return std::abs(a - b) < tol;
130  }

References a, funct::abs(), and b.

Referenced by fillArbitrationInfo().

◆ arbitrateMuons()

void MuonIdProducer::arbitrateMuons ( reco::MuonCollection *  muons,
reco::CaloMuonCollection *  caloMuons 
)
private

Definition at line 1027 of file MuonIdProducer.cc.

1027  {
1028  reco::Muon::ArbitrationType arbitration = reco::Muon::SegmentAndTrackArbitration;
1029  // arbitrate TrackerMuons
1030  // if a muon was exclusively TrackerMuon check if it can be a calo muon
1031  for (reco::MuonCollection::iterator muon = muons->begin(); muon != muons->end();) {
1032  if (muon->isTrackerMuon()) {
1033  if (muon->numberOfMatches(arbitration) < minNumberOfMatches_) {
1034  // TrackerMuon failed arbitration
1035  // If not any other base type - erase the element
1036  // (PFMuon is not a base type)
1037  unsigned int mask = reco::Muon::TrackerMuon | reco::Muon::PFMuon;
1038  if ((muon->type() & (~mask)) == 0) {
1039  const reco::CaloMuon& caloMuon = makeCaloMuon(*muon);
1040  if (isGoodCaloMuon(caloMuon))
1041  caloMuons->push_back(caloMuon);
1042  muon = muons->erase(muon);
1043  continue;
1044  } else {
1045  muon->setType(muon->type() & (~reco::Muon::TrackerMuon));
1046  }
1047  }
1048  }
1049  muon++;
1050  }
1051 }

References mergedMuons_cfi::caloMuons, isGoodCaloMuon(), makeCaloMuon(), minNumberOfMatches_, PDWG_BPHSkim_cff::muons, reco::Muon::PFMuon, reco::Muon::SegmentAndTrackArbitration, and reco::Muon::TrackerMuon.

Referenced by produce().

◆ beginRun()

void MuonIdProducer::beginRun ( const edm::Run &  iRun,
const edm::EventSetup &  iSetup 
)
override

Definition at line 414 of file MuonIdProducer.cc.

414  {
415  meshAlgo_->setCSCGeometry(&iSetup.getData(geomTokenRun_));
416 
417  if (fillShowerDigis_ && fillMatching_)
418  theShowerDigiFiller_->getES(iSetup);
419 }

References fillMatching_, fillShowerDigis_, geomTokenRun_, edm::EventSetup::getData(), meshAlgo_, and theShowerDigiFiller_.

◆ chamberId()

unsigned int MuonIdProducer::chamberId ( const DetId &  id)
private

Definition at line 371 of file MuonIdProducer.cc.

371  {
372  if (id.det() != DetId::Muon)
373  return 0;
374 
375  const auto subdetId = id.subdetId();
376  if (subdetId == MuonSubdetId::DT) {
377  return DTChamberId(id.rawId()).rawId();
378  } else if (subdetId == MuonSubdetId::CSC) {
379  return CSCDetId(id.rawId()).chamberId().rawId();
380  }
381 
382  return 0;
383 }

References CSCDetId::chamberId(), MuonSubdetId::CSC, MuonSubdetId::DT, DetId::Muon, and DetId::rawId().

Referenced by overlap().

◆ checkLinks()

bool MuonIdProducer::checkLinks ( const reco::MuonTrackLinks *  links) const
private

Definition at line 1369 of file MuonIdProducer.cc.

1369  {
1370  const bool trackBAD = links->trackerTrack().isNull();
1371  const bool staBAD = links->standAloneTrack().isNull();
1372  const bool glbBAD = links->globalTrack().isNull();
1373  if (trackBAD || staBAD || glbBAD) {
1374  edm::LogWarning("muonIDbadLinks") << "Global muon links to constituent tracks are invalid: trkBad " << trackBAD
1375  << " standaloneBad " << staBAD << " globalBad " << glbBAD
1376  << ". There should be no such object. Muon is skipped.";
1377  return false;
1378  }
1379  return true;
1380 }

References electronStore::links.

Referenced by produce().

◆ fillArbitrationInfo()

void MuonIdProducer::fillArbitrationInfo ( reco::MuonCollection *  pOutputMuons,
unsigned int  muonType = reco::Muon::TrackerMuon 
)
private

Definition at line 1053 of file MuonIdProducer.cc.

1053  {
1054  //
1055  // apply segment flags
1056  //
1057  std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> > chamberPairs; // for chamber segment sorting
1058  std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> > stationPairs; // for station segment sorting
1059  std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> >
1060  arbitrationPairs; // for muon segment arbitration
1061 
1062  // muonIndex1
1063  for (unsigned int muonIndex1 = 0; muonIndex1 < pOutputMuons->size(); ++muonIndex1) {
1064  auto& muon1 = pOutputMuons->at(muonIndex1);
1065  // chamberIter1
1066  for (auto& chamber1 : muon1.matches()) {
1067  // segmentIter1
1068  std::vector<reco::MuonSegmentMatch>* segmentMatches1 = getSegmentMatches(chamber1, muonType);
1069 
1070  if (segmentMatches1->empty())
1071  continue;
1072  chamberPairs.clear();
1073 
1074  for (auto& segment1 : *segmentMatches1) {
1075  chamberPairs.push_back(std::make_pair(&chamber1, &segment1));
1076  if (!segment1.isMask()) // has not yet been arbitrated
1077  {
1078  arbitrationPairs.clear();
1079  arbitrationPairs.push_back(std::make_pair(&chamber1, &segment1));
1080 
1081  // find identical segments with which to arbitrate
1082  // tracker muons only
1083  if (muon1.type() & muonType) {
1084  // muonIndex2
1085  for (unsigned int muonIndex2 = muonIndex1 + 1; muonIndex2 < pOutputMuons->size(); ++muonIndex2) {
1086  auto& muon2 = pOutputMuons->at(muonIndex2);
1087  // tracker muons only
1088  if (!(muon2.type() & muonType))
1089  continue;
1090  // chamberIter2
1091  for (auto& chamber2 : muon2.matches()) {
1092  // segmentIter2
1093  std::vector<reco::MuonSegmentMatch>* segmentMatches2 = getSegmentMatches(chamber2, muonType);
1094  for (auto& segment2 : *segmentMatches2) {
1095  if (segment2.isMask())
1096  continue; // has already been arbitrated
1097  if (approxEqual(segment2.x, segment1.x) && approxEqual(segment2.y, segment1.y) &&
1098  approxEqual(segment2.dXdZ, segment1.dXdZ) && approxEqual(segment2.dYdZ, segment1.dYdZ) &&
1099  approxEqual(segment2.xErr, segment1.xErr) && approxEqual(segment2.yErr, segment1.yErr) &&
1100  approxEqual(segment2.dXdZErr, segment1.dXdZErr) &&
1101  approxEqual(segment2.dYdZErr, segment1.dYdZErr)) {
1102  arbitrationPairs.push_back(std::make_pair(&chamber2, &segment2));
1103  }
1104  } // segmentIter2
1105  } // chamberIter2
1106  } // muonIndex2
1107  }
1108 
1109  // arbitration segment sort
1110  if (arbitrationPairs.empty())
1111  continue; // this should never happen
1112  if (arbitrationPairs.size() == 1) {
1113  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDRSlope);
1114  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDXSlope);
1115  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDR);
1116  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDX);
1117  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::Arbitrated);
1118  } else {
1119  sort(arbitrationPairs.begin(),
1120  arbitrationPairs.end(),
1121  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDRSlope));
1122  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDRSlope);
1123  sort(arbitrationPairs.begin(),
1124  arbitrationPairs.end(),
1125  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDXSlope));
1126  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDXSlope);
1127  sort(arbitrationPairs.begin(),
1128  arbitrationPairs.end(),
1129  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDR));
1130  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDR);
1131  sort(arbitrationPairs.begin(),
1132  arbitrationPairs.end(),
1133  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDX));
1134  arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDX);
1135  for (auto& ap : arbitrationPairs) {
1136  ap.second->setMask(reco::MuonSegmentMatch::Arbitrated);
1137  }
1138  }
1139  }
1140 
1141  // setup me1a cleaning for later
1142  if (muonType == reco::Muon::TrackerMuon && chamber1.id.subdetId() == MuonSubdetId::CSC && arbClean_ &&
1143  CSCDetId(chamber1.id).ring() == 4) {
1144  for (auto& segment2 : chamber1.segmentMatches) {
1145  if (segment1.cscSegmentRef.isNull() || segment2.cscSegmentRef.isNull())
1146  continue;
1147  if (meshAlgo_->isDuplicateOf(segment1.cscSegmentRef, segment2.cscSegmentRef) &&
1148  (segment2.mask & 0x1e0000) && (segment1.mask & 0x1e0000)) {
1149  segment2.setMask(reco::MuonSegmentMatch::BelongsToTrackByME1aClean);
1150  //if the track has lost the segment already through normal arbitration no need to do it again.
1151  }
1152  }
1153  } // mark all ME1/a duplicates that this track owns
1154 
1155  } // segmentIter1
1156 
1157  // chamber segment sort
1158  if (chamberPairs.empty())
1159  continue; // this should never happen
1160  if (chamberPairs.size() == 1) {
1161  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDRSlope);
1162  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDXSlope);
1163  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDR);
1164  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDX);
1165  } else {
1166  sort(chamberPairs.begin(),
1167  chamberPairs.end(),
1168  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDRSlope));
1169  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDRSlope);
1170  sort(chamberPairs.begin(),
1171  chamberPairs.end(),
1172  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDXSlope));
1173  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDXSlope);
1174  sort(chamberPairs.begin(),
1175  chamberPairs.end(),
1176  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDR));
1177  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDR);
1178  sort(chamberPairs.begin(),
1179  chamberPairs.end(),
1180  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDX));
1181  chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDX);
1182  }
1183  } // chamberIter1
1184 
1185  // station segment sort
1186  for (int stationIndex = 1; stationIndex < 5; ++stationIndex) {
1187  for (int detectorIndex = 1; detectorIndex <= 5;
1188  ++detectorIndex) // 1-5, as in DataFormats/MuonDetId/interface/MuonSubdetId.h
1189  {
1190  stationPairs.clear();
1191 
1192  // chamberIter
1193  for (auto& chamber : muon1.matches()) {
1194  if (!(chamber.station() == stationIndex && chamber.detector() == detectorIndex))
1195  continue;
1196  std::vector<reco::MuonSegmentMatch>* segmentMatches = getSegmentMatches(chamber, muonType);
1197  if (segmentMatches->empty())
1198  continue;
1199 
1200  for (auto& segment : *segmentMatches) {
1201  stationPairs.push_back(std::make_pair(&chamber, &segment));
1202  }
1203  } // chamberIter
1204 
1205  if (stationPairs.empty())
1206  continue; // this may very well happen
1207  if (stationPairs.size() == 1) {
1208  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDRSlope);
1209  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDXSlope);
1210  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDR);
1211  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDX);
1212  } else {
1213  sort(stationPairs.begin(),
1214  stationPairs.end(),
1215  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDRSlope));
1216  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDRSlope);
1217  sort(stationPairs.begin(),
1218  stationPairs.end(),
1219  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDXSlope));
1220  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDXSlope);
1221  sort(stationPairs.begin(),
1222  stationPairs.end(),
1223  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDR));
1224  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDR);
1225  sort(stationPairs.begin(),
1226  stationPairs.end(),
1227  SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDX));
1228  stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDX);
1229  }
1230  }
1231  }
1232 
1233  } // muonIndex1
1234 
1235  if (arbClean_) {
1236  // clear old mesh, create and prune new mesh!
1237  meshAlgo_->clearMesh();
1238  meshAlgo_->runMesh(pOutputMuons);
1239  }
1240 }

References approxEqual(), arbClean_, reco::MuonSegmentMatch::Arbitrated, reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BelongsToTrackByDRSlope, reco::MuonSegmentMatch::BelongsToTrackByDX, reco::MuonSegmentMatch::BelongsToTrackByDXSlope, reco::MuonSegmentMatch::BelongsToTrackByME1aClean, reco::MuonSegmentMatch::BestInChamberByDR, reco::MuonSegmentMatch::BestInChamberByDRSlope, reco::MuonSegmentMatch::BestInChamberByDX, reco::MuonSegmentMatch::BestInChamberByDXSlope, reco::MuonSegmentMatch::BestInStationByDR, reco::MuonSegmentMatch::BestInStationByDRSlope, reco::MuonSegmentMatch::BestInStationByDX, reco::MuonSegmentMatch::BestInStationByDXSlope, relativeConstraints::chamber, MuonSubdetId::CSC, getSegmentMatches(), meshAlgo_, CSCDetId::ring(), plotscripts::stationIndex(), and reco::Muon::TrackerMuon.

Referenced by produce().

◆ fillDescriptions()

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

Definition at line 1382 of file MuonIdProducer.cc.

1382  {
1383  edm::ParameterSetDescription desc;
1384  desc.setAllowAnything();
1385 
1386  desc.add<bool>("arbitrateTrackerMuons", false);
1387  desc.add<bool>("storeCrossedHcalRecHits", false);
1388  desc.add<bool>("fillShowerDigis", false);
1389 
1390  edm::ParameterSetDescription descTrkAsoPar;
1391  descTrkAsoPar.add<edm::InputTag>("GEMSegmentCollectionLabel", edm::InputTag("gemSegments"));
1392  descTrkAsoPar.add<edm::InputTag>("ME0SegmentCollectionLabel", edm::InputTag("me0Segments"));
1393  descTrkAsoPar.add<bool>("useGEM", false);
1394  descTrkAsoPar.add<bool>("useME0", false);
1395  descTrkAsoPar.setAllowAnything();
1396  desc.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
1397 
1398  edm::ParameterSetDescription descJet;
1399  descJet.setAllowAnything();
1400  descJet.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
1401  desc.add<edm::ParameterSetDescription>("JetExtractorPSet", descJet);
1402 
1403  edm::ParameterSetDescription descCalo;
1404  descCalo.setAllowAnything();
1405  descCalo.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
1406  desc.add<edm::ParameterSetDescription>("CaloExtractorPSet", descCalo);
1407 
1408  descriptions.addDefault(desc);
1409 }

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and edm::ParameterSetDescription::setAllowAnything().

◆ fillGlbQuality()

void MuonIdProducer::fillGlbQuality ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup,
reco::Muon &  aMuon 
)
private

Definition at line 1348 of file MuonIdProducer.cc.

1348  {
1349  if (aMuon.isGlobalMuon() && glbQualHandle_.isValid() && !glbQualHandle_.failedToGet()) {
1350  aMuon.setCombinedQuality((*glbQualHandle_)[aMuon.combinedMuon()]);
1351  }
1352 
1353  LogDebug("MuonIdentification") << "tkChiVal " << aMuon.combinedQuality().trkRelChi2;
1354 }

References reco::Muon::combinedMuon(), reco::Muon::combinedQuality(), edm::HandleBase::failedToGet(), glbQualHandle_, reco::Muon::isGlobalMuon(), edm::HandleBase::isValid(), LogDebug, reco::Muon::setCombinedQuality(), and reco::MuonQuality::trkRelChi2.

Referenced by produce().

◆ fillMuonId()

void MuonIdProducer::fillMuonId ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup,
reco::Muon &  aMuon,
TrackDetectorAssociator::Direction  direction = TrackDetectorAssociator::InsideOut 
)
private

Definition at line 792 of file MuonIdProducer.cc.

795  {
796  LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId";
797 
798  // perform track - detector association
799  const reco::Track* track = nullptr;
800  if (aMuon.track().isNonnull())
801  track = aMuon.track().get();
802  else if (aMuon.standAloneMuon().isNonnull())
803  track = aMuon.standAloneMuon().get();
804  else
805  throw cms::Exception("FatalError")
806  << "Failed to fill muon id information for a muon with undefined references to tracks";
807 
808  TrackDetMatchInfo info = trackAssociator_.associate(iEvent, iSetup, *track, parameters_, direction);
809 
810  LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fillEnergy = " << fillEnergy_;
811 
812  if (fillEnergy_) {
813  reco::MuonEnergy muonEnergy;
814  muonEnergy.em = info.crossedEnergy(TrackDetMatchInfo::EcalRecHits);
815  muonEnergy.had = info.crossedEnergy(TrackDetMatchInfo::HcalRecHits);
816  muonEnergy.ho = info.crossedEnergy(TrackDetMatchInfo::HORecHits);
817  muonEnergy.tower = info.crossedEnergy(TrackDetMatchInfo::TowerTotal);
818  muonEnergy.emS9 = info.nXnEnergy(TrackDetMatchInfo::EcalRecHits, 1); // 3x3 energy
819  muonEnergy.emS25 = info.nXnEnergy(TrackDetMatchInfo::EcalRecHits, 2); // 5x5 energy
820  muonEnergy.hadS9 = info.nXnEnergy(TrackDetMatchInfo::HcalRecHits, 1); // 3x3 energy
821  muonEnergy.hoS9 = info.nXnEnergy(TrackDetMatchInfo::HORecHits, 1); // 3x3 energy
822  muonEnergy.towerS9 = info.nXnEnergy(TrackDetMatchInfo::TowerTotal, 1); // 3x3 energy
823  if (storeCrossedHcalRecHits_) {
824  muonEnergy.crossedHadRecHits.clear();
825  for (auto hit : info.crossedHcalRecHits) {
826  reco::HcalMuonRecHit mhit;
827  mhit.energy = hit->energy();
828  mhit.chi2 = hit->chi2();
829  mhit.time = hit->time();
830  mhit.detId = hit->id();
831  muonEnergy.crossedHadRecHits.push_back(mhit);
832  }
833  }
834  muonEnergy.ecal_position = info.trkGlobPosAtEcal;
835  muonEnergy.hcal_position = info.trkGlobPosAtHcal;
836  if (!info.crossedEcalIds.empty())
837  muonEnergy.ecal_id = info.crossedEcalIds.front();
838  if (!info.crossedHcalIds.empty())
839  muonEnergy.hcal_id = info.crossedHcalIds.front();
840  // find maximal energy depositions and their time
841  DetId emMaxId = info.findMaxDeposition(TrackDetMatchInfo::EcalRecHits, 2); // max energy deposit in 5x5 shape
842  for (const auto& hit : info.ecalRecHits) {
843  if (hit->id() != emMaxId)
844  continue;
845  muonEnergy.emMax = hit->energy();
846  muonEnergy.ecal_time = hit->time();
847  }
848  DetId hadMaxId = info.findMaxDeposition(TrackDetMatchInfo::HcalRecHits, 1); // max energy deposit in 3x3 shape
849  for (const auto& hit : info.hcalRecHits) {
850  if (hit->id() != hadMaxId)
851  continue;
852  muonEnergy.hadMax = hit->energy();
853  muonEnergy.hcal_time = hit->time();
854  }
855  aMuon.setCalEnergy(muonEnergy);
856  }
857  if (!fillMatching_ && !aMuon.isTrackerMuon() && !aMuon.isRPCMuon())
858  return;
859 
860  // fill muon match info
861  LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fill muon match info ";
862  std::vector<reco::MuonChamberMatch> muonChamberMatches;
863  unsigned int nubmerOfMatchesAccordingToTrackAssociator = 0;
864  for (const auto& chamber : info.chambers) {
865  if (chamber.id.subdetId() == MuonSubdetId::RPC && rpcHitHandle_.isValid())
866  continue; // Skip RPC chambers, they are taken care of below)
867  reco::MuonChamberMatch matchedChamber;
868 
869  const auto& lErr = chamber.tState.localError();
870  const auto& lPos = chamber.tState.localPosition();
871  const auto& lDir = chamber.tState.localDirection();
872 
873  const auto& localError = lErr.positionError();
874  matchedChamber.x = lPos.x();
875  matchedChamber.y = lPos.y();
876  matchedChamber.xErr = sqrt(localError.xx());
877  matchedChamber.yErr = sqrt(localError.yy());
878 
879  matchedChamber.dXdZ = lDir.z() != 0 ? lDir.x() / lDir.z() : 9999;
880  matchedChamber.dYdZ = lDir.z() != 0 ? lDir.y() / lDir.z() : 9999;
881  // DANGEROUS - compiler cannot guaranty parameters ordering
882  AlgebraicSymMatrix55 trajectoryCovMatrix = lErr.matrix();
883  matchedChamber.dXdZErr = trajectoryCovMatrix(1, 1) > 0 ? sqrt(trajectoryCovMatrix(1, 1)) : 0;
884  matchedChamber.dYdZErr = trajectoryCovMatrix(2, 2) > 0 ? sqrt(trajectoryCovMatrix(2, 2)) : 0;
885 
886  matchedChamber.edgeX = chamber.localDistanceX;
887  matchedChamber.edgeY = chamber.localDistanceY;
888 
889  matchedChamber.id = chamber.id;
890 
891  if (fillShowerDigis_) {
892  theShowerDigiFiller_->fill(matchedChamber);
893  } else {
894  theShowerDigiFiller_->fillDefault(matchedChamber);
895  }
896 
897  if (!chamber.segments.empty())
898  ++nubmerOfMatchesAccordingToTrackAssociator;
899 
900  // fill segments
901  for (const auto& segment : chamber.segments) {
902  reco::MuonSegmentMatch matchedSegment;
903  matchedSegment.x = segment.segmentLocalPosition.x();
904  matchedSegment.y = segment.segmentLocalPosition.y();
905  matchedSegment.dXdZ =
906  segment.segmentLocalDirection.z() ? segment.segmentLocalDirection.x() / segment.segmentLocalDirection.z() : 0;
907  matchedSegment.dYdZ =
908  segment.segmentLocalDirection.z() ? segment.segmentLocalDirection.y() / segment.segmentLocalDirection.z() : 0;
909  matchedSegment.xErr = segment.segmentLocalErrorXX > 0 ? sqrt(segment.segmentLocalErrorXX) : 0;
910  matchedSegment.yErr = segment.segmentLocalErrorYY > 0 ? sqrt(segment.segmentLocalErrorYY) : 0;
911  matchedSegment.dXdZErr = segment.segmentLocalErrorDxDz > 0 ? sqrt(segment.segmentLocalErrorDxDz) : 0;
912  matchedSegment.dYdZErr = segment.segmentLocalErrorDyDz > 0 ? sqrt(segment.segmentLocalErrorDyDz) : 0;
913  matchedSegment.t0 = segment.t0;
914  matchedSegment.mask = 0;
915  matchedSegment.dtSegmentRef = segment.dtSegmentRef;
916  matchedSegment.cscSegmentRef = segment.cscSegmentRef;
917  matchedSegment.gemSegmentRef = segment.gemSegmentRef;
918  matchedSegment.me0SegmentRef = segment.me0SegmentRef;
919  matchedSegment.hasZed_ = segment.hasZed;
920  matchedSegment.hasPhi_ = segment.hasPhi;
921  // test segment
922  bool matchedX = false;
923  bool matchedY = false;
924  LogTrace("MuonIdentification") << " matching local x, segment x: " << matchedSegment.x
925  << ", chamber x: " << matchedChamber.x << ", max: " << maxAbsDx_;
926  LogTrace("MuonIdentification") << " matching local y, segment y: " << matchedSegment.y
927  << ", chamber y: " << matchedChamber.y << ", max: " << maxAbsDy_;
928  const double matchedSegChDx = std::abs(matchedSegment.x - matchedChamber.x);
929  const double matchedSegChDy = std::abs(matchedSegment.y - matchedChamber.y);
930  if (matchedSegment.xErr > 0 && matchedChamber.xErr > 0)
931  LogTrace("MuonIdentification") << " xpull: "
932  << matchedSegChDx / std::sqrt(std::pow(matchedSegment.xErr, 2) +
933  std::pow(matchedChamber.xErr, 2));
934  if (matchedSegment.yErr > 0 && matchedChamber.yErr > 0)
935  LogTrace("MuonIdentification") << " ypull: "
936  << matchedSegChDy / std::sqrt(std::pow(matchedSegment.yErr, 2) +
937  std::pow(matchedChamber.yErr, 2));
938 
939  if (matchedSegChDx < maxAbsDx_)
940  matchedX = true;
941  else if (matchedSegment.xErr > 0 && matchedChamber.xErr > 0) {
942  const double invMatchedSegChPullX2 = std::pow(matchedSegment.xErr, 2) + std::pow(matchedChamber.xErr, 2);
943  if (matchedSegChDx * matchedSegChDx < maxAbsPullX2_ * invMatchedSegChPullX2)
944  matchedX = true;
945  }
946  if (matchedSegChDy < maxAbsDy_)
947  matchedY = true;
948  else if (matchedSegment.yErr > 0 && matchedChamber.yErr > 0) {
949  const double invMatchedSegChPullY2 = std::pow(matchedSegment.yErr, 2) + std::pow(matchedChamber.yErr, 2);
950  if (matchedSegChDy * matchedSegChDy < maxAbsPullY2_ * invMatchedSegChPullY2)
951  matchedY = true;
952  }
953  if (matchedX && matchedY) {
954  if (matchedChamber.id.subdetId() == MuonSubdetId::ME0)
955  matchedChamber.me0Matches.push_back(matchedSegment);
956  else if (matchedChamber.id.subdetId() == MuonSubdetId::GEM)
957  matchedChamber.gemMatches.push_back(matchedSegment);
958  else
959  matchedChamber.segmentMatches.push_back(matchedSegment);
960  }
961  }
962  muonChamberMatches.push_back(matchedChamber);
963  }
964 
965  // Fill RPC info
966  LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fill RPC info";
967  if (rpcHitHandle_.isValid()) {
968  for (const auto& chamber : info.chambers) {
969  if (chamber.id.subdetId() != MuonSubdetId::RPC)
970  continue; // Consider RPC chambers only
971  const auto& lErr = chamber.tState.localError();
972  const auto& lPos = chamber.tState.localPosition();
973  const auto& lDir = chamber.tState.localDirection();
974 
975  reco::MuonChamberMatch matchedChamber;
976 
977  LocalError localError = lErr.positionError();
978  matchedChamber.x = lPos.x();
979  matchedChamber.y = lPos.y();
980  matchedChamber.xErr = sqrt(localError.xx());
981  matchedChamber.yErr = sqrt(localError.yy());
982 
983  matchedChamber.dXdZ = lDir.z() != 0 ? lDir.x() / lDir.z() : 9999;
984  matchedChamber.dYdZ = lDir.z() != 0 ? lDir.y() / lDir.z() : 9999;
985  // DANGEROUS - compiler cannot guaranty parameters ordering
986  AlgebraicSymMatrix55 trajectoryCovMatrix = lErr.matrix();
987  matchedChamber.dXdZErr = trajectoryCovMatrix(1, 1) > 0 ? sqrt(trajectoryCovMatrix(1, 1)) : 0;
988  matchedChamber.dYdZErr = trajectoryCovMatrix(2, 2) > 0 ? sqrt(trajectoryCovMatrix(2, 2)) : 0;
989 
990  matchedChamber.edgeX = chamber.localDistanceX;
991  matchedChamber.edgeY = chamber.localDistanceY;
992 
993  theShowerDigiFiller_->fillDefault(matchedChamber);
994 
995  matchedChamber.id = chamber.id;
996 
997  for (const auto& rpcRecHit : *rpcHitHandle_) {
998  reco::MuonRPCHitMatch rpcHitMatch;
999 
1000  if (rpcRecHit.rawId() != chamber.id.rawId())
1001  continue;
1002 
1003  rpcHitMatch.x = rpcRecHit.localPosition().x();
1004  rpcHitMatch.mask = 0;
1005  rpcHitMatch.bx = rpcRecHit.BunchX();
1006 
1007  const double absDx = std::abs(rpcRecHit.localPosition().x() - chamber.tState.localPosition().x());
1008  if (absDx <= 20 or absDx * absDx <= 16 * localError.xx())
1009  matchedChamber.rpcMatches.push_back(rpcHitMatch);
1010  }
1011 
1012  muonChamberMatches.push_back(matchedChamber);
1013  }
1014  }
1015 
1016  aMuon.setMatches(muonChamberMatches);
1017 
1018  LogTrace("MuonIdentification") << "number of muon chambers: " << aMuon.matches().size() << "\n"
1019  << "number of chambers with segments according to the associator requirements: "
1020  << nubmerOfMatchesAccordingToTrackAssociator;
1021  LogTrace("MuonIdentification") << "number of segment matches with the producer requirements: "
1022  << aMuon.numberOfMatches(reco::Muon::NoArbitration);
1023 
1024  // fillTime( iEvent, iSetup, aMuon );
1025 }

References funct::abs(), TrackDetectorAssociator::associate(), reco::MuonRPCHitMatch::bx, relativeConstraints::chamber, reco::HcalMuonRecHit::chi2, reco::MuonEnergy::crossedHadRecHits, reco::MuonSegmentMatch::cscSegmentRef, reco::HcalMuonRecHit::detId, reco::MuonSegmentMatch::dtSegmentRef, reco::MuonChamberMatch::dXdZ, reco::MuonSegmentMatch::dXdZ, reco::MuonChamberMatch::dXdZErr, reco::MuonSegmentMatch::dXdZErr, reco::MuonChamberMatch::dYdZ, reco::MuonSegmentMatch::dYdZ, reco::MuonChamberMatch::dYdZErr, reco::MuonSegmentMatch::dYdZErr, reco::MuonEnergy::ecal_id, reco::MuonEnergy::ecal_position, reco::MuonEnergy::ecal_time, TrackDetMatchInfo::EcalRecHits, reco::MuonChamberMatch::edgeX, reco::MuonChamberMatch::edgeY, reco::MuonEnergy::em, reco::MuonEnergy::emMax, reco::MuonEnergy::emS25, reco::MuonEnergy::emS9, reco::HcalMuonRecHit::energy, Exception, fillEnergy_, fillMatching_, fillShowerDigis_, MuonSubdetId::GEM, reco::MuonChamberMatch::gemMatches, reco::MuonSegmentMatch::gemSegmentRef, edm::Ref< C, T, F >::get(), reco::MuonEnergy::had, reco::MuonEnergy::hadMax, reco::MuonEnergy::hadS9, reco::MuonSegmentMatch::hasPhi_, reco::MuonSegmentMatch::hasZed_, reco::MuonEnergy::hcal_id, reco::MuonEnergy::hcal_position, reco::MuonEnergy::hcal_time, TrackDetMatchInfo::HcalRecHits, reco::MuonEnergy::ho, TrackDetMatchInfo::HORecHits, reco::MuonEnergy::hoS9, reco::MuonChamberMatch::id, hit::id, iEvent, info(), edm::Ref< C, T, F >::isNonnull(), reco::Muon::isRPCMuon(), reco::Muon::isTrackerMuon(), edm::HandleBase::isValid(), LogTrace, reco::MuonRPCHitMatch::mask, reco::MuonSegmentMatch::mask, reco::Muon::matches(), maxAbsDx_, maxAbsDy_, maxAbsPullX2_, maxAbsPullY2_, MuonSubdetId::ME0, reco::MuonChamberMatch::me0Matches, reco::MuonSegmentMatch::me0SegmentRef, reco::Muon::NoArbitration, reco::Muon::numberOfMatches(), or, parameters_, funct::pow(), MuonSubdetId::RPC, rpcHitHandle_, reco::MuonChamberMatch::rpcMatches, reco::MuonChamberMatch::segmentMatches, reco::Muon::setCalEnergy(), reco::Muon::setMatches(), mathSSE::sqrt(), reco::Muon::standAloneMuon(), storeCrossedHcalRecHits_, DetId::subdetId(), reco::MuonSegmentMatch::t0, theShowerDigiFiller_, reco::HcalMuonRecHit::time, reco::MuonEnergy::tower, reco::MuonEnergy::towerS9, TrackDetMatchInfo::TowerTotal, reco::Muon::track(), HLT_FULL_cff::track, trackAssociator_, reco::MuonRPCHitMatch::x, reco::MuonChamberMatch::x, reco::MuonSegmentMatch::x, reco::MuonChamberMatch::xErr, reco::MuonSegmentMatch::xErr, LocalError::xx(), reco::MuonChamberMatch::y, reco::MuonSegmentMatch::y, reco::MuonChamberMatch::yErr, reco::MuonSegmentMatch::yErr, and LocalError::yy().

Referenced by produce().

◆ fillMuonIsolation()

void MuonIdProducer::fillMuonIsolation ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup,
reco::Muon &  aMuon,
reco::IsoDeposit &  trackDep,
reco::IsoDeposit &  ecalDep,
reco::IsoDeposit &  hcalDep,
reco::IsoDeposit &  hoDep,
reco::IsoDeposit &  jetDep 
)
private

Definition at line 1242 of file MuonIdProducer.cc.

1249  {
1250  const reco::Track* track = nullptr;
1251  if (aMuon.track().isNonnull())
1252  track = aMuon.track().get();
1253  else if (aMuon.standAloneMuon().isNonnull())
1254  track = aMuon.standAloneMuon().get();
1255  else
1256  throw cms::Exception("FatalError")
1257  << "Failed to compute muon isolation information for a muon with undefined references to tracks";
1258 
1259  reco::MuonIsolation isoR03, isoR05;
1260 
1261  // get deposits
1262  reco::IsoDeposit depTrk = muIsoExtractorTrack_->deposit(iEvent, iSetup, *track);
1263  std::vector<reco::IsoDeposit> caloDeps = muIsoExtractorCalo_->deposits(iEvent, iSetup, *track);
1264  reco::IsoDeposit depJet = muIsoExtractorJet_->deposit(iEvent, iSetup, *track);
1265 
1266  if (caloDeps.size() != 3) {
1267  LogTrace("MuonIdentification") << "Failed to fill vector of calorimeter isolation deposits!";
1268  return;
1269  }
1270 
1271  reco::IsoDeposit depEcal = caloDeps.at(0);
1272  reco::IsoDeposit depHcal = caloDeps.at(1);
1273  reco::IsoDeposit depHo = caloDeps.at(2);
1274 
1275  //no need to copy outside if we don't write them
1276  if (writeIsoDeposits_) {
1277  trackDep = depTrk;
1278  ecalDep = depEcal;
1279  hcalDep = depHcal;
1280  hoDep = depHo;
1281  jetDep = depJet;
1282  }
1283 
1284  isoR03.sumPt = depTrk.depositWithin(0.3);
1285  isoR03.emEt = depEcal.depositWithin(0.3);
1286  isoR03.hadEt = depHcal.depositWithin(0.3);
1287  isoR03.hoEt = depHo.depositWithin(0.3);
1288  isoR03.nTracks = depTrk.depositAndCountWithin(0.3).second;
1289  isoR03.nJets = depJet.depositAndCountWithin(0.3).second;
1290  isoR03.trackerVetoPt = depTrk.candEnergy();
1291  isoR03.emVetoEt = depEcal.candEnergy();
1292  isoR03.hadVetoEt = depHcal.candEnergy();
1293  isoR03.hoVetoEt = depHo.candEnergy();
1294 
1295  isoR05.sumPt = depTrk.depositWithin(0.5);
1296  isoR05.emEt = depEcal.depositWithin(0.5);
1297  isoR05.hadEt = depHcal.depositWithin(0.5);
1298  isoR05.hoEt = depHo.depositWithin(0.5);
1299  isoR05.nTracks = depTrk.depositAndCountWithin(0.5).second;
1300  isoR05.nJets = depJet.depositAndCountWithin(0.5).second;
1301  isoR05.trackerVetoPt = depTrk.candEnergy();
1302  isoR05.emVetoEt = depEcal.candEnergy();
1303  isoR05.hadVetoEt = depHcal.candEnergy();
1304  isoR05.hoVetoEt = depHo.candEnergy();
1305 
1306  aMuon.setIsolation(isoR03, isoR05);
1307 }

References reco::IsoDeposit::candEnergy(), reco::IsoDeposit::depositAndCountWithin(), reco::IsoDeposit::depositWithin(), reco::MuonIsolation::emEt, reco::MuonIsolation::emVetoEt, Exception, edm::Ref< C, T, F >::get(), reco::MuonIsolation::hadEt, reco::MuonIsolation::hadVetoEt, reco::MuonIsolation::hoEt, reco::MuonIsolation::hoVetoEt, iEvent, edm::Ref< C, T, F >::isNonnull(), LogTrace, muIsoExtractorCalo_, muIsoExtractorJet_, muIsoExtractorTrack_, reco::MuonIsolation::nJets, reco::MuonIsolation::nTracks, reco::Muon::setIsolation(), reco::Muon::standAloneMuon(), reco::MuonIsolation::sumPt, reco::Muon::track(), HLT_FULL_cff::track, reco::MuonIsolation::trackerVetoPt, and writeIsoDeposits_.

Referenced by produce().

◆ fillTrackerKink()

void MuonIdProducer::fillTrackerKink ( reco::Muon &  aMuon)
private

Definition at line 1356 of file MuonIdProducer.cc.

1356  {
1357  // skip muons with no tracks
1358  if (aMuon.innerTrack().isNull())
1359  return;
1360  // get quality from muon if already there, otherwise make empty one
1361  reco::MuonQuality quality = (aMuon.isQualityValid() ? aMuon.combinedQuality() : reco::MuonQuality());
1362  // fill it
1363  const bool filled = trackerKinkFinder_->fillTrkKink(quality, *aMuon.innerTrack());
1364  // if quality was there, or if we filled it, commit to the muon
1365  if (filled || aMuon.isQualityValid())
1366  aMuon.setCombinedQuality(quality);
1367 }

References reco::Muon::combinedQuality(), reco::Muon::innerTrack(), edm::Ref< C, T, F >::isNull(), reco::Muon::isQualityValid(), qcdUeDQM_cfi::quality, reco::Muon::setCombinedQuality(), and trackerKinkFinder_.

Referenced by produce().

◆ getSegmentMatches()

std::vector<reco::MuonSegmentMatch>* MuonIdProducer::getSegmentMatches ( reco::MuonChamberMatch &  chamber,
unsigned int  muonType 
) const
inlineprivate

get the segment matches of the appropriate type

Definition at line 133 of file MuonIdProducer.h.

133  {
134  if (muonType == reco::Muon::TrackerMuon)
135  return &chamber.segmentMatches;
136  else if (muonType == reco::Muon::ME0Muon)
137  return &chamber.me0Matches;
138  else if (muonType == reco::Muon::GEMMuon)
139  return &chamber.gemMatches;
140  else
141  throw cms::Exception("getSegmentMatches called with unsupported muonType");
142  }

References relativeConstraints::chamber, Exception, reco::Muon::GEMMuon, reco::Muon::ME0Muon, and reco::Muon::TrackerMuon.

Referenced by fillArbitrationInfo().

◆ init()

void MuonIdProducer::init ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
private

Definition at line 191 of file MuonIdProducer.cc.

191  {
192  innerTrackCollectionHandle_.clear();
193  outerTrackCollectionHandle_.clear();
194  linkCollectionHandle_.clear();
195  muonCollectionHandle_.clear();
196 
197  tpfmsCollectionHandle_.clear();
198  pickyCollectionHandle_.clear();
199  dytCollectionHandle_.clear();
200 
201  trackAssociator_.setPropagator(&iSetup.getData(propagatorToken_));
202 
203  if (fillTrackerKink_)
204  trackerKinkFinder_->init(iSetup);
205 
206  for (unsigned int i = 0; i < inputCollectionLabels_.size(); ++i) {
207  const auto& inputLabel = inputCollectionLabels_[i];
208  const auto inputType = inputCollectionTypes_[i];
209  if (inputType == ICTypes::INNER_TRACKS) {
210  iEvent.getByToken(innerTrackCollectionToken_, innerTrackCollectionHandle_);
211  if (!innerTrackCollectionHandle_.isValid())
212  throw cms::Exception("FatalError") << "Failed to get input track collection with label: " << inputLabel;
213  LogTrace("MuonIdentification") << "Number of input inner tracks: " << innerTrackCollectionHandle_->size();
214  } else if (inputType == ICTypes::OUTER_TRACKS) {
215  iEvent.getByToken(outerTrackCollectionToken_, outerTrackCollectionHandle_);
216  if (!outerTrackCollectionHandle_.isValid())
217  throw cms::Exception("FatalError") << "Failed to get input track collection with label: " << inputLabel;
218  LogTrace("MuonIdentification") << "Number of input outer tracks: " << outerTrackCollectionHandle_->size();
219  } else if (inputType == ICTypes::LINKS) {
220  iEvent.getByToken(linkCollectionToken_, linkCollectionHandle_);
221  if (!linkCollectionHandle_.isValid())
222  throw cms::Exception("FatalError") << "Failed to get input link collection with label: " << inputLabel;
223  LogTrace("MuonIdentification") << "Number of input links: " << linkCollectionHandle_->size();
224  } else if (inputType == ICTypes::MUONS) {
225  iEvent.getByToken(muonCollectionToken_, muonCollectionHandle_);
226  if (!muonCollectionHandle_.isValid())
227  throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
228  LogTrace("MuonIdentification") << "Number of input muons: " << muonCollectionHandle_->size();
229  } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_FIRSTHIT) {
230  iEvent.getByToken(tpfmsCollectionToken_, tpfmsCollectionHandle_);
231  if (!tpfmsCollectionHandle_.isValid())
232  throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
233  LogTrace("MuonIdentification") << "Number of input muons: " << tpfmsCollectionHandle_->size();
234  } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_PICKY) {
235  iEvent.getByToken(pickyCollectionToken_, pickyCollectionHandle_);
236  if (!pickyCollectionHandle_.isValid())
237  throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
238  LogTrace("MuonIdentification") << "Number of input muons: " << pickyCollectionHandle_->size();
239  } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_DYT) {
240  iEvent.getByToken(dytCollectionToken_, dytCollectionHandle_);
241  if (!dytCollectionHandle_.isValid())
242  throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
243  LogTrace("MuonIdentification") << "Number of input muons: " << dytCollectionHandle_->size();
244  } else
245  throw cms::Exception("FatalError") << "Unknown input collection type: #" << ICTypes::toStr(inputType);
246  }
247 
248  iEvent.getByToken(rpcHitToken_, rpcHitHandle_);
249  if (fillGlobalTrackQuality_)
250  iEvent.getByToken(glbQualToken_, glbQualHandle_);
251 }

References edm::HandleBase::clear(), dytCollectionHandle_, dytCollectionToken_, Exception, fillGlobalTrackQuality_, fillGlobalTrackRefits_, fillTrackerKink_, edm::EventSetup::getData(), glbQualHandle_, glbQualToken_, mps_fire::i, iEvent, MuonIdProducer::ICTypes::INNER_TRACKS, innerTrackCollectionHandle_, innerTrackCollectionToken_, inputCollectionLabels_, inputCollectionTypes_, DataMixerDataOnData_cff::inputLabel, edm::HandleBase::isValid(), linkCollectionHandle_, linkCollectionToken_, MuonIdProducer::ICTypes::LINKS, LogTrace, muonCollectionHandle_, muonCollectionToken_, MuonIdProducer::ICTypes::MUONS, MuonIdProducer::ICTypes::OUTER_TRACKS, outerTrackCollectionHandle_, outerTrackCollectionToken_, pickyCollectionHandle_, pickyCollectionToken_, propagatorToken_, rpcHitHandle_, rpcHitToken_, TrackDetectorAssociator::setPropagator(), MuonIdProducer::ICTypes::TEV_DYT, MuonIdProducer::ICTypes::TEV_FIRSTHIT, MuonIdProducer::ICTypes::TEV_PICKY, MuonIdProducer::ICTypes::toStr(), tpfmsCollectionHandle_, tpfmsCollectionToken_, trackAssociator_, and trackerKinkFinder_.

Referenced by produce().

◆ isGoodCaloMuon()

bool MuonIdProducer::isGoodCaloMuon ( const reco::CaloMuon &  muon)
private

Definition at line 764 of file MuonIdProducer.cc.

764  {
765  if (!caloMuon.isCaloCompatibilityValid() || caloMuon.caloCompatibility() < caloCut_ || caloMuon.p() < minPCaloMuon_)
766  return false;
767  return true;
768 }

References reco::CaloMuon::caloCompatibility(), caloCut_, reco::CaloMuon::isCaloCompatibilityValid(), minPCaloMuon_, and reco::CaloMuon::p().

Referenced by arbitrateMuons(), and produce().

◆ isGoodGEMMuon()

bool MuonIdProducer::isGoodGEMMuon ( const reco::Muon &  muon)
private

Definition at line 779 of file MuonIdProducer.cc.

779  {
780  if (muon.track()->pt() < minPt_ || muon.track()->p() < minP_)
781  return false;
782  return (muon.numberOfMatches(reco::Muon::GEMSegmentAndTrackArbitration) >= 1);
783 }

References reco::Muon::GEMSegmentAndTrackArbitration, minP_, and minPt_.

Referenced by produce().

◆ isGoodME0Muon()

bool MuonIdProducer::isGoodME0Muon ( const reco::Muon &  muon)
private

Definition at line 785 of file MuonIdProducer.cc.

785  {
786  // need to update min cuts on pt
787  if (muon.track()->p() < minP_)
788  return false;
789  return (muon.numberOfMatches(reco::Muon::ME0SegmentAndTrackArbitration) >= 1);
790 }

References reco::Muon::ME0SegmentAndTrackArbitration, and minP_.

Referenced by produce().

◆ isGoodRPCMuon()

bool MuonIdProducer::isGoodRPCMuon ( const reco::Muon &  muon)
private

Definition at line 770 of file MuonIdProducer.cc.

770  {
771  if (muon.track()->pt() < minPt_ || muon.track()->p() < minP_)
772  return false;
773  if (addExtraSoftMuons_ && muon.pt() < 5 && std::abs(muon.eta()) < 1.5 &&
774  muon.numberOfMatchedRPCLayers(reco::Muon::RPCHitAndTrackArbitration) > 1)
775  return true;
776  return (muon.numberOfMatchedRPCLayers(reco::Muon::RPCHitAndTrackArbitration) > minNumberOfMatches_);
777 }

References funct::abs(), addExtraSoftMuons_, minNumberOfMatches_, minP_, minPt_, and reco::Muon::RPCHitAndTrackArbitration.

Referenced by produce().

◆ isGoodTrack()

bool MuonIdProducer::isGoodTrack ( const reco::Track &  track)
private

Definition at line 351 of file MuonIdProducer.cc.

351  {
352  // Pt and absolute momentum requirement
353  const double p = track.p();
354  const double pt = track.pt();
355  if (pt < minPt_ || (p < minP_ && p < minPCaloMuon_)) {
356  LogTrace("MuonIdentification") << "Skipped low momentum track (Pt,P): " << pt << ", " << track.p() << " GeV";
357  return false;
358  }
359 
360  // Eta requirement
361  const double eta = track.eta();
362  const double absEta = std::abs(eta);
363  if (absEta > maxAbsEta_) {
364  LogTrace("MuonIdentification") << "Skipped track with large pseudo rapidity (Eta: " << track.eta() << " )";
365  return false;
366  }
367 
368  return true;
369 }

References funct::abs(), PVValHelper::eta, LogTrace, maxAbsEta_, minP_, minPCaloMuon_, minPt_, AlCaHLTBitMon_ParallelJobs::p, DiDispStaMuonMonitor_cfi::pt, and HLT_FULL_cff::track.

Referenced by produce().

◆ isGoodTrackerMuon()

bool MuonIdProducer::isGoodTrackerMuon ( const reco::Muon &  muon)
private

Definition at line 755 of file MuonIdProducer.cc.

755  {
756  if (muon.track()->pt() < minPt_ || muon.track()->p() < minP_)
757  return false;
758  if (addExtraSoftMuons_ && muon.pt() < 5 && std::abs(muon.eta()) < 1.5 &&
759  muon.numberOfMatches(reco::Muon::NoArbitration) >= 1)
760  return true;
761  return (muon.numberOfMatches(reco::Muon::NoArbitration) >= minNumberOfMatches_);
762 }

References funct::abs(), addExtraSoftMuons_, minNumberOfMatches_, minP_, minPt_, and reco::Muon::NoArbitration.

Referenced by produce().

◆ makeCaloMuon()

reco::CaloMuon MuonIdProducer::makeCaloMuon ( const reco::Muon &  muon)
private

Definition at line 273 of file MuonIdProducer.cc.

273  {
274  LogTrace("MuonIdentification") << "Creating a CaloMuon from a Muon";
275 
276  reco::CaloMuon aMuon;
277  aMuon.setInnerTrack(muon.innerTrack());
278 
279  if (muon.isEnergyValid())
280  aMuon.setCalEnergy(muon.calEnergy());
281  // get calo compatibility
282  if (fillCaloCompatibility_)
283  aMuon.setCaloCompatibility(muonCaloCompatibility_.evaluate(muon));
284  return aMuon;
285 }

References MuonCaloCompatibility::evaluate(), fillCaloCompatibility_, LogTrace, muonCaloCompatibility_, reco::CaloMuon::setCalEnergy(), reco::CaloMuon::setCaloCompatibility(), and reco::CaloMuon::setInnerTrack().

Referenced by arbitrateMuons(), and produce().

◆ makeMuon() [1/3]

reco::Muon MuonIdProducer::makeMuon ( const reco::MuonTrackLinks &  links)
private

Definition at line 287 of file MuonIdProducer.cc.

287  {
288  LogTrace("MuonIdentification") << "Creating a muon from a link to tracks object";
289 
290  reco::Muon aMuon;
291  reco::Muon::MuonTrackTypePair chosenTrack;
292  reco::TrackRef tpfmsRef;
293  reco::TrackRef pickyRef;
294  reco::TrackRef dytRef;
295  bool useSigmaSwitch = false;
296 
297  if (tpfmsCollectionHandle_.isValid() && !tpfmsCollectionHandle_.failedToGet() && pickyCollectionHandle_.isValid() &&
298  !pickyCollectionHandle_.failedToGet()) {
299  tpfmsRef = muon::getTevRefitTrack(links.globalTrack(), *tpfmsCollectionHandle_);
300  pickyRef = muon::getTevRefitTrack(links.globalTrack(), *pickyCollectionHandle_);
301  dytRef = muon::getTevRefitTrack(links.globalTrack(), *dytCollectionHandle_);
302 
303  if (tpfmsRef.isNull() && pickyRef.isNull() && dytRef.isNull()) {
304  edm::LogWarning("MakeMuonWithTEV") << "Failed to get TEV refits, fall back to sigma switch.";
305  useSigmaSwitch = true;
306  }
307  } else {
308  useSigmaSwitch = true;
309  }
310 
311  if (useSigmaSwitch) {
312  chosenTrack = muon::sigmaSwitch(links.globalTrack(),
313  links.trackerTrack(),
314  sigmaThresholdToFillCandidateP4WithGlobalFit_,
315  ptThresholdToFillCandidateP4WithGlobalFit_);
316  } else {
317  chosenTrack = muon::tevOptimized(links.globalTrack(),
318  links.trackerTrack(),
319  tpfmsRef,
320  pickyRef,
321  dytRef,
322  ptThresholdToFillCandidateP4WithGlobalFit_);
323  }
324  aMuon = makeMuon(*chosenTrack.first);
325  aMuon.setInnerTrack(links.trackerTrack());
326  aMuon.setOuterTrack(links.standAloneTrack());
327  aMuon.setGlobalTrack(links.globalTrack());
328  aMuon.setBestTrack(chosenTrack.second);
329  aMuon.setTunePBestTrack(chosenTrack.second);
330 
331  if (fillGlobalTrackRefits_) {
332  if (tpfmsCollectionHandle_.isValid() && !tpfmsCollectionHandle_.failedToGet()) {
333  reco::TrackToTrackMap::const_iterator it = tpfmsCollectionHandle_->find(links.globalTrack());
334  if (it != tpfmsCollectionHandle_->end())
335  aMuon.setMuonTrack(reco::Muon::TPFMS, (it->val));
336  }
337  if (pickyCollectionHandle_.isValid() && !pickyCollectionHandle_.failedToGet()) {
338  reco::TrackToTrackMap::const_iterator it = pickyCollectionHandle_->find(links.globalTrack());
339  if (it != pickyCollectionHandle_->end())
340  aMuon.setMuonTrack(reco::Muon::Picky, (it->val));
341  }
342  if (dytCollectionHandle_.isValid() && !dytCollectionHandle_.failedToGet()) {
343  reco::TrackToTrackMap::const_iterator it = dytCollectionHandle_->find(links.globalTrack());
344  if (it != dytCollectionHandle_->end())
345  aMuon.setMuonTrack(reco::Muon::DYT, (it->val));
346  }
347  }
348  return aMuon;
349 }

References reco::Muon::DYT, dytCollectionHandle_, fillGlobalTrackRefits_, muon::getTevRefitTrack(), edm::Ref< C, T, F >::isNull(), electronStore::links, LogTrace, makeMuon(), reco::Muon::Picky, pickyCollectionHandle_, ptThresholdToFillCandidateP4WithGlobalFit_, reco::Muon::setBestTrack(), reco::Muon::setGlobalTrack(), reco::Muon::setInnerTrack(), reco::Muon::setMuonTrack(), reco::Muon::setOuterTrack(), reco::Muon::setTunePBestTrack(), muon::sigmaSwitch(), sigmaThresholdToFillCandidateP4WithGlobalFit_, muon::tevOptimized(), reco::Muon::TPFMS, tpfmsCollectionHandle_, and edm::helpers::KeyVal< K, V >::val.

◆ makeMuon() [2/3]

reco::Muon MuonIdProducer::makeMuon ( const reco::Track &  track)
private

Definition at line 1309 of file MuonIdProducer.cc.

1309  {
1310  const double energy = std::sqrt(track.p() * track.p() + 0.105658369 * 0.105658369);
1311  const math::XYZTLorentzVector p4(track.px(), track.py(), track.pz(), energy);
1312  return reco::Muon(track.charge(), p4, track.vertex());
1313 }

References HCALHighEnergyHPDFilter_cfi::energy, dumpRecoGeometry_cfg::Muon, p4, mathSSE::sqrt(), and HLT_FULL_cff::track.

◆ makeMuon() [3/3]

reco::Muon MuonIdProducer::makeMuon ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup,
const reco::TrackRef &  track,
MuonIdProducer::TrackType  type 
)
private

Definition at line 253 of file MuonIdProducer.cc.

256  {
257  LogTrace("MuonIdentification") << "Creating a muon from a track " << track.get()->pt()
258  << " Pt (GeV), eta: " << track.get()->eta();
259  reco::Muon aMuon(makeMuon(*(track.get())));
260 
261  LogTrace("MuonIdentification") << "Muon created from a track ";
262 
263  aMuon.setMuonTrack(type, track);
264  aMuon.setBestTrack(type);
265  aMuon.setTunePBestTrack(type);
266 
267  LogTrace("MuonIdentification")
268  << "Muon created from a track and setMuonBestTrack, setBestTrack and setTunePBestTrack called";
269 
270  return aMuon;
271 }

References LogTrace, and HLT_FULL_cff::track.

Referenced by makeMuon(), and produce().

◆ overlap()

int MuonIdProducer::overlap ( const reco::Muon &  muon,
const reco::Track &  track 
)
private

Definition at line 385 of file MuonIdProducer.cc.

385  {
386  if (!muon.isMatchesValid() || track.extra().isNull() || track.extra()->recHitsSize() == 0)
387  return 0;
388 
389  int numberOfCommonDetIds = 0;
390  const std::vector<reco::MuonChamberMatch>& matches(muon.matches());
391  for (const auto& match : matches) {
392  if (match.segmentMatches.empty())
393  continue;
394 
395  bool foundCommonDetId = false;
396  for (auto hit = track.extra()->recHitsBegin(); hit != track.extra()->recHitsEnd(); ++hit) {
397  // LogTrace("MuonIdentification") << "hit DetId: " << std::hex << hit->get()->geographicalId().rawId() <<
398  // "\t hit chamber DetId: " << getChamberId(hit->get()->geographicalId()) <<
399  // "\t segment DetId: " << match->id.rawId() << std::dec;
400 
401  if (chamberId((*hit)->geographicalId()) == match.id.rawId()) {
402  foundCommonDetId = true;
403  break;
404  }
405  }
406  if (foundCommonDetId) {
407  ++numberOfCommonDetIds;
408  break;
409  }
410  }
411  return numberOfCommonDetIds;
412 }

References chamberId(), match(), patCandidatesForDimuonsSequences_cff::matches, and HLT_FULL_cff::track.

Referenced by produce().

◆ phiOfMuonInteractionRegion()

double MuonIdProducer::phiOfMuonInteractionRegion ( const reco::Muon &  muon) const
private

Definition at line 1335 of file MuonIdProducer.cc.

1335  {
1336  if (muon.isStandAloneMuon())
1337  return muon.standAloneMuon()->innerPosition().phi();
1338  // the rest is tracker muon only
1339  if (muon.matches().empty()) {
1340  if (muon.innerTrack().isAvailable() && muon.innerTrack()->extra().isAvailable())
1341  return muon.innerTrack()->outerPosition().phi();
1342  else
1343  return muon.phi(); // makes little sense, but what else can I use
1344  }
1345  return sectorPhi(muon.matches().at(0).id);
1346 }

References sectorPhi().

Referenced by produce().

◆ produce()

void MuonIdProducer::produce ( edm::Event &  iEvent,
const edm::EventSetup &  iSetup 
)
override

Definition at line 433 of file MuonIdProducer.cc.

433  {
434  auto outputMuons = std::make_unique<reco::MuonCollection>();
435  auto caloMuons = std::make_unique<reco::CaloMuonCollection>();
436 
437  init(iEvent, iSetup);
438 
439  if (fillShowerDigis_ && fillMatching_)
440  theShowerDigiFiller_->getDigis(iEvent);
441 
442  // loop over input collections
443 
444  // muons first - no cleaning, take as is.
445  if (muonCollectionHandle_.isValid()) {
446  for (const auto& muon : *muonCollectionHandle_) {
447  outputMuons->push_back(muon);
448  }
449  }
450 
451  // links second ( assume global muon type )
452  if (linkCollectionHandle_.isValid()) {
453  const auto nLink = linkCollectionHandle_->size();
454  std::vector<bool> goodmuons(nLink, true);
455  if (nLink > 1) {
456  // check for shared tracker tracks
457  for (unsigned int i = 0; i < nLink - 1; ++i) {
458  const auto& iLink = linkCollectionHandle_->at(i);
459  if (iLink.trackerTrack().isNull() || !checkLinks(&iLink))
460  continue;
461  for (unsigned int j = i + 1; j < nLink; ++j) {
462  const auto& jLink = linkCollectionHandle_->at(j);
463  if (!checkLinks(&jLink))
464  continue;
465  if (iLink.trackerTrack() == jLink.trackerTrack()) {
466  // Tracker track is the essential part that dominates muon resolution
467  // so taking either muon is fine. All that is important is to preserve
468  // the muon identification information. If number of hits is small,
469  // keep the one with large number of hits, otherwise take the smalest chi2/ndof
470  if (validateGlobalMuonPair(iLink, jLink))
471  goodmuons[j] = false;
472  else
473  goodmuons[i] = false;
474  }
475  }
476  }
477  // check for shared stand-alone muons.
478  for (unsigned int i = 0; i < nLink - 1; ++i) {
479  if (!goodmuons[i])
480  continue;
481  const auto& iLink = linkCollectionHandle_->at(i);
482  if (iLink.standAloneTrack().isNull() || !checkLinks(&iLink))
483  continue;
484  for (unsigned int j = i + 1; j < nLink; ++j) {
485  if (!goodmuons[j])
486  continue;
487  const auto& jLink = linkCollectionHandle_->at(j);
488  if (!checkLinks(&jLink))
489  continue;
490  if (iLink.standAloneTrack() == jLink.standAloneTrack()) {
491  if (validateGlobalMuonPair(iLink, jLink))
492  goodmuons[j] = false;
493  else
494  goodmuons[i] = false;
495  }
496  }
497  }
498  }
499  for (unsigned int i = 0; i < nLink; ++i) {
500  if (!goodmuons[i])
501  continue;
502  const auto& iLink = linkCollectionHandle_->at(i);
503  if (!checkLinks(&iLink))
504  continue;
505  // check if this muon is already in the list
506  bool newMuon = true;
507  for (const auto& muon : *outputMuons) {
508  if (muon.track() == iLink.trackerTrack() && muon.standAloneMuon() == iLink.standAloneTrack() &&
509  muon.combinedMuon() == iLink.globalTrack()) {
510  newMuon = false;
511  break;
512  }
513  }
514  if (newMuon) {
515  outputMuons->push_back(makeMuon(iLink));
516  outputMuons->back().setType(reco::Muon::GlobalMuon | reco::Muon::StandAloneMuon);
517  }
518  }
519  }
520 
521  // tracker and calo muons are next
522  if (innerTrackCollectionHandle_.isValid()) {
523  LogTrace("MuonIdentification") << "Creating tracker muons";
524  std::vector<TrackDetectorAssociator::Direction> directions1, directions2;
525  directions1.push_back(TrackDetectorAssociator::InsideOut);
526  directions1.push_back(TrackDetectorAssociator::OutsideIn);
527  directions2.push_back(TrackDetectorAssociator::Any);
528 
529  for (unsigned int i = 0; i < innerTrackCollectionHandle_->size(); ++i) {
530  const reco::Track& track = innerTrackCollectionHandle_->at(i);
531  if (!isGoodTrack(track))
532  continue;
533  const auto& trackRef = reco::TrackRef(innerTrackCollectionHandle_, i);
534  bool splitTrack = false;
535  if (track.extra().isAvailable() && TrackDetectorAssociator::crossedIP(track))
536  splitTrack = true;
537  const auto& directions = splitTrack ? directions1 : directions2;
538  for (const auto direction : directions) {
539  // make muon
540  reco::Muon trackerMuon(makeMuon(iEvent, iSetup, trackRef, reco::Muon::InnerTrack));
541  fillMuonId(iEvent, iSetup, trackerMuon, direction);
542 
543  if (debugWithTruthMatching_) {
544  // add MC hits to a list of matched segments.
545  // Since it's debugging mode - code is slow
546  MuonIdTruthInfo::truthMatchMuon(iEvent, iSetup, trackerMuon);
547  }
548 
549  // check if this muon is already in the list
550  // have to check where muon hits are really located
551  // to match properly
552  bool newMuon = true;
553  const bool goodTrackerMuon = isGoodTrackerMuon(trackerMuon);
554  const bool goodRPCMuon = isGoodRPCMuon(trackerMuon);
555  const bool goodGEMMuon = isGoodGEMMuon(trackerMuon);
556  const bool goodME0Muon = isGoodME0Muon(trackerMuon);
557  if (goodTrackerMuon)
558  trackerMuon.setType(trackerMuon.type() | reco::Muon::TrackerMuon);
559  if (goodRPCMuon)
560  trackerMuon.setType(trackerMuon.type() | reco::Muon::RPCMuon);
561  if (goodGEMMuon)
562  trackerMuon.setType(trackerMuon.type() | reco::Muon::GEMMuon);
563  if (goodME0Muon)
564  trackerMuon.setType(trackerMuon.type() | reco::Muon::ME0Muon);
565 
566  for (auto& muon : *outputMuons) {
567  if (muon.innerTrack().get() == trackerMuon.innerTrack().get() &&
568  std::abs(reco::deltaPhi(phiOfMuonInteractionRegion(muon), phiOfMuonInteractionRegion(trackerMuon))) <
569  M_PI_2) {
570  newMuon = false;
571  muon.setMatches(trackerMuon.matches());
572  if (trackerMuon.isTimeValid())
573  muon.setTime(trackerMuon.time());
574  if (trackerMuon.isEnergyValid())
575  muon.setCalEnergy(trackerMuon.calEnergy());
576  if (goodTrackerMuon)
577  muon.setType(muon.type() | reco::Muon::TrackerMuon);
578  if (goodRPCMuon)
579  muon.setType(muon.type() | reco::Muon::RPCMuon);
580  if (goodGEMMuon)
581  muon.setType(muon.type() | reco::Muon::GEMMuon);
582  if (goodME0Muon)
583  muon.setType(muon.type() | reco::Muon::ME0Muon);
584  LogTrace("MuonIdentification") << "Found a corresponding global muon. Set energy, matches and move on";
585  break;
586  }
587  }
588  if (newMuon) {
589  if (goodTrackerMuon || goodRPCMuon || goodGEMMuon || goodME0Muon) {
590  outputMuons->push_back(trackerMuon);
591  } else {
592  LogTrace("MuonIdentification") << "track failed minimal number of muon matches requirement";
593  const reco::CaloMuon& caloMuon = makeCaloMuon(trackerMuon);
594  if (isGoodCaloMuon(caloMuon))
595  caloMuons->push_back(caloMuon);
596  }
597  }
598  }
599  }
600  }
601 
602  // and at last the stand alone muons
603  if (outerTrackCollectionHandle_.isValid()) {
604  LogTrace("MuonIdentification") << "Looking for new muons among stand alone muon tracks";
605  for (unsigned int i = 0; i < outerTrackCollectionHandle_->size(); ++i) {
606  const auto& outerTrack = outerTrackCollectionHandle_->at(i);
607 
608  // check if this muon is already in the list of global muons
609  bool newMuon = true;
610  for (auto& muon : *outputMuons) {
611  if (!muon.standAloneMuon().isNull()) {
612  // global muon
613  if (muon.standAloneMuon().get() == &outerTrack) {
614  newMuon = false;
615  break;
616  }
617  } else {
618  // tracker muon - no direct links to the standalone muon
619  // since we have only a few real muons in an event, matching
620  // the stand alone muon to the tracker muon by DetIds should
621  // be good enough for association. At the end it's up to a
622  // user to redefine the association and what it means. Here
623  // we would like to avoid obvious double counting and we
624  // tolerate a potential miss association
625  if (overlap(muon, outerTrack) > 0) {
626  LogTrace("MuonIdentification") << "Found associated tracker muon. Set a reference and move on";
627  newMuon = false;
628  muon.setOuterTrack(reco::TrackRef(outerTrackCollectionHandle_, i));
629  muon.setType(muon.type() | reco::Muon::StandAloneMuon);
630  break;
631  }
632  }
633  }
634  if (newMuon) {
635  LogTrace("MuonIdentification") << "No associated stand alone track is found. Making a muon";
636  outputMuons->push_back(
637  makeMuon(iEvent, iSetup, reco::TrackRef(outerTrackCollectionHandle_, i), reco::Muon::OuterTrack));
638  outputMuons->back().setType(reco::Muon::StandAloneMuon);
639  }
640  }
641  }
642 
643  if (arbitrateTrackerMuons_) {
644  fillArbitrationInfo(outputMuons.get());
645  arbitrateMuons(outputMuons.get(), caloMuons.get());
646  }
647 
648  LogTrace("MuonIdentification") << "Dress up muons if it's necessary";
649 
650  const int nMuons = outputMuons->size();
651 
652  std::vector<reco::MuonTimeExtra> dtTimeColl(nMuons);
653  std::vector<reco::MuonTimeExtra> cscTimeColl(nMuons);
654  std::vector<reco::MuonTimeExtra> combinedTimeColl(nMuons);
655  std::vector<reco::IsoDeposit> trackDepColl(nMuons);
656  std::vector<reco::IsoDeposit> ecalDepColl(nMuons);
657  std::vector<reco::IsoDeposit> hcalDepColl(nMuons);
658  std::vector<reco::IsoDeposit> hoDepColl(nMuons);
659  std::vector<reco::IsoDeposit> jetDepColl(nMuons);
660 
661  // Fill various information
662  for (unsigned int i = 0; i < outputMuons->size(); ++i) {
663  auto& muon = outputMuons->at(i);
664 
665  // Fill muonID
666  if ((fillMatching_ && !muon.isMatchesValid()) || (fillEnergy_ && !muon.isEnergyValid())) {
667  // predict direction based on the muon interaction region location
668  // if it's available
669  if (muon.isStandAloneMuon()) {
670  if (std::abs(reco::deltaPhi(phiOfMuonInteractionRegion(muon), muon.phi())) < M_PI_2) {
671  fillMuonId(iEvent, iSetup, muon, TrackDetectorAssociator::InsideOut);
672  } else {
673  fillMuonId(iEvent, iSetup, muon, TrackDetectorAssociator::OutsideIn);
674  }
675  } else {
676  LogTrace("MuonIdentification") << "THIS SHOULD NEVER HAPPEN";
677  fillMuonId(iEvent, iSetup, muon);
678  }
679  }
680 
681  if (fillGlobalTrackQuality_) {
682  // Fill global quality information
683  fillGlbQuality(iEvent, iSetup, muon);
684  }
685  LogDebug("MuonIdentification");
686 
687  if (fillTrackerKink_) {
688  fillTrackerKink(muon);
689  }
690 
691  if (fillCaloCompatibility_)
692  muon.setCaloCompatibility(muonCaloCompatibility_.evaluate(muon));
693 
694  if (fillIsolation_) {
695  fillMuonIsolation(
696  iEvent, iSetup, muon, trackDepColl[i], ecalDepColl[i], hcalDepColl[i], hoDepColl[i], jetDepColl[i]);
697  }
698 
699  // fill timing information
700  reco::MuonTime muonTime;
701  reco::MuonTimeExtra dtTime;
702  reco::MuonTimeExtra cscTime;
703  reco::MuonTime rpcTime;
704  reco::MuonTimeExtra combinedTime;
705 
706  theTimingFiller_->fillTiming(muon, dtTime, cscTime, rpcTime, combinedTime, iEvent, iSetup);
707 
708  muonTime.nDof = combinedTime.nDof();
709  muonTime.timeAtIpInOut = combinedTime.timeAtIpInOut();
710  muonTime.timeAtIpInOutErr = combinedTime.timeAtIpInOutErr();
711  muonTime.timeAtIpOutIn = combinedTime.timeAtIpOutIn();
712  muonTime.timeAtIpOutInErr = combinedTime.timeAtIpOutInErr();
713 
714  muon.setTime(muonTime);
715  muon.setRPCTime(rpcTime);
716  dtTimeColl[i] = dtTime;
717  cscTimeColl[i] = cscTime;
718  combinedTimeColl[i] = combinedTime;
719  }
720 
721  LogTrace("MuonIdentification") << "number of muons produced: " << outputMuons->size();
722  if (fillMatching_) {
723  fillArbitrationInfo(outputMuons.get(), reco::Muon::TrackerMuon);
724  fillArbitrationInfo(outputMuons.get(), reco::Muon::ME0Muon);
725  fillArbitrationInfo(outputMuons.get(), reco::Muon::GEMMuon);
726  }
727  edm::OrphanHandle<reco::MuonCollection> muonHandle = iEvent.put(std::move(outputMuons));
728 
729  auto fillMap = [](auto refH, auto& vec, edm::Event& ev, const std::string& cAl = "") {
730  typedef edm::ValueMap<typename std::decay<decltype(vec)>::type::value_type> MapType;
731  auto oMap = std::make_unique<MapType>();
732  {
733  typename MapType::Filler filler(*oMap);
734  filler.insert(refH, vec.begin(), vec.end());
735  vec.clear();
736  filler.fill();
737  }
738  ev.put(std::move(oMap), cAl);
739  };
740  fillMap(muonHandle, combinedTimeColl, iEvent, "combined");
741  fillMap(muonHandle, dtTimeColl, iEvent, "dt");
742  fillMap(muonHandle, cscTimeColl, iEvent, "csc");
743 
744  if (writeIsoDeposits_ && fillIsolation_) {
745  fillMap(muonHandle, trackDepColl, iEvent, trackDepositName_);
746  fillMap(muonHandle, ecalDepColl, iEvent, ecalDepositName_);
747  fillMap(muonHandle, hcalDepColl, iEvent, hcalDepositName_);
748  fillMap(muonHandle, hoDepColl, iEvent, hoDepositName_);
749  fillMap(muonHandle, jetDepColl, iEvent, jetDepositName_);
750  }
751 
752  iEvent.put(std::move(caloMuons));
753 }

References funct::abs(), TrackDetectorAssociator::Any, arbitrateMuons(), arbitrateTrackerMuons_, mergedMuons_cfi::caloMuons, checkLinks(), TrackDetectorAssociator::crossedIP(), debugWithTruthMatching_, PA_ZEESkim_cff::decay, reco::deltaPhi(), ecalDepositName_, ev, MuonCaloCompatibility::evaluate(), fillArbitrationInfo(), fillCaloCompatibility_, fillEnergy_, trigObjTnPSource_cfi::filler, fillGlbQuality(), fillGlobalTrackQuality_, fillIsolation_, fillMatching_, fillMuonId(), fillMuonIsolation(), fillShowerDigis_, fillTrackerKink(), fillTrackerKink_, reco::Muon::GEMMuon, reco::Muon::GlobalMuon, hcalDepositName_, hoDepositName_, mps_fire::i, iEvent, init(), reco::Muon::InnerTrack, innerTrackCollectionHandle_, TrackDetectorAssociator::InsideOut, isGoodCaloMuon(), isGoodGEMMuon(), isGoodME0Muon(), isGoodRPCMuon(), isGoodTrack(), isGoodTrackerMuon(), edm::HandleBase::isValid(), dqmiolumiharvest::j, jetDepositName_, linkCollectionHandle_, LogDebug, LogTrace, M_PI_2, makeCaloMuon(), makeMuon(), reco::Muon::ME0Muon, eostools::move(), muonCaloCompatibility_, muonCollectionHandle_, reco::MuonTime::nDof, reco::MuonTimeExtra::nDof(), custom_jme_cff::nMuons, reco::Muon::OuterTrack, outerTrackCollectionHandle_, TrackDetectorAssociator::OutsideIn, overlap(), phiOfMuonInteractionRegion(), reco::Muon::RPCMuon, reco::Muon::StandAloneMuon, AlCaHLTBitMon_QueryRunRegistry::string, theShowerDigiFiller_, theTimingFiller_, reco::MuonTime::timeAtIpInOut, reco::MuonTimeExtra::timeAtIpInOut(), reco::MuonTime::timeAtIpInOutErr, reco::MuonTimeExtra::timeAtIpInOutErr(), reco::MuonTime::timeAtIpOutIn, reco::MuonTimeExtra::timeAtIpOutIn(), reco::MuonTime::timeAtIpOutInErr, reco::MuonTimeExtra::timeAtIpOutInErr(), HLT_FULL_cff::track, trackDepositName_, susybsm::HSCParticleType::trackerMuon, reco::Muon::TrackerMuon, MuonIdTruthInfo::truthMatchMuon(), validateGlobalMuonPair(), and writeIsoDeposits_.

◆ sectorPhi()

double MuonIdProducer::sectorPhi ( const DetId &  id)
static

Definition at line 1315 of file MuonIdProducer.cc.

1315  {
1316  double phi = 0;
1317  if (id.subdetId() == MuonSubdetId::DT) { // DT
1318  DTChamberId muonId(id.rawId());
1319  if (muonId.sector() <= 12)
1320  phi = (muonId.sector() - 1) / 6. * M_PI;
1321  if (muonId.sector() == 13)
1322  phi = 3 / 6. * M_PI;
1323  if (muonId.sector() == 14)
1324  phi = 9 / 6. * M_PI;
1325  }
1326  if (id.subdetId() == MuonSubdetId::CSC) { // CSC
1327  CSCDetId muonId(id.rawId());
1328  phi = M_PI / 4 + (muonId.triggerSector() - 1) / 3. * M_PI;
1329  }
1330  if (phi > M_PI)
1331  phi -= 2 * M_PI;
1332  return phi;
1333 }

References MuonSubdetId::CSC, MuonSubdetId::DT, M_PI, phi, DTChamberId::sector(), and CSCDetId::triggerSector().

Referenced by phiOfMuonInteractionRegion().

Member Data Documentation

◆ addExtraSoftMuons_

bool MuonIdProducer::addExtraSoftMuons_
private

Definition at line 204 of file MuonIdProducer.h.

Referenced by isGoodRPCMuon(), isGoodTrackerMuon(), and MuonIdProducer().

◆ arbClean_

bool MuonIdProducer::arbClean_
private

Definition at line 271 of file MuonIdProducer.h.

Referenced by fillArbitrationInfo(), and MuonIdProducer().

◆ arbitrateTrackerMuons_

bool MuonIdProducer::arbitrateTrackerMuons_
private

Definition at line 223 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ caloCut_

double MuonIdProducer::caloCut_
private

Definition at line 269 of file MuonIdProducer.h.

Referenced by isGoodCaloMuon(), and MuonIdProducer().

◆ debugWithTruthMatching_

bool MuonIdProducer::debugWithTruthMatching_
private

Definition at line 225 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ dytCollectionHandle_

edm::Handle<reco::TrackToTrackMap> MuonIdProducer::dytCollectionHandle_
private

Definition at line 233 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

◆ dytCollectionToken_

edm::EDGetTokenT<reco::TrackToTrackMap> MuonIdProducer::dytCollectionToken_
private

Definition at line 241 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ ecalDepositName_

std::string MuonIdProducer::ecalDepositName_
private

Definition at line 257 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ fillCaloCompatibility_

bool MuonIdProducer::fillCaloCompatibility_
private

Definition at line 213 of file MuonIdProducer.h.

Referenced by makeCaloMuon(), MuonIdProducer(), and produce().

◆ fillEnergy_

bool MuonIdProducer::fillEnergy_
private

Definition at line 214 of file MuonIdProducer.h.

Referenced by fillMuonId(), MuonIdProducer(), and produce().

◆ fillGlobalTrackQuality_

bool MuonIdProducer::fillGlobalTrackQuality_
private

Definition at line 262 of file MuonIdProducer.h.

Referenced by init(), MuonIdProducer(), and produce().

◆ fillGlobalTrackRefits_

bool MuonIdProducer::fillGlobalTrackRefits_
private

Definition at line 263 of file MuonIdProducer.h.

Referenced by init(), makeMuon(), and MuonIdProducer().

◆ fillIsolation_

bool MuonIdProducer::fillIsolation_
private

Definition at line 218 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ fillMatching_

bool MuonIdProducer::fillMatching_
private

Definition at line 216 of file MuonIdProducer.h.

Referenced by beginRun(), fillMuonId(), MuonIdProducer(), and produce().

◆ fillShowerDigis_

bool MuonIdProducer::fillShowerDigis_
private

Definition at line 217 of file MuonIdProducer.h.

Referenced by beginRun(), fillMuonId(), MuonIdProducer(), and produce().

◆ fillTrackerKink_

bool MuonIdProducer::fillTrackerKink_
private

Definition at line 266 of file MuonIdProducer.h.

Referenced by init(), MuonIdProducer(), and produce().

◆ geomTokenRun_

const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> MuonIdProducer::geomTokenRun_
private

Definition at line 249 of file MuonIdProducer.h.

Referenced by beginRun().

◆ glbQualHandle_

edm::Handle<edm::ValueMap<reco::MuonQuality> > MuonIdProducer::glbQualHandle_
private

Definition at line 247 of file MuonIdProducer.h.

Referenced by fillGlbQuality(), and init().

◆ glbQualToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonQuality> > MuonIdProducer::glbQualToken_
private

Definition at line 244 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ globalTrackQualityInputTag_

edm::InputTag MuonIdProducer::globalTrackQualityInputTag_
private

Definition at line 264 of file MuonIdProducer.h.

◆ hcalDepositName_

std::string MuonIdProducer::hcalDepositName_
private

Definition at line 258 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ hoDepositName_

std::string MuonIdProducer::hoDepositName_
private

Definition at line 259 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ innerTrackCollectionHandle_

edm::Handle<reco::TrackCollection> MuonIdProducer::innerTrackCollectionHandle_
private

Definition at line 227 of file MuonIdProducer.h.

Referenced by init(), and produce().

◆ innerTrackCollectionToken_

edm::EDGetTokenT<reco::TrackCollection> MuonIdProducer::innerTrackCollectionToken_
private

Definition at line 235 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ inputCollectionLabels_

std::vector<edm::InputTag> MuonIdProducer::inputCollectionLabels_
private

Definition at line 191 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ inputCollectionTypes_

std::vector<ICTypes::ICTypeKey> MuonIdProducer::inputCollectionTypes_
private

Definition at line 192 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ jetDepositName_

std::string MuonIdProducer::jetDepositName_
private

Definition at line 260 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ linkCollectionHandle_

edm::Handle<reco::MuonTrackLinksCollection> MuonIdProducer::linkCollectionHandle_
private

Definition at line 230 of file MuonIdProducer.h.

Referenced by init(), and produce().

◆ linkCollectionToken_

edm::EDGetTokenT<reco::MuonTrackLinksCollection> MuonIdProducer::linkCollectionToken_
private

Definition at line 238 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ maxAbsDx_

double MuonIdProducer::maxAbsDx_
private

Definition at line 207 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

◆ maxAbsDy_

double MuonIdProducer::maxAbsDy_
private

Definition at line 209 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

◆ maxAbsEta_

double MuonIdProducer::maxAbsEta_
private

Definition at line 203 of file MuonIdProducer.h.

Referenced by isGoodTrack(), and MuonIdProducer().

◆ maxAbsPullX2_

double MuonIdProducer::maxAbsPullX2_
private

Definition at line 208 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

◆ maxAbsPullY2_

double MuonIdProducer::maxAbsPullY2_
private

Definition at line 210 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

◆ meshAlgo_

std::unique_ptr<MuonMesh> MuonIdProducer::meshAlgo_
private

Definition at line 272 of file MuonIdProducer.h.

Referenced by beginRun(), fillArbitrationInfo(), and MuonIdProducer().

◆ minNumberOfMatches_

int MuonIdProducer::minNumberOfMatches_
private

Definition at line 202 of file MuonIdProducer.h.

Referenced by arbitrateMuons(), isGoodRPCMuon(), isGoodTrackerMuon(), and MuonIdProducer().

◆ minP_

double MuonIdProducer::minP_
private

Definition at line 200 of file MuonIdProducer.h.

Referenced by isGoodGEMMuon(), isGoodME0Muon(), isGoodRPCMuon(), isGoodTrack(), isGoodTrackerMuon(), and MuonIdProducer().

◆ minPCaloMuon_

double MuonIdProducer::minPCaloMuon_
private

Definition at line 201 of file MuonIdProducer.h.

Referenced by isGoodCaloMuon(), isGoodTrack(), and MuonIdProducer().

◆ minPt_

double MuonIdProducer::minPt_
private

Definition at line 199 of file MuonIdProducer.h.

Referenced by isGoodGEMMuon(), isGoodRPCMuon(), isGoodTrack(), isGoodTrackerMuon(), and MuonIdProducer().

◆ muIsoExtractorCalo_

std::unique_ptr<reco::isodeposit::IsoDepositExtractor> MuonIdProducer::muIsoExtractorCalo_
private

Definition at line 253 of file MuonIdProducer.h.

Referenced by fillMuonIsolation(), and MuonIdProducer().

◆ muIsoExtractorJet_

std::unique_ptr<reco::isodeposit::IsoDepositExtractor> MuonIdProducer::muIsoExtractorJet_
private

Definition at line 255 of file MuonIdProducer.h.

Referenced by fillMuonIsolation(), and MuonIdProducer().

◆ muIsoExtractorTrack_

std::unique_ptr<reco::isodeposit::IsoDepositExtractor> MuonIdProducer::muIsoExtractorTrack_
private

Definition at line 254 of file MuonIdProducer.h.

Referenced by fillMuonIsolation(), and MuonIdProducer().

◆ muonCaloCompatibility_

MuonCaloCompatibility MuonIdProducer::muonCaloCompatibility_
private

Definition at line 252 of file MuonIdProducer.h.

Referenced by makeCaloMuon(), MuonIdProducer(), and produce().

◆ muonCollectionHandle_

edm::Handle<reco::MuonCollection> MuonIdProducer::muonCollectionHandle_
private

Definition at line 229 of file MuonIdProducer.h.

Referenced by init(), and produce().

◆ muonCollectionToken_

edm::EDGetTokenT<reco::MuonCollection> MuonIdProducer::muonCollectionToken_
private

Definition at line 237 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ outerTrackCollectionHandle_

edm::Handle<reco::TrackCollection> MuonIdProducer::outerTrackCollectionHandle_
private

Definition at line 228 of file MuonIdProducer.h.

Referenced by init(), and produce().

◆ outerTrackCollectionToken_

edm::EDGetTokenT<reco::TrackCollection> MuonIdProducer::outerTrackCollectionToken_
private

Definition at line 236 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ parameters_

TrackAssociatorParameters MuonIdProducer::parameters_
private

Definition at line 145 of file MuonIdProducer.h.

Referenced by Mixins._TypedParameterizable::clone(), Types.PSet::clone(), Types.EDAlias::clone(), Mixins._TypedParameterizable::copy(), fillMuonId(), and MuonIdProducer().

◆ pickyCollectionHandle_

edm::Handle<reco::TrackToTrackMap> MuonIdProducer::pickyCollectionHandle_
private

Definition at line 232 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

◆ pickyCollectionToken_

edm::EDGetTokenT<reco::TrackToTrackMap> MuonIdProducer::pickyCollectionToken_
private

Definition at line 240 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ propagatorToken_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> MuonIdProducer::propagatorToken_
private

Definition at line 250 of file MuonIdProducer.h.

Referenced by init().

◆ ptThresholdToFillCandidateP4WithGlobalFit_

double MuonIdProducer::ptThresholdToFillCandidateP4WithGlobalFit_
private

Definition at line 220 of file MuonIdProducer.h.

Referenced by makeMuon(), and MuonIdProducer().

◆ rpcHitHandle_

edm::Handle<RPCRecHitCollection> MuonIdProducer::rpcHitHandle_
private

Definition at line 246 of file MuonIdProducer.h.

Referenced by fillMuonId(), and init().

◆ rpcHitToken_

edm::EDGetTokenT<RPCRecHitCollection> MuonIdProducer::rpcHitToken_
private

Definition at line 243 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ sigmaThresholdToFillCandidateP4WithGlobalFit_

double MuonIdProducer::sigmaThresholdToFillCandidateP4WithGlobalFit_
private

Definition at line 221 of file MuonIdProducer.h.

Referenced by makeMuon(), and MuonIdProducer().

◆ storeCrossedHcalRecHits_

bool MuonIdProducer::storeCrossedHcalRecHits_
private

Definition at line 215 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

◆ theShowerDigiFiller_

std::unique_ptr<MuonShowerDigiFiller> MuonIdProducer::theShowerDigiFiller_
private

Definition at line 196 of file MuonIdProducer.h.

Referenced by beginRun(), fillMuonId(), MuonIdProducer(), and produce().

◆ theTimingFiller_

std::unique_ptr<MuonTimingFiller> MuonIdProducer::theTimingFiller_
private

Definition at line 194 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ tpfmsCollectionHandle_

edm::Handle<reco::TrackToTrackMap> MuonIdProducer::tpfmsCollectionHandle_
private

Definition at line 231 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

◆ tpfmsCollectionToken_

edm::EDGetTokenT<reco::TrackToTrackMap> MuonIdProducer::tpfmsCollectionToken_
private

Definition at line 239 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

◆ trackAssociator_

TrackDetectorAssociator MuonIdProducer::trackAssociator_
private

Definition at line 144 of file MuonIdProducer.h.

Referenced by fillMuonId(), and init().

◆ trackDepositName_

std::string MuonIdProducer::trackDepositName_
private

Definition at line 256 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

◆ trackerKinkFinder_

std::unique_ptr<MuonKinkFinder> MuonIdProducer::trackerKinkFinder_
private

Definition at line 267 of file MuonIdProducer.h.

Referenced by fillTrackerKink(), init(), and MuonIdProducer().

◆ writeIsoDeposits_

bool MuonIdProducer::writeIsoDeposits_
private

Definition at line 219 of file MuonIdProducer.h.

Referenced by fillMuonIsolation(), MuonIdProducer(), and produce().

MuonIdProducer::fillIsolation_
bool fillIsolation_
Definition: MuonIdProducer.h:218
MuonIdProducer::fillGlobalTrackQuality_
bool fillGlobalTrackQuality_
Definition: MuonIdProducer.h:262
MuonSubdetId::GEM
static constexpr int GEM
Definition: MuonSubdetId.h:14
MuonIdProducer::maxAbsPullY2_
double maxAbsPullY2_
Definition: MuonIdProducer.h:210
MuonIdProducer::maxAbsPullX2_
double maxAbsPullX2_
Definition: MuonIdProducer.h:208
reco::Muon::RPCHitAndTrackArbitration
Definition: Muon.h:192
MuonIdProducer::tpfmsCollectionHandle_
edm::Handle< reco::TrackToTrackMap > tpfmsCollectionHandle_
Definition: MuonIdProducer.h:231
PDWG_BPHSkim_cff.muons
muons
Definition: PDWG_BPHSkim_cff.py:47
reco::MuonSegmentMatch::BelongsToTrackByDXSlope
static const unsigned int BelongsToTrackByDXSlope
Definition: MuonSegmentMatch.h:26
reco::MuonEnergy
Definition: MuonEnergy.h:17
MuonIdProducer::minPt_
double minPt_
Definition: MuonIdProducer.h:199
reco::MuonEnergy::ecal_time
float ecal_time
Calorimeter timing.
Definition: MuonEnergy.h:47
TrackDetectorAssociator::crossedIP
static bool crossedIP(const reco::Track &track)
Definition: TrackDetectorAssociator.cc:1056
BeamSpotPI::parameters
parameters
Definition: BeamSpotPayloadInspectorHelper.h:29
MuonSubdetId::CSC
static constexpr int CSC
Definition: MuonSubdetId.h:12
MuonIdProducer::ICTypes::INNER_TRACKS
Definition: MuonIdProducer.h:148
TrackDetectorAssociator::Any
Definition: TrackDetectorAssociator.h:50
MuonIdProducer::muonCollectionHandle_
edm::Handle< reco::MuonCollection > muonCollectionHandle_
Definition: MuonIdProducer.h:229
MuonIdProducer::muonCaloCompatibility_
MuonCaloCompatibility muonCaloCompatibility_
Definition: MuonIdProducer.h:252
mps_fire.i
i
Definition: mps_fire.py:428
edm::ESInputTag
Definition: ESInputTag.h:87
edm::ParameterSetDescription::add
ParameterDescriptionBase * add(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:95
reco::MuonQuality
Definition: MuonQuality.h:6
MuonIdProducer::outerTrackCollectionHandle_
edm::Handle< reco::TrackCollection > outerTrackCollectionHandle_
Definition: MuonIdProducer.h:228
reco::Muon::MuonTrackTypePair
std::pair< TrackRef, Muon::MuonTrackType > MuonTrackTypePair
Definition: Muon.h:38
reco::Muon::setMatches
void setMatches(const std::vector< MuonChamberMatch > &matches)
set muon matching information
Definition: Muon.h:148
HLT_FULL_cff.track
track
Definition: HLT_FULL_cff.py:11713
muon::tevOptimized
reco::Muon::MuonTrackTypePair tevOptimized(const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const reco::TrackRef &tpfmsTrack, const reco::TrackRef &pickyTrack, const reco::TrackRef &dytTrack, const double ptThreshold=200., const double tune1=17., const double tune2=40., const double dptcut=0.25)
Definition: MuonCocktails.cc:9
MuonIdProducer::muIsoExtractorJet_
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorJet_
Definition: MuonIdProducer.h:255
HLT_FULL_cff.inputCollectionTypes
inputCollectionTypes
Definition: HLT_FULL_cff.py:11575
MuonIdProducer::pickyCollectionToken_
edm::EDGetTokenT< reco::TrackToTrackMap > pickyCollectionToken_
Definition: MuonIdProducer.h:240
MuonIdProducer::ICTypes::TEV_PICKY
Definition: MuonIdProducer.h:148
hit::id
unsigned int id
Definition: SiStripHitEffFromCalibTree.cc:92
MuonIdProducer::init
void init(edm::Event &, const edm::EventSetup &)
Definition: MuonIdProducer.cc:191
MuonIdProducer::arbitrateTrackerMuons_
bool arbitrateTrackerMuons_
Definition: MuonIdProducer.h:223
reco::Muon::SegmentAndTrackArbitration
Definition: Muon.h:190
MuonIdProducer::jetDepositName_
std::string jetDepositName_
Definition: MuonIdProducer.h:260
reco::Muon::StandAloneMuon
static const unsigned int StandAloneMuon
Definition: Muon.h:287
reco::MuonEnergy::hcal_position
math::XYZPointF hcal_position
Definition: MuonEnergy.h:54
MuonIdProducer::isGoodTrackerMuon
bool isGoodTrackerMuon(const reco::Muon &muon)
Definition: MuonIdProducer.cc:755
custom_jme_cff.nMuons
nMuons
Definition: custom_jme_cff.py:148
muon
Definition: MuonCocktails.h:17
reco::Muon::isRPCMuon
bool isRPCMuon() const
Definition: Muon.h:304
MuonIdProducer::ICTypes::TEV_FIRSTHIT
Definition: MuonIdProducer.h:148
reco::MuonChamberMatch::x
float x
Definition: MuonChamberMatch.h:19
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
reco::Muon::TPFMS
Definition: Muon.h:36
reco::MuonIsolation::emEt
float emEt
ecal sum-Et
Definition: MuonIsolation.h:7
reco::deltaPhi
constexpr double deltaPhi(double phi1, double phi2)
Definition: deltaPhi.h:26
MuonIdProducer::innerTrackCollectionHandle_
edm::Handle< reco::TrackCollection > innerTrackCollectionHandle_
Definition: MuonIdProducer.h:227
reco::MuonSegmentMatch::BestInStationByDRSlope
static const unsigned int BestInStationByDRSlope
Definition: MuonSegmentMatch.h:23
edm::Ref::isNull
bool isNull() const
Checks for null.
Definition: Ref.h:235
reco::MuonQuality::trkRelChi2
float trkRelChi2
chi2 value for the inner track stub with respect to the global track
Definition: MuonQuality.h:15
reco::MuonIsolation::nJets
int nJets
number of jets in the cone
Definition: MuonIsolation.h:11
CSCDetId::ring
int ring() const
Definition: CSCDetId.h:68
MuonIdProducer::pickyCollectionHandle_
edm::Handle< reco::TrackToTrackMap > pickyCollectionHandle_
Definition: MuonIdProducer.h:232
MuonIdProducer::outerTrackCollectionToken_
edm::EDGetTokenT< reco::TrackCollection > outerTrackCollectionToken_
Definition: MuonIdProducer.h:236
reco::Muon::setTunePBestTrack
virtual void setTunePBestTrack(MuonTrackType muonType)
Definition: Muon.h:88
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
reco::MuonTimeExtra::timeAtIpInOutErr
float timeAtIpInOutErr() const
Definition: MuonTimeExtra.h:44
reco::Muon::DYT
Definition: Muon.h:36
reco::Muon::matches
std::vector< MuonChamberMatch > & matches()
get muon matching information
Definition: Muon.h:145
MuonIdProducer::ptThresholdToFillCandidateP4WithGlobalFit_
double ptThresholdToFillCandidateP4WithGlobalFit_
Definition: MuonIdProducer.h:220
reco::Muon::setInnerTrack
virtual void setInnerTrack(const TrackRef &t)
set reference to Track
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89287
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
reco::MuonChamberMatch::dYdZ
float dYdZ
Definition: MuonChamberMatch.h:24
reco::IsoDeposit::depositAndCountWithin
std::pair< double, int > depositAndCountWithin(double coneSize, const Vetos &vetos=Vetos(), double threshold=-1e+36, bool skipDepositVeto=false) const
Get deposit.
Definition: IsoDeposit.cc:37
reco::MuonRPCHitMatch::bx
int bx
Definition: MuonRPCHitMatch.h:11
MuonIdProducer::storeCrossedHcalRecHits_
bool storeCrossedHcalRecHits_
Definition: MuonIdProducer.h:215
MuonIdProducer::isGoodTrack
bool isGoodTrack(const reco::Track &track)
Definition: MuonIdProducer.cc:351
edm::Ref::get
T const * get() const
Returns C++ pointer to the item.
Definition: Ref.h:232
MuonIdProducer::maxAbsDx_
double maxAbsDx_
Definition: MuonIdProducer.h:207
reco::Muon::setCombinedQuality
void setCombinedQuality(const MuonQuality &combinedQuality)
set energy deposition information
Definition: Muon.h:121
MuonIdProducer::dytCollectionToken_
edm::EDGetTokenT< reco::TrackToTrackMap > dytCollectionToken_
Definition: MuonIdProducer.h:241
reco::Muon::PFMuon
static const unsigned int PFMuon
Definition: Muon.h:289
reco::MuonEnergy::had
float had
Definition: MuonEnergy.h:36
reco::MuonChamberMatch::rpcMatches
std::vector< reco::MuonRPCHitMatch > rpcMatches
Definition: MuonChamberMatch.h:16
info
static const TGPicture * info(bool iBackgroundIsBlack)
Definition: FWCollectionSummaryWidget.cc:153
SortMuonSegmentMatches
functor predicate for standard library sort algorithm
Definition: MuonArbitrationMethods.h:12
reco::MuonTime::timeAtIpOutInErr
float timeAtIpOutInErr
Definition: MuonTime.h:17
reco::MuonTimeExtra::nDof
int nDof() const
number of measurements used in timing calculation
Definition: MuonTimeExtra.h:22
reco::HcalMuonRecHit::time
float time
Definition: MuonEnergy.h:12
MuonIdProducer::linkCollectionToken_
edm::EDGetTokenT< reco::MuonTrackLinksCollection > linkCollectionToken_
Definition: MuonIdProducer.h:238
MuonIdProducer::innerTrackCollectionToken_
edm::EDGetTokenT< reco::TrackCollection > innerTrackCollectionToken_
Definition: MuonIdProducer.h:235
MuonIdProducer::writeIsoDeposits_
bool writeIsoDeposits_
Definition: MuonIdProducer.h:219
MuonIdProducer::ICTypes::toKey
static ICTypeKey toKey(const std::string &s)
Definition: MuonIdProducer.h:150
MuonIdProducer::minNumberOfMatches_
int minNumberOfMatches_
Definition: MuonIdProducer.h:202
MuonIdProducer::rpcHitHandle_
edm::Handle< RPCRecHitCollection > rpcHitHandle_
Definition: MuonIdProducer.h:246
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
reco::MuonEnergy::hcal_time
float hcal_time
Definition: MuonEnergy.h:49
reco::MuonEnergy::hadS9
float hadS9
energy deposited in 3x3 HCAL tower shape around central tower
Definition: MuonEnergy.h:38
MuonIdProducer::theShowerDigiFiller_
std::unique_ptr< MuonShowerDigiFiller > theShowerDigiFiller_
Definition: MuonIdProducer.h:196
MuonIdProducer::ICTypes::LINKS
Definition: MuonIdProducer.h:148
reco::MuonSegmentMatch::dtSegmentRef
DTRecSegment4DRef dtSegmentRef
Definition: MuonSegmentMatch.h:50
reco::MuonSegmentMatch::y
float y
Definition: MuonSegmentMatch.h:35
reco::Muon::setIsolation
void setIsolation(const MuonIsolation &isoR03, const MuonIsolation &isoR05)
reco::MuonSegmentMatch::xErr
float xErr
Definition: MuonSegmentMatch.h:36
reco::Muon::setBestTrack
virtual void setBestTrack(MuonTrackType muonType)
Definition: Muon.h:86
reco::MuonEnergy::tower
float tower
Definition: MuonEnergy.h:20
reco::MuonIsolation
Definition: MuonIsolation.h:5
edm::LogWarning
Log< level::Warning, false > LogWarning
Definition: MessageLogger.h:122
reco::Muon::setOuterTrack
virtual void setOuterTrack(const TrackRef &t)
set reference to Track
reco::MuonSegmentMatch::BelongsToTrackByDR
static const unsigned int BelongsToTrackByDR
Definition: MuonSegmentMatch.h:25
reco::CaloMuon::setCaloCompatibility
void setCaloCompatibility(float input)
Definition: CaloMuon.h:46
reco::MuonChamberMatch::dXdZErr
float dXdZErr
Definition: MuonChamberMatch.h:25
reco::Muon
Definition: Muon.h:27
MuonIdProducer::trackAssociator_
TrackDetectorAssociator trackAssociator_
Definition: MuonIdProducer.h:144
MuonIdProducer::linkCollectionHandle_
edm::Handle< reco::MuonTrackLinksCollection > linkCollectionHandle_
Definition: MuonIdProducer.h:230
edm::Ref< TrackCollection >
MuonIdProducer::muonCollectionToken_
edm::EDGetTokenT< reco::MuonCollection > muonCollectionToken_
Definition: MuonIdProducer.h:237
reco::MuonTime
Definition: MuonTime.h:5
MuonIdProducer::ecalDepositName_
std::string ecalDepositName_
Definition: MuonIdProducer.h:257
reco::MuonSegmentMatch::BestInStationByDX
static const unsigned int BestInStationByDX
Definition: MuonSegmentMatch.h:20
reco::MuonSegmentMatch::cscSegmentRef
CSCSegmentRef cscSegmentRef
Definition: MuonSegmentMatch.h:51
reco::Muon::GEMMuon
static const unsigned int GEMMuon
Definition: Muon.h:291
reco::MuonSegmentMatch::BelongsToTrackByDRSlope
static const unsigned int BelongsToTrackByDRSlope
Definition: MuonSegmentMatch.h:27
TrackDetMatchInfo::EcalRecHits
Definition: TrackDetMatchInfo.h:15
reco::MuonSegmentMatch::BestInStationByDXSlope
static const unsigned int BestInStationByDXSlope
Definition: MuonSegmentMatch.h:22
susybsm::HSCParticleType::trackerMuon
Definition: HSCParticle.h:20
DetId
Definition: DetId.h:17
MuonIdProducer::meshAlgo_
std::unique_ptr< MuonMesh > meshAlgo_
Definition: MuonIdProducer.h:272
MuonIdProducer::ICTypes::TEV_DYT
Definition: MuonIdProducer.h:148
reco::MuonIsolation::sumPt
float sumPt
sum-pt of tracks
Definition: MuonIsolation.h:6
reco::MuonIsolation::hoVetoEt
float hoVetoEt
ho sum-et in the veto region in r-phi
Definition: MuonIsolation.h:15
MuonIdProducer::inputCollectionLabels_
std::vector< edm::InputTag > inputCollectionLabels_
Definition: MuonIdProducer.h:191
reco::CaloMuon::setInnerTrack
virtual void setInnerTrack(const TrackRef &t)
set reference to Track
Definition: CaloMuon.h:30
reco::MuonSegmentMatch::me0SegmentRef
ME0SegmentRef me0SegmentRef
Definition: MuonSegmentMatch.h:53
MuonIdProducer::dytCollectionHandle_
edm::Handle< reco::TrackToTrackMap > dytCollectionHandle_
Definition: MuonIdProducer.h:233
reco::MuonEnergy::crossedHadRecHits
std::vector< HcalMuonRecHit > crossedHadRecHits
Definition: MuonEnergy.h:66
reco::MuonSegmentMatch
Definition: MuonSegmentMatch.h:12
reco::MuonTimeExtra
Definition: MuonTimeExtra.h:15
MuonIdProducer::makeMuon
reco::Muon makeMuon(edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::TrackRef &track, TrackType type)
Definition: MuonIdProducer.cc:253
directions
directions
Definition: DeviationsFromFileSensor2D.cc:15
MuonCaloCompatibility::configure
void configure(const edm::ParameterSet &)
Definition: MuonCaloCompatibility.cc:21
reco::MuonSegmentMatch::Arbitrated
static const unsigned int Arbitrated
segment mask flags
Definition: MuonSegmentMatch.h:15
reco::Muon::OuterTrack
Definition: Muon.h:36
reco::Muon::setGlobalTrack
virtual void setGlobalTrack(const TrackRef &t)
set reference to Track
MuonIdProducer::isGoodGEMMuon
bool isGoodGEMMuon(const reco::Muon &muon)
Definition: MuonIdProducer.cc:779
MuonIdProducer::arbitrateMuons
void arbitrateMuons(reco::MuonCollection *, reco::CaloMuonCollection *)
Definition: MuonIdProducer.cc:1027
LocalError::xx
float xx() const
Definition: LocalError.h:22
reco::MuonSegmentMatch::BestInChamberByDX
static const unsigned int BestInChamberByDX
Definition: MuonSegmentMatch.h:16
PVValHelper::eta
Definition: PVValidationHelpers.h:69
MuonIdProducer::fillMatching_
bool fillMatching_
Definition: MuonIdProducer.h:216
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
reco::MuonChamberMatch::gemMatches
std::vector< reco::MuonSegmentMatch > gemMatches
Definition: MuonChamberMatch.h:13
MuonIdProducer::getSegmentMatches
std::vector< reco::MuonSegmentMatch > * getSegmentMatches(reco::MuonChamberMatch &chamber, unsigned int muonType) const
get the segment matches of the appropriate type
Definition: MuonIdProducer.h:133
muon::sigmaSwitch
reco::Muon::MuonTrackTypePair sigmaSwitch(const reco::TrackRef &combinedTrack, const reco::TrackRef &trackerTrack, const double nSigma=2., const double ptThreshold=200.)
Definition: MuonCocktails.cc:139
validateGlobalMuonPair
bool validateGlobalMuonPair(const reco::MuonTrackLinks &goodMuon, const reco::MuonTrackLinks &badMuon)
Definition: MuonIdProducer.cc:421
reco::Track
Definition: Track.h:27
MuonIdProducer::ICTypes::toStr
static std::string toStr(const ICTypeKey k)
Definition: MuonIdProducer.h:169
reco::MuonSegmentMatch::gemSegmentRef
GEMSegmentRef gemSegmentRef
Definition: MuonSegmentMatch.h:52
TrackDetectorAssociator::OutsideIn
Definition: TrackDetectorAssociator.h:50
MuonIdProducer::glbQualToken_
edm::EDGetTokenT< edm::ValueMap< reco::MuonQuality > > glbQualToken_
Definition: MuonIdProducer.h:244
reco::Muon::setMuonTrack
void setMuonTrack(const MuonTrackType &, const TrackRef &)
MuonIdProducer::muIsoExtractorCalo_
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorCalo_
Definition: MuonIdProducer.h:253
HCALHighEnergyHPDFilter_cfi.energy
energy
Definition: HCALHighEnergyHPDFilter_cfi.py:5
MuonSubdetId::DT
static constexpr int DT
Definition: MuonSubdetId.h:11
reco::MuonEnergy::ho
float ho
energy deposited in crossed HO towers
Definition: MuonEnergy.h:42
reco::MuonRPCHitMatch::x
float x
Definition: MuonRPCHitMatch.h:9
TrackAssociatorParameters::loadParameters
void loadParameters(const edm::ParameterSet &, edm::ConsumesCollector &)
Definition: TrackAssociatorParameters.cc:18
b
double b
Definition: hdecay.h:118
reco::MuonTime::nDof
int nDof
number of muon stations used
Definition: MuonTime.h:9
reco::MuonSegmentMatch::hasZed_
bool hasZed_
Definition: MuonSegmentMatch.h:43
reco::MuonSegmentMatch::dYdZ
float dYdZ
Definition: MuonSegmentMatch.h:39
reco::MuonChamberMatch::dYdZErr
float dYdZErr
Definition: MuonChamberMatch.h:26
reco::Muon::Picky
Definition: Muon.h:36
reco::MuonTimeExtra::timeAtIpOutIn
float timeAtIpOutIn() const
b) particle is moving from outside in
Definition: MuonTimeExtra.h:48
TrackDetectorAssociator::setPropagator
void setPropagator(const Propagator *)
use a user configured propagator
Definition: TrackDetectorAssociator.cc:76
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
reco::MuonRPCHitMatch::mask
unsigned int mask
Definition: MuonRPCHitMatch.h:10
reco::MuonChamberMatch::dXdZ
float dXdZ
Definition: MuonChamberMatch.h:23
MuonIdProducer::caloCut_
double caloCut_
Definition: MuonIdProducer.h:269
reco::TrackRef
edm::Ref< TrackCollection > TrackRef
persistent reference to a Track
Definition: TrackFwd.h:20
reco::HcalMuonRecHit::detId
HcalDetId detId
Definition: MuonEnergy.h:13
reco::Muon::combinedMuon
TrackRef combinedMuon() const override
reference to a stand-alone muon Track
Definition: Muon.h:52
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
reco::MuonEnergy::emS25
float emS25
energy deposited in 5x5 ECAL crystal shape around central crystal
Definition: MuonEnergy.h:30
reco::Muon::isGlobalMuon
bool isGlobalMuon() const override
Definition: Muon.h:299
MuonIdProducer::ICTypes::MUONS
Definition: MuonIdProducer.h:148
reco::MuonEnergy::hcal_id
DetId hcal_id
DetId of the central HCAL tower with smallest depth.
Definition: MuonEnergy.h:60
edm::helpers::KeyVal::val
V val
Definition: AssociationMapHelpers.h:33
reco::MuonEnergy::emS9
float emS9
energy deposited in 3x3 ECAL crystal shape around central crystal
Definition: MuonEnergy.h:28
reco::Muon::isQualityValid
bool isQualityValid() const
Definition: Muon.h:117
reco::Muon::NoArbitration
Definition: Muon.h:188
edm::HandleBase::clear
void clear()
Definition: HandleBase.h:51
edm::HandleBase::failedToGet
bool failedToGet() const
Definition: HandleBase.h:72
MuonIdProducer::debugWithTruthMatching_
bool debugWithTruthMatching_
Definition: MuonIdProducer.h:225
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:223
MuonIdProducer::makeCaloMuon
reco::CaloMuon makeCaloMuon(const reco::Muon &)
Definition: MuonIdProducer.cc:273
edm::ParameterSet
Definition: ParameterSet.h:47
MuonIdProducer::sectorPhi
static double sectorPhi(const DetId &id)
Definition: MuonIdProducer.cc:1315
MuonIdProducer::fillTrackerKink_
bool fillTrackerKink_
Definition: MuonIdProducer.h:266
a
double a
Definition: hdecay.h:119
reco::MuonRPCHitMatch
Definition: MuonRPCHitMatch.h:7
reco::MuonTime::timeAtIpInOutErr
float timeAtIpInOutErr
Definition: MuonTime.h:14
muon::getTevRefitTrack
reco::TrackRef getTevRefitTrack(const reco::TrackRef &combinedTrack, const reco::TrackToTrackMap &map)
Definition: MuonCocktails.cc:131
reco::MuonChamberMatch::id
DetId id
Definition: MuonChamberMatch.h:27
reco::MuonTime::timeAtIpOutIn
float timeAtIpOutIn
b) particle is moving from outside in
Definition: MuonTime.h:16
reco::MuonEnergy::hadMax
float hadMax
maximal energy of HCAL tower in the 3x3 shape
Definition: MuonEnergy.h:40
reco::Muon::GlobalMuon
static const unsigned int GlobalMuon
Definition: Muon.h:285
LocalError
Definition: LocalError.h:12
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
MuonIdProducer::trackDepositName_
std::string trackDepositName_
Definition: MuonIdProducer.h:256
reco::MuonIsolation::hadVetoEt
float hadVetoEt
hcal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:14
trigObjTnPSource_cfi.filler
filler
Definition: trigObjTnPSource_cfi.py:21
edm::Ref::isNonnull
bool isNonnull() const
Checks for non-null.
Definition: Ref.h:238
MuonIdProducer::isGoodME0Muon
bool isGoodME0Muon(const reco::Muon &muon)
Definition: MuonIdProducer.cc:785
CSCDetId
Definition: CSCDetId.h:26
MuonIdProducer::minP_
double minP_
Definition: MuonIdProducer.h:200
match
std::pair< typename Association::data_type::first_type, double > match(Reference key, Association association, bool bestMatchByMaxValue)
Generic matching function.
Definition: Utils.h:10
MuonIdProducer::glbQualHandle_
edm::Handle< edm::ValueMap< reco::MuonQuality > > glbQualHandle_
Definition: MuonIdProducer.h:247
MuonIdTruthInfo::truthMatchMuon
static void truthMatchMuon(const edm::Event &iEvent, const edm::EventSetup &iSetup, reco::Muon &aMuon)
Definition: MuonIdTruthInfo.cc:17
reco::MuonSegmentMatch::mask
unsigned int mask
Definition: MuonSegmentMatch.h:42
reco::MuonEnergy::hoS9
float hoS9
energy deposited in 3x3 HO tower shape around central tower
Definition: MuonEnergy.h:44
iEvent
int iEvent
Definition: GenABIO.cc:224
dumpRecoGeometry_cfg.Muon
Muon
Definition: dumpRecoGeometry_cfg.py:190
reco::MuonEnergy::towerS9
float towerS9
total energy in 3x3 tower shape
Definition: MuonEnergy.h:22
mergedMuons_cfi.caloMuons
caloMuons
Definition: mergedMuons_cfi.py:7
reco::Muon::GEMSegmentAndTrackArbitration
Definition: Muon.h:193
caloParams_cfi.caloParams
caloParams
Definition: caloParams_cfi.py:10
p4
double p4[4]
Definition: TauolaWrapper.h:92
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
reco::IsoDeposit::candEnergy
double candEnergy() const
Get energy or pT attached to cand trajectory.
Definition: IsoDeposit.h:129
CSCDetId::chamberId
CSCDetId chamberId() const
Definition: CSCDetId.h:47
reco::MuonIsolation::nTracks
int nTracks
number of tracks in the cone (excluding veto region)
Definition: MuonIsolation.h:10
reco::MuonChamberMatch::xErr
float xErr
Definition: MuonChamberMatch.h:21
reco::MuonIsolation::hoEt
float hoEt
ho sum-Et
Definition: MuonIsolation.h:9
MuonIdProducer::fillMuonIsolation
void fillMuonIsolation(edm::Event &, const edm::EventSetup &, reco::Muon &aMuon, reco::IsoDeposit &trackDep, reco::IsoDeposit &ecalDep, reco::IsoDeposit &hcalDep, reco::IsoDeposit &hoDep, reco::IsoDeposit &jetDep)
Definition: MuonIdProducer.cc:1242
MuonIdProducer::checkLinks
bool checkLinks(const reco::MuonTrackLinks *) const
Definition: MuonIdProducer.cc:1369
MuonSubdetId::ME0
static constexpr int ME0
Definition: MuonSubdetId.h:15
MuonIdProducer::arbClean_
bool arbClean_
Definition: MuonIdProducer.h:271
reco::JetExtendedAssociation::value_type
Container::value_type value_type
Definition: JetExtendedAssociation.h:30
edm::ParameterSetDescription::setAllowAnything
void setAllowAnything()
allow any parameter label/value pairs
Definition: ParameterSetDescription.cc:37
reco::MuonSegmentMatch::hasPhi_
bool hasPhi_
Definition: MuonSegmentMatch.h:44
MuonIdProducer::addExtraSoftMuons_
bool addExtraSoftMuons_
Definition: MuonIdProducer.h:204
reco::MuonChamberMatch
Definition: MuonChamberMatch.h:10
TrackDetectorAssociator::InsideOut
Definition: TrackDetectorAssociator.h:50
reco::Muon::InnerTrack
Definition: Muon.h:36
get
#define get
MuonIdProducer::propagatorToken_
const edm::ESGetToken< Propagator, TrackingComponentsRecord > propagatorToken_
Definition: MuonIdProducer.h:250
MuonIdProducer::hcalDepositName_
std::string hcalDepositName_
Definition: MuonIdProducer.h:258
DataMixerDataOnData_cff.inputLabel
inputLabel
Definition: DataMixerDataOnData_cff.py:44
reco::MuonIsolation::emVetoEt
float emVetoEt
ecal sum-et in the veto region in r-phi
Definition: MuonIsolation.h:13
reco::MuonChamberMatch::yErr
float yErr
Definition: MuonChamberMatch.h:22
reco::MuonSegmentMatch::dXdZ
float dXdZ
Definition: MuonSegmentMatch.h:38
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:120
MuonIdProducer::hoDepositName_
std::string hoDepositName_
Definition: MuonIdProducer.h:259
MuonIdProducer::fillShowerDigis_
bool fillShowerDigis_
Definition: MuonIdProducer.h:217
reco::MuonChamberMatch::me0Matches
std::vector< reco::MuonSegmentMatch > me0Matches
Definition: MuonChamberMatch.h:14
reco::Muon::track
TrackRef track() const override
reference to a Track
Definition: Muon.h:46
reco::Muon::innerTrack
virtual TrackRef innerTrack() const
Definition: Muon.h:45
DDAxes::phi
MuonIdProducer::theTimingFiller_
std::unique_ptr< MuonTimingFiller > theTimingFiller_
Definition: MuonIdProducer.h:194
reco::MuonTimeExtra::timeAtIpOutInErr
float timeAtIpOutInErr() const
Definition: MuonTimeExtra.h:49
reco::MuonChamberMatch::edgeY
float edgeY
Definition: MuonChamberMatch.h:18
TrackDetMatchInfo
Definition: TrackDetMatchInfo.h:13
MuonIdProducer::approxEqual
bool approxEqual(const double a, const double b, const double tol=1E-3) const
Definition: MuonIdProducer.h:128
PA_ZEESkim_cff.decay
decay
Definition: PA_ZEESkim_cff.py:26
MuonIdProducer::overlap
int overlap(const reco::Muon &muon, const reco::Track &track)
Definition: MuonIdProducer.cc:385
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
eostools.move
def move(src, dest)
Definition: eostools.py:511
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
edm::OrphanHandle
Definition: EDProductfwd.h:39
MuonIdProducer::phiOfMuonInteractionRegion
double phiOfMuonInteractionRegion(const reco::Muon &muon) const
Definition: MuonIdProducer.cc:1335
reco::MuonEnergy::emMax
float emMax
maximal energy of ECAL crystal in the 5x5 shape
Definition: MuonEnergy.h:32
reco::Muon::isTrackerMuon
bool isTrackerMuon() const override
Definition: Muon.h:300
MuonIdProducer::trackerKinkFinder_
std::unique_ptr< MuonKinkFinder > trackerKinkFinder_
Definition: MuonIdProducer.h:267
reco::MuonIsolation::hadEt
float hadEt
hcal sum-Et
Definition: MuonIsolation.h:8
reco::MuonSegmentMatch::BestInChamberByDRSlope
static const unsigned int BestInChamberByDRSlope
Definition: MuonSegmentMatch.h:19
reco::HcalMuonRecHit::energy
float energy
Definition: MuonEnergy.h:10
qcdUeDQM_cfi.quality
quality
Definition: qcdUeDQM_cfi.py:31
reco::IsoDeposit::depositWithin
double depositWithin(double coneSize, const Vetos &vetos=Vetos(), bool skipDepositVeto=false) const
Get deposit.
Definition: IsoDeposit.cc:29
MuonIdProducer::fillTrackerKink
void fillTrackerKink(reco::Muon &aMuon)
Definition: MuonIdProducer.cc:1356
reco::CaloMuon
Definition: CaloMuon.h:21
MuonSubdetId::RPC
static constexpr int RPC
Definition: MuonSubdetId.h:13
math::XYZTLorentzVector
XYZTLorentzVectorD XYZTLorentzVector
Lorentz vector with cylindrical internal representation using pseudorapidity.
Definition: LorentzVector.h:29
edm::ValueMap
Definition: ValueMap.h:107
ev
bool ev
Definition: Hydjet2Hadronizer.cc:95
Exception
Definition: hltDiff.cc:246
MuonIdProducer::fillCaloCompatibility_
bool fillCaloCompatibility_
Definition: MuonIdProducer.h:213
reco::Muon::setCalEnergy
void setCalEnergy(const MuonEnergy &calEnergy)
set energy deposition information
Definition: Muon.h:108
reco::Muon::ME0SegmentAndTrackArbitration
Definition: Muon.h:194
reco::Muon::numberOfMatches
int numberOfMatches(ArbitrationType type=SegmentAndTrackArbitration) const
get number of chambers with matched segments
electronStore.links
links
Definition: electronStore.py:149
reco::MuonChamberMatch::y
float y
Definition: MuonChamberMatch.h:20
MuonIdProducer::maxAbsDy_
double maxAbsDy_
Definition: MuonIdProducer.h:209
relativeConstraints.chamber
chamber
Definition: relativeConstraints.py:53
or
The Signals That Services Can Subscribe To This is based on ActivityRegistry and is current per Services can connect to the signals distributed by the ActivityRegistry in order to monitor the activity of the application Each possible callback has some defined which we here list in angle e< void, edm::EventID const &, edm::Timestamp const & > We also list in braces which AR_WATCH_USING_METHOD_ is used for those or
Definition: Activities.doc:12
reco::MuonIsolation::trackerVetoPt
float trackerVetoPt
(sum-)pt inside the veto region in r-phi
Definition: MuonIsolation.h:12
reco::MuonSegmentMatch::BestInChamberByDXSlope
static const unsigned int BestInChamberByDXSlope
Definition: MuonSegmentMatch.h:18
reco::IsoDeposit
Definition: IsoDeposit.h:49
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
Definition: ParameterSet.h:303
TrackDetMatchInfo::HcalRecHits
Definition: TrackDetMatchInfo.h:15
reco::MuonSegmentMatch::BestInStationByDR
static const unsigned int BestInStationByDR
Definition: MuonSegmentMatch.h:21
reco::MuonSegmentMatch::yErr
float yErr
Definition: MuonSegmentMatch.h:37
patCandidatesForDimuonsSequences_cff.matches
matches
Definition: patCandidatesForDimuonsSequences_cff.py:131
reco::MuonEnergy::ecal_position
math::XYZPointF ecal_position
Trajectory position at the calorimeter.
Definition: MuonEnergy.h:53
MuonIdProducer::ICTypes::OUTER_TRACKS
Definition: MuonIdProducer.h:148
reco::MuonChamberMatch::edgeX
float edgeX
Definition: MuonChamberMatch.h:17
reco::Muon::RPCMuon
static const unsigned int RPCMuon
Definition: Muon.h:290
MuonIdProducer::geomTokenRun_
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord > geomTokenRun_
Definition: MuonIdProducer.h:249
TrackDetMatchInfo::HORecHits
Definition: TrackDetMatchInfo.h:15
funct::pow
Power< A, B >::type pow(const A &a, const B &b)
Definition: Power.h:29
reco::Muon::combinedQuality
MuonQuality combinedQuality() const
get energy deposition information
Definition: Muon.h:119
reco::MuonSegmentMatch::BelongsToTrackByME1aClean
static const unsigned int BelongsToTrackByME1aClean
Definition: MuonSegmentMatch.h:28
M_PI_2
#define M_PI_2
Definition: CSCGattiFunction.cc:6
reco::MuonEnergy::ecal_id
DetId ecal_id
DetId of the central ECAL crystal.
Definition: MuonEnergy.h:57
MuonIdProducer::fillEnergy_
bool fillEnergy_
Definition: MuonIdProducer.h:214
cms::Exception
Definition: Exception.h:70
DetId::Muon
Definition: DetId.h:26
reco::Muon::TrackerMuon
static const unsigned int TrackerMuon
Definition: Muon.h:286
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TrackDetectorAssociator::associate
TrackDetMatchInfo associate(const edm::Event &, const edm::EventSetup &, const FreeTrajectoryState &, const AssociatorParameters &)
Definition: TrackDetectorAssociator.cc:110
DTChamberId
Definition: DTChamberId.h:14
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:224
reco::HcalMuonRecHit::chi2
float chi2
Definition: MuonEnergy.h:11
reco::MuonTime::timeAtIpInOut
float timeAtIpInOut
Definition: MuonTime.h:13
reco::MuonSegmentMatch::BelongsToTrackByDX
static const unsigned int BelongsToTrackByDX
Definition: MuonSegmentMatch.h:24
reco::MuonTimeExtra::timeAtIpInOut
float timeAtIpInOut() const
Definition: MuonTimeExtra.h:43
MuonIdProducer::chamberId
unsigned int chamberId(const DetId &)
Definition: MuonIdProducer.cc:371
MuonIdProducer::tpfmsCollectionToken_
edm::EDGetTokenT< reco::TrackToTrackMap > tpfmsCollectionToken_
Definition: MuonIdProducer.h:239
TrackDetMatchInfo::TowerTotal
Definition: TrackDetMatchInfo.h:15
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
MuonIdProducer::rpcHitToken_
edm::EDGetTokenT< RPCRecHitCollection > rpcHitToken_
Definition: MuonIdProducer.h:243
MuonIdProducer::fillMuonId
void fillMuonId(edm::Event &, const edm::EventSetup &, reco::Muon &, TrackDetectorAssociator::Direction direction=TrackDetectorAssociator::InsideOut)
Definition: MuonIdProducer.cc:792
MuonIdProducer::inputCollectionTypes_
std::vector< ICTypes::ICTypeKey > inputCollectionTypes_
Definition: MuonIdProducer.h:192
reco::MuonSegmentMatch::dXdZErr
float dXdZErr
Definition: MuonSegmentMatch.h:40
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
MuonCaloCompatibility::evaluate
double evaluate(const reco::Muon &)
Definition: MuonCaloCompatibility.cc:154
MuonIdProducer::isGoodCaloMuon
bool isGoodCaloMuon(const reco::CaloMuon &muon)
Definition: MuonIdProducer.cc:764
edm::Event
Definition: Event.h:73
reco::MuonSegmentMatch::x
float x
Definition: MuonSegmentMatch.h:34
MuonIdProducer::minPCaloMuon_
double minPCaloMuon_
Definition: MuonIdProducer.h:201
edm::ConfigurationDescriptions::addDefault
void addDefault(ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:99
AlgebraicSymMatrix55
ROOT::Math::SMatrix< double, 5, 5, ROOT::Math::MatRepSym< double, 5 > > AlgebraicSymMatrix55
Definition: AlgebraicROOTObjects.h:23
plotscripts.stationIndex
def stationIndex(name)
Definition: plotscripts.py:355
MuonIdProducer::parameters_
TrackAssociatorParameters parameters_
Definition: MuonIdProducer.h:145
edm::AssociationMap::const_iterator
const iterator
Definition: AssociationMap.h:76
reco::Muon::ME0Muon
static const unsigned int ME0Muon
Definition: Muon.h:292
reco::MuonEnergy::em
float em
Definition: MuonEnergy.h:26
LocalError::yy
float yy() const
Definition: LocalError.h:24
reco::HcalMuonRecHit
Definition: MuonEnergy.h:9
MuonIdProducer::maxAbsEta_
double maxAbsEta_
Definition: MuonIdProducer.h:203
reco::MuonChamberMatch::segmentMatches
std::vector< reco::MuonSegmentMatch > segmentMatches
Definition: MuonChamberMatch.h:12
edm::InputTag
Definition: InputTag.h:15
MuonIdProducer::isGoodRPCMuon
bool isGoodRPCMuon(const reco::Muon &muon)
Definition: MuonIdProducer.cc:770
MuonIdProducer::fillGlobalTrackRefits_
bool fillGlobalTrackRefits_
Definition: MuonIdProducer.h:263
MuonIdProducer::muIsoExtractorTrack_
std::unique_ptr< reco::isodeposit::IsoDepositExtractor > muIsoExtractorTrack_
Definition: MuonIdProducer.h:254
edm::ConsumesCollector
Definition: ConsumesCollector.h:45
MuonIdProducer::sigmaThresholdToFillCandidateP4WithGlobalFit_
double sigmaThresholdToFillCandidateP4WithGlobalFit_
Definition: MuonIdProducer.h:221
hit
Definition: SiStripHitEffFromCalibTree.cc:88
MuonIdProducer::fillArbitrationInfo
void fillArbitrationInfo(reco::MuonCollection *, unsigned int muonType=reco::Muon::TrackerMuon)
Definition: MuonIdProducer.cc:1053
reco::CaloMuon::setCalEnergy
void setCalEnergy(const MuonEnergy &calEnergy)
set energy deposition information
Definition: CaloMuon.h:37
reco::MuonSegmentMatch::BestInChamberByDR
static const unsigned int BestInChamberByDR
Definition: MuonSegmentMatch.h:17
reco::MuonSegmentMatch::dYdZErr
float dYdZErr
Definition: MuonSegmentMatch.h:41
reco::Muon::standAloneMuon
TrackRef standAloneMuon() const override
reference to a stand-alone muon Track
Definition: Muon.h:49
reco::Muon::ArbitrationType
ArbitrationType
define arbitration schemes
Definition: Muon.h:187
MuonIdProducer::fillGlbQuality
void fillGlbQuality(edm::Event &, const edm::EventSetup &, reco::Muon &aMuon)
Definition: MuonIdProducer.cc:1348
reco::MuonSegmentMatch::t0
float t0
Definition: MuonSegmentMatch.h:48
Generated for CMSSW Reference Manual by doxygen 1.8.16