CosmicMuonLinksProducer Class Reference

#include <CosmicMuonLinksProducer.h>

Inheritance diagram for CosmicMuonLinksProducer:

Public Member Functions
	CosmicMuonLinksProducer (const edm::ParameterSet &)
void	produce (edm::Event &, const edm::EventSetup &) override
	~CosmicMuonLinksProducer () override
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
	EDProducer (const EDProducer &)=delete
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final
const EDProducer &	operator= (const EDProducer &)=delete

Private Member Functions
reco::TrackToTrackMap	mapTracks (const edm::Handle< reco::TrackCollection > &, const edm::Handle< reco::TrackCollection > &) const
int	sharedHits (const reco::Track &track1, const reco::Track &track2) const

Private Attributes
std::string	category_
MuonServiceProxy *	theService
std::vector< std::pair< std::string, std::string > >	theTrackLinkNames
std::vector< std::pair< edm::EDGetTokenT< reco::TrackCollection >, edm::EDGetTokenT< reco::TrackCollection > > >	theTrackLinks

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T... >
using	GlobalCache = typename CacheTypes::GlobalCache
using	HasAbility = AbilityChecker< T... >
using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache
using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache
using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >
using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache
using	RunCache = typename CacheTypes::RunCache
using	RunContext = RunContextT< RunCache, GlobalCache >
using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Detailed Description

Original Author: Chang Liu - Purdue University chang.nosp@m..liu.nosp@m.@cern.nosp@m..ch

Definition at line 16 of file CosmicMuonLinksProducer.h.

Constructor & Destructor Documentation

CosmicMuonLinksProducer()

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

explicit

Definition at line 36 of file CosmicMuonLinksProducer.cc.

References edm::ParameterSet::getParameter(), edm::InputTag::label(), LogDebug, MuonServiceProxy_cff::MuonServiceProxy, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                            {
  category_ = "Muon|RecoMuon|CosmicMuon|CosmicMuonLinksProducer";

  ParameterSet serviceParameters = iConfig.getParameter<ParameterSet>("ServiceParameters");

  theService = new MuonServiceProxy(serviceParameters, consumesCollector());

  std::vector<edm::ParameterSet> theMapPSets = iConfig.getParameter<std::vector<edm::ParameterSet> >("Maps");
  for (std::vector<edm::ParameterSet>::const_iterator iMPS = theMapPSets.begin(); iMPS != theMapPSets.end(); iMPS++) {
    edm::InputTag sTag = (*iMPS).getParameter<edm::InputTag>("subTrack");
    edm::InputTag pTag = (*iMPS).getParameter<edm::InputTag>("parentTrack");

    edm::EDGetTokenT<reco::TrackCollection> subTrackTag = consumes<reco::TrackCollection>(sTag);
    edm::EDGetTokenT<reco::TrackCollection> parentTrackTag = consumes<reco::TrackCollection>(pTag);
    theTrackLinks.push_back(make_pair(subTrackTag, parentTrackTag));
    theTrackLinkNames.push_back(make_pair(sTag.label(), pTag.label()));

    LogDebug(category_) << "preparing map between " << sTag << " & " << pTag;
    std::string mapname = sTag.label() + "To" + pTag.label();
    produces<reco::TrackToTrackMap>(mapname);
  }
}

~CosmicMuonLinksProducer()

CosmicMuonLinksProducer::~CosmicMuonLinksProducer ( )

override

Definition at line 59 of file CosmicMuonLinksProducer.cc.

                                                  {
  if (theService)
    delete theService;
}

Member Function Documentation

mapTracks()

reco::TrackToTrackMap CosmicMuonLinksProducer::mapTracks ( const edm::Handle< reco::TrackCollection > &  subTracks, const edm::Handle< reco::TrackCollection > &  parentTracks  ) const

private

Definition at line 103 of file CosmicMuonLinksProducer.cc.

References LogTrace, genParticles_cff::map, and muonCosmicCompatibility_cfi::sharedHits.

                                                                                                                {
  reco::TrackToTrackMap map(subTracks, parentTracks);
  for (unsigned int position1 = 0; position1 != subTracks->size(); ++position1) {
    TrackRef track1(subTracks, position1);
    for (unsigned int position2 = 0; position2 != parentTracks->size(); ++position2) {
      TrackRef track2(parentTracks, position2);
      int shared = sharedHits(*track1, *track2);
      LogTrace(category_) << "sharedHits " << shared << " track1 " << track1->found() << " track2 " << track2->found()
                          << endl;

      if (shared > (track1->found()) / 2)
        map.insert(track1, track2);
    }
  }

  return map;
}

produce()

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

override

DAMN I cannot read the label of the TOKEN so I need to do this stupid thing to create the labels of the products!

Definition at line 65 of file CosmicMuonLinksProducer.cc.

References counter, iEvent, LogDebug, LogTrace, edm::ProductLabels::module, edm::AssociationMap< Tag >::size(), AlCaHLTBitMon_QueryRunRegistry::string, and trackerHitRTTI::vector.

                                                                             {
  LogInfo(category_) << "Processing event number: " << iEvent.id();

  theService->update(iSetup);

  unsigned int counter =
      0;  
  for (std::vector<std::pair<edm::EDGetTokenT<reco::TrackCollection>,
                             edm::EDGetTokenT<reco::TrackCollection> > >::const_iterator iLink = theTrackLinks.begin();
       iLink != theTrackLinks.end();
       iLink++) {
#ifdef EDM_ML_DEBUG
    edm::EDConsumerBase::Labels labels_first;
    edm::EDConsumerBase::Labels labels_second;
    labelsForToken(iLink->first, labels_first);
    labelsForToken(iLink->second, labels_second);
    LogDebug(category_) << "making map between " << labels_first.module << " and " << labels_second.module;
#endif
    std::string mapname = theTrackLinkNames[counter].first + "To" + theTrackLinkNames[counter].second;
    reco::TrackToTrackMap ttmap;

    Handle<reco::TrackCollection> subTracks;
    Handle<reco::TrackCollection> parentTracks;

    iEvent.getByToken((*iLink).first, subTracks);
    iEvent.getByToken((*iLink).second, parentTracks);

    ttmap = mapTracks(subTracks, parentTracks);
    LogTrace(category_) << "Mapped: " << theTrackLinkNames[counter].first << " " << subTracks->size() << " and "
                        << theTrackLinkNames[counter].second << " " << parentTracks->size()
                        << ", results: " << ttmap.size() << endl;

    iEvent.put(std::make_unique<reco::TrackToTrackMap>(ttmap), mapname);

    counter++;
  }
}

sharedHits()

int CosmicMuonLinksProducer::sharedHits ( const reco::Track &  track1, const reco::Track &  track2  ) const

private

Definition at line 122 of file CosmicMuonLinksProducer.cc.

References MillePedeFileConverter_cfg::e, globals_cff::id1, globals_cff::id2, LogTrace, edm::match(), DetId::Muon, reco::Track::recHitsBegin(), and reco::Track::recHitsEnd().

                                                                                              {
  int match = 0;

  for (trackingRecHit_iterator hit1 = track1.recHitsBegin(); hit1 != track1.recHitsEnd(); ++hit1) {
    if (!(*hit1)->isValid())
      continue;
    DetId id1 = (*hit1)->geographicalId();
    if (id1.det() != DetId::Muon)
      continue;  //ONLY MUON
    LogTrace(category_) << "first ID " << id1.rawId() << " " << (*hit1)->localPosition() << endl;
    GlobalPoint pos1 = theService->trackingGeometry()->idToDet(id1)->surface().toGlobal((*hit1)->localPosition());

    for (trackingRecHit_iterator hit2 = track2.recHitsBegin(); hit2 != track2.recHitsEnd(); ++hit2) {
      if (!(*hit2)->isValid())
        continue;

      DetId id2 = (*hit2)->geographicalId();
      if (id2.det() != DetId::Muon)
        continue;  //ONLY MUON

      //          LogTrace(category_)<<"second ID "<<id2.rawId()<< (*hit2)->localPosition()<<endl;

      if (id2.rawId() != id1.rawId())
        continue;

      GlobalPoint pos2 = theService->trackingGeometry()->idToDet(id2)->surface().toGlobal((*hit2)->localPosition());
      if ((pos1 - pos2).mag() < 10e-5)
        match++;
    }
  }

  return match;
}

Member Data Documentation

category_

std::string CosmicMuonLinksProducer::category_

private

Definition at line 36 of file CosmicMuonLinksProducer.h.

theService

MuonServiceProxy* CosmicMuonLinksProducer::theService

private

Definition at line 30 of file CosmicMuonLinksProducer.h.

theTrackLinkNames

std::vector<std::pair<std::string, std::string> > CosmicMuonLinksProducer::theTrackLinkNames

private

Definition at line 34 of file CosmicMuonLinksProducer.h.

theTrackLinks

std::vector<std::pair<edm::EDGetTokenT<reco::TrackCollection>, edm::EDGetTokenT<reco::TrackCollection> > > CosmicMuonLinksProducer::theTrackLinks

private

Definition at line 33 of file CosmicMuonLinksProducer.h.