#include <NtupleDump/TrackingNtuple/plugins/TrackingNtuple.cc>

Inheritance diagram for TrackingNtuple:

Classes
class	DetIdCommon

class	DetIdOTCommon

class	DetIdPhase2OTOnly

class	DetIdPixelOnly

class	DetIdStripOnly

struct	SimHitData

struct	TPHitIndex

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

	~TrackingNtuple () override

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDAnalyzerBase () override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
using	DetIdAll = CombineDetId< DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdStripOnly >

using	DetIdAllPhase2 = CombineDetId< DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdPhase2OTOnly >

using	DetIdPhase2OT = CombineDetId< DetIdCommon, DetIdOTCommon, DetIdPhase2OTOnly >

using	DetIdPixel = CombineDetId< DetIdCommon, DetIdPixelOnly >

using	DetIdStrip = CombineDetId< DetIdCommon, DetIdOTCommon, DetIdStripOnly >

enum	HitSimType { HitSimType::Signal = 0, HitSimType::ITPileup = 1, HitSimType::OOTPileup = 2, HitSimType::Noise = 3, HitSimType::Unknown = 99 }

enum	HitType { HitType::Pixel = 0, HitType::Strip = 1, HitType::Glued = 2, HitType::Invalid = 3, HitType::Phase2OT = 4, HitType::Unknown = 99 }

using	MVACollection = std::vector< float >

using	QualityMaskCollection = std::vector< unsigned char >

Private Member Functions
size_t	addStripMatchedHit (const SiStripMatchedRecHit2D &hit, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)

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

void	clearVariables ()

void	fillBeamSpot (const reco::BeamSpot &bs)

void	fillPhase2OTHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)

void	fillPixelHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)

void	fillSeeds (const edm::Event &iEvent, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const reco::BeamSpot &bs, const reco::TrackToTrackingParticleAssociator &associatorByHits, const ClusterTPAssociation &clusterToTPMap, const TransientTrackingRecHitBuilder &theTTRHBuilder, const MagneticField &theMF, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList, const std::set< edm::ProductID > &hitProductIds, std::map< edm::ProductID, size_t > &seedToCollIndex)

void	fillSimHits (const TrackerGeometry &tracker, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const TrackerTopology &tTopo, SimHitRefKeyToIndex &simHitRefKeyToIndex, std::vector< TPHitIndex > &tpHitList)

void	fillStripMatchedHits (const edm::Event &iEvent, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)

void	fillStripRphiStereoHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< StripDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)

void	fillTrackingParticles (const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::RefToBaseVector< reco::Track > &tracks, const reco::BeamSpot &bs, const TrackingParticleRefVector &tpCollection, const TrackingVertexRefKeyToIndex &tvKeyToIndex, const reco::TrackToTrackingParticleAssociator &associatorByHits, const std::vector< TPHitIndex > &tpHitList, const TrackingParticleRefKeyToCount &tpKeyToClusterCount)

void	fillTrackingParticlesForSeeds (const TrackingParticleRefVector &tpCollection, const reco::SimToRecoCollection &simRecColl, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const unsigned int seedOffset)

void	fillTrackingVertices (const TrackingVertexRefVector &trackingVertices, const TrackingParticleRefKeyToIndex &tpKeyToIndex)

void	fillTracks (const edm::RefToBaseVector< reco::Track > &tracks, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const TrackingParticleRefKeyToCount &tpKeyToClusterCount, const MagneticField &mf, const reco::BeamSpot &bs, const reco::VertexCollection &vertices, const reco::TrackToTrackingParticleAssociator &associatorByHits, const ClusterTPAssociation &clusterToTPMap, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const std::set< edm::ProductID > &hitProductIds, const std::map< edm::ProductID, size_t > &seedToCollIndex, const std::vector< const MVACollection * > &mvaColls, const std::vector< const QualityMaskCollection * > &qualColls)

void	fillVertices (const reco::VertexCollection &vertices, const edm::RefToBaseVector< reco::Track > &tracks)

template<typename SimLink >
SimHitData	matchCluster (const OmniClusterRef &cluster, DetId hitId, int clusterKey, const TransientTrackingRecHit::RecHitPointer &ttrh, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< SimLink > &digiSimLinks, const SimHitRefKeyToIndex &simHitRefKeyToIndex, HitType hitType)

Static Private Member Functions
static bool	tpHitIndexListLess (const TPHitIndex &i, const TPHitIndex &j)

static bool	tpHitIndexListLessSort (const TPHitIndex &i, const TPHitIndex &j)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

float	bsp_sigmax

float	bsp_sigmay

float	bsp_sigmaz

float	bsp_x

float	bsp_y

float	bsp_z

std::string	builderName_

edm::EDGetTokenT< ClusterTPAssociation >	clusterTPMapToken_

edm::EventNumber_t	ev_event

edm::LuminosityBlockNumber_t	ev_lumi

edm::RunNumber_t	ev_run

std::vector< float >	glu_bbxi

DetIdStrip	glu_detId

std::vector< short >	glu_isBarrel

std::vector< int >	glu_monoIdx

std::vector< float >	glu_radL

std::vector< std::vector< int > >	glu_seeIdx

std::vector< int >	glu_stereoIdx

std::vector< float >	glu_x

std::vector< float >	glu_xx

std::vector< float >	glu_xy

std::vector< float >	glu_y

std::vector< float >	glu_yy

std::vector< float >	glu_yz

std::vector< float >	glu_z

std::vector< float >	glu_zx

std::vector< float >	glu_zz

const bool	includeAllHits_

const bool	includeMVA_

bool	includePhase2OTHits_

const bool	includeSeeds_

bool	includeStripHits_

const bool	includeTrackingParticles_

DetIdAll	inv_detId

DetIdAllPhase2	inv_detId_phase2

std::vector< short >	inv_isBarrel

std::vector< unsigned short >	inv_type

std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > >	mvaQualityCollectionTokens_

std::string	parametersDefinerName_

std::vector< float >	ph2_bbxi

DetIdPhase2OT	ph2_detId

std::vector< short >	ph2_isBarrel

std::vector< float >	ph2_radL

std::vector< std::vector< int > >	ph2_seeIdx

std::vector< std::vector< int > >	ph2_simHitIdx

std::vector< unsigned short >	ph2_simType

std::vector< std::vector< int > >	ph2_trkIdx

std::vector< float >	ph2_x

std::vector< float >	ph2_xx

std::vector< float >	ph2_xy

std::vector< float >	ph2_y

std::vector< float >	ph2_yy

std::vector< float >	ph2_yz

std::vector< float >	ph2_z

std::vector< float >	ph2_zx

std::vector< float >	ph2_zz

edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew >	phase2OTRecHitToken_

std::vector< float >	pix_bbxi

std::vector< std::vector< float > >	pix_chargeFraction

DetIdPixel	pix_detId

std::vector< short >	pix_isBarrel

std::vector< float >	pix_radL

std::vector< std::vector< int > >	pix_seeIdx

std::vector< std::vector< int > >	pix_simHitIdx

std::vector< unsigned short >	pix_simType

std::vector< std::vector< int > >	pix_trkIdx

std::vector< float >	pix_x

std::vector< float >	pix_xx

std::vector< float >	pix_xy

std::vector< float >	pix_y

std::vector< float >	pix_yy

std::vector< float >	pix_yz

std::vector< float >	pix_z

std::vector< float >	pix_zx

std::vector< float >	pix_zz

edm::EDGetTokenT< SiPixelRecHitCollection >	pixelRecHitToken_

edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	pixelSimLinkToken_

std::vector< unsigned int >	see_algo

std::vector< int >	see_bestFromFirstHitSimTrkIdx

std::vector< float >	see_bestFromFirstHitSimTrkShareFrac

std::vector< int >	see_bestSimTrkIdx

std::vector< float >	see_bestSimTrkShareFrac

std::vector< float >	see_chi2

std::vector< float >	see_dxy

std::vector< float >	see_dxyErr

std::vector< float >	see_dz

std::vector< float >	see_dzErr

std::vector< float >	see_eta

std::vector< float >	see_etaErr

std::vector< short >	see_fitok

std::vector< std::vector< int > >	see_hitIdx

std::vector< std::vector< int > >	see_hitType

std::vector< short >	see_isTrue

std::vector< unsigned short >	see_nCands

std::vector< unsigned int >	see_nCluster

std::vector< unsigned int >	see_nGlued

std::vector< unsigned int >	see_nPhase2OT

std::vector< unsigned int >	see_nPixel

std::vector< unsigned int >	see_nStrip

std::vector< unsigned int >	see_nValid

std::vector< unsigned int >	see_offset

std::vector< float >	see_phi

std::vector< float >	see_phiErr

std::vector< float >	see_pt

std::vector< float >	see_ptErr

std::vector< float >	see_px

std::vector< float >	see_py

std::vector< float >	see_pz

std::vector< int >	see_q

std::vector< std::vector< int > >	see_simTrkIdx

std::vector< std::vector< float > >	see_simTrkShareFrac

std::vector< float >	see_statePt

std::vector< float >	see_stateTrajPx

std::vector< float >	see_stateTrajPy

std::vector< float >	see_stateTrajPz

std::vector< float >	see_stateTrajX

std::vector< float >	see_stateTrajY

std::vector< unsigned short >	see_stopReason

std::vector< int >	see_trkIdx

std::vector< edm::EDGetTokenT< std::vector< SeedStopInfo > > >	seedStopInfoTokens_

std::vector< edm::EDGetTokenT< edm::View< reco::Track > > >	seedTokens_

std::vector< int >	sim_bunchCrossing

std::vector< std::vector< int > >	sim_decayVtxIdx

std::vector< float >	sim_eta

std::vector< int >	sim_event

std::vector< std::vector< int > >	sim_genPdgIds

std::vector< int >	sim_isFromBHadron

std::vector< unsigned int >	sim_n3DLay

std::vector< unsigned int >	sim_nLay

std::vector< unsigned int >	sim_nPixel

std::vector< unsigned int >	sim_nPixelLay

std::vector< unsigned int >	sim_nRecoClusters

std::vector< unsigned int >	sim_nStrip

std::vector< unsigned int >	sim_nTrackerHits

std::vector< unsigned int >	sim_nValid

std::vector< int >	sim_parentVtxIdx

std::vector< float >	sim_pca_cotTheta

std::vector< float >	sim_pca_dxy

std::vector< float >	sim_pca_dz

std::vector< float >	sim_pca_eta

std::vector< float >	sim_pca_lambda

std::vector< float >	sim_pca_phi

std::vector< float >	sim_pca_pt

std::vector< int >	sim_pdgId

std::vector< float >	sim_phi

std::vector< float >	sim_pt

std::vector< float >	sim_px

std::vector< float >	sim_py

std::vector< float >	sim_pz

std::vector< int >	sim_q

std::vector< std::vector< int > >	sim_seedIdx

std::vector< std::vector< int > >	sim_simHitIdx

std::vector< std::vector< int > >	sim_trkIdx

std::vector< std::vector< float > >	sim_trkShareFrac

DetIdAll	simhit_detId

DetIdAllPhase2	simhit_detId_phase2

std::vector< float >	simhit_eloss

std::vector< std::vector< int > >	simhit_hitIdx

std::vector< std::vector< int > >	simhit_hitType

std::vector< int >	simhit_particle

std::vector< short >	simhit_process

std::vector< int >	simhit_simTrkIdx

std::vector< float >	simhit_tof

std::vector< float >	simhit_x

std::vector< float >	simhit_y

std::vector< float >	simhit_z

edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList >	simHitTPMapToken_

std::vector< int >	simpv_idx

std::vector< int >	simvtx_bunchCrossing

std::vector< std::vector< int > >	simvtx_daughterSimIdx

std::vector< int >	simvtx_event

std::vector< unsigned int >	simvtx_processType

std::vector< std::vector< int > >	simvtx_sourceSimIdx

std::vector< float >	simvtx_x

std::vector< float >	simvtx_y

std::vector< float >	simvtx_z

edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	siphase2OTSimLinksToken_

std::vector< float >	str_bbxi

std::vector< std::vector< float > >	str_chargeFraction

DetIdStrip	str_detId

std::vector< short >	str_isBarrel

std::vector< float >	str_radL

std::vector< std::vector< int > >	str_seeIdx

std::vector< std::vector< int > >	str_simHitIdx

std::vector< unsigned short >	str_simType

std::vector< std::vector< int > >	str_trkIdx

std::vector< float >	str_x

std::vector< float >	str_xx

std::vector< float >	str_xy

std::vector< float >	str_y

std::vector< float >	str_yy

std::vector< float >	str_yz

std::vector< float >	str_z

std::vector< float >	str_zx

std::vector< float >	str_zz

edm::EDGetTokenT< SiStripMatchedRecHit2DCollection >	stripMatchedRecHitToken_

edm::EDGetTokenT< SiStripRecHit2DCollection >	stripRphiRecHitToken_

edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	stripSimLinkToken_

edm::EDGetTokenT< SiStripRecHit2DCollection >	stripStereoRecHitToken_

TTree *	t

edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNLayersToken_

edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNPixelLayersToken_

edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNStripStereoLayersToken_

HistoryBase	tracer_

edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator >	trackAssociatorToken_

edm::EDGetTokenT< TrackingParticleRefVector >	trackingParticleRefToken_

edm::EDGetTokenT< TrackingParticleCollection >	trackingParticleToken_

edm::EDGetTokenT< TrackingVertexCollection >	trackingVertexToken_

edm::EDGetTokenT< edm::View< reco::Track > >	trackToken_

std::vector< unsigned int >	trk_algo

std::vector< decltype(reco::TrackBase().algoMaskUL())>	trk_algoMask

std::vector< int >	trk_bestFromFirstHitSimTrkIdx

std::vector< float >	trk_bestFromFirstHitSimTrkNChi2

std::vector< float >	trk_bestFromFirstHitSimTrkShareFrac

std::vector< float >	trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

std::vector< float >	trk_bestFromFirstHitSimTrkShareFracSimDenom

std::vector< int >	trk_bestSimTrkIdx

std::vector< float >	trk_bestSimTrkNChi2

std::vector< float >	trk_bestSimTrkShareFrac

std::vector< float >	trk_bestSimTrkShareFracSimClusterDenom

std::vector< float >	trk_bestSimTrkShareFracSimDenom

std::vector< float >	trk_cotTheta

std::vector< float >	trk_dxy

std::vector< float >	trk_dxyClosestPV

std::vector< float >	trk_dxyErr

std::vector< float >	trk_dxyPV

std::vector< float >	trk_dz

std::vector< float >	trk_dzClosestPV

std::vector< float >	trk_dzErr

std::vector< float >	trk_dzPV

std::vector< float >	trk_eta

std::vector< float >	trk_etaErr

std::vector< std::vector< int > >	trk_hitIdx

std::vector< std::vector< int > >	trk_hitType

std::vector< float >	trk_inner_pt

std::vector< float >	trk_inner_px

std::vector< float >	trk_inner_py

std::vector< float >	trk_inner_pz

std::vector< short >	trk_isHP

std::vector< short >	trk_isTrue

std::vector< float >	trk_lambda

std::vector< float >	trk_lambdaErr

std::vector< std::vector< float > >	trk_mvas

std::vector< unsigned int >	trk_n3DLay

std::vector< float >	trk_nChi2

std::vector< float >	trk_nChi2_1Dmod

std::vector< unsigned int >	trk_nCluster

std::vector< float >	trk_ndof

std::vector< unsigned int >	trk_nInactive

std::vector< unsigned int >	trk_nInnerInactive

std::vector< unsigned int >	trk_nInnerLost

std::vector< unsigned int >	trk_nLost

std::vector< unsigned int >	trk_nLostLay

std::vector< unsigned int >	trk_nOuterInactive

std::vector< unsigned int >	trk_nOuterLost

std::vector< unsigned int >	trk_nPixel

std::vector< unsigned int >	trk_nPixelLay

std::vector< unsigned int >	trk_nStrip

std::vector< unsigned int >	trk_nStripLay

std::vector< unsigned int >	trk_nValid

std::vector< unsigned int >	trk_originalAlgo

std::vector< float >	trk_outer_pt

std::vector< float >	trk_outer_px

std::vector< float >	trk_outer_py

std::vector< float >	trk_outer_pz

std::vector< float >	trk_phi

std::vector< float >	trk_phiErr

std::vector< float >	trk_pt

std::vector< float >	trk_ptErr

std::vector< float >	trk_px

std::vector< float >	trk_py

std::vector< float >	trk_pz

std::vector< int >	trk_q

std::vector< std::vector< unsigned short > >	trk_qualityMasks

std::vector< float >	trk_refpoint_x

std::vector< float >	trk_refpoint_y

std::vector< float >	trk_refpoint_z

std::vector< int >	trk_seedIdx

std::vector< std::vector< int > >	trk_simTrkIdx

std::vector< std::vector< float > >	trk_simTrkNChi2

std::vector< std::vector< float > >	trk_simTrkShareFrac

std::vector< unsigned short >	trk_stopReason

std::vector< int >	trk_vtxIdx

edm::EDGetTokenT< reco::VertexCollection >	vertexToken_

std::vector< float >	vtx_chi2

std::vector< short >	vtx_fake

std::vector< float >	vtx_ndof

std::vector< std::vector< int > >	vtx_trkIdx

std::vector< short >	vtx_valid

std::vector< float >	vtx_x

std::vector< float >	vtx_xErr

std::vector< float >	vtx_y

std::vector< float >	vtx_yErr

std::vector< float >	vtx_z

std::vector< float >	vtx_zErr

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

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

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

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 469 of file TrackingNtuple.cc.

Member Typedef Documentation

using TrackingNtuple::DetIdAll = CombineDetId<DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdStripOnly>

private

Definition at line 935 of file TrackingNtuple.cc.

using TrackingNtuple::DetIdAllPhase2 = CombineDetId<DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdPhase2OTOnly>

private

Definition at line 936 of file TrackingNtuple.cc.

using TrackingNtuple::DetIdPhase2OT = CombineDetId<DetIdCommon, DetIdOTCommon, DetIdPhase2OTOnly>

private

Definition at line 934 of file TrackingNtuple.cc.

using TrackingNtuple::DetIdPixel = CombineDetId<DetIdCommon, DetIdPixelOnly>

private

Definition at line 932 of file TrackingNtuple.cc.

using TrackingNtuple::DetIdStrip = CombineDetId<DetIdCommon, DetIdOTCommon, DetIdStripOnly>

private

Definition at line 933 of file TrackingNtuple.cc.

using TrackingNtuple::MVACollection = std::vector<float>

private

Definition at line 489 of file TrackingNtuple.cc.

using TrackingNtuple::QualityMaskCollection = std::vector<unsigned char>

private

Definition at line 490 of file TrackingNtuple.cc.

Member Enumeration Documentation

enum TrackingNtuple::HitSimType

strongprivate

Enumerator
Signal
ITPileup
OOTPileup
Noise
Unknown

Definition at line 487 of file TrackingNtuple.cc.

487 { Signal = 0, ITPileup = 1, OOTPileup = 2, Noise = 3, Unknown = 99 };

DigiDM_cff.Noise

Noise

Definition: DigiDM_cff.py:38

reco::Unknown

Definition: MuonSimInfo.h:32

ntupleEnum.ITPileup

ITPileup

Definition: ntupleEnum.py:106

ntupleEnum.OOTPileup

OOTPileup

Definition: ntupleEnum.py:107

Signal

Definition: vlib.h:28

enum TrackingNtuple::HitType

strongprivate

Enumerator
Pixel
Strip
Glued
Invalid
Phase2OT
Unknown

Definition at line 481 of file TrackingNtuple.cc.

481 { Pixel = 0, Strip = 1, Glued = 2, Invalid = 3, Phase2OT = 4, Unknown = 99 };

reco::Unknown

Definition: MuonSimInfo.h:32

align::Pixel

Definition: StructureType.h:68

Invalid

Definition: hltDiff.cc:248

align::Strip

Definition: StructureType.h:69

Constructor & Destructor Documentation

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

explicit

Definition at line 1257 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, HistoryBase::depth(), Exception, edm::ParameterSet::getUntrackedParameter(), glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, mps_fire::i, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, TFileService::kSharedResource, TFileService::make(), mvaQualityCollectionTokens_, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_bestFromFirstHitSimTrkIdx, see_bestFromFirstHitSimTrkShareFrac, see_bestSimTrkIdx, see_bestSimTrkShareFrac, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_isTrue, see_nCands, see_nCluster, see_nGlued, see_nPhase2OT, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_simTrkIdx, see_simTrkShareFrac, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_seedIdx, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::tag, MuonAssociatorByHits_cfi::tpTag, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_hitIdx, trk_hitType, trk_isHP, trk_isTrue, trk_seedIdx, trk_simTrkIdx, trk_simTrkNChi2, trk_simTrkShareFrac, trk_stopReason, trk_vtxIdx, edm::vector_transform(), vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

     : trackToken_(consumes<edm::View<reco::Track>>(iConfig.getUntrackedParameter<edm::InputTag>("tracks"))),
       clusterTPMapToken_(consumes<ClusterTPAssociation>(iConfig.getUntrackedParameter<edm::InputTag>("clusterTPMap"))),
       simHitTPMapToken_(consumes<SimHitTPAssociationProducer::SimHitTPAssociationList>(
           iConfig.getUntrackedParameter<edm::InputTag>("simHitTPMap"))),
       trackAssociatorToken_(consumes<reco::TrackToTrackingParticleAssociator>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackAssociator"))),
       pixelSimLinkToken_(consumes<edm::DetSetVector<PixelDigiSimLink>>(
           iConfig.getUntrackedParameter<edm::InputTag>("pixelDigiSimLink"))),
       stripSimLinkToken_(consumes<edm::DetSetVector<StripDigiSimLink>>(
           iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink"))),
       siphase2OTSimLinksToken_(consumes<edm::DetSetVector<PixelDigiSimLink>>(
           iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink"))),
       includeStripHits_(!iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink").label().empty()),
       includePhase2OTHits_(!iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink").label().empty()),
       beamSpotToken_(consumes<reco::BeamSpot>(iConfig.getUntrackedParameter<edm::InputTag>("beamSpot"))),
       pixelRecHitToken_(
           consumes<SiPixelRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("pixelRecHits"))),
       stripRphiRecHitToken_(
           consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripRphiRecHits"))),
       stripStereoRecHitToken_(
           consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripStereoRecHits"))),
       stripMatchedRecHitToken_(consumes<SiStripMatchedRecHit2DCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("stripMatchedRecHits"))),
       phase2OTRecHitToken_(consumes<Phase2TrackerRecHit1DCollectionNew>(
           iConfig.getUntrackedParameter<edm::InputTag>("phase2OTRecHits"))),
       vertexToken_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertices"))),
       trackingVertexToken_(
           consumes<TrackingVertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackingVertices"))),
       tpNLayersToken_(consumes<edm::ValueMap<unsigned int>>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNlayers"))),
       tpNPixelLayersToken_(consumes<edm::ValueMap<unsigned int>>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNpixellayers"))),
       tpNStripStereoLayersToken_(consumes<edm::ValueMap<unsigned int>>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNstripstereolayers"))),
       builderName_(iConfig.getUntrackedParameter<std::string>("TTRHBuilder")),
       parametersDefinerName_(iConfig.getUntrackedParameter<std::string>("parametersDefiner")),
       includeSeeds_(iConfig.getUntrackedParameter<bool>("includeSeeds")),
       includeAllHits_(iConfig.getUntrackedParameter<bool>("includeAllHits")),
       includeMVA_(iConfig.getUntrackedParameter<bool>("includeMVA")),
       includeTrackingParticles_(iConfig.getUntrackedParameter<bool>("includeTrackingParticles")) {
   if (includeSeeds_) {
     seedTokens_ =
         edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("seedTracks"),
                               [&](const edm::InputTag& tag) { return consumes<edm::View<reco::Track>>(tag); });
     seedStopInfoTokens_ =
         edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("trackCandidates"),
                               [&](const edm::InputTag& tag) { return consumes<std::vector<SeedStopInfo>>(tag); });
     if (seedTokens_.size() != seedStopInfoTokens_.size()) {
       throw cms::Exception("Configuration") << "Got " << seedTokens_.size() << " seed collections, but "
                                             << seedStopInfoTokens_.size() << " track candidate collections";
     }
   }
 
   if (includeAllHits_) {
     if (includeStripHits_ && includePhase2OTHits_) {
       throw cms::Exception("Configuration")
           << "Both stripDigiSimLink and phase2OTSimLink are set, please set only either one (this information is used "
              "to infer if you're running phase0/1 or phase2 detector)";
     }
     if (!includeStripHits_ && !includePhase2OTHits_) {
       throw cms::Exception("Configuration")
           << "Neither stripDigiSimLink or phase2OTSimLink are set, please set either one.";
     }
   }
 
   const bool tpRef = iConfig.getUntrackedParameter<bool>("trackingParticlesRef");
   const auto tpTag = iConfig.getUntrackedParameter<edm::InputTag>("trackingParticles");
   if (tpRef) {
     trackingParticleRefToken_ = consumes<TrackingParticleRefVector>(tpTag);
   } else {
     trackingParticleToken_ = consumes<TrackingParticleCollection>(tpTag);
   }
 
   tracer_.depth(-2);  // as in SimTracker/TrackHistory/src/TrackClassifier.cc
 
   if (includeMVA_) {
     mvaQualityCollectionTokens_ = edm::vector_transform(
         iConfig.getUntrackedParameter<std::vector<std::string>>("trackMVAs"), [&](const std::string& tag) {
           return std::make_tuple(consumes<MVACollection>(edm::InputTag(tag, "MVAValues")),
                                  consumes<QualityMaskCollection>(edm::InputTag(tag, "QualityMasks")));
         });
   }
 
   usesResource(TFileService::kSharedResource);
   edm::Service<TFileService> fs;
   t = fs->make<TTree>("tree", "tree");
 
   t->Branch("event", &ev_event);
   t->Branch("lumi", &ev_lumi);
   t->Branch("run", &ev_run);
 
   //tracks
   t->Branch("trk_px", &trk_px);
   t->Branch("trk_py", &trk_py);
   t->Branch("trk_pz", &trk_pz);
   t->Branch("trk_pt", &trk_pt);
   t->Branch("trk_inner_px", &trk_inner_px);
   t->Branch("trk_inner_py", &trk_inner_py);
   t->Branch("trk_inner_pz", &trk_inner_pz);
   t->Branch("trk_inner_pt", &trk_inner_pt);
   t->Branch("trk_outer_px", &trk_outer_px);
   t->Branch("trk_outer_py", &trk_outer_py);
   t->Branch("trk_outer_pz", &trk_outer_pz);
   t->Branch("trk_outer_pt", &trk_outer_pt);
   t->Branch("trk_eta", &trk_eta);
   t->Branch("trk_lambda", &trk_lambda);
   t->Branch("trk_cotTheta", &trk_cotTheta);
   t->Branch("trk_phi", &trk_phi);
   t->Branch("trk_dxy", &trk_dxy);
   t->Branch("trk_dz", &trk_dz);
   t->Branch("trk_dxyPV", &trk_dxyPV);
   t->Branch("trk_dzPV", &trk_dzPV);
   t->Branch("trk_dxyClosestPV", &trk_dxyClosestPV);
   t->Branch("trk_dzClosestPV", &trk_dzClosestPV);
   t->Branch("trk_ptErr", &trk_ptErr);
   t->Branch("trk_etaErr", &trk_etaErr);
   t->Branch("trk_lambdaErr", &trk_lambdaErr);
   t->Branch("trk_phiErr", &trk_phiErr);
   t->Branch("trk_dxyErr", &trk_dxyErr);
   t->Branch("trk_dzErr", &trk_dzErr);
   t->Branch("trk_refpoint_x", &trk_refpoint_x);
   t->Branch("trk_refpoint_y", &trk_refpoint_y);
   t->Branch("trk_refpoint_z", &trk_refpoint_z);
   t->Branch("trk_nChi2", &trk_nChi2);
   t->Branch("trk_nChi2_1Dmod", &trk_nChi2_1Dmod);
   t->Branch("trk_ndof", &trk_ndof);
   if (includeMVA_) {
     trk_mvas.resize(mvaQualityCollectionTokens_.size());
     trk_qualityMasks.resize(mvaQualityCollectionTokens_.size());
     if (!trk_mvas.empty()) {
       t->Branch("trk_mva", &(trk_mvas[0]));
       t->Branch("trk_qualityMask", &(trk_qualityMasks[0]));
       for (size_t i = 1; i < trk_mvas.size(); ++i) {
         t->Branch(("trk_mva" + std::to_string(i + 1)).c_str(), &(trk_mvas[i]));
         t->Branch(("trk_qualityMask" + std::to_string(i + 1)).c_str(), &(trk_qualityMasks[i]));
       }
     }
   }
   t->Branch("trk_q", &trk_q);
   t->Branch("trk_nValid", &trk_nValid);
   t->Branch("trk_nLost", &trk_nLost);
   t->Branch("trk_nInactive", &trk_nInactive);
   t->Branch("trk_nPixel", &trk_nPixel);
   t->Branch("trk_nStrip", &trk_nStrip);
   t->Branch("trk_nOuterLost", &trk_nOuterLost);
   t->Branch("trk_nInnerLost", &trk_nInnerLost);
   t->Branch("trk_nOuterInactive", &trk_nOuterInactive);
   t->Branch("trk_nInnerInactive", &trk_nInnerInactive);
   t->Branch("trk_nPixelLay", &trk_nPixelLay);
   t->Branch("trk_nStripLay", &trk_nStripLay);
   t->Branch("trk_n3DLay", &trk_n3DLay);
   t->Branch("trk_nLostLay", &trk_nLostLay);
   t->Branch("trk_nCluster", &trk_nCluster);
   t->Branch("trk_algo", &trk_algo);
   t->Branch("trk_originalAlgo", &trk_originalAlgo);
   t->Branch("trk_algoMask", &trk_algoMask);
   t->Branch("trk_stopReason", &trk_stopReason);
   t->Branch("trk_isHP", &trk_isHP);
   if (includeSeeds_) {
     t->Branch("trk_seedIdx", &trk_seedIdx);
   }
   t->Branch("trk_vtxIdx", &trk_vtxIdx);
   if (includeTrackingParticles_) {
     t->Branch("trk_simTrkIdx", &trk_simTrkIdx);
     t->Branch("trk_simTrkShareFrac", &trk_simTrkShareFrac);
     t->Branch("trk_simTrkNChi2", &trk_simTrkNChi2);
     t->Branch("trk_bestSimTrkIdx", &trk_bestSimTrkIdx);
     t->Branch("trk_bestFromFirstHitSimTrkIdx", &trk_bestFromFirstHitSimTrkIdx);
   } else {
     t->Branch("trk_isTrue", &trk_isTrue);
   }
   t->Branch("trk_bestSimTrkShareFrac", &trk_bestSimTrkShareFrac);
   t->Branch("trk_bestSimTrkShareFracSimDenom", &trk_bestSimTrkShareFracSimDenom);
   t->Branch("trk_bestSimTrkShareFracSimClusterDenom", &trk_bestSimTrkShareFracSimClusterDenom);
   t->Branch("trk_bestSimTrkNChi2", &trk_bestSimTrkNChi2);
   t->Branch("trk_bestFromFirstHitSimTrkShareFrac", &trk_bestFromFirstHitSimTrkShareFrac);
   t->Branch("trk_bestFromFirstHitSimTrkShareFracSimDenom", &trk_bestFromFirstHitSimTrkShareFracSimDenom);
   t->Branch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom", &trk_bestFromFirstHitSimTrkShareFracSimClusterDenom);
   t->Branch("trk_bestFromFirstHitSimTrkNChi2", &trk_bestFromFirstHitSimTrkNChi2);
   if (includeAllHits_) {
     t->Branch("trk_hitIdx", &trk_hitIdx);
     t->Branch("trk_hitType", &trk_hitType);
   }
   if (includeTrackingParticles_) {
     //sim tracks
     t->Branch("sim_event", &sim_event);
     t->Branch("sim_bunchCrossing", &sim_bunchCrossing);
     t->Branch("sim_pdgId", &sim_pdgId);
     t->Branch("sim_genPdgIds", &sim_genPdgIds);
     t->Branch("sim_isFromBHadron", &sim_isFromBHadron);
     t->Branch("sim_px", &sim_px);
     t->Branch("sim_py", &sim_py);
     t->Branch("sim_pz", &sim_pz);
     t->Branch("sim_pt", &sim_pt);
     t->Branch("sim_eta", &sim_eta);
     t->Branch("sim_phi", &sim_phi);
     t->Branch("sim_pca_pt", &sim_pca_pt);
     t->Branch("sim_pca_eta", &sim_pca_eta);
     t->Branch("sim_pca_lambda", &sim_pca_lambda);
     t->Branch("sim_pca_cotTheta", &sim_pca_cotTheta);
     t->Branch("sim_pca_phi", &sim_pca_phi);
     t->Branch("sim_pca_dxy", &sim_pca_dxy);
     t->Branch("sim_pca_dz", &sim_pca_dz);
     t->Branch("sim_q", &sim_q);
     t->Branch("sim_nValid", &sim_nValid);
     t->Branch("sim_nPixel", &sim_nPixel);
     t->Branch("sim_nStrip", &sim_nStrip);
     t->Branch("sim_nLay", &sim_nLay);
     t->Branch("sim_nPixelLay", &sim_nPixelLay);
     t->Branch("sim_n3DLay", &sim_n3DLay);
     t->Branch("sim_nTrackerHits", &sim_nTrackerHits);
     t->Branch("sim_nRecoClusters", &sim_nRecoClusters);
     t->Branch("sim_trkIdx", &sim_trkIdx);
     t->Branch("sim_trkShareFrac", &sim_trkShareFrac);
     if (includeSeeds_) {
       t->Branch("sim_seedIdx", &sim_seedIdx);
     }
     t->Branch("sim_parentVtxIdx", &sim_parentVtxIdx);
     t->Branch("sim_decayVtxIdx", &sim_decayVtxIdx);
     if (includeAllHits_) {
       t->Branch("sim_simHitIdx", &sim_simHitIdx);
     }
   }
   if (includeAllHits_) {
     //pixels
     t->Branch("pix_isBarrel", &pix_isBarrel);
     pix_detId.book("pix", t);
     t->Branch("pix_trkIdx", &pix_trkIdx);
     if (includeSeeds_) {
       t->Branch("pix_seeIdx", &pix_seeIdx);
     }
     if (includeTrackingParticles_) {
       t->Branch("pix_simHitIdx", &pix_simHitIdx);
       t->Branch("pix_chargeFraction", &pix_chargeFraction);
       t->Branch("pix_simType", &pix_simType);
     }
     t->Branch("pix_x", &pix_x);
     t->Branch("pix_y", &pix_y);
     t->Branch("pix_z", &pix_z);
     t->Branch("pix_xx", &pix_xx);
     t->Branch("pix_xy", &pix_xy);
     t->Branch("pix_yy", &pix_yy);
     t->Branch("pix_yz", &pix_yz);
     t->Branch("pix_zz", &pix_zz);
     t->Branch("pix_zx", &pix_zx);
     t->Branch("pix_radL", &pix_radL);
     t->Branch("pix_bbxi", &pix_bbxi);
     t->Branch("pix_bbxi", &pix_bbxi);
     //strips
     if (includeStripHits_) {
       t->Branch("str_isBarrel", &str_isBarrel);
       str_detId.book("str", t);
       t->Branch("str_trkIdx", &str_trkIdx);
       if (includeSeeds_) {
         t->Branch("str_seeIdx", &str_seeIdx);
       }
       if (includeTrackingParticles_) {
         t->Branch("str_simHitIdx", &str_simHitIdx);
         t->Branch("str_chargeFraction", &str_chargeFraction);
         t->Branch("str_simType", &str_simType);
       }
       t->Branch("str_x", &str_x);
       t->Branch("str_y", &str_y);
       t->Branch("str_z", &str_z);
       t->Branch("str_xx", &str_xx);
       t->Branch("str_xy", &str_xy);
       t->Branch("str_yy", &str_yy);
       t->Branch("str_yz", &str_yz);
       t->Branch("str_zz", &str_zz);
       t->Branch("str_zx", &str_zx);
       t->Branch("str_radL", &str_radL);
       t->Branch("str_bbxi", &str_bbxi);
       //matched hits
       t->Branch("glu_isBarrel", &glu_isBarrel);
       glu_detId.book("glu", t);
       t->Branch("glu_monoIdx", &glu_monoIdx);
       t->Branch("glu_stereoIdx", &glu_stereoIdx);
       if (includeSeeds_) {
         t->Branch("glu_seeIdx", &glu_seeIdx);
       }
       t->Branch("glu_x", &glu_x);
       t->Branch("glu_y", &glu_y);
       t->Branch("glu_z", &glu_z);
       t->Branch("glu_xx", &glu_xx);
       t->Branch("glu_xy", &glu_xy);
       t->Branch("glu_yy", &glu_yy);
       t->Branch("glu_yz", &glu_yz);
       t->Branch("glu_zz", &glu_zz);
       t->Branch("glu_zx", &glu_zx);
       t->Branch("glu_radL", &glu_radL);
       t->Branch("glu_bbxi", &glu_bbxi);
     }
     //phase2 OT
     if (includePhase2OTHits_) {
       t->Branch("ph2_isBarrel", &ph2_isBarrel);
       ph2_detId.book("ph2", t);
       t->Branch("ph2_trkIdx", &ph2_trkIdx);
       if (includeSeeds_) {
         t->Branch("ph2_seeIdx", &ph2_seeIdx);
       }
       if (includeTrackingParticles_) {
         t->Branch("ph2_simHitIdx", &ph2_simHitIdx);
         t->Branch("ph2_simType", &ph2_simType);
       }
       t->Branch("ph2_x", &ph2_x);
       t->Branch("ph2_y", &ph2_y);
       t->Branch("ph2_z", &ph2_z);
       t->Branch("ph2_xx", &ph2_xx);
       t->Branch("ph2_xy", &ph2_xy);
       t->Branch("ph2_yy", &ph2_yy);
       t->Branch("ph2_yz", &ph2_yz);
       t->Branch("ph2_zz", &ph2_zz);
       t->Branch("ph2_zx", &ph2_zx);
       t->Branch("ph2_radL", &ph2_radL);
       t->Branch("ph2_bbxi", &ph2_bbxi);
       t->Branch("ph2_bbxi", &ph2_bbxi);
     }
     //invalid hits
     t->Branch("inv_isBarrel", &inv_isBarrel);
     if (includeStripHits_)
       inv_detId.book("inv", t);
     else
       inv_detId_phase2.book("inv", t);
     t->Branch("inv_type", &inv_type);
     //simhits
     if (includeTrackingParticles_) {
       if (includeStripHits_)
         simhit_detId.book("simhit", t);
       else
         simhit_detId_phase2.book("simhit", t);
       t->Branch("simhit_x", &simhit_x);
       t->Branch("simhit_y", &simhit_y);
       t->Branch("simhit_z", &simhit_z);
       t->Branch("simhit_particle", &simhit_particle);
       t->Branch("simhit_process", &simhit_process);
       t->Branch("simhit_eloss", &simhit_eloss);
       t->Branch("simhit_tof", &simhit_tof);
       t->Branch("simhit_simTrkIdx", &simhit_simTrkIdx);
       t->Branch("simhit_hitIdx", &simhit_hitIdx);
       t->Branch("simhit_hitType", &simhit_hitType);
     }
   }
   //beam spot
   t->Branch("bsp_x", &bsp_x, "bsp_x/F");
   t->Branch("bsp_y", &bsp_y, "bsp_y/F");
   t->Branch("bsp_z", &bsp_z, "bsp_z/F");
   t->Branch("bsp_sigmax", &bsp_sigmax, "bsp_sigmax/F");
   t->Branch("bsp_sigmay", &bsp_sigmay, "bsp_sigmay/F");
   t->Branch("bsp_sigmaz", &bsp_sigmaz, "bsp_sigmaz/F");
   if (includeSeeds_) {
     //seeds
     t->Branch("see_fitok", &see_fitok);
     t->Branch("see_px", &see_px);
     t->Branch("see_py", &see_py);
     t->Branch("see_pz", &see_pz);
     t->Branch("see_pt", &see_pt);
     t->Branch("see_eta", &see_eta);
     t->Branch("see_phi", &see_phi);
     t->Branch("see_dxy", &see_dxy);
     t->Branch("see_dz", &see_dz);
     t->Branch("see_ptErr", &see_ptErr);
     t->Branch("see_etaErr", &see_etaErr);
     t->Branch("see_phiErr", &see_phiErr);
     t->Branch("see_dxyErr", &see_dxyErr);
     t->Branch("see_dzErr", &see_dzErr);
     t->Branch("see_chi2", &see_chi2);
     t->Branch("see_statePt", &see_statePt);
     t->Branch("see_stateTrajX", &see_stateTrajX);
     t->Branch("see_stateTrajY", &see_stateTrajY);
     t->Branch("see_stateTrajPx", &see_stateTrajPx);
     t->Branch("see_stateTrajPy", &see_stateTrajPy);
     t->Branch("see_stateTrajPz", &see_stateTrajPz);
     t->Branch("see_q", &see_q);
     t->Branch("see_nValid", &see_nValid);
     t->Branch("see_nPixel", &see_nPixel);
     t->Branch("see_nGlued", &see_nGlued);
     t->Branch("see_nStrip", &see_nStrip);
     t->Branch("see_nPhase2OT", &see_nPhase2OT);
     t->Branch("see_nCluster", &see_nCluster);
     t->Branch("see_algo", &see_algo);
     t->Branch("see_stopReason", &see_stopReason);
     t->Branch("see_nCands", &see_nCands);
     t->Branch("see_trkIdx", &see_trkIdx);
     if (includeTrackingParticles_) {
       t->Branch("see_simTrkIdx", &see_simTrkIdx);
       t->Branch("see_simTrkShareFrac", &see_simTrkShareFrac);
       t->Branch("see_bestSimTrkIdx", &see_bestSimTrkIdx);
       t->Branch("see_bestFromFirstHitSimTrkIdx", &see_bestFromFirstHitSimTrkIdx);
     } else {
       t->Branch("see_isTrue", &see_isTrue);
     }
     t->Branch("see_bestSimTrkShareFrac", &see_bestSimTrkShareFrac);
     t->Branch("see_bestFromFirstHitSimTrkShareFrac", &see_bestFromFirstHitSimTrkShareFrac);
     if (includeAllHits_) {
       t->Branch("see_hitIdx", &see_hitIdx);
       t->Branch("see_hitType", &see_hitType);
     }
     //seed algo offset
     t->Branch("see_offset", &see_offset);
   }
 
   //vertices
   t->Branch("vtx_x", &vtx_x);
   t->Branch("vtx_y", &vtx_y);
   t->Branch("vtx_z", &vtx_z);
   t->Branch("vtx_xErr", &vtx_xErr);
   t->Branch("vtx_yErr", &vtx_yErr);
   t->Branch("vtx_zErr", &vtx_zErr);
   t->Branch("vtx_ndof", &vtx_ndof);
   t->Branch("vtx_chi2", &vtx_chi2);
   t->Branch("vtx_fake", &vtx_fake);
   t->Branch("vtx_valid", &vtx_valid);
   t->Branch("vtx_trkIdx", &vtx_trkIdx);
 
   // tracking vertices
   t->Branch("simvtx_event", &simvtx_event);
   t->Branch("simvtx_bunchCrossing", &simvtx_bunchCrossing);
   t->Branch("simvtx_processType", &simvtx_processType);
   t->Branch("simvtx_x", &simvtx_x);
   t->Branch("simvtx_y", &simvtx_y);
   t->Branch("simvtx_z", &simvtx_z);
   t->Branch("simvtx_sourceSimIdx", &simvtx_sourceSimIdx);
   t->Branch("simvtx_daughterSimIdx", &simvtx_daughterSimIdx);
 
   t->Branch("simpv_idx", &simpv_idx);
 
   //t->Branch("" , &);
 }

TrackingNtuple::~TrackingNtuple ( )

override

Definition at line 1687 of file TrackingNtuple.cc.

                                 {
   // do anything here that needs to be done at desctruction time
   // (e.g. close files, deallocate resources etc.)
 }

Member Function Documentation

size_t TrackingNtuple::addStripMatchedHit	(	const SiStripMatchedRecHit2D &	hit,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		std::vector< std::pair< int, int >> &	monoStereoClusterList
	)

private

Definition at line 2644 of file TrackingNtuple.cc.

References TransientTrackingRecHitBuilder::build(), SiStripRecHit2D::cluster(), TrackingRecHit::geographicalId(), glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, edm::Ref< C, T, F >::key(), TrackerTopology::layer(), LogTrace, SiStripMatchedRecHit2D::monoHit(), SiStripMatchedRecHit2D::stereoHit(), StripSubdetector::TIB, and StripSubdetector::TOB.

Referenced by fillSeeds(), and fillStripMatchedHits().

                                                                                                {
   TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
   const auto hitId = hit.geographicalId();
   const int lay = tTopo.layer(hitId);
   monoStereoClusterList.emplace_back(hit.monoHit().cluster().key(), hit.stereoHit().cluster().key());
   glu_isBarrel.push_back((hitId.subdetId() == StripSubdetector::TIB || hitId.subdetId() == StripSubdetector::TOB));
   glu_detId.push_back(tTopo, hitId);
   glu_monoIdx.push_back(hit.monoHit().cluster().key());
   glu_stereoIdx.push_back(hit.stereoHit().cluster().key());
   glu_seeIdx.emplace_back();  // filled in fillSeeds
   glu_x.push_back(ttrh->globalPosition().x());
   glu_y.push_back(ttrh->globalPosition().y());
   glu_z.push_back(ttrh->globalPosition().z());
   glu_xx.push_back(ttrh->globalPositionError().cxx());
   glu_xy.push_back(ttrh->globalPositionError().cyx());
   glu_yy.push_back(ttrh->globalPositionError().cyy());
   glu_yz.push_back(ttrh->globalPositionError().czy());
   glu_zz.push_back(ttrh->globalPositionError().czz());
   glu_zx.push_back(ttrh->globalPositionError().czx());
   glu_radL.push_back(ttrh->surface()->mediumProperties().radLen());
   glu_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
   LogTrace("TrackingNtuple") << "stripMatchedHit"
                              << " cluster0=" << hit.stereoHit().cluster().key()
                              << " cluster1=" << hit.monoHit().cluster().key() << " subdId=" << hitId.subdetId()
                              << " lay=" << lay << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
   return glu_isBarrel.size() - 1;
 }

void TrackingNtuple::analyze	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overrideprivate

Definition at line 1981 of file TrackingNtuple.cc.

References align::BeamSpot, EncodedEventId::bunchCrossing(), clearVariables(), edm::EventID::event(), TrackingVertex::eventId(), Exception, fillBeamSpot(), fillPhase2OTHits(), fillPixelHits(), fillSeeds(), fillSimHits(), fillStripMatchedHits(), fillStripRphiStereoHits(), fillTrackingParticles(), fillTrackingVertices(), fillTracks(), fillVertices(), edm::EventSetup::get(), edm::Event::getByToken(), mps_fire::i, edm::EventBase::id(), edm::EDGetTokenT< T >::isUninitialized(), LogDebug, edm::EventID::luminosityBlock(), mvaQualityCollectionTokens_, edm::Handle< T >::product(), edm::RefToBaseVector< T >::push_back(), edm::RefVector< C, T, F >::push_back(), edm::View< T >::refAt(), edm::EventID::run(), edm::RefVector< C, T, F >::size(), edm::View< T >::size(), findQualityFiles::size, tpHitIndexListLessSort(), findQualityFiles::v, and pwdgSkimBPark_cfi::vertices.

                                                                                 {
   using namespace edm;
   using namespace reco;
   using namespace std;
 
   edm::ESHandle<MagneticField> mfHandle;
   iSetup.get<IdealMagneticFieldRecord>().get(mfHandle);
   const auto& mf = *mfHandle;
 
   edm::ESHandle<TransientTrackingRecHitBuilder> theTTRHBuilder;
   iSetup.get<TransientRecHitRecord>().get(builderName_, theTTRHBuilder);
 
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology& tTopo = *tTopoHandle;
 
   edm::ESHandle<TrackerGeometry> geometryHandle;
   iSetup.get<TrackerDigiGeometryRecord>().get(geometryHandle);
   const TrackerGeometry& tracker = *geometryHandle;
 
   edm::Handle<reco::TrackToTrackingParticleAssociator> theAssociator;
   iEvent.getByToken(trackAssociatorToken_, theAssociator);
   const reco::TrackToTrackingParticleAssociator& associatorByHits = *theAssociator;
 
   LogDebug("TrackingNtuple") << "Analyzing new event";
 
   //initialize tree variables
   clearVariables();
 
   // FIXME: we really need to move to edm::View for reading the
   // TrackingParticles... Unfortunately it has non-trivial
   // consequences on the associator/association interfaces etc.
   TrackingParticleRefVector tmpTP;
   const TrackingParticleRefVector* tmpTPptr = nullptr;
   edm::Handle<TrackingParticleCollection> TPCollectionH;
   edm::Handle<TrackingParticleRefVector> TPCollectionHRefVector;
 
   if (!trackingParticleToken_.isUninitialized()) {
     iEvent.getByToken(trackingParticleToken_, TPCollectionH);
     for (size_t i = 0, size = TPCollectionH->size(); i < size; ++i) {
       tmpTP.push_back(TrackingParticleRef(TPCollectionH, i));
     }
     tmpTPptr = &tmpTP;
   } else {
     iEvent.getByToken(trackingParticleRefToken_, TPCollectionHRefVector);
     tmpTPptr = TPCollectionHRefVector.product();
   }
   const TrackingParticleRefVector& tpCollection = *tmpTPptr;
 
   // Fill mapping from Ref::key() to index
   TrackingParticleRefKeyToIndex tpKeyToIndex;
   for (size_t i = 0; i < tpCollection.size(); ++i) {
     tpKeyToIndex[tpCollection[i].key()] = i;
   }
 
   // tracking vertices
   edm::Handle<TrackingVertexCollection> htv;
   iEvent.getByToken(trackingVertexToken_, htv);
   const TrackingVertexCollection& tvs = *htv;
 
   // Fill mapping from Ref::key() to index
   TrackingVertexRefVector tvRefs;
   TrackingVertexRefKeyToIndex tvKeyToIndex;
   for (size_t i = 0; i < tvs.size(); ++i) {
     const TrackingVertex& v = tvs[i];
     if (v.eventId().bunchCrossing() != 0)  // Ignore OOTPU; would be better to not to hardcode?
       continue;
     tvKeyToIndex[i] = tvRefs.size();
     tvRefs.push_back(TrackingVertexRef(htv, i));
   }
 
   //get association maps, etc.
   Handle<ClusterTPAssociation> pCluster2TPListH;
   iEvent.getByToken(clusterTPMapToken_, pCluster2TPListH);
   const ClusterTPAssociation& clusterToTPMap = *pCluster2TPListH;
   edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
   iEvent.getByToken(simHitTPMapToken_, simHitsTPAssoc);
 
   // TP -> cluster count
   TrackingParticleRefKeyToCount tpKeyToClusterCount;
   for (const auto& clusterTP : clusterToTPMap) {
     tpKeyToClusterCount[clusterTP.second.key()] += 1;
   }
 
   // SimHit key -> index mapping
   SimHitRefKeyToIndex simHitRefKeyToIndex;
 
   //make a list to link TrackingParticles to its simhits
   std::vector<TPHitIndex> tpHitList;
 
   // Count the number of reco cluster per TP
 
   std::set<edm::ProductID> hitProductIds;
   std::map<edm::ProductID, size_t> seedCollToOffset;
 
   ev_run = iEvent.id().run();
   ev_lumi = iEvent.id().luminosityBlock();
   ev_event = iEvent.id().event();
 
   // Digi->Sim links for pixels and strips
   edm::Handle<edm::DetSetVector<PixelDigiSimLink>> pixelDigiSimLinksHandle;
   iEvent.getByToken(pixelSimLinkToken_, pixelDigiSimLinksHandle);
   const auto& pixelDigiSimLinks = *pixelDigiSimLinksHandle;
 
   edm::Handle<edm::DetSetVector<StripDigiSimLink>> stripDigiSimLinksHandle;
   iEvent.getByToken(stripSimLinkToken_, stripDigiSimLinksHandle);
 
   // Phase2 OT DigiSimLink
   edm::Handle<edm::DetSetVector<PixelDigiSimLink>> siphase2OTSimLinksHandle;
   iEvent.getByToken(siphase2OTSimLinksToken_, siphase2OTSimLinksHandle);
 
   //beamspot
   Handle<reco::BeamSpot> recoBeamSpotHandle;
   iEvent.getByToken(beamSpotToken_, recoBeamSpotHandle);
   BeamSpot const& bs = *recoBeamSpotHandle;
   fillBeamSpot(bs);
 
   //prapare list to link matched hits to collection
   vector<pair<int, int>> monoStereoClusterList;
   if (includeAllHits_) {
     // simhits, only if TPs are saved as well
     if (includeTrackingParticles_) {
       fillSimHits(tracker, tpKeyToIndex, *simHitsTPAssoc, tTopo, simHitRefKeyToIndex, tpHitList);
     }
 
     //pixel hits
     fillPixelHits(iEvent,
                   clusterToTPMap,
                   tpKeyToIndex,
                   *simHitsTPAssoc,
                   pixelDigiSimLinks,
                   *theTTRHBuilder,
                   tTopo,
                   simHitRefKeyToIndex,
                   hitProductIds);
 
     //strip hits
     if (includeStripHits_) {
       LogDebug("TrackingNtuple") << "foundStripSimLink";
       const auto& stripDigiSimLinks = *stripDigiSimLinksHandle;
       fillStripRphiStereoHits(iEvent,
                               clusterToTPMap,
                               tpKeyToIndex,
                               *simHitsTPAssoc,
                               stripDigiSimLinks,
                               *theTTRHBuilder,
                               tTopo,
                               simHitRefKeyToIndex,
                               hitProductIds);
 
       //matched hits
       fillStripMatchedHits(iEvent, *theTTRHBuilder, tTopo, monoStereoClusterList);
     }
 
     if (includePhase2OTHits_) {
       LogDebug("TrackingNtuple") << "foundPhase2OTSimLinks";
       const auto& phase2OTSimLinks = *siphase2OTSimLinksHandle;
       fillPhase2OTHits(iEvent,
                        clusterToTPMap,
                        tpKeyToIndex,
                        *simHitsTPAssoc,
                        phase2OTSimLinks,
                        *theTTRHBuilder,
                        tTopo,
                        simHitRefKeyToIndex,
                        hitProductIds);
     }
   }
 
   //seeds
   if (includeSeeds_) {
     fillSeeds(iEvent,
               tpCollection,
               tpKeyToIndex,
               bs,
               associatorByHits,
               clusterToTPMap,
               *theTTRHBuilder,
               mf,
               tTopo,
               monoStereoClusterList,
               hitProductIds,
               seedCollToOffset);
   }
 
   //tracks
   edm::Handle<edm::View<reco::Track>> tracksHandle;
   iEvent.getByToken(trackToken_, tracksHandle);
   const edm::View<reco::Track>& tracks = *tracksHandle;
   // The associator interfaces really need to be fixed...
   edm::RefToBaseVector<reco::Track> trackRefs;
   for (edm::View<Track>::size_type i = 0; i < tracks.size(); ++i) {
     trackRefs.push_back(tracks.refAt(i));
   }
   std::vector<const MVACollection*> mvaColls;
   std::vector<const QualityMaskCollection*> qualColls;
   if (includeMVA_) {
     edm::Handle<MVACollection> hmva;
     edm::Handle<QualityMaskCollection> hqual;
 
     for (const auto& tokenTpl : mvaQualityCollectionTokens_) {
       iEvent.getByToken(std::get<0>(tokenTpl), hmva);
       iEvent.getByToken(std::get<1>(tokenTpl), hqual);
 
       mvaColls.push_back(hmva.product());
       qualColls.push_back(hqual.product());
       if (mvaColls.back()->size() != tracks.size()) {
         throw cms::Exception("Configuration")
             << "Inconsistency in track collection and MVA sizes. Track collection has " << tracks.size()
             << " tracks, whereas the MVA " << (mvaColls.size() - 1) << " has " << mvaColls.back()->size()
             << " entries. Double-check your configuration.";
       }
       if (qualColls.back()->size() != tracks.size()) {
         throw cms::Exception("Configuration")
             << "Inconsistency in track collection and quality mask sizes. Track collection has " << tracks.size()
             << " tracks, whereas the quality mask " << (qualColls.size() - 1) << " has " << qualColls.back()->size()
             << " entries. Double-check your configuration.";
       }
     }
   }
 
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(vertexToken_, vertices);
 
   fillTracks(trackRefs,
              tpCollection,
              tpKeyToIndex,
              tpKeyToClusterCount,
              mf,
              bs,
              *vertices,
              associatorByHits,
              clusterToTPMap,
              *theTTRHBuilder,
              tTopo,
              hitProductIds,
              seedCollToOffset,
              mvaColls,
              qualColls);
 
   //tracking particles
   //sort association maps with simHits
   std::sort(tpHitList.begin(), tpHitList.end(), tpHitIndexListLessSort);
   fillTrackingParticles(
       iEvent, iSetup, trackRefs, bs, tpCollection, tvKeyToIndex, associatorByHits, tpHitList, tpKeyToClusterCount);
 
   // vertices
   fillVertices(*vertices, trackRefs);
 
   // tracking vertices
   fillTrackingVertices(tvRefs, tpKeyToIndex);
 
   t->Fill();
 }

void TrackingNtuple::clearVariables ( )

private

Definition at line 1695 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, beam_dqm_sourceclient-live_cfg::mva, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_bestFromFirstHitSimTrkIdx, see_bestFromFirstHitSimTrkShareFrac, see_bestSimTrkIdx, see_bestSimTrkShareFrac, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_nCands, see_nCluster, see_nGlued, see_nPhase2OT, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_simTrkIdx, see_simTrkShareFrac, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_seedIdx, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_hitIdx, trk_hitType, trk_isHP, trk_isTrue, trk_seedIdx, trk_simTrkIdx, trk_simTrkNChi2, trk_simTrkShareFrac, trk_stopReason, trk_vtxIdx, vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

Referenced by analyze().

                                     {
   ev_run = 0;
   ev_lumi = 0;
   ev_event = 0;
 
   //tracks
   trk_px.clear();
   trk_py.clear();
   trk_pz.clear();
   trk_pt.clear();
   trk_inner_px.clear();
   trk_inner_py.clear();
   trk_inner_pz.clear();
   trk_inner_pt.clear();
   trk_outer_px.clear();
   trk_outer_py.clear();
   trk_outer_pz.clear();
   trk_outer_pt.clear();
   trk_eta.clear();
   trk_lambda.clear();
   trk_cotTheta.clear();
   trk_phi.clear();
   trk_dxy.clear();
   trk_dz.clear();
   trk_dxyPV.clear();
   trk_dzPV.clear();
   trk_dxyClosestPV.clear();
   trk_dzClosestPV.clear();
   trk_ptErr.clear();
   trk_etaErr.clear();
   trk_lambdaErr.clear();
   trk_phiErr.clear();
   trk_dxyErr.clear();
   trk_dzErr.clear();
   trk_refpoint_x.clear();
   trk_refpoint_y.clear();
   trk_refpoint_z.clear();
   trk_nChi2.clear();
   trk_nChi2_1Dmod.clear();
   trk_ndof.clear();
   for (auto& mva : trk_mvas) {
     mva.clear();
   }
   for (auto& mask : trk_qualityMasks) {
     mask.clear();
   }
   trk_q.clear();
   trk_nValid.clear();
   trk_nLost.clear();
   trk_nInactive.clear();
   trk_nPixel.clear();
   trk_nStrip.clear();
   trk_nOuterLost.clear();
   trk_nInnerLost.clear();
   trk_nOuterInactive.clear();
   trk_nInnerInactive.clear();
   trk_nPixelLay.clear();
   trk_nStripLay.clear();
   trk_n3DLay.clear();
   trk_nLostLay.clear();
   trk_nCluster.clear();
   trk_algo.clear();
   trk_originalAlgo.clear();
   trk_algoMask.clear();
   trk_stopReason.clear();
   trk_isHP.clear();
   trk_seedIdx.clear();
   trk_vtxIdx.clear();
   trk_isTrue.clear();
   trk_bestSimTrkIdx.clear();
   trk_bestSimTrkShareFrac.clear();
   trk_bestSimTrkShareFracSimDenom.clear();
   trk_bestSimTrkShareFracSimClusterDenom.clear();
   trk_bestSimTrkNChi2.clear();
   trk_bestFromFirstHitSimTrkIdx.clear();
   trk_bestFromFirstHitSimTrkShareFrac.clear();
   trk_bestFromFirstHitSimTrkShareFracSimDenom.clear();
   trk_bestFromFirstHitSimTrkShareFracSimClusterDenom.clear();
   trk_bestFromFirstHitSimTrkNChi2.clear();
   trk_simTrkIdx.clear();
   trk_simTrkShareFrac.clear();
   trk_simTrkNChi2.clear();
   trk_hitIdx.clear();
   trk_hitType.clear();
   //sim tracks
   sim_event.clear();
   sim_bunchCrossing.clear();
   sim_pdgId.clear();
   sim_genPdgIds.clear();
   sim_isFromBHadron.clear();
   sim_px.clear();
   sim_py.clear();
   sim_pz.clear();
   sim_pt.clear();
   sim_eta.clear();
   sim_phi.clear();
   sim_pca_pt.clear();
   sim_pca_eta.clear();
   sim_pca_lambda.clear();
   sim_pca_cotTheta.clear();
   sim_pca_phi.clear();
   sim_pca_dxy.clear();
   sim_pca_dz.clear();
   sim_q.clear();
   sim_nValid.clear();
   sim_nPixel.clear();
   sim_nStrip.clear();
   sim_nLay.clear();
   sim_nPixelLay.clear();
   sim_n3DLay.clear();
   sim_nTrackerHits.clear();
   sim_nRecoClusters.clear();
   sim_trkIdx.clear();
   sim_seedIdx.clear();
   sim_trkShareFrac.clear();
   sim_parentVtxIdx.clear();
   sim_decayVtxIdx.clear();
   sim_simHitIdx.clear();
   //pixels
   pix_isBarrel.clear();
   pix_detId.clear();
   pix_trkIdx.clear();
   pix_seeIdx.clear();
   pix_simHitIdx.clear();
   pix_chargeFraction.clear();
   pix_simType.clear();
   pix_x.clear();
   pix_y.clear();
   pix_z.clear();
   pix_xx.clear();
   pix_xy.clear();
   pix_yy.clear();
   pix_yz.clear();
   pix_zz.clear();
   pix_zx.clear();
   pix_radL.clear();
   pix_bbxi.clear();
   //strips
   str_isBarrel.clear();
   str_detId.clear();
   str_trkIdx.clear();
   str_seeIdx.clear();
   str_simHitIdx.clear();
   str_chargeFraction.clear();
   str_simType.clear();
   str_x.clear();
   str_y.clear();
   str_z.clear();
   str_xx.clear();
   str_xy.clear();
   str_yy.clear();
   str_yz.clear();
   str_zz.clear();
   str_zx.clear();
   str_radL.clear();
   str_bbxi.clear();
   //matched hits
   glu_isBarrel.clear();
   glu_detId.clear();
   glu_monoIdx.clear();
   glu_stereoIdx.clear();
   glu_seeIdx.clear();
   glu_x.clear();
   glu_y.clear();
   glu_z.clear();
   glu_xx.clear();
   glu_xy.clear();
   glu_yy.clear();
   glu_yz.clear();
   glu_zz.clear();
   glu_zx.clear();
   glu_radL.clear();
   glu_bbxi.clear();
   //phase2 OT
   ph2_isBarrel.clear();
   ph2_detId.clear();
   ph2_trkIdx.clear();
   ph2_seeIdx.clear();
   ph2_simHitIdx.clear();
   ph2_simType.clear();
   ph2_x.clear();
   ph2_y.clear();
   ph2_z.clear();
   ph2_xx.clear();
   ph2_xy.clear();
   ph2_yy.clear();
   ph2_yz.clear();
   ph2_zz.clear();
   ph2_zx.clear();
   ph2_radL.clear();
   ph2_bbxi.clear();
   //invalid hits
   inv_isBarrel.clear();
   inv_detId.clear();
   inv_detId_phase2.clear();
   inv_type.clear();
   // simhits
   simhit_detId.clear();
   simhit_detId_phase2.clear();
   simhit_x.clear();
   simhit_y.clear();
   simhit_z.clear();
   simhit_particle.clear();
   simhit_process.clear();
   simhit_eloss.clear();
   simhit_tof.clear();
   //simhit_simTrackId.clear();
   simhit_simTrkIdx.clear();
   simhit_hitIdx.clear();
   simhit_hitType.clear();
   //beamspot
   bsp_x = -9999.;
   bsp_y = -9999.;
   bsp_z = -9999.;
   bsp_sigmax = -9999.;
   bsp_sigmay = -9999.;
   bsp_sigmaz = -9999.;
   //seeds
   see_fitok.clear();
   see_px.clear();
   see_py.clear();
   see_pz.clear();
   see_pt.clear();
   see_eta.clear();
   see_phi.clear();
   see_dxy.clear();
   see_dz.clear();
   see_ptErr.clear();
   see_etaErr.clear();
   see_phiErr.clear();
   see_dxyErr.clear();
   see_dzErr.clear();
   see_chi2.clear();
   see_statePt.clear();
   see_stateTrajX.clear();
   see_stateTrajY.clear();
   see_stateTrajPx.clear();
   see_stateTrajPy.clear();
   see_stateTrajPz.clear();
   see_q.clear();
   see_nValid.clear();
   see_nPixel.clear();
   see_nGlued.clear();
   see_nStrip.clear();
   see_nPhase2OT.clear();
   see_nCluster.clear();
   see_algo.clear();
   see_stopReason.clear();
   see_nCands.clear();
   see_trkIdx.clear();
   see_bestSimTrkIdx.clear();
   see_bestSimTrkShareFrac.clear();
   see_bestFromFirstHitSimTrkIdx.clear();
   see_bestFromFirstHitSimTrkShareFrac.clear();
   see_simTrkIdx.clear();
   see_simTrkShareFrac.clear();
   see_hitIdx.clear();
   see_hitType.clear();
   //seed algo offset
   see_offset.clear();
 
   // vertices
   vtx_x.clear();
   vtx_y.clear();
   vtx_z.clear();
   vtx_xErr.clear();
   vtx_yErr.clear();
   vtx_zErr.clear();
   vtx_ndof.clear();
   vtx_chi2.clear();
   vtx_fake.clear();
   vtx_valid.clear();
   vtx_trkIdx.clear();
 
   // Tracking vertices
   simvtx_event.clear();
   simvtx_bunchCrossing.clear();
   simvtx_x.clear();
   simvtx_y.clear();
   simvtx_z.clear();
   simvtx_sourceSimIdx.clear();
   simvtx_daughterSimIdx.clear();
   simpv_idx.clear();
 }

void TrackingNtuple::fillBeamSpot ( const reco::BeamSpot & bs )

private

Definition at line 2236 of file TrackingNtuple.cc.

References reco::BeamSpot::BeamWidthX(), reco::BeamSpot::BeamWidthY(), bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, OmniClusterRef::pixelCluster(), reco::BeamSpot::sigmaZ(), OmniClusterRef::stripCluster(), reco::BeamSpot::x0(), and reco::BeamSpot::y0().

Referenced by analyze().

                                                         {
   bsp_x = bs.x0();
   bsp_y = bs.y0();
   bsp_z = bs.x0();
   bsp_sigmax = bs.BeamWidthX();
   bsp_sigmay = bs.BeamWidthY();
   bsp_sigmaz = bs.sigmaZ();
 }

void TrackingNtuple::fillDescriptions ( edm::ConfigurationDescriptions & descriptions )

static

Definition at line 3624 of file TrackingNtuple.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), DEFINE_FWK_MODULE, HLT_2018_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                 {
   //The following says we do not know what parameters are allowed so do no validation
   // Please change this to state exactly what you do use, even if it is no parameters
   edm::ParameterSetDescription desc;
   desc.addUntracked<std::vector<edm::InputTag>>(
       "seedTracks",
       std::vector<edm::InputTag>{edm::InputTag("seedTracksinitialStepSeeds"),
                                  edm::InputTag("seedTracksdetachedTripletStepSeeds"),
                                  edm::InputTag("seedTrackspixelPairStepSeeds"),
                                  edm::InputTag("seedTrackslowPtTripletStepSeeds"),
                                  edm::InputTag("seedTracksmixedTripletStepSeeds"),
                                  edm::InputTag("seedTrackspixelLessStepSeeds"),
                                  edm::InputTag("seedTrackstobTecStepSeeds"),
                                  edm::InputTag("seedTracksjetCoreRegionalStepSeeds"),
                                  edm::InputTag("seedTracksmuonSeededSeedsInOut"),
                                  edm::InputTag("seedTracksmuonSeededSeedsOutIn")});
   desc.addUntracked<std::vector<edm::InputTag>>(
       "trackCandidates",
       std::vector<edm::InputTag>{edm::InputTag("initialStepTrackCandidates"),
                                  edm::InputTag("detachedTripletStepTrackCandidates"),
                                  edm::InputTag("pixelPairStepTrackCandidates"),
                                  edm::InputTag("lowPtTripletStepTrackCandidates"),
                                  edm::InputTag("mixedTripletStepTrackCandidates"),
                                  edm::InputTag("pixelLessStepTrackCandidates"),
                                  edm::InputTag("tobTecStepTrackCandidates"),
                                  edm::InputTag("jetCoreRegionalStepTrackCandidates"),
                                  edm::InputTag("muonSeededTrackCandidatesInOut"),
                                  edm::InputTag("muonSeededTrackCandidatesOutIn")});
   desc.addUntracked<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.addUntracked<std::vector<std::string>>("trackMVAs", std::vector<std::string>{{"generalTracks"}});
   desc.addUntracked<edm::InputTag>("trackingParticles", edm::InputTag("mix", "MergedTrackTruth"));
   desc.addUntracked<bool>("trackingParticlesRef", false);
   desc.addUntracked<edm::InputTag>("clusterTPMap", edm::InputTag("tpClusterProducer"));
   desc.addUntracked<edm::InputTag>("simHitTPMap", edm::InputTag("simHitTPAssocProducer"));
   desc.addUntracked<edm::InputTag>("trackAssociator", edm::InputTag("quickTrackAssociatorByHits"));
   desc.addUntracked<edm::InputTag>("pixelDigiSimLink", edm::InputTag("simSiPixelDigis"));
   desc.addUntracked<edm::InputTag>("stripDigiSimLink", edm::InputTag("simSiStripDigis"));
   desc.addUntracked<edm::InputTag>("phase2OTSimLink", edm::InputTag(""));
   desc.addUntracked<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
   desc.addUntracked<edm::InputTag>("pixelRecHits", edm::InputTag("siPixelRecHits"));
   desc.addUntracked<edm::InputTag>("stripRphiRecHits", edm::InputTag("siStripMatchedRecHits", "rphiRecHit"));
   desc.addUntracked<edm::InputTag>("stripStereoRecHits", edm::InputTag("siStripMatchedRecHits", "stereoRecHit"));
   desc.addUntracked<edm::InputTag>("stripMatchedRecHits", edm::InputTag("siStripMatchedRecHits", "matchedRecHit"));
   desc.addUntracked<edm::InputTag>("phase2OTRecHits", edm::InputTag("siPhase2RecHits"));
   desc.addUntracked<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.addUntracked<edm::InputTag>("trackingVertices", edm::InputTag("mix", "MergedTrackTruth"));
   desc.addUntracked<edm::InputTag>("trackingParticleNlayers",
                                    edm::InputTag("trackingParticleNumberOfLayersProducer", "trackerLayers"));
   desc.addUntracked<edm::InputTag>("trackingParticleNpixellayers",
                                    edm::InputTag("trackingParticleNumberOfLayersProducer", "pixelLayers"));
   desc.addUntracked<edm::InputTag>("trackingParticleNstripstereolayers",
                                    edm::InputTag("trackingParticleNumberOfLayersProducer", "stripStereoLayers"));
   desc.addUntracked<std::string>("TTRHBuilder", "WithTrackAngle");
   desc.addUntracked<std::string>("parametersDefiner", "LhcParametersDefinerForTP");
   desc.addUntracked<bool>("includeSeeds", false);
   desc.addUntracked<bool>("includeAllHits", false);
   desc.addUntracked<bool>("includeMVA", true);
   desc.addUntracked<bool>("includeTrackingParticles", true);
   descriptions.add("trackingNtuple", desc);
 }

void TrackingNtuple::fillPhase2OTHits	(	const edm::Event &	iEvent,
		const ClusterTPAssociation &	clusterToTPMap,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const SimHitTPAssociationProducer::SimHitTPAssociationList &	simHitsTPAssoc,
		const edm::DetSetVector< PixelDigiSimLink > &	digiSimLink,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		const SimHitRefKeyToIndex &	simHitRefKeyToIndex,
		std::set< edm::ProductID > &	hitProductIds
	)

private

Definition at line 2688 of file TrackingNtuple.cc.

References edmNew::DetSetVector< T >::begin(), TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, edmNew::DetSetVector< T >::end(), TrackingNtuple::SimHitData::event, SiStripMatchedRecHit2D::firstClusterRef(), edm::Event::getByToken(), crabWrapper::key, TrackerTopology::layer(), LogTrace, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, Phase2OT, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), and TrackingNtuple::SimHitData::type.

Referenced by analyze().

                                                                            {
   edm::Handle<Phase2TrackerRecHit1DCollectionNew> phase2OTHits;
   iEvent.getByToken(phase2OTRecHitToken_, phase2OTHits);
   for (auto it = phase2OTHits->begin(); it != phase2OTHits->end(); it++) {
     const DetId hitId = it->detId();
     for (auto hit = it->begin(); hit != it->end(); hit++) {
       TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
 
       hitProductIds.insert(hit->cluster().id());
 
       const int key = hit->cluster().key();
       const int lay = tTopo.layer(hitId);
 
       ph2_isBarrel.push_back(hitId.subdetId() == 1);
       ph2_detId.push_back(tTopo, hitId);
       ph2_trkIdx.emplace_back();  // filled in fillTracks
       ph2_seeIdx.emplace_back();  // filled in fillSeeds
       ph2_x.push_back(ttrh->globalPosition().x());
       ph2_y.push_back(ttrh->globalPosition().y());
       ph2_z.push_back(ttrh->globalPosition().z());
       ph2_xx.push_back(ttrh->globalPositionError().cxx());
       ph2_xy.push_back(ttrh->globalPositionError().cyx());
       ph2_yy.push_back(ttrh->globalPositionError().cyy());
       ph2_yz.push_back(ttrh->globalPositionError().czy());
       ph2_zz.push_back(ttrh->globalPositionError().czz());
       ph2_zx.push_back(ttrh->globalPositionError().czx());
       ph2_radL.push_back(ttrh->surface()->mediumProperties().radLen());
       ph2_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
 
       LogTrace("TrackingNtuple") << "phase2 OT cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                  << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
 
       if (includeTrackingParticles_) {
         SimHitData simHitData = matchCluster(hit->firstClusterRef(),
                                              hitId,
                                              key,
                                              ttrh,
                                              clusterToTPMap,
                                              tpKeyToIndex,
                                              simHitsTPAssoc,
                                              digiSimLink,
                                              simHitRefKeyToIndex,
                                              HitType::Phase2OT);
         ph2_simHitIdx.push_back(simHitData.matchingSimHit);
         ph2_simType.push_back(static_cast<int>(simHitData.type));
         LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
         if (!simHitData.matchingSimHit.empty()) {
           const auto simHitIdx = simHitData.matchingSimHit[0];
           LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
                                      << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                      << " energyLoss=" << simhit_eloss[simHitIdx]
                                      << " particleType=" << simhit_particle[simHitIdx]
                                      << " processType=" << simhit_process[simHitIdx]
                                      << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                      << " event=" << simHitData.event[0];
         }
       }
     }
   }
 }

void TrackingNtuple::fillPixelHits	(	const edm::Event &	iEvent,
		const ClusterTPAssociation &	clusterToTPMap,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const SimHitTPAssociationProducer::SimHitTPAssociationList &	simHitsTPAssoc,
		const edm::DetSetVector< PixelDigiSimLink > &	digiSimLink,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		const SimHitRefKeyToIndex &	simHitRefKeyToIndex,
		std::set< edm::ProductID > &	hitProductIds
	)

private

Definition at line 2479 of file TrackingNtuple.cc.

References edmNew::DetSetVector< T >::begin(), TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, edmNew::DetSetVector< T >::end(), TrackingNtuple::SimHitData::event, SiStripMatchedRecHit2D::firstClusterRef(), edm::Event::getByToken(), crabWrapper::key, TrackerTopology::layer(), LogTrace, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, Pixel, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), and TrackingNtuple::SimHitData::type.

Referenced by analyze().

                                                                         {
   edm::Handle<SiPixelRecHitCollection> pixelHits;
   iEvent.getByToken(pixelRecHitToken_, pixelHits);
   for (auto it = pixelHits->begin(); it != pixelHits->end(); it++) {
     const DetId hitId = it->detId();
     for (auto hit = it->begin(); hit != it->end(); hit++) {
       TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
 
       hitProductIds.insert(hit->cluster().id());
 
       const int key = hit->cluster().key();
       const int lay = tTopo.layer(hitId);
 
       pix_isBarrel.push_back(hitId.subdetId() == 1);
       pix_detId.push_back(tTopo, hitId);
       pix_trkIdx.emplace_back();  // filled in fillTracks
       pix_seeIdx.emplace_back();  // filled in fillSeeds
       pix_x.push_back(ttrh->globalPosition().x());
       pix_y.push_back(ttrh->globalPosition().y());
       pix_z.push_back(ttrh->globalPosition().z());
       pix_xx.push_back(ttrh->globalPositionError().cxx());
       pix_xy.push_back(ttrh->globalPositionError().cyx());
       pix_yy.push_back(ttrh->globalPositionError().cyy());
       pix_yz.push_back(ttrh->globalPositionError().czy());
       pix_zz.push_back(ttrh->globalPositionError().czz());
       pix_zx.push_back(ttrh->globalPositionError().czx());
       pix_radL.push_back(ttrh->surface()->mediumProperties().radLen());
       pix_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
 
       LogTrace("TrackingNtuple") << "pixHit cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                  << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
       if (includeTrackingParticles_) {
         SimHitData simHitData = matchCluster(hit->firstClusterRef(),
                                              hitId,
                                              key,
                                              ttrh,
                                              clusterToTPMap,
                                              tpKeyToIndex,
                                              simHitsTPAssoc,
                                              digiSimLink,
                                              simHitRefKeyToIndex,
                                              HitType::Pixel);
         pix_simHitIdx.push_back(simHitData.matchingSimHit);
         pix_simType.push_back(static_cast<int>(simHitData.type));
         pix_chargeFraction.push_back(simHitData.chargeFraction);
         LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
         if (!simHitData.matchingSimHit.empty()) {
           const auto simHitIdx = simHitData.matchingSimHit[0];
           LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
                                      << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                      << " energyLoss=" << simhit_eloss[simHitIdx]
                                      << " particleType=" << simhit_particle[simHitIdx]
                                      << " processType=" << simhit_process[simHitIdx]
                                      << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                      << " event=" << simHitData.event[0];
         }
       }
     }
   }
 }

void TrackingNtuple::fillSeeds	(	const edm::Event &	iEvent,
		const TrackingParticleRefVector &	tpCollection,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const reco::BeamSpot &	bs,
		const reco::TrackToTrackingParticleAssociator &	associatorByHits,
		const ClusterTPAssociation &	clusterToTPMap,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const MagneticField &	theMF,
		const TrackerTopology &	tTopo,
		std::vector< std::pair< int, int >> &	monoStereoClusterList,
		const std::set< edm::ProductID > &	hitProductIds,
		std::map< edm::ProductID, size_t > &	seedToCollIndex
	)

private

Hmm, the following could make sense instead of plain failing if propagation to beam line fails

Definition at line 2757 of file TrackingNtuple.cc.

References addStripMatchedHit(), ecalcalib_dqm_sourceclient-live_cfg::algo, reco::TrackBase::algoByName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), reco::TrackToTrackingParticleAssociator::associateSimToReco(), TransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, RZLine::chi2(), OmniClusterRef::cluster_phase2OT(), OmniClusterRef::cluster_pixel(), KineDebug3::count(), declareDynArray, HLT_2018_cff::distance, edm::AssociationMap< Tag >::end(), PVValHelper::eta, Exception, fillTrackingParticlesForSeeds(), spr::find(), edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), edm::Event::getByToken(), glu_seeIdx, Glued, runTauDisplay::gp, track_associator::hitsToClusterRefs(), mps_fire::i, triggerObjects_cff::id, OmniClusterRef::id(), createfilelist::int, trackerHitRTTI::isMatched(), OmniClusterRef::key(), edm::Ref< C, T, F >::key(), label, SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), LogTrace, edm::ProductLabels::module, SiStripMatchedRecHit2D::monoClusterRef(), heavyionUCCDQM_cfi::nClusters, hltrates_dqm_sourceclient-live_cfg::offset, ph2_seeIdx, Phase2OT, phi, pix_seeIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::BeamSpot::position(), DiDispStaMuonMonitor_cfi::pt, edm::RefToBaseVector< T >::push_back(), rpcPointValidation_cfi::recHit, see_algo, see_bestFromFirstHitSimTrkIdx, see_bestFromFirstHitSimTrkShareFrac, see_bestSimTrkIdx, see_bestSimTrkShareFrac, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_isTrue, see_nCands, see_nCluster, see_nGlued, see_nPhase2OT, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_simTrkIdx, see_simTrkShareFrac, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, SurveyInfoScenario_cff::seed, trackingNtuple_cff::seedTracks, edm::RefToBaseVector< T >::size(), SiStripMatchedRecHit2D::stereoClusterRef(), str_seeIdx, Strip, StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, and trackFromSeedFitFailed().

Referenced by analyze().

                                                                                {
   TSCBLBuilderNoMaterial tscblBuilder;
   for (size_t iColl = 0; iColl < seedTokens_.size(); ++iColl) {
     const auto& seedToken = seedTokens_[iColl];
 
     edm::Handle<edm::View<reco::Track>> seedTracksHandle;
     iEvent.getByToken(seedToken, seedTracksHandle);
     const auto& seedTracks = *seedTracksHandle;
 
     if (seedTracks.empty())
       continue;
 
     edm::EDConsumerBase::Labels labels;
     labelsForToken(seedToken, labels);
 
     const auto& seedStopInfoToken = seedStopInfoTokens_[iColl];
     edm::Handle<std::vector<SeedStopInfo>> seedStopInfoHandle;
     iEvent.getByToken(seedStopInfoToken, seedStopInfoHandle);
     const auto& seedStopInfos = *seedStopInfoHandle;
     if (seedTracks.size() != seedStopInfos.size()) {
       edm::EDConsumerBase::Labels labels2;
       labelsForToken(seedStopInfoToken, labels2);
 
       throw cms::Exception("LogicError") << "Got " << seedTracks.size() << " seeds, but " << seedStopInfos.size()
                                          << " seed stopping infos for collections " << labels.module << ", "
                                          << labels2.module;
     }
 
     // The associator interfaces really need to be fixed...
     edm::RefToBaseVector<reco::Track> seedTrackRefs;
     for (edm::View<reco::Track>::size_type i = 0; i < seedTracks.size(); ++i) {
       seedTrackRefs.push_back(seedTracks.refAt(i));
     }
     reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(seedTrackRefs, tpCollection);
     reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(seedTrackRefs, tpCollection);
 
     TString label = labels.module;
     //format label to match algoName
     label.ReplaceAll("seedTracks", "");
     label.ReplaceAll("Seeds", "");
     label.ReplaceAll("muonSeeded", "muonSeededStep");
     int algo = reco::TrackBase::algoByName(label.Data());
 
     edm::ProductID id = seedTracks[0].seedRef().id();
     const auto offset = see_fitok.size();
     auto inserted = seedCollToOffset.emplace(id, offset);
     if (!inserted.second)
       throw cms::Exception("Configuration")
           << "Trying to add seeds with ProductID " << id << " for a second time from collection " << labels.module
           << ", seed algo " << label << ". Typically this is caused by a configuration problem.";
     see_offset.push_back(offset);
 
     LogTrace("TrackingNtuple") << "NEW SEED LABEL: " << label << " size: " << seedTracks.size() << " algo=" << algo
                                << " ProductID " << id;
 
     for (size_t iSeed = 0; iSeed < seedTrackRefs.size(); ++iSeed) {
       const auto& seedTrackRef = seedTrackRefs[iSeed];
       const auto& seedTrack = *seedTrackRef;
       const auto& seedRef = seedTrack.seedRef();
       const auto& seed = *seedRef;
 
       const auto seedStopInfo = seedStopInfos[iSeed];
 
       if (seedRef.id() != id)
         throw cms::Exception("LogicError")
             << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the "
                "element 0 had ProductID "
             << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id()
             << ". The source collection is " << labels.module << ".";
 
       std::vector<int> tpIdx;
       std::vector<float> sharedFraction;
       auto foundTPs = recSimColl.find(seedTrackRef);
       if (foundTPs != recSimColl.end()) {
         for (const auto tpQuality : foundTPs->val) {
           tpIdx.push_back(tpKeyToIndex.at(tpQuality.first.key()));
           sharedFraction.push_back(tpQuality.second);
         }
       }
 
       // Search for a best-matching TrackingParticle for a seed
       const int nHits = seedTrack.numberOfValidHits();
       const auto clusters = track_associator::hitsToClusterRefs(
           seedTrack.recHitsBegin(),
           seedTrack.recHitsEnd());  // TODO: this function is called 3 times per track, try to reduce
       const int nClusters = clusters.size();
       const auto bestKeyCount = findBestMatchingTrackingParticle(seedTrack, clusterToTPMap, tpKeyToIndex);
       const float bestShareFrac =
           nClusters > 0 ? static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(nClusters) : 0;
       // Another way starting from the first hit of the seed
       const auto bestFirstHitKeyCount =
           findMatchingTrackingParticleFromFirstHit(seedTrack, clusterToTPMap, tpKeyToIndex);
       const float bestFirstHitShareFrac =
           nClusters > 0 ? static_cast<float>(bestFirstHitKeyCount.countClusters) / static_cast<float>(nClusters) : 0;
 
       const bool seedFitOk = !trackFromSeedFitFailed(seedTrack);
       const int charge = seedTrack.charge();
       const float pt = seedFitOk ? seedTrack.pt() : 0;
       const float eta = seedFitOk ? seedTrack.eta() : 0;
       const float phi = seedFitOk ? seedTrack.phi() : 0;
 
       const auto seedIndex = see_fitok.size();
 
       see_fitok.push_back(seedFitOk);
 
       see_px.push_back(seedFitOk ? seedTrack.px() : 0);
       see_py.push_back(seedFitOk ? seedTrack.py() : 0);
       see_pz.push_back(seedFitOk ? seedTrack.pz() : 0);
       see_pt.push_back(pt);
       see_eta.push_back(eta);
       see_phi.push_back(phi);
       see_q.push_back(charge);
       see_nValid.push_back(nHits);
 
       see_dxy.push_back(seedFitOk ? seedTrack.dxy(bs.position()) : 0);
       see_dz.push_back(seedFitOk ? seedTrack.dz(bs.position()) : 0);
       see_ptErr.push_back(seedFitOk ? seedTrack.ptError() : 0);
       see_etaErr.push_back(seedFitOk ? seedTrack.etaError() : 0);
       see_phiErr.push_back(seedFitOk ? seedTrack.phiError() : 0);
       see_dxyErr.push_back(seedFitOk ? seedTrack.dxyError() : 0);
       see_dzErr.push_back(seedFitOk ? seedTrack.dzError() : 0);
       see_algo.push_back(algo);
       see_stopReason.push_back(seedStopInfo.stopReasonUC());
       see_nCands.push_back(seedStopInfo.candidatesPerSeed());
 
       const auto& state = seedTrack.seedRef()->startingState();
       const auto& pos = state.parameters().position();
       const auto& mom = state.parameters().momentum();
       see_statePt.push_back(state.pt());
       see_stateTrajX.push_back(pos.x());
       see_stateTrajY.push_back(pos.y());
       see_stateTrajPx.push_back(mom.x());
       see_stateTrajPy.push_back(mom.y());
       see_stateTrajPz.push_back(mom.z());
 
       see_trkIdx.push_back(-1);  // to be set correctly in fillTracks
       if (includeTrackingParticles_) {
         see_simTrkIdx.push_back(tpIdx);
         see_simTrkShareFrac.push_back(sharedFraction);
         see_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
         see_bestFromFirstHitSimTrkIdx.push_back(
             bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key) : -1);
       } else {
         see_isTrue.push_back(!tpIdx.empty());
       }
       see_bestSimTrkShareFrac.push_back(bestShareFrac);
       see_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
 
       /*
       TransientTrackingRecHit::RecHitPointer lastRecHit = theTTRHBuilder.build(&*(seed.recHits().second-1));
       TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( itSeed->startingState(), lastRecHit->surface(), &theMF);
       float pt  = state.globalParameters().momentum().perp();
       float eta = state.globalParameters().momentum().eta();
       float phi = state.globalParameters().momentum().phi();
       see_px      .push_back( state.globalParameters().momentum().x() );
       see_py      .push_back( state.globalParameters().momentum().y() );
       see_pz      .push_back( state.globalParameters().momentum().z() );
       */
 
       std::vector<int> hitIdx;
       std::vector<int> hitType;
 
       for (auto hit = seed.recHits().first; hit != seed.recHits().second; ++hit) {
         TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder.build(&*hit);
         int subid = recHit->geographicalId().subdetId();
         if (subid == (int)PixelSubdetector::PixelBarrel || subid == (int)PixelSubdetector::PixelEndcap) {
           const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
           const auto& clusterRef = bhit->firstClusterRef();
           const auto clusterKey = clusterRef.cluster_pixel().key();
           if (includeAllHits_) {
             checkProductID(hitProductIds, clusterRef.id(), "seed");
             pix_seeIdx[clusterKey].push_back(seedIndex);
           }
           hitIdx.push_back(clusterKey);
           hitType.push_back(static_cast<int>(HitType::Pixel));
         } else if (subid == (int)StripSubdetector::TOB || subid == (int)StripSubdetector::TID ||
                    subid == (int)StripSubdetector::TIB || subid == (int)StripSubdetector::TEC) {
           if (trackerHitRTTI::isMatched(*recHit)) {
             const SiStripMatchedRecHit2D* matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(&*recHit);
             if (includeAllHits_) {
               checkProductID(hitProductIds, matchedHit->monoClusterRef().id(), "seed");
               checkProductID(hitProductIds, matchedHit->stereoClusterRef().id(), "seed");
             }
             int monoIdx = matchedHit->monoClusterRef().key();
             int stereoIdx = matchedHit->stereoClusterRef().key();
 
             std::vector<std::pair<int, int>>::iterator pos =
                 find(monoStereoClusterList.begin(), monoStereoClusterList.end(), std::make_pair(monoIdx, stereoIdx));
             size_t gluedIndex = -1;
             if (pos != monoStereoClusterList.end()) {
               gluedIndex = std::distance(monoStereoClusterList.begin(), pos);
             } else {
               // We can encounter glued hits not in the input
               // SiStripMatchedRecHit2DCollection, e.g. via muon
               // outside-in seeds (or anything taking hits from
               // MeasurementTrackerEvent). So let's add them here.
               gluedIndex = addStripMatchedHit(*matchedHit, theTTRHBuilder, tTopo, monoStereoClusterList);
             }
 
             if (includeAllHits_)
               glu_seeIdx[gluedIndex].push_back(seedIndex);
             hitIdx.push_back(gluedIndex);
             hitType.push_back(static_cast<int>(HitType::Glued));
           } else {
             const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
             const auto& clusterRef = bhit->firstClusterRef();
             unsigned int clusterKey;
             if (clusterRef.isPhase2()) {
               clusterKey = clusterRef.cluster_phase2OT().key();
             } else {
               clusterKey = clusterRef.cluster_strip().key();
             }
 
             if (includeAllHits_) {
               checkProductID(hitProductIds, clusterRef.id(), "seed");
               if (clusterRef.isPhase2()) {
                 ph2_seeIdx[clusterKey].push_back(seedIndex);
               } else {
                 str_seeIdx[clusterKey].push_back(seedIndex);
               }
             }
 
             hitIdx.push_back(clusterKey);
             if (clusterRef.isPhase2()) {
               hitType.push_back(static_cast<int>(HitType::Phase2OT));
             } else {
               hitType.push_back(static_cast<int>(HitType::Strip));
             }
           }
         } else {
           LogTrace("TrackingNtuple") << " not pixel and not Strip detector";
         }
       }
       see_hitIdx.push_back(hitIdx);
       see_hitType.push_back(hitType);
       see_nPixel.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Pixel)));
       see_nGlued.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Glued)));
       see_nStrip.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Strip)));
       see_nPhase2OT.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Phase2OT)));
       see_nCluster.push_back(nClusters);
       //the part below is not strictly needed
       float chi2 = -1;
       if (nHits == 2) {
         TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
         TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first + 1));
         std::vector<GlobalPoint> gp(2);
         std::vector<GlobalError> ge(2);
         gp[0] = recHit0->globalPosition();
         ge[0] = recHit0->globalPositionError();
         gp[1] = recHit1->globalPosition();
         ge[1] = recHit1->globalPositionError();
         LogTrace("TrackingNtuple")
             << "seed " << seedTrackRef.key() << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
             << " - PAIR - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
             << " hitpos: " << gp[0] << " " << gp[1] << " trans0: "
             << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[0]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " "
             << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[1]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " trans1: "
             << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[0]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " "
             << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[1]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " eta,phi: " << gp[0].eta() << "," << gp[0].phi();
       } else if (nHits == 3) {
         TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
         TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first + 1));
         TransientTrackingRecHit::RecHitPointer recHit2 = theTTRHBuilder.build(&*(seed.recHits().first + 2));
         declareDynArray(GlobalPoint, 4, gp);
         declareDynArray(GlobalError, 4, ge);
         declareDynArray(bool, 4, bl);
         gp[0] = recHit0->globalPosition();
         ge[0] = recHit0->globalPositionError();
         int subid0 = recHit0->geographicalId().subdetId();
         bl[0] = (subid0 == StripSubdetector::TIB || subid0 == StripSubdetector::TOB ||
                  subid0 == (int)PixelSubdetector::PixelBarrel);
         gp[1] = recHit1->globalPosition();
         ge[1] = recHit1->globalPositionError();
         int subid1 = recHit1->geographicalId().subdetId();
         bl[1] = (subid1 == StripSubdetector::TIB || subid1 == StripSubdetector::TOB ||
                  subid1 == (int)PixelSubdetector::PixelBarrel);
         gp[2] = recHit2->globalPosition();
         ge[2] = recHit2->globalPositionError();
         int subid2 = recHit2->geographicalId().subdetId();
         bl[2] = (subid2 == StripSubdetector::TIB || subid2 == StripSubdetector::TOB ||
                  subid2 == (int)PixelSubdetector::PixelBarrel);
         RZLine rzLine(gp, ge, bl);
         float seed_chi2 = rzLine.chi2();
         //float seed_pt = state.globalParameters().momentum().perp();
         float seed_pt = pt;
         LogTrace("TrackingNtuple")
             << "seed " << seedTrackRef.key() << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
             << " - TRIPLET - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
             << " " << recHit2->geographicalId().rawId() << " hitpos: " << gp[0] << " " << gp[1] << " " << gp[2]
             << " trans0: "
             << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[0]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " "
             << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[1]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " trans1: "
             << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[0]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " "
             << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[1]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " trans2: "
             << (recHit2->transientHits().size() > 1 ? recHit2->transientHits()[0]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " "
             << (recHit2->transientHits().size() > 1 ? recHit2->transientHits()[1]->globalPosition()
                                                     : GlobalPoint(0, 0, 0))
             << " local: "
             << recHit2->localPosition()
             //<< " tsos pos, mom: " << state.globalPosition()<<" "<<state.globalMomentum()
             << " eta,phi: " << gp[0].eta() << "," << gp[0].phi() << " pt,chi2: " << seed_pt << "," << seed_chi2;
         chi2 = seed_chi2;
       }
       see_chi2.push_back(chi2);
     }
 
     fillTrackingParticlesForSeeds(tpCollection, simRecColl, tpKeyToIndex, offset);
   }
 }

void TrackingNtuple::fillSimHits	(	const TrackerGeometry &	tracker,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const SimHitTPAssociationProducer::SimHitTPAssociationList &	simHitsTPAssoc,
		const TrackerTopology &	tTopo,
		SimHitRefKeyToIndex &	simHitRefKeyToIndex,
		std::vector< TPHitIndex > &	tpHitList
	)

private

Definition at line 2367 of file TrackingNtuple.cc.

References funct::abs(), trackingPlots::assoc, DetId::det(), Exception, TrackerGeometry::idToDetUnit(), LogTrace, TrackingParticle::pdgId(), simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, SimHitTPAssociationProducer::simHitTPAssociationListGreater(), muonSimHitMatcherPSet::simTrack, and DetId::Tracker.

Referenced by analyze().

                                                                    {
   for (const auto& assoc : simHitsTPAssoc) {
     auto tpKey = assoc.first.key();
 
     // SimHitTPAssociationList can contain more TrackingParticles than
     // what are given to this EDAnalyzer, so we can filter those out here.
     auto found = tpKeyToIndex.find(tpKey);
     if (found == tpKeyToIndex.end())
       continue;
     const auto tpIndex = found->second;
 
     // skip non-tracker simhits (mostly muons)
     const auto& simhit = *(assoc.second);
     auto detId = DetId(simhit.detUnitId());
     if (detId.det() != DetId::Tracker)
       continue;
 
     // Skip electron SimHits for non-electron TrackingParticles to
     // filter out delta rays. The delta ray hits just confuse. If we
     // need them later, let's add them as a separate "collection" of
     // hits of a TP
     const TrackingParticle& tp = *(assoc.first);
     if (std::abs(simhit.particleType()) == 11 && std::abs(tp.pdgId()) != 11)
       continue;
 
     auto simHitKey = std::make_pair(assoc.second.key(), assoc.second.id());
 
     if (simHitRefKeyToIndex.find(simHitKey) != simHitRefKeyToIndex.end()) {
       for (const auto& assoc2 : simHitsTPAssoc) {
         if (std::make_pair(assoc2.second.key(), assoc2.second.id()) == simHitKey) {
 #ifdef EDM_ML_DEBUG
           auto range1 = std::equal_range(simHitsTPAssoc.begin(),
                                          simHitsTPAssoc.end(),
                                          std::make_pair(assoc.first, TrackPSimHitRef()),
                                          SimHitTPAssociationProducer::simHitTPAssociationListGreater);
           auto range2 = std::equal_range(simHitsTPAssoc.begin(),
                                          simHitsTPAssoc.end(),
                                          std::make_pair(assoc2.first, TrackPSimHitRef()),
                                          SimHitTPAssociationProducer::simHitTPAssociationListGreater);
 
           LogTrace("TrackingNtuple") << "Earlier TP " << assoc2.first.key() << " SimTrack Ids";
           for (const auto& simTrack : assoc2.first->g4Tracks()) {
             edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event "
                                             << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
           }
           for (auto iHit = range2.first; iHit != range2.second; ++iHit) {
             LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof "
                                        << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event "
                                        << iHit->second->eventId().bunchCrossing() << ":"
                                        << iHit->second->eventId().event();
           }
           LogTrace("TrackingNtuple") << "Current TP " << assoc.first.key() << " SimTrack Ids";
           for (const auto& simTrack : assoc.first->g4Tracks()) {
             edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event "
                                             << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
           }
           for (auto iHit = range1.first; iHit != range1.second; ++iHit) {
             LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof "
                                        << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event "
                                        << iHit->second->eventId().bunchCrossing() << ":"
                                        << iHit->second->eventId().event();
           }
 #endif
 
           throw cms::Exception("LogicError")
               << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second
               << ", first time with TrackingParticle " << assoc2.first.key() << ", now with " << tpKey;
         }
       }
       throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of "
                                          << simHitKey.second << ", now with TrackingParticle " << tpKey
                                          << ", but I didn't find the first occurrance!";
     }
 
     auto det = tracker.idToDetUnit(detId);
     if (!det)
       throw cms::Exception("LogicError") << "Did not find a det unit for DetId " << simhit.detUnitId()
                                          << " from tracker geometry";
 
     const auto pos = det->surface().toGlobal(simhit.localPosition());
     const float tof = simhit.timeOfFlight();
 
     const auto simHitIndex = simhit_x.size();
     simHitRefKeyToIndex[simHitKey] = simHitIndex;
 
     if (includeStripHits_)
       simhit_detId.push_back(tTopo, detId);
     else
       simhit_detId_phase2.push_back(tTopo, detId);
     simhit_x.push_back(pos.x());
     simhit_y.push_back(pos.y());
     simhit_z.push_back(pos.z());
     simhit_particle.push_back(simhit.particleType());
     simhit_process.push_back(simhit.processType());
     simhit_eloss.push_back(simhit.energyLoss());
     simhit_tof.push_back(tof);
     //simhit_simTrackId.push_back(simhit.trackId());
 
     simhit_simTrkIdx.push_back(tpIndex);
 
     simhit_hitIdx.emplace_back();   // filled in matchCluster
     simhit_hitType.emplace_back();  // filled in matchCluster
 
     tpHitList.emplace_back(tpKey, simHitIndex, tof, simhit.detUnitId());
   }
 }

void TrackingNtuple::fillStripMatchedHits	(	const edm::Event &	iEvent,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		std::vector< std::pair< int, int >> &	monoStereoClusterList
	)

private

Definition at line 2675 of file TrackingNtuple.cc.

References addStripMatchedHit(), edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), and edm::Event::getByToken().

Referenced by analyze().

                                                                                                {
   edm::Handle<SiStripMatchedRecHit2DCollection> matchedHits;
   iEvent.getByToken(stripMatchedRecHitToken_, matchedHits);
   for (auto it = matchedHits->begin(); it != matchedHits->end(); it++) {
     for (auto hit = it->begin(); hit != it->end(); hit++) {
       addStripMatchedHit(*hit, theTTRHBuilder, tTopo, monoStereoClusterList);
     }
   }
 }

void TrackingNtuple::fillStripRphiStereoHits	(	const edm::Event &	iEvent,
		const ClusterTPAssociation &	clusterToTPMap,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const SimHitTPAssociationProducer::SimHitTPAssociationList &	simHitsTPAssoc,
		const edm::DetSetVector< StripDigiSimLink > &	digiSimLink,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		const SimHitRefKeyToIndex &	simHitRefKeyToIndex,
		std::set< edm::ProductID > &	hitProductIds
	)

private

Definition at line 2548 of file TrackingNtuple.cc.

References TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, edmNew::DetSetVector< T >::dataSize(), TrackingNtuple::SimHitData::event, ntuplemaker::fill, SiStripMatchedRecHit2D::firstClusterRef(), edm::Event::getByToken(), hfClusterShapes_cfi::hits, crabWrapper::key, TrackerTopology::layer(), LogTrace, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, Skims_PA_cff::name, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, Strip, DetId::subdetId(), StripSubdetector::TIB, StripSubdetector::TOB, and TrackingNtuple::SimHitData::type.

Referenced by analyze().

                                                                                   {
   //index strip hit branches by cluster index
   edm::Handle<SiStripRecHit2DCollection> rphiHits;
   iEvent.getByToken(stripRphiRecHitToken_, rphiHits);
   edm::Handle<SiStripRecHit2DCollection> stereoHits;
   iEvent.getByToken(stripStereoRecHitToken_, stereoHits);
   int totalStripHits = rphiHits->dataSize() + stereoHits->dataSize();
   str_isBarrel.resize(totalStripHits);
   str_detId.resize(totalStripHits);
   str_trkIdx.resize(totalStripHits);  // filled in fillTracks
   str_seeIdx.resize(totalStripHits);  // filled in fillSeeds
   str_simHitIdx.resize(totalStripHits);
   str_simType.resize(totalStripHits);
   str_chargeFraction.resize(totalStripHits);
   str_x.resize(totalStripHits);
   str_y.resize(totalStripHits);
   str_z.resize(totalStripHits);
   str_xx.resize(totalStripHits);
   str_xy.resize(totalStripHits);
   str_yy.resize(totalStripHits);
   str_yz.resize(totalStripHits);
   str_zz.resize(totalStripHits);
   str_zx.resize(totalStripHits);
   str_radL.resize(totalStripHits);
   str_bbxi.resize(totalStripHits);
 
   auto fill = [&](const SiStripRecHit2DCollection& hits, const char* name) {
     for (const auto& detset : hits) {
       const DetId hitId = detset.detId();
       for (const auto& hit : detset) {
         TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
 
         hitProductIds.insert(hit.cluster().id());
 
         const int key = hit.cluster().key();
         const int lay = tTopo.layer(hitId);
         str_isBarrel[key] = (hitId.subdetId() == StripSubdetector::TIB || hitId.subdetId() == StripSubdetector::TOB);
         str_detId.set(key, tTopo, hitId);
         str_x[key] = ttrh->globalPosition().x();
         str_y[key] = ttrh->globalPosition().y();
         str_z[key] = ttrh->globalPosition().z();
         str_xx[key] = ttrh->globalPositionError().cxx();
         str_xy[key] = ttrh->globalPositionError().cyx();
         str_yy[key] = ttrh->globalPositionError().cyy();
         str_yz[key] = ttrh->globalPositionError().czy();
         str_zz[key] = ttrh->globalPositionError().czz();
         str_zx[key] = ttrh->globalPositionError().czx();
         str_radL[key] = ttrh->surface()->mediumProperties().radLen();
         str_bbxi[key] = ttrh->surface()->mediumProperties().xi();
         LogTrace("TrackingNtuple") << name << " cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                    << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
 
         if (includeTrackingParticles_) {
           SimHitData simHitData = matchCluster(hit.firstClusterRef(),
                                                hitId,
                                                key,
                                                ttrh,
                                                clusterToTPMap,
                                                tpKeyToIndex,
                                                simHitsTPAssoc,
                                                digiSimLink,
                                                simHitRefKeyToIndex,
                                                HitType::Strip);
           str_simHitIdx[key] = simHitData.matchingSimHit;
           str_simType[key] = static_cast<int>(simHitData.type);
           str_chargeFraction[key] = simHitData.chargeFraction;
           LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
           if (!simHitData.matchingSimHit.empty()) {
             const auto simHitIdx = simHitData.matchingSimHit[0];
             LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
                                        << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                        << " simHitPos="
                                        << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                        << " energyLoss=" << simhit_eloss[simHitIdx]
                                        << " particleType=" << simhit_particle[simHitIdx]
                                        << " processType=" << simhit_process[simHitIdx]
                                        << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                        << " event=" << simHitData.event[0];
           }
         }
       }
     }
   };
 
   fill(*rphiHits, "stripRPhiHit");
   fill(*stereoHits, "stripStereoHit");
 }

void TrackingNtuple::fillTrackingParticles	(	const edm::Event &	iEvent,
		const edm::EventSetup &	iSetup,
		const edm::RefToBaseVector< reco::Track > &	tracks,
		const reco::BeamSpot &	bs,
		const TrackingParticleRefVector &	tpCollection,
		const TrackingVertexRefKeyToIndex &	tvKeyToIndex,
		const reco::TrackToTrackingParticleAssociator &	associatorByHits,
		const std::vector< TPHitIndex > &	tpHitList,
		const TrackingParticleRefKeyToCount &	tpKeyToClusterCount
	)

private

Definition at line 3379 of file TrackingNtuple.cc.

References reco::TrackToTrackingParticleAssociator::associateSimToReco(), TrackingParticleIP::dxy(), TrackingParticleIP::dz(), edm::AssociationMap< Tag >::end(), HistoryBase::evaluate(), Exception, edm::AssociationMap< Tag >::find(), edm::EventSetup::get(), edm::Event::getByToken(), LogTrace, M_PI, ParametersDefinerForTP::momentum(), MuonTrackValidator_cfi::parametersDefiner, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::BeamSpot::position(), edm::ESHandle< T >::product(), HistoryBase::recoGenParticleTrail(), sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_hitType, mathSSE::sqrt(), funct::tan(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, tpHitIndexListLess(), DetId::Tracker, StandaloneTrackMonitor_cfi::trackQuality, Unknown, findQualityFiles::v, bphysicsOniaDQM_cfi::vertex, and ParametersDefinerForTP::vertex().

Referenced by analyze().

                                                                                                      {
   edm::ESHandle<ParametersDefinerForTP> parametersDefinerH;
   iSetup.get<TrackAssociatorRecord>().get(parametersDefinerName_, parametersDefinerH);
   const ParametersDefinerForTP* parametersDefiner = parametersDefinerH.product();
 
   // Number of 3D layers for TPs
   edm::Handle<edm::ValueMap<unsigned int>> tpNLayersH;
   iEvent.getByToken(tpNLayersToken_, tpNLayersH);
   const auto& nLayers_tPCeff = *tpNLayersH;
 
   iEvent.getByToken(tpNPixelLayersToken_, tpNLayersH);
   const auto& nPixelLayers_tPCeff = *tpNLayersH;
 
   iEvent.getByToken(tpNStripStereoLayersToken_, tpNLayersH);
   const auto& nStripMonoAndStereoLayers_tPCeff = *tpNLayersH;
 
   reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(tracks, tpCollection);
 
   for (const TrackingParticleRef& tp : tpCollection) {
     LogTrace("TrackingNtuple") << "tracking particle pt=" << tp->pt() << " eta=" << tp->eta() << " phi=" << tp->phi();
     bool isRecoMatched = false;
     std::vector<int> tkIdx;
     std::vector<float> sharedFraction;
     auto foundTracks = simRecColl.find(tp);
     if (foundTracks != simRecColl.end()) {
       isRecoMatched = true;
       for (const auto trackQuality : foundTracks->val) {
         sharedFraction.push_back(trackQuality.second);
         tkIdx.push_back(trackQuality.first.key());
       }
     }
 
     sim_genPdgIds.emplace_back();
     for (const auto& genRef : tp->genParticles()) {
       if (genRef.isNonnull())
         sim_genPdgIds.back().push_back(genRef->pdgId());
     }
 
     bool isFromBHadron = false;
     // Logic is similar to SimTracker/TrackHistory
     if (tracer_.evaluate(tp)) {  // ignore TP if history can not be traced
       // following is from TrackClassifier::processesAtGenerator()
       HistoryBase::RecoGenParticleTrail const& recoGenParticleTrail = tracer_.recoGenParticleTrail();
       for (const auto& particle : recoGenParticleTrail) {
         HepPDT::ParticleID particleID(particle->pdgId());
         if (particleID.hasBottom()) {
           isFromBHadron = true;
           break;
         }
       }
     }
 
     LogTrace("TrackingNtuple") << "matched to tracks = " << make_VectorPrinter(tkIdx)
                                << " isRecoMatched=" << isRecoMatched;
     sim_event.push_back(tp->eventId().event());
     sim_bunchCrossing.push_back(tp->eventId().bunchCrossing());
     sim_pdgId.push_back(tp->pdgId());
     sim_isFromBHadron.push_back(isFromBHadron);
     sim_px.push_back(tp->px());
     sim_py.push_back(tp->py());
     sim_pz.push_back(tp->pz());
     sim_pt.push_back(tp->pt());
     sim_eta.push_back(tp->eta());
     sim_phi.push_back(tp->phi());
     sim_q.push_back(tp->charge());
     sim_trkIdx.push_back(tkIdx);
     sim_trkShareFrac.push_back(sharedFraction);
     sim_parentVtxIdx.push_back(tvKeyToIndex.at(tp->parentVertex().key()));
     std::vector<int> decayIdx;
     for (const auto& v : tp->decayVertices())
       decayIdx.push_back(tvKeyToIndex.at(v.key()));
     sim_decayVtxIdx.push_back(decayIdx);
 
     //Calcualte the impact parameters w.r.t. PCA
     TrackingParticle::Vector momentum = parametersDefiner->momentum(iEvent, iSetup, tp);
     TrackingParticle::Point vertex = parametersDefiner->vertex(iEvent, iSetup, tp);
     auto dxySim = TrackingParticleIP::dxy(vertex, momentum, bs.position());
     auto dzSim = TrackingParticleIP::dz(vertex, momentum, bs.position());
     const double lambdaSim = M_PI / 2 - momentum.theta();
     sim_pca_pt.push_back(std::sqrt(momentum.perp2()));
     sim_pca_eta.push_back(momentum.Eta());
     sim_pca_lambda.push_back(lambdaSim);
     sim_pca_cotTheta.push_back(1 / tan(M_PI * 0.5 - lambdaSim));
     sim_pca_phi.push_back(momentum.phi());
     sim_pca_dxy.push_back(dxySim);
     sim_pca_dz.push_back(dzSim);
 
     std::vector<int> hitIdx;
     int nPixel = 0, nStrip = 0;
     auto rangeHit = std::equal_range(tpHitList.begin(), tpHitList.end(), TPHitIndex(tp.key()), tpHitIndexListLess);
     for (auto ip = rangeHit.first; ip != rangeHit.second; ++ip) {
       auto type = HitType::Unknown;
       if (!simhit_hitType[ip->simHitIdx].empty())
         type = static_cast<HitType>(simhit_hitType[ip->simHitIdx][0]);
       LogTrace("TrackingNtuple") << "simhit=" << ip->simHitIdx << " type=" << static_cast<int>(type);
       hitIdx.push_back(ip->simHitIdx);
       const auto detid = DetId(includeStripHits_ ? simhit_detId[ip->simHitIdx] : simhit_detId_phase2[ip->simHitIdx]);
       if (detid.det() != DetId::Tracker) {
         throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId "
                                            << detid.rawId() << " whose det() is not Tracker but " << detid.det();
       }
       const auto subdet = detid.subdetId();
       switch (subdet) {
         case PixelSubdetector::PixelBarrel:
         case PixelSubdetector::PixelEndcap:
           ++nPixel;
           break;
         case StripSubdetector::TIB:
         case StripSubdetector::TID:
         case StripSubdetector::TOB:
         case StripSubdetector::TEC:
           ++nStrip;
           break;
         default:
           throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId "
                                              << detid.rawId() << " whose subdet is not recognized, is " << subdet;
       };
     }
     sim_nValid.push_back(hitIdx.size());
     sim_nPixel.push_back(nPixel);
     sim_nStrip.push_back(nStrip);
 
     const auto nSimLayers = nLayers_tPCeff[tp];
     const auto nSimPixelLayers = nPixelLayers_tPCeff[tp];
     const auto nSimStripMonoAndStereoLayers = nStripMonoAndStereoLayers_tPCeff[tp];
     sim_nLay.push_back(nSimLayers);
     sim_nPixelLay.push_back(nSimPixelLayers);
     sim_n3DLay.push_back(nSimPixelLayers + nSimStripMonoAndStereoLayers);
 
     sim_nTrackerHits.push_back(tp->numberOfTrackerHits());
     auto found = tpKeyToClusterCount.find(tp.key());
     sim_nRecoClusters.push_back(found != cend(tpKeyToClusterCount) ? found->second : 0);
 
     sim_simHitIdx.push_back(hitIdx);
   }
 }

void TrackingNtuple::fillTrackingParticlesForSeeds	(	const TrackingParticleRefVector &	tpCollection,
		const reco::SimToRecoCollection &	simRecColl,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const unsigned int	seedOffset
	)

private

Definition at line 3525 of file TrackingNtuple.cc.

References sim_seedIdx, and edm::RefVector< C, T, F >::size().

Referenced by fillSeeds().

                                                                                   {
   if (sim_seedIdx.empty())  // first call
     sim_seedIdx.resize(tpCollection.size());
 
   for (const auto& keyVal : simRecColl) {
     const auto& tpRef = keyVal.key;
     auto found = tpKeyToIndex.find(tpRef.key());
     if (found == tpKeyToIndex.end())
       throw cms::Exception("Assert") << __FILE__ << ":" << __LINE__ << " fillTrackingParticlesForSeeds: tpRef.key() "
                                      << tpRef.key() << " not found from tpKeyToIndex. tpKeyToIndex size "
                                      << tpKeyToIndex.size();
     const auto tpIndex = found->second;
     for (const auto& pair : keyVal.val) {
       const auto& seedRef = pair.first->seedRef();
       sim_seedIdx[tpIndex].push_back(seedOffset + seedRef.key());
     }
   }
 }

void TrackingNtuple::fillTrackingVertices	(	const TrackingVertexRefVector &	trackingVertices,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex
	)

private

Definition at line 3580 of file TrackingNtuple.cc.

References EncodedEventId::bunchCrossing(), TrackingVertex::daughterTracks(), EncodedEventId::event(), TrackingVertex::eventId(), ntuplemaker::fill, TrackingVertex::g4Vertices(), training_settings::idx, SiStripPI::max, TrackingVertex::position(), simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, TrackingVertex::sourceTracks(), and findQualityFiles::v.

Referenced by analyze().

                                                                                              {
   int current_event = -1;
   for (const auto& ref : trackingVertices) {
     const TrackingVertex v = *ref;
     if (v.eventId().event() != current_event) {
       // next PV
       current_event = v.eventId().event();
       simpv_idx.push_back(simvtx_x.size());
     }
 
     unsigned int processType = std::numeric_limits<unsigned int>::max();
     if (!v.g4Vertices().empty()) {
       processType = v.g4Vertices()[0].processType();
     }
 
     simvtx_event.push_back(v.eventId().event());
     simvtx_bunchCrossing.push_back(v.eventId().bunchCrossing());
     simvtx_processType.push_back(processType);
 
     simvtx_x.push_back(v.position().x());
     simvtx_y.push_back(v.position().y());
     simvtx_z.push_back(v.position().z());
 
     auto fill = [&](const TrackingParticleRefVector& tps, std::vector<int>& idx) {
       for (const auto& tpRef : tps) {
         auto found = tpKeyToIndex.find(tpRef.key());
         if (found != tpKeyToIndex.end()) {
           idx.push_back(found->second);
         }
       }
     };
 
     std::vector<int> sourceIdx;
     std::vector<int> daughterIdx;
     fill(v.sourceTracks(), sourceIdx);
     fill(v.daughterTracks(), daughterIdx);
 
     simvtx_sourceSimIdx.push_back(sourceIdx);
     simvtx_daughterSimIdx.push_back(daughterIdx);
   }
 }

void TrackingNtuple::fillTracks	(	const edm::RefToBaseVector< reco::Track > &	tracks,
		const TrackingParticleRefVector &	tpCollection,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const TrackingParticleRefKeyToCount &	tpKeyToClusterCount,
		const MagneticField &	mf,
		const reco::BeamSpot &	bs,
		const reco::VertexCollection &	vertices,
		const reco::TrackToTrackingParticleAssociator &	associatorByHits,
		const ClusterTPAssociation &	clusterToTPMap,
		const TransientTrackingRecHitBuilder &	theTTRHBuilder,
		const TrackerTopology &	tTopo,
		const std::set< edm::ProductID > &	hitProductIds,
		const std::map< edm::ProductID, size_t > &	seedToCollIndex,
		const std::vector< const MVACollection * > &	mvaColls,
		const std::vector< const QualityMaskCollection * > &	qualColls
	)

private

Definition at line 3097 of file TrackingNtuple.cc.

Referenced by analyze().

                                                                                           {
   reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(tracks, tpCollection);
   edm::EDConsumerBase::Labels labels;
   labelsForToken(trackToken_, labels);
   LogTrace("TrackingNtuple") << "NEW TRACK LABEL: " << labels.module;
 
   auto pvPosition = vertices[0].position();
 
   for (size_t iTrack = 0; iTrack < tracks.size(); ++iTrack) {
     const auto& itTrack = tracks[iTrack];
     int charge = itTrack->charge();
     float pt = itTrack->pt();
     float eta = itTrack->eta();
     const double lambda = itTrack->lambda();
     float chi2 = itTrack->normalizedChi2();
     float ndof = itTrack->ndof();
     float phi = itTrack->phi();
     int nHits = itTrack->numberOfValidHits();
     const reco::HitPattern& hp = itTrack->hitPattern();
 
     const auto& tkParam = itTrack->parameters();
     auto tkCov = itTrack->covariance();
     tkCov.Invert();
 
     // Standard track-TP matching
     int nSimHits = 0;
     bool isSimMatched = false;
     std::vector<int> tpIdx;
     std::vector<float> sharedFraction;
     std::vector<float> tpChi2;
     auto foundTPs = recSimColl.find(itTrack);
     if (foundTPs != recSimColl.end()) {
       if (!foundTPs->val.empty()) {
         nSimHits = foundTPs->val[0].first->numberOfTrackerHits();
         isSimMatched = true;
       }
       for (const auto tpQuality : foundTPs->val) {
         tpIdx.push_back(tpKeyToIndex.at(tpQuality.first.key()));
         sharedFraction.push_back(tpQuality.second);
         tpChi2.push_back(track_associator::trackAssociationChi2(tkParam, tkCov, *(tpCollection[tpIdx.back()]), mf, bs));
       }
     }
 
     // Search for a best-matching TrackingParticle for a track
     const auto clusters = track_associator::hitsToClusterRefs(
         itTrack->recHitsBegin(),
         itTrack->recHitsEnd());  // TODO: this function is called 3 times per track, try to reduce
     const int nClusters = clusters.size();
 
     const auto bestKeyCount = findBestMatchingTrackingParticle(*itTrack, clusterToTPMap, tpKeyToIndex);
     const float bestShareFrac = static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(nClusters);
     float bestShareFracSimDenom = 0;
     float bestShareFracSimClusterDenom = 0;
     float bestChi2 = -1;
     if (bestKeyCount.key >= 0) {
       bestShareFracSimDenom =
           static_cast<float>(bestKeyCount.countClusters) /
           static_cast<float>(tpCollection[tpKeyToIndex.at(bestKeyCount.key)]->numberOfTrackerHits());
       bestShareFracSimClusterDenom =
           static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(tpKeyToClusterCount.at(bestKeyCount.key));
       bestChi2 = track_associator::trackAssociationChi2(
           tkParam, tkCov, *(tpCollection[tpKeyToIndex.at(bestKeyCount.key)]), mf, bs);
     }
     // Another way starting from the first hit of the track
     const auto bestFirstHitKeyCount = findMatchingTrackingParticleFromFirstHit(*itTrack, clusterToTPMap, tpKeyToIndex);
     const float bestFirstHitShareFrac =
         static_cast<float>(bestFirstHitKeyCount.countClusters) / static_cast<float>(nClusters);
     float bestFirstHitShareFracSimDenom = 0;
     float bestFirstHitShareFracSimClusterDenom = 0;
     float bestFirstHitChi2 = -1;
     if (bestFirstHitKeyCount.key >= 0) {
       bestFirstHitShareFracSimDenom =
           static_cast<float>(bestFirstHitKeyCount.countClusters) /
           static_cast<float>(tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]->numberOfTrackerHits());
       bestFirstHitShareFracSimClusterDenom = static_cast<float>(bestFirstHitKeyCount.countClusters) /
                                              static_cast<float>(tpKeyToClusterCount.at(bestFirstHitKeyCount.key));
       bestFirstHitChi2 = track_associator::trackAssociationChi2(
           tkParam, tkCov, *(tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]), mf, bs);
     }
 
     float chi2_1Dmod = chi2;
     int count1dhits = 0;
     for (auto iHit = itTrack->recHitsBegin(), iEnd = itTrack->recHitsEnd(); iHit != iEnd; ++iHit) {
       const TrackingRecHit& hit = **iHit;
       if (hit.isValid() && typeid(hit) == typeid(SiStripRecHit1D))
         ++count1dhits;
     }
     if (count1dhits > 0) {
       chi2_1Dmod = (chi2 + count1dhits) / (ndof + count1dhits);
     }
 
     Point bestPV = getBestVertex(*itTrack, vertices);
 
     trk_px.push_back(itTrack->px());
     trk_py.push_back(itTrack->py());
     trk_pz.push_back(itTrack->pz());
     trk_pt.push_back(pt);
     trk_inner_px.push_back(itTrack->innerMomentum().x());
     trk_inner_py.push_back(itTrack->innerMomentum().y());
     trk_inner_pz.push_back(itTrack->innerMomentum().z());
     trk_inner_pt.push_back(itTrack->innerMomentum().rho());
     trk_outer_px.push_back(itTrack->outerMomentum().x());
     trk_outer_py.push_back(itTrack->outerMomentum().y());
     trk_outer_pz.push_back(itTrack->outerMomentum().z());
     trk_outer_pt.push_back(itTrack->outerMomentum().rho());
     trk_eta.push_back(eta);
     trk_lambda.push_back(lambda);
     trk_cotTheta.push_back(1 / tan(M_PI * 0.5 - lambda));
     trk_phi.push_back(phi);
     trk_dxy.push_back(itTrack->dxy(bs.position()));
     trk_dz.push_back(itTrack->dz(bs.position()));
     trk_dxyPV.push_back(itTrack->dxy(pvPosition));
     trk_dzPV.push_back(itTrack->dz(pvPosition));
     trk_dxyClosestPV.push_back(itTrack->dxy(bestPV));
     trk_dzClosestPV.push_back(itTrack->dz(bestPV));
     trk_ptErr.push_back(itTrack->ptError());
     trk_etaErr.push_back(itTrack->etaError());
     trk_lambdaErr.push_back(itTrack->lambdaError());
     trk_phiErr.push_back(itTrack->phiError());
     trk_dxyErr.push_back(itTrack->dxyError());
     trk_dzErr.push_back(itTrack->dzError());
     trk_refpoint_x.push_back(itTrack->vx());
     trk_refpoint_y.push_back(itTrack->vy());
     trk_refpoint_z.push_back(itTrack->vz());
     trk_nChi2.push_back(chi2);
     trk_nChi2_1Dmod.push_back(chi2_1Dmod);
     trk_ndof.push_back(ndof);
     trk_q.push_back(charge);
     trk_nValid.push_back(hp.numberOfValidHits());
     trk_nLost.push_back(hp.numberOfLostHits(reco::HitPattern::TRACK_HITS));
     trk_nInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::TRACK_HITS));
     trk_nPixel.push_back(hp.numberOfValidPixelHits());
     trk_nStrip.push_back(hp.numberOfValidStripHits());
     trk_nOuterLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS));
     trk_nInnerLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS));
     trk_nOuterInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::MISSING_OUTER_HITS));
     trk_nInnerInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::MISSING_INNER_HITS));
     trk_nPixelLay.push_back(hp.pixelLayersWithMeasurement());
     trk_nStripLay.push_back(hp.stripLayersWithMeasurement());
     trk_n3DLay.push_back(hp.numberOfValidStripLayersWithMonoAndStereo() + hp.pixelLayersWithMeasurement());
     trk_nLostLay.push_back(hp.trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS));
     trk_nCluster.push_back(nClusters);
     trk_algo.push_back(itTrack->algo());
     trk_originalAlgo.push_back(itTrack->originalAlgo());
     trk_algoMask.push_back(itTrack->algoMaskUL());
     trk_stopReason.push_back(itTrack->stopReason());
     trk_isHP.push_back(itTrack->quality(reco::TrackBase::highPurity));
     if (includeMVA_) {
       for (size_t i = 0; i < trk_mvas.size(); ++i) {
         trk_mvas[i].push_back((*(mvaColls[i]))[iTrack]);
         trk_qualityMasks[i].push_back((*(qualColls[i]))[iTrack]);
       }
     }
     if (includeSeeds_) {
       auto offset = seedCollToOffset.find(itTrack->seedRef().id());
       if (offset == seedCollToOffset.end()) {
         throw cms::Exception("Configuration")
             << "Track algo '" << reco::TrackBase::algoName(itTrack->algo()) << "' originalAlgo '"
             << reco::TrackBase::algoName(itTrack->originalAlgo()) << "' refers to seed collection "
             << itTrack->seedRef().id()
             << ", but that seed collection is not given as an input. The following collections were given as an input "
             << make_ProductIDMapPrinter(seedCollToOffset);
       }
 
       const auto seedIndex = offset->second + itTrack->seedRef().key();
       trk_seedIdx.push_back(seedIndex);
       if (see_trkIdx[seedIndex] != -1) {
         throw cms::Exception("LogicError") << "Track index has already been set for seed " << seedIndex << " to "
                                            << see_trkIdx[seedIndex] << "; was trying to set it to " << iTrack;
       }
       see_trkIdx[seedIndex] = iTrack;
     }
     trk_vtxIdx.push_back(-1);  // to be set correctly in fillVertices
     if (includeTrackingParticles_) {
       trk_simTrkIdx.push_back(tpIdx);
       trk_simTrkShareFrac.push_back(sharedFraction);
       trk_simTrkNChi2.push_back(tpChi2);
       trk_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
       trk_bestFromFirstHitSimTrkIdx.push_back(bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key)
                                                                             : -1);
     } else {
       trk_isTrue.push_back(!tpIdx.empty());
     }
     trk_bestSimTrkShareFrac.push_back(bestShareFrac);
     trk_bestSimTrkShareFracSimDenom.push_back(bestShareFracSimDenom);
     trk_bestSimTrkShareFracSimClusterDenom.push_back(bestShareFracSimClusterDenom);
     trk_bestSimTrkNChi2.push_back(bestChi2);
     trk_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
     trk_bestFromFirstHitSimTrkShareFracSimDenom.push_back(bestFirstHitShareFracSimDenom);
     trk_bestFromFirstHitSimTrkShareFracSimClusterDenom.push_back(bestFirstHitShareFracSimClusterDenom);
     trk_bestFromFirstHitSimTrkNChi2.push_back(bestFirstHitChi2);
 
     LogTrace("TrackingNtuple") << "Track #" << itTrack.key() << " with q=" << charge << ", pT=" << pt
                                << " GeV, eta: " << eta << ", phi: " << phi << ", chi2=" << chi2 << ", Nhits=" << nHits
                                << ", algo=" << itTrack->algoName(itTrack->algo()).c_str()
                                << " hp=" << itTrack->quality(reco::TrackBase::highPurity)
                                << " seed#=" << itTrack->seedRef().key() << " simMatch=" << isSimMatched
                                << " nSimHits=" << nSimHits
                                << " sharedFraction=" << (sharedFraction.empty() ? -1 : sharedFraction[0])
                                << " tpIdx=" << (tpIdx.empty() ? -1 : tpIdx[0]);
     std::vector<int> hitIdx;
     std::vector<int> hitType;
 
     for (auto i = itTrack->recHitsBegin(); i != itTrack->recHitsEnd(); i++) {
       TransientTrackingRecHit::RecHitPointer hit = theTTRHBuilder.build(&**i);
       DetId hitId = hit->geographicalId();
       LogTrace("TrackingNtuple") << "hit #" << std::distance(itTrack->recHitsBegin(), i)
                                  << " subdet=" << hitId.subdetId();
       if (hitId.det() != DetId::Tracker)
         continue;
 
       LogTrace("TrackingNtuple") << " " << subdetstring(hitId.subdetId()) << " " << tTopo.layer(hitId);
 
       if (hit->isValid()) {
         //ugly... but works
         const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*hit);
         const auto& clusterRef = bhit->firstClusterRef();
         unsigned int clusterKey;
         if (clusterRef.isPixel()) {
           clusterKey = clusterRef.cluster_pixel().key();
         } else if (clusterRef.isPhase2()) {
           clusterKey = clusterRef.cluster_phase2OT().key();
         } else {
           clusterKey = clusterRef.cluster_strip().key();
         }
 
         LogTrace("TrackingNtuple") << " id: " << hitId.rawId() << " - globalPos =" << hit->globalPosition()
                                    << " cluster=" << clusterKey << " clusterRef ID=" << clusterRef.id()
                                    << " eta,phi: " << hit->globalPosition().eta() << "," << hit->globalPosition().phi();
         if (includeAllHits_) {
           checkProductID(hitProductIds, clusterRef.id(), "track");
           if (clusterRef.isPixel()) {
             pix_trkIdx[clusterKey].push_back(iTrack);
           } else if (clusterRef.isPhase2()) {
             ph2_trkIdx[clusterKey].push_back(iTrack);
           } else {
             str_trkIdx[clusterKey].push_back(iTrack);
           }
         }
 
         hitIdx.push_back(clusterKey);
         if (clusterRef.isPixel()) {
           hitType.push_back(static_cast<int>(HitType::Pixel));
         } else if (clusterRef.isPhase2()) {
           hitType.push_back(static_cast<int>(HitType::Phase2OT));
         } else {
           hitType.push_back(static_cast<int>(HitType::Strip));
         }
       } else {
         LogTrace("TrackingNtuple") << " - invalid hit";
 
         hitIdx.push_back(inv_isBarrel.size());
         hitType.push_back(static_cast<int>(HitType::Invalid));
 
         inv_isBarrel.push_back(hitId.subdetId() == 1);
         if (includeStripHits_)
           inv_detId.push_back(tTopo, hitId);
         else
           inv_detId_phase2.push_back(tTopo, hitId);
         inv_type.push_back(hit->getType());
       }
     }
 
     trk_hitIdx.push_back(hitIdx);
     trk_hitType.push_back(hitType);
   }
 }

void TrackingNtuple::fillVertices	(	const reco::VertexCollection &	vertices,
		const edm::RefToBaseVector< reco::Track > &	tracks
	)

private

Definition at line 3547 of file TrackingNtuple.cc.

References reco::Vertex::chi2(), Exception, edm::RefToBaseVector< T >::id(), reco::Vertex::isFake(), reco::Vertex::isValid(), reco::Vertex::ndof(), findQualityFiles::size, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), trk_vtxIdx, bphysicsOniaDQM_cfi::vertex, vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, vtx_zErr, reco::Vertex::x(), reco::Vertex::xError(), reco::Vertex::y(), reco::Vertex::yError(), reco::Vertex::z(), and reco::Vertex::zError().

Referenced by analyze().

                                                                                {
   for (size_t iVertex = 0, size = vertices.size(); iVertex < size; ++iVertex) {
     const reco::Vertex& vertex = vertices[iVertex];
     vtx_x.push_back(vertex.x());
     vtx_y.push_back(vertex.y());
     vtx_z.push_back(vertex.z());
     vtx_xErr.push_back(vertex.xError());
     vtx_yErr.push_back(vertex.yError());
     vtx_zErr.push_back(vertex.zError());
     vtx_chi2.push_back(vertex.chi2());
     vtx_ndof.push_back(vertex.ndof());
     vtx_fake.push_back(vertex.isFake());
     vtx_valid.push_back(vertex.isValid());
 
     std::vector<int> trkIdx;
     for (auto iTrack = vertex.tracks_begin(); iTrack != vertex.tracks_end(); ++iTrack) {
       // Ignore link if vertex was fit from a track collection different from the input
       if (iTrack->id() != tracks.id())
         continue;
 
       trkIdx.push_back(iTrack->key());
 
       if (trk_vtxIdx[iTrack->key()] != -1) {
         throw cms::Exception("LogicError") << "Vertex index has already been set for track " << iTrack->key() << " to "
                                            << trk_vtxIdx[iTrack->key()] << "; was trying to set it to " << iVertex;
       }
       trk_vtxIdx[iTrack->key()] = iVertex;
     }
     vtx_trkIdx.push_back(trkIdx);
   }
 }

template<typename SimLink >

TrackingNtuple::SimHitData TrackingNtuple::matchCluster	(	const OmniClusterRef &	cluster,
		DetId	hitId,
		int	clusterKey,
		const TransientTrackingRecHit::RecHitPointer &	ttrh,
		const ClusterTPAssociation &	clusterToTPMap,
		const TrackingParticleRefKeyToIndex &	tpKeyToIndex,
		const SimHitTPAssociationProducer::SimHitTPAssociationList &	simHitsTPAssoc,
		const edm::DetSetVector< SimLink > &	digiSimLinks,
		const SimHitRefKeyToIndex &	simHitRefKeyToIndex,
		HitType	hitType
	)

private

Definition at line 2259 of file TrackingNtuple.cc.

References funct::abs(), TrackingNtuple::SimHitData::bunchCrossing, l1GtPatternGenerator_cfi::bx, TrackingNtuple::SimHitData::chargeFraction, TTClusterAssociation_cfi::digiSimLinks, ClusterTPAssociation::equal_range(), TrackingNtuple::SimHitData::event, Exception, edm::Ref< C, T, F >::id(), ITPileup, edm::Ref< C, T, F >::key(), TrackingNtuple::SimHitData::matchingSimHit, min(), Noise, OOTPileup, Phase2OT, OmniClusterRef::phase2OTCluster(), FastTimerService_cff::range, DetId::rawId(), runTheMatrix::ret, Signal, simhit_hitIdx, simhit_hitType, SimHitTPAssociationProducer::simHitTPAssociationListGreater(), and TrackingNtuple::SimHitData::type.

Referenced by fillPhase2OTHits(), fillPixelHits(), and fillStripRphiStereoHits().

                      {
   SimHitData ret;
 
   std::map<unsigned int, double> simTrackIdToChargeFraction;
   if (hitType == HitType::Phase2OT)
     simTrackIdToChargeFraction = chargeFraction(cluster.phase2OTCluster(), hitId, digiSimLinks);
   else
     simTrackIdToChargeFraction = chargeFraction(GetCluster<SimLink>::call(cluster), hitId, digiSimLinks);
 
   ret.type = HitSimType::Noise;
   auto range = clusterToTPMap.equal_range(cluster);
   if (range.first != range.second) {
     for (auto ip = range.first; ip != range.second; ++ip) {
       const TrackingParticleRef& trackingParticle = ip->second;
 
       // Find out if the cluster is from signal/ITPU/OOTPU
       const auto event = trackingParticle->eventId().event();
       const auto bx = trackingParticle->eventId().bunchCrossing();
       HitSimType type = HitSimType::OOTPileup;
       if (bx == 0) {
         type = (event == 0 ? HitSimType::Signal : HitSimType::ITPileup);
       }
       ret.type = static_cast<HitSimType>(std::min(static_cast<int>(ret.type), static_cast<int>(type)));
 
       // Limit to only input TrackingParticles (usually signal+ITPU)
       auto tpIndex = tpKeyToIndex.find(trackingParticle.key());
       if (tpIndex == tpKeyToIndex.end())
         continue;
 
       //now get the corresponding sim hit
       std::pair<TrackingParticleRef, TrackPSimHitRef> simHitTPpairWithDummyTP(trackingParticle, TrackPSimHitRef());
       //SimHit is dummy: for simHitTPAssociationListGreater sorting only the TP is needed
       auto range = std::equal_range(simHitsTPAssoc.begin(),
                                     simHitsTPAssoc.end(),
                                     simHitTPpairWithDummyTP,
                                     SimHitTPAssociationProducer::simHitTPAssociationListGreater);
       bool foundSimHit = false;
       bool foundElectron = false;
       for (auto ip = range.first; ip != range.second; ++ip) {
         TrackPSimHitRef TPhit = ip->second;
         DetId dId = DetId(TPhit->detUnitId());
         if (dId.rawId() == hitId.rawId()) {
           // skip electron SimHits for non-electron TPs also here
           if (std::abs(TPhit->particleType()) == 11 && std::abs(trackingParticle->pdgId()) != 11) {
             foundElectron = true;
             continue;
           }
 
           foundSimHit = true;
           auto simHitKey = TPhit.key();
           auto simHitID = TPhit.id();
 
           auto simHitIndex = simHitRefKeyToIndex.at(std::make_pair(simHitKey, simHitID));
           ret.matchingSimHit.push_back(simHitIndex);
 
           double chargeFraction = 0.;
           for (const SimTrack& simtrk : trackingParticle->g4Tracks()) {
             auto found = simTrackIdToChargeFraction.find(simtrk.trackId());
             if (found != simTrackIdToChargeFraction.end()) {
               chargeFraction += found->second;
             }
           }
           ret.chargeFraction.push_back(chargeFraction);
 
           // only for debug prints
           ret.bunchCrossing.push_back(bx);
           ret.event.push_back(event);
 
           simhit_hitIdx[simHitIndex].push_back(clusterKey);
           simhit_hitType[simHitIndex].push_back(static_cast<int>(hitType));
         }
       }
       if (!foundSimHit) {
         // In case we didn't find a simhit because of filtered-out
         // electron SimHit, just ignore the missing SimHit.
         if (foundElectron)
           continue;
 
         auto ex = cms::Exception("LogicError")
                   << "Did not find SimHit for reco hit DetId " << hitId.rawId() << " for TP " << trackingParticle.key()
                   << " bx:event " << bx << ":" << event << ".\nFound SimHits from detectors ";
         for (auto ip = range.first; ip != range.second; ++ip) {
           TrackPSimHitRef TPhit = ip->second;
           DetId dId = DetId(TPhit->detUnitId());
           ex << dId.rawId() << " ";
         }
         if (trackingParticle->eventId().event() != 0) {
           ex << "\nSince this is a TrackingParticle from pileup, check that you're running the pileup mixing in "
                 "playback mode.";
         }
         throw ex;
       }
     }
   }
 
   return ret;
 }

static bool TrackingNtuple::tpHitIndexListLess	(	const TPHitIndex &	i,
		const TPHitIndex &	j
	)

inlinestaticprivate

Definition at line 500 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::tpKey.

Referenced by fillTrackingParticles().

500 { return (i.tpKey < j.tpKey); }

mps_fire.i

i

Definition: mps_fire.py:341

dqmiolumiharvest.j

j

Definition: dqmiolumiharvest.py:66

static bool TrackingNtuple::tpHitIndexListLessSort	(	const TPHitIndex &	i,
		const TPHitIndex &	j
	)

inlinestaticprivate

Definition at line 501 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::detId, HLT_2018_cff::fillTracks, iEvent, edm::isNotFinite(), TrackingNtuple::TPHitIndex::tof, TrackingNtuple::TPHitIndex::tpKey, PbPb_ZMuSkimMuonDPG_cff::tracker, PDWG_EXOHSCP_cff::tracks, and pwdgSkimBPark_cfi::vertices.

Referenced by analyze().

                                                                                {
     if (i.tpKey == j.tpKey) {
       if (edm::isNotFinite(i.tof) && edm::isNotFinite(j.tof)) {
         return i.detId < j.detId;
       }
       return i.tof < j.tof;  // works as intended if either one is NaN
     }
     return i.tpKey < j.tpKey;
   }

Member Data Documentation

edm::EDGetTokenT<reco::BeamSpot> TrackingNtuple::beamSpotToken_

private

Definition at line 643 of file TrackingNtuple.cc.

float TrackingNtuple::bsp_sigmax

private

Definition at line 1175 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

float TrackingNtuple::bsp_sigmay

private

Definition at line 1176 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

float TrackingNtuple::bsp_sigmaz

private

Definition at line 1177 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

float TrackingNtuple::bsp_x

private

Definition at line 1172 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

float TrackingNtuple::bsp_y

private

Definition at line 1173 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

float TrackingNtuple::bsp_z

private

Definition at line 1174 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillBeamSpot(), and TrackingNtuple().

std::string TrackingNtuple::builderName_

private

Definition at line 654 of file TrackingNtuple.cc.

edm::EDGetTokenT<ClusterTPAssociation> TrackingNtuple::clusterTPMapToken_

private

Definition at line 636 of file TrackingNtuple.cc.

edm::EventNumber_t TrackingNtuple::ev_event

private

Definition at line 941 of file TrackingNtuple.cc.

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi

private

Definition at line 940 of file TrackingNtuple.cc.

edm::RunNumber_t TrackingNtuple::ev_run

private

Definition at line 939 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::glu_bbxi

private

Definition at line 1123 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

DetIdStrip TrackingNtuple::glu_detId

private

Definition at line 1108 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<short> TrackingNtuple::glu_isBarrel

private

Definition at line 1107 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<int> TrackingNtuple::glu_monoIdx

private

Definition at line 1109 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_radL

private

Definition at line 1122 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::glu_seeIdx

private

Definition at line 1111 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<int> TrackingNtuple::glu_stereoIdx

private

Definition at line 1110 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_x

private

Definition at line 1112 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_xx

private

Definition at line 1115 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_xy

private

Definition at line 1116 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_y

private

Definition at line 1113 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_yy

private

Definition at line 1117 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_yz

private

Definition at line 1118 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_z

private

Definition at line 1114 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_zx

private

Definition at line 1120 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

std::vector<float> TrackingNtuple::glu_zz

private

Definition at line 1119 of file TrackingNtuple.cc.

Referenced by addStripMatchedHit(), clearVariables(), and TrackingNtuple().

const bool TrackingNtuple::includeAllHits_

private

Definition at line 657 of file TrackingNtuple.cc.

const bool TrackingNtuple::includeMVA_

private

Definition at line 658 of file TrackingNtuple.cc.

bool TrackingNtuple::includePhase2OTHits_

private

Definition at line 642 of file TrackingNtuple.cc.

const bool TrackingNtuple::includeSeeds_

private

Definition at line 656 of file TrackingNtuple.cc.

bool TrackingNtuple::includeStripHits_

private

Definition at line 642 of file TrackingNtuple.cc.

const bool TrackingNtuple::includeTrackingParticles_

private

Definition at line 659 of file TrackingNtuple.cc.

DetIdAll TrackingNtuple::inv_detId

private

Definition at line 1151 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

DetIdAllPhase2 TrackingNtuple::inv_detId_phase2

private

Definition at line 1152 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<short> TrackingNtuple::inv_isBarrel

private

Definition at line 1150 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::inv_type

private

Definition at line 1153 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<std::tuple<edm::EDGetTokenT<MVACollection>, edm::EDGetTokenT<QualityMaskCollection> > > TrackingNtuple::mvaQualityCollectionTokens_

private

Definition at line 633 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

std::string TrackingNtuple::parametersDefinerName_

private

Definition at line 655 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::ph2_bbxi

private

Definition at line 1145 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

DetIdPhase2OT TrackingNtuple::ph2_detId

private

Definition at line 1128 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<short> TrackingNtuple::ph2_isBarrel

private

Definition at line 1127 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_radL

private

Definition at line 1144 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::ph2_seeIdx

private

Definition at line 1130 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::ph2_simHitIdx

private

Definition at line 1131 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::ph2_simType

private

Definition at line 1133 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::ph2_trkIdx

private

Definition at line 1129 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_x

private

Definition at line 1134 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_xx

private

Definition at line 1137 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_xy

private

Definition at line 1138 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_y

private

Definition at line 1135 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_yy

private

Definition at line 1139 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_yz

private

Definition at line 1140 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_z

private

Definition at line 1136 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_zx

private

Definition at line 1142 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::ph2_zz

private

Definition at line 1141 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), and TrackingNtuple().

edm::EDGetTokenT<Phase2TrackerRecHit1DCollectionNew> TrackingNtuple::phase2OTRecHitToken_

private

Definition at line 648 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::pix_bbxi

private

Definition at line 1081 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::pix_chargeFraction

private

Definition at line 1068 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

DetIdPixel TrackingNtuple::pix_detId

private

Definition at line 1064 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<short> TrackingNtuple::pix_isBarrel

private

Definition at line 1063 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_radL

private

Definition at line 1080 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::pix_seeIdx

private

Definition at line 1066 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::pix_simHitIdx

private

Definition at line 1067 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::pix_simType

private

Definition at line 1069 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::pix_trkIdx

private

Definition at line 1065 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_x

private

Definition at line 1070 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_xx

private

Definition at line 1073 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_xy

private

Definition at line 1074 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_y

private

Definition at line 1071 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_yy

private

Definition at line 1075 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_yz

private

Definition at line 1076 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_z

private

Definition at line 1072 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_zx

private

Definition at line 1078 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::pix_zz

private

Definition at line 1077 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPixelHits(), and TrackingNtuple().

edm::EDGetTokenT<SiPixelRecHitCollection> TrackingNtuple::pixelRecHitToken_

private

Definition at line 644 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::DetSetVector<PixelDigiSimLink> > TrackingNtuple::pixelSimLinkToken_

private

Definition at line 639 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::see_algo

private

Definition at line 1209 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<int> TrackingNtuple::see_bestFromFirstHitSimTrkIdx

private

Definition at line 1216 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_bestFromFirstHitSimTrkShareFrac

private

Definition at line 1217 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<int> TrackingNtuple::see_bestSimTrkIdx

private

Definition at line 1214 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_bestSimTrkShareFrac

private

Definition at line 1215 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_chi2

private

Definition at line 1195 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_dxy

private

Definition at line 1188 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_dxyErr

private

Definition at line 1193 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_dz

private

Definition at line 1189 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_dzErr

private

Definition at line 1194 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_eta

private

Definition at line 1186 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_etaErr

private

Definition at line 1191 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<short> TrackingNtuple::see_fitok

private

Definition at line 1181 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::see_hitIdx

private

Definition at line 1220 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::see_hitType

private

Definition at line 1221 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<short> TrackingNtuple::see_isTrue

private

Definition at line 1213 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::see_nCands

private

Definition at line 1211 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nCluster

private

Definition at line 1208 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nGlued

private

Definition at line 1205 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nPhase2OT

private

Definition at line 1207 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nPixel

private

Definition at line 1204 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nStrip

private

Definition at line 1206 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_nValid

private

Definition at line 1203 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::see_offset

private

Definition at line 1223 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_phi

private

Definition at line 1187 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_phiErr

private

Definition at line 1192 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_pt

private

Definition at line 1185 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_ptErr

private

Definition at line 1190 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_px

private

Definition at line 1182 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_py

private

Definition at line 1183 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_pz

private

Definition at line 1184 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<int> TrackingNtuple::see_q

private

Definition at line 1202 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::see_simTrkIdx

private

Definition at line 1219 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::see_simTrkShareFrac

private

Definition at line 1218 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_statePt

private

Definition at line 1196 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_stateTrajPx

private

Definition at line 1199 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_stateTrajPy

private

Definition at line 1200 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_stateTrajPz

private

Definition at line 1201 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_stateTrajX

private

Definition at line 1197 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<float> TrackingNtuple::see_stateTrajY

private

Definition at line 1198 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::see_stopReason

private

Definition at line 1210 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), and TrackingNtuple().

std::vector<int> TrackingNtuple::see_trkIdx

private

Definition at line 1212 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), fillTracks(), and TrackingNtuple().

std::vector<edm::EDGetTokenT<std::vector<SeedStopInfo> > > TrackingNtuple::seedStopInfoTokens_

private

Definition at line 630 of file TrackingNtuple.cc.

std::vector<edm::EDGetTokenT<edm::View<reco::Track> > > TrackingNtuple::seedTokens_

private

Definition at line 629 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::sim_bunchCrossing

private

Definition at line 1024 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::sim_decayVtxIdx

private

Definition at line 1058 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_eta

private

Definition at line 1032 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<int> TrackingNtuple::sim_event

private

Definition at line 1023 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::sim_genPdgIds

private

Definition at line 1026 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<int> TrackingNtuple::sim_isFromBHadron

private

Definition at line 1027 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_n3DLay

private

Definition at line 1048 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nLay

private

Definition at line 1046 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nPixel

private

Definition at line 1044 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nPixelLay

private

Definition at line 1047 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nRecoClusters

private

Definition at line 1052 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nStrip

private

Definition at line 1045 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nTrackerHits

private

Definition at line 1050 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::sim_nValid

private

Definition at line 1043 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<int> TrackingNtuple::sim_parentVtxIdx

private

Definition at line 1057 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_cotTheta

private

Definition at line 1037 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_dxy

private

Definition at line 1039 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_dz

private

Definition at line 1040 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_eta

private

Definition at line 1035 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_lambda

private

Definition at line 1036 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_phi

private

Definition at line 1038 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pca_pt

private

Definition at line 1034 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<int> TrackingNtuple::sim_pdgId

private

Definition at line 1025 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_phi

private

Definition at line 1033 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pt

private

Definition at line 1031 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_px

private

Definition at line 1028 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_py

private

Definition at line 1029 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::sim_pz

private

Definition at line 1030 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<int> TrackingNtuple::sim_q

private

Definition at line 1041 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::sim_seedIdx

private

Definition at line 1056 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticlesForSeeds(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::sim_simHitIdx

private

Definition at line 1059 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::sim_trkIdx

private

Definition at line 1054 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::sim_trkShareFrac

private

Definition at line 1055 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingParticles(), and TrackingNtuple().

DetIdAll TrackingNtuple::simhit_detId

private

Definition at line 1157 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), fillTrackingParticles(), and TrackingNtuple().

DetIdAllPhase2 TrackingNtuple::simhit_detId_phase2

private

Definition at line 1158 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), fillTrackingParticles(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simhit_eloss

private

Definition at line 1164 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::simhit_hitIdx

private

Definition at line 1168 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), matchCluster(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::simhit_hitType

private

Definition at line 1169 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), fillTrackingParticles(), matchCluster(), and TrackingNtuple().

std::vector<int> TrackingNtuple::simhit_particle

private

Definition at line 1162 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<short> TrackingNtuple::simhit_process

private

Definition at line 1163 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<int> TrackingNtuple::simhit_simTrkIdx

private

Definition at line 1167 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simhit_tof

private

Definition at line 1165 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSimHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simhit_x

private

Definition at line 1159 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simhit_y

private

Definition at line 1160 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simhit_z

private

Definition at line 1161 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillPhase2OTHits(), fillPixelHits(), fillSimHits(), fillStripRphiStereoHits(), and TrackingNtuple().

edm::EDGetTokenT<SimHitTPAssociationProducer::SimHitTPAssociationList> TrackingNtuple::simHitTPMapToken_

private

Definition at line 637 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::simpv_idx

private

Definition at line 1251 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<int> TrackingNtuple::simvtx_bunchCrossing

private

Definition at line 1244 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::simvtx_daughterSimIdx

private

Definition at line 1250 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<int> TrackingNtuple::simvtx_event

private

Definition at line 1243 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<unsigned int> TrackingNtuple::simvtx_processType

private

Definition at line 1245 of file TrackingNtuple.cc.

Referenced by fillTrackingVertices(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::simvtx_sourceSimIdx

private

Definition at line 1249 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simvtx_x

private

Definition at line 1246 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simvtx_y

private

Definition at line 1247 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::simvtx_z

private

Definition at line 1248 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTrackingVertices(), and TrackingNtuple().

edm::EDGetTokenT<edm::DetSetVector<PixelDigiSimLink> > TrackingNtuple::siphase2OTSimLinksToken_

private

Definition at line 641 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::str_bbxi

private

Definition at line 1103 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::str_chargeFraction

private

Definition at line 1090 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

DetIdStrip TrackingNtuple::str_detId

private

Definition at line 1086 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<short> TrackingNtuple::str_isBarrel

private

Definition at line 1085 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_radL

private

Definition at line 1102 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::str_seeIdx

private

Definition at line 1088 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillSeeds(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::str_simHitIdx

private

Definition at line 1089 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::str_simType

private

Definition at line 1091 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::str_trkIdx

private

Definition at line 1087 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_x

private

Definition at line 1092 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_xx

private

Definition at line 1095 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_xy

private

Definition at line 1096 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_y

private

Definition at line 1093 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_yy

private

Definition at line 1097 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_yz

private

Definition at line 1098 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_z

private

Definition at line 1094 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_zx

private

Definition at line 1100 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

std::vector<float> TrackingNtuple::str_zz

private

Definition at line 1099 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillStripRphiStereoHits(), and TrackingNtuple().

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> TrackingNtuple::stripMatchedRecHitToken_

private

Definition at line 647 of file TrackingNtuple.cc.

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripRphiRecHitToken_

private

Definition at line 645 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::DetSetVector<StripDigiSimLink> > TrackingNtuple::stripSimLinkToken_

private

Definition at line 640 of file TrackingNtuple.cc.

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripStereoRecHitToken_

private

Definition at line 646 of file TrackingNtuple.cc.

TTree* TrackingNtuple::t

private

Definition at line 663 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::ValueMap<unsigned int> > TrackingNtuple::tpNLayersToken_

private

Definition at line 651 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::ValueMap<unsigned int> > TrackingNtuple::tpNPixelLayersToken_

private

Definition at line 652 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::ValueMap<unsigned int> > TrackingNtuple::tpNStripStereoLayersToken_

private

Definition at line 653 of file TrackingNtuple.cc.

HistoryBase TrackingNtuple::tracer_

private

Definition at line 661 of file TrackingNtuple.cc.

edm::EDGetTokenT<reco::TrackToTrackingParticleAssociator> TrackingNtuple::trackAssociatorToken_

private

Definition at line 638 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingParticleRefVector> TrackingNtuple::trackingParticleRefToken_

private

Definition at line 635 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingParticleCollection> TrackingNtuple::trackingParticleToken_

private

Definition at line 634 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingVertexCollection> TrackingNtuple::trackingVertexToken_

private

Definition at line 650 of file TrackingNtuple.cc.

edm::EDGetTokenT<edm::View<reco::Track> > TrackingNtuple::trackToken_

private

Definition at line 631 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_algo

private

Definition at line 997 of file TrackingNtuple.cc.

std::vector<decltype(reco::TrackBase().algoMaskUL())> TrackingNtuple::trk_algoMask

private

Definition at line 999 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<int> TrackingNtuple::trk_bestFromFirstHitSimTrkIdx

private

Definition at line 1010 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkNChi2

private

Definition at line 1014 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFrac

private

Definition at line 1011 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

private

Definition at line 1013 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimDenom

private

Definition at line 1012 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<int> TrackingNtuple::trk_bestSimTrkIdx

private

Definition at line 1005 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestSimTrkNChi2

private

Definition at line 1009 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFrac

private

Definition at line 1006 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimClusterDenom

private

Definition at line 1008 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimDenom

private

Definition at line 1007 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_cotTheta

private

Definition at line 960 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxy

private

Definition at line 962 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxyClosestPV

private

Definition at line 966 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxyErr

private

Definition at line 972 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxyPV

private

Definition at line 964 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dz

private

Definition at line 963 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dzClosestPV

private

Definition at line 967 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dzErr

private

Definition at line 973 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dzPV

private

Definition at line 965 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_eta

private

Definition at line 958 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_etaErr

private

Definition at line 969 of file TrackingNtuple.cc.

std::vector<std::vector<int> > TrackingNtuple::trk_hitIdx

private

Definition at line 1018 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::trk_hitType

private

Definition at line 1019 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_inner_pt

private

Definition at line 953 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_px

private

Definition at line 950 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_py

private

Definition at line 951 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_pz

private

Definition at line 952 of file TrackingNtuple.cc.

std::vector<short> TrackingNtuple::trk_isHP

private

Definition at line 1001 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<short> TrackingNtuple::trk_isTrue

private

Definition at line 1004 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<float> TrackingNtuple::trk_lambda

private

Definition at line 959 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_lambdaErr

private

Definition at line 970 of file TrackingNtuple.cc.

std::vector<std::vector<float> > TrackingNtuple::trk_mvas

private

Definition at line 980 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_n3DLay

private

Definition at line 994 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_nChi2

private

Definition at line 977 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_nChi2_1Dmod

private

Definition at line 978 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nCluster

private

Definition at line 996 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_ndof

private

Definition at line 979 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nInactive

private

Definition at line 985 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nInnerInactive

private

Definition at line 991 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nInnerLost

private

Definition at line 989 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nLost

private

Definition at line 984 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nLostLay

private

Definition at line 995 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nOuterInactive

private

Definition at line 990 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nOuterLost

private

Definition at line 988 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nPixel

private

Definition at line 986 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nPixelLay

private

Definition at line 992 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nStrip

private

Definition at line 987 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nStripLay

private

Definition at line 993 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_nValid

private

Definition at line 983 of file TrackingNtuple.cc.

std::vector<unsigned int> TrackingNtuple::trk_originalAlgo

private

Definition at line 998 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_pt

private

Definition at line 957 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_px

private

Definition at line 954 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_py

private

Definition at line 955 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_pz

private

Definition at line 956 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_phi

private

Definition at line 961 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_phiErr

private

Definition at line 971 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_pt

private

Definition at line 949 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_ptErr

private

Definition at line 968 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_px

private

Definition at line 946 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_py

private

Definition at line 947 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_pz

private

Definition at line 948 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::trk_q

private

Definition at line 982 of file TrackingNtuple.cc.

std::vector<std::vector<unsigned short> > TrackingNtuple::trk_qualityMasks

private

Definition at line 981 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_x

private

Definition at line 974 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_y

private

Definition at line 975 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_z

private

Definition at line 976 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::trk_seedIdx

private

Definition at line 1002 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::trk_simTrkIdx

private

Definition at line 1017 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::trk_simTrkNChi2

private

Definition at line 1016 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<std::vector<float> > TrackingNtuple::trk_simTrkShareFrac

private

Definition at line 1015 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<unsigned short> TrackingNtuple::trk_stopReason

private

Definition at line 1000 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), and TrackingNtuple().

std::vector<int> TrackingNtuple::trk_vtxIdx

private

Definition at line 1003 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillTracks(), fillVertices(), and TrackingNtuple().

edm::EDGetTokenT<reco::VertexCollection> TrackingNtuple::vertexToken_

private

Definition at line 649 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::vtx_chi2

private

Definition at line 1235 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<short> TrackingNtuple::vtx_fake

private

Definition at line 1236 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_ndof

private

Definition at line 1234 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<std::vector<int> > TrackingNtuple::vtx_trkIdx

private

Definition at line 1238 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<short> TrackingNtuple::vtx_valid

private

Definition at line 1237 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_x

private

Definition at line 1228 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_xErr

private

Definition at line 1231 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_y

private

Definition at line 1229 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_yErr

private

Definition at line 1232 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_z

private

Definition at line 1230 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

std::vector<float> TrackingNtuple::vtx_zErr

private

Definition at line 1233 of file TrackingNtuple.cc.

Referenced by clearVariables(), fillVertices(), and TrackingNtuple().

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation