#include <TrackMergeremb.h>

Inheritance diagram for TrackMergeremb< T1 >:

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

	~TrackMergeremb () override

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
typedef edm::ValueMap< reco::GsfTrackRefVector >	GsfTrackToTrackMapnew

typedef T1	TrackCollectionemb

typedef edm::ValueMap< reco::TrackRefVector >	TrackToTrackMapnew

Private Member Functions
void	merg_and_put (edm::Event &, std::string, std::vector< edm::EDGetTokenT< TrackCollectionemb >> &)

template<>
void	merg_and_put (edm::Event &iEvent, std::string instance, std::vector< edm::EDGetTokenT< reco::TrackCollection >> &to_merge)

template<>
void	merg_and_put (edm::Event &iEvent, std::string instance, std::vector< edm::EDGetTokenT< reco::GsfTrackCollection >> &to_merge)

template<>
void	merg_and_put (edm::Event &iEvent, std::string instance, std::vector< edm::EDGetTokenT< reco::MuonCollection >> &to_merge)

template<>
void	merg_and_put (edm::Event &iEvent, std::string instance, std::vector< edm::EDGetTokenT< reco::PFCandidateCollection >> &to_merge)

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

void	willconsume (const edm::ParameterSet &iConfig)

template<>
void	willconsume (const edm::ParameterSet &iConfig)

template<>
void	willconsume (const edm::ParameterSet &iConfig)

template<>
void	willconsume (const edm::ParameterSet &iConfig)

void	willproduce (std::string instance, std::string alias)

template<>
void	willproduce (std::string instance, std::string alias)

template<>
void	willproduce (std::string instance, std::string alias)

template<>
void	willproduce (std::string instance, std::string alias)

template<>
void	willproduce (std::string instance, std::string alias)

Private Attributes
std::string	alias

const GlobalTrackingGeometry *	geometry_ = nullptr

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	globalGeomToken_

std::map< std::string, std::vector< edm::EDGetTokenT< TrackCollectionemb > > >	inputs_

edm::EDGetTokenT< reco::GsfTrackCollection >	inputs_fixgsftrackcol_

edm::EDGetTokenT< GsfTrackToTrackMapnew >	inputs_fixgsftrackrefs_

edm::EDGetTokenT< reco::MuonCollection >	inputs_fixmucol_

edm::EDGetTokenT< reco::MuonToMuonMap >	inputs_fixmurefs_

edm::EDGetTokenT< reco::TrackCollection >	inputs_fixtrackcol_

edm::EDGetTokenT< TrackToTrackMapnew >	inputs_fixtrackrefs_

std::map< std::string, std::vector< edm::EDGetTokenT< edm::ValueMap< reco::MuonQuality > > > >	inputs_qual_

edm::EDGetTokenT< reco::ElectronSeedCollection >	inputs_rElectronMergedSeeds_

edm::EDGetTokenT< edm::View< TrajectorySeed > >	inputs_rElectronMergedSeedViews_

edm::EDGetTokenT< reco::SuperClusterCollection >	inputs_SC_

Additional Inherited Members
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

Detailed Description

template<typename T1>
class TrackMergeremb< T1 >

Author: Stefan Wayand; Christian Veelken, LLR Clean Up from Christian Winter & Sebastian Brommer, KIT

Definition at line 47 of file TrackMergeremb.h.

Member Typedef Documentation

◆ GsfTrackToTrackMapnew

template<typename T1 >

typedef edm::ValueMap<reco::GsfTrackRefVector> TrackMergeremb< T1 >::GsfTrackToTrackMapnew

private

Definition at line 65 of file TrackMergeremb.h.

◆ TrackCollectionemb

template<typename T1 >

typedef T1 TrackMergeremb< T1 >::TrackCollectionemb

private

Definition at line 55 of file TrackMergeremb.h.

◆ TrackToTrackMapnew

template<typename T1 >

typedef edm::ValueMap<reco::TrackRefVector> TrackMergeremb< T1 >::TrackToTrackMapnew

private

Definition at line 64 of file TrackMergeremb.h.

Constructor & Destructor Documentation

◆ TrackMergeremb()

template<typename T1 >

TrackMergeremb< T1 >::TrackMergeremb ( const edm::ParameterSet & iConfig )

explicit

Definition at line 54 of file TrackMergeremb.cc.

References isoTrack_cff::alias, deDxTools::esConsumes(), edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                  {
   alias = iConfig.getParameter<std::string>("@module_label");
   std::vector<edm::InputTag> inCollections = iConfig.getParameter<std::vector<edm::InputTag>>("mergCollections");
   globalGeomToken_ = esConsumes();
   for (const auto &inCollection : inCollections) {
     inputs_[inCollection.instance()].push_back(consumes<TrackCollectionemb>(inCollection));
   }
   willconsume(iConfig);
   for (const auto &toproduce : inputs_) {
     willproduce(toproduce.first, alias);
   }
 }

◆ ~TrackMergeremb()

template<typename T1 >

TrackMergeremb< T1 >::~TrackMergeremb ( )

override

Definition at line 68 of file TrackMergeremb.cc.

                                     {
   // nothing to be done yet...
 }

Member Function Documentation

◆ merg_and_put() [1/5]

template<typename T1 >

void TrackMergeremb< T1 >::merg_and_put	(	edm::Event &	iEvent,
		std::string	instance,
		std::vector< edm::EDGetTokenT< TrackCollectionemb >> &	to_merge
	)

private

Definition at line 90 of file TrackMergeremb.cc.

References iEvent, instance, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, and eostools::move().

                                                                                                {
   std::unique_ptr<TrackCollectionemb> outTracks = std::unique_ptr<TrackCollectionemb>(new TrackCollectionemb);
 
   for (auto akt_collection : to_merge) {
     edm::Handle<TrackCollectionemb> track_col_in;
     iEvent.getByToken(akt_collection, track_col_in);
 
     size_t sedref_it = 0;
     for (typename TrackCollectionemb::const_iterator it = track_col_in->begin(); it != track_col_in->end();
          ++it, ++sedref_it) {
       outTracks->push_back(typename T1::value_type(*it));
     }
 
   }  // end merge
 
   iEvent.put(std::move(outTracks), instance);
 }

◆ merg_and_put() [2/5]

template<>

void TrackMergeremb< reco::TrackCollection >::merg_and_put	(	edm::Event &	iEvent,
		std::string	instance,
		std::vector< edm::EDGetTokenT< reco::TrackCollection >> &	to_merge
	)

private

Definition at line 119 of file TrackMergeremb.cc.

References trigObjTnPSource_cfi::filler, iEvent, instance, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, eostools::move(), and edm::RefVector< C, T, F >::push_back().

                                                                                                     {
   std::unique_ptr<reco::TrackCollection> outTracks = std::make_unique<reco::TrackCollection>();
   std::unique_ptr<reco::TrackExtraCollection> outTracks_ex = std::make_unique<reco::TrackExtraCollection>();
   std::unique_ptr<TrackingRecHitCollection> outTracks_rh = std::make_unique<TrackingRecHitCollection>();
   std::unique_ptr<TrackToTrackMapnew> outTracks_refs = std::make_unique<TrackToTrackMapnew>();
 
   auto rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
 
   std::vector<reco::TrackRefVector> trackRefColl;
 
   for (auto akt_collection : to_merge) {
     edm::Handle<reco::TrackCollection> track_col_in;
     iEvent.getByToken(akt_collection, track_col_in);
 
     unsigned sedref_it = 0;
     for (reco::TrackCollection::const_iterator it = track_col_in->begin(); it != track_col_in->end();
          ++it, ++sedref_it) {
       outTracks->push_back(reco::Track(*it));
       auto rechits = it->recHits();
       // Fixing geometry records of detector components for tracking rec. hits
       for (auto ith = rechits.begin(); ith != rechits.end(); ith++) {
         auto hit = *(&(*ith));
         hit->setDet(*geometry_->idToDet(hit->rawId()));
       }
       outTracks_ex->push_back(reco::TrackExtra(*it->extra()));
       outTracks->back().setExtra(reco::TrackExtraRef(rTrackExtras, outTracks_ex->size() - 1));
       reco::TrackRef trackRefold(track_col_in, sedref_it);
 
       reco::TrackRefVector trackRefColl_helpvec;
       trackRefColl_helpvec.push_back(trackRefold);
       trackRefColl.push_back(trackRefColl_helpvec);
     }
 
   }  // end merge
 
   edm::OrphanHandle<reco::TrackCollection> trackHandle = iEvent.put(std::move(outTracks), instance);
   iEvent.put(std::move(outTracks_ex), instance);
 
   TrackToTrackMapnew::Filler filler(*outTracks_refs);
   filler.insert(trackHandle, trackRefColl.begin(), trackRefColl.end());
   filler.fill();
 
   iEvent.put(std::move(outTracks_refs));
   iEvent.put(std::move(outTracks_rh), instance);  // not implemented so far
 }

◆ merg_and_put() [3/5]

template<>

void TrackMergeremb< reco::GsfTrackCollection >::merg_and_put	(	edm::Event &	iEvent,
		std::string	instance,
		std::vector< edm::EDGetTokenT< reco::GsfTrackCollection >> &	to_merge
	)

private

Definition at line 185 of file TrackMergeremb.cc.

References trigObjTnPSource_cfi::filler, iEvent, instance, edm::Ref< C, T, F >::isAvailable(), ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, eostools::move(), edm::RefVector< C, T, F >::push_back(), fileCollector::seed, reco::TrackExtra::setSeedRef(), and cuy::tex.

                                                                                                        {
   std::unique_ptr<reco::GsfTrackCollection> outTracks = std::make_unique<reco::GsfTrackCollection>();
   std::unique_ptr<reco::TrackExtraCollection> outTracks_ex = std::make_unique<reco::TrackExtraCollection>();
   std::unique_ptr<reco::GsfTrackExtraCollection> outTracks_exgsf = std::make_unique<reco::GsfTrackExtraCollection>();
   std::unique_ptr<TrackingRecHitCollection> outTracks_rh = std::make_unique<TrackingRecHitCollection>();
   std::unique_ptr<GsfTrackToTrackMapnew> outTracks_refs = std::make_unique<GsfTrackToTrackMapnew>();
 
   auto rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
   auto rTrackExtras_gsf = iEvent.getRefBeforePut<reco::GsfTrackExtraCollection>();
 
   auto rHits = iEvent.getRefBeforePut<TrackingRecHitCollection>();
   std::vector<reco::GsfTrackRefVector> trackRefColl;
 
   // track to track map for trackerdriven seed fix
   edm::Handle<TrackToTrackMapnew> track_ref_map;
   iEvent.getByToken(inputs_fixtrackrefs_, track_ref_map);
 
   edm::Handle<reco::TrackCollection> track_new_col;
   iEvent.getByToken(inputs_fixtrackcol_, track_new_col);
 
   std::map<reco::TrackRef, reco::TrackRef> simple_track_to_track_map;
   for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
     reco::TrackRef trackRef(track_new_col, abc);
     simple_track_to_track_map[trackRef] = trackRef;
     simple_track_to_track_map[((*track_ref_map)[trackRef])[0]] = trackRef;
   }
 
   // merge begin
   for (auto akt_collection : to_merge) {
     edm::Handle<reco::GsfTrackCollection> track_col_in;
     iEvent.getByToken(akt_collection, track_col_in);
 
     size_t sedref_it = 0;
     for (reco::GsfTrackCollection::const_iterator it = track_col_in->begin(); it != track_col_in->end();
          ++it, ++sedref_it) {
       reco::ElectronSeedRef seed = it->seedRef().castTo<reco::ElectronSeedRef>();
       (const_cast<reco::ElectronSeed *>(seed.get()))->setCtfTrack(simple_track_to_track_map[seed->ctfTrack()]);
       outTracks->push_back(reco::GsfTrack(*it));
       auto rechits = it->recHits();
       // Fixing geometry records of detector components for tracking rec. hits
       for (auto ith = rechits.begin(); ith != rechits.end(); ith++) {
         auto hit = *(&(*ith));
         hit->setDet(*geometry_->idToDet(hit->rawId()));
       }
       outTracks_ex->push_back(reco::TrackExtra(*it->extra()));
       outTracks_exgsf->push_back(reco::GsfTrackExtra(*it->gsfExtra()));
 
       outTracks->back().setExtra(reco::TrackExtraRef(rTrackExtras, outTracks_ex->size() - 1));
       outTracks->back().setGsfExtra(reco::GsfTrackExtraRef(rTrackExtras_gsf, outTracks_exgsf->size() - 1));
 
       reco::GsfTrackRef trackRefold(track_col_in, sedref_it);
       reco::GsfTrackRefVector trackRefColl_helpvec;
       trackRefColl_helpvec.push_back(trackRefold);
       trackRefColl.push_back(trackRefColl_helpvec);
     }
 
   }  // end merge
 
   edm::OrphanHandle<reco::GsfTrackCollection> trackHandle = iEvent.put(std::move(outTracks), instance);
   GsfTrackToTrackMapnew::Filler filler(*outTracks_refs);
   filler.insert(trackHandle, trackRefColl.begin(), trackRefColl.end());
   filler.fill();
 
   edm::Handle<reco::ElectronSeedCollection> elSeeds;
   iEvent.getByToken(inputs_rElectronMergedSeeds_, elSeeds);
   auto bElSeeds = elSeeds->cbegin();
   auto eElSeeds = elSeeds->cend();
 
   edm::Handle<edm::View<TrajectorySeed>> seedViewsHandle;
   iEvent.getByToken(inputs_rElectronMergedSeedViews_, seedViewsHandle);
 
   std::unique_ptr<reco::TrackExtraCollection> outTracks_ex_new = std::make_unique<reco::TrackExtraCollection>();
 
   // fix track extras to new merged seeds
   for (typename reco::TrackExtraCollection::const_iterator tex = outTracks_ex->begin(); tex != outTracks_ex->end();
        ++tex) {
     reco::TrackExtra newTrackExtra(*tex);
 
     if (tex->seedRef().isAvailable()) {
       const reco::ElectronSeedRef &trSeedRef(tex->seedRef().castTo<reco::ElectronSeedRef>());
       if (trSeedRef.isAvailable()) {
         // find new seed with corresponding supercluster or ctfTrack
         // note that seed can be both Ecal- and Tracker-driven
         size_t sedref_it = 0;
         for (auto tseed = bElSeeds; tseed != eElSeeds; ++tseed, ++sedref_it) {
           const reco::ElectronSeedRef elSeedRef(elSeeds, sedref_it);
 
           if (trSeedRef->isEcalDriven() && elSeedRef->isEcalDriven()) {
             // match seeds by pair of detIds
             if (trSeedRef->detId(0) == elSeedRef->detId(0) && trSeedRef->detId(1) == elSeedRef->detId(1)) {
               edm::RefToBase<TrajectorySeed> traSeedRef(seedViewsHandle, sedref_it);
               newTrackExtra.setSeedRef(traSeedRef);
             }
           }
           if (trSeedRef->isTrackerDriven() && elSeedRef->isTrackerDriven()) {
             // if tracker driven, check for same ctf track
             if (simple_track_to_track_map[trSeedRef->ctfTrack()] == elSeedRef->ctfTrack()) {
               edm::RefToBase<TrajectorySeed> traSeedRef(seedViewsHandle, sedref_it);
               newTrackExtra.setSeedRef(traSeedRef);
             }
           }
         }
       }
     }
 
     outTracks_ex_new->push_back(newTrackExtra);
   }
 
   iEvent.put(std::move(outTracks_refs));
   iEvent.put(std::move(outTracks_ex_new), instance);
   iEvent.put(std::move(outTracks_exgsf), instance);
   iEvent.put(std::move(outTracks_rh), instance);
 }

◆ merg_and_put() [4/5]

template<>

void TrackMergeremb< reco::MuonCollection >::merg_and_put	(	edm::Event &	iEvent,
		std::string	instance,
		std::vector< edm::EDGetTokenT< reco::MuonCollection >> &	to_merge
	)

private

Definition at line 330 of file TrackMergeremb.cc.

References makeMEIFBenchmarkPlots::ev, trigObjTnPSource_cfi::filler, iEvent, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, eostools::move(), custom_jme_cff::nMuons, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                                  {
   std::unique_ptr<reco::MuonCollection> outTracks = std::make_unique<reco::MuonCollection>();
   std::unique_ptr<reco::CaloMuonCollection> calomu =
       std::make_unique<reco::CaloMuonCollection>();  // not implemented so far
 
   edm::Handle<TrackToTrackMapnew> track_ref_map;
   iEvent.getByToken(inputs_fixtrackrefs_, track_ref_map);
 
   edm::Handle<reco::TrackCollection> track_new_col;
   iEvent.getByToken(inputs_fixtrackcol_, track_new_col);
   std::map<reco::TrackRef, reco::TrackRef> simple_track_to_track_map;
   for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
     reco::TrackRef trackRef(track_new_col, abc);
     simple_track_to_track_map[trackRef] =
         trackRef;  // catch the case, where a seed ctf track could already be updated, such that the update doesn't happen again
     simple_track_to_track_map[((*track_ref_map)[trackRef])[0]] = trackRef;
   }
 
   std::vector<reco::MuonRef> muonRefColl;
   reco::MuonRefProd outputMuonsRefProd = iEvent.getRefBeforePut<reco::MuonCollection>();
   unsigned new_idx = 0;
   for (auto akt_collection : to_merge) {
     edm::Handle<reco::MuonCollection> track_col_in;
     iEvent.getByToken(akt_collection, track_col_in);
     unsigned old_idx = 0;
     for (reco::MuonCollection::const_iterator it = track_col_in->begin(); it != track_col_in->end();
          ++it, ++old_idx, ++new_idx) {
       outTracks->push_back(reco::Muon(*it));
       reco::MuonRef muRefold(track_col_in, old_idx);
       muonRefColl.push_back(muRefold);
       reco::MuonRef muRefnew(outputMuonsRefProd, new_idx);
 
       if (it->track().isNonnull()) {
         outTracks->back().setTrack(simple_track_to_track_map[it->track()]);
       }
     }
 
   }  // end merge
 
   const int nMuons = outTracks->size();
 
   std::vector<reco::MuonTimeExtra> dtTimeColl(nMuons);
   std::vector<reco::MuonTimeExtra> cscTimeColl(nMuons);
   std::vector<reco::MuonTimeExtra> combinedTimeColl(nMuons);
   std::vector<reco::IsoDeposit> trackDepColl(nMuons);
   std::vector<reco::IsoDeposit> ecalDepColl(nMuons);
   std::vector<reco::IsoDeposit> hcalDepColl(nMuons);
   std::vector<reco::IsoDeposit> hoDepColl(nMuons);
   std::vector<reco::IsoDeposit> jetDepColl(nMuons);
 
   edm::OrphanHandle<reco::MuonCollection> muonHandle = iEvent.put(std::move(outTracks));
 
   auto fillMap = [](auto refH, auto &vec, edm::Event &ev, const std::string &cAl = "") {
     typedef edm::ValueMap<typename std::decay<decltype(vec)>::type::value_type> MapType;
     std::unique_ptr<MapType> oMap(new MapType());
     {
       typename MapType::Filler filler(*oMap);
       filler.insert(refH, vec.begin(), vec.end());
       vec.clear();
       filler.fill();
     }
     ev.put(std::move(oMap), cAl);
   };
 
   fillMap(muonHandle, combinedTimeColl, iEvent, "combined");
   fillMap(muonHandle, dtTimeColl, iEvent, "dt");
   fillMap(muonHandle, cscTimeColl, iEvent, "csc");
   fillMap(muonHandle, trackDepColl, iEvent, "tracker");
   fillMap(muonHandle, ecalDepColl, iEvent, "ecal");
   fillMap(muonHandle, hcalDepColl, iEvent, "hcal");
   fillMap(muonHandle, hoDepColl, iEvent, "ho");
   fillMap(muonHandle, jetDepColl, iEvent, "jets");
   fillMap(muonHandle, muonRefColl, iEvent);
   iEvent.put(std::move(calomu));
 }

◆ merg_and_put() [5/5]

template<>

void TrackMergeremb< reco::PFCandidateCollection >::merg_and_put	(	edm::Event &	iEvent,
		std::string	instance,
		std::vector< edm::EDGetTokenT< reco::PFCandidateCollection >> &	to_merge
	)

private

Definition at line 425 of file TrackMergeremb.cc.

References HLT_2024v14_cff::distance, l1ctLayer1_cff::dr, generator_cfi::drMin, PVValHelper::dx, PVValHelper::dy, PVValHelper::dz, iEvent, instance, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, eostools::move(), and mathSSE::sqrt().

                                                                                                           {
   std::unique_ptr<reco::PFCandidateCollection> outTracks = std::make_unique<reco::PFCandidateCollection>();
 
   edm::Handle<TrackToTrackMapnew> track_ref_map;
   iEvent.getByToken(inputs_fixtrackrefs_, track_ref_map);
 
   edm::Handle<reco::TrackCollection> track_new_col;
   iEvent.getByToken(inputs_fixtrackcol_, track_new_col);
   std::map<reco::TrackRef, reco::TrackRef> simple_track_to_track_map;
   for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
     reco::TrackRef trackRef(track_new_col, abc);
     simple_track_to_track_map[trackRef] =
         trackRef;  // catch the case, where a seed ctf track could already be updated, such that the update doesn't happen again
     simple_track_to_track_map[((*track_ref_map)[trackRef])[0]] = trackRef;
   }
 
   edm::Handle<GsfTrackToTrackMapnew> gsftrack_ref_map;
   iEvent.getByToken(inputs_fixgsftrackrefs_, gsftrack_ref_map);
 
   edm::Handle<reco::GsfTrackCollection> gsftrack_new_col;
   iEvent.getByToken(inputs_fixgsftrackcol_, gsftrack_new_col);
   std::map<reco::GsfTrackRef, reco::GsfTrackRef> simple_gsftrack_to_gsftrack_map;
   for (unsigned abc = 0; abc < gsftrack_new_col->size(); ++abc) {
     reco::GsfTrackRef gsfTrackRef(gsftrack_new_col, abc);
     simple_gsftrack_to_gsftrack_map[((*gsftrack_ref_map)[gsfTrackRef])[0]] = gsfTrackRef;
   }
 
   edm::Handle<reco::MuonToMuonMap> muon_ref_map;
   iEvent.getByToken(inputs_fixmurefs_, muon_ref_map);
 
   edm::Handle<reco::MuonCollection> muon_new_col;
   iEvent.getByToken(inputs_fixmucol_, muon_new_col);
   std::map<reco::MuonRef, reco::MuonRef> simple_mu_to_mu_map;
   for (unsigned abc = 0; abc < muon_new_col->size(); ++abc) {
     reco::MuonRef muRef(muon_new_col, abc);
     simple_mu_to_mu_map[(*muon_ref_map)[muRef]] = muRef;
   }
 
   // used for photon matching
   edm::Handle<reco::SuperClusterCollection> sCs;
   iEvent.getByToken(inputs_SC_, sCs);
   auto bSc = sCs->cbegin();
   auto eSc = sCs->cend();
 
   for (auto akt_collection : to_merge) {
     edm::Handle<reco::PFCandidateCollection> track_col_in;
     iEvent.getByToken(akt_collection, track_col_in);
     for (reco::PFCandidateCollection::const_iterator it = track_col_in->begin(); it != track_col_in->end(); ++it) {
       outTracks->push_back(reco::PFCandidate(*it));
       if (it->trackRef().isNonnull() && outTracks->back().charge()) {
         outTracks->back().setTrackRef(simple_track_to_track_map[it->trackRef()]);
       }
       if (it->gsfTrackRef().isNonnull()) {
         outTracks->back().setGsfTrackRef(simple_gsftrack_to_gsftrack_map[it->gsfTrackRef()]);
       }
       if (it->superClusterRef().isNonnull()) {
         const reco::SuperClusterRef &pfScRef(it->superClusterRef());
 
         float dx, dy, dz, dr;
         float drMin = 10.0;  // also used as treshold for matching
         reco::SuperClusterRef ccrefMin;
         for (auto sc = bSc; sc != eSc; ++sc) {
           const reco::SuperClusterRef &scRef(reco::SuperClusterRef(sCs, std::distance(bSc, sc)));
           dx = fabs(scRef->x() - pfScRef->x());
           dy = fabs(scRef->y() - pfScRef->y());
           dz = fabs(scRef->z() - pfScRef->z());
           dr = sqrt(dx * dx + dy * dy + dz * dz);
           if (dr < drMin) {
             drMin = dr;
             outTracks->back().setSuperClusterRef(scRef);
           }
         }
       }
       if (it->muonRef().isNonnull()) {
         outTracks->back().setMuonRef(simple_mu_to_mu_map[it->muonRef()]);
       }
     }
   }  // end merge
 
   iEvent.put(std::move(outTracks), instance);
 }

◆ produce()

template<typename T1 >

void TrackMergeremb< T1 >::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 73 of file TrackMergeremb.cc.

References edm::EventSetup::getData(), and iEvent.

                                                                               {
   geometry_ = &iSetup.getData(globalGeomToken_);
   for (auto input_ : inputs_) {
     merg_and_put(iEvent, input_.first, input_.second);
 
   }  // end instance
 }

◆ willconsume() [1/4]

template<typename T1 >

void TrackMergeremb< T1 >::willconsume ( const edm::ParameterSet & iConfig )

private

Definition at line 87 of file TrackMergeremb.cc.

87 {}

◆ willconsume() [2/4]

template<>

void TrackMergeremb< reco::GsfTrackCollection >::willconsume ( const edm::ParameterSet & iConfig )

private

Definition at line 167 of file TrackMergeremb.cc.

References ProducerED_cfi::InputTag.

                                                                                        {
   // track refs for trackerdriven seeds
   inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
   inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
   inputs_rElectronMergedSeeds_ = consumes<reco::ElectronSeedCollection>(edm::InputTag("electronMergedSeeds"));
   inputs_rElectronMergedSeedViews_ = consumes<edm::View<TrajectorySeed>>(edm::InputTag("electronMergedSeeds"));
 }

◆ willconsume() [3/4]

template<>

void TrackMergeremb< reco::MuonCollection >::willconsume ( const edm::ParameterSet & iConfig )

private

Definition at line 319 of file TrackMergeremb.cc.

References isoTrack_cff::alias, and ProducerED_cfi::InputTag.

                                                                                    {
   if (alias == "displacedMuons1stStep") {
     inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("displacedTracks"));
     inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("displacedTracks"));
   } else {
     inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
     inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
   }
 }

◆ willconsume() [4/4]

template<>

void TrackMergeremb< reco::PFCandidateCollection >::willconsume ( const edm::ParameterSet & iConfig )

private

Definition at line 414 of file TrackMergeremb.cc.

References ProducerED_cfi::InputTag.

                                                                                           {
   inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
   inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
   inputs_fixgsftrackrefs_ = consumes<GsfTrackToTrackMapnew>(edm::InputTag("electronGsfTracks"));
   inputs_fixgsftrackcol_ = consumes<reco::GsfTrackCollection>(edm::InputTag("electronGsfTracks"));
   inputs_fixmurefs_ = consumes<reco::MuonToMuonMap>(edm::InputTag("muons1stStep"));
   inputs_fixmucol_ = consumes<reco::MuonCollection>(edm::InputTag("muons1stStep"));
   inputs_SC_ = consumes<reco::SuperClusterCollection>(edm::InputTag("particleFlowEGamma"));
 }

◆ willproduce() [1/5]

template<typename T1 >

void TrackMergeremb< T1 >::willproduce	(	std::string	instance,
		std::string	alias
	)

private

Definition at line 82 of file TrackMergeremb.cc.

References instance.

                                                                         {
   produces<TrackCollectionemb>(instance);
 }

◆ willproduce() [2/5]

template<>

void TrackMergeremb< reco::TrackCollection >::willproduce	(	std::string	instance,
		std::string	alias
	)

private

Definition at line 111 of file TrackMergeremb.cc.

References isoTrack_cff::alias, and instance.

                                                                                          {
   produces<reco::TrackCollection>(instance).setBranchAlias(alias + "Tracks");
   produces<reco::TrackExtraCollection>(instance).setBranchAlias(alias + "TrackExtras");
   produces<TrackingRecHitCollection>(instance).setBranchAlias(alias + "RecHits");
   produces<TrackToTrackMapnew>();
 }

◆ willproduce() [3/5]

template<>

void TrackMergeremb< reco::GsfTrackCollection >::willproduce	(	std::string	instance,
		std::string	alias
	)

private

Definition at line 176 of file TrackMergeremb.cc.

References isoTrack_cff::alias, and instance.

                                                                                             {
   produces<reco::GsfTrackCollection>(instance).setBranchAlias(alias + "GsfTracks");
   produces<reco::TrackExtraCollection>(instance).setBranchAlias(alias + "TrackExtras");
   produces<reco::GsfTrackExtraCollection>(instance).setBranchAlias(alias + "GsfTrackExtras");
   produces<TrackingRecHitCollection>(instance).setBranchAlias(alias + "RecHits");
   produces<GsfTrackToTrackMapnew>();
 }

◆ willproduce() [4/5]

template<>

void TrackMergeremb< reco::MuonCollection >::willproduce	(	std::string	instance,
		std::string	alias
	)

private

Definition at line 301 of file TrackMergeremb.cc.

                                                                                         {
   produces<reco::MuonCollection>();
   produces<reco::CaloMuonCollection>();
   produces<reco::MuonTimeExtraMap>("combined");
   produces<reco::MuonTimeExtraMap>("dt");
   produces<reco::MuonTimeExtraMap>("csc");
 
   // todo make this configurable (or not )
   produces<reco::IsoDepositMap>("tracker");
   produces<reco::IsoDepositMap>("ecal");
   produces<reco::IsoDepositMap>("hcal");
   produces<reco::IsoDepositMap>("ho");
   produces<reco::IsoDepositMap>("jets");
 
   produces<reco::MuonToMuonMap>();
 }

◆ willproduce() [5/5]

template<>

void TrackMergeremb< reco::PFCandidateCollection >::willproduce	(	std::string	instance,
		std::string	alias
	)

private

Definition at line 409 of file TrackMergeremb.cc.

References instance.

                                                                                                {
   produces<reco::PFCandidateCollection>(instance);
 }

Member Data Documentation

◆ alias

template<typename T1 >

std::string TrackMergeremb< T1 >::alias

private

Definition at line 83 of file TrackMergeremb.h.

◆ geometry_

template<typename T1 >

const GlobalTrackingGeometry* TrackMergeremb< T1 >::geometry_ = nullptr

private

Definition at line 68 of file TrackMergeremb.h.

◆ globalGeomToken_

template<typename T1 >

edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> TrackMergeremb< T1 >::globalGeomToken_

private

Definition at line 67 of file TrackMergeremb.h.

◆ inputs_

template<typename T1 >

std::map<std::string, std::vector<edm::EDGetTokenT<TrackCollectionemb> > > TrackMergeremb< T1 >::inputs_

private

Definition at line 61 of file TrackMergeremb.h.

◆ inputs_fixgsftrackcol_

template<typename T1 >

edm::EDGetTokenT<reco::GsfTrackCollection> TrackMergeremb< T1 >::inputs_fixgsftrackcol_

private

Definition at line 74 of file TrackMergeremb.h.

◆ inputs_fixgsftrackrefs_

template<typename T1 >

edm::EDGetTokenT<GsfTrackToTrackMapnew> TrackMergeremb< T1 >::inputs_fixgsftrackrefs_

private

Definition at line 73 of file TrackMergeremb.h.

◆ inputs_fixmucol_

template<typename T1 >

edm::EDGetTokenT<reco::MuonCollection> TrackMergeremb< T1 >::inputs_fixmucol_

private

Definition at line 77 of file TrackMergeremb.h.

◆ inputs_fixmurefs_

template<typename T1 >

edm::EDGetTokenT<reco::MuonToMuonMap> TrackMergeremb< T1 >::inputs_fixmurefs_

private

Definition at line 76 of file TrackMergeremb.h.

◆ inputs_fixtrackcol_

template<typename T1 >

edm::EDGetTokenT<reco::TrackCollection> TrackMergeremb< T1 >::inputs_fixtrackcol_

private

Definition at line 71 of file TrackMergeremb.h.

◆ inputs_fixtrackrefs_

template<typename T1 >

edm::EDGetTokenT<TrackToTrackMapnew> TrackMergeremb< T1 >::inputs_fixtrackrefs_

private

Definition at line 70 of file TrackMergeremb.h.

◆ inputs_qual_

template<typename T1 >

std::map<std::string, std::vector<edm::EDGetTokenT<edm::ValueMap<reco::MuonQuality> > > > TrackMergeremb< T1 >::inputs_qual_

private

Definition at line 62 of file TrackMergeremb.h.

◆ inputs_rElectronMergedSeeds_

template<typename T1 >

edm::EDGetTokenT<reco::ElectronSeedCollection> TrackMergeremb< T1 >::inputs_rElectronMergedSeeds_

private

Definition at line 80 of file TrackMergeremb.h.

◆ inputs_rElectronMergedSeedViews_

template<typename T1 >

edm::EDGetTokenT<edm::View<TrajectorySeed> > TrackMergeremb< T1 >::inputs_rElectronMergedSeedViews_

private

Definition at line 81 of file TrackMergeremb.h.

◆ inputs_SC_

template<typename T1 >

edm::EDGetTokenT<reco::SuperClusterCollection> TrackMergeremb< T1 >::inputs_SC_

private

Definition at line 79 of file TrackMergeremb.h.

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

template<typename T1> class TrackMergeremb< T1 >

Member Typedef Documentation

◆ GsfTrackToTrackMapnew

◆ TrackCollectionemb

◆ TrackToTrackMapnew

Constructor & Destructor Documentation

◆ TrackMergeremb()

◆ ~TrackMergeremb()

Member Function Documentation

◆ merg_and_put() [1/5]

◆ merg_and_put() [2/5]

◆ merg_and_put() [3/5]

◆ merg_and_put() [4/5]

◆ merg_and_put() [5/5]

◆ produce()

◆ willconsume() [1/4]

◆ willconsume() [2/4]

◆ willconsume() [3/4]

◆ willconsume() [4/4]

◆ willproduce() [1/5]

◆ willproduce() [2/5]

◆ willproduce() [3/5]

◆ willproduce() [4/5]

◆ willproduce() [5/5]

Member Data Documentation

◆ alias

◆ geometry_

◆ globalGeomToken_

◆ inputs_

◆ inputs_fixgsftrackcol_

◆ inputs_fixgsftrackrefs_

◆ inputs_fixmucol_

◆ inputs_fixmurefs_

◆ inputs_fixtrackcol_

◆ inputs_fixtrackrefs_

◆ inputs_qual_

◆ inputs_rElectronMergedSeeds_

◆ inputs_rElectronMergedSeedViews_

◆ inputs_SC_

template<typename T1>
class TrackMergeremb< T1 >