L3MuonCandidateProducer Class Reference

#include <L3MuonCandidateProducer.h>

Inheritance diagram for L3MuonCandidateProducer:

Public Types
enum	MuonTrackType { InnerTrack, OuterTrack, CombinedTrack }
Public Types inherited from edm::global::EDProducerBase
typedef EDProducerBase	ModuleType
Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Member Functions
	L3MuonCandidateProducer (const edm::ParameterSet &)
	constructor with config More...
virtual void	produce (edm::StreamID, edm::Event &, const edm::EventSetup &) const override
	produce candidates More...
virtual	~L3MuonCandidateProducer ()
	destructor More...
Public Member Functions inherited from edm::global::EDProducer<>
	EDProducer ()=default
Public Member Functions inherited from edm::global::EDProducerBase
	EDProducerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDProducerBase ()
Public Member Functions inherited from edm::ProducerBase
	ProducerBase ()
void	registerProducts (ProducerBase *, ProductRegistry *, ModuleDescription const &)
std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...
virtual	~ProducerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
	EDConsumerBase ()
ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const
std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)
virtual	~EDConsumerBase ()

Private Attributes
edm::EDGetTokenT < reco::MuonTrackLinksCollection >	linkToken_
edm::InputTag	theL3CollectionLabel
edm::InputTag	theL3LinksLabel
enum MuonTrackType	theType
bool	theUseLinks
edm::EDGetTokenT < reco::TrackCollection >	trackToken_

Additional Inherited Members
Static Public Member Functions inherited from edm::global::EDProducerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)
Protected Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
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

Intermediate step in the L3 muons selection. This class takes the L3 muons (which are reco::Tracks) and creates the correspondent reco::RecoChargedCandidate.

Riccardo's comment: The separation between the L3MuonProducer and this class allows the interchangeability of the L3MuonProducer and the StandAloneMuonProducer This class is supposed to be removed once the L3/STA comparison will be done, then the RecoChargedCandidate production will be put into the L3MuonProducer class.

Author

J.Alcaraz

Intermediate step in the L3 muons selection. This class takes the L3 muons (which are reco::Tracks) and creates the correspondent reco::RecoChargedCandidate.

Riccardo's comment: The separation between the L3MuonProducer and this class allows the interchangeability of the L3MuonProducer and the StandAloneMuonProducer This class is supposed to be removed once the L3/STA comparison will be done, then the RecoChargedCandidate production will be done into the L3MuonProducer class.

Author

J.Alcaraz

Definition at line 30 of file L3MuonCandidateProducer.h.

Member Enumeration Documentation

enum L3MuonCandidateProducer::MuonTrackType

Enumerator
InnerTrack
OuterTrack
CombinedTrack

Definition at line 33 of file L3MuonCandidateProducer.h.

{InnerTrack, OuterTrack, CombinedTrack};

Constructor & Destructor Documentation

L3MuonCandidateProducer::L3MuonCandidateProducer

(

const edm::ParameterSet &

parameterSet

)

constructor with config

Definition at line 44 of file L3MuonCandidateProducer.cc.

References category, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), LogTrace, or, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                {
  LogTrace(category)<<" constructor called";

  // StandAlone Collection Label
  theL3CollectionLabel = parameterSet.getParameter<InputTag>("InputObjects");
  trackToken_ = consumes<reco::TrackCollection>(theL3CollectionLabel);
 
  // use links
  theUseLinks = parameterSet.existsAs<InputTag>("InputLinksObjects");
  if (theUseLinks) {
    theL3LinksLabel = parameterSet.getParameter<InputTag>("InputLinksObjects");
    linkToken_ = consumes<reco::MuonTrackLinksCollection>(theL3LinksLabel);
    if (theL3LinksLabel.label() == "" or theL3LinksLabel.label() == "unused")
      theUseLinks = false;
  }

  // use global, standalone or tracker pT/4-vector assignment
  const std::string & muon_track_for_momentum = parameterSet.existsAs<std::string>("MuonPtOption") ?  parameterSet.getParameter<std::string>("MuonPtOption") : "Global";
  if (muon_track_for_momentum == std::string("Tracker"))
    theType=InnerTrack;
  else if (muon_track_for_momentum == std::string("Standalone"))
    theType=OuterTrack;
  else if (muon_track_for_momentum == std::string("Global"))
    theType=CombinedTrack;
  else {
    LogError(category)<<"invalid value for MuonPtOption, please choose among 'Tracker', 'Standalone', 'Global'";
    theType=CombinedTrack;
  }

  produces<RecoChargedCandidateCollection>();
}

L3MuonCandidateProducer::~L3MuonCandidateProducer ( )

virtual

destructor

Definition at line 77 of file L3MuonCandidateProducer.cc.

References category, and LogTrace.

                                                 {
  LogTrace(category)<<" L3MuonCandidateProducer destructor called";
}

Member Function Documentation

void L3MuonCandidateProducer::produce ( edm::StreamID  , edm::Event &  event, const edm::EventSetup &  eventSetup  ) const

overridevirtual

produce candidates

reconstruct muons

Implements edm::global::EDProducerBase.

Definition at line 83 of file L3MuonCandidateProducer.cc.

References funct::abs(), objects.IsoTrackAnalyzer::candidates, category, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, i, edm::Ref< C, T, F >::isNull(), MainPageGenerator::link, electronStore::links, LogDebug, LogTrace, p4, sysUtil::pid, lumiQueryAPI::q, reco::RecoChargedCandidate::setTrack(), and testEve_cfg::tracks.

                                                                                               {
  // Take the L3 container
  LogTrace(category)<<" Taking the L3/GLB muons: "<<theL3CollectionLabel.label();
  Handle<TrackCollection> tracks;
  event.getByToken(trackToken_,tracks);

  edm::Handle<reco::MuonTrackLinksCollection> links;
  if (theUseLinks)
    event.getByToken(linkToken_, links);

  // Create a RecoChargedCandidate collection
  LogTrace(category)<<" Creating the RecoChargedCandidate collection";
  auto_ptr<RecoChargedCandidateCollection> candidates( new RecoChargedCandidateCollection());
  LogDebug(category) << " size = " << tracks->size();
  for (unsigned int i=0; i<tracks->size(); i++) {
    TrackRef inRef(tracks,i);
    TrackRef tkRef = TrackRef();

    if (theUseLinks) {
      for(reco::MuonTrackLinksCollection::const_iterator link = links->begin();
          link != links->end(); ++link){ LogDebug(category) << " i = " << i;

        if (not link->trackerTrack().isNull()) LogTrace(category) << " link tk pt " << link->trackerTrack()->pt();
        if (not link->standAloneTrack().isNull()) LogTrace(category) << " sta pt " << link->standAloneTrack()->pt();
        if (not link->globalTrack().isNull()) LogTrace(category) << " global pt " << link->globalTrack()->pt();
        if (not inRef.isNull()) LogTrace(category) << " inRef pt " << inRef->pt();

        if (link->globalTrack().isNull()) {
          edm::LogError(category) << "null reference to the global track";
          // skip this candidate
          continue;
        }

        float dR  = deltaR(inRef->eta(),inRef->phi(),link->globalTrack()->eta(),link->globalTrack()->phi());
        float dPt = abs(inRef->pt() - link->globalTrack()->pt())/inRef->pt();
        if (dR < 0.02 and dPt < 0.001) {
          LogTrace(category) << " *** pt matches *** ";
          switch(theType) {
            case InnerTrack:    tkRef = link->trackerTrack();    break;
            case OuterTrack:    tkRef = link->standAloneTrack(); break;
            case CombinedTrack: tkRef = link->globalTrack();     break;
            default:            tkRef = link->globalTrack();     break;
          }
        }
      }
      if (tkRef.isNull()) {
        edm::LogWarning(category) << "null reference to the linked track, reverting to old behaviour";
        tkRef = inRef;
      }
    } else {
      // theUseLinks is false
      tkRef = inRef;
    }
    LogDebug(category) << "tkRef Used For Momentum pt " << tkRef->pt() << " inRef from the input collection pt " << inRef->pt();

    Particle::Charge q = tkRef->charge();
    Particle::LorentzVector p4(tkRef->px(), tkRef->py(), tkRef->pz(), tkRef->p());
    Particle::Point vtx(tkRef->vx(),tkRef->vy(), tkRef->vz());

    int pid = 13;
    if(abs(q)==1) pid = q < 0 ? 13 : -13;
    else LogWarning(category) << "L3MuonCandidate has charge = "<<q;
    RecoChargedCandidate cand(q, p4, vtx, pid);

    //set the inRef as the RecoChargedCandidate ref so that the isolation maps
    //work in downstream filters
    cand.setTrack(inRef);
    candidates->push_back(cand);
  }

  event.put(candidates);

  LogTrace(category)<<" Event loaded"
                   <<"================================";
}

Member Data Documentation

edm::EDGetTokenT<reco::MuonTrackLinksCollection> L3MuonCandidateProducer::linkToken_

private

Definition at line 49 of file L3MuonCandidateProducer.h.

edm::InputTag L3MuonCandidateProducer::theL3CollectionLabel

private

Definition at line 46 of file L3MuonCandidateProducer.h.

edm::InputTag L3MuonCandidateProducer::theL3LinksLabel

private

Definition at line 47 of file L3MuonCandidateProducer.h.

enum MuonTrackType L3MuonCandidateProducer::theType

private

Definition at line 51 of file L3MuonCandidateProducer.h.

bool L3MuonCandidateProducer::theUseLinks

private

Definition at line 52 of file L3MuonCandidateProducer.h.

edm::EDGetTokenT<reco::TrackCollection> L3MuonCandidateProducer::trackToken_

private

Definition at line 48 of file L3MuonCandidateProducer.h.