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

Inheritance diagram for TrackingNtuple:

Classes
struct	SimHitData

struct	TPHitIndex

Public Member Functions
	TrackingNtuple (const edm::ParameterSet &)

	~TrackingNtuple ()

Public Member Functions inherited from edm::one::EDAnalyzer< edm::one::SharedResources >
	EDAnalyzer ()=default

Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector < ProductResolverIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)

Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
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::Unknown = 99 }

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

typedef std::map < SimHitFullKey, size_t >	SimHitRefKeyToIndex

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

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

typedef TrackingParticleRefKeyToIndex	TrackingVertexRefKeyToIndex

Private Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &) override

void	clearVariables ()

void	fillBeamSpot (const reco::BeamSpot &bs)

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

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

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

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

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

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

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

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

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

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

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

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

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamSpotToken_

float	bsp_sigmax

float	bsp_sigmay

float	bsp_sigmaz

float	bsp_x

float	bsp_y

float	bsp_z

std::string	builderName_

edm::EDGetTokenT < ClusterTPAssociation >	clusterTPMapToken_

edm::EventNumber_t	ev_event

edm::LuminosityBlockNumber_t	ev_lumi

edm::RunNumber_t	ev_run

std::vector< float >	glu_bbxi

std::vector< unsigned int >	glu_det

std::vector< unsigned int >	glu_detId

std::vector< short >	glu_isBarrel

std::vector< unsigned int >	glu_lay

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	includeSeeds_

std::vector< unsigned short >	inv_det

std::vector< unsigned int >	inv_detId

std::vector< short >	inv_isBarrel

std::vector< unsigned short >	inv_lay

std::vector< unsigned short >	inv_type

std::string	parametersDefinerName_

std::vector< float >	pix_bbxi

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

std::vector< unsigned short >	pix_det

std::vector< unsigned int >	pix_detId

std::vector< short >	pix_isBarrel

std::vector< unsigned short >	pix_lay

std::vector< float >	pix_radL

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

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

std::vector< unsigned short >	pix_simType

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

std::vector< float >	pix_x

std::vector< float >	pix_xx

std::vector< float >	pix_xy

std::vector< float >	pix_y

std::vector< float >	pix_yy

std::vector< float >	pix_yz

std::vector< float >	pix_z

std::vector< float >	pix_zx

std::vector< float >	pix_zz

edm::EDGetTokenT < SiPixelRecHitCollection >	pixelRecHitToken_

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

std::vector< unsigned int >	see_algo

std::vector< float >	see_chi2

std::vector< float >	see_dxy

std::vector< float >	see_dxyErr

std::vector< float >	see_dz

std::vector< float >	see_dzErr

std::vector< float >	see_eta

std::vector< float >	see_etaErr

std::vector< short >	see_fitok

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

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

std::vector< unsigned int >	see_nGlued

std::vector< unsigned int >	see_nPixel

std::vector< unsigned int >	see_nStrip

std::vector< unsigned int >	see_nValid

std::vector< unsigned int >	see_offset

std::vector< float >	see_phi

std::vector< float >	see_phiErr

std::vector< float >	see_pt

std::vector< float >	see_ptErr

std::vector< float >	see_px

std::vector< float >	see_py

std::vector< float >	see_pz

std::vector< int >	see_q

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

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

std::vector< int >	see_trkIdx

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< unsigned int >	sim_n3DLay

std::vector< unsigned int >	sim_nLay

std::vector< unsigned int >	sim_nPixel

std::vector< unsigned int >	sim_nPixelLay

std::vector< unsigned int >	sim_nStrip

std::vector< unsigned int >	sim_nValid

std::vector< int >	sim_parentVtxIdx

std::vector< float >	sim_pca_cotTheta

std::vector< float >	sim_pca_dxy

std::vector< float >	sim_pca_dz

std::vector< float >	sim_pca_eta

std::vector< float >	sim_pca_lambda

std::vector< float >	sim_pca_phi

std::vector< float >	sim_pca_pt

std::vector< int >	sim_pdgId

std::vector< float >	sim_phi

std::vector< float >	sim_pt

std::vector< float >	sim_px

std::vector< float >	sim_py

std::vector< float >	sim_pz

std::vector< int >	sim_q

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

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

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

std::vector< unsigned short >	simhit_det

std::vector< unsigned int >	simhit_detId

std::vector< float >	simhit_eloss

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

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

std::vector< unsigned short >	simhit_lay

std::vector< int >	simhit_particle

std::vector< short >	simhit_process

std::vector< int >	simhit_simTrkIdx

std::vector< float >	simhit_tof

std::vector< float >	simhit_x

std::vector< float >	simhit_y

std::vector< float >	simhit_z

edm::EDGetTokenT < SimHitTPAssociationProducer::SimHitTPAssociationList >	simHitTPMapToken_

std::vector< int >	simpv_idx

std::vector< int >	simvtx_bunchCrossing

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

std::vector< int >	simvtx_event

std::vector< unsigned int >	simvtx_processType

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

std::vector< float >	simvtx_x

std::vector< float >	simvtx_y

std::vector< float >	simvtx_z

std::vector< float >	str_bbxi

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

std::vector< unsigned short >	str_det

std::vector< unsigned int >	str_detId

std::vector< short >	str_isBarrel

std::vector< short >	str_isStereo

std::vector< unsigned short >	str_lay

std::vector< float >	str_radL

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

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

std::vector< unsigned short >	str_simType

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

std::vector< float >	str_x

std::vector< float >	str_xx

std::vector< float >	str_xy

std::vector< float >	str_y

std::vector< float >	str_yy

std::vector< float >	str_yz

std::vector< float >	str_z

std::vector< float >	str_zx

std::vector< float >	str_zz

edm::EDGetTokenT < SiStripMatchedRecHit2DCollection >	stripMatchedRecHitToken_

edm::EDGetTokenT < SiStripRecHit2DCollection >	stripRphiRecHitToken_

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

edm::EDGetTokenT < SiStripRecHit2DCollection >	stripStereoRecHitToken_

TTree *	t

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

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

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

edm::EDGetTokenT < reco::TrackToTrackingParticleAssociator >	trackAssociatorToken_

edm::EDGetTokenT < TrackingParticleRefVector >	trackingParticleRefToken_

edm::EDGetTokenT < TrackingParticleCollection >	trackingParticleToken_

edm::EDGetTokenT < TrackingVertexCollection >	trackingVertexToken_

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

std::vector< unsigned int >	trk_algo

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

std::vector< float >	trk_cotTheta

std::vector< float >	trk_dxy

std::vector< float >	trk_dxyErr

std::vector< float >	trk_dz

std::vector< float >	trk_dzErr

std::vector< float >	trk_eta

std::vector< float >	trk_etaErr

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

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

std::vector< float >	trk_inner_pt

std::vector< float >	trk_inner_px

std::vector< float >	trk_inner_py

std::vector< float >	trk_inner_pz

std::vector< short >	trk_isHP

std::vector< float >	trk_lambda

std::vector< float >	trk_lambdaErr

std::vector< unsigned int >	trk_n3DLay

std::vector< float >	trk_nChi2

std::vector< unsigned int >	trk_nInnerLost

std::vector< unsigned int >	trk_nInvalid

std::vector< unsigned int >	trk_nOuterLost

std::vector< unsigned int >	trk_nPixel

std::vector< unsigned int >	trk_nPixelLay

std::vector< unsigned int >	trk_nStrip

std::vector< unsigned int >	trk_nStripLay

std::vector< unsigned int >	trk_nValid

std::vector< unsigned int >	trk_originalAlgo

std::vector< float >	trk_outer_pt

std::vector< float >	trk_outer_px

std::vector< float >	trk_outer_py

std::vector< float >	trk_outer_pz

std::vector< float >	trk_phi

std::vector< float >	trk_phiErr

std::vector< float >	trk_pt

std::vector< float >	trk_ptErr

std::vector< float >	trk_px

std::vector< float >	trk_py

std::vector< float >	trk_pz

std::vector< int >	trk_q

std::vector< float >	trk_refpoint_x

std::vector< float >	trk_refpoint_y

std::vector< float >	trk_refpoint_z

std::vector< int >	trk_seedIdx

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

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

std::vector< unsigned int >	trk_stopReason

std::vector< int >	trk_vtxIdx

edm::EDGetTokenT < reco::VertexCollection >	vertexToken_

std::vector< float >	vtx_chi2

std::vector< short >	vtx_fake

std::vector< float >	vtx_ndof

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

std::vector< short >	vtx_valid

std::vector< float >	vtx_x

std::vector< float >	vtx_xErr

std::vector< float >	vtx_y

std::vector< float >	vtx_yErr

std::vector< float >	vtx_z

std::vector< float >	vtx_zErr

Additional Inherited Members
Public Types inherited from edm::one::EDAnalyzerBase
typedef EDAnalyzerBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Description: [one line class summary]

Implementation: [Notes on implementation]

Definition at line 246 of file TrackingNtuple.cc.

Member Typedef Documentation

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

private

Definition at line 264 of file TrackingNtuple.cc.

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

private

Definition at line 265 of file TrackingNtuple.cc.

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

private

Definition at line 261 of file TrackingNtuple.cc.

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

private

Definition at line 262 of file TrackingNtuple.cc.

typedef TrackingParticleRefKeyToIndex TrackingNtuple::TrackingVertexRefKeyToIndex

private

Definition at line 263 of file TrackingNtuple.cc.

Member Enumeration Documentation

enum TrackingNtuple::HitSimType

strongprivate

Enumerator
Signal
ITPileup
OOTPileup
Noise
Unknown

Definition at line 279 of file TrackingNtuple.cc.

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

enum TrackingNtuple::HitType

strongprivate

Enumerator
Pixel
Strip
Glued
Invalid
Unknown

Definition at line 267 of file TrackingNtuple.cc.

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

Constructor & Destructor Documentation

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

explicit

Definition at line 681 of file TrackingNtuple.cc.

References GlobalPosition_Frontier_DevDB_cff::tag.

                                                             :
   seedTokens_(edm::vector_transform(iConfig.getUntrackedParameter<std::vector<edm::InputTag> >("seedTracks"), [&](const edm::InputTag& tag) {
         return consumes<edm::View<reco::Track> >(tag);
       })),

TrackingNtuple::~TrackingNtuple ( )

Definition at line 970 of file TrackingNtuple.cc.

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

Member Function Documentation

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

overrideprivatevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 1210 of file TrackingNtuple.cc.

References beamSpotToken_, builderName_, EncodedEventId::bunchCrossing(), clearVariables(), clusterTPMapToken_, ev_event, ev_lumi, ev_run, edm::EventID::event(), TrackingVertex::eventId(), fillBeamSpot(), fillPixelHits(), fillSeeds(), fillSimHits(), fillStripMatchedHits(), fillStripRphiStereoHits(), fillTrackingParticles(), fillTrackingVertices(), fillTracks(), fillVertices(), edm::EventSetup::get(), edm::Event::getByToken(), i, edm::EventBase::id(), includeAllHits_, includeSeeds_, edm::EDGetTokenT< T >::isUninitialized(), LogDebug, edm::EventID::luminosityBlock(), pixelSimLinkToken_, edm::RefToBaseVector< T >::push_back(), dt_dqm_sourceclient_common_cff::reco, edm::EventID::run(), simHitTPMapToken_, findQualityFiles::size, stripSimLinkToken_, t, tpHitIndexListLessSort(), trackAssociatorToken_, patCandidatesForDimuonsSequences_cff::tracker, trackingParticleRefToken_, trackingParticleToken_, trackingVertexToken_, testEve_cfg::tracks, trackToken_, findQualityFiles::v, vertexToken_, and HLT_25ns10e33_v2_cff::vertices.

                                                                                 {
 
   using namespace edm;
   using namespace reco;
   using namespace std;
 
   edm::ESHandle<MagneticField> theMF;
   iSetup.get<IdealMagneticFieldRecord>().get(theMF);
 
   edm::ESHandle<TransientTrackingRecHitBuilder> theTTRHBuilder;
   iSetup.get<TransientRecHitRecord>().get(builderName_,theTTRHBuilder);
 
   edm::ESHandle<TrackerTopology> tTopoHandle;
   iSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
   const TrackerTopology& tTopo = *tTopoHandle;
 
   edm::ESHandle<TrackerGeometry> geometryHandle;
   iSetup.get<TrackerDigiGeometryRecord>().get(geometryHandle);
   const TrackerGeometry &tracker = *geometryHandle;
 
   edm::Handle<reco::TrackToTrackingParticleAssociator> theAssociator;
   iEvent.getByToken(trackAssociatorToken_, theAssociator);
   const reco::TrackToTrackingParticleAssociator& associatorByHits = *theAssociator;
 
   LogDebug("TrackingNtuple") << "Analyzing new event";
 
   //initialize tree variables
   clearVariables();
 
   // FIXME: we really need to move to edm::View for reading the
   // TrackingParticles... Unfortunately it has non-trivial
   // consequences on the associator/association interfaces etc.
   TrackingParticleRefVector tmpTP;
   TrackingParticleRefKeySet tmpTPkeys;
   const TrackingParticleRefVector *tmpTPptr = nullptr;
   edm::Handle<TrackingParticleCollection>  TPCollectionH;
   edm::Handle<TrackingParticleRefVector>  TPCollectionHRefVector;
 
   if(!trackingParticleToken_.isUninitialized()) {
     iEvent.getByToken(trackingParticleToken_, TPCollectionH);
     for(size_t i=0, size=TPCollectionH->size(); i<size; ++i) {
       tmpTP.push_back(TrackingParticleRef(TPCollectionH, i));
     }
     tmpTPptr = &tmpTP;
   }
   else {
     iEvent.getByToken(trackingParticleRefToken_, TPCollectionHRefVector);
     tmpTPptr = TPCollectionHRefVector.product();
     for(const auto& ref: *tmpTPptr) {
       tmpTPkeys.insert(ref.key());
     }
   }
   const TrackingParticleRefVector& tpCollection = *tmpTPptr;
 
   // Fill mapping from Ref::key() to index
   TrackingParticleRefKeyToIndex tpKeyToIndex;
   for(size_t i=0; i<tpCollection.size(); ++i) {
     tpKeyToIndex[tpCollection[i].key()] = i;
   }
 
   // tracking vertices
   edm::Handle<TrackingVertexCollection> htv;
   iEvent.getByToken(trackingVertexToken_, htv);
   const TrackingVertexCollection& tvs = *htv;
 
   // Fill mapping from Ref::key() to index
   TrackingVertexRefVector tvRefs;
   TrackingVertexRefKeyToIndex tvKeyToIndex;
   for(size_t i=0; i<tvs.size(); ++i) {
     const TrackingVertex& v = tvs[i];
     if(v.eventId().bunchCrossing() != 0) // Ignore OOTPU; would be better to not to hardcode?
       continue;
     tvKeyToIndex[i] = tvRefs.size();
     tvRefs.push_back(TrackingVertexRef(htv, i));
   }
 
   //get association maps, etc.
   Handle<ClusterTPAssociation> pCluster2TPListH;
   iEvent.getByToken(clusterTPMapToken_, pCluster2TPListH);
   const ClusterTPAssociation& clusterToTPMap = *pCluster2TPListH;
   edm::Handle<SimHitTPAssociationProducer::SimHitTPAssociationList> simHitsTPAssoc;
   iEvent.getByToken(simHitTPMapToken_, simHitsTPAssoc);
 
   // SimHit key -> index mapping
   SimHitRefKeyToIndex simHitRefKeyToIndex;
 
   //make a list to link TrackingParticles to its simhits
   std::vector<TPHitIndex> tpHitList;
 
   std::set<edm::ProductID> hitProductIds;
   std::map<edm::ProductID, size_t> seedCollToOffset;
 
   ev_run = iEvent.id().run();
   ev_lumi = iEvent.id().luminosityBlock();
   ev_event = iEvent.id().event();
 
   // Digi->Sim links for pixels and strips
   edm::Handle<edm::DetSetVector<PixelDigiSimLink> > pixelDigiSimLinksHandle;
   iEvent.getByToken(pixelSimLinkToken_, pixelDigiSimLinksHandle);
   const auto& pixelDigiSimLinks = *pixelDigiSimLinksHandle;
 
   edm::Handle<edm::DetSetVector<StripDigiSimLink> > stripDigiSimLinksHandle;
   iEvent.getByToken(stripSimLinkToken_, stripDigiSimLinksHandle);
   const auto& stripDigiSimLinks = *stripDigiSimLinksHandle;
 
   //beamspot
   Handle<reco::BeamSpot> recoBeamSpotHandle;
   iEvent.getByToken(beamSpotToken_, recoBeamSpotHandle);
   BeamSpot const & bs = *recoBeamSpotHandle;
   fillBeamSpot(bs);
 
   //prapare list to link matched hits to collection
   vector<pair<int,int> > monoStereoClusterList;
   if(includeAllHits_) {
     // simhits
     fillSimHits(tracker, tpKeyToIndex, *simHitsTPAssoc, tTopo, simHitRefKeyToIndex, tpHitList);
 
     //pixel hits
     fillPixelHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, pixelDigiSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);
 
     //strip hits
     fillStripRphiStereoHits(iEvent, clusterToTPMap, tpKeyToIndex, *simHitsTPAssoc, stripDigiSimLinks, *theTTRHBuilder, tTopo, simHitRefKeyToIndex, hitProductIds);
 
     //matched hits
     fillStripMatchedHits(iEvent, *theTTRHBuilder, tTopo, monoStereoClusterList);
   }
 
   //seeds
   if(includeSeeds_) {
     fillSeeds(iEvent, tpCollection, tpKeyToIndex, bs, associatorByHits, *theTTRHBuilder, theMF.product(), monoStereoClusterList, hitProductIds, seedCollToOffset);
   }
 
   //tracks
   edm::Handle<edm::View<reco::Track> > tracksHandle;
   iEvent.getByToken(trackToken_, tracksHandle);
   const edm::View<reco::Track>& tracks = *tracksHandle;
   // The associator interfaces really need to be fixed...
   edm::RefToBaseVector<reco::Track> trackRefs;
   for(edm::View<Track>::size_type i=0; i<tracks.size(); ++i) {
     trackRefs.push_back(tracks.refAt(i));
   }
   fillTracks(trackRefs, tpCollection, tpKeyToIndex, bs, associatorByHits, *theTTRHBuilder, tTopo, hitProductIds, seedCollToOffset);
 
   //tracking particles
   //sort association maps with simHits
   std::sort( tpHitList.begin(), tpHitList.end(), tpHitIndexListLessSort );
   fillTrackingParticles(iEvent, iSetup, trackRefs, tpCollection, tvKeyToIndex, associatorByHits, tpHitList);
 
   // vertices
   edm::Handle<reco::VertexCollection> vertices;
   iEvent.getByToken(vertexToken_, vertices);
   fillVertices(*vertices, trackRefs);
 
   // tracking vertices
   fillTrackingVertices(tvRefs, tpKeyToIndex);
 
   t->Fill();
 
 }

void TrackingNtuple::clearVariables ( )

private

Definition at line 979 of file TrackingNtuple.cc.

References bsp_sigmax, bsp_sigmay, bsp_sigmaz, bsp_x, bsp_y, bsp_z, ev_event, ev_lumi, ev_run, glu_bbxi, glu_det, glu_detId, glu_isBarrel, glu_lay, 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_det, inv_detId, inv_isBarrel, inv_lay, inv_type, pix_bbxi, pix_chargeFraction, pix_det, pix_detId, pix_isBarrel, pix_lay, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, see_algo, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_nGlued, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_shareFrac, see_simTrkIdx, see_trkIdx, sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nStrip, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_shareFrac, sim_simHitIdx, sim_trkIdx, simhit_det, simhit_detId, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_lay, 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_det, str_detId, str_isBarrel, str_isStereo, str_lay, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, trk_algo, trk_algoMask, trk_cotTheta, trk_dxy, trk_dxyErr, trk_dz, trk_dzErr, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_lambda, trk_lambdaErr, trk_n3DLay, trk_nChi2, trk_nInnerLost, trk_nInvalid, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, trk_seedIdx, trk_shareFrac, trk_simTrkIdx, trk_stopReason, trk_vtxIdx, vtx_chi2, vtx_fake, vtx_ndof, vtx_trkIdx, vtx_valid, vtx_x, vtx_xErr, vtx_y, vtx_yErr, vtx_z, and vtx_zErr.

Referenced by analyze().

                                     {
 
   ev_run = 0;
   ev_lumi = 0;
   ev_event = 0;
 
   //tracks
   trk_px       .clear();
   trk_py       .clear();
   trk_pz       .clear();
   trk_pt       .clear();
   trk_inner_px .clear();
   trk_inner_py .clear();
   trk_inner_pz .clear();
   trk_inner_pt .clear();
   trk_outer_px .clear();
   trk_outer_py .clear();
   trk_outer_pz .clear();
   trk_outer_pt .clear();
   trk_eta      .clear();
   trk_lambda   .clear();
   trk_cotTheta .clear();
   trk_phi      .clear();
   trk_dxy      .clear();
   trk_dz       .clear();
   trk_ptErr    .clear();
   trk_etaErr   .clear();
   trk_lambdaErr.clear();
   trk_phiErr   .clear();
   trk_dxyErr   .clear();
   trk_dzErr    .clear();
   trk_refpoint_x.clear();
   trk_refpoint_y.clear();
   trk_refpoint_z.clear();
   trk_nChi2    .clear();
   trk_q        .clear();
   trk_nValid   .clear();
   trk_nInvalid .clear();
   trk_nPixel   .clear();
   trk_nStrip   .clear();
   trk_nPixelLay.clear();
   trk_nStripLay.clear();
   trk_n3DLay   .clear();
   trk_nOuterLost.clear();
   trk_nInnerLost.clear();
   trk_algo     .clear();
   trk_originalAlgo.clear();
   trk_algoMask .clear();
   trk_stopReason.clear();
   trk_isHP     .clear();
   trk_seedIdx  .clear();
   trk_vtxIdx   .clear();
   trk_shareFrac.clear();
   trk_simTrkIdx.clear();
   trk_hitIdx   .clear();
   trk_hitType  .clear();
   //sim tracks
   sim_event    .clear();
   sim_bunchCrossing.clear();
   sim_pdgId    .clear();
   sim_px       .clear();
   sim_py       .clear();
   sim_pz       .clear();
   sim_pt       .clear();
   sim_eta      .clear();
   sim_phi      .clear();
   sim_pca_pt   .clear();
   sim_pca_eta  .clear();
   sim_pca_lambda.clear();
   sim_pca_cotTheta.clear();
   sim_pca_phi  .clear();
   sim_pca_dxy  .clear();
   sim_pca_dz   .clear();
   sim_q        .clear();
   sim_nValid   .clear();
   sim_nPixel   .clear();
   sim_nStrip   .clear();
   sim_nLay     .clear();
   sim_nPixelLay.clear();
   sim_n3DLay   .clear();
   sim_trkIdx   .clear();
   sim_shareFrac.clear();
   sim_parentVtxIdx.clear();
   sim_decayVtxIdx.clear();
   sim_simHitIdx   .clear();
   //pixels
   pix_isBarrel .clear();
   pix_det      .clear();
   pix_lay      .clear();
   pix_detId    .clear();
   pix_trkIdx   .clear();
   pix_seeIdx   .clear();
   pix_simHitIdx.clear();
   pix_chargeFraction.clear();
   pix_simType.clear();
   pix_x    .clear();
   pix_y    .clear();
   pix_z    .clear();
   pix_xx   .clear();
   pix_xy   .clear();
   pix_yy   .clear();
   pix_yz   .clear();
   pix_zz   .clear();
   pix_zx   .clear();
   pix_radL .clear();
   pix_bbxi .clear();
   //strips
   str_isBarrel .clear();
   str_isStereo .clear();
   str_det      .clear();
   str_lay      .clear();
   str_detId    .clear();
   str_trkIdx   .clear();
   str_seeIdx   .clear();
   str_simHitIdx.clear();
   str_chargeFraction.clear();
   str_simType.clear();
   str_x    .clear();
   str_y    .clear();
   str_z    .clear();
   str_xx   .clear();
   str_xy   .clear();
   str_yy   .clear();
   str_yz   .clear();
   str_zz   .clear();
   str_zx   .clear();
   str_radL .clear();
   str_bbxi .clear();
   //matched hits
   glu_isBarrel .clear();
   glu_det      .clear();
   glu_lay      .clear();
   glu_detId    .clear();
   glu_monoIdx  .clear();
   glu_stereoIdx.clear();
   glu_seeIdx   .clear();
   glu_x        .clear();
   glu_y        .clear();
   glu_z        .clear();
   glu_xx       .clear();
   glu_xy       .clear();
   glu_yy       .clear();
   glu_yz       .clear();
   glu_zz       .clear();
   glu_zx       .clear();
   glu_radL     .clear();
   glu_bbxi     .clear();
   //invalid hits
   inv_isBarrel .clear();
   inv_det      .clear();
   inv_lay      .clear();
   inv_detId    .clear();
   inv_type     .clear();
   // simhits
   simhit_det.clear();
   simhit_lay.clear();
   simhit_detId.clear();
   simhit_x.clear();
   simhit_y.clear();
   simhit_z.clear();
   simhit_particle.clear();
   simhit_process.clear();
   simhit_eloss.clear();
   simhit_tof.clear();
   //simhit_simTrackId.clear();
   simhit_simTrkIdx.clear();
   simhit_hitIdx.clear();
   simhit_hitType.clear();
   //beamspot
   bsp_x = -9999.;
   bsp_y = -9999.;
   bsp_z = -9999.;
   bsp_sigmax = -9999.;
   bsp_sigmay = -9999.;
   bsp_sigmaz = -9999.;
   //seeds
   see_fitok   .clear();
   see_px      .clear();
   see_py      .clear();
   see_pz      .clear();
   see_pt      .clear();
   see_eta     .clear();
   see_phi     .clear();
   see_dxy     .clear();
   see_dz      .clear();
   see_ptErr   .clear();
   see_etaErr  .clear();
   see_phiErr  .clear();
   see_dxyErr  .clear();
   see_dzErr   .clear();
   see_chi2    .clear();
   see_q       .clear();
   see_nValid  .clear();
   see_nPixel  .clear();
   see_nGlued  .clear();
   see_nStrip  .clear();
   see_algo    .clear();
   see_trkIdx  .clear();
   see_shareFrac.clear();
   see_simTrkIdx.clear();
   see_hitIdx  .clear();
   see_hitType .clear();
   //seed algo offset
   see_offset.clear();
 
   // vertices
   vtx_x.clear();
   vtx_y.clear();
   vtx_z.clear();
   vtx_xErr.clear();
   vtx_yErr.clear();
   vtx_zErr.clear();
   vtx_ndof.clear();
   vtx_chi2.clear();
   vtx_fake.clear();
   vtx_valid.clear();
   vtx_trkIdx.clear();
 
   // Tracking vertices
   simvtx_event.clear();
   simvtx_bunchCrossing.clear();
   simvtx_x.clear();
   simvtx_y.clear();
   simvtx_z.clear();
   simvtx_sourceSimIdx.clear();
   simvtx_daughterSimIdx.clear();
   simpv_idx.clear();
 }

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

private

Definition at line 1370 of file TrackingNtuple.cc.

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

Referenced by analyze().

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

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

static

Definition at line 2367 of file TrackingNtuple.cc.

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

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

void TrackingNtuple::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 1589 of file TrackingNtuple.cc.

References TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, TrackingNtuple::SimHitData::event, edm::Event::getByToken(), hit::id, relval_steps::key, TrackerTopology::layer(), LogTrace, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, pix_bbxi, pix_chargeFraction, pix_det, pix_detId, pix_isBarrel, pix_lay, pix_radL, pix_seeIdx, pix_simHitIdx, pix_simType, pix_trkIdx, pix_x, pix_xx, pix_xy, pix_y, pix_yy, pix_yz, pix_z, pix_zx, pix_zz, Pixel, pixelRecHitToken_, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, DetId::subdetId(), and TrackingNtuple::SimHitData::type.

Referenced by analyze().

                                      {
   edm::Handle<SiPixelRecHitCollection> pixelHits;
   iEvent.getByToken(pixelRecHitToken_, pixelHits);
   for (auto it = pixelHits->begin(); it!=pixelHits->end(); it++ ) {
     const DetId hitId = it->detId();
     for (auto hit = it->begin(); hit!=it->end(); hit++ ) {
       TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&*hit);
 
       hitProductIds.insert(hit->cluster().id());
 
       const int key = hit->cluster().key();
       const int lay = tTopo.layer(hitId);
       SimHitData simHitData = matchCluster(hit->firstClusterRef(), hitId, key, ttrh,
                                            clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Pixel);
 
       pix_isBarrel .push_back( hitId.subdetId()==1 );
       pix_det      .push_back( hitId.subdetId() );
       pix_lay      .push_back( lay );
       pix_detId    .push_back( hitId.rawId() );
       pix_trkIdx   .emplace_back(); // filled in fillTracks
       pix_seeIdx   .emplace_back(); // filled in fillSeeds
       pix_simHitIdx.push_back( simHitData.matchingSimHit );
       pix_simType.push_back( static_cast<int>(simHitData.type) );
       pix_x    .push_back( ttrh->globalPosition().x() );
       pix_y    .push_back( ttrh->globalPosition().y() );
       pix_z    .push_back( ttrh->globalPosition().z() );
       pix_xx   .push_back( ttrh->globalPositionError().cxx() );
       pix_xy   .push_back( ttrh->globalPositionError().cyx() );
       pix_yy   .push_back( ttrh->globalPositionError().cyy() );
       pix_yz   .push_back( ttrh->globalPositionError().czy() );
       pix_zz   .push_back( ttrh->globalPositionError().czz() );
       pix_zx   .push_back( ttrh->globalPositionError().czx() );
       pix_chargeFraction.push_back( simHitData.chargeFraction );
       pix_radL .push_back( ttrh->surface()->mediumProperties().radLen() );
       pix_bbxi .push_back( ttrh->surface()->mediumProperties().xi() );
       LogTrace("TrackingNtuple") << "pixHit cluster=" << key
                                  << " subdId=" << hitId.subdetId()
                                  << " lay=" << lay
                                  << " rawId=" << hitId.rawId()
                                  << " pos =" << ttrh->globalPosition()
                                  << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
       if(!simHitData.matchingSimHit.empty()) {
         const auto simHitIdx = simHitData.matchingSimHit[0];
         LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
                                    << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                    << " energyLoss=" << simhit_eloss[simHitIdx]
                                    << " particleType=" << simhit_particle[simHitIdx]
                                    << " processType=" << simhit_process[simHitIdx]
                                    << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                    << " event=" << simHitData.event[0];
       }
     }
   }
 }

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

private

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

Definition at line 1790 of file TrackingNtuple.cc.

References ecalcalib_dqm_sourceclient-live_cfg::algo, reco::TrackBase::algoByName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), TransientTrackingRecHitBuilder::build(), RecoTauCleanerPlugins::charge, RZLine::chi2(), beam_dqm_sourceclient-live_cfg::chi2, OmniClusterRef::cluster_pixel(), OmniClusterRef::cluster_strip(), KineDebug3::count(), declareDynArray, HLT_25ns10e33_v2_cff::distance, edm::AssociationMap< Tag >::end(), eta, Exception, spr::find(), edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), edm::Event::getByToken(), glu_seeIdx, Glued, runTauDisplay::gp, i, edm::ProductID::id(), OmniClusterRef::id(), includeAllHits_, trackerHitRTTI::isMatched(), OmniClusterRef::key(), edm::Ref< C, T, F >::key(), diffTwoXMLs::label, HLT_25ns10e33_v2_cff::labels, edm::EDConsumerBase::labelsForToken(), LogTrace, edm::ProductLabels::module, SiStripMatchedRecHit2D::monoClusterRef(), phi, pix_seeIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::BeamSpot::position(), EnergyCorrector::pt, edm::RefToBaseVector< T >::push_back(), see_algo, see_chi2, see_dxy, see_dxyErr, see_dz, see_dzErr, see_eta, see_etaErr, see_fitok, see_hitIdx, see_hitType, see_nGlued, see_nPixel, see_nStrip, see_nValid, see_offset, see_phi, see_phiErr, see_pt, see_ptErr, see_px, see_py, see_pz, see_q, see_shareFrac, see_simTrkIdx, see_trkIdx, fileCollector::seed, seedTokens_, SiStripMatchedRecHit2D::stereoClusterRef(), str_seeIdx, Strip, StripSubdetector::TIB, StripSubdetector::TOB, and trackFromSeedFitFailed().

Referenced by analyze().

                                  {
   TSCBLBuilderNoMaterial tscblBuilder;
   for(const auto& seedToken: seedTokens_) {
     edm::Handle<edm::View<reco::Track> > seedTracksHandle;
     iEvent.getByToken(seedToken, seedTracksHandle);
     const auto& seedTracks = *seedTracksHandle;
 
     if(seedTracks.empty())
       continue;
 
     // The associator interfaces really need to be fixed...
     edm::RefToBaseVector<reco::Track> seedTrackRefs;
     for(edm::View<reco::Track>::size_type i=0; i<seedTracks.size(); ++i) {
       seedTrackRefs.push_back(seedTracks.refAt(i));
     }
     reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(seedTrackRefs, tpCollection);
 
     edm::EDConsumerBase::Labels labels;
     labelsForToken(seedToken, labels);
     TString label = labels.module;
     //format label to match algoName
     label.ReplaceAll("seedTracks", "");
     label.ReplaceAll("Seeds","");
     label.ReplaceAll("muonSeeded","muonSeededStep");
     int algo = reco::TrackBase::algoByName(label.Data());
 
     edm::ProductID id = seedTracks[0].seedRef().id();
     auto inserted = seedCollToOffset.emplace(id, see_fitok.size());
     if(!inserted.second)
       throw cms::Exception("Configuration") << "Trying to add seeds with ProductID " << id << " for a second time from collection " << labels.module << ", seed algo " << label << ". Typically this is caused by a configuration problem.";
     see_offset.push_back(see_fitok.size());
 
     LogTrace("TrackingNtuple") << "NEW SEED LABEL: " << label << " size: " << seedTracks.size() << " algo=" << algo
                                << " ProductID " << id;
 
     for(const auto& seedTrackRef: seedTrackRefs) {
       const auto& seedTrack = *seedTrackRef;
       const auto& seedRef = seedTrack.seedRef();
       const auto& seed = *seedRef;
 
       if(seedRef.id() != id)
         throw cms::Exception("LogicError") << "All tracks in 'TracksFromSeeds' collection should point to seeds in the same collection. Now the element 0 had ProductID " << id << " while the element " << seedTrackRef.key() << " had " << seedTrackRef.id() << ". The source collection is " << labels.module << ".";
 
       std::vector<float> sharedFraction;
       std::vector<int> tpIdx;
       auto foundTPs = recSimColl.find(seedTrackRef);
       if (foundTPs != recSimColl.end()) {
         for(const auto tpQuality: foundTPs->val) {
           sharedFraction.push_back(tpQuality.second);
           tpIdx.push_back( tpKeyToIndex.at( tpQuality.first.key() ) );
         }
       }
 
 
       const bool seedFitOk = !trackFromSeedFitFailed(seedTrack);
       const int charge = seedTrack.charge();
       const float pt  = seedFitOk ? seedTrack.pt()  : 0;
       const float eta = seedFitOk ? seedTrack.eta() : 0;
       const float phi = seedFitOk ? seedTrack.phi() : 0;
       const int nHits = seedTrack.numberOfValidHits();
 
       const auto seedIndex = see_fitok.size();
 
       see_fitok   .push_back(seedFitOk);
 
       see_px      .push_back( seedFitOk ? seedTrack.px() : 0 );
       see_py      .push_back( seedFitOk ? seedTrack.py() : 0 );
       see_pz      .push_back( seedFitOk ? seedTrack.pz() : 0 );
       see_pt      .push_back( pt );
       see_eta     .push_back( eta );
       see_phi     .push_back( phi );
       see_q       .push_back( charge );
       see_nValid  .push_back( nHits );
 
       see_dxy     .push_back( seedFitOk ? seedTrack.dxy(bs.position()) : 0);
       see_dz      .push_back( seedFitOk ? seedTrack.dz(bs.position()) : 0);
       see_ptErr   .push_back( seedFitOk ? seedTrack.ptError() : 0);
       see_etaErr  .push_back( seedFitOk ? seedTrack.etaError() : 0);
       see_phiErr  .push_back( seedFitOk ? seedTrack.phiError() : 0);
       see_dxyErr  .push_back( seedFitOk ? seedTrack.dxyError() : 0);
       see_dzErr   .push_back( seedFitOk ? seedTrack.dzError() : 0);
       see_algo    .push_back( algo );
 
       see_trkIdx  .push_back(-1); // to be set correctly in fillTracks
       see_shareFrac.push_back( sharedFraction );
       see_simTrkIdx.push_back( tpIdx );
 
       /*
       TransientTrackingRecHit::RecHitPointer lastRecHit = theTTRHBuilder.build(&*(seed.recHits().second-1));
       TrajectoryStateOnSurface state = trajectoryStateTransform::transientState( itSeed->startingState(), lastRecHit->surface(), theMF);
       float pt  = state.globalParameters().momentum().perp();
       float eta = state.globalParameters().momentum().eta();
       float phi = state.globalParameters().momentum().phi();
       see_px      .push_back( state.globalParameters().momentum().x() );
       see_py      .push_back( state.globalParameters().momentum().y() );
       see_pz      .push_back( state.globalParameters().momentum().z() );
       */
 
       std::vector<int> hitIdx;
       std::vector<int> hitType;
 
       for (auto hit=seed.recHits().first; hit!=seed.recHits().second; ++hit) {
     TransientTrackingRecHit::RecHitPointer recHit = theTTRHBuilder.build(&*hit);
     int subid = recHit->geographicalId().subdetId();
     if (subid == (int) PixelSubdetector::PixelBarrel || subid == (int) PixelSubdetector::PixelEndcap) {
       const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
           const auto& clusterRef = bhit->firstClusterRef();
           const auto clusterKey = clusterRef.cluster_pixel().key();
           if(includeAllHits_) {
             checkProductID(hitProductIds, clusterRef.id(), "seed");
             pix_seeIdx[clusterKey].push_back(seedIndex);
           }
           hitIdx.push_back( clusterKey );
           hitType.push_back( static_cast<int>(HitType::Pixel) );
     } else {
       if (trackerHitRTTI::isMatched(*recHit)) {
         const SiStripMatchedRecHit2D * matchedHit = dynamic_cast<const SiStripMatchedRecHit2D *>(&*recHit);
             if(includeAllHits_) {
               checkProductID(hitProductIds, matchedHit->monoClusterRef().id(), "seed");
               checkProductID(hitProductIds, matchedHit->stereoClusterRef().id(), "seed");
             }
         int monoIdx = matchedHit->monoClusterRef().key();
         int stereoIdx = matchedHit->stereoClusterRef().key();
 
             std::vector<std::pair<int,int> >::const_iterator pos = find( monoStereoClusterList.begin(), monoStereoClusterList.end(), std::make_pair(monoIdx,stereoIdx) );
             const auto gluedIndex = std::distance(monoStereoClusterList.begin(), pos);
             if(includeAllHits_) glu_seeIdx[gluedIndex].push_back(seedIndex);
             hitIdx.push_back( gluedIndex );
             hitType.push_back( static_cast<int>(HitType::Glued) );
       } else {
         const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*recHit);
             const auto& clusterRef = bhit->firstClusterRef();
             const auto clusterKey = clusterRef.cluster_strip().key();
             if(includeAllHits_) {
               checkProductID(hitProductIds, clusterRef.id(), "seed");
               str_seeIdx[clusterKey].push_back(seedIndex);
             }
             hitIdx.push_back( clusterKey );
             hitType.push_back( static_cast<int>(HitType::Strip) );
       }
     }
       }
       see_hitIdx  .push_back( hitIdx  );
       see_hitType .push_back( hitType );
       see_nPixel  .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Pixel)) );
       see_nGlued  .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Glued)) );
       see_nStrip  .push_back( std::count(hitType.begin(), hitType.end(), static_cast<int>(HitType::Strip)) );
       //the part below is not strictly needed
       float chi2 = -1;
       if (nHits==2) {
     TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
     TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
         std::vector<GlobalPoint> gp(2);
         std::vector<GlobalError> ge(2);
     gp[0] = recHit0->globalPosition();
     ge[0] = recHit0->globalPositionError();
     gp[1] = recHit1->globalPosition();
     ge[1] = recHit1->globalPositionError();
         LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
                                    << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
                                    << " - PAIR - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId()
                                    << " hitpos: " << gp[0] << " " << gp[1]
                                    << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                    << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                    << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                    << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                    << " eta,phi: " << gp[0].eta() << "," << gp[0].phi();
       } else if (nHits==3) {
     TransientTrackingRecHit::RecHitPointer recHit0 = theTTRHBuilder.build(&*(seed.recHits().first));
     TransientTrackingRecHit::RecHitPointer recHit1 = theTTRHBuilder.build(&*(seed.recHits().first+1));
     TransientTrackingRecHit::RecHitPointer recHit2 = theTTRHBuilder.build(&*(seed.recHits().first+2));
     declareDynArray(GlobalPoint,4, gp);
     declareDynArray(GlobalError,4, ge);
     declareDynArray(bool,4, bl);
     gp[0] = recHit0->globalPosition();
     ge[0] = recHit0->globalPositionError();
     int subid0 = recHit0->geographicalId().subdetId();
     bl[0] = (subid0 == StripSubdetector::TIB || subid0 == StripSubdetector::TOB || subid0 == (int) PixelSubdetector::PixelBarrel);
     gp[1] = recHit1->globalPosition();
     ge[1] = recHit1->globalPositionError();
     int subid1 = recHit1->geographicalId().subdetId();
     bl[1] = (subid1 == StripSubdetector::TIB || subid1 == StripSubdetector::TOB || subid1 == (int) PixelSubdetector::PixelBarrel);
     gp[2] = recHit2->globalPosition();
     ge[2] = recHit2->globalPositionError();
     int subid2 = recHit2->geographicalId().subdetId();
     bl[2] = (subid2 == StripSubdetector::TIB || subid2 == StripSubdetector::TOB || subid2 == (int) PixelSubdetector::PixelBarrel);
     RZLine rzLine(gp,ge,bl);
     float seed_chi2 = rzLine.chi2();
     //float seed_pt = state.globalParameters().momentum().perp();
         float seed_pt = pt;
     LogTrace("TrackingNtuple") << "seed " << seedTrackRef.key()
                                    << " pt=" << pt << " eta=" << eta << " phi=" << phi << " q=" << charge
                                    << " - TRIPLET - ids: " << recHit0->geographicalId().rawId() << " " << recHit1->geographicalId().rawId() << " " << recHit2->geographicalId().rawId()
                                    << " hitpos: " << gp[0] << " " << gp[1] << " " << gp[2]
                                    << " trans0: " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                    << " " << (recHit0->transientHits().size()>1 ? recHit0->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                    << " trans1: " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                    << " " << (recHit1->transientHits().size()>1 ? recHit1->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                    << " trans2: " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[0]->globalPosition() : GlobalPoint(0,0,0))
                                    << " " << (recHit2->transientHits().size()>1 ? recHit2->transientHits()[1]->globalPosition() : GlobalPoint(0,0,0))
                                    << " local: " << recHit2->localPosition()
           //<< " tsos pos, mom: " << state.globalPosition()<<" "<<state.globalMomentum()
                                    << " eta,phi: " << gp[0].eta() << "," << gp[0].phi()
                                    << " pt,chi2: " << seed_pt << "," << seed_chi2;
     chi2 = seed_chi2;
       }
       see_chi2   .push_back( chi2 );
     }
   }
 }

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

private

Definition at line 1493 of file TrackingNtuple.cc.

References funct::abs(), DetId::det(), Exception, TrackerGeometry::idToDetUnit(), TrackerTopology::layer(), LogTrace, TrackingParticle::pdgId(), DetId::rawId(), simhit_det, simhit_detId, simhit_eloss, simhit_hitIdx, simhit_hitType, simhit_lay, simhit_particle, simhit_process, simhit_simTrkIdx, simhit_tof, simhit_x, simhit_y, simhit_z, SimHitTPAssociationProducer::simHitTPAssociationListGreater(), DetId::subdetId(), and DetId::Tracker.

Referenced by analyze().

                                                                    {
 
   for(const auto& assoc: simHitsTPAssoc) {
     auto tpKey = assoc.first.key();
 
     // SimHitTPAssociationList can contain more TrackingParticles than
     // what are given to this EDAnalyzer, so we can filter those out here.
     auto found = tpKeyToIndex.find(tpKey);
     if(found == tpKeyToIndex.end())
       continue;
     const auto tpIndex = found->second;
 
     // skip non-tracker simhits (mostly muons)
     const auto& simhit = *(assoc.second);
     auto detId = DetId(simhit.detUnitId());
     if(detId.det() != DetId::Tracker) continue;
 
     // Skip electron SimHits for non-electron TrackingParticles to
     // filter out delta rays. The delta ray hits just confuse. If we
     // need them later, let's add them as a separate "collection" of
     // hits of a TP
     const TrackingParticle& tp = *(assoc.first);
     if(std::abs(simhit.particleType()) == 11 && std::abs(tp.pdgId()) != 11) continue;
 
     auto simHitKey = std::make_pair(assoc.second.key(), assoc.second.id());
 
     if(simHitRefKeyToIndex.find(simHitKey) != simHitRefKeyToIndex.end()) {
       for(const auto& assoc2: simHitsTPAssoc) {
         if(std::make_pair(assoc2.second.key(), assoc2.second.id()) == simHitKey) {
 
 #ifdef EDM_ML_DEBUG
           auto range1 = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                          std::make_pair(assoc.first, TrackPSimHitRef()),
                                          SimHitTPAssociationProducer::simHitTPAssociationListGreater);
           auto range2 = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                          std::make_pair(assoc2.first, TrackPSimHitRef()),
                                          SimHitTPAssociationProducer::simHitTPAssociationListGreater);
 
           LogTrace("TrackingNtuple") << "Earlier TP " << assoc2.first.key() << " SimTrack Ids";
           for(const auto& simTrack: assoc2.first->g4Tracks()) {
             edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event " << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
           }
           for(auto iHit = range2.first; iHit != range2.second; ++iHit) {
             LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof " << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event " << iHit->second->eventId().bunchCrossing() << ":" << iHit->second->eventId().event();
           }
           LogTrace("TrackingNtuple") << "Current TP " << assoc.first.key() << " SimTrack Ids";
           for(const auto& simTrack: assoc.first->g4Tracks()) {
             edm::LogPrint("TrackingNtuple") << " SimTrack " << simTrack.trackId() << " BX:event " << simTrack.eventId().bunchCrossing() << ":" << simTrack.eventId().event();
           }
           for(auto iHit = range1.first; iHit != range1.second; ++iHit) {
             LogTrace("TrackingNtuple") << " SimHit " << iHit->second.key() << " " << iHit->second.id() << " tof " << iHit->second->tof() << " trackId " << iHit->second->trackId() << " BX:event " << iHit->second->eventId().bunchCrossing() << ":" << iHit->second->eventId().event();
           }
 #endif
 
           throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second << ", first time with TrackingParticle " << assoc2.first.key() << ", now with " << tpKey;
         }
       }
       throw cms::Exception("LogicError") << "Got second time the SimHit " << simHitKey.first << " of " << simHitKey.second << ", now with TrackingParticle " << tpKey << ", but I didn't find the first occurrance!";
     }
 
     auto det = tracker.idToDetUnit(detId);
     if(!det)
       throw cms::Exception("LogicError") << "Did not find a det unit for DetId " << simhit.detUnitId() << " from tracker geometry";
 
     const auto pos = det->surface().toGlobal(simhit.localPosition());
     const float tof = simhit.timeOfFlight();
 
     const auto simHitIndex = simhit_detId.size();
     simHitRefKeyToIndex[simHitKey] = simHitIndex;
 
     simhit_det.push_back(detId.subdetId());
     simhit_lay.push_back(tTopo.layer(detId));
     simhit_detId.push_back(detId.rawId());
     simhit_x.push_back(pos.x());
     simhit_y.push_back(pos.y());
     simhit_z.push_back(pos.z());
     simhit_particle.push_back(simhit.particleType());
     simhit_process.push_back(simhit.processType());
     simhit_eloss.push_back(simhit.energyLoss());
     simhit_tof.push_back(tof);
     //simhit_simTrackId.push_back(simhit.trackId());
 
     simhit_simTrkIdx.push_back(tpIndex);
 
     simhit_hitIdx.emplace_back();  // filled in matchCluster
     simhit_hitType.emplace_back(); // filled in matchCluster
 
     tpHitList.emplace_back(tpKey, simHitIndex, tof, simhit.detUnitId());
   }
 }

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

private

Definition at line 1748 of file TrackingNtuple.cc.

References TransientTrackingRecHitBuilder::build(), edm::Event::getByToken(), glu_bbxi, glu_det, glu_detId, glu_isBarrel, glu_lay, glu_monoIdx, glu_radL, glu_seeIdx, glu_stereoIdx, glu_x, glu_xx, glu_xy, glu_y, glu_yy, glu_yz, glu_z, glu_zx, glu_zz, TrackerTopology::layer(), LogTrace, DetId::rawId(), stripMatchedRecHitToken_, DetId::subdetId(), StripSubdetector::TIB, and StripSubdetector::TOB.

Referenced by analyze().

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

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

private

Definition at line 1654 of file TrackingNtuple.cc.

References TransientTrackingRecHitBuilder::build(), TrackingNtuple::SimHitData::bunchCrossing, TrackingNtuple::SimHitData::chargeFraction, TrackingNtuple::SimHitData::event, lumiContext::fill, edm::Event::getByToken(), hit::id, relval_steps::key, TrackerTopology::layer(), LogTrace, matchCluster(), TrackingNtuple::SimHitData::matchingSimHit, mergeVDriftHistosByStation::name, DetId::rawId(), simhit_eloss, simhit_particle, simhit_process, simhit_x, simhit_y, simhit_z, str_bbxi, str_chargeFraction, str_det, str_detId, str_isBarrel, str_isStereo, str_lay, str_radL, str_seeIdx, str_simHitIdx, str_simType, str_trkIdx, str_x, str_xx, str_xy, str_y, str_yy, str_yz, str_z, str_zx, str_zz, Strip, stripRphiRecHitToken_, stripStereoRecHitToken_, DetId::subdetId(), StripSubdetector::TIB, StripSubdetector::TOB, and TrackingNtuple::SimHitData::type.

Referenced by analyze().

                                                {
   //index strip hit branches by cluster index
   edm::Handle<SiStripRecHit2DCollection> rphiHits;
   iEvent.getByToken(stripRphiRecHitToken_, rphiHits);
   edm::Handle<SiStripRecHit2DCollection> stereoHits;
   iEvent.getByToken(stripStereoRecHitToken_, stereoHits);
   int totalStripHits = rphiHits->dataSize()+stereoHits->dataSize();
   str_isBarrel .resize(totalStripHits);
   str_isStereo .resize(totalStripHits);
   str_det      .resize(totalStripHits);
   str_lay      .resize(totalStripHits);
   str_detId    .resize(totalStripHits);
   str_trkIdx   .resize(totalStripHits); // filled in fillTracks
   str_seeIdx   .resize(totalStripHits); // filled in fillSeeds
   str_simHitIdx.resize(totalStripHits);
   str_simType  .resize(totalStripHits);
   str_x    .resize(totalStripHits);
   str_y    .resize(totalStripHits);
   str_z    .resize(totalStripHits);
   str_xx   .resize(totalStripHits);
   str_xy   .resize(totalStripHits);
   str_yy   .resize(totalStripHits);
   str_yz   .resize(totalStripHits);
   str_zz   .resize(totalStripHits);
   str_zx   .resize(totalStripHits);
   str_chargeFraction.resize(totalStripHits);
   str_radL .resize(totalStripHits);
   str_bbxi .resize(totalStripHits);
 
   auto fill = [&](const SiStripRecHit2DCollection& hits, const char *name, bool isStereo) {
     for(const auto& detset: hits) {
       const DetId hitId = detset.detId();
       for(const auto& hit: detset) {
         TransientTrackingRecHit::RecHitPointer ttrh = theTTRHBuilder.build(&hit);
 
         hitProductIds.insert(hit.cluster().id());
 
         const int key = hit.cluster().key();
         const int lay = tTopo.layer(hitId);
         SimHitData simHitData = matchCluster(hit.firstClusterRef(), hitId, key, ttrh,
                                              clusterToTPMap, tpKeyToIndex, simHitsTPAssoc, digiSimLink, simHitRefKeyToIndex, HitType::Strip);
         str_isBarrel [key] = (hitId.subdetId()==StripSubdetector::TIB || hitId.subdetId()==StripSubdetector::TOB);
         str_isStereo [key] = isStereo;
         str_det      [key] = hitId.subdetId();
         str_lay      [key] = lay;
         str_detId    [key] = hitId.rawId();
         str_simHitIdx[key] = simHitData.matchingSimHit;
         str_simType  [key] = static_cast<int>(simHitData.type);
         str_x    [key] = ttrh->globalPosition().x();
         str_y    [key] = ttrh->globalPosition().y();
         str_z    [key] = ttrh->globalPosition().z();
         str_xx   [key] = ttrh->globalPositionError().cxx();
         str_xy   [key] = ttrh->globalPositionError().cyx();
         str_yy   [key] = ttrh->globalPositionError().cyy();
         str_yz   [key] = ttrh->globalPositionError().czy();
         str_zz   [key] = ttrh->globalPositionError().czz();
         str_zx   [key] = ttrh->globalPositionError().czx();
         str_chargeFraction[key] = simHitData.chargeFraction;
         str_radL [key] = ttrh->surface()->mediumProperties().radLen();
         str_bbxi [key] = ttrh->surface()->mediumProperties().xi();
         LogTrace("TrackingNtuple") << name << " cluster=" << key
                                    << " subdId=" << hitId.subdetId()
                                    << " lay=" << lay
                                    << " rawId=" << hitId.rawId()
                                    << " pos =" << ttrh->globalPosition()
                                    << " nMatchingSimHit=" << simHitData.matchingSimHit.size();
         if(!simHitData.matchingSimHit.empty()) {
           const auto simHitIdx = simHitData.matchingSimHit[0];
           LogTrace("TrackingNtuple") << " firstMatchingSimHit=" << simHitIdx
                                      << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                      << " simHitPos=" << GlobalPoint(simhit_x[simHitIdx], simhit_y[simHitIdx], simhit_z[simHitIdx])
                                      << " energyLoss=" << simhit_eloss[simHitIdx]
                                      << " particleType=" << simhit_particle[simHitIdx]
                                      << " processType=" << simhit_process[simHitIdx]
                                      << " bunchCrossing=" << simHitData.bunchCrossing[0]
                                      << " event=" << simHitData.event[0];
         }
       }
     }
   };
 
   fill(*rphiHits, "stripRPhiHit", false);
   fill(*stereoHits, "stripStereoHit", true);
 }

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

private

Definition at line 2175 of file TrackingNtuple.cc.

References reco::TrackToTrackingParticleAssociator::associateSimToReco(), funct::cos(), edm::AssociationMap< Tag >::end(), Exception, edm::AssociationMap< Tag >::find(), edm::EventSetup::get(), edm::Event::getByToken(), LogTrace, M_PI, ParametersDefinerForTP::momentum(), parametersDefinerName_, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, edm::ESHandle< class >::product(), sim_bunchCrossing, sim_decayVtxIdx, sim_eta, sim_event, sim_n3DLay, sim_nLay, sim_nPixel, sim_nPixelLay, sim_nStrip, sim_nValid, sim_parentVtxIdx, sim_pca_cotTheta, sim_pca_dxy, sim_pca_dz, sim_pca_eta, sim_pca_lambda, sim_pca_phi, sim_pca_pt, sim_pdgId, sim_phi, sim_pt, sim_px, sim_py, sim_pz, sim_q, sim_shareFrac, sim_simHitIdx, sim_trkIdx, simhit_detId, simhit_hitType, funct::sin(), mathSSE::sqrt(), funct::tan(), StripSubdetector::TEC, StripSubdetector::TIB, StripSubdetector::TID, StripSubdetector::TOB, tpHitIndexListLess(), tpNLayersToken_, tpNPixelLayersToken_, tpNStripStereoLayersToken_, DetId::Tracker, HLT_25ns10e33_v2_cff::trackQuality, Unknown, findQualityFiles::v, and ParametersDefinerForTP::vertex().

Referenced by analyze().

                                              {
   edm::ESHandle<ParametersDefinerForTP> parametersDefinerH;
   iSetup.get<TrackAssociatorRecord>().get(parametersDefinerName_, parametersDefinerH);
   const ParametersDefinerForTP *parametersDefiner = parametersDefinerH.product();
 
   // Number of 3D layers for TPs
   edm::Handle<edm::ValueMap<unsigned int>> tpNLayersH;
   iEvent.getByToken(tpNLayersToken_, tpNLayersH);
   const auto& nLayers_tPCeff = *tpNLayersH;
 
   iEvent.getByToken(tpNPixelLayersToken_, tpNLayersH);
   const auto& nPixelLayers_tPCeff = *tpNLayersH;
 
   iEvent.getByToken(tpNStripStereoLayersToken_, tpNLayersH);
   const auto& nStripMonoAndStereoLayers_tPCeff = *tpNLayersH;
 
   reco::SimToRecoCollection simRecColl = associatorByHits.associateSimToReco(tracks, tpCollection);
 
   for(const TrackingParticleRef& tp: tpCollection) {
     LogTrace("TrackingNtuple") << "tracking particle pt=" << tp->pt() << " eta=" << tp->eta() << " phi=" << tp->phi();
     bool isRecoMatched = false;
     std::vector<int> tkIdx;
     std::vector<float> sharedFraction;
     auto foundTracks = simRecColl.find(tp);
     if(foundTracks != simRecColl.end()) {
       isRecoMatched = true;
       for(const auto trackQuality: foundTracks->val) {
         sharedFraction.push_back(trackQuality.second);
         tkIdx.push_back(trackQuality.first.key());
       }
     }
     LogTrace("TrackingNtuple") << "matched to tracks = " << make_VectorPrinter(tkIdx) << " isRecoMatched=" << isRecoMatched;
     sim_event    .push_back(tp->eventId().event());
     sim_bunchCrossing.push_back(tp->eventId().bunchCrossing());
     sim_pdgId    .push_back(tp->pdgId());
     sim_px       .push_back(tp->px());
     sim_py       .push_back(tp->py());
     sim_pz       .push_back(tp->pz());
     sim_pt       .push_back(tp->pt());
     sim_eta      .push_back(tp->eta());
     sim_phi      .push_back(tp->phi());
     sim_q        .push_back(tp->charge());
     sim_trkIdx   .push_back(tkIdx);
     sim_shareFrac.push_back(sharedFraction);
     sim_parentVtxIdx.push_back( tvKeyToIndex.at(tp->parentVertex().key()) );
     std::vector<int> decayIdx;
     for(const auto& v: tp->decayVertices())
       decayIdx.push_back( tvKeyToIndex.at(v.key()) );
     sim_decayVtxIdx.push_back(decayIdx);
 
     //Calcualte the impact parameters w.r.t. PCA
     TrackingParticle::Vector momentum = parametersDefiner->momentum(iEvent,iSetup,tp);
     TrackingParticle::Point vertex = parametersDefiner->vertex(iEvent,iSetup,tp);
     float dxySim = (-vertex.x()*sin(momentum.phi())+vertex.y()*cos(momentum.phi()));
     float dzSim = vertex.z() - (vertex.x()*momentum.x()+vertex.y()*momentum.y())/sqrt(momentum.perp2())
       * momentum.z()/sqrt(momentum.perp2());
     const double lambdaSim = M_PI/2 - momentum.theta();
     sim_pca_pt       .push_back(std::sqrt(momentum.perp2()));
     sim_pca_eta      .push_back(momentum.Eta());
     sim_pca_lambda   .push_back(lambdaSim);
     sim_pca_cotTheta .push_back(1/tan(M_PI*0.5-lambdaSim));
     sim_pca_phi      .push_back(momentum.phi());
     sim_pca_dxy      .push_back(dxySim);
     sim_pca_dz       .push_back(dzSim);
 
     std::vector<int> hitIdx;
     int nPixel=0, nStrip=0;
     auto rangeHit = std::equal_range(tpHitList.begin(), tpHitList.end(), TPHitIndex(tp.key()), tpHitIndexListLess);
     for(auto ip = rangeHit.first; ip != rangeHit.second; ++ip) {
       auto type = HitType::Unknown;
       if(!simhit_hitType[ip->simHitIdx].empty())
         type = static_cast<HitType>(simhit_hitType[ip->simHitIdx][0]);
       LogTrace("TrackingNtuple") << "simhit=" << ip->simHitIdx << " type=" << static_cast<int>(type);
       hitIdx.push_back(ip->simHitIdx);
       const auto detid = DetId(simhit_detId[ip->simHitIdx]);
       if(detid.det() != DetId::Tracker) {
         throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId " << detid.rawId() << " whose det() is not Tracker but " << detid.det();
       }
       const auto subdet = detid.subdetId();
       switch(subdet) {
       case PixelSubdetector::PixelBarrel:
       case PixelSubdetector::PixelEndcap:
         ++nPixel;
         break;
       case StripSubdetector::TIB:
       case StripSubdetector::TID:
       case StripSubdetector::TOB:
       case StripSubdetector::TEC:
         ++nStrip;
         break;
       default:
         throw cms::Exception("LogicError") << "Encountered SimHit for TP " << tp.key() << " with DetId " << detid.rawId() << " whose subdet is not recognized, is " << subdet;
       };
     }
     sim_nValid   .push_back( hitIdx.size() );
     sim_nPixel   .push_back( nPixel );
     sim_nStrip   .push_back( nStrip );
 
     const auto nSimLayers = nLayers_tPCeff[tp];
     const auto nSimPixelLayers = nPixelLayers_tPCeff[tp];
     const auto nSimStripMonoAndStereoLayers = nStripMonoAndStereoLayers_tPCeff[tp];
     sim_nLay     .push_back( nSimLayers );
     sim_nPixelLay.push_back( nSimPixelLayers );
     sim_n3DLay   .push_back( nSimPixelLayers+nSimStripMonoAndStereoLayers );
 
     sim_simHitIdx.push_back(hitIdx);
   }
 }

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

private

Definition at line 2322 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                             {
   int current_event = -1;
   for(const auto& ref: trackingVertices) {
     const TrackingVertex v = *ref;
     if(v.eventId().event() != current_event) {
       // next PV
       current_event = v.eventId().event();
       simpv_idx.push_back(simvtx_x.size());
     }
 
     unsigned int processType = std::numeric_limits<unsigned int>::max();
     if(!v.g4Vertices().empty()) {
       processType = v.g4Vertices()[0].processType();
     }
 
     simvtx_event.push_back(v.eventId().event());
     simvtx_bunchCrossing.push_back(v.eventId().bunchCrossing());
     simvtx_processType.push_back(processType);
 
     simvtx_x.push_back(v.position().x());
     simvtx_y.push_back(v.position().y());
     simvtx_z.push_back(v.position().z());
 
     auto fill = [&](const TrackingParticleRefVector& tps, std::vector<int>& idx) {
       for(const auto& tpRef: tps) {
         auto found = tpKeyToIndex.find(tpRef.key());
         if(found != tpKeyToIndex.end()) {
           idx.push_back(tpRef.key());
         }
       }
     };
 
     std::vector<int> sourceIdx;
     std::vector<int> daughterIdx;
     fill(v.sourceTracks(), sourceIdx);
     fill(v.daughterTracks(), daughterIdx);
 
     simvtx_sourceSimIdx.push_back(sourceIdx);
     simvtx_daughterSimIdx.push_back(daughterIdx);
   }
 }

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

private

Definition at line 2012 of file TrackingNtuple.cc.

References reco::TrackBase::algoName(), reco::TrackToTrackingParticleAssociator::associateRecoToSim(), TransientTrackingRecHitBuilder::build(), RecoTauCleanerPlugins::charge, beam_dqm_sourceclient-live_cfg::chi2, DetId::det(), HLT_25ns10e33_v2_cff::distance, edm::AssociationMap< Tag >::end(), eta, Exception, edm::AssociationMap< Tag >::find(), BaseTrackerRecHit::firstClusterRef(), reco::TrackBase::highPurity, AnalysisDataFormats_SUSYBSMObjects::hp, i, includeAllHits_, includeSeeds_, inv_det, inv_detId, inv_isBarrel, inv_lay, inv_type, Invalid, fastTrackerRecHitType::isPixel(), OmniClusterRef::isPixel(), HLT_25ns10e33_v2_cff::labels, edm::EDConsumerBase::labelsForToken(), TrackerTopology::layer(), LogTrace, M_PI, reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, edm::ProductLabels::module, reco::HitPattern::numberOfLostHits(), reco::HitPattern::numberOfLostTrackerHits(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), reco::HitPattern::numberOfValidStripHits(), reco::HitPattern::numberOfValidStripLayersWithMonoAndStereo(), hltrates_dqm_sourceclient-live_cfg::offset, phi, pix_trkIdx, Pixel, PixelSubdetector::PixelBarrel, PixelSubdetector::PixelEndcap, reco::HitPattern::pixelLayersWithMeasurement(), reco::BeamSpot::position(), EnergyCorrector::pt, DetId::rawId(), see_trkIdx, edm::RefToBaseVector< T >::size(), str_trkIdx, Strip, reco::HitPattern::stripLayersWithMeasurement(), DetId::subdetId(), funct::tan(), reco::HitPattern::TRACK_HITS, DetId::Tracker, trackToken_, trk_algo, trk_algoMask, trk_cotTheta, trk_dxy, trk_dxyErr, trk_dz, trk_dzErr, trk_eta, trk_etaErr, trk_hitIdx, trk_hitType, trk_inner_pt, trk_inner_px, trk_inner_py, trk_inner_pz, trk_isHP, trk_lambda, trk_lambdaErr, trk_n3DLay, trk_nChi2, trk_nInnerLost, trk_nInvalid, trk_nOuterLost, trk_nPixel, trk_nPixelLay, trk_nStrip, trk_nStripLay, trk_nValid, trk_originalAlgo, trk_outer_pt, trk_outer_px, trk_outer_py, trk_outer_pz, trk_phi, trk_phiErr, trk_pt, trk_ptErr, trk_px, trk_py, trk_pz, trk_q, trk_refpoint_x, trk_refpoint_y, trk_refpoint_z, trk_seedIdx, trk_shareFrac, trk_simTrkIdx, trk_stopReason, and trk_vtxIdx.

Referenced by analyze().

                                   {
   reco::RecoToSimCollection recSimColl = associatorByHits.associateRecoToSim(tracks, tpCollection);
   edm::EDConsumerBase::Labels labels;
   labelsForToken(trackToken_, labels);
   LogTrace("TrackingNtuple") << "NEW TRACK LABEL: " << labels.module;
   for(size_t iTrack = 0; iTrack<tracks.size(); ++iTrack) {
     const auto& itTrack = tracks[iTrack];
     int nSimHits = 0;
     bool isSimMatched = false;
     std::vector<float> sharedFraction;
     std::vector<int> tpIdx;
     auto foundTPs = recSimColl.find(itTrack);
     if (foundTPs != recSimColl.end()) {
       if (!foundTPs->val.empty()) {
     nSimHits = foundTPs->val[0].first->numberOfTrackerHits();
     isSimMatched = true;
       }
       for(const auto tpQuality: foundTPs->val) {
         sharedFraction.push_back(tpQuality.second);
     tpIdx.push_back( tpKeyToIndex.at( tpQuality.first.key() ) );
       }
     }
     int charge = itTrack->charge();
     float pt = itTrack->pt();
     float eta = itTrack->eta();
     const double lambda = itTrack->lambda();
     float chi2 = itTrack->normalizedChi2();
     float phi = itTrack->phi();
     int nHits = itTrack->numberOfValidHits();
     const reco::HitPattern& hp = itTrack->hitPattern();
     trk_px       .push_back(itTrack->px());
     trk_py       .push_back(itTrack->py());
     trk_pz       .push_back(itTrack->pz());
     trk_pt       .push_back(pt);
     trk_inner_px.push_back(itTrack->innerMomentum().x());
     trk_inner_py.push_back(itTrack->innerMomentum().y());
     trk_inner_pz.push_back(itTrack->innerMomentum().z());
     trk_inner_pt.push_back(itTrack->innerMomentum().rho());
     trk_outer_px.push_back(itTrack->outerMomentum().x());
     trk_outer_py.push_back(itTrack->outerMomentum().y());
     trk_outer_pz.push_back(itTrack->outerMomentum().z());
     trk_outer_pt.push_back(itTrack->outerMomentum().rho());
     trk_eta      .push_back(eta);
     trk_lambda   .push_back(lambda);
     trk_cotTheta .push_back(1/tan(M_PI*0.5-lambda));
     trk_phi      .push_back(phi);
     trk_dxy      .push_back(itTrack->dxy(bs.position()));
     trk_dz       .push_back(itTrack->dz(bs.position()));
     trk_ptErr    .push_back(itTrack->ptError());
     trk_etaErr   .push_back(itTrack->etaError());
     trk_lambdaErr.push_back(itTrack->lambdaError());
     trk_phiErr   .push_back(itTrack->phiError());
     trk_dxyErr   .push_back(itTrack->dxyError());
     trk_dzErr    .push_back(itTrack->dzError());
     trk_refpoint_x.push_back(itTrack->vx());
     trk_refpoint_y.push_back(itTrack->vy());
     trk_refpoint_z.push_back(itTrack->vz());
     trk_nChi2    .push_back( itTrack->normalizedChi2());
     trk_shareFrac.push_back(sharedFraction);
     trk_q        .push_back(charge);
     trk_nValid   .push_back(hp.numberOfValidHits());
     trk_nInvalid .push_back(hp.numberOfLostHits(reco::HitPattern::TRACK_HITS));
     trk_nPixel   .push_back(hp.numberOfValidPixelHits());
     trk_nStrip   .push_back(hp.numberOfValidStripHits());
     trk_nPixelLay.push_back(hp.pixelLayersWithMeasurement());
     trk_nStripLay.push_back(hp.stripLayersWithMeasurement());
     trk_n3DLay   .push_back(hp.numberOfValidStripLayersWithMonoAndStereo()+hp.pixelLayersWithMeasurement());
     trk_nOuterLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_OUTER_HITS));
     trk_nInnerLost.push_back(hp.numberOfLostTrackerHits(reco::HitPattern::MISSING_INNER_HITS));
     trk_algo     .push_back(itTrack->algo());
     trk_originalAlgo.push_back(itTrack->originalAlgo());
     trk_algoMask .push_back(itTrack->algoMaskUL());
     trk_stopReason.push_back(itTrack->stopReason());
     trk_isHP     .push_back(itTrack->quality(reco::TrackBase::highPurity));
     if(includeSeeds_) {
       auto offset = seedCollToOffset.find(itTrack->seedRef().id());
       if(offset == seedCollToOffset.end()) {
         throw cms::Exception("Configuration") << "Track algo '" << reco::TrackBase::algoName(itTrack->algo())
                                               << "' originalAlgo '" << reco::TrackBase::algoName(itTrack->originalAlgo())
                                               << "' refers to seed collection " << itTrack->seedRef().id()
                                               << ", but that seed collection is not given as an input. The following collections were given as an input " << make_ProductIDMapPrinter(seedCollToOffset);
       }
 
       const auto seedIndex = offset->second + itTrack->seedRef().key();
       trk_seedIdx  .push_back(seedIndex);
       if(see_trkIdx[seedIndex] != -1) {
         throw cms::Exception("LogicError") << "Track index has already been set for seed " << seedIndex << " to " << see_trkIdx[seedIndex] << "; was trying to set it to " << iTrack;
       }
       see_trkIdx[seedIndex] = iTrack;
     }
     trk_vtxIdx   .push_back(-1); // to be set correctly in fillVertices
     trk_simTrkIdx.push_back(tpIdx);
     LogTrace("TrackingNtuple") << "Track #" << itTrack.key() << " with q=" << charge
                                << ", pT=" << pt << " GeV, eta: " << eta << ", phi: " << phi
                                << ", chi2=" << chi2
                                << ", Nhits=" << nHits
                                << ", algo=" << itTrack->algoName(itTrack->algo()).c_str()
                                << " hp=" << itTrack->quality(reco::TrackBase::highPurity)
                                << " seed#=" << itTrack->seedRef().key()
                                << " simMatch=" << isSimMatched
                                << " nSimHits=" << nSimHits
                                << " sharedFraction=" << (sharedFraction.empty()?-1:sharedFraction[0])
                                << " tpIdx=" << (tpIdx.empty()?-1:tpIdx[0]);
     std::vector<int> hitIdx;
     std::vector<int> hitType;
 
     for(auto i=itTrack->recHitsBegin(); i!=itTrack->recHitsEnd(); i++) {
       TransientTrackingRecHit::RecHitPointer hit=theTTRHBuilder.build(&**i );
       DetId hitId = hit->geographicalId();
       LogTrace("TrackingNtuple") << "hit #" << std::distance(itTrack->recHitsBegin(), i) << " subdet=" << hitId.subdetId();
       if(hitId.det() != DetId::Tracker)
         continue;
 
       LogTrace("TrackingNtuple") << " " << subdetstring(hitId.subdetId()) << " " << tTopo.layer(hitId);
       bool isPixel = (hitId.subdetId() == (int) PixelSubdetector::PixelBarrel || hitId.subdetId() == (int) PixelSubdetector::PixelEndcap );
 
       if (hit->isValid()) {
         //ugly... but works
         const BaseTrackerRecHit* bhit = dynamic_cast<const BaseTrackerRecHit*>(&*hit);
         const auto& clusterRef = bhit->firstClusterRef();
         const auto clusterKey = clusterRef.isPixel() ? clusterRef.cluster_pixel().key() :  clusterRef.cluster_strip().key();
 
         LogTrace("TrackingNtuple") << " id: " << hitId.rawId() << " - globalPos =" << hit->globalPosition()
                                    << " cluster=" << clusterKey
                                    << " eta,phi: " << hit->globalPosition().eta() << "," << hit->globalPosition().phi();
         if(includeAllHits_) {
           checkProductID(hitProductIds, clusterRef.id(), "track");
           if(isPixel) pix_trkIdx[clusterKey].push_back(iTrack);
           else        str_trkIdx[clusterKey].push_back(iTrack);
         }
 
         hitIdx.push_back(clusterKey);
         hitType.push_back( static_cast<int>( isPixel ? HitType::Pixel : HitType::Strip ) );
       } else  {
         LogTrace("TrackingNtuple") << " - invalid hit";
 
         hitIdx.push_back( inv_isBarrel.size() );
         hitType.push_back( static_cast<int>(HitType::Invalid) );
 
         inv_isBarrel.push_back( hitId.subdetId()==1 );
         inv_det     .push_back( hitId.subdetId() );
         inv_lay     .push_back( tTopo.layer(hitId) );
         inv_detId   .push_back( hitId.rawId() );
         inv_type    .push_back( hit->getType() );
 
       }
     }
 
     trk_hitIdx.push_back(hitIdx);
     trk_hitType.push_back(hitType);
   }
 }

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

private

Definition at line 2290 of file TrackingNtuple.cc.

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

Referenced by analyze().

                                                                                {
   for(size_t iVertex=0, size=vertices.size(); iVertex<size; ++iVertex) {
     const reco::Vertex& vertex = vertices[iVertex];
     vtx_x.push_back(vertex.x());
     vtx_y.push_back(vertex.y());
     vtx_z.push_back(vertex.z());
     vtx_xErr.push_back(vertex.xError());
     vtx_yErr.push_back(vertex.yError());
     vtx_zErr.push_back(vertex.zError());
     vtx_chi2.push_back(vertex.chi2());
     vtx_ndof.push_back(vertex.ndof());
     vtx_fake.push_back(vertex.isFake());
     vtx_valid.push_back(vertex.isValid());
 
     std::vector<int> trkIdx;
     for(auto iTrack = vertex.tracks_begin(); iTrack != vertex.tracks_end(); ++iTrack) {
       // Ignore link if vertex was fit from a track collection different from the input
       if(iTrack->id() != tracks.id())
         continue;
 
       trkIdx.push_back(iTrack->key());
 
       if(trk_vtxIdx[iTrack->key()] != -1) {
         throw cms::Exception("LogicError") << "Vertex index has already been set for track " << iTrack->key() << " to " << trk_vtxIdx[iTrack->key()] << "; was trying to set it to " << iVertex;
       }
       trk_vtxIdx[iTrack->key()] = iVertex;
     }
     vtx_trkIdx.push_back(trkIdx);
   }
 }

template<typename SimLink >

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

private

Definition at line 1392 of file TrackingNtuple.cc.

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

Referenced by fillPixelHits(), and fillStripRphiStereoHits().

                                                           {
   SimHitData ret;
 
   auto simTrackIdToChargeFraction = chargeFraction(GetCluster<SimLink>::call(cluster), hitId, digiSimLinks);
 
   ret.type = HitSimType::Noise;
   auto range = clusterToTPMap.equal_range( cluster );
   if( range.first != range.second ) {
     for( auto ip=range.first; ip != range.second; ++ip ) {
       const TrackingParticleRef& trackingParticle = ip->second;
 
       // Find out if the cluster is from signal/ITPU/OOTPU
       const auto event = trackingParticle->eventId().event();
       const auto bx = trackingParticle->eventId().bunchCrossing();
       HitSimType type = HitSimType::OOTPileup;
       if(bx == 0) {
         type = (event == 0 ? HitSimType::Signal : HitSimType::ITPileup);
       }
       ret.type = static_cast<HitSimType>(std::min(static_cast<int>(ret.type), static_cast<int>(type)));
 
       // Limit to only input TrackingParticles (usually signal+ITPU)
       auto tpIndex = tpKeyToIndex.find(trackingParticle.key());
       if( tpIndex == tpKeyToIndex.end())
         continue;
       if( trackingParticle->numberOfHits() == 0 ) continue;
 
       //now get the corresponding sim hit
       std::pair<TrackingParticleRef, TrackPSimHitRef> simHitTPpairWithDummyTP(trackingParticle,TrackPSimHitRef());
       //SimHit is dummy: for simHitTPAssociationListGreater sorting only the TP is needed
       auto range = std::equal_range(simHitsTPAssoc.begin(), simHitsTPAssoc.end(),
                                     simHitTPpairWithDummyTP, SimHitTPAssociationProducer::simHitTPAssociationListGreater);
       int simHitKey = -1;
       bool foundElectron = false;
       edm::ProductID simHitID;
       for(auto ip = range.first; ip != range.second; ++ip) {
         TrackPSimHitRef TPhit = ip->second;
         DetId dId = DetId(TPhit->detUnitId());
         if (dId.rawId()==hitId.rawId()) {
           // skip electron SimHits for non-electron TPs also here
           if(std::abs(TPhit->particleType()) == 11 && std::abs(trackingParticle->pdgId()) != 11) {
             foundElectron = true;
             continue;
           }
 
           simHitKey = TPhit.key();
           simHitID = TPhit.id();
           break;
         }
       }
       if(simHitKey < 0) {
         // In case we didn't find a simhit because of filtered-out
         // electron SimHit, just ignore the missing SimHit.
         if(foundElectron)
           continue;
 
         auto ex = cms::Exception("LogicError") << "Did not find SimHit for reco hit DetId " << hitId.rawId()
                                                << " for TP " << trackingParticle.key() << " bx:event " << bx << ":" << event
                                                << ".\nFound SimHits from detectors ";
         for(auto ip = range.first; ip != range.second; ++ip) {
           TrackPSimHitRef TPhit = ip->second;
           DetId dId = DetId(TPhit->detUnitId());
           ex << dId.rawId() << " ";
         }
         if(trackingParticle->eventId().event() != 0) {
           ex << "\nSince this is a TrackingParticle from pileup, check that you're running the pileup mixing in playback mode.";
         }
         throw ex;
       }
       auto simHitIndex = simHitRefKeyToIndex.at(std::make_pair(simHitKey, simHitID));
       ret.matchingSimHit.push_back(simHitIndex);
 
       double chargeFraction = 0.;
       for(const SimTrack& simtrk: trackingParticle->g4Tracks()) {
         auto found = simTrackIdToChargeFraction.find(simtrk.trackId());
         if(found != simTrackIdToChargeFraction.end()) {
           chargeFraction += found->second;
         }
       }
       ret.chargeFraction.push_back(chargeFraction);
 
       // only for debug prints
       ret.bunchCrossing.push_back(bx);
       ret.event.push_back(event);
 
       simhit_hitIdx[simHitIndex].push_back(clusterKey);
       simhit_hitType[simHitIndex].push_back(static_cast<int>(hitType));
     }
   }
 
   return ret;
 }

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

inlinestaticprivate

Definition at line 294 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::tpKey.

Referenced by fillTrackingParticles().

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

i

int i

Definition: DBlmapReader.cc:9

j

int j

Definition: DBlmapReader.cc:9

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

inlinestaticprivate

Definition at line 295 of file TrackingNtuple.cc.

References TrackingNtuple::TPHitIndex::detId, edm::isNotFinite(), TrackingNtuple::TPHitIndex::tof, and TrackingNtuple::TPHitIndex::tpKey.

Referenced by analyze().

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

Member Data Documentation

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

private

Definition at line 411 of file TrackingNtuple.cc.

Referenced by analyze().

float TrackingNtuple::bsp_sigmax

private

Definition at line 613 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

float TrackingNtuple::bsp_sigmay

private

Definition at line 614 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

float TrackingNtuple::bsp_sigmaz

private

Definition at line 615 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

float TrackingNtuple::bsp_x

private

Definition at line 610 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

float TrackingNtuple::bsp_y

private

Definition at line 611 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

float TrackingNtuple::bsp_z

private

Definition at line 612 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillBeamSpot().

std::string TrackingNtuple::builderName_

private

Definition at line 421 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EDGetTokenT<ClusterTPAssociation> TrackingNtuple::clusterTPMapToken_

private

Definition at line 406 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EventNumber_t TrackingNtuple::ev_event

private

Definition at line 430 of file TrackingNtuple.cc.

Referenced by analyze(), and clearVariables().

edm::LuminosityBlockNumber_t TrackingNtuple::ev_lumi

private

Definition at line 429 of file TrackingNtuple.cc.

Referenced by analyze(), and clearVariables().

edm::RunNumber_t TrackingNtuple::ev_run

private

Definition at line 428 of file TrackingNtuple.cc.

Referenced by analyze(), and clearVariables().

std::vector<float> TrackingNtuple::glu_bbxi

private

Definition at line 582 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

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

private

Definition at line 566 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

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

private

Definition at line 568 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<short> TrackingNtuple::glu_isBarrel

private

Definition at line 565 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

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

private

Definition at line 567 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<int> TrackingNtuple::glu_monoIdx

private

Definition at line 569 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_radL

private

Definition at line 581 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

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

private

Definition at line 571 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::glu_stereoIdx

private

Definition at line 570 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_x

private

Definition at line 572 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_xx

private

Definition at line 575 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_xy

private

Definition at line 576 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_y

private

Definition at line 573 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_yy

private

Definition at line 577 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_yz

private

Definition at line 578 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_z

private

Definition at line 574 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_zx

private

Definition at line 580 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

std::vector<float> TrackingNtuple::glu_zz

private

Definition at line 579 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripMatchedHits().

const bool TrackingNtuple::includeAllHits_

private

Definition at line 424 of file TrackingNtuple.cc.

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

const bool TrackingNtuple::includeSeeds_

private

Definition at line 423 of file TrackingNtuple.cc.

Referenced by analyze(), and fillTracks().

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

private

Definition at line 587 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 589 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<short> TrackingNtuple::inv_isBarrel

private

Definition at line 586 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 588 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 590 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::string TrackingNtuple::parametersDefinerName_

private

Definition at line 422 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

std::vector<float> TrackingNtuple::pix_bbxi

private

Definition at line 537 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 525 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 519 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 521 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<short> TrackingNtuple::pix_isBarrel

private

Definition at line 518 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 520 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_radL

private

Definition at line 536 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 523 of file TrackingNtuple.cc.

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

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

private

Definition at line 524 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 526 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

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

private

Definition at line 522 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::pix_x

private

Definition at line 527 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_xx

private

Definition at line 530 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_xy

private

Definition at line 531 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_y

private

Definition at line 528 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_yy

private

Definition at line 532 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_yz

private

Definition at line 533 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_z

private

Definition at line 529 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_zx

private

Definition at line 535 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

std::vector<float> TrackingNtuple::pix_zz

private

Definition at line 534 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillPixelHits().

edm::EDGetTokenT<SiPixelRecHitCollection> TrackingNtuple::pixelRecHitToken_

private

Definition at line 412 of file TrackingNtuple.cc.

Referenced by fillPixelHits().

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

private

Definition at line 409 of file TrackingNtuple.cc.

Referenced by analyze().

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

private

Definition at line 639 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_chi2

private

Definition at line 633 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_dxy

private

Definition at line 626 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_dxyErr

private

Definition at line 631 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_dz

private

Definition at line 627 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_dzErr

private

Definition at line 632 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_eta

private

Definition at line 624 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_etaErr

private

Definition at line 629 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<short> TrackingNtuple::see_fitok

private

Definition at line 619 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 643 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 644 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 637 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 636 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 638 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 635 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 646 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_phi

private

Definition at line 625 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_phiErr

private

Definition at line 630 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_pt

private

Definition at line 623 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_ptErr

private

Definition at line 628 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_px

private

Definition at line 620 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_py

private

Definition at line 621 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<float> TrackingNtuple::see_pz

private

Definition at line 622 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<int> TrackingNtuple::see_q

private

Definition at line 634 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 641 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

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

private

Definition at line 642 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSeeds().

std::vector<int> TrackingNtuple::see_trkIdx

private

Definition at line 640 of file TrackingNtuple.cc.

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

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

private

Definition at line 402 of file TrackingNtuple.cc.

Referenced by fillSeeds().

std::vector<int> TrackingNtuple::sim_bunchCrossing

private

Definition at line 488 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 513 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_eta

private

Definition at line 494 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<int> TrackingNtuple::sim_event

private

Definition at line 487 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 509 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 507 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 505 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 508 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 506 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 504 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<int> TrackingNtuple::sim_parentVtxIdx

private

Definition at line 512 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_cotTheta

private

Definition at line 499 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_dxy

private

Definition at line 501 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_dz

private

Definition at line 502 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_eta

private

Definition at line 497 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_lambda

private

Definition at line 498 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_phi

private

Definition at line 500 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pca_pt

private

Definition at line 496 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<int> TrackingNtuple::sim_pdgId

private

Definition at line 489 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_phi

private

Definition at line 495 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pt

private

Definition at line 493 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_px

private

Definition at line 490 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_py

private

Definition at line 491 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<float> TrackingNtuple::sim_pz

private

Definition at line 492 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

std::vector<int> TrackingNtuple::sim_q

private

Definition at line 503 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 511 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 514 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 510 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingParticles().

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

private

Definition at line 594 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSimHits().

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

private

Definition at line 596 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_eloss

private

Definition at line 602 of file TrackingNtuple.cc.

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

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

private

Definition at line 606 of file TrackingNtuple.cc.

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

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

private

Definition at line 607 of file TrackingNtuple.cc.

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

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

private

Definition at line 595 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSimHits().

std::vector<int> TrackingNtuple::simhit_particle

private

Definition at line 600 of file TrackingNtuple.cc.

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

std::vector<short> TrackingNtuple::simhit_process

private

Definition at line 601 of file TrackingNtuple.cc.

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

std::vector<int> TrackingNtuple::simhit_simTrkIdx

private

Definition at line 605 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSimHits().

std::vector<float> TrackingNtuple::simhit_tof

private

Definition at line 603 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillSimHits().

std::vector<float> TrackingNtuple::simhit_x

private

Definition at line 597 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_y

private

Definition at line 598 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::simhit_z

private

Definition at line 599 of file TrackingNtuple.cc.

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

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

private

Definition at line 407 of file TrackingNtuple.cc.

Referenced by analyze().

std::vector<int> TrackingNtuple::simpv_idx

private

Definition at line 675 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<int> TrackingNtuple::simvtx_bunchCrossing

private

Definition at line 668 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

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

private

Definition at line 674 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<int> TrackingNtuple::simvtx_event

private

Definition at line 667 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

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

private

Definition at line 669 of file TrackingNtuple.cc.

Referenced by fillTrackingVertices().

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

private

Definition at line 673 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<float> TrackingNtuple::simvtx_x

private

Definition at line 670 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<float> TrackingNtuple::simvtx_y

private

Definition at line 671 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<float> TrackingNtuple::simvtx_z

private

Definition at line 672 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTrackingVertices().

std::vector<float> TrackingNtuple::str_bbxi

private

Definition at line 561 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 549 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 543 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 545 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<short> TrackingNtuple::str_isBarrel

private

Definition at line 541 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<short> TrackingNtuple::str_isStereo

private

Definition at line 542 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 544 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_radL

private

Definition at line 560 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 547 of file TrackingNtuple.cc.

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

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

private

Definition at line 548 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 550 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

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

private

Definition at line 546 of file TrackingNtuple.cc.

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

std::vector<float> TrackingNtuple::str_x

private

Definition at line 551 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_xx

private

Definition at line 554 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_xy

private

Definition at line 555 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_y

private

Definition at line 552 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_yy

private

Definition at line 556 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_yz

private

Definition at line 557 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_z

private

Definition at line 553 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_zx

private

Definition at line 559 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

std::vector<float> TrackingNtuple::str_zz

private

Definition at line 558 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillStripRphiStereoHits().

edm::EDGetTokenT<SiStripMatchedRecHit2DCollection> TrackingNtuple::stripMatchedRecHitToken_

private

Definition at line 415 of file TrackingNtuple.cc.

Referenced by fillStripMatchedHits().

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripRphiRecHitToken_

private

Definition at line 413 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

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

private

Definition at line 410 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EDGetTokenT<SiStripRecHit2DCollection> TrackingNtuple::stripStereoRecHitToken_

private

Definition at line 414 of file TrackingNtuple.cc.

Referenced by fillStripRphiStereoHits().

TTree* TrackingNtuple::t

private

Definition at line 426 of file TrackingNtuple.cc.

Referenced by analyze().

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

private

Definition at line 418 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

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

private

Definition at line 419 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

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

private

Definition at line 420 of file TrackingNtuple.cc.

Referenced by fillTrackingParticles().

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

private

Definition at line 408 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EDGetTokenT<TrackingParticleRefVector> TrackingNtuple::trackingParticleRefToken_

private

Definition at line 405 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EDGetTokenT<TrackingParticleCollection> TrackingNtuple::trackingParticleToken_

private

Definition at line 404 of file TrackingNtuple.cc.

Referenced by analyze().

edm::EDGetTokenT<TrackingVertexCollection> TrackingNtuple::trackingVertexToken_

private

Definition at line 417 of file TrackingNtuple.cc.

Referenced by analyze().

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

private

Definition at line 403 of file TrackingNtuple.cc.

Referenced by analyze(), and fillTracks().

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

private

Definition at line 473 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 475 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_cotTheta

private

Definition at line 449 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_dxy

private

Definition at line 451 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_dxyErr

private

Definition at line 457 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_dz

private

Definition at line 452 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_dzErr

private

Definition at line 458 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_eta

private

Definition at line 447 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_etaErr

private

Definition at line 454 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 482 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 483 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_inner_pt

private

Definition at line 442 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_inner_px

private

Definition at line 439 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_inner_py

private

Definition at line 440 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_inner_pz

private

Definition at line 441 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<short> TrackingNtuple::trk_isHP

private

Definition at line 477 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_lambda

private

Definition at line 448 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_lambdaErr

private

Definition at line 455 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 470 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_nChi2

private

Definition at line 462 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 472 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 465 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 471 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 466 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 468 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 467 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 469 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 464 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 474 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_outer_pt

private

Definition at line 446 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_outer_px

private

Definition at line 443 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_outer_py

private

Definition at line 444 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_outer_pz

private

Definition at line 445 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_phi

private

Definition at line 450 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_phiErr

private

Definition at line 456 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_pt

private

Definition at line 438 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_ptErr

private

Definition at line 453 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_px

private

Definition at line 435 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_py

private

Definition at line 436 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_pz

private

Definition at line 437 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<int> TrackingNtuple::trk_q

private

Definition at line 463 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_refpoint_x

private

Definition at line 459 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_refpoint_y

private

Definition at line 460 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<float> TrackingNtuple::trk_refpoint_z

private

Definition at line 461 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<int> TrackingNtuple::trk_seedIdx

private

Definition at line 478 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 480 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 481 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

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

private

Definition at line 476 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillTracks().

std::vector<int> TrackingNtuple::trk_vtxIdx

private

Definition at line 479 of file TrackingNtuple.cc.

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

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

private

Definition at line 416 of file TrackingNtuple.cc.

Referenced by analyze().

std::vector<float> TrackingNtuple::vtx_chi2

private

Definition at line 659 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<short> TrackingNtuple::vtx_fake

private

Definition at line 660 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_ndof

private

Definition at line 658 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

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

private

Definition at line 662 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<short> TrackingNtuple::vtx_valid

private

Definition at line 661 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_x

private

Definition at line 652 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_xErr

private

Definition at line 655 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_y

private

Definition at line 653 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_yErr

private

Definition at line 656 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_z

private

Definition at line 654 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

std::vector<float> TrackingNtuple::vtx_zErr

private

Definition at line 657 of file TrackingNtuple.cc.

Referenced by clearVariables(), and fillVertices().

Classes

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Static Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation