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
 
SerialTaskQueueglobalLuminosityBlocksQueue () final
 
SerialTaskQueueglobalRunsQueue () 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< ConsumesInfoconsumesInfo () const
 
void convertCurrentProcessAlias (std::string const &processName)
 Convert "@currentProcess" in InputTag process names to the actual current process name. More...
 
 EDConsumerBase ()
 
 EDConsumerBase (EDConsumerBase const &)=delete
 
 EDConsumerBase (EDConsumerBase &&)=default
 
ESProxyIndex const * esGetTokenIndices (edm::Transition iTrans) const
 
ProductResolverIndexAndSkipBit indexFrom (EDGetToken, BranchType, TypeID const &) const
 
void itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
void itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
 
std::vector< ProductResolverIndexAndSkipBit > const & itemsToGetFrom (BranchType iType) const
 
void labelsForToken (EDGetToken iToken, Labels &oLabels) const
 
void modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
 
EDConsumerBase const & operator= (EDConsumerBase const &)=delete
 
EDConsumerBaseoperator= (EDConsumerBase &&)=default
 
bool registeredToConsume (ProductResolverIndex, bool, BranchType) const
 
bool registeredToConsumeMany (TypeID const &, BranchType) const
 
ProductResolverIndexAndSkipBit uncheckedIndexFrom (EDGetToken) const
 
void updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
 
void updateLookup (eventsetup::ESRecordsToProxyIndices const &)
 
virtual ~EDConsumerBase () noexcept(false)
 

Static Public Member Functions

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

Private Types

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

Private Member Functions

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

Static Private Member Functions

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

Private Attributes

edm::EDGetTokenT< reco::BeamSpotbeamSpotToken_
 
float bsp_sigmax
 
float bsp_sigmay
 
float bsp_sigmaz
 
float bsp_x
 
float bsp_y
 
float bsp_z
 
std::string builderName_
 
edm::EDGetTokenT< ClusterTPAssociationclusterTPMapToken_
 
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< Phase2TrackerRecHit1DCollectionNewphase2OTRecHitToken_
 
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< SiPixelRecHitCollectionpixelRecHitToken_
 
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::SimHitTPAssociationListsimHitTPMapToken_
 
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< SiStripMatchedRecHit2DCollectionstripMatchedRecHitToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollectionstripRphiRecHitToken_
 
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > > stripSimLinkToken_
 
edm::EDGetTokenT< SiStripRecHit2DCollectionstripStereoRecHitToken_
 
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::TrackToTrackingParticleAssociatortrackAssociatorToken_
 
edm::EDGetTokenT< TrackingParticleRefVectortrackingParticleRefToken_
 
edm::EDGetTokenT< TrackingParticleCollectiontrackingParticleToken_
 
edm::EDGetTokenT< TrackingVertexCollectiontrackingVertexToken_
 
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::VertexCollectionvertexToken_
 
std::vector< float > vtx_chi2
 
std::vector< short > vtx_fake
 
std::vector< float > vtx_ndof
 
std::vector< std::vector< int > > vtx_trkIdx
 
std::vector< short > vtx_valid
 
std::vector< float > vtx_x
 
std::vector< float > vtx_xErr
 
std::vector< float > vtx_y
 
std::vector< float > vtx_yErr
 
std::vector< float > vtx_z
 
std::vector< float > vtx_zErr
 

Additional Inherited Members

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

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 466 of file TrackingNtuple.cc.

Member Typedef Documentation

Definition at line 957 of file TrackingNtuple.cc.

Definition at line 958 of file TrackingNtuple.cc.

Definition at line 956 of file TrackingNtuple.cc.

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

Definition at line 954 of file TrackingNtuple.cc.

Definition at line 955 of file TrackingNtuple.cc.

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

Definition at line 500 of file TrackingNtuple.cc.

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

Definition at line 501 of file TrackingNtuple.cc.

Member Enumeration Documentation

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

Definition at line 492 of file TrackingNtuple.cc.

492  {
493  Signal = 0,
494  ITPileup = 1,
495  OOTPileup = 2,
496  Noise = 3,
497  Unknown = 99
498  };
Definition: vlib.h:39
enum TrackingNtuple::HitType
strongprivate
Enumerator
Pixel 
Strip 
Glued 
Invalid 
Phase2OT 
Unknown 

Definition at line 479 of file TrackingNtuple.cc.

479  {
480  Pixel = 0,
481  Strip = 1,
482  Glued = 2,
483  Invalid = 3,
484  Phase2OT = 4,
485  Unknown = 99
486  };

Constructor & Destructor Documentation

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

Definition at line 1276 of file TrackingNtuple.cc.

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

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

Definition at line 1689 of file TrackingNtuple.cc.

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

Member Function Documentation

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

Definition at line 2566 of file TrackingNtuple.cc.

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

Referenced by fillSeeds(), and fillStripMatchedHits().

2570  {
2571  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
2572  const auto hitId = hit.geographicalId();
2573  const int lay = tTopo.layer(hitId);
2574  monoStereoClusterList.emplace_back(hit.monoHit().cluster().key(),hit.stereoHit().cluster().key());
2575  glu_isBarrel .push_back( (hitId.subdetId()==StripSubdetector::TIB || hitId.subdetId()==StripSubdetector::TOB) );
2576  glu_detId .push_back( tTopo, hitId );
2577  glu_monoIdx .push_back( hit.monoHit().cluster().key() );
2578  glu_stereoIdx.push_back( hit.stereoHit().cluster().key() );
2579  glu_seeIdx .emplace_back(); // filled in fillSeeds
2580  glu_x .push_back( ttrh->globalPosition().x() );
2581  glu_y .push_back( ttrh->globalPosition().y() );
2582  glu_z .push_back( ttrh->globalPosition().z() );
2583  glu_xx .push_back( ttrh->globalPositionError().cxx() );
2584  glu_xy .push_back( ttrh->globalPositionError().cyx() );
2585  glu_yy .push_back( ttrh->globalPositionError().cyy() );
2586  glu_yz .push_back( ttrh->globalPositionError().czy() );
2587  glu_zz .push_back( ttrh->globalPositionError().czz() );
2588  glu_zx .push_back( ttrh->globalPositionError().czx() );
2589  glu_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
2590  glu_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );
2591  LogTrace("TrackingNtuple") << "stripMatchedHit"
2592  << " cluster0=" << hit.stereoHit().cluster().key()
2593  << " cluster1=" << hit.monoHit().cluster().key()
2594  << " subdId=" << hitId.subdetId()
2595  << " lay=" << lay
2596  << " rawId=" << hitId.rawId()
2597  << " pos =" << ttrh->globalPosition();
2598  return glu_isBarrel.size()-1;
2599 }
std::vector< float > glu_xy
std::vector< float > glu_radL
std::vector< int > glu_monoIdx
std::vector< short > glu_isBarrel
std::vector< float > glu_x
std::vector< float > glu_z
key_type key() const
Accessor for product key.
Definition: Ref.h:263
std::vector< float > glu_y
std::vector< float > glu_yz
std::vector< float > glu_yy
ClusterRef cluster() const
std::vector< std::vector< int > > glu_seeIdx
#define LogTrace(id)
std::vector< float > glu_zz
std::vector< float > glu_zx
std::shared_ptr< TrackingRecHit const > RecHitPointer
virtual RecHitPointer build(const TrackingRecHit *p) const =0
build a tracking rechit from an existing rechit
std::vector< int > glu_stereoIdx
SiStripRecHit2D stereoHit() const
unsigned int layer(const DetId &id) const
SiStripRecHit2D monoHit() const
std::vector< float > glu_bbxi
std::vector< float > glu_xx
DetId geographicalId() const
DetIdStrip glu_detId
void TrackingNtuple::analyze ( const edm::Event iEvent,
const edm::EventSetup iSetup 
)
overrideprivate

Definition at line 1986 of file TrackingNtuple.cc.

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

1986  {
1987 
1988  using namespace edm;
1989  using namespace reco;
1990  using namespace std;
1991 
1993  iSetup.get<IdealMagneticFieldRecord>().get(mfHandle);
1994  const auto& mf = *mfHandle;
1995 
1997  iSetup.get<TransientRecHitRecord>().get(builderName_,theTTRHBuilder);
1998 
1999  edm::ESHandle<TrackerTopology> tTopoHandle;
2000  iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
2001  const TrackerTopology& tTopo = *tTopoHandle;
2002 
2003  edm::ESHandle<TrackerGeometry> geometryHandle;
2004  iSetup.get<TrackerDigiGeometryRecord>().get(geometryHandle);
2005  const TrackerGeometry &tracker = *geometryHandle;
2006 
2008  iEvent.getByToken(trackAssociatorToken_, theAssociator);
2009  const reco::TrackToTrackingParticleAssociator& associatorByHits = *theAssociator;
2010 
2011  LogDebug("TrackingNtuple") << "Analyzing new event";
2012 
2013  //initialize tree variables
2014  clearVariables();
2015 
2016  // FIXME: we really need to move to edm::View for reading the
2017  // TrackingParticles... Unfortunately it has non-trivial
2018  // consequences on the associator/association interfaces etc.
2020  const TrackingParticleRefVector *tmpTPptr = nullptr;
2022  edm::Handle<TrackingParticleRefVector> TPCollectionHRefVector;
2023 
2025  iEvent.getByToken(trackingParticleToken_, TPCollectionH);
2026  for(size_t i=0, size=TPCollectionH->size(); i<size; ++i) {
2027  tmpTP.push_back(TrackingParticleRef(TPCollectionH, i));
2028  }
2029  tmpTPptr = &tmpTP;
2030  }
2031  else {
2032  iEvent.getByToken(trackingParticleRefToken_, TPCollectionHRefVector);
2033  tmpTPptr = TPCollectionHRefVector.product();
2034  }
2035  const TrackingParticleRefVector& tpCollection = *tmpTPptr;
2036 
2037  // Fill mapping from Ref::key() to index
2038  TrackingParticleRefKeyToIndex tpKeyToIndex;
2039  for(size_t i=0; i<tpCollection.size(); ++i) {
2040  tpKeyToIndex[tpCollection[i].key()] = i;
2041  }
2042 
2043  // tracking vertices
2045  iEvent.getByToken(trackingVertexToken_, htv);
2046  const TrackingVertexCollection& tvs = *htv;
2047 
2048  // Fill mapping from Ref::key() to index
2049  TrackingVertexRefVector tvRefs;
2050  TrackingVertexRefKeyToIndex tvKeyToIndex;
2051  for(size_t i=0; i<tvs.size(); ++i) {
2052  const TrackingVertex& v = tvs[i];
2053  if(v.eventId().bunchCrossing() != 0) // Ignore OOTPU; would be better to not to hardcode?
2054  continue;
2055  tvKeyToIndex[i] = tvRefs.size();
2056  tvRefs.push_back(TrackingVertexRef(htv, i));
2057  }
2058 
2059  //get association maps, etc.
2060  Handle<ClusterTPAssociation> pCluster2TPListH;
2061  iEvent.getByToken(clusterTPMapToken_, pCluster2TPListH);
2062  const ClusterTPAssociation& clusterToTPMap = *pCluster2TPListH;
2064  iEvent.getByToken(simHitTPMapToken_, simHitsTPAssoc);
2065 
2066  // TP -> cluster count
2067  TrackingParticleRefKeyToCount tpKeyToClusterCount;
2068  for(const auto& clusterTP: clusterToTPMap) {
2069  tpKeyToClusterCount[clusterTP.second.key()] += 1;
2070  }
2071 
2072  // SimHit key -> index mapping
2073  SimHitRefKeyToIndex simHitRefKeyToIndex;
2074 
2075  //make a list to link TrackingParticles to its simhits
2076  std::vector<TPHitIndex> tpHitList;
2077 
2078  // Count the number of reco cluster per TP
2079 
2080  std::set<edm::ProductID> hitProductIds;
2081  std::map<edm::ProductID, size_t> seedCollToOffset;
2082 
2083  ev_run = iEvent.id().run();
2084  ev_lumi = iEvent.id().luminosityBlock();
2085  ev_event = iEvent.id().event();
2086 
2087  // Digi->Sim links for pixels and strips
2088  edm::Handle<edm::DetSetVector<PixelDigiSimLink> > pixelDigiSimLinksHandle;
2089  iEvent.getByToken(pixelSimLinkToken_, pixelDigiSimLinksHandle);
2090  const auto& pixelDigiSimLinks = *pixelDigiSimLinksHandle;
2091 
2092  edm::Handle<edm::DetSetVector<StripDigiSimLink> > stripDigiSimLinksHandle;
2093  iEvent.getByToken(stripSimLinkToken_, stripDigiSimLinksHandle);
2094 
2095  // Phase2 OT DigiSimLink
2096  edm::Handle<edm::DetSetVector<PixelDigiSimLink> > siphase2OTSimLinksHandle;
2097  iEvent.getByToken(siphase2OTSimLinksToken_, siphase2OTSimLinksHandle);
2098 
2099  //beamspot
2100  Handle<reco::BeamSpot> recoBeamSpotHandle;
2101  iEvent.getByToken(beamSpotToken_, recoBeamSpotHandle);
2102  BeamSpot const & bs = *recoBeamSpotHandle;
2103  fillBeamSpot(bs);
2104 
2105 
2106  //prapare list to link matched hits to collection
2107  vector<pair<int,int> > monoStereoClusterList;
2108  if(includeAllHits_) {
2109  // simhits, only if TPs are saved as well
2111  fillSimHits(tracker, tpKeyToIndex, *simHitsTPAssoc, tTopo, simHitRefKeyToIndex, tpHitList);
2112  }
2113 
2114  //pixel hits
2115  fillPixelHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, pixelDigiSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);
2116 
2117  //strip hits
2118  if(includeStripHits_){
2119  LogDebug("TrackingNtuple") << "foundStripSimLink" ;
2120  const auto& stripDigiSimLinks = *stripDigiSimLinksHandle;
2121  fillStripRphiStereoHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, stripDigiSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);
2122 
2123  //matched hits
2124  fillStripMatchedHits(iEvent, *theTTRHBuilder, tTopo, monoStereoClusterList);
2125  }
2126 
2128  LogDebug("TrackingNtuple") << "foundPhase2OTSimLinks" ;
2129  const auto& phase2OTSimLinks = *siphase2OTSimLinksHandle;
2130  fillPhase2OTHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, phase2OTSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);
2131  }
2132  }
2133 
2134  //seeds
2135  if(includeSeeds_) {
2136  fillSeeds(iEvent, tpCollection, tpKeyToIndex, bs, associatorByHits, clusterToTPMap, *theTTRHBuilder, mf, tTopo, monoStereoClusterList, hitProductIds, seedCollToOffset);
2137  }
2138 
2139  //tracks
2140  edm::Handle<edm::View<reco::Track> > tracksHandle;
2141  iEvent.getByToken(trackToken_, tracksHandle);
2142  const edm::View<reco::Track>& tracks = *tracksHandle;
2143  // The associator interfaces really need to be fixed...
2145  for(edm::View<Track>::size_type i=0; i<tracks.size(); ++i) {
2146  trackRefs.push_back(tracks.refAt(i));
2147  }
2148  std::vector<const MVACollection *> mvaColls;
2149  std::vector<const QualityMaskCollection *> qualColls;
2150  if(includeMVA_) {
2153 
2154  for(const auto& tokenTpl: mvaQualityCollectionTokens_) {
2155  iEvent.getByToken(std::get<0>(tokenTpl), hmva);
2156  iEvent.getByToken(std::get<1>(tokenTpl), hqual);
2157 
2158  mvaColls.push_back(hmva.product());
2159  qualColls.push_back(hqual.product());
2160  if(mvaColls.back()->size() != tracks.size()) {
2161  throw cms::Exception("Configuration") << "Inconsistency in track collection and MVA sizes. Track collection has " << tracks.size() << " tracks, whereas the MVA " << (mvaColls.size()-1) << " has " << mvaColls.back()->size() << " entries. Double-check your configuration.";
2162  }
2163  if(qualColls.back()->size() != tracks.size()) {
2164  throw cms::Exception("Configuration") << "Inconsistency in track collection and quality mask sizes. Track collection has " << tracks.size() << " tracks, whereas the quality mask " << (qualColls.size()-1) << " has " << qualColls.back()->size() << " entries. Double-check your configuration.";
2165  }
2166  }
2167  }
2168 
2170  iEvent.getByToken(vertexToken_, vertices);
2171 
2172  fillTracks(trackRefs, tpCollection, tpKeyToIndex, tpKeyToClusterCount, mf, bs, *vertices, associatorByHits, clusterToTPMap, *theTTRHBuilder, tTopo, hitProductIds, seedCollToOffset, mvaColls, qualColls);
2173 
2174  //tracking particles
2175  //sort association maps with simHits
2176  std::sort( tpHitList.begin(), tpHitList.end(), tpHitIndexListLessSort );
2177  fillTrackingParticles(iEvent, iSetup, trackRefs, bs, tpCollection, tvKeyToIndex, associatorByHits, tpHitList, tpKeyToClusterCount);
2178 
2179  // vertices
2180  fillVertices(*vertices, trackRefs);
2181 
2182  // tracking vertices
2183  fillTrackingVertices(tvRefs, tpKeyToIndex);
2184 
2185  t->Fill();
2186 
2187 }
#define LogDebug(id)
RunNumber_t run() const
Definition: EventID.h:39
size
Write out results.
edm::LuminosityBlockNumber_t ev_lumi
edm::EDGetTokenT< TrackingParticleRefVector > trackingParticleRefToken_
EventNumber_t event() const
Definition: EventID.h:41
unsigned int size_type
Definition: View.h:90
void fillTrackingVertices(const TrackingVertexRefVector &trackingVertices, const TrackingParticleRefKeyToIndex &tpKeyToIndex)
void fillStripMatchedHits(const edm::Event &iEvent, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int > > &monoStereoClusterList)
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
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 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)
edm::EDGetTokenT< reco::TrackToTrackingParticleAssociator > trackAssociatorToken_
edm::EDGetTokenT< edm::View< reco::Track > > trackToken_
void fillBeamSpot(const reco::BeamSpot &bs)
size_type size() const
LuminosityBlockNumber_t luminosityBlock() const
Definition: EventID.h:40
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)
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > pixelSimLinkToken_
RefToBase< value_type > refAt(size_type i) const
std::vector< std::tuple< edm::EDGetTokenT< MVACollection >, edm::EDGetTokenT< QualityMaskCollection > > > mvaQualityCollectionTokens_
edm::EDGetTokenT< edm::DetSetVector< PixelDigiSimLink > > siphase2OTSimLinksToken_
int bunchCrossing() const
get the detector field from this detid
edm::EDGetTokenT< SimHitTPAssociationProducer::SimHitTPAssociationList > simHitTPMapToken_
edm::RunNumber_t ev_run
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)
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexToken_
static bool tpHitIndexListLessSort(const TPHitIndex &i, const TPHitIndex &j)
const bool includeSeeds_
const bool includeTrackingParticles_
void fillSimHits(const TrackerGeometry &tracker, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const SimHitTPAssociationProducer::SimHitTPAssociationList &simHitsTPAssoc, const TrackerTopology &tTopo, SimHitRefKeyToIndex &simHitRefKeyToIndex, std::vector< TPHitIndex > &tpHitList)
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 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)
edm::Ref< TrackingVertexCollection > TrackingVertexRef
edm::EventNumber_t ev_event
edm::EDGetTokenT< reco::VertexCollection > vertexToken_
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleToken_
T const * product() const
Definition: Handle.h:74
const bool includeMVA_
std::vector< TrackingVertex > TrackingVertexCollection
const bool includeAllHits_
edm::EventID id() const
Definition: EventBase.h:59
const EncodedEventId & eventId() const
edm::EDGetTokenT< ClusterTPAssociation > clusterTPMapToken_
fixed size matrix
HLT enums.
T get() const
Definition: EventSetup.h:71
void push_back(const RefToBase< T > &)
edm::EDGetTokenT< reco::BeamSpot > beamSpotToken_
void push_back(value_type const &ref)
Add a Ref<C, T> to the RefVector.
Definition: RefVector.h:69
std::string builderName_
size_type size() const
Size of the RefVector.
Definition: RefVector.h:107
bool isUninitialized() const
Definition: EDGetToken.h:70
void fillVertices(const reco::VertexCollection &vertices, const edm::RefToBaseVector< reco::Track > &tracks)
edm::Ref< TrackingParticleCollection > TrackingParticleRef
edm::EDGetTokenT< edm::DetSetVector< StripDigiSimLink > > stripSimLinkToken_
void TrackingNtuple::clearVariables ( )
private

Definition at line 1698 of file TrackingNtuple.cc.

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

Referenced by analyze().

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

Definition at line 2189 of file TrackingNtuple.cc.

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

Referenced by analyze().

2189  {
2190  bsp_x = bs.x0();
2191  bsp_y = bs.y0();
2192  bsp_z = bs.x0();
2193  bsp_sigmax = bs.BeamWidthX();
2194  bsp_sigmay = bs.BeamWidthY();
2195  bsp_sigmaz = bs.sigmaZ();
2196 }
double BeamWidthX() const
beam width X
Definition: BeamSpot.h:86
double sigmaZ() const
sigma z
Definition: BeamSpot.h:80
double BeamWidthY() const
beam width Y
Definition: BeamSpot.h:88
double y0() const
y coordinate
Definition: BeamSpot.h:66
double x0() const
x coordinate
Definition: BeamSpot.h:64
void TrackingNtuple::fillDescriptions ( edm::ConfigurationDescriptions descriptions)
static

Definition at line 3500 of file TrackingNtuple.cc.

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

3500  {
3501  //The following says we do not know what parameters are allowed so do no validation
3502  // Please change this to state exactly what you do use, even if it is no parameters
3504  desc.addUntracked<std::vector<edm::InputTag> >("seedTracks", std::vector<edm::InputTag>{
3505  edm::InputTag("seedTracksinitialStepSeeds"),
3506  edm::InputTag("seedTracksdetachedTripletStepSeeds"),
3507  edm::InputTag("seedTrackspixelPairStepSeeds"),
3508  edm::InputTag("seedTrackslowPtTripletStepSeeds"),
3509  edm::InputTag("seedTracksmixedTripletStepSeeds"),
3510  edm::InputTag("seedTrackspixelLessStepSeeds"),
3511  edm::InputTag("seedTrackstobTecStepSeeds"),
3512  edm::InputTag("seedTracksjetCoreRegionalStepSeeds"),
3513  edm::InputTag("seedTracksmuonSeededSeedsInOut"),
3514  edm::InputTag("seedTracksmuonSeededSeedsOutIn")
3515  });
3516  desc.addUntracked<std::vector<edm::InputTag> >("trackCandidates", std::vector<edm::InputTag>{
3517  edm::InputTag("initialStepTrackCandidates"),
3518  edm::InputTag("detachedTripletStepTrackCandidates"),
3519  edm::InputTag("pixelPairStepTrackCandidates"),
3520  edm::InputTag("lowPtTripletStepTrackCandidates"),
3521  edm::InputTag("mixedTripletStepTrackCandidates"),
3522  edm::InputTag("pixelLessStepTrackCandidates"),
3523  edm::InputTag("tobTecStepTrackCandidates"),
3524  edm::InputTag("jetCoreRegionalStepTrackCandidates"),
3525  edm::InputTag("muonSeededTrackCandidatesInOut"),
3526  edm::InputTag("muonSeededTrackCandidatesOutIn")
3527  });
3528  desc.addUntracked<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
3529  desc.addUntracked<std::vector<std::string> >("trackMVAs", std::vector<std::string>{{"generalTracks"}});
3530  desc.addUntracked<edm::InputTag>("trackingParticles", edm::InputTag("mix", "MergedTrackTruth"));
3531  desc.addUntracked<bool>("trackingParticlesRef", false);
3532  desc.addUntracked<edm::InputTag>("clusterTPMap", edm::InputTag("tpClusterProducer"));
3533  desc.addUntracked<edm::InputTag>("simHitTPMap", edm::InputTag("simHitTPAssocProducer"));
3534  desc.addUntracked<edm::InputTag>("trackAssociator", edm::InputTag("quickTrackAssociatorByHits"));
3535  desc.addUntracked<edm::InputTag>("pixelDigiSimLink", edm::InputTag("simSiPixelDigis"));
3536  desc.addUntracked<edm::InputTag>("stripDigiSimLink", edm::InputTag("simSiStripDigis"));
3537  desc.addUntracked<edm::InputTag>("phase2OTSimLink", edm::InputTag(""));
3538  desc.addUntracked<edm::InputTag>("beamSpot", edm::InputTag("offlineBeamSpot"));
3539  desc.addUntracked<edm::InputTag>("pixelRecHits", edm::InputTag("siPixelRecHits"));
3540  desc.addUntracked<edm::InputTag>("stripRphiRecHits", edm::InputTag("siStripMatchedRecHits", "rphiRecHit"));
3541  desc.addUntracked<edm::InputTag>("stripStereoRecHits", edm::InputTag("siStripMatchedRecHits", "stereoRecHit"));
3542  desc.addUntracked<edm::InputTag>("stripMatchedRecHits", edm::InputTag("siStripMatchedRecHits", "matchedRecHit"));
3543  desc.addUntracked<edm::InputTag>("phase2OTRecHits", edm::InputTag("siPhase2RecHits"));
3544  desc.addUntracked<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
3545  desc.addUntracked<edm::InputTag>("trackingVertices", edm::InputTag("mix", "MergedTrackTruth"));
3546  desc.addUntracked<edm::InputTag>("trackingParticleNlayers", edm::InputTag("trackingParticleNumberOfLayersProducer", "trackerLayers"));
3547  desc.addUntracked<edm::InputTag>("trackingParticleNpixellayers", edm::InputTag("trackingParticleNumberOfLayersProducer", "pixelLayers"));
3548  desc.addUntracked<edm::InputTag>("trackingParticleNstripstereolayers", edm::InputTag("trackingParticleNumberOfLayersProducer", "stripStereoLayers"));
3549  desc.addUntracked<std::string>("TTRHBuilder", "WithTrackAngle");
3550  desc.addUntracked<std::string>("parametersDefiner", "LhcParametersDefinerForTP");
3551  desc.addUntracked<bool>("includeSeeds", false);
3552  desc.addUntracked<bool>("includeAllHits", false);
3553  desc.addUntracked<bool>("includeMVA", true);
3554  desc.addUntracked<bool>("includeTrackingParticles", true);
3555  descriptions.add("trackingNtuple",desc);
3556 }
ParameterDescriptionBase * addUntracked(U const &iLabel, T const &value)
void add(std::string const &label, ParameterSetDescription const &psetDescription)
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 2615 of file TrackingNtuple.cc.

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

Referenced by analyze().

2624  {
2626  iEvent.getByToken(phase2OTRecHitToken_, phase2OTHits);
2627  for (auto it = phase2OTHits->begin(); it!=phase2OTHits->end(); it++ ) {
2628  const DetId hitId = it->detId();
2629  for (auto hit = it->begin(); hit!=it->end(); hit++ ) {
2630  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
2631 
2632  hitProductIds.insert(hit->cluster().id());
2633 
2634  const int key = hit->cluster().key();
2635  const int lay = tTopo.layer(hitId);
2636 
2637  ph2_isBarrel .push_back( hitId.subdetId()==1 );
2638  ph2_detId .push_back( tTopo, hitId );
2639  ph2_trkIdx .emplace_back(); // filled in fillTracks
2640  ph2_seeIdx .emplace_back(); // filled in fillSeeds
2641  ph2_x .push_back( ttrh->globalPosition().x() );
2642  ph2_y .push_back( ttrh->globalPosition().y() );
2643  ph2_z .push_back( ttrh->globalPosition().z() );
2644  ph2_xx .push_back( ttrh->globalPositionError().cxx() );
2645  ph2_xy .push_back( ttrh->globalPositionError().cyx() );
2646  ph2_yy .push_back( ttrh->globalPositionError().cyy() );
2647  ph2_yz .push_back( ttrh->globalPositionError().czy() );
2648  ph2_zz .push_back( ttrh->globalPositionError().czz() );
2649  ph2_zx .push_back( ttrh->globalPositionError().czx() );
2650  ph2_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
2651  ph2_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );
2652 
2653  LogTrace("TrackingNtuple") << "phase2 OT cluster=" << key
2654  << " subdId=" << hitId.subdetId()
2655  << " lay=" << lay
2656  << " rawId=" << hitId.rawId()
2657  << " pos =" << ttrh->globalPosition();
2658 
2660  SimHitData simHitData = matchCluster(hit->firstClusterRef(), hitId, key, ttrh,
2661  clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Phase2OT);
2662  ph2_simHitIdx.push_back( simHitData.matchingSimHit );
2663  ph2_simType.push_back( static_cast<int>(simHitData.type) );
2664  LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
2665  if(!simHitData.matchingSimHit.empty()) {
2666  const auto simHitIdx = simHitData.matchingSimHit[0];
2667  LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
2668  << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2669  << " energyLoss=" << simhit_eloss[simHitIdx]
2670  << " particleType=" << simhit_particle[simHitIdx]
2671  << " processType=" << simhit_process[simHitIdx]
2672  << " bunchCrossing=" << simHitData.bunchCrossing[0]
2673  << " event=" << simHitData.event[0];
2674  }
2675  }
2676  }
2677  }
2678 }
std::vector< float > ph2_radL
std::vector< short > ph2_isBarrel
const_iterator end(bool update=false) const
std::vector< std::vector< int > > ph2_seeIdx
std::vector< float > ph2_bbxi
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)
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:50
std::vector< float > ph2_xx
std::vector< std::vector< int > > ph2_trkIdx
edm::EDGetTokenT< Phase2TrackerRecHit1DCollectionNew > phase2OTRecHitToken_
std::vector< short > simhit_process
std::vector< float > ph2_zx
std::vector< float > simhit_z
std::vector< float > ph2_z
std::vector< float > ph2_yy
std::vector< float > ph2_y
std::vector< float > ph2_xy
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:41
std::vector< std::vector< int > > ph2_simHitIdx
DetIdPhase2OT ph2_detId
const bool includeTrackingParticles_
#define LogTrace(id)
std::shared_ptr< TrackingRecHit const > RecHitPointer
virtual RecHitPointer build(const TrackingRecHit *p) const =0
build a tracking rechit from an existing rechit
unsigned int id
Definition: DetId.h:18
std::vector< float > ph2_x
unsigned int layer(const DetId &id) const
std::vector< int > simhit_particle
std::vector< unsigned short > ph2_simType
std::vector< float > ph2_yz
std::vector< float > simhit_y
std::vector< float > simhit_x
std::vector< float > ph2_zz
const_iterator begin(bool update=false) const
std::vector< float > simhit_eloss
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 2408 of file TrackingNtuple.cc.

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

Referenced by analyze().

2417  {
2419  iEvent.getByToken(pixelRecHitToken_, pixelHits);
2420  for (auto it = pixelHits->begin(); it!=pixelHits->end(); it++ ) {
2421  const DetId hitId = it->detId();
2422  for (auto hit = it->begin(); hit!=it->end(); hit++ ) {
2423  TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
2424 
2425  hitProductIds.insert(hit->cluster().id());
2426 
2427  const int key = hit->cluster().key();
2428  const int lay = tTopo.layer(hitId);
2429 
2430  pix_isBarrel .push_back( hitId.subdetId()==1 );
2431  pix_detId .push_back( tTopo, hitId );
2432  pix_trkIdx .emplace_back(); // filled in fillTracks
2433  pix_seeIdx .emplace_back(); // filled in fillSeeds
2434  pix_x .push_back( ttrh->globalPosition().x() );
2435  pix_y .push_back( ttrh->globalPosition().y() );
2436  pix_z .push_back( ttrh->globalPosition().z() );
2437  pix_xx .push_back( ttrh->globalPositionError().cxx() );
2438  pix_xy .push_back( ttrh->globalPositionError().cyx() );
2439  pix_yy .push_back( ttrh->globalPositionError().cyy() );
2440  pix_yz .push_back( ttrh->globalPositionError().czy() );
2441  pix_zz .push_back( ttrh->globalPositionError().czz() );
2442  pix_zx .push_back( ttrh->globalPositionError().czx() );
2443  pix_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
2444  pix_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );
2445 
2446  LogTrace("TrackingNtuple") << "pixHit cluster=" << key
2447  << " subdId=" << hitId.subdetId()
2448  << " lay=" << lay
2449  << " rawId=" << hitId.rawId()
2450  << " pos =" << ttrh->globalPosition();
2452  SimHitData simHitData = matchCluster(hit->firstClusterRef(), hitId, key, ttrh,
2453  clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Pixel);
2454  pix_simHitIdx.push_back( simHitData.matchingSimHit );
2455  pix_simType.push_back( static_cast<int>(simHitData.type) );
2456  pix_chargeFraction.push_back( simHitData.chargeFraction );
2457  LogTrace("TrackingNtuple") << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
2458  if(!simHitData.matchingSimHit.empty()) {
2459  const auto simHitIdx = simHitData.matchingSimHit[0];
2460  LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
2461  << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
2462  << " energyLoss=" << simhit_eloss[simHitIdx]
2463  << " particleType=" << simhit_particle[simHitIdx]
2464  << " processType=" << simhit_process[simHitIdx]
2465  << " bunchCrossing=" << simHitData.bunchCrossing[0]
2466  << " event=" << simHitData.event[0];
2467  }
2468  }
2469  }
2470  }
2471 }
const_iterator end(bool update=false) const
std::vector< float > pix_y
std::vector< float > pix_zz
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)
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
std::vector< unsigned short > pix_simType
std::vector< float > pix_zx
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
constexpr uint32_t rawId() const
get the raw id
Definition: DetId.h:50
DetIdPixel pix_detId
std::vector< short > simhit_process
std::vector< float > pix_xx
std::vector< float > pix_radL
std::vector< float > pix_bbxi
std::vector< std::vector< int > > pix_seeIdx
std::vector< float > simhit_z
edm::EDGetTokenT< SiPixelRecHitCollection > pixelRecHitToken_
std::vector< short > pix_isBarrel
std::vector< float > pix_z
std::vector< float > pix_yz
constexpr int subdetId() const
get the contents of the subdetector field (not cast into any detector&#39;s numbering enum) ...
Definition: DetId.h:41
std::vector< std::vector< float > > pix_chargeFraction
std::vector< std::vector< int > > pix_trkIdx
const bool includeTrackingParticles_
#define LogTrace(id)
std::shared_ptr< TrackingRecHit const > RecHitPointer
virtual RecHitPointer build(const TrackingRecHit *p) const =0
build a tracking rechit from an existing rechit
unsigned int id
Definition: DetId.h:18
std::vector< std::vector< int > > pix_simHitIdx
std::vector< float > pix_x
unsigned int layer(const DetId &id) const
std::vector< int > simhit_particle
std::vector< float > simhit_y
std::vector< float > simhit_x
std::vector< float > pix_xy
std::vector< float > pix_yy
const_iterator begin(bool update=false) const
std::vector< float > simhit_eloss
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 2681 of file TrackingNtuple.cc.

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

Referenced by analyze().

2693  {
2694  TSCBLBuilderNoMaterial tscblBuilder;
2695  for(size_t iColl=0; iColl < seedTokens_.size(); ++iColl) {
2696  const auto& seedToken = seedTokens_[iColl];
2697 
2698  edm::Handle<edm::View<reco::Track> > seedTracksHandle;
2699  iEvent.getByToken(seedToken, seedTracksHandle);
2700  const auto& seedTracks = *seedTracksHandle;
2701 
2702  if(seedTracks.empty())
2703  continue;
2704 
2706  labelsForToken(seedToken, labels);
2707 
2708  const auto& seedStopInfoToken = seedStopInfoTokens_[iColl];
2709  edm::Handle<std::vector<SeedStopInfo> > seedStopInfoHandle;
2710  iEvent.getByToken(seedStopInfoToken, seedStopInfoHandle);
2711  const auto& seedStopInfos = *seedStopInfoHandle;
2712  if(seedTracks.size() != seedStopInfos.size()) {
2714  labelsForToken(seedStopInfoToken, labels2);
2715 
2716  throw cms::Exception("LogicError") << "Got " << seedTracks.size() << " seeds, but " << seedStopInfos.size() << " seed stopping infos for collections " << labels.module << ", " << labels2.module;
2717  }
2718 
2719  // The associator interfaces really need to be fixed...
2720  edm::RefToBaseVector<reco::Track> seedTrackRefs;
2721  for(edm::View<reco::Track>::size_type i=0; i<seedTracks.size(); ++i) {
2722  seedTrackRefs.push_back(seedTracks.refAt(i));
2723  }
2724  reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(seedTrackRefs, tpCollection);
2725  reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(seedTrackRefs, tpCollection);
2726 
2727  TString label = labels.module;
2728  //format label to match algoName
2729  label.ReplaceAll("seedTracks", "");
2730  label.ReplaceAll("Seeds","");
2731  label.ReplaceAll("muonSeeded","muonSeededStep");
2732  int algo = reco::TrackBase::algoByName(label.Data());
2733 
2734  edm::ProductID id = seedTracks[0].seedRef().id();
2735  const auto offset = see_fitok.size();
2736  auto inserted = seedCollToOffset.emplace(id, offset);
2737  if(!inserted.second)
2738  throw cms::Exception("Configuration") << "Trying to add seeds with ProductID " << id << " for a second time from collection " << labels.module << ", seed algo " << label << ". Typically this is caused by a configuration problem.";
2739  see_offset.push_back(offset);
2740 
2741  LogTrace("TrackingNtuple") << "NEW SEED LABEL: " << label << " size: " << seedTracks.size() << " algo=" << algo
2742  << " ProductID " << id;
2743 
2744  for(size_t iSeed=0; iSeed < seedTrackRefs.size(); ++iSeed) {
2745  const auto& seedTrackRef = seedTrackRefs[iSeed];
2746  const auto& seedTrack = *seedTrackRef;
2747  const auto& seedRef = seedTrack.seedRef();
2748  const auto& seed = *seedRef;
2749 
2750  const auto seedStopInfo = seedStopInfos[iSeed];
2751 
2752  if(seedRef.id() != id)
2753  throw cms::Exception("LogicError") << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the element 0 had ProductID " << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id() << ". The source collection is " << labels.module << ".";
2754 
2755  std::vector<int> tpIdx;
2756  std::vector<float> sharedFraction;
2757  auto foundTPs = recSimColl.find(seedTrackRef);
2758  if (foundTPs != recSimColl.end()) {
2759  for(const auto tpQuality: foundTPs->val) {
2760  tpIdx.push_back( tpKeyToIndex.at( tpQuality.first.key() ) );
2761  sharedFraction.push_back(tpQuality.second);
2762  }
2763  }
2764 
2765  // Search for a best-matching TrackingParticle for a seed
2766  const int nHits = seedTrack.numberOfValidHits();
2767  const auto clusters = track_associator::hitsToClusterRefs(seedTrack.recHitsBegin(), seedTrack.recHitsEnd()); // TODO: this function is called 3 times per track, try to reduce
2768  const int nClusters = clusters.size();
2769  const auto bestKeyCount = findBestMatchingTrackingParticle(seedTrack, clusterToTPMap, tpKeyToIndex);
2770  const float bestShareFrac = nClusters > 0 ? static_cast<float>(bestKeyCount.countClusters)/static_cast<float>(nClusters): 0;
2771  // Another way starting from the first hit of the seed
2772  const auto bestFirstHitKeyCount = findMatchingTrackingParticleFromFirstHit(seedTrack, clusterToTPMap, tpKeyToIndex);
2773  const float bestFirstHitShareFrac = nClusters > 0 ? static_cast<float>(bestFirstHitKeyCount.countClusters)/static_cast<float>(nClusters) : 0;
2774 
2775  const bool seedFitOk = !trackFromSeedFitFailed(seedTrack);
2776  const int charge = seedTrack.charge();
2777  const float pt = seedFitOk ? seedTrack.pt() : 0;
2778  const float eta = seedFitOk ? seedTrack.eta() : 0;
2779  const float phi = seedFitOk ? seedTrack.phi() : 0;
2780 
2781  const auto seedIndex = see_fitok.size();
2782 
2783  see_fitok .push_back(seedFitOk);
2784 
2785  see_px .push_back( seedFitOk ? seedTrack.px() : 0 );
2786  see_py .push_back( seedFitOk ? seedTrack.py() : 0 );
2787  see_pz .push_back( seedFitOk ? seedTrack.pz() : 0 );
2788  see_pt .push_back( pt );
2789  see_eta .push_back( eta );
2790  see_phi .push_back( phi );
2791  see_q .push_back( charge );
2792  see_nValid .push_back( nHits );
2793 
2794  see_dxy .push_back( seedFitOk ? seedTrack.dxy(bs.position()) : 0);
2795  see_dz .push_back( seedFitOk ? seedTrack.dz(bs.position()) : 0);
2796  see_ptErr .push_back( seedFitOk ? seedTrack.ptError() : 0);
2797  see_etaErr .push_back( seedFitOk ? seedTrack.etaError() : 0);
2798  see_phiErr .push_back( seedFitOk ? seedTrack.phiError() : 0);
2799  see_dxyErr .push_back( seedFitOk ? seedTrack.dxyError() : 0);
2800  see_dzErr .push_back( seedFitOk ? seedTrack.dzError() : 0);
2801  see_algo .push_back( algo );
2802  see_stopReason.push_back( seedStopInfo.stopReasonUC() );
2803  see_nCands .push_back( seedStopInfo.candidatesPerSeed() );
2804 
2805  const auto& state = seedTrack.seedRef()->startingState();
2806  const auto& pos = state.parameters().position();
2807  const auto& mom = state.parameters().momentum();
2808  see_statePt.push_back(state.pt());
2809  see_stateTrajX.push_back(pos.x());
2810  see_stateTrajY.push_back(pos.y());
2811  see_stateTrajPx.push_back(mom.x());
2812  see_stateTrajPy.push_back(mom.y());
2813  see_stateTrajPz.push_back(mom.z());
2814 
2815  see_trkIdx .push_back(-1); // to be set correctly in fillTracks
2817  see_simTrkIdx.push_back( tpIdx );
2818  see_simTrkShareFrac.push_back( sharedFraction );
2819  see_bestSimTrkIdx.push_back(bestKeyCount.key >= 0 ? tpKeyToIndex.at(bestKeyCount.key) : -1);
2820  see_bestFromFirstHitSimTrkIdx.push_back(bestFirstHitKeyCount.key >= 0 ? tpKeyToIndex.at(bestFirstHitKeyCount.key) : -1);
2821  }
2822  else {
2823  see_isTrue.push_back(!tpIdx.empty());
2824  }
2825  see_bestSimTrkShareFrac.push_back(bestShareFrac);
2826  see_bestFromFirstHitSimTrkShareFrac.push_back(bestFirstHitShareFrac);
2827 
2829  /*
2830  TransientTrackingRecHit::RecHitPointer lastRecHit = theTTRHBuilder.build(&*(seed.recHits().second-1));
2831  TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( itSeed->startingState(), lastRecHit->surface(), &theMF);
2832  float pt = state.globalParameters().momentum().perp();
2833  float eta = state.globalParameters().momentum().eta();
2834  float phi = state.globalParameters().momentum().phi();
2835  see_px .push_back( state.globalParameters().momentum().x() );
2836  see_py .push_back( state.globalParameters().momentum().y() );
2837  see_pz .push_back( state.globalParameters().momentum().z() );
2838  */
2839 
2840  std::vector<int> hitIdx;
2841  std::vector<int> hitType;
2842 
2843  for (auto hit=seed.recHits().first; hit!=seed.recHits().second; ++hit) {
2845  int subid = recHit->geographicalId().subdetId();
2846  if (subid == (int) PixelSubdetector::PixelBarrel || subid == (int) PixelSubdetector::PixelEndcap) {
2847  const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
2848  const auto& clusterRef = bhit->firstClusterRef();
2849  const auto clusterKey = clusterRef.cluster_pixel().key();
2850  if(includeAllHits_) {
2851  checkProductID(hitProductIds, clusterRef.id(), "seed");
2852  pix_seeIdx[clusterKey].push_back(seedIndex);
2853  }
2854  hitIdx.push_back( clusterKey );
2855  hitType.push_back( static_cast<int>(HitType::Pixel) );
2856  } else if (subid == (int) StripSubdetector::TOB || subid == (int) StripSubdetector::TID ||
2857  subid == (int) StripSubdetector::TIB || subid == (int) StripSubdetector::TEC) {
2858  if (trackerHitRTTI::isMatched(*recHit)) {
2859  const SiStripMatchedRecHit2D * matchedHit = dynamic_cast<const SiStripMatchedRecHit2D *>(&*recHit);
2860  if(includeAllHits_) {
2861  checkProductID(hitProductIds, matchedHit->monoClusterRef().id(), "seed");
2862  checkProductID(hitProductIds, matchedHit->stereoClusterRef().id(), "seed");
2863  }
2864  int monoIdx = matchedHit->monoClusterRef().key();
2865  int stereoIdx = matchedHit->stereoClusterRef().key();
2866 
2867  std::vector<std::pair<int,int> >::iterator pos = find( monoStereoClusterList.begin(), monoStereoClusterList.end(), std::make_pair(monoIdx,stereoIdx) );
2868  size_t gluedIndex = -1;
2869  if(pos != monoStereoClusterList.end()) {
2870  gluedIndex = std::distance(monoStereoClusterList.begin(), pos);
2871  }
2872  else {
2873  // We can encounter glued hits not in the input
2874  // SiStripMatchedRecHit2DCollection, e.g. via muon
2875  // outside-in seeds (or anything taking hits from
2876  // MeasurementTrackerEvent). So let's add them here.
2877  gluedIndex = addStripMatchedHit(*matchedHit, theTTRHBuilder, tTopo, monoStereoClusterList);
2878  }
2879 
2880  if(includeAllHits_) glu_seeIdx[gluedIndex].push_back(seedIndex);
2881  hitIdx.push_back( gluedIndex );
2882  hitType.push_back( static_cast<int>(HitType::Glued) );
2883  } else {
2884  const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
2885  const auto& clusterRef = bhit->firstClusterRef();
2886  unsigned int clusterKey;
2887  if(clusterRef.isPhase2()){
2888  clusterKey = clusterRef.cluster_phase2OT().key();
2889  } else {
2890  clusterKey = clusterRef.cluster_strip().key();
2891  }
2892 
2893  if(includeAllHits_) {
2894  checkProductID(hitProductIds, clusterRef.id(), "seed");
2895  if(clusterRef.isPhase2()){
2896  ph2_seeIdx[clusterKey].push_back(seedIndex);
2897  } else {
2898  str_seeIdx[clusterKey].push_back(seedIndex);
2899  }
2900  }
2901 
2902  hitIdx.push_back( clusterKey );
2903  if(clusterRef.isPhase2()){
2904  hitType.push_back( static_cast<int>(HitType::Phase2OT) );
2905  } else {
2906  hitType.push_back( static_cast<int>(HitType::Strip) );
2907  }
2908  }
2909  } else {
2910  LogTrace("TrackingNtuple") << " not pixel and not Strip detector";
2911  }
2912  }
2913  see_hitIdx .push_back( hitIdx );
2914  see_hitType .push_back( hitType );
2915  see_nPixel .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Pixel)) );
2916  see_nGlued .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Glued)) );
2917  see_nStrip .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Strip)) );
2918  see_nPhase2OT.push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Phase2OT)) );
2919  see_nCluster .push_back( nClusters );
2920  //the part below is not strictly needed
2921  float chi2 = -1;
2922  if (nHits==2) {
2923  TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
2924  TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
2925  std::vector<GlobalPoint> gp(2);
2926  std::vector<GlobalError> ge(2);
2927  gp[0] = recHit0->globalPosition();
2928  ge[0] = recHit0->globalPositionError();
2929  gp[1] = recHit1->globalPosition();
2930  ge[1] = recHit1->globalPositionError();
2931  LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
2932  << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
2933  << " - PAIR - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
2934  << " hitpos: " << gp[0] << " " << gp[1]
2935  << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
2936  << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
2937  << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
2938  << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
2939  << " eta,phi: " << gp[0].eta() << "," << gp[0].phi();
2940  } else if (nHits==3) {
2941  TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
2942  TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
2943  TransientTrackingRecHit::RecHitPointer recHit2 = theTTRHBuilder.build(&*(seed.recHits().first+2));
2946  declareDynArray(bool,4, bl);
2947  gp[0] = recHit0->globalPosition();
2948  ge[0] = recHit0->globalPositionError();
2949  int subid0 = recHit0->geographicalId().subdetId();
2950  bl[0] = (subid0 == StripSubdetector::TIB || subid0 == StripSubdetector::TOB || subid0 == (int) PixelSubdetector::PixelBarrel);
2951  gp[1] = recHit1->globalPosition();
2952  ge[1] = recHit1->globalPositionError();
2953  int subid1 = recHit1->geographicalId().subdetId();
2954  bl[1] = (subid1 == StripSubdetector::TIB || subid1 == StripSubdetector::TOB || subid1 == (int) PixelSubdetector::PixelBarrel);
2955  gp[2] = recHit2->globalPosition();
2956  ge[2] = recHit2->globalPositionError();
2957  int subid2 = recHit2->geographicalId().subdetId();
2958  bl[2] = (subid2 == StripSubdetector::TIB || subid2 == StripSubdetector::TOB || subid2 == (int) PixelSubdetector::PixelBarrel);
2959  RZLine rzLine(gp,ge,bl);
2960  float seed_chi2 = rzLine.chi2();
2961  //float seed_pt = state.globalParameters().momentum().perp();
2962  float seed_pt = pt;
2963  LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
2964  << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
2965  << " - TRIPLET - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId() << " " << recHit2->geographicalId().rawId()
2966  << " hitpos: " << gp[0] << " " << gp[1] << " " << gp[2]
2967  << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
2968  << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
2969  << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
2970  << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
2971  << " trans2: " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
2972  << " " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
2973  << " local: " << recHit2->localPosition()
2974  //<< " tsos pos, mom: " << state.globalPosition()<<" "<<state.globalMomentum()
2975  << " eta,phi: " << gp[0].eta() << "," << gp[0].phi()
2976  << " pt,chi2: " << seed_pt << "," << seed_chi2;
2977  chi2 = seed_chi2;
2978  }
2979  see_chi2 .push_back( chi2 );
2980  }
2981 
2982  fillTrackingParticlesForSeeds(tpCollection, simRecColl, tpKeyToIndex, offset);
2983  }
2984 }
reco::SimToRecoCollection associateSimToReco(const edm::Handle< edm::View< reco::Track >> &tCH, const edm::Handle< TrackingParticleCollection > &tPCH) const
unsigned int size_type
Definition: View.h:90
std::vector< float > see_bestSimTrkShareFrac
std::vector< std::vector< float > > see_simTrkShareFrac
std::vector< short > see_fitok
Phase2Cluster1DRef cluster_phase2OT() const
std::vector< std::vector< int > > see_hitType
std::vector< float > see_stateTrajX
std::vector< std::vector< int > > ph2_seeIdx
std::vector< float > see_stateTrajPy
std::vector< unsigned int > see_nValid
bool trackFromSeedFitFailed(const reco::Track &track)
std::vector< float > see_phiErr
const_iterator end() const
last iterator over the map (read only)
std::vector< float > see_dzErr
bool getByToken(EDGetToken token, Handle< PROD > &result) const
Definition: Event.h:517
std::vector< unsigned int > see_nStrip
std::vector< float > see_stateTrajPz
OmniClusterRef const & stereoClusterRef() const
std::vector< float > see_px
std::vector< float > see_chi2
const_iterator find(const key_type &k) const
find element with specified reference key
std::vector< float > see_stateTrajY
size_t addStripMatchedHit(const SiStripMatchedRecHit2D &hit, const TransientTrackingRecHitBuilder &theTTRHBuilder, const TrackerTopology &tTopo, std::vector< std::pair< int, int > > &monoStereoClusterList)
Global3DPoint GlobalPoint
Definition: GlobalPoint.h:10
std::vector< unsigned short > see_stopReason
std::vector< OmniClusterRef > hitsToClusterRefs(iter begin, iter end)
std::vector< unsigned int > see_algo
std::vector< std::vector< int > > str_seeIdx
std::vector< std::vector< int > > see_simTrkIdx
key_type key() const
Accessor for product key.
Definition: Ref.h:263
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:20
std::vector< std::vector< int > > pix_seeIdx
ClusterPixelRef cluster_pixel() const
std::vector< short > see_isTrue
std::vector< float > see_etaErr
char const * label
std::vector< int > see_bestSimTrkIdx
std::vector< unsigned int > see_nCluster
void fillTrackingParticlesForSeeds(const TrackingParticleRefVector &tpCollection, const reco::SimToRecoCollection &simRecColl, const TrackingParticleRefKeyToIndex &tpKeyToIndex, const unsigned int seedOffset)
std::vector< int > see_bestFromFirstHitSimTrkIdx
std::vector< int > see_q
std::vector< edm::EDGetTokenT< edm::View< reco::Track > > > seedTokens_
std::vector< float > see_dxyErr
bool isMatched(TrackingRecHit const &hit)
std::vector< float > see_pt
std::vector< unsigned int > see_nPhase2OT
std::vector< std::vector< int > > glu_seeIdx
std::vector< float > see_dxy
const bool includeTrackingParticles_
size_type size() const
std::vector< float > see_phi
OmniClusterRef const & monoClusterRef() const
char const * module
Definition: ProductLabels.h:5