TrackingNtuple Class Reference

#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
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () 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
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, 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
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices 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	Phase2OTMaskContainer = edm::ContainerMask< edmNew::DetSetVector< Phase2TrackerCluster1D > >
using	PixelMaskContainer = edm::ContainerMask< edmNew::DetSetVector< SiPixelCluster > >
using	QualityMaskCollection = std::vector< unsigned char >
using	StripMaskContainer = edm::ContainerMask< edmNew::DetSetVector< SiStripCluster > >

Private Member Functions
size_t	addStripMatchedHit (const SiStripMatchedRecHit2D &hit, const TrackerGeometry &tracker, const TrackerTopology &tTopo, const std::vector< std::pair< uint64_t, StripMaskContainer const *>> &stripMasks, 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	fillCandidates (const edm::Handle< TrackCandidateCollection > &candsHandle, int algo, 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 TrackerGeometry &tracker, const TrackerTopology &tTopo, const std::set< edm::ProductID > &hitProductIds, const std::map< edm::ProductID, size_t > &seedToCollIndex)
void	fillPhase2OTHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackerGeometry &tracker, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)
void	fillPixelHits (const edm::Event &iEvent, const TrackerGeometry &tracker, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, 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 TrackerGeometry &tracker, const reco::TrackToTrackingParticleAssociator &associatorByHits, const ClusterTPAssociation &clusterToTPMap, 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 TrackerGeometry &tracker, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)
void	fillStripRphiStereoHits (const edm::Event &iEvent, const TrackerGeometry &tracker, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< StripDigiSimLink > &digiSimLink, 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 TrackerGeometry &tracker, 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 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 TrackingRecHit &hit, 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
const bool	addSeedCurvCov_
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_
std::vector< edm::EDGetTokenT< TrackCandidateCollection > >	candidateTokens_
edm::EDGetTokenT< ClusterTPAssociation >	clusterTPMapToken_
edm::EventNumber_t	ev_event
edm::LuminosityBlockNumber_t	ev_lumi
edm::RunNumber_t	ev_run
std::vector< float >	glu_bbxi
std::vector< float >	glu_chargePerCM
std::vector< int >	glu_clustSizeMono
std::vector< int >	glu_clustSizeStereo
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< uint64_t >	glu_usedMaskMono
std::vector< uint64_t >	glu_usedMaskStereo
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_
const bool	includeOnTrackHitData_
const bool	includeOOT_
bool	includePhase2OTHits_
const bool	includeSeeds_
bool	includeStripHits_
const bool	includeTrackCandidates_
const bool	includeTrackingParticles_
DetIdAll	inv_detId
DetIdAllPhase2	inv_detId_phase2
std::vector< short >	inv_isBarrel
std::vector< unsigned short >	inv_type
const bool	keepEleSimHits_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	mfToken_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > >	mvaQualityCollectionTokens_
ParametersDefinerForTP	parametersDefiner_
std::vector< float >	ph2_bbxi
DetIdPhase2OT	ph2_detId
std::vector< short >	ph2_isBarrel
std::vector< std::vector< float > >	ph2_onTrk_x
std::vector< std::vector< float > >	ph2_onTrk_xx
std::vector< std::vector< float > >	ph2_onTrk_xy
std::vector< std::vector< float > >	ph2_onTrk_y
std::vector< std::vector< float > >	ph2_onTrk_yy
std::vector< std::vector< float > >	ph2_onTrk_yz
std::vector< std::vector< float > >	ph2_onTrk_z
std::vector< std::vector< float > >	ph2_onTrk_zx
std::vector< std::vector< float > >	ph2_onTrk_zz
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_tcandIdx
std::vector< std::vector< int > >	ph2_trkIdx
std::vector< uint64_t >	ph2_usedMask
std::vector< float >	ph2_x
std::vector< float >	ph2_xx
std::vector< float >	ph2_xy
std::vector< std::vector< float > >	ph2_xySignificance
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
std::vector< std::pair< unsigned int, edm::EDGetTokenT< Phase2OTMaskContainer > > >	ph2OTUseMaskTokens_
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew >	phase2OTRecHitToken_
std::vector< float >	pix_bbxi
std::vector< std::vector< float > >	pix_chargeFraction
std::vector< int >	pix_clustSizeCol
std::vector< int >	pix_clustSizeRow
DetIdPixel	pix_detId
std::vector< short >	pix_isBarrel
std::vector< std::vector< float > >	pix_onTrk_x
std::vector< std::vector< float > >	pix_onTrk_xx
std::vector< std::vector< float > >	pix_onTrk_xy
std::vector< std::vector< float > >	pix_onTrk_y
std::vector< std::vector< float > >	pix_onTrk_yy
std::vector< std::vector< float > >	pix_onTrk_yz
std::vector< std::vector< float > >	pix_onTrk_z
std::vector< std::vector< float > >	pix_onTrk_zx
std::vector< std::vector< float > >	pix_onTrk_zz
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_tcandIdx
std::vector< std::vector< int > >	pix_trkIdx
std::vector< uint64_t >	pix_usedMask
std::vector< float >	pix_x
std::vector< float >	pix_xx
std::vector< float >	pix_xy
std::vector< std::vector< float > >	pix_xySignificance
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< std::pair< unsigned int, edm::EDGetTokenT< PixelMaskContainer > > >	pixelUseMaskTokens_
const bool	saveSimHitsP3_
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< std::vector< float > >	see_stateCurvCov
std::vector< float >	see_statePt
std::vector< float >	see_stateTrajGlbPx
std::vector< float >	see_stateTrajGlbPy
std::vector< float >	see_stateTrajGlbPz
std::vector< float >	see_stateTrajGlbX
std::vector< float >	see_stateTrajGlbY
std::vector< float >	see_stateTrajGlbZ
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_tcandIdx
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< float >	simhit_px
std::vector< float >	simhit_py
std::vector< float >	simhit_pz
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
const bool	simHitBySignificance_
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
std::vector< float >	str_chargePerCM
std::vector< int >	str_clustSize
DetIdStrip	str_detId
std::vector< short >	str_isBarrel
std::vector< std::vector< float > >	str_onTrk_x
std::vector< std::vector< float > >	str_onTrk_xx
std::vector< std::vector< float > >	str_onTrk_xy
std::vector< std::vector< float > >	str_onTrk_y
std::vector< std::vector< float > >	str_onTrk_yy
std::vector< std::vector< float > >	str_onTrk_yz
std::vector< std::vector< float > >	str_onTrk_z
std::vector< std::vector< float > >	str_onTrk_zx
std::vector< std::vector< float > >	str_onTrk_zz
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_tcandIdx
std::vector< std::vector< int > >	str_trkIdx
std::vector< uint64_t >	str_usedMask
std::vector< float >	str_x
std::vector< float >	str_xx
std::vector< float >	str_xy
std::vector< std::vector< float > >	str_xySignificance
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_
std::vector< std::pair< unsigned int, edm::EDGetTokenT< StripMaskContainer > > >	stripUseMaskTokens_
TTree *	t
std::vector< unsigned int >	tcand_algo
std::vector< int >	tcand_bestFromFirstHitSimTrkIdx
std::vector< float >	tcand_bestFromFirstHitSimTrkNChi2
std::vector< float >	tcand_bestFromFirstHitSimTrkShareFrac
std::vector< float >	tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom
std::vector< float >	tcand_bestFromFirstHitSimTrkShareFracSimDenom
std::vector< int >	tcand_bestSimTrkIdx
std::vector< float >	tcand_bestSimTrkNChi2
std::vector< float >	tcand_bestSimTrkShareFrac
std::vector< float >	tcand_bestSimTrkShareFracSimClusterDenom
std::vector< float >	tcand_bestSimTrkShareFracSimDenom
std::vector< std::vector< int > >	tcand_hitIdx
std::vector< std::vector< int > >	tcand_hitType
std::vector< short >	tcand_isTrue
std::vector< float >	tcand_lambdaErr
std::vector< unsigned int >	tcand_nCluster
std::vector< float >	tcand_ndof
std::vector< unsigned int >	tcand_nPixel
std::vector< unsigned int >	tcand_nStrip
std::vector< unsigned int >	tcand_nValid
std::vector< float >	tcand_pca_dxy
std::vector< float >	tcand_pca_dxyErr
std::vector< float >	tcand_pca_dz
std::vector< float >	tcand_pca_dzErr
std::vector< float >	tcand_pca_eta
std::vector< float >	tcand_pca_etaErr
std::vector< float >	tcand_pca_lambdaErr
std::vector< float >	tcand_pca_phi
std::vector< float >	tcand_pca_phiErr
std::vector< float >	tcand_pca_pt
std::vector< float >	tcand_pca_ptErr
std::vector< float >	tcand_pca_px
std::vector< float >	tcand_pca_py
std::vector< float >	tcand_pca_pz
std::vector< short >	tcand_pca_valid
std::vector< float >	tcand_phiErr
std::vector< float >	tcand_pt
std::vector< float >	tcand_px
std::vector< float >	tcand_py
std::vector< float >	tcand_pz
std::vector< int >	tcand_q
std::vector< float >	tcand_qbpErr
std::vector< int >	tcand_seedIdx
std::vector< std::vector< int > >	tcand_simTrkIdx
std::vector< std::vector< float > >	tcand_simTrkNChi2
std::vector< std::vector< float > >	tcand_simTrkShareFrac
std::vector< unsigned short >	tcand_stopReason
std::vector< int >	tcand_vtxIdx
std::vector< float >	tcand_x
std::vector< float >	tcand_xtErr
std::vector< float >	tcand_y
std::vector< float >	tcand_ytErr
std::vector< float >	tcand_z
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	tGeomToken_
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
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	tTopoToken_
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)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
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)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 472 of file TrackingNtuple.cc.

Member Typedef Documentation

DetIdAll

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

private

Definition at line 983 of file TrackingNtuple.cc.

DetIdAllPhase2

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

private

Definition at line 984 of file TrackingNtuple.cc.

DetIdPhase2OT

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

private

Definition at line 982 of file TrackingNtuple.cc.

DetIdPixel

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

private

Definition at line 980 of file TrackingNtuple.cc.

DetIdStrip

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

private

Definition at line 981 of file TrackingNtuple.cc.

MVACollection

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

private

Definition at line 492 of file TrackingNtuple.cc.

Phase2OTMaskContainer

using TrackingNtuple::Phase2OTMaskContainer = edm::ContainerMask<edmNew::DetSetVector<Phase2TrackerCluster1D> >

private

Definition at line 497 of file TrackingNtuple.cc.

PixelMaskContainer

using TrackingNtuple::PixelMaskContainer = edm::ContainerMask<edmNew::DetSetVector<SiPixelCluster> >

private

Definition at line 495 of file TrackingNtuple.cc.

QualityMaskCollection

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

private

Definition at line 493 of file TrackingNtuple.cc.

StripMaskContainer

using TrackingNtuple::StripMaskContainer = edm::ContainerMask<edmNew::DetSetVector<SiStripCluster> >

private

Definition at line 496 of file TrackingNtuple.cc.

Member Enumeration Documentation

HitSimType

enum TrackingNtuple::HitSimType

strongprivate

Enumerator
Signal
ITPileup
OOTPileup
Noise
Unknown

Definition at line 490 of file TrackingNtuple.cc.

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

HitType

enum TrackingNtuple::HitType

strongprivate

Enumerator
Pixel
Strip
Glued
Invalid
Phase2OT
Unknown

Definition at line 484 of file TrackingNtuple.cc.

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

Constructor & Destructor Documentation

TrackingNtuple()

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

explicit

Definition at line 1417 of file TrackingNtuple.cc.

References addSeedCurvCov_, cms::cuda::assert(), bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, candidateTokens_, HistoryBase::depth(), ev_event, ev_lumi, ev_run, Exception, compareTotals::fs, edm::ParameterSet::getUntrackedParameter(), edm::ParameterSet::getUntrackedParameterSetVector(), glu_bbxi, glu_chargePerCM, glu_clustSizeMono, glu_clustSizeStereo, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_usedMaskMono, glu_usedMaskStereo, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, mps_fire::i, includeAllHits_, includeMVA_, includeOnTrackHitData_, includePhase2OTHits_, includeSeeds_, includeStripHits_, includeTrackCandidates_, includeTrackingParticles_, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, TFileService::kSharedResource, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, mvaQualityCollectionTokens_, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_onTrk_x, ph2_onTrk_xx, ph2_onTrk_xy, ph2_onTrk_y, ph2_onTrk_yy, ph2_onTrk_yz, ph2_onTrk_z, ph2_onTrk_zx, ph2_onTrk_zz, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_tcandIdx, ph2_trkIdx, ph2_usedMask, ph2_x, ph2_xx, ph2_xy, ph2_xySignificance, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, ph2OTUseMaskTokens_, pix_bbxi, pix_chargeFraction, pix_clustSizeCol, pix_clustSizeRow, pix_detId, pix_isBarrel, pix_onTrk_x, pix_onTrk_xx, pix_onTrk_xy, pix_onTrk_y, pix_onTrk_yy, pix_onTrk_yz, pix_onTrk_z, pix_onTrk_zx, pix_onTrk_zz, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_tcandIdx, pix_trkIdx, pix_usedMask, pix_x, pix_xx, pix_xy, pix_xySignificance, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, pixelUseMaskTokens_, saveSimHitsP3_, 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_stateCurvCov, see_statePt, see_stateTrajGlbPx, see_stateTrajGlbPy, see_stateTrajGlbPz, see_stateTrajGlbX, see_stateTrajGlbY, see_stateTrajGlbZ, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_tcandIdx, see_trkIdx, seedStopInfoTokens_, seedTokens_, 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_px, simhit_py, simhit_pz, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simHitBySignificance_, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_chargePerCM, str_clustSize, str_detId, str_isBarrel, str_onTrk_x, str_onTrk_xx, str_onTrk_xy, str_onTrk_y, str_onTrk_yy, str_onTrk_yz, str_onTrk_z, str_onTrk_zx, str_onTrk_zz, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_tcandIdx, str_trkIdx, str_usedMask, str_x, str_xx, str_xy, str_xySignificance, str_y, str_yy, str_yz, str_z, str_zx, str_zz, AlCaHLTBitMon_QueryRunRegistry::string, stripUseMaskTokens_, t, makeGlobalPositionRcd_cfg::tag, tcand_algo, tcand_bestFromFirstHitSimTrkIdx, tcand_bestFromFirstHitSimTrkNChi2, tcand_bestFromFirstHitSimTrkShareFrac, tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom, tcand_bestFromFirstHitSimTrkShareFracSimDenom, tcand_bestSimTrkIdx, tcand_bestSimTrkNChi2, tcand_bestSimTrkShareFrac, tcand_bestSimTrkShareFracSimClusterDenom, tcand_bestSimTrkShareFracSimDenom, tcand_hitIdx, tcand_hitType, tcand_isTrue, tcand_lambdaErr, tcand_nCluster, tcand_ndof, tcand_nPixel, tcand_nStrip, tcand_nValid, tcand_pca_dxy, tcand_pca_dxyErr, tcand_pca_dz, tcand_pca_dzErr, tcand_pca_eta, tcand_pca_etaErr, tcand_pca_lambdaErr, tcand_pca_phi, tcand_pca_phiErr, tcand_pca_pt, tcand_pca_ptErr, tcand_pca_px, tcand_pca_py, tcand_pca_pz, tcand_pca_valid, tcand_phiErr, tcand_pt, tcand_px, tcand_py, tcand_pz, tcand_q, tcand_qbpErr, tcand_seedIdx, tcand_simTrkIdx, tcand_simTrkNChi2, tcand_simTrkShareFrac, tcand_stopReason, tcand_vtxIdx, tcand_x, tcand_xtErr, tcand_y, tcand_ytErr, tcand_z, to_string(), MuonAssociatorByHits_cfi::tpTag, tracer_, trackingParticleRefToken_, trackingParticleToken_, trk_algo, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_cotTheta, trk_dxy, trk_dxyClosestPV, trk_dxyErr, trk_dxyPV, trk_dz, trk_dzClosestPV, trk_dzErr, trk_dzPV, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_isTrue, trk_lambda, trk_lambdaErr, trk_mvas, trk_n3DLay, trk_nChi2, trk_nChi2_1Dmod, trk_nCluster, trk_ndof, trk_nInactive, trk_nInnerInactive, trk_nInnerLost, trk_nLost, trk_nLostLay, trk_nOuterInactive, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_qualityMasks, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, 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.

    : mfToken_(esConsumes()),
      tTopoToken_(esConsumes()),
      tGeomToken_(esConsumes()),
      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"))),
      includeSeeds_(iConfig.getUntrackedParameter<bool>("includeSeeds")),
      includeTrackCandidates_(iConfig.getUntrackedParameter<bool>("includeTrackCandidates")),
      addSeedCurvCov_(iConfig.getUntrackedParameter<bool>("addSeedCurvCov")),
      includeAllHits_(iConfig.getUntrackedParameter<bool>("includeAllHits")),
      includeOnTrackHitData_(iConfig.getUntrackedParameter<bool>("includeOnTrackHitData")),
      includeMVA_(iConfig.getUntrackedParameter<bool>("includeMVA")),
      includeTrackingParticles_(iConfig.getUntrackedParameter<bool>("includeTrackingParticles")),
      includeOOT_(iConfig.getUntrackedParameter<bool>("includeOOT")),
      keepEleSimHits_(iConfig.getUntrackedParameter<bool>("keepEleSimHits")),
      saveSimHitsP3_(iConfig.getUntrackedParameter<bool>("saveSimHitsP3")),
      simHitBySignificance_(iConfig.getUntrackedParameter<bool>("simHitBySignificance")),
      parametersDefiner_(iConfig.getUntrackedParameter<edm::InputTag>("beamSpot"), consumesCollector()) {
  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 (includeTrackCandidates_)
    candidateTokens_ =
        edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("trackCandidates"),
                              [&](const edm::InputTag& tag) { return consumes<TrackCandidateCollection>(tag); });

  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.";
    }

    auto const& maskVPset = iConfig.getUntrackedParameterSetVector("clusterMasks");
    pixelUseMaskTokens_.reserve(maskVPset.size());
    stripUseMaskTokens_.reserve(maskVPset.size());
    ph2OTUseMaskTokens_.reserve(maskVPset.size());
    for (auto const& mask : maskVPset) {
      auto index = mask.getUntrackedParameter<unsigned int>("index");
      assert(index < 64);
      pixelUseMaskTokens_.emplace_back(index,
                                       consumes<PixelMaskContainer>(mask.getUntrackedParameter<edm::InputTag>("src")));
      if (includeStripHits_)
        stripUseMaskTokens_.emplace_back(
            index, consumes<StripMaskContainer>(mask.getUntrackedParameter<edm::InputTag>("src")));
      if (includePhase2OTHits_)
        ph2OTUseMaskTokens_.emplace_back(
            index, consumes<Phase2OTMaskContainer>(mask.getUntrackedParameter<edm::InputTag>("src")));
    }
  }

  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 (includeTrackCandidates_) {
    t->Branch("tcand_pca_valid", &tcand_pca_valid);
    t->Branch("tcand_pca_px", &tcand_pca_px);
    t->Branch("tcand_pca_py", &tcand_pca_py);
    t->Branch("tcand_pca_pz", &tcand_pca_pz);
    t->Branch("tcand_pca_pt", &tcand_pca_pt);
    t->Branch("tcand_pca_eta", &tcand_pca_eta);
    t->Branch("tcand_pca_phi", &tcand_pca_phi);
    t->Branch("tcand_pca_dxy", &tcand_pca_dxy);
    t->Branch("tcand_pca_dz", &tcand_pca_dz);
    t->Branch("tcand_pca_ptErr", &tcand_pca_ptErr);
    t->Branch("tcand_pca_etaErr", &tcand_pca_etaErr);
    t->Branch("tcand_pca_lambdaErr", &tcand_pca_lambdaErr);
    t->Branch("tcand_pca_phiErr", &tcand_pca_phiErr);
    t->Branch("tcand_pca_dxyErr", &tcand_pca_dxyErr);
    t->Branch("tcand_pca_dzErr", &tcand_pca_dzErr);
    t->Branch("tcand_px", &tcand_px);
    t->Branch("tcand_py", &tcand_py);
    t->Branch("tcand_pz", &tcand_pz);
    t->Branch("tcand_pt", &tcand_pt);
    t->Branch("tcand_x", &tcand_x);
    t->Branch("tcand_y", &tcand_y);
    t->Branch("tcand_z", &tcand_z);
    t->Branch("tcand_qbpErr", &tcand_qbpErr);
    t->Branch("tcand_lambdaErr", &tcand_lambdaErr);
    t->Branch("tcand_phiErr", &tcand_phiErr);
    t->Branch("tcand_xtErr", &tcand_xtErr);
    t->Branch("tcand_ytErr", &tcand_ytErr);
    t->Branch("tcand_q", &tcand_q);
    t->Branch("tcand_ndof", &tcand_ndof);
    t->Branch("tcand_nValid", &tcand_nValid);
    t->Branch("tcand_nPixel", &tcand_nPixel);
    t->Branch("tcand_nStrip", &tcand_nStrip);
    t->Branch("tcand_nCluster", &tcand_nCluster);
    t->Branch("tcand_algo", &tcand_algo);
    t->Branch("tcand_stopReason", &tcand_stopReason);
    if (includeSeeds_) {
      t->Branch("tcand_seedIdx", &tcand_seedIdx);
    }
    t->Branch("tcand_vtxIdx", &tcand_vtxIdx);
    if (includeTrackingParticles_) {
      t->Branch("tcand_simTrkIdx", &tcand_simTrkIdx);
      t->Branch("tcand_simTrkShareFrac", &tcand_simTrkShareFrac);
      t->Branch("tcand_simTrkNChi2", &tcand_simTrkNChi2);
      t->Branch("tcand_bestSimTrkIdx", &tcand_bestSimTrkIdx);
      t->Branch("tcand_bestFromFirstHitSimTrkIdx", &tcand_bestFromFirstHitSimTrkIdx);
    } else {
      t->Branch("tcand_isTrue", &tcand_isTrue);
    }
    t->Branch("tcand_bestSimTrkShareFrac", &tcand_bestSimTrkShareFrac);
    t->Branch("tcand_bestSimTrkShareFracSimDenom", &tcand_bestSimTrkShareFracSimDenom);
    t->Branch("tcand_bestSimTrkShareFracSimClusterDenom", &tcand_bestSimTrkShareFracSimClusterDenom);
    t->Branch("tcand_bestSimTrkNChi2", &tcand_bestSimTrkNChi2);
    t->Branch("tcand_bestFromFirstHitSimTrkShareFrac", &tcand_bestFromFirstHitSimTrkShareFrac);
    t->Branch("tcand_bestFromFirstHitSimTrkShareFracSimDenom", &tcand_bestFromFirstHitSimTrkShareFracSimDenom);
    t->Branch("tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom",
              &tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom);
    t->Branch("tcand_bestFromFirstHitSimTrkNChi2", &tcand_bestFromFirstHitSimTrkNChi2);
    if (includeAllHits_) {
      t->Branch("tcand_hitIdx", &tcand_hitIdx);
      t->Branch("tcand_hitType", &tcand_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 (includeOnTrackHitData_) {
      t->Branch("pix_onTrk_x", &pix_onTrk_x);
      t->Branch("pix_onTrk_y", &pix_onTrk_y);
      t->Branch("pix_onTrk_z", &pix_onTrk_z);
      t->Branch("pix_onTrk_xx", &pix_onTrk_xx);
      t->Branch("pix_onTrk_xy", &pix_onTrk_xy);
      t->Branch("pix_onTrk_yy", &pix_onTrk_yy);
      t->Branch("pix_onTrk_yz", &pix_onTrk_yz);
      t->Branch("pix_onTrk_zz", &pix_onTrk_zz);
      t->Branch("pix_onTrk_zx", &pix_onTrk_zx);
    }
    if (includeTrackCandidates_)
      t->Branch("pix_tcandIdx", &pix_tcandIdx);
    if (includeSeeds_) {
      t->Branch("pix_seeIdx", &pix_seeIdx);
    }
    if (includeTrackingParticles_) {
      t->Branch("pix_simHitIdx", &pix_simHitIdx);
      if (simHitBySignificance_) {
        t->Branch("pix_xySignificance", &pix_xySignificance);
      }
      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_clustSizeCol", &pix_clustSizeCol);
    t->Branch("pix_clustSizeRow", &pix_clustSizeRow);
    t->Branch("pix_usedMask", &pix_usedMask);
    //strips
    if (includeStripHits_) {
      t->Branch("str_isBarrel", &str_isBarrel);
      str_detId.book("str", t);
      t->Branch("str_trkIdx", &str_trkIdx);
      if (includeOnTrackHitData_) {
        t->Branch("str_onTrk_x", &str_onTrk_x);
        t->Branch("str_onTrk_y", &str_onTrk_y);
        t->Branch("str_onTrk_z", &str_onTrk_z);
        t->Branch("str_onTrk_xx", &str_onTrk_xx);
        t->Branch("str_onTrk_xy", &str_onTrk_xy);
        t->Branch("str_onTrk_yy", &str_onTrk_yy);
        t->Branch("str_onTrk_yz", &str_onTrk_yz);
        t->Branch("str_onTrk_zz", &str_onTrk_zz);
        t->Branch("str_onTrk_zx", &str_onTrk_zx);
      }
      if (includeTrackCandidates_)
        t->Branch("str_tcandIdx", &str_tcandIdx);
      if (includeSeeds_) {
        t->Branch("str_seeIdx", &str_seeIdx);
      }
      if (includeTrackingParticles_) {
        t->Branch("str_simHitIdx", &str_simHitIdx);
        if (simHitBySignificance_) {
          t->Branch("str_xySignificance", &str_xySignificance);
        }
        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);
      t->Branch("str_chargePerCM", &str_chargePerCM);
      t->Branch("str_clustSize", &str_clustSize);
      t->Branch("str_usedMask", &str_usedMask);
      //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);
      t->Branch("glu_chargePerCM", &glu_chargePerCM);
      t->Branch("glu_clustSizeMono", &glu_clustSizeMono);
      t->Branch("glu_clustSizeStereo", &glu_clustSizeStereo);
      t->Branch("glu_usedMaskMono", &glu_usedMaskMono);
      t->Branch("glu_usedMaskStereo", &glu_usedMaskStereo);
    }
    //phase2 OT
    if (includePhase2OTHits_) {
      t->Branch("ph2_isBarrel", &ph2_isBarrel);
      ph2_detId.book("ph2", t);
      t->Branch("ph2_trkIdx", &ph2_trkIdx);
      if (includeOnTrackHitData_) {
        t->Branch("ph2_onTrk_x", &ph2_onTrk_x);
        t->Branch("ph2_onTrk_y", &ph2_onTrk_y);
        t->Branch("ph2_onTrk_z", &ph2_onTrk_z);
        t->Branch("ph2_onTrk_xx", &ph2_onTrk_xx);
        t->Branch("ph2_onTrk_xy", &ph2_onTrk_xy);
        t->Branch("ph2_onTrk_yy", &ph2_onTrk_yy);
        t->Branch("ph2_onTrk_yz", &ph2_onTrk_yz);
        t->Branch("ph2_onTrk_zz", &ph2_onTrk_zz);
        t->Branch("ph2_onTrk_zx", &ph2_onTrk_zx);
      }
      if (includeTrackCandidates_)
        t->Branch("ph2_tcandIdx", &ph2_tcandIdx);
      if (includeSeeds_) {
        t->Branch("ph2_seeIdx", &ph2_seeIdx);
      }
      if (includeTrackingParticles_) {
        t->Branch("ph2_simHitIdx", &ph2_simHitIdx);
        if (simHitBySignificance_) {
          t->Branch("ph2_xySignificance", &ph2_xySignificance);
        }
        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_usedMask", &ph2_usedMask);
    }
    //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);
      if (saveSimHitsP3_) {
        t->Branch("simhit_px", &simhit_px);
        t->Branch("simhit_py", &simhit_py);
        t->Branch("simhit_pz", &simhit_pz);
      }
      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_stateTrajGlbX", &see_stateTrajGlbX);
    t->Branch("see_stateTrajGlbY", &see_stateTrajGlbY);
    t->Branch("see_stateTrajGlbZ", &see_stateTrajGlbZ);
    t->Branch("see_stateTrajGlbPx", &see_stateTrajGlbPx);
    t->Branch("see_stateTrajGlbPy", &see_stateTrajGlbPy);
    t->Branch("see_stateTrajGlbPz", &see_stateTrajGlbPz);
    if (addSeedCurvCov_) {
      t->Branch("see_stateCurvCov", &see_stateCurvCov);
    }
    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 (includeTrackCandidates_)
      t->Branch("see_tcandIdx", &see_tcandIdx);
    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::~TrackingNtuple ( )

override

Definition at line 2014 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

addStripMatchedHit()

size_t TrackingNtuple::addStripMatchedHit ( const SiStripMatchedRecHit2D &  hit, const TrackerGeometry &  tracker, const TrackerTopology &  tTopo, const std::vector< std::pair< uint64_t, StripMaskContainer const *>> &  stripMasks, std::vector< std::pair< int, int >> &  monoStereoClusterList  )

private

Definition at line 3252 of file TrackingNtuple.cc.

References siStripClusterTools::chargePerCM(), glu_bbxi, glu_chargePerCM, glu_clustSizeMono, glu_clustSizeStereo, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_usedMaskMono, glu_usedMaskStereo, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, submitPVResolutionJobs::key, TrackerTopology::layer(), LogTrace, visualization-live-secondInstance_cfg::m, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, StripSubdetector::TIB, StripSubdetector::TOB, PbPb_ZMuSkimMuonDPG_cff::tracker, hit::x, hit::y, and hit::z.

Referenced by fillSeeds(), and fillStripMatchedHits().

                                                                                               {
  auto strUsedMask = [&stripMasks](size_t key) {
    uint64_t mask = 0;
    for (auto const& m : stripMasks) {
      if (m.second->mask(key))
        mask |= m.first;
    }
    return mask;
  };

  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(tracker, 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(hit.globalPosition().x());
  glu_y.push_back(hit.globalPosition().y());
  glu_z.push_back(hit.globalPosition().z());
  glu_xx.push_back(hit.globalPositionError().cxx());
  glu_xy.push_back(hit.globalPositionError().cyx());
  glu_yy.push_back(hit.globalPositionError().cyy());
  glu_yz.push_back(hit.globalPositionError().czy());
  glu_zz.push_back(hit.globalPositionError().czz());
  glu_zx.push_back(hit.globalPositionError().czx());
  glu_radL.push_back(hit.surface()->mediumProperties().radLen());
  glu_bbxi.push_back(hit.surface()->mediumProperties().xi());
  glu_chargePerCM.push_back(siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster()));
  glu_clustSizeMono.push_back(hit.monoHit().cluster()->amplitudes().size());
  glu_clustSizeStereo.push_back(hit.stereoHit().cluster()->amplitudes().size());
  glu_usedMaskMono.push_back(strUsedMask(hit.monoHit().cluster().key()));
  glu_usedMaskStereo.push_back(strUsedMask(hit.stereoHit().cluster().key()));
  LogTrace("TrackingNtuple") << "stripMatchedHit"
                             << " cluster0=" << hit.stereoHit().cluster().key()
                             << " cluster1=" << hit.monoHit().cluster().key() << " subdId=" << hitId.subdetId()
                             << " lay=" << lay << " rawId=" << hitId.rawId() << " pos =" << hit.globalPosition();
  return glu_isBarrel.size() - 1;
}

analyze()

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 2420 of file TrackingNtuple.cc.

References reco::TrackBase::algoByName(), align::BeamSpot, beamSpotToken_, cms::cuda::bs, candidateTokens_, clearVariables(), clusterTPMapToken_, ev_event, ev_lumi, ev_run, Exception, fillBeamSpot(), fillCandidates(), fillPhase2OTHits(), fillPixelHits(), fillSeeds(), fillSimHits(), fillStripMatchedHits(), fillStripRphiStereoHits(), fillTrackingParticles(), fillTrackingVertices(), fillTracks(), fillVertices(), edm::EventSetup::getData(), mps_fire::i, iEvent, includeAllHits_, includeMVA_, includeOOT_, includePhase2OTHits_, includeSeeds_, includeStripHits_, includeTrackCandidates_, includeTrackingParticles_, edm::EDGetTokenT< T >::isUninitialized(), label, SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), LogDebug, mfToken_, mvaQualityCollectionTokens_, pixelSimLinkToken_, edm::Handle< T >::product(), edm::RefToBaseVector< T >::push_back(), edm::RefVector< C, T, F >::push_back(), simHitTPMapToken_, siphase2OTSimLinksToken_, edm::RefVector< C, T, F >::size(), findQualityFiles::size, jetUpdater_cfi::sort, stripSimLinkToken_, t, tGeomToken_, unpackBuffers-CaloStage2::token, tpHitIndexListLessSort(), trackAssociatorToken_, PbPb_ZMuSkimMuonDPG_cff::tracker, trackingParticleRefToken_, trackingParticleToken_, trackingVertexToken_, DiMuonV_cfg::tracks, trackToken_, tTopoToken_, findQualityFiles::v, vertexToken_, and AlignmentTracksFromVertexSelector_cfi::vertices.

                                                                                {
  using namespace edm;
  using namespace reco;
  using namespace std;

  const auto& mf = iSetup.getData(mfToken_);
  const TrackerTopology& tTopo = iSetup.getData(tTopoToken_);
  const TrackerGeometry& tracker = iSetup.getData(tGeomToken_);

  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 (!includeOOT_ && v.eventId().bunchCrossing() != 0)  // Ignore OOTPU
      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,
                  tracker,
                  clusterToTPMap,
                  tpKeyToIndex,
                  *simHitsTPAssoc,
                  pixelDigiSimLinks,
                  tTopo,
                  simHitRefKeyToIndex,
                  hitProductIds);

    //strip hits
    if (includeStripHits_) {
      LogDebug("TrackingNtuple") << "foundStripSimLink";
      const auto& stripDigiSimLinks = *stripDigiSimLinksHandle;
      fillStripRphiStereoHits(iEvent,
                              tracker,
                              clusterToTPMap,
                              tpKeyToIndex,
                              *simHitsTPAssoc,
                              stripDigiSimLinks,
                              tTopo,
                              simHitRefKeyToIndex,
                              hitProductIds);

      //matched hits
      fillStripMatchedHits(iEvent, tracker, tTopo, monoStereoClusterList);
    }

    if (includePhase2OTHits_) {
      LogDebug("TrackingNtuple") << "foundPhase2OTSimLinks";
      const auto& phase2OTSimLinks = *siphase2OTSimLinksHandle;
      fillPhase2OTHits(iEvent,
                       clusterToTPMap,
                       tracker,
                       tpKeyToIndex,
                       *simHitsTPAssoc,
                       phase2OTSimLinks,
                       tTopo,
                       simHitRefKeyToIndex,
                       hitProductIds);
    }
  }

  //seeds
  if (includeSeeds_) {
    fillSeeds(iEvent,
              tpCollection,
              tpKeyToIndex,
              bs,
              tracker,
              associatorByHits,
              clusterToTPMap,
              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,
             tracker,
             tpCollection,
             tpKeyToIndex,
             tpKeyToClusterCount,
             mf,
             bs,
             *vertices,
             associatorByHits,
             clusterToTPMap,
             tTopo,
             hitProductIds,
             seedCollToOffset,
             mvaColls,
             qualColls);

  if (includeTrackCandidates_) {
    //candidates
    for (auto const& token : candidateTokens_) {
      auto const tCandsHandle = iEvent.getHandle(token);

      edm::EDConsumerBase::Labels labels;
      labelsForToken(token, labels);
      TString label = labels.module;
      label.ReplaceAll("TrackCandidates", "");
      label.ReplaceAll("muonSeeded", "muonSeededStep");
      int algo = reco::TrackBase::algoByName(label.Data());

      fillCandidates(tCandsHandle,
                     algo,
                     tpCollection,
                     tpKeyToIndex,
                     tpKeyToClusterCount,
                     mf,
                     bs,
                     *vertices,
                     associatorByHits,
                     clusterToTPMap,
                     tracker,
                     tTopo,
                     hitProductIds,
                     seedCollToOffset);
    }
  }

  //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();
}

clearVariables()

void TrackingNtuple::clearVariables ( )

private

Definition at line 2022 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, ev_event, ev_lumi, ev_run, glu_bbxi, glu_chargePerCM, glu_clustSizeMono, glu_clustSizeStereo, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_usedMaskMono, glu_usedMaskStereo, 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, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, beam_dqm_sourceclient-live_cfg::mva, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_onTrk_x, ph2_onTrk_xx, ph2_onTrk_xy, ph2_onTrk_y, ph2_onTrk_yy, ph2_onTrk_yz, ph2_onTrk_z, ph2_onTrk_zx, ph2_onTrk_zz, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_tcandIdx, ph2_trkIdx, ph2_usedMask, ph2_x, ph2_xx, ph2_xy, ph2_xySignificance, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_clustSizeCol, pix_clustSizeRow, pix_detId, pix_isBarrel, pix_onTrk_x, pix_onTrk_xx, pix_onTrk_xy, pix_onTrk_y, pix_onTrk_yy, pix_onTrk_yz, pix_onTrk_z, pix_onTrk_zx, pix_onTrk_zz, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_tcandIdx, pix_trkIdx, pix_usedMask, pix_x, pix_xx, pix_xy, pix_xySignificance, 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_stateCurvCov, see_statePt, see_stateTrajGlbPx, see_stateTrajGlbPy, see_stateTrajGlbPz, see_stateTrajGlbX, see_stateTrajGlbY, see_stateTrajGlbZ, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_tcandIdx, 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_px, simhit_py, simhit_pz, 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_chargePerCM, str_clustSize, str_detId, str_isBarrel, str_onTrk_x, str_onTrk_xx, str_onTrk_xy, str_onTrk_y, str_onTrk_yy, str_onTrk_yz, str_onTrk_z, str_onTrk_zx, str_onTrk_zz, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_tcandIdx, str_trkIdx, str_usedMask, str_x, str_xx, str_xy, str_xySignificance, str_y, str_yy, str_yz, str_z, str_zx, str_zz, tcand_algo, tcand_bestFromFirstHitSimTrkIdx, tcand_bestFromFirstHitSimTrkNChi2, tcand_bestFromFirstHitSimTrkShareFrac, tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom, tcand_bestFromFirstHitSimTrkShareFracSimDenom, tcand_bestSimTrkIdx, tcand_bestSimTrkNChi2, tcand_bestSimTrkShareFrac, tcand_bestSimTrkShareFracSimClusterDenom, tcand_bestSimTrkShareFracSimDenom, tcand_hitIdx, tcand_hitType, tcand_isTrue, tcand_lambdaErr, tcand_nCluster, tcand_ndof, tcand_nPixel, tcand_nStrip, tcand_nValid, tcand_pca_dxy, tcand_pca_dxyErr, tcand_pca_dz, tcand_pca_dzErr, tcand_pca_eta, tcand_pca_etaErr, tcand_pca_lambdaErr, tcand_pca_phi, tcand_pca_phiErr, tcand_pca_pt, tcand_pca_ptErr, tcand_pca_px, tcand_pca_py, tcand_pca_pz, tcand_pca_valid, tcand_phiErr, tcand_pt, tcand_px, tcand_py, tcand_pz, tcand_q, tcand_qbpErr, tcand_seedIdx, tcand_simTrkIdx, tcand_simTrkNChi2, tcand_simTrkShareFrac, tcand_stopReason, tcand_vtxIdx, tcand_x, tcand_xtErr, tcand_y, tcand_ytErr, tcand_z, trk_algo, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_cotTheta, trk_dxy, trk_dxyClosestPV, trk_dxyErr, trk_dxyPV, trk_dz, trk_dzClosestPV, trk_dzErr, trk_dzPV, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_isTrue, trk_lambda, trk_lambdaErr, trk_mvas, trk_n3DLay, trk_nChi2, trk_nChi2_1Dmod, trk_nCluster, trk_ndof, trk_nInactive, trk_nInnerInactive, trk_nInnerLost, trk_nLost, trk_nLostLay, trk_nOuterInactive, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_qualityMasks, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, 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();
  //track candidates
  tcand_pca_valid.clear();
  tcand_pca_px.clear();
  tcand_pca_py.clear();
  tcand_pca_pz.clear();
  tcand_pca_pt.clear();
  tcand_pca_eta.clear();
  tcand_pca_phi.clear();
  tcand_pca_dxy.clear();
  tcand_pca_dz.clear();
  tcand_pca_ptErr.clear();
  tcand_pca_etaErr.clear();
  tcand_pca_lambdaErr.clear();
  tcand_pca_phiErr.clear();
  tcand_pca_dxyErr.clear();
  tcand_pca_dzErr.clear();
  tcand_px.clear();
  tcand_py.clear();
  tcand_pz.clear();
  tcand_pt.clear();
  tcand_x.clear();
  tcand_y.clear();
  tcand_z.clear();
  tcand_qbpErr.clear();
  tcand_lambdaErr.clear();
  tcand_phiErr.clear();
  tcand_xtErr.clear();
  tcand_ytErr.clear();
  tcand_ndof.clear();
  tcand_q.clear();
  tcand_nValid.clear();
  tcand_nPixel.clear();
  tcand_nStrip.clear();
  tcand_nCluster.clear();
  tcand_algo.clear();
  tcand_stopReason.clear();
  tcand_seedIdx.clear();
  tcand_vtxIdx.clear();
  tcand_isTrue.clear();
  tcand_bestSimTrkIdx.clear();
  tcand_bestSimTrkShareFrac.clear();
  tcand_bestSimTrkShareFracSimDenom.clear();
  tcand_bestSimTrkShareFracSimClusterDenom.clear();
  tcand_bestSimTrkNChi2.clear();
  tcand_bestFromFirstHitSimTrkIdx.clear();
  tcand_bestFromFirstHitSimTrkShareFrac.clear();
  tcand_bestFromFirstHitSimTrkShareFracSimDenom.clear();
  tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom.clear();
  tcand_bestFromFirstHitSimTrkNChi2.clear();
  tcand_simTrkShareFrac.clear();
  tcand_simTrkNChi2.clear();
  tcand_simTrkIdx.clear();
  tcand_hitIdx.clear();
  tcand_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_onTrk_x.clear();
  pix_onTrk_y.clear();
  pix_onTrk_z.clear();
  pix_onTrk_xx.clear();
  pix_onTrk_xy.clear();
  pix_onTrk_yy.clear();
  pix_onTrk_yz.clear();
  pix_onTrk_zz.clear();
  pix_onTrk_zx.clear();
  pix_tcandIdx.clear();
  pix_seeIdx.clear();
  pix_simHitIdx.clear();
  pix_xySignificance.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();
  pix_clustSizeCol.clear();
  pix_clustSizeRow.clear();
  pix_usedMask.clear();
  //strips
  str_isBarrel.clear();
  str_detId.clear();
  str_trkIdx.clear();
  str_onTrk_x.clear();
  str_onTrk_y.clear();
  str_onTrk_z.clear();
  str_onTrk_xx.clear();
  str_onTrk_xy.clear();
  str_onTrk_yy.clear();
  str_onTrk_yz.clear();
  str_onTrk_zz.clear();
  str_onTrk_zx.clear();
  str_tcandIdx.clear();
  str_seeIdx.clear();
  str_simHitIdx.clear();
  str_xySignificance.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();
  str_chargePerCM.clear();
  str_clustSize.clear();
  str_usedMask.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();
  glu_chargePerCM.clear();
  glu_clustSizeMono.clear();
  glu_clustSizeStereo.clear();
  glu_usedMaskMono.clear();
  glu_usedMaskStereo.clear();
  //phase2 OT
  ph2_isBarrel.clear();
  ph2_detId.clear();
  ph2_trkIdx.clear();
  ph2_onTrk_x.clear();
  ph2_onTrk_y.clear();
  ph2_onTrk_z.clear();
  ph2_onTrk_xx.clear();
  ph2_onTrk_xy.clear();
  ph2_onTrk_yy.clear();
  ph2_onTrk_yz.clear();
  ph2_onTrk_zz.clear();
  ph2_onTrk_zx.clear();
  ph2_tcandIdx.clear();
  ph2_seeIdx.clear();
  ph2_xySignificance.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();
  ph2_usedMask.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_px.clear();
  simhit_py.clear();
  simhit_pz.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_stateTrajGlbX.clear();
  see_stateTrajGlbY.clear();
  see_stateTrajGlbZ.clear();
  see_stateTrajGlbPx.clear();
  see_stateTrajGlbPy.clear();
  see_stateTrajGlbPz.clear();
  see_stateCurvCov.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_tcandIdx.clear();
  see_isTrue.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_processType.clear();
  simvtx_x.clear();
  simvtx_y.clear();
  simvtx_z.clear();
  simvtx_sourceSimIdx.clear();
  simvtx_daughterSimIdx.clear();
  simpv_idx.clear();
}

fillBeamSpot()

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

private

Definition at line 2693 of file TrackingNtuple.cc.

References cms::cuda::bs, bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, and bsp_z.

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

fillCandidates()

void TrackingNtuple::fillCandidates ( const edm::Handle< TrackCandidateCollection > &  candsHandle, int  algo, 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 TrackerGeometry &  tracker, const TrackerTopology &  tTopo, const std::set< edm::ProductID > &  hitProductIds, const std::map< edm::ProductID, size_t > &  seedToCollIndex  )

private

Definition at line 4095 of file TrackingNtuple.cc.

References reco::TrackToTrackingParticleAssociator::associateRecoToSim(), edm::RefVector< C, T, F >::at(), cms::cuda::bs, HLT_2024v13_cff::cands, OmniClusterRef::cluster_pixel(), bsc_activity_cfg::clusters, DetId::det(), HLT_2024v13_cff::distance, edm::AssociationMap< Tag >::end(), Exception, edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), track_associator::hitsToClusterRefs(), mps_fire::i, hit::id, includeAllHits_, includeSeeds_, includeTrackingParticles_, TrajectoryStateClosestToBeamLine::isValid(), edm::Ref< C, T, F >::key(), TrackerTopology::layer(), LogTrace, heavyionUCCDQM_cfi::nClusters, ndof, hltrates_dqm_sourceclient-live_cfg::offset, AlCaHLTBitMon_ParallelJobs::p, reco::TrackBase::parameters(), ph2_tcandIdx, Phase2OT, pix_tcandIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DetId::rawId(), see_tcandIdx, mathSSE::sqrt(), str_tcandIdx, Strip, DetId::subdetId(), tcand_algo, tcand_bestFromFirstHitSimTrkIdx, tcand_bestFromFirstHitSimTrkNChi2, tcand_bestFromFirstHitSimTrkShareFrac, tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom, tcand_bestFromFirstHitSimTrkShareFracSimDenom, tcand_bestSimTrkIdx, tcand_bestSimTrkNChi2, tcand_bestSimTrkShareFrac, tcand_bestSimTrkShareFracSimClusterDenom, tcand_bestSimTrkShareFracSimDenom, tcand_hitIdx, tcand_hitType, tcand_isTrue, tcand_lambdaErr, tcand_nCluster, tcand_ndof, tcand_nPixel, tcand_nStrip, tcand_nValid, tcand_pca_dxy, tcand_pca_dxyErr, tcand_pca_dz, tcand_pca_dzErr, tcand_pca_eta, tcand_pca_etaErr, tcand_pca_lambdaErr, tcand_pca_phi, tcand_pca_phiErr, tcand_pca_pt, tcand_pca_ptErr, tcand_pca_px, tcand_pca_py, tcand_pca_pz, tcand_pca_valid, tcand_phiErr, tcand_pt, tcand_px, tcand_py, tcand_pz, tcand_q, tcand_qbpErr, tcand_seedIdx, tcand_simTrkIdx, tcand_simTrkNChi2, tcand_simTrkShareFrac, tcand_stopReason, tcand_vtxIdx, tcand_x, tcand_xtErr, tcand_y, tcand_ytErr, tcand_z, track_associator::trackAssociationChi2(), DetId::Tracker, PbPb_ZMuSkimMuonDPG_cff::tracker, TrajectoryStateClosestToBeamLine::trackStateAtPCA(), trajectoryStateTransform::transientState(), V0Monitor_cff::v0, and edm::helpers::KeyVal< K, V >::val.

Referenced by analyze().

                                                                                          {
  reco::RecoToSimCollectionTCandidate recSimColl = associatorByHits.associateRecoToSim(candsHandle, tpCollection);

  TSCBLBuilderNoMaterial tscblBuilder;

  auto const& cands = *candsHandle;
  for (size_t iCand = 0; iCand < cands.size(); ++iCand) {
    const auto& aCand = cands[iCand];
    const edm::Ref<TrackCandidateCollection> aCandRef(candsHandle, iCand);

    //get parameters and errors from the candidate state
    auto const& pState = aCand.trajectoryStateOnDet();
    TrajectoryStateOnSurface state =
        trajectoryStateTransform::transientState(pState, &(tracker.idToDet(pState.detId())->surface()), &mf);
    TrajectoryStateClosestToBeamLine tbStateAtPCA = tscblBuilder(*state.freeState(), bs);
    if (!tbStateAtPCA.isValid()) {
      edm::LogVerbatim("TrackBuilding") << "TrajectoryStateClosestToBeamLine not valid";
    }

    auto const& stateAtPCA = tbStateAtPCA.trackStateAtPCA();
    auto v0 = stateAtPCA.position();
    auto p = stateAtPCA.momentum();
    math::XYZPoint pos(v0.x(), v0.y(), v0.z());
    math::XYZVector mom(p.x(), p.y(), p.z());

    //pseduo track for access to easy methods
    static const reco::Track::CovarianceMatrix dummyCov = AlgebraicMatrixID();
    reco::Track trk(
        0, 0, pos, mom, stateAtPCA.charge(), tbStateAtPCA.isValid() ? stateAtPCA.curvilinearError().matrix() : dummyCov);

    const auto& tkParam = trk.parameters();
    auto tkCov = trk.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(aCandRef);
    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(aCand.recHits().begin(), aCand.recHits().end());
    const int nClusters = clusters.size();

    const auto bestKeyCount = findBestMatchingTrackingParticle(aCand.recHits(), clusterToTPMap, tpKeyToIndex);
    const float bestCountF = bestKeyCount.countClusters;
    const float bestShareFrac = bestCountF / nClusters;
    float bestShareFracSimDenom = 0;
    float bestShareFracSimClusterDenom = 0;
    float bestChi2 = -1;
    if (bestKeyCount.key >= 0) {
      bestShareFracSimDenom = bestCountF / tpCollection[tpKeyToIndex.at(bestKeyCount.key)]->numberOfTrackerHits();
      bestShareFracSimClusterDenom = bestCountF / 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(aCand.recHits(), clusterToTPMap, tpKeyToIndex);
    const float bestFirstCountF = bestFirstHitKeyCount.countClusters;
    const float bestFirstHitShareFrac = bestFirstCountF / nClusters;
    float bestFirstHitShareFracSimDenom = 0;
    float bestFirstHitShareFracSimClusterDenom = 0;
    float bestFirstHitChi2 = -1;
    if (bestFirstHitKeyCount.key >= 0) {
      bestFirstHitShareFracSimDenom =
          bestFirstCountF / tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]->numberOfTrackerHits();
      bestFirstHitShareFracSimClusterDenom = bestFirstCountF / tpKeyToClusterCount.at(bestFirstHitKeyCount.key);
      bestFirstHitChi2 = track_associator::trackAssociationChi2(
          tkParam, tkCov, *(tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]), mf, bs);
    }

    auto iglobCand = tcand_pca_valid.size();  //global cand index
    tcand_pca_valid.push_back(tbStateAtPCA.isValid());
    tcand_pca_px.push_back(trk.px());
    tcand_pca_py.push_back(trk.py());
    tcand_pca_pz.push_back(trk.pz());
    tcand_pca_pt.push_back(trk.pt());
    tcand_pca_eta.push_back(trk.eta());
    tcand_pca_phi.push_back(trk.phi());
    tcand_pca_dxy.push_back(trk.dxy());
    tcand_pca_dz.push_back(trk.dz());
    tcand_pca_ptErr.push_back(trk.ptError());
    tcand_pca_etaErr.push_back(trk.etaError());
    tcand_pca_lambdaErr.push_back(trk.lambdaError());
    tcand_pca_phiErr.push_back(trk.phiError());
    tcand_pca_dxyErr.push_back(trk.dxyError());
    tcand_pca_dzErr.push_back(trk.dzError());
    tcand_px.push_back(state.globalMomentum().x());
    tcand_py.push_back(state.globalMomentum().y());
    tcand_pz.push_back(state.globalMomentum().z());
    tcand_pt.push_back(state.globalMomentum().perp());
    tcand_x.push_back(state.globalPosition().x());
    tcand_y.push_back(state.globalPosition().y());
    tcand_z.push_back(state.globalPosition().z());

    auto const& pStateCov = state.curvilinearError().matrix();
    tcand_qbpErr.push_back(sqrt(pStateCov(0, 0)));
    tcand_lambdaErr.push_back(sqrt(pStateCov(1, 1)));
    tcand_phiErr.push_back(sqrt(pStateCov(2, 2)));
    tcand_xtErr.push_back(sqrt(pStateCov(3, 3)));
    tcand_ytErr.push_back(sqrt(pStateCov(4, 4)));

    int ndof = -5;
    int nValid = 0;
    int nPixel = 0;
    int nStrip = 0;
    for (auto const& hit : aCand.recHits()) {
      if (hit.isValid()) {
        ndof += hit.dimension();
        nValid++;

        auto const subdet = hit.geographicalId().subdetId();
        if (subdet == PixelSubdetector::PixelBarrel || subdet == PixelSubdetector::PixelEndcap)
          nPixel++;
        else
          nStrip++;
      }
    }
    tcand_ndof.push_back(ndof);
    tcand_q.push_back(trk.charge());
    tcand_nValid.push_back(nValid);
    tcand_nPixel.push_back(nPixel);
    tcand_nStrip.push_back(nStrip);
    tcand_nCluster.push_back(nClusters);
    tcand_algo.push_back(algo);
    tcand_stopReason.push_back(aCand.stopReason());
    if (includeSeeds_) {
      auto offset = seedCollToOffset.find(aCand.seedRef().id());
      if (offset == seedCollToOffset.end()) {
        throw cms::Exception("Configuration")
            << "Track candidate refers to seed collection " << aCand.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 + aCand.seedRef().key();
      tcand_seedIdx.push_back(seedIndex);
      if (see_tcandIdx[seedIndex] != -1) {
        throw cms::Exception("LogicError")
            << "Track cand index has already been set for seed " << seedIndex << " to " << see_tcandIdx[seedIndex]
            << "; was trying to set it to " << iglobCand << " current " << iCand;
      }
      see_tcandIdx[seedIndex] = iglobCand;
    }
    tcand_vtxIdx.push_back(-1);  // to be set correctly in fillVertices
    if (includeTrackingParticles_) {
      tcand_simTrkIdx.push_back(tpIdx);
      tcand_simTrkShareFrac.push_back(sharedFraction);
      tcand_simTrkNChi2.push_back(tpChi2);
      tcand_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
      tcand_bestFromFirstHitSimTrkIdx.push_back(
          bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key) : -1);
    } else {
      tcand_isTrue.push_back(!tpIdx.empty());
    }
    tcand_bestSimTrkShareFrac.push_back(bestShareFrac);
    tcand_bestSimTrkShareFracSimDenom.push_back(bestShareFracSimDenom);
    tcand_bestSimTrkShareFracSimClusterDenom.push_back(bestShareFracSimClusterDenom);
    tcand_bestSimTrkNChi2.push_back(bestChi2);
    tcand_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
    tcand_bestFromFirstHitSimTrkShareFracSimDenom.push_back(bestFirstHitShareFracSimDenom);
    tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom.push_back(bestFirstHitShareFracSimClusterDenom);
    tcand_bestFromFirstHitSimTrkNChi2.push_back(bestFirstHitChi2);

    LogTrace("TrackingNtuple") << "Track cand #" << iCand << " glob " << iglobCand << " with q=" << trk.charge()
                               << ", pT=" << trk.pt() << " GeV, eta: " << trk.eta() << ", phi: " << trk.phi()
                               << ", nValid=" << nValid << " seed#=" << aCand.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 = aCand.recHits().begin(); i != aCand.recHits().end(); i++) {
      const TrackingRecHit* hit = &*i;
      DetId hitId = hit->geographicalId();
      LogTrace("TrackingNtuple") << "hit #" << std::distance(aCand.recHits().begin(), 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_tcandIdx[clusterKey].push_back(iglobCand);
          } else if (clusterRef.isPhase2()) {
            ph2_tcandIdx[clusterKey].push_back(iglobCand);
          } else {
            str_tcandIdx[clusterKey].push_back(iglobCand);
          }
        }

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

    tcand_hitIdx.push_back(hitIdx);
    tcand_hitType.push_back(hitType);
  }
}

fillDescriptions()

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

static

Definition at line 4589 of file TrackingNtuple.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), edm::ParameterSet::addUntrackedParameter(), reco::TrackBase::algoName(), submitPVResolutionJobs::desc, reco::TrackBase::detachedQuadStep, reco::TrackBase::detachedTripletStep, reco::TrackBase::highPtTripletStep, ProducerED_cfi::InputTag, reco::TrackBase::lowPtQuadStep, reco::TrackBase::lowPtTripletStep, reco::TrackBase::mixedTripletStep, reco::TrackBase::pixelLessStep, reco::TrackBase::pixelPairStep, AlCaHLTBitMon_QueryRunRegistry::string, and reco::TrackBase::tobTecStep.

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

  edm::ParameterSetDescription cMaskDesc;
  cMaskDesc.addUntracked<unsigned int>("index");
  cMaskDesc.addUntracked<edm::InputTag>("src");
  std::vector<edm::ParameterSet> cMasks;
  auto addMask = [&cMasks](reco::Track::TrackAlgorithm algo) {
    edm::ParameterSet ps;
    ps.addUntrackedParameter<unsigned int>("index", static_cast<unsigned int>(algo));
    ps.addUntrackedParameter<edm::InputTag>("src", {reco::Track::algoName(algo) + "Clusters"});
    cMasks.push_back(ps);
  };
  addMask(reco::Track::detachedQuadStep);
  addMask(reco::Track::highPtTripletStep);
  addMask(reco::Track::detachedTripletStep);
  addMask(reco::Track::lowPtQuadStep);
  addMask(reco::Track::lowPtTripletStep);
  addMask(reco::Track::mixedTripletStep);
  addMask(reco::Track::pixelLessStep);
  addMask(reco::Track::pixelPairStep);
  addMask(reco::Track::tobTecStep);
  desc.addVPSetUntracked("clusterMasks", cMaskDesc, cMasks);

  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")
      ->setComment("currently not used: keep for possible future use");
  desc.addUntracked<bool>("includeSeeds", false);
  desc.addUntracked<bool>("includeTrackCandidates", false);
  desc.addUntracked<bool>("addSeedCurvCov", false);
  desc.addUntracked<bool>("includeAllHits", false);
  desc.addUntracked<bool>("includeOnTrackHitData", false);
  desc.addUntracked<bool>("includeMVA", true);
  desc.addUntracked<bool>("includeTrackingParticles", true);
  desc.addUntracked<bool>("includeOOT", false);
  desc.addUntracked<bool>("keepEleSimHits", false);
  desc.addUntracked<bool>("saveSimHitsP3", false);
  desc.addUntracked<bool>("simHitBySignificance", false);
  descriptions.add("trackingNtuple", desc);
}

fillPhase2OTHits()

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

private

Definition at line 3318 of file TrackingNtuple.cc.

References edmNew::DetSetVector< T >::begin(), TrackingNtuple::SimHitData::bunchCrossing, edmNew::DetSetVector< T >::end(), TrackingNtuple::SimHitData::event, hit::id, iEvent, includeTrackingParticles_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::key, TrackerTopology::layer(), LogTrace, visualization-live-secondInstance_cfg::m, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_onTrk_x, ph2_onTrk_xx, ph2_onTrk_xy, ph2_onTrk_y, ph2_onTrk_yy, ph2_onTrk_yz, ph2_onTrk_z, ph2_onTrk_zx, ph2_onTrk_zz, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_tcandIdx, ph2_trkIdx, ph2_usedMask, ph2_x, ph2_xx, ph2_xy, ph2_xySignificance, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, ph2OTUseMaskTokens_, Phase2OT, phase2OTRecHitToken_, edm::Handle< T >::product(), DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), PbPb_ZMuSkimMuonDPG_cff::tracker, TrackingNtuple::SimHitData::type, hit::x, TrackingNtuple::SimHitData::xySignificance, hit::y, and hit::z.

Referenced by analyze().

                                                                           {
  std::vector<std::pair<uint64_t, Phase2OTMaskContainer const*>> phase2OTMasks;
  phase2OTMasks.reserve(ph2OTUseMaskTokens_.size());
  for (const auto& itoken : ph2OTUseMaskTokens_) {
    edm::Handle<Phase2OTMaskContainer> aH;
    iEvent.getByToken(itoken.second, aH);
    phase2OTMasks.emplace_back(1 << itoken.first, aH.product());
  }
  auto ph2OTUsedMask = [&phase2OTMasks](size_t key) {
    uint64_t mask = 0;
    for (auto const& m : phase2OTMasks) {
      if (m.second->mask(key))
        mask |= m.first;
    }
    return mask;
  };

  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++) {
      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(tracker, tTopo, hitId);
      ph2_trkIdx.emplace_back();  // filled in fillTracks
      ph2_onTrk_x.emplace_back();
      ph2_onTrk_y.emplace_back();
      ph2_onTrk_z.emplace_back();
      ph2_onTrk_xx.emplace_back();
      ph2_onTrk_xy.emplace_back();
      ph2_onTrk_yy.emplace_back();
      ph2_onTrk_yz.emplace_back();
      ph2_onTrk_zz.emplace_back();
      ph2_onTrk_zx.emplace_back();
      ph2_tcandIdx.emplace_back();  // filled in fillCandidates
      ph2_seeIdx.emplace_back();    // filled in fillSeeds
      ph2_x.push_back(hit->globalPosition().x());
      ph2_y.push_back(hit->globalPosition().y());
      ph2_z.push_back(hit->globalPosition().z());
      ph2_xx.push_back(hit->globalPositionError().cxx());
      ph2_xy.push_back(hit->globalPositionError().cyx());
      ph2_yy.push_back(hit->globalPositionError().cyy());
      ph2_yz.push_back(hit->globalPositionError().czy());
      ph2_zz.push_back(hit->globalPositionError().czz());
      ph2_zx.push_back(hit->globalPositionError().czx());
      ph2_radL.push_back(hit->surface()->mediumProperties().radLen());
      ph2_bbxi.push_back(hit->surface()->mediumProperties().xi());
      ph2_usedMask.push_back(ph2OTUsedMask(hit->firstClusterRef().key()));

      LogTrace("TrackingNtuple") << "phase2 OT cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                 << " rawId=" << hitId.rawId() << " pos =" << hit->globalPosition();

      if (includeTrackingParticles_) {
        SimHitData simHitData = matchCluster(hit->firstClusterRef(),
                                             hitId,
                                             key,
                                             *hit,
                                             clusterToTPMap,
                                             tpKeyToIndex,
                                             simHitsTPAssoc,
                                             digiSimLink,
                                             simHitRefKeyToIndex,
                                             HitType::Phase2OT);
        ph2_xySignificance.push_back(simHitData.xySignificance);
        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];
        }
      }
    }
  }
}

fillPixelHits()

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

private

Definition at line 3026 of file TrackingNtuple.cc.

References TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, TrackingNtuple::SimHitData::event, hit::id, iEvent, includeTrackingParticles_, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, submitPVResolutionJobs::key, TrackerTopology::layer(), LogTrace, visualization-live-secondInstance_cfg::m, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, pix_bbxi, pix_chargeFraction, pix_clustSizeCol, pix_clustSizeRow, pix_detId, pix_isBarrel, pix_onTrk_x, pix_onTrk_xx, pix_onTrk_xy, pix_onTrk_y, pix_onTrk_yy, pix_onTrk_yz, pix_onTrk_z, pix_onTrk_zx, pix_onTrk_zz, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_tcandIdx, pix_trkIdx, pix_usedMask, pix_x, pix_xx, pix_xy, pix_xySignificance, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, Pixel, InitialStepPreSplitting_cff::pixelHits, pixelRecHitToken_, pixelUseMaskTokens_, edm::Handle< T >::product(), DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), PbPb_ZMuSkimMuonDPG_cff::tracker, TrackingNtuple::SimHitData::type, hit::x, TrackingNtuple::SimHitData::xySignificance, hit::y, and hit::z.

Referenced by analyze().

                                                                        {
  std::vector<std::pair<uint64_t, PixelMaskContainer const*>> pixelMasks;
  pixelMasks.reserve(pixelUseMaskTokens_.size());
  for (const auto& itoken : pixelUseMaskTokens_) {
    edm::Handle<PixelMaskContainer> aH;
    iEvent.getByToken(itoken.second, aH);
    pixelMasks.emplace_back(1 << itoken.first, aH.product());
  }
  auto pixUsedMask = [&pixelMasks](size_t key) {
    uint64_t mask = 0;
    for (auto const& m : pixelMasks) {
      if (m.second->mask(key))
        mask |= m.first;
    }
    return mask;
  };

  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++) {
      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(tracker, tTopo, hitId);
      pix_trkIdx.emplace_back();  // filled in fillTracks
      pix_onTrk_x.emplace_back();
      pix_onTrk_y.emplace_back();
      pix_onTrk_z.emplace_back();
      pix_onTrk_xx.emplace_back();
      pix_onTrk_xy.emplace_back();
      pix_onTrk_yy.emplace_back();
      pix_onTrk_yz.emplace_back();
      pix_onTrk_zz.emplace_back();
      pix_onTrk_zx.emplace_back();
      pix_tcandIdx.emplace_back();  // filled in fillCandidates
      pix_seeIdx.emplace_back();    // filled in fillSeeds
      pix_x.push_back(hit->globalPosition().x());
      pix_y.push_back(hit->globalPosition().y());
      pix_z.push_back(hit->globalPosition().z());
      pix_xx.push_back(hit->globalPositionError().cxx());
      pix_xy.push_back(hit->globalPositionError().cyx());
      pix_yy.push_back(hit->globalPositionError().cyy());
      pix_yz.push_back(hit->globalPositionError().czy());
      pix_zz.push_back(hit->globalPositionError().czz());
      pix_zx.push_back(hit->globalPositionError().czx());
      pix_radL.push_back(hit->surface()->mediumProperties().radLen());
      pix_bbxi.push_back(hit->surface()->mediumProperties().xi());
      pix_clustSizeCol.push_back(hit->cluster()->sizeY());
      pix_clustSizeRow.push_back(hit->cluster()->sizeX());
      pix_usedMask.push_back(pixUsedMask(hit->firstClusterRef().key()));

      LogTrace("TrackingNtuple") << "pixHit cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                 << " rawId=" << hitId.rawId() << " pos =" << hit->globalPosition();
      if (includeTrackingParticles_) {
        SimHitData simHitData = matchCluster(hit->firstClusterRef(),
                                             hitId,
                                             key,
                                             *hit,
                                             clusterToTPMap,
                                             tpKeyToIndex,
                                             simHitsTPAssoc,
                                             digiSimLink,
                                             simHitRefKeyToIndex,
                                             HitType::Pixel);
        pix_simHitIdx.push_back(simHitData.matchingSimHit);
        pix_simType.push_back(static_cast<int>(simHitData.type));
        pix_xySignificance.push_back(simHitData.xySignificance);
        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];
        }
      }
    }
  }
}

fillSeeds()

void TrackingNtuple::fillSeeds ( const edm::Event &  iEvent, const TrackingParticleRefVector &  tpCollection, const TrackingParticleRefKeyToIndex &  tpKeyToIndex, const reco::BeamSpot &  bs, const TrackerGeometry &  tracker, const reco::TrackToTrackingParticleAssociator &  associatorByHits, const ClusterTPAssociation &  clusterToTPMap, 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

the following is useful for analysis in global coords at seed hit surface

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

Definition at line 3413 of file TrackingNtuple.cc.

References addSeedCurvCov_, addStripMatchedHit(), reco::TrackBase::algoByName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), reco::TrackToTrackingParticleAssociator::associateSimToReco(), cms::cuda::bs, ALCARECOTkAlJpsiMuMu_cff::charge, RZLine::chi2(), nano_mu_local_reco_cff::chi2, OmniClusterRef::cluster_phase2OT(), OmniClusterRef::cluster_pixel(), bsc_activity_cfg::clusters, submitPVResolutionJobs::count, TrajectoryStateOnSurface::curvilinearError(), declareDynArray, HLT_2024v13_cff::distance, edm::AssociationMap< Tag >::end(), PVValHelper::eta, Exception, fillTrackingParticlesForSeeds(), spr::find(), edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), TrajectoryStateOnSurface::globalParameters(), glu_seeIdx, Glued, runTauDisplay::gp, track_associator::hitsToClusterRefs(), mps_fire::i, OmniClusterRef::id(), l1ctLayer2EG_cff::id, iEvent, includeAllHits_, includeTrackingParticles_, createfilelist::int, trackerHitRTTI::isMatched(), OmniClusterRef::key(), edm::Ref< C, T, F >::key(), label, SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), LogTrace, CurvilinearTrajectoryError::matrix(), edm::ProductLabels::module, SiStripMatchedRecHit2D::monoClusterRef(), eostools::move(), heavyionUCCDQM_cfi::nClusters, nHits, hltrates_dqm_sourceclient-live_cfg::offset, ph2_seeIdx, Phase2OT, phi, pix_seeIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, edm::Handle< T >::product(), DiDispStaMuonMonitor_cfi::pt, edm::RefToBaseVector< T >::push_back(), 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_stateCurvCov, see_statePt, see_stateTrajGlbPx, see_stateTrajGlbPy, see_stateTrajGlbPz, see_stateTrajGlbX, see_stateTrajGlbY, see_stateTrajGlbZ, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_tcandIdx, see_trkIdx, fileCollector::seed, seedStopInfoTokens_, seedTokens_, trackingNtuple_cff::seedTracks, edm::RefToBaseVector< T >::size(), SiStripMatchedRecHit2D::stereoClusterRef(), str_seeIdx, Strip, stripUseMaskTokens_, TrackingRecHit::surface(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, PbPb_ZMuSkimMuonDPG_cff::tracker, trackFromSeedFitFailed(), trajectoryStateTransform::transientState(), and heppy_batch::val.

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

    std::vector<std::pair<uint64_t, StripMaskContainer const*>> stripMasks;
    stripMasks.reserve(stripUseMaskTokens_.size());
    for (const auto& itoken : stripUseMaskTokens_) {
      edm::Handle<StripMaskContainer> aH;
      iEvent.getByToken(itoken.second, aH);
      stripMasks.emplace_back(1 << itoken.first, aH.product());
    }

    // 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");
    //for HLT seeds
    label.ReplaceAll("FromPixelTracks", "");
    label.ReplaceAll("PFLowPixel", "");
    label.ReplaceAll("hltDoubletRecovery", "pixelPairStep");  //random choice
    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.recHits(), 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.recHits(), 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());

      const TrackingRecHit* lastRecHit = &*(seed.recHits().end() - 1);
      TrajectoryStateOnSurface tsos =
          trajectoryStateTransform::transientState(seed.startingState(), lastRecHit->surface(), &theMF);
      auto const& stateGlobal = tsos.globalParameters();
      see_stateTrajGlbX.push_back(stateGlobal.position().x());
      see_stateTrajGlbY.push_back(stateGlobal.position().y());
      see_stateTrajGlbZ.push_back(stateGlobal.position().z());
      see_stateTrajGlbPx.push_back(stateGlobal.momentum().x());
      see_stateTrajGlbPy.push_back(stateGlobal.momentum().y());
      see_stateTrajGlbPz.push_back(stateGlobal.momentum().z());
      if (addSeedCurvCov_) {
        auto const& stateCcov = tsos.curvilinearError().matrix();
        std::vector<float> cov(15);
        auto covP = cov.begin();
        for (auto const val : stateCcov)
          *(covP++) = val;  //row-major
        see_stateCurvCov.push_back(std::move(cov));
      }

      see_trkIdx.push_back(-1);    // to be set correctly in fillTracks
      see_tcandIdx.push_back(-1);  // to be set correctly in fillCandidates
      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);

      /*
      const TrackingRecHit* lastRecHit = &*(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 const& hit : seed.recHits()) {
        int subid = hit.geographicalId().subdetId();
        if (subid == (int)PixelSubdetector::PixelBarrel || subid == (int)PixelSubdetector::PixelEndcap) {
          const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&hit);
          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(hit)) {
            const SiStripMatchedRecHit2D* matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(&hit);
            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, tracker, tTopo, stripMasks, 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*>(&hit);
            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) {
        auto const recHit0 = seed.recHits().begin();
        auto const recHit1 = seed.recHits().begin() + 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) {
        auto const recHit0 = seed.recHits().begin();
        auto const recHit1 = seed.recHits().begin() + 1;
        auto const recHit2 = seed.recHits().begin() + 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);
  }
}

fillSimHits()

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 2908 of file TrackingNtuple.cc.

References funct::abs(), trackingPlots::assoc, hcalRecHitTable_cff::detId, Exception, newFWLiteAna::found, includeStripHits_, keepEleSimHits_, LogTrace, saveSimHitsP3_, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_px, simhit_py, simhit_pz, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, SimHitTPAssociationProducer::simHitTPAssociationListGreater(), cscDigiValidation_cfi::simTrack, cmsswSequenceInfo::tp, DetId::Tracker, and PbPb_ZMuSkimMuonDPG_cff::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 (!keepEleSimHits_ && 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(tracker, tTopo, detId);
    else
      simhit_detId_phase2.push_back(tracker, tTopo, detId);
    simhit_x.push_back(pos.x());
    simhit_y.push_back(pos.y());
    simhit_z.push_back(pos.z());
    if (saveSimHitsP3_) {
      const auto mom = det->surface().toGlobal(simhit.momentumAtEntry());
      simhit_px.push_back(mom.x());
      simhit_py.push_back(mom.y());
      simhit_pz.push_back(mom.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());
  }
}

fillStripMatchedHits()

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

private

Definition at line 3297 of file TrackingNtuple.cc.

References addStripMatchedHit(), edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), iEvent, ALPAKA_ACCELERATOR_NAMESPACE::vertexFinder::it, edm::Handle< T >::product(), stripMatchedRecHitToken_, stripUseMaskTokens_, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by analyze().

                                                                                               {
  std::vector<std::pair<uint64_t, StripMaskContainer const*>> stripMasks;
  stripMasks.reserve(stripUseMaskTokens_.size());
  for (const auto& itoken : stripUseMaskTokens_) {
    edm::Handle<StripMaskContainer> aH;
    iEvent.getByToken(itoken.second, aH);
    stripMasks.emplace_back(1 << itoken.first, aH.product());
  }

  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, tracker, tTopo, stripMasks, monoStereoClusterList);
    }
  }
}

fillStripRphiStereoHits()

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

private

Definition at line 3123 of file TrackingNtuple.cc.

References TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, siStripClusterTools::chargePerCM(), edmNew::DetSetVector< T >::dataSize(), TrackingNtuple::SimHitData::event, ntuplemaker::fill, hfClusterShapes_cfi::hits, hit::id, iEvent, includeTrackingParticles_, submitPVResolutionJobs::key, TrackerTopology::layer(), LogTrace, visualization-live-secondInstance_cfg::m, ALPAKA_ACCELERATOR_NAMESPACE::pixelClustering::pixelStatus::mask, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, Skims_PA_cff::name, edm::Handle< T >::product(), DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, str_bbxi, str_chargeFraction, str_chargePerCM, str_clustSize, str_detId, str_isBarrel, str_onTrk_x, str_onTrk_xx, str_onTrk_xy, str_onTrk_y, str_onTrk_yy, str_onTrk_yz, str_onTrk_z, str_onTrk_zx, str_onTrk_zz, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_tcandIdx, str_trkIdx, str_usedMask, str_x, str_xx, str_xy, str_xySignificance, str_y, str_yy, str_yz, str_z, str_zx, str_zz, Strip, stripRphiRecHitToken_, stripStereoRecHitToken_, stripUseMaskTokens_, DetId::subdetId(), StripSubdetector::TIB, StripSubdetector::TOB, PbPb_ZMuSkimMuonDPG_cff::tracker, TrackingNtuple::SimHitData::type, hit::x, TrackingNtuple::SimHitData::xySignificance, hit::y, and hit::z.

Referenced by analyze().

                                                                                  {
  std::vector<std::pair<uint64_t, StripMaskContainer const*>> stripMasks;
  stripMasks.reserve(stripUseMaskTokens_.size());
  for (const auto& itoken : stripUseMaskTokens_) {
    edm::Handle<StripMaskContainer> aH;
    iEvent.getByToken(itoken.second, aH);
    stripMasks.emplace_back(1 << itoken.first, aH.product());
  }
  auto strUsedMask = [&stripMasks](size_t key) {
    uint64_t mask = 0;
    for (auto const& m : stripMasks) {
      if (m.second->mask(key))
        mask |= m.first;
    }
    return mask;
  };

  //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_onTrk_x.resize(totalStripHits);
  str_onTrk_y.resize(totalStripHits);
  str_onTrk_z.resize(totalStripHits);
  str_onTrk_xx.resize(totalStripHits);
  str_onTrk_xy.resize(totalStripHits);
  str_onTrk_yy.resize(totalStripHits);
  str_onTrk_yz.resize(totalStripHits);
  str_onTrk_zz.resize(totalStripHits);
  str_onTrk_zx.resize(totalStripHits);
  str_tcandIdx.resize(totalStripHits);  // filled in fillCandidates
  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_xySignificance.resize(totalStripHits);
  str_chargeFraction.resize(totalStripHits);
  str_radL.resize(totalStripHits);
  str_bbxi.resize(totalStripHits);
  str_chargePerCM.resize(totalStripHits);
  str_clustSize.resize(totalStripHits);
  str_usedMask.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) {
        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, tracker, tTopo, hitId);
        str_x[key] = hit.globalPosition().x();
        str_y[key] = hit.globalPosition().y();
        str_z[key] = hit.globalPosition().z();
        str_xx[key] = hit.globalPositionError().cxx();
        str_xy[key] = hit.globalPositionError().cyx();
        str_yy[key] = hit.globalPositionError().cyy();
        str_yz[key] = hit.globalPositionError().czy();
        str_zz[key] = hit.globalPositionError().czz();
        str_zx[key] = hit.globalPositionError().czx();
        str_radL[key] = hit.surface()->mediumProperties().radLen();
        str_bbxi[key] = hit.surface()->mediumProperties().xi();
        str_chargePerCM[key] = siStripClusterTools::chargePerCM(hitId, hit.firstClusterRef().stripCluster());
        str_clustSize[key] = hit.cluster()->amplitudes().size();
        str_usedMask[key] = strUsedMask(key);
        LogTrace("TrackingNtuple") << name << " cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
                                   << " rawId=" << hitId.rawId() << " pos =" << hit.globalPosition();

        if (includeTrackingParticles_) {
          SimHitData simHitData = matchCluster(hit.firstClusterRef(),
                                               hitId,
                                               key,
                                               hit,
                                               clusterToTPMap,
                                               tpKeyToIndex,
                                               simHitsTPAssoc,
                                               digiSimLink,
                                               simHitRefKeyToIndex,
                                               HitType::Strip);
          str_simHitIdx[key] = simHitData.matchingSimHit;
          str_simType[key] = static_cast<int>(simHitData.type);
          str_xySignificance[key] = simHitData.xySignificance;
          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");
}

fillTrackingParticles()

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 4348 of file TrackingNtuple.cc.

References reco::TrackToTrackingParticleAssociator::associateSimToReco(), cms::cuda::bs, TrackingParticleIP::dxy(), TrackingParticleIP::dz(), edm::AssociationMap< Tag >::end(), HistoryBase::evaluate(), Exception, edm::AssociationMap< Tag >::find(), newFWLiteAna::found, iEvent, includeStripHits_, LogTrace, M_PI, ParametersDefinerForTP::momentum(), parametersDefiner_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, 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, cmsswSequenceInfo::tp, tpHitIndexListLess(), tpNLayersToken_, tpNPixelLayersToken_, tpNStripStereoLayersToken_, tracer_, DetId::Tracker, StandaloneTrackMonitor_cfi::trackQuality, DiMuonV_cfg::tracks, Unknown, findQualityFiles::v, bphysicsOniaDQM_cfi::vertex, and ParametersDefinerForTP::vertex().

Referenced by analyze().

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

fillTrackingParticlesForSeeds()

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

private

Definition at line 4490 of file TrackingNtuple.cc.

References newFWLiteAna::found, 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());
    }
  }
}

fillTrackingVertices()

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

private

Definition at line 4545 of file TrackingNtuple.cc.

References ntuplemaker::fill, newFWLiteAna::found, heavyIonCSV_trainingSettings::idx, SiStripPI::max, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, 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);
  }
}

fillTracks()

void TrackingNtuple::fillTracks ( const edm::RefToBaseVector< reco::Track > &  tracks, const TrackerGeometry &  tracker, 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 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 3785 of file TrackingNtuple.cc.

References reco::TrackBase::algoName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), cms::cuda::bs, ALCARECOTkAlJpsiMuMu_cff::charge, nano_mu_local_reco_cff::chi2, OmniClusterRef::cluster_pixel(), bsc_activity_cfg::clusters, DetId::det(), HLT_2024v13_cff::distance, edm::AssociationMap< Tag >::end(), PVValHelper::eta, Exception, edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), getBestVertex(), reco::TrackBase::highPurity, track_associator::hitsToClusterRefs(), trackingPlots::hp, mps_fire::i, hit::id, includeAllHits_, includeMVA_, includeSeeds_, includeStripHits_, includeTrackingParticles_, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, Invalid, edm::Ref< C, T, F >::key(), SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), TrackerTopology::layer(), LogTrace, M_PI, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, heavyionUCCDQM_cfi::nClusters, ndof, nHits, hltrates_dqm_sourceclient-live_cfg::offset, ph2_onTrk_x, ph2_onTrk_xx, ph2_onTrk_xy, ph2_onTrk_y, ph2_onTrk_yy, ph2_onTrk_yz, ph2_onTrk_z, ph2_onTrk_zx, ph2_onTrk_zz, ph2_trkIdx, Phase2OT, phi, pix_onTrk_x, pix_onTrk_xx, pix_onTrk_xy, pix_onTrk_y, pix_onTrk_yy, pix_onTrk_yz, pix_onTrk_z, pix_onTrk_zx, pix_onTrk_zz, pix_trkIdx, Pixel, DiDispStaMuonMonitor_cfi::pt, DetId::rawId(), see_trkIdx, str_onTrk_x, str_onTrk_xx, str_onTrk_xy, str_onTrk_y, str_onTrk_yy, str_onTrk_yz, str_onTrk_z, str_onTrk_zx, str_onTrk_zz, str_trkIdx, Strip, DetId::subdetId(), funct::tan(), reco::HitPattern::TRACK_HITS, track_associator::trackAssociationChi2(), DetId::Tracker, PbPb_ZMuSkimMuonDPG_cff::tracker, DiMuonV_cfg::tracks, trackToken_, trk_algo, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_cotTheta, trk_dxy, trk_dxyClosestPV, trk_dxyErr, trk_dxyPV, trk_dz, trk_dzClosestPV, trk_dzErr, trk_dzPV, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_isTrue, trk_lambda, trk_lambdaErr, trk_mvas, trk_n3DLay, trk_nChi2, trk_nChi2_1Dmod, trk_nCluster, trk_ndof, trk_nInactive, trk_nInnerInactive, trk_nInnerLost, trk_nLost, trk_nLostLay, trk_nOuterInactive, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_qualityMasks, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, trk_seedIdx, trk_simTrkIdx, trk_simTrkNChi2, trk_simTrkShareFrac, trk_stopReason, trk_vtxIdx, edm::helpers::KeyVal< K, V >::val, AlignmentTracksFromVertexSelector_cfi::vertices, hit::x, hit::y, and hit::z.

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->recHits(), 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->recHits(), 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++) {
      auto hit = *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);
            pix_onTrk_x[clusterKey].push_back(hit->globalPosition().x());
            pix_onTrk_y[clusterKey].push_back(hit->globalPosition().y());
            pix_onTrk_z[clusterKey].push_back(hit->globalPosition().z());
            pix_onTrk_xx[clusterKey].push_back(hit->globalPositionError().cxx());
            pix_onTrk_xy[clusterKey].push_back(hit->globalPositionError().cyx());
            pix_onTrk_yy[clusterKey].push_back(hit->globalPositionError().cyy());
            pix_onTrk_yz[clusterKey].push_back(hit->globalPositionError().czy());
            pix_onTrk_zz[clusterKey].push_back(hit->globalPositionError().czz());
            pix_onTrk_zx[clusterKey].push_back(hit->globalPositionError().czx());
          } else if (clusterRef.isPhase2()) {
            ph2_trkIdx[clusterKey].push_back(iTrack);
            ph2_onTrk_x[clusterKey].push_back(hit->globalPosition().x());
            ph2_onTrk_y[clusterKey].push_back(hit->globalPosition().y());
            ph2_onTrk_z[clusterKey].push_back(hit->globalPosition().z());
            ph2_onTrk_xx[clusterKey].push_back(hit->globalPositionError().cxx());
            ph2_onTrk_xy[clusterKey].push_back(hit->globalPositionError().cyx());
            ph2_onTrk_yy[clusterKey].push_back(hit->globalPositionError().cyy());
            ph2_onTrk_yz[clusterKey].push_back(hit->globalPositionError().czy());
            ph2_onTrk_zz[clusterKey].push_back(hit->globalPositionError().czz());
            ph2_onTrk_zx[clusterKey].push_back(hit->globalPositionError().czx());
          } else {
            str_trkIdx[clusterKey].push_back(iTrack);
            str_onTrk_x[clusterKey].push_back(hit->globalPosition().x());
            str_onTrk_y[clusterKey].push_back(hit->globalPosition().y());
            str_onTrk_z[clusterKey].push_back(hit->globalPosition().z());
            str_onTrk_xx[clusterKey].push_back(hit->globalPositionError().cxx());
            str_onTrk_xy[clusterKey].push_back(hit->globalPositionError().cyx());
            str_onTrk_yy[clusterKey].push_back(hit->globalPositionError().cyy());
            str_onTrk_yz[clusterKey].push_back(hit->globalPositionError().czy());
            str_onTrk_zz[clusterKey].push_back(hit->globalPositionError().czz());
            str_onTrk_zx[clusterKey].push_back(hit->globalPositionError().czx());
          }
        }

        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(tracker, tTopo, hitId);
        else
          inv_detId_phase2.push_back(tracker, tTopo, hitId);
        inv_type.push_back(hit->getType());
      }
    }

    trk_hitIdx.push_back(hitIdx);
    trk_hitType.push_back(hitType);
  }
}

fillVertices()

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

private

Definition at line 4512 of file TrackingNtuple.cc.

References Exception, findQualityFiles::size, DiMuonV_cfg::tracks, trk_vtxIdx, bphysicsOniaDQM_cfi::vertex, AlignmentTracksFromVertexSelector_cfi::vertices, 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().

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

matchCluster()

template<typename SimLink >

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

private

Definition at line 2716 of file TrackingNtuple.cc.

References funct::abs(), nano_mu_digi_cff::bx, TTClusterAssociation_cfi::digiSimLinks, PVValHelper::dx, PVValHelper::dy, ClusterTPAssociation::equal_range(), Exception, newFWLiteAna::found, edm::Ref< C, T, F >::id(), ITPileup, keepEleSimHits_, edm::Ref< C, T, F >::key(), SiStripPI::min, HLT_2024v13_cff::minSignificance, Noise, OOTPileup, Phase2OT, OmniClusterRef::phase2OTCluster(), FastTimerService_cff::range, DetId::rawId(), runTheMatrix::ret, Signal, simhit_hitIdx, simhit_hitType, simHitBySignificance_, SimHitTPAssociationProducer::simHitTPAssociationListGreater(), fftjetcommon_cfi::sx, fftjetcommon_cfi::sy, hit::x, and hit::y.

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

  float h_x = 0, h_y = 0;
  float h_xx = 0, h_xy = 0, h_yy = 0;
  if (simHitBySignificance_) {
    h_x = hit.localPosition().x();
    h_y = hit.localPosition().y();
    h_xx = hit.localPositionError().xx();
    h_xy = hit.localPositionError().xy();
    h_yy = hit.localPositionError().yy();
  }

  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);
      } else
        type = HitSimType::OOTPileup;
      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;
      int foundNonElectrons = 0;
      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) {
            continue;  //electrons found
          } else {
            foundNonElectrons++;
          }
        }
      }

      float minSignificance = 1e12;
      if (simHitBySignificance_) {  //save the best matching hit

        int simHitKey = -1;
        edm::ProductID simHitID;
        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;
              if (!keepEleSimHits_)
                continue;
            }

            float sx = TPhit->localPosition().x();
            float sy = TPhit->localPosition().y();
            float dx = sx - h_x;
            float dy = sy - h_y;
            float sig = (dx * dx * h_yy - 2 * dx * dy * h_xy + dy * dy * h_xx) / (h_xx * h_yy - h_xy * h_xy);

            if (sig < minSignificance) {
              minSignificance = sig;
              foundSimHit = true;
              simHitKey = TPhit.key();
              simHitID = TPhit.id();
            }
          }
        }  //loop over matching hits

        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.xySignificance.push_back(minSignificance);
        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));

      } else {  //save all matching hits
        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;
              if (!keepEleSimHits_)
                continue;
              if (foundNonElectrons > 0)
                continue;  //prioritize: skip electrons if non-electrons are present
            }

            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.xySignificance.push_back(minSignificance);
            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/else simHitBySignificance_
      if (!foundSimHit) {
        // In case we didn't find a simhit because of filtered-out
        // electron SimHit, just ignore the missing SimHit.
        if (foundElectron && !keepEleSimHits_)
          continue;

        auto ex = cms::Exception("LogicError")
                  << "Did not find SimHit for reco hit DetId " << hitId.rawId() << " for TP " << trackingParticle.key()
                  << " bx:event " << bx << ":" << event << " PDGid " << trackingParticle->pdgId() << " q "
                  << trackingParticle->charge() << " p4 " << trackingParticle->p4() << " nG4 "
                  << trackingParticle->g4Tracks().size() << ".\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;
}

tpHitIndexListLess()

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

inlinestaticprivate

Definition at line 507 of file TrackingNtuple.cc.

References mps_fire::i, and dqmiolumiharvest::j.

Referenced by fillTrackingParticles().

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

tpHitIndexListLessSort()

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

inlinestaticprivate

Definition at line 508 of file TrackingNtuple.cc.

References mps_fire::i, edm::isNotFinite(), and dqmiolumiharvest::j.

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

addSeedCurvCov_

const bool TrackingNtuple::addSeedCurvCov_

private

Definition at line 692 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

beamSpotToken_

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

private

Definition at line 673 of file TrackingNtuple.cc.

Referenced by analyze().

bsp_sigmax

float TrackingNtuple::bsp_sigmax

private

Definition at line 1327 of file TrackingNtuple.cc.

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

bsp_sigmay

float TrackingNtuple::bsp_sigmay

private

Definition at line 1328 of file TrackingNtuple.cc.

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

bsp_sigmaz

float TrackingNtuple::bsp_sigmaz

private

Definition at line 1329 of file TrackingNtuple.cc.

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

bsp_x

float TrackingNtuple::bsp_x

private

Definition at line 1324 of file TrackingNtuple.cc.

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

bsp_y

float TrackingNtuple::bsp_y

private

Definition at line 1325 of file TrackingNtuple.cc.

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

bsp_z

float TrackingNtuple::bsp_z

private

Definition at line 1326 of file TrackingNtuple.cc.

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

builderName_

std::string TrackingNtuple::builderName_

private

Definition at line 689 of file TrackingNtuple.cc.

candidateTokens_

std::vector<edm::EDGetTokenT<TrackCandidateCollection> > TrackingNtuple::candidateTokens_

private

Definition at line 660 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

clusterTPMapToken_

edm::EDGetTokenT<ClusterTPAssociation> TrackingNtuple::clusterTPMapToken_

private

Definition at line 666 of file TrackingNtuple.cc.

Referenced by analyze().

ev_event

edm::EventNumber_t TrackingNtuple::ev_event

private

Definition at line 989 of file TrackingNtuple.cc.

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

ev_lumi

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi

private

Definition at line 988 of file TrackingNtuple.cc.

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

ev_run

edm::RunNumber_t TrackingNtuple::ev_run

private

Definition at line 987 of file TrackingNtuple.cc.

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

glu_bbxi

std::vector<float> TrackingNtuple::glu_bbxi

private

Definition at line 1255 of file TrackingNtuple.cc.

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

glu_chargePerCM

std::vector<float> TrackingNtuple::glu_chargePerCM

private

Definition at line 1256 of file TrackingNtuple.cc.

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

glu_clustSizeMono

std::vector<int> TrackingNtuple::glu_clustSizeMono

private

Definition at line 1257 of file TrackingNtuple.cc.

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

glu_clustSizeStereo

std::vector<int> TrackingNtuple::glu_clustSizeStereo

private

Definition at line 1258 of file TrackingNtuple.cc.

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

glu_detId

DetIdStrip TrackingNtuple::glu_detId

private

Definition at line 1240 of file TrackingNtuple.cc.

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

glu_isBarrel

std::vector<short> TrackingNtuple::glu_isBarrel

private

Definition at line 1239 of file TrackingNtuple.cc.

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

glu_monoIdx

std::vector<int> TrackingNtuple::glu_monoIdx

private

Definition at line 1241 of file TrackingNtuple.cc.

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

glu_radL

std::vector<float> TrackingNtuple::glu_radL

private

Definition at line 1254 of file TrackingNtuple.cc.

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

glu_seeIdx

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

private

Definition at line 1243 of file TrackingNtuple.cc.

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

glu_stereoIdx

std::vector<int> TrackingNtuple::glu_stereoIdx

private

Definition at line 1242 of file TrackingNtuple.cc.

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

glu_usedMaskMono

std::vector<uint64_t> TrackingNtuple::glu_usedMaskMono

private

Definition at line 1259 of file TrackingNtuple.cc.

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

glu_usedMaskStereo

std::vector<uint64_t> TrackingNtuple::glu_usedMaskStereo

private

Definition at line 1260 of file TrackingNtuple.cc.

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

glu_x

std::vector<float> TrackingNtuple::glu_x

private

Definition at line 1244 of file TrackingNtuple.cc.

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

glu_xx

std::vector<float> TrackingNtuple::glu_xx

private

Definition at line 1247 of file TrackingNtuple.cc.

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

glu_xy

std::vector<float> TrackingNtuple::glu_xy

private

Definition at line 1248 of file TrackingNtuple.cc.

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

glu_y

std::vector<float> TrackingNtuple::glu_y

private

Definition at line 1245 of file TrackingNtuple.cc.

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

glu_yy

std::vector<float> TrackingNtuple::glu_yy

private

Definition at line 1249 of file TrackingNtuple.cc.

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

glu_yz

std::vector<float> TrackingNtuple::glu_yz

private

Definition at line 1250 of file TrackingNtuple.cc.

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

glu_z

std::vector<float> TrackingNtuple::glu_z

private

Definition at line 1246 of file TrackingNtuple.cc.

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

glu_zx

std::vector<float> TrackingNtuple::glu_zx

private

Definition at line 1252 of file TrackingNtuple.cc.

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

glu_zz

std::vector<float> TrackingNtuple::glu_zz

private

Definition at line 1251 of file TrackingNtuple.cc.

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

includeAllHits_

const bool TrackingNtuple::includeAllHits_

private

Definition at line 693 of file TrackingNtuple.cc.

Referenced by analyze(), fillCandidates(), fillSeeds(), fillTracks(), and TrackingNtuple().

includeMVA_

const bool TrackingNtuple::includeMVA_

private

Definition at line 695 of file TrackingNtuple.cc.

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

includeOnTrackHitData_

const bool TrackingNtuple::includeOnTrackHitData_

private

Definition at line 694 of file TrackingNtuple.cc.

Referenced by TrackingNtuple().

includeOOT_

const bool TrackingNtuple::includeOOT_

private

Definition at line 697 of file TrackingNtuple.cc.

Referenced by analyze().

includePhase2OTHits_

bool TrackingNtuple::includePhase2OTHits_

private

Definition at line 672 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

includeSeeds_

const bool TrackingNtuple::includeSeeds_

private

Definition at line 690 of file TrackingNtuple.cc.

Referenced by analyze(), fillCandidates(), fillTracks(), and TrackingNtuple().

includeStripHits_

bool TrackingNtuple::includeStripHits_

private

Definition at line 672 of file TrackingNtuple.cc.

Referenced by analyze(), fillSimHits(), fillTrackingParticles(), fillTracks(), and TrackingNtuple().

includeTrackCandidates_

const bool TrackingNtuple::includeTrackCandidates_

private

Definition at line 691 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

includeTrackingParticles_

const bool TrackingNtuple::includeTrackingParticles_

private

Definition at line 696 of file TrackingNtuple.cc.

Referenced by analyze(), fillCandidates(), fillPhase2OTHits(), fillPixelHits(), fillSeeds(), fillStripRphiStereoHits(), fillTracks(), and TrackingNtuple().

inv_detId

DetIdAll TrackingNtuple::inv_detId

private

Definition at line 1300 of file TrackingNtuple.cc.

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

inv_detId_phase2

DetIdAllPhase2 TrackingNtuple::inv_detId_phase2

private

Definition at line 1301 of file TrackingNtuple.cc.

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

inv_isBarrel

std::vector<short> TrackingNtuple::inv_isBarrel

private

Definition at line 1299 of file TrackingNtuple.cc.

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

inv_type

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

private

Definition at line 1302 of file TrackingNtuple.cc.

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

keepEleSimHits_

const bool TrackingNtuple::keepEleSimHits_

private

Definition at line 698 of file TrackingNtuple.cc.

Referenced by fillSimHits(), and matchCluster().

mfToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TrackingNtuple::mfToken_

private

Definition at line 653 of file TrackingNtuple.cc.

Referenced by analyze().

mvaQualityCollectionTokens_

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

private

Definition at line 663 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

parametersDefiner_

ParametersDefinerForTP TrackingNtuple::parametersDefiner_

private

Definition at line 703 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

ph2_bbxi

std::vector<float> TrackingNtuple::ph2_bbxi

private

Definition at line 1293 of file TrackingNtuple.cc.

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

ph2_detId

DetIdPhase2OT TrackingNtuple::ph2_detId

private

Definition at line 1265 of file TrackingNtuple.cc.

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

ph2_isBarrel

std::vector<short> TrackingNtuple::ph2_isBarrel

private

Definition at line 1264 of file TrackingNtuple.cc.

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

ph2_onTrk_x

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_x

private

Definition at line 1267 of file TrackingNtuple.cc.

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

ph2_onTrk_xx

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_xx

private

Definition at line 1270 of file TrackingNtuple.cc.

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

ph2_onTrk_xy

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_xy

private

Definition at line 1271 of file TrackingNtuple.cc.

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

ph2_onTrk_y

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_y

private

Definition at line 1268 of file TrackingNtuple.cc.

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

ph2_onTrk_yy

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_yy

private

Definition at line 1272 of file TrackingNtuple.cc.

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

ph2_onTrk_yz

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_yz

private

Definition at line 1273 of file TrackingNtuple.cc.

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

ph2_onTrk_z

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_z

private

Definition at line 1269 of file TrackingNtuple.cc.

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

ph2_onTrk_zx

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_zx

private

Definition at line 1275 of file TrackingNtuple.cc.

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

ph2_onTrk_zz

std::vector<std::vector<float> > TrackingNtuple::ph2_onTrk_zz

private

Definition at line 1274 of file TrackingNtuple.cc.

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

ph2_radL

std::vector<float> TrackingNtuple::ph2_radL

private

Definition at line 1292 of file TrackingNtuple.cc.

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

ph2_seeIdx

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

private

Definition at line 1277 of file TrackingNtuple.cc.

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

ph2_simHitIdx

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

private

Definition at line 1278 of file TrackingNtuple.cc.

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

ph2_simType

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

private

Definition at line 1281 of file TrackingNtuple.cc.

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

ph2_tcandIdx

std::vector<std::vector<int> > TrackingNtuple::ph2_tcandIdx

private

Definition at line 1276 of file TrackingNtuple.cc.

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

ph2_trkIdx

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

private

Definition at line 1266 of file TrackingNtuple.cc.

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

ph2_usedMask

std::vector<uint64_t> TrackingNtuple::ph2_usedMask

private

Definition at line 1294 of file TrackingNtuple.cc.

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

ph2_x

std::vector<float> TrackingNtuple::ph2_x

private

Definition at line 1282 of file TrackingNtuple.cc.

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

ph2_xx

std::vector<float> TrackingNtuple::ph2_xx

private

Definition at line 1285 of file TrackingNtuple.cc.

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

ph2_xy

std::vector<float> TrackingNtuple::ph2_xy

private

Definition at line 1286 of file TrackingNtuple.cc.

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

ph2_xySignificance

std::vector<std::vector<float> > TrackingNtuple::ph2_xySignificance

private

Definition at line 1279 of file TrackingNtuple.cc.

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

ph2_y

std::vector<float> TrackingNtuple::ph2_y

private

Definition at line 1283 of file TrackingNtuple.cc.

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

ph2_yy

std::vector<float> TrackingNtuple::ph2_yy

private

Definition at line 1287 of file TrackingNtuple.cc.

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

ph2_yz

std::vector<float> TrackingNtuple::ph2_yz

private

Definition at line 1288 of file TrackingNtuple.cc.

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

ph2_z

std::vector<float> TrackingNtuple::ph2_z

private

Definition at line 1284 of file TrackingNtuple.cc.

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

ph2_zx

std::vector<float> TrackingNtuple::ph2_zx

private

Definition at line 1290 of file TrackingNtuple.cc.

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

ph2_zz

std::vector<float> TrackingNtuple::ph2_zz

private

Definition at line 1289 of file TrackingNtuple.cc.

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

ph2OTUseMaskTokens_

std::vector<std::pair<unsigned int, edm::EDGetTokenT<Phase2OTMaskContainer> > > TrackingNtuple::ph2OTUseMaskTokens_

private

Definition at line 687 of file TrackingNtuple.cc.

Referenced by fillPhase2OTHits(), and TrackingNtuple().

phase2OTRecHitToken_

edm::EDGetTokenT<Phase2TrackerRecHit1DCollectionNew> TrackingNtuple::phase2OTRecHitToken_

private

Definition at line 678 of file TrackingNtuple.cc.

Referenced by fillPhase2OTHits().

pix_bbxi

std::vector<float> TrackingNtuple::pix_bbxi

private

Definition at line 1196 of file TrackingNtuple.cc.

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

pix_chargeFraction

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

private

Definition at line 1183 of file TrackingNtuple.cc.

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

pix_clustSizeCol

std::vector<int> TrackingNtuple::pix_clustSizeCol

private

Definition at line 1197 of file TrackingNtuple.cc.

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

pix_clustSizeRow

std::vector<int> TrackingNtuple::pix_clustSizeRow

private

Definition at line 1198 of file TrackingNtuple.cc.

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

pix_detId

DetIdPixel TrackingNtuple::pix_detId

private

Definition at line 1168 of file TrackingNtuple.cc.

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

pix_isBarrel

std::vector<short> TrackingNtuple::pix_isBarrel

private

Definition at line 1167 of file TrackingNtuple.cc.

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

pix_onTrk_x

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_x

private

Definition at line 1170 of file TrackingNtuple.cc.

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

pix_onTrk_xx

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_xx

private

Definition at line 1173 of file TrackingNtuple.cc.

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

pix_onTrk_xy

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_xy

private

Definition at line 1174 of file TrackingNtuple.cc.

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

pix_onTrk_y

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_y

private

Definition at line 1171 of file TrackingNtuple.cc.

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

pix_onTrk_yy

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_yy

private

Definition at line 1175 of file TrackingNtuple.cc.

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

pix_onTrk_yz

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_yz

private

Definition at line 1176 of file TrackingNtuple.cc.

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

pix_onTrk_z

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_z

private

Definition at line 1172 of file TrackingNtuple.cc.

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

pix_onTrk_zx

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_zx

private

Definition at line 1178 of file TrackingNtuple.cc.

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

pix_onTrk_zz

std::vector<std::vector<float> > TrackingNtuple::pix_onTrk_zz

private

Definition at line 1177 of file TrackingNtuple.cc.

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

pix_radL

std::vector<float> TrackingNtuple::pix_radL

private

Definition at line 1195 of file TrackingNtuple.cc.

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

pix_seeIdx

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

private

Definition at line 1180 of file TrackingNtuple.cc.

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

pix_simHitIdx

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

private

Definition at line 1181 of file TrackingNtuple.cc.

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

pix_simType

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

private

Definition at line 1184 of file TrackingNtuple.cc.

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

pix_tcandIdx

std::vector<std::vector<int> > TrackingNtuple::pix_tcandIdx

private

Definition at line 1179 of file TrackingNtuple.cc.

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

pix_trkIdx

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

private

Definition at line 1169 of file TrackingNtuple.cc.

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

pix_usedMask

std::vector<uint64_t> TrackingNtuple::pix_usedMask

private

Definition at line 1199 of file TrackingNtuple.cc.

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

pix_x

std::vector<float> TrackingNtuple::pix_x

private

Definition at line 1185 of file TrackingNtuple.cc.

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

pix_xx

std::vector<float> TrackingNtuple::pix_xx

private

Definition at line 1188 of file TrackingNtuple.cc.

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

pix_xy

std::vector<float> TrackingNtuple::pix_xy

private

Definition at line 1189 of file TrackingNtuple.cc.

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

pix_xySignificance

std::vector<std::vector<float> > TrackingNtuple::pix_xySignificance

private

Definition at line 1182 of file TrackingNtuple.cc.

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

pix_y

std::vector<float> TrackingNtuple::pix_y

private

Definition at line 1186 of file TrackingNtuple.cc.

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

pix_yy

std::vector<float> TrackingNtuple::pix_yy

private

Definition at line 1190 of file TrackingNtuple.cc.

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

pix_yz

std::vector<float> TrackingNtuple::pix_yz

private

Definition at line 1191 of file TrackingNtuple.cc.

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

pix_z

std::vector<float> TrackingNtuple::pix_z

private

Definition at line 1187 of file TrackingNtuple.cc.

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

pix_zx

std::vector<float> TrackingNtuple::pix_zx

private

Definition at line 1193 of file TrackingNtuple.cc.

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

pix_zz

std::vector<float> TrackingNtuple::pix_zz

private

Definition at line 1192 of file TrackingNtuple.cc.

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

pixelRecHitToken_

edm::EDGetTokenT<SiPixelRecHitCollection> TrackingNtuple::pixelRecHitToken_

private

Definition at line 674 of file TrackingNtuple.cc.

Referenced by fillPixelHits().

pixelSimLinkToken_

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

private

Definition at line 669 of file TrackingNtuple.cc.

Referenced by analyze().

pixelUseMaskTokens_

std::vector<std::pair<unsigned int, edm::EDGetTokenT<PixelMaskContainer> > > TrackingNtuple::pixelUseMaskTokens_

private

Definition at line 685 of file TrackingNtuple.cc.

Referenced by fillPixelHits(), and TrackingNtuple().

saveSimHitsP3_

const bool TrackingNtuple::saveSimHitsP3_

private

Definition at line 699 of file TrackingNtuple.cc.

Referenced by fillSimHits(), and TrackingNtuple().

see_algo

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

private

Definition at line 1368 of file TrackingNtuple.cc.

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

see_bestFromFirstHitSimTrkIdx

std::vector<int> TrackingNtuple::see_bestFromFirstHitSimTrkIdx

private

Definition at line 1376 of file TrackingNtuple.cc.

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

see_bestFromFirstHitSimTrkShareFrac

std::vector<float> TrackingNtuple::see_bestFromFirstHitSimTrkShareFrac

private

Definition at line 1377 of file TrackingNtuple.cc.

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

see_bestSimTrkIdx

std::vector<int> TrackingNtuple::see_bestSimTrkIdx

private

Definition at line 1374 of file TrackingNtuple.cc.

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

see_bestSimTrkShareFrac

std::vector<float> TrackingNtuple::see_bestSimTrkShareFrac

private

Definition at line 1375 of file TrackingNtuple.cc.

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

see_chi2

std::vector<float> TrackingNtuple::see_chi2

private

Definition at line 1347 of file TrackingNtuple.cc.

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

see_dxy

std::vector<float> TrackingNtuple::see_dxy

private

Definition at line 1340 of file TrackingNtuple.cc.

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

see_dxyErr

std::vector<float> TrackingNtuple::see_dxyErr

private

Definition at line 1345 of file TrackingNtuple.cc.

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

see_dz

std::vector<float> TrackingNtuple::see_dz

private

Definition at line 1341 of file TrackingNtuple.cc.

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

see_dzErr

std::vector<float> TrackingNtuple::see_dzErr

private

Definition at line 1346 of file TrackingNtuple.cc.

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

see_eta

std::vector<float> TrackingNtuple::see_eta

private

Definition at line 1338 of file TrackingNtuple.cc.

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

see_etaErr

std::vector<float> TrackingNtuple::see_etaErr

private

Definition at line 1343 of file TrackingNtuple.cc.

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

see_fitok

std::vector<short> TrackingNtuple::see_fitok

private

Definition at line 1333 of file TrackingNtuple.cc.

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

see_hitIdx

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

private

Definition at line 1380 of file TrackingNtuple.cc.

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

see_hitType

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

private

Definition at line 1381 of file TrackingNtuple.cc.

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

see_isTrue

std::vector<short> TrackingNtuple::see_isTrue

private

Definition at line 1373 of file TrackingNtuple.cc.

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

see_nCands

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

private

Definition at line 1370 of file TrackingNtuple.cc.

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

see_nCluster

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

private

Definition at line 1367 of file TrackingNtuple.cc.

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

see_nGlued

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

private

Definition at line 1364 of file TrackingNtuple.cc.

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

see_nPhase2OT

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

private

Definition at line 1366 of file TrackingNtuple.cc.

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

see_nPixel

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

private

Definition at line 1363 of file TrackingNtuple.cc.

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

see_nStrip

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

private

Definition at line 1365 of file TrackingNtuple.cc.

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

see_nValid

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

private

Definition at line 1362 of file TrackingNtuple.cc.

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

see_offset

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

private

Definition at line 1383 of file TrackingNtuple.cc.

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

see_phi

std::vector<float> TrackingNtuple::see_phi

private

Definition at line 1339 of file TrackingNtuple.cc.

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

see_phiErr

std::vector<float> TrackingNtuple::see_phiErr

private

Definition at line 1344 of file TrackingNtuple.cc.

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

see_pt

std::vector<float> TrackingNtuple::see_pt

private

Definition at line 1337 of file TrackingNtuple.cc.

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

see_ptErr

std::vector<float> TrackingNtuple::see_ptErr

private

Definition at line 1342 of file TrackingNtuple.cc.

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

see_px

std::vector<float> TrackingNtuple::see_px

private

Definition at line 1334 of file TrackingNtuple.cc.

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

see_py

std::vector<float> TrackingNtuple::see_py

private

Definition at line 1335 of file TrackingNtuple.cc.

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

see_pz

std::vector<float> TrackingNtuple::see_pz

private

Definition at line 1336 of file TrackingNtuple.cc.

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

see_q

std::vector<int> TrackingNtuple::see_q

private

Definition at line 1361 of file TrackingNtuple.cc.

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

see_simTrkIdx

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

private

Definition at line 1379 of file TrackingNtuple.cc.

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

see_simTrkShareFrac

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

private

Definition at line 1378 of file TrackingNtuple.cc.

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

see_stateCurvCov

std::vector<std::vector<float> > TrackingNtuple::see_stateCurvCov

private

Definition at line 1360 of file TrackingNtuple.cc.

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

see_statePt

std::vector<float> TrackingNtuple::see_statePt

private

Definition at line 1348 of file TrackingNtuple.cc.

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

see_stateTrajGlbPx

std::vector<float> TrackingNtuple::see_stateTrajGlbPx

private

Definition at line 1357 of file TrackingNtuple.cc.

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

see_stateTrajGlbPy

std::vector<float> TrackingNtuple::see_stateTrajGlbPy

private

Definition at line 1358 of file TrackingNtuple.cc.

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

see_stateTrajGlbPz

std::vector<float> TrackingNtuple::see_stateTrajGlbPz

private

Definition at line 1359 of file TrackingNtuple.cc.

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

see_stateTrajGlbX

std::vector<float> TrackingNtuple::see_stateTrajGlbX

private

Definition at line 1354 of file TrackingNtuple.cc.

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

see_stateTrajGlbY

std::vector<float> TrackingNtuple::see_stateTrajGlbY

private

Definition at line 1355 of file TrackingNtuple.cc.

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

see_stateTrajGlbZ

std::vector<float> TrackingNtuple::see_stateTrajGlbZ

private

Definition at line 1356 of file TrackingNtuple.cc.

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

see_stateTrajPx

std::vector<float> TrackingNtuple::see_stateTrajPx

private

Definition at line 1351 of file TrackingNtuple.cc.

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

see_stateTrajPy

std::vector<float> TrackingNtuple::see_stateTrajPy

private

Definition at line 1352 of file TrackingNtuple.cc.

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

see_stateTrajPz

std::vector<float> TrackingNtuple::see_stateTrajPz

private

Definition at line 1353 of file TrackingNtuple.cc.

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

see_stateTrajX

std::vector<float> TrackingNtuple::see_stateTrajX

private

Definition at line 1349 of file TrackingNtuple.cc.

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

see_stateTrajY

std::vector<float> TrackingNtuple::see_stateTrajY

private

Definition at line 1350 of file TrackingNtuple.cc.

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

see_stopReason

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

private

Definition at line 1369 of file TrackingNtuple.cc.

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

see_tcandIdx

std::vector<int> TrackingNtuple::see_tcandIdx

private

Definition at line 1372 of file TrackingNtuple.cc.

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

see_trkIdx

std::vector<int> TrackingNtuple::see_trkIdx

private

Definition at line 1371 of file TrackingNtuple.cc.

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

seedStopInfoTokens_

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

private

Definition at line 658 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

seedTokens_

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

private

Definition at line 657 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

sim_bunchCrossing

std::vector<int> TrackingNtuple::sim_bunchCrossing

private

Definition at line 1128 of file TrackingNtuple.cc.

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

sim_decayVtxIdx

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

private

Definition at line 1162 of file TrackingNtuple.cc.

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

sim_eta

std::vector<float> TrackingNtuple::sim_eta

private

Definition at line 1136 of file TrackingNtuple.cc.

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

sim_event

std::vector<int> TrackingNtuple::sim_event

private

Definition at line 1127 of file TrackingNtuple.cc.

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

sim_genPdgIds

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

private

Definition at line 1130 of file TrackingNtuple.cc.

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

sim_isFromBHadron

std::vector<int> TrackingNtuple::sim_isFromBHadron

private

Definition at line 1131 of file TrackingNtuple.cc.

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

sim_n3DLay

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

private

Definition at line 1152 of file TrackingNtuple.cc.

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

sim_nLay

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

private

Definition at line 1150 of file TrackingNtuple.cc.

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

sim_nPixel

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

private

Definition at line 1148 of file TrackingNtuple.cc.

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

sim_nPixelLay

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

private

Definition at line 1151 of file TrackingNtuple.cc.

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

sim_nRecoClusters

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

private

Definition at line 1156 of file TrackingNtuple.cc.

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

sim_nStrip

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

private

Definition at line 1149 of file TrackingNtuple.cc.

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

sim_nTrackerHits

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

private

Definition at line 1154 of file TrackingNtuple.cc.

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

sim_nValid

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

private

Definition at line 1147 of file TrackingNtuple.cc.

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

sim_parentVtxIdx

std::vector<int> TrackingNtuple::sim_parentVtxIdx

private

Definition at line 1161 of file TrackingNtuple.cc.

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

sim_pca_cotTheta

std::vector<float> TrackingNtuple::sim_pca_cotTheta

private

Definition at line 1141 of file TrackingNtuple.cc.

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

sim_pca_dxy

std::vector<float> TrackingNtuple::sim_pca_dxy

private

Definition at line 1143 of file TrackingNtuple.cc.

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

sim_pca_dz

std::vector<float> TrackingNtuple::sim_pca_dz

private

Definition at line 1144 of file TrackingNtuple.cc.

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

sim_pca_eta

std::vector<float> TrackingNtuple::sim_pca_eta

private

Definition at line 1139 of file TrackingNtuple.cc.

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

sim_pca_lambda

std::vector<float> TrackingNtuple::sim_pca_lambda

private

Definition at line 1140 of file TrackingNtuple.cc.

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

sim_pca_phi

std::vector<float> TrackingNtuple::sim_pca_phi

private

Definition at line 1142 of file TrackingNtuple.cc.

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

sim_pca_pt

std::vector<float> TrackingNtuple::sim_pca_pt

private

Definition at line 1138 of file TrackingNtuple.cc.

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

sim_pdgId

std::vector<int> TrackingNtuple::sim_pdgId

private

Definition at line 1129 of file TrackingNtuple.cc.

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

sim_phi

std::vector<float> TrackingNtuple::sim_phi

private

Definition at line 1137 of file TrackingNtuple.cc.

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

sim_pt

std::vector<float> TrackingNtuple::sim_pt

private

Definition at line 1135 of file TrackingNtuple.cc.

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

sim_px

std::vector<float> TrackingNtuple::sim_px

private

Definition at line 1132 of file TrackingNtuple.cc.

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

sim_py

std::vector<float> TrackingNtuple::sim_py

private

Definition at line 1133 of file TrackingNtuple.cc.

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

sim_pz

std::vector<float> TrackingNtuple::sim_pz

private

Definition at line 1134 of file TrackingNtuple.cc.

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

sim_q

std::vector<int> TrackingNtuple::sim_q

private

Definition at line 1145 of file TrackingNtuple.cc.

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

sim_seedIdx

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

private

Definition at line 1160 of file TrackingNtuple.cc.

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

sim_simHitIdx

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

private

Definition at line 1163 of file TrackingNtuple.cc.

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

sim_trkIdx

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

private

Definition at line 1158 of file TrackingNtuple.cc.

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

sim_trkShareFrac

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

private

Definition at line 1159 of file TrackingNtuple.cc.

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

simhit_detId

DetIdAll TrackingNtuple::simhit_detId

private

Definition at line 1306 of file TrackingNtuple.cc.

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

simhit_detId_phase2

DetIdAllPhase2 TrackingNtuple::simhit_detId_phase2

private

Definition at line 1307 of file TrackingNtuple.cc.

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

simhit_eloss

std::vector<float> TrackingNtuple::simhit_eloss

private

Definition at line 1316 of file TrackingNtuple.cc.

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

simhit_hitIdx

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

private

Definition at line 1320 of file TrackingNtuple.cc.

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

simhit_hitType

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

private

Definition at line 1321 of file TrackingNtuple.cc.

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

simhit_particle

std::vector<int> TrackingNtuple::simhit_particle

private

Definition at line 1314 of file TrackingNtuple.cc.

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

simhit_process

std::vector<short> TrackingNtuple::simhit_process

private

Definition at line 1315 of file TrackingNtuple.cc.

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

simhit_px

std::vector<float> TrackingNtuple::simhit_px

private

Definition at line 1311 of file TrackingNtuple.cc.

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

simhit_py

std::vector<float> TrackingNtuple::simhit_py

private

Definition at line 1312 of file TrackingNtuple.cc.

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

simhit_pz

std::vector<float> TrackingNtuple::simhit_pz

private

Definition at line 1313 of file TrackingNtuple.cc.

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

simhit_simTrkIdx

std::vector<int> TrackingNtuple::simhit_simTrkIdx

private

Definition at line 1319 of file TrackingNtuple.cc.

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

simhit_tof

std::vector<float> TrackingNtuple::simhit_tof

private

Definition at line 1317 of file TrackingNtuple.cc.

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

simhit_x

std::vector<float> TrackingNtuple::simhit_x

private

Definition at line 1308 of file TrackingNtuple.cc.

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

simhit_y

std::vector<float> TrackingNtuple::simhit_y

private

Definition at line 1309 of file TrackingNtuple.cc.

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

simhit_z

std::vector<float> TrackingNtuple::simhit_z

private

Definition at line 1310 of file TrackingNtuple.cc.

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

simHitBySignificance_

const bool TrackingNtuple::simHitBySignificance_

private

Definition at line 700 of file TrackingNtuple.cc.

Referenced by matchCluster(), and TrackingNtuple().

simHitTPMapToken_

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

private

Definition at line 667 of file TrackingNtuple.cc.

Referenced by analyze().

simpv_idx

std::vector<int> TrackingNtuple::simpv_idx

private

Definition at line 1411 of file TrackingNtuple.cc.

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

simvtx_bunchCrossing

std::vector<int> TrackingNtuple::simvtx_bunchCrossing

private

Definition at line 1404 of file TrackingNtuple.cc.

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

simvtx_daughterSimIdx

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

private

Definition at line 1410 of file TrackingNtuple.cc.

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

simvtx_event

std::vector<int> TrackingNtuple::simvtx_event

private

Definition at line 1403 of file TrackingNtuple.cc.

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

simvtx_processType

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

private

Definition at line 1405 of file TrackingNtuple.cc.

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

simvtx_sourceSimIdx

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

private

Definition at line 1409 of file TrackingNtuple.cc.

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

simvtx_x

std::vector<float> TrackingNtuple::simvtx_x

private

Definition at line 1406 of file TrackingNtuple.cc.

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

simvtx_y

std::vector<float> TrackingNtuple::simvtx_y

private

Definition at line 1407 of file TrackingNtuple.cc.

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

simvtx_z

std::vector<float> TrackingNtuple::simvtx_z

private

Definition at line 1408 of file TrackingNtuple.cc.

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

siphase2OTSimLinksToken_

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

private

Definition at line 671 of file TrackingNtuple.cc.

Referenced by analyze().

str_bbxi

std::vector<float> TrackingNtuple::str_bbxi

private

Definition at line 1232 of file TrackingNtuple.cc.

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

str_chargeFraction

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

private

Definition at line 1219 of file TrackingNtuple.cc.

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

str_chargePerCM

std::vector<float> TrackingNtuple::str_chargePerCM

private

Definition at line 1233 of file TrackingNtuple.cc.

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

str_clustSize

std::vector<int> TrackingNtuple::str_clustSize

private

Definition at line 1234 of file TrackingNtuple.cc.

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

str_detId

DetIdStrip TrackingNtuple::str_detId

private

Definition at line 1204 of file TrackingNtuple.cc.

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

str_isBarrel

std::vector<short> TrackingNtuple::str_isBarrel

private

Definition at line 1203 of file TrackingNtuple.cc.

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

str_onTrk_x

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_x

private

Definition at line 1206 of file TrackingNtuple.cc.

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

str_onTrk_xx

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_xx

private

Definition at line 1209 of file TrackingNtuple.cc.

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

str_onTrk_xy

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_xy

private

Definition at line 1210 of file TrackingNtuple.cc.

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

str_onTrk_y

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_y

private

Definition at line 1207 of file TrackingNtuple.cc.

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

str_onTrk_yy

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_yy

private

Definition at line 1211 of file TrackingNtuple.cc.

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

str_onTrk_yz

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_yz

private

Definition at line 1212 of file TrackingNtuple.cc.

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

str_onTrk_z

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_z

private

Definition at line 1208 of file TrackingNtuple.cc.

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

str_onTrk_zx

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_zx

private

Definition at line 1214 of file TrackingNtuple.cc.

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

str_onTrk_zz

std::vector<std::vector<float> > TrackingNtuple::str_onTrk_zz

private

Definition at line 1213 of file TrackingNtuple.cc.

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

str_radL

std::vector<float> TrackingNtuple::str_radL

private

Definition at line 1231 of file TrackingNtuple.cc.

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

str_seeIdx

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

private

Definition at line 1216 of file TrackingNtuple.cc.

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

str_simHitIdx

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

private

Definition at line 1217 of file TrackingNtuple.cc.

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

str_simType

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

private

Definition at line 1220 of file TrackingNtuple.cc.

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

str_tcandIdx

std::vector<std::vector<int> > TrackingNtuple::str_tcandIdx

private

Definition at line 1215 of file TrackingNtuple.cc.

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

str_trkIdx

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

private

Definition at line 1205 of file TrackingNtuple.cc.

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

str_usedMask

std::vector<uint64_t> TrackingNtuple::str_usedMask

private

Definition at line 1235 of file TrackingNtuple.cc.

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

str_x

std::vector<float> TrackingNtuple::str_x

private

Definition at line 1221 of file TrackingNtuple.cc.

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

str_xx

std::vector<float> TrackingNtuple::str_xx

private

Definition at line 1224 of file TrackingNtuple.cc.

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

str_xy

std::vector<float> TrackingNtuple::str_xy

private

Definition at line 1225 of file TrackingNtuple.cc.

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

str_xySignificance

std::vector<std::vector<float> > TrackingNtuple::str_xySignificance

private

Definition at line 1218 of file TrackingNtuple.cc.

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

str_y

std::vector<float> TrackingNtuple::str_y

private

Definition at line 1222 of file TrackingNtuple.cc.

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

str_yy

std::vector<float> TrackingNtuple::str_yy

private

Definition at line 1226 of file TrackingNtuple.cc.

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

str_yz

std::vector<float> TrackingNtuple::str_yz

private

Definition at line 1227 of file TrackingNtuple.cc.

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

str_z

std::vector<float> TrackingNtuple::str_z

private

Definition at line 1223 of file TrackingNtuple.cc.

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

str_zx

std::vector<float> TrackingNtuple::str_zx

private

Definition at line 1229 of file TrackingNtuple.cc.

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

str_zz

std::vector<float> TrackingNtuple::str_zz

private

Definition at line 1228 of file TrackingNtuple.cc.

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

stripMatchedRecHitToken_

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> TrackingNtuple::stripMatchedRecHitToken_

private

Definition at line 677 of file TrackingNtuple.cc.

Referenced by fillStripMatchedHits().

stripRphiRecHitToken_

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripRphiRecHitToken_

private

Definition at line 675 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

stripSimLinkToken_

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

private

Definition at line 670 of file TrackingNtuple.cc.

Referenced by analyze().

stripStereoRecHitToken_

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripStereoRecHitToken_

private

Definition at line 676 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

stripUseMaskTokens_

std::vector<std::pair<unsigned int, edm::EDGetTokenT<StripMaskContainer> > > TrackingNtuple::stripUseMaskTokens_

private

Definition at line 686 of file TrackingNtuple.cc.

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

t

TTree* TrackingNtuple::t

private

Definition at line 705 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

tcand_algo

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

private

Definition at line 1104 of file TrackingNtuple.cc.

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

tcand_bestFromFirstHitSimTrkIdx

std::vector<int> TrackingNtuple::tcand_bestFromFirstHitSimTrkIdx

private

Definition at line 1114 of file TrackingNtuple.cc.

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

tcand_bestFromFirstHitSimTrkNChi2

std::vector<float> TrackingNtuple::tcand_bestFromFirstHitSimTrkNChi2

private

Definition at line 1118 of file TrackingNtuple.cc.

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

tcand_bestFromFirstHitSimTrkShareFrac

std::vector<float> TrackingNtuple::tcand_bestFromFirstHitSimTrkShareFrac

private

Definition at line 1115 of file TrackingNtuple.cc.

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

tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::tcand_bestFromFirstHitSimTrkShareFracSimClusterDenom

private

Definition at line 1117 of file TrackingNtuple.cc.

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

tcand_bestFromFirstHitSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::tcand_bestFromFirstHitSimTrkShareFracSimDenom

private

Definition at line 1116 of file TrackingNtuple.cc.

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

tcand_bestSimTrkIdx

std::vector<int> TrackingNtuple::tcand_bestSimTrkIdx

private

Definition at line 1109 of file TrackingNtuple.cc.

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

tcand_bestSimTrkNChi2

std::vector<float> TrackingNtuple::tcand_bestSimTrkNChi2

private

Definition at line 1113 of file TrackingNtuple.cc.

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

tcand_bestSimTrkShareFrac

std::vector<float> TrackingNtuple::tcand_bestSimTrkShareFrac

private

Definition at line 1110 of file TrackingNtuple.cc.

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

tcand_bestSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::tcand_bestSimTrkShareFracSimClusterDenom

private

Definition at line 1112 of file TrackingNtuple.cc.

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

tcand_bestSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::tcand_bestSimTrkShareFracSimDenom

private

Definition at line 1111 of file TrackingNtuple.cc.

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

tcand_hitIdx

std::vector<std::vector<int> > TrackingNtuple::tcand_hitIdx

private

Definition at line 1122 of file TrackingNtuple.cc.

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

tcand_hitType

std::vector<std::vector<int> > TrackingNtuple::tcand_hitType

private

Definition at line 1123 of file TrackingNtuple.cc.

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

tcand_isTrue

std::vector<short> TrackingNtuple::tcand_isTrue

private

Definition at line 1108 of file TrackingNtuple.cc.

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

tcand_lambdaErr

std::vector<float> TrackingNtuple::tcand_lambdaErr

private

Definition at line 1094 of file TrackingNtuple.cc.

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

tcand_nCluster

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

private

Definition at line 1103 of file TrackingNtuple.cc.

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

tcand_ndof

std::vector<float> TrackingNtuple::tcand_ndof

private

Definition at line 1098 of file TrackingNtuple.cc.

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

tcand_nPixel

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

private

Definition at line 1101 of file TrackingNtuple.cc.

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

tcand_nStrip

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

private

Definition at line 1102 of file TrackingNtuple.cc.

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

tcand_nValid

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

private

Definition at line 1100 of file TrackingNtuple.cc.

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

tcand_pca_dxy

std::vector<float> TrackingNtuple::tcand_pca_dxy

private

Definition at line 1078 of file TrackingNtuple.cc.

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

tcand_pca_dxyErr

std::vector<float> TrackingNtuple::tcand_pca_dxyErr

private

Definition at line 1084 of file TrackingNtuple.cc.

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

tcand_pca_dz

std::vector<float> TrackingNtuple::tcand_pca_dz

private

Definition at line 1079 of file TrackingNtuple.cc.

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

tcand_pca_dzErr

std::vector<float> TrackingNtuple::tcand_pca_dzErr

private

Definition at line 1085 of file TrackingNtuple.cc.

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

tcand_pca_eta

std::vector<float> TrackingNtuple::tcand_pca_eta

private

Definition at line 1076 of file TrackingNtuple.cc.

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

tcand_pca_etaErr

std::vector<float> TrackingNtuple::tcand_pca_etaErr

private

Definition at line 1081 of file TrackingNtuple.cc.

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

tcand_pca_lambdaErr

std::vector<float> TrackingNtuple::tcand_pca_lambdaErr

private

Definition at line 1082 of file TrackingNtuple.cc.

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

tcand_pca_phi

std::vector<float> TrackingNtuple::tcand_pca_phi

private

Definition at line 1077 of file TrackingNtuple.cc.

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

tcand_pca_phiErr

std::vector<float> TrackingNtuple::tcand_pca_phiErr

private

Definition at line 1083 of file TrackingNtuple.cc.

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

tcand_pca_pt

std::vector<float> TrackingNtuple::tcand_pca_pt

private

Definition at line 1075 of file TrackingNtuple.cc.

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

tcand_pca_ptErr

std::vector<float> TrackingNtuple::tcand_pca_ptErr

private

Definition at line 1080 of file TrackingNtuple.cc.

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

tcand_pca_px

std::vector<float> TrackingNtuple::tcand_pca_px

private

Definition at line 1072 of file TrackingNtuple.cc.

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

tcand_pca_py

std::vector<float> TrackingNtuple::tcand_pca_py

private

Definition at line 1073 of file TrackingNtuple.cc.

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

tcand_pca_pz

std::vector<float> TrackingNtuple::tcand_pca_pz

private

Definition at line 1074 of file TrackingNtuple.cc.

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

tcand_pca_valid

std::vector<short> TrackingNtuple::tcand_pca_valid

private

Definition at line 1071 of file TrackingNtuple.cc.

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

tcand_phiErr

std::vector<float> TrackingNtuple::tcand_phiErr

private

Definition at line 1095 of file TrackingNtuple.cc.

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

tcand_pt

std::vector<float> TrackingNtuple::tcand_pt

private

Definition at line 1089 of file TrackingNtuple.cc.

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

tcand_px

std::vector<float> TrackingNtuple::tcand_px

private

Definition at line 1086 of file TrackingNtuple.cc.

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

tcand_py

std::vector<float> TrackingNtuple::tcand_py

private

Definition at line 1087 of file TrackingNtuple.cc.

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

tcand_pz

std::vector<float> TrackingNtuple::tcand_pz

private

Definition at line 1088 of file TrackingNtuple.cc.

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

tcand_q

std::vector<int> TrackingNtuple::tcand_q

private

Definition at line 1099 of file TrackingNtuple.cc.

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

tcand_qbpErr

std::vector<float> TrackingNtuple::tcand_qbpErr

private

Definition at line 1093 of file TrackingNtuple.cc.

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

tcand_seedIdx

std::vector<int> TrackingNtuple::tcand_seedIdx

private

Definition at line 1106 of file TrackingNtuple.cc.

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

tcand_simTrkIdx

std::vector<std::vector<int> > TrackingNtuple::tcand_simTrkIdx

private

Definition at line 1121 of file TrackingNtuple.cc.

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

tcand_simTrkNChi2

std::vector<std::vector<float> > TrackingNtuple::tcand_simTrkNChi2

private

Definition at line 1120 of file TrackingNtuple.cc.

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

tcand_simTrkShareFrac

std::vector<std::vector<float> > TrackingNtuple::tcand_simTrkShareFrac

private

Definition at line 1119 of file TrackingNtuple.cc.

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

tcand_stopReason

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

private

Definition at line 1105 of file TrackingNtuple.cc.

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

tcand_vtxIdx

std::vector<int> TrackingNtuple::tcand_vtxIdx

private

Definition at line 1107 of file TrackingNtuple.cc.

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

tcand_x

std::vector<float> TrackingNtuple::tcand_x

private

Definition at line 1090 of file TrackingNtuple.cc.

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

tcand_xtErr

std::vector<float> TrackingNtuple::tcand_xtErr

private

Definition at line 1096 of file TrackingNtuple.cc.

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

tcand_y

std::vector<float> TrackingNtuple::tcand_y

private

Definition at line 1091 of file TrackingNtuple.cc.

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

tcand_ytErr

std::vector<float> TrackingNtuple::tcand_ytErr

private

Definition at line 1097 of file TrackingNtuple.cc.

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

tcand_z

std::vector<float> TrackingNtuple::tcand_z

private

Definition at line 1092 of file TrackingNtuple.cc.

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

tGeomToken_

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> TrackingNtuple::tGeomToken_

private

Definition at line 655 of file TrackingNtuple.cc.

Referenced by analyze().

tpNLayersToken_

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

private

Definition at line 681 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

tpNPixelLayersToken_

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

private

Definition at line 682 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

tpNStripStereoLayersToken_

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

private

Definition at line 683 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

tracer_

HistoryBase TrackingNtuple::tracer_

private

Definition at line 702 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles(), and TrackingNtuple().

trackAssociatorToken_

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

private

Definition at line 668 of file TrackingNtuple.cc.

Referenced by analyze().

trackingParticleRefToken_

edm::EDGetTokenT<TrackingParticleRefVector> TrackingNtuple::trackingParticleRefToken_

private

Definition at line 665 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

trackingParticleToken_

edm::EDGetTokenT<TrackingParticleCollection> TrackingNtuple::trackingParticleToken_

private

Definition at line 664 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

trackingVertexToken_

edm::EDGetTokenT<TrackingVertexCollection> TrackingNtuple::trackingVertexToken_

private

Definition at line 680 of file TrackingNtuple.cc.

Referenced by analyze().

trackToken_

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

private

Definition at line 661 of file TrackingNtuple.cc.

Referenced by analyze(), and fillTracks().

trk_algo

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

private

Definition at line 1045 of file TrackingNtuple.cc.

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

trk_algoMask

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

private

Definition at line 1047 of file TrackingNtuple.cc.

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

trk_bestFromFirstHitSimTrkIdx

std::vector<int> TrackingNtuple::trk_bestFromFirstHitSimTrkIdx

private

Definition at line 1058 of file TrackingNtuple.cc.

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

trk_bestFromFirstHitSimTrkNChi2

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkNChi2

private

Definition at line 1062 of file TrackingNtuple.cc.

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

trk_bestFromFirstHitSimTrkShareFrac

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFrac

private

Definition at line 1059 of file TrackingNtuple.cc.

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

trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

private

Definition at line 1061 of file TrackingNtuple.cc.

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

trk_bestFromFirstHitSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimDenom

private

Definition at line 1060 of file TrackingNtuple.cc.

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

trk_bestSimTrkIdx

std::vector<int> TrackingNtuple::trk_bestSimTrkIdx

private

Definition at line 1053 of file TrackingNtuple.cc.

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

trk_bestSimTrkNChi2

std::vector<float> TrackingNtuple::trk_bestSimTrkNChi2

private

Definition at line 1057 of file TrackingNtuple.cc.

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

trk_bestSimTrkShareFrac

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFrac

private

Definition at line 1054 of file TrackingNtuple.cc.

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

trk_bestSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimClusterDenom

private

Definition at line 1056 of file TrackingNtuple.cc.

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

trk_bestSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimDenom

private

Definition at line 1055 of file TrackingNtuple.cc.

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

trk_cotTheta

std::vector<float> TrackingNtuple::trk_cotTheta

private

Definition at line 1008 of file TrackingNtuple.cc.

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

trk_dxy

std::vector<float> TrackingNtuple::trk_dxy

private

Definition at line 1010 of file TrackingNtuple.cc.

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

trk_dxyClosestPV

std::vector<float> TrackingNtuple::trk_dxyClosestPV

private

Definition at line 1014 of file TrackingNtuple.cc.

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

trk_dxyErr

std::vector<float> TrackingNtuple::trk_dxyErr

private

Definition at line 1020 of file TrackingNtuple.cc.

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

trk_dxyPV

std::vector<float> TrackingNtuple::trk_dxyPV

private

Definition at line 1012 of file TrackingNtuple.cc.

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

trk_dz

std::vector<float> TrackingNtuple::trk_dz

private

Definition at line 1011 of file TrackingNtuple.cc.

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

trk_dzClosestPV

std::vector<float> TrackingNtuple::trk_dzClosestPV

private

Definition at line 1015 of file TrackingNtuple.cc.

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

trk_dzErr

std::vector<float> TrackingNtuple::trk_dzErr

private

Definition at line 1021 of file TrackingNtuple.cc.

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

trk_dzPV

std::vector<float> TrackingNtuple::trk_dzPV

private

Definition at line 1013 of file TrackingNtuple.cc.

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

trk_eta

std::vector<float> TrackingNtuple::trk_eta

private

Definition at line 1006 of file TrackingNtuple.cc.

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

trk_etaErr

std::vector<float> TrackingNtuple::trk_etaErr

private

Definition at line 1017 of file TrackingNtuple.cc.

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

trk_hitIdx

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

private

Definition at line 1066 of file TrackingNtuple.cc.

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

trk_hitType

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

private

Definition at line 1067 of file TrackingNtuple.cc.

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

trk_inner_pt

std::vector<float> TrackingNtuple::trk_inner_pt

private

Definition at line 1001 of file TrackingNtuple.cc.

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

trk_inner_px

std::vector<float> TrackingNtuple::trk_inner_px

private

Definition at line 998 of file TrackingNtuple.cc.

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

trk_inner_py

std::vector<float> TrackingNtuple::trk_inner_py

private

Definition at line 999 of file TrackingNtuple.cc.

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

trk_inner_pz

std::vector<float> TrackingNtuple::trk_inner_pz

private

Definition at line 1000 of file TrackingNtuple.cc.

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

trk_isHP

std::vector<short> TrackingNtuple::trk_isHP

private

Definition at line 1049 of file TrackingNtuple.cc.

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

trk_isTrue

std::vector<short> TrackingNtuple::trk_isTrue

private

Definition at line 1052 of file TrackingNtuple.cc.

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

trk_lambda

std::vector<float> TrackingNtuple::trk_lambda

private

Definition at line 1007 of file TrackingNtuple.cc.

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

trk_lambdaErr

std::vector<float> TrackingNtuple::trk_lambdaErr

private

Definition at line 1018 of file TrackingNtuple.cc.

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

trk_mvas

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

private

Definition at line 1028 of file TrackingNtuple.cc.

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

trk_n3DLay

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

private

Definition at line 1042 of file TrackingNtuple.cc.

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

trk_nChi2

std::vector<float> TrackingNtuple::trk_nChi2

private

Definition at line 1025 of file TrackingNtuple.cc.

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

trk_nChi2_1Dmod

std::vector<float> TrackingNtuple::trk_nChi2_1Dmod

private

Definition at line 1026 of file TrackingNtuple.cc.

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

trk_nCluster

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

private

Definition at line 1044 of file TrackingNtuple.cc.

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

trk_ndof

std::vector<float> TrackingNtuple::trk_ndof

private

Definition at line 1027 of file TrackingNtuple.cc.

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

trk_nInactive

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

private

Definition at line 1033 of file TrackingNtuple.cc.

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

trk_nInnerInactive

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

private

Definition at line 1039 of file TrackingNtuple.cc.

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

trk_nInnerLost

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

private

Definition at line 1037 of file TrackingNtuple.cc.

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

trk_nLost

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

private

Definition at line 1032 of file TrackingNtuple.cc.

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

trk_nLostLay

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

private

Definition at line 1043 of file TrackingNtuple.cc.

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

trk_nOuterInactive

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

private

Definition at line 1038 of file TrackingNtuple.cc.

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

trk_nOuterLost

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

private

Definition at line 1036 of file TrackingNtuple.cc.

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

trk_nPixel

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

private

Definition at line 1034 of file TrackingNtuple.cc.

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

trk_nPixelLay

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

private

Definition at line 1040 of file TrackingNtuple.cc.

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

trk_nStrip

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

private

Definition at line 1035 of file TrackingNtuple.cc.

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

trk_nStripLay

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

private

Definition at line 1041 of file TrackingNtuple.cc.

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

trk_nValid

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

private

Definition at line 1031 of file TrackingNtuple.cc.

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

trk_originalAlgo

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

private

Definition at line 1046 of file TrackingNtuple.cc.

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

trk_outer_pt

std::vector<float> TrackingNtuple::trk_outer_pt

private

Definition at line 1005 of file TrackingNtuple.cc.

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

trk_outer_px

std::vector<float> TrackingNtuple::trk_outer_px

private

Definition at line 1002 of file TrackingNtuple.cc.

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

trk_outer_py

std::vector<float> TrackingNtuple::trk_outer_py

private

Definition at line 1003 of file TrackingNtuple.cc.

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

trk_outer_pz

std::vector<float> TrackingNtuple::trk_outer_pz

private

Definition at line 1004 of file TrackingNtuple.cc.

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

trk_phi

std::vector<float> TrackingNtuple::trk_phi

private

Definition at line 1009 of file TrackingNtuple.cc.

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

trk_phiErr

std::vector<float> TrackingNtuple::trk_phiErr

private

Definition at line 1019 of file TrackingNtuple.cc.

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

trk_pt

std::vector<float> TrackingNtuple::trk_pt

private

Definition at line 997 of file TrackingNtuple.cc.

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

trk_ptErr

std::vector<float> TrackingNtuple::trk_ptErr

private

Definition at line 1016 of file TrackingNtuple.cc.

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

trk_px

std::vector<float> TrackingNtuple::trk_px

private

Definition at line 994 of file TrackingNtuple.cc.

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

trk_py

std::vector<float> TrackingNtuple::trk_py

private

Definition at line 995 of file TrackingNtuple.cc.

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

trk_pz

std::vector<float> TrackingNtuple::trk_pz

private

Definition at line 996 of file TrackingNtuple.cc.

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

trk_q

std::vector<int> TrackingNtuple::trk_q

private

Definition at line 1030 of file TrackingNtuple.cc.

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

trk_qualityMasks

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

private

Definition at line 1029 of file TrackingNtuple.cc.

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

trk_refpoint_x

std::vector<float> TrackingNtuple::trk_refpoint_x

private

Definition at line 1022 of file TrackingNtuple.cc.

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

trk_refpoint_y

std::vector<float> TrackingNtuple::trk_refpoint_y

private

Definition at line 1023 of file TrackingNtuple.cc.

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

trk_refpoint_z

std::vector<float> TrackingNtuple::trk_refpoint_z

private

Definition at line 1024 of file TrackingNtuple.cc.

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

trk_seedIdx

std::vector<int> TrackingNtuple::trk_seedIdx

private

Definition at line 1050 of file TrackingNtuple.cc.

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

trk_simTrkIdx

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

private

Definition at line 1065 of file TrackingNtuple.cc.

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

trk_simTrkNChi2

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

private

Definition at line 1064 of file TrackingNtuple.cc.

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

trk_simTrkShareFrac

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

private

Definition at line 1063 of file TrackingNtuple.cc.

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

trk_stopReason

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

private

Definition at line 1048 of file TrackingNtuple.cc.

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

trk_vtxIdx

std::vector<int> TrackingNtuple::trk_vtxIdx

private

Definition at line 1051 of file TrackingNtuple.cc.

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

tTopoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> TrackingNtuple::tTopoToken_

private

Definition at line 654 of file TrackingNtuple.cc.

Referenced by analyze().

vertexToken_

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

private

Definition at line 679 of file TrackingNtuple.cc.

Referenced by analyze().

vtx_chi2

std::vector<float> TrackingNtuple::vtx_chi2

private

Definition at line 1395 of file TrackingNtuple.cc.

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

vtx_fake

std::vector<short> TrackingNtuple::vtx_fake

private

Definition at line 1396 of file TrackingNtuple.cc.

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

vtx_ndof

std::vector<float> TrackingNtuple::vtx_ndof

private

Definition at line 1394 of file TrackingNtuple.cc.

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

vtx_trkIdx

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

private

Definition at line 1398 of file TrackingNtuple.cc.

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

vtx_valid

std::vector<short> TrackingNtuple::vtx_valid

private

Definition at line 1397 of file TrackingNtuple.cc.

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

vtx_x

std::vector<float> TrackingNtuple::vtx_x

private

Definition at line 1388 of file TrackingNtuple.cc.

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

vtx_xErr

std::vector<float> TrackingNtuple::vtx_xErr

private

Definition at line 1391 of file TrackingNtuple.cc.

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

vtx_y

std::vector<float> TrackingNtuple::vtx_y

private

Definition at line 1389 of file TrackingNtuple.cc.

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

vtx_yErr

std::vector<float> TrackingNtuple::vtx_yErr

private

Definition at line 1392 of file TrackingNtuple.cc.

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

vtx_z

std::vector<float> TrackingNtuple::vtx_z

private

Definition at line 1390 of file TrackingNtuple.cc.

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

vtx_zErr

std::vector<float> TrackingNtuple::vtx_zErr

private

Definition at line 1393 of file TrackingNtuple.cc.

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