#include <SoftPFElectronTagInfoProducer.h>

Inheritance diagram for SoftPFElectronTagInfoProducer:

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

	~SoftPFElectronTagInfoProducer ()

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

bool	isElecClean (edm::Event &, const reco::GsfElectron *)

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

Private Attributes
float	DeltaRElectronJet

bool	goodvertex

float	MaxSip3Dsig

edm::EDGetTokenT < reco::ConversionCollection >	token_allConversions

edm::EDGetTokenT< reco::BeamSpot >	token_BeamSpot

edm::EDGetTokenT< edm::View < reco::GsfElectron > >	token_elec

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

edm::EDGetTokenT < reco::VertexCollection >	token_primaryVertex

const TransientTrackBuilder *	transientTrackBuilder

const reco::Vertex *	vertex

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 30 of file SoftPFElectronTagInfoProducer.h.

Constructor & Destructor Documentation

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

Definition at line 30 of file SoftPFElectronTagInfoProducer.cc.

References DeltaRElectronJet, edm::ParameterSet::getParameter(), HLT_25ns14e33_v1_cff::InputTag, MaxSip3Dsig, token_allConversions, token_BeamSpot, token_elec, token_jets, and token_primaryVertex.

 {
     token_jets          = consumes<edm::View<reco::Jet> >(conf.getParameter<edm::InputTag>("jets"));
     token_elec          = consumes<edm::View<reco::GsfElectron> >(conf.getParameter<edm::InputTag>("electrons"));
     token_primaryVertex = consumes<reco::VertexCollection>(conf.getParameter<edm::InputTag>("primaryVertex"));
     token_BeamSpot      = consumes<reco::BeamSpot>(edm::InputTag("offlineBeamSpot"));
     token_allConversions= consumes<reco::ConversionCollection>(edm::InputTag("allConversions"));
     DeltaRElectronJet   = conf.getParameter<double>("DeltaRElectronJet");
     MaxSip3Dsig            = conf.getParameter<double>("MaxSip3Dsig");
         produces<reco::CandSoftLeptonTagInfoCollection>();
 }

SoftPFElectronTagInfoProducer::~SoftPFElectronTagInfoProducer ( )

Definition at line 42 of file SoftPFElectronTagInfoProducer.cc.

 {
 
 }

Member Function Documentation

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

private

Definition at line 139 of file SoftPFElectronTagInfoProducer.cc.

References metsig::jet.

Referenced by produce().

                                                                                                        {
     static const double lepton_mass = 0.00; 
     static const double jet_mass    = 5.279; 
     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();
 }

bool SoftPFElectronTagInfoProducer::isElecClean	(	edm::Event &	iEvent,
		const reco::GsfElectron *	candidate
	)

private

Definition at line 125 of file SoftPFElectronTagInfoProducer.cc.

References edm::Ref< C, T, F >::get(), reco::GsfElectron::gsfTrack(), and dt_dqm_sourceclient_common_cff::reco.

Referenced by produce().

 {
     using namespace reco;
     const HitPattern &hitPattern = candidate->gsfTrack().get()->hitPattern();
     uint32_t hit = hitPattern.getHitPattern(HitPattern::TRACK_HITS, 0);
     bool hitCondition = !(HitPattern::validHitFilter(hit) 
             && ((HitPattern::pixelBarrelHitFilter(hit) 
                         && HitPattern::getLayer(hit) < 3) 
                     || HitPattern::pixelEndcapHitFilter(hit))); 
     if(hitCondition) return false;
 
     return true;
 }

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

privatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 47 of file SoftPFElectronTagInfoProducer.cc.

 {
     std::auto_ptr<reco::CandSoftLeptonTagInfoCollection> theElecTagInfo(new reco::CandSoftLeptonTagInfoCollection);
     edm::ESHandle<TransientTrackBuilder> builder;
     iSetup.get<TransientTrackRecord>().get("TransientTrackBuilder", builder);
     transientTrackBuilder=builder.product();
  
     edm::Handle<reco::VertexCollection> PVCollection;
     iEvent.getByToken(token_primaryVertex, PVCollection);
     if(!PVCollection.isValid()) return;
     if(!PVCollection->empty()){
         goodvertex = true;
         vertex=&PVCollection->front();
     }else goodvertex = false; 
     edm::Handle<reco::ConversionCollection> hConversions;
     iEvent.getByToken(token_allConversions, hConversions);
  
     edm::Handle<edm::View<reco::Jet> > theJetCollection;
     iEvent.getByToken(token_jets, theJetCollection);
 
     edm::Handle<edm::View<reco::GsfElectron > > theGEDGsfElectronCollection;
     iEvent.getByToken(token_elec, theGEDGsfElectronCollection);
 
     edm::Handle<reco::BeamSpot> bsHandle;
     iEvent.getByToken(token_BeamSpot, bsHandle);
     const reco::BeamSpot &beamspot = *bsHandle.product();
 
      for (unsigned int i = 0; i < theJetCollection->size(); i++){
             edm::RefToBase<reco::Jet> jetRef = theJetCollection->refAt(i);
         reco::CandSoftLeptonTagInfo tagInfo;
                 tagInfo.setJetRef(jetRef);
             std::vector<const reco::GsfElectron *> Elec;
         for(unsigned int ie=0, ne=theGEDGsfElectronCollection->size(); ie<ne; ++ie){
             //Get the edm::Ptr and the GsfElectron
             edm::Ptr<reco::Candidate> lepPtr=theGEDGsfElectronCollection->ptrAt(ie);
             const reco::GsfElectron* recoelectron=theGEDGsfElectronCollection->refAt(ie).get();
             const pat::Electron* patelec=dynamic_cast<const pat::Electron*>(recoelectron);
             if(patelec){
                 if(!patelec->passConversionVeto()) continue;
             }
             else{
                 if(ConversionTools::hasMatchedConversion(*(recoelectron),hConversions,beamspot.position())) continue;
             }
             //Make sure that the electron is inside the jet
             if(reco::deltaR2((*recoelectron),(*jetRef))>DeltaRElectronJet*DeltaRElectronJet) continue;
             // Need a gsfTrack
             if(recoelectron->gsfTrack().get()==NULL) continue;
             reco::SoftLeptonProperties properties;
             // reject if it has issues with the track
             if(!isElecClean(iEvent,recoelectron) ) continue;
             //Compute the TagInfos members
             math::XYZVector pel=recoelectron->p4().Vect();
             math::XYZVector pjet=jetRef->p4().Vect();
             reco::TransientTrack transientTrack=transientTrackBuilder->build(recoelectron->gsfTrack());
             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), (*recoelectron));
             properties.ptRel    = ( (pjet-pel).Cross(pel) ).R() / pjet.R();
             float mag = pel.R()*pjet.R();
             float dot = recoelectron->p4().Dot(jetRef->p4());
             properties.etaRel   = -log((mag - dot)/(mag + dot)) / 2.;
             properties.ratio    = recoelectron->pt() / jetRef->pt();
             properties.ratioRel = recoelectron->p4().Dot(jetRef->p4()) / pjet.Mag2();
             properties.p0Par    = boostedPPar(recoelectron->momentum(), jetRef->momentum());
             properties.elec_mva    = recoelectron->mva_e_pi();
             if(std::abs(properties.sip3dsig)>MaxSip3Dsig) continue;
             // Fill the TagInfos
             tagInfo.insert(lepPtr, properties );
         }
         theElecTagInfo->push_back(tagInfo);
     }
     iEvent.put(theElecTagInfo);
 }