#include <SoftPFMuonTagInfoProducer.h>

Inheritance diagram for SoftPFMuonTagInfoProducer:

Public Member Functions
	SoftPFMuonTagInfoProducer (const edm::ParameterSet &conf)

	~SoftPFMuonTagInfoProducer ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

	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 Member Functions
virtual float	boostedPPar (const math::XYZVector &, const math::XYZVector &)

virtual void	produce (edm::Event &, const edm::EventSetup &)

Private Attributes
float	IPsigcut

edm::EDGetTokenT< edm::View < reco::Jet > >	jetToken

edm::EDGetTokenT< edm::View < reco::Muon > >	muonToken

float	pTcut

float	ratio1cut

float	ratio2cut

float	SIPsigcut

bool	useFilter

edm::EDGetTokenT < reco::VertexCollection >	vertexToken

Additional Inherited Members
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
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 29 of file SoftPFMuonTagInfoProducer.h.

Constructor & Destructor Documentation

SoftPFMuonTagInfoProducer::SoftPFMuonTagInfoProducer ( const edm::ParameterSet & conf )

Definition at line 36 of file SoftPFMuonTagInfoProducer.cc.

References edm::ParameterSet::getParameter(), IPsigcut, jetToken, muonToken, pTcut, ratio1cut, ratio2cut, SIPsigcut, useFilter, and vertexToken.

                                                                                 {
   jetToken    = consumes<edm::View<reco::Jet> >(conf.getParameter<edm::InputTag>("jets"));
   muonToken   = consumes<edm::View<reco::Muon> >(conf.getParameter<edm::InputTag>("muons"));
   vertexToken = consumes<reco::VertexCollection>(conf.getParameter<edm::InputTag>("primaryVertex"));
   pTcut       = conf.getParameter<double>("muonPt");
   SIPsigcut      = conf.getParameter<double>("muonSIPsig");
   IPsigcut       = conf.getParameter<double>("filterIpsig");
   ratio1cut   = conf.getParameter<double>("filterRatio1");
   ratio2cut   = conf.getParameter<double>("filterRatio2");
   useFilter   = conf.getParameter<bool>("filterPromptMuons");
   produces<reco::CandSoftLeptonTagInfoCollection>();
 }

SoftPFMuonTagInfoProducer::~SoftPFMuonTagInfoProducer ( )

Definition at line 49 of file SoftPFMuonTagInfoProducer.cc.

49 {}

Member Function Documentation

float SoftPFMuonTagInfoProducer::boostedPPar	(	const math::XYZVector &	vector,
		const math::XYZVector &	axis
	)

privatevirtual

Definition at line 156 of file SoftPFMuonTagInfoProducer.cc.

References metsig::jet.

Referenced by produce().

                                                                                                    {
   static const double lepton_mass = 0.00;       // assume a massless (ultrarelativistic) lepton
   static const double jet_mass    = 5.279;      // use B±/B0 mass as the jet rest mass [PDG 2007 updates]
   ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> > lepton(vector.Dot(axis) / axis.r(), ROOT::Math::VectorUtil::Perp(vector, axis), 0., lepton_mass);
   ROOT::Math::LorentzVector<ROOT::Math::PxPyPzM4D<double> > jet( axis.r(), 0., 0., jet_mass );
   ROOT::Math::BoostX boost( -jet.Beta() );
   return boost(lepton).x();
 }

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

privatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 51 of file SoftPFMuonTagInfoProducer.cc.

References funct::abs(), boostedPPar(), TransientTrackBuilder::build(), reco::CompositePtrCandidate::daughterPtr(), reco::deltaR(), dot(), edm::EventSetup::get(), edm::Ptr< T >::get(), edm::Ref< C, T, F >::get(), edm::Event::getByToken(), reco::Muon::innerTrack(), reco::TemplatedSoftLeptonTagInfo< REF >::insert(), IPsigcut, muon::isLooseMuon(), edm::HandleBase::isValid(), jetToken, cmsBatch::log, mag(), reco::LeafCandidate::momentum(), metsig::muon, reco::PFCandidate::muonRef(), muonToken, NULL, reco::CompositePtrCandidate::numberOfDaughters(), pat::PATObject< ObjectType >::originalObjectRef(), reco::LeafCandidate::p4(), edm::ESHandle< class >::product(), reco::LeafCandidate::pt(), pTcut, edm::Event::put(), reco::LeafCandidate::px(), reco::LeafCandidate::py(), reco::LeafCandidate::pz(), dttmaxenums::R, ratio1cut, ratio2cut, reco::JetTagInfo::setJetRef(), IPTools::signedImpactParameter3D(), IPTools::signedTransverseImpactParameter(), Measurement1D::significance(), SIPsigcut, dumpRecoGeometry_cfg::tagInfo, useFilter, Measurement1D::value(), and vertexToken.

                                                                                      {
   // Declare produced collection
   std::auto_ptr<reco::CandSoftLeptonTagInfoCollection> theMuonTagInfo(new reco::CandSoftLeptonTagInfoCollection);
   
   // Declare and open Jet collection
   edm::Handle<edm::View<reco::Jet> > theJetCollection;
   iEvent.getByToken(jetToken, theJetCollection);
   
   // Declare Muon collection
   edm::Handle<edm::View<reco::Muon> > theMuonCollection;
   iEvent.getByToken(muonToken, theMuonCollection);
   
   // Declare and open Vertex collection
   edm::Handle<reco::VertexCollection> theVertexCollection;
   iEvent.getByToken(vertexToken, theVertexCollection);
   if(!theVertexCollection.isValid() || theVertexCollection->empty()) return;
   const reco::Vertex* vertex=&theVertexCollection->front();
   
   // Biult TransientTrackBuilder
   edm::ESHandle<TransientTrackBuilder> theTrackBuilder;
   iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", theTrackBuilder);
   const TransientTrackBuilder* transientTrackBuilder=theTrackBuilder.product();
   
   // Loop on jets
   for(unsigned int ij=0, nj=theJetCollection->size(); ij<nj; ij++) {
     edm::RefToBase<reco::Jet> jetRef = theJetCollection->refAt(ij);
     // Build TagInfo object
     reco::CandSoftLeptonTagInfo tagInfo;
     tagInfo.setJetRef(jetRef);
     // Loop on jet daughters
     for(unsigned int id=0, nd=jetRef->numberOfDaughters(); id<nd; ++id) {
       edm::Ptr<reco::Candidate> lepPtr = jetRef->daughterPtr(id);
       if(std::abs(lepPtr->pdgId())!=13) continue;
       
       const reco::Muon* muon(NULL);
       // Step 1: try to access the muon from reco::PFCandidate
       const reco::PFCandidate* pfcand=dynamic_cast<const reco::PFCandidate*>(lepPtr.get());
       if(pfcand) {
         muon=pfcand->muonRef().get();
       }
       // If not PFCandidate is available, find a match looping on the muon collection
       else {
         for(unsigned int im=0, nm=theMuonCollection->size(); im<nm; ++im) { // --- Begin loop on muons
           const reco::Muon* recomuon=&theMuonCollection->at(im);
           const pat::Muon* patmuon=dynamic_cast<const pat::Muon*>(recomuon);
           // Step 2: try a match between reco::Candidate
           if(patmuon) {
             if(patmuon->originalObjectRef()==lepPtr) {
               muon=theMuonCollection->refAt(im).get();
               break;
             }
           }
           // Step 3: try a match with dR and dpT if pat::Muon casting fails
           else {
             if(reco::deltaR(*recomuon, *lepPtr)<0.01 && std::abs(recomuon->pt()-lepPtr->pt())/lepPtr->pt()<0.1) {
               muon=theMuonCollection->refAt(im).get();
               break;
             }
           }
         } // --- End loop on muons
       }
       if(!muon || !muon::isLooseMuon(*muon) || muon->pt()<pTcut) continue;
       reco::TrackRef trkRef( muon->innerTrack() );
       reco::TrackBaseRef trkBaseRef( trkRef );
       // Build Transient Track
       reco::TransientTrack transientTrack=transientTrackBuilder->build(trkRef);
       // Define jet and muon vectors
       reco::Candidate::Vector jetvect(jetRef->p4().Vect()), muonvect(muon->p4().Vect());
       // Calculate variables
       reco::SoftLeptonProperties properties;
       Measurement1D ip2d    = IPTools::signedTransverseImpactParameter(transientTrack, GlobalVector(jetRef->px(), jetRef->py(), jetRef->pz()), *vertex).second;
       Measurement1D ip3d    = IPTools::signedImpactParameter3D(transientTrack, GlobalVector(jetRef->px(), jetRef->py(), jetRef->pz()), *vertex).second;
       properties.sip2dsig    = ip2d.significance();
       properties.sip3dsig    = ip3d.significance();
       properties.sip2d    = ip2d.value();
       properties.sip3d    = ip3d.value();
       properties.deltaR   = reco::deltaR(*jetRef, *muon);
       properties.ptRel    = ( (jetvect-muonvect).Cross(muonvect) ).R() / jetvect.R(); // | (Pj-Pu) X Pu | / | Pj |
       float mag = muonvect.R()*jetvect.R();
       float dot = muon->p4().Dot(jetRef->p4());
       properties.etaRel   = -log((mag - dot)/(mag + dot)) / 2.;
       properties.ratio    = muon->pt() / jetRef->pt();
       properties.ratioRel = muon->p4().Dot(jetRef->p4()) / jetvect.Mag2();
       properties.p0Par    = boostedPPar(muon->momentum(), jetRef->momentum());
       
       if(std::abs(properties.sip3dsig)>SIPsigcut) continue;
       
       // Filter leptons from W, Z decays
       if(useFilter && ((std::abs(properties.sip3dsig)<IPsigcut && properties.ratio>ratio1cut) || properties.ratio>ratio2cut)) continue;
       
       // Insert lepton properties
       tagInfo.insert(lepPtr, properties);
       
     } // --- End loop on daughters
     
     // Fill the TagInfo collection
     theMuonTagInfo->push_back(tagInfo);
   } // --- End loop on jets
   
   // Put the TagInfo collection in the event
   iEvent.put(theMuonTagInfo);
 }