#include <TrackFullCloneSelectorBase.h>

Inheritance diagram for reco::modules::TrackFullCloneSelectorBase< Selector >:

Public Member Functions
	TrackFullCloneSelectorBase (const edm::ParameterSet &cfg)
	constructor More...

virtual	~TrackFullCloneSelectorBase ()
	destructor More...

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)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

virtual	~ProducerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Member Functions
void	produce (edm::Event &evt, const edm::EventSetup &es) override
	process one event More...

Private Attributes
bool	copyExtras_
	copy only the tracks, not extras and rechits (for AOD) More...

bool	copyTrajectories_
	copy also trajectories and trajectory->track associations More...

edm::EDGetTokenT < reco::TrackCollection >	hSrcTrackToken_
	source collection label More...

edm::EDGetTokenT< std::vector < Trajectory > >	hTrajToken_

edm::EDGetTokenT < TrajTrackAssociationCollection >	hTTAssToken_

Selector	selector_
	filter event More...

std::auto_ptr < TrackingRecHitCollection >	selHits_

std::auto_ptr < reco::TrackExtraCollection >	selTrackExtras_

std::auto_ptr < reco::TrackCollection >	selTracks_

std::auto_ptr< std::vector < Trajectory > >	selTrajs_

std::auto_ptr < TrajTrackAssociationCollection >	selTTAss_

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 Selector>
class reco::modules::TrackFullCloneSelectorBase< Selector >

Definition at line 36 of file TrackFullCloneSelectorBase.h.

Constructor & Destructor Documentation

template<typename Selector >

reco::modules::TrackFullCloneSelectorBase< Selector >::TrackFullCloneSelectorBase ( const edm::ParameterSet & cfg )

inlineexplicit

constructor

Definition at line 39 of file TrackFullCloneSelectorBase.h.

References HLT_25ns14e33_v1_cff::alias, reco::modules::TrackFullCloneSelectorBase< Selector >::copyExtras_, reco::modules::TrackFullCloneSelectorBase< Selector >::copyTrajectories_, edm::ParameterSet::getParameter(), and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                      :
     hSrcTrackToken_( consumes<reco::TrackCollection>( cfg.template getParameter<edm::InputTag>( "src" ) ) ),
     hTrajToken_( mayConsume< std::vector<Trajectory> >( cfg.template getParameter<edm::InputTag>( "src" ) ) ),
     hTTAssToken_( mayConsume< TrajTrackAssociationCollection >( cfg.template getParameter<edm::InputTag>( "src" ) ) ),
     copyExtras_(cfg.template getUntrackedParameter<bool>("copyExtras", false)),
     copyTrajectories_(cfg.template getUntrackedParameter<bool>("copyTrajectories", false)),
     selector_( cfg, consumesCollector() ) {
       std::string alias( cfg.getParameter<std::string>( "@module_label" ) );
       produces<reco::TrackCollection>().setBranchAlias( alias + "Tracks" );
       if (copyExtras_) {
           produces<reco::TrackExtraCollection>().setBranchAlias( alias + "TrackExtras" );
           produces<TrackingRecHitCollection>().setBranchAlias( alias + "RecHits" );
           if (copyTrajectories_) {
               produces< std::vector<Trajectory> >().setBranchAlias( alias + "Trajectories" );
               produces< TrajTrackAssociationCollection >().setBranchAlias( alias + "TrajectoryTrackAssociations" );
           }
       }
    }

template<typename Selector >

virtual reco::modules::TrackFullCloneSelectorBase< Selector >::~TrackFullCloneSelectorBase ( )

inlinevirtual

destructor

Definition at line 58 of file TrackFullCloneSelectorBase.h.

58 { }

Member Function Documentation

template<typename Selector >

void reco::modules::TrackFullCloneSelectorBase< Selector >::produce	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

inlineoverrideprivatevirtual

process one event

Implements edm::stream::EDProducerBase.

Definition at line 62 of file TrackFullCloneSelectorBase.h.

Referenced by JSONExport.JsonExport::export(), HTMLExport.HTMLExport::export(), and HTMLExport.HTMLExportStatic::export().

                                                                  {
       edm::Handle<reco::TrackCollection> hSrcTrack;
       evt.getByToken( hSrcTrackToken_, hSrcTrack );
 
       selTracks_ = std::auto_ptr<reco::TrackCollection>(new reco::TrackCollection());
       if (copyExtras_) {
           selTrackExtras_ = std::auto_ptr<reco::TrackExtraCollection>(new reco::TrackExtraCollection());
           selHits_ = std::auto_ptr<TrackingRecHitCollection>(new TrackingRecHitCollection());
       }
 
       TrackRefProd rTracks = evt.template getRefBeforePut<TrackCollection>();
 
       TrackingRecHitRefProd rHits;
       TrackExtraRefProd rTrackExtras;
       if (copyExtras_) {
           rHits = evt.template getRefBeforePut<TrackingRecHitCollection>();
           rTrackExtras = evt.template getRefBeforePut<TrackExtraCollection>();
       }
 
       typedef reco::TrackRef::key_type TrackRefKey;
       std::map<TrackRefKey, reco::TrackRef  > goodTracks;
       TrackRefKey current = 0;
 
       selector_.init(evt,es);
       for (reco::TrackCollection::const_iterator it = hSrcTrack->begin(), ed = hSrcTrack->end(); it != ed; ++it, ++current) {
           const reco::Track & trk = * it;
           if (!selector_(trk)) continue;
 
           selTracks_->push_back( Track( trk ) ); // clone and store
           if (!copyExtras_) continue;
 
           // TrackExtras
           selTrackExtras_->push_back( TrackExtra( trk.outerPosition(), trk.outerMomentum(), trk.outerOk(),
                       trk.innerPosition(), trk.innerMomentum(), trk.innerOk(),
                       trk.outerStateCovariance(), trk.outerDetId(),
                       trk.innerStateCovariance(), trk.innerDetId(),
                       trk.seedDirection() ) );
           selTracks_->back().setExtra( TrackExtraRef( rTrackExtras, selTrackExtras_->size() - 1) );
           TrackExtra & tx = selTrackExtras_->back();
           // TrackingRecHits
           auto const firstHitIndex = selHits_->size();
           for( trackingRecHit_iterator hit = trk.recHitsBegin(); hit != trk.recHitsEnd(); ++ hit ) {
               selHits_->push_back( (*hit)->clone() );
           }
           tx.setHits( rHits, firstHitIndex, selHits_->size() - firstHitIndex );
 
           if (copyTrajectories_) {
               goodTracks[current] = reco::TrackRef(rTracks, selTracks_->size() - 1);
           }
       }
       if ( copyTrajectories_ ) {
           edm::Handle< std::vector<Trajectory> > hTraj;
           edm::Handle< TrajTrackAssociationCollection > hTTAss;
           evt.getByToken(hTTAssToken_, hTTAss);
           evt.getByToken(hTrajToken_, hTraj);
           edm::RefProd< std::vector<Trajectory> > TrajRefProd = evt.template getRefBeforePut< std::vector<Trajectory> >();
           selTrajs_ = std::auto_ptr< std::vector<Trajectory> >(new std::vector<Trajectory>());
           selTTAss_ = std::auto_ptr< TrajTrackAssociationCollection >(new TrajTrackAssociationCollection());
           for (size_t i = 0, n = hTraj->size(); i < n; ++i) {
               edm::Ref< std::vector<Trajectory> > trajRef(hTraj, i);
               TrajTrackAssociationCollection::const_iterator match = hTTAss->find(trajRef);
               if (match != hTTAss->end()) {
                   const edm::Ref<reco::TrackCollection> &trkRef = match->val;
                   TrackRefKey oldKey = trkRef.key();
                   std::map<TrackRefKey, reco::TrackRef>::iterator getref = goodTracks.find(oldKey);
                   if (getref != goodTracks.end()) {
                       // do the clone
                       selTrajs_->push_back( Trajectory(*trajRef) );
                       selTTAss_->insert ( edm::Ref< std::vector<Trajectory> >(TrajRefProd, selTrajs_->size() - 1),
                                           getref->second );
                   }
               }
           }
       }
 
       evt.put(selTracks_);
       if (copyExtras_) {
             evt.put(selTrackExtras_);
             evt.put(selHits_);
             if ( copyTrajectories_ ) {
                 evt.put(selTrajs_);
                 evt.put(selTTAss_);
             }
       }
   }