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
 
- 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
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase & 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
 
std::string builderName_
 
edm::EDGetTokenT< ClusterTPAssociation > clusterTPMapToken_
 
edm::EventNumber_t ev_event
 
edm::LuminosityBlockNumber_t ev_lumi
 
edm::RunNumber_t ev_run
 
std::vector< float > glu_bbxi
 
DetIdStrip glu_detId
 
std::vector< short > glu_isBarrel
 
std::vector< int > glu_monoIdx
 
std::vector< float > glu_radL
 
std::vector< std::vector< int > > glu_seeIdx
 
std::vector< int > glu_stereoIdx
 
std::vector< float > glu_x
 
std::vector< float > glu_xx
 
std::vector< float > glu_xy
 
std::vector< float > glu_y
 
std::vector< float > glu_yy
 
std::vector< float > glu_yz
 
std::vector< float > glu_z
 
std::vector< float > glu_zx
 
std::vector< float > glu_zz
 
const bool includeAllHits_
 
const bool includeMVA_
 
bool includePhase2OTHits_
 
const bool includeSeeds_
 
bool includeStripHits_
 
const bool includeTrackingParticles_
 
DetIdAll inv_detId
 
DetIdAllPhase2 inv_detId_phase2
 
std::vector< short > inv_isBarrel
 
std::vector< unsigned short > inv_type
 
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityCollectionTokens_
 
std::string parametersDefinerName_
 
std::vector< float > ph2_bbxi
 
DetIdPhase2OT ph2_detId
 
std::vector< short > ph2_isBarrel
 
std::vector< float > ph2_radL
 
std::vector< std::vector< int > > ph2_seeIdx
 
std::vector< std::vector< int > > ph2_simHitIdx
 
std::vector< unsigned short > ph2_simType
 
std::vector< std::vector< int > > ph2_trkIdx
 
std::vector< float > ph2_x
 
std::vector< float > ph2_xx
 
std::vector< float > ph2_xy
 
std::vector< float > ph2_y
 
std::vector< float > ph2_yy
 
std::vector< float > ph2_yz
 
std::vector< float > ph2_z
 
std::vector< float > ph2_zx
 
std::vector< float > ph2_zz
 
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew > phase2OTRecHitToken_
 
std::vector< float > pix_bbxi
 
std::vector< std::vector< float > > pix_chargeFraction
 
DetIdPixel pix_detId
 
std::vector< short > pix_isBarrel
 
std::vector< float > pix_radL
 
std::vector< std::vector< int > > pix_seeIdx
 
std::vector< std::vector< int > > pix_simHitIdx
 
std::vector< unsigned short > pix_simType
 
std::vector< std::vector< int > > pix_trkIdx
 
std::vector< float > pix_x
 
std::vector< float > pix_xx
 
std::vector< float > pix_xy
 
std::vector< float > pix_y
 
std::vector< float > pix_yy
 
std::vector< float > pix_yz
 
std::vector< float > pix_z
 
std::vector< float > pix_zx
 
std::vector< float > pix_zz
 
edm::EDGetTokenT< SiPixelRecHitCollection > pixelRecHitToken_
 
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinkToken_
 
std::vector< unsigned int > see_algo
 
std::vector< int > see_bestFromFirstHitSimTrkIdx
 
std::vector< float > see_bestFromFirstHitSimTrkShareFrac
 
std::vector< int > see_bestSimTrkIdx
 
std::vector< float > see_bestSimTrkShareFrac
 
std::vector< float > see_chi2
 
std::vector< float > see_dxy
 
std::vector< float > see_dxyErr
 
std::vector< float > see_dz
 
std::vector< float > see_dzErr
 
std::vector< float > see_eta
 
std::vector< float > see_etaErr
 
std::vector< short > see_fitok
 
std::vector< std::vector< int > > see_hitIdx
 
std::vector< std::vector< int > > see_hitType
 
std::vector< short > see_isTrue
 
std::vector< unsigned short > see_nCands
 
std::vector< unsigned int > see_nCluster
 
std::vector< unsigned int > see_nGlued
 
std::vector< unsigned int > see_nPhase2OT
 
std::vector< unsigned int > see_nPixel
 
std::vector< unsigned int > see_nStrip
 
std::vector< unsigned int > see_nValid
 
std::vector< unsigned int > see_offset
 
std::vector< float > see_phi
 
std::vector< float > see_phiErr
 
std::vector< float > see_pt
 
std::vector< float > see_ptErr
 
std::vector< float > see_px
 
std::vector< float > see_py
 
std::vector< float > see_pz
 
std::vector< int > see_q
 
std::vector< std::vector< int > > see_simTrkIdx
 
std::vector< std::vector< float > > see_simTrkShareFrac
 
std::vector< float > see_statePt
 
std::vector< float > see_stateTrajPx
 
std::vector< float > see_stateTrajPy
 
std::vector< float > see_stateTrajPz
 
std::vector< float > see_stateTrajX
 
std::vector< float > see_stateTrajY
 
std::vector< unsigned short > see_stopReason
 
std::vector< int > see_trkIdx
 
std::vector< edm::EDGetTokenT< std::vector< SeedStopInfo > > > seedStopInfoTokens_
 
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > seedTokens_
 
std::vector< int > sim_bunchCrossing
 
std::vector< std::vector< int > > sim_decayVtxIdx
 
std::vector< float > sim_eta
 
std::vector< int > sim_event
 
std::vector< std::vector< int > > sim_genPdgIds
 
std::vector< int > sim_isFromBHadron
 
std::vector< unsigned int > sim_n3DLay
 
std::vector< unsigned int > sim_nLay
 
std::vector< unsigned int > sim_nPixel
 
std::vector< unsigned int > sim_nPixelLay
 
std::vector< unsigned int > sim_nRecoClusters
 
std::vector< unsigned int > sim_nStrip
 
std::vector< unsigned int > sim_nTrackerHits
 
std::vector< unsigned int > sim_nValid
 
std::vector< int > sim_parentVtxIdx
 
std::vector< float > sim_pca_cotTheta
 
std::vector< float > sim_pca_dxy
 
std::vector< float > sim_pca_dz
 
std::vector< float > sim_pca_eta
 
std::vector< float > sim_pca_lambda
 
std::vector< float > sim_pca_phi
 
std::vector< float > sim_pca_pt
 
std::vector< int > sim_pdgId
 
std::vector< float > sim_phi
 
std::vector< float > sim_pt
 
std::vector< float > sim_px
 
std::vector< float > sim_py
 
std::vector< float > sim_pz
 
std::vector< int > sim_q
 
std::vector< std::vector< int > > sim_seedIdx
 
std::vector< std::vector< int > > sim_simHitIdx
 
std::vector< std::vector< int > > sim_trkIdx
 
std::vector< std::vector< float > > sim_trkShareFrac
 
DetIdAll simhit_detId
 
DetIdAllPhase2 simhit_detId_phase2
 
std::vector< float > simhit_eloss
 
std::vector< std::vector< int > > simhit_hitIdx
 
std::vector< std::vector< int > > simhit_hitType
 
std::vector< int > simhit_particle
 
std::vector< short > simhit_process
 
std::vector< int > simhit_simTrkIdx
 
std::vector< float > simhit_tof
 
std::vector< float > simhit_x
 
std::vector< float > simhit_y
 
std::vector< float > simhit_z
 
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > simHitTPMapToken_
 
std::vector< int > simpv_idx
 
std::vector< int > simvtx_bunchCrossing
 
std::vector< std::vector< int > > simvtx_daughterSimIdx
 
std::vector< int > simvtx_event
 
std::vector< unsigned int > simvtx_processType
 
std::vector< std::vector< int > > simvtx_sourceSimIdx
 
std::vector< float > simvtx_x
 
std::vector< float > simvtx_y
 
std::vector< float > simvtx_z
 
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > siphase2OTSimLinksToken_
 
std::vector< float > str_bbxi
 
std::vector< std::vector< float > > str_chargeFraction
 
DetIdStrip str_detId
 
std::vector< short > str_isBarrel
 
std::vector< float > str_radL
 
std::vector< std::vector< int > > str_seeIdx
 
std::vector< std::vector< int > > str_simHitIdx
 
std::vector< unsigned short > str_simType
 
std::vector< std::vector< int > > str_trkIdx
 
std::vector< float > str_x
 
std::vector< float > str_xx
 
std::vector< float > str_xy
 
std::vector< float > str_y
 
std::vector< float > str_yy
 
std::vector< float > str_yz
 
std::vector< float > str_z
 
std::vector< float > str_zx
 
std::vector< float > str_zz
 
edm::EDGetTokenT< SiStripMatchedRecHit2DCollection > stripMatchedRecHitToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollection > stripRphiRecHitToken_
 
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > > stripSimLinkToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollection > stripStereoRecHitToken_
 
TTree * t
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNLayersToken_
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNPixelLayersToken_
 
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNStripStereoLayersToken_
 
HistoryBase tracer_
 
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociatorToken_
 
edm::EDGetTokenT< TrackingParticleRefVector > trackingParticleRefToken_
 
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleToken_
 
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexToken_
 
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
 
std::vector< unsigned int > trk_algo
 
std::vector< decltype(reco::TrackBase().algoMaskUL())> trk_algoMask
 
std::vector< int > trk_bestFromFirstHitSimTrkIdx
 
std::vector< float > trk_bestFromFirstHitSimTrkNChi2
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFrac
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
 
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimDenom
 
std::vector< int > trk_bestSimTrkIdx
 
std::vector< float > trk_bestSimTrkNChi2
 
std::vector< float > trk_bestSimTrkShareFrac
 
std::vector< float > trk_bestSimTrkShareFracSimClusterDenom
 
std::vector< float > trk_bestSimTrkShareFracSimDenom
 
std::vector< float > trk_cotTheta
 
std::vector< float > trk_dxy
 
std::vector< float > trk_dxyClosestPV
 
std::vector< float > trk_dxyErr
 
std::vector< float > trk_dxyPV
 
std::vector< float > trk_dz
 
std::vector< float > trk_dzClosestPV
 
std::vector< float > trk_dzErr
 
std::vector< float > trk_dzPV
 
std::vector< float > trk_eta
 
std::vector< float > trk_etaErr
 
std::vector< std::vector< int > > trk_hitIdx
 
std::vector< std::vector< int > > trk_hitType
 
std::vector< float > trk_inner_pt
 
std::vector< float > trk_inner_px
 
std::vector< float > trk_inner_py
 
std::vector< float > trk_inner_pz
 
std::vector< short > trk_isHP
 
std::vector< short > trk_isTrue
 
std::vector< float > trk_lambda
 
std::vector< float > trk_lambdaErr
 
std::vector< std::vector< float > > trk_mvas
 
std::vector< unsigned int > trk_n3DLay
 
std::vector< float > trk_nChi2
 
std::vector< float > trk_nChi2_1Dmod
 
std::vector< unsigned int > trk_nCluster
 
std::vector< float > trk_ndof
 
std::vector< unsigned int > trk_nInactive
 
std::vector< unsigned int > trk_nInnerInactive
 
std::vector< unsigned int > trk_nInnerLost
 
std::vector< unsigned int > trk_nLost
 
std::vector< unsigned int > trk_nLostLay
 
std::vector< unsigned int > trk_nOuterInactive
 
std::vector< unsigned int > trk_nOuterLost
 
std::vector< unsigned int > trk_nPixel
 
std::vector< unsigned int > trk_nPixelLay
 
std::vector< unsigned int > trk_nStrip
 
std::vector< unsigned int > trk_nStripLay
 
std::vector< unsigned int > trk_nValid
 
std::vector< unsigned int > trk_originalAlgo
 
std::vector< float > trk_outer_pt
 
std::vector< float > trk_outer_px
 
std::vector< float > trk_outer_py
 
std::vector< float > trk_outer_pz
 
std::vector< float > trk_phi
 
std::vector< float > trk_phiErr
 
std::vector< float > trk_pt
 
std::vector< float > trk_ptErr
 
std::vector< float > trk_px
 
std::vector< float > trk_py
 
std::vector< float > trk_pz
 
std::vector< int > trk_q
 
std::vector< std::vector< unsigned short > > trk_qualityMasks
 
std::vector< float > trk_refpoint_x
 
std::vector< float > trk_refpoint_y
 
std::vector< float > trk_refpoint_z
 
std::vector< int > trk_seedIdx
 
std::vector< std::vector< int > > trk_simTrkIdx
 
std::vector< std::vector< float > > trk_simTrkNChi2
 
std::vector< std::vector< float > > trk_simTrkShareFrac
 
std::vector< unsigned short > trk_stopReason
 
std::vector< int > trk_vtxIdx
 
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
 
std::vector< float > vtx_chi2
 
std::vector< short > vtx_fake
 
std::vector< float > vtx_ndof
 
std::vector< std::vector< int > > vtx_trkIdx
 
std::vector< short > vtx_valid
 
std::vector< float > vtx_x
 
std::vector< float > vtx_xErr
 
std::vector< float > vtx_y
 
std::vector< float > vtx_yErr
 
std::vector< float > vtx_z
 
std::vector< float > vtx_zErr
 

Additional Inherited Members

- Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase ModuleType
 
- Public Types inherited from edm::EDConsumerBase
typedef ProductLabels Labels
 
- Protected Member Functions inherited from edm::EDConsumerBase
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>
EDGetToken consumes (TypeToGet const &id, edm::InputTag const &tag)
 
ConsumesCollector consumesCollector ()
 Use a ConsumesCollector to gather consumes information from helper functions. More...
 
template<typename ProductType , BranchType B = InEvent>
void consumesMany ()
 
void consumesMany (const TypeToGet &id)
 
template<BranchType B>
void consumesMany (const TypeToGet &id)
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes ()
 
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto esConsumes (ESInputTag const &tag)
 
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 935 of file TrackingNtuple.cc.

◆ DetIdAllPhase2

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

Definition at line 936 of file TrackingNtuple.cc.

◆ DetIdPhase2OT

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

Definition at line 934 of file TrackingNtuple.cc.

◆ DetIdPixel

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

Definition at line 932 of file TrackingNtuple.cc.

◆ DetIdStrip

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

Definition at line 933 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 1257 of file TrackingNtuple.cc.

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

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

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

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

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

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

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

References align::BeamSpot, beamSpotToken_, cms::cuda::bs, builderName_, clearVariables(), clusterTPMapToken_, ev_event, ev_lumi, ev_run, Exception, fillBeamSpot(), fillPhase2OTHits(), fillPixelHits(), fillSeeds(), fillSimHits(), fillStripMatchedHits(), fillStripRphiStereoHits(), fillTrackingParticles(), fillTrackingVertices(), fillTracks(), fillVertices(), edm::EventSetup::get(), get, mps_fire::i, iEvent, includeAllHits_, includeMVA_, includePhase2OTHits_, includeSeeds_, includeStripHits_, includeTrackingParticles_, edm::EDGetTokenT< T >::isUninitialized(), LogDebug, 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, stripSimLinkToken_, t, tpHitIndexListLessSort(), trackAssociatorToken_, PbPb_ZMuSkimMuonDPG_cff::tracker, trackingParticleRefToken_, trackingParticleToken_, trackingVertexToken_, PDWG_EXOHSCP_cff::tracks, trackToken_, findQualityFiles::v, vertexToken_, and pwdgSkimBPark_cfi::vertices.

◆ clearVariables()

void TrackingNtuple::clearVariables ( )
private

Definition at line 1695 of file TrackingNtuple.cc.

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

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

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

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

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

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), HLT_2018_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 2690 of file TrackingNtuple.cc.

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

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

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

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

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

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, KineDebug3::count(), declareDynArray, HLT_2018_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, 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, SurveyInfoScenario_cff::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 2369 of file TrackingNtuple.cc.

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

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(), muonSimHitMatcherPSet::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 2677 of file TrackingNtuple.cc.

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

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

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

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

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

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::get(), get, iEvent, includeStripHits_, LogTrace, M_PI, MuonTrackValidator_cfi::parametersDefiner, parametersDefinerName_, EgammaObjectsElectrons_cfi::particleID, LHEGenericFilter_cfi::ParticleID, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, edm::ESHandle< T >::product(), HistoryBase::recoGenParticleTrail(), sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_genPdgIds, sim_isFromBHadron, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nRecoClusters, sim_nStrip, sim_nTrackerHits, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_simHitIdx, sim_trkIdx, sim_trkShareFrac, simhit_detId, simhit_detId_phase2, simhit_hitType, mathSSE::sqrt(), funct::tan(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, cmsswSequenceInfo::tp, tpHitIndexListLess(), tpNLayersToken_, tpNPixelLayersToken_, tpNStripStereoLayersToken_, tracer_, DetId::Tracker, StandaloneTrackMonitor_cfi::trackQuality, PDWG_EXOHSCP_cff::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 3527 of file TrackingNtuple.cc.

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

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

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

References ntuplemaker::fill, newFWLiteAna::found, training_settings::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 3099 of file TrackingNtuple.cc.

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

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_2018_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, 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, PDWG_EXOHSCP_cff::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 3549 of file TrackingNtuple.cc.

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

References Exception, findQualityFiles::size, PDWG_EXOHSCP_cff::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 2261 of file TrackingNtuple.cc.

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

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

Referenced by analyze().

◆ bsp_sigmax

float TrackingNtuple::bsp_sigmax
private

Definition at line 1175 of file TrackingNtuple.cc.

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

◆ bsp_sigmay

float TrackingNtuple::bsp_sigmay
private

Definition at line 1176 of file TrackingNtuple.cc.

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

◆ bsp_sigmaz

float TrackingNtuple::bsp_sigmaz
private

Definition at line 1177 of file TrackingNtuple.cc.

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

◆ bsp_x

float TrackingNtuple::bsp_x
private

Definition at line 1172 of file TrackingNtuple.cc.

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

◆ bsp_y

float TrackingNtuple::bsp_y
private

Definition at line 1173 of file TrackingNtuple.cc.

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

◆ bsp_z

float TrackingNtuple::bsp_z
private

Definition at line 1174 of file TrackingNtuple.cc.

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

◆ builderName_

std::string TrackingNtuple::builderName_
private

Definition at line 654 of file TrackingNtuple.cc.

Referenced by analyze().

◆ clusterTPMapToken_

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

Definition at line 636 of file TrackingNtuple.cc.

Referenced by analyze().

◆ ev_event

edm::EventNumber_t TrackingNtuple::ev_event
private

Definition at line 941 of file TrackingNtuple.cc.

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

◆ ev_lumi

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi
private

Definition at line 940 of file TrackingNtuple.cc.

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

◆ ev_run

edm::RunNumber_t TrackingNtuple::ev_run
private

Definition at line 939 of file TrackingNtuple.cc.

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

◆ glu_bbxi

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

Definition at line 1123 of file TrackingNtuple.cc.

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

◆ glu_detId

DetIdStrip TrackingNtuple::glu_detId
private

Definition at line 1108 of file TrackingNtuple.cc.

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

◆ glu_isBarrel

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

Definition at line 1107 of file TrackingNtuple.cc.

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

◆ glu_monoIdx

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

Definition at line 1109 of file TrackingNtuple.cc.

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

◆ glu_radL

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

Definition at line 1122 of file TrackingNtuple.cc.

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

◆ glu_seeIdx

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

Definition at line 1111 of file TrackingNtuple.cc.

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

◆ glu_stereoIdx

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

Definition at line 1110 of file TrackingNtuple.cc.

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

◆ glu_x

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

Definition at line 1112 of file TrackingNtuple.cc.

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

◆ glu_xx

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

Definition at line 1115 of file TrackingNtuple.cc.

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

◆ glu_xy

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

Definition at line 1116 of file TrackingNtuple.cc.

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

◆ glu_y

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

Definition at line 1113 of file TrackingNtuple.cc.

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

◆ glu_yy

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

Definition at line 1117 of file TrackingNtuple.cc.

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

◆ glu_yz

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

Definition at line 1118 of file TrackingNtuple.cc.

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

◆ glu_z

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

Definition at line 1114 of file TrackingNtuple.cc.

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

◆ glu_zx

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

Definition at line 1120 of file TrackingNtuple.cc.

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

◆ glu_zz

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

Definition at line 1119 of file TrackingNtuple.cc.

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

◆ includeAllHits_

const bool TrackingNtuple::includeAllHits_
private

Definition at line 657 of file TrackingNtuple.cc.

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

◆ includeMVA_

const bool TrackingNtuple::includeMVA_
private

Definition at line 658 of file TrackingNtuple.cc.

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

◆ includePhase2OTHits_

bool TrackingNtuple::includePhase2OTHits_
private

Definition at line 642 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ includeSeeds_

const bool TrackingNtuple::includeSeeds_
private

Definition at line 656 of file TrackingNtuple.cc.

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

◆ includeStripHits_

bool TrackingNtuple::includeStripHits_
private

Definition at line 642 of file TrackingNtuple.cc.

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

◆ includeTrackingParticles_

const bool TrackingNtuple::includeTrackingParticles_
private

Definition at line 659 of file TrackingNtuple.cc.

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

◆ inv_detId

DetIdAll TrackingNtuple::inv_detId
private

Definition at line 1151 of file TrackingNtuple.cc.

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

◆ inv_detId_phase2

DetIdAllPhase2 TrackingNtuple::inv_detId_phase2
private

Definition at line 1152 of file TrackingNtuple.cc.

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

◆ inv_isBarrel

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

Definition at line 1150 of file TrackingNtuple.cc.

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

◆ inv_type

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

Definition at line 1153 of file TrackingNtuple.cc.

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

◆ mvaQualityCollectionTokens_

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

Definition at line 633 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ parametersDefinerName_

std::string TrackingNtuple::parametersDefinerName_
private

Definition at line 655 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ ph2_bbxi

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

Definition at line 1145 of file TrackingNtuple.cc.

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

◆ ph2_detId

DetIdPhase2OT TrackingNtuple::ph2_detId
private

Definition at line 1128 of file TrackingNtuple.cc.

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

◆ ph2_isBarrel

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

Definition at line 1127 of file TrackingNtuple.cc.

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

◆ ph2_radL

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

Definition at line 1144 of file TrackingNtuple.cc.

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

◆ ph2_seeIdx

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

Definition at line 1130 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 1131 of file TrackingNtuple.cc.

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

◆ ph2_simType

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

Definition at line 1133 of file TrackingNtuple.cc.

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

◆ ph2_trkIdx

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

Definition at line 1129 of file TrackingNtuple.cc.

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

◆ ph2_x

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

Definition at line 1134 of file TrackingNtuple.cc.

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

◆ ph2_xx

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

Definition at line 1137 of file TrackingNtuple.cc.

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

◆ ph2_xy

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

Definition at line 1138 of file TrackingNtuple.cc.

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

◆ ph2_y

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

Definition at line 1135 of file TrackingNtuple.cc.

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

◆ ph2_yy

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

Definition at line 1139 of file TrackingNtuple.cc.

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

◆ ph2_yz

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

Definition at line 1140 of file TrackingNtuple.cc.

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

◆ ph2_z

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

Definition at line 1136 of file TrackingNtuple.cc.

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

◆ ph2_zx

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

Definition at line 1142 of file TrackingNtuple.cc.

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

◆ ph2_zz

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

Definition at line 1141 of file TrackingNtuple.cc.

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

◆ phase2OTRecHitToken_

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

Definition at line 648 of file TrackingNtuple.cc.

Referenced by fillPhase2OTHits().

◆ pix_bbxi

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

Definition at line 1081 of file TrackingNtuple.cc.

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

◆ pix_chargeFraction

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

Definition at line 1068 of file TrackingNtuple.cc.

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

◆ pix_detId

DetIdPixel TrackingNtuple::pix_detId
private

Definition at line 1064 of file TrackingNtuple.cc.

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

◆ pix_isBarrel

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

Definition at line 1063 of file TrackingNtuple.cc.

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

◆ pix_radL

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

Definition at line 1080 of file TrackingNtuple.cc.

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

◆ pix_seeIdx

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

Definition at line 1066 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 1067 of file TrackingNtuple.cc.

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

◆ pix_simType

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

Definition at line 1069 of file TrackingNtuple.cc.

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

◆ pix_trkIdx

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

Definition at line 1065 of file TrackingNtuple.cc.

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

◆ pix_x

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

Definition at line 1070 of file TrackingNtuple.cc.

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

◆ pix_xx

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

Definition at line 1073 of file TrackingNtuple.cc.

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

◆ pix_xy

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

Definition at line 1074 of file TrackingNtuple.cc.

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

◆ pix_y

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

Definition at line 1071 of file TrackingNtuple.cc.

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

◆ pix_yy

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

Definition at line 1075 of file TrackingNtuple.cc.

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

◆ pix_yz

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

Definition at line 1076 of file TrackingNtuple.cc.

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

◆ pix_z

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

Definition at line 1072 of file TrackingNtuple.cc.

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

◆ pix_zx

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

Definition at line 1078 of file TrackingNtuple.cc.

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

◆ pix_zz

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

Definition at line 1077 of file TrackingNtuple.cc.

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

◆ pixelRecHitToken_

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

Definition at line 644 of file TrackingNtuple.cc.

Referenced by fillPixelHits().

◆ pixelSimLinkToken_

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

Definition at line 639 of file TrackingNtuple.cc.

Referenced by analyze().

◆ see_algo

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

Definition at line 1209 of file TrackingNtuple.cc.

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

◆ see_bestFromFirstHitSimTrkIdx

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

Definition at line 1216 of file TrackingNtuple.cc.

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

◆ see_bestFromFirstHitSimTrkShareFrac

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

Definition at line 1217 of file TrackingNtuple.cc.

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

◆ see_bestSimTrkIdx

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

Definition at line 1214 of file TrackingNtuple.cc.

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

◆ see_bestSimTrkShareFrac

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

Definition at line 1215 of file TrackingNtuple.cc.

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

◆ see_chi2

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

Definition at line 1195 of file TrackingNtuple.cc.

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

◆ see_dxy

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

Definition at line 1188 of file TrackingNtuple.cc.

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

◆ see_dxyErr

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

Definition at line 1193 of file TrackingNtuple.cc.

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

◆ see_dz

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

Definition at line 1189 of file TrackingNtuple.cc.

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

◆ see_dzErr

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

Definition at line 1194 of file TrackingNtuple.cc.

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

◆ see_eta

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

Definition at line 1186 of file TrackingNtuple.cc.

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

◆ see_etaErr

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

Definition at line 1191 of file TrackingNtuple.cc.

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

◆ see_fitok

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

Definition at line 1181 of file TrackingNtuple.cc.

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

◆ see_hitIdx

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

Definition at line 1220 of file TrackingNtuple.cc.

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

◆ see_hitType

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

Definition at line 1221 of file TrackingNtuple.cc.

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

◆ see_isTrue

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

Definition at line 1213 of file TrackingNtuple.cc.

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

◆ see_nCands

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

Definition at line 1211 of file TrackingNtuple.cc.

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

◆ see_nCluster

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

Definition at line 1208 of file TrackingNtuple.cc.

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

◆ see_nGlued

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

Definition at line 1205 of file TrackingNtuple.cc.

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

◆ see_nPhase2OT

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

Definition at line 1207 of file TrackingNtuple.cc.

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

◆ see_nPixel

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

Definition at line 1204 of file TrackingNtuple.cc.

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

◆ see_nStrip

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

Definition at line 1206 of file TrackingNtuple.cc.

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

◆ see_nValid

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

Definition at line 1203 of file TrackingNtuple.cc.

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

◆ see_offset

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

Definition at line 1223 of file TrackingNtuple.cc.

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

◆ see_phi

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

Definition at line 1187 of file TrackingNtuple.cc.

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

◆ see_phiErr

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

Definition at line 1192 of file TrackingNtuple.cc.

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

◆ see_pt

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

Definition at line 1185 of file TrackingNtuple.cc.

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

◆ see_ptErr

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

Definition at line 1190 of file TrackingNtuple.cc.

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

◆ see_px

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

Definition at line 1182 of file TrackingNtuple.cc.

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

◆ see_py

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

Definition at line 1183 of file TrackingNtuple.cc.

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

◆ see_pz

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

Definition at line 1184 of file TrackingNtuple.cc.

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

◆ see_q

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

Definition at line 1202 of file TrackingNtuple.cc.

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

◆ see_simTrkIdx

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

Definition at line 1219 of file TrackingNtuple.cc.

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

◆ see_simTrkShareFrac

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

Definition at line 1218 of file TrackingNtuple.cc.

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

◆ see_statePt

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

Definition at line 1196 of file TrackingNtuple.cc.

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

◆ see_stateTrajPx

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

Definition at line 1199 of file TrackingNtuple.cc.

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

◆ see_stateTrajPy

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

Definition at line 1200 of file TrackingNtuple.cc.

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

◆ see_stateTrajPz

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

Definition at line 1201 of file TrackingNtuple.cc.

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

◆ see_stateTrajX

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

Definition at line 1197 of file TrackingNtuple.cc.

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

◆ see_stateTrajY

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

Definition at line 1198 of file TrackingNtuple.cc.

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

◆ see_stopReason

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

Definition at line 1210 of file TrackingNtuple.cc.

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

◆ see_trkIdx

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

Definition at line 1212 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 630 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

◆ seedTokens_

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

Definition at line 629 of file TrackingNtuple.cc.

Referenced by fillSeeds(), and TrackingNtuple().

◆ sim_bunchCrossing

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

Definition at line 1024 of file TrackingNtuple.cc.

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

◆ sim_decayVtxIdx

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

Definition at line 1058 of file TrackingNtuple.cc.

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

◆ sim_eta

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

Definition at line 1032 of file TrackingNtuple.cc.

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

◆ sim_event

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

Definition at line 1023 of file TrackingNtuple.cc.

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

◆ sim_genPdgIds

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

Definition at line 1026 of file TrackingNtuple.cc.

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

◆ sim_isFromBHadron

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

Definition at line 1027 of file TrackingNtuple.cc.

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

◆ sim_n3DLay

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

Definition at line 1048 of file TrackingNtuple.cc.

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

◆ sim_nLay

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

Definition at line 1046 of file TrackingNtuple.cc.

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

◆ sim_nPixel

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

Definition at line 1044 of file TrackingNtuple.cc.

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

◆ sim_nPixelLay

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

Definition at line 1047 of file TrackingNtuple.cc.

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

◆ sim_nRecoClusters

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

Definition at line 1052 of file TrackingNtuple.cc.

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

◆ sim_nStrip

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

Definition at line 1045 of file TrackingNtuple.cc.

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

◆ sim_nTrackerHits

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

Definition at line 1050 of file TrackingNtuple.cc.

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

◆ sim_nValid

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

Definition at line 1043 of file TrackingNtuple.cc.

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

◆ sim_parentVtxIdx

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

Definition at line 1057 of file TrackingNtuple.cc.

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

◆ sim_pca_cotTheta

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

Definition at line 1037 of file TrackingNtuple.cc.

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

◆ sim_pca_dxy

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

Definition at line 1039 of file TrackingNtuple.cc.

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

◆ sim_pca_dz

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

Definition at line 1040 of file TrackingNtuple.cc.

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

◆ sim_pca_eta

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

Definition at line 1035 of file TrackingNtuple.cc.

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

◆ sim_pca_lambda

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

Definition at line 1036 of file TrackingNtuple.cc.

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

◆ sim_pca_phi

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

Definition at line 1038 of file TrackingNtuple.cc.

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

◆ sim_pca_pt

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

Definition at line 1034 of file TrackingNtuple.cc.

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

◆ sim_pdgId

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

Definition at line 1025 of file TrackingNtuple.cc.

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

◆ sim_phi

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

Definition at line 1033 of file TrackingNtuple.cc.

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

◆ sim_pt

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

Definition at line 1031 of file TrackingNtuple.cc.

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

◆ sim_px

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

Definition at line 1028 of file TrackingNtuple.cc.

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

◆ sim_py

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

Definition at line 1029 of file TrackingNtuple.cc.

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

◆ sim_pz

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

Definition at line 1030 of file TrackingNtuple.cc.

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

◆ sim_q

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

Definition at line 1041 of file TrackingNtuple.cc.

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

◆ sim_seedIdx

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

Definition at line 1056 of file TrackingNtuple.cc.

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

◆ sim_simHitIdx

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

Definition at line 1059 of file TrackingNtuple.cc.

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

◆ sim_trkIdx

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

Definition at line 1054 of file TrackingNtuple.cc.

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

◆ sim_trkShareFrac

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

Definition at line 1055 of file TrackingNtuple.cc.

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

◆ simhit_detId

DetIdAll TrackingNtuple::simhit_detId
private

Definition at line 1157 of file TrackingNtuple.cc.

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

◆ simhit_detId_phase2

DetIdAllPhase2 TrackingNtuple::simhit_detId_phase2
private

Definition at line 1158 of file TrackingNtuple.cc.

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

◆ simhit_eloss

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

Definition at line 1164 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 1168 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 1169 of file TrackingNtuple.cc.

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

◆ simhit_particle

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

Definition at line 1162 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 1163 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 1167 of file TrackingNtuple.cc.

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

◆ simhit_tof

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

Definition at line 1165 of file TrackingNtuple.cc.

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

◆ simhit_x

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

Definition at line 1159 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 1160 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 1161 of file TrackingNtuple.cc.

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

◆ simHitTPMapToken_

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

Definition at line 637 of file TrackingNtuple.cc.

Referenced by analyze().

◆ simpv_idx

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

Definition at line 1251 of file TrackingNtuple.cc.

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

◆ simvtx_bunchCrossing

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

Definition at line 1244 of file TrackingNtuple.cc.

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

◆ simvtx_daughterSimIdx

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

Definition at line 1250 of file TrackingNtuple.cc.

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

◆ simvtx_event

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

Definition at line 1243 of file TrackingNtuple.cc.

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

◆ simvtx_processType

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

Definition at line 1245 of file TrackingNtuple.cc.

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

◆ simvtx_sourceSimIdx

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

Definition at line 1249 of file TrackingNtuple.cc.

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

◆ simvtx_x

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

Definition at line 1246 of file TrackingNtuple.cc.

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

◆ simvtx_y

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

Definition at line 1247 of file TrackingNtuple.cc.

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

◆ simvtx_z

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

Definition at line 1248 of file TrackingNtuple.cc.

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

◆ siphase2OTSimLinksToken_

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

Definition at line 641 of file TrackingNtuple.cc.

Referenced by analyze().

◆ str_bbxi

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

Definition at line 1103 of file TrackingNtuple.cc.

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

◆ str_chargeFraction

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

Definition at line 1090 of file TrackingNtuple.cc.

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

◆ str_detId

DetIdStrip TrackingNtuple::str_detId
private

Definition at line 1086 of file TrackingNtuple.cc.

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

◆ str_isBarrel

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

Definition at line 1085 of file TrackingNtuple.cc.

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

◆ str_radL

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

Definition at line 1102 of file TrackingNtuple.cc.

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

◆ str_seeIdx

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

Definition at line 1088 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 1089 of file TrackingNtuple.cc.

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

◆ str_simType

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

Definition at line 1091 of file TrackingNtuple.cc.

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

◆ str_trkIdx

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

Definition at line 1087 of file TrackingNtuple.cc.

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

◆ str_x

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

Definition at line 1092 of file TrackingNtuple.cc.

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

◆ str_xx

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

Definition at line 1095 of file TrackingNtuple.cc.

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

◆ str_xy

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

Definition at line 1096 of file TrackingNtuple.cc.

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

◆ str_y

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

Definition at line 1093 of file TrackingNtuple.cc.

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

◆ str_yy

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

Definition at line 1097 of file TrackingNtuple.cc.

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

◆ str_yz

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

Definition at line 1098 of file TrackingNtuple.cc.

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

◆ str_z

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

Definition at line 1094 of file TrackingNtuple.cc.

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

◆ str_zx

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

Definition at line 1100 of file TrackingNtuple.cc.

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

◆ str_zz

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

Definition at line 1099 of file TrackingNtuple.cc.

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

◆ stripMatchedRecHitToken_

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

Definition at line 647 of file TrackingNtuple.cc.

Referenced by fillStripMatchedHits().

◆ stripRphiRecHitToken_

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

Definition at line 645 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

◆ stripSimLinkToken_

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

Definition at line 640 of file TrackingNtuple.cc.

Referenced by analyze().

◆ stripStereoRecHitToken_

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

Definition at line 646 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

◆ t

TTree* TrackingNtuple::t
private

Definition at line 663 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ tpNLayersToken_

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

Definition at line 651 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tpNPixelLayersToken_

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

Definition at line 652 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tpNStripStereoLayersToken_

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

Definition at line 653 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

◆ tracer_

HistoryBase TrackingNtuple::tracer_
private

Definition at line 661 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles(), and TrackingNtuple().

◆ trackAssociatorToken_

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

Definition at line 638 of file TrackingNtuple.cc.

Referenced by analyze().

◆ trackingParticleRefToken_

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

Definition at line 635 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ trackingParticleToken_

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

Definition at line 634 of file TrackingNtuple.cc.

Referenced by analyze(), and TrackingNtuple().

◆ trackingVertexToken_

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

Definition at line 650 of file TrackingNtuple.cc.

Referenced by analyze().

◆ trackToken_

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

Definition at line 631 of file TrackingNtuple.cc.

Referenced by analyze(), and fillTracks().

◆ trk_algo

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

Definition at line 997 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 999 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkIdx

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

Definition at line 1010 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkNChi2

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

Definition at line 1014 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFrac

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

Definition at line 1011 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFracSimClusterDenom

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

Definition at line 1013 of file TrackingNtuple.cc.

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

◆ trk_bestFromFirstHitSimTrkShareFracSimDenom

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

Definition at line 1012 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkIdx

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

Definition at line 1005 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkNChi2

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

Definition at line 1009 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFrac

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

Definition at line 1006 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFracSimClusterDenom

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

Definition at line 1008 of file TrackingNtuple.cc.

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

◆ trk_bestSimTrkShareFracSimDenom

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

Definition at line 1007 of file TrackingNtuple.cc.

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

◆ trk_cotTheta

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

Definition at line 960 of file TrackingNtuple.cc.

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

◆ trk_dxy

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

Definition at line 962 of file TrackingNtuple.cc.

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

◆ trk_dxyClosestPV

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

Definition at line 966 of file TrackingNtuple.cc.

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

◆ trk_dxyErr

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

Definition at line 972 of file TrackingNtuple.cc.

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

◆ trk_dxyPV

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

Definition at line 964 of file TrackingNtuple.cc.

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

◆ trk_dz

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

Definition at line 963 of file TrackingNtuple.cc.

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

◆ trk_dzClosestPV

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

Definition at line 967 of file TrackingNtuple.cc.

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

◆ trk_dzErr

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

Definition at line 973 of file TrackingNtuple.cc.

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

◆ trk_dzPV

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

Definition at line 965 of file TrackingNtuple.cc.

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

◆ trk_eta

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

Definition at line 958 of file TrackingNtuple.cc.

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

◆ trk_etaErr

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

Definition at line 969 of file TrackingNtuple.cc.

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

◆ trk_hitIdx

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

Definition at line 1018 of file TrackingNtuple.cc.

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

◆ trk_hitType

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

Definition at line 1019 of file TrackingNtuple.cc.

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

◆ trk_inner_pt

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

Definition at line 953 of file TrackingNtuple.cc.

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

◆ trk_inner_px

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

Definition at line 950 of file TrackingNtuple.cc.

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

◆ trk_inner_py

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

Definition at line 951 of file TrackingNtuple.cc.

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

◆ trk_inner_pz

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

Definition at line 952 of file TrackingNtuple.cc.

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

◆ trk_isHP

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

Definition at line 1001 of file TrackingNtuple.cc.

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

◆ trk_isTrue

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

Definition at line 1004 of file TrackingNtuple.cc.

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

◆ trk_lambda

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

Definition at line 959 of file TrackingNtuple.cc.

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

◆ trk_lambdaErr

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

Definition at line 970 of file TrackingNtuple.cc.

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

◆ trk_mvas

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

Definition at line 980 of file TrackingNtuple.cc.

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

◆ trk_n3DLay

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

Definition at line 994 of file TrackingNtuple.cc.

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

◆ trk_nChi2

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

Definition at line 977 of file TrackingNtuple.cc.

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

◆ trk_nChi2_1Dmod

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

Definition at line 978 of file TrackingNtuple.cc.

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

◆ trk_nCluster

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

Definition at line 996 of file TrackingNtuple.cc.

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

◆ trk_ndof

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

Definition at line 979 of file TrackingNtuple.cc.

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

◆ trk_nInactive

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

Definition at line 985 of file TrackingNtuple.cc.

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

◆ trk_nInnerInactive

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

Definition at line 991 of file TrackingNtuple.cc.

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

◆ trk_nInnerLost

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

Definition at line 989 of file TrackingNtuple.cc.

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

◆ trk_nLost

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

Definition at line 984 of file TrackingNtuple.cc.

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

◆ trk_nLostLay

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

Definition at line 995 of file TrackingNtuple.cc.

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

◆ trk_nOuterInactive

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

Definition at line 990 of file TrackingNtuple.cc.

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

◆ trk_nOuterLost

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

Definition at line 988 of file TrackingNtuple.cc.

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

◆ trk_nPixel

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

Definition at line 986 of file TrackingNtuple.cc.

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

◆ trk_nPixelLay

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

Definition at line 992 of file TrackingNtuple.cc.

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

◆ trk_nStrip

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

Definition at line 987 of file TrackingNtuple.cc.

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

◆ trk_nStripLay

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

Definition at line 993 of file TrackingNtuple.cc.

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

◆ trk_nValid

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

Definition at line 983 of file TrackingNtuple.cc.

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

◆ trk_originalAlgo

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

Definition at line 998 of file TrackingNtuple.cc.

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

◆ trk_outer_pt

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

Definition at line 957 of file TrackingNtuple.cc.

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

◆ trk_outer_px

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

Definition at line 954 of file TrackingNtuple.cc.

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

◆ trk_outer_py

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

Definition at line 955 of file TrackingNtuple.cc.

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

◆ trk_outer_pz

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

Definition at line 956 of file TrackingNtuple.cc.

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

◆ trk_phi

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

Definition at line 961 of file TrackingNtuple.cc.

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

◆ trk_phiErr

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

Definition at line 971 of file TrackingNtuple.cc.

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

◆ trk_pt

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

Definition at line 949 of file TrackingNtuple.cc.

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

◆ trk_ptErr

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

Definition at line 968 of file TrackingNtuple.cc.

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

◆ trk_px

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

Definition at line 946 of file TrackingNtuple.cc.

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

◆ trk_py

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

Definition at line 947 of file TrackingNtuple.cc.

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

◆ trk_pz

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

Definition at line 948 of file TrackingNtuple.cc.

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

◆ trk_q

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

Definition at line 982 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 981 of file TrackingNtuple.cc.

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

◆ trk_refpoint_x

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

Definition at line 974 of file TrackingNtuple.cc.

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

◆ trk_refpoint_y

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

Definition at line 975 of file TrackingNtuple.cc.

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

◆ trk_refpoint_z

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

Definition at line 976 of file TrackingNtuple.cc.

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

◆ trk_seedIdx

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

Definition at line 1002 of file TrackingNtuple.cc.

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

◆ trk_simTrkIdx

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

Definition at line 1017 of file TrackingNtuple.cc.

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

◆ trk_simTrkNChi2

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

Definition at line 1016 of file TrackingNtuple.cc.

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

◆ trk_simTrkShareFrac

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

Definition at line 1015 of file TrackingNtuple.cc.

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

◆ trk_stopReason

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

Definition at line 1000 of file TrackingNtuple.cc.

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

◆ trk_vtxIdx

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

Definition at line 1003 of file TrackingNtuple.cc.

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

◆ vertexToken_

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

Definition at line 649 of file TrackingNtuple.cc.

Referenced by analyze().

◆ vtx_chi2

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

Definition at line 1235 of file TrackingNtuple.cc.

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

◆ vtx_fake

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

Definition at line 1236 of file TrackingNtuple.cc.

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

◆ vtx_ndof

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

Definition at line 1234 of file TrackingNtuple.cc.

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

◆ vtx_trkIdx

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

Definition at line 1238 of file TrackingNtuple.cc.

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

◆ vtx_valid

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

Definition at line 1237 of file TrackingNtuple.cc.

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

◆ vtx_x

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

Definition at line 1228 of file TrackingNtuple.cc.

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

◆ vtx_xErr

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

Definition at line 1231 of file TrackingNtuple.cc.

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

◆ vtx_y

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

Definition at line 1229 of file TrackingNtuple.cc.

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

◆ vtx_yErr

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

Definition at line 1232 of file TrackingNtuple.cc.

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

◆ vtx_z

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

Definition at line 1230 of file TrackingNtuple.cc.

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

◆ vtx_zErr

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

Definition at line 1233 of file TrackingNtuple.cc.

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

runTheMatrix.ret
ret
prodAgent to be discontinued
Definition: runTheMatrix.py:355
TrackingNtuple::sim_px
std::vector< float > sim_px
Definition: TrackingNtuple.cc:1028
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:2481
SummaryClient_cfi.labels
labels
Definition: SummaryClient_cfi.py:61
TrackingNtuple::trackAssociatorToken_
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociatorToken_
Definition: TrackingNtuple.cc:638
edm::ESHandle::product
T const * product() const
Definition: ESHandle.h:86
edm::DetSetVector
Definition: DetSetVector.h:61
TrackingNtuple::HitSimType::Noise
TrackingNtuple::vtx_chi2
std::vector< float > vtx_chi2
Definition: TrackingNtuple.cc:1235
heavyionUCCDQM_cfi.nClusters
nClusters
Definition: heavyionUCCDQM_cfi.py:9
TrackingNtuple::pix_simHitIdx
std::vector< std::vector< int > > pix_simHitIdx
Definition: TrackingNtuple.cc:1067
reco::HitPattern::MISSING_OUTER_HITS
Definition: HitPattern.h:155
TrackingNtuple::sim_simHitIdx
std::vector< std::vector< int > > sim_simHitIdx
Definition: TrackingNtuple.cc:1059
FastTimerService_cff.range
range
Definition: FastTimerService_cff.py:34
TrackingNtuple::see_hitIdx
std::vector< std::vector< int > > see_hitIdx
Definition: TrackingNtuple.cc:1220
TrackingNtuple::vtx_xErr
std::vector< float > vtx_xErr
Definition: TrackingNtuple.cc:1231
TrackingNtuple::str_yz
std::vector< float > str_yz
Definition: TrackingNtuple.cc:1098
PDWG_EXOHSCP_cff.tracks
tracks
Definition: PDWG_EXOHSCP_cff.py:28
TrackingNtuple::t
TTree * t
Definition: TrackingNtuple.cc:663
TrackingNtuple::trk_refpoint_z
std::vector< float > trk_refpoint_z
Definition: TrackingNtuple.cc:976
TrackingNtuple::see_eta
std::vector< float > see_eta
Definition: TrackingNtuple.cc:1186
TrackingNtuple::ev_lumi
edm::LuminosityBlockNumber_t ev_lumi
Definition: TrackingNtuple.cc:940
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:355
TrackingNtuple::trk_seedIdx
std::vector< int > trk_seedIdx
Definition: TrackingNtuple.cc:1002
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:2261
TrackingNtuple::sim_trkShareFrac
std::vector< std::vector< float > > sim_trkShareFrac
Definition: TrackingNtuple.cc:1055
TrackingNtuple::trackToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
Definition: TrackingNtuple.cc:631
TrackingNtuple::str_seeIdx
std::vector< std::vector< int > > str_seeIdx
Definition: TrackingNtuple.cc:1088
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:1117
TrackingNtuple::trk_nChi2_1Dmod
std::vector< float > trk_nChi2_1Dmod
Definition: TrackingNtuple.cc:978
TrackingNtuple::trk_inner_pz
std::vector< float > trk_inner_pz
Definition: TrackingNtuple.cc:952
TrackingNtuple::trk_qualityMasks
std::vector< std::vector< unsigned short > > trk_qualityMasks
Definition: TrackingNtuple.cc:981
TrackingNtuple::trk_originalAlgo
std::vector< unsigned int > trk_originalAlgo
Definition: TrackingNtuple.cc:998
TrackingNtuple::includeTrackingParticles_
const bool includeTrackingParticles_
Definition: TrackingNtuple.cc:659
TrackingNtuple::str_radL
std::vector< float > str_radL
Definition: TrackingNtuple.cc:1102
TrackingNtuple::see_stateTrajPy
std::vector< float > see_stateTrajPy
Definition: TrackingNtuple.cc:1200
TrackingNtuple::trk_dzPV
std::vector< float > trk_dzPV
Definition: TrackingNtuple.cc:965
TrackingNtuple::trk_isHP
std::vector< short > trk_isHP
Definition: TrackingNtuple.cc:1001
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:1695
TrackingNtuple::see_nPixel
std::vector< unsigned int > see_nPixel
Definition: TrackingNtuple.cc:1204
hfClusterShapes_cfi.hits
hits
Definition: hfClusterShapes_cfi.py:5
TrackingNtuple::ev_event
edm::EventNumber_t ev_event
Definition: TrackingNtuple.cc:941
TrackingNtuple::str_y
std::vector< float > str_y
Definition: TrackingNtuple.cc:1093
TrackingNtuple::trackingVertexToken_
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexToken_
Definition: TrackingNtuple.cc:650
TrackingNtuple::glu_seeIdx
std::vector< std::vector< int > > glu_seeIdx
Definition: TrackingNtuple.cc:1111
TrackingNtuple::trk_n3DLay
std::vector< unsigned int > trk_n3DLay
Definition: TrackingNtuple.cc:994
TrackingNtuple::see_stateTrajX
std::vector< float > see_stateTrajX
Definition: TrackingNtuple.cc:1197
TrackingNtuple::trk_nPixel
std::vector< unsigned int > trk_nPixel
Definition: TrackingNtuple.cc:986
TrackingNtuple::glu_xx
std::vector< float > glu_xx
Definition: TrackingNtuple.cc:1115
TrackingNtuple::trk_nOuterInactive
std::vector< unsigned int > trk_nOuterInactive
Definition: TrackingNtuple.cc:990
TrackingNtuple::trk_dz
std::vector< float > trk_dz
Definition: TrackingNtuple.cc:963
edm::isNotFinite
constexpr bool isNotFinite(T x)
Definition: isFinite.h:9
TrackingNtuple::see_stateTrajPz
std::vector< float > see_stateTrajPz
Definition: TrackingNtuple.cc:1201
TrackingNtuple::str_isBarrel
std::vector< short > str_isBarrel
Definition: TrackingNtuple.cc:1085
TrackingNtuple::trk_dzErr
std::vector< float > trk_dzErr
Definition: TrackingNtuple.cc:973
TrackingNtuple::ph2_z
std::vector< float > ph2_z
Definition: TrackingNtuple.cc:1136
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
TrackingNtuple::see_simTrkIdx
std::vector< std::vector< int > > see_simTrkIdx
Definition: TrackingNtuple.cc:1219
TrackingNtuple::tracer_
HistoryBase tracer_
Definition: TrackingNtuple.cc:661
TrackingNtuple::trk_etaErr
std::vector< float > trk_etaErr
Definition: TrackingNtuple.cc:969
TrackingNtuple::trk_isTrue
std::vector< short > trk_isTrue
Definition: TrackingNtuple.cc:1004
min
T min(T a, T b)
Definition: MathUtil.h:58
TrackingNtuple::includeAllHits_
const bool includeAllHits_
Definition: TrackingNtuple.cc:657
TrackingNtuple::trk_bestSimTrkNChi2
std::vector< float > trk_bestSimTrkNChi2
Definition: TrackingNtuple.cc:1009
TrackingNtuple::trk_bestSimTrkIdx
std::vector< int > trk_bestSimTrkIdx
Definition: TrackingNtuple.cc:1005
edm
HLT enums.
Definition: AlignableModifier.h:19
TrackingNtuple::includeMVA_
const bool includeMVA_
Definition: TrackingNtuple.cc:658
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimDenom
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimDenom
Definition: TrackingNtuple.cc:1012
TrackerTopology
Definition: TrackerTopology.h:16
TrackingNtuple::see_px
std::vector< float > see_px
Definition: TrackingNtuple.cc:1182
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
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:1188
TrackingNtuple::HitSimType
HitSimType
Definition: TrackingNtuple.cc:487
TrackingNtuple::trk_nOuterLost
std::vector< unsigned int > trk_nOuterLost
Definition: TrackingNtuple.cc:988
TrackingNtuple::bsp_sigmax
float bsp_sigmax
Definition: TrackingNtuple.cc:1175
pos
Definition: PixelAliasList.h:18
TrackingNtuple::pixelSimLinkToken_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinkToken_
Definition: TrackingNtuple.cc:639
TrackingNtuple::ph2_xy
std::vector< float > ph2_xy
Definition: TrackingNtuple.cc:1138
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
TransientRecHitRecord
Definition: TransientRecHitRecord.h:14
TrackingNtuple::see_hitType
std::vector< std::vector< int > > see_hitType
Definition: TrackingNtuple.cc:1221
TrackingNtuple::simhit_detId
DetIdAll simhit_detId
Definition: TrackingNtuple.cc:1157
TrackingNtuple::simhit_process
std::vector< short > simhit_process
Definition: TrackingNtuple.cc:1163
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
HLT_2018_cff.distance
distance
Definition: HLT_2018_cff.py:6417
TrackingNtuple::vertexToken_
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
Definition: TrackingNtuple.cc:649
TrackingVertexCollection
std::vector< TrackingVertex > TrackingVertexCollection
Definition: TrackingVertexContainer.h:8
TrackingNtuple::trk_nPixelLay
std::vector< unsigned int > trk_nPixelLay
Definition: TrackingNtuple.cc:992
TrackingNtuple::see_trkIdx
std::vector< int > see_trkIdx
Definition: TrackingNtuple.cc:1212
TrackingNtuple::tpNLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNLayersToken_
Definition: TrackingNtuple.cc:651
TrackingNtuple::inv_detId
DetIdAll inv_detId
Definition: TrackingNtuple.cc:1151
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:1087
TrackingNtuple::trk_nCluster
std::vector< unsigned int > trk_nCluster
Definition: TrackingNtuple.cc:996
edmNew::DetSetVector::begin
const_iterator begin(bool update=false) const
Definition: DetSetVectorNew.h:572
TrackingNtuple::see_bestFromFirstHitSimTrkShareFrac
std::vector< float > see_bestFromFirstHitSimTrkShareFrac
Definition: TrackingNtuple.cc:1217
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:975
TrackingNtuple::simpv_idx
std::vector< int > simpv_idx
Definition: TrackingNtuple.cc:1251
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:1205
TrackingNtuple::sim_parentVtxIdx
std::vector< int > sim_parentVtxIdx
Definition: TrackingNtuple.cc:1057
edm::RefVector< TrackingParticleCollection >
TrackingNtuple::trk_px
std::vector< float > trk_px
Definition: TrackingNtuple.cc:946
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFrac
std::vector< float > trk_bestFromFirstHitSimTrkShareFrac
Definition: TrackingNtuple.cc:1011
TrackingNtuple::pix_isBarrel
std::vector< short > pix_isBarrel
Definition: TrackingNtuple.cc:1063
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
TrackingNtuple::trk_inner_pt
std::vector< float > trk_inner_pt
Definition: TrackingNtuple.cc:953
TrackingRecHit::RecHitPointer
std::shared_ptr< TrackingRecHit const > RecHitPointer
Definition: TrackingRecHit.h:24
TrackingNtuple::pix_yz
std::vector< float > pix_yz
Definition: TrackingNtuple.cc:1076
Signal
Definition: vlib.h:28
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:116
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:956
TrackingNtuple::str_xy
std::vector< float > str_xy
Definition: TrackingNtuple.cc:1096
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
edm::Handle< reco::TrackToTrackingParticleAssociator >
training_settings.idx
idx
Definition: training_settings.py:16
TrackingNtuple::simhit_z
std::vector< float > simhit_z
Definition: TrackingNtuple.cc:1161
TrackingNtuple::ph2_zz
std::vector< float > ph2_zz
Definition: TrackingNtuple.cc:1141
TrackingNtuple::ph2_yy
std::vector< float > ph2_yy
Definition: TrackingNtuple.cc:1139
TrackingNtuple::sim_nStrip
std::vector< unsigned int > sim_nStrip
Definition: TrackingNtuple.cc:1045
TrackingNtuple::see_dzErr
std::vector< float > see_dzErr
Definition: TrackingNtuple.cc:1194
TrackingNtuple::sim_isFromBHadron
std::vector< int > sim_isFromBHadron
Definition: TrackingNtuple.cc:1027
rpcPointValidation_cfi.recHit
recHit
Definition: rpcPointValidation_cfi.py:7
TrackingNtuple::trk_nInnerLost
std::vector< unsigned int > trk_nInnerLost
Definition: TrackingNtuple.cc:989
TrackingNtuple::sim_nRecoClusters
std::vector< unsigned int > sim_nRecoClusters
Definition: TrackingNtuple.cc:1052
edm::Ref
Definition: AssociativeIterator.h:58
TrackingNtuple::glu_zx
std::vector< float > glu_zx
Definition: TrackingNtuple.cc:1120
TrackingNtuple::glu_detId
DetIdStrip glu_detId
Definition: TrackingNtuple.cc:1108
OmniClusterRef::cluster_phase2OT
Phase2Cluster1DRef cluster_phase2OT() const
Definition: OmniClusterRef.h:48
TrackingNtuple::pix_zx
std::vector< float > pix_zx
Definition: TrackingNtuple.cc:1078
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:2759
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:3099
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:2369
trackingPlots.assoc
assoc
Definition: trackingPlots.py:183
ndof
Definition: HIMultiTrackSelector.h:49
MuonAssociatorByHits_cfi.tpTag
tpTag
Definition: MuonAssociatorByHits_cfi.py:152
TrackingNtuple::str_chargeFraction
std::vector< std::vector< float > > str_chargeFraction
Definition: TrackingNtuple.cc:1090
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:3381
IdealMagneticFieldRecord
Definition: IdealMagneticFieldRecord.h:11
edm::InputTag::label
std::string const & label() const
Definition: InputTag.h:36
DetId
Definition: DetId.h:17
cmsdt::algo
algo
Definition: constants.h:164
TrackingNtuple::str_z
std::vector< float > str_z
Definition: TrackingNtuple.cc:1094
TrackingNtuple::glu_zz
std::vector< float > glu_zz
Definition: TrackingNtuple.cc:1119
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:1058
TrackingNtuple::bsp_sigmay
float bsp_sigmay
Definition: TrackingNtuple.cc:1176
reco::HitPattern
Definition: HitPattern.h:147
track_associator::hitsToClusterRefs
std::vector< OmniClusterRef > hitsToClusterRefs(iter begin, iter end)
Definition: trackHitsToClusterRefs.h:19
TrackingNtuple::sim_q
std::vector< int > sim_q
Definition: TrackingNtuple.cc:1041
TrackingNtuple::HitType::Pixel
TTClusterAssociation_cfi.digiSimLinks
digiSimLinks
Definition: TTClusterAssociation_cfi.py:7
TrackingNtuple::trk_algo
std::vector< unsigned int > trk_algo
Definition: TrackingNtuple.cc:997
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:961
TrackingNtuple::ph2_simType
std::vector< unsigned short > ph2_simType
Definition: TrackingNtuple.cc:1133
trackingPlots.hp
hp
Definition: trackingPlots.py:1246
edm::EventSetup::get
T get() const
Definition: EventSetup.h:73
TrackingNtuple::trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
std::vector< float > trk_bestFromFirstHitSimTrkShareFracSimClusterDenom
Definition: TrackingNtuple.cc:1013
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:999
TrackingNtuple::see_pt
std::vector< float > see_pt
Definition: TrackingNtuple.cc:1185
TrackingNtuple::trk_dxyClosestPV
std::vector< float > trk_dxyClosestPV
Definition: TrackingNtuple.cc:966
TrackingNtuple::see_pz
std::vector< float > see_pz
Definition: TrackingNtuple.cc:1184
GlobalPosition_Frontier_DevDB_cff.tag
tag
Definition: GlobalPosition_Frontier_DevDB_cff.py:11
TrackingNtuple::inv_detId_phase2
DetIdAllPhase2 inv_detId_phase2
Definition: TrackingNtuple.cc:1152
BaseTrackerRecHit
Definition: BaseTrackerRecHit.h:15
TrackingNtuple::see_nValid
std::vector< unsigned int > see_nValid
Definition: TrackingNtuple.cc:1203
TrackingNtuple::simhit_tof
std::vector< float > simhit_tof
Definition: TrackingNtuple.cc:1165
TrackingNtuple::pix_x
std::vector< float > pix_x
Definition: TrackingNtuple.cc:1070
TrackingNtuple::HitType::Glued
PVValHelper::eta
Definition: PVValidationHelpers.h:69
TrackingNtuple::inv_type
std::vector< unsigned short > inv_type
Definition: TrackingNtuple.cc:1153
TrackingNtuple::see_etaErr
std::vector< float > see_etaErr
Definition: TrackingNtuple.cc:1191
edm::EDGetTokenT::isUninitialized
bool isUninitialized() const
Definition: EDGetToken.h:70
TrackingNtuple::pix_zz
std::vector< float > pix_zz
Definition: TrackingNtuple.cc:1077
TrackerDigiGeometryRecord
Definition: TrackerDigiGeometryRecord.h:15
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
TrackingNtuple::ph2_yz
std::vector< float > ph2_yz
Definition: TrackingNtuple.cc:1140
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:2690
TrackingNtuple::trk_simTrkIdx
std::vector< std::vector< int > > trk_simTrkIdx
Definition: TrackingNtuple.cc:1017
reco::BeamSpot
Definition: BeamSpot.h:21
TrackAssociatorRecord
Definition: TrackAssociatorRecord.h:18
edm::ESHandle< MagneticField >
TrackingNtuple::sim_pca_eta
std::vector< float > sim_pca_eta
Definition: TrackingNtuple.cc:1035
TrackingNtuple::str_simHitIdx
std::vector< std::vector< int > > str_simHitIdx
Definition: TrackingNtuple.cc:1089
TrackingVertexRef
edm::Ref< TrackingVertexCollection > TrackingVertexRef
Definition: TrackingVertexContainer.h:9
TrackingNtuple::sim_nPixelLay
std::vector< unsigned int > sim_nPixelLay
Definition: TrackingNtuple.cc:1047
declareDynArray
#define declareDynArray(T, n, x)
Definition: DynArray.h:91
TrackingNtuple::see_dz
std::vector< float > see_dz
Definition: TrackingNtuple.cc:1189
TrackingNtuple::see_bestSimTrkShareFrac
std::vector< float > see_bestSimTrkShareFrac
Definition: TrackingNtuple.cc:1215
TrackingNtuple::bsp_x
float bsp_x
Definition: TrackingNtuple.cc:1172
TrackingNtuple::trk_simTrkNChi2
std::vector< std::vector< float > > trk_simTrkNChi2
Definition: TrackingNtuple.cc:1016
TrackingNtuple::sim_pca_cotTheta
std::vector< float > sim_pca_cotTheta
Definition: TrackingNtuple.cc:1037
StripSubdetector::TIB
static constexpr auto TIB
Definition: StripSubdetector.h:16
TrackingNtuple::simvtx_daughterSimIdx
std::vector< std::vector< int > > simvtx_daughterSimIdx
Definition: TrackingNtuple.cc:1250
TrackingNtuple::sim_trkIdx
std::vector< std::vector< int > > sim_trkIdx
Definition: TrackingNtuple.cc:1054
reco::TrackBase::algoName
std::string algoName() const
Definition: TrackBase.h:535
TrackingNtuple::trk_lambdaErr
std::vector< float > trk_lambdaErr
Definition: TrackingNtuple.cc:970
TrackingNtuple::ph2_isBarrel
std::vector< short > ph2_isBarrel
Definition: TrackingNtuple.cc:1127
TrackingNtuple::sim_pca_lambda
std::vector< float > sim_pca_lambda
Definition: TrackingNtuple.cc:1036
TrackingNtuple::pix_xy
std::vector< float > pix_xy
Definition: TrackingNtuple.cc:1074
GlobalPoint
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
TrackingNtuple::pix_simType
std::vector< unsigned short > pix_simType
Definition: TrackingNtuple.cc:1069
TrackingNtuple::simhit_x
std::vector< float > simhit_x
Definition: TrackingNtuple.cc:1159
TrackingNtuple::trk_simTrkShareFrac
std::vector< std::vector< float > > trk_simTrkShareFrac
Definition: TrackingNtuple.cc:1015
TrackingNtuple::vtx_valid
std::vector< short > vtx_valid
Definition: TrackingNtuple.cc:1237
TrackingNtuple::ph2_radL
std::vector< float > ph2_radL
Definition: TrackingNtuple.cc:1144
TrackingNtuple::ev_run
edm::RunNumber_t ev_run
Definition: TrackingNtuple.cc:939
Point3DBase< float, GlobalTag >
TrackingNtuple::sim_pca_pt
std::vector< float > sim_pca_pt
Definition: TrackingNtuple.cc:1034
TrackingNtuple::tpHitIndexListLess
static bool tpHitIndexListLess(const TPHitIndex &i, const TPHitIndex &j)
Definition: TrackingNtuple.cc:500
TrackingNtuple::ph2_detId
DetIdPhase2OT ph2_detId
Definition: TrackingNtuple.cc:1128
TrackingNtuple::mvaQualityCollectionTokens_
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityCollectionTokens_
Definition: TrackingNtuple.cc:633
TrackingNtuple::trk_nInnerInactive
std::vector< unsigned int > trk_nInnerInactive
Definition: TrackingNtuple.cc:991
TrackingNtuple::simhit_y
std::vector< float > simhit_y
Definition: TrackingNtuple.cc:1160
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
TrackingNtuple::see_bestSimTrkIdx
std::vector< int > see_bestSimTrkIdx
Definition: TrackingNtuple.cc:1214
edmNew::DetSetVector::dataSize
size_type dataSize() const
Definition: DetSetVectorNew.h:594
TrackingNtuple::see_statePt
std::vector< float > see_statePt
Definition: TrackingNtuple.cc:1196
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:959
TrackingNtuple::glu_isBarrel
std::vector< short > glu_isBarrel
Definition: TrackingNtuple.cc:1107
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:948
TrackingNtuple::sim_nLay
std::vector< unsigned int > sim_nLay
Definition: TrackingNtuple.cc:1046
TrackingNtuple::str_simType
std::vector< unsigned short > str_simType
Definition: TrackingNtuple.cc:1091
TrackingNtuple::ph2_xx
std::vector< float > ph2_xx
Definition: TrackingNtuple.cc:1137
TrackingNtuple::trk_mvas
std::vector< std::vector< float > > trk_mvas
Definition: TrackingNtuple.cc:980
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:643
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:640
TrackingNtuple::pix_y
std::vector< float > pix_y
Definition: TrackingNtuple.cc:1071
edm::View
Definition: CaloClusterFwd.h:14
ntuplemaker.fill
fill
Definition: ntuplemaker.py:304
TrackingNtuple::trk_vtxIdx
std::vector< int > trk_vtxIdx
Definition: TrackingNtuple.cc:1003
edm::ParameterSetDescription::addUntracked
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
Definition: ParameterSetDescription.h:100
Point
Structure Point Contains parameters of Gaussian fits to DMRs.
Definition: DMRtrends.cc:57
trackerHitRTTI::isMatched
bool isMatched(TrackingRecHit const &hit)
Definition: trackerHitRTTI.h:32
ntupleEnum.OOTPileup
OOTPileup
Definition: ntupleEnum.py:107
TrackingNtuple::trk_nChi2
std::vector< float > trk_nChi2
Definition: TrackingNtuple.cc:977
TrackingNtuple::see_simTrkShareFrac
std::vector< std::vector< float > > see_simTrkShareFrac
Definition: TrackingNtuple.cc:1218
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
TrackingNtuple::stripMatchedRecHitToken_
edm::EDGetTokenT< SiStripMatchedRecHit2DCollection > stripMatchedRecHitToken_
Definition: TrackingNtuple.cc:647
HLT_2018_cff.InputTag
InputTag
Definition: HLT_2018_cff.py:79016
TrackingNtuple::str_zx
std::vector< float > str_zx
Definition: TrackingNtuple.cc:1100
LogDebug
#define LogDebug(id)
Definition: MessageLogger.h:670
TrackingNtuple::trk_inner_py
std::vector< float > trk_inner_py
Definition: TrackingNtuple.cc:951
TrackingNtuple::see_nPhase2OT
std::vector< unsigned int > see_nPhase2OT
Definition: TrackingNtuple.cc:1207
TrackingNtuple::sim_genPdgIds
std::vector< std::vector< int > > sim_genPdgIds
Definition: TrackingNtuple.cc:1026
DetId::Tracker
Definition: DetId.h:25
TrackingNtuple::see_nCluster
std::vector< unsigned int > see_nCluster
Definition: TrackingNtuple.cc:1208
TrackingNtuple::sim_nValid
std::vector< unsigned int > sim_nValid
Definition: TrackingNtuple.cc:1043
TrackingNtuple::seedTokens_
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > seedTokens_
Definition: TrackingNtuple.cc:629
TrackingNtuple::trackingParticleToken_
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleToken_
Definition: TrackingNtuple.cc:634
TrackingNtuple::simHitTPMapToken_
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > simHitTPMapToken_
Definition: TrackingNtuple.cc:637
TrackingNtuple::HitSimType::ITPileup
TrackingNtuple::ph2_simHitIdx
std::vector< std::vector< int > > ph2_simHitIdx
Definition: TrackingNtuple.cc:1131
TrackingNtuple::sim_bunchCrossing
std::vector< int > sim_bunchCrossing
Definition: TrackingNtuple.cc:1024
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
TrackingNtuple::pix_yy
std::vector< float > pix_yy
Definition: TrackingNtuple.cc:1075
SiStripMatchedRecHit2D::stereoClusterRef
OmniClusterRef const & stereoClusterRef() const
Definition: SiStripMatchedRecHit2D.h:34
edm::AssociationMap< edm::OneToManyWithQualityGeneric< edm::View< reco::Track >, TrackingParticleCollection, double > >
KineDebug3::count
void count()
Definition: KinematicConstrainedVertexUpdatorT.h:21
TrackingNtuple::glu_x
std::vector< float > glu_x
Definition: TrackingNtuple.cc:1112
TrackingNtuple::fillTrackingVertices
void fillTrackingVertices(const TrackingVertexRefVector &trackingVertices, const TrackingParticleRefKeyToIndex &tpKeyToIndex)
Definition: TrackingNtuple.cc:3582
TrackingVertex
Definition: TrackingVertex.h:22
TrackingNtuple::trk_q
std::vector< int > trk_q
Definition: TrackingNtuple.cc:982
TrackingNtuple::sim_event
std::vector< int > sim_event
Definition: TrackingNtuple.cc:1023
trackingNtuple_cff.seedTracks
seedTracks
Definition: trackingNtuple_cff.py:76
TrackingNtuple::stripStereoRecHitToken_
edm::EDGetTokenT< SiStripRecHit2DCollection > stripStereoRecHitToken_
Definition: TrackingNtuple.cc:646
TrackingNtuple::see_py
std::vector< float > see_py
Definition: TrackingNtuple.cc:1183
TrackingNtuple::parametersDefinerName_
std::string parametersDefinerName_
Definition: TrackingNtuple.cc:655
TrackingNtuple::see_nStrip
std::vector< unsigned int > see_nStrip
Definition: TrackingNtuple.cc:1206
muonSimHitMatcherPSet.simTrack
simTrack
Definition: muonSimHitMatcherPSet.py:4
TrackingNtuple::see_stopReason
std::vector< unsigned short > see_stopReason
Definition: TrackingNtuple.cc:1210
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:1118
TrackingNtuple::glu_z
std::vector< float > glu_z
Definition: TrackingNtuple.cc:1114
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:1130
TrackingNtuple::trk_bestFromFirstHitSimTrkNChi2
std::vector< float > trk_bestFromFirstHitSimTrkNChi2
Definition: TrackingNtuple.cc:1014
TrackingNtuple::sim_pz
std::vector< float > sim_pz
Definition: TrackingNtuple.cc:1030
TrackingNtuple::simvtx_sourceSimIdx
std::vector< std::vector< int > > simvtx_sourceSimIdx
Definition: TrackingNtuple.cc:1249
M_PI
#define M_PI
Definition: BXVectorInputProducer.cc:50
TrackingNtuple::sim_eta
std::vector< float > sim_eta
Definition: TrackingNtuple.cc:1032
TrackingNtuple::trk_nLost
std::vector< unsigned int > trk_nLost
Definition: TrackingNtuple.cc:984
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:1236
TrackingNtuple::trk_outer_py
std::vector< float > trk_outer_py
Definition: TrackingNtuple.cc:955
edm::LogPrint
Definition: MessageLogger.h:342
MuonTrackValidator_cfi.parametersDefiner
parametersDefiner
Definition: MuonTrackValidator_cfi.py:26
GlobalErrorBase< double, ErrorMatrixTag >
TrackingNtuple::see_isTrue
std::vector< short > see_isTrue
Definition: TrackingNtuple.cc:1213
TrackingNtuple::simhit_eloss
std::vector< float > simhit_eloss
Definition: TrackingNtuple.cc:1164
BaseTrackerRecHit::firstClusterRef
virtual OmniClusterRef const & firstClusterRef() const =0
TrackingNtuple::trk_hitIdx
std::vector< std::vector< int > > trk_hitIdx
Definition: TrackingNtuple.cc:1018
TrackingNtuple::simvtx_x
std::vector< float > simvtx_x
Definition: TrackingNtuple.cc:1246
TrackingNtuple::simhit_detId_phase2
DetIdAllPhase2 simhit_detId_phase2
Definition: TrackingNtuple.cc:1158
TrackingNtuple::trk_dxy
std::vector< float > trk_dxy
Definition: TrackingNtuple.cc:962
TrackingNtuple::pix_xx
std::vector< float > pix_xx
Definition: TrackingNtuple.cc:1073
TrackingNtuple::glu_stereoIdx
std::vector< int > glu_stereoIdx
Definition: TrackingNtuple.cc:1110
TrackingNtuple::str_zz
std::vector< float > str_zz
Definition: TrackingNtuple.cc:1099
TrackingNtuple::addStripMatchedHit
size_t addStripMatchedHit(const SiStripMatchedRecHit2D &hit, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)
Definition: TrackingNtuple.cc:2646
TrackingNtuple::trk_py
std::vector< float > trk_py
Definition: TrackingNtuple.cc:947
TrackingNtuple::vtx_zErr
std::vector< float > vtx_zErr
Definition: TrackingNtuple.cc:1233
Invalid
Definition: hltDiff.cc:248
SiStripRecHit1D
Definition: SiStripRecHit1D.h:8
TrackingNtuple::trk_bestFromFirstHitSimTrkIdx
std::vector< int > trk_bestFromFirstHitSimTrkIdx
Definition: TrackingNtuple.cc:1010
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:2550
TrackingNtuple::simvtx_event
std::vector< int > simvtx_event
Definition: TrackingNtuple.cc:1243
get
#define get
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:1103
TrackingNtuple::bsp_z
float bsp_z
Definition: TrackingNtuple.cc:1174
TrackingNtuple::trk_nInactive
std::vector< unsigned int > trk_nInactive
Definition: TrackingNtuple.cc:985
TrackingNtuple::ph2_x
std::vector< float > ph2_x
Definition: TrackingNtuple.cc:1134
TrackingNtuple::tpNPixelLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNPixelLayersToken_
Definition: TrackingNtuple.cc:652
TrackingNtuple::str_detId
DetIdStrip str_detId
Definition: TrackingNtuple.cc:1086
TrackingNtuple::includeSeeds_
const bool includeSeeds_
Definition: TrackingNtuple.cc:656
reco::HitPattern::TRACK_HITS
Definition: HitPattern.h:155
TrackingNtuple::trk_bestSimTrkShareFracSimClusterDenom
std::vector< float > trk_bestSimTrkShareFracSimClusterDenom
Definition: TrackingNtuple.cc:1008
TrackingNtuple::trk_nStripLay
std::vector< unsigned int > trk_nStripLay
Definition: TrackingNtuple.cc:993
TrackingNtuple::trk_ndof
std::vector< float > trk_ndof
Definition: TrackingNtuple.cc:979
TrackingNtuple::trk_outer_pt
std::vector< float > trk_outer_pt
Definition: TrackingNtuple.cc:957
TrackingNtuple::sim_nTrackerHits
std::vector< unsigned int > sim_nTrackerHits
Definition: TrackingNtuple.cc:1050
TrackingRecHit
Definition: TrackingRecHit.h:21
TrackingNtuple::glu_bbxi
std::vector< float > glu_bbxi
Definition: TrackingNtuple.cc:1123
TrackingNtuple::trk_bestSimTrkShareFrac
std::vector< float > trk_bestSimTrkShareFrac
Definition: TrackingNtuple.cc:1006
TrackingNtuple::glu_monoIdx
std::vector< int > glu_monoIdx
Definition: TrackingNtuple.cc:1109
TrackingNtuple::vtx_ndof
std::vector< float > vtx_ndof
Definition: TrackingNtuple.cc:1234
edm::EDConsumerBase::labelsForToken
void labelsForToken(EDGetToken iToken, Labels &oLabels) const
Definition: EDConsumerBase.cc:347
TrackingNtuple::simvtx_z
std::vector< float > simvtx_z
Definition: TrackingNtuple.cc:1248
TrackingNtuple::trk_cotTheta
std::vector< float > trk_cotTheta
Definition: TrackingNtuple.cc:960
TrackingNtuple::includePhase2OTHits_
bool includePhase2OTHits_
Definition: TrackingNtuple.cc:642
DDAxes::phi
TrackingNtuple::trk_refpoint_x
std::vector< float > trk_refpoint_x
Definition: TrackingNtuple.cc:974
TrackingNtuple::vtx_y
std::vector< float > vtx_y
Definition: TrackingNtuple.cc:1229
TrackingNtuple::stripRphiRecHitToken_
edm::EDGetTokenT< SiStripRecHit2DCollection > stripRphiRecHitToken_
Definition: TrackingNtuple.cc:645
TrackingNtuple::trk_stopReason
std::vector< unsigned short > trk_stopReason
Definition: TrackingNtuple.cc:1000
TrackingNtuple::clusterTPMapToken_
edm::EDGetTokenT< ClusterTPAssociation > clusterTPMapToken_
Definition: TrackingNtuple.cc:636
TrackingNtuple::trk_nLostLay
std::vector< unsigned int > trk_nLostLay
Definition: TrackingNtuple.cc:995
RZLine
Definition: RZLine.h:12
edmNew::DetSetVector
Definition: DetSetNew.h:13
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
TrackingNtuple::ph2_bbxi
std::vector< float > ph2_bbxi
Definition: TrackingNtuple.cc:1145
type
type
Definition: HCALResponse.h:21
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:2238
TrackingNtuple::trk_outer_px
std::vector< float > trk_outer_px
Definition: TrackingNtuple.cc:954
StripSubdetector::TEC
static constexpr auto TEC
Definition: StripSubdetector.h:19
TrackingNtuple::pix_detId
DetIdPixel pix_detId
Definition: TrackingNtuple.cc:1064
TrackingNtuple::pix_trkIdx
std::vector< std::vector< int > > pix_trkIdx
Definition: TrackingNtuple.cc:1065
TrackingNtuple::pixelRecHitToken_
edm::EDGetTokenT< SiPixelRecHitCollection > pixelRecHitToken_
Definition: TrackingNtuple.cc:644
TrackingNtuple::inv_isBarrel
std::vector< short > inv_isBarrel
Definition: TrackingNtuple.cc:1150
TrackingNtuple::glu_xy
std::vector< float > glu_xy
Definition: TrackingNtuple.cc:1116
TrackingNtuple::sim_nPixel
std::vector< unsigned int > sim_nPixel
Definition: TrackingNtuple.cc:1044
TrackingNtuple::ph2_zx
std::vector< float > ph2_zx
Definition: TrackingNtuple.cc:1142
SiStripMatchedRecHit2D
Definition: SiStripMatchedRecHit2D.h:8
TrackingNtuple::phase2OTRecHitToken_
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew > phase2OTRecHitToken_
Definition: TrackingNtuple.cc:648
SimTrack
Definition: SimTrack.h:6
TrackingNtuple::see_algo
std::vector< unsigned int > see_algo
Definition: TrackingNtuple.cc:1209
triggerObjects_cff.id
id
Definition: triggerObjects_cff.py:31
TrackingNtuple::trk_dxyErr
std::vector< float > trk_dxyErr
Definition: TrackingNtuple.cc:972
TSCBLBuilderNoMaterial
Definition: TSCBLBuilderNoMaterial.h:13
TrackingNtuple::trk_pt
std::vector< float > trk_pt
Definition: TrackingNtuple.cc:949
TrackingNtuple::trk_eta
std::vector< float > trk_eta
Definition: TrackingNtuple.cc:958
edmNew::DetSetVector::end
const_iterator end(bool update=false) const
Definition: DetSetVectorNew.h:577
TrackingNtuple::see_stateTrajPx
std::vector< float > see_stateTrajPx
Definition: TrackingNtuple.cc:1199
edm::ValueMap
Definition: ValueMap.h:107
TrackingNtuple::vtx_trkIdx
std::vector< std::vector< int > > vtx_trkIdx
Definition: TrackingNtuple.cc:1238
Exception
Definition: hltDiff.cc:246
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:1211
TrackingNtuple::sim_pca_dxy
std::vector< float > sim_pca_dxy
Definition: TrackingNtuple.cc:1039
TrackingNtuple::see_stateTrajY
std::vector< float > see_stateTrajY
Definition: TrackingNtuple.cc:1198
TrackingNtuple::simhit_hitIdx
std::vector< std::vector< int > > simhit_hitIdx
Definition: TrackingNtuple.cc:1168
TrackingNtuple::simhit_particle
std::vector< int > simhit_particle
Definition: TrackingNtuple.cc:1162
TrackingNtuple::bsp_y
float bsp_y
Definition: TrackingNtuple.cc:1173
align::Strip
Definition: StructureType.h:69
TrackingNtuple::glu_radL
std::vector< float > glu_radL
Definition: TrackingNtuple.cc:1122
TrackingNtuple::trk_nValid
std::vector< unsigned int > trk_nValid
Definition: TrackingNtuple.cc:983
StripSubdetector::TOB
static constexpr auto TOB
Definition: StripSubdetector.h:18
TrackingNtuple::trk_hitType
std::vector< std::vector< int > > trk_hitType
Definition: TrackingNtuple.cc:1019
TrackPSimHitRef
edm::Ref< edm::PSimHitContainer > TrackPSimHitRef
Definition: PSimHitContainer.h:14
TrackingNtuple::str_xx
std::vector< float > str_xx
Definition: TrackingNtuple.cc:1095
TrackingNtuple::see_phi
std::vector< float > see_phi
Definition: TrackingNtuple.cc:1187
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
TrackingNtuple::siphase2OTSimLinksToken_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > siphase2OTSimLinksToken_
Definition: TrackingNtuple.cc:641
TrackingNtuple::tpNStripStereoLayersToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > > tpNStripStereoLayersToken_
Definition: TrackingNtuple.cc:653
align::Pixel
Definition: StructureType.h:68
TrackingNtuple::see_q
std::vector< int > see_q
Definition: TrackingNtuple.cc:1202
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:1113
TrackingNtuple::see_dxyErr
std::vector< float > see_dxyErr
Definition: TrackingNtuple.cc:1193
TrackingNtuple::fillVertices
void fillVertices(const reco::VertexCollection &vertices, const edm::RefToBaseVector< reco::Track > &tracks)
Definition: TrackingNtuple.cc:3549
TrackingNtuple::HitType::Invalid
TrackingNtuple::sim_pt
std::vector< float > sim_pt
Definition: TrackingNtuple.cc:1031
TrackingNtuple::trk_ptErr
std::vector< float > trk_ptErr
Definition: TrackingNtuple.cc:968
TrackingNtuple::pix_radL
std::vector< float > pix_radL
Definition: TrackingNtuple.cc:1080
TrackingNtuple::pix_bbxi
std::vector< float > pix_bbxi
Definition: TrackingNtuple.cc:1081
ntupleEnum.ITPileup
ITPileup
Definition: ntupleEnum.py:106
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:964
TrackingNtuple::vtx_z
std::vector< float > vtx_z
Definition: TrackingNtuple.cc:1230
TrackingNtuple::fillStripMatchedHits
void fillStripMatchedHits(const edm::Event &iEvent, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int >> &monoStereoClusterList)
Definition: TrackingNtuple.cc:2677
TrackingNtuple::sim_seedIdx
std::vector< std::vector< int > > sim_seedIdx
Definition: TrackingNtuple.cc:1056
TrackingNtuple::sim_pca_dz
std::vector< float > sim_pca_dz
Definition: TrackingNtuple.cc:1040
TrackingNtuple::see_fitok
std::vector< short > see_fitok
Definition: TrackingNtuple.cc:1181
TrackingNtuple::trk_nStrip
std::vector< unsigned int > trk_nStrip
Definition: TrackingNtuple.cc:987
DigiDM_cff.Noise
Noise
Definition: DigiDM_cff.py:38
TrackingNtuple::str_x
std::vector< float > str_x
Definition: TrackingNtuple.cc:1092
TrackingNtuple::see_offset
std::vector< unsigned int > see_offset
Definition: TrackingNtuple.cc:1223
TrackingNtuple::sim_n3DLay
std::vector< unsigned int > sim_n3DLay
Definition: TrackingNtuple.cc:1048
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:1097
TrackingNtuple::pix_z
std::vector< float > pix_z
Definition: TrackingNtuple.cc:1072
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
TrackingNtuple::builderName_
std::string builderName_
Definition: TrackingNtuple.cc:654
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:671
TrackerTopologyRcd
Definition: TrackerTopologyRcd.h:10
TrackingNtuple::trk_inner_px
std::vector< float > trk_inner_px
Definition: TrackingNtuple.cc:950
TrackingParticleRef
edm::Ref< TrackingParticleCollection > TrackingParticleRef
Definition: TrackingParticleFwd.h:10
edm::EDConsumerBase::consumes
EDGetTokenT< ProductType > consumes(edm::InputTag const &tag)
Definition: EDConsumerBase.h:126
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
TrackingNtuple::sim_pca_phi
std::vector< float > sim_pca_phi
Definition: TrackingNtuple.cc:1038
TrackingNtuple::ph2_trkIdx
std::vector< std::vector< int > > ph2_trkIdx
Definition: TrackingNtuple.cc:1129
TrackingNtuple::trk_bestSimTrkShareFracSimDenom
std::vector< float > trk_bestSimTrkShareFracSimDenom
Definition: TrackingNtuple.cc:1007
TrackingNtuple::simvtx_processType
std::vector< unsigned int > simvtx_processType
Definition: TrackingNtuple.cc:1245
event
Definition: event.py:1
TrackingNtuple::trackingParticleRefToken_
edm::EDGetTokenT< TrackingParticleRefVector > trackingParticleRefToken_
Definition: TrackingNtuple.cc:635
TrackingNtuple::fillTrackingParticlesForSeeds
void fillTrackingParticlesForSeeds(const TrackingParticleRefVector &tpCollection, const reco::SimToRecoCollection &simRecColl, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const unsigned int seedOffset)
Definition: TrackingNtuple.cc:3527
hltrates_dqm_sourceclient-live_cfg.offset
offset
Definition: hltrates_dqm_sourceclient-live_cfg.py:78
TrackingNtuple::see_phiErr
std::vector< float > see_phiErr
Definition: TrackingNtuple.cc:1192
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
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:1025
LHEGenericFilter_cfi.ParticleID
ParticleID
Definition: LHEGenericFilter_cfi.py:6
TrackingNtuple::seedStopInfoTokens_
std::vector< edm::EDGetTokenT< std::vector< SeedStopInfo > > > seedStopInfoTokens_
Definition: TrackingNtuple.cc:630
TrackingNtuple::see_ptErr
std::vector< float > see_ptErr
Definition: TrackingNtuple.cc:1190
TrackingNtuple::simhit_hitType
std::vector< std::vector< int > > simhit_hitType
Definition: TrackingNtuple.cc:1169
edm::InputTag
Definition: InputTag.h:15
TrackingNtuple::includeStripHits_
bool includeStripHits_
Definition: TrackingNtuple.cc:642
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:1068
TrackingNtuple::simvtx_y
std::vector< float > simvtx_y
Definition: TrackingNtuple.cc:1247
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:1135
TrackingNtuple::sim_phi
std::vector< float > sim_phi
Definition: TrackingNtuple.cc:1033
SurveyInfoScenario_cff.seed
seed
Definition: SurveyInfoScenario_cff.py:295
hit
Definition: SiStripHitEffFromCalibTree.cc:88
TrackingNtuple::HitType::Strip
TrackingNtuple::sim_py
std::vector< float > sim_py
Definition: TrackingNtuple.cc:1029
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:1177
TrackingNtuple::vtx_x
std::vector< float > vtx_x
Definition: TrackingNtuple.cc:1228
TrackingNtuple::simhit_simTrkIdx
std::vector< int > simhit_simTrkIdx
Definition: TrackingNtuple.cc:1167
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:1244
TrackingNtuple::trk_phiErr
std::vector< float > trk_phiErr
Definition: TrackingNtuple.cc:971
TrackingNtuple::see_bestFromFirstHitSimTrkIdx
std::vector< int > see_bestFromFirstHitSimTrkIdx
Definition: TrackingNtuple.cc:1216
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:1066
SimHitTPAssociationProducer::simHitTPAssociationListGreater
static bool simHitTPAssociationListGreater(SimHitTPPair i, SimHitTPPair j)
Definition: SimHitTPAssociationProducer.h:23
TrackingNtuple::see_chi2
std::vector< float > see_chi2
Definition: TrackingNtuple.cc:1195
TrackingNtuple::trk_dzClosestPV
std::vector< float > trk_dzClosestPV
Definition: TrackingNtuple.cc:967
reco::TrackBase::highPurity
Definition: TrackBase.h:154
TrackingNtuple::vtx_yErr
std::vector< float > vtx_yErr
Definition: TrackingNtuple.cc:1232
Generated for CMSSW Reference Manual by doxygen 1.8.16