Inheritance diagram for TracksToTrajectories:

Public Member Functions
void	produce (edm::Event &, const edm::EventSetup &) override
	Convert a reco::TrackCollection into std::vector<Trajectory> More...

	TracksToTrajectories (const edm::ParameterSet &, const Count *)
	Constructor. More...

	~TracksToTrajectories () override
	Destructor. More...

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< Count > >
	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

Static Public Member Functions
static void	globalEndJob (Count const *iCount)

static std::unique_ptr< Count >	initializeGlobalCache (edm::ParameterSet const &)

Private Attributes
edm::EDGetTokenT< reco::TrackCollection >	theTracksToken

std::unique_ptr< TrackTransformerBase >	theTrackTransformer

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< Count > >
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

Detailed Description

This class, which is a EDProducer, takes a reco::TrackCollection from the Event and refits the rechits strored in the reco::Tracks. The final result is a std::vector of Trajectories (objs of the type "Trajectory"), which is loaded into the Event in a transient way

Author: R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 43 of file TracksToTrajectories.cc.

Constructor & Destructor Documentation

◆ TracksToTrajectories()

TracksToTrajectories::TracksToTrajectories	(	const edm::ParameterSet &	parameterSet,
		const Count *
	)

Constructor.

Definition at line 68 of file TracksToTrajectories.cc.

                                                                                          {
   theTracksToken = consumes<reco::TrackCollection>(parameterSet.getParameter<InputTag>("Tracks"));
  
   ParameterSet trackTransformerParam = parameterSet.getParameter<ParameterSet>("TrackTransformer");
  
   string type = parameterSet.getParameter<string>("Type");
  
   if (type == "Default")
     theTrackTransformer = std::make_unique<TrackTransformer>(trackTransformerParam, consumesCollector());
   else if (type == "GlobalCosmicMuonsForAlignment")
     theTrackTransformer = std::make_unique<TrackTransformerForGlobalCosmicMuons>(trackTransformerParam);
   else if (type == "CosmicMuonsForAlignment")
     theTrackTransformer = std::make_unique<TrackTransformerForCosmicMuons>(trackTransformerParam);
   else {
     throw cms::Exception("TracksToTrajectories")
         << "The selected algorithm does not exist"
         << "\n"
         << "Possible choices are:"
         << "\n"
         << "Type = [Default, GlobalCosmicMuonsForAlignment, CosmicMuonsForAlignment]";
   }
  
   produces<vector<Trajectory>>("Refitted");
   produces<TrajTrackAssociationCollection>("Refitted");
 }

References Exception, edm::ParameterSet::getParameter(), and edm::parameterSet().

◆ ~TracksToTrajectories()

TracksToTrajectories::~TracksToTrajectories ( )

override

Destructor.

Definition at line 95 of file TracksToTrajectories.cc.

95 {}

Member Function Documentation

◆ globalEndJob()

void TracksToTrajectories::globalEndJob ( Count const * iCount )

static

Definition at line 97 of file TracksToTrajectories.cc.

                                                            {
   constexpr char metname[] = "Reco|TrackingTools|TracksToTrajectories";
  
   auto theNFailures = iCount->theNFailures.load();
   auto theNTracks = iCount->theNTracks.load();
  
   if (theNFailures != 0)
     LogWarning(metname) << "During the refit there were " << theNFailures << " out of " << theNTracks
                         << " tracks, i.e. failure rate is: " << double(theNFailures) / theNTracks;
   else {
     LogTrace(metname) << "Refit of the tracks done without any failure";
   }
 }

References LogTrace, metname, tracksToTrajectories::Count::theNFailures, and tracksToTrajectories::Count::theNTracks.

◆ initializeGlobalCache()

static std::unique_ptr<Count> TracksToTrajectories::initializeGlobalCache ( edm::ParameterSet const & )

inlinestatic

Definition at line 51 of file TracksToTrajectories.cc.

51 { return std::make_unique<Count>(); }

◆ produce()

void TracksToTrajectories::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

override

Convert a reco::TrackCollection into std::vector<Trajectory>

Convert Tracks into Trajectories.

Definition at line 112 of file TracksToTrajectories.cc.

                                                                         {
 #ifdef EDM_ML_DEBUG
   constexpr char metname[] = "Reco|TrackingTools|TracksToTrajectories";
 #endif
  
   theTrackTransformer->setServices(setup);
  
   // Collection of Trajectory
   auto trajectoryCollection = std::make_unique<vector<Trajectory>>();
  
   // Get the reference
   RefProd<vector<Trajectory>> trajectoryCollectionRefProd = event.getRefBeforePut<vector<Trajectory>>("Refitted");
  
   // Get the RecTrack collection from the event
   Handle<reco::TrackCollection> tracks;
   event.getByToken(theTracksToken, tracks);
  
   // Association map between Trajectory and Track
   auto trajTrackMap = std::make_unique<TrajTrackAssociationCollection>(trajectoryCollectionRefProd, tracks);
  
   Ref<vector<Trajectory>>::key_type trajectoryIndex = 0;
   reco::TrackRef::key_type trackIndex = 0;
  
   // Loop over the Rec tracks
   for (auto const& newTrack : *tracks) {
     ++(globalCache()->theNTracks);
  
     auto const& trajectoriesSM = theTrackTransformer->transform(newTrack);
  
     if (!trajectoriesSM.empty()) {
       // Load the trajectory in the Trajectory Container
       trajectoryCollection->push_back(trajectoriesSM.front());
  
       // Make the association between the Trajectory and the original Track
       trajTrackMap->insert(Ref<vector<Trajectory>>(trajectoryCollectionRefProd, trajectoryIndex++),
                            reco::TrackRef(tracks, trackIndex++));
     } else {
       LogTrace(metname) << "Error in the Track refitting. This should not happen";
       ++(globalCache()->theNFailures);
     }
   }
   LogTrace(metname) << "Load the Trajectory Collection";
   event.put(move(trajectoryCollection), "Refitted");
   event.put(move(trajTrackMap), "Refitted");
 }

References LogTrace, metname, eostools::move(), singleTopDQM_cfi::setup, and tracks.

Member Data Documentation

◆ theTracksToken

edm::EDGetTokenT<reco::TrackCollection> TracksToTrajectories::theTracksToken

private

Definition at line 60 of file TracksToTrajectories.cc.

◆ theTrackTransformer

std::unique_ptr<TrackTransformerBase> TracksToTrajectories::theTrackTransformer