#include <MuonIdProducer.h>

Inheritance diagram for MuonIdProducer:

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	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () 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 (edm::Event &iEvent, const edm::EventSetup &iSetup, const reco::TrackRef &track, TrackType type)

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

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

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

double	phiOfMuonIneteractionRegion (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_

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	maxAbsPullX_

double	maxAbsPullY_

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_

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

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

Definition at line 68 of file MuonIdProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 35 of file MuonIdProducer.cc.

                                                              {
   LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: Constructor called";
 
   produces<reco::MuonCollection>();
   produces<reco::CaloMuonCollection>();
   produces<reco::MuonTimeExtraMap>("combined");
   produces<reco::MuonTimeExtraMap>("dt");
   produces<reco::MuonTimeExtraMap>("csc");
 
   minPt_ = iConfig.getParameter<double>("minPt");
   minP_ = iConfig.getParameter<double>("minP");
   minPCaloMuon_ = iConfig.getParameter<double>("minPCaloMuon");
   minNumberOfMatches_ = iConfig.getParameter<int>("minNumberOfMatches");
   addExtraSoftMuons_ = iConfig.getParameter<bool>("addExtraSoftMuons");
   maxAbsEta_ = iConfig.getParameter<double>("maxAbsEta");
   maxAbsDx_ = iConfig.getParameter<double>("maxAbsDx");
   maxAbsPullX_ = iConfig.getParameter<double>("maxAbsPullX");
   maxAbsDy_ = iConfig.getParameter<double>("maxAbsDy");
   maxAbsPullY_ = iConfig.getParameter<double>("maxAbsPullY");
   fillCaloCompatibility_ = iConfig.getParameter<bool>("fillCaloCompatibility");
   fillEnergy_ = iConfig.getParameter<bool>("fillEnergy");
   storeCrossedHcalRecHits_ = iConfig.getParameter<bool>("storeCrossedHcalRecHits");
   fillMatching_ = iConfig.getParameter<bool>("fillMatching");
   fillIsolation_ = iConfig.getParameter<bool>("fillIsolation");
   fillShowerDigis_ = iConfig.getParameter<bool>("fillShowerDigis");
   writeIsoDeposits_ = iConfig.getParameter<bool>("writeIsoDeposits");
   fillGlobalTrackQuality_ = iConfig.getParameter<bool>("fillGlobalTrackQuality");
   fillGlobalTrackRefits_ = iConfig.getParameter<bool>("fillGlobalTrackRefits");
   arbitrateTrackerMuons_ = iConfig.getParameter<bool>("arbitrateTrackerMuons");
   //SK: (maybe temporary) run it only if the global is also run
   fillTrackerKink_ = false;
   if (fillGlobalTrackQuality_)
     fillTrackerKink_ = iConfig.getParameter<bool>("fillTrackerKink");
 
   ptThresholdToFillCandidateP4WithGlobalFit_ =
       iConfig.getParameter<double>("ptThresholdToFillCandidateP4WithGlobalFit");
   sigmaThresholdToFillCandidateP4WithGlobalFit_ =
       iConfig.getParameter<double>("sigmaThresholdToFillCandidateP4WithGlobalFit");
   caloCut_ = iConfig.getParameter<double>("minCaloCompatibility");  //CaloMuons
   arbClean_ = iConfig.getParameter<bool>("runArbitrationCleaner");  // muon mesh
 
   // Load TrackDetectorAssociator parameters
   const edm::ParameterSet parameters = iConfig.getParameter<edm::ParameterSet>("TrackAssociatorParameters");
   edm::ConsumesCollector iC = consumesCollector();
   parameters_.loadParameters(parameters, iC);
 
   // Load parameters for the TimingFiller
   edm::ParameterSet timingParameters = iConfig.getParameter<edm::ParameterSet>("TimingFillerParameters");
   theTimingFiller_ = std::make_unique<MuonTimingFiller>(timingParameters, consumesCollector());
 
   // Load parameters for the ShowerDigiFiller
   if (fillShowerDigis_ && fillMatching_) {
     edm::ParameterSet showerDigiParameters = iConfig.getParameter<edm::ParameterSet>("ShowerDigiFillerParameters");
     theShowerDigiFiller_ = std::make_unique<MuonShowerDigiFiller>(showerDigiParameters, consumesCollector());
   }
 
   if (fillCaloCompatibility_) {
     // Load MuonCaloCompatibility parameters
     const auto caloParams = iConfig.getParameter<edm::ParameterSet>("MuonCaloCompatibility");
     muonCaloCompatibility_.configure(caloParams);
   }
 
   if (fillIsolation_) {
     // Load MuIsoExtractor parameters
     edm::ParameterSet caloExtractorPSet = iConfig.getParameter<edm::ParameterSet>("CaloExtractorPSet");
     std::string caloExtractorName = caloExtractorPSet.getParameter<std::string>("ComponentName");
     muIsoExtractorCalo_ =
         IsoDepositExtractorFactory::get()->create(caloExtractorName, caloExtractorPSet, consumesCollector());
 
     edm::ParameterSet trackExtractorPSet = iConfig.getParameter<edm::ParameterSet>("TrackExtractorPSet");
     std::string trackExtractorName = trackExtractorPSet.getParameter<std::string>("ComponentName");
     muIsoExtractorTrack_ =
         IsoDepositExtractorFactory::get()->create(trackExtractorName, trackExtractorPSet, consumesCollector());
 
     edm::ParameterSet jetExtractorPSet = iConfig.getParameter<edm::ParameterSet>("JetExtractorPSet");
     std::string jetExtractorName = jetExtractorPSet.getParameter<std::string>("ComponentName");
     muIsoExtractorJet_ =
         IsoDepositExtractorFactory::get()->create(jetExtractorName, jetExtractorPSet, consumesCollector());
   }
   if (fillIsolation_ && writeIsoDeposits_) {
     trackDepositName_ = iConfig.getParameter<std::string>("trackDepositName");
     produces<reco::IsoDepositMap>(trackDepositName_);
     ecalDepositName_ = iConfig.getParameter<std::string>("ecalDepositName");
     produces<reco::IsoDepositMap>(ecalDepositName_);
     hcalDepositName_ = iConfig.getParameter<std::string>("hcalDepositName");
     produces<reco::IsoDepositMap>(hcalDepositName_);
     hoDepositName_ = iConfig.getParameter<std::string>("hoDepositName");
     produces<reco::IsoDepositMap>(hoDepositName_);
     jetDepositName_ = iConfig.getParameter<std::string>("jetDepositName");
     produces<reco::IsoDepositMap>(jetDepositName_);
   }
 
   inputCollectionLabels_ = iConfig.getParameter<std::vector<edm::InputTag> >("inputCollectionLabels");
   const auto inputCollectionTypes = iConfig.getParameter<std::vector<std::string> >("inputCollectionTypes");
   if (inputCollectionLabels_.size() != inputCollectionTypes.size())
     throw cms::Exception("ConfigurationError")
         << "Number of input collection labels is different from number of types. "
         << "For each collection label there should be exactly one collection type specified.";
   if (inputCollectionLabels_.size() > 7 || inputCollectionLabels_.empty())
     throw cms::Exception("ConfigurationError") << "Number of input collections should be from 1 to 7.";
 
   debugWithTruthMatching_ = iConfig.getParameter<bool>("debugWithTruthMatching");
   if (debugWithTruthMatching_)
     edm::LogWarning("MuonIdentification")
         << "========================================================================\n"
         << "Debugging mode with truth matching is turned on!!! Make sure you understand what you are doing!\n"
         << "========================================================================\n";
   if (fillGlobalTrackQuality_) {
     const auto& glbQualTag = iConfig.getParameter<edm::InputTag>("globalTrackQualityInputTag");
     glbQualToken_ = consumes<edm::ValueMap<reco::MuonQuality> >(glbQualTag);
   }
 
   if (fillTrackerKink_) {
     trackerKinkFinder_ =
         std::make_unique<MuonKinkFinder>(iConfig.getParameter<edm::ParameterSet>("TrackerKinkFinderParameters"));
   }
 
   //create mesh holder
   meshAlgo_ = std::make_unique<MuonMesh>(iConfig.getParameter<edm::ParameterSet>("arbitrationCleanerOptions"));
 
   edm::InputTag rpcHitTag("rpcRecHits");
   rpcHitToken_ = consumes<RPCRecHitCollection>(rpcHitTag);
 
   //Consumes... UGH
   inputCollectionTypes_.resize(inputCollectionLabels_.size());
   for (unsigned int i = 0; i < inputCollectionLabels_.size(); ++i) {
     const auto inputLabel = inputCollectionLabels_[i];
     const auto inputType = ICTypes::toKey(inputCollectionTypes[i]);  // Note: thorws exception if type is undefined.
 
     if (inputType == ICTypes::INNER_TRACKS) {
       innerTrackCollectionToken_ = consumes<reco::TrackCollection>(inputLabel);
     } else if (inputType == ICTypes::OUTER_TRACKS) {
       outerTrackCollectionToken_ = consumes<reco::TrackCollection>(inputLabel);
     } else if (inputType == ICTypes::LINKS) {
       linkCollectionToken_ = consumes<reco::MuonTrackLinksCollection>(inputLabel);
     } else if (inputType == ICTypes::MUONS) {
       muonCollectionToken_ = consumes<reco::MuonCollection>(inputLabel);
     } else if (inputType == ICTypes::TEV_FIRSTHIT) {
       tpfmsCollectionToken_ = consumes<reco::TrackToTrackMap>(inputLabel);
     } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_PICKY) {
       pickyCollectionToken_ = consumes<reco::TrackToTrackMap>(inputLabel);
     } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_DYT) {
       dytCollectionToken_ = consumes<reco::TrackToTrackMap>(inputCollectionLabels_.at(i));
     }
 
     inputCollectionTypes_[i] = inputType;
   }
 }

MuonIdProducer::~MuonIdProducer ( )

override

Definition at line 184 of file MuonIdProducer.cc.

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

Member Function Documentation

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

inlineprivate

Definition at line 128 of file MuonIdProducer.h.

References funct::abs().

Referenced by fillArbitrationInfo().

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

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

private

Definition at line 1020 of file MuonIdProducer.cc.

References isGoodCaloMuon(), makeCaloMuon(), minNumberOfMatches_, reco::Muon::PFMuon, reco::Muon::SegmentAndTrackArbitration, and reco::Muon::TrackerMuon.

Referenced by produce().

                                                                                                 {
   reco::Muon::ArbitrationType arbitration = reco::Muon::SegmentAndTrackArbitration;
   // arbitrate TrackerMuons
   // if a muon was exclusively TrackerMuon check if it can be a calo muon
   for (reco::MuonCollection::iterator muon = muons->begin(); muon != muons->end();) {
     if (muon->isTrackerMuon()) {
       if (muon->numberOfMatches(arbitration) < minNumberOfMatches_) {
         // TrackerMuon failed arbitration
         // If not any other base type - erase the element
         // (PFMuon is not a base type)
         unsigned int mask = reco::Muon::TrackerMuon | reco::Muon::PFMuon;
         if ((muon->type() & (~mask)) == 0) {
           const reco::CaloMuon& caloMuon = makeCaloMuon(*muon);
           if (isGoodCaloMuon(caloMuon))
             caloMuons->push_back(caloMuon);
           muon = muons->erase(muon);
           continue;
         } else {
           muon->setType(muon->type() & (~reco::Muon::TrackerMuon));
         }
       }
     }
     muon++;
   }
 }

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

override

Definition at line 413 of file MuonIdProducer.cc.

References fillMatching_, fillShowerDigis_, edm::EventSetup::get(), meshAlgo_, edm::ESHandle< T >::product(), and theShowerDigiFiller_.

                                                                              {
   edm::ESHandle<CSCGeometry> geomHandle;
   iSetup.get<MuonGeometryRecord>().get(geomHandle);
 
   meshAlgo_->setCSCGeometry(geomHandle.product());
 
   if (fillShowerDigis_ && fillMatching_)
     theShowerDigiFiller_->getES(iSetup);
 }

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

private

Definition at line 370 of file MuonIdProducer.cc.

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

Referenced by overlap().

                                                       {
   if (id.det() != DetId::Muon)
     return 0;
 
   const auto subdetId = id.subdetId();
   if (subdetId == MuonSubdetId::DT) {
     return DTChamberId(id.rawId()).rawId();
   } else if (subdetId == MuonSubdetId::CSC) {
     return CSCDetId(id.rawId()).chamberId().rawId();
   }
 
   return 0;
 }

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

private

Definition at line 1362 of file MuonIdProducer.cc.

References reco::MuonTrackLinks::globalTrack(), edm::Ref< C, T, F >::isNull(), reco::MuonTrackLinks::standAloneTrack(), and reco::MuonTrackLinks::trackerTrack().

Referenced by produce().

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

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

private

Definition at line 1046 of file MuonIdProducer.cc.

Referenced by produce().

                                                                                                 {
   //
   // apply segment flags
   //
   std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> > chamberPairs;  // for chamber segment sorting
   std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> > stationPairs;  // for station segment sorting
   std::vector<std::pair<reco::MuonChamberMatch*, reco::MuonSegmentMatch*> >
       arbitrationPairs;  // for muon segment arbitration
 
   // muonIndex1
   for (unsigned int muonIndex1 = 0; muonIndex1 < pOutputMuons->size(); ++muonIndex1) {
     auto& muon1 = pOutputMuons->at(muonIndex1);
     // chamberIter1
     for (auto& chamber1 : muon1.matches()) {
       // segmentIter1
       std::vector<reco::MuonSegmentMatch>* segmentMatches1 = getSegmentMatches(chamber1, muonType);
 
       if (segmentMatches1->empty())
         continue;
       chamberPairs.clear();
 
       for (auto& segment1 : *segmentMatches1) {
         chamberPairs.push_back(std::make_pair(&chamber1, &segment1));
         if (!segment1.isMask())  // has not yet been arbitrated
         {
           arbitrationPairs.clear();
           arbitrationPairs.push_back(std::make_pair(&chamber1, &segment1));
 
           // find identical segments with which to arbitrate
           // tracker muons only
           if (muon1.type() & muonType) {
             // muonIndex2
             for (unsigned int muonIndex2 = muonIndex1 + 1; muonIndex2 < pOutputMuons->size(); ++muonIndex2) {
               auto& muon2 = pOutputMuons->at(muonIndex2);
               // tracker muons only
               if (!(muon2.type() & muonType))
                 continue;
               // chamberIter2
               for (auto& chamber2 : muon2.matches()) {
                 // segmentIter2
                 std::vector<reco::MuonSegmentMatch>* segmentMatches2 = getSegmentMatches(chamber2, muonType);
                 for (auto& segment2 : *segmentMatches2) {
                   if (segment2.isMask())
                     continue;  // has already been arbitrated
                   if (approxEqual(segment2.x, segment1.x) && approxEqual(segment2.y, segment1.y) &&
                       approxEqual(segment2.dXdZ, segment1.dXdZ) && approxEqual(segment2.dYdZ, segment1.dYdZ) &&
                       approxEqual(segment2.xErr, segment1.xErr) && approxEqual(segment2.yErr, segment1.yErr) &&
                       approxEqual(segment2.dXdZErr, segment1.dXdZErr) &&
                       approxEqual(segment2.dYdZErr, segment1.dYdZErr)) {
                     arbitrationPairs.push_back(std::make_pair(&chamber2, &segment2));
                   }
                 }  // segmentIter2
               }    // chamberIter2
             }      // muonIndex2
           }
 
           // arbitration segment sort
           if (arbitrationPairs.empty())
             continue;  // this should never happen
           if (arbitrationPairs.size() == 1) {
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDRSlope);
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDXSlope);
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDR);
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDX);
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::Arbitrated);
           } else {
             sort(arbitrationPairs.begin(),
                  arbitrationPairs.end(),
                  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDRSlope));
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDRSlope);
             sort(arbitrationPairs.begin(),
                  arbitrationPairs.end(),
                  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDXSlope));
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDXSlope);
             sort(arbitrationPairs.begin(),
                  arbitrationPairs.end(),
                  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDR));
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDR);
             sort(arbitrationPairs.begin(),
                  arbitrationPairs.end(),
                  SortMuonSegmentMatches(reco::MuonSegmentMatch::BelongsToTrackByDX));
             arbitrationPairs.front().second->setMask(reco::MuonSegmentMatch::BelongsToTrackByDX);
             for (auto& ap : arbitrationPairs) {
               ap.second->setMask(reco::MuonSegmentMatch::Arbitrated);
             }
           }
         }
 
         // setup me1a cleaning for later
         if (muonType == reco::Muon::TrackerMuon && chamber1.id.subdetId() == MuonSubdetId::CSC && arbClean_ &&
             CSCDetId(chamber1.id).ring() == 4) {
           for (auto& segment2 : chamber1.segmentMatches) {
             if (segment1.cscSegmentRef.isNull() || segment2.cscSegmentRef.isNull())
               continue;
             if (meshAlgo_->isDuplicateOf(segment1.cscSegmentRef, segment2.cscSegmentRef) &&
                 (segment2.mask & 0x1e0000) && (segment1.mask & 0x1e0000)) {
               segment2.setMask(reco::MuonSegmentMatch::BelongsToTrackByME1aClean);
               //if the track has lost the segment already through normal arbitration no need to do it again.
             }
           }
         }  // mark all ME1/a duplicates that this track owns
 
       }  // segmentIter1
 
       // chamber segment sort
       if (chamberPairs.empty())
         continue;  // this should never happen
       if (chamberPairs.size() == 1) {
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDRSlope);
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDXSlope);
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDR);
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDX);
       } else {
         sort(chamberPairs.begin(),
              chamberPairs.end(),
              SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDRSlope));
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDRSlope);
         sort(chamberPairs.begin(),
              chamberPairs.end(),
              SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDXSlope));
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDXSlope);
         sort(chamberPairs.begin(),
              chamberPairs.end(),
              SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDR));
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDR);
         sort(chamberPairs.begin(),
              chamberPairs.end(),
              SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInChamberByDX));
         chamberPairs.front().second->setMask(reco::MuonSegmentMatch::BestInChamberByDX);
       }
     }  // chamberIter1
 
     // station segment sort
     for (int stationIndex = 1; stationIndex < 5; ++stationIndex) {
       for (int detectorIndex = 1; detectorIndex <= 5;
            ++detectorIndex)  // 1-5, as in DataFormats/MuonDetId/interface/MuonSubdetId.h
       {
         stationPairs.clear();
 
         // chamberIter
         for (auto& chamber : muon1.matches()) {
           if (!(chamber.station() == stationIndex && chamber.detector() == detectorIndex))
             continue;
           std::vector<reco::MuonSegmentMatch>* segmentMatches = getSegmentMatches(chamber, muonType);
           if (segmentMatches->empty())
             continue;
 
           for (auto& segment : *segmentMatches) {
             stationPairs.push_back(std::make_pair(&chamber, &segment));
           }
         }  // chamberIter
 
         if (stationPairs.empty())
           continue;  // this may very well happen
         if (stationPairs.size() == 1) {
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDRSlope);
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDXSlope);
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDR);
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDX);
         } else {
           sort(stationPairs.begin(),
                stationPairs.end(),
                SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDRSlope));
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDRSlope);
           sort(stationPairs.begin(),
                stationPairs.end(),
                SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDXSlope));
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDXSlope);
           sort(stationPairs.begin(),
                stationPairs.end(),
                SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDR));
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDR);
           sort(stationPairs.begin(),
                stationPairs.end(),
                SortMuonSegmentMatches(reco::MuonSegmentMatch::BestInStationByDX));
           stationPairs.front().second->setMask(reco::MuonSegmentMatch::BestInStationByDX);
         }
       }
     }
 
   }  // muonIndex1
 
   if (arbClean_) {
     // clear old mesh, create and prune new mesh!
     meshAlgo_->clearMesh();
     meshAlgo_->runMesh(pOutputMuons);
   }
 }

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

static

Definition at line 1375 of file MuonIdProducer.cc.

References edm::ParameterSetDescription::add(), edm::ConfigurationDescriptions::addDefault(), HLT_2018_cff::InputTag, and edm::ParameterSetDescription::setAllowAnything().

                                                                                 {
   edm::ParameterSetDescription desc;
   desc.setAllowAnything();
 
   desc.add<bool>("arbitrateTrackerMuons", false);
   desc.add<bool>("storeCrossedHcalRecHits", false);
   desc.add<bool>("fillShowerDigis", false);
 
   edm::ParameterSetDescription descTrkAsoPar;
   descTrkAsoPar.add<edm::InputTag>("GEMSegmentCollectionLabel", edm::InputTag("gemSegments"));
   descTrkAsoPar.add<edm::InputTag>("ME0SegmentCollectionLabel", edm::InputTag("me0Segments"));
   descTrkAsoPar.add<bool>("useGEM", false);
   descTrkAsoPar.add<bool>("useME0", false);
   descTrkAsoPar.setAllowAnything();
   desc.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
 
   edm::ParameterSetDescription descJet;
   descJet.setAllowAnything();
   descJet.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
   desc.add<edm::ParameterSetDescription>("JetExtractorPSet", descJet);
 
   edm::ParameterSetDescription descCalo;
   descCalo.setAllowAnything();
   descCalo.add<edm::ParameterSetDescription>("TrackAssociatorParameters", descTrkAsoPar);
   desc.add<edm::ParameterSetDescription>("CaloExtractorPSet", descCalo);
 
   descriptions.addDefault(desc);
 }

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

private

Definition at line 1341 of file MuonIdProducer.cc.

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().

                                                                                                   {
   if (aMuon.isGlobalMuon() && glbQualHandle_.isValid() && !glbQualHandle_.failedToGet()) {
     aMuon.setCombinedQuality((*glbQualHandle_)[aMuon.combinedMuon()]);
   }
 
   LogDebug("MuonIdentification") << "tkChiVal " << aMuon.combinedQuality().trkRelChi2;
 }

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

private

Definition at line 793 of file MuonIdProducer.cc.

Referenced by produce().

                                                                             {
   LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId";
 
   // perform track - detector association
   const reco::Track* track = nullptr;
   if (aMuon.track().isNonnull())
     track = aMuon.track().get();
   else if (aMuon.standAloneMuon().isNonnull())
     track = aMuon.standAloneMuon().get();
   else
     throw cms::Exception("FatalError")
         << "Failed to fill muon id information for a muon with undefined references to tracks";
 
   TrackDetMatchInfo info = trackAssociator_.associate(iEvent, iSetup, *track, parameters_, direction);
 
   LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fillEnergy = " << fillEnergy_;
 
   if (fillEnergy_) {
     reco::MuonEnergy muonEnergy;
     muonEnergy.em = info.crossedEnergy(TrackDetMatchInfo::EcalRecHits);
     muonEnergy.had = info.crossedEnergy(TrackDetMatchInfo::HcalRecHits);
     muonEnergy.ho = info.crossedEnergy(TrackDetMatchInfo::HORecHits);
     muonEnergy.tower = info.crossedEnergy(TrackDetMatchInfo::TowerTotal);
     muonEnergy.emS9 = info.nXnEnergy(TrackDetMatchInfo::EcalRecHits, 1);    // 3x3 energy
     muonEnergy.emS25 = info.nXnEnergy(TrackDetMatchInfo::EcalRecHits, 2);   // 5x5 energy
     muonEnergy.hadS9 = info.nXnEnergy(TrackDetMatchInfo::HcalRecHits, 1);   // 3x3 energy
     muonEnergy.hoS9 = info.nXnEnergy(TrackDetMatchInfo::HORecHits, 1);      // 3x3 energy
     muonEnergy.towerS9 = info.nXnEnergy(TrackDetMatchInfo::TowerTotal, 1);  // 3x3 energy
     if (storeCrossedHcalRecHits_) {
       muonEnergy.crossedHadRecHits.clear();
       for (auto hit : info.crossedHcalRecHits) {
         reco::HcalMuonRecHit mhit;
         mhit.energy = hit->energy();
         mhit.chi2 = hit->chi2();
         mhit.time = hit->time();
         mhit.detId = hit->id();
         muonEnergy.crossedHadRecHits.push_back(mhit);
       }
     }
     muonEnergy.ecal_position = info.trkGlobPosAtEcal;
     muonEnergy.hcal_position = info.trkGlobPosAtHcal;
     if (!info.crossedEcalIds.empty())
       muonEnergy.ecal_id = info.crossedEcalIds.front();
     if (!info.crossedHcalIds.empty())
       muonEnergy.hcal_id = info.crossedHcalIds.front();
     // find maximal energy depositions and their time
     DetId emMaxId = info.findMaxDeposition(TrackDetMatchInfo::EcalRecHits, 2);  // max energy deposit in 5x5 shape
     for (const auto& hit : info.ecalRecHits) {
       if (hit->id() != emMaxId)
         continue;
       muonEnergy.emMax = hit->energy();
       muonEnergy.ecal_time = hit->time();
     }
     DetId hadMaxId = info.findMaxDeposition(TrackDetMatchInfo::HcalRecHits, 1);  // max energy deposit in 3x3 shape
     for (const auto& hit : info.hcalRecHits) {
       if (hit->id() != hadMaxId)
         continue;
       muonEnergy.hadMax = hit->energy();
       muonEnergy.hcal_time = hit->time();
     }
     aMuon.setCalEnergy(muonEnergy);
   }
   if (!fillMatching_ && !aMuon.isTrackerMuon() && !aMuon.isRPCMuon())
     return;
 
   // fill muon match info
   LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fill muon match info ";
   std::vector<reco::MuonChamberMatch> muonChamberMatches;
   unsigned int nubmerOfMatchesAccordingToTrackAssociator = 0;
   for (const auto& chamber : info.chambers) {
     if (chamber.id.subdetId() == 3 && rpcHitHandle_.isValid())
       continue;  // Skip RPC chambers, they are taken care of below)
     reco::MuonChamberMatch matchedChamber;
 
     const auto& lErr = chamber.tState.localError();
     const auto& lPos = chamber.tState.localPosition();
     const auto& lDir = chamber.tState.localDirection();
 
     const auto& localError = lErr.positionError();
     matchedChamber.x = lPos.x();
     matchedChamber.y = lPos.y();
     matchedChamber.xErr = sqrt(localError.xx());
     matchedChamber.yErr = sqrt(localError.yy());
 
     matchedChamber.dXdZ = lDir.z() != 0 ? lDir.x() / lDir.z() : 9999;
     matchedChamber.dYdZ = lDir.z() != 0 ? lDir.y() / lDir.z() : 9999;
     // DANGEROUS - compiler cannot guaranty parameters ordering
     AlgebraicSymMatrix55 trajectoryCovMatrix = lErr.matrix();
     matchedChamber.dXdZErr = trajectoryCovMatrix(1, 1) > 0 ? sqrt(trajectoryCovMatrix(1, 1)) : 0;
     matchedChamber.dYdZErr = trajectoryCovMatrix(2, 2) > 0 ? sqrt(trajectoryCovMatrix(2, 2)) : 0;
 
     matchedChamber.edgeX = chamber.localDistanceX;
     matchedChamber.edgeY = chamber.localDistanceY;
 
     matchedChamber.id = chamber.id;
 
     if (fillShowerDigis_) {
       theShowerDigiFiller_->fill(matchedChamber);
     } else {
       theShowerDigiFiller_->fillDefault(matchedChamber);
     }
 
     if (!chamber.segments.empty())
       ++nubmerOfMatchesAccordingToTrackAssociator;
 
     // fill segments
     for (const auto& segment : chamber.segments) {
       reco::MuonSegmentMatch matchedSegment;
       matchedSegment.x = segment.segmentLocalPosition.x();
       matchedSegment.y = segment.segmentLocalPosition.y();
       matchedSegment.dXdZ =
           segment.segmentLocalDirection.z() ? segment.segmentLocalDirection.x() / segment.segmentLocalDirection.z() : 0;
       matchedSegment.dYdZ =
           segment.segmentLocalDirection.z() ? segment.segmentLocalDirection.y() / segment.segmentLocalDirection.z() : 0;
       matchedSegment.xErr = segment.segmentLocalErrorXX > 0 ? sqrt(segment.segmentLocalErrorXX) : 0;
       matchedSegment.yErr = segment.segmentLocalErrorYY > 0 ? sqrt(segment.segmentLocalErrorYY) : 0;
       matchedSegment.dXdZErr = segment.segmentLocalErrorDxDz > 0 ? sqrt(segment.segmentLocalErrorDxDz) : 0;
       matchedSegment.dYdZErr = segment.segmentLocalErrorDyDz > 0 ? sqrt(segment.segmentLocalErrorDyDz) : 0;
       matchedSegment.t0 = segment.t0;
       matchedSegment.mask = 0;
       matchedSegment.dtSegmentRef = segment.dtSegmentRef;
       matchedSegment.cscSegmentRef = segment.cscSegmentRef;
       matchedSegment.gemSegmentRef = segment.gemSegmentRef;
       matchedSegment.me0SegmentRef = segment.me0SegmentRef;
       matchedSegment.hasZed_ = segment.hasZed;
       matchedSegment.hasPhi_ = segment.hasPhi;
       // test segment
       bool matchedX = false;
       bool matchedY = false;
       LogTrace("MuonIdentification") << " matching local x, segment x: " << matchedSegment.x
                                      << ", chamber x: " << matchedChamber.x << ", max: " << maxAbsDx_;
       LogTrace("MuonIdentification") << " matching local y, segment y: " << matchedSegment.y
                                      << ", chamber y: " << matchedChamber.y << ", max: " << maxAbsDy_;
       const double matchedSegChDx = std::abs(matchedSegment.x - matchedChamber.x);
       const double matchedSegChDy = std::abs(matchedSegment.y - matchedChamber.y);
       const double matchedSegChPullX = matchedSegChDx / std::hypot(matchedSegment.xErr, matchedChamber.xErr);
       const double matchedSegChPullY = matchedSegChDy / std::hypot(matchedSegment.yErr, matchedChamber.yErr);
       if (matchedSegment.xErr > 0 && matchedChamber.xErr > 0)
         LogTrace("MuonIdentification") << " xpull: " << matchedSegChPullX;
       if (matchedSegment.yErr > 0 && matchedChamber.yErr > 0)
         LogTrace("MuonIdentification") << " ypull: " << matchedSegChPullY;
 
       if (matchedSegChDx < maxAbsDx_)
         matchedX = true;
       if (matchedSegChDy < maxAbsDy_)
         matchedY = true;
       if (matchedSegment.xErr > 0 && matchedChamber.xErr > 0 && matchedSegChPullX < maxAbsPullX_)
         matchedX = true;
       if (matchedSegment.yErr > 0 && matchedChamber.yErr > 0 && matchedSegChPullY < maxAbsPullY_)
         matchedY = true;
       if (matchedX && matchedY) {
         if (matchedChamber.id.subdetId() == MuonSubdetId::ME0)
           matchedChamber.me0Matches.push_back(matchedSegment);
         else if (matchedChamber.id.subdetId() == MuonSubdetId::GEM)
           matchedChamber.gemMatches.push_back(matchedSegment);
         else
           matchedChamber.segmentMatches.push_back(matchedSegment);
       }
     }
     muonChamberMatches.push_back(matchedChamber);
   }
 
   // Fill RPC info
   LogTrace("MuonIdentification") << "RecoMuon/MuonIdProducer :: fillMuonId :: fill RPC info";
   if (rpcHitHandle_.isValid()) {
     for (const auto& chamber : info.chambers) {
       if (chamber.id.subdetId() != 3)
         continue;  // Consider RPC chambers only
       const auto& lErr = chamber.tState.localError();
       const auto& lPos = chamber.tState.localPosition();
       const auto& lDir = chamber.tState.localDirection();
 
       reco::MuonChamberMatch matchedChamber;
 
       LocalError localError = lErr.positionError();
       matchedChamber.x = lPos.x();
       matchedChamber.y = lPos.y();
       matchedChamber.xErr = sqrt(localError.xx());
       matchedChamber.yErr = sqrt(localError.yy());
 
       matchedChamber.dXdZ = lDir.z() != 0 ? lDir.x() / lDir.z() : 9999;
       matchedChamber.dYdZ = lDir.z() != 0 ? lDir.y() / lDir.z() : 9999;
       // DANGEROUS - compiler cannot guaranty parameters ordering
       AlgebraicSymMatrix55 trajectoryCovMatrix = lErr.matrix();
       matchedChamber.dXdZErr = trajectoryCovMatrix(1, 1) > 0 ? sqrt(trajectoryCovMatrix(1, 1)) : 0;
       matchedChamber.dYdZErr = trajectoryCovMatrix(2, 2) > 0 ? sqrt(trajectoryCovMatrix(2, 2)) : 0;
 
       matchedChamber.edgeX = chamber.localDistanceX;
       matchedChamber.edgeY = chamber.localDistanceY;
 
       theShowerDigiFiller_->fillDefault(matchedChamber);
 
       matchedChamber.id = chamber.id;
 
       for (const auto& rpcRecHit : *rpcHitHandle_) {
         reco::MuonRPCHitMatch rpcHitMatch;
 
         if (rpcRecHit.rawId() != chamber.id.rawId())
           continue;
 
         rpcHitMatch.x = rpcRecHit.localPosition().x();
         rpcHitMatch.mask = 0;
         rpcHitMatch.bx = rpcRecHit.BunchX();
 
         const double absDx = std::abs(rpcRecHit.localPosition().x() - chamber.tState.localPosition().x());
         if (absDx <= 20 or absDx / sqrt(localError.xx()) <= 4)
           matchedChamber.rpcMatches.push_back(rpcHitMatch);
       }
 
       muonChamberMatches.push_back(matchedChamber);
     }
   }
 
   aMuon.setMatches(muonChamberMatches);
 
   LogTrace("MuonIdentification") << "number of muon chambers: " << aMuon.matches().size() << "\n"
                                  << "number of chambers with segments according to the associator requirements: "
                                  << nubmerOfMatchesAccordingToTrackAssociator;
   LogTrace("MuonIdentification") << "number of segment matches with the producer requirements: "
                                  << aMuon.numberOfMatches(reco::Muon::NoArbitration);
 
   // fillTime( iEvent, iSetup, aMuon );
 }

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 1235 of file MuonIdProducer.cc.

Referenced by produce().

                                                                {
   const reco::Track* track = nullptr;
   if (aMuon.track().isNonnull())
     track = aMuon.track().get();
   else if (aMuon.standAloneMuon().isNonnull())
     track = aMuon.standAloneMuon().get();
   else
     throw cms::Exception("FatalError")
         << "Failed to compute muon isolation information for a muon with undefined references to tracks";
 
   reco::MuonIsolation isoR03, isoR05;
 
   // get deposits
   reco::IsoDeposit depTrk = muIsoExtractorTrack_->deposit(iEvent, iSetup, *track);
   std::vector<reco::IsoDeposit> caloDeps = muIsoExtractorCalo_->deposits(iEvent, iSetup, *track);
   reco::IsoDeposit depJet = muIsoExtractorJet_->deposit(iEvent, iSetup, *track);
 
   if (caloDeps.size() != 3) {
     LogTrace("MuonIdentification") << "Failed to fill vector of calorimeter isolation deposits!";
     return;
   }
 
   reco::IsoDeposit depEcal = caloDeps.at(0);
   reco::IsoDeposit depHcal = caloDeps.at(1);
   reco::IsoDeposit depHo = caloDeps.at(2);
 
   //no need to copy outside if we don't write them
   if (writeIsoDeposits_) {
     trackDep = depTrk;
     ecalDep = depEcal;
     hcalDep = depHcal;
     hoDep = depHo;
     jetDep = depJet;
   }
 
   isoR03.sumPt = depTrk.depositWithin(0.3);
   isoR03.emEt = depEcal.depositWithin(0.3);
   isoR03.hadEt = depHcal.depositWithin(0.3);
   isoR03.hoEt = depHo.depositWithin(0.3);
   isoR03.nTracks = depTrk.depositAndCountWithin(0.3).second;
   isoR03.nJets = depJet.depositAndCountWithin(0.3).second;
   isoR03.trackerVetoPt = depTrk.candEnergy();
   isoR03.emVetoEt = depEcal.candEnergy();
   isoR03.hadVetoEt = depHcal.candEnergy();
   isoR03.hoVetoEt = depHo.candEnergy();
 
   isoR05.sumPt = depTrk.depositWithin(0.5);
   isoR05.emEt = depEcal.depositWithin(0.5);
   isoR05.hadEt = depHcal.depositWithin(0.5);
   isoR05.hoEt = depHo.depositWithin(0.5);
   isoR05.nTracks = depTrk.depositAndCountWithin(0.5).second;
   isoR05.nJets = depJet.depositAndCountWithin(0.5).second;
   isoR05.trackerVetoPt = depTrk.candEnergy();
   isoR05.emVetoEt = depEcal.candEnergy();
   isoR05.hadVetoEt = depHcal.candEnergy();
   isoR05.hoVetoEt = depHo.candEnergy();
 
   aMuon.setIsolation(isoR03, isoR05);
 }

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

private

Definition at line 1349 of file MuonIdProducer.cc.

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().

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

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.

References Exception, reco::MuonChamberMatch::gemMatches, reco::Muon::GEMMuon, reco::MuonChamberMatch::me0Matches, reco::Muon::ME0Muon, reco::MuonChamberMatch::segmentMatches, and reco::Muon::TrackerMuon.

Referenced by fillArbitrationInfo().

                                                                                                                  {
     if (muonType == reco::Muon::TrackerMuon)
       return &chamber.segmentMatches;
     else if (muonType == reco::Muon::ME0Muon)
       return &chamber.me0Matches;
     else if (muonType == reco::Muon::GEMMuon)
       return &chamber.gemMatches;
     else
       throw cms::Exception("getSegmentMatches called with unsupported muonType");
   }

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

private

Definition at line 188 of file MuonIdProducer.cc.

Referenced by produce().

                                                                        {
   innerTrackCollectionHandle_.clear();
   outerTrackCollectionHandle_.clear();
   linkCollectionHandle_.clear();
   muonCollectionHandle_.clear();
 
   tpfmsCollectionHandle_.clear();
   pickyCollectionHandle_.clear();
   dytCollectionHandle_.clear();
 
   edm::ESHandle<Propagator> propagator;
   iSetup.get<TrackingComponentsRecord>().get("SteppingHelixPropagatorAny", propagator);
   trackAssociator_.setPropagator(propagator.product());
 
   if (fillTrackerKink_)
     trackerKinkFinder_->init(iSetup);
 
   for (unsigned int i = 0; i < inputCollectionLabels_.size(); ++i) {
     const auto& inputLabel = inputCollectionLabels_[i];
     const auto inputType = inputCollectionTypes_[i];
     if (inputType == ICTypes::INNER_TRACKS) {
       iEvent.getByToken(innerTrackCollectionToken_, innerTrackCollectionHandle_);
       if (!innerTrackCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input track collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input inner tracks: " << innerTrackCollectionHandle_->size();
     } else if (inputType == ICTypes::OUTER_TRACKS) {
       iEvent.getByToken(outerTrackCollectionToken_, outerTrackCollectionHandle_);
       if (!outerTrackCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input track collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input outer tracks: " << outerTrackCollectionHandle_->size();
     } else if (inputType == ICTypes::LINKS) {
       iEvent.getByToken(linkCollectionToken_, linkCollectionHandle_);
       if (!linkCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input link collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input links: " << linkCollectionHandle_->size();
     } else if (inputType == ICTypes::MUONS) {
       iEvent.getByToken(muonCollectionToken_, muonCollectionHandle_);
       if (!muonCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input muons: " << muonCollectionHandle_->size();
     } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_FIRSTHIT) {
       iEvent.getByToken(tpfmsCollectionToken_, tpfmsCollectionHandle_);
       if (!tpfmsCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input muons: " << tpfmsCollectionHandle_->size();
     } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_PICKY) {
       iEvent.getByToken(pickyCollectionToken_, pickyCollectionHandle_);
       if (!pickyCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input muons: " << pickyCollectionHandle_->size();
     } else if (fillGlobalTrackRefits_ && inputType == ICTypes::TEV_DYT) {
       iEvent.getByToken(dytCollectionToken_, dytCollectionHandle_);
       if (!dytCollectionHandle_.isValid())
         throw cms::Exception("FatalError") << "Failed to get input muon collection with label: " << inputLabel;
       LogTrace("MuonIdentification") << "Number of input muons: " << dytCollectionHandle_->size();
     } else
       throw cms::Exception("FatalError") << "Unknown input collection type: #" << ICTypes::toStr(inputType);
   }
 
   iEvent.getByToken(rpcHitToken_, rpcHitHandle_);
   if (fillGlobalTrackQuality_)
     iEvent.getByToken(glbQualToken_, glbQualHandle_);
 }

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

private

Definition at line 765 of file MuonIdProducer.cc.

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

Referenced by arbitrateMuons(), and produce().

                                                                 {
   if (!caloMuon.isCaloCompatibilityValid() || caloMuon.caloCompatibility() < caloCut_ || caloMuon.p() < minPCaloMuon_)
     return false;
   return true;
 }

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

private

Definition at line 780 of file MuonIdProducer.cc.

References reco::Muon::GEMSegmentAndTrackArbitration, minP_, minPt_, reco::Muon::numberOfMatches(), and reco::Muon::track().

Referenced by produce().

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

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

private

Definition at line 786 of file MuonIdProducer.cc.

References reco::Muon::ME0SegmentAndTrackArbitration, minP_, reco::Muon::numberOfMatches(), and reco::Muon::track().

Referenced by produce().

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

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

private

Definition at line 771 of file MuonIdProducer.cc.

References funct::abs(), addExtraSoftMuons_, reco::LeafCandidate::eta(), minNumberOfMatches_, minP_, minPt_, reco::Muon::numberOfMatchedRPCLayers(), reco::LeafCandidate::pt(), reco::Muon::RPCHitAndTrackArbitration, and reco::Muon::track().

Referenced by produce().

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

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

private

Definition at line 350 of file MuonIdProducer.cc.

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

Referenced by produce().

                                                        {
   // Pt and absolute momentum requirement
   const double p = track.p();
   const double pt = track.pt();
   if (pt < minPt_ || (p < minP_ && p < minPCaloMuon_)) {
     LogTrace("MuonIdentification") << "Skipped low momentum track (Pt,P): " << pt << ", " << track.p() << " GeV";
     return false;
   }
 
   // Eta requirement
   const double eta = track.eta();
   const double absEta = std::abs(eta);
   if (absEta > maxAbsEta_) {
     LogTrace("MuonIdentification") << "Skipped track with large pseudo rapidity (Eta: " << track.eta() << " )";
     return false;
   }
 
   return true;
 }

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

private

Definition at line 756 of file MuonIdProducer.cc.

References funct::abs(), addExtraSoftMuons_, reco::LeafCandidate::eta(), minNumberOfMatches_, minP_, minPt_, reco::Muon::NoArbitration, reco::Muon::numberOfMatches(), reco::LeafCandidate::pt(), and reco::Muon::track().

Referenced by produce().

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

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

private

Definition at line 272 of file MuonIdProducer.cc.

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

Referenced by arbitrateMuons(), and produce().

                                                               {
   LogTrace("MuonIdentification") << "Creating a CaloMuon from a Muon";
 
   reco::CaloMuon aMuon;
   aMuon.setInnerTrack(muon.innerTrack());
 
   if (muon.isEnergyValid())
     aMuon.setCalEnergy(muon.calEnergy());
   // get calo compatibility
   if (fillCaloCompatibility_)
     aMuon.setCaloCompatibility(muonCaloCompatibility_.evaluate(muon));
   return aMuon;
 }

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

private

Definition at line 252 of file MuonIdProducer.cc.

References edm::Ref< C, T, F >::get(), and LogTrace.

Referenced by makeMuon(), and produce().

                                                                   {
   LogTrace("MuonIdentification") << "Creating a muon from a track " << track.get()->pt()
                                  << " Pt (GeV), eta: " << track.get()->eta();
   reco::Muon aMuon(makeMuon(*(track.get())));
 
   LogTrace("MuonIdentification") << "Muon created from a track ";
 
   aMuon.setMuonTrack(type, track);
   aMuon.setBestTrack(type);
   aMuon.setTunePBestTrack(type);
 
   LogTrace("MuonIdentification")
       << "Muon created from a track and setMuonBestTrack, setBestTrack and setTunePBestTrack called";
 
   return aMuon;
 }

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

private

Definition at line 286 of file MuonIdProducer.cc.

References reco::Muon::DYT, dytCollectionHandle_, edm::AssociationMap< Tag >::end(), edm::HandleBase::failedToGet(), fillGlobalTrackRefits_, edm::AssociationMap< Tag >::find(), muon::getTevRefitTrack(), reco::MuonTrackLinks::globalTrack(), edm::Ref< C, T, F >::isNull(), edm::HandleBase::isValid(), LogTrace, makeMuon(), reco::Muon::Picky, pickyCollectionHandle_, ptThresholdToFillCandidateP4WithGlobalFit_, muon::sigmaSwitch(), sigmaThresholdToFillCandidateP4WithGlobalFit_, reco::MuonTrackLinks::standAloneTrack(), muon::tevOptimized(), reco::Muon::TPFMS, tpfmsCollectionHandle_, reco::MuonTrackLinks::trackerTrack(), and edm::helpers::KeyVal< K, V >::val.

                                                                  {
   LogTrace("MuonIdentification") << "Creating a muon from a link to tracks object";
 
   reco::Muon aMuon;
   reco::Muon::MuonTrackTypePair chosenTrack;
   reco::TrackRef tpfmsRef;
   reco::TrackRef pickyRef;
   reco::TrackRef dytRef;
   bool useSigmaSwitch = false;
 
   if (tpfmsCollectionHandle_.isValid() && !tpfmsCollectionHandle_.failedToGet() && pickyCollectionHandle_.isValid() &&
       !pickyCollectionHandle_.failedToGet()) {
     tpfmsRef = muon::getTevRefitTrack(links.globalTrack(), *tpfmsCollectionHandle_);
     pickyRef = muon::getTevRefitTrack(links.globalTrack(), *pickyCollectionHandle_);
     dytRef = muon::getTevRefitTrack(links.globalTrack(), *dytCollectionHandle_);
 
     if (tpfmsRef.isNull() && pickyRef.isNull() && dytRef.isNull()) {
       edm::LogWarning("MakeMuonWithTEV") << "Failed to get  TEV refits, fall back to sigma switch.";
       useSigmaSwitch = true;
     }
   } else {
     useSigmaSwitch = true;
   }
 
   if (useSigmaSwitch) {
     chosenTrack = muon::sigmaSwitch(links.globalTrack(),
                                     links.trackerTrack(),
                                     sigmaThresholdToFillCandidateP4WithGlobalFit_,
                                     ptThresholdToFillCandidateP4WithGlobalFit_);
   } else {
     chosenTrack = muon::tevOptimized(links.globalTrack(),
                                      links.trackerTrack(),
                                      tpfmsRef,
                                      pickyRef,
                                      dytRef,
                                      ptThresholdToFillCandidateP4WithGlobalFit_);
   }
   aMuon = makeMuon(*chosenTrack.first);
   aMuon.setInnerTrack(links.trackerTrack());
   aMuon.setOuterTrack(links.standAloneTrack());
   aMuon.setGlobalTrack(links.globalTrack());
   aMuon.setBestTrack(chosenTrack.second);
   aMuon.setTunePBestTrack(chosenTrack.second);
 
   if (fillGlobalTrackRefits_) {
     if (tpfmsCollectionHandle_.isValid() && !tpfmsCollectionHandle_.failedToGet()) {
       reco::TrackToTrackMap::const_iterator it = tpfmsCollectionHandle_->find(links.globalTrack());
       if (it != tpfmsCollectionHandle_->end())
         aMuon.setMuonTrack(reco::Muon::TPFMS, (it->val));
     }
     if (pickyCollectionHandle_.isValid() && !pickyCollectionHandle_.failedToGet()) {
       reco::TrackToTrackMap::const_iterator it = pickyCollectionHandle_->find(links.globalTrack());
       if (it != pickyCollectionHandle_->end())
         aMuon.setMuonTrack(reco::Muon::Picky, (it->val));
     }
     if (dytCollectionHandle_.isValid() && !dytCollectionHandle_.failedToGet()) {
       reco::TrackToTrackMap::const_iterator it = dytCollectionHandle_->find(links.globalTrack());
       if (it != dytCollectionHandle_->end())
         aMuon.setMuonTrack(reco::Muon::DYT, (it->val));
     }
   }
   return aMuon;
 }

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

private

Definition at line 1302 of file MuonIdProducer.cc.

References reco::TrackBase::charge(), HCALHighEnergyHPDFilter_cfi::energy, dumpRecoGeometry_cfg::Muon, reco::TrackBase::p(), p4, reco::TrackBase::px(), reco::TrackBase::py(), reco::TrackBase::pz(), and reco::TrackBase::vertex().

                                                         {
   const double energy = hypot(track.p(), 0.105658369);
   const math::XYZTLorentzVector p4(track.px(), track.py(), track.pz(), energy);
   return reco::Muon(track.charge(), p4, track.vertex());
 }

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

private

Definition at line 384 of file MuonIdProducer.cc.

References chamberId(), reco::Track::extra(), reco::Muon::isMatchesValid(), edm::Ref< C, T, F >::isNull(), match(), patCandidatesForDimuonsSequences_cff::matches, and reco::Muon::matches().

Referenced by produce().

                                                                         {
   if (!muon.isMatchesValid() || track.extra().isNull() || track.extra()->recHitsSize() == 0)
     return 0;
 
   int numberOfCommonDetIds = 0;
   const std::vector<reco::MuonChamberMatch>& matches(muon.matches());
   for (const auto& match : matches) {
     if (match.segmentMatches.empty())
       continue;
 
     bool foundCommonDetId = false;
     for (auto hit = track.extra()->recHitsBegin(); hit != track.extra()->recHitsEnd(); ++hit) {
       // LogTrace("MuonIdentification") << "hit DetId: " << std::hex << hit->get()->geographicalId().rawId() <<
       //  "\t hit chamber DetId: " << getChamberId(hit->get()->geographicalId()) <<
       //  "\t segment DetId: " << match->id.rawId() << std::dec;
 
       if (chamberId((*hit)->geographicalId()) == match.id.rawId()) {
         foundCommonDetId = true;
         break;
       }
     }
     if (foundCommonDetId) {
       ++numberOfCommonDetIds;
       break;
     }
   }
   return numberOfCommonDetIds;
 }

double MuonIdProducer::phiOfMuonIneteractionRegion ( const reco::Muon & muon ) const

private

Definition at line 1328 of file MuonIdProducer.cc.

References reco::Muon::innerTrack(), edm::Ref< C, T, F >::isAvailable(), reco::Muon::isStandAloneMuon(), reco::Muon::matches(), reco::LeafCandidate::phi(), sectorPhi(), and reco::Muon::standAloneMuon().

Referenced by produce().

                                                                              {
   if (muon.isStandAloneMuon())
     return muon.standAloneMuon()->innerPosition().phi();
   // the rest is tracker muon only
   if (muon.matches().empty()) {
     if (muon.innerTrack().isAvailable() && muon.innerTrack()->extra().isAvailable())
       return muon.innerTrack()->outerPosition().phi();
     else
       return muon.phi();  // makes little sense, but what else can I use
   }
   return sectorPhi(muon.matches().at(0).id);
 }

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

override

Definition at line 435 of file MuonIdProducer.cc.

References TrackDetectorAssociator::Any, arbitrateMuons(), arbitrateTrackerMuons_, reco::Muon::calEnergy(), mergedMuons_cfi::caloMuons, checkLinks(), funct::cos(), TrackDetectorAssociator::crossedIP(), debugWithTruthMatching_, ecalDepositName_, ev, MuonCaloCompatibility::evaluate(), reco::Track::extra(), fillArbitrationInfo(), fillCaloCompatibility_, fillEnergy_, trigObjTnPSource_cfi::filler, fillGlbQuality(), fillGlobalTrackQuality_, fillIsolation_, fillMatching_, fillMuonId(), fillMuonIsolation(), fillShowerDigis_, fillTrackerKink(), fillTrackerKink_, reco::Muon::GEMMuon, edm::Ref< C, T, F >::get(), reco::Muon::GlobalMuon, hcalDepositName_, hoDepositName_, mps_fire::i, init(), reco::Muon::InnerTrack, reco::Muon::innerTrack(), innerTrackCollectionHandle_, TrackDetectorAssociator::InsideOut, edm::Ref< C, T, F >::isAvailable(), reco::Muon::isEnergyValid(), isGoodCaloMuon(), isGoodGEMMuon(), isGoodME0Muon(), isGoodRPCMuon(), isGoodTrack(), isGoodTrackerMuon(), reco::Muon::isTimeValid(), edm::HandleBase::isValid(), dqmiolumiharvest::j, jetDepositName_, linkCollectionHandle_, LogDebug, LogTrace, makeCaloMuon(), makeMuon(), reco::Muon::matches(), reco::Muon::ME0Muon, eostools::move(), muonCaloCompatibility_, muonCollectionHandle_, reco::MuonTime::nDof, reco::MuonTimeExtra::nDof(), jets_cff::nMuons, reco::Muon::OuterTrack, outerTrackCollectionHandle_, TrackDetectorAssociator::OutsideIn, overlap(), phiOfMuonIneteractionRegion(), edm::Event::put(), reco::Muon::RPCMuon, reco::Muon::setType(), reco::Muon::StandAloneMuon, AlCaHLTBitMon_QueryRunRegistry::string, theShowerDigiFiller_, theTimingFiller_, reco::Muon::time(), 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_2018_cff::track, trackDepositName_, susybsm::HSCParticleType::trackerMuon, reco::Muon::TrackerMuon, MuonIdTruthInfo::truthMatchMuon(), reco::Muon::type(), validateGlobalMuonPair(), and writeIsoDeposits_.

                                                                           {
   auto outputMuons = std::make_unique<reco::MuonCollection>();
   auto caloMuons = std::make_unique<reco::CaloMuonCollection>();
 
   init(iEvent, iSetup);
 
   if (fillShowerDigis_ && fillMatching_)
     theShowerDigiFiller_->getDigis(iEvent);
 
   // loop over input collections
 
   // muons first - no cleaning, take as is.
   if (muonCollectionHandle_.isValid()) {
     for (const auto muon : *muonCollectionHandle_) {
       outputMuons->push_back(muon);
     }
   }
 
   // links second ( assume global muon type )
   if (linkCollectionHandle_.isValid()) {
     const auto nLink = linkCollectionHandle_->size();
     std::vector<bool> goodmuons(nLink, true);
     if (nLink > 1) {
       // check for shared tracker tracks
       for (unsigned int i = 0; i < nLink - 1; ++i) {
         const auto& iLink = linkCollectionHandle_->at(i);
         if (iLink.trackerTrack().isNull() || !checkLinks(&iLink))
           continue;
         for (unsigned int j = i + 1; j < nLink; ++j) {
           const auto& jLink = linkCollectionHandle_->at(j);
           if (!checkLinks(&jLink))
             continue;
           if (iLink.trackerTrack() == jLink.trackerTrack()) {
             // Tracker track is the essential part that dominates muon resolution
             // so taking either muon is fine. All that is important is to preserve
             // the muon identification information. If number of hits is small,
             // keep the one with large number of hits, otherwise take the smalest chi2/ndof
             if (validateGlobalMuonPair(iLink, jLink))
               goodmuons[j] = false;
             else
               goodmuons[i] = false;
           }
         }
       }
       // check for shared stand-alone muons.
       for (unsigned int i = 0; i < nLink - 1; ++i) {
         if (!goodmuons[i])
           continue;
         const auto& iLink = linkCollectionHandle_->at(i);
         if (iLink.standAloneTrack().isNull() || !checkLinks(&iLink))
           continue;
         for (unsigned int j = i + 1; j < nLink; ++j) {
           if (!goodmuons[j])
             continue;
           const auto& jLink = linkCollectionHandle_->at(j);
           if (!checkLinks(&jLink))
             continue;
           if (iLink.standAloneTrack() == jLink.standAloneTrack()) {
             if (validateGlobalMuonPair(iLink, jLink))
               goodmuons[j] = false;
             else
               goodmuons[i] = false;
           }
         }
       }
     }
     for (unsigned int i = 0; i < nLink; ++i) {
       if (!goodmuons[i])
         continue;
       const auto& iLink = linkCollectionHandle_->at(i);
       if (!checkLinks(&iLink))
         continue;
       // check if this muon is already in the list
       bool newMuon = true;
       for (auto muon : *outputMuons) {
         if (muon.track() == iLink.trackerTrack() && muon.standAloneMuon() == iLink.standAloneTrack() &&
             muon.combinedMuon() == iLink.globalTrack()) {
           newMuon = false;
           break;
         }
       }
       if (newMuon) {
         outputMuons->push_back(makeMuon(iLink));
         outputMuons->back().setType(reco::Muon::GlobalMuon | reco::Muon::StandAloneMuon);
       }
     }
   }
 
   // tracker and calo muons are next
   if (innerTrackCollectionHandle_.isValid()) {
     LogTrace("MuonIdentification") << "Creating tracker muons";
     std::vector<TrackDetectorAssociator::Direction> directions1, directions2;
     directions1.push_back(TrackDetectorAssociator::InsideOut);
     directions1.push_back(TrackDetectorAssociator::OutsideIn);
     directions2.push_back(TrackDetectorAssociator::Any);
 
     for (unsigned int i = 0; i < innerTrackCollectionHandle_->size(); ++i) {
       const reco::Track& track = innerTrackCollectionHandle_->at(i);
       if (!isGoodTrack(track))
         continue;
       const auto& trackRef = reco::TrackRef(innerTrackCollectionHandle_, i);
       bool splitTrack = false;
       if (track.extra().isAvailable() && TrackDetectorAssociator::crossedIP(track))
         splitTrack = true;
       const auto& directions = splitTrack ? directions1 : directions2;
       for (const auto direction : directions) {
         // make muon
         reco::Muon trackerMuon(makeMuon(iEvent, iSetup, trackRef, reco::Muon::InnerTrack));
         fillMuonId(iEvent, iSetup, trackerMuon, direction);
 
         if (debugWithTruthMatching_) {
           // add MC hits to a list of matched segments.
           // Since it's debugging mode - code is slow
           MuonIdTruthInfo::truthMatchMuon(iEvent, iSetup, trackerMuon);
         }
 
         // check if this muon is already in the list
         // have to check where muon hits are really located
         // to match properly
         bool newMuon = true;
         const bool goodTrackerMuon = isGoodTrackerMuon(trackerMuon);
         const bool goodRPCMuon = isGoodRPCMuon(trackerMuon);
         const bool goodGEMMuon = isGoodGEMMuon(trackerMuon);
         const bool goodME0Muon = isGoodME0Muon(trackerMuon);
         if (goodTrackerMuon)
           trackerMuon.setType(trackerMuon.type() | reco::Muon::TrackerMuon);
         if (goodRPCMuon)
           trackerMuon.setType(trackerMuon.type() | reco::Muon::RPCMuon);
         if (goodGEMMuon)
           trackerMuon.setType(trackerMuon.type() | reco::Muon::GEMMuon);
         if (goodME0Muon)
           trackerMuon.setType(trackerMuon.type() | reco::Muon::ME0Muon);
 
         for (auto& muon : *outputMuons) {
           if (muon.innerTrack().get() == trackerMuon.innerTrack().get() &&
               cos(phiOfMuonIneteractionRegion(muon) - phiOfMuonIneteractionRegion(trackerMuon)) > 0) {
             newMuon = false;
             muon.setMatches(trackerMuon.matches());
             if (trackerMuon.isTimeValid())
               muon.setTime(trackerMuon.time());
             if (trackerMuon.isEnergyValid())
               muon.setCalEnergy(trackerMuon.calEnergy());
             if (goodTrackerMuon)
               muon.setType(muon.type() | reco::Muon::TrackerMuon);
             if (goodRPCMuon)
               muon.setType(muon.type() | reco::Muon::RPCMuon);
             if (goodGEMMuon)
               muon.setType(muon.type() | reco::Muon::GEMMuon);
             if (goodME0Muon)
               muon.setType(muon.type() | reco::Muon::ME0Muon);
             LogTrace("MuonIdentification") << "Found a corresponding global muon. Set energy, matches and move on";
             break;
           }
         }
         if (newMuon) {
           if (goodTrackerMuon || goodRPCMuon || goodGEMMuon || goodME0Muon) {
             outputMuons->push_back(trackerMuon);
           } else {
             LogTrace("MuonIdentification") << "track failed minimal number of muon matches requirement";
             const reco::CaloMuon& caloMuon = makeCaloMuon(trackerMuon);
             if (isGoodCaloMuon(caloMuon))
               caloMuons->push_back(caloMuon);
           }
         }
       }
     }
   }
 
   // and at last the stand alone muons
   if (outerTrackCollectionHandle_.isValid()) {
     LogTrace("MuonIdentification") << "Looking for new muons among stand alone muon tracks";
     for (unsigned int i = 0; i < outerTrackCollectionHandle_->size(); ++i) {
       const auto& outerTrack = outerTrackCollectionHandle_->at(i);
 
       // check if this muon is already in the list of global muons
       bool newMuon = true;
       for (auto& muon : *outputMuons) {
         if (!muon.standAloneMuon().isNull()) {
           // global muon
           if (muon.standAloneMuon().get() == &outerTrack) {
             newMuon = false;
             break;
           }
         } else {
           // tracker muon - no direct links to the standalone muon
           // since we have only a few real muons in an event, matching
           // the stand alone muon to the tracker muon by DetIds should
           // be good enough for association. At the end it's up to a
           // user to redefine the association and what it means. Here
           // we would like to avoid obvious double counting and we
           // tolerate a potential miss association
           if (overlap(muon, outerTrack) > 0) {
             LogTrace("MuonIdentification") << "Found associated tracker muon. Set a reference and move on";
             newMuon = false;
             muon.setOuterTrack(reco::TrackRef(outerTrackCollectionHandle_, i));
             muon.setType(muon.type() | reco::Muon::StandAloneMuon);
             break;
           }
         }
       }
       if (newMuon) {
         LogTrace("MuonIdentification") << "No associated stand alone track is found. Making a muon";
         outputMuons->push_back(
             makeMuon(iEvent, iSetup, reco::TrackRef(outerTrackCollectionHandle_, i), reco::Muon::OuterTrack));
         outputMuons->back().setType(reco::Muon::StandAloneMuon);
       }
     }
   }
 
   if (arbitrateTrackerMuons_) {
     fillArbitrationInfo(outputMuons.get());
     arbitrateMuons(outputMuons.get(), caloMuons.get());
   }
 
   LogTrace("MuonIdentification") << "Dress up muons if it's necessary";
 
   const int nMuons = outputMuons->size();
 
   std::vector<reco::MuonTimeExtra> dtTimeColl(nMuons);
   std::vector<reco::MuonTimeExtra> cscTimeColl(nMuons);
   std::vector<reco::MuonTimeExtra> combinedTimeColl(nMuons);
   std::vector<reco::IsoDeposit> trackDepColl(nMuons);
   std::vector<reco::IsoDeposit> ecalDepColl(nMuons);
   std::vector<reco::IsoDeposit> hcalDepColl(nMuons);
   std::vector<reco::IsoDeposit> hoDepColl(nMuons);
   std::vector<reco::IsoDeposit> jetDepColl(nMuons);
 
   // Fill various information
   for (unsigned int i = 0; i < outputMuons->size(); ++i) {
     auto& muon = outputMuons->at(i);
 
     // Fill muonID
     if ((fillMatching_ && !muon.isMatchesValid()) || (fillEnergy_ && !muon.isEnergyValid())) {
       // predict direction based on the muon interaction region location
       // if it's available
       if (muon.isStandAloneMuon()) {
         if (cos(phiOfMuonIneteractionRegion(muon) - muon.phi()) > 0) {
           fillMuonId(iEvent, iSetup, muon, TrackDetectorAssociator::InsideOut);
         } else {
           fillMuonId(iEvent, iSetup, muon, TrackDetectorAssociator::OutsideIn);
         }
       } else {
         LogTrace("MuonIdentification") << "THIS SHOULD NEVER HAPPEN";
         fillMuonId(iEvent, iSetup, muon);
       }
     }
 
     if (fillGlobalTrackQuality_) {
       // Fill global quality information
       fillGlbQuality(iEvent, iSetup, muon);
     }
     LogDebug("MuonIdentification");
 
     if (fillTrackerKink_) {
       fillTrackerKink(muon);
     }
 
     if (fillCaloCompatibility_)
       muon.setCaloCompatibility(muonCaloCompatibility_.evaluate(muon));
 
     if (fillIsolation_) {
       fillMuonIsolation(
           iEvent, iSetup, muon, trackDepColl[i], ecalDepColl[i], hcalDepColl[i], hoDepColl[i], jetDepColl[i]);
     }
 
     // fill timing information
     reco::MuonTime muonTime;
     reco::MuonTimeExtra dtTime;
     reco::MuonTimeExtra cscTime;
     reco::MuonTime rpcTime;
     reco::MuonTimeExtra combinedTime;
 
     theTimingFiller_->fillTiming(muon, dtTime, cscTime, rpcTime, combinedTime, iEvent, iSetup);
 
     muonTime.nDof = combinedTime.nDof();
     muonTime.timeAtIpInOut = combinedTime.timeAtIpInOut();
     muonTime.timeAtIpInOutErr = combinedTime.timeAtIpInOutErr();
     muonTime.timeAtIpOutIn = combinedTime.timeAtIpOutIn();
     muonTime.timeAtIpOutInErr = combinedTime.timeAtIpOutInErr();
 
     muon.setTime(muonTime);
     muon.setRPCTime(rpcTime);
     dtTimeColl[i] = dtTime;
     cscTimeColl[i] = cscTime;
     combinedTimeColl[i] = combinedTime;
   }
 
   LogTrace("MuonIdentification") << "number of muons produced: " << outputMuons->size();
   if (fillMatching_) {
     fillArbitrationInfo(outputMuons.get(), reco::Muon::TrackerMuon);
     fillArbitrationInfo(outputMuons.get(), reco::Muon::ME0Muon);
     fillArbitrationInfo(outputMuons.get(), reco::Muon::GEMMuon);
   }
   edm::OrphanHandle<reco::MuonCollection> muonHandle = iEvent.put(std::move(outputMuons));
 
   auto fillMap = [](auto refH, auto& vec, edm::Event& ev, const std::string& cAl = "") {
     typedef edm::ValueMap<typename std::decay<decltype(vec)>::type::value_type> MapType;
     auto oMap = std::make_unique<MapType>();
     {
       typename MapType::Filler filler(*oMap);
       filler.insert(refH, vec.begin(), vec.end());
       vec.clear();
       filler.fill();
     }
     ev.put(std::move(oMap), cAl);
   };
   fillMap(muonHandle, combinedTimeColl, iEvent, "combined");
   fillMap(muonHandle, dtTimeColl, iEvent, "dt");
   fillMap(muonHandle, cscTimeColl, iEvent, "csc");
 
   if (writeIsoDeposits_ && fillIsolation_) {
     fillMap(muonHandle, trackDepColl, iEvent, trackDepositName_);
     fillMap(muonHandle, ecalDepColl, iEvent, ecalDepositName_);
     fillMap(muonHandle, hcalDepColl, iEvent, hcalDepositName_);
     fillMap(muonHandle, hoDepColl, iEvent, hoDepositName_);
     fillMap(muonHandle, jetDepColl, iEvent, jetDepositName_);
   }
 
   iEvent.put(std::move(caloMuons));
 }

double MuonIdProducer::sectorPhi ( const DetId & id )

static

Definition at line 1308 of file MuonIdProducer.cc.

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

Referenced by phiOfMuonIneteractionRegion().

                                                 {
   double phi = 0;
   if (id.subdetId() == MuonSubdetId::DT) {  // DT
     DTChamberId muonId(id.rawId());
     if (muonId.sector() <= 12)
       phi = (muonId.sector() - 1) / 6. * M_PI;
     if (muonId.sector() == 13)
       phi = 3 / 6. * M_PI;
     if (muonId.sector() == 14)
       phi = 9 / 6. * M_PI;
   }
   if (id.subdetId() == MuonSubdetId::CSC) {  // CSC
     CSCDetId muonId(id.rawId());
     phi = M_PI / 4 + (muonId.triggerSector() - 1) / 3. * M_PI;
   }
   if (phi > M_PI)
     phi -= 2 * M_PI;
   return phi;
 }