#include <EgammaHLTGsfTrackVarProducer.h>

Inheritance diagram for EgammaHLTGsfTrackVarProducer:

Classes
class	TrackExtrapolator

Public Member Functions
	EgammaHLTGsfTrackVarProducer (const edm::ParameterSet &)

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

	~EgammaHLTGsfTrackVarProducer ()

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 &	itemsToGetFromEvent () 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 Attributes
const edm::EDGetTokenT < reco::BeamSpot >	beamSpotTag_

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

const edm::EDGetTokenT < reco::GsfTrackCollection >	inputCollectionTag2_

const int	lowerTrackNrToRemoveCut_

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

TrackExtrapolator	trackExtrapolator_

const int	upperTrackNrToRemoveCut_

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

Definition at line 41 of file EgammaHLTGsfTrackVarProducer.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 33 of file EgammaHLTGsfTrackVarProducer.cc.

                                                                                        :
   recoEcalCandTag_         (consumes<reco::RecoEcalCandidateCollection>(config.getParameter<edm::InputTag>("recoEcalCandidateProducer"))),
   inputCollectionTag1_     (consumes<reco::ElectronCollection>(config.getParameter<edm::InputTag>("inputCollection"))),
   inputCollectionTag2_     (consumes<reco::GsfTrackCollection>(config.getParameter<edm::InputTag>("inputCollection"))),
   beamSpotTag_             (consumes<reco::BeamSpot>(config.getParameter<edm::InputTag>("beamSpotProducer"))),
   upperTrackNrToRemoveCut_ (config.getParameter<int>("upperTrackNrToRemoveCut")),
   lowerTrackNrToRemoveCut_ (config.getParameter<int>("lowerTrackNrToRemoveCut")) {
  
   //register your products
   produces < reco::RecoEcalCandidateIsolationMap >( "Deta" ).setBranchAlias( "deta" );
   produces < reco::RecoEcalCandidateIsolationMap >( "DetaSeed" ).setBranchAlias( "detaseed" );
   produces < reco::RecoEcalCandidateIsolationMap >( "Dphi" ).setBranchAlias( "dphi" );
   produces < reco::RecoEcalCandidateIsolationMap >( "OneOESuperMinusOneOP" );
   produces < reco::RecoEcalCandidateIsolationMap >( "OneOESeedMinusOneOP" );
   produces < reco::RecoEcalCandidateIsolationMap >( "MissingHits" ).setBranchAlias( "missinghits" );
   produces < reco::RecoEcalCandidateIsolationMap >( "Chi2" ).setBranchAlias( "chi2" );
   produces < reco::RecoEcalCandidateIsolationMap >( "ValidHits" ).setBranchAlias( "validhits" );
 }

EgammaHLTGsfTrackVarProducer::~EgammaHLTGsfTrackVarProducer ( )

Definition at line 52 of file EgammaHLTGsfTrackVarProducer.cc.

53 {}

Member Function Documentation

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

static

Definition at line 55 of file EgammaHLTGsfTrackVarProducer.cc.

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

                                                                                               {
   edm::ParameterSetDescription desc;
   desc.add<edm::InputTag>(("recoEcalCandidateProducer"), edm::InputTag("hltRecoEcalSuperClusterActivityCandidate"));
   desc.add<edm::InputTag>(("inputCollection"), edm::InputTag("hltActivityElectronGsfTracks"));
   desc.add<edm::InputTag>(("beamSpotProducer"), edm::InputTag("hltOnlineBeamSpot"));
   desc.add<int>(("upperTrackNrToRemoveCut"), 9999); 
   desc.add<int>(("lowerTrackNrToRemoveCut"), -1);
   descriptions.add("hltEgammaHLTGsfTrackVarProducer", desc);
 }

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

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 64 of file EgammaHLTGsfTrackVarProducer.cc.

References SiPixelRawToDigiRegional_cfi::beamSpot, beamSpotTag_, edm::RefToBase< T >::castTo(), EgammaHLTGsfTrackVarProducer::TrackExtrapolator::extrapolateTrackPosToPoint(), edm::EventSetup::get(), edm::Event::getByToken(), inputCollectionTag1_, inputCollectionTag2_, edm::AssociationMap< Tag >::insert(), edm::HandleBase::isValid(), lowerTrackNrToRemoveCut_, reco::HitPattern::MISSING_INNER_HITS, eostools::move(), TrackCollections2monitor_cff::numberOfValidHits, reco::BeamSpot::position(), edm::Event::put(), recoEcalCandTag_, fileCollector::seed, EgammaHLTGsfTrackVarProducer::TrackExtrapolator::setup(), trackExtrapolator_, and upperTrackNrToRemoveCut_.

                                                                                         {
 
   trackExtrapolator_.setup(iSetup);
   
   // Get the HLT filtered objects
   edm::Handle<reco::RecoEcalCandidateCollection> recoEcalCandHandle;
   iEvent.getByToken(recoEcalCandTag_,recoEcalCandHandle);
 
   edm::Handle<reco::ElectronCollection> electronHandle;
   iEvent.getByToken(inputCollectionTag1_,electronHandle);
 
   edm::Handle<reco::GsfTrackCollection> gsfTracksHandle;
   if(!electronHandle.isValid()) 
     iEvent.getByToken(inputCollectionTag2_, gsfTracksHandle);
 
   edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
   iEvent.getByToken(beamSpotTag_,recoBeamSpotHandle);
   // gets its position
   const reco::BeamSpot& beamSpot = *recoBeamSpotHandle; 
 
   edm::ESHandle<MagneticField> theMagField;
   iSetup.get<IdealMagneticFieldRecord>().get(theMagField);
 
   reco::RecoEcalCandidateIsolationMap dEtaMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap dEtaSeedMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap dPhiMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap oneOverESuperMinusOneOverPMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap oneOverESeedMinusOneOverPMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap missingHitsMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap validHitsMap(recoEcalCandHandle);
   reco::RecoEcalCandidateIsolationMap chi2Map(recoEcalCandHandle);
 
   for(reco::RecoEcalCandidateCollection::const_iterator iRecoEcalCand = recoEcalCandHandle->begin(); iRecoEcalCand != recoEcalCandHandle->end(); iRecoEcalCand++){
     reco::RecoEcalCandidateRef recoEcalCandRef(recoEcalCandHandle,iRecoEcalCand-recoEcalCandHandle->begin());
    
     const reco::SuperClusterRef scRef = recoEcalCandRef->superCluster();
    
     //the idea is that we can take the tracks from properly associated electrons or just take all gsf tracks with that sc as a seed
     std::vector<const reco::GsfTrack*> gsfTracks;
     if(electronHandle.isValid()){
       for(reco::ElectronCollection::const_iterator eleIt = electronHandle->begin(); eleIt != electronHandle->end(); eleIt++){
     if(eleIt->superCluster()==scRef){
       gsfTracks.push_back(&*eleIt->gsfTrack());
     }
       }
     }else{ 
       for(reco::GsfTrackCollection::const_iterator trkIt =gsfTracksHandle->begin();trkIt!=gsfTracksHandle->end();++trkIt){
     edm::RefToBase<TrajectorySeed> seed = trkIt->extra()->seedRef() ;
     reco::ElectronSeedRef elseed = seed.castTo<reco::ElectronSeedRef>() ;
     edm::RefToBase<reco::CaloCluster> caloCluster = elseed->caloCluster() ;
     reco::SuperClusterRef scRefFromTrk = caloCluster.castTo<reco::SuperClusterRef>() ;
     if(scRefFromTrk==scRef){
       gsfTracks.push_back(&*trkIt);
     }
       }
       
     }
 
     int validHitsValue = 9999999;
     float chi2Value = 9999999.;
     float missingHitsValue = 9999999;
     float dEtaInValue=999999;
     float dEtaSeedInValue=999999;
     float dPhiInValue=999999;
     float oneOverESuperMinusOneOverPValue=999999;
     float oneOverESeedMinusOneOverPValue=999999;
     
     if(static_cast<int>(gsfTracks.size())>=upperTrackNrToRemoveCut_){
       dEtaInValue=0;
       dEtaSeedInValue=0;
       dPhiInValue=0;
       missingHitsValue = 0;
       validHitsValue = 0;
       chi2Value = 0;
     }else if(static_cast<int>(gsfTracks.size())<=lowerTrackNrToRemoveCut_){
       dEtaInValue=0;
       dEtaSeedInValue=0;
       dPhiInValue=0;
       missingHitsValue = 0;
       validHitsValue = 0;
       chi2Value = 0;
     }else{
       for(size_t trkNr=0;trkNr<gsfTracks.size();trkNr++){
       
     GlobalPoint scPos(scRef->x(),scRef->y(),scRef->z());
     GlobalPoint trackExtrapToSC = trackExtrapolator_.extrapolateTrackPosToPoint(*gsfTracks[trkNr],scPos);
     EleRelPointPair scAtVtx(scRef->position(),trackExtrapToSC,beamSpot.position());
     
     float trkP = gsfTracks[trkNr]->p();
     if(scRef->energy()!=0 && trkP!=0){
       if(fabs(1/scRef->energy() - 1/trkP)<oneOverESuperMinusOneOverPValue) oneOverESuperMinusOneOverPValue =fabs(1/scRef->energy() - 1/trkP);
     }
     if(scRef->seed().isNonnull() && scRef->seed()->energy()!=0 && trkP!=0){
       if(fabs(1/scRef->seed()->energy() - 1/trkP)<oneOverESeedMinusOneOverPValue) oneOverESeedMinusOneOverPValue =fabs(1/scRef->seed()->energy() - 1/trkP);
     }
 
 
     if (gsfTracks[trkNr]->hitPattern().numberOfHits(reco::HitPattern::MISSING_INNER_HITS) < missingHitsValue) 
       missingHitsValue = gsfTracks[trkNr]->hitPattern().numberOfHits(reco::HitPattern::MISSING_INNER_HITS);
     
     if (gsfTracks[trkNr]->numberOfValidHits() < validHitsValue)
       validHitsValue = gsfTracks[trkNr]->numberOfValidHits();
 
     if (gsfTracks[trkNr]->numberOfValidHits() < chi2Value)
       chi2Value = gsfTracks[trkNr]->normalizedChi2();
 
     if (fabs(scAtVtx.dEta())<dEtaInValue) 
       dEtaInValue=fabs(scAtVtx.dEta()); //we are allowing them to come from different tracks
 
     if (fabs(scAtVtx.dEta())<dEtaSeedInValue) 
       dEtaSeedInValue = fabs(scAtVtx.dEta()-scRef->position().eta()+scRef->seed()->position().eta());
 
     if (fabs(scAtVtx.dPhi())<dPhiInValue) 
       dPhiInValue=fabs(scAtVtx.dPhi());//we are allowing them to come from different tracks
       } 
     }
    
     dEtaMap.insert(recoEcalCandRef, dEtaInValue);
     dEtaSeedMap.insert(recoEcalCandRef, dEtaSeedInValue);
     dPhiMap.insert(recoEcalCandRef, dPhiInValue);
     oneOverESuperMinusOneOverPMap.insert(recoEcalCandRef,oneOverESuperMinusOneOverPValue);   
     oneOverESeedMinusOneOverPMap.insert(recoEcalCandRef,oneOverESeedMinusOneOverPValue);
     missingHitsMap.insert(recoEcalCandRef, missingHitsValue);
     validHitsMap.insert(recoEcalCandRef, validHitsValue);
     chi2Map.insert(recoEcalCandRef, chi2Value);
   }
 
   auto dEtaMapForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(dEtaMap);
   auto dEtaSeedMapForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(dEtaSeedMap);
   auto dPhiMapForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(dPhiMap);
   auto oneOverESuperMinusOneOverPMapForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(oneOverESuperMinusOneOverPMap);
   auto oneOverESeedMinusOneOverPMapForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(oneOverESeedMinusOneOverPMap);
   auto missingHitsForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(missingHitsMap);
   auto validHitsForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(validHitsMap);
   auto chi2ForEvent = std::make_unique<reco::RecoEcalCandidateIsolationMap>(chi2Map);
 
   iEvent.put(std::move(dEtaMapForEvent), "Deta" );
   iEvent.put(std::move(dEtaSeedMapForEvent), "DetaSeed" );
   iEvent.put(std::move(dPhiMapForEvent), "Dphi" );
   iEvent.put(std::move(oneOverESuperMinusOneOverPMapForEvent), "OneOESuperMinusOneOP");
   iEvent.put(std::move(oneOverESeedMinusOneOverPMapForEvent), "OneOESeedMinusOneOP");
   iEvent.put(std::move(missingHitsForEvent), "MissingHits");
   iEvent.put(std::move(validHitsForEvent), "ValidHits");
   iEvent.put(std::move(chi2ForEvent), "Chi2");
 }