#include <TrackMergeremb.h>

Inheritance diagram for TrackMergeremb< T1 >:

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

	~TrackMergeremb ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

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

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

virtual	~EDConsumerBase () noexcept(false)

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)

virtual 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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 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

template<typename T1>
class TrackMergeremb< T1 >

Author: Stefan Wayand; Christian Veelken, LLR

Definition at line 38 of file TrackMergeremb.h.

Member Typedef Documentation

template<typename T1 >

typedef T1 TrackMergeremb< T1 >::TrackCollectionemb

private

Definition at line 47 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 58 of file TrackMergeremb.h.

Constructor & Destructor Documentation

template<typename T1 >

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

explicit

Definition at line 71 of file TrackMergeremb.h.

References egammaCTFFinalFitWithMaterial_cff::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 ( )

Definition at line 85 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 68 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 101 of file TrackMergeremb.cc.

References edm::helper::Filler< Map >::fill(), objects.autophobj::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 159 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 232 of file TrackMergeremb.cc.

References ev, objects.autophobj::filler, edm::Event::getByToken(), edm::Event::getRefBeforePut(), eostools::move(), 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 334 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
	)

overrideprivatevirtual

Definition at line 92 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 62 of file TrackMergeremb.cc.

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

 {
 
 }

template<>

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

private

Definition at line 220 of file TrackMergeremb.cc.

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

 {
 
    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 56 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 90 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 150 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 199 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 310 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 54 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 65 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 64 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 62 of file TrackMergeremb.h.

template<typename T1 >

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

private

Definition at line 61 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 55 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

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

template<typename T1>
class TrackMergeremb< T1 >