#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 Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

static double	sectorPhi (const DetId &id)

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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_

Additional Inherited Members
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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.

                                                             :
 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.

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.

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.

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.

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