#include <GsfTrackRefitter.h>

Inheritance diagram for GsfTrackRefitter:

Public Member Functions
	GsfTrackRefitter (const edm::ParameterSet &iConfig)
	Constructor. More...

void	produce (edm::Event &, const edm::EventSetup &) override
	Implementation of produce method. More...

Public Member Functions inherited from GsfTrackProducerBase
	GsfTrackProducerBase (bool trajectoryInEvent, bool split)
	Constructor. More...

virtual void	putInEvt (edm::Event &, const Propagator prop, const MeasurementTracker measTk, std::unique_ptr< TrackingRecHitCollection > &, std::unique_ptr< reco::GsfTrackCollection > &, std::unique_ptr< reco::TrackExtraCollection > &, std::unique_ptr< reco::GsfTrackExtraCollection > &, std::unique_ptr< std::vector< Trajectory > > &, AlgoProductCollection &, TransientTrackingRecHitBuilder const , const reco::BeamSpot &, const TrackerTopology ttopo)
	Put produced collections in the event. More...

Public Member Functions inherited from TrackProducerBase< reco::GsfTrack >
const edm::ParameterSet &	getConf () const

virtual void	getFromES (const edm::EventSetup &, edm::ESHandle< TrackerGeometry > &, edm::ESHandle< MagneticField > &, edm::ESHandle< TrajectoryFitter > &, edm::ESHandle< Propagator > &, edm::ESHandle< MeasurementTracker > &, edm::ESHandle< TransientTrackingRecHitBuilder > &)
	Get needed services from the Event Setup. More...

virtual void	getFromEvt (edm::Event &, edm::Handle< TrackCandidateCollection > &, reco::BeamSpot &)
	Get TrackCandidateCollection from the Event (needed by TrackProducer) More...

virtual void	getFromEvt (edm::Event &, edm::Handle< TrackView > &, reco::BeamSpot &)
	Get TrackCollection from the Event (needed by TrackRefitter) More...

void	initTrackProducerBase (const edm::ParameterSet &conf, edm::ConsumesCollector cc, const edm::EDGetToken &src)
	Call this method in inheriting class' constructor. More...

void	setAlias (std::string alias)
	set the aliases of produced collections More...

void	setSecondHitPattern (Trajectory traj, reco::GsfTrack &track, const Propagator prop, const MeasurementTrackerEvent measTk, const TrackerTopology ttopo)

	TrackProducerBase (bool trajectoryInEvent=false)
	Constructor. More...

virtual	~TrackProducerBase () noexcept(false)
	Destructor. More...

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

Private Types
enum	Constraint { none, vertex }

Private Attributes
Constraint	constraint_

edm::EDGetTokenT < GsfTrackVtxConstraintAssociationCollection >	gsfTrackVtxConstraintTag_

TrackProducerAlgorithm < reco::GsfTrack >	theAlgo

Additional Inherited Members
Public Types inherited from TrackProducerBase< reco::GsfTrack >
using	AlgoProductCollection = typename Base::AlgoProductCollection

using	Base = AlgoProductTraits< reco::GsfTrack >

using	TrackCollection = typename Base::TrackCollection

using	TrackView = typename Base::TrackView

Public Types inherited from AlgoProductTraits< reco::GsfTrack >
using	AlgoProductCollection = std::vector< AlgoProduct >

using	TrackCollection = std::vector< reco::GsfTrack >

using	TrackView = edm::View< reco::GsfTrack >

Public Types inherited from edm::stream::EDProducer<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Protected Member Functions inherited from GsfTrackProducerBase
void	fillMode (reco::GsfTrack &track, const TrajectoryStateOnSurface innertsos, const Propagator &gsfProp, const TransverseImpactPointExtrapolator &tipExtrapolator, TrajectoryStateClosestToBeamLineBuilder &tscblBuilder, const reco::BeamSpot &bs) const

void	fillStates (TrajectoryStateOnSurface tsos, std::vector< reco::GsfComponent5D > &states) const

Protected Attributes inherited from TrackProducerBase< reco::GsfTrack >
std::string	alias_

edm::EDGetTokenT< reco::BeamSpot >	bsSrc_

edm::ESGetToken < TransientTrackingRecHitBuilder, TransientRecHitRecord >	builderSrc_

edm::ParameterSet	conf_

edm::ESGetToken < TrajectoryFitter, TrajectoryFitter::Record >	fitterSrc_

edm::ESGetToken < MeasurementTracker, CkfComponentsRecord >	measTkSrc_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	mfSrc_

edm::EDGetTokenT < MeasurementTrackerEvent >	mteSrc_

edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagatorSrc_

edm::OrphanHandle < TrackCollection >	rTracks_

edm::ESGetToken < NavigationSchool, NavigationSchoolRecord >	schoolSrc_

edm::EDGetToken	src_

edm::ESHandle< NavigationSchool >	theSchool

edm::ESGetToken < TrackerGeometry, TrackerDigiGeometryRecord >	trackGeomSrc_

bool	trajectoryInEvent_

bool	useSchool_

Detailed Description

Refit GSF Tracks. Based on the TrackRefitter.

Definition at line 14 of file GsfTrackRefitter.h.

Member Enumeration Documentation

enum GsfTrackRefitter::Constraint

private

Enumerator
none
vertex

Definition at line 24 of file GsfTrackRefitter.h.

                   {
     none,
     //          momentum,
     vertex
   };

Constructor & Destructor Documentation

GsfTrackRefitter::GsfTrackRefitter ( const edm::ParameterSet & iConfig )

explicit

Constructor.

Definition at line 18 of file GsfTrackRefitter.cc.

References TrackProducerBase< reco::GsfTrack >::alias_, constraint_, Exception, edm::ParameterSet::getParameter(), gsfTrackVtxConstraintTag_, TrackProducerBase< reco::GsfTrack >::initTrackProducerBase(), none, TrackProducerBase< reco::GsfTrack >::setAlias(), AlCaHLTBitMon_QueryRunRegistry::string, and vertex.

     : GsfTrackProducerBase(iConfig.getParameter<bool>("TrajectoryInEvent"),
                            iConfig.getParameter<bool>("useHitsSplitting")),
       theAlgo(iConfig) {
   initTrackProducerBase(
       iConfig, consumesCollector(), consumes<edm::View<reco::GsfTrack>>(iConfig.getParameter<edm::InputTag>("src")));
   setAlias(iConfig.getParameter<std::string>("@module_label"));
   std::string constraint_str = iConfig.getParameter<std::string>("constraint");
 
   if (constraint_str.empty())
     constraint_ = none;
   //   else if (constraint_str == "momentum") constraint_ = momentum;
   else if (constraint_str == "vertex") {
     constraint_ = vertex;
     gsfTrackVtxConstraintTag_ = consumes<GsfTrackVtxConstraintAssociationCollection>(
         iConfig.getParameter<edm::InputTag>("gsfTrackVtxConstraintTag"));
   } else {
     edm::LogError("GsfTrackRefitter") << "constraint: " << constraint_str
                                       << " not understood. Set it to 'momentum', 'vertex' or leave it empty";
     throw cms::Exception("GsfTrackRefitter")
         << "unknown type of contraint! Set it to 'momentum', 'vertex' or leave it empty";
   }
 
   //register your products
   produces<reco::GsfTrackCollection>().setBranchAlias(alias_ + "GsfTracks");
   produces<reco::TrackExtraCollection>().setBranchAlias(alias_ + "TrackExtras");
   produces<reco::GsfTrackExtraCollection>().setBranchAlias(alias_ + "GsfTrackExtras");
   produces<TrackingRecHitCollection>().setBranchAlias(alias_ + "RecHits");
   produces<std::vector<Trajectory>>();
   produces<TrajGsfTrackAssociationCollection>();
 }

Member Function Documentation

void GsfTrackRefitter::produce	(	edm::Event &	theEvent,
		const edm::EventSetup &	setup
	)

overridevirtual

Implementation of produce method.

Implements TrackProducerBase< reco::GsfTrack >.

Definition at line 50 of file GsfTrackRefitter.cc.

References cms::cuda::bs, TrackProducerBase< reco::GsfTrack >::bsSrc_, constraint_, alignCSCRings::e, edm::HandleBase::failedToGet(), edm::EventSetup::get(), edm::Event::getByToken(), TrackProducerBase< reco::GsfTrack >::getFromES(), TrackProducerBase< reco::GsfTrack >::getFromEvt(), gsfTrackVtxConstraintTag_, edm::EventBase::id(), LogDebug, none, edm::ESHandle< class >::product(), GsfTrackProducerBase::putInEvt(), TrackProducerAlgorithm< T >::runWithTrack(), TrackProducerAlgorithm< T >::runWithVertex(), theAlgo, and vertex.

                                                                              {
   edm::LogInfo("GsfTrackRefitter") << "Analyzing event number: " << theEvent.id() << "\n";
   //
   // create empty output collections
   //
   std::unique_ptr<TrackingRecHitCollection> outputRHColl(new TrackingRecHitCollection);
   std::unique_ptr<reco::GsfTrackCollection> outputTColl(new reco::GsfTrackCollection);
   std::unique_ptr<reco::TrackExtraCollection> outputTEColl(new reco::TrackExtraCollection);
   std::unique_ptr<reco::GsfTrackExtraCollection> outputGsfTEColl(new reco::GsfTrackExtraCollection);
   std::unique_ptr<std::vector<Trajectory>> outputTrajectoryColl(new std::vector<Trajectory>);
 
   //
   //declare and get stuff to be retrieved from ES
   //
   edm::ESHandle<TrackerGeometry> theG;
   edm::ESHandle<MagneticField> theMF;
   edm::ESHandle<TrajectoryFitter> theFitter;
   edm::ESHandle<Propagator> thePropagator;
   edm::ESHandle<MeasurementTracker> theMeasTk;
   //  getFromES(setup,theG,theMF,theFitter,thePropagator);
   edm::ESHandle<TransientTrackingRecHitBuilder> theBuilder;
   getFromES(setup, theG, theMF, theFitter, thePropagator, theMeasTk, theBuilder);
 
   edm::ESHandle<TrackerTopology> httopo;
   setup.get<TrackerTopologyRcd>().get(httopo);
 
   //
   //declare and get TrackCollection to be retrieved from the event
   //
   AlgoProductCollection algoResults;
   reco::BeamSpot bs;
   switch (constraint_) {
     case none: {
       edm::Handle<edm::View<reco::GsfTrack>> theTCollection;
       getFromEvt(theEvent, theTCollection, bs);
       if (theTCollection.failedToGet()) {
         edm::LogError("GsfTrackRefitter") << "could not get the reco::GsfTrackCollection.";
         return;
       }
       LogDebug("GsfTrackRefitter") << "run the algorithm"
                                    << "\n";
       try {
         theAlgo.runWithTrack(theG.product(),
                              theMF.product(),
                              *theTCollection,
                              theFitter.product(),
                              thePropagator.product(),
                              theBuilder.product(),
                              bs,
                              algoResults);
       } catch (cms::Exception& e) {
         edm::LogError("TrackProducer") << "cms::Exception caught during theAlgo.runWithTrack."
                                        << "\n"
                                        << e << "\n";
         throw;
       }
       break;
     }
     case vertex: {
       edm::Handle<GsfTrackVtxConstraintAssociationCollection> theTCollectionWithConstraint;
       theEvent.getByToken(gsfTrackVtxConstraintTag_, theTCollectionWithConstraint);
       edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
       theEvent.getByToken(bsSrc_, recoBeamSpotHandle);
       bs = *recoBeamSpotHandle;
       if (theTCollectionWithConstraint.failedToGet()) {
         edm::LogError("TrackRefitter") << "could not get TrackVtxConstraintAssociationCollection product.";
         break;
       }
       LogDebug("TrackRefitter") << "run the algorithm"
                                 << "\n";
       try {
         theAlgo.runWithVertex(theG.product(),
                               theMF.product(),
                               *theTCollectionWithConstraint,
                               theFitter.product(),
                               thePropagator.product(),
                               theBuilder.product(),
                               bs,
                               algoResults);
       } catch (cms::Exception& e) {
         edm::LogError("TrackProducer") << "cms::Exception caught during theAlgo.runWithTrack."
                                        << "\n"
                                        << e << "\n";
         throw;
       }
     }
       //default... there cannot be any other possibility due to the check in the ctor
   }
 
   //put everything in th event
   putInEvt(theEvent,
            thePropagator.product(),
            theMeasTk.product(),
            outputRHColl,
            outputTColl,
            outputTEColl,
            outputGsfTEColl,
            outputTrajectoryColl,
            algoResults,
            theBuilder.product(),
            bs,
            httopo.product());
   LogDebug("GsfTrackRefitter") << "end"
                                << "\n";
 }