#include <RecoTracker/NuclearSeedGenerator/plugin/NuclearTrackCorrector.cc>

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

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)

	~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 const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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 const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

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
ProducesCollector	producesCollector ()

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, 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)

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

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

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

Detailed Description

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

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

Definition at line 68 of file NuclearTrackCorrector.h.

Member Typedef Documentation

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

Definition at line 75 of file NuclearTrackCorrector.h.

typedef TransientTrackingRecHit::ConstRecHitContainer NuclearTrackCorrector::ConstRecHitContainer

Definition at line 73 of file NuclearTrackCorrector.h.

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

Definition at line 72 of file NuclearTrackCorrector.h.

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

Definition at line 71 of file NuclearTrackCorrector.h.

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

Definition at line 70 of file NuclearTrackCorrector.h.

Constructor & Destructor Documentation

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

explicit

Definition at line 34 of file NuclearTrackCorrector.cc.

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

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

NuclearTrackCorrector::~NuclearTrackCorrector ( )

override

Definition at line 53 of file NuclearTrackCorrector.cc.

53 {}

Member Function Documentation

void NuclearTrackCorrector::endJob ( void )

overrideprivatevirtual

Reimplemented from edm::EDProducer.

Definition at line 177 of file NuclearTrackCorrector.cc.

177 {}

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.

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

Referenced by getTrackFromTrajectory().

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

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

private

get a new TrackExtra from an AlgoProductCollection

Definition at line 263 of file NuclearTrackCorrector.cc.

References alongMomentum, TrajectoryStateOnSurface::curvilinearError(), Trajectory::direction(), Trajectory::firstMeasurement(), TrajectoryStateOnSurface::globalParameters(), Trajectory::lastMeasurement(), GlobalTrajectoryParameters::momentum(), AlCaHLTBitMon_ParallelJobs::p, GlobalTrajectoryParameters::position(), TrajectoryMeasurement::recHit(), TrajectoryMeasurement::updatedState(), findQualityFiles::v, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by produce().

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

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.

References 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().

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

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.

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().

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

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

overrideprivate

Definition at line 55 of file NuclearTrackCorrector.cc.

References edm::RefToBase< T >::castTo(), conf_, dqmdumpme::first, edm::EventSetup::get(), edm::Event::getByLabel(), getNewTrackExtra(), edm::ParameterSet::getParameter(), edm::Event::getRefBeforePut(), getTrackFromTrajectory(), mps_fire::i, 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::Event::put(), 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, edm::helpers::KeyVal< K, V >::val, and verbosity.

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

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.

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

Referenced by produce().

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