#include <EgammaHLTPixelMatchElectronAlgo.h>

Public Member Functions
	EgammaHLTPixelMatchElectronAlgo (const edm::ParameterSet &conf, edm::ConsumesCollector &&iC)

void	run (edm::Event &, reco::ElectronCollection &)

void	setupES (const edm::EventSetup &setup)

	~EgammaHLTPixelMatchElectronAlgo ()

Private Member Functions
	EgammaHLTPixelMatchElectronAlgo (const EgammaHLTPixelMatchElectronAlgo &rhs)

bool	isInnerMostWithLostHits (const reco::GsfTrackRef &, const reco::GsfTrackRef &, bool &)

EgammaHLTPixelMatchElectronAlgo &	operator= (const EgammaHLTPixelMatchElectronAlgo &rhs)

void	process (edm::Handle< reco::TrackCollection > tracksH, edm::Handle< reco::GsfTrackCollection > gsfTracksH, reco::ElectronCollection &outEle, Global3DPoint &bs)

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

unsigned long long	cacheIDMagField_

int unsigned long long	cacheIDTDGeom_

edm::EDGetTokenT< reco::GsfTrackCollection >	gsfTrackProducer_

edm::ESHandle< MagneticField >	magField_

MultiTrajectoryStateTransform *	mtsTransform_

edm::ESHandle< TrackerGeometry >	trackerGeom_

edm::EDGetTokenT< reco::TrackCollection >	trackProducer_

bool	useGsfTracks_

Detailed Description

Description: top algorithm producing TrackCandidate and Electron objects from supercluster driven pixel seeded Ckf tracking for HLT

Class to reconstruct electron tracks from electron pixel seeds keep track of information about the initiating supercluster

Author: Monica Vazquez Acosta (CERN)

Definition at line 30 of file EgammaHLTPixelMatchElectronAlgo.h.

Constructor & Destructor Documentation

◆ EgammaHLTPixelMatchElectronAlgo() [1/2]

EgammaHLTPixelMatchElectronAlgo::EgammaHLTPixelMatchElectronAlgo	(	const edm::ParameterSet &	conf,
		edm::ConsumesCollector &&	iC
	)

Definition at line 49 of file EgammaHLTPixelMatchElectronAlgo.cc.

     : trackProducer_(iC.consumes<reco::TrackCollection>(conf.getParameter<edm::InputTag>("TrackProducer"))),
       gsfTrackProducer_(iC.consumes<reco::GsfTrackCollection>(conf.getParameter<edm::InputTag>("GsfTrackProducer"))),
       useGsfTracks_(conf.getParameter<bool>("UseGsfTracks")),
       bsProducer_(iC.consumes<reco::BeamSpot>(conf.getParameter<edm::InputTag>("BSProducer"))),
       mtsTransform_(nullptr),
       cacheIDTDGeom_(0),
       cacheIDMagField_(0) {}

◆ ~EgammaHLTPixelMatchElectronAlgo()

EgammaHLTPixelMatchElectronAlgo::~EgammaHLTPixelMatchElectronAlgo ( )

Definition at line 59 of file EgammaHLTPixelMatchElectronAlgo.cc.

59 { delete mtsTransform_; }

References mtsTransform_.

◆ EgammaHLTPixelMatchElectronAlgo() [2/2]

EgammaHLTPixelMatchElectronAlgo::EgammaHLTPixelMatchElectronAlgo ( const EgammaHLTPixelMatchElectronAlgo & rhs )

inlineprivate

Definition at line 38 of file EgammaHLTPixelMatchElectronAlgo.h.

38 {}

Member Function Documentation

◆ isInnerMostWithLostHits()

bool EgammaHLTPixelMatchElectronAlgo::isInnerMostWithLostHits	(	const reco::GsfTrackRef &	nGsfTrack,
		const reco::GsfTrackRef &	iGsfTrack,
		bool &	sameLayer
	)

private

Definition at line 218 of file EgammaHLTPixelMatchElectronAlgo.cc.

                                                                                {
   // define closest using the lost hits on the expectedhitsineer
   unsigned int nLostHits = nGsfTrack->hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS);
   unsigned int iLostHits = iGsfTrack->hitPattern().numberOfLostHits(HitPattern::MISSING_INNER_HITS);
  
   if (nLostHits != iLostHits) {
     return (nLostHits > iLostHits);
   } else {
     sameLayer = true;
     return false;
   }
 }

Referenced by process().

◆ operator=()

EgammaHLTPixelMatchElectronAlgo& EgammaHLTPixelMatchElectronAlgo::operator= ( const EgammaHLTPixelMatchElectronAlgo & rhs )

inlineprivate

Definition at line 39 of file EgammaHLTPixelMatchElectronAlgo.h.

39 { return *this; }

◆ process()

void EgammaHLTPixelMatchElectronAlgo::process	(	edm::Handle< reco::TrackCollection >	tracksH,
		edm::Handle< reco::GsfTrackCollection >	gsfTracksH,
		reco::ElectronCollection &	outEle,
		Global3DPoint &	bs
	)

private

Definition at line 108 of file EgammaHLTPixelMatchElectronAlgo.cc.

                                                                  {
   if (!useGsfTracks_) {
     for (unsigned int i = 0; i < tracksH->size(); ++i) {
       const TrackRef trackRef = edm::Ref<TrackCollection>(tracksH, i);
       edm::RefToBase<TrajectorySeed> seed = trackRef->extra()->seedRef();
       ElectronSeedRef elseed = seed.castTo<ElectronSeedRef>();
  
       edm::RefToBase<CaloCluster> caloCluster = elseed->caloCluster();
       SuperClusterRef scRef = caloCluster.castTo<SuperClusterRef>();
  
       // Get the momentum at vertex (not at the innermost layer)
       TSCPBuilderNoMaterial tscpBuilder;
  
       FreeTrajectoryState fts = trajectoryStateTransform::innerFreeState(*trackRef, magField_.product());
       TrajectoryStateClosestToPoint tscp = tscpBuilder(fts, bs);
  
       float scale = scRef->energy() / tscp.momentum().mag();
  
       const math::XYZTLorentzVector momentum(
           tscp.momentum().x() * scale, tscp.momentum().y() * scale, tscp.momentum().z() * scale, scRef->energy());
  
       Electron ele(trackRef->charge(), momentum, trackRef->vertex());
       ele.setSuperCluster(scRef);
       edm::Ref<TrackCollection> myRef(tracksH, i);
       ele.setTrack(myRef);
       outEle.push_back(ele);
     }  // loop over tracks
   } else {
     // clean gsf tracks
     std::vector<unsigned int> flag(gsfTracksH->size(), 0);
     if (gsfTracksH->empty())
       return;
  
     for (unsigned int i = 0; i < gsfTracksH->size() - 1; ++i) {
       const GsfTrackRef trackRef1 = edm::Ref<GsfTrackCollection>(gsfTracksH, i);
       ElectronSeedRef elseed1 = trackRef1->extra()->seedRef().castTo<ElectronSeedRef>();
       SuperClusterRef scRef1 = elseed1->caloCluster().castTo<SuperClusterRef>();
  
       TrajectoryStateOnSurface inTSOS = mtsTransform_->innerStateOnSurface((*trackRef1));
       TrajectoryStateOnSurface fts = mtsTransform_->extrapolatedState(inTSOS, bs);
       GlobalVector innMom;
       float pin1 = trackRef1->pMode();
       if (fts.isValid()) {
         multiTrajectoryStateMode::momentumFromModeCartesian(fts, innMom);
         pin1 = innMom.mag();
       }
  
       for (unsigned int j = i + 1; j < gsfTracksH->size(); ++j) {
         const GsfTrackRef trackRef2 = edm::Ref<GsfTrackCollection>(gsfTracksH, j);
         ElectronSeedRef elseed2 = trackRef2->extra()->seedRef().castTo<ElectronSeedRef>();
         SuperClusterRef scRef2 = elseed2->caloCluster().castTo<SuperClusterRef>();
  
         TrajectoryStateOnSurface inTSOS = mtsTransform_->innerStateOnSurface((*trackRef2));
         TrajectoryStateOnSurface fts = mtsTransform_->extrapolatedState(inTSOS, bs);
         GlobalVector innMom;
         float pin2 = trackRef2->pMode();
         if (fts.isValid()) {
           multiTrajectoryStateMode::momentumFromModeCartesian(fts, innMom);
           pin2 = innMom.mag();
         }
  
         if (scRef1 == scRef2) {
           bool isSameLayer = false;
           bool iGsfInnermostWithLostHits = isInnerMostWithLostHits(trackRef2, trackRef1, isSameLayer);
  
           if (iGsfInnermostWithLostHits) {
             flag[j] = 1;
           } else if (isSameLayer) {
             if (fabs((scRef1->energy() / pin1) - 1) < fabs((scRef2->energy() / pin2) - 1))
               flag[j] = 1;
           } else {
             flag[i] = 1;
           }
         }
       }
     }
  
     for (unsigned int i = 0; i < gsfTracksH->size(); ++i) {
       if (flag[i] == 1)
         continue;
  
       const GsfTrackRef trackRef = edm::Ref<GsfTrackCollection>(gsfTracksH, i);
       ElectronSeedRef elseed = trackRef->extra()->seedRef().castTo<ElectronSeedRef>();
       SuperClusterRef scRef = elseed->caloCluster().castTo<SuperClusterRef>();
  
       // Get the momentum at vertex (not at the innermost layer)
       TrajectoryStateOnSurface inTSOS = mtsTransform_->innerStateOnSurface((*trackRef));
       TrajectoryStateOnSurface fts = mtsTransform_->extrapolatedState(inTSOS, bs);
       GlobalVector innMom;
       multiTrajectoryStateMode::momentumFromModeCartesian(inTSOS, innMom);
       if (fts.isValid()) {
         multiTrajectoryStateMode::momentumFromModeCartesian(fts, innMom);
       }
  
       float scale = scRef->energy() / innMom.mag();
       const math::XYZTLorentzVector momentum(
           innMom.x() * scale, innMom.y() * scale, innMom.z() * scale, scRef->energy());
  
       Electron ele(trackRef->charge(), momentum, trackRef->vertex());
       ele.setSuperCluster(scRef);
       edm::Ref<GsfTrackCollection> myRef(gsfTracksH, i);
       ele.setGsfTrack(myRef);
       outEle.push_back(ele);
     }
   }
 }

References cms::cuda::bs, MultiTrajectoryStateTransform::extrapolatedState(), RemoveAddSevLevel::flag, mps_fire::i, trajectoryStateTransform::innerFreeState(), MultiTrajectoryStateTransform::innerStateOnSurface(), isInnerMostWithLostHits(), TrajectoryStateOnSurface::isValid(), dqmiolumiharvest::j, PV3DBase< T, PVType, FrameType >::mag(), magField_, multiTrajectoryStateMode::momentumFromModeCartesian(), mtsTransform_, edm::ESHandle< T >::product(), Scenarios_cff::scale, SurveyInfoScenario_cff::seed, useGsfTracks_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by run().

◆ run()

void EgammaHLTPixelMatchElectronAlgo::run	(	edm::Event &	e,
		reco::ElectronCollection &	outEle
	)

Definition at line 85 of file EgammaHLTPixelMatchElectronAlgo.cc.

                                                                               {
   // get the input
   edm::Handle<TrackCollection> tracksH;
   if (!useGsfTracks_)
     e.getByToken(trackProducer_, tracksH);
  
   // get the input
   edm::Handle<GsfTrackCollection> gsfTracksH;
   if (useGsfTracks_)
     e.getByToken(gsfTrackProducer_, gsfTracksH);
  
   //Get the Beam Spot position
   edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
   e.getByToken(bsProducer_, recoBeamSpotHandle);
  
   // gets its position
   const BeamSpot::Point& bsPosition = recoBeamSpotHandle->position();
   Global3DPoint bs(bsPosition.x(), bsPosition.y(), 0);
   process(tracksH, gsfTracksH, outEle, bs);
  
   return;
 }

References cms::cuda::bs, bsProducer_, MillePedeFileConverter_cfg::e, gsfTrackProducer_, reco::BeamSpot::position(), process(), trackProducer_, and useGsfTracks_.

Referenced by EgammaHLTPixelMatchElectronProducers::produce().

◆ setupES()

void EgammaHLTPixelMatchElectronAlgo::setupES ( const edm::EventSetup & setup )

Definition at line 61 of file EgammaHLTPixelMatchElectronAlgo.cc.

                                                                      {
   //services
  
   bool updateField(false);
   if (cacheIDMagField_ != es.get<IdealMagneticFieldRecord>().cacheIdentifier()) {
     updateField = true;
     cacheIDMagField_ = es.get<IdealMagneticFieldRecord>().cacheIdentifier();
     es.get<IdealMagneticFieldRecord>().get(magField_);
   }
  
   if (useGsfTracks_) {  //only need the geom and mtsTransform if we are doing gsf tracks
     bool updateGeometry(false);
     if (cacheIDTDGeom_ != es.get<TrackerDigiGeometryRecord>().cacheIdentifier()) {
       updateGeometry = true;
       cacheIDTDGeom_ = es.get<TrackerDigiGeometryRecord>().cacheIdentifier();
       es.get<TrackerDigiGeometryRecord>().get(trackerGeom_);
     }
     if (updateField || updateGeometry || !mtsTransform_) {
       delete mtsTransform_;
       mtsTransform_ = new MultiTrajectoryStateTransform(trackerGeom_.product(), magField_.product());
     }
   }
 }