TrackRefitter Class Reference

#include <TrackRefitter.h>

Inheritance diagram for TrackRefitter:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	Implementation of produce method. More...
	TrackRefitter (const edm::ParameterSet &iConfig)
	Constructor. More...
Public Member Functions inherited from KfTrackProducerBase
	KfTrackProducerBase (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::TrackCollection > &, std::unique_ptr< reco::TrackExtraCollection > &, std::unique_ptr< std::vector< Trajectory > > &, std::unique_ptr< std::vector< int > > &, AlgoProductCollection &, TransientTrackingRecHitBuilder const *, const TrackerTopology *ttopo, int BeforeOrAfter=0)
	Put produced collections in the event. More...
Public Member Functions inherited from TrackProducerBase< reco::Track >
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	setAlias (std::string alias)
	set the aliases of produced collections More...
void	setClusterRemovalInfo (const edm::InputTag &clusterRemovalInfo)
	Sets the information on cluster removal, and turns it on. More...
void	setConf (const edm::ParameterSet &conf)
	Set parameter set. More...
void	setSecondHitPattern (Trajectory *traj, reco::Track &track, const Propagator *prop, const MeasurementTrackerEvent *measTk, const TrackerTopology *ttopo)
void	setSrc (const edm::EDGetToken &src, const edm::EDGetTokenT< reco::BeamSpot > &bsSrc, const edm::EDGetTokenT< MeasurementTrackerEvent > &mteSrc)
	set label of source collection More...
	TrackProducerBase (bool trajectoryInEvent=false)
	Constructor. More...
virtual	~TrackProducerBase () noexcept(false)
	Destructor. More...
Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Types
enum	Constraint { none, momentum, vertex, trackParameters }

Private Attributes
Constraint	constraint_
TrackProducerAlgorithm< reco::Track >	theAlgo
edm::EDGetToken	trkconstrcoll_

Additional Inherited Members
Public Types inherited from TrackProducerBase< reco::Track >
using	AlgoProductCollection = typename Base::AlgoProductCollection
using	Base = AlgoProductTraits< reco::Track >
using	TrackCollection = typename Base::TrackCollection
using	TrackView = typename Base::TrackView
Public Types inherited from AlgoProductTraits< reco::Track >
using	AlgoProductCollection = std::vector< AlgoProduct >
using	TrackCollection = std::vector< reco::Track >
using	TrackView = edm::View< reco::Track >
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
Protected Attributes inherited from TrackProducerBase< reco::Track >
std::string	alias_
edm::EDGetTokenT< reco::BeamSpot >	bsSrc_
edm::InputTag	clusterRemovalInfo_
edm::ParameterSet	conf_
edm::EDGetTokenT< MeasurementTrackerEvent >	mteSrc_
bool	rekeyClusterRefs_
edm::OrphanHandle< TrackCollection >	rTracks_
edm::EDGetToken	src_
edm::ESHandle< NavigationSchool >	theSchool
bool	trajectoryInEvent_

Detailed Description

Refit Tracks: Produce Tracks from TrackCollection. It performs a new final fit on a TrackCollection.

Author

cerati

Definition at line 14 of file TrackRefitter.h.

Member Enumeration Documentation

Constraint

enum TrackRefitter::Constraint

private

Enumerator
none
momentum
vertex
trackParameters

Definition at line 24 of file TrackRefitter.h.

{ none, momentum, vertex, trackParameters };

Constructor & Destructor Documentation

TrackRefitter()

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

explicit

Constructor.

Definition at line 16 of file TrackRefitter.cc.

    : KfTrackProducerBase(iConfig.getParameter<bool>("TrajectoryInEvent"),
                          iConfig.getParameter<bool>("useHitsSplitting")),
      theAlgo(iConfig) {
  setConf(iConfig);
  setSrc(consumes<edm::View<reco::Track>>(iConfig.getParameter<edm::InputTag>("src")),
         consumes<reco::BeamSpot>(iConfig.getParameter<edm::InputTag>("beamSpot")),
         consumes<MeasurementTrackerEvent>(iConfig.getParameter<edm::InputTag>("MeasurementTrackerEvent")));
  setAlias(iConfig.getParameter<std::string>("@module_label"));
  std::string constraint_str = iConfig.getParameter<std::string>("constraint");
  edm::InputTag trkconstrcoll = iConfig.getParameter<edm::InputTag>("srcConstr");
 
  if (constraint_str.empty())
    constraint_ = none;
  else if (constraint_str == "momentum") {
    constraint_ = momentum;
    trkconstrcoll_ = consumes<TrackMomConstraintAssociationCollection>(trkconstrcoll);
  } else if (constraint_str == "vertex") {
    constraint_ = vertex;
    trkconstrcoll_ = consumes<TrackVtxConstraintAssociationCollection>(trkconstrcoll);
  } else if (constraint_str == "trackParameters") {
    constraint_ = trackParameters;
    trkconstrcoll_ = consumes<TrackParamConstraintAssociationCollection>(trkconstrcoll);
  } else {
    edm::LogError("TrackRefitter")
        << "constraint: " << constraint_str
        << " not understood. Set it to 'momentum', 'vertex', 'trackParameters' or leave it empty";
    throw cms::Exception("TrackRefitter")
        << "unknown type of contraint! Set it to 'momentum', 'vertex', 'trackParameters' or leave it empty";
  }
 
  //register your products
  produces<reco::TrackCollection>().setBranchAlias(alias_ + "Tracks");
  produces<reco::TrackExtraCollection>().setBranchAlias(alias_ + "TrackExtras");
  produces<TrackingRecHitCollection>().setBranchAlias(alias_ + "RecHits");
  produces<std::vector<Trajectory>>();
  produces<std::vector<int>>();
  produces<TrajTrackAssociationCollection>();
}

References TrackProducerBase< reco::Track >::alias_, constraint_, Exception, edm::ParameterSet::getParameter(), momentum, none, TrackProducerBase< reco::Track >::setAlias(), TrackProducerBase< reco::Track >::setConf(), TrackProducerBase< reco::Track >::setSrc(), AlCaHLTBitMon_QueryRunRegistry::string, trackParameters, trkconstrcoll_, and vertex.

Member Function Documentation

produce()

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

overridevirtual

Implementation of produce method.

Implements TrackProducerBase< reco::Track >.

Definition at line 56 of file TrackRefitter.cc.

                                                                          {
  LogDebug("TrackRefitter") << "Analyzing event number: " << theEvent.id() << "\n";
  //
  // create empty output collections
  //
  std::unique_ptr<TrackingRecHitCollection> outputRHColl(new TrackingRecHitCollection);
  std::unique_ptr<reco::TrackCollection> outputTColl(new reco::TrackCollection);
  std::unique_ptr<reco::TrackExtraCollection> outputTEColl(new reco::TrackExtraCollection);
  std::unique_ptr<std::vector<Trajectory>> outputTrajectoryColl(new std::vector<Trajectory>);
  std::unique_ptr<std::vector<int>> outputIndecesInputColl(new std::vector<int>);
 
  //
  //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;
  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::Track>> theTCollection;
      getFromEvt(theEvent, theTCollection, bs);
 
      LogDebug("TrackRefitter") << "TrackRefitter::produce(none):Number of Trajectories:" << (*theTCollection).size();
 
      if (bs.position() == math::XYZPoint(0., 0., 0.) && bs.type() == reco::BeamSpot::Unknown) {
        edm::LogError("TrackRefitter") << " BeamSpot is (0,0,0), it is probably because is not valid in the event";
        break;
      }
 
      if (theTCollection.failedToGet()) {
        edm::EDConsumerBase::Labels labels;
        labelsForToken(src_, labels);
        edm::LogError("TrackRefitter") << "could not get the reco::TrackCollection." << labels.module;
        break;
      }
      LogDebug("TrackRefitter") << "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 momentum: {
      edm::Handle<TrackMomConstraintAssociationCollection> theTCollectionWithConstraint;
      theEvent.getByToken(trkconstrcoll_, theTCollectionWithConstraint);
 
      edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
      theEvent.getByToken(bsSrc_, recoBeamSpotHandle);
      if (!recoBeamSpotHandle.isValid())
        break;
      bs = *recoBeamSpotHandle;
      if (theTCollectionWithConstraint.failedToGet()) {
        //edm::LogError("TrackRefitter")<<"could not get TrackMomConstraintAssociationCollection product.";
        break;
      }
      LogDebug("TrackRefitter") << "run the algorithm"
                                << "\n";
      try {
        theAlgo.runWithMomentum(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.runWithMomentum."
                                       << "\n"
                                       << e << "\n";
        throw;
      }
      break;
    }
    case vertex: {
      edm::Handle<TrackVtxConstraintAssociationCollection> theTCollectionWithConstraint;
      theEvent.getByToken(trkconstrcoll_, theTCollectionWithConstraint);
      edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
      theEvent.getByToken(bsSrc_, recoBeamSpotHandle);
      if (!recoBeamSpotHandle.isValid())
        break;
      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.runWithVertex."
                                       << "\n"
                                       << e << "\n";
        throw;
      }
      break;
    }
    case trackParameters: {
      edm::Handle<TrackParamConstraintAssociationCollection> theTCollectionWithConstraint;
      theEvent.getByToken(trkconstrcoll_, theTCollectionWithConstraint);
      edm::Handle<reco::BeamSpot> recoBeamSpotHandle;
      theEvent.getByToken(bsSrc_, recoBeamSpotHandle);
      if (!recoBeamSpotHandle.isValid())
        break;
      bs = *recoBeamSpotHandle;
      if (theTCollectionWithConstraint.failedToGet()) {
        //edm::LogError("TrackRefitter")<<"could not get TrackParamConstraintAssociationCollection product.";
        break;
      }
      LogDebug("TrackRefitter") << "run the algorithm"
                                << "\n";
      try {
        theAlgo.runWithTrackParameters(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.runWithTrackParameters."
                                       << "\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,
           outputTrajectoryColl,
           outputIndecesInputColl,
           algoResults,
           theBuilder.product(),
           httopo.product());
  LogDebug("TrackRefitter") << "end"
                            << "\n";
}

References cms::cuda::bs, TrackProducerBase< reco::Track >::bsSrc_, constraint_, MillePedeFileConverter_cfg::e, edm::HandleBase::failedToGet(), get, edm::Event::getByToken(), TrackProducerBase< reco::Track >::getFromES(), TrackProducerBase< reco::Track >::getFromEvt(), edm::EventBase::id(), edm::HandleBase::isValid(), SummaryClient_cfi::labels, LogDebug, momentum, none, edm::ESHandle< T >::product(), KfTrackProducerBase::putInEvt(), TrackProducerAlgorithm< T >::runWithMomentum(), TrackProducerAlgorithm< T >::runWithTrack(), TrackProducerAlgorithm< T >::runWithTrackParameters(), TrackProducerAlgorithm< T >::runWithVertex(), singleTopDQM_cfi::setup, TrackProducerBase< reco::Track >::src_, theAlgo, trackParameters, trkconstrcoll_, reco::BeamSpot::Unknown, and vertex.

Member Data Documentation

constraint_

Constraint TrackRefitter::constraint_

private

Definition at line 25 of file TrackRefitter.h.

Referenced by produce(), and TrackRefitter().

theAlgo

TrackProducerAlgorithm<reco::Track> TrackRefitter::theAlgo

private

Definition at line 23 of file TrackRefitter.h.

Referenced by produce().

trkconstrcoll_

edm::EDGetToken TrackRefitter::trkconstrcoll_

private

Definition at line 26 of file TrackRefitter.h.

Referenced by produce(), and TrackRefitter().