CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Static Public Member Functions | Private Types | Private Member Functions | Static Private Member Functions | Private Attributes
TrackingNtuple Class Reference

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

Inheritance diagram for TrackingNtuple:
edm::one::EDAnalyzer< edm::one::SharedResources > edm::one::EDAnalyzerBase edm::EDConsumerBase

Classes

class  DetIdCommon
 
class  DetIdOTCommon
 
class  DetIdPhase2OTOnly
 
class  DetIdPixelOnly
 
class  DetIdStripOnly
 
struct  SimHitData
 
struct  TPHitIndex
 

Public Member Functions

 TrackingNtuple (const edm::ParameterSet &)
 
 ~TrackingNtuple () override
 
- Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
 EDAnalyzer ()=default
 
SerialTaskQueue * globalLuminosityBlocksQueue () final
 
SerialTaskQueue * globalRunsQueue () final
 
bool wantsGlobalLuminosityBlocks () const final
 
bool wantsGlobalRuns () const final
 
bool wantsInputProcessBlocks () const final
 
bool wantsProcessBlocks () const final
 
- Public Member Functions inherited from edm::one::EDAnalyzerBase
void callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
 
 EDAnalyzerBase ()
 
ModuleDescription const & moduleDescription () const
 
bool wantsStreamLuminosityBlocks () const
 
bool wantsStreamRuns () const
 
 ~EDAnalyzerBase () override
 
- Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo > consumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase &&)=default
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
std::vector< ESProxyIndex > const & esGetTokenIndicesVector (edm::Transition iTrans) const
 
std::vector< ESRecordIndex > const & esGetTokenRecordIndicesVector (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::array< std::vector< ModuleDescription const * > *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & operator= (EDConsumerBase &&)=default
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Static Public Member Functions

static void fillDescriptions (edm::ConfigurationDescriptions &descriptions)
 
- Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string & baseType ()
 
static void fillDescriptions (ConfigurationDescriptions &descriptions)
 
static void prevalidate (ConfigurationDescriptions &descriptions)
 

Private Types

using DetIdAll = CombineDetId< DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdStripOnly >
 
using DetIdAllPhase2 = CombineDetId< DetIdCommon, DetIdPixelOnly, DetIdOTCommon, DetIdPhase2OTOnly >
 
using DetIdPhase2OT = CombineDetId< DetIdCommon, DetIdOTCommon, DetIdPhase2OTOnly >
 
using DetIdPixel = CombineDetId< DetIdCommon, DetIdPixelOnly >
 
using DetIdStrip = CombineDetId< DetIdCommon, DetIdOTCommon, DetIdStripOnly >
 
enum  HitSimType {
  HitSimType::Signal = 0, HitSimType::ITPileup = 1, HitSimType::OOTPileup = 2, HitSimType::Noise = 3,
  HitSimType::Unknown = 99
}
 
enum  HitType {
  HitType::Pixel = 0, HitType::Strip = 1, HitType::Glued = 2, HitType::Invalid = 3,
  HitType::Phase2OT = 4, HitType::Unknown = 99
}
 
using MVACollection = std::vector< float >
 
using QualityMaskCollection = std::vector< unsigned char >
 

Private Member Functions

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

Static Private Member Functions

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

Private Attributes

edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
 
float bsp_sigmax
 
float bsp_sigmay
 
float bsp_sigmaz
 
float bsp_x
 
float bsp_y
 
float bsp_z
 
edm::EDGetTokenT< ClusterTPAssociation > clusterTPMapToken_
 
edm::EventNumber_t ev_event
 
edm::LuminosityBlockNumber_t ev_lumi
 
edm::RunNumber_t ev_run
 
std::vector< float > glu_bbxi
 
DetIdStrip glu_detId
 
std::vector< short > glu_isBarrel
 
std::vector< int > glu_monoIdx
 
std::vector< float > glu_radL
 
std::vector< std::vector< int > > glu_seeIdx
 
std::vector< int > glu_stereoIdx
 
std::vector< float > glu_x
 
std::vector< float > glu_xx
 
std::vector< float > glu_xy
 
std::vector< float > glu_y
 
std::vector< float > glu_yy
 
std::vector< float > glu_yz
 
std::vector< float > glu_z
 
std::vector< float > glu_zx
 
std::vector< float > glu_zz
 
const bool includeAllHits_
 
const bool includeMVA_
 
bool includePhase2OTHits_
 
const bool includeSeeds_
 
bool includeStripHits_
 
const bool includeTrackingParticles_
 
DetIdAll inv_detId
 
DetIdAllPhase2 inv_detId_phase2
 
std::vector< short > inv_isBarrel
 
std::vector< unsigned short > inv_type
 
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > mfToken_
 
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityCollectionTokens_
 
const edm::ESGetToken< ParametersDefinerForTP, TrackAssociatorRecord > paramsDefineToken_
 
std::vector< float > ph2_bbxi
 
DetIdPhase2OT ph2_detId
 
std::vector< short > ph2_isBarrel
 
std::vector< float > ph2_radL
 
std::vector< std::vector< int > > ph2_seeIdx
 
std::vector< std::vector< int > > ph2_simHitIdx
 
std::vector< unsigned short > ph2_simType
 
std::vector< std::vector< int > > ph2_trkIdx
 
std::vector< float > ph2_x
 
std::vector< float > ph2_xx
 
std::vector< float > ph2_xy
 
std::vector< float > ph2_y
 
std::vector< float > ph2_yy
 
std::vector< float > ph2_yz
 
std::vector< float > ph2_z
 
std::vector< float > ph2_zx
 
std::vector< float > ph2_zz
 
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew > phase2OTRecHitToken_
 
std::vector< float > pix_bbxi
 
std::vector< std::vector< float > > pix_chargeFraction
 
DetIdPixel pix_detId
 
std::vector< short > pix_isBarrel
 
std::vector< float > pix_radL
 
std::vector< std::vector< int > > pix_seeIdx
 
std::vector< std::vector< int > > pix_simHitIdx
 
std::vector< unsigned short > pix_simType
 
std::vector< std::vector< int > > pix_trkIdx
 
std::vector< float > pix_x
 
std::vector< float > pix_xx
 
std::vector< float > pix_xy
 
std::vector< float > pix_y
 
std::vector< float > pix_yy
 
std::vector< float > pix_yz
 
std::vector< float > pix_z
 
std::vector< float > pix_zx
 
std::vector< float > pix_zz
 
edm::EDGetTokenT< SiPixelRecHitCollection > pixelRecHitToken_
 
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinkToken_
 
std::vector< unsigned int > see_algo
 
std::vector< int > see_bestFromFirstHitSimTrkIdx
 
std::vector< float > see_bestFromFirstHitSimTrkShareFrac
 
std::vector< int > see_bestSimTrkIdx
 
std::vector< float > see_bestSimTrkShareFrac
 
std::vector< float > see_chi2
 
std::vector< float > see_dxy
 
std::vector< float > see_dxyErr
 
std::vector< float > see_dz
 
std::vector< float > see_dzErr
 
std::vector< float > see_eta
 
std::vector< float > see_etaErr
 
std::vector< short > see_fitok
 
std::vector< std::vector< int > > see_hitIdx
 
std::vector< std::vector< int > > see_hitType
 
std::vector< short > see_isTrue
 
std::vector< unsigned short > see_nCands
 
std::vector< unsigned int > see_nCluster
 
std::vector< unsigned int > see_nGlued
 
std::vector< unsigned int > see_nPhase2OT
 
std::vector< unsigned int > see_nPixel
 
std::vector< unsigned int > see_nStrip
 
std::vector< unsigned int > see_nValid
 
std::vector< unsigned int > see_offset
 
std::vector< float > see_phi
 
std::vector< float > see_phiErr
 
std::vector< float > see_pt
 
std::vector< float > see_ptErr
 
std::vector< float > see_px
 
std::vector< float > see_py
 
std::vector< float > see_pz
 
std::vector< int > see_q
 
std::vector< std::vector< int > > see_simTrkIdx
 
std::vector< std::vector< float > > see_simTrkShareFrac
 
std::vector< float > see_statePt
 
std::vector< float > see_stateTrajPx
 
std::vector< float > see_stateTrajPy
 
std::vector< float > see_stateTrajPz
 
std::vector< float > see_stateTrajX
 
std::vector< float > see_stateTrajY
 
std::vector< unsigned short > see_stopReason
 
std::vector< int > see_trkIdx
 
std::vector< edm::EDGetTokenT< std::vector< SeedStopInfo > > > seedStopInfoTokens_
 
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > seedTokens_
 
std::vector< int > sim_bunchCrossing
 
std::vector< std::vector< int > > sim_decayVtxIdx
 
std::vector< float > sim_eta
 
std::vector< int > sim_event
 
std::vector< std::vector< int > > sim_genPdgIds
 
std::vector< int > sim_isFromBHadron
 
std::vector< unsigned int > sim_n3DLay
 
std::vector< unsigned int > sim_nLay
 
std::vector< unsigned int > sim_nPixel
 
std::vector< unsigned int > sim_nPixelLay
 
std::vector< unsigned int > sim_nRecoClusters
 
std::vector< unsigned int > sim_nStrip
 
std::vector< unsigned int > sim_nTrackerHits
 
std::vector< unsigned int > sim_nValid
 
std::vector< int > sim_parentVtxIdx
 
std::vector< float > sim_pca_cotTheta
 
std::vector< float > sim_pca_dxy
 
std::vector< float > sim_pca_dz
 
std::vector< float > sim_pca_eta
 
std::vector< float > sim_pca_lambda
 
std::vector< float > sim_pca_phi
 
std::vector< float > sim_pca_pt
 
std::vector< int > sim_pdgId
 
std::vector< float > sim_phi
 
std::vector< float > sim_pt
 
std::vector< float > sim_px
 
std::vector< float > sim_py
 
std::vector< float > sim_pz
 
std::vector< int > sim_q
 
std::vector< std::vector< int > > sim_seedIdx
 
std::vector< std::vector< int > > sim_simHitIdx
 
std::vector< std::vector< int > > sim_trkIdx
 
std::vector< std::vector< float > > sim_trkShareFrac
 
DetIdAll simhit_detId
 
DetIdAllPhase2 simhit_detId_phase2
 
std::vector< float > simhit_eloss
 
std::vector< std::vector< int > > simhit_hitIdx
 
std::vector< std::vector< int > > simhit_hitType
 
std::vector< int > simhit_particle
 
std::vector< short > simhit_process
 
std::vector< int > simhit_simTrkIdx
 
std::vector< float > simhit_tof
 
std::vector< float > simhit_x
 
std::vector< float > simhit_y
 
std::vector< float > simhit_z
 
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > simHitTPMapToken_
 
std::vector< int > simpv_idx
 
std::vector< int > simvtx_bunchCrossing
 
std::vector< std::vector< int > > simvtx_daughterSimIdx
 
std::vector< int > simvtx_event
 
std::vector< unsigned int > simvtx_processType
 
std::vector< std::vector< int > > simvtx_sourceSimIdx
 
std::vector< float > simvtx_x
 
std::vector< float > simvtx_y
 
std::vector< float > simvtx_z
 
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > siphase2OTSimLinksToken_
 
std::vector< float > str_bbxi
 
std::vector< std::vector< float > > str_chargeFraction
 
DetIdStrip str_detId
 
std::vector< short > str_isBarrel
 
std::vector< float > str_radL
 
std::vector< std::vector< int > > str_seeIdx
 
std::vector< std::vector< int > > str_simHitIdx
 
std::vector< unsigned short > str_simType
 
std::vector< std::vector< int > > str_trkIdx
 
std::vector< float > str_x
 
std::vector< float > str_xx
 
std::vector< float > str_xy
 
std::vector< float > str_y
 
std::vector< float > str_yy
 
std::vector< float > str_yz
 
std::vector< float > str_z
 
std::vector< float > str_zx
 
std::vector< float > str_zz
 
edm::EDGetTokenT< SiStripMatchedRecHit2DCollection > stripMatchedRecHitToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollection > stripRphiRecHitToken_
 
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > > stripSimLinkToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollection > stripStereoRecHitToken_
 
TTree * t
 
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > tGeomToken_
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNLayersToken_
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNPixelLayersToken_
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNStripStereoLayersToken_
 
HistoryBase tracer_
 
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociatorToken_
 
edm::EDGetTokenT< TrackingParticleRefVector > trackingParticleRefToken_
 
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleToken_
 
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexToken_
 
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
 
std::vector< unsigned int > trk_algo
 
std::vector< decltype(reco::TrackBase().algoMaskUL())> trk_algoMask
 
std::vector< int > trk_bestFromFirstHitSimTrkIdx
 
std::vector< float > trk_bestFromFirstHitSimTrkNChi2
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFrac
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimDenom
 
std::vector< int > trk_bestSimTrkIdx
 
std::vector< float > trk_bestSimTrkNChi2
 
std::vector< float > trk_bestSimTrkShareFrac
 
std::vector< float > trk_bestSimTrkShareFracSimClusterDenom
 
std::vector< float > trk_bestSimTrkShareFracSimDenom
 
std::vector< float > trk_cotTheta
 
std::vector< float > trk_dxy
 
std::vector< float > trk_dxyClosestPV
 
std::vector< float > trk_dxyErr
 
std::vector< float > trk_dxyPV
 
std::vector< float > trk_dz
 
std::vector< float > trk_dzClosestPV
 
std::vector< float > trk_dzErr
 
std::vector< float > trk_dzPV
 
std::vector< float > trk_eta
 
std::vector< float > trk_etaErr
 
std::vector< std::vector< int > > trk_hitIdx
 
std::vector< std::vector< int > > trk_hitType
 
std::vector< float > trk_inner_pt
 
std::vector< float > trk_inner_px
 
std::vector< float > trk_inner_py
 
std::vector< float > trk_inner_pz
 
std::vector< short > trk_isHP
 
std::vector< short > trk_isTrue
 
std::vector< float > trk_lambda
 
std::vector< float > trk_lambdaErr
 
std::vector< std::vector< float > > trk_mvas
 
std::vector< unsigned int > trk_n3DLay
 
std::vector< float > trk_nChi2
 
std::vector< float > trk_nChi2_1Dmod
 
std::vector< unsigned int > trk_nCluster
 
std::vector< float > trk_ndof
 
std::vector< unsigned int > trk_nInactive
 
std::vector< unsigned int > trk_nInnerInactive
 
std::vector< unsigned int > trk_nInnerLost
 
std::vector< unsigned int > trk_nLost
 
std::vector< unsigned int > trk_nLostLay
 
std::vector< unsigned int > trk_nOuterInactive
 
std::vector< unsigned int > trk_nOuterLost
 
std::vector< unsigned int > trk_nPixel
 
std::vector< unsigned int > trk_nPixelLay
 
std::vector< unsigned int > trk_nStrip
 
std::vector< unsigned int > trk_nStripLay
 
std::vector< unsigned int > trk_nValid
 
std::vector< unsigned int > trk_originalAlgo
 
std::vector< float > trk_outer_pt
 
std::vector< float > trk_outer_px
 
std::vector< float > trk_outer_py
 
std::vector< float > trk_outer_pz
 
std::vector< float > trk_phi
 
std::vector< float > trk_phiErr
 
std::vector< float > trk_pt
 
std::vector< float > trk_ptErr
 
std::vector< float > trk_px
 
std::vector< float > trk_py
 
std::vector< float > trk_pz
 
std::vector< int > trk_q
 
std::vector< std::vector< unsigned short > > trk_qualityMasks
 
std::vector< float > trk_refpoint_x
 
std::vector< float > trk_refpoint_y
 
std::vector< float > trk_refpoint_z
 
std::vector< int > trk_seedIdx
 
std::vector< std::vector< int > > trk_simTrkIdx
 
std::vector< std::vector< float > > trk_simTrkNChi2
 
std::vector< std::vector< float > > trk_simTrkShareFrac
 
std::vector< unsigned short > trk_stopReason
 
std::vector< int > trk_vtxIdx
 
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > tTopoToken_
 
const edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > ttrhToken_
 
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
EDGetToken consumes (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > consumes (edm::InputTag const &tag)
 
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B > consumes (edm::InputTag tag) noexcept
 
template<BranchType B>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<Transition Tr = Transition::Event>
constexpr auto esConsumes () noexcept
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
template<Transition Tr = Transition::Event>
auto esConsumes (ESInputTag tag) noexcept
 
template<Transition Tr = Transition::Event>
ESGetTokenGeneric esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
 Used with EventSetupRecord::doGet. More...
 
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<BranchType B>
EDGetToken mayConsume (const TypeToGet &id, edm::InputTag const &tag)
 
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType > mayConsume (edm::InputTag const &tag)
 

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 469 of file TrackingNtuple.cc.

Member Typedef Documentation

◆ DetIdAll

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

Definition at line 939 of file TrackingNtuple.cc.

◆ DetIdAllPhase2

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

Definition at line 940 of file TrackingNtuple.cc.

◆ DetIdPhase2OT

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

Definition at line 938 of file TrackingNtuple.cc.

◆ DetIdPixel

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

Definition at line 936 of file TrackingNtuple.cc.

◆ DetIdStrip

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

Definition at line 937 of file TrackingNtuple.cc.

◆ MVACollection

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

Definition at line 489 of file TrackingNtuple.cc.

◆ QualityMaskCollection

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

Definition at line 490 of file TrackingNtuple.cc.

Member Enumeration Documentation

◆ HitSimType

enum TrackingNtuple::HitSimType
strongprivate
Enumerator
Signal 
ITPileup 
OOTPileup 
Noise 
Unknown 

Definition at line 487 of file TrackingNtuple.cc.

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

◆ HitType

enum TrackingNtuple::HitType
strongprivate
Enumerator
Pixel 
Strip 
Glued 
Invalid 
Phase2OT 
Unknown 

Definition at line 481 of file TrackingNtuple.cc.

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

Constructor & Destructor Documentation

◆ TrackingNtuple()

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

Definition at line 1261 of file TrackingNtuple.cc.

1262  : mfToken_(esConsumes()),
1263  ttrhToken_(esConsumes(edm::ESInputTag("", iConfig.getUntrackedParameter<std::string>("TTRHBuilder")))),
1264  tTopoToken_(esConsumes()),
1265  tGeomToken_(esConsumes()),
1266  paramsDefineToken_(
1267  esConsumes(edm::ESInputTag("", iConfig.getUntrackedParameter<std::string>("parametersDefiner")))),
1268  trackToken_(consumes<edm::View<reco::Track>>(iConfig.getUntrackedParameter<edm::InputTag>("tracks"))),
1269  clusterTPMapToken_(consumes<ClusterTPAssociation>(iConfig.getUntrackedParameter<edm::InputTag>("clusterTPMap"))),
1270  simHitTPMapToken_(consumes<SimHitTPAssociationProducer::SimHitTPAssociationList>(
1271  iConfig.getUntrackedParameter<edm::InputTag>("simHitTPMap"))),
1272  trackAssociatorToken_(consumes<reco::TrackToTrackingParticleAssociator>(
1273  iConfig.getUntrackedParameter<edm::InputTag>("trackAssociator"))),
1274  pixelSimLinkToken_(consumes<edm::DetSetVector<PixelDigiSimLink>>(
1275  iConfig.getUntrackedParameter<edm::InputTag>("pixelDigiSimLink"))),
1276  stripSimLinkToken_(consumes<edm::DetSetVector<StripDigiSimLink>>(
1277  iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink"))),
1278  siphase2OTSimLinksToken_(consumes<edm::DetSetVector<PixelDigiSimLink>>(
1279  iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink"))),
1280  includeStripHits_(!iConfig.getUntrackedParameter<edm::InputTag>("stripDigiSimLink").label().empty()),
1281  includePhase2OTHits_(!iConfig.getUntrackedParameter<edm::InputTag>("phase2OTSimLink").label().empty()),
1282  beamSpotToken_(consumes<reco::BeamSpot>(iConfig.getUntrackedParameter<edm::InputTag>("beamSpot"))),
1283  pixelRecHitToken_(
1284  consumes<SiPixelRecHitCollection>(iConfig.getUntrackedParameter<edm::InputTag>("pixelRecHits"))),
1285  stripRphiRecHitToken_(
1286  consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripRphiRecHits"))),
1287  stripStereoRecHitToken_(
1288  consumes<SiStripRecHit2DCollection>(iConfig.getUntrackedParameter<edm::InputTag>("stripStereoRecHits"))),
1289  stripMatchedRecHitToken_(consumes<SiStripMatchedRecHit2DCollection>(
1290  iConfig.getUntrackedParameter<edm::InputTag>("stripMatchedRecHits"))),
1291  phase2OTRecHitToken_(consumes<Phase2TrackerRecHit1DCollectionNew>(
1292  iConfig.getUntrackedParameter<edm::InputTag>("phase2OTRecHits"))),
1293  vertexToken_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertices"))),
1294  trackingVertexToken_(
1295  consumes<TrackingVertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackingVertices"))),
1296  tpNLayersToken_(consumes<edm::ValueMap<unsigned int>>(
1297  iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNlayers"))),
1298  tpNPixelLayersToken_(consumes<edm::ValueMap<unsigned int>>(
1299  iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNpixellayers"))),
1300  tpNStripStereoLayersToken_(consumes<edm::ValueMap<unsigned int>>(
1301  iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleNstripstereolayers"))),
1302  includeSeeds_(iConfig.getUntrackedParameter<bool>("includeSeeds")),
1303  includeAllHits_(iConfig.getUntrackedParameter<bool>("includeAllHits")),
1304  includeMVA_(iConfig.getUntrackedParameter<bool>("includeMVA")),
1305  includeTrackingParticles_(iConfig.getUntrackedParameter<bool>("includeTrackingParticles")) {
1306  if (includeSeeds_) {
1307  seedTokens_ =
1308  edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("seedTracks"),
1309  [&](const edm::InputTag& tag) { return consumes<edm::View<reco::Track>>(tag); });
1310  seedStopInfoTokens_ =
1311  edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag>>("trackCandidates"),
1312  [&](const edm::InputTag& tag) { return consumes<std::vector<SeedStopInfo>>(tag); });
1313  if (seedTokens_.size() != seedStopInfoTokens_.size()) {
1314  throw cms::Exception("Configuration") << "Got " << seedTokens_.size() << " seed collections, but "
1315  << seedStopInfoTokens_.size() << " track candidate collections";
1316  }
1317  }
1318 
1319  if (includeAllHits_) {
1320  if (includeStripHits_ && includePhase2OTHits_) {
1321  throw cms::Exception("Configuration")
1322  << "Both stripDigiSimLink and phase2OTSimLink are set, please set only either one (this information is used "
1323  "to infer if you're running phase0/1 or phase2 detector)";
1324  }
1325  if (!includeStripHits_ && !includePhase2OTHits_) {
1326  throw cms::Exception("Configuration")
1327  << "Neither stripDigiSimLink or phase2OTSimLink are set, please set either one.";
1328  }
1329  }
1330 
1331  const bool tpRef = iConfig.getUntrackedParameter<bool>("trackingParticlesRef");
1332  const auto tpTag = iConfig.getUntrackedParameter<edm::InputTag>("trackingParticles");
1333  if (tpRef) {
1334  trackingParticleRefToken_ = consumes<TrackingParticleRefVector>(tpTag);
1335  } else {
1336  trackingParticleToken_ = consumes<TrackingParticleCollection>(tpTag);
1337  }
1338 
1339  tracer_.depth(-2); // as in SimTracker/TrackHistory/src/TrackClassifier.cc
1340 
1341  if (includeMVA_) {
1342  mvaQualityCollectionTokens_ = edm::vector_transform(
1343  iConfig.getUntrackedParameter<std::vector<std::string>>("trackMVAs"), [&](const std::string& tag) {
1344  return std::make_tuple(consumes<MVACollection>(edm::InputTag(tag, "MVAValues")),
1345  consumes<QualityMaskCollection>(edm::InputTag(tag, "QualityMasks")));
1346  });
1347  }
1348 
1349  usesResource(TFileService::kSharedResource);
1350  edm::Service<TFileService> fs;
1351  t = fs->make<TTree>("tree", "tree");
1352 
1353  t->Branch("event", &ev_event);
1354  t->Branch("lumi", &ev_lumi);
1355  t->Branch("run", &ev_run);
1356 
1357  //tracks
1358  t->Branch("trk_px", &trk_px);
1359  t->Branch("trk_py", &trk_py);
1360  t->Branch("trk_pz", &trk_pz);
1361  t->Branch("trk_pt", &trk_pt);
1362  t->Branch("trk_inner_px", &trk_inner_px);
1363  t->Branch("trk_inner_py", &trk_inner_py);
1364  t->Branch("trk_inner_pz", &trk_inner_pz);
1365  t->Branch("trk_inner_pt", &trk_inner_pt);
1366  t->Branch("trk_outer_px", &trk_outer_px);
1367  t->Branch("trk_outer_py", &trk_outer_py);
1368  t->Branch("trk_outer_pz", &trk_outer_pz);
1369  t->Branch("trk_outer_pt", &trk_outer_pt);
1370  t->Branch("trk_eta", &trk_eta);
1371  t->Branch("trk_lambda", &trk_lambda);
1372  t->Branch("trk_cotTheta", &trk_cotTheta);
1373  t->Branch("trk_phi", &trk_phi);
1374  t->Branch("trk_dxy", &trk_dxy);
1375  t->Branch("trk_dz", &trk_dz);
1376  t->Branch("trk_dxyPV", &trk_dxyPV);
1377  t->Branch("trk_dzPV", &trk_dzPV);
1378  t->Branch("trk_dxyClosestPV", &trk_dxyClosestPV);
1379  t->Branch("trk_dzClosestPV", &trk_dzClosestPV);
1380  t->Branch("trk_ptErr", &trk_ptErr);
1381  t->Branch("trk_etaErr", &trk_etaErr);
1382  t->Branch("trk_lambdaErr", &trk_lambdaErr);
1383  t->Branch("trk_phiErr", &trk_phiErr);
1384  t->Branch("trk_dxyErr", &trk_dxyErr);
1385  t->Branch("trk_dzErr", &trk_dzErr);
1386  t->Branch("trk_refpoint_x", &trk_refpoint_x);
1387  t->Branch("trk_refpoint_y", &trk_refpoint_y);
1388  t->Branch("trk_refpoint_z", &trk_refpoint_z);
1389  t->Branch("trk_nChi2", &trk_nChi2);
1390  t->Branch("trk_nChi2_1Dmod", &trk_nChi2_1Dmod);
1391  t->Branch("trk_ndof", &trk_ndof);
1392  if (includeMVA_) {
1393  trk_mvas.resize(mvaQualityCollectionTokens_.size());
1394  trk_qualityMasks.resize(mvaQualityCollectionTokens_.size());
1395  if (!trk_mvas.empty()) {
1396  t->Branch("trk_mva", &(trk_mvas[0]));
1397  t->Branch("trk_qualityMask", &(trk_qualityMasks[0]));
1398  for (size_t i = 1; i < trk_mvas.size(); ++i) {
1399  t->Branch(("trk_mva" + std::to_string(i + 1)).c_str(), &(trk_mvas[i]));
1400  t->Branch(("trk_qualityMask" + std::to_string(i + 1)).c_str(), &(trk_qualityMasks[i]));
1401  }
1402  }
1403  }
1404  t->Branch("trk_q", &trk_q);
1405  t->Branch("trk_nValid", &trk_nValid);
1406  t->Branch("trk_nLost", &trk_nLost);
1407  t->Branch("trk_nInactive", &trk_nInactive);
1408  t->Branch("trk_nPixel", &trk_nPixel);
1409  t->Branch("trk_nStrip", &trk_nStrip);
1410  t->Branch("trk_nOuterLost", &trk_nOuterLost);
1411  t->Branch("trk_nInnerLost", &trk_nInnerLost);
1412  t->Branch("trk_nOuterInactive", &trk_nOuterInactive);
1413  t->Branch("trk_nInnerInactive", &trk_nInnerInactive);
1414  t->Branch("trk_nPixelLay", &trk_nPixelLay);
1415  t->Branch("trk_nStripLay", &trk_nStripLay);
1416  t->Branch("trk_n3DLay", &trk_n3DLay);
1417  t->Branch("trk_nLostLay", &trk_nLostLay);
1418  t->Branch("trk_nCluster", &trk_nCluster);
1419  t->Branch("trk_algo", &trk_algo);
1420  t->Branch("trk_originalAlgo", &trk_originalAlgo);
1421  t->Branch("trk_algoMask", &trk_algoMask);
1422  t->Branch("trk_stopReason", &trk_stopReason);
1423  t->Branch("trk_isHP", &trk_isHP);
1424  if (includeSeeds_) {
1425  t->Branch("trk_seedIdx", &trk_seedIdx);
1426  }
1427  t->Branch("trk_vtxIdx", &trk_vtxIdx);
1428  if (includeTrackingParticles_) {
1429  t->Branch("trk_simTrkIdx", &trk_simTrkIdx);
1430  t->Branch("trk_simTrkShareFrac", &trk_simTrkShareFrac);
1431  t->Branch("trk_simTrkNChi2", &trk_simTrkNChi2);
1432  t->Branch("trk_bestSimTrkIdx", &trk_bestSimTrkIdx);
1433  t->Branch("trk_bestFromFirstHitSimTrkIdx", &trk_bestFromFirstHitSimTrkIdx);
1434  } else {
1435  t->Branch("trk_isTrue", &trk_isTrue);
1436  }
1437  t->Branch("trk_bestSimTrkShareFrac", &trk_bestSimTrkShareFrac);
1438  t->Branch("trk_bestSimTrkShareFracSimDenom", &trk_bestSimTrkShareFracSimDenom);
1439  t->Branch("trk_bestSimTrkShareFracSimClusterDenom", &trk_bestSimTrkShareFracSimClusterDenom);
1440  t->Branch("trk_bestSimTrkNChi2", &trk_bestSimTrkNChi2);
1441  t->Branch("trk_bestFromFirstHitSimTrkShareFrac", &trk_bestFromFirstHitSimTrkShareFrac);
1442  t->Branch("trk_bestFromFirstHitSimTrkShareFracSimDenom", &trk_bestFromFirstHitSimTrkShareFracSimDenom);
1443  t->Branch("trk_bestFromFirstHitSimTrkShareFracSimClusterDenom", &trk_bestFromFirstHitSimTrkShareFracSimClusterDenom);
1444  t->Branch("trk_bestFromFirstHitSimTrkNChi2", &trk_bestFromFirstHitSimTrkNChi2);
1445  if (includeAllHits_) {
1446  t->Branch("trk_hitIdx", &trk_hitIdx);
1447  t->Branch("trk_hitType", &trk_hitType);
1448  }
1449  if (includeTrackingParticles_) {
1450  //sim tracks
1451  t->Branch("sim_event", &sim_event);
1452  t->Branch("sim_bunchCrossing", &sim_bunchCrossing);
1453  t->Branch("sim_pdgId", &sim_pdgId);
1454  t->Branch("sim_genPdgIds", &sim_genPdgIds);
1455  t->Branch("sim_isFromBHadron", &sim_isFromBHadron);
1456  t->Branch("sim_px", &sim_px);
1457  t->Branch("sim_py", &sim_py);
1458  t->Branch("sim_pz", &sim_pz);
1459  t->Branch("sim_pt", &sim_pt);
1460  t->Branch("sim_eta", &sim_eta);
1461  t->Branch("sim_phi", &sim_phi);
1462  t->Branch("sim_pca_pt", &sim_pca_pt);
1463  t->Branch("sim_pca_eta", &sim_pca_eta);
1464  t->Branch("sim_pca_lambda", &sim_pca_lambda);
1465  t->Branch("sim_pca_cotTheta", &sim_pca_cotTheta);
1466  t->Branch("sim_pca_phi", &sim_pca_phi);
1467  t->Branch("sim_pca_dxy", &sim_pca_dxy);
1468  t->Branch("sim_pca_dz", &sim_pca_dz);
1469  t->Branch("sim_q", &sim_q);
1470  t->Branch("sim_nValid", &sim_nValid);
1471  t->Branch("sim_nPixel", &sim_nPixel);
1472  t->Branch("sim_nStrip", &sim_nStrip);
1473  t->Branch("sim_nLay", &sim_nLay);
1474  t->Branch("sim_nPixelLay", &sim_nPixelLay);
1475  t->Branch("sim_n3DLay", &sim_n3DLay);
1476  t->Branch("sim_nTrackerHits", &sim_nTrackerHits);
1477  t->Branch("sim_nRecoClusters", &sim_nRecoClusters);
1478  t->Branch("sim_trkIdx", &sim_trkIdx);
1479  t->Branch("sim_trkShareFrac", &sim_trkShareFrac);
1480  if (includeSeeds_) {
1481  t->Branch("sim_seedIdx", &sim_seedIdx);
1482  }
1483  t->Branch("sim_parentVtxIdx", &sim_parentVtxIdx);
1484  t->Branch("sim_decayVtxIdx", &sim_decayVtxIdx);
1485  if (includeAllHits_) {
1486  t->Branch("sim_simHitIdx", &sim_simHitIdx);
1487  }
1488  }
1489  if (includeAllHits_) {
1490  //pixels
1491  t->Branch("pix_isBarrel", &pix_isBarrel);
1492  pix_detId.book("pix", t);
1493  t->Branch("pix_trkIdx", &pix_trkIdx);
1494  if (includeSeeds_) {
1495  t->Branch("pix_seeIdx", &pix_seeIdx);
1496  }
1497  if (includeTrackingParticles_) {
1498  t->Branch("pix_simHitIdx", &pix_simHitIdx);
1499  t->Branch("pix_chargeFraction", &pix_chargeFraction);
1500  t->Branch("pix_simType", &pix_simType);
1501  }
1502  t->Branch("pix_x", &pix_x);
1503  t->Branch("pix_y", &pix_y);
1504  t->Branch("pix_z", &pix_z);
1505  t->Branch("pix_xx", &pix_xx);
1506  t->Branch("pix_xy", &pix_xy);
1507  t->Branch("pix_yy", &pix_yy);
1508  t->Branch("pix_yz", &pix_yz);
1509  t->Branch("pix_zz", &pix_zz);
1510  t->Branch("pix_zx", &pix_zx);
1511  t->Branch("pix_radL", &pix_radL);
1512  t->Branch("pix_bbxi", &pix_bbxi);
1513  t->Branch("pix_bbxi", &pix_bbxi);
1514  //strips
1515  if (includeStripHits_) {
1516  t->Branch("str_isBarrel", &str_isBarrel);
1517  str_detId.book("str", t);
1518  t->Branch("str_trkIdx", &str_trkIdx);
1519  if (includeSeeds_) {
1520  t->Branch("str_seeIdx", &str_seeIdx);
1521  }
1522  if (includeTrackingParticles_) {
1523  t->Branch("str_simHitIdx", &str_simHitIdx);
1524  t->Branch("str_chargeFraction", &str_chargeFraction);
1525  t->Branch("str_simType", &str_simType);
1526  }
1527  t->Branch("str_x", &str_x);
1528  t->Branch("str_y", &str_y);
1529  t->Branch("str_z", &str_z);
1530  t->Branch("str_xx", &str_xx);
1531  t->Branch("str_xy", &str_xy);
1532  t->Branch("str_yy", &str_yy);
1533  t->Branch("str_yz", &str_yz);
1534  t->Branch("str_zz", &str_zz);
1535  t->Branch("str_zx", &str_zx);
1536  t->Branch("str_radL", &str_radL);
1537  t->Branch("str_bbxi", &str_bbxi);
1538  //matched hits
1539  t->Branch("glu_isBarrel", &glu_isBarrel);
1540  glu_detId.book("glu", t);
1541  t->Branch("glu_monoIdx", &glu_monoIdx);
1542  t->Branch("glu_stereoIdx", &glu_stereoIdx);
1543  if (includeSeeds_) {
1544  t->Branch("glu_seeIdx", &glu_seeIdx);
1545  }
1546  t->Branch("glu_x", &glu_x);
1547  t->Branch("glu_y", &glu_y);
1548  t->Branch("glu_z", &glu_z);
1549  t->Branch("glu_xx", &glu_xx);
1550  t->Branch("glu_xy", &glu_xy);
1551  t->Branch("glu_yy", &glu_yy);
1552  t->Branch("glu_yz", &glu_yz);
1553  t->Branch("glu_zz", &glu_zz);
1554  t->Branch("glu_zx", &glu_zx);
1555  t->Branch("glu_radL", &glu_radL);
1556  t->Branch("glu_bbxi", &glu_bbxi);
1557  }
1558  //phase2 OT
1559  if (includePhase2OTHits_) {
1560  t->Branch("ph2_isBarrel", &ph2_isBarrel);
1561  ph2_detId.book("ph2", t);
1562  t->Branch("ph2_trkIdx", &ph2_trkIdx);
1563  if (includeSeeds_) {
1564  t->Branch("ph2_seeIdx", &ph2_seeIdx);
1565  }
1566  if (includeTrackingParticles_) {
1567  t->Branch("ph2_simHitIdx", &ph2_simHitIdx);
1568  t->Branch("ph2_simType", &ph2_simType);
1569  }
1570  t->Branch("ph2_x", &ph2_x);
1571  t->Branch("ph2_y", &ph2_y);
1572  t->Branch("ph2_z", &ph2_z);
1573  t->Branch("ph2_xx", &ph2_xx);
1574  t->Branch("ph2_xy", &ph2_xy);
1575  t->Branch("ph2_yy", &ph2_yy);
1576  t->Branch("ph2_yz", &ph2_yz);
1577  t->Branch("ph2_zz", &ph2_zz);
1578  t->Branch("ph2_zx", &ph2_zx);
1579  t->Branch("ph2_radL", &ph2_radL);
1580  t->Branch("ph2_bbxi", &ph2_bbxi);
1581  t->Branch("ph2_bbxi", &ph2_bbxi);
1582  }
1583  //invalid hits
1584  t->Branch("inv_isBarrel", &inv_isBarrel);
1585  if (includeStripHits_)
1586  inv_detId.book("inv", t);
1587  else
1588  inv_detId_phase2.book("inv", t);
1589  t->Branch("inv_type", &inv_type);
1590  //simhits
1591  if (includeTrackingParticles_) {
1592  if (includeStripHits_)
1593  simhit_detId.book("simhit", t);
1594  else
1595  simhit_detId_phase2.book("simhit", t);
1596  t->Branch("simhit_x", &simhit_x);
1597  t->Branch("simhit_y", &simhit_y);
1598  t->Branch("simhit_z", &simhit_z);
1599  t->Branch("simhit_particle", &simhit_particle);
1600  t->Branch("simhit_process", &simhit_process);
1601  t->Branch("simhit_eloss", &simhit_eloss);
1602  t->Branch("simhit_tof", &simhit_tof);
1603  t->Branch("simhit_simTrkIdx", &simhit_simTrkIdx);
1604  t->Branch("simhit_hitIdx", &simhit_hitIdx);
1605  t->Branch("simhit_hitType", &simhit_hitType);
1606  }
1607  }
1608  //beam spot
1609  t->Branch("bsp_x", &bsp_x, "bsp_x/F");
1610  t->Branch("bsp_y", &bsp_y, "bsp_y/F");
1611  t->Branch("bsp_z", &bsp_z, "bsp_z/F");
1612  t->Branch("bsp_sigmax", &bsp_sigmax, "bsp_sigmax/F");
1613  t->Branch("bsp_sigmay", &bsp_sigmay, "bsp_sigmay/F");
1614  t->Branch("bsp_sigmaz", &bsp_sigmaz, "bsp_sigmaz/F");
1615  if (includeSeeds_) {
1616  //seeds
1617  t->Branch("see_fitok", &see_fitok);
1618  t->Branch("see_px", &see_px);
1619  t->Branch("see_py", &see_py);
1620  t->Branch("see_pz", &see_pz);
1621  t->Branch("see_pt", &see_pt);
1622  t->Branch("see_eta", &see_eta);
1623  t->Branch("see_phi", &see_phi);
1624  t->Branch("see_dxy", &see_dxy);
1625  t->Branch("see_dz", &see_dz);
1626  t->Branch("see_ptErr", &see_ptErr);
1627  t->Branch("see_etaErr", &see_etaErr);
1628  t->Branch("see_phiErr", &see_phiErr);
1629  t->Branch("see_dxyErr", &see_dxyErr);
1630  t->Branch("see_dzErr", &see_dzErr);
1631  t->Branch("see_chi2", &see_chi2);
1632  t->Branch("see_statePt", &see_statePt);
1633  t->Branch("see_stateTrajX", &see_stateTrajX);
1634  t->Branch("see_stateTrajY", &see_stateTrajY);
1635  t->Branch("see_stateTrajPx", &see_stateTrajPx);
1636  t->Branch("see_stateTrajPy", &see_stateTrajPy);
1637  t->Branch("see_stateTrajPz", &see_stateTrajPz);
1638  t->Branch("see_q", &see_q);
1639  t->Branch("see_nValid", &see_nValid);
1640  t->Branch("see_nPixel", &see_nPixel);
1641  t->Branch("see_nGlued", &see_nGlued);
1642  t->Branch("see_nStrip", &see_nStrip);
1643  t->Branch("see_nPhase2OT", &see_nPhase2OT);
1644  t->Branch("see_nCluster", &see_nCluster);
1645  t->Branch("see_algo", &see_algo);
1646  t->Branch("see_stopReason", &see_stopReason);
1647  t->Branch("see_nCands", &see_nCands);
1648  t->Branch("see_trkIdx", &see_trkIdx);
1649  if (includeTrackingParticles_) {
1650  t->Branch("see_simTrkIdx", &see_simTrkIdx);
1651  t->Branch("see_simTrkShareFrac", &see_simTrkShareFrac);
1652  t->Branch("see_bestSimTrkIdx", &see_bestSimTrkIdx);
1653  t->Branch("see_bestFromFirstHitSimTrkIdx", &see_bestFromFirstHitSimTrkIdx);
1654  } else {
1655  t->Branch("see_isTrue", &see_isTrue);
1656  }
1657  t->Branch("see_bestSimTrkShareFrac", &see_bestSimTrkShareFrac);
1658  t->Branch("see_bestFromFirstHitSimTrkShareFrac", &see_bestFromFirstHitSimTrkShareFrac);
1659  if (includeAllHits_) {
1660  t->Branch("see_hitIdx", &see_hitIdx);
1661  t->Branch("see_hitType", &see_hitType);
1662  }
1663  //seed algo offset
1664  t->Branch("see_offset", &see_offset);
1665  }
1666 
1667  //vertices
1668  t->Branch("vtx_x", &vtx_x);
1669  t->Branch("vtx_y", &vtx_y);
1670  t->Branch("vtx_z", &vtx_z);
1671  t->Branch("vtx_xErr", &vtx_xErr);
1672  t->Branch("vtx_yErr", &vtx_yErr);
1673  t->Branch("vtx_zErr", &vtx_zErr);
1674  t->Branch("vtx_ndof", &vtx_ndof);
1675  t->Branch("vtx_chi2", &vtx_chi2);
1676  t->Branch("vtx_fake", &vtx_fake);
1677  t->Branch("vtx_valid", &vtx_valid);
1678  t->Branch("vtx_trkIdx", &vtx_trkIdx);
1679 
1680  // tracking vertices
1681  t->Branch("simvtx_event", &simvtx_event);
1682  t->Branch("simvtx_bunchCrossing", &simvtx_bunchCrossing);
1683  t->Branch("simvtx_processType", &simvtx_processType);
1684  t->Branch("simvtx_x", &simvtx_x);
1685  t->Branch("simvtx_y", &simvtx_y);
1686  t->Branch("simvtx_z", &simvtx_z);
1687  t->Branch("simvtx_sourceSimIdx", &simvtx_sourceSimIdx);
1688  t->Branch("simvtx_daughterSimIdx", &simvtx_daughterSimIdx);
1689 
1690  t->Branch("simpv_idx", &simpv_idx);
1691 
1692  //t->Branch("" , &);
1693 }

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, HistoryBase::depth(), ev_event, ev_lumi, ev_run, Exception, edm::ParameterSet::getUntrackedParameter(), glu_bbxi, glu_detId, glu_isBarrel, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, mps_fire::i, includeAllHits_, includeMVA_, includePhase2OTHits_, includeSeeds_, includeStripHits_, includeTrackingParticles_, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, TFileService::kSharedResource, TFileService::make(), mvaQualityCollectionTokens_, ph2_bbxi, ph2_detId, ph2_isBarrel, ph2_radL, ph2_seeIdx, ph2_simHitIdx, ph2_simType, ph2_trkIdx, ph2_x, ph2_xx, ph2_xy, ph2_y, ph2_yy, ph2_yz, ph2_z, ph2_zx, ph2_zz, pix_bbxi, pix_chargeFraction, pix_detId, pix_isBarrel, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_bestFromFirstHitSimTrkIdx, see_bestFromFirstHitSimTrkShareFrac, see_bestSimTrkIdx, see_bestSimTrkShareFrac, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_isTrue, see_nCands, see_nCluster, see_nGlued, see_nPhase2OT, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_simTrkIdx, see_simTrkShareFrac, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, seedStopInfoTokens_, seedTokens_, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_seedIdx, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, str_bbxi, str_chargeFraction, str_detId, str_isBarrel, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, AlCaHLTBitMon_QueryRunRegistry::string, t, GlobalPosition_Frontier_DevDB_cff::tag, MuonAssociatorByHits_cfi::tpTag, tracer_, trackingParticleRefToken_, trackingParticleToken_, trk_algo, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_cotTheta, trk_dxy, trk_dxyClosestPV, trk_dxyErr, trk_dxyPV, trk_dz, trk_dzClosestPV, trk_dzErr, trk_dzPV, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_isTrue, trk_lambda, trk_lambdaErr, trk_mvas, trk_n3DLay, trk_nChi2, trk_nChi2_1Dmod, trk_nCluster, trk_ndof, trk_nInactive, trk_nInnerInactive, trk_nInnerLost, trk_nLost, trk_nLostLay, trk_nOuterInactive, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_qualityMasks, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, trk_seedIdx, trk_simTrkIdx, trk_simTrkNChi2, trk_simTrkShareFrac, trk_stopReason, trk_vtxIdx, edm::vector_transform(), vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

◆ ~TrackingNtuple()

TrackingNtuple::~TrackingNtuple ( )
override

Definition at line 1695 of file TrackingNtuple.cc.

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

Member Function Documentation

◆ addStripMatchedHit()

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

Definition at line 2644 of file TrackingNtuple.cc.

2647  {
2648  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
2649  const auto hitId = hit.geographicalId();
2650  const int lay = tTopo.layer(hitId);
2651  monoStereoClusterList.emplace_back(hit.monoHit().cluster().key(), hit.stereoHit().cluster().key());
2652  glu_isBarrel.push_back((hitId.subdetId() == StripSubdetector::TIB || hitId.subdetId() == StripSubdetector::TOB));
2653  glu_detId.push_back(tTopo, hitId);
2654  glu_monoIdx.push_back(hit.monoHit().cluster().key());
2655  glu_stereoIdx.push_back(hit.stereoHit().cluster().key());
2656  glu_seeIdx.emplace_back(); // filled in fillSeeds
2657  glu_x.push_back(ttrh->globalPosition().x());
2658  glu_y.push_back(ttrh->globalPosition().y());
2659  glu_z.push_back(ttrh->globalPosition().z());
2660  glu_xx.push_back(ttrh->globalPositionError().cxx());
2661  glu_xy.push_back(ttrh->globalPositionError().cyx());
2662  glu_yy.push_back(ttrh->globalPositionError().cyy());
2663  glu_yz.push_back(ttrh->globalPositionError().czy());
2664  glu_zz.push_back(ttrh->globalPositionError().czz());
2665  glu_zx.push_back(ttrh->globalPositionError().czx());
2666  glu_radL.push_back(ttrh->surface()->mediumProperties().radLen());
2667  glu_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
2668  LogTrace("TrackingNtuple") << "stripMatchedHit"
2669  << " cluster0=" << hit.stereoHit().cluster().key()
2670  << " cluster1=" << hit.monoHit().cluster().key() << " subdId=" << hitId.subdetId()
2671  << " lay=" << lay << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
2672  return glu_isBarrel.size() - 1;
2673 }

References TransientTrackingRecHitBuilder::build(), 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, StripSubdetector::TIB, and StripSubdetector::TOB.

Referenced by fillSeeds(), and fillStripMatchedHits().

◆ analyze()

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

Implements edm::one::EDAnalyzerBase.

Definition at line 1991 of file TrackingNtuple.cc.

1991  {
1992  using namespace edm;
1993  using namespace reco;
1994  using namespace std;
1995 
1996  const auto& mf = iSetup.getData(mfToken_);
1997  const auto& theTTRHBuilder = &iSetup.getData(ttrhToken_);
1998  const TrackerTopology& tTopo = iSetup.getData(tTopoToken_);
1999  const TrackerGeometry& tracker = iSetup.getData(tGeomToken_);
2000 
2001  edm::Handle<reco::TrackToTrackingParticleAssociator> theAssociator;
2002  iEvent.getByToken(trackAssociatorToken_, theAssociator);
2003  const reco::TrackToTrackingParticleAssociator& associatorByHits = *theAssociator;
2004 
2005  LogDebug("TrackingNtuple") << "Analyzing new event";
2006 
2007  //initialize tree variables
2008  clearVariables();
2009 
2010  // FIXME: we really need to move to edm::View for reading the
2011  // TrackingParticles... Unfortunately it has non-trivial
2012  // consequences on the associator/association interfaces etc.
2013  TrackingParticleRefVector tmpTP;
2014  const TrackingParticleRefVector* tmpTPptr = nullptr;
2015  edm::Handle<TrackingParticleCollection> TPCollectionH;
2016  edm::Handle<TrackingParticleRefVector> TPCollectionHRefVector;
2017 
2018  if (!trackingParticleToken_.isUninitialized()) {
2019  iEvent.getByToken(trackingParticleToken_, TPCollectionH);
2020  for (size_t i = 0, size = TPCollectionH->size(); i < size; ++i) {
2021  tmpTP.push_back(TrackingParticleRef(TPCollectionH, i));
2022  }
2023  tmpTPptr = &tmpTP;
2024  } else {
2025  iEvent.getByToken(trackingParticleRefToken_, TPCollectionHRefVector);
2026  tmpTPptr = TPCollectionHRefVector.product();
2027  }
2028  const TrackingParticleRefVector& tpCollection = *tmpTPptr;
2029 
2030  // Fill mapping from Ref::key() to index
2031  TrackingParticleRefKeyToIndex tpKeyToIndex;
2032  for (size_t i = 0; i < tpCollection.size(); ++i) {
2033  tpKeyToIndex[tpCollection[i].key()] = i;
2034  }
2035 
2036  // tracking vertices
2037  edm::Handle<TrackingVertexCollection> htv;
2038  iEvent.getByToken(trackingVertexToken_, htv);
2039  const TrackingVertexCollection& tvs = *htv;
2040 
2041  // Fill mapping from Ref::key() to index
2042  TrackingVertexRefVector tvRefs;
2043  TrackingVertexRefKeyToIndex tvKeyToIndex;
2044  for (size_t i = 0; i < tvs.size(); ++i) {
2045  const TrackingVertex& v = tvs[i];
2046  if (v.eventId().bunchCrossing() != 0) // Ignore OOTPU; would be better to not to hardcode?
2047  continue;
2048  tvKeyToIndex[i] = tvRefs.size();
2049  tvRefs.push_back(TrackingVertexRef(htv, i));
2050  }
2051 
2052  //get association maps, etc.
2053  Handle<ClusterTPAssociation> pCluster2TPListH;
2054  iEvent.getByToken(clusterTPMapToken_, pCluster2TPListH);
2055  const ClusterTPAssociation& clusterToTPMap = *pCluster2TPListH;
2056  edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
2057  iEvent.getByToken(simHitTPMapToken_, simHitsTPAssoc);
2058 
2059  // TP -> cluster count
2060  TrackingParticleRefKeyToCount tpKeyToClusterCount;
2061  for (const auto& clusterTP : clusterToTPMap) {
2062  tpKeyToClusterCount[clusterTP.second.key()] += 1;
2063  }
2064 
2065  // SimHit key -> index mapping
2066  SimHitRefKeyToIndex simHitRefKeyToIndex;
2067 
2068  //make a list to link TrackingParticles to its simhits
2069  std::vector<TPHitIndex> tpHitList;
2070 
2071  // Count the number of reco cluster per TP
2072 
2073  std::set<edm::ProductID> hitProductIds;
2074  std::map<edm::ProductID, size_t> seedCollToOffset;
2075 
2076  ev_run = iEvent.id().run();
2077  ev_lumi = iEvent.id().luminosityBlock();
2078  ev_event = iEvent.id().event();
2079 
2080  // Digi->Sim links for pixels and strips
2081  edm::Handle<edm::DetSetVector<PixelDigiSimLink>> pixelDigiSimLinksHandle;
2082  iEvent.getByToken(pixelSimLinkToken_, pixelDigiSimLinksHandle);
2083  const auto& pixelDigiSimLinks = *pixelDigiSimLinksHandle;
2084 
2085  edm::Handle<edm::DetSetVector<StripDigiSimLink>> stripDigiSimLinksHandle;
2086  iEvent.getByToken(stripSimLinkToken_, stripDigiSimLinksHandle);
2087 
2088  // Phase2 OT DigiSimLink
2089  edm::Handle<edm::DetSetVector<PixelDigiSimLink>> siphase2OTSimLinksHandle;
2090  iEvent.getByToken(siphase2OTSimLinksToken_, siphase2OTSimLinksHandle);
2091 
2092  //beamspot
2093  Handle<reco::BeamSpot> recoBeamSpotHandle;
2094  iEvent.getByToken(beamSpotToken_, recoBeamSpotHandle);
2095  BeamSpot const& bs = *recoBeamSpotHandle;
2096  fillBeamSpot(bs);
2097 
2098  //prapare list to link matched hits to collection
2099  vector<pair<int, int>> monoStereoClusterList;
2100  if (includeAllHits_) {
2101  // simhits, only if TPs are saved as well
2102  if (includeTrackingParticles_) {
2103  fillSimHits(tracker, tpKeyToIndex, *simHitsTPAssoc, tTopo, simHitRefKeyToIndex, tpHitList);
2104  }
2105 
2106  //pixel hits
2107  fillPixelHits(iEvent,
2108  clusterToTPMap,
2109  tpKeyToIndex,
2110  *simHitsTPAssoc,
2111  pixelDigiSimLinks,
2112  *theTTRHBuilder,
2113  tTopo,
2114  simHitRefKeyToIndex,
2115  hitProductIds);
2116 
2117  //strip hits
2118  if (includeStripHits_) {
2119  LogDebug("TrackingNtuple") << "foundStripSimLink";
2120  const auto& stripDigiSimLinks = *stripDigiSimLinksHandle;
2121  fillStripRphiStereoHits(iEvent,
2122  clusterToTPMap,
2123  tpKeyToIndex,
2124  *simHitsTPAssoc,
2125  stripDigiSimLinks,
2126  *theTTRHBuilder,
2127  tTopo,
2128  simHitRefKeyToIndex,
2129  hitProductIds);
2130 
2131  //matched hits
2132  fillStripMatchedHits(iEvent, *theTTRHBuilder, tTopo, monoStereoClusterList);
2133  }
2134 
2135  if (includePhase2OTHits_) {
2136  LogDebug("TrackingNtuple") << "foundPhase2OTSimLinks";
2137  const auto& phase2OTSimLinks = *siphase2OTSimLinksHandle;
2138  fillPhase2OTHits(iEvent,
2139  clusterToTPMap,
2140  tpKeyToIndex,
2141  *simHitsTPAssoc,
2142  phase2OTSimLinks,
2143  *theTTRHBuilder,
2144  tTopo,
2145  simHitRefKeyToIndex,
2146  hitProductIds);
2147  }
2148  }
2149 
2150  //seeds
2151  if (includeSeeds_) {
2152  fillSeeds(iEvent,
2153  tpCollection,
2154  tpKeyToIndex,
2155  bs,
2156  associatorByHits,
2157  clusterToTPMap,
2158  *theTTRHBuilder,
2159  mf,
2160  tTopo,
2161  monoStereoClusterList,
2162  hitProductIds,
2163  seedCollToOffset);
2164  }
2165 
2166  //tracks
2167  edm::Handle<edm::View<reco::Track>> tracksHandle;
2168  iEvent.getByToken(trackToken_, tracksHandle);
2169  const edm::View<reco::Track>& tracks = *tracksHandle;
2170  // The associator interfaces really need to be fixed...
2171  edm::RefToBaseVector<reco::Track> trackRefs;
2172  for (edm::View<Track>::size_type i = 0; i < tracks.size(); ++i) {
2173  trackRefs.push_back(tracks.refAt(i));
2174  }
2175  std::vector<const MVACollection*> mvaColls;
2176  std::vector<const QualityMaskCollection*> qualColls;
2177  if (includeMVA_) {
2178  edm::Handle<MVACollection> hmva;
2179  edm::Handle<QualityMaskCollection> hqual;
2180 
2181  for (const auto& tokenTpl : mvaQualityCollectionTokens_) {
2182  iEvent.getByToken(std::get<0>(tokenTpl), hmva);
2183  iEvent.getByToken(std::get<1>(tokenTpl), hqual);
2184 
2185  mvaColls.push_back(hmva.product());
2186  qualColls.push_back(hqual.product());
2187  if (mvaColls.back()->size() != tracks.size()) {
2188  throw cms::Exception("Configuration")
2189  << "Inconsistency in track collection and MVA sizes. Track collection has " << tracks.size()
2190  << " tracks, whereas the MVA " << (mvaColls.size() - 1) << " has " << mvaColls.back()->size()
2191  << " entries. Double-check your configuration.";
2192  }
2193  if (qualColls.back()->size() != tracks.size()) {
2194  throw cms::Exception("Configuration")
2195  << "Inconsistency in track collection and quality mask sizes. Track collection has " << tracks.size()
2196  << " tracks, whereas the quality mask " << (qualColls.size() - 1) << " has " << qualColls.back()->size()
2197  << " entries. Double-check your configuration.";
2198  }
2199  }
2200  }
2201 
2202  edm::Handle<reco::VertexCollection> vertices;
2203  iEvent.getByToken(vertexToken_, vertices);
2204 
2205  fillTracks(trackRefs,
2206  tpCollection,
2207  tpKeyToIndex,
2208  tpKeyToClusterCount,
2209  mf,
2210  bs,
2211  *vertices,
2212  associatorByHits,
2213  clusterToTPMap,
2214  *theTTRHBuilder,
2215  tTopo,
2216  hitProductIds,
2217  seedCollToOffset,
2218  mvaColls,
2219  qualColls);
2220 
2221  //tracking particles
2222  //sort association maps with simHits
2223  std::sort(tpHitList.begin(), tpHitList.end(), tpHitIndexListLessSort);
2224  fillTrackingParticles(
2225  iEvent, iSetup, trackRefs, bs, tpCollection, tvKeyToIndex, associatorByHits, tpHitList, tpKeyToClusterCount);
2226 
2227  // vertices
2228  fillVertices(*vertices, trackRefs);
2229 
2230  // tracking vertices
2231  fillTrackingVertices(tvRefs, tpKeyToIndex);
2232 
2233  t->Fill();
2234 }

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

◆ clearVariables()

void TrackingNtuple::clearVariables ( )
private

Definition at line 1703 of file TrackingNtuple.cc.

1703  {
1704  ev_run = 0;
1705  ev_lumi = 0;
1706  ev_event = 0;
1707 
1708  //tracks
1709  trk_px.clear();
1710  trk_py.clear();
1711  trk_pz.clear();
1712  trk_pt.clear();
1713  trk_inner_px.clear();
1714  trk_inner_py.clear();
1715  trk_inner_pz.clear();
1716  trk_inner_pt.clear();
1717  trk_outer_px.clear();
1718  trk_outer_py.clear();
1719  trk_outer_pz.clear();
1720  trk_outer_pt.clear();
1721  trk_eta.clear();
1722  trk_lambda.clear();
1723  trk_cotTheta.clear();
1724  trk_phi.clear();
1725  trk_dxy.clear();
1726  trk_dz.clear();
1727  trk_dxyPV.clear();
1728  trk_dzPV.clear();
1729  trk_dxyClosestPV.clear();
1730  trk_dzClosestPV.clear();
1731  trk_ptErr.clear();
1732  trk_etaErr.clear();
1733  trk_lambdaErr.clear();
1734  trk_phiErr.clear();
1735  trk_dxyErr.clear();
1736  trk_dzErr.clear();
1737  trk_refpoint_x.clear();
1738  trk_refpoint_y.clear();
1739  trk_refpoint_z.clear();
1740  trk_nChi2.clear();
1741  trk_nChi2_1Dmod.clear();
1742  trk_ndof.clear();
1743  for (auto& mva : trk_mvas) {
1744  mva.clear();
1745  }
1746  for (auto& mask : trk_qualityMasks) {
1747  mask.clear();
1748  }
1749  trk_q.clear();
1750  trk_nValid.clear();
1751  trk_nLost.clear();
1752  trk_nInactive.clear();
1753  trk_nPixel.clear();
1754  trk_nStrip.clear();
1755  trk_nOuterLost.clear();
1756  trk_nInnerLost.clear();
1757  trk_nOuterInactive.clear();
1758  trk_nInnerInactive.clear();
1759  trk_nPixelLay.clear();
1760  trk_nStripLay.clear();
1761  trk_n3DLay.clear();
1762  trk_nLostLay.clear();
1763  trk_nCluster.clear();
1764  trk_algo.clear();
1765  trk_originalAlgo.clear();
1766  trk_algoMask.clear();
1767  trk_stopReason.clear();
1768  trk_isHP.clear();
1769  trk_seedIdx.clear();
1770  trk_vtxIdx.clear();
1771  trk_isTrue.clear();
1772  trk_bestSimTrkIdx.clear();
1773  trk_bestSimTrkShareFrac.clear();
1774  trk_bestSimTrkShareFracSimDenom.clear();
1775  trk_bestSimTrkShareFracSimClusterDenom.clear();
1776  trk_bestSimTrkNChi2.clear();
1777  trk_bestFromFirstHitSimTrkIdx.clear();
1778  trk_bestFromFirstHitSimTrkShareFrac.clear();
1779  trk_bestFromFirstHitSimTrkShareFracSimDenom.clear();
1780  trk_bestFromFirstHitSimTrkShareFracSimClusterDenom.clear();
1781  trk_bestFromFirstHitSimTrkNChi2.clear();
1782  trk_simTrkIdx.clear();
1783  trk_simTrkShareFrac.clear();
1784  trk_simTrkNChi2.clear();
1785  trk_hitIdx.clear();
1786  trk_hitType.clear();
1787  //sim tracks
1788  sim_event.clear();
1789  sim_bunchCrossing.clear();
1790  sim_pdgId.clear();
1791  sim_genPdgIds.clear();
1792  sim_isFromBHadron.clear();
1793  sim_px.clear();
1794  sim_py.clear();
1795  sim_pz.clear();
1796  sim_pt.clear();
1797  sim_eta.clear();
1798  sim_phi.clear();
1799  sim_pca_pt.clear();
1800  sim_pca_eta.clear();
1801  sim_pca_lambda.clear();
1802  sim_pca_cotTheta.clear();
1803  sim_pca_phi.clear();
1804  sim_pca_dxy.clear();
1805  sim_pca_dz.clear();
1806  sim_q.clear();
1807  sim_nValid.clear();
1808  sim_nPixel.clear();
1809  sim_nStrip.clear();
1810  sim_nLay.clear();
1811  sim_nPixelLay.clear();
1812  sim_n3DLay.clear();
1813  sim_nTrackerHits.clear();
1814  sim_nRecoClusters.clear();
1815  sim_trkIdx.clear();
1816  sim_seedIdx.clear();
1817  sim_trkShareFrac.clear();
1818  sim_parentVtxIdx.clear();
1819  sim_decayVtxIdx.clear();
1820  sim_simHitIdx.clear();
1821  //pixels
1822  pix_isBarrel.clear();
1823  pix_detId.clear();
1824  pix_trkIdx.clear();
1825  pix_seeIdx.clear();
1826  pix_simHitIdx.clear();
1827  pix_chargeFraction.clear();
1828  pix_simType.clear();
1829  pix_x.clear();
1830  pix_y.clear();
1831  pix_z.clear();
1832  pix_xx.clear();
1833  pix_xy.clear();
1834  pix_yy.clear();
1835  pix_yz.clear();
1836  pix_zz.clear();
1837  pix_zx.clear();
1838  pix_radL.clear();
1839  pix_bbxi.clear();
1840  //strips
1841  str_isBarrel.clear();
1842  str_detId.clear();
1843  str_trkIdx.clear();
1844  str_seeIdx.clear();
1845  str_simHitIdx.clear();
1846  str_chargeFraction.clear();
1847  str_simType.clear();
1848  str_x.clear();
1849  str_y.clear();
1850  str_z.clear();
1851  str_xx.clear();
1852  str_xy.clear();
1853  str_yy.clear();
1854  str_yz.clear();
1855  str_zz.clear();
1856  str_zx.clear();
1857  str_radL.clear();
1858  str_bbxi.clear();
1859  //matched hits
1860  glu_isBarrel.clear();
1861  glu_detId.clear();
1862  glu_monoIdx.clear();
1863  glu_stereoIdx.clear();
1864  glu_seeIdx.clear();
1865  glu_x.clear();
1866  glu_y.clear();
1867  glu_z.clear();
1868  glu_xx.clear();
1869  glu_xy.clear();
1870  glu_yy.clear();
1871  glu_yz.clear();
1872  glu_zz.clear();
1873  glu_zx.clear();
1874  glu_radL.clear();
1875  glu_bbxi.clear();
1876  //phase2 OT
1877  ph2_isBarrel.clear();
1878  ph2_detId.clear();
1879  ph2_trkIdx.clear();
1880  ph2_seeIdx.clear();
1881  ph2_simHitIdx.clear();
1882  ph2_simType.clear();
1883  ph2_x.clear();
1884  ph2_y.clear();
1885  ph2_z.clear();
1886  ph2_xx.clear();
1887  ph2_xy.clear();
1888  ph2_yy.clear();
1889  ph2_yz.clear();
1890  ph2_zz.clear();
1891  ph2_zx.clear();
1892  ph2_radL.clear();
1893  ph2_bbxi.clear();
1894  //invalid hits
1895  inv_isBarrel.clear();
1896  inv_detId.clear();
1897  inv_detId_phase2.clear();
1898  inv_type.clear();
1899  // simhits
1900  simhit_detId.clear();
1901  simhit_detId_phase2.clear();
1902  simhit_x.clear();
1903  simhit_y.clear();
1904  simhit_z.clear();
1905  simhit_particle.clear();
1906  simhit_process.clear();
1907  simhit_eloss.clear();
1908  simhit_tof.clear();
1909  //simhit_simTrackId.clear();
1910  simhit_simTrkIdx.clear();
1911  simhit_hitIdx.clear();
1912  simhit_hitType.clear();
1913  //beamspot
1914  bsp_x = -9999.;
1915  bsp_y = -9999.;
1916  bsp_z = -9999.;
1917  bsp_sigmax = -9999.;
1918  bsp_sigmay = -9999.;
1919  bsp_sigmaz = -9999.;
1920  //seeds
1921  see_fitok.clear();
1922  see_px.clear();
1923  see_py.clear();
1924  see_pz.clear();
1925  see_pt.clear();
1926  see_eta.clear();
1927  see_phi.clear();
1928  see_dxy.clear();
1929  see_dz.clear();
1930  see_ptErr.clear();
1931  see_etaErr.clear();
1932  see_phiErr.clear();
1933  see_dxyErr.clear();
1934  see_dzErr.clear();
1935  see_chi2.clear();
1936  see_statePt.clear();
1937  see_stateTrajX.clear();
1938  see_stateTrajY.clear();
1939  see_stateTrajPx.clear();
1940  see_stateTrajPy.clear();
1941  see_stateTrajPz.clear();
1942  see_q.clear();
1943  see_nValid.clear();
1944  see_nPixel.clear();
1945  see_nGlued.clear();
1946  see_nStrip.clear();
1947  see_nPhase2OT.clear();
1948  see_nCluster.clear();
1949  see_algo.clear();
1950  see_stopReason.clear();
1951  see_nCands.clear();
1952  see_trkIdx.clear();
1953  see_isTrue.clear();
1954  see_bestSimTrkIdx.clear();
1955  see_bestSimTrkShareFrac.clear();
1956  see_bestFromFirstHitSimTrkIdx.clear();
1957  see_bestFromFirstHitSimTrkShareFrac.clear();
1958  see_simTrkIdx.clear();
1959  see_simTrkShareFrac.clear();
1960  see_hitIdx.clear();
1961  see_hitType.clear();
1962  //seed algo offset
1963  see_offset.clear();
1964 
1965  // vertices
1966  vtx_x.clear();
1967  vtx_y.clear();
1968  vtx_z.clear();
1969  vtx_xErr.clear();
1970  vtx_yErr.clear();
1971  vtx_zErr.clear();
1972  vtx_ndof.clear();
1973  vtx_chi2.clear();
1974  vtx_fake.clear();
1975  vtx_valid.clear();
1976  vtx_trkIdx.clear();
1977 
1978  // Tracking vertices
1979  simvtx_event.clear();
1980  simvtx_bunchCrossing.clear();
1981  simvtx_processType.clear();
1982  simvtx_x.clear();
1983  simvtx_y.clear();
1984  simvtx_z.clear();
1985  simvtx_sourceSimIdx.clear();
1986  simvtx_daughterSimIdx.clear();
1987  simpv_idx.clear();
1988 }

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

Referenced by analyze().

◆ fillBeamSpot()

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

Definition at line 2236 of file TrackingNtuple.cc.

2236  {
2237  bsp_x = bs.x0();
2238  bsp_y = bs.y0();
2239  bsp_z = bs.x0();
2240  bsp_sigmax = bs.BeamWidthX();
2241  bsp_sigmay = bs.BeamWidthY();
2242  bsp_sigmaz = bs.sigmaZ();
2243 }

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

Referenced by analyze().

◆ fillDescriptions()

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

Definition at line 3622 of file TrackingNtuple.cc.

3622  {
3623  //The following says we do not know what parameters are allowed so do no validation
3624  // Please change this to state exactly what you do use, even if it is no parameters
3625  edm::ParameterSetDescription desc;
3626  desc.addUntracked<std::vector<edm::InputTag>>(
3627  "seedTracks",
3628  std::vector<edm::InputTag>{edm::InputTag("seedTracksinitialStepSeeds"),
3629  edm::InputTag("seedTracksdetachedTripletStepSeeds"),
3630  edm::InputTag("seedTrackspixelPairStepSeeds"),
3631  edm::InputTag("seedTrackslowPtTripletStepSeeds"),
3632  edm::InputTag("seedTracksmixedTripletStepSeeds"),
3633  edm::InputTag("seedTrackspixelLessStepSeeds"),
3634  edm::InputTag("seedTrackstobTecStepSeeds"),
3635  edm::InputTag("seedTracksjetCoreRegionalStepSeeds"),
3636  edm::InputTag("seedTracksmuonSeededSeedsInOut"),
3637  edm::InputTag("seedTracksmuonSeededSeedsOutIn")});
3638  desc.addUntracked<std::vector<edm::InputTag>>(
3639  "trackCandidates",
3640  std::vector<edm::InputTag>{edm::InputTag("initialStepTrackCandidates"),
3641  edm::InputTag("detachedTripletStepTrackCandidates"),
3642  edm::InputTag("pixelPairStepTrackCandidates"),
3643  edm::InputTag("lowPtTripletStepTrackCandidates"),
3644  edm::InputTag("mixedTripletStepTrackCandidates"),
3645  edm::InputTag("pixelLessStepTrackCandidates"),
3646  edm::InputTag("tobTecStepTrackCandidates"),
3647  edm::InputTag("jetCoreRegionalStepTrackCandidates"),
3648  edm::InputTag("muonSeededTrackCandidatesInOut"),
3649  edm::InputTag("muonSeededTrackCandidatesOutIn")});
3650  desc.addUntracked<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
3651  desc.addUntracked<std::vector<std::string>>("trackMVAs", std::vector<std::string>{{"generalTracks"}});
3652  desc.addUntracked<edm::InputTag>("trackingParticles", edm::InputTag("mix", "MergedTrackTruth"));
3653  desc.addUntracked<bool>("trackingParticlesRef", false);
3654  desc.addUntracked<edm::InputTag>("clusterTPMap", edm::InputTag("tpClusterProducer"));
3655  desc.addUntracked<edm::InputTag>("simHitTPMap", edm::InputTag("simHitTPAssocProducer"));
3656  desc.addUntracked<edm::InputTag>("trackAssociator", edm::InputTag("quickTrackAssociatorByHits"));
3657  desc.addUntracked<edm::InputTag>("pixelDigiSimLink", edm::InputTag("simSiPixelDigis"));
3658  desc.addUntracked<edm::InputTag>("stripDigiSimLink", edm::InputTag("simSiStripDigis"));
3659  desc.addUntracked<edm::InputTag>("phase2OTSimLink", edm::InputTag(""));
3660  desc.addUntracked<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
3661  desc.addUntracked<edm::InputTag>("pixelRecHits", edm::InputTag("siPixelRecHits"));
3662  desc.addUntracked<edm::InputTag>("stripRphiRecHits", edm::InputTag("siStripMatchedRecHits", "rphiRecHit"));
3663  desc.addUntracked<edm::InputTag>("stripStereoRecHits", edm::InputTag("siStripMatchedRecHits", "stereoRecHit"));
3664  desc.addUntracked<edm::InputTag>("stripMatchedRecHits", edm::InputTag("siStripMatchedRecHits", "matchedRecHit"));
3665  desc.addUntracked<edm::InputTag>("phase2OTRecHits", edm::InputTag("siPhase2RecHits"));
3666  desc.addUntracked<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
3667  desc.addUntracked<edm::InputTag>("trackingVertices", edm::InputTag("mix", "MergedTrackTruth"));
3668  desc.addUntracked<edm::InputTag>("trackingParticleNlayers",
3669  edm::InputTag("trackingParticleNumberOfLayersProducer", "trackerLayers"));
3670  desc.addUntracked<edm::InputTag>("trackingParticleNpixellayers",
3671  edm::InputTag("trackingParticleNumberOfLayersProducer", "pixelLayers"));
3672  desc.addUntracked<edm::InputTag>("trackingParticleNstripstereolayers",
3673  edm::InputTag("trackingParticleNumberOfLayersProducer", "stripStereoLayers"));
3674  desc.addUntracked<std::string>("TTRHBuilder", "WithTrackAngle");
3675  desc.addUntracked<std::string>("parametersDefiner", "LhcParametersDefinerForTP");
3676  desc.addUntracked<bool>("includeSeeds", false);
3677  desc.addUntracked<bool>("includeAllHits", false);
3678  desc.addUntracked<bool>("includeMVA", true);
3679  desc.addUntracked<bool>("includeTrackingParticles", true);
3680  descriptions.add("trackingNtuple", desc);
3681 }

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

◆ fillPhase2OTHits()

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

Definition at line 2688 of file TrackingNtuple.cc.

2696  {
2697  edm::Handle<Phase2TrackerRecHit1DCollectionNew> phase2OTHits;
2698  iEvent.getByToken(phase2OTRecHitToken_, phase2OTHits);
2699  for (auto it = phase2OTHits->begin(); it != phase2OTHits->end(); it++) {
2700  const DetId hitId = it->detId();
2701  for (auto hit = it->begin(); hit != it->end(); hit++) {
2702  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
2703 
2704  hitProductIds.insert(hit->cluster().id());
2705 
2706  const int key = hit->cluster().key();
2707  const int lay = tTopo.layer(hitId);
2708 
2709  ph2_isBarrel.push_back(hitId.subdetId() == 1);
2710  ph2_detId.push_back(tTopo, hitId);
2711  ph2_trkIdx.emplace_back(); // filled in fillTracks
2712  ph2_seeIdx.emplace_back(); // filled in fillSeeds
2713  ph2_x.push_back(ttrh->globalPosition().x());
2714  ph2_y.push_back(ttrh->globalPosition().y());
2715  ph2_z.push_back(ttrh->globalPosition().z());
2716  ph2_xx.push_back(ttrh->globalPositionError().cxx());
2717  ph2_xy.push_back(ttrh->globalPositionError().cyx());
2718  ph2_yy.push_back(ttrh->globalPositionError().cyy());
2719  ph2_yz.push_back(ttrh->globalPositionError().czy());
2720  ph2_zz.push_back(ttrh->globalPositionError().czz());
2721  ph2_zx.push_back(ttrh->globalPositionError().czx());
2722  ph2_radL.push_back(ttrh->surface()->mediumProperties().radLen());
2723  ph2_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
2724 
2725  LogTrace("TrackingNtuple") << "phase2 OT cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
2726  << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
2727 
2728  if (includeTrackingParticles_) {
2729  SimHitData simHitData = matchCluster(hit->firstClusterRef(),
2730  hitId,
2731  key,
2732  ttrh,
2733  clusterToTPMap,
2734  tpKeyToIndex,
2735  simHitsTPAssoc,
2736  digiSimLink,
2737  simHitRefKeyToIndex,
2738  HitType::Phase2OT);
2739  ph2_simHitIdx.push_back(simHitData.matchingSimHit);
2740  ph2_simType.push_back(static_cast<int>(simHitData.type));
2741  LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
2742  if (!simHitData.matchingSimHit.empty()) {
2743  const auto simHitIdx = simHitData.matchingSimHit[0];
2744  LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
2745  << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2746  << " energyLoss=" << simhit_eloss[simHitIdx]
2747  << " particleType=" << simhit_particle[simHitIdx]
2748  << " processType=" << simhit_process[simHitIdx]
2749  << " bunchCrossing=" << simHitData.bunchCrossing[0]
2750  << " event=" << simHitData.event[0];
2751  }
2752  }
2753  }
2754  }
2755 }

References edmNew::DetSetVector< T >::begin(), TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, edmNew::DetSetVector< T >::end(), TrackingNtuple::SimHitData::event, hit::id, iEvent, includeTrackingParticles_, 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, phase2OTRecHitToken_, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), and TrackingNtuple::SimHitData::type.

Referenced by analyze().

◆ fillPixelHits()

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

Definition at line 2479 of file TrackingNtuple.cc.

2487  {
2488  edm::Handle<SiPixelRecHitCollection> pixelHits;
2489  iEvent.getByToken(pixelRecHitToken_, pixelHits);
2490  for (auto it = pixelHits->begin(); it != pixelHits->end(); it++) {
2491  const DetId hitId = it->detId();
2492  for (auto hit = it->begin(); hit != it->end(); hit++) {
2493  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
2494 
2495  hitProductIds.insert(hit->cluster().id());
2496 
2497  const int key = hit->cluster().key();
2498  const int lay = tTopo.layer(hitId);
2499 
2500  pix_isBarrel.push_back(hitId.subdetId() == 1);
2501  pix_detId.push_back(tTopo, hitId);
2502  pix_trkIdx.emplace_back(); // filled in fillTracks
2503  pix_seeIdx.emplace_back(); // filled in fillSeeds
2504  pix_x.push_back(ttrh->globalPosition().x());
2505  pix_y.push_back(ttrh->globalPosition().y());
2506  pix_z.push_back(ttrh->globalPosition().z());
2507  pix_xx.push_back(ttrh->globalPositionError().cxx());
2508  pix_xy.push_back(ttrh->globalPositionError().cyx());
2509  pix_yy.push_back(ttrh->globalPositionError().cyy());
2510  pix_yz.push_back(ttrh->globalPositionError().czy());
2511  pix_zz.push_back(ttrh->globalPositionError().czz());
2512  pix_zx.push_back(ttrh->globalPositionError().czx());
2513  pix_radL.push_back(ttrh->surface()->mediumProperties().radLen());
2514  pix_bbxi.push_back(ttrh->surface()->mediumProperties().xi());
2515 
2516  LogTrace("TrackingNtuple") << "pixHit cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
2517  << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
2518  if (includeTrackingParticles_) {
2519  SimHitData simHitData = matchCluster(hit->firstClusterRef(),
2520  hitId,
2521  key,
2522  ttrh,
2523  clusterToTPMap,
2524  tpKeyToIndex,
2525  simHitsTPAssoc,
2526  digiSimLink,
2527  simHitRefKeyToIndex,
2528  HitType::Pixel);
2529  pix_simHitIdx.push_back(simHitData.matchingSimHit);
2530  pix_simType.push_back(static_cast<int>(simHitData.type));
2531  pix_chargeFraction.push_back(simHitData.chargeFraction);
2532  LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
2533  if (!simHitData.matchingSimHit.empty()) {
2534  const auto simHitIdx = simHitData.matchingSimHit[0];
2535  LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
2536  << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2537  << " energyLoss=" << simhit_eloss[simHitIdx]
2538  << " particleType=" << simhit_particle[simHitIdx]
2539  << " processType=" << simhit_process[simHitIdx]
2540  << " bunchCrossing=" << simHitData.bunchCrossing[0]
2541  << " event=" << simHitData.event[0];
2542  }
2543  }
2544  }
2545  }
2546 }

References edmNew::DetSetVector< T >::begin(), TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, edmNew::DetSetVector< T >::end(), TrackingNtuple::SimHitData::event, hit::id, iEvent, includeTrackingParticles_, 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, pixelRecHitToken_, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), and TrackingNtuple::SimHitData::type.

Referenced by analyze().

◆ fillSeeds()

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

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

Definition at line 2757 of file TrackingNtuple.cc.

2768  {
2769  TSCBLBuilderNoMaterial tscblBuilder;
2770  for (size_t iColl = 0; iColl < seedTokens_.size(); ++iColl) {
2771  const auto& seedToken = seedTokens_[iColl];
2772 
2773  edm::Handle<edm::View<reco::Track>> seedTracksHandle;
2774  iEvent.getByToken(seedToken, seedTracksHandle);
2775  const auto& seedTracks = *seedTracksHandle;
2776 
2777  if (seedTracks.empty())
2778  continue;
2779 
2780  edm::EDConsumerBase::Labels labels;
2781  labelsForToken(seedToken, labels);
2782 
2783  const auto& seedStopInfoToken = seedStopInfoTokens_[iColl];
2784  edm::Handle<std::vector<SeedStopInfo>> seedStopInfoHandle;
2785  iEvent.getByToken(seedStopInfoToken, seedStopInfoHandle);
2786  const auto& seedStopInfos = *seedStopInfoHandle;
2787  if (seedTracks.size() != seedStopInfos.size()) {
2788  edm::EDConsumerBase::Labels labels2;
2789  labelsForToken(seedStopInfoToken, labels2);
2790 
2791  throw cms::Exception("LogicError") << "Got " << seedTracks.size() << " seeds, but " << seedStopInfos.size()
2792  << " seed stopping infos for collections " << labels.module << ", "
2793  << labels2.module;
2794  }
2795 
2796  // The associator interfaces really need to be fixed...
2797  edm::RefToBaseVector<reco::Track> seedTrackRefs;
2798  for (edm::View<reco::Track>::size_type i = 0; i < seedTracks.size(); ++i) {
2799  seedTrackRefs.push_back(seedTracks.refAt(i));
2800  }
2801  reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(seedTrackRefs, tpCollection);
2802  reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(seedTrackRefs, tpCollection);
2803 
2804  TString label = labels.module;
2805  //format label to match algoName
2806  label.ReplaceAll("seedTracks", "");
2807  label.ReplaceAll("Seeds", "");
2808  label.ReplaceAll("muonSeeded", "muonSeededStep");
2809  int algo = reco::TrackBase::algoByName(label.Data());
2810 
2811  edm::ProductID id = seedTracks[0].seedRef().id();
2812  const auto offset = see_fitok.size();
2813  auto inserted = seedCollToOffset.emplace(id, offset);
2814  if (!inserted.second)
2815  throw cms::Exception("Configuration")
2816  << "Trying to add seeds with ProductID " << id << " for a second time from collection " << labels.module
2817  << ", seed algo " << label << ". Typically this is caused by a configuration problem.";
2818  see_offset.push_back(offset);
2819 
2820  LogTrace("TrackingNtuple") << "NEW SEED LABEL: " << label << " size: " << seedTracks.size() << " algo=" << algo
2821  << " ProductID " << id;
2822 
2823  for (size_t iSeed = 0; iSeed < seedTrackRefs.size(); ++iSeed) {
2824  const auto& seedTrackRef = seedTrackRefs[iSeed];
2825  const auto& seedTrack = *seedTrackRef;
2826  const auto& seedRef = seedTrack.seedRef();
2827  const auto& seed = *seedRef;
2828 
2829  const auto seedStopInfo = seedStopInfos[iSeed];
2830 
2831  if (seedRef.id() != id)
2832  throw cms::Exception("LogicError")
2833  << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the "
2834  "element 0 had ProductID "
2835  << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id()
2836  << ". The source collection is " << labels.module << ".";
2837 
2838  std::vector<int> tpIdx;
2839  std::vector<float> sharedFraction;
2840  auto foundTPs = recSimColl.find(seedTrackRef);
2841  if (foundTPs != recSimColl.end()) {
2842  for (const auto& tpQuality : foundTPs->val) {
2843  tpIdx.push_back(tpKeyToIndex.at(tpQuality.first.key()));
2844  sharedFraction.push_back(tpQuality.second);
2845  }
2846  }
2847 
2848  // Search for a best-matching TrackingParticle for a seed
2849  const int nHits = seedTrack.numberOfValidHits();
2850  const auto clusters = track_associator::hitsToClusterRefs(
2851  seedTrack.recHitsBegin(),
2852  seedTrack.recHitsEnd()); // TODO: this function is called 3 times per track, try to reduce
2853  const int nClusters = clusters.size();
2854  const auto bestKeyCount = findBestMatchingTrackingParticle(seedTrack, clusterToTPMap, tpKeyToIndex);
2855  const float bestShareFrac =
2856  nClusters > 0 ? static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(nClusters) : 0;
2857  // Another way starting from the first hit of the seed
2858  const auto bestFirstHitKeyCount =
2859  findMatchingTrackingParticleFromFirstHit(seedTrack, clusterToTPMap, tpKeyToIndex);
2860  const float bestFirstHitShareFrac =
2861  nClusters > 0 ? static_cast<float>(bestFirstHitKeyCount.countClusters) / static_cast<float>(nClusters) : 0;
2862 
2863  const bool seedFitOk = !trackFromSeedFitFailed(seedTrack);
2864  const int charge = seedTrack.charge();
2865  const float pt = seedFitOk ? seedTrack.pt() : 0;
2866  const float eta = seedFitOk ? seedTrack.eta() : 0;
2867  const float phi = seedFitOk ? seedTrack.phi() : 0;
2868 
2869  const auto seedIndex = see_fitok.size();
2870 
2871  see_fitok.push_back(seedFitOk);
2872 
2873  see_px.push_back(seedFitOk ? seedTrack.px() : 0);
2874  see_py.push_back(seedFitOk ? seedTrack.py() : 0);
2875  see_pz.push_back(seedFitOk ? seedTrack.pz() : 0);
2876  see_pt.push_back(pt);
2877  see_eta.push_back(eta);
2878  see_phi.push_back(phi);
2879  see_q.push_back(charge);
2880  see_nValid.push_back(nHits);
2881 
2882  see_dxy.push_back(seedFitOk ? seedTrack.dxy(bs.position()) : 0);
2883  see_dz.push_back(seedFitOk ? seedTrack.dz(bs.position()) : 0);
2884  see_ptErr.push_back(seedFitOk ? seedTrack.ptError() : 0);
2885  see_etaErr.push_back(seedFitOk ? seedTrack.etaError() : 0);
2886  see_phiErr.push_back(seedFitOk ? seedTrack.phiError() : 0);
2887  see_dxyErr.push_back(seedFitOk ? seedTrack.dxyError() : 0);
2888  see_dzErr.push_back(seedFitOk ? seedTrack.dzError() : 0);
2889  see_algo.push_back(algo);
2890  see_stopReason.push_back(seedStopInfo.stopReasonUC());
2891  see_nCands.push_back(seedStopInfo.candidatesPerSeed());
2892 
2893  const auto& state = seedTrack.seedRef()->startingState();
2894  const auto& pos = state.parameters().position();
2895  const auto& mom = state.parameters().momentum();
2896  see_statePt.push_back(state.pt());
2897  see_stateTrajX.push_back(pos.x());
2898  see_stateTrajY.push_back(pos.y());
2899  see_stateTrajPx.push_back(mom.x());
2900  see_stateTrajPy.push_back(mom.y());
2901  see_stateTrajPz.push_back(mom.z());
2902 
2903  see_trkIdx.push_back(-1); // to be set correctly in fillTracks
2904  if (includeTrackingParticles_) {
2905  see_simTrkIdx.push_back(tpIdx);
2906  see_simTrkShareFrac.push_back(sharedFraction);
2907  see_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
2908  see_bestFromFirstHitSimTrkIdx.push_back(
2909  bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key) : -1);
2910  } else {
2911  see_isTrue.push_back(!tpIdx.empty());
2912  }
2913  see_bestSimTrkShareFrac.push_back(bestShareFrac);
2914  see_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
2915 
2917  /*
2918  TransientTrackingRecHit::RecHitPointer lastRecHit = theTTRHBuilder.build(&*(seed.recHits().second-1));
2919  TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( itSeed->startingState(), lastRecHit->surface(), &theMF);
2920  float pt = state.globalParameters().momentum().perp();
2921  float eta = state.globalParameters().momentum().eta();
2922  float phi = state.globalParameters().momentum().phi();
2923  see_px .push_back( state.globalParameters().momentum().x() );
2924  see_py .push_back( state.globalParameters().momentum().y() );
2925  see_pz .push_back( state.globalParameters().momentum().z() );
2926  */
2927 
2928  std::vector<int> hitIdx;
2929  std::vector<int> hitType;
2930 
2931  for (auto const& hit : seed.recHits()) {
2932  TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder.build(&hit);
2933  int subid = recHit->geographicalId().subdetId();
2934  if (subid == (int)PixelSubdetector::PixelBarrel || subid == (int)PixelSubdetector::PixelEndcap) {
2935  const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
2936  const auto& clusterRef = bhit->firstClusterRef();
2937  const auto clusterKey = clusterRef.cluster_pixel().key();
2938  if (includeAllHits_) {
2939  checkProductID(hitProductIds, clusterRef.id(), "seed");
2940  pix_seeIdx[clusterKey].push_back(seedIndex);
2941  }
2942  hitIdx.push_back(clusterKey);
2943  hitType.push_back(static_cast<int>(HitType::Pixel));
2944  } else if (subid == (int)StripSubdetector::TOB || subid == (int)StripSubdetector::TID ||
2945  subid == (int)StripSubdetector::TIB || subid == (int)StripSubdetector::TEC) {
2946  if (trackerHitRTTI::isMatched(*recHit)) {
2947  const SiStripMatchedRecHit2D* matchedHit = dynamic_cast<const SiStripMatchedRecHit2D*>(&*recHit);
2948  if (includeAllHits_) {
2949  checkProductID(hitProductIds, matchedHit->monoClusterRef().id(), "seed");
2950  checkProductID(hitProductIds, matchedHit->stereoClusterRef().id(), "seed");
2951  }
2952  int monoIdx = matchedHit->monoClusterRef().key();
2953  int stereoIdx = matchedHit->stereoClusterRef().key();
2954 
2955  std::vector<std::pair<int, int>>::iterator pos =
2956  find(monoStereoClusterList.begin(), monoStereoClusterList.end(), std::make_pair(monoIdx, stereoIdx));
2957  size_t gluedIndex = -1;
2958  if (pos != monoStereoClusterList.end()) {
2959  gluedIndex = std::distance(monoStereoClusterList.begin(), pos);
2960  } else {
2961  // We can encounter glued hits not in the input
2962  // SiStripMatchedRecHit2DCollection, e.g. via muon
2963  // outside-in seeds (or anything taking hits from
2964  // MeasurementTrackerEvent). So let's add them here.
2965  gluedIndex = addStripMatchedHit(*matchedHit, theTTRHBuilder, tTopo, monoStereoClusterList);
2966  }
2967 
2968  if (includeAllHits_)
2969  glu_seeIdx[gluedIndex].push_back(seedIndex);
2970  hitIdx.push_back(gluedIndex);
2971  hitType.push_back(static_cast<int>(HitType::Glued));
2972  } else {
2973  const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
2974  const auto& clusterRef = bhit->firstClusterRef();
2975  unsigned int clusterKey;
2976  if (clusterRef.isPhase2()) {
2977  clusterKey = clusterRef.cluster_phase2OT().key();
2978  } else {
2979  clusterKey = clusterRef.cluster_strip().key();
2980  }
2981 
2982  if (includeAllHits_) {
2983  checkProductID(hitProductIds, clusterRef.id(), "seed");
2984  if (clusterRef.isPhase2()) {
2985  ph2_seeIdx[clusterKey].push_back(seedIndex);
2986  } else {
2987  str_seeIdx[clusterKey].push_back(seedIndex);
2988  }
2989  }
2990 
2991  hitIdx.push_back(clusterKey);
2992  if (clusterRef.isPhase2()) {
2993  hitType.push_back(static_cast<int>(HitType::Phase2OT));
2994  } else {
2995  hitType.push_back(static_cast<int>(HitType::Strip));
2996  }
2997  }
2998  } else {
2999  LogTrace("TrackingNtuple") << " not pixel and not Strip detector";
3000  }
3001  }
3002  see_hitIdx.push_back(hitIdx);
3003  see_hitType.push_back(hitType);
3004  see_nPixel.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Pixel)));
3005  see_nGlued.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Glued)));
3006  see_nStrip.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Strip)));
3007  see_nPhase2OT.push_back(std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Phase2OT)));
3008  see_nCluster.push_back(nClusters);
3009  //the part below is not strictly needed
3010  float chi2 = -1;
3011  if (nHits == 2) {
3012  TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().begin()));
3013  TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().begin() + 1));
3014  std::vector<GlobalPoint> gp(2);
3015  std::vector<GlobalError> ge(2);
3016  gp[0] = recHit0->globalPosition();
3017  ge[0] = recHit0->globalPositionError();
3018  gp[1] = recHit1->globalPosition();
3019  ge[1] = recHit1->globalPositionError();
3020  LogTrace("TrackingNtuple")
3021  << "seed " << seedTrackRef.key() << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
3022  << " - PAIR - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
3023  << " hitpos: " << gp[0] << " " << gp[1] << " trans0: "
3024  << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[0]->globalPosition()
3025  : GlobalPoint(0, 0, 0))
3026  << " "
3027  << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[1]->globalPosition()
3028  : GlobalPoint(0, 0, 0))
3029  << " trans1: "
3030  << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[0]->globalPosition()
3031  : GlobalPoint(0, 0, 0))
3032  << " "
3033  << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[1]->globalPosition()
3034  : GlobalPoint(0, 0, 0))
3035  << " eta,phi: " << gp[0].eta() << "," << gp[0].phi();
3036  } else if (nHits == 3) {
3037  TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().begin()));
3038  TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().begin() + 1));
3039  TransientTrackingRecHit::RecHitPointer recHit2 = theTTRHBuilder.build(&*(seed.recHits().begin() + 2));
3040  declareDynArray(GlobalPoint, 4, gp);
3041  declareDynArray(GlobalError, 4, ge);
3042  declareDynArray(bool, 4, bl);
3043  gp[0] = recHit0->globalPosition();
3044  ge[0] = recHit0->globalPositionError();
3045  int subid0 = recHit0->geographicalId().subdetId();
3046  bl[0] = (subid0 == StripSubdetector::TIB || subid0 == StripSubdetector::TOB ||
3047  subid0 == (int)PixelSubdetector::PixelBarrel);
3048  gp[1] = recHit1->globalPosition();
3049  ge[1] = recHit1->globalPositionError();
3050  int subid1 = recHit1->geographicalId().subdetId();
3051  bl[1] = (subid1 == StripSubdetector::TIB || subid1 == StripSubdetector::TOB ||
3052  subid1 == (int)PixelSubdetector::PixelBarrel);
3053  gp[2] = recHit2->globalPosition();
3054  ge[2] = recHit2->globalPositionError();
3055  int subid2 = recHit2->geographicalId().subdetId();
3056  bl[2] = (subid2 == StripSubdetector::TIB || subid2 == StripSubdetector::TOB ||
3057  subid2 == (int)PixelSubdetector::PixelBarrel);
3058  RZLine rzLine(gp, ge, bl);
3059  float seed_chi2 = rzLine.chi2();
3060  //float seed_pt = state.globalParameters().momentum().perp();
3061  float seed_pt = pt;
3062  LogTrace("TrackingNtuple")
3063  << "seed " << seedTrackRef.key() << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
3064  << " - TRIPLET - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
3065  << " " << recHit2->geographicalId().rawId() << " hitpos: " << gp[0] << " " << gp[1] << " " << gp[2]
3066  << " trans0: "
3067  << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[0]->globalPosition()
3068  : GlobalPoint(0, 0, 0))
3069  << " "
3070  << (recHit0->transientHits().size() > 1 ? recHit0->transientHits()[1]->globalPosition()
3071  : GlobalPoint(0, 0, 0))
3072  << " trans1: "
3073  << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[0]->globalPosition()
3074  : GlobalPoint(0, 0, 0))
3075  << " "
3076  << (recHit1->transientHits().size() > 1 ? recHit1->transientHits()[1]->globalPosition()
3077  : GlobalPoint(0, 0, 0))
3078  << " trans2: "
3079  << (recHit2->transientHits().size() > 1 ? recHit2->transientHits()[0]->globalPosition()
3080  : GlobalPoint(0, 0, 0))
3081  << " "
3082  << (recHit2->transientHits().size() > 1 ? recHit2->transientHits()[1]->globalPosition()
3083  : GlobalPoint(0, 0, 0))
3084  << " local: "
3085  << recHit2->localPosition()
3086  //<< " tsos pos, mom: " << state.globalPosition()<<" "<<state.globalMomentum()
3087  << " eta,phi: " << gp[0].eta() << "," << gp[0].phi() << " pt,chi2: " << seed_pt << "," << seed_chi2;
3088  chi2 = seed_chi2;
3089  }
3090  see_chi2.push_back(chi2);
3091  }
3092 
3093  fillTrackingParticlesForSeeds(tpCollection, simRecColl, tpKeyToIndex, offset);
3094  }
3095 }

References addStripMatchedHit(), reco::TrackBase::algoByName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), reco::TrackToTrackingParticleAssociator::associateSimToReco(), cms::cuda::bs, TransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, RZLine::chi2(), OmniClusterRef::cluster_phase2OT(), OmniClusterRef::cluster_pixel(), bsc_activity_cfg::clusters, submitPVResolutionJobs::count, declareDynArray, HLT_FULL_cff::distance, edm::AssociationMap< Tag >::end(), PVValHelper::eta, Exception, fillTrackingParticlesForSeeds(), spr::find(), edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), glu_seeIdx, Glued, runTauDisplay::gp, track_associator::hitsToClusterRefs(), mps_fire::i, triggerObjects_cff::id, OmniClusterRef::id(), iEvent, includeAllHits_, includeTrackingParticles_, createfilelist::int, trackerHitRTTI::isMatched(), OmniClusterRef::key(), edm::Ref< C, T, F >::key(), label, SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), LogTrace, edm::ProductLabels::module, SiStripMatchedRecHit2D::monoClusterRef(), heavyionUCCDQM_cfi::nClusters, nHits, hltrates_dqm_sourceclient-live_cfg::offset, ph2_seeIdx, Phase2OT, phi, pix_seeIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, DiDispStaMuonMonitor_cfi::pt, edm::RefToBaseVector< T >::push_back(), rpcPointValidation_cfi::recHit, see_algo, see_bestFromFirstHitSimTrkIdx, see_bestFromFirstHitSimTrkShareFrac, see_bestSimTrkIdx, see_bestSimTrkShareFrac, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_isTrue, see_nCands, see_nCluster, see_nGlued, see_nPhase2OT, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_simTrkIdx, see_simTrkShareFrac, see_statePt, see_stateTrajPx, see_stateTrajPy, see_stateTrajPz, see_stateTrajX, see_stateTrajY, see_stopReason, see_trkIdx, fileCollector::seed, seedStopInfoTokens_, seedTokens_, 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().

◆ fillSimHits()

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

Definition at line 2367 of file TrackingNtuple.cc.

2372  {
2373  for (const auto& assoc : simHitsTPAssoc) {
2374  auto tpKey = assoc.first.key();
2375 
2376  // SimHitTPAssociationList can contain more TrackingParticles than
2377  // what are given to this EDAnalyzer, so we can filter those out here.
2378  auto found = tpKeyToIndex.find(tpKey);
2379  if (found == tpKeyToIndex.end())
2380  continue;
2381  const auto tpIndex = found->second;
2382 
2383  // skip non-tracker simhits (mostly muons)
2384  const auto& simhit = *(assoc.second);
2385  auto detId = DetId(simhit.detUnitId());
2386  if (detId.det() != DetId::Tracker)
2387  continue;
2388 
2389  // Skip electron SimHits for non-electron TrackingParticles to
2390  // filter out delta rays. The delta ray hits just confuse. If we
2391  // need them later, let's add them as a separate "collection" of
2392  // hits of a TP
2393  const TrackingParticle& tp = *(assoc.first);
2394  if (std::abs(simhit.particleType()) == 11 && std::abs(tp.pdgId()) != 11)
2395  continue;
2396 
2397  auto simHitKey = std::make_pair(assoc.second.key(), assoc.second.id());
2398 
2399  if (simHitRefKeyToIndex.find(simHitKey) != simHitRefKeyToIndex.end()) {
2400  for (const auto& assoc2 : simHitsTPAssoc) {
2401  if (std::make_pair(assoc2.second.key(), assoc2.second.id()) == simHitKey) {
2402 #ifdef EDM_ML_DEBUG
2403  auto range1 = std::equal_range(simHitsTPAssoc.begin(),
2404  simHitsTPAssoc.end(),
2405  std::make_pair(assoc.first, TrackPSimHitRef()),
2406  SimHitTPAssociationProducer::simHitTPAssociationListGreater);
2407  auto range2 = std::equal_range(simHitsTPAssoc.begin(),
2408  simHitsTPAssoc.end(),
2409  std::make_pair(assoc2.first, TrackPSimHitRef()),
2410  SimHitTPAssociationProducer::simHitTPAssociationListGreater);
2411 
2412  LogTrace("TrackingNtuple") << "Earlier TP " << assoc2.first.key() << " SimTrack Ids";
2413  for (const auto& simTrack : assoc2.first->g4Tracks()) {
2414  edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event "
2415  << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
2416  }
2417  for (auto iHit = range2.first; iHit != range2.second; ++iHit) {
2418  LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof "
2419  << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event "
2420  << iHit->second->eventId().bunchCrossing() << ":"
2421  << iHit->second->eventId().event();
2422  }
2423  LogTrace("TrackingNtuple") << "Current TP " << assoc.first.key() << " SimTrack Ids";
2424  for (const auto& simTrack : assoc.first->g4Tracks()) {
2425  edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event "
2426  << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
2427  }
2428  for (auto iHit = range1.first; iHit != range1.second; ++iHit) {
2429  LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof "
2430  << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event "
2431  << iHit->second->eventId().bunchCrossing() << ":"
2432  << iHit->second->eventId().event();
2433  }
2434 #endif
2435 
2436  throw cms::Exception("LogicError")
2437  << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second
2438  << ", first time with TrackingParticle " << assoc2.first.key() << ", now with " << tpKey;
2439  }
2440  }
2441  throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of "
2442  << simHitKey.second << ", now with TrackingParticle " << tpKey
2443  << ", but I didn't find the first occurrance!";
2444  }
2445 
2446  auto det = tracker.idToDetUnit(detId);
2447  if (!det)
2448  throw cms::Exception("LogicError") << "Did not find a det unit for DetId " << simhit.detUnitId()
2449  << " from tracker geometry";
2450 
2451  const auto pos = det->surface().toGlobal(simhit.localPosition());
2452  const float tof = simhit.timeOfFlight();
2453 
2454  const auto simHitIndex = simhit_x.size();
2455  simHitRefKeyToIndex[simHitKey] = simHitIndex;
2456 
2457  if (includeStripHits_)
2458  simhit_detId.push_back(tTopo, detId);
2459  else
2460  simhit_detId_phase2.push_back(tTopo, detId);
2461  simhit_x.push_back(pos.x());
2462  simhit_y.push_back(pos.y());
2463  simhit_z.push_back(pos.z());
2464  simhit_particle.push_back(simhit.particleType());
2465  simhit_process.push_back(simhit.processType());
2466  simhit_eloss.push_back(simhit.energyLoss());
2467  simhit_tof.push_back(tof);
2468  //simhit_simTrackId.push_back(simhit.trackId());
2469 
2470  simhit_simTrkIdx.push_back(tpIndex);
2471 
2472  simhit_hitIdx.emplace_back(); // filled in matchCluster
2473  simhit_hitType.emplace_back(); // filled in matchCluster
2474 
2475  tpHitList.emplace_back(tpKey, simHitIndex, tof, simhit.detUnitId());
2476  }
2477 }

References funct::abs(), trackingPlots::assoc, DetId::det(), Exception, newFWLiteAna::found, includeStripHits_, LogTrace, 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(), cscDigiValidation_cfi::simTrack, cmsswSequenceInfo::tp, DetId::Tracker, and PbPb_ZMuSkimMuonDPG_cff::tracker.

Referenced by analyze().

◆ fillStripMatchedHits()

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

Definition at line 2675 of file TrackingNtuple.cc.

2678  {
2679  edm::Handle<SiStripMatchedRecHit2DCollection> matchedHits;
2680  iEvent.getByToken(stripMatchedRecHitToken_, matchedHits);
2681  for (auto it = matchedHits->begin(); it != matchedHits->end(); it++) {
2682  for (auto hit = it->begin(); hit != it->end(); hit++) {
2683  addStripMatchedHit(*hit, theTTRHBuilder, tTopo, monoStereoClusterList);
2684  }
2685  }
2686 }

References addStripMatchedHit(), edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::end(), iEvent, and stripMatchedRecHitToken_.

Referenced by analyze().

◆ fillStripRphiStereoHits()

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

Definition at line 2548 of file TrackingNtuple.cc.

2556  {
2557  //index strip hit branches by cluster index
2558  edm::Handle<SiStripRecHit2DCollection> rphiHits;
2559  iEvent.getByToken(stripRphiRecHitToken_, rphiHits);
2560  edm::Handle<SiStripRecHit2DCollection> stereoHits;
2561  iEvent.getByToken(stripStereoRecHitToken_, stereoHits);
2562  int totalStripHits = rphiHits->dataSize() + stereoHits->dataSize();
2563  str_isBarrel.resize(totalStripHits);
2564  str_detId.resize(totalStripHits);
2565  str_trkIdx.resize(totalStripHits); // filled in fillTracks
2566  str_seeIdx.resize(totalStripHits); // filled in fillSeeds
2567  str_simHitIdx.resize(totalStripHits);
2568  str_simType.resize(totalStripHits);
2569  str_chargeFraction.resize(totalStripHits);
2570  str_x.resize(totalStripHits);
2571  str_y.resize(totalStripHits);
2572  str_z.resize(totalStripHits);
2573  str_xx.resize(totalStripHits);
2574  str_xy.resize(totalStripHits);
2575  str_yy.resize(totalStripHits);
2576  str_yz.resize(totalStripHits);
2577  str_zz.resize(totalStripHits);
2578  str_zx.resize(totalStripHits);
2579  str_radL.resize(totalStripHits);
2580  str_bbxi.resize(totalStripHits);
2581 
2582  auto fill = [&](const SiStripRecHit2DCollection& hits, const char* name) {
2583  for (const auto& detset : hits) {
2584  const DetId hitId = detset.detId();
2585  for (const auto& hit : detset) {
2586  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
2587 
2588  hitProductIds.insert(hit.cluster().id());
2589 
2590  const int key = hit.cluster().key();
2591  const int lay = tTopo.layer(hitId);
2592  str_isBarrel[key] = (hitId.subdetId() == StripSubdetector::TIB || hitId.subdetId() == StripSubdetector::TOB);
2593  str_detId.set(key, tTopo, hitId);
2594  str_x[key] = ttrh->globalPosition().x();
2595  str_y[key] = ttrh->globalPosition().y();
2596  str_z[key] = ttrh->globalPosition().z();
2597  str_xx[key] = ttrh->globalPositionError().cxx();
2598  str_xy[key] = ttrh->globalPositionError().cyx();
2599  str_yy[key] = ttrh->globalPositionError().cyy();
2600  str_yz[key] = ttrh->globalPositionError().czy();
2601  str_zz[key] = ttrh->globalPositionError().czz();
2602  str_zx[key] = ttrh->globalPositionError().czx();
2603  str_radL[key] = ttrh->surface()->mediumProperties().radLen();
2604  str_bbxi[key] = ttrh->surface()->mediumProperties().xi();
2605  LogTrace("TrackingNtuple") << name << " cluster=" << key << " subdId=" << hitId.subdetId() << " lay=" << lay
2606  << " rawId=" << hitId.rawId() << " pos =" << ttrh->globalPosition();
2607 
2608  if (includeTrackingParticles_) {
2609  SimHitData simHitData = matchCluster(hit.firstClusterRef(),
2610  hitId,
2611  key,
2612  ttrh,
2613  clusterToTPMap,
2614  tpKeyToIndex,
2615  simHitsTPAssoc,
2616  digiSimLink,
2617  simHitRefKeyToIndex,
2618  HitType::Strip);
2619  str_simHitIdx[key] = simHitData.matchingSimHit;
2620  str_simType[key] = static_cast<int>(simHitData.type);
2621  str_chargeFraction[key] = simHitData.chargeFraction;
2622  LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
2623  if (!simHitData.matchingSimHit.empty()) {
2624  const auto simHitIdx = simHitData.matchingSimHit[0];
2625  LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx << " simHitPos="
2626  << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2627  << " simHitPos="
2628  << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2629  << " energyLoss=" << simhit_eloss[simHitIdx]
2630  << " particleType=" << simhit_particle[simHitIdx]
2631  << " processType=" << simhit_process[simHitIdx]
2632  << " bunchCrossing=" << simHitData.bunchCrossing[0]
2633  << " event=" << simHitData.event[0];
2634  }
2635  }
2636  }
2637  }
2638  };
2639 
2640  fill(*rphiHits, "stripRPhiHit");
2641  fill(*stereoHits, "stripStereoHit");
2642 }

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

Referenced by analyze().

◆ fillTrackingParticles()

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

Definition at line 3379 of file TrackingNtuple.cc.

3387  {
3388  const ParametersDefinerForTP* parametersDefiner = &iSetup.getData(paramsDefineToken_);
3389 
3390  // Number of 3D layers for TPs
3391  edm::Handle<edm::ValueMap<unsigned int>> tpNLayersH;
3392  iEvent.getByToken(tpNLayersToken_, tpNLayersH);
3393  const auto& nLayers_tPCeff = *tpNLayersH;
3394 
3395  iEvent.getByToken(tpNPixelLayersToken_, tpNLayersH);
3396  const auto& nPixelLayers_tPCeff = *tpNLayersH;
3397 
3398  iEvent.getByToken(tpNStripStereoLayersToken_, tpNLayersH);
3399  const auto& nStripMonoAndStereoLayers_tPCeff = *tpNLayersH;
3400 
3401  reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(tracks, tpCollection);
3402 
3403  for (const TrackingParticleRef& tp : tpCollection) {
3404  LogTrace("TrackingNtuple") << "tracking particle pt=" << tp->pt() << " eta=" << tp->eta() << " phi=" << tp->phi();
3405  bool isRecoMatched = false;
3406  std::vector<int> tkIdx;
3407  std::vector<float> sharedFraction;
3408  auto foundTracks = simRecColl.find(tp);
3409  if (foundTracks != simRecColl.end()) {
3410  isRecoMatched = true;
3411  for (const auto& trackQuality : foundTracks->val) {
3412  sharedFraction.push_back(trackQuality.second);
3413  tkIdx.push_back(trackQuality.first.key());
3414  }
3415  }
3416 
3417  sim_genPdgIds.emplace_back();
3418  for (const auto& genRef : tp->genParticles()) {
3419  if (genRef.isNonnull())
3420  sim_genPdgIds.back().push_back(genRef->pdgId());
3421  }
3422 
3423  bool isFromBHadron = false;
3424  // Logic is similar to SimTracker/TrackHistory
3425  if (tracer_.evaluate(tp)) { // ignore TP if history can not be traced
3426  // following is from TrackClassifier::processesAtGenerator()
3427  HistoryBase::RecoGenParticleTrail const& recoGenParticleTrail = tracer_.recoGenParticleTrail();
3428  for (const auto& particle : recoGenParticleTrail) {
3429  HepPDT::ParticleID particleID(particle->pdgId());
3430  if (particleID.hasBottom()) {
3431  isFromBHadron = true;
3432  break;
3433  }
3434  }
3435  }
3436 
3437  LogTrace("TrackingNtuple") << "matched to tracks = " << make_VectorPrinter(tkIdx)
3438  << " isRecoMatched=" << isRecoMatched;
3439  sim_event.push_back(tp->eventId().event());
3440  sim_bunchCrossing.push_back(tp->eventId().bunchCrossing());
3441  sim_pdgId.push_back(tp->pdgId());
3442  sim_isFromBHadron.push_back(isFromBHadron);
3443  sim_px.push_back(tp->px());
3444  sim_py.push_back(tp->py());
3445  sim_pz.push_back(tp->pz());
3446  sim_pt.push_back(tp->pt());
3447  sim_eta.push_back(tp->eta());
3448  sim_phi.push_back(tp->phi());
3449  sim_q.push_back(tp->charge());
3450  sim_trkIdx.push_back(tkIdx);
3451  sim_trkShareFrac.push_back(sharedFraction);
3452  sim_parentVtxIdx.push_back(tvKeyToIndex.at(tp->parentVertex().key()));
3453  std::vector<int> decayIdx;
3454  for (const auto& v : tp->decayVertices())
3455  decayIdx.push_back(tvKeyToIndex.at(v.key()));
3456  sim_decayVtxIdx.push_back(decayIdx);
3457 
3458  //Calcualte the impact parameters w.r.t. PCA
3459  TrackingParticle::Vector momentum = parametersDefiner->momentum(iEvent, iSetup, tp);
3460  TrackingParticle::Point vertex = parametersDefiner->vertex(iEvent, iSetup, tp);
3461  auto dxySim = TrackingParticleIP::dxy(vertex, momentum, bs.position());
3462  auto dzSim = TrackingParticleIP::dz(vertex, momentum, bs.position());
3463  const double lambdaSim = M_PI / 2 - momentum.theta();
3464  sim_pca_pt.push_back(std::sqrt(momentum.perp2()));
3465  sim_pca_eta.push_back(momentum.Eta());
3466  sim_pca_lambda.push_back(lambdaSim);
3467  sim_pca_cotTheta.push_back(1 / tan(M_PI * 0.5 - lambdaSim));
3468  sim_pca_phi.push_back(momentum.phi());
3469  sim_pca_dxy.push_back(dxySim);
3470  sim_pca_dz.push_back(dzSim);
3471 
3472  std::vector<int> hitIdx;
3473  int nPixel = 0, nStrip = 0;
3474  auto rangeHit = std::equal_range(tpHitList.begin(), tpHitList.end(), TPHitIndex(tp.key()), tpHitIndexListLess);
3475  for (auto ip = rangeHit.first; ip != rangeHit.second; ++ip) {
3476  auto type = HitType::Unknown;
3477  if (!simhit_hitType[ip->simHitIdx].empty())
3478  type = static_cast<HitType>(simhit_hitType[ip->simHitIdx][0]);
3479  LogTrace("TrackingNtuple") << "simhit=" << ip->simHitIdx << " type=" << static_cast<int>(type);
3480  hitIdx.push_back(ip->simHitIdx);
3481  const auto detid = DetId(includeStripHits_ ? simhit_detId[ip->simHitIdx] : simhit_detId_phase2[ip->simHitIdx]);
3482  if (detid.det() != DetId::Tracker) {
3483  throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId "
3484  << detid.rawId() << " whose det() is not Tracker but " << detid.det();
3485  }
3486  const auto subdet = detid.subdetId();
3487  switch (subdet) {
3488  case PixelSubdetector::PixelBarrel:
3489  case PixelSubdetector::PixelEndcap:
3490  ++nPixel;
3491  break;
3492  case StripSubdetector::TIB:
3493  case StripSubdetector::TID:
3494  case StripSubdetector::TOB:
3495  case StripSubdetector::TEC:
3496  ++nStrip;
3497  break;
3498  default:
3499  throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId "
3500  << detid.rawId() << " whose subdet is not recognized, is " << subdet;
3501  };
3502  }
3503  sim_nValid.push_back(hitIdx.size());
3504  sim_nPixel.push_back(nPixel);
3505  sim_nStrip.push_back(nStrip);
3506 
3507  const auto nSimLayers = nLayers_tPCeff[tp];
3508  const auto nSimPixelLayers = nPixelLayers_tPCeff[tp];
3509  const auto nSimStripMonoAndStereoLayers = nStripMonoAndStereoLayers_tPCeff[tp];
3510  sim_nLay.push_back(nSimLayers);
3511  sim_nPixelLay.push_back(nSimPixelLayers);
3512  sim_n3DLay.push_back(nSimPixelLayers + nSimStripMonoAndStereoLayers);
3513 
3514  sim_nTrackerHits.push_back(tp->numberOfTrackerHits());
3515  auto found = tpKeyToClusterCount.find(tp.key());
3516  sim_nRecoClusters.push_back(found != cend(tpKeyToClusterCount) ? found->second : 0);
3517 
3518  sim_simHitIdx.push_back(hitIdx);
3519  }
3520 }

References reco::TrackToTrackingParticleAssociator::associateSimToReco(), cms::cuda::bs, TrackingParticleIP::dxy(), TrackingParticleIP::dz(), edm::AssociationMap< Tag >::end(), HistoryBase::evaluate(), Exception, edm::AssociationMap< Tag >::find(), newFWLiteAna::found, edm::EventSetup::getData(), iEvent, includeStripHits_, LogTrace, M_PI, MuonTrackValidator_cfi::parametersDefiner, paramsDefineToken_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, HistoryBase::recoGenParticleTrail(), sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_hitType, mathSSE::sqrt(), funct::tan(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, cmsswSequenceInfo::tp, tpHitIndexListLess(), tpNLayersToken_, tpNPixelLayersToken_, tpNStripStereoLayersToken_, tracer_, DetId::Tracker, StandaloneTrackMonitor_cfi::trackQuality, tracks, Unknown, findQualityFiles::v, and bphysicsOniaDQM_cfi::vertex.

Referenced by analyze().

◆ fillTrackingParticlesForSeeds()

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

Definition at line 3523 of file TrackingNtuple.cc.

3526  {
3527  if (sim_seedIdx.empty()) // first call
3528  sim_seedIdx.resize(tpCollection.size());
3529 
3530  for (const auto& keyVal : simRecColl) {
3531  const auto& tpRef = keyVal.key;
3532  auto found = tpKeyToIndex.find(tpRef.key());
3533  if (found == tpKeyToIndex.end())
3534  throw cms::Exception("Assert") << __FILE__ << ":" << __LINE__ << " fillTrackingParticlesForSeeds: tpRef.key() "
3535  << tpRef.key() << " not found from tpKeyToIndex. tpKeyToIndex size "
3536  << tpKeyToIndex.size();
3537  const auto tpIndex = found->second;
3538  for (const auto& pair : keyVal.val) {
3539  const auto& seedRef = pair.first->seedRef();
3540  sim_seedIdx[tpIndex].push_back(seedOffset + seedRef.key());
3541  }
3542  }
3543 }

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

Referenced by fillSeeds().

◆ fillTrackingVertices()

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

Definition at line 3578 of file TrackingNtuple.cc.

3579  {
3580  int current_event = -1;
3581  for (const auto& ref : trackingVertices) {
3582  const TrackingVertex v = *ref;
3583  if (v.eventId().event() != current_event) {
3584  // next PV
3585  current_event = v.eventId().event();
3586  simpv_idx.push_back(simvtx_x.size());
3587  }
3588 
3589  unsigned int processType = std::numeric_limits<unsigned int>::max();
3590  if (!v.g4Vertices().empty()) {
3591  processType = v.g4Vertices()[0].processType();
3592  }
3593 
3594  simvtx_event.push_back(v.eventId().event());
3595  simvtx_bunchCrossing.push_back(v.eventId().bunchCrossing());
3596  simvtx_processType.push_back(processType);
3597 
3598  simvtx_x.push_back(v.position().x());
3599  simvtx_y.push_back(v.position().y());
3600  simvtx_z.push_back(v.position().z());
3601 
3602  auto fill = [&](const TrackingParticleRefVector& tps, std::vector<int>& idx) {
3603  for (const auto& tpRef : tps) {
3604  auto found = tpKeyToIndex.find(tpRef.key());
3605  if (found != tpKeyToIndex.end()) {
3606  idx.push_back(found->second);
3607  }
3608  }
3609  };
3610 
3611  std::vector<int> sourceIdx;
3612  std::vector<int> daughterIdx;
3613  fill(v.sourceTracks(), sourceIdx);
3614  fill(v.daughterTracks(), daughterIdx);
3615 
3616  simvtx_sourceSimIdx.push_back(sourceIdx);
3617  simvtx_daughterSimIdx.push_back(daughterIdx);
3618  }
3619 }

References ntuplemaker::fill, newFWLiteAna::found, heavyIonCSV_trainingSettings::idx, SiStripPI::max, simpv_idx, simvtx_bunchCrossing, simvtx_daughterSimIdx, simvtx_event, simvtx_processType, simvtx_sourceSimIdx, simvtx_x, simvtx_y, simvtx_z, and findQualityFiles::v.

Referenced by analyze().

◆ fillTracks()

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

Definition at line 3097 of file TrackingNtuple.cc.

3111  {
3112  reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(tracks, tpCollection);
3113  edm::EDConsumerBase::Labels labels;
3114  labelsForToken(trackToken_, labels);
3115  LogTrace("TrackingNtuple") << "NEW TRACK LABEL: " << labels.module;
3116 
3117  auto pvPosition = vertices[0].position();
3118 
3119  for (size_t iTrack = 0; iTrack < tracks.size(); ++iTrack) {
3120  const auto& itTrack = tracks[iTrack];
3121  int charge = itTrack->charge();
3122  float pt = itTrack->pt();
3123  float eta = itTrack->eta();
3124  const double lambda = itTrack->lambda();
3125  float chi2 = itTrack->normalizedChi2();
3126  float ndof = itTrack->ndof();
3127  float phi = itTrack->phi();
3128  int nHits = itTrack->numberOfValidHits();
3129  const reco::HitPattern& hp = itTrack->hitPattern();
3130 
3131  const auto& tkParam = itTrack->parameters();
3132  auto tkCov = itTrack->covariance();
3133  tkCov.Invert();
3134 
3135  // Standard track-TP matching
3136  int nSimHits = 0;
3137  bool isSimMatched = false;
3138  std::vector<int> tpIdx;
3139  std::vector<float> sharedFraction;
3140  std::vector<float> tpChi2;
3141  auto foundTPs = recSimColl.find(itTrack);
3142  if (foundTPs != recSimColl.end()) {
3143  if (!foundTPs->val.empty()) {
3144  nSimHits = foundTPs->val[0].first->numberOfTrackerHits();
3145  isSimMatched = true;
3146  }
3147  for (const auto& tpQuality : foundTPs->val) {
3148  tpIdx.push_back(tpKeyToIndex.at(tpQuality.first.key()));
3149  sharedFraction.push_back(tpQuality.second);
3150  tpChi2.push_back(track_associator::trackAssociationChi2(tkParam, tkCov, *(tpCollection[tpIdx.back()]), mf, bs));
3151  }
3152  }
3153 
3154  // Search for a best-matching TrackingParticle for a track
3155  const auto clusters = track_associator::hitsToClusterRefs(
3156  itTrack->recHitsBegin(),
3157  itTrack->recHitsEnd()); // TODO: this function is called 3 times per track, try to reduce
3158  const int nClusters = clusters.size();
3159 
3160  const auto bestKeyCount = findBestMatchingTrackingParticle(*itTrack, clusterToTPMap, tpKeyToIndex);
3161  const float bestShareFrac = static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(nClusters);
3162  float bestShareFracSimDenom = 0;
3163  float bestShareFracSimClusterDenom = 0;
3164  float bestChi2 = -1;
3165  if (bestKeyCount.key >= 0) {
3166  bestShareFracSimDenom =
3167  static_cast<float>(bestKeyCount.countClusters) /
3168  static_cast<float>(tpCollection[tpKeyToIndex.at(bestKeyCount.key)]->numberOfTrackerHits());
3169  bestShareFracSimClusterDenom =
3170  static_cast<float>(bestKeyCount.countClusters) / static_cast<float>(tpKeyToClusterCount.at(bestKeyCount.key));
3171  bestChi2 = track_associator::trackAssociationChi2(
3172  tkParam, tkCov, *(tpCollection[tpKeyToIndex.at(bestKeyCount.key)]), mf, bs);
3173  }
3174  // Another way starting from the first hit of the track
3175  const auto bestFirstHitKeyCount = findMatchingTrackingParticleFromFirstHit(*itTrack, clusterToTPMap, tpKeyToIndex);
3176  const float bestFirstHitShareFrac =
3177  static_cast<float>(bestFirstHitKeyCount.countClusters) / static_cast<float>(nClusters);
3178  float bestFirstHitShareFracSimDenom = 0;
3179  float bestFirstHitShareFracSimClusterDenom = 0;
3180  float bestFirstHitChi2 = -1;
3181  if (bestFirstHitKeyCount.key >= 0) {
3182  bestFirstHitShareFracSimDenom =
3183  static_cast<float>(bestFirstHitKeyCount.countClusters) /
3184  static_cast<float>(tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]->numberOfTrackerHits());
3185  bestFirstHitShareFracSimClusterDenom = static_cast<float>(bestFirstHitKeyCount.countClusters) /
3186  static_cast<float>(tpKeyToClusterCount.at(bestFirstHitKeyCount.key));
3187  bestFirstHitChi2 = track_associator::trackAssociationChi2(
3188  tkParam, tkCov, *(tpCollection[tpKeyToIndex.at(bestFirstHitKeyCount.key)]), mf, bs);
3189  }
3190 
3191  float chi2_1Dmod = chi2;
3192  int count1dhits = 0;
3193  for (auto iHit = itTrack->recHitsBegin(), iEnd = itTrack->recHitsEnd(); iHit != iEnd; ++iHit) {
3194  const TrackingRecHit& hit = **iHit;
3195  if (hit.isValid() && typeid(hit) == typeid(SiStripRecHit1D))
3196  ++count1dhits;
3197  }
3198  if (count1dhits > 0) {
3199  chi2_1Dmod = (chi2 + count1dhits) / (ndof + count1dhits);
3200  }
3201 
3202  Point bestPV = getBestVertex(*itTrack, vertices);
3203 
3204  trk_px.push_back(itTrack->px());
3205  trk_py.push_back(itTrack->py());
3206  trk_pz.push_back(itTrack->pz());
3207  trk_pt.push_back(pt);
3208  trk_inner_px.push_back(itTrack->innerMomentum().x());
3209  trk_inner_py.push_back(itTrack->innerMomentum().y());
3210  trk_inner_pz.push_back(itTrack->innerMomentum().z());
3211  trk_inner_pt.push_back(itTrack->innerMomentum().rho());
3212  trk_outer_px.push_back(itTrack->outerMomentum().x());
3213  trk_outer_py.push_back(itTrack->outerMomentum().y());
3214  trk_outer_pz.push_back(itTrack->outerMomentum().z());
3215  trk_outer_pt.push_back(itTrack->outerMomentum().rho());
3216  trk_eta.push_back(eta);
3217  trk_lambda.push_back(lambda);
3218  trk_cotTheta.push_back(1 / tan(M_PI * 0.5 - lambda));
3219  trk_phi.push_back(phi);
3220  trk_dxy.push_back(itTrack->dxy(bs.position()));
3221  trk_dz.push_back(itTrack->dz(bs.position()));
3222  trk_dxyPV.push_back(itTrack->dxy(pvPosition));
3223  trk_dzPV.push_back(itTrack->dz(pvPosition));
3224  trk_dxyClosestPV.push_back(itTrack->dxy(bestPV));
3225  trk_dzClosestPV.push_back(itTrack->dz(bestPV));
3226  trk_ptErr.push_back(itTrack->ptError());
3227  trk_etaErr.push_back(itTrack->etaError());
3228  trk_lambdaErr.push_back(itTrack->lambdaError());
3229  trk_phiErr.push_back(itTrack->phiError());
3230  trk_dxyErr.push_back(itTrack->dxyError());
3231  trk_dzErr.push_back(itTrack->dzError());
3232  trk_refpoint_x.push_back(itTrack->vx());
3233  trk_refpoint_y.push_back(itTrack->vy());
3234  trk_refpoint_z.push_back(itTrack->vz());
3235  trk_nChi2.push_back(chi2);
3236  trk_nChi2_1Dmod.push_back(chi2_1Dmod);
3237  trk_ndof.push_back(ndof);
3238  trk_q.push_back(charge);
3239  trk_nValid.push_back(hp.numberOfValidHits());
3240  trk_nLost.push_back(hp.numberOfLostHits(reco::HitPattern::TRACK_HITS));
3241  trk_nInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::TRACK_HITS));
3242  trk_nPixel.push_back(hp.numberOfValidPixelHits());
3243  trk_nStrip.push_back(hp.numberOfValidStripHits());
3244  trk_nOuterLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS));
3245  trk_nInnerLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS));
3246  trk_nOuterInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::MISSING_OUTER_HITS));
3247  trk_nInnerInactive.push_back(hp.trackerLayersTotallyOffOrBad(reco::HitPattern::MISSING_INNER_HITS));
3248  trk_nPixelLay.push_back(hp.pixelLayersWithMeasurement());
3249  trk_nStripLay.push_back(hp.stripLayersWithMeasurement());
3250  trk_n3DLay.push_back(hp.numberOfValidStripLayersWithMonoAndStereo() + hp.pixelLayersWithMeasurement());
3251  trk_nLostLay.push_back(hp.trackerLayersWithoutMeasurement(reco::HitPattern::TRACK_HITS));
3252  trk_nCluster.push_back(nClusters);
3253  trk_algo.push_back(itTrack->algo());
3254  trk_originalAlgo.push_back(itTrack->originalAlgo());
3255  trk_algoMask.push_back(itTrack->algoMaskUL());
3256  trk_stopReason.push_back(itTrack->stopReason());
3257  trk_isHP.push_back(itTrack->quality(reco::TrackBase::highPurity));
3258  if (includeMVA_) {
3259  for (size_t i = 0; i < trk_mvas.size(); ++i) {
3260  trk_mvas[i].push_back((*(mvaColls[i]))[iTrack]);
3261  trk_qualityMasks[i].push_back((*(qualColls[i]))[iTrack]);
3262  }
3263  }
3264  if (includeSeeds_) {
3265  auto offset = seedCollToOffset.find(itTrack->seedRef().id());
3266  if (offset == seedCollToOffset.end()) {
3267  throw cms::Exception("Configuration")
3268  << "Track algo '" << reco::TrackBase::algoName(itTrack->algo()) << "' originalAlgo '"
3269  << reco::TrackBase::algoName(itTrack->originalAlgo()) << "' refers to seed collection "
3270  << itTrack->seedRef().id()
3271  << ", but that seed collection is not given as an input. The following collections were given as an input "
3272  << make_ProductIDMapPrinter(seedCollToOffset);
3273  }
3274 
3275  const auto seedIndex = offset->second + itTrack->seedRef().key();
3276  trk_seedIdx.push_back(seedIndex);
3277  if (see_trkIdx[seedIndex] != -1) {
3278  throw cms::Exception("LogicError") << "Track index has already been set for seed " << seedIndex << " to "
3279  << see_trkIdx[seedIndex] << "; was trying to set it to " << iTrack;
3280  }
3281  see_trkIdx[seedIndex] = iTrack;
3282  }
3283  trk_vtxIdx.push_back(-1); // to be set correctly in fillVertices
3284  if (includeTrackingParticles_) {
3285  trk_simTrkIdx.push_back(tpIdx);
3286  trk_simTrkShareFrac.push_back(sharedFraction);
3287  trk_simTrkNChi2.push_back(tpChi2);
3288  trk_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
3289  trk_bestFromFirstHitSimTrkIdx.push_back(bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key)
3290  : -1);
3291  } else {
3292  trk_isTrue.push_back(!tpIdx.empty());
3293  }
3294  trk_bestSimTrkShareFrac.push_back(bestShareFrac);
3295  trk_bestSimTrkShareFracSimDenom.push_back(bestShareFracSimDenom);
3296  trk_bestSimTrkShareFracSimClusterDenom.push_back(bestShareFracSimClusterDenom);
3297  trk_bestSimTrkNChi2.push_back(bestChi2);
3298  trk_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
3299  trk_bestFromFirstHitSimTrkShareFracSimDenom.push_back(bestFirstHitShareFracSimDenom);
3300  trk_bestFromFirstHitSimTrkShareFracSimClusterDenom.push_back(bestFirstHitShareFracSimClusterDenom);
3301  trk_bestFromFirstHitSimTrkNChi2.push_back(bestFirstHitChi2);
3302 
3303  LogTrace("TrackingNtuple") << "Track #" << itTrack.key() << " with q=" << charge << ", pT=" << pt
3304  << " GeV, eta: " << eta << ", phi: " << phi << ", chi2=" << chi2 << ", Nhits=" << nHits
3305  << ", algo=" << itTrack->algoName(itTrack->algo()).c_str()
3306  << " hp=" << itTrack->quality(reco::TrackBase::highPurity)
3307  << " seed#=" << itTrack->seedRef().key() << " simMatch=" << isSimMatched
3308  << " nSimHits=" << nSimHits
3309  << " sharedFraction=" << (sharedFraction.empty() ? -1 : sharedFraction[0])
3310  << " tpIdx=" << (tpIdx.empty() ? -1 : tpIdx[0]);
3311  std::vector<int> hitIdx;
3312  std::vector<int> hitType;
3313 
3314  for (auto i = itTrack->recHitsBegin(); i != itTrack->recHitsEnd(); i++) {
3315  TransientTrackingRecHit::RecHitPointer hit = theTTRHBuilder.build(&**i);
3316  DetId hitId = hit->geographicalId();
3317  LogTrace("TrackingNtuple") << "hit #" << std::distance(itTrack->recHitsBegin(), i)
3318  << " subdet=" << hitId.subdetId();
3319  if (hitId.det() != DetId::Tracker)
3320  continue;
3321 
3322  LogTrace("TrackingNtuple") << " " << subdetstring(hitId.subdetId()) << " " << tTopo.layer(hitId);
3323 
3324  if (hit->isValid()) {
3325  //ugly... but works
3326  const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*hit);
3327  const auto& clusterRef = bhit->firstClusterRef();
3328  unsigned int clusterKey;
3329  if (clusterRef.isPixel()) {
3330  clusterKey = clusterRef.cluster_pixel().key();
3331  } else if (clusterRef.isPhase2()) {
3332  clusterKey = clusterRef.cluster_phase2OT().key();
3333  } else {
3334  clusterKey = clusterRef.cluster_strip().key();
3335  }
3336 
3337  LogTrace("TrackingNtuple") << " id: " << hitId.rawId() << " - globalPos =" << hit->globalPosition()
3338  << " cluster=" << clusterKey << " clusterRef ID=" << clusterRef.id()
3339  << " eta,phi: " << hit->globalPosition().eta() << "," << hit->globalPosition().phi();
3340  if (includeAllHits_) {
3341  checkProductID(hitProductIds, clusterRef.id(), "track");
3342  if (clusterRef.isPixel()) {
3343  pix_trkIdx[clusterKey].push_back(iTrack);
3344  } else if (clusterRef.isPhase2()) {
3345  ph2_trkIdx[clusterKey].push_back(iTrack);
3346  } else {
3347  str_trkIdx[clusterKey].push_back(iTrack);
3348  }
3349  }
3350 
3351  hitIdx.push_back(clusterKey);
3352  if (clusterRef.isPixel()) {
3353  hitType.push_back(static_cast<int>(HitType::Pixel));
3354  } else if (clusterRef.isPhase2()) {
3355  hitType.push_back(static_cast<int>(HitType::Phase2OT));
3356  } else {
3357  hitType.push_back(static_cast<int>(HitType::Strip));
3358  }
3359  } else {
3360  LogTrace("TrackingNtuple") << " - invalid hit";
3361 
3362  hitIdx.push_back(inv_isBarrel.size());
3363  hitType.push_back(static_cast<int>(HitType::Invalid));
3364 
3365  inv_isBarrel.push_back(hitId.subdetId() == 1);
3366  if (includeStripHits_)
3367  inv_detId.push_back(tTopo, hitId);
3368  else
3369  inv_detId_phase2.push_back(tTopo, hitId);
3370  inv_type.push_back(hit->getType());
3371  }
3372  }
3373 
3374  trk_hitIdx.push_back(hitIdx);
3375  trk_hitType.push_back(hitType);
3376  }
3377 }

References reco::TrackBase::algoName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), cms::cuda::bs, TransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, hltPixelTracks_cff::chi2, OmniClusterRef::cluster_pixel(), bsc_activity_cfg::clusters, DetId::det(), HLT_FULL_cff::distance, edm::AssociationMap< Tag >::end(), PVValHelper::eta, Exception, edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), getBestVertex(), reco::TrackBase::highPurity, track_associator::hitsToClusterRefs(), trackingPlots::hp, mps_fire::i, hit::id, includeAllHits_, includeMVA_, includeSeeds_, includeStripHits_, includeTrackingParticles_, inv_detId, inv_detId_phase2, inv_isBarrel, inv_type, Invalid, edm::Ref< C, T, F >::key(), SummaryClient_cfi::labels, edm::EDConsumerBase::labelsForToken(), TrackerTopology::layer(), LogTrace, M_PI, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, heavyionUCCDQM_cfi::nClusters, ndof, nHits, hltrates_dqm_sourceclient-live_cfg::offset, ph2_trkIdx, Phase2OT, phi, pix_trkIdx, Pixel, DiDispStaMuonMonitor_cfi::pt, DetId::rawId(), see_trkIdx, str_trkIdx, Strip, DetId::subdetId(), funct::tan(), reco::HitPattern::TRACK_HITS, track_associator::trackAssociationChi2(), DetId::Tracker, tracks, trackToken_, trk_algo, trk_algoMask, trk_bestFromFirstHitSimTrkIdx, trk_bestFromFirstHitSimTrkNChi2, trk_bestFromFirstHitSimTrkShareFrac, trk_bestFromFirstHitSimTrkShareFracSimClusterDenom, trk_bestFromFirstHitSimTrkShareFracSimDenom, trk_bestSimTrkIdx, trk_bestSimTrkNChi2, trk_bestSimTrkShareFrac, trk_bestSimTrkShareFracSimClusterDenom, trk_bestSimTrkShareFracSimDenom, trk_cotTheta, trk_dxy, trk_dxyClosestPV, trk_dxyErr, trk_dxyPV, trk_dz, trk_dzClosestPV, trk_dzErr, trk_dzPV, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_isTrue, trk_lambda, trk_lambdaErr, trk_mvas, trk_n3DLay, trk_nChi2, trk_nChi2_1Dmod, trk_nCluster, trk_ndof, trk_nInactive, trk_nInnerInactive, trk_nInnerLost, trk_nLost, trk_nLostLay, trk_nOuterInactive, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_qualityMasks, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, trk_seedIdx, trk_simTrkIdx, trk_simTrkNChi2, trk_simTrkShareFrac, trk_stopReason, trk_vtxIdx, and pwdgSkimBPark_cfi::vertices.

Referenced by analyze().

◆ fillVertices()

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

Definition at line 3545 of file TrackingNtuple.cc.

3546  {
3547  for (size_t iVertex = 0, size = vertices.size(); iVertex < size; ++iVertex) {
3548  const reco::Vertex& vertex = vertices[iVertex];
3549  vtx_x.push_back(vertex.x());
3550  vtx_y.push_back(vertex.y());
3551  vtx_z.push_back(vertex.z());
3552  vtx_xErr.push_back(vertex.xError());
3553  vtx_yErr.push_back(vertex.yError());
3554  vtx_zErr.push_back(vertex.zError());
3555  vtx_chi2.push_back(vertex.chi2());
3556  vtx_ndof.push_back(vertex.ndof());
3557  vtx_fake.push_back(vertex.isFake());
3558  vtx_valid.push_back(vertex.isValid());
3559 
3560  std::vector<int> trkIdx;
3561  for (auto iTrack = vertex.tracks_begin(); iTrack != vertex.tracks_end(); ++iTrack) {
3562  // Ignore link if vertex was fit from a track collection different from the input
3563  if (iTrack->id() != tracks.id())
3564  continue;
3565 
3566  trkIdx.push_back(iTrack->key());
3567 
3568  if (trk_vtxIdx[iTrack->key()] != -1) {
3569  throw cms::Exception("LogicError") << "Vertex index has already been set for track " << iTrack->key() << " to "
3570  << trk_vtxIdx[iTrack->key()] << "; was trying to set it to " << iVertex;
3571  }
3572  trk_vtxIdx[iTrack->key()] = iVertex;
3573  }
3574  vtx_trkIdx.push_back(trkIdx);
3575  }
3576 }

References Exception, findQualityFiles::size, tracks, trk_vtxIdx, bphysicsOniaDQM_cfi::vertex, pwdgSkimBPark_cfi::vertices, vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

Referenced by analyze().

◆ matchCluster()

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

Definition at line 2259 of file TrackingNtuple.cc.

2269  {
2270  SimHitData ret;
2271 
2272  std::map<unsigned int, double> simTrackIdToChargeFraction;
2273  if (hitType == HitType::Phase2OT)
2274  simTrackIdToChargeFraction = chargeFraction(cluster.phase2OTCluster(), hitId, digiSimLinks);
2275  else
2276  simTrackIdToChargeFraction = chargeFraction(GetCluster<SimLink>::call(cluster), hitId, digiSimLinks);
2277 
2278  ret.type = HitSimType::Noise;
2279  auto range = clusterToTPMap.equal_range(cluster);
2280  if (range.first != range.second) {
2281  for (auto ip = range.first; ip != range.second; ++ip) {
2282  const TrackingParticleRef& trackingParticle = ip->second;
2283 
2284  // Find out if the cluster is from signal/ITPU/OOTPU
2285  const auto event = trackingParticle->eventId().event();
2286  const auto bx = trackingParticle->eventId().bunchCrossing();
2287  HitSimType type = HitSimType::OOTPileup;
2288  if (bx == 0) {
2289  type = (event == 0 ? HitSimType::Signal : HitSimType::ITPileup);
2290  }
2291  ret.type = static_cast<HitSimType>(std::min(static_cast<int>(ret.type), static_cast<int>(type)));
2292 
2293  // Limit to only input TrackingParticles (usually signal+ITPU)
2294  auto tpIndex = tpKeyToIndex.find(trackingParticle.key());
2295  if (tpIndex == tpKeyToIndex.end())
2296  continue;
2297 
2298  //now get the corresponding sim hit
2299  std::pair<TrackingParticleRef, TrackPSimHitRef> simHitTPpairWithDummyTP(trackingParticle, TrackPSimHitRef());
2300  //SimHit is dummy: for simHitTPAssociationListGreater sorting only the TP is needed
2301  auto range = std::equal_range(simHitsTPAssoc.begin(),
2302  simHitsTPAssoc.end(),
2303  simHitTPpairWithDummyTP,
2304  SimHitTPAssociationProducer::simHitTPAssociationListGreater);
2305  bool foundSimHit = false;
2306  bool foundElectron = false;
2307  for (auto ip = range.first; ip != range.second; ++ip) {
2308  TrackPSimHitRef TPhit = ip->second;
2309  DetId dId = DetId(TPhit->detUnitId());
2310  if (dId.rawId() == hitId.rawId()) {
2311  // skip electron SimHits for non-electron TPs also here
2312  if (std::abs(TPhit->particleType()) == 11 && std::abs(trackingParticle->pdgId()) != 11) {
2313  foundElectron = true;
2314  continue;
2315  }
2316 
2317  foundSimHit = true;
2318  auto simHitKey = TPhit.key();
2319  auto simHitID = TPhit.id();
2320 
2321  auto simHitIndex = simHitRefKeyToIndex.at(std::make_pair(simHitKey, simHitID));
2322  ret.matchingSimHit.push_back(simHitIndex);
2323 
2324  double chargeFraction = 0.;
2325  for (const SimTrack& simtrk : trackingParticle->g4Tracks()) {
2326  auto found = simTrackIdToChargeFraction.find(simtrk.trackId());
2327  if (found != simTrackIdToChargeFraction.end()) {
2328  chargeFraction += found->second;
2329  }
2330  }
2331  ret.chargeFraction.push_back(chargeFraction);
2332 
2333  // only for debug prints
2334  ret.bunchCrossing.push_back(bx);
2335  ret.event.push_back(event);
2336 
2337  simhit_hitIdx[simHitIndex].push_back(clusterKey);
2338  simhit_hitType[simHitIndex].push_back(static_cast<int>(hitType));
2339  }
2340  }
2341  if (!foundSimHit) {
2342  // In case we didn't find a simhit because of filtered-out
2343  // electron SimHit, just ignore the missing SimHit.
2344  if (foundElectron)
2345  continue;
2346 
2347  auto ex = cms::Exception("LogicError")
2348  << "Did not find SimHit for reco hit DetId " << hitId.rawId() << " for TP " << trackingParticle.key()
2349  << " bx:event " << bx << ":" << event << ".\nFound SimHits from detectors ";
2350  for (auto ip = range.first; ip != range.second; ++ip) {
2351  TrackPSimHitRef TPhit = ip->second;
2352  DetId dId = DetId(TPhit->detUnitId());
2353  ex << dId.rawId() << " ";
2354  }
2355  if (trackingParticle->eventId().event() != 0) {
2356  ex << "\nSince this is a TrackingParticle from pileup, check that you're running the pileup mixing in "
2357  "playback mode.";
2358  }
2359  throw ex;
2360  }
2361  }
2362  }
2363 
2364  return ret;
2365 }

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

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

◆ tpHitIndexListLess()

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

Definition at line 500 of file TrackingNtuple.cc.

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

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

Referenced by fillTrackingParticles().

◆ tpHitIndexListLessSort()

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

Definition at line 501 of file TrackingNtuple.cc.

501  {
502  if (i.tpKey == j.tpKey) {
503  if (edm::isNotFinite(i.tof) && edm::isNotFinite(j.tof)) {
504  return i.detId < j.detId;
505  }
506  return i.tof < j.tof; // works as intended if either one is NaN
507  }
508  return i.tpKey < j.tpKey;
509  }

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

Referenced by analyze().

Member Data Documentation

◆ beamSpotToken_

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

Definition at line 649 of file TrackingNtuple.cc.

Referenced by analyze().

◆ bsp_sigmax

float TrackingNtuple::bsp_sigmax
private

Definition at line 1179 of file TrackingNtuple.cc.

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

◆ bsp_sigmay

float TrackingNtuple::bsp_sigmay
private

Definition at line 1180 of file TrackingNtuple.cc.

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

◆ bsp_sigmaz

float TrackingNtuple::bsp_sigmaz
private

Definition at line 1181 of file TrackingNtuple.cc.

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

◆ bsp_x

float TrackingNtuple::bsp_x
private

Definition at line 1176 of file TrackingNtuple.cc.

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

◆ bsp_y

float TrackingNtuple::bsp_y
private

Definition at line 1177 of file TrackingNtuple.cc.

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

◆ bsp_z

float TrackingNtuple::bsp_z
private

Definition at line 1178 of file TrackingNtuple.cc.

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

◆ clusterTPMapToken_

edm::EDGetTokenT<ClusterTPAssociation> TrackingNtuple::clusterTPMapToken_
private

Definition at line 642 of file TrackingNtuple.cc.

Referenced by analyze().

◆ ev_event

edm::EventNumber_t TrackingNtuple::ev_event
private

Definition at line 945 of file TrackingNtuple.cc.

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

◆ ev_lumi

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi
private

Definition at line 944 of file TrackingNtuple.cc.

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

◆ ev_run

edm::RunNumber_t TrackingNtuple::ev_run
private

Definition at line 943 of file TrackingNtuple.cc.

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

◆ glu_bbxi

std::vector<float> TrackingNtuple::glu_bbxi
private

Definition at line 1127 of file TrackingNtuple.cc.

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

◆ glu_detId

DetIdStrip TrackingNtuple::glu_detId
private

Definition at line 1112 of file TrackingNtuple.cc.

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

◆ glu_isBarrel

std::vector<short> TrackingNtuple::glu_isBarrel
private

Definition at line 1111 of file TrackingNtuple.cc.

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

◆ glu_monoIdx

std::vector<int> TrackingNtuple::glu_monoIdx
private

Definition at line 1113 of file TrackingNtuple.cc.

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

◆ glu_radL

std::vector<float> TrackingNtuple::glu_radL
private

Definition at line 1126 of file TrackingNtuple.cc.

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

◆ glu_seeIdx

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

Definition at line 1115 of file TrackingNtuple.cc.

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

◆ glu_stereoIdx

std::vector<int> TrackingNtuple::glu_stereoIdx
private

Definition at line 1114 of file TrackingNtuple.cc.

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

◆ glu_x

std::vector<float> TrackingNtuple::glu_x
private

Definition at line 1116 of file TrackingNtuple.cc.

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

◆ glu_xx

std::vector<float> TrackingNtuple::glu_xx
private

Definition at line 1119 of file TrackingNtuple.cc.

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

◆ glu_xy

std::vector<float> TrackingNtuple::glu_xy
private

Definition at line 1120 of file TrackingNtuple.cc.

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

◆ glu_y

std::vector<float> TrackingNtuple::glu_y
private

Definition at line 1117 of file TrackingNtuple.cc.

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

◆ glu_yy

std::vector<float> TrackingNtuple::glu_yy
private

Definition at line 1121 of file TrackingNtuple.cc.

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

◆ glu_yz

std::vector<float> TrackingNtuple::glu_yz
private

Definition at line 1122 of file TrackingNtuple.cc.

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

◆ glu_z

std::vector<float> TrackingNtuple::glu_z
private

Definition at line 1118 of file TrackingNtuple.cc.

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

◆ glu_zx

std::vector<float> TrackingNtuple::glu_zx
private

Definition at line 1124 of file TrackingNtuple.cc.

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

◆ glu_zz

std::vector<float> TrackingNtuple::glu_zz
private

Definition at line 1123 of file TrackingNtuple.cc.

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

◆ includeAllHits_

const bool TrackingNtuple::includeAllHits_
private

Definition at line 661 of file TrackingNtuple.cc.

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

◆ includeMVA_

const bool TrackingNtuple::includeMVA_
private

Definition at line 662 of file TrackingNtuple.cc.

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

◆ includePhase2OTHits_

bool TrackingNtuple::includePhase2OTHits_
private

Definition at line 648 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ includeSeeds_

const bool TrackingNtuple::includeSeeds_
private

Definition at line 660 of file TrackingNtuple.cc.

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

◆ includeStripHits_

bool TrackingNtuple::includeStripHits_
private

Definition at line 648 of file TrackingNtuple.cc.

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

◆ includeTrackingParticles_

const bool TrackingNtuple::includeTrackingParticles_
private

Definition at line 663 of file TrackingNtuple.cc.

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

◆ inv_detId

DetIdAll TrackingNtuple::inv_detId
private

Definition at line 1155 of file TrackingNtuple.cc.

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

◆ inv_detId_phase2

DetIdAllPhase2 TrackingNtuple::inv_detId_phase2
private

Definition at line 1156 of file TrackingNtuple.cc.

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

◆ inv_isBarrel

std::vector<short> TrackingNtuple::inv_isBarrel
private

Definition at line 1154 of file TrackingNtuple.cc.

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

◆ inv_type

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

Definition at line 1157 of file TrackingNtuple.cc.

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

◆ mfToken_

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

Definition at line 629 of file TrackingNtuple.cc.

Referenced by analyze().

◆ mvaQualityCollectionTokens_

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

Definition at line 639 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ paramsDefineToken_

const edm::ESGetToken<ParametersDefinerForTP, TrackAssociatorRecord> TrackingNtuple::paramsDefineToken_
private

Definition at line 633 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ ph2_bbxi

std::vector<float> TrackingNtuple::ph2_bbxi
private

Definition at line 1149 of file TrackingNtuple.cc.

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

◆ ph2_detId

DetIdPhase2OT TrackingNtuple::ph2_detId
private

Definition at line 1132 of file TrackingNtuple.cc.

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

◆ ph2_isBarrel

std::vector<short> TrackingNtuple::ph2_isBarrel
private

Definition at line 1131 of file TrackingNtuple.cc.

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

◆ ph2_radL

std::vector<float> TrackingNtuple::ph2_radL
private

Definition at line 1148 of file TrackingNtuple.cc.

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

◆ ph2_seeIdx

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

Definition at line 1134 of file TrackingNtuple.cc.

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

◆ ph2_simHitIdx

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

Definition at line 1135 of file TrackingNtuple.cc.

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

◆ ph2_simType

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

Definition at line 1137 of file TrackingNtuple.cc.

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

◆ ph2_trkIdx

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

Definition at line 1133 of file TrackingNtuple.cc.

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

◆ ph2_x

std::vector<float> TrackingNtuple::ph2_x
private

Definition at line 1138 of file TrackingNtuple.cc.

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

◆ ph2_xx

std::vector<float> TrackingNtuple::ph2_xx
private

Definition at line 1141 of file TrackingNtuple.cc.

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

◆ ph2_xy

std::vector<float> TrackingNtuple::ph2_xy
private

Definition at line 1142 of file TrackingNtuple.cc.

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

◆ ph2_y

std::vector<float> TrackingNtuple::ph2_y
private

Definition at line 1139 of file TrackingNtuple.cc.

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

◆ ph2_yy

std::vector<float> TrackingNtuple::ph2_yy
private

Definition at line 1143 of file TrackingNtuple.cc.

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

◆ ph2_yz

std::vector<float> TrackingNtuple::ph2_yz
private

Definition at line 1144 of file TrackingNtuple.cc.

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

◆ ph2_z

std::vector<float> TrackingNtuple::ph2_z
private

Definition at line 1140 of file TrackingNtuple.cc.

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

◆ ph2_zx

std::vector<float> TrackingNtuple::ph2_zx
private

Definition at line 1146 of file TrackingNtuple.cc.

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

◆ ph2_zz

std::vector<float> TrackingNtuple::ph2_zz
private

Definition at line 1145 of file TrackingNtuple.cc.

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

◆ phase2OTRecHitToken_

edm::EDGetTokenT<Phase2TrackerRecHit1DCollectionNew> TrackingNtuple::phase2OTRecHitToken_
private

Definition at line 654 of file TrackingNtuple.cc.

Referenced by fillPhase2OTHits().

◆ pix_bbxi

std::vector<float> TrackingNtuple::pix_bbxi
private

Definition at line 1085 of file TrackingNtuple.cc.

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

◆ pix_chargeFraction

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

Definition at line 1072 of file TrackingNtuple.cc.

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

◆ pix_detId

DetIdPixel TrackingNtuple::pix_detId
private

Definition at line 1068 of file TrackingNtuple.cc.

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

◆ pix_isBarrel

std::vector<short> TrackingNtuple::pix_isBarrel
private

Definition at line 1067 of file TrackingNtuple.cc.

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

◆ pix_radL

std::vector<float> TrackingNtuple::pix_radL
private

Definition at line 1084 of file TrackingNtuple.cc.

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

◆ pix_seeIdx

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

Definition at line 1070 of file TrackingNtuple.cc.

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

◆ pix_simHitIdx

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

Definition at line 1071 of file TrackingNtuple.cc.

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

◆ pix_simType

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

Definition at line 1073 of file TrackingNtuple.cc.

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

◆ pix_trkIdx

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

Definition at line 1069 of file TrackingNtuple.cc.

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

◆ pix_x

std::vector<float> TrackingNtuple::pix_x
private

Definition at line 1074 of file TrackingNtuple.cc.

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

◆ pix_xx

std::vector<float> TrackingNtuple::pix_xx
private

Definition at line 1077 of file TrackingNtuple.cc.

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

◆ pix_xy

std::vector<float> TrackingNtuple::pix_xy
private

Definition at line 1078 of file TrackingNtuple.cc.

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

◆ pix_y

std::vector<float> TrackingNtuple::pix_y
private

Definition at line 1075 of file TrackingNtuple.cc.

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

◆ pix_yy

std::vector<float> TrackingNtuple::pix_yy
private

Definition at line 1079 of file TrackingNtuple.cc.

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

◆ pix_yz

std::vector<float> TrackingNtuple::pix_yz
private

Definition at line 1080 of file TrackingNtuple.cc.

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

◆ pix_z

std::vector<float> TrackingNtuple::pix_z
private

Definition at line 1076 of file TrackingNtuple.cc.

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

◆ pix_zx

std::vector<float> TrackingNtuple::pix_zx
private

Definition at line 1082 of file TrackingNtuple.cc.

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

◆ pix_zz

std::vector<float> TrackingNtuple::pix_zz
private

Definition at line 1081 of file TrackingNtuple.cc.

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

◆ pixelRecHitToken_

edm::EDGetTokenT<SiPixelRecHitCollection> TrackingNtuple::pixelRecHitToken_
private

Definition at line 650 of file TrackingNtuple.cc.

Referenced by fillPixelHits().

◆ pixelSimLinkToken_

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

Definition at line 645 of file TrackingNtuple.cc.

Referenced by analyze().

◆ see_algo

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

Definition at line 1213 of file TrackingNtuple.cc.

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

◆ see_bestFromFirstHitSimTrkIdx

std::vector<int> TrackingNtuple::see_bestFromFirstHitSimTrkIdx
private

Definition at line 1220 of file TrackingNtuple.cc.

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

◆ see_bestFromFirstHitSimTrkShareFrac

std::vector<float> TrackingNtuple::see_bestFromFirstHitSimTrkShareFrac
private

Definition at line 1221 of file TrackingNtuple.cc.

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

◆ see_bestSimTrkIdx

std::vector<int> TrackingNtuple::see_bestSimTrkIdx
private

Definition at line 1218 of file TrackingNtuple.cc.

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

◆ see_bestSimTrkShareFrac

std::vector<float> TrackingNtuple::see_bestSimTrkShareFrac
private

Definition at line 1219 of file TrackingNtuple.cc.

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

◆ see_chi2

std::vector<float> TrackingNtuple::see_chi2
private

Definition at line 1199 of file TrackingNtuple.cc.

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

◆ see_dxy

std::vector<float> TrackingNtuple::see_dxy
private

Definition at line 1192 of file TrackingNtuple.cc.

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

◆ see_dxyErr

std::vector<float> TrackingNtuple::see_dxyErr
private

Definition at line 1197 of file TrackingNtuple.cc.

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

◆ see_dz

std::vector<float> TrackingNtuple::see_dz
private

Definition at line 1193 of file TrackingNtuple.cc.

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

◆ see_dzErr

std::vector<float> TrackingNtuple::see_dzErr
private

Definition at line 1198 of file TrackingNtuple.cc.

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

◆ see_eta

std::vector<float> TrackingNtuple::see_eta
private

Definition at line 1190 of file TrackingNtuple.cc.

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

◆ see_etaErr

std::vector<float> TrackingNtuple::see_etaErr
private

Definition at line 1195 of file TrackingNtuple.cc.

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

◆ see_fitok

std::vector<short> TrackingNtuple::see_fitok
private

Definition at line 1185 of file TrackingNtuple.cc.

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

◆ see_hitIdx

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

Definition at line 1224 of file TrackingNtuple.cc.

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

◆ see_hitType

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

Definition at line 1225 of file TrackingNtuple.cc.

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

◆ see_isTrue

std::vector<short> TrackingNtuple::see_isTrue
private

Definition at line 1217 of file TrackingNtuple.cc.

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

◆ see_nCands

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

Definition at line 1215 of file TrackingNtuple.cc.

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

◆ see_nCluster

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

Definition at line 1212 of file TrackingNtuple.cc.

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

◆ see_nGlued

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

Definition at line 1209 of file TrackingNtuple.cc.

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

◆ see_nPhase2OT

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

Definition at line 1211 of file TrackingNtuple.cc.

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

◆ see_nPixel

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

Definition at line 1208 of file TrackingNtuple.cc.

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

◆ see_nStrip

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

Definition at line 1210 of file TrackingNtuple.cc.

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

◆ see_nValid

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

Definition at line 1207 of file TrackingNtuple.cc.

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

◆ see_offset

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

Definition at line 1227 of file TrackingNtuple.cc.

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

◆ see_phi

std::vector<float> TrackingNtuple::see_phi
private

Definition at line 1191 of file TrackingNtuple.cc.

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

◆ see_phiErr

std::vector<float> TrackingNtuple::see_phiErr
private

Definition at line 1196 of file TrackingNtuple.cc.

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

◆ see_pt

std::vector<float> TrackingNtuple::see_pt
private

Definition at line 1189 of file TrackingNtuple.cc.

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

◆ see_ptErr

std::vector<float> TrackingNtuple::see_ptErr
private

Definition at line 1194 of file TrackingNtuple.cc.

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

◆ see_px

std::vector<float> TrackingNtuple::see_px
private

Definition at line 1186 of file TrackingNtuple.cc.

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

◆ see_py

std::vector<float> TrackingNtuple::see_py
private

Definition at line 1187 of file TrackingNtuple.cc.

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

◆ see_pz

std::vector<float> TrackingNtuple::see_pz
private

Definition at line 1188 of file TrackingNtuple.cc.

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

◆ see_q

std::vector<int> TrackingNtuple::see_q
private

Definition at line 1206 of file TrackingNtuple.cc.

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

◆ see_simTrkIdx

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

Definition at line 1223 of file TrackingNtuple.cc.

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

◆ see_simTrkShareFrac

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

Definition at line 1222 of file TrackingNtuple.cc.

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

◆ see_statePt

std::vector<float> TrackingNtuple::see_statePt
private

Definition at line 1200 of file TrackingNtuple.cc.

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

◆ see_stateTrajPx

std::vector<float> TrackingNtuple::see_stateTrajPx
private

Definition at line 1203 of file TrackingNtuple.cc.

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

◆ see_stateTrajPy

std::vector<float> TrackingNtuple::see_stateTrajPy
private

Definition at line 1204 of file TrackingNtuple.cc.

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

◆ see_stateTrajPz

std::vector<float> TrackingNtuple::see_stateTrajPz
private

Definition at line 1205 of file TrackingNtuple.cc.

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

◆ see_stateTrajX

std::vector<float> TrackingNtuple::see_stateTrajX
private

Definition at line 1201 of file TrackingNtuple.cc.

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

◆ see_stateTrajY

std::vector<float> TrackingNtuple::see_stateTrajY
private

Definition at line 1202 of file TrackingNtuple.cc.

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

◆ see_stopReason

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

Definition at line 1214 of file TrackingNtuple.cc.

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

◆ see_trkIdx

std::vector<int> TrackingNtuple::see_trkIdx
private

Definition at line 1216 of file TrackingNtuple.cc.

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

◆ seedStopInfoTokens_

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

Definition at line 636 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

◆ seedTokens_

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

Definition at line 635 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

◆ sim_bunchCrossing

std::vector<int> TrackingNtuple::sim_bunchCrossing
private

Definition at line 1028 of file TrackingNtuple.cc.

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

◆ sim_decayVtxIdx

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

Definition at line 1062 of file TrackingNtuple.cc.

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

◆ sim_eta

std::vector<float> TrackingNtuple::sim_eta
private

Definition at line 1036 of file TrackingNtuple.cc.

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

◆ sim_event

std::vector<int> TrackingNtuple::sim_event
private

Definition at line 1027 of file TrackingNtuple.cc.

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

◆ sim_genPdgIds

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

Definition at line 1030 of file TrackingNtuple.cc.

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

◆ sim_isFromBHadron

std::vector<int> TrackingNtuple::sim_isFromBHadron
private

Definition at line 1031 of file TrackingNtuple.cc.

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

◆ sim_n3DLay

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

Definition at line 1052 of file TrackingNtuple.cc.

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

◆ sim_nLay

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

Definition at line 1050 of file TrackingNtuple.cc.

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

◆ sim_nPixel

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

Definition at line 1048 of file TrackingNtuple.cc.

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

◆ sim_nPixelLay

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

Definition at line 1051 of file TrackingNtuple.cc.

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

◆ sim_nRecoClusters

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

Definition at line 1056 of file TrackingNtuple.cc.

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

◆ sim_nStrip

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

Definition at line 1049 of file TrackingNtuple.cc.

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

◆ sim_nTrackerHits

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

Definition at line 1054 of file TrackingNtuple.cc.

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

◆ sim_nValid

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

Definition at line 1047 of file TrackingNtuple.cc.

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

◆ sim_parentVtxIdx

std::vector<int> TrackingNtuple::sim_parentVtxIdx
private

Definition at line 1061 of file TrackingNtuple.cc.

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

◆ sim_pca_cotTheta

std::vector<float> TrackingNtuple::sim_pca_cotTheta
private

Definition at line 1041 of file TrackingNtuple.cc.

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

◆ sim_pca_dxy

std::vector<float> TrackingNtuple::sim_pca_dxy
private

Definition at line 1043 of file TrackingNtuple.cc.

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

◆ sim_pca_dz

std::vector<float> TrackingNtuple::sim_pca_dz
private

Definition at line 1044 of file TrackingNtuple.cc.

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

◆ sim_pca_eta

std::vector<float> TrackingNtuple::sim_pca_eta
private

Definition at line 1039 of file TrackingNtuple.cc.

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

◆ sim_pca_lambda

std::vector<float> TrackingNtuple::sim_pca_lambda
private

Definition at line 1040 of file TrackingNtuple.cc.

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

◆ sim_pca_phi

std::vector<float> TrackingNtuple::sim_pca_phi
private

Definition at line 1042 of file TrackingNtuple.cc.

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

◆ sim_pca_pt

std::vector<float> TrackingNtuple::sim_pca_pt
private

Definition at line 1038 of file TrackingNtuple.cc.

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

◆ sim_pdgId

std::vector<int> TrackingNtuple::sim_pdgId
private

Definition at line 1029 of file TrackingNtuple.cc.

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

◆ sim_phi

std::vector<float> TrackingNtuple::sim_phi
private

Definition at line 1037 of file TrackingNtuple.cc.

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

◆ sim_pt

std::vector<float> TrackingNtuple::sim_pt
private

Definition at line 1035 of file TrackingNtuple.cc.

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

◆ sim_px

std::vector<float> TrackingNtuple::sim_px
private

Definition at line 1032 of file TrackingNtuple.cc.

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

◆ sim_py

std::vector<float> TrackingNtuple::sim_py
private

Definition at line 1033 of file TrackingNtuple.cc.

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

◆ sim_pz

std::vector<float> TrackingNtuple::sim_pz
private

Definition at line 1034 of file TrackingNtuple.cc.

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

◆ sim_q

std::vector<int> TrackingNtuple::sim_q
private

Definition at line 1045 of file TrackingNtuple.cc.

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

◆ sim_seedIdx

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

Definition at line 1060 of file TrackingNtuple.cc.

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

◆ sim_simHitIdx

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

Definition at line 1063 of file TrackingNtuple.cc.

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

◆ sim_trkIdx

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

Definition at line 1058 of file TrackingNtuple.cc.

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

◆ sim_trkShareFrac

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

Definition at line 1059 of file TrackingNtuple.cc.

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

◆ simhit_detId

DetIdAll TrackingNtuple::simhit_detId
private

Definition at line 1161 of file TrackingNtuple.cc.

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

◆ simhit_detId_phase2

DetIdAllPhase2 TrackingNtuple::simhit_detId_phase2
private

Definition at line 1162 of file TrackingNtuple.cc.

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

◆ simhit_eloss

std::vector<float> TrackingNtuple::simhit_eloss
private

Definition at line 1168 of file TrackingNtuple.cc.

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

◆ simhit_hitIdx

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

Definition at line 1172 of file TrackingNtuple.cc.

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

◆ simhit_hitType

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

Definition at line 1173 of file TrackingNtuple.cc.

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

◆ simhit_particle

std::vector<int> TrackingNtuple::simhit_particle
private

Definition at line 1166 of file TrackingNtuple.cc.

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

◆ simhit_process

std::vector<short> TrackingNtuple::simhit_process
private

Definition at line 1167 of file TrackingNtuple.cc.

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

◆ simhit_simTrkIdx

std::vector<int> TrackingNtuple::simhit_simTrkIdx
private

Definition at line 1171 of file TrackingNtuple.cc.

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

◆ simhit_tof

std::vector<float> TrackingNtuple::simhit_tof
private

Definition at line 1169 of file TrackingNtuple.cc.

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

◆ simhit_x

std::vector<float> TrackingNtuple::simhit_x
private

Definition at line 1163 of file TrackingNtuple.cc.

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

◆ simhit_y

std::vector<float> TrackingNtuple::simhit_y
private

Definition at line 1164 of file TrackingNtuple.cc.

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

◆ simhit_z

std::vector<float> TrackingNtuple::simhit_z
private

Definition at line 1165 of file TrackingNtuple.cc.

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

◆ simHitTPMapToken_

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

Definition at line 643 of file TrackingNtuple.cc.

Referenced by analyze().

◆ simpv_idx

std::vector<int> TrackingNtuple::simpv_idx
private

Definition at line 1255 of file TrackingNtuple.cc.

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

◆ simvtx_bunchCrossing

std::vector<int> TrackingNtuple::simvtx_bunchCrossing
private

Definition at line 1248 of file TrackingNtuple.cc.

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

◆ simvtx_daughterSimIdx

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

Definition at line 1254 of file TrackingNtuple.cc.

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

◆ simvtx_event

std::vector<int> TrackingNtuple::simvtx_event
private

Definition at line 1247 of file TrackingNtuple.cc.

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

◆ simvtx_processType

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

Definition at line 1249 of file TrackingNtuple.cc.

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

◆ simvtx_sourceSimIdx

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

Definition at line 1253 of file TrackingNtuple.cc.

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

◆ simvtx_x

std::vector<float> TrackingNtuple::simvtx_x
private

Definition at line 1250 of file TrackingNtuple.cc.

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

◆ simvtx_y

std::vector<float> TrackingNtuple::simvtx_y
private

Definition at line 1251 of file TrackingNtuple.cc.

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

◆ simvtx_z

std::vector<float> TrackingNtuple::simvtx_z
private

Definition at line 1252 of file TrackingNtuple.cc.

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

◆ siphase2OTSimLinksToken_

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

Definition at line 647 of file TrackingNtuple.cc.

Referenced by analyze().

◆ str_bbxi

std::vector<float> TrackingNtuple::str_bbxi
private

Definition at line 1107 of file TrackingNtuple.cc.

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

◆ str_chargeFraction

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

Definition at line 1094 of file TrackingNtuple.cc.

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

◆ str_detId

DetIdStrip TrackingNtuple::str_detId
private

Definition at line 1090 of file TrackingNtuple.cc.

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

◆ str_isBarrel

std::vector<short> TrackingNtuple::str_isBarrel
private

Definition at line 1089 of file TrackingNtuple.cc.

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

◆ str_radL

std::vector<float> TrackingNtuple::str_radL
private

Definition at line 1106 of file TrackingNtuple.cc.

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

◆ str_seeIdx

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

Definition at line 1092 of file TrackingNtuple.cc.

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

◆ str_simHitIdx

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

Definition at line 1093 of file TrackingNtuple.cc.

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

◆ str_simType

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

Definition at line 1095 of file TrackingNtuple.cc.

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

◆ str_trkIdx

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

Definition at line 1091 of file TrackingNtuple.cc.

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

◆ str_x

std::vector<float> TrackingNtuple::str_x
private

Definition at line 1096 of file TrackingNtuple.cc.

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

◆ str_xx

std::vector<float> TrackingNtuple::str_xx
private

Definition at line 1099 of file TrackingNtuple.cc.

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

◆ str_xy

std::vector<float> TrackingNtuple::str_xy
private

Definition at line 1100 of file TrackingNtuple.cc.

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

◆ str_y

std::vector<float> TrackingNtuple::str_y
private

Definition at line 1097 of file TrackingNtuple.cc.

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

◆ str_yy

std::vector<float> TrackingNtuple::str_yy
private

Definition at line 1101 of file TrackingNtuple.cc.

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

◆ str_yz

std::vector<float> TrackingNtuple::str_yz
private

Definition at line 1102 of file TrackingNtuple.cc.

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

◆ str_z

std::vector<float> TrackingNtuple::str_z
private

Definition at line 1098 of file TrackingNtuple.cc.

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

◆ str_zx

std::vector<float> TrackingNtuple::str_zx
private

Definition at line 1104 of file TrackingNtuple.cc.

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

◆ str_zz

std::vector<float> TrackingNtuple::str_zz
private

Definition at line 1103 of file TrackingNtuple.cc.

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

◆ stripMatchedRecHitToken_

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> TrackingNtuple::stripMatchedRecHitToken_
private

Definition at line 653 of file TrackingNtuple.cc.

Referenced by fillStripMatchedHits().

◆ stripRphiRecHitToken_

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripRphiRecHitToken_
private

Definition at line 651 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

◆ stripSimLinkToken_

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

Definition at line 646 of file TrackingNtuple.cc.

Referenced by analyze().

◆ stripStereoRecHitToken_

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripStereoRecHitToken_
private

Definition at line 652 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

◆ t

TTree* TrackingNtuple::t
private

Definition at line 667 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ tGeomToken_

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

Definition at line 632 of file TrackingNtuple.cc.

Referenced by analyze().

◆ tpNLayersToken_

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

Definition at line 657 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tpNPixelLayersToken_

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

Definition at line 658 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tpNStripStereoLayersToken_

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

Definition at line 659 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tracer_

HistoryBase TrackingNtuple::tracer_
private

Definition at line 665 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles(), and TrackingNtuple().

◆ trackAssociatorToken_

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

Definition at line 644 of file TrackingNtuple.cc.

Referenced by analyze().

◆ trackingParticleRefToken_

edm::EDGetTokenT<TrackingParticleRefVector> TrackingNtuple::trackingParticleRefToken_
private

Definition at line 641 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ trackingParticleToken_

edm::EDGetTokenT<TrackingParticleCollection> TrackingNtuple::trackingParticleToken_
private

Definition at line 640 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ trackingVertexToken_

edm::EDGetTokenT<TrackingVertexCollection> TrackingNtuple::trackingVertexToken_
private

Definition at line 656 of file TrackingNtuple.cc.

Referenced by analyze().

◆ trackToken_

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

Definition at line 637 of file TrackingNtuple.cc.

Referenced by analyze(), and fillTracks().

◆ trk_algo

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

Definition at line 1001 of file TrackingNtuple.cc.

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

◆ trk_algoMask

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

Definition at line 1003 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkIdx

std::vector<int> TrackingNtuple::trk_bestFromFirstHitSimTrkIdx
private

Definition at line 1014 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkNChi2

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkNChi2
private

Definition at line 1018 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFrac

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFrac
private

Definition at line 1015 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
private

Definition at line 1017 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimDenom
private

Definition at line 1016 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkIdx

std::vector<int> TrackingNtuple::trk_bestSimTrkIdx
private

Definition at line 1009 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkNChi2

std::vector<float> TrackingNtuple::trk_bestSimTrkNChi2
private

Definition at line 1013 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFrac

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFrac
private

Definition at line 1010 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFracSimClusterDenom

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimClusterDenom
private

Definition at line 1012 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFracSimDenom

std::vector<float> TrackingNtuple::trk_bestSimTrkShareFracSimDenom
private

Definition at line 1011 of file TrackingNtuple.cc.

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

◆ trk_cotTheta

std::vector<float> TrackingNtuple::trk_cotTheta
private

Definition at line 964 of file TrackingNtuple.cc.

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

◆ trk_dxy

std::vector<float> TrackingNtuple::trk_dxy
private

Definition at line 966 of file TrackingNtuple.cc.

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

◆ trk_dxyClosestPV

std::vector<float> TrackingNtuple::trk_dxyClosestPV
private

Definition at line 970 of file TrackingNtuple.cc.

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

◆ trk_dxyErr

std::vector<float> TrackingNtuple::trk_dxyErr
private

Definition at line 976 of file TrackingNtuple.cc.

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

◆ trk_dxyPV

std::vector<float> TrackingNtuple::trk_dxyPV
private

Definition at line 968 of file TrackingNtuple.cc.

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

◆ trk_dz

std::vector<float> TrackingNtuple::trk_dz
private

Definition at line 967 of file TrackingNtuple.cc.

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

◆ trk_dzClosestPV

std::vector<float> TrackingNtuple::trk_dzClosestPV
private

Definition at line 971 of file TrackingNtuple.cc.

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

◆ trk_dzErr

std::vector<float> TrackingNtuple::trk_dzErr
private

Definition at line 977 of file TrackingNtuple.cc.

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

◆ trk_dzPV

std::vector<float> TrackingNtuple::trk_dzPV
private

Definition at line 969 of file TrackingNtuple.cc.

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

◆ trk_eta

std::vector<float> TrackingNtuple::trk_eta
private

Definition at line 962 of file TrackingNtuple.cc.

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

◆ trk_etaErr

std::vector<float> TrackingNtuple::trk_etaErr
private

Definition at line 973 of file TrackingNtuple.cc.

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

◆ trk_hitIdx

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

Definition at line 1022 of file TrackingNtuple.cc.

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

◆ trk_hitType

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

Definition at line 1023 of file TrackingNtuple.cc.

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

◆ trk_inner_pt

std::vector<float> TrackingNtuple::trk_inner_pt
private

Definition at line 957 of file TrackingNtuple.cc.

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

◆ trk_inner_px

std::vector<float> TrackingNtuple::trk_inner_px
private

Definition at line 954 of file TrackingNtuple.cc.

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

◆ trk_inner_py

std::vector<float> TrackingNtuple::trk_inner_py
private

Definition at line 955 of file TrackingNtuple.cc.

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

◆ trk_inner_pz

std::vector<float> TrackingNtuple::trk_inner_pz
private

Definition at line 956 of file TrackingNtuple.cc.

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

◆ trk_isHP

std::vector<short> TrackingNtuple::trk_isHP
private

Definition at line 1005 of file TrackingNtuple.cc.

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

◆ trk_isTrue

std::vector<short> TrackingNtuple::trk_isTrue
private

Definition at line 1008 of file TrackingNtuple.cc.

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

◆ trk_lambda

std::vector<float> TrackingNtuple::trk_lambda
private

Definition at line 963 of file TrackingNtuple.cc.

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

◆ trk_lambdaErr

std::vector<float> TrackingNtuple::trk_lambdaErr
private

Definition at line 974 of file TrackingNtuple.cc.

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

◆ trk_mvas

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

Definition at line 984 of file TrackingNtuple.cc.

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

◆ trk_n3DLay

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

Definition at line 998 of file TrackingNtuple.cc.

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

◆ trk_nChi2

std::vector<float> TrackingNtuple::trk_nChi2
private

Definition at line 981 of file TrackingNtuple.cc.

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

◆ trk_nChi2_1Dmod

std::vector<float> TrackingNtuple::trk_nChi2_1Dmod
private

Definition at line 982 of file TrackingNtuple.cc.

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

◆ trk_nCluster

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

Definition at line 1000 of file TrackingNtuple.cc.

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

◆ trk_ndof

std::vector<float> TrackingNtuple::trk_ndof
private

Definition at line 983 of file TrackingNtuple.cc.

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

◆ trk_nInactive

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

Definition at line 989 of file TrackingNtuple.cc.

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

◆ trk_nInnerInactive

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

Definition at line 995 of file TrackingNtuple.cc.

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

◆ trk_nInnerLost

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

Definition at line 993 of file TrackingNtuple.cc.

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

◆ trk_nLost

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

Definition at line 988 of file TrackingNtuple.cc.

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

◆ trk_nLostLay

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

Definition at line 999 of file TrackingNtuple.cc.

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

◆ trk_nOuterInactive

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

Definition at line 994 of file TrackingNtuple.cc.

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

◆ trk_nOuterLost

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

Definition at line 992 of file TrackingNtuple.cc.

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

◆ trk_nPixel

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

Definition at line 990 of file TrackingNtuple.cc.

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

◆ trk_nPixelLay

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

Definition at line 996 of file TrackingNtuple.cc.

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

◆ trk_nStrip

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

Definition at line 991 of file TrackingNtuple.cc.

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

◆ trk_nStripLay

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

Definition at line 997 of file TrackingNtuple.cc.

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

◆ trk_nValid

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

Definition at line 987 of file TrackingNtuple.cc.

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

◆ trk_originalAlgo

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

Definition at line 1002 of file TrackingNtuple.cc.

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

◆ trk_outer_pt

std::vector<float> TrackingNtuple::trk_outer_pt
private

Definition at line 961 of file TrackingNtuple.cc.

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

◆ trk_outer_px

std::vector<float> TrackingNtuple::trk_outer_px
private

Definition at line 958 of file TrackingNtuple.cc.

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

◆ trk_outer_py

std::vector<float> TrackingNtuple::trk_outer_py
private

Definition at line 959 of file TrackingNtuple.cc.

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

◆ trk_outer_pz

std::vector<float> TrackingNtuple::trk_outer_pz
private

Definition at line 960 of file TrackingNtuple.cc.

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

◆ trk_phi

std::vector<float> TrackingNtuple::trk_phi
private

Definition at line 965 of file TrackingNtuple.cc.

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

◆ trk_phiErr

std::vector<float> TrackingNtuple::trk_phiErr
private

Definition at line 975 of file TrackingNtuple.cc.

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

◆ trk_pt

std::vector<float> TrackingNtuple::trk_pt
private

Definition at line 953 of file TrackingNtuple.cc.

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

◆ trk_ptErr

std::vector<float> TrackingNtuple::trk_ptErr
private

Definition at line 972 of file TrackingNtuple.cc.

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

◆ trk_px

std::vector<float> TrackingNtuple::trk_px
private

Definition at line 950 of file TrackingNtuple.cc.

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

◆ trk_py

std::vector<float> TrackingNtuple::trk_py
private

Definition at line 951 of file TrackingNtuple.cc.

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

◆ trk_pz

std::vector<float> TrackingNtuple::trk_pz
private

Definition at line 952 of file TrackingNtuple.cc.

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

◆ trk_q

std::vector<int> TrackingNtuple::trk_q
private

Definition at line 986 of file TrackingNtuple.cc.

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

◆ trk_qualityMasks

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

Definition at line 985 of file TrackingNtuple.cc.

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

◆ trk_refpoint_x

std::vector<float> TrackingNtuple::trk_refpoint_x
private

Definition at line 978 of file TrackingNtuple.cc.

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

◆ trk_refpoint_y

std::vector<float> TrackingNtuple::trk_refpoint_y
private

Definition at line 979 of file TrackingNtuple.cc.

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

◆ trk_refpoint_z

std::vector<float> TrackingNtuple::trk_refpoint_z
private

Definition at line 980 of file TrackingNtuple.cc.

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

◆ trk_seedIdx

std::vector<int> TrackingNtuple::trk_seedIdx
private

Definition at line 1006 of file TrackingNtuple.cc.

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

◆ trk_simTrkIdx

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

Definition at line 1021 of file TrackingNtuple.cc.

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

◆ trk_simTrkNChi2

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

Definition at line 1020 of file TrackingNtuple.cc.

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

◆ trk_simTrkShareFrac

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

Definition at line 1019 of file TrackingNtuple.cc.

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

◆ trk_stopReason

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

Definition at line 1004 of file TrackingNtuple.cc.

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

◆ trk_vtxIdx

std::vector<int> TrackingNtuple::trk_vtxIdx
private

Definition at line 1007 of file TrackingNtuple.cc.

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

◆ tTopoToken_

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

Definition at line 631 of file TrackingNtuple.cc.

Referenced by analyze().

◆ ttrhToken_

const edm::ESGetToken<TransientTrackingRecHitBuilder, TransientRecHitRecord> TrackingNtuple::ttrhToken_
private

Definition at line 630 of file TrackingNtuple.cc.

Referenced by analyze().

◆ vertexToken_

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

Definition at line 655 of file TrackingNtuple.cc.

Referenced by analyze().

◆ vtx_chi2

std::vector<float> TrackingNtuple::vtx_chi2
private

Definition at line 1239 of file TrackingNtuple.cc.

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

◆ vtx_fake

std::vector<short> TrackingNtuple::vtx_fake
private

Definition at line 1240 of file TrackingNtuple.cc.

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

◆ vtx_ndof

std::vector<float> TrackingNtuple::vtx_ndof
private

Definition at line 1238 of file TrackingNtuple.cc.

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

◆ vtx_trkIdx

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

Definition at line 1242 of file TrackingNtuple.cc.

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

◆ vtx_valid

std::vector<short> TrackingNtuple::vtx_valid
private

Definition at line 1241 of file TrackingNtuple.cc.

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

◆ vtx_x

std::vector<float> TrackingNtuple::vtx_x
private

Definition at line 1232 of file TrackingNtuple.cc.

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

◆ vtx_xErr

std::vector<float> TrackingNtuple::vtx_xErr
private

Definition at line 1235 of file TrackingNtuple.cc.

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

◆ vtx_y

std::vector<float> TrackingNtuple::vtx_y
private

Definition at line 1233 of file TrackingNtuple.cc.

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

◆ vtx_yErr

std::vector<float> TrackingNtuple::vtx_yErr
private

Definition at line 1236 of file TrackingNtuple.cc.

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

◆ vtx_z

std::vector<float> TrackingNtuple::vtx_z
private

Definition at line 1234 of file TrackingNtuple.cc.

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

◆ vtx_zErr

std::vector<float> TrackingNtuple::vtx_zErr
private

Definition at line 1237 of file TrackingNtuple.cc.

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

runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:542
TrackingNtuple::sim_px
std::vector< float > sim_px
Definition: TrackingNtuple.cc:1032
TrackingNtuple::HitType::Unknown
TrackingNtuple::fillPixelHits
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)
Definition: TrackingNtuple.cc:2479
SummaryClient_cfi.labels
labels
Definition: SummaryClient_cfi.py:61
TrackingNtuple::trackAssociatorToken_
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociatorToken_
Definition: TrackingNtuple.cc:644
edm::DetSetVector
Definition: DetSetVector.h:61
TrackingNtuple::HitSimType::Noise
TrackingNtuple::vtx_chi2
std::vector< float > vtx_chi2
Definition: TrackingNtuple.cc:1239
heavyionUCCDQM_cfi.nClusters
nClusters
Definition: heavyionUCCDQM_cfi.py:9
TrackingNtuple::pix_simHitIdx
std::vector< std::vector< int > > pix_simHitIdx
Definition: TrackingNtuple.cc:1071
reco::HitPattern::MISSING_OUTER_HITS
Definition: HitPattern.h:155
TrackingNtuple::sim_simHitIdx
std::vector< std::vector< int > > sim_simHitIdx
Definition: TrackingNtuple.cc:1063
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
TrackingNtuple::see_hitIdx
std::vector< std::vector< int > > see_hitIdx
Definition: TrackingNtuple.cc:1224
TrackingNtuple::vtx_xErr
std::vector< float > vtx_xErr
Definition: TrackingNtuple.cc:1235
TrackingNtuple::str_yz
std::vector< float > str_yz
Definition: TrackingNtuple.cc:1102
TrackingNtuple::t
TTree * t
Definition: TrackingNtuple.cc:667
TrackingNtuple::trk_refpoint_z
std::vector< float > trk_refpoint_z
Definition: TrackingNtuple.cc:980
cscDigiValidation_cfi.simTrack
simTrack
Definition: cscDigiValidation_cfi.py:29
TrackingNtuple::see_eta
std::vector< float > see_eta
Definition: TrackingNtuple.cc:1190
TrackingNtuple::ev_lumi
edm::LuminosityBlockNumber_t ev_lumi
Definition: TrackingNtuple.cc:944
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:173
mps_fire.i
i
Definition: mps_fire.py:428
edm::ESInputTag
Definition: ESInputTag.h:87
TrackingNtuple::trk_seedIdx
std::vector< int > trk_seedIdx
Definition: TrackingNtuple.cc:1006
TrackingNtuple::HitType::Phase2OT
TrackingNtuple::matchCluster
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)
Definition: TrackingNtuple.cc:2259
TrackingNtuple::sim_trkShareFrac
std::vector< std::vector< float > > sim_trkShareFrac
Definition: TrackingNtuple.cc:1059
TrackingNtuple::trackToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
Definition: TrackingNtuple.cc:637
TrackingNtuple::str_seeIdx
std::vector< std::vector< int > > str_seeIdx
Definition: TrackingNtuple.cc:1092
TrackingNtuple::tpHitIndexListLessSort
static bool tpHitIndexListLessSort(const TPHitIndex &i, const TPHitIndex &j)
Definition: TrackingNtuple.cc:501
StandaloneTrackMonitor_cfi.trackQuality
trackQuality
Definition: StandaloneTrackMonitor_cfi.py:11
TrackingNtuple::glu_yy
std::vector< float > glu_yy
Definition: TrackingNtuple.cc:1121
TrackingNtuple::trk_nChi2_1Dmod
std::vector< float > trk_nChi2_1Dmod
Definition: TrackingNtuple.cc:982
TrackingNtuple::trk_inner_pz
std::vector< float > trk_inner_pz
Definition: TrackingNtuple.cc:956
TrackingNtuple::trk_qualityMasks
std::vector< std::vector< unsigned short > > trk_qualityMasks
Definition: TrackingNtuple.cc:985
TrackingNtuple::trk_originalAlgo
std::vector< unsigned int > trk_originalAlgo
Definition: TrackingNtuple.cc:1002
TrackingNtuple::includeTrackingParticles_
const bool includeTrackingParticles_
Definition: TrackingNtuple.cc:663
TrackingNtuple::str_radL
std::vector< float > str_radL
Definition: TrackingNtuple.cc:1106
TrackingNtuple::see_stateTrajPy
std::vector< float > see_stateTrajPy
Definition: TrackingNtuple.cc:1204
TrackingNtuple::trk_dzPV
std::vector< float > trk_dzPV
Definition: TrackingNtuple.cc:969
TrackingNtuple::trk_isHP
std::vector< short > trk_isHP
Definition: TrackingNtuple.cc:1005
PixelSubdetector::PixelEndcap
Definition: PixelSubdetector.h:11
hit::id
unsigned int id
Definition: SiStripHitEffFromCalibTree.cc:92
PixelSubdetector::PixelBarrel
Definition: PixelSubdetector.h:11
edm::Handle::product
T const * product() const
Definition: Handle.h:70
TrackingNtuple::clearVariables
void clearVariables()
Definition: TrackingNtuple.cc:1703
TrackingNtuple::see_nPixel
std::vector< unsigned int > see_nPixel
Definition: TrackingNtuple.cc:1208
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
TrackingNtuple::ev_event
edm::EventNumber_t ev_event
Definition: TrackingNtuple.cc:945
TrackingNtuple::str_y
std::vector< float > str_y
Definition: TrackingNtuple.cc:1097
TrackingNtuple::trackingVertexToken_
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexToken_
Definition: TrackingNtuple.cc:656
TrackingNtuple::glu_seeIdx
std::vector< std::vector< int > > glu_seeIdx
Definition: TrackingNtuple.cc:1115
TrackingNtuple::trk_n3DLay
std::vector< unsigned int > trk_n3DLay
Definition: TrackingNtuple.cc:998
TrackingNtuple::see_stateTrajX
std::vector< float > see_stateTrajX
Definition: TrackingNtuple.cc:1201
TrackingNtuple::trk_nPixel
std::vector< unsigned int > trk_nPixel
Definition: TrackingNtuple.cc:990
TrackingNtuple::glu_xx
std::vector< float > glu_xx
Definition: TrackingNtuple.cc:1119
TrackingNtuple::trk_nOuterInactive
std::vector< unsigned int > trk_nOuterInactive
Definition: TrackingNtuple.cc:994
TrackingNtuple::trk_dz
std::vector< float > trk_dz
Definition: TrackingNtuple.cc:967
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
TrackingNtuple::see_stateTrajPz
std::vector< float > see_stateTrajPz
Definition: TrackingNtuple.cc:1205
TrackingNtuple::str_isBarrel
std::vector< short > str_isBarrel
Definition: TrackingNtuple.cc:1089
TrackingNtuple::trk_dzErr
std::vector< float > trk_dzErr
Definition: TrackingNtuple.cc:977
TrackingNtuple::ph2_z
std::vector< float > ph2_z
Definition: TrackingNtuple.cc:1140
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
TrackingNtuple::see_simTrkIdx
std::vector< std::vector< int > > see_simTrkIdx
Definition: TrackingNtuple.cc:1223
TrackingNtuple::tracer_
HistoryBase tracer_
Definition: TrackingNtuple.cc:665
TrackingNtuple::trk_etaErr
std::vector< float > trk_etaErr
Definition: TrackingNtuple.cc:973
TrackingNtuple::trk_isTrue
std::vector< short > trk_isTrue
Definition: TrackingNtuple.cc:1008
min
T min(T a, T b)
Definition: MathUtil.h:58
TrackingNtuple::ttrhToken_
const edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord > ttrhToken_
Definition: TrackingNtuple.cc:630
TrackingNtuple::includeAllHits_
const bool includeAllHits_
Definition: TrackingNtuple.cc:661
TrackingNtuple::trk_bestSimTrkNChi2
std::vector< float > trk_bestSimTrkNChi2
Definition: TrackingNtuple.cc:1013
TrackingNtuple::trk_bestSimTrkIdx
std::vector< int > trk_bestSimTrkIdx
Definition: TrackingNtuple.cc:1009
edm
HLT enums.
Definition: AlignableModifier.h:19
TrackingNtuple::includeMVA_
const bool includeMVA_
Definition: TrackingNtuple.cc:662
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimDenom
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimDenom
Definition: TrackingNtuple.cc:1016
TrackerTopology
Definition: TrackerTopology.h:16
TrackingNtuple::see_px
std::vector< float > see_px
Definition: TrackingNtuple.cc:1186
edm::ProductLabels::module
char const * module
Definition: ProductLabels.h:5
reco::TrackToTrackingParticleAssociator::associateRecoToSim
reco::RecoToSimCollection associateRecoToSim(const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const
Definition: TrackToTrackingParticleAssociator.h:64
TrackingNtuple::paramsDefineToken_
const edm::ESGetToken< ParametersDefinerForTP, TrackAssociatorRecord > paramsDefineToken_
Definition: TrackingNtuple.cc:633
DetId::det
constexpr Detector det() const
get the detector field from this detid
Definition: DetId.h:46
TrackingNtuple::see_dxy
std::vector< float > see_dxy
Definition: TrackingNtuple.cc:1192
TrackingNtuple::HitSimType
HitSimType
Definition: TrackingNtuple.cc:487
TrackingNtuple::trk_nOuterLost
std::vector< unsigned int > trk_nOuterLost
Definition: TrackingNtuple.cc:992
TrackingNtuple::bsp_sigmax
float bsp_sigmax
Definition: TrackingNtuple.cc:1179
pos
Definition: PixelAliasList.h:18
edm::LogPrint
Log< level::Warning, true > LogPrint
Definition: MessageLogger.h:130
TrackingNtuple::pixelSimLinkToken_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinkToken_
Definition: TrackingNtuple.cc:645
TrackingNtuple::ph2_xy
std::vector< float > ph2_xy
Definition: TrackingNtuple.cc:1142
HLT_FULL_cff.InputTag
InputTag
Definition: HLT_FULL_cff.py:89285
reco::TrackToTrackingParticleAssociator
Definition: TrackToTrackingParticleAssociator.h:51
ClusterTPAssociation
Definition: ClusterTPAssociation.h:21
l1GtPatternGenerator_cfi.bx
bx
Definition: l1GtPatternGenerator_cfi.py:18
edm::ParameterSetDescription
Definition: ParameterSetDescription.h:52
TrackingNtuple::see_hitType
std::vector< std::vector< int > > see_hitType
Definition: TrackingNtuple.cc:1225
TrackingNtuple::simhit_detId
DetIdAll simhit_detId
Definition: TrackingNtuple.cc:1161
TrackingNtuple::simhit_process
std::vector< short > simhit_process
Definition: TrackingNtuple.cc:1167
track_associator::trackAssociationChi2
double trackAssociationChi2(const reco::TrackBase::ParameterVector &rParameters, const reco::TrackBase::CovarianceMatrix &recoTrackCovMatrix, const Basic3DVector< double > &momAtVtx, const Basic3DVector< double > &vert, int charge, const MagneticField &magfield, const reco::BeamSpot &bs)
basic method where chi2 is computed
Definition: trackAssociationChi2.cc:9
TrackingNtuple::vertexToken_
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
Definition: TrackingNtuple.cc:655
edm::EDGetTokenT::isUninitialized
constexpr bool isUninitialized() const noexcept
Definition: EDGetToken.h:99
TrackingVertexCollection
std::vector< TrackingVertex > TrackingVertexCollection
Definition: TrackingVertexContainer.h:8
TrackingNtuple::trk_nPixelLay
std::vector< unsigned int > trk_nPixelLay
Definition: TrackingNtuple.cc:996
TrackingNtuple::see_trkIdx
std::vector< int > see_trkIdx
Definition: TrackingNtuple.cc:1216
TrackingNtuple::tpNLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNLayersToken_
Definition: TrackingNtuple.cc:657
TrackingNtuple::inv_detId
DetIdAll inv_detId
Definition: TrackingNtuple.cc:1155
TrackerTopology::layer
unsigned int layer(const DetId &id) const
Definition: TrackerTopology.cc:47
reco::Unknown
Definition: MuonSimInfo.h:32
TrackingNtuple::str_trkIdx
std::vector< std::vector< int > > str_trkIdx
Definition: TrackingNtuple.cc:1091
TrackingNtuple::trk_nCluster
std::vector< unsigned int > trk_nCluster
Definition: TrackingNtuple.cc:1000
edmNew::DetSetVector::begin
const_iterator begin(bool update=false) const
Definition: DetSetVectorNew.h:530
TrackingNtuple::see_bestFromFirstHitSimTrkShareFrac
std::vector< float > see_bestFromFirstHitSimTrkShareFrac
Definition: TrackingNtuple.cc:1221
HistoryBase::recoGenParticleTrail
const RecoGenParticleTrail & recoGenParticleTrail() const
Return all reco::GenParticle in the history.
Definition: HistoryBase.h:64
TrackingNtuple::trk_refpoint_y
std::vector< float > trk_refpoint_y
Definition: TrackingNtuple.cc:979
TrackingNtuple::simpv_idx
std::vector< int > simpv_idx
Definition: TrackingNtuple.cc:1255
HistoryBase::RecoGenParticleTrail
std::vector< const reco::GenParticle * > RecoGenParticleTrail
reco::GenParticle trail type.
Definition: HistoryBase.h:18
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
TrackingParticle::Vector
math::XYZVectorD Vector
point in the space
Definition: TrackingParticle.h:37
TrackingNtuple::see_nGlued
std::vector< unsigned int > see_nGlued
Definition: TrackingNtuple.cc:1209
TrackingNtuple::sim_parentVtxIdx
std::vector< int > sim_parentVtxIdx
Definition: TrackingNtuple.cc:1061
edm::RefVector< TrackingParticleCollection >
TrackingNtuple::trk_px
std::vector< float > trk_px
Definition: TrackingNtuple.cc:950
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFrac
std::vector< float > trk_bestFromFirstHitSimTrkShareFrac
Definition: TrackingNtuple.cc:1015
TrackingNtuple::pix_isBarrel
std::vector< short > pix_isBarrel
Definition: TrackingNtuple.cc:1067
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
TrackingNtuple::trk_inner_pt
std::vector< float > trk_inner_pt
Definition: TrackingNtuple.cc:957
TrackingRecHit::RecHitPointer
std::shared_ptr< TrackingRecHit const > RecHitPointer
Definition: TrackingRecHit.h:24
TrackingNtuple::pix_yz
std::vector< float > pix_yz
Definition: TrackingNtuple.cc:1080
Signal
findQualityFiles.v
v
Definition: findQualityFiles.py:179
hltPixelTracks_cff.chi2
chi2
Definition: hltPixelTracks_cff.py:25
beam_dqm_sourceclient-live_cfg.mva
mva
Definition: beam_dqm_sourceclient-live_cfg.py:126
TransientTrackingRecHitBuilder::build
virtual RecHitPointer build(const TrackingRecHit *p) const =0
build a tracking rechit from an existing rechit
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
TrackingNtuple::trk_outer_pz
std::vector< float > trk_outer_pz
Definition: TrackingNtuple.cc:960
TrackingNtuple::str_xy
std::vector< float > str_xy
Definition: TrackingNtuple.cc:1100
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
edm::Handle< reco::TrackToTrackingParticleAssociator >
TrackingNtuple::simhit_z
std::vector< float > simhit_z
Definition: TrackingNtuple.cc:1165
TrackingNtuple::ph2_zz
std::vector< float > ph2_zz
Definition: TrackingNtuple.cc:1145
TrackingNtuple::ph2_yy
std::vector< float > ph2_yy
Definition: TrackingNtuple.cc:1143
TrackingNtuple::sim_nStrip
std::vector< unsigned int > sim_nStrip
Definition: TrackingNtuple.cc:1049
TrackingNtuple::see_dzErr
std::vector< float > see_dzErr
Definition: TrackingNtuple.cc:1198
TrackingNtuple::sim_isFromBHadron
std::vector< int > sim_isFromBHadron
Definition: TrackingNtuple.cc:1031
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
TrackingNtuple::trk_nInnerLost
std::vector< unsigned int > trk_nInnerLost
Definition: TrackingNtuple.cc:993
TrackingNtuple::sim_nRecoClusters
std::vector< unsigned int > sim_nRecoClusters
Definition: TrackingNtuple.cc:1056
edm::Ref
Definition: AssociativeIterator.h:58
TrackingNtuple::glu_zx
std::vector< float > glu_zx
Definition: TrackingNtuple.cc:1124
TrackingNtuple::glu_detId
DetIdStrip glu_detId
Definition: TrackingNtuple.cc:1112
OmniClusterRef::cluster_phase2OT
Phase2Cluster1DRef cluster_phase2OT() const
Definition: OmniClusterRef.h:48
heavyIonCSV_trainingSettings.idx
idx
Definition: heavyIonCSV_trainingSettings.py:5
TrackingNtuple::pix_zx
std::vector< float > pix_zx
Definition: TrackingNtuple.cc:1082
TrackingNtuple::fillSeeds
void fillSeeds(const edm::Event &iEvent, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const reco::BeamSpot &bs, const reco::TrackToTrackingParticleAssociator &associatorByHits, const ClusterTPAssociation &clusterToTPMap, const TransientTrackingRecHitBuilder &theTTRHBuilder, const MagneticField &theMF, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList, const std::set< edm::ProductID > &hitProductIds, std::map< edm::ProductID, size_t > &seedToCollIndex)
Definition: TrackingNtuple.cc:2757
TrackingNtuple::fillTracks
void fillTracks(const edm::RefToBaseVector< reco::Track > &tracks, const TrackingParticleRefVector &tpCollection, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const TrackingParticleRefKeyToCount &tpKeyToClusterCount, const MagneticField &mf, const reco::BeamSpot &bs, const reco::VertexCollection &vertices, const reco::TrackToTrackingParticleAssociator &associatorByHits, const ClusterTPAssociation &clusterToTPMap, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, const std::set< edm::ProductID > &hitProductIds, const std::map< edm::ProductID, size_t > &seedToCollIndex, const std::vector< const MVACollection * > &mvaColls, const std::vector< const QualityMaskCollection * > &qualColls)
Definition: TrackingNtuple.cc:3097
TrackingNtuple::fillSimHits
void fillSimHits(const TrackerGeometry &tracker, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const TrackerTopology &tTopo, SimHitRefKeyToIndex &simHitRefKeyToIndex, std::vector< TPHitIndex > &tpHitList)
Definition: TrackingNtuple.cc:2367
trackingPlots.assoc
assoc
Definition: trackingPlots.py:184
ndof
Definition: HIMultiTrackSelector.h:49
MuonAssociatorByHits_cfi.tpTag
tpTag
Definition: MuonAssociatorByHits_cfi.py:152
fileCollector.seed
seed
Definition: fileCollector.py:127
TrackingNtuple::str_chargeFraction
std::vector< std::vector< float > > str_chargeFraction
Definition: TrackingNtuple.cc:1094
TrackingNtuple::fillTrackingParticles
void fillTrackingParticles(const edm::Event &iEvent, const edm::EventSetup &iSetup, const edm::RefToBaseVector< reco::Track > &tracks, const reco::BeamSpot &bs, const TrackingParticleRefVector &tpCollection, const TrackingVertexRefKeyToIndex &tvKeyToIndex, const reco::TrackToTrackingParticleAssociator &associatorByHits, const std::vector< TPHitIndex > &tpHitList, const TrackingParticleRefKeyToCount &tpKeyToClusterCount)
Definition: TrackingNtuple.cc:3379
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
DetId
Definition: DetId.h:17
cmsdt::algo
algo
Definition: constants.h:165
TrackingNtuple::str_z
std::vector< float > str_z
Definition: TrackingNtuple.cc:1098
TrackingNtuple::glu_zz
std::vector< float > glu_zz
Definition: TrackingNtuple.cc:1123
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:171
cms::cuda::bs
bs
Definition: HistoContainer.h:127
TrackingNtuple::sim_decayVtxIdx
std::vector< std::vector< int > > sim_decayVtxIdx
Definition: TrackingNtuple.cc:1062
TrackingNtuple::bsp_sigmay
float bsp_sigmay
Definition: TrackingNtuple.cc:1180
reco::HitPattern
Definition: HitPattern.h:147
track_associator::hitsToClusterRefs
std::vector< OmniClusterRef > hitsToClusterRefs(iter begin, iter end)
Definition: trackHitsToClusterRefs.h:21
TrackingNtuple::sim_q
std::vector< int > sim_q
Definition: TrackingNtuple.cc:1045
TrackingNtuple::HitType::Pixel
TTClusterAssociation_cfi.digiSimLinks
digiSimLinks
Definition: TTClusterAssociation_cfi.py:8
TrackingNtuple::trk_algo
std::vector< unsigned int > trk_algo
Definition: TrackingNtuple.cc:1001
EgammaObjectsElectrons_cfi.particleID
particleID
Definition: EgammaObjectsElectrons_cfi.py:4
TrackingParticleIP::dxy
auto dxy(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
Definition: TrackingParticleIP.h:11
TrackingNtuple::trk_phi
std::vector< float > trk_phi
Definition: TrackingNtuple.cc:965
TrackingNtuple::ph2_simType
std::vector< unsigned short > ph2_simType
Definition: TrackingNtuple.cc:1137
trackingPlots.hp
hp
Definition: trackingPlots.py:1230
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
Definition: TrackingNtuple.cc:1017
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
edm::RefToBaseVector::push_back
void push_back(const RefToBase< T > &)
Definition: RefToBaseVector.h:217
TrackingNtuple::trk_algoMask
std::vector< decltype(reco::TrackBase().algoMaskUL())> trk_algoMask
Definition: TrackingNtuple.cc:1003
TrackingNtuple::see_pt
std::vector< float > see_pt
Definition: TrackingNtuple.cc:1189
nHits
const caConstants::TupleMultiplicity *__restrict__ const HitsOnGPU *__restrict__ double *__restrict__ float *__restrict__ double *__restrict__ uint32_t nHits
Definition: BrokenLineFitOnGPU.h:27
TrackingNtuple::trk_dxyClosestPV
std::vector< float > trk_dxyClosestPV
Definition: TrackingNtuple.cc:970
TrackingNtuple::see_pz
std::vector< float > see_pz
Definition: TrackingNtuple.cc:1188
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
TrackingNtuple::inv_detId_phase2
DetIdAllPhase2 inv_detId_phase2
Definition: TrackingNtuple.cc:1156
BaseTrackerRecHit
Definition: BaseTrackerRecHit.h:15
TrackingNtuple::see_nValid
std::vector< unsigned int > see_nValid
Definition: TrackingNtuple.cc:1207
TrackingNtuple::simhit_tof
std::vector< float > simhit_tof
Definition: TrackingNtuple.cc:1169
TrackingNtuple::pix_x
std::vector< float > pix_x
Definition: TrackingNtuple.cc:1074
TrackingNtuple::HitType::Glued
PVValHelper::eta
Definition: PVValidationHelpers.h:70
TrackingNtuple::inv_type
std::vector< unsigned short > inv_type
Definition: TrackingNtuple.cc:1157
TrackingNtuple::see_etaErr
std::vector< float > see_etaErr
Definition: TrackingNtuple.cc:1195
TrackingNtuple::pix_zz
std::vector< float > pix_zz
Definition: TrackingNtuple.cc:1081
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
TrackingNtuple::ph2_yz
std::vector< float > ph2_yz
Definition: TrackingNtuple.cc:1144
TrackingParticle
Monte Carlo truth information used for tracking validation.
Definition: TrackingParticle.h:29
TrackingNtuple::fillPhase2OTHits
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)
Definition: TrackingNtuple.cc:2688
TrackingNtuple::trk_simTrkIdx
std::vector< std::vector< int > > trk_simTrkIdx
Definition: TrackingNtuple.cc:1021
reco::BeamSpot
Definition: BeamSpot.h:21
TrackingNtuple::sim_pca_eta
std::vector< float > sim_pca_eta
Definition: TrackingNtuple.cc:1039
TrackingNtuple::str_simHitIdx
std::vector< std::vector< int > > str_simHitIdx
Definition: TrackingNtuple.cc:1093
TrackingVertexRef
edm::Ref< TrackingVertexCollection > TrackingVertexRef
Definition: TrackingVertexContainer.h:9
TrackingNtuple::sim_nPixelLay
std::vector< unsigned int > sim_nPixelLay
Definition: TrackingNtuple.cc:1051
declareDynArray
#define declareDynArray(T, n, x)
Definition: DynArray.h:91
TrackingNtuple::see_dz
std::vector< float > see_dz
Definition: TrackingNtuple.cc:1193
TrackingNtuple::see_bestSimTrkShareFrac
std::vector< float > see_bestSimTrkShareFrac
Definition: TrackingNtuple.cc:1219
TrackingNtuple::bsp_x
float bsp_x
Definition: TrackingNtuple.cc:1176
TrackingNtuple::trk_simTrkNChi2
std::vector< std::vector< float > > trk_simTrkNChi2
Definition: TrackingNtuple.cc:1020
submitPVResolutionJobs.count
count
Definition: submitPVResolutionJobs.py:352
TrackingNtuple::sim_pca_cotTheta
std::vector< float > sim_pca_cotTheta
Definition: TrackingNtuple.cc:1041
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
TrackingNtuple::simvtx_daughterSimIdx
std::vector< std::vector< int > > simvtx_daughterSimIdx
Definition: TrackingNtuple.cc:1254
TrackingNtuple::sim_trkIdx
std::vector< std::vector< int > > sim_trkIdx
Definition: TrackingNtuple.cc:1058
reco::TrackBase::algoName
std::string algoName() const
Definition: TrackBase.h:550
TrackingNtuple::trk_lambdaErr
std::vector< float > trk_lambdaErr
Definition: TrackingNtuple.cc:974
TrackingNtuple::ph2_isBarrel
std::vector< short > ph2_isBarrel
Definition: TrackingNtuple.cc:1131
TrackingNtuple::sim_pca_lambda
std::vector< float > sim_pca_lambda
Definition: TrackingNtuple.cc:1040
TrackingNtuple::pix_xy
std::vector< float > pix_xy
Definition: TrackingNtuple.cc:1078
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
TrackingNtuple::pix_simType
std::vector< unsigned short > pix_simType
Definition: TrackingNtuple.cc:1073
TrackingNtuple::simhit_x
std::vector< float > simhit_x
Definition: TrackingNtuple.cc:1163
TrackingNtuple::trk_simTrkShareFrac
std::vector< std::vector< float > > trk_simTrkShareFrac
Definition: TrackingNtuple.cc:1019
TrackingNtuple::vtx_valid
std::vector< short > vtx_valid
Definition: TrackingNtuple.cc:1241
TrackingNtuple::ph2_radL
std::vector< float > ph2_radL
Definition: TrackingNtuple.cc:1148
TrackingNtuple::ev_run
edm::RunNumber_t ev_run
Definition: TrackingNtuple.cc:943
Point3DBase< float, GlobalTag >
TrackingNtuple::sim_pca_pt
std::vector< float > sim_pca_pt
Definition: TrackingNtuple.cc:1038
TrackingNtuple::tpHitIndexListLess
static bool tpHitIndexListLess(const TPHitIndex &i, const TPHitIndex &j)
Definition: TrackingNtuple.cc:500
TrackingNtuple::ph2_detId
DetIdPhase2OT ph2_detId
Definition: TrackingNtuple.cc:1132
TrackingNtuple::mvaQualityCollectionTokens_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityCollectionTokens_
Definition: TrackingNtuple.cc:639
TrackingNtuple::trk_nInnerInactive
std::vector< unsigned int > trk_nInnerInactive
Definition: TrackingNtuple.cc:995
TrackingNtuple::simhit_y
std::vector< float > simhit_y
Definition: TrackingNtuple.cc:1164
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
TrackingNtuple::see_bestSimTrkIdx
std::vector< int > see_bestSimTrkIdx
Definition: TrackingNtuple.cc:1218
edmNew::DetSetVector::dataSize
size_type dataSize() const
Definition: DetSetVectorNew.h:552
TrackingNtuple::see_statePt
std::vector< float > see_statePt
Definition: TrackingNtuple.cc:1200
DetId::subdetId
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector's numbering enum)
Definition: DetId.h:48
TrackingNtuple::trk_lambda
std::vector< float > trk_lambda
Definition: TrackingNtuple.cc:963
TrackingNtuple::glu_isBarrel
std::vector< short > glu_isBarrel
Definition: TrackingNtuple.cc:1111
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::vector_transform
auto vector_transform(std::vector< InputType > const &input, Function predicate) -> std::vector< typename std::remove_cv< typename std::remove_reference< decltype(predicate(input.front()))>::type >::type >
Definition: transform.h:11
TrackingNtuple::trk_pz
std::vector< float > trk_pz
Definition: TrackingNtuple.cc:952
TrackingNtuple::sim_nLay
std::vector< unsigned int > sim_nLay
Definition: TrackingNtuple.cc:1050
TrackingNtuple::str_simType
std::vector< unsigned short > str_simType
Definition: TrackingNtuple.cc:1095
TrackingNtuple::ph2_xx
std::vector< float > ph2_xx
Definition: TrackingNtuple.cc:1141
TrackingNtuple::trk_mvas
std::vector< std::vector< float > > trk_mvas
Definition: TrackingNtuple.cc:984
bsc_activity_cfg.clusters
clusters
Definition: bsc_activity_cfg.py:36
PbPb_ZMuSkimMuonDPG_cff.tracker
tracker
Definition: PbPb_ZMuSkimMuonDPG_cff.py:60
TrackingNtuple::beamSpotToken_
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
Definition: TrackingNtuple.cc:649
ALCARECOTkAlJpsiMuMu_cff.charge
charge
Definition: ALCARECOTkAlJpsiMuMu_cff.py:47
trackFromSeedFitFailed
bool trackFromSeedFitFailed(const reco::Track &track)
Definition: trackFromSeedFitFailed.h:6
runTauDisplay.gp
gp
Definition: runTauDisplay.py:431
TrackingNtuple::stripSimLinkToken_
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > > stripSimLinkToken_
Definition: TrackingNtuple.cc:646
TrackingNtuple::pix_y
std::vector< float > pix_y
Definition: TrackingNtuple.cc:1075
edm::View
Definition: CaloClusterFwd.h:14
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
TrackingNtuple::trk_vtxIdx
std::vector< int > trk_vtxIdx
Definition: TrackingNtuple.cc:1007
Point
Structure Point Contains parameters of Gaussian fits to DMRs.
Definition: DMRtrends.cc:57
trackerHitRTTI::isMatched
bool isMatched(TrackingRecHit const &hit)
Definition: trackerHitRTTI.h:33
ntupleEnum.OOTPileup
OOTPileup
Definition: ntupleEnum.py:108
TrackingNtuple::trk_nChi2
std::vector< float > trk_nChi2
Definition: TrackingNtuple.cc:981
TrackingNtuple::see_simTrkShareFrac
std::vector< std::vector< float > > see_simTrkShareFrac
Definition: TrackingNtuple.cc:1222
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
TrackingNtuple::stripMatchedRecHitToken_
edm::EDGetTokenT< SiStripMatchedRecHit2DCollection > stripMatchedRecHitToken_
Definition: TrackingNtuple.cc:653
TrackingNtuple::str_zx
std::vector< float > str_zx
Definition: TrackingNtuple.cc:1104
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:233
TrackingNtuple::trk_inner_py
std::vector< float > trk_inner_py
Definition: TrackingNtuple.cc:955
TrackingNtuple::see_nPhase2OT
std::vector< unsigned int > see_nPhase2OT
Definition: TrackingNtuple.cc:1211
TrackingNtuple::sim_genPdgIds
std::vector< std::vector< int > > sim_genPdgIds
Definition: TrackingNtuple.cc:1030
DetId::Tracker
Definition: DetId.h:25
TrackingNtuple::see_nCluster
std::vector< unsigned int > see_nCluster
Definition: TrackingNtuple.cc:1212
TrackingNtuple::sim_nValid
std::vector< unsigned int > sim_nValid
Definition: TrackingNtuple.cc:1047
TrackingNtuple::seedTokens_
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > seedTokens_
Definition: TrackingNtuple.cc:635
TrackingNtuple::trackingParticleToken_
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleToken_
Definition: TrackingNtuple.cc:640
tracks
const uint32_t *__restrict__ const HitContainer *__restrict__ TkSoA *__restrict__ tracks
Definition: CAHitNtupletGeneratorKernelsImpl.h:159
TrackingNtuple::simHitTPMapToken_
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > simHitTPMapToken_
Definition: TrackingNtuple.cc:643
TrackingNtuple::HitSimType::ITPileup
TrackingNtuple::ph2_simHitIdx
std::vector< std::vector< int > > ph2_simHitIdx
Definition: TrackingNtuple.cc:1135
TrackingNtuple::sim_bunchCrossing
std::vector< int > sim_bunchCrossing
Definition: TrackingNtuple.cc:1028
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
TrackingNtuple::pix_yy
std::vector< float > pix_yy
Definition: TrackingNtuple.cc:1079
SiStripMatchedRecHit2D::stereoClusterRef
OmniClusterRef const & stereoClusterRef() const
Definition: SiStripMatchedRecHit2D.h:34
edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >
type
type
Definition: SiPixelVCal_PayloadInspector.cc:37
TrackingNtuple::glu_x
std::vector< float > glu_x
Definition: TrackingNtuple.cc:1116
TrackingNtuple::fillTrackingVertices
void fillTrackingVertices(const TrackingVertexRefVector &trackingVertices, const TrackingParticleRefKeyToIndex &tpKeyToIndex)
Definition: TrackingNtuple.cc:3578
TrackingVertex
Definition: TrackingVertex.h:22
TrackingNtuple::trk_q
std::vector< int > trk_q
Definition: TrackingNtuple.cc:986
TrackingNtuple::sim_event
std::vector< int > sim_event
Definition: TrackingNtuple.cc:1027
trackingNtuple_cff.seedTracks
seedTracks
Definition: trackingNtuple_cff.py:76
jetUpdater_cfi.sort
sort
Definition: jetUpdater_cfi.py:29
TrackingNtuple::stripStereoRecHitToken_
edm::EDGetTokenT< SiStripRecHit2DCollection > stripStereoRecHitToken_
Definition: TrackingNtuple.cc:652
TrackingNtuple::see_py
std::vector< float > see_py
Definition: TrackingNtuple.cc:1187
TrackingNtuple::see_nStrip
std::vector< unsigned int > see_nStrip
Definition: TrackingNtuple.cc:1210
TrackingNtuple::see_stopReason
std::vector< unsigned short > see_stopReason
Definition: TrackingNtuple.cc:1214
TrackingNtuple::HitSimType::Signal
funct::tan
Tan< T >::type tan(const T &t)
Definition: Tan.h:22
OmniClusterRef::phase2OTCluster
Phase2TrackerCluster1D const & phase2OTCluster() const
Definition: OmniClusterRef.h:56
TrackingNtuple::glu_yz
std::vector< float > glu_yz
Definition: TrackingNtuple.cc:1122
TrackingNtuple::glu_z
std::vector< float > glu_z
Definition: TrackingNtuple.cc:1118
edm::Service< TFileService >
createfilelist.int
int
Definition: createfilelist.py:10
iEvent
int iEvent
Definition: GenABIO.cc:224
TrackingNtuple::ph2_seeIdx
std::vector< std::vector< int > > ph2_seeIdx
Definition: TrackingNtuple.cc:1134
TrackingNtuple::trk_bestFromFirstHitSimTrkNChi2
std::vector< float > trk_bestFromFirstHitSimTrkNChi2
Definition: TrackingNtuple.cc:1018
TrackingNtuple::sim_pz
std::vector< float > sim_pz
Definition: TrackingNtuple.cc:1034
TrackingNtuple::tGeomToken_
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord > tGeomToken_
Definition: TrackingNtuple.cc:632
TrackingNtuple::simvtx_sourceSimIdx
std::vector< std::vector< int > > simvtx_sourceSimIdx
Definition: TrackingNtuple.cc:1253
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:49
TrackingNtuple::sim_eta
std::vector< float > sim_eta
Definition: TrackingNtuple.cc:1036
TrackingNtuple::trk_nLost
std::vector< unsigned int > trk_nLost
Definition: TrackingNtuple.cc:988
ClusterTPAssociation::equal_range
range equal_range(const OmniClusterRef &key) const
Definition: ClusterTPAssociation.h:65
TrackingNtuple::vtx_fake
std::vector< short > vtx_fake
Definition: TrackingNtuple.cc:1240
TrackingNtuple::trk_outer_py
std::vector< float > trk_outer_py
Definition: TrackingNtuple.cc:959
MuonTrackValidator_cfi.parametersDefiner
parametersDefiner
Definition: MuonTrackValidator_cfi.py:26
GlobalErrorBase< double, ErrorMatrixTag >
TrackingNtuple::see_isTrue
std::vector< short > see_isTrue
Definition: TrackingNtuple.cc:1217
TrackingNtuple::simhit_eloss
std::vector< float > simhit_eloss
Definition: TrackingNtuple.cc:1168
BaseTrackerRecHit::firstClusterRef
virtual OmniClusterRef const & firstClusterRef() const =0
TrackingNtuple::trk_hitIdx
std::vector< std::vector< int > > trk_hitIdx
Definition: TrackingNtuple.cc:1022
TrackingNtuple::simvtx_x
std::vector< float > simvtx_x
Definition: TrackingNtuple.cc:1250
TrackingNtuple::simhit_detId_phase2
DetIdAllPhase2 simhit_detId_phase2
Definition: TrackingNtuple.cc:1162
TrackingNtuple::trk_dxy
std::vector< float > trk_dxy
Definition: TrackingNtuple.cc:966
TrackingNtuple::pix_xx
std::vector< float > pix_xx
Definition: TrackingNtuple.cc:1077
TrackingNtuple::glu_stereoIdx
std::vector< int > glu_stereoIdx
Definition: TrackingNtuple.cc:1114
TrackingNtuple::str_zz
std::vector< float > str_zz
Definition: TrackingNtuple.cc:1103
TrackingNtuple::addStripMatchedHit
size_t addStripMatchedHit(const SiStripMatchedRecHit2D &hit, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)
Definition: TrackingNtuple.cc:2644
TrackingNtuple::trk_py
std::vector< float > trk_py
Definition: TrackingNtuple.cc:951
TrackingNtuple::vtx_zErr
std::vector< float > vtx_zErr
Definition: TrackingNtuple.cc:1237
Invalid
Definition: hltDiff.cc:247
SiStripRecHit1D
Definition: SiStripRecHit1D.h:8
TrackingNtuple::trk_bestFromFirstHitSimTrkIdx
std::vector< int > trk_bestFromFirstHitSimTrkIdx
Definition: TrackingNtuple.cc:1014
TrackingNtuple::fillStripRphiStereoHits
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)
Definition: TrackingNtuple.cc:2548
TrackingNtuple::simvtx_event
std::vector< int > simvtx_event
Definition: TrackingNtuple.cc:1247
edm::RefVector::push_back
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:67
edm::RefToBaseVector< reco::Track >
SiStripMatchedRecHit2D::monoClusterRef
OmniClusterRef const & monoClusterRef() const
Definition: SiStripMatchedRecHit2D.h:35
TrackingNtuple::str_bbxi
std::vector< float > str_bbxi
Definition: TrackingNtuple.cc:1107
TrackingNtuple::bsp_z
float bsp_z
Definition: TrackingNtuple.cc:1178
TrackingNtuple::trk_nInactive
std::vector< unsigned int > trk_nInactive
Definition: TrackingNtuple.cc:989
TrackingNtuple::ph2_x
std::vector< float > ph2_x
Definition: TrackingNtuple.cc:1138
TrackingNtuple::tpNPixelLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNPixelLayersToken_
Definition: TrackingNtuple.cc:658
TrackingNtuple::str_detId
DetIdStrip str_detId
Definition: TrackingNtuple.cc:1090
TrackingNtuple::includeSeeds_
const bool includeSeeds_
Definition: TrackingNtuple.cc:660
reco::HitPattern::TRACK_HITS
Definition: HitPattern.h:155
TrackingNtuple::trk_bestSimTrkShareFracSimClusterDenom
std::vector< float > trk_bestSimTrkShareFracSimClusterDenom
Definition: TrackingNtuple.cc:1012
TrackingNtuple::trk_nStripLay
std::vector< unsigned int > trk_nStripLay
Definition: TrackingNtuple.cc:997
edm::EventSetup::getData
bool getData(T &iHolder) const
Definition: EventSetup.h:127
TrackingNtuple::trk_ndof
std::vector< float > trk_ndof
Definition: TrackingNtuple.cc:983
TrackingNtuple::trk_outer_pt
std::vector< float > trk_outer_pt
Definition: TrackingNtuple.cc:961
TrackingNtuple::sim_nTrackerHits
std::vector< unsigned int > sim_nTrackerHits
Definition: TrackingNtuple.cc:1054
TrackingRecHit
Definition: TrackingRecHit.h:21
TrackingNtuple::glu_bbxi
std::vector< float > glu_bbxi
Definition: TrackingNtuple.cc:1127
TrackingNtuple::trk_bestSimTrkShareFrac
std::vector< float > trk_bestSimTrkShareFrac
Definition: TrackingNtuple.cc:1010
TrackingNtuple::glu_monoIdx
std::vector< int > glu_monoIdx
Definition: TrackingNtuple.cc:1113
TrackingNtuple::vtx_ndof
std::vector< float > vtx_ndof
Definition: TrackingNtuple.cc:1238
edm::EDConsumerBase::labelsForToken
void labelsForToken(EDGetToken iToken, Labels &oLabels) const
Definition: EDConsumerBase.cc:338
TrackingNtuple::simvtx_z
std::vector< float > simvtx_z
Definition: TrackingNtuple.cc:1252
TrackingNtuple::trk_cotTheta
std::vector< float > trk_cotTheta
Definition: TrackingNtuple.cc:964
TrackingNtuple::includePhase2OTHits_
bool includePhase2OTHits_
Definition: TrackingNtuple.cc:648
DDAxes::phi
TrackingNtuple::trk_refpoint_x
std::vector< float > trk_refpoint_x
Definition: TrackingNtuple.cc:978
TrackingNtuple::vtx_y
std::vector< float > vtx_y
Definition: TrackingNtuple.cc:1233
TrackingNtuple::stripRphiRecHitToken_
edm::EDGetTokenT< SiStripRecHit2DCollection > stripRphiRecHitToken_
Definition: TrackingNtuple.cc:651
TrackingNtuple::trk_stopReason
std::vector< unsigned short > trk_stopReason
Definition: TrackingNtuple.cc:1004
TrackingNtuple::clusterTPMapToken_
edm::EDGetTokenT< ClusterTPAssociation > clusterTPMapToken_
Definition: TrackingNtuple.cc:642
TrackingNtuple::trk_nLostLay
std::vector< unsigned int > trk_nLostLay
Definition: TrackingNtuple.cc:999
RZLine
Definition: RZLine.h:12
edmNew::DetSetVector
Definition: DetSetNew.h:13
TrackingNtuple::mfToken_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord > mfToken_
Definition: TrackingNtuple.cc:629
edm::Ref::id
ProductID id() const
Accessor for product ID.
Definition: Ref.h:244
edm::RefToBaseVector::size
size_type size() const
Definition: RefToBaseVector.h:160
submitPVResolutionJobs.desc
string desc
Definition: submitPVResolutionJobs.py:251
TrackingNtuple::ph2_bbxi
std::vector< float > ph2_bbxi
Definition: TrackingNtuple.cc:1149
OmniClusterRef::id
edm::ProductID id() const
Definition: OmniClusterRef.h:69
std
Definition: JetResolutionObject.h:76
DetId::rawId
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:57
TrackingNtuple::fillBeamSpot
void fillBeamSpot(const reco::BeamSpot &bs)
Definition: TrackingNtuple.cc:2236
TrackingNtuple::trk_outer_px
std::vector< float > trk_outer_px
Definition: TrackingNtuple.cc:958
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
TrackingNtuple::pix_detId
DetIdPixel pix_detId
Definition: TrackingNtuple.cc:1068
TrackingNtuple::pix_trkIdx
std::vector< std::vector< int > > pix_trkIdx
Definition: TrackingNtuple.cc:1069
RunInfoPI::state
state
Definition: RunInfoPayloadInspectoHelper.h:16
TrackingNtuple::pixelRecHitToken_
edm::EDGetTokenT< SiPixelRecHitCollection > pixelRecHitToken_
Definition: TrackingNtuple.cc:650
TrackingNtuple::inv_isBarrel
std::vector< short > inv_isBarrel
Definition: TrackingNtuple.cc:1154
TrackingNtuple::glu_xy
std::vector< float > glu_xy
Definition: TrackingNtuple.cc:1120
TrackingNtuple::sim_nPixel
std::vector< unsigned int > sim_nPixel
Definition: TrackingNtuple.cc:1048
TrackingNtuple::ph2_zx
std::vector< float > ph2_zx
Definition: TrackingNtuple.cc:1146
SiStripMatchedRecHit2D
Definition: SiStripMatchedRecHit2D.h:8
TrackingNtuple::phase2OTRecHitToken_
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew > phase2OTRecHitToken_
Definition: TrackingNtuple.cc:654
SimTrack
Definition: SimTrack.h:9
TrackingNtuple::see_algo
std::vector< unsigned int > see_algo
Definition: TrackingNtuple.cc:1213
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:29
TrackingNtuple::trk_dxyErr
std::vector< float > trk_dxyErr
Definition: TrackingNtuple.cc:976
TSCBLBuilderNoMaterial
Definition: TSCBLBuilderNoMaterial.h:13
TrackingNtuple::trk_pt
std::vector< float > trk_pt
Definition: TrackingNtuple.cc:953
TrackingNtuple::trk_eta
std::vector< float > trk_eta
Definition: TrackingNtuple.cc:962
edmNew::DetSetVector::end
const_iterator end(bool update=false) const
Definition: DetSetVectorNew.h:535
TrackingNtuple::see_stateTrajPx
std::vector< float > see_stateTrajPx
Definition: TrackingNtuple.cc:1203
edm::ValueMap
Definition: ValueMap.h:107
TrackingNtuple::vtx_trkIdx
std::vector< std::vector< int > > vtx_trkIdx
Definition: TrackingNtuple.cc:1242
Exception
Definition: hltDiff.cc:245
TFileService::kSharedResource
static const std::string kSharedResource
Definition: TFileService.h:76
reco::HitPattern::MISSING_INNER_HITS
Definition: HitPattern.h:155
TrackingNtuple::see_nCands
std::vector< unsigned short > see_nCands
Definition: TrackingNtuple.cc:1215
TrackingNtuple::sim_pca_dxy
std::vector< float > sim_pca_dxy
Definition: TrackingNtuple.cc:1043
TrackingNtuple::see_stateTrajY
std::vector< float > see_stateTrajY
Definition: TrackingNtuple.cc:1202
TrackingNtuple::simhit_hitIdx
std::vector< std::vector< int > > simhit_hitIdx
Definition: TrackingNtuple.cc:1172
TrackingNtuple::simhit_particle
std::vector< int > simhit_particle
Definition: TrackingNtuple.cc:1166
TrackingNtuple::bsp_y
float bsp_y
Definition: TrackingNtuple.cc:1177
align::Strip
Definition: StructureType.h:69
TrackingNtuple::glu_radL
std::vector< float > glu_radL
Definition: TrackingNtuple.cc:1126
TrackingNtuple::trk_nValid
std::vector< unsigned int > trk_nValid
Definition: TrackingNtuple.cc:987
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
TrackingNtuple::trk_hitType
std::vector< std::vector< int > > trk_hitType
Definition: TrackingNtuple.cc:1023
TrackPSimHitRef
edm::Ref< edm::PSimHitContainer > TrackPSimHitRef
Definition: PSimHitContainer.h:14
TrackingNtuple::str_xx
std::vector< float > str_xx
Definition: TrackingNtuple.cc:1099
TrackingNtuple::see_phi
std::vector< float > see_phi
Definition: TrackingNtuple.cc:1191
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
TrackingNtuple::siphase2OTSimLinksToken_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > siphase2OTSimLinksToken_
Definition: TrackingNtuple.cc:647
TrackingNtuple::tpNStripStereoLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNStripStereoLayersToken_
Definition: TrackingNtuple.cc:659
align::Pixel
Definition: StructureType.h:68
TrackingNtuple::see_q
std::vector< int > see_q
Definition: TrackingNtuple.cc:1206
reco::TrackToTrackingParticleAssociator::associateSimToReco
reco::SimToRecoCollection associateSimToReco(const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const
Definition: TrackToTrackingParticleAssociator.h:71
TrackingNtuple::glu_y
std::vector< float > glu_y
Definition: TrackingNtuple.cc:1117
TrackingNtuple::see_dxyErr
std::vector< float > see_dxyErr
Definition: TrackingNtuple.cc:1197
TrackingNtuple::fillVertices
void fillVertices(const reco::VertexCollection &vertices, const edm::RefToBaseVector< reco::Track > &tracks)
Definition: TrackingNtuple.cc:3545
TrackingNtuple::HitType::Invalid
TrackingNtuple::sim_pt
std::vector< float > sim_pt
Definition: TrackingNtuple.cc:1035
TrackingNtuple::trk_ptErr
std::vector< float > trk_ptErr
Definition: TrackingNtuple.cc:972
TrackingNtuple::pix_radL
std::vector< float > pix_radL
Definition: TrackingNtuple.cc:1084
TrackingNtuple::pix_bbxi
std::vector< float > pix_bbxi
Definition: TrackingNtuple.cc:1085
ntupleEnum.ITPileup
ITPileup
Definition: ntupleEnum.py:107
edm::EDConsumerBase::esConsumes
auto esConsumes()
Definition: EDConsumerBase.h:202
edm::Ref::key
key_type key() const
Accessor for product key.
Definition: Ref.h:250
TrackingNtuple::trk_dxyPV
std::vector< float > trk_dxyPV
Definition: TrackingNtuple.cc:968
TrackingNtuple::vtx_z
std::vector< float > vtx_z
Definition: TrackingNtuple.cc:1234
TrackingNtuple::fillStripMatchedHits
void fillStripMatchedHits(const edm::Event &iEvent, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)
Definition: TrackingNtuple.cc:2675
TrackingNtuple::sim_seedIdx
std::vector< std::vector< int > > sim_seedIdx
Definition: TrackingNtuple.cc:1060
TrackingNtuple::sim_pca_dz
std::vector< float > sim_pca_dz
Definition: TrackingNtuple.cc:1044
TrackingNtuple::see_fitok
std::vector< short > see_fitok
Definition: TrackingNtuple.cc:1185
TrackingNtuple::trk_nStrip
std::vector< unsigned int > trk_nStrip
Definition: TrackingNtuple.cc:991
DigiDM_cff.Noise
Noise
Definition: DigiDM_cff.py:38
TrackingNtuple::str_x
std::vector< float > str_x
Definition: TrackingNtuple.cc:1096
TrackingNtuple::see_offset
std::vector< unsigned int > see_offset
Definition: TrackingNtuple.cc:1227
TrackingNtuple::sim_n3DLay
std::vector< unsigned int > sim_n3DLay
Definition: TrackingNtuple.cc:1052
cms::Exception
Definition: Exception.h:70
reco::TrackBase::algoByName
static TrackAlgorithm algoByName(const std::string &name)
Definition: TrackBase.cc:137
TrackingNtuple::str_yy
std::vector< float > str_yy
Definition: TrackingNtuple.cc:1101
TrackingNtuple::pix_z
std::vector< float > pix_z
Definition: TrackingNtuple.cc:1076
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
TrackingNtuple::trk_inner_px
std::vector< float > trk_inner_px
Definition: TrackingNtuple.cc:954
TrackingParticleRef
edm::Ref< TrackingParticleCollection > TrackingParticleRef
Definition: TrackingParticleFwd.h:12
edm::EDConsumerBase::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: EDConsumerBase.h:155
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
TrackingNtuple::sim_pca_phi
std::vector< float > sim_pca_phi
Definition: TrackingNtuple.cc:1042
TrackingNtuple::ph2_trkIdx
std::vector< std::vector< int > > ph2_trkIdx
Definition: TrackingNtuple.cc:1133
TrackingNtuple::trk_bestSimTrkShareFracSimDenom
std::vector< float > trk_bestSimTrkShareFracSimDenom
Definition: TrackingNtuple.cc:1011
TrackingNtuple::simvtx_processType
std::vector< unsigned int > simvtx_processType
Definition: TrackingNtuple.cc:1249
event
Definition: event.py:1
TrackingNtuple::trackingParticleRefToken_
edm::EDGetTokenT< TrackingParticleRefVector > trackingParticleRefToken_
Definition: TrackingNtuple.cc:641
TrackingNtuple::fillTrackingParticlesForSeeds
void fillTrackingParticlesForSeeds(const TrackingParticleRefVector &tpCollection, const reco::SimToRecoCollection &simRecColl, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const unsigned int seedOffset)
Definition: TrackingNtuple.cc:3523
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:82
TrackingNtuple::see_phiErr
std::vector< float > see_phiErr
Definition: TrackingNtuple.cc:1196
TrackingParticle::Point
math::XYZPointD Point
point in the space
Definition: TrackingParticle.h:36
edm::RefVector::size
size_type size() const
Size of the RefVector.
Definition: RefVector.h:102
HLT_FULL_cff.distance
distance
Definition: HLT_FULL_cff.py:7733
crabWrapper.key
key
Definition: crabWrapper.py:19
OmniClusterRef::key
unsigned int key() const
Definition: OmniClusterRef.h:70
HistoryBase::evaluate
bool evaluate(TrackingParticleRef tpr)
Evaluate track history using a TrackingParticleRef.
Definition: HistoryBase.h:96
TrackingNtuple::sim_pdgId
std::vector< int > sim_pdgId
Definition: TrackingNtuple.cc:1029
TrackingNtuple::tTopoToken_
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd > tTopoToken_
Definition: TrackingNtuple.cc:631
LHEGenericFilter_cfi.ParticleID
ParticleID
Definition: LHEGenericFilter_cfi.py:6
TrackingNtuple::seedStopInfoTokens_
std::vector< edm::EDGetTokenT< std::vector< SeedStopInfo > > > seedStopInfoTokens_
Definition: TrackingNtuple.cc:636
TrackingNtuple::see_ptErr
std::vector< float > see_ptErr
Definition: TrackingNtuple.cc:1194
TrackingNtuple::simhit_hitType
std::vector< std::vector< int > > simhit_hitType
Definition: TrackingNtuple.cc:1173
edm::InputTag
Definition: InputTag.h:15
TrackingNtuple::includeStripHits_
bool includeStripHits_
Definition: TrackingNtuple.cc:648
label
const char * label
Definition: PFTauDecayModeTools.cc:11
TrackingNtuple::HitSimType::OOTPileup
OmniClusterRef::cluster_pixel
ClusterPixelRef cluster_pixel() const
Definition: OmniClusterRef.h:40
HistoryBase::depth
void depth(int d)
Set the depth of the history.
Definition: HistoryBase.h:49
TrackingNtuple::pix_chargeFraction
std::vector< std::vector< float > > pix_chargeFraction
Definition: TrackingNtuple.cc:1072
TrackingNtuple::simvtx_y
std::vector< float > simvtx_y
Definition: TrackingNtuple.cc:1251
edm::ProductID
Definition: ProductID.h:27
reco::Vertex
Definition: Vertex.h:35
StripSubdetector::TID
static constexpr auto TID
Definition: StripSubdetector.h:17
TrackingNtuple::ph2_y
std::vector< float > ph2_y
Definition: TrackingNtuple.cc:1139
TrackingNtuple::sim_phi
std::vector< float > sim_phi
Definition: TrackingNtuple.cc:1037
hit
Definition: SiStripHitEffFromCalibTree.cc:88
TrackingNtuple::HitType::Strip
TrackingNtuple::sim_py
std::vector< float > sim_py
Definition: TrackingNtuple.cc:1033
TFileService::make
T * make(const Args &... args) const
make new ROOT object
Definition: TFileService.h:64
edm::View::size_type
unsigned int size_type
Definition: View.h:90
TrackingNtuple::bsp_sigmaz
float bsp_sigmaz
Definition: TrackingNtuple.cc:1181
TrackingNtuple::vtx_x
std::vector< float > vtx_x
Definition: TrackingNtuple.cc:1232
TrackingNtuple::simhit_simTrkIdx
std::vector< int > simhit_simTrkIdx
Definition: TrackingNtuple.cc:1171
getBestVertex
Point getBestVertex(reco::Track const &trk, reco::VertexCollection const &vertices, const size_t minNtracks=2)
Definition: getBestVertex.h:8
edm::ProductLabels
Definition: ProductLabels.h:4
TrackingNtuple::simvtx_bunchCrossing
std::vector< int > simvtx_bunchCrossing
Definition: TrackingNtuple.cc:1248
TrackingNtuple::trk_phiErr
std::vector< float > trk_phiErr
Definition: TrackingNtuple.cc:975
TrackingNtuple::see_bestFromFirstHitSimTrkIdx
std::vector< int > see_bestFromFirstHitSimTrkIdx
Definition: TrackingNtuple.cc:1220
ParametersDefinerForTP
Definition: ParametersDefinerForTP.h:19
findQualityFiles.size
size
Write out results.
Definition: findQualityFiles.py:443
pwdgSkimBPark_cfi.vertices
vertices
Definition: pwdgSkimBPark_cfi.py:7
TrackingParticleIP::dz
auto dz(const T_Vertex &vertex, const T_Momentum &momentum, const T_Point &point)
Definition: TrackingParticleIP.h:16
TrackerGeometry
Definition: TrackerGeometry.h:14
TrackingNtuple::pix_seeIdx
std::vector< std::vector< int > > pix_seeIdx
Definition: TrackingNtuple.cc:1070
SimHitTPAssociationProducer::simHitTPAssociationListGreater
static bool simHitTPAssociationListGreater(SimHitTPPair i, SimHitTPPair j)
Definition: SimHitTPAssociationProducer.h:23
TrackingNtuple::see_chi2
std::vector< float > see_chi2
Definition: TrackingNtuple.cc:1199
TrackingNtuple::trk_dzClosestPV
std::vector< float > trk_dzClosestPV
Definition: TrackingNtuple.cc:971
reco::TrackBase::highPurity
Definition: TrackBase.h:154
TrackingNtuple::vtx_yErr
std::vector< float > vtx_yErr
Definition: TrackingNtuple.cc:1236
Generated for CMSSW Reference Manual by doxygen 1.8.16