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

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

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

void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer ()

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

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

virtual bool	getCanSaveByLumi ()

Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
	EDProducer ()=default

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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

Static Public Member Functions inherited from DQMEDAnalyzer
static void	globalEndJob (DQMEDAnalyzerGlobalCache const *)

static void	globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)

static void	globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)

static std::unique_ptr< DQMEDAnalyzerGlobalCache >	initializeGlobalCache (edm::ParameterSet const &)

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::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
using	CacheTypes = CacheContexts< T... >

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T... >

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

Protected Member Functions inherited from DQMEDAnalyzer
uint64_t	meId () const

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

edm::EDPutTokenT< DQMToken >	runToken_

unsigned int	streamId_

Detailed Description

Definition at line 400 of file PackedCandidateTrackValidator.cc.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

private

Enumerator
sf_AllTracks
sf_AssociatedToPC
sf_PCIsCharged
sf_PCHasTrack
sf_PCIsNotElectron
sf_PCHasHits
sf_PCNdofNot0
sf_NoMissingInnerHits

Definition at line 418 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::PackedCandidateTrackValidator ( const edm::ParameterSet & pset )

Definition at line 492 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::~PackedCandidateTrackValidator ( )

override

Definition at line 511 of file PackedCandidateTrackValidator.cc.

511 {}

Member Function Documentation

◆ analyze()

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

overridevirtual

Reimplemented from DQMEDAnalyzer.

Definition at line 818 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;
     }
   }
 }

◆ bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 525 of file PackedCandidateTrackValidator.cc.

References dqm::implementation::IBooker::book1D(), ALPAKA_ACCELERATOR_NAMESPACE::brokenline::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::implementation::NavigatorBase::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);
 }

◆ fillDescriptions()

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

static

Definition at line 513 of file PackedCandidateTrackValidator.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::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);
 }