#include <RecoEgamma/EgammaHLTProducers/interface/EgammaHLTElectronDetaDphiProducer.h>

Inheritance diagram for EgammaHLTElectronDetaDphiProducer:

Public Member Functions
void	beginRun (edm::Run const &, edm::EventSetup const &) override

	EgammaHLTElectronDetaDphiProducer (const edm::ParameterSet &)

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

	~EgammaHLTElectronDetaDphiProducer ()

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)

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

	ProducerBase ()

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 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
std::pair< float, float >	calDEtaDPhiSCTrk (reco::ElectronRef &eleref, const reco::BeamSpot::Point &BSPosition, const MagneticField *magField)

Static Private Member Functions
static reco::ElectronRef	getEleRef (const reco::RecoEcalCandidateRef &recoEcalCandRef, const edm::Handle< reco::ElectronCollection > &electronHandle)

Private Attributes
const edm::EDGetTokenT< reco::BeamSpot >	bsProducer_

const edm::EDGetTokenT< reco::ElectronCollection >	electronProducer_

const MagneticField *	magField_

const edm::EDGetTokenT< reco::RecoEcalCandidateCollection >	recoEcalCandidateProducer_

const bool	useSCRefs_

const bool	useTrackProjectionToEcal_

const bool	variablesAtVtx_

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

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

Author: Roberto Covarelli (CERN)

Id: EgammaHLTElectronDetaDphiProducer.cc,v 1.8 2012/03/29 14:15:04 sani Exp

Author: Roberto Covarelli (CERN)

Id: EgammaHLTGsfTrackVarProducer.cc,v 1.1 2012/01/23 12:56:38 sharper Exp

Definition at line 37 of file EgammaHLTElectronDetaDphiProducer.h.

Constructor & Destructor Documentation

EgammaHLTElectronDetaDphiProducer::EgammaHLTElectronDetaDphiProducer ( const edm::ParameterSet & config )

explicit

Definition at line 31 of file EgammaHLTElectronDetaDphiProducer.cc.

References useSCRefs_.

                                                                                                  :
   electronProducer_          (consumes<reco::ElectronCollection>(config.getParameter<edm::InputTag>("electronProducer"))),
   bsProducer_                (consumes<reco::BeamSpot>(config.getParameter<edm::InputTag>("BSProducer"))),
   recoEcalCandidateProducer_ (consumes<reco::RecoEcalCandidateCollection>(config.getParameter<edm::InputTag>("recoEcalCandidateProducer"))),
   useSCRefs_                 (config.getParameter<bool>("useSCRefs")),
   useTrackProjectionToEcal_  (config.getParameter<bool>("useTrackProjectionToEcal")),
   variablesAtVtx_            (config.getParameter<bool>("variablesAtVtx")) {
 
   //register your products
   if(!useSCRefs_){
     produces < reco::ElectronIsolationMap >( "Deta" ).setBranchAlias( "deta" );
     produces < reco::ElectronIsolationMap >( "Dphi" ).setBranchAlias( "dphi" ); 
   }else{
     produces < reco::RecoEcalCandidateIsolationMap >( "Deta" ).setBranchAlias( "deta" );
     produces < reco::RecoEcalCandidateIsolationMap >( "Dphi" ).setBranchAlias( "dphi" ); 
   }
 }

EgammaHLTElectronDetaDphiProducer::~EgammaHLTElectronDetaDphiProducer ( )

Definition at line 49 of file EgammaHLTElectronDetaDphiProducer.cc.

50 {}

Member Function Documentation

void EgammaHLTElectronDetaDphiProducer::beginRun	(	edm::Run const &	,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Reimplemented from edm::stream::EDProducerBase.

Definition at line 178 of file EgammaHLTElectronDetaDphiProducer.cc.

References edm::EventSetup::get(), magField_, seedCreatorFromRegionConsecutiveHitsEDProducer_cff::magneticField, and edm::ESHandle< T >::product().

                                                                                            {
   using namespace edm;
 
   ESHandle<MagneticField> magneticField;
   iSetup.get<IdealMagneticFieldRecord>().get(magneticField);
   magField_ = magneticField.product();
 
 }

std::pair< float, float > EgammaHLTElectronDetaDphiProducer::calDEtaDPhiSCTrk	(	reco::ElectronRef &	eleref,
		const reco::BeamSpot::Point &	BSPosition,
		const MagneticField *	magField
	)

private

Definition at line 117 of file EgammaHLTElectronDetaDphiProducer.cc.

References ECALPositionCalculator::ecalPhi(), TrajectoryStateOnSurface::globalPosition(), TrajectoryStateOnSurface::isValid(), magField_, or, reco::TransientTrack::stateOnSurface(), HiIsolationCommonParameters_cff::track, groupFilesInBlocks::tt, useTrackProjectionToEcal_, and variablesAtVtx_.

Referenced by produce().

                                                                                                                                                                    {
 
   const reco::SuperClusterRef theClus = eleref->superCluster();
   const math::XYZVector trackMom =  eleref->track()->momentum();
   
   math::XYZPoint SCcorrPosition(theClus->x()-bsPosition.x(), theClus->y()-bsPosition.y() , theClus->z()-eleref->track()->vz() );
   float deltaeta = fabs(SCcorrPosition.eta()-eleref->track()->eta());
   float deltaphi = 999.;
   
   bool recoveryForFailingPropagation = false;
   if (variablesAtVtx_) {
     reco::TrackRef track = eleref->track();
     reco::TransientTrack tt(track, magField_);
     TrajectoryStateOnSurface sclTSOS = tt.stateOnSurface(GlobalPoint(theClus->x(),theClus->y(),theClus->z()));
 
     if (sclTSOS.isValid()) {
       EleRelPointPair scAtVtx(theClus->position(), sclTSOS.globalPosition(), bsPosition);
       deltaeta = fabs(scAtVtx.dEta());
       deltaphi = fabs(scAtVtx.dPhi());
     } else {
       recoveryForFailingPropagation = true;
     }
   } else if (useTrackProjectionToEcal_ or recoveryForFailingPropagation) { 
     ECALPositionCalculator posCalc;
     const math::XYZPoint vertex(bsPosition.x(),bsPosition.y(),eleref->track()->vz());
     
     float phi1= posCalc.ecalPhi(magField,trackMom,vertex,1);
     float phi2= posCalc.ecalPhi(magField,trackMom,vertex,-1);
     
     float deltaphi1=fabs( phi1 - theClus->position().phi() );
     if(deltaphi1>6.283185308) deltaphi1 -= 6.283185308;
     if(deltaphi1>3.141592654) deltaphi1 = 6.283185308-deltaphi1;
 
     float deltaphi2=fabs( phi2 - theClus->position().phi() );
     if(deltaphi2>6.283185308) deltaphi2 -= 6.283185308;
     if(deltaphi2>3.141592654) deltaphi2 = 6.283185308-deltaphi2;
     
     deltaphi = deltaphi1;
     if(deltaphi2<deltaphi1){ deltaphi = deltaphi2;}
   } else {
     deltaphi=fabs(eleref->track()->outerPosition().phi()-theClus->phi());
     if(deltaphi>6.283185308) deltaphi -= 6.283185308;
     if(deltaphi>3.141592654) deltaphi = 6.283185308-deltaphi;  
   }
   
   return std::make_pair(deltaeta,deltaphi);  
 }

void EgammaHLTElectronDetaDphiProducer::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 52 of file EgammaHLTElectronDetaDphiProducer.cc.

References edm::ConfigurationDescriptions::add(), and edm::ParameterSetDescription::add().

                                                                                                    {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>(("electronProducer"), edm::InputTag("hltEleAnyWP80PixelMatchElectronsL1Seeded"));
   desc.add<edm::InputTag>(("BSProducer"), edm::InputTag("hltOnlineBeamSpot"));
   desc.add<edm::InputTag>(("recoEcalCandidateProducer"), edm::InputTag()); 
   desc.add<bool>(("useSCRefs"), false);
   desc.add<bool>(("useTrackProjectionToEcal"), false);
   desc.add<bool>(("variablesAtVtx"), true);
   descriptions.add(("hltEgammaHLTElectronDetaDphiProducer"), desc);  
 }

reco::ElectronRef EgammaHLTElectronDetaDphiProducer::getEleRef	(	const reco::RecoEcalCandidateRef &	recoEcalCandRef,
		const edm::Handle< reco::ElectronCollection > &	electronHandle
	)

staticprivate

Definition at line 165 of file EgammaHLTElectronDetaDphiProducer.cc.

Referenced by produce().

 {
   reco::ElectronRef eleRef;
   for(reco::ElectronCollection::const_iterator eleIt = electronHandle->begin(); eleIt != electronHandle->end(); eleIt++){
     if(eleIt->superCluster()==recoEcalCandRef->superCluster()){
       eleRef = reco::ElectronRef(electronHandle,eleIt - electronHandle->begin());
       break;
     }
   }
   return eleRef;
 }

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

override

Definition at line 63 of file EgammaHLTElectronDetaDphiProducer.cc.

References bsProducer_, calDEtaDPhiSCTrk(), electronProducer_, edm::EventSetup::get(), edm::Event::getByToken(), getEleRef(), edm::AssociationMap< Tag >::insert(), reco::BeamSpot::position(), edm::ESHandle< T >::product(), edm::Event::put(), recoEcalCandidateProducer_, and useSCRefs_.

                                                                                              {
   // Get the HLT filtered objects
   edm::Handle<reco::ElectronCollection> electronHandle;
   iEvent.getByToken(electronProducer_,electronHandle);
   
   edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
   iEvent.getByToken(bsProducer_,recoBeamSpotHandle);
   // gets its position
   const reco::BeamSpot::Point& bsPosition = recoBeamSpotHandle->position(); 
 
   edm::ESHandle<MagneticField> theMagField;
   iSetup.get<IdealMagneticFieldRecord>().get(theMagField);
 
   reco::ElectronIsolationMap detaMap(electronHandle);
   reco::ElectronIsolationMap dphiMap(electronHandle);
   
   if(!useSCRefs_){
 
     for(reco::ElectronCollection::const_iterator iElectron = electronHandle->begin(); iElectron != electronHandle->end(); iElectron++){
   
       reco::ElectronRef eleref(reco::ElectronRef(electronHandle,iElectron - electronHandle->begin()));
       std::pair<float,float> dEtaDPhi = calDEtaDPhiSCTrk(eleref,bsPosition,theMagField.product());
       
       detaMap.insert(eleref, dEtaDPhi.first);
       dphiMap.insert(eleref, dEtaDPhi.second);
     }
   }else { //we loop over reco ecal candidates
      edm::Handle<reco::RecoEcalCandidateCollection> recoEcalCandHandle;
      iEvent.getByToken(recoEcalCandidateProducer_,recoEcalCandHandle);
      reco::RecoEcalCandidateIsolationMap detaCandMap(recoEcalCandHandle);
      reco::RecoEcalCandidateIsolationMap dphiCandMap(recoEcalCandHandle);
 
      for(reco::RecoEcalCandidateCollection::const_iterator iRecoEcalCand = recoEcalCandHandle->begin(); iRecoEcalCand != recoEcalCandHandle->end(); iRecoEcalCand++){
     
        reco::RecoEcalCandidateRef recoEcalCandRef(recoEcalCandHandle,iRecoEcalCand-recoEcalCandHandle->begin());
     
        reco::ElectronRef eleRef = getEleRef(recoEcalCandRef,electronHandle);
        std::pair<float,float> dEtaDPhi(999999,999999);
        if(eleRef.isNonnull()) dEtaDPhi =  calDEtaDPhiSCTrk(eleRef,bsPosition,theMagField.product());
        detaCandMap.insert(recoEcalCandRef, dEtaDPhi.first);
        dphiCandMap.insert(recoEcalCandRef, dEtaDPhi.second);
      }//end loop over reco ecal candidates
 
     iEvent.put(std::make_unique<reco::RecoEcalCandidateIsolationMap>(detaCandMap), "Deta" );
     iEvent.put(std::make_unique<reco::RecoEcalCandidateIsolationMap>(dphiCandMap), "Dphi" );
 
   }//end if between electrons or reco ecal candidates
 
   if(!useSCRefs_){
     iEvent.put(std::make_unique<reco::ElectronIsolationMap>(detaMap), "Deta" );
     iEvent.put(std::make_unique<reco::ElectronIsolationMap>(dphiMap), "Dphi" );
   }
 }