#include <RecoTracker/NuclearSeedGenerator/interface/NuclearTrackCorrector.h>

Inheritance diagram for NuclearTrackCorrector:

Public Types
using	AlgoProductCollection = TrackProducerAlgorithm< reco::Track >::AlgoProductCollection

typedef TransientTrackingRecHit::ConstRecHitContainer	ConstRecHitContainer

typedef edm::Ref< TrackCandidateCollection >	TrackCandidateRef

typedef edm::Ref< TrajectoryCollection >	TrajectoryRef

typedef edm::RefVector< TrajectorySeedCollection >	TrajectorySeedRefVector

Public Types inherited from edm::EDProducer
typedef EDProducer	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex > >

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
	NuclearTrackCorrector (const edm::ParameterSet &)

	~NuclearTrackCorrector () override

Public Member Functions inherited from edm::EDProducer
	EDProducer ()

SerialTaskQueue *	globalLuminosityBlocksQueue ()

SerialTaskQueue *	globalRunsQueue ()

ModuleDescription const &	moduleDescription () const

	~EDProducer () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

std::vector< bool > const &	recordProvenanceList () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

TypeLabelList const &	typeLabelList () const
	used by the fwk to register the list of products of this module More...

	~ProducerBase () noexcept(false) override

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase &&)=default

	EDConsumerBase (EDConsumerBase const &)=delete

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase &	operator= (EDConsumerBase &&)=default

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Private Member Functions
void	endJob () override

TrajectoryStateOnSurface	getInitialState (const reco::Track theT, TransientTrackingRecHit::RecHitContainer &hits, const TrackingGeometry theG, const MagneticField *theMF)
	Calculate the inital state to be used to buil the track. More...

reco::TrackExtra	getNewTrackExtra (const AlgoProductCollection &algoresults)
	get a new TrackExtra from an AlgoProductCollection More...

bool	getTrackFromTrajectory (const Trajectory &newTraj, const TrajectoryRef &initialTrajRef, AlgoProductCollection &algoResults)
	Get the refitted track from the Trajectory. More...

bool	newTrajNeeded (Trajectory &newtrajectory, const TrajectoryRef &trajRef, const reco::NuclearInteraction &ni)
	check if the trajectory has to be refitted and get the new trajectory More...

void	produce (edm::Event &, const edm::EventSetup &) override

void	swap_map (const edm::Handle< TrajectoryCollection > &trajColl, std::map< reco::TrackRef, edm::Ref< TrajectoryCollection > > &result)

Private Attributes
edm::ParameterSet	conf_

std::vector< std::pair< unsigned int, unsigned int > >	Indice_Map

int	int_Input_Hit_Distance

int	KeepOnlyCorrectedTracks

const TrajTrackAssociationCollection *	m_TrajToTrackCollection

std::string	str_Input_NuclearInteraction

std::string	str_Input_Trajectory

TrackProducerAlgorithm< reco::Track > *	theAlgo

edm::ESHandle< TrajectoryFitter >	theFitter

edm::ESHandle< TrackerGeometry >	theG

TransientInitialStateEstimator *	theInitialState

edm::ESHandle< MagneticField >	theMF

edm::ESHandle< Propagator >	thePropagator

int	verbosity

Additional Inherited Members
Static Public Member Functions inherited from edm::EDProducer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

static bool	wantsGlobalLuminosityBlocks ()

static bool	wantsGlobalRuns ()

static bool	wantsStreamLuminosityBlocks ()

static bool	wantsStreamRuns ()

Protected Member Functions inherited from edm::ProducerBase
template<class ProductType >
BranchAliasSetterT< ProductType >	produces ()
	declare what type of product will make and with which optional label More...

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces ()

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces ()

BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<BranchType B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<Transition B>
BranchAliasSetter	produces (const TypeID &id, std::string instanceName=std::string(), bool recordProvenance=true)

template<typename ProductType , Transition B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<class ProductType >
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

template<typename ProductType , BranchType B>
BranchAliasSetterT< ProductType >	produces (std::string instanceName)

ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 67 of file NuclearTrackCorrector.h.

Member Typedef Documentation

◆ AlgoProductCollection

using NuclearTrackCorrector::AlgoProductCollection = TrackProducerAlgorithm<reco::Track>::AlgoProductCollection

Definition at line 74 of file NuclearTrackCorrector.h.

◆ ConstRecHitContainer

typedef TransientTrackingRecHit::ConstRecHitContainer NuclearTrackCorrector::ConstRecHitContainer

Definition at line 72 of file NuclearTrackCorrector.h.

◆ TrackCandidateRef

typedef edm::Ref<TrackCandidateCollection> NuclearTrackCorrector::TrackCandidateRef

Definition at line 71 of file NuclearTrackCorrector.h.

◆ TrajectoryRef

typedef edm::Ref<TrajectoryCollection> NuclearTrackCorrector::TrajectoryRef

Definition at line 70 of file NuclearTrackCorrector.h.

◆ TrajectorySeedRefVector

typedef edm::RefVector<TrajectorySeedCollection> NuclearTrackCorrector::TrajectorySeedRefVector

Definition at line 69 of file NuclearTrackCorrector.h.

Constructor & Destructor Documentation

◆ NuclearTrackCorrector()

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

explicit

Definition at line 34 of file NuclearTrackCorrector.cc.

     : conf_(iConfig), theInitialState(nullptr) {
   str_Input_Trajectory = iConfig.getParameter<std::string>("InputTrajectory");
   str_Input_NuclearInteraction = iConfig.getParameter<std::string>("InputNuclearInteraction");
   verbosity = iConfig.getParameter<int>("Verbosity");
   KeepOnlyCorrectedTracks = iConfig.getParameter<bool>("KeepOnlyCorrectedTracks");
  
   theAlgo = new TrackProducerAlgorithm<reco::Track>(iConfig);
  
   produces<TrajectoryCollection>();
   produces<TrajectoryToTrajectoryMap>();
  
   produces<reco::TrackExtraCollection>();
   produces<reco::TrackCollection>();
   produces<TrackToTrajectoryMap>();
  
   produces<TrackToTrackMap>();
 }

References edm::ParameterSet::getParameter(), KeepOnlyCorrectedTracks, str_Input_NuclearInteraction, str_Input_Trajectory, AlCaHLTBitMon_QueryRunRegistry::string, theAlgo, and verbosity.

◆ ~NuclearTrackCorrector()

NuclearTrackCorrector::~NuclearTrackCorrector ( )

override

Definition at line 53 of file NuclearTrackCorrector.cc.

53 {}

Member Function Documentation

◆ endJob()

void NuclearTrackCorrector::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 177 of file NuclearTrackCorrector.cc.

177 {}

◆ getInitialState()

TrajectoryStateOnSurface NuclearTrackCorrector::getInitialState	(	const reco::Track *	theT,
		TransientTrackingRecHit::RecHitContainer &	hits,
		const TrackingGeometry *	theG,
		const MagneticField *	theMF
	)

private

Calculate the inital state to be used to buil the track.

Definition at line 304 of file NuclearTrackCorrector.cc.

                                                                                             {
   TrajectoryStateOnSurface theInitialStateForRefitting;
   //the starting state is the state closest to the first hit along seedDirection.
  
   //avoiding to use transientTrack, it should be faster;
   TrajectoryStateOnSurface innerStateFromTrack = trajectoryStateTransform::innerStateOnSurface(*theT, *theG, theMF);
   TrajectoryStateOnSurface outerStateFromTrack = trajectoryStateTransform::outerStateOnSurface(*theT, *theG, theMF);
   TrajectoryStateOnSurface initialStateFromTrack =
       ((innerStateFromTrack.globalPosition() - hits.front()->globalPosition()).mag2() <
        (outerStateFromTrack.globalPosition() - hits.front()->globalPosition()).mag2())
           ? innerStateFromTrack
           : outerStateFromTrack;
  
   // error is rescaled, but correlation are kept.
   initialStateFromTrack.rescaleError(100);
   theInitialStateForRefitting = TrajectoryStateOnSurface(initialStateFromTrack.localParameters(),
                                                          initialStateFromTrack.localError(),
                                                          initialStateFromTrack.surface(),
                                                          theMF);
   return theInitialStateForRefitting;
 }

References TrajectoryStateOnSurface::globalPosition(), hfClusterShapes_cfi::hits, trajectoryStateTransform::innerStateOnSurface(), TrajectoryStateOnSurface::localError(), TrajectoryStateOnSurface::localParameters(), mag2(), trajectoryStateTransform::outerStateOnSurface(), TrajectoryStateOnSurface::rescaleError(), TrajectoryStateOnSurface::surface(), theG, and theMF.

Referenced by getTrackFromTrajectory().

◆ getNewTrackExtra()

reco::TrackExtra NuclearTrackCorrector::getNewTrackExtra ( const AlgoProductCollection & algoresults )

private

get a new TrackExtra from an AlgoProductCollection

Definition at line 263 of file NuclearTrackCorrector.cc.

                                                                                                {
   Trajectory* theTraj = algoResults[0].trajectory;
   PropagationDirection seedDir = algoResults[0].pDir;
  
   TrajectoryStateOnSurface outertsos;
   TrajectoryStateOnSurface innertsos;
   unsigned int innerId, outerId;
   if (theTraj->direction() == alongMomentum) {
     outertsos = theTraj->lastMeasurement().updatedState();
     innertsos = theTraj->firstMeasurement().updatedState();
     outerId = theTraj->lastMeasurement().recHit()->geographicalId().rawId();
     innerId = theTraj->firstMeasurement().recHit()->geographicalId().rawId();
   } else {
     outertsos = theTraj->firstMeasurement().updatedState();
     innertsos = theTraj->lastMeasurement().updatedState();
     outerId = theTraj->firstMeasurement().recHit()->geographicalId().rawId();
     innerId = theTraj->lastMeasurement().recHit()->geographicalId().rawId();
   }
  
   GlobalPoint v = outertsos.globalParameters().position();
   GlobalVector p = outertsos.globalParameters().momentum();
   math::XYZVector outmom(p.x(), p.y(), p.z());
   math::XYZPoint outpos(v.x(), v.y(), v.z());
   v = innertsos.globalParameters().position();
   p = innertsos.globalParameters().momentum();
   math::XYZVector inmom(p.x(), p.y(), p.z());
   math::XYZPoint inpos(v.x(), v.y(), v.z());
  
   return reco::TrackExtra(outpos,
                           outmom,
                           true,
                           inpos,
                           inmom,
                           true,
                           outertsos.curvilinearError(),
                           outerId,
                           innertsos.curvilinearError(),
                           innerId,
                           seedDir);
 }

References alongMomentum, TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), Trajectory::lastMeasurement(), GlobalTrajectoryParameters::momentum(), AlCaHLTBitMon_ParallelJobs::p, GlobalTrajectoryParameters::position(), TrajectoryMeasurement::recHit(), TrajectoryMeasurement::updatedState(), and findQualityFiles::v.

Referenced by produce().

◆ getTrackFromTrajectory()

bool NuclearTrackCorrector::getTrackFromTrajectory	(	const Trajectory &	newTraj,
		const TrajectoryRef &	initialTrajRef,
		AlgoProductCollection &	algoResults
	)

private

Get the refitted track from the Trajectory.

Definition at line 220 of file NuclearTrackCorrector.cc.

                                                                                        {
   const Trajectory* it = &newTraj;
  
   TransientTrackingRecHit::RecHitContainer hits;
   it->validRecHits(hits);
  
   float ndof = 0;
   for (unsigned int h = 0; h < hits.size(); h++) {
     if (hits[h]->isValid()) {
       ndof = ndof + hits[h]->dimension() * hits[h]->weight();
     } else {
       LogDebug("NuclearSeedGenerator") << " HIT IS INVALID ???";
     }
   }
  
   ndof = ndof - 5;
   reco::TrackRef theT = m_TrajToTrackCollection->operator[](initialTrajRef);
   LogDebug("NuclearSeedGenerator") << " TrackCorrector - number of valid hits" << hits.size() << "\n"
                                    << "                - number of hits from Track " << theT->recHitsSize() << "\n"
                                    << "                - number of valid hits from initial track "
                                    << theT->numberOfValidHits();
  
   if (hits.size() > 1) {
     TrajectoryStateOnSurface theInitialStateForRefitting =
         getInitialState(&(*theT), hits, theG.product(), theMF.product());
  
     reco::BeamSpot bs;
     return theAlgo->buildTrack(theFitter.product(),
                                thePropagator.product(),
                                algoResults,
                                hits,
                                theInitialStateForRefitting,
                                it->seed(),
                                ndof,
                                bs,
                                theT->seedRef());
   }
  
   return false;
 }

References cms::cuda::bs, TrackProducerAlgorithm< T >::buildTrack(), getInitialState(), h, hfClusterShapes_cfi::hits, LogDebug, m_TrajToTrackCollection, ndof, edm::ESHandle< T >::product(), Trajectory::seed(), theAlgo, theFitter, theG, theMF, thePropagator, and Trajectory::validRecHits().

Referenced by produce().

◆ newTrajNeeded()

bool NuclearTrackCorrector::newTrajNeeded	(	Trajectory &	newtrajectory,
		const TrajectoryRef &	trajRef,
		const reco::NuclearInteraction &	ni
	)

private

check if the trajectory has to be refitted and get the new trajectory

Definition at line 179 of file NuclearTrackCorrector.cc.

                                                                         {
   bool needNewTraj = false;
   reco::Vertex::Point vtx_pos = ni.vertex().position();
   double vtx_pos_mag = sqrt(vtx_pos.X() * vtx_pos.X() + vtx_pos.Y() * vtx_pos.Y() + vtx_pos.Z() * vtx_pos.Z());
   if (verbosity >= 2)
     printf("Nuclear Interaction pos = %f\n", vtx_pos_mag);
  
   newtrajectory = Trajectory(trajRef->seed(), alongMomentum);
  
   // Look all the Hits of the trajectory and keep only Hits before seeds
   Trajectory::DataContainer Measurements = trajRef->measurements();
   if (verbosity >= 2)
     LogDebug("NuclearTrackCorrector") << "Size of Measurements  = " << Measurements.size();
  
   for (unsigned int m = Measurements.size() - 1; m != (unsigned int)-1; m--) {
     if (!Measurements[m].recHit()->isValid())
       continue;
     GlobalPoint hit_pos = theG->idToDet(Measurements[m].recHit()->geographicalId())
                               ->surface()
                               .toGlobal(Measurements[m].recHit()->localPosition());
  
     if (verbosity >= 2)
       printf("Hit pos = %f", hit_pos.mag());
  
     if (hit_pos.mag() > vtx_pos_mag) {
       if (verbosity >= 2)
         printf(" X ");
       needNewTraj = true;
     } else {
       newtrajectory.push(Measurements[m]);
     }
     if (verbosity >= 2)
       printf("\n");
   }
  
   return needNewTraj;
 }

References alongMomentum, TrackerGeometry::idToDet(), createfilelist::int, LogDebug, visualization-live-secondInstance_cfg::m, PV3DBase< T, PVType, FrameType >::mag(), reco::Vertex::position(), Trajectory::push(), rpcPointValidation_cfi::recHit, mathSSE::sqrt(), GeomDet::surface(), theG, Surface::toGlobal(), verbosity, and reco::NuclearInteraction::vertex().

Referenced by produce().

◆ produce()

void NuclearTrackCorrector::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivatevirtual

Implements edm::EDProducer.

Definition at line 55 of file NuclearTrackCorrector.cc.

                                                                                  {
   // Create Output Collections
   // --------------------------------------------------------------------------------------------------
   auto Output_traj = std::make_unique<TrajectoryCollection>();
   auto Output_trajmap = std::make_unique<TrajectoryToTrajectoryMap>();
  
   auto Output_trackextra = std::make_unique<reco::TrackExtraCollection>();
   auto Output_track = std::make_unique<reco::TrackCollection>();
   auto Output_trackmap = std::make_unique<TrackToTrajectoryMap>();
  
   // Load Reccord
   // --------------------------------------------------------------------------------------------------
   std::string fitterName = conf_.getParameter<std::string>("Fitter");
   iSetup.get<TrajectoryFitter::Record>().get(fitterName, theFitter);
  
   std::string propagatorName = conf_.getParameter<std::string>("Propagator");
   iSetup.get<TrackingComponentsRecord>().get(propagatorName, thePropagator);
  
   iSetup.get<TrackerDigiGeometryRecord>().get(theG);
  
   reco::TrackExtraRefProd rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
  
   iSetup.get<IdealMagneticFieldRecord>().get(theMF);
  
   // Load Inputs
   // --------------------------------------------------------------------------------------------------
   edm::Handle<TrajectoryCollection> temp_m_TrajectoryCollection;
   iEvent.getByLabel(str_Input_Trajectory, temp_m_TrajectoryCollection);
   const TrajectoryCollection m_TrajectoryCollection = *(temp_m_TrajectoryCollection.product());
  
   edm::Handle<NuclearInteractionCollection> temp_m_NuclearInteractionCollection;
   iEvent.getByLabel(str_Input_NuclearInteraction, temp_m_NuclearInteractionCollection);
   const NuclearInteractionCollection m_NuclearInteractionCollection = *(temp_m_NuclearInteractionCollection.product());
  
   edm::Handle<TrajTrackAssociationCollection> h_TrajToTrackCollection;
   iEvent.getByLabel(str_Input_Trajectory, h_TrajToTrackCollection);
   m_TrajToTrackCollection = h_TrajToTrackCollection.product();
  
   // Correct the trajectories (Remove trajectory's hits that are located after the nuclear interacion)
   // --------------------------------------------------------------------------------------------------
   if (verbosity >= 1) {
     LogDebug("NuclearTrackCorrector") << "Number of trajectories                    = " << m_TrajectoryCollection.size()
                                       << std::endl
                                       << "Number of nuclear interactions            = "
                                       << m_NuclearInteractionCollection.size();
   }
  
   std::map<reco::TrackRef, TrajectoryRef> m_TrackToTrajMap;
   swap_map(temp_m_TrajectoryCollection, m_TrackToTrajMap);
  
   for (unsigned int i = 0; i < m_NuclearInteractionCollection.size(); i++) {
     reco::NuclearInteraction ni = m_NuclearInteractionCollection[i];
     if (ni.likelihood() < 0.4)
       continue;
  
     reco::TrackRef primTrackRef = ni.primaryTrack().castTo<reco::TrackRef>();
  
     TrajectoryRef trajRef = m_TrackToTrajMap[primTrackRef];
  
     Trajectory newTraj;
     if (newTrajNeeded(newTraj, trajRef, ni)) {
       AlgoProductCollection algoResults;
       bool isOK = getTrackFromTrajectory(newTraj, trajRef, algoResults);
  
       if (isOK) {
         pair<unsigned int, unsigned int> tempory_pair;
         tempory_pair.first = Output_track->size();
         tempory_pair.second = i;
         Indice_Map.push_back(tempory_pair);
  
         reco::TrackExtraRef teref = reco::TrackExtraRef(rTrackExtras, i);
         reco::TrackExtra newTrackExtra = getNewTrackExtra(algoResults);
         (algoResults[0].track)->setExtra(teref);
  
         Output_track->push_back(*algoResults[0].track);
         Output_trackextra->push_back(newTrackExtra);
         Output_traj->push_back(newTraj);
       }
     } else {
       if (!KeepOnlyCorrectedTracks) {
         Output_track->push_back(*primTrackRef);
         Output_trackextra->push_back(*primTrackRef->extra());
         Output_traj->push_back(*trajRef);
       }
     }
   }
   const edm::OrphanHandle<TrajectoryCollection> Handle_traj = iEvent.put(std::move(Output_traj));
   const edm::OrphanHandle<reco::TrackCollection> Handle_tracks = iEvent.put(std::move(Output_track));
   iEvent.put(std::move(Output_trackextra));
  
   // Make Maps between elements
   // --------------------------------------------------------------------------------------------------
   if (Handle_tracks->size() != Handle_traj->size()) {
     printf("ERROR Handle_tracks->size() != Handle_traj->size() \n");
     return;
   }
  
   auto Output_tracktrackmap = std::make_unique<TrackToTrackMap>(Handle_tracks, m_TrajToTrackCollection->refProd().val);
  
   for (unsigned int i = 0; i < Indice_Map.size(); i++) {
     TrajectoryRef InTrajRef(temp_m_TrajectoryCollection, Indice_Map[i].second);
     TrajectoryRef OutTrajRef(Handle_traj, Indice_Map[i].first);
     reco::TrackRef TrackRef(Handle_tracks, Indice_Map[i].first);
  
     Output_trajmap->insert(OutTrajRef, InTrajRef);
     Output_trackmap->insert(TrackRef, InTrajRef);
  
     try {
       reco::TrackRef PrimaryTrackRef = m_TrajToTrackCollection->operator[](InTrajRef);
       Output_tracktrackmap->insert(TrackRef, PrimaryTrackRef);
     } catch (edm::Exception const&) {
     }
   }
   iEvent.put(std::move(Output_trajmap));
   iEvent.put(std::move(Output_trackmap));
   iEvent.put(std::move(Output_tracktrackmap));
  
   if (verbosity >= 3)
     printf("-----------------------\n");
 }

References edm::RefToBase< T >::castTo(), conf_, dqmdumpme::first, edm::EventSetup::get(), get, getNewTrackExtra(), edm::ParameterSet::getParameter(), getTrackFromTrajectory(), mps_fire::i, iEvent, Indice_Map, edm::AssociationMap< Tag >::insert(), KeepOnlyCorrectedTracks, reco::NuclearInteraction::likelihood(), LogDebug, m_TrajToTrackCollection, eostools::move(), newTrajNeeded(), reco::NuclearInteraction::primaryTrack(), edm::Handle< T >::product(), HLT_2018_cff::propagatorName, edm::AssociationMap< Tag >::refProd(), edm::second(), str_Input_NuclearInteraction, str_Input_Trajectory, AlCaHLTBitMon_QueryRunRegistry::string, swap_map(), theFitter, theG, theMF, thePropagator, HLT_2018_cff::track, and verbosity.

◆ swap_map()

void NuclearTrackCorrector::swap_map	(	const edm::Handle< TrajectoryCollection > &	trajColl,
		std::map< reco::TrackRef, edm::Ref< TrajectoryCollection > > &	result
	)

private

Definition at line 329 of file NuclearTrackCorrector.cc.

                                                                                                   {
   for (unsigned int i = 0; i < trajColl->size(); i++) {
     TrajectoryRef InTrajRef(trajColl, i);
     reco::TrackRef PrimaryTrackRef = m_TrajToTrackCollection->operator[](InTrajRef);
     result[PrimaryTrackRef] = InTrajRef;
   }
 }

References mps_fire::i, m_TrajToTrackCollection, and mps_fire::result.

Referenced by produce().

Member Data Documentation

◆ conf_

edm::ParameterSet NuclearTrackCorrector::conf_

private

Definition at line 119 of file NuclearTrackCorrector.h.

Referenced by produce().

◆ Indice_Map

std::vector<std::pair<unsigned int, unsigned int> > NuclearTrackCorrector::Indice_Map

private

Definition at line 113 of file NuclearTrackCorrector.h.

Referenced by produce().

◆ int_Input_Hit_Distance

int NuclearTrackCorrector::int_Input_Hit_Distance

private

Definition at line 108 of file NuclearTrackCorrector.h.

◆ KeepOnlyCorrectedTracks

int NuclearTrackCorrector::KeepOnlyCorrectedTracks

private

Definition at line 111 of file NuclearTrackCorrector.h.

Referenced by NuclearTrackCorrector(), and produce().

◆ m_TrajToTrackCollection

const TrajTrackAssociationCollection* NuclearTrackCorrector::m_TrajToTrackCollection

private

Definition at line 123 of file NuclearTrackCorrector.h.

Referenced by getTrackFromTrajectory(), produce(), and swap_map().

◆ str_Input_NuclearInteraction

std::string NuclearTrackCorrector::str_Input_NuclearInteraction

private

Definition at line 107 of file NuclearTrackCorrector.h.

Referenced by NuclearTrackCorrector(), and produce().

◆ str_Input_Trajectory

std::string NuclearTrackCorrector::str_Input_Trajectory

private

Definition at line 106 of file NuclearTrackCorrector.h.

Referenced by NuclearTrackCorrector(), and produce().

◆ theAlgo

TrackProducerAlgorithm<reco::Track>* NuclearTrackCorrector::theAlgo

private

Definition at line 122 of file NuclearTrackCorrector.h.

Referenced by getTrackFromTrajectory(), and NuclearTrackCorrector().

◆ theFitter

edm::ESHandle<TrajectoryFitter> NuclearTrackCorrector::theFitter

private

Definition at line 117 of file NuclearTrackCorrector.h.

Referenced by getTrackFromTrajectory(), and produce().

◆ theG

edm::ESHandle<TrackerGeometry> NuclearTrackCorrector::theG

private

Definition at line 115 of file NuclearTrackCorrector.h.

Referenced by getInitialState(), getTrackFromTrajectory(), newTrajNeeded(), and produce().

◆ theInitialState

TransientInitialStateEstimator* NuclearTrackCorrector::theInitialState

private

Definition at line 120 of file NuclearTrackCorrector.h.

◆ theMF

edm::ESHandle<MagneticField> NuclearTrackCorrector::theMF

private

Definition at line 116 of file NuclearTrackCorrector.h.

Referenced by getInitialState(), getTrackFromTrajectory(), and produce().

◆ thePropagator

edm::ESHandle<Propagator> NuclearTrackCorrector::thePropagator

private

Definition at line 118 of file NuclearTrackCorrector.h.

Referenced by getTrackFromTrajectory(), and produce().

◆ verbosity

int NuclearTrackCorrector::verbosity

private

Definition at line 110 of file NuclearTrackCorrector.h.

Referenced by newTrajNeeded(), NuclearTrackCorrector(), and produce().

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ AlgoProductCollection

◆ ConstRecHitContainer

◆ TrackCandidateRef

◆ TrajectoryRef

◆ TrajectorySeedRefVector

Constructor & Destructor Documentation

◆ NuclearTrackCorrector()

◆ ~NuclearTrackCorrector()

Member Function Documentation

◆ endJob()

◆ getInitialState()

◆ getNewTrackExtra()

◆ getTrackFromTrajectory()

◆ newTrajNeeded()

◆ produce()

◆ swap_map()

Member Data Documentation

◆ conf_

◆ Indice_Map

◆ int_Input_Hit_Distance

◆ KeepOnlyCorrectedTracks

◆ m_TrajToTrackCollection

◆ str_Input_NuclearInteraction

◆ str_Input_Trajectory

◆ theAlgo

◆ theFitter

◆ theG

◆ theInitialState

◆ theMF

◆ thePropagator

◆ verbosity