TrackMergeremb< T1 > Class Template Reference

#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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

Private Types
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)
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::map< std::string, std::vector< edm::EDGetTokenT< TrackCollectionemb > > >	inputs_
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_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	RunSummaryCache

Detailed Description

template<typename T1>
class TrackMergeremb< T1 >

Author

Stefan Wayand; Christian Veelken, LLR

Definition at line 34 of file TrackMergeremb.h.

Member Typedef Documentation

template<typename T1 >

typedef T1 TrackMergeremb< T1 >::TrackCollectionemb

private

Definition at line 42 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 52 of file TrackMergeremb.h.

Constructor & Destructor Documentation

template<typename T1 >

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

explicit

Definition at line 62 of file TrackMergeremb.h.

References SiStripOfflineCRack_cfg::alias, edm::ParameterSet::getParameter(), TrackMergeremb< T1 >::inputs_, AlCaHLTBitMon_QueryRunRegistry::string, TrackMergeremb< T1 >::willconsume(), and TrackMergeremb< T1 >::willproduce().

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

template<typename T1 >

TrackMergeremb< T1 >::~TrackMergeremb ( )

override

Definition at line 75 of file TrackMergeremb.h.

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

Member Function Documentation

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 56 of file TrackMergeremb.cc.

References edm::Event::getByToken(), eostools::move(), and edm::Event::put().

Referenced by TrackMergeremb< T1 >::produce().

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

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 85 of file TrackMergeremb.cc.

References edm::helper::Filler< Map >::fill(), trigObjTnPSource_cfi::filler, edm::Event::getByToken(), edm::Event::getRefBeforePut(), edm::helper::Filler< Map >::insert(), eostools::move(), edm::RefVector< C, T, F >::push_back(), and edm::Event::put().

                                                                                                     {
  std::unique_ptr<reco::TrackCollection> outTracks = std::unique_ptr<reco::TrackCollection>(new reco::TrackCollection);
  std::unique_ptr<reco::TrackExtraCollection> outTracks_ex =
      std::unique_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection());
  std::unique_ptr<TrackingRecHitCollection> outTracks_rh =
      std::unique_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());
  std::unique_ptr<TrackToTrackMapnew> outTracks_refs = std::unique_ptr<TrackToTrackMapnew>(new TrackToTrackMapnew());

  auto rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
  // auto rHits = iEvent.getRefBeforePut<TrackingRecHitCollection>();

  std::vector<reco::TrackRefVector> trackRefColl;
  //std::vector<reco::TrackRef> 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));
      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
}

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 139 of file TrackMergeremb.cc.

References edm::Event::getByToken(), edm::Event::getRefBeforePut(), eostools::move(), and edm::Event::put().

                                                                                                        {
  std::unique_ptr<reco::GsfTrackCollection> outTracks =
      std::unique_ptr<reco::GsfTrackCollection>(new reco::GsfTrackCollection);
  std::unique_ptr<reco::TrackExtraCollection> outTracks_ex =
      std::unique_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection());
  std::unique_ptr<reco::GsfTrackExtraCollection> outTracks_exgsf =
      std::unique_ptr<reco::GsfTrackExtraCollection>(new reco::GsfTrackExtraCollection());
  std::unique_ptr<TrackingRecHitCollection> outTracks_rh =
      std::unique_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());

  auto rTrackExtras = iEvent.getRefBeforePut<reco::TrackExtraCollection>();
  auto rTrackExtras_gsf = iEvent.getRefBeforePut<reco::GsfTrackExtraCollection>();

  auto rHits = iEvent.getRefBeforePut<TrackingRecHitCollection>();

  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) {
      outTracks->push_back(reco::GsfTrack(*it));
      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));
    }

  }  // end merge

  iEvent.put(std::move(outTracks), instance);
  iEvent.put(std::move(outTracks_ex), instance);
  iEvent.put(std::move(outTracks_exgsf), instance);
  iEvent.put(std::move(outTracks_rh), instance);
}

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 203 of file TrackMergeremb.cc.

References ev, trigObjTnPSource_cfi::filler, edm::Event::getByToken(), edm::Event::getRefBeforePut(), eostools::move(), jets_cff::nMuons, edm::Event::put(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                    {
  std::unique_ptr<reco::MuonCollection> outTracks = std::unique_ptr<reco::MuonCollection>(new reco::MuonCollection);
  std::unique_ptr<reco::CaloMuonCollection> calomu =
      std::unique_ptr<reco::CaloMuonCollection>(new 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;  //I didn't find a more elegant way, so just build a good old fassion std::map
  for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
    reco::TrackRef trackRef(track_new_col, abc);
    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()) {
        //std::cout<<"pfmerge tr: "<<it->trackRef().id()<< " "<< it->trackRef().key()<< " " << simple_track_to_track_map[it->trackRef()].id() <<  " " << simple_track_to_track_map[it->trackRef()].key() <<std::endl;
        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));
}

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 295 of file TrackMergeremb.cc.

References DEFINE_FWK_MODULE, edm::Event::getByToken(), eostools::move(), and edm::Event::put().

                                                                                                           {
  std::unique_ptr<reco::PFCandidateCollection> outTracks =
      std::unique_ptr<reco::PFCandidateCollection>(new 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;  //I didn't find a more elegant way, so just build a good old fassion std::map
  for (unsigned abc = 0; abc < track_new_col->size(); ++abc) {
    reco::TrackRef trackRef(track_new_col, abc);
    simple_track_to_track_map[((*track_ref_map)[trackRef])[0]] = trackRef;
  }

  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;  //I didn't find a more elegant way, so just build a good old fassion std::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;
  }

  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 (fabs(it->pdgId()) == 13){
      if (it->trackRef().isNonnull() && outTracks->back().charge()) {
        //std::cout<<"pfmerge tr: "<<it->trackRef().id()<< " "<< it->trackRef().key()<< " " << simple_track_to_track_map[it->trackRef()].id() <<  " " << simple_track_to_track_map[it->trackRef()].key() <<std::endl;
        outTracks->back().setTrackRef(simple_track_to_track_map[it->trackRef()]);
      }
      if (it->muonRef().isNonnull()) {
        //std::cout<<"pfmerge mu: "<<it->muonRef().id()<< " "<< it->muonRef().key()<< " " << simple_mu_to_mu_map[it->muonRef()].id() <<  " " << simple_mu_to_mu_map[it->muonRef()].key() <<std::endl;
        outTracks->back().setMuonRef(simple_mu_to_mu_map[it->muonRef()]);
      }
    }
  }  // end merge

  iEvent.put(std::move(outTracks), instance);
}

template<typename T1 >

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

overrideprivate

Definition at line 80 of file TrackMergeremb.h.

References TrackMergeremb< T1 >::inputs_, and TrackMergeremb< T1 >::merg_and_put().

                                                                              {
  for (auto input_ : inputs_) {
    merg_and_put(iEvent, input_.first, input_.second);

  }  // end instance
}

template<typename T1 >

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

private

Definition at line 53 of file TrackMergeremb.cc.

Referenced by TrackMergeremb< T1 >::TrackMergeremb().

{}

template<>

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

private

Definition at line 197 of file TrackMergeremb.cc.

References HLT_2018_cff::InputTag.

                                                                                   {
  inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
  inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
}

template<>

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

private

Definition at line 287 of file TrackMergeremb.cc.

References HLT_2018_cff::InputTag.

                                                                                          {
  inputs_fixtrackrefs_ = consumes<TrackToTrackMapnew>(edm::InputTag("generalTracks"));
  inputs_fixtrackcol_ = consumes<reco::TrackCollection>(edm::InputTag("generalTracks"));
  inputs_fixmurefs_ = consumes<reco::MuonToMuonMap>(edm::InputTag("muons1stStep"));
  inputs_fixmucol_ = consumes<reco::MuonCollection>(edm::InputTag("muons1stStep"));
}

template<typename T1 >

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

private

Definition at line 48 of file TrackMergeremb.cc.

References instance.

Referenced by TrackMergeremb< T1 >::TrackMergeremb().

                                                                        {
  produces<TrackCollectionemb>(instance);
}

template<>

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

private

Definition at line 77 of file TrackMergeremb.cc.

References instance.

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

template<>

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

private

Definition at line 131 of file TrackMergeremb.cc.

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

template<>

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

private

Definition at line 179 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>();
}

template<>

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

private

Definition at line 281 of file TrackMergeremb.cc.

References instance.

                                                                                               {
  produces<reco::PFCandidateCollection>(instance);
  // std::cout<<"Produce PF Collection: "<<instance<<std::endl;
}

Member Data Documentation

template<typename T1 >

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

private

Definition at line 48 of file TrackMergeremb.h.

Referenced by TrackMergeremb< T1 >::produce(), and TrackMergeremb< T1 >::TrackMergeremb().

template<typename T1 >

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

private

Definition at line 58 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 57 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 55 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 54 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 49 of file TrackMergeremb.h.