#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::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 ( )

Definition at line 59 of file EgammaHLTPixelMatchElectronAlgo.cc.

References mtsTransform_.

59 { delete mtsTransform_; }

EgammaHLTPixelMatchElectronAlgo::mtsTransform_

MultiTrajectoryStateTransform * mtsTransform_

Definition: EgammaHLTPixelMatchElectronAlgo.h:59

EgammaHLTPixelMatchElectronAlgo::EgammaHLTPixelMatchElectronAlgo ( const EgammaHLTPixelMatchElectronAlgo & rhs )

inlineprivate

Definition at line 38 of file EgammaHLTPixelMatchElectronAlgo.h.

38 {}

Member Function Documentation

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

private

Definition at line 218 of file EgammaHLTPixelMatchElectronAlgo.cc.

Referenced by operator=(), and process().

                                                                                {
   // 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;
   }
 }

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

inlineprivate

Definition at line 39 of file EgammaHLTPixelMatchElectronAlgo.h.

References isInnerMostWithLostHits(), process(), run(), singleTopDQM_cfi::setup, and setupES().

39 { return *this; }

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.

References 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 operator=(), and run().

                                                                  {
   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);
     }
   }
 }

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

Definition at line 85 of file EgammaHLTPixelMatchElectronAlgo.cc.

References bsProducer_, edm::Event::getByToken(), gsfTrackProducer_, reco::BeamSpot::position(), process(), trackProducer_, and useGsfTracks_.

Referenced by operator=(), and EgammaHLTPixelMatchElectronProducers::produce().

                                                                               {
   // 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;
 }

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

Definition at line 61 of file EgammaHLTPixelMatchElectronAlgo.cc.

References edm::eventsetup::EventSetupRecord::cacheIdentifier(), cacheIDMagField_, cacheIDTDGeom_, edm::EventSetup::get(), magField_, mtsTransform_, edm::ESHandle< T >::product(), trackerGeom_, and useGsfTracks_.

Referenced by operator=(), and EgammaHLTPixelMatchElectronProducers::produce().

                                                                      {
   //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());
     }
   }
 }