MuonIdProducer Class Reference

#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	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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	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_
MuonMesh *	meshAlgo_
int	minNumberOfMatches_
double	minP_
double	minPCaloMuon_
double	minPt_
reco::isodeposit::IsoDepositExtractor *	muIsoExtractorCalo_
reco::isodeposit::IsoDepositExtractor *	muIsoExtractorJet_
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_
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 67 of file MuonIdProducer.h.

Member Typedef Documentation

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

Definition at line 69 of file MuonIdProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 36 of file MuonIdProducer.cc.

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

                                                            :
muIsoExtractorCalo_(nullptr),muIsoExtractorTrack_(nullptr),muIsoExtractorJet_(nullptr)
{
  
  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");
   fillMatching_            = iConfig.getParameter<bool>("fillMatching");
   fillIsolation_           = iConfig.getParameter<bool>("fillIsolation");
   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_ = new MuonTimingFiller(timingParameters,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_ = new 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 182 of file MuonIdProducer.cc.

References meshAlgo_, muIsoExtractorCalo_, muIsoExtractorJet_, muIsoExtractorTrack_, and theTimingFiller_.

{
   if (muIsoExtractorCalo_) delete muIsoExtractorCalo_;
   if (muIsoExtractorTrack_) delete muIsoExtractorTrack_;
   if (muIsoExtractorJet_) delete muIsoExtractorJet_;
   if (theTimingFiller_) delete theTimingFiller_;
   if (meshAlgo_) delete meshAlgo_;
   // 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 123 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 986 of file MuonIdProducer.cc.

References isGoodCaloMuon(), makeCaloMuon(), RecoTauDiscriminantConfiguration::mask, 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 427 of file MuonIdProducer.cc.

References edm::EventSetup::get(), meshAlgo_, edm::ESHandle< T >::product(), and MuonMesh::setCSCGeometry().

{
  edm::ESHandle<CSCGeometry> geomHandle;
  iSetup.get<MuonGeometryRecord>().get(geomHandle);

  meshAlgo_->setCSCGeometry(geomHandle.product());

}

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

private

Definition at line 378 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 1301 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 1012 of file MuonIdProducer.cc.

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, MuonMesh::clearMesh(), MuonSubdetId::CSC, getSegmentMatches(), MuonMesh::isDuplicateOf(), meshAlgo_, CSCDetId::ring(), MuonMesh::runMesh(), plotscripts::stationIndex(), and reco::Muon::TrackerMuon.

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

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

                                                                                {  
  edm::ParameterSetDescription desc;  
  desc.setAllowAnything();
  
  desc.add<bool>("arbitrateTrackerMuons",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 1280 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 792 of file MuonIdProducer.cc.

References funct::abs(), TrackDetectorAssociator::associate(), reco::MuonRPCHitMatch::bx, relativeConstraints::chamber, TrackDetMatchInfo::chambers, TrackDetMatchInfo::crossedEcalIds, TrackDetMatchInfo::crossedEnergy(), TrackDetMatchInfo::crossedHcalIds, reco::MuonSegmentMatch::cscSegmentRef, 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, TrackDetMatchInfo::ecalRecHits, reco::MuonChamberMatch::edgeX, reco::MuonChamberMatch::edgeY, reco::MuonEnergy::em, reco::MuonEnergy::emMax, reco::MuonEnergy::emS25, reco::MuonEnergy::emS9, Exception, fillEnergy_, fillMatching_, TrackDetMatchInfo::findMaxDeposition(), 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, TrackDetMatchInfo::hcalRecHits, reco::MuonEnergy::ho, TrackDetMatchInfo::HORecHits, reco::MuonEnergy::hoS9, reco::MuonChamberMatch::id, hit::id, 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_, maxAbsPullX_, maxAbsPullY_, MuonSubdetId::ME0, reco::MuonChamberMatch::me0Matches, reco::MuonSegmentMatch::me0SegmentRef, reco::Muon::NoArbitration, reco::Muon::numberOfMatches(), TrackDetMatchInfo::nXnEnergy(), or, parameters_, rpcHitHandle_, reco::MuonChamberMatch::rpcMatches, reco::MuonChamberMatch::segmentMatches, reco::Muon::setCalEnergy(), reco::Muon::setMatches(), mathSSE::sqrt(), reco::Muon::standAloneMuon(), DetId::subdetId(), reco::MuonSegmentMatch::t0, reco::MuonEnergy::tower, reco::MuonEnergy::towerS9, TrackDetMatchInfo::TowerTotal, HiIsolationCommonParameters_cff::track, reco::Muon::track(), trackAssociator_, TrackDetMatchInfo::trkGlobPosAtEcal, TrackDetMatchInfo::trkGlobPosAtHcal, 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().

{

   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
      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 ( ! 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;

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

References reco::IsoDeposit::candEnergy(), reco::isodeposit::IsoDepositExtractor::deposit(), reco::IsoDeposit::depositAndCountWithin(), reco::isodeposit::IsoDepositExtractor::deposits(), 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, 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, HiIsolationCommonParameters_cff::track, reco::Muon::track(), reco::MuonIsolation::trackerVetoPt, and writeIsoDeposits_.

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

References reco::Muon::combinedQuality(), reco::Muon::innerTrack(), edm::Ref< C, T, F >::isNull(), reco::Muon::isQualityValid(), jets_cff::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 130 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 192 of file MuonIdProducer.cc.

References edm::HandleBase::clear(), dytCollectionHandle_, dytCollectionToken_, Exception, fillGlobalTrackQuality_, fillGlobalTrackRefits_, fillTrackerKink_, edm::EventSetup::get(), edm::Event::getByToken(), glbQualHandle_, glbQualToken_, mps_fire::i, MuonIdProducer::ICTypes::INNER_TRACKS, innerTrackCollectionHandle_, innerTrackCollectionToken_, inputCollectionLabels_, inputCollectionTypes_, fftjetpileupestimator_calo_cfi::inputLabel, edm::HandleBase::isValid(), linkCollectionHandle_, linkCollectionToken_, MuonIdProducer::ICTypes::LINKS, LogTrace, muonCollectionHandle_, muonCollectionToken_, MuonIdProducer::ICTypes::MUONS, MuonIdProducer::ICTypes::OUTER_TRACKS, outerTrackCollectionHandle_, outerTrackCollectionToken_, pickyCollectionHandle_, pickyCollectionToken_, edm::ESHandle< T >::product(), PhotonConversionTrajectorySeedProducerFromQuadruplets_cfi::propagator, rpcHitHandle_, rpcHitToken_, TrackDetectorAssociator::setPropagator(), edm::AssociationMap< Tag >::size(), MuonIdProducer::ICTypes::TEV_DYT, MuonIdProducer::ICTypes::TEV_FIRSTHIT, MuonIdProducer::ICTypes::TEV_PICKY, MuonIdProducer::ICTypes::toStr(), tpfmsCollectionHandle_, tpfmsCollectionToken_, trackAssociator_, and trackerKinkFinder_.

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 764 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 779 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 785 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 770 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 356 of file MuonIdProducer.cc.

References funct::abs(), PVValHelper::eta, reco::TrackBase::eta(), LogTrace, maxAbsEta_, minP_, minPCaloMuon_, minPt_, AlCaHLTBitMon_ParallelJobs::p, reco::TrackBase::p(), EnergyCorrector::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 755 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 281 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 263 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 296 of file MuonIdProducer.cc.

References edm::AssociationMap< edm::OneToOne< reco::TrackCollection, reco::TrackCollection > >::const_iterator, 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_, and reco::MuonTrackLinks::trackerTrack().

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

References reco::TrackBase::charge(), nanoDQM_cfi::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 394 of file MuonIdProducer.cc.

References chamberId(), reco::Track::extra(), reco::Muon::isMatchesValid(), edm::Ref< C, T, F >::isNull(), match(), patRefSel_triggerMatching_cfi::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 1266 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 450 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_, objects.autophobj::filler, fillGlbQuality(), fillGlobalTrackQuality_, fillIsolation_, fillMatching_, fillMuonId(), fillMuonIsolation(), MuonTimingFiller::fillTiming(), 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(), 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, 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(), HiIsolationCommonParameters_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);

   // 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 1248 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;
}

Member Data Documentation

bool MuonIdProducer::addExtraSoftMuons_

private

Definition at line 186 of file MuonIdProducer.h.

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

bool MuonIdProducer::arbClean_

private

Definition at line 248 of file MuonIdProducer.h.

Referenced by fillArbitrationInfo(), and MuonIdProducer().

bool MuonIdProducer::arbitrateTrackerMuons_

private

Definition at line 203 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

double MuonIdProducer::caloCut_

private

Definition at line 246 of file MuonIdProducer.h.

Referenced by isGoodCaloMuon(), and MuonIdProducer().

bool MuonIdProducer::debugWithTruthMatching_

private

Definition at line 205 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

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

private

Definition at line 213 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

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

private

Definition at line 221 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

std::string MuonIdProducer::ecalDepositName_

private

Definition at line 234 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

bool MuonIdProducer::fillCaloCompatibility_

private

Definition at line 195 of file MuonIdProducer.h.

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

bool MuonIdProducer::fillEnergy_

private

Definition at line 196 of file MuonIdProducer.h.

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

bool MuonIdProducer::fillGlobalTrackQuality_

private

Definition at line 239 of file MuonIdProducer.h.

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

bool MuonIdProducer::fillGlobalTrackRefits_

private

Definition at line 240 of file MuonIdProducer.h.

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

bool MuonIdProducer::fillIsolation_

private

Definition at line 198 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

bool MuonIdProducer::fillMatching_

private

Definition at line 197 of file MuonIdProducer.h.

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

bool MuonIdProducer::fillTrackerKink_

private

Definition at line 243 of file MuonIdProducer.h.

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

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

private

Definition at line 227 of file MuonIdProducer.h.

Referenced by fillGlbQuality(), and init().

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

private

Definition at line 224 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

edm::InputTag MuonIdProducer::globalTrackQualityInputTag_

private

Definition at line 241 of file MuonIdProducer.h.

std::string MuonIdProducer::hcalDepositName_

private

Definition at line 235 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

std::string MuonIdProducer::hoDepositName_

private

Definition at line 236 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

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

private

Definition at line 207 of file MuonIdProducer.h.

Referenced by init(), and produce().

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

private

Definition at line 215 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

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

private

Definition at line 175 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

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

private

Definition at line 176 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

std::string MuonIdProducer::jetDepositName_

private

Definition at line 237 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

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

private

Definition at line 210 of file MuonIdProducer.h.

Referenced by init(), and produce().

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

private

Definition at line 218 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

double MuonIdProducer::maxAbsDx_

private

Definition at line 189 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

double MuonIdProducer::maxAbsDy_

private

Definition at line 191 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

double MuonIdProducer::maxAbsEta_

private

Definition at line 185 of file MuonIdProducer.h.

Referenced by isGoodTrack(), and MuonIdProducer().

double MuonIdProducer::maxAbsPullX_

private

Definition at line 190 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

double MuonIdProducer::maxAbsPullY_

private

Definition at line 192 of file MuonIdProducer.h.

Referenced by fillMuonId(), and MuonIdProducer().

MuonMesh* MuonIdProducer::meshAlgo_

private

Definition at line 249 of file MuonIdProducer.h.

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

int MuonIdProducer::minNumberOfMatches_

private

Definition at line 184 of file MuonIdProducer.h.

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

double MuonIdProducer::minP_

private

Definition at line 182 of file MuonIdProducer.h.

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

double MuonIdProducer::minPCaloMuon_

private

Definition at line 183 of file MuonIdProducer.h.

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

double MuonIdProducer::minPt_

private

Definition at line 181 of file MuonIdProducer.h.

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

reco::isodeposit::IsoDepositExtractor* MuonIdProducer::muIsoExtractorCalo_

private

Definition at line 230 of file MuonIdProducer.h.

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

reco::isodeposit::IsoDepositExtractor* MuonIdProducer::muIsoExtractorJet_

private

Definition at line 232 of file MuonIdProducer.h.

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

reco::isodeposit::IsoDepositExtractor* MuonIdProducer::muIsoExtractorTrack_

private

Definition at line 231 of file MuonIdProducer.h.

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

MuonCaloCompatibility MuonIdProducer::muonCaloCompatibility_

private

Definition at line 229 of file MuonIdProducer.h.

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

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

private

Definition at line 209 of file MuonIdProducer.h.

Referenced by init(), and produce().

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

private

Definition at line 217 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

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

private

Definition at line 208 of file MuonIdProducer.h.

Referenced by init(), and produce().

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

private

Definition at line 216 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

TrackAssociatorParameters MuonIdProducer::parameters_

private

Definition at line 138 of file MuonIdProducer.h.

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

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

private

Definition at line 212 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

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

private

Definition at line 220 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

double MuonIdProducer::ptThresholdToFillCandidateP4WithGlobalFit_

private

Definition at line 200 of file MuonIdProducer.h.

Referenced by makeMuon(), and MuonIdProducer().

edm::Handle<RPCRecHitCollection> MuonIdProducer::rpcHitHandle_

private

Definition at line 226 of file MuonIdProducer.h.

Referenced by fillMuonId(), and init().

edm::EDGetTokenT<RPCRecHitCollection> MuonIdProducer::rpcHitToken_

private

Definition at line 223 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

double MuonIdProducer::sigmaThresholdToFillCandidateP4WithGlobalFit_

private

Definition at line 201 of file MuonIdProducer.h.

Referenced by makeMuon(), and MuonIdProducer().

MuonTimingFiller* MuonIdProducer::theTimingFiller_

private

Definition at line 178 of file MuonIdProducer.h.

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

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

private

Definition at line 211 of file MuonIdProducer.h.

Referenced by init(), and makeMuon().

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

private

Definition at line 219 of file MuonIdProducer.h.

Referenced by init(), and MuonIdProducer().

TrackDetectorAssociator MuonIdProducer::trackAssociator_

private

Definition at line 137 of file MuonIdProducer.h.

Referenced by fillMuonId(), and init().

std::string MuonIdProducer::trackDepositName_

private

Definition at line 233 of file MuonIdProducer.h.

Referenced by MuonIdProducer(), and produce().

std::unique_ptr<MuonKinkFinder> MuonIdProducer::trackerKinkFinder_

private

Definition at line 244 of file MuonIdProducer.h.

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

bool MuonIdProducer::writeIsoDeposits_

private

Definition at line 199 of file MuonIdProducer.h.

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