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 ()
Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
virtual	~EDAnalyzerBase ()
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

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 }
typedef std::pair< TrackPSimHitRef::key_type, edm::ProductID >	SimHitFullKey
typedef std::map< SimHitFullKey, size_t >	SimHitRefKeyToIndex
typedef std::unordered_set< reco::RecoToSimCollection::index_type >	TrackingParticleRefKeySet
typedef std::unordered_map< reco::RecoToSimCollection::index_type, size_t >	TrackingParticleRefKeyToIndex
typedef TrackingParticleRefKeyToIndex	TrackingVertexRefKeyToIndex

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override
void	clearVariables ()
void	fillBeamSpot (const reco::BeamSpot &bs)
void	fillPhase2OTHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)
void	fillPixelHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< PixelDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)
void	fillSeeds (const edm::Event &iEvent, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const reco::BeamSpot &bs, const reco::TrackToTrackingParticleAssociator &associatorByHits, const TransientTrackingRecHitBuilder &theTTRHBuilder, const MagneticField *theMF, const std::vector< std::pair< int, int > > &monoStereoClusterList, const std::set< edm::ProductID > &hitProductIds, std::map< edm::ProductID, size_t > &seedToCollIndex)
void	fillSimHits (const TrackerGeometry &tracker, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const TrackerTopology &tTopo, SimHitRefKeyToIndex &simHitRefKeyToIndex, std::vector< TPHitIndex > &tpHitList)
void	fillStripMatchedHits (const edm::Event &iEvent, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int > > &monoStereoClusterList)
void	fillStripRphiStereoHits (const edm::Event &iEvent, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< StripDigiSimLink > &digiSimLink, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const SimHitRefKeyToIndex &simHitRefKeyToIndex, std::set< edm::ProductID > &hitProductIds)
void	fillTrackingParticles (const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::RefToBaseVector< reco::Track > &tracks, const reco::BeamSpot &bs, const TrackingParticleRefVector &tpCollection, const TrackingVertexRefKeyToIndex &tvKeyToIndex, const reco::TrackToTrackingParticleAssociator &associatorByHits, const std::vector< TPHitIndex > &tpHitList)
void	fillTrackingParticlesForSeeds (const TrackingParticleRefVector &tpCollection, const reco::SimToRecoCollection &simRecColl, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const unsigned int seedOffset)
void	fillTrackingVertices (const TrackingVertexRefVector &trackingVertices, const TrackingParticleRefKeyToIndex &tpKeyToIndex)
void	fillTracks (const edm::RefToBaseVector< reco::Track > &tracks, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const reco::BeamSpot &bs, const reco::TrackToTrackingParticleAssociator &associatorByHits, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const std::set< edm::ProductID > &hitProductIds, const std::map< edm::ProductID, size_t > &seedToCollIndex)
void	fillVertices (const reco::VertexCollection &vertices, const edm::RefToBaseVector< reco::Track > &tracks)
template<typename SimLink >
SimHitData	matchCluster (const OmniClusterRef &cluster, DetId hitId, int clusterKey, const TransientTrackingRecHit::RecHitPointer &ttrh, const ClusterTPAssociation &clusterToTPMap, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const edm::DetSetVector< SimLink > &digiSimLinks, const SimHitRefKeyToIndex &simHitRefKeyToIndex, HitType hitType)

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

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_
float	bsp_sigmax
float	bsp_sigmay
float	bsp_sigmaz
float	bsp_x
float	bsp_y
float	bsp_z
std::string	builderName_
edm::EDGetTokenT< ClusterTPAssociation >	clusterTPMapToken_
edm::EventNumber_t	ev_event
edm::LuminosityBlockNumber_t	ev_lumi
edm::RunNumber_t	ev_run
std::vector< float >	glu_bbxi
DetIdStrip	glu_detId
std::vector< short >	glu_isBarrel
std::vector< int >	glu_monoIdx
std::vector< float >	glu_radL
std::vector< std::vector< int > >	glu_seeIdx
std::vector< int >	glu_stereoIdx
std::vector< float >	glu_x
std::vector< float >	glu_xx
std::vector< float >	glu_xy
std::vector< float >	glu_y
std::vector< float >	glu_yy
std::vector< float >	glu_yz
std::vector< float >	glu_z
std::vector< float >	glu_zx
std::vector< float >	glu_zz
const bool	includeAllHits_
bool	includePhase2OTHits_
const bool	includeSeeds_
bool	includeStripHits_
DetIdAll	inv_detId
DetIdAllPhase2	inv_detId_phase2
std::vector< short >	inv_isBarrel
std::vector< unsigned short >	inv_type
std::string	parametersDefinerName_
std::vector< float >	ph2_bbxi
DetIdPhase2OT	ph2_detId
std::vector< short >	ph2_isBarrel
std::vector< float >	ph2_radL
std::vector< std::vector< int > >	ph2_seeIdx
std::vector< std::vector< int > >	ph2_simHitIdx
std::vector< unsigned short >	ph2_simType
std::vector< std::vector< int > >	ph2_trkIdx
std::vector< float >	ph2_x
std::vector< float >	ph2_xx
std::vector< float >	ph2_xy
std::vector< float >	ph2_y
std::vector< float >	ph2_yy
std::vector< float >	ph2_yz
std::vector< float >	ph2_z
std::vector< float >	ph2_zx
std::vector< float >	ph2_zz
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew >	phase2OTRecHitToken_
std::vector< float >	pix_bbxi
std::vector< std::vector< float > >	pix_chargeFraction
DetIdPixel	pix_detId
std::vector< short >	pix_isBarrel
std::vector< float >	pix_radL
std::vector< std::vector< int > >	pix_seeIdx
std::vector< std::vector< int > >	pix_simHitIdx
std::vector< unsigned short >	pix_simType
std::vector< std::vector< int > >	pix_trkIdx
std::vector< float >	pix_x
std::vector< float >	pix_xx
std::vector< float >	pix_xy
std::vector< float >	pix_y
std::vector< float >	pix_yy
std::vector< float >	pix_yz
std::vector< float >	pix_z
std::vector< float >	pix_zx
std::vector< float >	pix_zz
edm::EDGetTokenT< SiPixelRecHitCollection >	pixelRecHitToken_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	pixelSimLinkToken_
std::vector< unsigned int >	see_algo
std::vector< 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< 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< float > >	see_shareFrac
std::vector< std::vector< int > >	see_simTrkIdx
std::vector< float >	see_statePt
std::vector< float >	see_stateTrajPx
std::vector< float >	see_stateTrajPy
std::vector< float >	see_stateTrajPz
std::vector< float >	see_stateTrajX
std::vector< float >	see_stateTrajY
std::vector< unsigned short >	see_stopReason
std::vector< int >	see_trkIdx
std::vector< edm::EDGetTokenT< std::vector< short > > >	seedStopReasonTokens_
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_nStrip
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< float > >	sim_shareFrac
std::vector< std::vector< int > >	sim_simHitIdx
std::vector< std::vector< int > >	sim_trkIdx
DetIdAll	simhit_detId
DetIdAllPhase2	simhit_detId_phase2
std::vector< float >	simhit_eloss
std::vector< std::vector< int > >	simhit_hitIdx
std::vector< std::vector< int > >	simhit_hitType
std::vector< int >	simhit_particle
std::vector< short >	simhit_process
std::vector< int >	simhit_simTrkIdx
std::vector< float >	simhit_tof
std::vector< float >	simhit_x
std::vector< float >	simhit_y
std::vector< float >	simhit_z
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList >	simHitTPMapToken_
std::vector< int >	simpv_idx
std::vector< int >	simvtx_bunchCrossing
std::vector< std::vector< int > >	simvtx_daughterSimIdx
std::vector< int >	simvtx_event
std::vector< unsigned int >	simvtx_processType
std::vector< std::vector< int > >	simvtx_sourceSimIdx
std::vector< float >	simvtx_x
std::vector< float >	simvtx_y
std::vector< float >	simvtx_z
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > >	siphase2OTSimLinksToken_
std::vector< float >	str_bbxi
std::vector< std::vector< float > >	str_chargeFraction
DetIdStrip	str_detId
std::vector< short >	str_isBarrel
std::vector< float >	str_radL
std::vector< std::vector< int > >	str_seeIdx
std::vector< std::vector< int > >	str_simHitIdx
std::vector< unsigned short >	str_simType
std::vector< std::vector< int > >	str_trkIdx
std::vector< float >	str_x
std::vector< float >	str_xx
std::vector< float >	str_xy
std::vector< float >	str_y
std::vector< float >	str_yy
std::vector< float >	str_yz
std::vector< float >	str_z
std::vector< float >	str_zx
std::vector< float >	str_zz
edm::EDGetTokenT< SiStripMatchedRecHit2DCollection >	stripMatchedRecHitToken_
edm::EDGetTokenT< SiStripRecHit2DCollection >	stripRphiRecHitToken_
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > >	stripSimLinkToken_
edm::EDGetTokenT< SiStripRecHit2DCollection >	stripStereoRecHitToken_
TTree *	t
edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNPixelLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > >	tpNStripStereoLayersToken_
HistoryBase	tracer_
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator >	trackAssociatorToken_
edm::EDGetTokenT< TrackingParticleRefVector >	trackingParticleRefToken_
edm::EDGetTokenT< TrackingParticleCollection >	trackingParticleToken_
edm::EDGetTokenT< TrackingVertexCollection >	trackingVertexToken_
edm::EDGetTokenT< edm::View< reco::Track > >	trackToken_
std::vector< unsigned int >	trk_algo
std::vector< decltype(reco::TrackBase().algoMaskUL())>	trk_algoMask
std::vector< float >	trk_cotTheta
std::vector< float >	trk_dxy
std::vector< float >	trk_dxyErr
std::vector< float >	trk_dz
std::vector< float >	trk_dzErr
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< float >	trk_lambda
std::vector< float >	trk_lambdaErr
std::vector< unsigned int >	trk_n3DLay
std::vector< float >	trk_nChi2
std::vector< unsigned int >	trk_nInnerLost
std::vector< unsigned int >	trk_nInvalid
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< 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< float > >	trk_shareFrac
std::vector< std::vector< int > >	trk_simTrkIdx
std::vector< unsigned short >	trk_stopReason
std::vector< int >	trk_vtxIdx
edm::EDGetTokenT< reco::VertexCollection >	vertexToken_
std::vector< float >	vtx_chi2
std::vector< short >	vtx_fake
std::vector< float >	vtx_ndof
std::vector< std::vector< int > >	vtx_trkIdx
std::vector< short >	vtx_valid
std::vector< float >	vtx_x
std::vector< float >	vtx_xErr
std::vector< float >	vtx_y
std::vector< float >	vtx_yErr
std::vector< float >	vtx_z
std::vector< float >	vtx_zErr

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 330 of file TrackingNtuple.cc.

Member Typedef Documentation

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

private

Definition at line 808 of file TrackingNtuple.cc.

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

private

Definition at line 809 of file TrackingNtuple.cc.

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

private

Definition at line 807 of file TrackingNtuple.cc.

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

private

Definition at line 805 of file TrackingNtuple.cc.

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

private

Definition at line 806 of file TrackingNtuple.cc.

typedef std::pair<TrackPSimHitRef::key_type, edm::ProductID> TrackingNtuple::SimHitFullKey

private

Definition at line 348 of file TrackingNtuple.cc.

typedef std::map<SimHitFullKey, size_t> TrackingNtuple::SimHitRefKeyToIndex

private

Definition at line 349 of file TrackingNtuple.cc.

typedef std::unordered_set<reco::RecoToSimCollection::index_type> TrackingNtuple::TrackingParticleRefKeySet

private

Definition at line 345 of file TrackingNtuple.cc.

typedef std::unordered_map<reco::RecoToSimCollection::index_type, size_t> TrackingNtuple::TrackingParticleRefKeyToIndex

private

Definition at line 346 of file TrackingNtuple.cc.

typedef TrackingParticleRefKeyToIndex TrackingNtuple::TrackingVertexRefKeyToIndex

private

Definition at line 347 of file TrackingNtuple.cc.

Member Enumeration Documentation

enum TrackingNtuple::HitSimType

strongprivate

Enumerator
Signal
ITPileup
OOTPileup
Noise
Unknown

Definition at line 364 of file TrackingNtuple.cc.

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

enum TrackingNtuple::HitType

strongprivate

Enumerator
Pixel
Strip
Glued
Invalid
Phase2OT
Unknown

Definition at line 351 of file TrackingNtuple.cc.

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

Constructor & Destructor Documentation

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

explicit

Definition at line 1089 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, HistoryBase::depth(), Exception, edm::ParameterSet::getUntrackedParameter(), glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, TFileService::kSharedResource, TFileService::make(), ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, 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_shareFrac, see_simTrkIdx, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nStrip, 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_shareFrac, sim_simHitIdx, sim_trkIdx, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, GlobalPosition_Frontier_DevDB_cff::tag, MuonAssociatorByHits_cfi::tpTag, trk_algoMask, trk_hitIdx, trk_hitType, trk_isHP, trk_seedIdx, trk_shareFrac, trk_simTrkIdx, trk_stopReason, trk_vtxIdx, edm::vector_transform(), vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

                                                            :
  trackToken_(consumes<edm::View<reco::Track> >(iConfig.getUntrackedParameter<edm::InputTag>("tracks"))),
  clusterTPMapToken_(consumes<ClusterTPAssociation>(iConfig.getUntrackedParameter<edm::InputTag>("clusterTPMap"))),
  simHitTPMapToken_(consumes<SimHitTPAssociationProducer::SimHitTPAssociationList>(iConfig.getUntrackedParameter<edm::InputTag>("simHitTPMap"))),
  trackAssociatorToken_(consumes<reco::TrackToTrackingParticleAssociator>(iConfig.getUntrackedParameter<edm::InputTag>("trackAssociator"))),
  pixelSimLinkToken_(consumes<edm::DetSetVector<PixelDigiSimLink> >(iConfig.getUntrackedParameter<edm::InputTag>("pixelDigiSimLink"))),
  stripSimLinkToken_(consumes<edm::DetSetVector<StripDigiSimLink> >(iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink"))),
  siphase2OTSimLinksToken_(consumes<edm::DetSetVector<PixelDigiSimLink> >(iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink"))),
  includeStripHits_(iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink").label() != ""),
  includePhase2OTHits_(iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink").label() != ""),
  beamSpotToken_(consumes<reco::BeamSpot>(iConfig.getUntrackedParameter<edm::InputTag>("beamSpot"))),
  pixelRecHitToken_(consumes<SiPixelRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("pixelRecHits"))),
  stripRphiRecHitToken_(consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripRphiRecHits"))),
  stripStereoRecHitToken_(consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripStereoRecHits"))),
  stripMatchedRecHitToken_(consumes<SiStripMatchedRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripMatchedRecHits"))),
  phase2OTRecHitToken_(consumes<Phase2TrackerRecHit1DCollectionNew>(iConfig.getUntrackedParameter<edm::InputTag>("phase2OTRecHits"))),
  vertexToken_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertices"))),
  trackingVertexToken_(consumes<TrackingVertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackingVertices"))),
  tpNLayersToken_(consumes<edm::ValueMap<unsigned int> >(iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNlayers"))),
  tpNPixelLayersToken_(consumes<edm::ValueMap<unsigned int> >(iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNpixellayers"))),
  tpNStripStereoLayersToken_(consumes<edm::ValueMap<unsigned int> >(iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNstripstereolayers"))),
  builderName_(iConfig.getUntrackedParameter<std::string>("TTRHBuilder")),
  parametersDefinerName_(iConfig.getUntrackedParameter<std::string>("parametersDefiner")),
  includeSeeds_(iConfig.getUntrackedParameter<bool>("includeSeeds")),
  includeAllHits_(iConfig.getUntrackedParameter<bool>("includeAllHits"))
{
  if(includeSeeds_) {
    seedTokens_ = edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag> >("seedTracks"), [&](const edm::InputTag& tag) {
        return consumes<edm::View<reco::Track> >(tag);
      });
    seedStopReasonTokens_ = edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag> >("trackCandidates"), [&](const edm::InputTag& tag) {
        return consumes<std::vector<short> >(tag);
      });
    if(seedTokens_.size() != seedStopReasonTokens_.size()) {
      throw cms::Exception("Configuration") << "Got " << seedTokens_.size() << " seed collections, but " << seedStopReasonTokens_.size() << " track candidate collections";
    }
  }

  if(includeAllHits_) {
    if(includeStripHits_ && includePhase2OTHits_) {
      throw cms::Exception("Configuration") << "Both stripDigiSimLink and phase2OTSimLink are set, please set only either one (this information is used to infer if you're running phase0/1 or phase2 detector)";
    }
    if(!includeStripHits_ && !includePhase2OTHits_) {
      throw cms::Exception("Configuration") << "Neither stripDigiSimLink or phase2OTSimLink are set, please set either one.";
    }
  }

  const bool tpRef = iConfig.getUntrackedParameter<bool>("trackingParticlesRef");
  const auto tpTag = iConfig.getUntrackedParameter<edm::InputTag>("trackingParticles");
  if(tpRef) {
    trackingParticleRefToken_ = consumes<TrackingParticleRefVector>(tpTag);
  }
  else {
    trackingParticleToken_ = consumes<TrackingParticleCollection>(tpTag);
  }

  tracer_.depth(-2); // as in SimTracker/TrackHistory/src/TrackClassifier.cc

  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_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_q"        , &trk_q);
  t->Branch("trk_nValid"   , &trk_nValid  );
  t->Branch("trk_nInvalid" , &trk_nInvalid);
  t->Branch("trk_nPixel"   , &trk_nPixel  );
  t->Branch("trk_nStrip"   , &trk_nStrip  );
  t->Branch("trk_nPixelLay", &trk_nPixelLay);
  t->Branch("trk_nStripLay", &trk_nStripLay);
  t->Branch("trk_n3DLay"   , &trk_n3DLay  );
  t->Branch("trk_nOuterLost", &trk_nOuterLost  );
  t->Branch("trk_nInnerLost", &trk_nInnerLost  );
  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);
  t->Branch("trk_shareFrac", &trk_shareFrac);
  t->Branch("trk_simTrkIdx", &trk_simTrkIdx  );
  if(includeAllHits_) {
    t->Branch("trk_hitIdx" , &trk_hitIdx);
    t->Branch("trk_hitType", &trk_hitType);
  }
  //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_trkIdx"   , &sim_trkIdx   );
  t->Branch("sim_shareFrac", &sim_shareFrac);
  if(includeSeeds_) {
    t->Branch("sim_seedIdx"   , &sim_seedIdx   );
  }
  t->Branch("sim_parentVtxIdx", &sim_parentVtxIdx);
  t->Branch("sim_decayVtxIdx", &sim_decayVtxIdx);
  if(includeAllHits_) {
    t->Branch("sim_simHitIdx" , &sim_simHitIdx );
  }
  if(includeAllHits_) {
    //pixels
    t->Branch("pix_isBarrel"  , &pix_isBarrel );
    pix_detId.book("pix", t);
    t->Branch("pix_trkIdx"    , &pix_trkIdx   );
    if(includeSeeds_) {
      t->Branch("pix_seeIdx"    , &pix_seeIdx   );
    }
    t->Branch("pix_simHitIdx" , &pix_simHitIdx);
    t->Branch("pix_chargeFraction", &pix_chargeFraction);
    t->Branch("pix_simType", &pix_simType);
    t->Branch("pix_x"     , &pix_x    );
    t->Branch("pix_y"     , &pix_y    );
    t->Branch("pix_z"     , &pix_z    );
    t->Branch("pix_xx"    , &pix_xx   );
    t->Branch("pix_xy"    , &pix_xy   );
    t->Branch("pix_yy"    , &pix_yy   );
    t->Branch("pix_yz"    , &pix_yz   );
    t->Branch("pix_zz"    , &pix_zz   );
    t->Branch("pix_zx"    , &pix_zx   );
    t->Branch("pix_radL"  , &pix_radL );
    t->Branch("pix_bbxi"  , &pix_bbxi );
    t->Branch("pix_bbxi"  , &pix_bbxi );
    //strips
    if(includeStripHits_){
      t->Branch("str_isBarrel"  , &str_isBarrel );
      str_detId.book("str", t);
      t->Branch("str_trkIdx"    , &str_trkIdx   );
      if(includeSeeds_) {
        t->Branch("str_seeIdx"    , &str_seeIdx   );
      }
      t->Branch("str_simHitIdx" , &str_simHitIdx);
      t->Branch("str_chargeFraction", &str_chargeFraction);
      t->Branch("str_simType", &str_simType);
      t->Branch("str_x"     , &str_x    );
      t->Branch("str_y"     , &str_y    );
      t->Branch("str_z"     , &str_z    );
      t->Branch("str_xx"    , &str_xx   );
      t->Branch("str_xy"    , &str_xy   );
      t->Branch("str_yy"    , &str_yy   );
      t->Branch("str_yz"    , &str_yz   );
      t->Branch("str_zz"    , &str_zz   );
      t->Branch("str_zx"    , &str_zx   );
      t->Branch("str_radL"  , &str_radL );
      t->Branch("str_bbxi"  , &str_bbxi );
      //matched hits
      t->Branch("glu_isBarrel"  , &glu_isBarrel );
      glu_detId.book("glu", t);
      t->Branch("glu_monoIdx"   , &glu_monoIdx  );
      t->Branch("glu_stereoIdx" , &glu_stereoIdx);
      if(includeSeeds_) {
        t->Branch("glu_seeIdx"    , &glu_seeIdx   );
      }
      t->Branch("glu_x"         , &glu_x        );
      t->Branch("glu_y"         , &glu_y        );
      t->Branch("glu_z"         , &glu_z        );
      t->Branch("glu_xx"        , &glu_xx       );
      t->Branch("glu_xy"        , &glu_xy       );
      t->Branch("glu_yy"        , &glu_yy       );
      t->Branch("glu_yz"        , &glu_yz       );
      t->Branch("glu_zz"        , &glu_zz       );
      t->Branch("glu_zx"        , &glu_zx       );
      t->Branch("glu_radL"      , &glu_radL     );
      t->Branch("glu_bbxi"      , &glu_bbxi     );
    }
    //phase2 OT
    if(includePhase2OTHits_){
      t->Branch("ph2_isBarrel"  , &ph2_isBarrel );
      ph2_detId.book("ph2", t);
      t->Branch("ph2_trkIdx"    , &ph2_trkIdx   );
      if(includeSeeds_) {
        t->Branch("ph2_seeIdx"    , &ph2_seeIdx   );
      }
      t->Branch("ph2_simHitIdx" , &ph2_simHitIdx);
      t->Branch("ph2_simType", &ph2_simType);
      t->Branch("ph2_x"     , &ph2_x    );
      t->Branch("ph2_y"     , &ph2_y    );
      t->Branch("ph2_z"     , &ph2_z    );
      t->Branch("ph2_xx"    , &ph2_xx   );
      t->Branch("ph2_xy"    , &ph2_xy   );
      t->Branch("ph2_yy"    , &ph2_yy   );
      t->Branch("ph2_yz"    , &ph2_yz   );
      t->Branch("ph2_zz"    , &ph2_zz   );
      t->Branch("ph2_zx"    , &ph2_zx   );
      t->Branch("ph2_radL"  , &ph2_radL );
      t->Branch("ph2_bbxi"  , &ph2_bbxi );
      t->Branch("ph2_bbxi"  , &ph2_bbxi );
    }
    //invalid hits
    t->Branch("inv_isBarrel"  , &inv_isBarrel );
    if(includeStripHits_)  inv_detId.book("inv", t);
    else                   inv_detId_phase2.book("inv", t);
    t->Branch("inv_type"      , &inv_type    );
    //simhits
    if(includeStripHits_) simhit_detId.book("simhit", t);
    else                  simhit_detId_phase2.book("simhit", t);
    t->Branch("simhit_x"       ,  &simhit_x);
    t->Branch("simhit_y"       ,  &simhit_y);
    t->Branch("simhit_z"       ,  &simhit_z);
    t->Branch("simhit_particle",  &simhit_particle);
    t->Branch("simhit_process" ,  &simhit_process);
    t->Branch("simhit_eloss"   ,  &simhit_eloss);
    t->Branch("simhit_tof"     ,  &simhit_tof);
    //t->Branch("simhit_simTrackId", &simhit_simTrackId);
    t->Branch("simhit_simTrkIdx", &simhit_simTrkIdx);
    t->Branch("simhit_hitIdx"  ,  &simhit_hitIdx);
    t->Branch("simhit_hitType" ,  &simhit_hitType);
  }
  //beam spot
  t->Branch("bsp_x" , &bsp_x , "bsp_x/F");
  t->Branch("bsp_y" , &bsp_y , "bsp_y/F");
  t->Branch("bsp_z" , &bsp_z , "bsp_z/F");
  t->Branch("bsp_sigmax" , &bsp_sigmax , "bsp_sigmax/F");
  t->Branch("bsp_sigmay" , &bsp_sigmay , "bsp_sigmay/F");
  t->Branch("bsp_sigmaz" , &bsp_sigmaz , "bsp_sigmaz/F");
  if(includeSeeds_) {
    //seeds
    t->Branch("see_fitok"    , &see_fitok   );
    t->Branch("see_px"       , &see_px      );
    t->Branch("see_py"       , &see_py      );
    t->Branch("see_pz"       , &see_pz      );
    t->Branch("see_pt"       , &see_pt      );
    t->Branch("see_eta"      , &see_eta     );
    t->Branch("see_phi"      , &see_phi     );
    t->Branch("see_dxy"      , &see_dxy     );
    t->Branch("see_dz"       , &see_dz      );
    t->Branch("see_ptErr"    , &see_ptErr   );
    t->Branch("see_etaErr"   , &see_etaErr  );
    t->Branch("see_phiErr"   , &see_phiErr  );
    t->Branch("see_dxyErr"   , &see_dxyErr  );
    t->Branch("see_dzErr"    , &see_dzErr   );
    t->Branch("see_chi2"     , &see_chi2    );
    t->Branch("see_statePt"  , &see_statePt );
    t->Branch("see_stateTrajX", &see_stateTrajX);
    t->Branch("see_stateTrajY", &see_stateTrajY);
    t->Branch("see_stateTrajPx", &see_stateTrajPx);
    t->Branch("see_stateTrajPy", &see_stateTrajPy);
    t->Branch("see_stateTrajPz", &see_stateTrajPz);
    t->Branch("see_q"        , &see_q       );
    t->Branch("see_nValid"   , &see_nValid  );
    t->Branch("see_nPixel"   , &see_nPixel  );
    t->Branch("see_nGlued"   , &see_nGlued  );
    t->Branch("see_nStrip"   , &see_nStrip  );
    t->Branch("see_nPhase2OT", &see_nPhase2OT);
    t->Branch("see_algo"     , &see_algo    );
    t->Branch("see_stopReason", &see_stopReason);
    t->Branch("see_trkIdx"   , &see_trkIdx  );
    t->Branch("see_shareFrac", &see_shareFrac);
    t->Branch("see_simTrkIdx", &see_simTrkIdx  );
    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

(

)

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

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

overrideprivatevirtual

Definition at line 1691 of file TrackingNtuple.cc.

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

                                                                                {

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

  edm::ESHandle<MagneticField> theMF;
  iSetup.get<IdealMagneticFieldRecord>().get(theMF);

  edm::ESHandle<TransientTrackingRecHitBuilder> theTTRHBuilder;
  iSetup.get<TransientRecHitRecord>().get(builderName_,theTTRHBuilder);

  edm::ESHandle<TrackerTopology> tTopoHandle;
  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology& tTopo = *tTopoHandle;

  edm::ESHandle<TrackerGeometry> geometryHandle;
  iSetup.get<TrackerDigiGeometryRecord>().get(geometryHandle);
  const TrackerGeometry &tracker = *geometryHandle;

  edm::Handle<reco::TrackToTrackingParticleAssociator> theAssociator;
  iEvent.getByToken(trackAssociatorToken_, theAssociator);
  const reco::TrackToTrackingParticleAssociator& associatorByHits = *theAssociator;

  LogDebug("TrackingNtuple") << "Analyzing new event";

  //initialize tree variables
  clearVariables();

  // FIXME: we really need to move to edm::View for reading the
  // TrackingParticles... Unfortunately it has non-trivial
  // consequences on the associator/association interfaces etc.
  TrackingParticleRefVector tmpTP;
  TrackingParticleRefKeySet tmpTPkeys;
  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();
    for(const auto& ref: *tmpTPptr) {
      tmpTPkeys.insert(ref.key());
    }
  }
  const TrackingParticleRefVector& tpCollection = *tmpTPptr;

  // Fill mapping from Ref::key() to index
  TrackingParticleRefKeyToIndex tpKeyToIndex;
  for(size_t i=0; i<tpCollection.size(); ++i) {
    tpKeyToIndex[tpCollection[i].key()] = i;
  }

  // tracking vertices
  edm::Handle<TrackingVertexCollection> htv;
  iEvent.getByToken(trackingVertexToken_, htv);
  const TrackingVertexCollection& tvs = *htv;

  // Fill mapping from Ref::key() to index
  TrackingVertexRefVector tvRefs;
  TrackingVertexRefKeyToIndex tvKeyToIndex;
  for(size_t i=0; i<tvs.size(); ++i) {
    const TrackingVertex& v = tvs[i];
    if(v.eventId().bunchCrossing() != 0) // Ignore OOTPU; would be better to not to hardcode?
      continue;
    tvKeyToIndex[i] = tvRefs.size();
    tvRefs.push_back(TrackingVertexRef(htv, i));
  }

  //get association maps, etc.
  Handle<ClusterTPAssociation> pCluster2TPListH;
  iEvent.getByToken(clusterTPMapToken_, pCluster2TPListH);
  const ClusterTPAssociation& clusterToTPMap = *pCluster2TPListH;
  edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
  iEvent.getByToken(simHitTPMapToken_, simHitsTPAssoc);

  // SimHit key -> index mapping
  SimHitRefKeyToIndex simHitRefKeyToIndex;

  //make a list to link TrackingParticles to its simhits
  std::vector<TPHitIndex> tpHitList;

  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
    fillSimHits(tracker, tpKeyToIndex, *simHitsTPAssoc, tTopo, simHitRefKeyToIndex, tpHitList);

    //pixel hits
    fillPixelHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, pixelDigiSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);

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

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

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

  //seeds
  if(includeSeeds_) {
    fillSeeds(iEvent, tpCollection, tpKeyToIndex, bs, associatorByHits, *theTTRHBuilder, theMF.product(), 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));
  }
  fillTracks(trackRefs, tpCollection, tpKeyToIndex, bs, associatorByHits, *theTTRHBuilder, 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);

  // vertices
  edm::Handle<reco::VertexCollection> vertices;
  iEvent.getByToken(vertexToken_, vertices);
  fillVertices(*vertices, trackRefs);

  // tracking vertices
  fillTrackingVertices(tvRefs, tpKeyToIndex);

  t->Fill();

}

void TrackingNtuple::clearVariables ( )

private

Definition at line 1440 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, 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_shareFrac, see_simTrkIdx, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nStrip, 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_shareFrac, sim_simHitIdx, sim_trkIdx, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, trk_algoMask, trk_hitIdx, trk_hitType, trk_isHP, trk_seedIdx, trk_shareFrac, trk_simTrkIdx, 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_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_q        .clear();
  trk_nValid   .clear();
  trk_nInvalid .clear();
  trk_nPixel   .clear();
  trk_nStrip   .clear();
  trk_nPixelLay.clear();
  trk_nStripLay.clear();
  trk_n3DLay   .clear();
  trk_nOuterLost.clear();
  trk_nInnerLost.clear();
  trk_algo     .clear();
  trk_originalAlgo.clear();
  trk_algoMask .clear();
  trk_stopReason.clear();
  trk_isHP     .clear();
  trk_seedIdx  .clear();
  trk_vtxIdx   .clear();
  trk_shareFrac.clear();
  trk_simTrkIdx.clear();
  trk_hitIdx   .clear();
  trk_hitType  .clear();
  //sim tracks
  sim_event    .clear();
  sim_bunchCrossing.clear();
  sim_pdgId    .clear();
  sim_genPdgIds.clear();
  sim_isFromBHadron.clear();
  sim_px       .clear();
  sim_py       .clear();
  sim_pz       .clear();
  sim_pt       .clear();
  sim_eta      .clear();
  sim_phi      .clear();
  sim_pca_pt   .clear();
  sim_pca_eta  .clear();
  sim_pca_lambda.clear();
  sim_pca_cotTheta.clear();
  sim_pca_phi  .clear();
  sim_pca_dxy  .clear();
  sim_pca_dz   .clear();
  sim_q        .clear();
  sim_nValid   .clear();
  sim_nPixel   .clear();
  sim_nStrip   .clear();
  sim_nLay     .clear();
  sim_nPixelLay.clear();
  sim_n3DLay   .clear();
  sim_trkIdx   .clear();
  sim_seedIdx   .clear();
  sim_shareFrac.clear();
  sim_parentVtxIdx.clear();
  sim_decayVtxIdx.clear();
  sim_simHitIdx   .clear();
  //pixels
  pix_isBarrel .clear();
  pix_detId    .clear();
  pix_trkIdx   .clear();
  pix_seeIdx   .clear();
  pix_simHitIdx.clear();
  pix_chargeFraction.clear();
  pix_simType.clear();
  pix_x    .clear();
  pix_y    .clear();
  pix_z    .clear();
  pix_xx   .clear();
  pix_xy   .clear();
  pix_yy   .clear();
  pix_yz   .clear();
  pix_zz   .clear();
  pix_zx   .clear();
  pix_radL .clear();
  pix_bbxi .clear();
  //strips
  str_isBarrel .clear();
  str_detId    .clear();
  str_trkIdx   .clear();
  str_seeIdx   .clear();
  str_simHitIdx.clear();
  str_chargeFraction.clear();
  str_simType.clear();
  str_x    .clear();
  str_y    .clear();
  str_z    .clear();
  str_xx   .clear();
  str_xy   .clear();
  str_yy   .clear();
  str_yz   .clear();
  str_zz   .clear();
  str_zx   .clear();
  str_radL .clear();
  str_bbxi .clear();
  //matched hits
  glu_isBarrel .clear();
  glu_detId    .clear();
  glu_monoIdx  .clear();
  glu_stereoIdx.clear();
  glu_seeIdx   .clear();
  glu_x        .clear();
  glu_y        .clear();
  glu_z        .clear();
  glu_xx       .clear();
  glu_xy       .clear();
  glu_yy       .clear();
  glu_yz       .clear();
  glu_zz       .clear();
  glu_zx       .clear();
  glu_radL     .clear();
  glu_bbxi     .clear();
  //phase2 OT
  ph2_isBarrel .clear();
  ph2_detId    .clear();
  ph2_trkIdx   .clear();
  ph2_seeIdx   .clear();
  ph2_simHitIdx.clear();
  ph2_simType.clear();
  ph2_x    .clear();
  ph2_y    .clear();
  ph2_z    .clear();
  ph2_xx   .clear();
  ph2_xy   .clear();
  ph2_yy   .clear();
  ph2_yz   .clear();
  ph2_zz   .clear();
  ph2_zx   .clear();
  ph2_radL .clear();
  ph2_bbxi .clear();
  //invalid hits
  inv_isBarrel .clear();
  inv_detId    .clear();
  inv_detId_phase2.clear();
  inv_type     .clear();
  // simhits
  simhit_detId.clear();
  simhit_detId_phase2.clear();
  simhit_x.clear();
  simhit_y.clear();
  simhit_z.clear();
  simhit_particle.clear();
  simhit_process.clear();
  simhit_eloss.clear();
  simhit_tof.clear();
  //simhit_simTrackId.clear();
  simhit_simTrkIdx.clear();
  simhit_hitIdx.clear();
  simhit_hitType.clear();
  //beamspot
  bsp_x = -9999.;
  bsp_y = -9999.;
  bsp_z = -9999.;
  bsp_sigmax = -9999.;
  bsp_sigmay = -9999.;
  bsp_sigmaz = -9999.;
  //seeds
  see_fitok   .clear();
  see_px      .clear();
  see_py      .clear();
  see_pz      .clear();
  see_pt      .clear();
  see_eta     .clear();
  see_phi     .clear();
  see_dxy     .clear();
  see_dz      .clear();
  see_ptErr   .clear();
  see_etaErr  .clear();
  see_phiErr  .clear();
  see_dxyErr  .clear();
  see_dzErr   .clear();
  see_chi2    .clear();
  see_statePt.clear();
  see_stateTrajX.clear();
  see_stateTrajY.clear();
  see_stateTrajPx.clear();
  see_stateTrajPy.clear();
  see_stateTrajPz.clear();
  see_q       .clear();
  see_nValid  .clear();
  see_nPixel  .clear();
  see_nGlued  .clear();
  see_nStrip  .clear();
  see_nPhase2OT.clear();
  see_algo    .clear();
  see_stopReason.clear();
  see_trkIdx  .clear();
  see_shareFrac.clear();
  see_simTrkIdx.clear();
  see_hitIdx  .clear();
  see_hitType .clear();
  //seed algo offset
  see_offset.clear();

  // vertices
  vtx_x.clear();
  vtx_y.clear();
  vtx_z.clear();
  vtx_xErr.clear();
  vtx_yErr.clear();
  vtx_zErr.clear();
  vtx_ndof.clear();
  vtx_chi2.clear();
  vtx_fake.clear();
  vtx_valid.clear();
  vtx_trkIdx.clear();

  // Tracking vertices
  simvtx_event.clear();
  simvtx_bunchCrossing.clear();
  simvtx_x.clear();
  simvtx_y.clear();
  simvtx_z.clear();
  simvtx_sourceSimIdx.clear();
  simvtx_daughterSimIdx.clear();
  simpv_idx.clear();
}

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

private

Definition at line 1865 of file TrackingNtuple.cc.

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

Referenced by analyze().

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

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

static

Definition at line 3029 of file TrackingNtuple.cc.

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

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

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

private

Definition at line 2275 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                     {
  edm::Handle<Phase2TrackerRecHit1DCollectionNew> phase2OTHits;
  iEvent.getByToken(phase2OTRecHitToken_, phase2OTHits);
  for (auto it = phase2OTHits->begin(); it!=phase2OTHits->end(); it++ ) {
    const DetId hitId = it->detId();
    for (auto hit = it->begin(); hit!=it->end(); hit++ ) {
      TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);

      hitProductIds.insert(hit->cluster().id());

      const int key = hit->cluster().key();
      const int lay = tTopo.layer(hitId);
      SimHitData simHitData = matchCluster(hit->firstClusterRef(), hitId, key, ttrh,
                                           clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Phase2OT);

      ph2_isBarrel .push_back( hitId.subdetId()==1 );
      ph2_detId    .push_back( tTopo, hitId );
      ph2_trkIdx   .emplace_back(); // filled in fillTracks
      ph2_seeIdx   .emplace_back(); // filled in fillSeeds
      ph2_simHitIdx.push_back( simHitData.matchingSimHit );
      ph2_simType.push_back( static_cast<int>(simHitData.type) );
      ph2_x    .push_back( ttrh->globalPosition().x() );
      ph2_y    .push_back( ttrh->globalPosition().y() );
      ph2_z    .push_back( ttrh->globalPosition().z() );
      ph2_xx   .push_back( ttrh->globalPositionError().cxx() );
      ph2_xy   .push_back( ttrh->globalPositionError().cyx() );
      ph2_yy   .push_back( ttrh->globalPositionError().cyy() );
      ph2_yz   .push_back( ttrh->globalPositionError().czy() );
      ph2_zz   .push_back( ttrh->globalPositionError().czz() );
      ph2_zx   .push_back( ttrh->globalPositionError().czx() );
      ph2_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
      ph2_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );

      LogTrace("TrackingNtuple") << "phase2 OT cluster=" << key
                                 << " subdId=" << hitId.subdetId()
                                 << " lay=" << lay
                                 << " rawId=" << hitId.rawId()
                                 << " pos =" << ttrh->globalPosition()
                                 << " nMatchingSimHit=" << simHitData.matchingSimHit.size();

      if(!simHitData.matchingSimHit.empty()) {
        const auto simHitIdx = simHitData.matchingSimHit[0];
        LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
                                   << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                   << " energyLoss=" << simhit_eloss[simHitIdx]
                                   << " particleType=" << simhit_particle[simHitIdx]
                                   << " processType=" << simhit_process[simHitIdx]
                                   << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                   << " event=" << simHitData.event[0];
      }
    }
  }
}

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

private

Definition at line 2084 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                     {
  edm::Handle<SiPixelRecHitCollection> pixelHits;
  iEvent.getByToken(pixelRecHitToken_, pixelHits);
  for (auto it = pixelHits->begin(); it!=pixelHits->end(); it++ ) {
    const DetId hitId = it->detId();
    for (auto hit = it->begin(); hit!=it->end(); hit++ ) {
      TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);

      hitProductIds.insert(hit->cluster().id());

      const int key = hit->cluster().key();
      const int lay = tTopo.layer(hitId);
      SimHitData simHitData = matchCluster(hit->firstClusterRef(), hitId, key, ttrh,
                                           clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Pixel);

      pix_isBarrel .push_back( hitId.subdetId()==1 );
      pix_detId    .push_back( tTopo, hitId );
      pix_trkIdx   .emplace_back(); // filled in fillTracks
      pix_seeIdx   .emplace_back(); // filled in fillSeeds
      pix_simHitIdx.push_back( simHitData.matchingSimHit );
      pix_simType.push_back( static_cast<int>(simHitData.type) );
      pix_x    .push_back( ttrh->globalPosition().x() );
      pix_y    .push_back( ttrh->globalPosition().y() );
      pix_z    .push_back( ttrh->globalPosition().z() );
      pix_xx   .push_back( ttrh->globalPositionError().cxx() );
      pix_xy   .push_back( ttrh->globalPositionError().cyx() );
      pix_yy   .push_back( ttrh->globalPositionError().cyy() );
      pix_yz   .push_back( ttrh->globalPositionError().czy() );
      pix_zz   .push_back( ttrh->globalPositionError().czz() );
      pix_zx   .push_back( ttrh->globalPositionError().czx() );
      pix_chargeFraction.push_back( simHitData.chargeFraction );
      pix_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
      pix_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );
      LogTrace("TrackingNtuple") << "pixHit cluster=" << key
                                 << " subdId=" << hitId.subdetId()
                                 << " lay=" << lay
                                 << " rawId=" << hitId.rawId()
                                 << " pos =" << ttrh->globalPosition()
                                 << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
      if(!simHitData.matchingSimHit.empty()) {
        const auto simHitIdx = simHitData.matchingSimHit[0];
        LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
                                   << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                   << " energyLoss=" << simhit_eloss[simHitIdx]
                                   << " particleType=" << simhit_particle[simHitIdx]
                                   << " processType=" << simhit_process[simHitIdx]
                                   << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                   << " event=" << simHitData.event[0];
      }
    }
  }
}

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

private

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

Definition at line 2339 of file TrackingNtuple.cc.

References patPFMETCorrections_cff::algo, reco::TrackBase::algoByName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), reco::TrackToTrackingParticleAssociator::associateSimToReco(), TransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, HiEvtPlane_cfi::chi2, RZLine::chi2(), OmniClusterRef::cluster_phase2OT(), OmniClusterRef::cluster_pixel(), KineDebug3::count(), declareDynArray, SoftLeptonByDistance_cfi::distance, edm::AssociationMap< Tag >::end(), stringResolutionProvider_cfi::eta, Exception, fillTrackingParticlesForSeeds(), spr::find(), edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), edm::Event::getByToken(), glu_seeIdx, Glued, runTauDisplay::gp, mps_fire::i, hcalTTPDigis_cfi::id, OmniClusterRef::id(), createfilelist::int, trackerHitRTTI::isMatched(), OmniClusterRef::key(), edm::Ref< C, T, F >::key(), diffTwoXMLs::label, tablePrinter::labels, edm::EDConsumerBase::labelsForToken(), LogTrace, edm::ProductLabels::module, SiStripMatchedRecHit2D::monoClusterRef(), PFRecoTauDiscriminationByIsolation_cfi::offset, ph2_seeIdx, Phase2OT, phi, pix_seeIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::BeamSpot::position(), EnergyCorrector::pt, edm::RefToBaseVector< T >::push_back(), rpcPointValidation_cfi::recHit, see_algo, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, 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_shareFrac, see_simTrkIdx, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, SurveyInfoScenario_cff::seed, trackingNtuple_cff::seedTracks, edm::RefToBaseVector< T >::size(), SiStripMatchedRecHit2D::stereoClusterRef(), str_seeIdx, Strip, StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, and trackFromSeedFitFailed().

Referenced by analyze().

                                 {
  TSCBLBuilderNoMaterial tscblBuilder;
  for(size_t iColl=0; iColl < seedTokens_.size(); ++iColl) {
    const auto& seedToken = seedTokens_[iColl];

    edm::Handle<edm::View<reco::Track> > seedTracksHandle;
    iEvent.getByToken(seedToken, seedTracksHandle);
    const auto& seedTracks = *seedTracksHandle;

    if(seedTracks.empty())
      continue;

    edm::EDConsumerBase::Labels labels;
    labelsForToken(seedToken, labels);

    const auto& seedStopReasonToken = seedStopReasonTokens_[iColl];
    edm::Handle<std::vector<short> > seedStopReasonHandle;
    iEvent.getByToken(seedStopReasonToken, seedStopReasonHandle);
    const auto& seedStopReasons = *seedStopReasonHandle;
    if(seedTracks.size() != seedStopReasons.size()) {
      edm::EDConsumerBase::Labels labels2;
      labelsForToken(seedStopReasonToken, labels2);
      
      throw cms::Exception("LogicError") << "Got " << seedTracks.size() << " seeds, but " << seedStopReasons.size() << " seed stopping reasons for collections " << labels.module << ", " << labels2.module;
    }

    // The associator interfaces really need to be fixed...
    edm::RefToBaseVector<reco::Track> seedTrackRefs;
    for(edm::View<reco::Track>::size_type i=0; i<seedTracks.size(); ++i) {
      seedTrackRefs.push_back(seedTracks.refAt(i));
    }
    reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(seedTrackRefs, tpCollection);
    reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(seedTrackRefs, tpCollection);

    TString label = labels.module;
    //format label to match algoName
    label.ReplaceAll("seedTracks", "");
    label.ReplaceAll("Seeds","");
    label.ReplaceAll("muonSeeded","muonSeededStep");
    int algo = reco::TrackBase::algoByName(label.Data());

    edm::ProductID id = seedTracks[0].seedRef().id();
    const auto offset = see_fitok.size();
    auto inserted = seedCollToOffset.emplace(id, offset);
    if(!inserted.second)
      throw cms::Exception("Configuration") << "Trying to add seeds with ProductID " << id << " for a second time from collection " << labels.module << ", seed algo " << label << ". Typically this is caused by a configuration problem.";
    see_offset.push_back(offset);

    LogTrace("TrackingNtuple") << "NEW SEED LABEL: " << label << " size: " << seedTracks.size() << " algo=" << algo
                               << " ProductID " << id;

    for(size_t iSeed=0; iSeed < seedTrackRefs.size(); ++iSeed) {
      const auto& seedTrackRef = seedTrackRefs[iSeed];
      const auto& seedTrack = *seedTrackRef;
      const auto& seedRef = seedTrack.seedRef();
      const auto& seed = *seedRef;

      const auto seedStopReason = seedStopReasons[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<float> sharedFraction;
      std::vector<int> tpIdx;
      auto foundTPs = recSimColl.find(seedTrackRef);
      if (foundTPs != recSimColl.end()) {
        for(const auto tpQuality: foundTPs->val) {
          sharedFraction.push_back(tpQuality.second);
          tpIdx.push_back( tpKeyToIndex.at( tpQuality.first.key() ) );
        }
      }


      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 int nHits = seedTrack.numberOfValidHits();

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

      const auto& state = seedTrack.seedRef()->startingState();
      const auto& pos = state.parameters().position();
      const auto& mom = state.parameters().momentum();
      see_statePt.push_back(state.pt());
      see_stateTrajX.push_back(pos.x());
      see_stateTrajY.push_back(pos.y());
      see_stateTrajPx.push_back(mom.x());
      see_stateTrajPy.push_back(mom.y());
      see_stateTrajPz.push_back(mom.z());

      see_trkIdx  .push_back(-1); // to be set correctly in fillTracks
      see_shareFrac.push_back( sharedFraction );
      see_simTrkIdx.push_back( tpIdx );

      /*
      TransientTrackingRecHit::RecHitPointer lastRecHit = theTTRHBuilder.build(&*(seed.recHits().second-1));
      TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( itSeed->startingState(), lastRecHit->surface(), theMF);
      float pt  = state.globalParameters().momentum().perp();
      float eta = state.globalParameters().momentum().eta();
      float phi = state.globalParameters().momentum().phi();
      see_px      .push_back( state.globalParameters().momentum().x() );
      see_py      .push_back( state.globalParameters().momentum().y() );
      see_pz      .push_back( state.globalParameters().momentum().z() );
      */

      std::vector<int> hitIdx;
      std::vector<int> hitType;

      for (auto hit=seed.recHits().first; hit!=seed.recHits().second; ++hit) {
    TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder.build(&*hit);
    int subid = recHit->geographicalId().subdetId();
    if (subid == (int) PixelSubdetector::PixelBarrel || subid == (int) PixelSubdetector::PixelEndcap) {
      const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
          const auto& clusterRef = bhit->firstClusterRef();
          const auto clusterKey = clusterRef.cluster_pixel().key();
          if(includeAllHits_) {
            checkProductID(hitProductIds, clusterRef.id(), "seed");
            pix_seeIdx[clusterKey].push_back(seedIndex);
          }
          hitIdx.push_back( clusterKey );
          hitType.push_back( static_cast<int>(HitType::Pixel) );
    } else if (subid == (int) StripSubdetector::TOB || subid == (int) StripSubdetector::TID ||
               subid == (int) StripSubdetector::TIB || subid == (int) StripSubdetector::TEC) {
      if (trackerHitRTTI::isMatched(*recHit)) {
        const SiStripMatchedRecHit2D * matchedHit = dynamic_cast<const SiStripMatchedRecHit2D *>(&*recHit);
            if(includeAllHits_) {
              checkProductID(hitProductIds, matchedHit->monoClusterRef().id(), "seed");
              checkProductID(hitProductIds, matchedHit->stereoClusterRef().id(), "seed");
            }
        int monoIdx = matchedHit->monoClusterRef().key();
        int stereoIdx = matchedHit->stereoClusterRef().key();

            std::vector<std::pair<int,int> >::const_iterator pos = find( monoStereoClusterList.begin(), monoStereoClusterList.end(), std::make_pair(monoIdx,stereoIdx) );
            const auto gluedIndex = std::distance(monoStereoClusterList.begin(), pos);
            if(includeAllHits_) glu_seeIdx[gluedIndex].push_back(seedIndex);
            hitIdx.push_back( gluedIndex );
            hitType.push_back( static_cast<int>(HitType::Glued) );
      } else {
        const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
            const auto& clusterRef = bhit->firstClusterRef();
            unsigned int clusterKey;
            if(clusterRef.isPhase2()){
              clusterKey = clusterRef.cluster_phase2OT().key();
            } else {
              clusterKey = clusterRef.cluster_strip().key();
            }

            if(includeAllHits_) {
              checkProductID(hitProductIds, clusterRef.id(), "seed");
              if(clusterRef.isPhase2()){
                ph2_seeIdx[clusterKey].push_back(seedIndex);
              } else {
                str_seeIdx[clusterKey].push_back(seedIndex);
              }
            }

            hitIdx.push_back( clusterKey );
            if(clusterRef.isPhase2()){
              hitType.push_back( static_cast<int>(HitType::Phase2OT) );
            } else {
              hitType.push_back( static_cast<int>(HitType::Strip) );
            }
      }
    } else {
          LogTrace("TrackingNtuple") << " not pixel and not Strip detector";
        }
      }
      see_hitIdx   .push_back( hitIdx  );
      see_hitType  .push_back( hitType );
      see_nPixel   .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Pixel)) );
      see_nGlued   .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Glued)) );
      see_nStrip   .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Strip)) );
      see_nPhase2OT.push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Phase2OT)) );
      //the part below is not strictly needed
      float chi2 = -1;
      if (nHits==2) {
    TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
    TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
        std::vector<GlobalPoint> gp(2);
        std::vector<GlobalError> ge(2);
    gp[0] = recHit0->globalPosition();
    ge[0] = recHit0->globalPositionError();
    gp[1] = recHit1->globalPosition();
    ge[1] = recHit1->globalPositionError();
        LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
                                   << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
                                   << " - PAIR - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
                                   << " hitpos: " << gp[0] << " " << gp[1]
                                   << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                   << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                   << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                   << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                   << " eta,phi: " << gp[0].eta() << "," << gp[0].phi();
      } else if (nHits==3) {
    TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
    TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
    TransientTrackingRecHit::RecHitPointer recHit2 = theTTRHBuilder.build(&*(seed.recHits().first+2));
    declareDynArray(GlobalPoint,4, gp);
    declareDynArray(GlobalError,4, ge);
    declareDynArray(bool,4, bl);
    gp[0] = recHit0->globalPosition();
    ge[0] = recHit0->globalPositionError();
    int subid0 = recHit0->geographicalId().subdetId();
    bl[0] = (subid0 == StripSubdetector::TIB || subid0 == StripSubdetector::TOB || subid0 == (int) PixelSubdetector::PixelBarrel);
    gp[1] = recHit1->globalPosition();
    ge[1] = recHit1->globalPositionError();
    int subid1 = recHit1->geographicalId().subdetId();
    bl[1] = (subid1 == StripSubdetector::TIB || subid1 == StripSubdetector::TOB || subid1 == (int) PixelSubdetector::PixelBarrel);
    gp[2] = recHit2->globalPosition();
    ge[2] = recHit2->globalPositionError();
    int subid2 = recHit2->geographicalId().subdetId();
    bl[2] = (subid2 == StripSubdetector::TIB || subid2 == StripSubdetector::TOB || subid2 == (int) PixelSubdetector::PixelBarrel);
    RZLine rzLine(gp,ge,bl);
    float seed_chi2 = rzLine.chi2();
    //float seed_pt = state.globalParameters().momentum().perp();
        float seed_pt = pt;
    LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
                                   << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
                                   << " - TRIPLET - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId() << " " << recHit2->geographicalId().rawId()
                                   << " hitpos: " << gp[0] << " " << gp[1] << " " << gp[2]
                                   << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                   << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                   << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                   << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                   << " trans2: " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                   << " " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                   << " local: " << recHit2->localPosition()
          //<< " tsos pos, mom: " << state.globalPosition()<<" "<<state.globalMomentum()
                                   << " eta,phi: " << gp[0].eta() << "," << gp[0].phi()
                                   << " pt,chi2: " << seed_pt << "," << seed_chi2;
    chi2 = seed_chi2;
      }
      see_chi2   .push_back( chi2 );
    }

    fillTrackingParticlesForSeeds(tpCollection, simRecColl, tpKeyToIndex, offset);
  }
}

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

private

Definition at line 1989 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                                                   {

  for(const auto& assoc: simHitsTPAssoc) {
    auto tpKey = assoc.first.key();

    // SimHitTPAssociationList can contain more TrackingParticles than
    // what are given to this EDAnalyzer, so we can filter those out here.
    auto found = tpKeyToIndex.find(tpKey);
    if(found == tpKeyToIndex.end())
      continue;
    const auto tpIndex = found->second;

    // skip non-tracker simhits (mostly muons)
    const auto& simhit = *(assoc.second);
    auto detId = DetId(simhit.detUnitId());
    if(detId.det() != DetId::Tracker) continue;

    // Skip electron SimHits for non-electron TrackingParticles to
    // filter out delta rays. The delta ray hits just confuse. If we
    // need them later, let's add them as a separate "collection" of
    // hits of a TP
    const TrackingParticle& tp = *(assoc.first);
    if(std::abs(simhit.particleType()) == 11 && std::abs(tp.pdgId()) != 11) continue;

    auto simHitKey = std::make_pair(assoc.second.key(), assoc.second.id());

    if(simHitRefKeyToIndex.find(simHitKey) != simHitRefKeyToIndex.end()) {
      for(const auto& assoc2: simHitsTPAssoc) {
        if(std::make_pair(assoc2.second.key(), assoc2.second.id()) == simHitKey) {

#ifdef EDM_ML_DEBUG
          auto range1 = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                         std::make_pair(assoc.first, TrackPSimHitRef()),
                                         SimHitTPAssociationProducer::simHitTPAssociationListGreater);
          auto range2 = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                         std::make_pair(assoc2.first, TrackPSimHitRef()),
                                         SimHitTPAssociationProducer::simHitTPAssociationListGreater);

          LogTrace("TrackingNtuple") << "Earlier TP " << assoc2.first.key() << " SimTrack Ids";
          for(const auto& simTrack: assoc2.first->g4Tracks()) {
            edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event " << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
          }
          for(auto iHit = range2.first; iHit != range2.second; ++iHit) {
            LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof " << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event " << iHit->second->eventId().bunchCrossing() << ":" << iHit->second->eventId().event();
          }
          LogTrace("TrackingNtuple") << "Current TP " << assoc.first.key() << " SimTrack Ids";
          for(const auto& simTrack: assoc.first->g4Tracks()) {
            edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event " << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
          }
          for(auto iHit = range1.first; iHit != range1.second; ++iHit) {
            LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof " << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event " << iHit->second->eventId().bunchCrossing() << ":" << iHit->second->eventId().event();
          }
#endif

          throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second << ", first time with TrackingParticle " << assoc2.first.key() << ", now with " << tpKey;
        }
      }
      throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second << ", now with TrackingParticle " << tpKey << ", but I didn't find the first occurrance!";
    }

    auto det = tracker.idToDetUnit(detId);
    if(!det)
      throw cms::Exception("LogicError") << "Did not find a det unit for DetId " << simhit.detUnitId() << " from tracker geometry";

    const auto pos = det->surface().toGlobal(simhit.localPosition());
    const float tof = simhit.timeOfFlight();

    const auto simHitIndex = simhit_x.size();
    simHitRefKeyToIndex[simHitKey] = simHitIndex;

    if(includeStripHits_) simhit_detId.push_back(tTopo, detId);
    else                  simhit_detId_phase2.push_back(tTopo, detId);
    simhit_x.push_back(pos.x());
    simhit_y.push_back(pos.y());
    simhit_z.push_back(pos.z());
    simhit_particle.push_back(simhit.particleType());
    simhit_process.push_back(simhit.processType());
    simhit_eloss.push_back(simhit.energyLoss());
    simhit_tof.push_back(tof);
    //simhit_simTrackId.push_back(simhit.trackId());

    simhit_simTrkIdx.push_back(tpIndex);

    simhit_hitIdx.emplace_back();  // filled in matchCluster
    simhit_hitType.emplace_back(); // filled in matchCluster

    tpHitList.emplace_back(tpKey, simHitIndex, tof, simhit.detUnitId());
  }
}

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

private

Definition at line 2235 of file TrackingNtuple.cc.

References edmNew::DetSetVector< T >::begin(), TransientTrackingRecHitBuilder::build(), edmNew::DetSetVector< T >::end(), edm::Event::getByToken(), glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, TrackerTopology::layer(), LogTrace, DetId::rawId(), DetId::subdetId(), StripSubdetector::TIB, and StripSubdetector::TOB.

Referenced by analyze().

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

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

private

Definition at line 2147 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                               {
  //index strip hit branches by cluster index
  edm::Handle<SiStripRecHit2DCollection> rphiHits;
  iEvent.getByToken(stripRphiRecHitToken_, rphiHits);
  edm::Handle<SiStripRecHit2DCollection> stereoHits;
  iEvent.getByToken(stripStereoRecHitToken_, stereoHits);
  int totalStripHits = rphiHits->dataSize()+stereoHits->dataSize();
  str_isBarrel .resize(totalStripHits);
  str_detId    .resize(totalStripHits);
  str_trkIdx   .resize(totalStripHits); // filled in fillTracks
  str_seeIdx   .resize(totalStripHits); // filled in fillSeeds
  str_simHitIdx.resize(totalStripHits);
  str_simType  .resize(totalStripHits);
  str_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_chargeFraction.resize(totalStripHits);
  str_radL .resize(totalStripHits);
  str_bbxi .resize(totalStripHits);

  auto fill = [&](const SiStripRecHit2DCollection& hits, const char *name) {
    for(const auto& detset: hits) {
      const DetId hitId = detset.detId();
      for(const auto& hit: detset) {
        TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);

        hitProductIds.insert(hit.cluster().id());

        const int key = hit.cluster().key();
        const int lay = tTopo.layer(hitId);
        SimHitData simHitData = matchCluster(hit.firstClusterRef(), hitId, key, ttrh,
                                             clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Strip);
        str_isBarrel [key] = (hitId.subdetId()==StripSubdetector::TIB || hitId.subdetId()==StripSubdetector::TOB);
        str_detId.set(key, tTopo, hitId);
        str_simHitIdx[key] = simHitData.matchingSimHit;
        str_simType  [key] = static_cast<int>(simHitData.type);
        str_x    [key] = ttrh->globalPosition().x();
        str_y    [key] = ttrh->globalPosition().y();
        str_z    [key] = ttrh->globalPosition().z();
        str_xx   [key] = ttrh->globalPositionError().cxx();
        str_xy   [key] = ttrh->globalPositionError().cyx();
        str_yy   [key] = ttrh->globalPositionError().cyy();
        str_yz   [key] = ttrh->globalPositionError().czy();
        str_zz   [key] = ttrh->globalPositionError().czz();
        str_zx   [key] = ttrh->globalPositionError().czx();
        str_chargeFraction[key] = simHitData.chargeFraction;
        str_radL [key] = ttrh->surface()->mediumProperties().radLen();
        str_bbxi [key] = ttrh->surface()->mediumProperties().xi();
        LogTrace("TrackingNtuple") << name << " cluster=" << key
                                   << " subdId=" << hitId.subdetId()
                                   << " lay=" << lay
                                   << " rawId=" << hitId.rawId()
                                   << " pos =" << ttrh->globalPosition()
                                   << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
        if(!simHitData.matchingSimHit.empty()) {
          const auto simHitIdx = simHitData.matchingSimHit[0];
          LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
                                     << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                     << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                     << " energyLoss=" << simhit_eloss[simHitIdx]
                                     << " particleType=" << simhit_particle[simHitIdx]
                                     << " processType=" << simhit_process[simHitIdx]
                                     << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                     << " event=" << simHitData.event[0];
        }
      }
    }
  };

  fill(*rphiHits, "stripRPhiHit");
  fill(*stereoHits, "stripStereoHit");
}

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

private

Definition at line 2793 of file TrackingNtuple.cc.

References reco::TrackToTrackingParticleAssociator::associateSimToReco(), TrackingParticleIP::dxy(), TrackingParticleIP::dz(), edm::AssociationMap< Tag >::end(), HistoryBase::evaluate(), Exception, edm::AssociationMap< Tag >::find(), edm::EventSetup::get(), edm::Event::getByToken(), LogTrace, M_PI, ParametersDefinerForTP::momentum(), MuonTrackValidator_cfi::parametersDefiner, EgammaObjectsElectrons_cfi::particleID, source_particleGun_cfi::ParticleID, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::BeamSpot::position(), edm::ESHandle< T >::product(), HistoryBase::recoGenParticleTrail(), sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nStrip, 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_shareFrac, sim_simHitIdx, sim_trkIdx, simhit_detId, simhit_detId_phase2, simhit_hitType, mathSSE::sqrt(), funct::tan(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, tpHitIndexListLess(), DetId::Tracker, photonIsolationHIProducer_cfi::trackQuality, Unknown, findQualityFiles::v, and ParametersDefinerForTP::vertex().

Referenced by analyze().

                                             {
  edm::ESHandle<ParametersDefinerForTP> parametersDefinerH;
  iSetup.get<TrackAssociatorRecord>().get(parametersDefinerName_, parametersDefinerH);
  const ParametersDefinerForTP *parametersDefiner = parametersDefinerH.product();

  // Number of 3D layers for TPs
  edm::Handle<edm::ValueMap<unsigned int>> tpNLayersH;
  iEvent.getByToken(tpNLayersToken_, tpNLayersH);
  const auto& nLayers_tPCeff = *tpNLayersH;

  iEvent.getByToken(tpNPixelLayersToken_, tpNLayersH);
  const auto& nPixelLayers_tPCeff = *tpNLayersH;

  iEvent.getByToken(tpNStripStereoLayersToken_, tpNLayersH);
  const auto& nStripMonoAndStereoLayers_tPCeff = *tpNLayersH;

  reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(tracks, tpCollection);

  for(const TrackingParticleRef& tp: tpCollection) {
    LogTrace("TrackingNtuple") << "tracking particle pt=" << tp->pt() << " eta=" << tp->eta() << " phi=" << tp->phi();
    bool isRecoMatched = false;
    std::vector<int> tkIdx;
    std::vector<float> sharedFraction;
    auto foundTracks = simRecColl.find(tp);
    if(foundTracks != simRecColl.end()) {
      isRecoMatched = true;
      for(const auto trackQuality: foundTracks->val) {
        sharedFraction.push_back(trackQuality.second);
        tkIdx.push_back(trackQuality.first.key());
      }
    }

    sim_genPdgIds.emplace_back();
    for(const auto& genRef: tp->genParticles()) {
      if(genRef.isNonnull())
        sim_genPdgIds.back().push_back(genRef->pdgId());
    }

    bool isFromBHadron = false;
    // Logic is similar to SimTracker/TrackHistory
    if(tracer_.evaluate(tp)) { // ignore TP if history can not be traced
      // following is from TrackClassifier::processesAtGenerator()
      HistoryBase::RecoGenParticleTrail const & recoGenParticleTrail = tracer_.recoGenParticleTrail();
      for(const auto& particle: recoGenParticleTrail) {
        HepPDT::ParticleID particleID(particle->pdgId());
        if(particleID.hasBottom()) {
          isFromBHadron = true;
          break;
        }
      }
    }

    LogTrace("TrackingNtuple") << "matched to tracks = " << make_VectorPrinter(tkIdx) << " isRecoMatched=" << isRecoMatched;
    sim_event    .push_back(tp->eventId().event());
    sim_bunchCrossing.push_back(tp->eventId().bunchCrossing());
    sim_pdgId    .push_back(tp->pdgId());
    sim_isFromBHadron.push_back(isFromBHadron);
    sim_px       .push_back(tp->px());
    sim_py       .push_back(tp->py());
    sim_pz       .push_back(tp->pz());
    sim_pt       .push_back(tp->pt());
    sim_eta      .push_back(tp->eta());
    sim_phi      .push_back(tp->phi());
    sim_q        .push_back(tp->charge());
    sim_trkIdx   .push_back(tkIdx);
    sim_shareFrac.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_simHitIdx.push_back(hitIdx);
  }
}

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

private

Definition at line 2931 of file TrackingNtuple.cc.

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

Referenced by fillSeeds().

                                                                                  {
  if(sim_seedIdx.empty()) // first call
    sim_seedIdx.resize(tpCollection.size());

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

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

private

Definition at line 2984 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                            {
  int current_event = -1;
  for(const auto& ref: trackingVertices) {
    const TrackingVertex v = *ref;
    if(v.eventId().event() != current_event) {
      // next PV
      current_event = v.eventId().event();
      simpv_idx.push_back(simvtx_x.size());
    }

    unsigned int processType = std::numeric_limits<unsigned int>::max();
    if(!v.g4Vertices().empty()) {
      processType = v.g4Vertices()[0].processType();
    }

    simvtx_event.push_back(v.eventId().event());
    simvtx_bunchCrossing.push_back(v.eventId().bunchCrossing());
    simvtx_processType.push_back(processType);

    simvtx_x.push_back(v.position().x());
    simvtx_y.push_back(v.position().y());
    simvtx_z.push_back(v.position().z());

    auto fill = [&](const TrackingParticleRefVector& tps, std::vector<int>& idx) {
      for(const auto& tpRef: tps) {
        auto found = tpKeyToIndex.find(tpRef.key());
        if(found != tpKeyToIndex.end()) {
          idx.push_back(found->second);
        }
      }
    };

    std::vector<int> sourceIdx;
    std::vector<int> daughterIdx;
    fill(v.sourceTracks(), sourceIdx);
    fill(v.daughterTracks(), daughterIdx);

    simvtx_sourceSimIdx.push_back(sourceIdx);
    simvtx_daughterSimIdx.push_back(daughterIdx);
  }
}

void TrackingNtuple::fillTracks ( const edm::RefToBaseVector< reco::Track > &  tracks, const TrackingParticleRefVector &  tpCollection, const TrackingParticleRefKeyToIndex &  tpKeyToIndex, const reco::BeamSpot &  bs, const reco::TrackToTrackingParticleAssociator &  associatorByHits, const TransientTrackingRecHitBuilder &  theTTRHBuilder, const TrackerTopology &  tTopo, const std::set< edm::ProductID > &  hitProductIds, const std::map< edm::ProductID, size_t > &  seedToCollIndex  )

private

Definition at line 2612 of file TrackingNtuple.cc.

References reco::TrackBase::algoName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), TransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, HiEvtPlane_cfi::chi2, OmniClusterRef::cluster_pixel(), DetId::det(), SoftLeptonByDistance_cfi::distance, edm::AssociationMap< Tag >::end(), stringResolutionProvider_cfi::eta, Exception, edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), reco::TrackBase::highPurity, AnalysisDataFormats_SUSYBSMObjects::hp, mps_fire::i, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, Invalid, edm::Ref< C, T, F >::key(), tablePrinter::labels, edm::EDConsumerBase::labelsForToken(), TrackerTopology::layer(), LogTrace, M_PI, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, edm::ProductLabels::module, reco::HitPattern::numberOfLostHits(), reco::HitPattern::numberOfLostTrackerHits(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidStripHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), PFRecoTauDiscriminationByIsolation_cfi::offset, ph2_trkIdx, Phase2OT, phi, pix_trkIdx, Pixel, reco::HitPattern::pixelLayersWithMeasurement(), reco::BeamSpot::position(), EnergyCorrector::pt, DetId::rawId(), see_trkIdx, edm::RefToBaseVector< T >::size(), str_trkIdx, Strip, reco::HitPattern::stripLayersWithMeasurement(), DetId::subdetId(), funct::tan(), reco::HitPattern::TRACK_HITS, DetId::Tracker, trk_algoMask, trk_hitIdx, trk_hitType, trk_isHP, trk_seedIdx, trk_shareFrac, trk_simTrkIdx, trk_stopReason, and trk_vtxIdx.

Referenced by analyze().

                                  {
  reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(tracks, tpCollection);
  edm::EDConsumerBase::Labels labels;
  labelsForToken(trackToken_, labels);
  LogTrace("TrackingNtuple") << "NEW TRACK LABEL: " << labels.module;
  for(size_t iTrack = 0; iTrack<tracks.size(); ++iTrack) {
    const auto& itTrack = tracks[iTrack];
    int nSimHits = 0;
    bool isSimMatched = false;
    std::vector<float> sharedFraction;
    std::vector<int> tpIdx;
    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) {
        sharedFraction.push_back(tpQuality.second);
    tpIdx.push_back( tpKeyToIndex.at( tpQuality.first.key() ) );
      }
    }
    int charge = itTrack->charge();
    float pt = itTrack->pt();
    float eta = itTrack->eta();
    const double lambda = itTrack->lambda();
    float chi2 = itTrack->normalizedChi2();
    float phi = itTrack->phi();
    int nHits = itTrack->numberOfValidHits();
    const reco::HitPattern& hp = itTrack->hitPattern();
    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_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( itTrack->normalizedChi2());
    trk_shareFrac.push_back(sharedFraction);
    trk_q        .push_back(charge);
    trk_nValid   .push_back(hp.numberOfValidHits());
    trk_nInvalid .push_back(hp.numberOfLostHits(reco::HitPattern::TRACK_HITS));
    trk_nPixel   .push_back(hp.numberOfValidPixelHits());
    trk_nStrip   .push_back(hp.numberOfValidStripHits());
    trk_nPixelLay.push_back(hp.pixelLayersWithMeasurement());
    trk_nStripLay.push_back(hp.stripLayersWithMeasurement());
    trk_n3DLay   .push_back(hp.numberOfValidStripLayersWithMonoAndStereo()+hp.pixelLayersWithMeasurement());
    trk_nOuterLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS));
    trk_nInnerLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS));
    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(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
    trk_simTrkIdx.push_back(tpIdx);
    LogTrace("TrackingNtuple") << "Track #" << itTrack.key() << " with q=" << charge
                               << ", pT=" << pt << " GeV, eta: " << eta << ", phi: " << phi
                               << ", chi2=" << chi2
                               << ", Nhits=" << nHits
                               << ", algo=" << itTrack->algoName(itTrack->algo()).c_str()
                               << " hp=" << itTrack->quality(reco::TrackBase::highPurity)
                               << " seed#=" << itTrack->seedRef().key()
                               << " simMatch=" << isSimMatched
                               << " nSimHits=" << nSimHits
                               << " sharedFraction=" << (sharedFraction.empty()?-1:sharedFraction[0])
                               << " tpIdx=" << (tpIdx.empty()?-1:tpIdx[0]);
    std::vector<int> hitIdx;
    std::vector<int> hitType;

    for(auto i=itTrack->recHitsBegin(); i!=itTrack->recHitsEnd(); i++) {
      TransientTrackingRecHit::RecHitPointer hit=theTTRHBuilder.build(&**i );
      DetId hitId = hit->geographicalId();
      LogTrace("TrackingNtuple") << "hit #" << std::distance(itTrack->recHitsBegin(), i) << " subdet=" << hitId.subdetId();
      if(hitId.det() != DetId::Tracker)
        continue;

      LogTrace("TrackingNtuple") << " " << subdetstring(hitId.subdetId()) << " " << tTopo.layer(hitId);

      if (hit->isValid()) {
        //ugly... but works
        const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*hit);
        const auto& clusterRef = bhit->firstClusterRef();
        unsigned int clusterKey;
        if(clusterRef.isPixel()){
          clusterKey = clusterRef.cluster_pixel().key();
        } else if(clusterRef.isPhase2()){
          clusterKey = clusterRef.cluster_phase2OT().key();
        } else {
          clusterKey = clusterRef.cluster_strip().key();
        }

        LogTrace("TrackingNtuple") << " id: " << hitId.rawId() << " - globalPos =" << hit->globalPosition()
                                   << " cluster=" << clusterKey
                                   << " clusterRef ID=" << clusterRef.id()
                                   << " eta,phi: " << hit->globalPosition().eta() << "," << hit->globalPosition().phi();
        if(includeAllHits_) {
          checkProductID(hitProductIds, clusterRef.id(), "track");
          if(clusterRef.isPixel()){
            pix_trkIdx[clusterKey].push_back(iTrack);
          } else if(clusterRef.isPhase2()){
            ph2_trkIdx[clusterKey].push_back(iTrack);
          } else {
            str_trkIdx[clusterKey].push_back(iTrack);
          }

        }

        hitIdx.push_back(clusterKey);
        if(clusterRef.isPixel()){
          hitType.push_back( static_cast<int>(HitType::Pixel));
        } else if(clusterRef.isPhase2()){
          hitType.push_back( static_cast<int>(HitType::Phase2OT));
        } else {
          hitType.push_back( static_cast<int>(HitType::Strip));
        }
      } else  {
        LogTrace("TrackingNtuple") << " - invalid hit";

        hitIdx.push_back( inv_isBarrel.size() );
        hitType.push_back( static_cast<int>(HitType::Invalid) );

        inv_isBarrel.push_back( hitId.subdetId()==1 );
        if(includeStripHits_)  inv_detId.push_back( tTopo, hitId );
        else                   inv_detId_phase2.push_back( tTopo, hitId );
        inv_type    .push_back( hit->getType() );

      }
    }

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

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

private

Definition at line 2952 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                                                               {
  for(size_t iVertex=0, size=vertices.size(); iVertex<size; ++iVertex) {
    const reco::Vertex& vertex = vertices[iVertex];
    vtx_x.push_back(vertex.x());
    vtx_y.push_back(vertex.y());
    vtx_z.push_back(vertex.z());
    vtx_xErr.push_back(vertex.xError());
    vtx_yErr.push_back(vertex.yError());
    vtx_zErr.push_back(vertex.zError());
    vtx_chi2.push_back(vertex.chi2());
    vtx_ndof.push_back(vertex.ndof());
    vtx_fake.push_back(vertex.isFake());
    vtx_valid.push_back(vertex.isValid());

    std::vector<int> trkIdx;
    for(auto iTrack = vertex.tracks_begin(); iTrack != vertex.tracks_end(); ++iTrack) {
      // Ignore link if vertex was fit from a track collection different from the input
      if(iTrack->id() != tracks.id())
        continue;

      trkIdx.push_back(iTrack->key());

      if(trk_vtxIdx[iTrack->key()] != -1) {
        throw cms::Exception("LogicError") << "Vertex index has already been set for track " << iTrack->key() << " to " << trk_vtxIdx[iTrack->key()] << "; was trying to set it to " << iVertex;
      }
      trk_vtxIdx[iTrack->key()] = iVertex;
    }
    vtx_trkIdx.push_back(trkIdx);
  }
}

template<typename SimLink >

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

private

Definition at line 1887 of file TrackingNtuple.cc.

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

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

                                                          {
  SimHitData ret;

  std::map<unsigned int, double> simTrackIdToChargeFraction;
  if(hitType == HitType::Phase2OT) simTrackIdToChargeFraction = chargeFraction(cluster.phase2OTCluster(), hitId, digiSimLinks);
  else simTrackIdToChargeFraction = chargeFraction(GetCluster<SimLink>::call(cluster), hitId, digiSimLinks);

  ret.type = HitSimType::Noise;
  auto range = clusterToTPMap.equal_range( cluster );
  if( range.first != range.second ) {
    for( auto ip=range.first; ip != range.second; ++ip ) {
      const TrackingParticleRef& trackingParticle = ip->second;

      // Find out if the cluster is from signal/ITPU/OOTPU
      const auto event = trackingParticle->eventId().event();
      const auto bx = trackingParticle->eventId().bunchCrossing();
      HitSimType type = HitSimType::OOTPileup;
      if(bx == 0) {
        type = (event == 0 ? HitSimType::Signal : HitSimType::ITPileup);
      }
      ret.type = static_cast<HitSimType>(std::min(static_cast<int>(ret.type), static_cast<int>(type)));

      // Limit to only input TrackingParticles (usually signal+ITPU)
      auto tpIndex = tpKeyToIndex.find(trackingParticle.key());
      if( tpIndex == tpKeyToIndex.end())
        continue;

      //now get the corresponding sim hit
      std::pair<TrackingParticleRef, TrackPSimHitRef> simHitTPpairWithDummyTP(trackingParticle,TrackPSimHitRef());
      //SimHit is dummy: for simHitTPAssociationListGreater sorting only the TP is needed
      auto range = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                    simHitTPpairWithDummyTP, SimHitTPAssociationProducer::simHitTPAssociationListGreater);
      int simHitKey = -1;
      bool foundElectron = false;
      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;
            continue;
          }

          simHitKey = TPhit.key();
          simHitID = TPhit.id();
          break;
        }
      }
      if(simHitKey < 0) {
        // In case we didn't find a simhit because of filtered-out
        // electron SimHit, just ignore the missing SimHit.
        if(foundElectron)
          continue;

        auto ex = cms::Exception("LogicError") << "Did not find SimHit for reco hit DetId " << hitId.rawId()
                                               << " for TP " << trackingParticle.key() << " bx:event " << bx << ":" << event
                                               << ".\nFound SimHits from detectors ";
        for(auto ip = range.first; ip != range.second; ++ip) {
          TrackPSimHitRef TPhit = ip->second;
          DetId dId = DetId(TPhit->detUnitId());
          ex << dId.rawId() << " ";
        }
        if(trackingParticle->eventId().event() != 0) {
          ex << "\nSince this is a TrackingParticle from pileup, check that you're running the pileup mixing in playback mode.";
        }
        throw ex;
      }
      auto simHitIndex = simHitRefKeyToIndex.at(std::make_pair(simHitKey, simHitID));
      ret.matchingSimHit.push_back(simHitIndex);

      double chargeFraction = 0.;
      for(const SimTrack& simtrk: trackingParticle->g4Tracks()) {
        auto found = simTrackIdToChargeFraction.find(simtrk.trackId());
        if(found != simTrackIdToChargeFraction.end()) {
          chargeFraction += found->second;
        }
      }
      ret.chargeFraction.push_back(chargeFraction);

      // only for debug prints
      ret.bunchCrossing.push_back(bx);
      ret.event.push_back(event);

      simhit_hitIdx[simHitIndex].push_back(clusterKey);
      simhit_hitType[simHitIndex].push_back(static_cast<int>(hitType));
    }
  }

  return ret;
}

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

inlinestaticprivate

Definition at line 379 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::tpKey.

Referenced by fillTrackingParticles().

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

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

inlinestaticprivate

Definition at line 380 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::detId, RecoMET_Cosmics_cff::fillTracks, iEvent, edm::isNotFinite(), TrackingNtuple::TPHitIndex::tof, TrackingNtuple::TPHitIndex::tpKey, mixOne_simraw_on_sim_cfi::tracker, l1t::tracks, and ecalDrivenElectronSeedsParameters_cff::vertices.

Referenced by analyze().

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

Member Data Documentation

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

private

Definition at line 517 of file TrackingNtuple.cc.

float TrackingNtuple::bsp_sigmax

private

Definition at line 1013 of file TrackingNtuple.cc.

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

float TrackingNtuple::bsp_sigmay

private

Definition at line 1014 of file TrackingNtuple.cc.

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

float TrackingNtuple::bsp_sigmaz

private

Definition at line 1015 of file TrackingNtuple.cc.

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

float TrackingNtuple::bsp_x

private

Definition at line 1010 of file TrackingNtuple.cc.

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

float TrackingNtuple::bsp_y

private

Definition at line 1011 of file TrackingNtuple.cc.

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

float TrackingNtuple::bsp_z

private

Definition at line 1012 of file TrackingNtuple.cc.

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

std::string TrackingNtuple::builderName_

private

Definition at line 528 of file TrackingNtuple.cc.

edm::EDGetTokenT<ClusterTPAssociation> TrackingNtuple::clusterTPMapToken_

private

Definition at line 510 of file TrackingNtuple.cc.

edm::EventNumber_t TrackingNtuple::ev_event

private

Definition at line 814 of file TrackingNtuple.cc.

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi

private

Definition at line 813 of file TrackingNtuple.cc.

edm::RunNumber_t TrackingNtuple::ev_run

private

Definition at line 812 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::glu_bbxi

private

Definition at line 962 of file TrackingNtuple.cc.

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

DetIdStrip TrackingNtuple::glu_detId

private

Definition at line 948 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::glu_isBarrel

private

Definition at line 947 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::glu_monoIdx

private

Definition at line 949 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_radL

private

Definition at line 961 of file TrackingNtuple.cc.

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

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

private

Definition at line 951 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::glu_stereoIdx

private

Definition at line 950 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_x

private

Definition at line 952 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_xx

private

Definition at line 955 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_xy

private

Definition at line 956 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_y

private

Definition at line 953 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_yy

private

Definition at line 957 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_yz

private

Definition at line 958 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_z

private

Definition at line 954 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_zx

private

Definition at line 960 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::glu_zz

private

Definition at line 959 of file TrackingNtuple.cc.

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

const bool TrackingNtuple::includeAllHits_

private

Definition at line 531 of file TrackingNtuple.cc.

bool TrackingNtuple::includePhase2OTHits_

private

Definition at line 516 of file TrackingNtuple.cc.

const bool TrackingNtuple::includeSeeds_

private

Definition at line 530 of file TrackingNtuple.cc.

bool TrackingNtuple::includeStripHits_

private

Definition at line 516 of file TrackingNtuple.cc.

DetIdAll TrackingNtuple::inv_detId

private

Definition at line 989 of file TrackingNtuple.cc.

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

DetIdAllPhase2 TrackingNtuple::inv_detId_phase2

private

Definition at line 990 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::inv_isBarrel

private

Definition at line 988 of file TrackingNtuple.cc.

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

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

private

Definition at line 991 of file TrackingNtuple.cc.

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

std::string TrackingNtuple::parametersDefinerName_

private

Definition at line 529 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::ph2_bbxi

private

Definition at line 983 of file TrackingNtuple.cc.

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

DetIdPhase2OT TrackingNtuple::ph2_detId

private

Definition at line 967 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::ph2_isBarrel

private

Definition at line 966 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_radL

private

Definition at line 982 of file TrackingNtuple.cc.

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

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

private

Definition at line 969 of file TrackingNtuple.cc.

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

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

private

Definition at line 970 of file TrackingNtuple.cc.

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

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

private

Definition at line 972 of file TrackingNtuple.cc.

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

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

private

Definition at line 968 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_x

private

Definition at line 973 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_xx

private

Definition at line 976 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_xy

private

Definition at line 977 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_y

private

Definition at line 974 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_yy

private

Definition at line 978 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_yz

private

Definition at line 979 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_z

private

Definition at line 975 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_zx

private

Definition at line 981 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::ph2_zz

private

Definition at line 980 of file TrackingNtuple.cc.

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

edm::EDGetTokenT<Phase2TrackerRecHit1DCollectionNew> TrackingNtuple::phase2OTRecHitToken_

private

Definition at line 522 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::pix_bbxi

private

Definition at line 922 of file TrackingNtuple.cc.

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

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

private

Definition at line 910 of file TrackingNtuple.cc.

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

DetIdPixel TrackingNtuple::pix_detId

private

Definition at line 906 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::pix_isBarrel

private

Definition at line 905 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_radL

private

Definition at line 921 of file TrackingNtuple.cc.

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

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

private

Definition at line 908 of file TrackingNtuple.cc.

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

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

private

Definition at line 909 of file TrackingNtuple.cc.

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

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

private

Definition at line 911 of file TrackingNtuple.cc.

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

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

private

Definition at line 907 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_x

private

Definition at line 912 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_xx

private

Definition at line 915 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_xy

private

Definition at line 916 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_y

private

Definition at line 913 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_yy

private

Definition at line 917 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_yz

private

Definition at line 918 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_z

private

Definition at line 914 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_zx

private

Definition at line 920 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_zz

private

Definition at line 919 of file TrackingNtuple.cc.

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

edm::EDGetTokenT<SiPixelRecHitCollection> TrackingNtuple::pixelRecHitToken_

private

Definition at line 518 of file TrackingNtuple.cc.

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

private

Definition at line 513 of file TrackingNtuple.cc.

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

private

Definition at line 1046 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_chi2

private

Definition at line 1033 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_dxy

private

Definition at line 1026 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_dxyErr

private

Definition at line 1031 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_dz

private

Definition at line 1027 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_dzErr

private

Definition at line 1032 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_eta

private

Definition at line 1024 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_etaErr

private

Definition at line 1029 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::see_fitok

private

Definition at line 1019 of file TrackingNtuple.cc.

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

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

private

Definition at line 1051 of file TrackingNtuple.cc.

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

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

private

Definition at line 1052 of file TrackingNtuple.cc.

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

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

private

Definition at line 1043 of file TrackingNtuple.cc.

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

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

private

Definition at line 1045 of file TrackingNtuple.cc.

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

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

private

Definition at line 1042 of file TrackingNtuple.cc.

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

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

private

Definition at line 1044 of file TrackingNtuple.cc.

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

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

private

Definition at line 1041 of file TrackingNtuple.cc.

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

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

private

Definition at line 1054 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_phi

private

Definition at line 1025 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_phiErr

private

Definition at line 1030 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_pt

private

Definition at line 1023 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_ptErr

private

Definition at line 1028 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_px

private

Definition at line 1020 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_py

private

Definition at line 1021 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_pz

private

Definition at line 1022 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::see_q

private

Definition at line 1040 of file TrackingNtuple.cc.

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

std::vector<std::vector<float> > TrackingNtuple::see_shareFrac

private

Definition at line 1049 of file TrackingNtuple.cc.

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

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

private

Definition at line 1050 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_statePt

private

Definition at line 1034 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_stateTrajPx

private

Definition at line 1037 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_stateTrajPy

private

Definition at line 1038 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_stateTrajPz

private

Definition at line 1039 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_stateTrajX

private

Definition at line 1035 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::see_stateTrajY

private

Definition at line 1036 of file TrackingNtuple.cc.

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

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

private

Definition at line 1047 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::see_trkIdx

private

Definition at line 1048 of file TrackingNtuple.cc.

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

std::vector<edm::EDGetTokenT<std::vector<short> > > TrackingNtuple::seedStopReasonTokens_

private

Definition at line 506 of file TrackingNtuple.cc.

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

private

Definition at line 505 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::sim_bunchCrossing

private

Definition at line 872 of file TrackingNtuple.cc.

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

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

private

Definition at line 900 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_eta

private

Definition at line 880 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::sim_event

private

Definition at line 871 of file TrackingNtuple.cc.

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

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

private

Definition at line 874 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::sim_isFromBHadron

private

Definition at line 875 of file TrackingNtuple.cc.

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

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

private

Definition at line 895 of file TrackingNtuple.cc.

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

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

private

Definition at line 893 of file TrackingNtuple.cc.

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

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

private

Definition at line 891 of file TrackingNtuple.cc.

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

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

private

Definition at line 894 of file TrackingNtuple.cc.

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

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

private

Definition at line 892 of file TrackingNtuple.cc.

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

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

private

Definition at line 890 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::sim_parentVtxIdx

private

Definition at line 899 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_cotTheta

private

Definition at line 885 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_dxy

private

Definition at line 887 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_dz

private

Definition at line 888 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_eta

private

Definition at line 883 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_lambda

private

Definition at line 884 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_phi

private

Definition at line 886 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pca_pt

private

Definition at line 882 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::sim_pdgId

private

Definition at line 873 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_phi

private

Definition at line 881 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pt

private

Definition at line 879 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_px

private

Definition at line 876 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_py

private

Definition at line 877 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::sim_pz

private

Definition at line 878 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::sim_q

private

Definition at line 889 of file TrackingNtuple.cc.

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

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

private

Definition at line 898 of file TrackingNtuple.cc.

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

std::vector<std::vector<float> > TrackingNtuple::sim_shareFrac

private

Definition at line 897 of file TrackingNtuple.cc.

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

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

private

Definition at line 901 of file TrackingNtuple.cc.

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

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

private

Definition at line 896 of file TrackingNtuple.cc.

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

DetIdAll TrackingNtuple::simhit_detId

private

Definition at line 995 of file TrackingNtuple.cc.

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

DetIdAllPhase2 TrackingNtuple::simhit_detId_phase2

private

Definition at line 996 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_eloss

private

Definition at line 1002 of file TrackingNtuple.cc.

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

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

private

Definition at line 1006 of file TrackingNtuple.cc.

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

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

private

Definition at line 1007 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::simhit_particle

private

Definition at line 1000 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::simhit_process

private

Definition at line 1001 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::simhit_simTrkIdx

private

Definition at line 1005 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_tof

private

Definition at line 1003 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_x

private

Definition at line 997 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_y

private

Definition at line 998 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_z

private

Definition at line 999 of file TrackingNtuple.cc.

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

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

private

Definition at line 511 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::simpv_idx

private

Definition at line 1083 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::simvtx_bunchCrossing

private

Definition at line 1076 of file TrackingNtuple.cc.

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

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

private

Definition at line 1082 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::simvtx_event

private

Definition at line 1075 of file TrackingNtuple.cc.

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

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

private

Definition at line 1077 of file TrackingNtuple.cc.

Referenced by fillTrackingVertices(), and TrackingNtuple().

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

private

Definition at line 1081 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simvtx_x

private

Definition at line 1078 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simvtx_y

private

Definition at line 1079 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simvtx_z

private

Definition at line 1080 of file TrackingNtuple.cc.

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

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

private

Definition at line 515 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::str_bbxi

private

Definition at line 943 of file TrackingNtuple.cc.

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

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

private

Definition at line 931 of file TrackingNtuple.cc.

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

DetIdStrip TrackingNtuple::str_detId

private

Definition at line 927 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::str_isBarrel

private

Definition at line 926 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_radL

private

Definition at line 942 of file TrackingNtuple.cc.

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

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

private

Definition at line 929 of file TrackingNtuple.cc.

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

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

private

Definition at line 930 of file TrackingNtuple.cc.

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

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

private

Definition at line 932 of file TrackingNtuple.cc.

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

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

private

Definition at line 928 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_x

private

Definition at line 933 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_xx

private

Definition at line 936 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_xy

private

Definition at line 937 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_y

private

Definition at line 934 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_yy

private

Definition at line 938 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_yz

private

Definition at line 939 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_z

private

Definition at line 935 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_zx

private

Definition at line 941 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_zz

private

Definition at line 940 of file TrackingNtuple.cc.

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

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> TrackingNtuple::stripMatchedRecHitToken_

private

Definition at line 521 of file TrackingNtuple.cc.

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripRphiRecHitToken_

private

Definition at line 519 of file TrackingNtuple.cc.

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

private

Definition at line 514 of file TrackingNtuple.cc.

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripStereoRecHitToken_

private

Definition at line 520 of file TrackingNtuple.cc.

TTree* TrackingNtuple::t

private

Definition at line 535 of file TrackingNtuple.cc.

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

private

Definition at line 525 of file TrackingNtuple.cc.

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

private

Definition at line 526 of file TrackingNtuple.cc.

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

private

Definition at line 527 of file TrackingNtuple.cc.

HistoryBase TrackingNtuple::tracer_

private

Definition at line 533 of file TrackingNtuple.cc.

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

private

Definition at line 512 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingParticleRefVector> TrackingNtuple::trackingParticleRefToken_

private

Definition at line 509 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingParticleCollection> TrackingNtuple::trackingParticleToken_

private

Definition at line 508 of file TrackingNtuple.cc.

edm::EDGetTokenT<TrackingVertexCollection> TrackingNtuple::trackingVertexToken_

private

Definition at line 524 of file TrackingNtuple.cc.

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

private

Definition at line 507 of file TrackingNtuple.cc.

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

private

Definition at line 857 of file TrackingNtuple.cc.

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

private

Definition at line 859 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::trk_cotTheta

private

Definition at line 833 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxy

private

Definition at line 835 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dxyErr

private

Definition at line 841 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dz

private

Definition at line 836 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_dzErr

private

Definition at line 842 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_eta

private

Definition at line 831 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_etaErr

private

Definition at line 838 of file TrackingNtuple.cc.

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

private

Definition at line 866 of file TrackingNtuple.cc.

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

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

private

Definition at line 867 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::trk_inner_pt

private

Definition at line 826 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_px

private

Definition at line 823 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_py

private

Definition at line 824 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_inner_pz

private

Definition at line 825 of file TrackingNtuple.cc.

std::vector<short> TrackingNtuple::trk_isHP

private

Definition at line 861 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::trk_lambda

private

Definition at line 832 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_lambdaErr

private

Definition at line 839 of file TrackingNtuple.cc.

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

private

Definition at line 854 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_nChi2

private

Definition at line 846 of file TrackingNtuple.cc.

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

private

Definition at line 856 of file TrackingNtuple.cc.

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

private

Definition at line 849 of file TrackingNtuple.cc.

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

private

Definition at line 855 of file TrackingNtuple.cc.

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

private

Definition at line 850 of file TrackingNtuple.cc.

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

private

Definition at line 852 of file TrackingNtuple.cc.

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

private

Definition at line 851 of file TrackingNtuple.cc.

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

private

Definition at line 853 of file TrackingNtuple.cc.

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

private

Definition at line 848 of file TrackingNtuple.cc.

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

private

Definition at line 858 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_pt

private

Definition at line 830 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_px

private

Definition at line 827 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_py

private

Definition at line 828 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_outer_pz

private

Definition at line 829 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_phi

private

Definition at line 834 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_phiErr

private

Definition at line 840 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_pt

private

Definition at line 822 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_ptErr

private

Definition at line 837 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_px

private

Definition at line 819 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_py

private

Definition at line 820 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_pz

private

Definition at line 821 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::trk_q

private

Definition at line 847 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_x

private

Definition at line 843 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_y

private

Definition at line 844 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::trk_refpoint_z

private

Definition at line 845 of file TrackingNtuple.cc.

std::vector<int> TrackingNtuple::trk_seedIdx

private

Definition at line 862 of file TrackingNtuple.cc.

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

std::vector<std::vector<float> > TrackingNtuple::trk_shareFrac

private

Definition at line 864 of file TrackingNtuple.cc.

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

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

private

Definition at line 865 of file TrackingNtuple.cc.

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

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

private

Definition at line 860 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::trk_vtxIdx

private

Definition at line 863 of file TrackingNtuple.cc.

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

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

private

Definition at line 523 of file TrackingNtuple.cc.

std::vector<float> TrackingNtuple::vtx_chi2

private

Definition at line 1067 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::vtx_fake

private

Definition at line 1068 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_ndof

private

Definition at line 1066 of file TrackingNtuple.cc.

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

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

private

Definition at line 1070 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::vtx_valid

private

Definition at line 1069 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_x

private

Definition at line 1060 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_xErr

private

Definition at line 1063 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_y

private

Definition at line 1061 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_yErr

private

Definition at line 1064 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_z

private

Definition at line 1062 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::vtx_zErr

private

Definition at line 1065 of file TrackingNtuple.cc.

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