Inheritance diagram for PackedCandidateTrackValidator:

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

void	bookHistograms (DQMStore::IBooker &, edm::Run const &, edm::EventSetup const &) override

	PackedCandidateTrackValidator (const edm::ParameterSet &pset)

	~PackedCandidateTrackValidator () override

Public Member Functions inherited from DQMEDAnalyzer
void	accumulate (edm::Event const &event, edm::EventSetup const &setup) final

virtual void	analyze (edm::Event const &, edm::EventSetup const &)

void	beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final

void	beginRun (edm::Run const &run, edm::EventSetup const &setup) final

virtual void	dqmBeginLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)

	DQMEDAnalyzer ()

virtual void	dqmEndLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &)

virtual void	dqmEndRun (edm::Run const &, edm::EventSetup const &)

void	endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &) final

void	endLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup) final

void	endRun (edm::Run const &, edm::EventSetup const &) final

void	endRunProduce (edm::Run &run, edm::EventSetup const &setup) final

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::one::EDProducer< edm::EndRunProducer, edm::one::WatchRuns, edm::EndLuminosityBlockProducer, edm::one::WatchLuminosityBlocks, edm::Accumulator >
	EDProducer ()=default

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

Public Member Functions inherited from edm::one::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

	~ProducerBase () noexcept(false) override

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

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const

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

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

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

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Types
enum	{ sf_AllTracks = 0, sf_AssociatedToPC = 1, sf_PCIsCharged = 2, sf_PCHasTrack = 3, sf_PCIsNotElectron = 4, sf_PCHasHits = 5, sf_PCNdofNot0 = 6, sf_NoMissingInnerHits = 7 }

Private Attributes
bool	debug_

MonitorElement *	h_diffCharge

PackedValueCheck< Float16Helper >	h_diffCovDszDsz

PackedValueCheck< Float16Helper >	h_diffCovDxyDsz

PackedValueCheck< Float16Helper >	h_diffCovDxyDxy

PackedValueCheck< LogIntHelper >	h_diffCovLambdaDsz

PackedValueCheck< LogIntHelper >	h_diffCovLambdaLambda

PackedValueCheck< LogIntHelper >	h_diffCovPhiDxy

PackedValueCheck< LogIntHelper >	h_diffCovPhiPhi

PackedValueCheck< LogIntHelper >	h_diffCovQoverpQoverp

MonitorElement *	h_diffDszError

PackedValueCheck< Float16Helper >	h_diffDxyAssocPV

MonitorElement *	h_diffDxyError

MonitorElement *	h_diffDxyPV

PackedValueCheck< Float16Helper >	h_diffDzAssocPV

MonitorElement *	h_diffDzError

MonitorElement *	h_diffDzPV

MonitorElement *	h_diffEta

MonitorElement *	h_diffEtaError

MonitorElement *	h_diffHitPatternHasValidHitInFirstPixelBarrel

MonitorElement *	h_diffHitPatternNumberOfLostInnerHits

MonitorElement *	h_diffHitPatternNumberOfValidHits

MonitorElement *	h_diffHitPatternNumberOfValidPixelHits

MonitorElement *	h_diffHitPatternPixelLayersWithMeasurement

MonitorElement *	h_diffHitPatternStripLayersWithMeasurement

MonitorElement *	h_diffHitPatternTrackerLayersWithMeasurement

MonitorElement *	h_diffIsHighPurity

MonitorElement *	h_diffLostInnerHits

MonitorElement *	h_diffNdof

MonitorElement *	h_diffNormalizedChi2

MonitorElement *	h_diffNumberOfHits

MonitorElement *	h_diffNumberOfPixelHits

MonitorElement *	h_diffNumberOfPixelLayers

MonitorElement *	h_diffNumberOfStripLayers

MonitorElement *	h_diffPhi

MonitorElement *	h_diffPt

MonitorElement *	h_diffPtError

MonitorElement *	h_diffTrackDxyAssocPV

MonitorElement *	h_diffTrackDxyError

MonitorElement *	h_diffTrackDzAssocPV

MonitorElement *	h_diffTrackDzError

MonitorElement *	h_diffVx

MonitorElement *	h_diffVy

MonitorElement *	h_diffVz

MonitorElement *	h_numberHitsOverMax

MonitorElement *	h_numberLayersOverMax

MonitorElement *	h_numberPixelHitsOverMax

MonitorElement *	h_numberPixelLayersOverMax

MonitorElement *	h_numberStripHitsOverMax

MonitorElement *	h_numberStripLayersOverMax

MonitorElement *	h_selectionFlow

std::string	rootFolder_

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

edm::EDGetTokenT< edm::Association< pat::PackedCandidateCollection > >	trackToPackedCandidateToken_

edm::EDGetTokenT< reco::VertexCollection >	verticesToken_

Additional Inherited Members
Public Types inherited from DQMEDAnalyzer
typedef dqm::reco::DQMStore	DQMStore

typedef dqm::reco::MonitorElement	MonitorElement

Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::ProducerBase
ProducesCollector	producesCollector ()

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

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

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

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

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

void	consumesMany (const TypeToGet &id)

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

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()

template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)

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

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

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

Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken >	lumiToken_

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 401 of file PackedCandidateTrackValidator.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
sf_AllTracks
sf_AssociatedToPC
sf_PCIsCharged
sf_PCHasTrack
sf_PCIsNotElectron
sf_PCHasHits
sf_PCNdofNot0
sf_NoMissingInnerHits

Definition at line 419 of file PackedCandidateTrackValidator.cc.

        {
     sf_AllTracks = 0,
     sf_AssociatedToPC = 1,
     sf_PCIsCharged = 2,
     sf_PCHasTrack = 3,
     sf_PCIsNotElectron = 4,
     sf_PCHasHits = 5,
     sf_PCNdofNot0 = 6,
     sf_NoMissingInnerHits = 7
   };

Constructor & Destructor Documentation

PackedCandidateTrackValidator::PackedCandidateTrackValidator ( const edm::ParameterSet & pset )

Definition at line 493 of file PackedCandidateTrackValidator.cc.

     : tracksToken_(consumes<edm::View<reco::Track>>(iConfig.getUntrackedParameter<edm::InputTag>("tracks"))),
       verticesToken_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertices"))),
       trackToPackedCandidateToken_(consumes<edm::Association<pat::PackedCandidateCollection>>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackToPackedCandidateAssociation"))),
       rootFolder_(iConfig.getUntrackedParameter<std::string>("rootFolder")),
       debug_(iConfig.getUntrackedParameter<bool>("debug")),
       h_diffDxyAssocPV(RangeAbs(0.001)),
       h_diffDzAssocPV(RangeAbs(0.001)),
       h_diffCovQoverpQoverp(Range(-1e-6, 0.13), -15, 0),  // despite of ceil in pack, there is rounding in double->float
       h_diffCovLambdaLambda(
           Range(-1e-6, 0.13), -20, -5),  // despite of ceil in pack, there is rounding in double->float
       h_diffCovLambdaDsz(RangeAbs(0.13), -17, -4),
       h_diffCovPhiPhi(RangeAbs(0.13), -15, 0),
       h_diffCovPhiDxy(RangeAbs(0.13), -17, -4),
       h_diffCovDxyDxy(RangeAbs(0.001)),
       h_diffCovDxyDsz(RangeAbs(0.001)),
       h_diffCovDszDsz(RangeAbs(0.001)) {}

PackedCandidateTrackValidator::~PackedCandidateTrackValidator ( )

override

Definition at line 512 of file PackedCandidateTrackValidator.cc.

512 {}

Member Function Documentation

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

override

Definition at line 819 of file PackedCandidateTrackValidator.cc.

                                                                                                {
   edm::Handle<edm::View<reco::Track>> htracks;
   iEvent.getByToken(tracksToken_, htracks);
   const auto& tracks = *htracks;
 
   edm::Handle<reco::VertexCollection> hvertices;
   iEvent.getByToken(verticesToken_, hvertices);
   const auto& vertices = *hvertices;
 
   if (vertices.empty())
     return;
   const reco::Vertex& pv = vertices[0];
 
   edm::Handle<edm::Association<pat::PackedCandidateCollection>> hassoc;
   iEvent.getByToken(trackToPackedCandidateToken_, hassoc);
   const auto& trackToPackedCandidate = *hassoc;
 
   for (size_t i = 0; i < tracks.size(); ++i) {
     auto trackPtr = tracks.ptrAt(i);
     const reco::Track& track = *trackPtr;
     h_selectionFlow->Fill(sf_AllTracks);
 
     pat::PackedCandidateRef pcRef = trackToPackedCandidate[trackPtr];
     if (pcRef.isNull()) {
       continue;
     }
     h_selectionFlow->Fill(sf_AssociatedToPC);
 
     // Filter out neutral PackedCandidates, some of them may have track associated, and for those the charge comparison fails
     if (pcRef->charge() == 0) {
       continue;
     }
     h_selectionFlow->Fill(sf_PCIsCharged);
 
     const reco::Track* trackPcPtr = pcRef->bestTrack();
     if (!trackPcPtr) {
       continue;
     }
     h_selectionFlow->Fill(sf_PCHasTrack);
 
     // Filter out electrons to avoid comparisons to PackedCandidates with GsfTrack
     if (std::abs(pcRef->pdgId()) == 11) {
       continue;
     }
     h_selectionFlow->Fill(sf_PCIsNotElectron);
 
     // Filter out PackedCandidate-tracks with no hits, as they won't have their details filled
     const reco::Track& trackPc = *trackPcPtr;
     if (trackPc.hitPattern().numberOfValidHits() == 0) {
       continue;
     }
     h_selectionFlow->Fill(sf_PCHasHits);
 
     auto slimmedVertexRef = pcRef->vertexRef();
     const reco::Vertex& pcVertex = vertices[slimmedVertexRef.key()];
 
     fillNoFlow(h_diffVx, trackPc.vx() - track.vx());
     fillNoFlow(h_diffVy, trackPc.vy() - track.vy());
     fillNoFlow(h_diffVz, trackPc.vz() - track.vz());
 
     // PackedCandidate recalculates the ndof in unpacking as
     // (nhits+npixelhits-5), but some strip hits may have dimension 2.
     // If PackedCandidate has ndof=0, the resulting normalizedChi2
     // will be 0 too. Hence, the comparison makes sense only for those
     // PackedCandidates that have ndof != 0.
     double diffNormalizedChi2 = 0;
     if (trackPc.ndof() != 0) {
       h_selectionFlow->Fill(sf_PCNdofNot0);
       diffNormalizedChi2 = trackPc.normalizedChi2() - track.normalizedChi2();
       fillNoFlow(h_diffNormalizedChi2, diffNormalizedChi2);
     }
     fillNoFlow(h_diffNdof, trackPc.ndof() - track.ndof());
 
     auto diffCharge = trackPc.charge() - track.charge();
     fillNoFlow(h_diffCharge, diffCharge);
     int diffHP = static_cast<int>(trackPc.quality(reco::TrackBase::highPurity)) -
                  static_cast<int>(track.quality(reco::TrackBase::highPurity));
     fillNoFlow(h_diffIsHighPurity, diffHP);
 
     const auto diffPt = diffRelative(trackPc.pt(), track.pt());
     const auto diffPhi = reco::deltaPhi(trackPc.phi(), track.phi());
     fillNoFlow(h_diffPt, diffPt);
     fillNoFlow(h_diffEta, trackPc.eta() - track.eta());
     fillNoFlow(h_diffPhi, diffPhi);
 
     const auto diffDxyAssocPV =
         h_diffDxyAssocPV.fill(pcRef->dxy(), track.dxy(pcVertex.position()), [](double value) { return value * 100.; });
     const auto diffDzAssocPV = h_diffDzAssocPV.fill(
         pcRef->dzAssociatedPV(), track.dz(pcVertex.position()), [](double value) { return value * 100.; });
     const auto diffDxyPV = diffRelative(pcRef->dxy(pv.position()), track.dxy(pv.position()));
     const auto diffDzPV = diffRelative(pcRef->dz(pv.position()), track.dz(pv.position()));
     fillNoFlow(h_diffDxyPV, diffDxyPV);
     fillNoFlow(h_diffDzPV, diffDzPV);
     fillNoFlow(h_diffTrackDxyAssocPV, diffRelative(trackPc.dxy(pcVertex.position()), track.dxy(pcVertex.position())));
     fillNoFlow(h_diffTrackDzAssocPV, diffRelative(trackPc.dz(pcVertex.position()), track.dz(pcVertex.position())));
 
     auto fillCov1 = [&](auto& hlp, const int i, const int j) {
       return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j));
     };
     auto fillCov2 = [&](auto& hlp, const int i, const int j, std::function<double(double)> modifyPack) {
       return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j), modifyPack);
     };
     auto fillCov3 = [&](auto& hlp,
                         const int i,
                         const int j,
                         std::function<double(double)> modifyPack,
                         std::function<double(double)> modifyUnpack) {
       return hlp.fill(trackPc.covariance(i, j), track.covariance(i, j), modifyPack, modifyUnpack);
     };
 
     const auto pcPt = pcRef->pt();
     const auto diffCovQoverpQoverp = fillCov3(h_diffCovQoverpQoverp,
                                               reco::TrackBase::i_qoverp,
                                               reco::TrackBase::i_qoverp,
                                               [=](double val) { return val * pcPt * pcPt; },
                                               [=](double val) { return val / pcPt / pcPt; });
     const auto diffCovLambdaLambda =
         fillCov1(h_diffCovLambdaLambda, reco::TrackBase::i_lambda, reco::TrackBase::i_lambda);
     const auto diffCovLambdaDsz = fillCov1(h_diffCovLambdaDsz, reco::TrackBase::i_lambda, reco::TrackBase::i_dsz);
     const auto diffCovPhiPhi = fillCov3(h_diffCovPhiPhi,
                                         reco::TrackBase::i_phi,
                                         reco::TrackBase::i_phi,
                                         [=](double val) { return val * pcPt * pcPt; },
                                         [=](double val) { return val / pcPt / pcPt; });
     const auto diffCovPhiDxy = fillCov1(h_diffCovPhiDxy, reco::TrackBase::i_phi, reco::TrackBase::i_dxy);
     const auto diffCovDxyDxy = fillCov2(
         h_diffCovDxyDxy, reco::TrackBase::i_dxy, reco::TrackBase::i_dxy, [](double value) { return value * 10000.; });
     const auto diffCovDxyDsz = fillCov2(
         h_diffCovDxyDsz, reco::TrackBase::i_dxy, reco::TrackBase::i_dsz, [](double value) { return value * 10000.; });
     const auto diffCovDszDsz = fillCov2(
         h_diffCovDszDsz, reco::TrackBase::i_dsz, reco::TrackBase::i_dsz, [](double value) { return value * 10000.; });
 
     if (isInRange(diffCovDszDsz.status())) {
       fillNoFlow(h_diffDszError, diffRelative(pcRef->dzError(), track.dszError()));
       fillNoFlow(h_diffDzError, diffRelative(pcRef->dzError(), track.dzError()));
       fillNoFlow(h_diffTrackDzError, diffRelative(trackPc.dzError(), track.dzError()));
     }
     if (isInRange(diffCovDxyDxy.status())) {
       fillNoFlow(h_diffDxyError, diffRelative(pcRef->dxyError(), track.dxyError()));
       fillNoFlow(h_diffTrackDxyError, diffRelative(trackPc.dxyError(), track.dxyError()));
     }
     fillNoFlow(h_diffPtError, diffRelative(trackPc.ptError(), track.ptError()));
     fillNoFlow(h_diffEtaError, diffRelative(trackPc.etaError(), track.etaError()));
 
     // For the non-HitPattern ones, take into account the PackedCandidate packing precision
     const auto trackNumberOfHits = track.hitPattern().numberOfValidHits();
     const auto trackNumberOfPixelHits = track.hitPattern().numberOfValidPixelHits();
     const auto trackNumberOfStripHits = track.hitPattern().numberOfValidStripHits();
     const auto pcNumberOfHits = pcRef->numberOfHits();
     const auto pcNumberOfPixelHits = pcRef->numberOfPixelHits();
     const auto pcNumberOfStripHits = pcNumberOfHits - pcNumberOfPixelHits;
     const auto trackNumberOfLayers = track.hitPattern().trackerLayersWithMeasurement();
     const auto trackNumberOfPixelLayers = track.hitPattern().pixelLayersWithMeasurement();
     const auto trackNumberOfStripLayers = track.hitPattern().stripLayersWithMeasurement();
     const auto pcNumberOfLayers = pcRef->trackerLayersWithMeasurement();
     const auto pcNumberOfPixelLayers = pcRef->pixelLayersWithMeasurement();
     const auto pcNumberOfStripLayers = pcRef->stripLayersWithMeasurement();
 
     // layer number overflow (should be zero)
     const int pixelLayerOverflow = trackNumberOfPixelLayers > pat::PackedCandidate::trackPixelHitsMask
                                        ? trackNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask
                                        : 0;
     const int stripLayerOverflow = trackNumberOfStripLayers > pat::PackedCandidate::trackStripHitsMask
                                        ? trackNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask
                                        : 0;
     const int layerOverflow =
         trackNumberOfLayers > (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
             ? trackNumberOfLayers -
                   (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
             : 0;
 
     // hit overflow (should also be zero)
     const int pixelOverflow =
         trackNumberOfPixelHits - pcNumberOfPixelLayers > pat::PackedCandidate::trackPixelHitsMask
             ? trackNumberOfPixelHits - pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask
             : 0;
     const int stripOverflow =
         trackNumberOfStripHits - pcNumberOfStripLayers > pat::PackedCandidate::trackStripHitsMask
             ? trackNumberOfStripHits - pcNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask
             : 0;
     const int hitsOverflow =
         trackNumberOfHits - pcNumberOfLayers >
                 (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
             ? trackNumberOfHits - pcNumberOfLayers -
                   (pat::PackedCandidate::trackPixelHitsMask + pat::PackedCandidate::trackStripHitsMask)
             : 0;
     // PackedCandidate counts overflow pixel hits as strip
     const int pixelInducedStripOverflow =
         (trackNumberOfStripHits + pixelOverflow - pcNumberOfStripLayers) > pat::PackedCandidate::trackStripHitsMask
             ? (trackNumberOfStripHits + pixelOverflow - stripOverflow - pcNumberOfStripLayers) -
                   pat::PackedCandidate::trackStripHitsMask
             : 0;
     h_numberPixelLayersOverMax->Fill(pixelLayerOverflow);
     h_numberStripLayersOverMax->Fill(stripLayerOverflow);
     h_numberLayersOverMax->Fill(layerOverflow);
     h_numberPixelHitsOverMax->Fill(pixelOverflow);
     h_numberStripHitsOverMax->Fill(stripOverflow);
     h_numberHitsOverMax->Fill(hitsOverflow);
 
     int diffNumberOfPixelHits = 0;
     int diffNumberOfHits = 0;
     int diffNumberOfPixelLayers = 0;
     int diffNumberOfStripLayers = 0;
     if (pixelLayerOverflow) {
       diffNumberOfPixelLayers = pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask;
     } else {
       diffNumberOfPixelLayers = pcNumberOfPixelLayers - trackNumberOfPixelLayers;
     }
     if (pixelOverflow) {
       diffNumberOfPixelHits = pcNumberOfPixelHits - pcNumberOfPixelLayers - pat::PackedCandidate::trackPixelHitsMask;
     } else {
       diffNumberOfPixelHits = pcNumberOfPixelHits - trackNumberOfPixelHits;
     }
     if (stripLayerOverflow) {
       diffNumberOfStripLayers = pcNumberOfStripLayers - pat::PackedCandidate::trackStripHitsMask;
     } else {
       diffNumberOfStripLayers = pcNumberOfStripLayers - trackNumberOfStripLayers;
     }
     if (stripOverflow || pixelInducedStripOverflow || pixelOverflow) {
       int diffNumberOfStripHits = 0;
       if (stripOverflow || pixelInducedStripOverflow) {
         diffNumberOfStripHits = pcNumberOfStripHits - pat::PackedCandidate::trackStripHitsMask;
       } else if (pixelOverflow) {
         diffNumberOfStripHits = (pcNumberOfStripHits - pixelOverflow) - trackNumberOfStripHits;
       }
 
       diffNumberOfHits = diffNumberOfPixelHits + diffNumberOfStripHits;
     } else {
       diffNumberOfHits = pcNumberOfHits - trackNumberOfHits;
     }
 
     fillNoFlow(h_diffNumberOfPixelHits, diffNumberOfPixelHits);
     fillNoFlow(h_diffNumberOfHits, diffNumberOfHits);
     fillNoFlow(h_diffNumberOfPixelLayers, diffNumberOfPixelLayers);
     fillNoFlow(h_diffNumberOfStripLayers, diffNumberOfStripLayers);
 
     int diffLostInnerHits = 0;
     const auto trackLostInnerHits = track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS);
     switch (pcRef->lostInnerHits()) {
       case pat::PackedCandidate::validHitInFirstPixelBarrelLayer:
       case pat::PackedCandidate::noLostInnerHits:
         diffLostInnerHits = -trackLostInnerHits;
         break;
       case pat::PackedCandidate::oneLostInnerHit:
         diffLostInnerHits = 1 - trackLostInnerHits;
         break;
       case pat::PackedCandidate::moreLostInnerHits:
         diffLostInnerHits = trackLostInnerHits >= 2 ? 0 : 2 - trackLostInnerHits;
         break;
     }
     fillNoFlow(h_diffLostInnerHits, diffLostInnerHits);
 
     // For HitPattern ones, calculate the full diff (i.e. some differences are expected)
     auto diffHitPatternPixelLayersWithMeasurement =
         trackPc.hitPattern().pixelLayersWithMeasurement() - trackNumberOfPixelLayers;
     fillNoFlow(h_diffHitPatternPixelLayersWithMeasurement, diffHitPatternPixelLayersWithMeasurement);
     auto diffHitPatternStripLayersWithMeasurement =
         trackPc.hitPattern().stripLayersWithMeasurement() - trackNumberOfStripLayers;
     fillNoFlow(h_diffHitPatternStripLayersWithMeasurement, diffHitPatternStripLayersWithMeasurement);
     auto diffHitPatternTrackerLayersWithMeasurement =
         trackPc.hitPattern().trackerLayersWithMeasurement() - trackNumberOfLayers;
     fillNoFlow(h_diffHitPatternTrackerLayersWithMeasurement, diffHitPatternTrackerLayersWithMeasurement);
     auto diffHitPatternNumberOfValidPixelHits = trackPc.hitPattern().numberOfValidPixelHits() - trackNumberOfPixelHits;
     fillNoFlow(h_diffHitPatternNumberOfValidPixelHits, diffHitPatternNumberOfValidPixelHits);
     auto diffHitPatternNumberOfValidHits = trackPc.hitPattern().numberOfValidHits() - trackNumberOfHits;
     fillNoFlow(h_diffHitPatternNumberOfValidHits, diffHitPatternNumberOfValidHits);
     fillNoFlow(h_diffHitPatternNumberOfLostInnerHits,
                trackPc.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) -
                    track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS));
 
     // hasValidHitInFirstPixelBarrel is set only if numberOfLostHits(MISSING_INNER_HITS) == 0
     int diffHitPatternHasValidHitInFirstPixelBarrel = 0;
     if (track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_INNER_HITS) == 0) {
       h_selectionFlow->Fill(sf_NoMissingInnerHits);
       diffHitPatternHasValidHitInFirstPixelBarrel =
           static_cast<int>(
               trackPc.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1)) -
           static_cast<int>(track.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1));
       fillNoFlow(h_diffHitPatternHasValidHitInFirstPixelBarrel, diffHitPatternHasValidHitInFirstPixelBarrel);
     }
 
     // Print warning if there are differences outside the expected range
     if (debug_ &&
         (diffNormalizedChi2 < -1 || diffNormalizedChi2 > 0 || diffCharge != 0 || diffHP != 0 ||
          std::abs(diffPhi) > 5e-4 || diffDxyAssocPV.outsideExpectedRange() || diffDzAssocPV.outsideExpectedRange() ||
          std::abs(diffDxyPV) > 0.05 || std::abs(diffDzPV) > 0.05 || diffCovQoverpQoverp.outsideExpectedRange() ||
          diffCovLambdaLambda.outsideExpectedRange() || diffCovLambdaDsz.outsideExpectedRange() ||
          diffCovPhiPhi.outsideExpectedRange() || diffCovPhiDxy.outsideExpectedRange() ||
          diffCovDxyDxy.outsideExpectedRange() || diffCovDxyDsz.outsideExpectedRange() ||
          diffCovDszDsz.outsideExpectedRange() || diffNumberOfPixelHits != 0 || diffNumberOfHits != 0 ||
          diffLostInnerHits != 0 || diffHitPatternHasValidHitInFirstPixelBarrel != 0)) {
       edm::LogInfo("PackedCandidateTrackValidator")
           << "Track " << i << " pt " << track.pt() << " eta " << track.eta() << " phi " << track.phi() << " chi2 "
           << track.chi2() << " ndof " << track.ndof() << "\n"
           << "  ptError " << track.ptError() << " etaError " << track.etaError() << " phiError " << track.phiError()
           << " dxyError " << track.dxyError() << " dzError " << track.dzError() << "\n"
           << "  refpoint " << track.referencePoint() << " momentum " << track.momentum() << "\n"
           << "  dxy " << track.dxy() << " dz " << track.dz() << "\n"
           << "  " << TrackAlgoPrinter(track) << " lost inner hits " << trackLostInnerHits << " lost outer hits "
           << track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS) << " hitpattern "
           << HitPatternPrinter(track) << " \n"
           << " PC " << pcRef.id() << ":" << pcRef.key() << " track pt " << trackPc.pt() << " eta " << trackPc.eta()
           << " phi " << trackPc.phi() << " (PC " << pcRef->phi() << ") chi2 " << trackPc.chi2() << " ndof "
           << trackPc.ndof() << " pdgId " << pcRef->pdgId() << " mass " << pcRef->mass() << "\n"
           << "  ptError " << trackPc.ptError() << " etaError " << trackPc.etaError() << " phiError "
           << trackPc.phiError() << "\n"
           << "  pc.vertex " << pcRef->vertex() << " momentum " << pcRef->momentum() << " track " << trackPc.momentum()
           << "\n"
           << "  dxy " << trackPc.dxy() << " dz " << trackPc.dz() << " pc.dz " << pcRef->dz() << " dxyError "
           << trackPc.dxyError() << " dzError " << trackPc.dzError() << "\n"
           << "  dxy(PV) " << trackPc.dxy(pv.position()) << " dz(PV) " << trackPc.dz(pv.position()) << " dxy(assocPV) "
           << trackPc.dxy(pcVertex.position()) << " dz(assocPV) " << trackPc.dz(pcVertex.position()) << "\n"
           << " (diff PackedCandidate track)"
           << " highPurity " << diffHP << " " << trackPc.quality(reco::TrackBase::highPurity) << " "
           << track.quality(reco::TrackBase::highPurity) << " charge " << diffCharge << " " << trackPc.charge() << " "
           << track.charge() << " normalizedChi2 " << diffNormalizedChi2 << " " << trackPc.normalizedChi2() << " "
           << track.normalizedChi2() << "\n "
           << " numberOfAllHits " << diffNumberOfHits << " " << pcNumberOfHits << " " << trackNumberOfHits
           << " numberOfPixelHits " << diffNumberOfPixelHits << " " << pcNumberOfPixelHits << " "
           << trackNumberOfPixelHits << " numberOfStripHits # " << pcNumberOfStripHits << " " << trackNumberOfStripHits
           << "\n "
           << " hitPattern.numberOfValidPixelHits " << diffHitPatternNumberOfValidPixelHits << " "
           << trackPc.hitPattern().numberOfValidPixelHits() << " " << track.hitPattern().numberOfValidPixelHits()
           << " hitPattern.numberOfValidHits " << diffHitPatternNumberOfValidHits << " "
           << trackPc.hitPattern().numberOfValidHits() << " " << track.hitPattern().numberOfValidHits()
           << " hitPattern.hasValidHitInFirstPixelBarrel " << diffHitPatternHasValidHitInFirstPixelBarrel << " "
           << trackPc.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1) << " "
           << track.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1) << "\n "
           << " lostInnerHits  " << diffLostInnerHits << " " << pcRef->lostInnerHits() << " #"
           << " phi (5e-4) " << diffPhi << " " << trackPc.phi() << " " << track.phi() << "\n "
           << " dxy(assocPV) " << diffDxyAssocPV << "\n "
           << " dz(assocPV) " << diffDzAssocPV << "\n "
           << " dxy(PV) (0.05) " << diffDxyPV << " " << pcRef->dxy(pv.position()) << " " << track.dxy(pv.position())
           << "\n "
           << " dz(PV) (0.05) " << diffDzPV << " " << pcRef->dz(pv.position()) << " " << track.dz(pv.position()) << "\n "
           << " cov(qoverp, qoverp)  " << diffCovQoverpQoverp << "\n "
           << " cov(lambda, lambda) " << diffCovLambdaLambda << "\n "
           << " cov(lambda, dsz) " << diffCovLambdaDsz << "\n "
           << " cov(phi, phi) " << diffCovPhiPhi << "\n "
           << " cov(phi, dxy) " << diffCovPhiDxy << "\n "
           << " cov(dxy, dxy) " << diffCovDxyDxy << "\n "
           << " cov(dxy, dsz) " << diffCovDxyDsz << "\n "
           << " cov(dsz, dsz) " << diffCovDszDsz;
     }
   }
 }

void PackedCandidateTrackValidator::bookHistograms	(	DQMStore::IBooker &	iBooker,
		edm::Run const &	,
		edm::EventSetup const &
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 526 of file PackedCandidateTrackValidator.cc.

References dqm::dqmstoreimpl::DQMStore::IBooker::book1D(), constexpr, h_diffCharge, h_diffCovDszDsz, h_diffCovDxyDsz, h_diffCovDxyDxy, h_diffCovLambdaDsz, h_diffCovLambdaLambda, h_diffCovPhiDxy, h_diffCovPhiPhi, h_diffCovQoverpQoverp, h_diffDszError, h_diffDxyAssocPV, h_diffDxyError, h_diffDxyPV, h_diffDzAssocPV, h_diffDzError, h_diffDzPV, h_diffEta, h_diffEtaError, h_diffHitPatternHasValidHitInFirstPixelBarrel, h_diffHitPatternNumberOfLostInnerHits, h_diffHitPatternNumberOfValidHits, h_diffHitPatternNumberOfValidPixelHits, h_diffHitPatternPixelLayersWithMeasurement, h_diffHitPatternStripLayersWithMeasurement, h_diffHitPatternTrackerLayersWithMeasurement, h_diffIsHighPurity, h_diffLostInnerHits, h_diffNdof, h_diffNormalizedChi2, h_diffNumberOfHits, h_diffNumberOfPixelHits, h_diffNumberOfPixelLayers, h_diffNumberOfStripLayers, h_diffPhi, h_diffPt, h_diffPtError, h_diffTrackDxyAssocPV, h_diffTrackDxyError, h_diffTrackDzAssocPV, h_diffTrackDzError, h_diffVx, h_diffVy, h_diffVz, h_numberHitsOverMax, h_numberLayersOverMax, h_numberPixelHitsOverMax, h_numberPixelLayersOverMax, h_numberStripHitsOverMax, h_numberStripLayersOverMax, h_selectionFlow, rootFolder_, dqm::impl::MonitorElement::setBinLabel(), and dqm::dqmstoreimpl::DQMStore::IBooker::setCurrentFolder().

                                                                          {
   iBooker.setCurrentFolder(rootFolder_);
 
   h_selectionFlow = iBooker.book1D("selectionFlow", "Track selection flow", 8, -0.5, 7.5);
   h_selectionFlow->setBinLabel(1, "All tracks");
   h_selectionFlow->setBinLabel(2, "Associated to PackedCandidate");
   h_selectionFlow->setBinLabel(3, "PC is charged"), h_selectionFlow->setBinLabel(4, "PC has track");
   h_selectionFlow->setBinLabel(5, "PC is not electron");
   h_selectionFlow->setBinLabel(6, "PC has hits");
   h_selectionFlow->setBinLabel(7, "PC ndof != 0");
   h_selectionFlow->setBinLabel(8, "Track: no missing inner hits");
 
   constexpr int diffBins = 50;
 
   h_diffVx =
       iBooker.book1D("diffVx", "PackedCandidate::bestTrack() - reco::Track in vx()", diffBins, -0.2, 0.2);  // not equal
   h_diffVy =
       iBooker.book1D("diffVy", "PackedCandidate::bestTrack() - reco::Track in vy()", diffBins, -0.2, 0.2);  // not equal
   h_diffVz =
       iBooker.book1D("diffVz", "PackedCandidate::bestTrack() - reco::Track in vz()", diffBins, -0.4, 0.4);  // not equal
 
   h_diffNormalizedChi2 = iBooker.book1D("diffNormalizedChi2",
                                         "PackedCandidate::bestTrack() - reco::Track in normalizedChi2()",
                                         30,
                                         -1.5,
                                         1.5);  // expected difference in -1...0
   h_diffNdof = iBooker.book1D(
       "diffNdof", "PackedCandidate::bestTrack() - reco::Track in ndof()", 33, -30.5, 2.5);  // to monitor the difference
 
   h_diffCharge = iBooker.book1D(
       "diffCharge", "PackedCandidate::bestTrack() - reco::Track in charge()", 5, -2.5, 2.5);  // expect equality
   h_diffIsHighPurity = iBooker.book1D("diffIsHighPurity",
                                       "PackedCandidate::bestTrack() - reco::Track in quality(highPurity)",
                                       3,
                                       -1.5,
                                       1.5);  // expect equality
 
   h_diffPt = iBooker.book1D("diffPt",
                             "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in pt()",
                             diffBins,
                             -1.1,
                             1.1);  // not equal, keep
   h_diffEta = iBooker.book1D(
       "diffEta", "PackedCandidate::bestTrack() - reco::Track in eta()", diffBins, -0.001, 0.001);  // not equal, keep
   h_diffPhi = iBooker.book1D("diffPhi",
                              "PackedCandidate::bestTrack() - reco::Track in phi()",
                              diffBins,
                              -0.0005,
                              0.0005);  // expect equality within precision
 
   h_diffDxyAssocPV.book(iBooker,
                         "diffDxyAssocPV",
                         "(PackedCandidate::dxy() - reco::Track::dxy(assocPV))/reco::Track",
                         40,
                         -0.001,
                         0.001,  // expect equality within precision
                         50,
                         -0.5,
                         0.5);
   h_diffDzAssocPV.book(iBooker,
                        "diffDzAssocPV",
                        "(PackedCandidate::dzAssociatedPV() - reco::Track::dz(assocPV))/reco::Track",
                        40,
                        -0.001,
                        0.001,  // expect equality within precision
                        50,
                        -0.5,
                        0.5);
   h_diffDxyPV = iBooker.book1D("diffDxyPV",
                                "(PackedCandidate::dxy(PV) - reco::Track::dxy(PV))/reco::Track",
                                diffBins,
                                -0.01,
                                0.01);  // expect equality within precision (worse than assocPV)
   h_diffDzPV = iBooker.book1D("diffDzPV",
                               "(PackedCandidate::dz(PV) - reco::Track::dz(PV))/reco::Track",
                               diffBins,
                               -0.01,
                               0.01);  // expect equality wihtin precision (worse than assocPV)
   h_diffTrackDxyAssocPV =
       iBooker.book1D("diffTrackDxyAssocPV",
                      "(PackedCandidate::bestTrack()::dxy(assocPV)) - reco::Track::dxy(assocPV))/reco::Track",
                      diffBins,
                      -0.01,
                      0.01);  // not equal
   h_diffTrackDzAssocPV =
       iBooker.book1D("diffTrackDzAssocPV",
                      "(PackedCandidate::bestTrack()::dz(assocPV)) - reco::Track::dz(assocPV))/reco::Track",
                      diffBins,
                      -0.01,
                      0.01);  // not equal
 
   h_diffCovQoverpQoverp.book(iBooker,
                              "diffCovQoverpQoverp",
                              "(PackedCandidate::bestTrack() - reco::Track)/reco::track in cov(qoverp, qoverp)",
                              40,
                              -0.05,
                              0.15,  // expect equality within precision (worst precision is exp(1/128*15) =~ 12 %
                              50,
                              -0.5,
                              0.5);
   h_diffCovLambdaLambda.book(
       iBooker,
       "diffCovLambdaLambda",
       "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, lambda)",
       40,
       -0.05,
       0.15,  // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
       50,
       -0.5,
       0.5);
   h_diffCovLambdaDsz.book(iBooker,
                           "diffCovLambdaDsz",
                           "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, dsz)",
                           60,
                           -0.15,
                           0.15,  // expect equality within precision, worst precision is exp(1/128*(17-4) =~ 11 %
                           50,
                           -1,
                           1);
   h_diffCovPhiPhi.book(
       iBooker,
       "diffCovPhiPhi",
       "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, phi)",
       40,
       -0.05,
       0.15,  // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
       50,
       -0.5,
       0.5);
   h_diffCovPhiDxy.book(iBooker,
                        "diffCovPhiDxy",
                        "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, dxy)",
                        60,
                        -0.15,
                        0.15,  // expect equality within precision, wors precision is exp(1/128)*(17-4) =~ 11 %
                        50,
                        -1,
                        1);
   h_diffCovDxyDxy.book(iBooker,
                        "diffCovDxyDxy",
                        "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dxy)",
                        40,
                        -0.001,
                        0.001,
                        50,
                        -0.1,
                        0.1);
   h_diffCovDxyDsz.book(iBooker,
                        "diffCovDxyDsz",
                        "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dsz)",
                        40,
                        -0.001,
                        0.001,  // expect equality within precision
                        50,
                        -0.5,
                        0.5);
   h_diffCovDszDsz.book(iBooker,
                        "diffCovDszDsz",
                        "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dsz, dsz)",
                        40,
                        -0.001,
                        0.001,  // expect equality within precision
                        50,
                        -0.1,
                        0.1);
 
   h_diffDxyError = iBooker.book1D("diffDxyError",
                                   "(PackedCandidate::dxyError() - reco::Track::dxyError())/reco::Track",
                                   40,
                                   -0.001,
                                   0.001);  // expect equality within precision
   h_diffDszError = iBooker.book1D("diffDszError",
                                   "(PackedCandidate::dzError() - reco::Track::dszError())/reco::Track",
                                   40,
                                   -0.001,
                                   0.001);  // ideally, not equal, but for now they are
   h_diffDzError = iBooker.book1D("diffDzError",
                                  "(PackedCandidate::dzError() - reco::Track::dzError())/reco::Track",
                                  40,
                                  -0.001,
                                  0.001);  // expect equality within precision (not currently the case)
 
   h_diffTrackDxyError = iBooker.book1D("diffTrackDxyError",
                                        "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dxyError()",
                                        40,
                                        -0.001,
                                        0.001);  // expect equality within precision
   h_diffTrackDzError = iBooker.book1D("diffTrackDzError",
                                       "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dzError()",
                                       40,
                                       -0.05,
                                       0.05);  // not equal
 
   h_diffPtError = iBooker.book1D("diffPtError",
                                  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in ptError()",
                                  diffBins,
                                  -1.1,
                                  1.1);  // not equal
   h_diffEtaError = iBooker.book1D("diffEtaError",
                                   "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in etaError()",
                                   60,
                                   -0.15,
                                   0.15);  // not equal
 
   h_diffNumberOfPixelLayers = iBooker.book1D(
       "diffNumberOfPixelLayers",
       "PackedCandidate::pixelLayersWithMeasurement() - reco::Track::hitPattern::pixelLayersWithMeasurement()",
       5,
       -2.5,
       2.5);  // expect equality
   h_diffNumberOfStripLayers = iBooker.book1D(
       "diffNumberOfStripLayers",
       "PackedCandidate::stripLayersWithMeasurement() - reco::Track::hitPattern::stripLayersWithMeasurement()",
       5,
       -2.5,
       2.5);  // expect equality
   h_diffNumberOfPixelHits =
       iBooker.book1D("diffNumberOfPixelHits",
                      "PackedCandidate::numberOfPixelHits() - reco::Track::hitPattern::numberOfValidPixelHits()",
                      5,
                      -2.5,
                      2.5);  // expect equality
   h_diffNumberOfHits = iBooker.book1D("diffNumberOfHits",
                                       "PackedCandidate::numberHits() - reco::Track::hitPattern::numberOfValidHits()",
                                       5,
                                       -2.5,
                                       2.5);  // expect equality
   h_diffLostInnerHits =
       iBooker.book1D("diffLostInnerHits",
                      "PackedCandidate::lostInnerHits() - reco::Track::hitPattern::numberOfLostHits(MISSING_INNER_HITS)",
                      5,
                      -2.5,
                      2.5);  // expect equality
 
   h_diffHitPatternPixelLayersWithMeasurement =
       iBooker.book1D("diffHitPatternPixelLayersWithMeasurement",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::pixelLayersWithMeasurement()",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternStripLayersWithMeasurement =
       iBooker.book1D("diffHitPatternStripLayersWithMeasurement",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::stripLayersWithMeasurement()",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternTrackerLayersWithMeasurement =
       iBooker.book1D("diffHitPatternTrackerLayersWithMeasurement",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::trackerLayersWithMeasurement()",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternNumberOfValidPixelHits =
       iBooker.book1D("diffHitPatternNumberOfValidPixelHits",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidPixelHits()",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternNumberOfValidHits =
       iBooker.book1D("diffHitPatternNumberOfValidHits",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidHits()",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternNumberOfLostInnerHits =
       iBooker.book1D("diffHitPatternNumberOfLostPixelHits",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfLostHits(MISSING_INNER_HITS)",
                      13,
                      -10.5,
                      2.5);  // not equal
   h_diffHitPatternHasValidHitInFirstPixelBarrel =
       iBooker.book1D("diffHitPatternHasValidHitInFirstPixelBarrel",
                      "PackedCandidate::bestTrack() - reco::Track in hitPattern::hasValidHitInFirstPixelBarrel",
                      3,
                      -1.5,
                      1.5);  // expect equality
 
   h_numberPixelLayersOverMax = iBooker.book1D(
       "numberPixelLayersOverMax", "Number of pixel layers over the maximum of PackedCandidate", 10, 0, 10);
   h_numberStripLayersOverMax = iBooker.book1D(
       "numberStripLayersOverMax", "Number of strip layers over the maximum of PackedCandidate", 10, 0, 10);
   h_numberLayersOverMax =
       iBooker.book1D("numberLayersOverMax", "Number of layers over the maximum of PackedCandidate", 20, 0, 20);
   h_numberPixelHitsOverMax =
       iBooker.book1D("numberPixelHitsOverMax", "Number of pixel hits over the maximum of PackedCandidate", 10, 0, 10);
   h_numberStripHitsOverMax =
       iBooker.book1D("numberStripHitsOverMax", "Number of strip hits over the maximum of PackedCandidate", 10, 0, 10);
   h_numberHitsOverMax =
       iBooker.book1D("numberHitsOverMax", "Number of hits over the maximum of PackedCandidate", 20, 0, 20);
 }

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

static

Definition at line 514 of file PackedCandidateTrackValidator.cc.

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

                                                                                                {
   edm::ParameterSetDescription desc;
 
   desc.addUntracked<edm::InputTag>("tracks", edm::InputTag("generalTracks"));
   desc.addUntracked<edm::InputTag>("vertices", edm::InputTag("offlinePrimaryVertices"));
   desc.addUntracked<edm::InputTag>("trackToPackedCandidateAssociation", edm::InputTag("packedPFCandidates"));
   desc.addUntracked<std::string>("rootFolder", "Tracking/PackedCandidate");
   desc.addUntracked<bool>("debug", false);
 
   descriptions.add("packedCandidateTrackValidator", desc);
 }