PackedCandidateTrackValidator Class Reference

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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginProcessBlocks () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndProcessBlocks () const final
bool	hasAbilityToProduceInEndRuns () const final

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 >
typedef CacheContexts< T... >	CacheTypes
typedef CacheTypes::GlobalCache	GlobalCache
typedef AbilityChecker< T... >	HasAbility
typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache
typedef LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext
typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache
typedef CacheTypes::RunCache	RunCache
typedef RunContextT< RunCache, GlobalCache >	RunContext
typedef CacheTypes::RunSummaryCache	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.

{}

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;
    }
  }
}

References funct::abs(), reco::TrackBase::charge(), reco::TrackBase::chi2(), reco::TrackBase::covariance(), debug_, reco::deltaPhi(), reco::TrackBase::dxy(), reco::TrackBase::dxyError(), reco::TrackBase::dz(), reco::TrackBase::dzError(), MillePedeFileConverter_cfg::e, reco::TrackBase::eta(), reco::TrackBase::etaError(), dqm::impl::MonitorElement::Fill(), HiBiasedCentrality_cfi::function, 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, reco::HitPattern::hasValidHitInPixelLayer(), reco::TrackBase::highPurity, reco::TrackBase::hitPattern(), mps_fire::i, reco::TrackBase::i_dsz, reco::TrackBase::i_dxy, reco::TrackBase::i_lambda, reco::TrackBase::i_phi, reco::TrackBase::i_qoverp, edm::Ref< C, T, F >::id(), iEvent, edm::Ref< C, T, F >::isNull(), dqmiolumiharvest::j, edm::Ref< C, T, F >::key(), reco::HitPattern::MISSING_INNER_HITS, reco::HitPattern::MISSING_OUTER_HITS, reco::TrackBase::momentum(), pat::PackedCandidate::moreLostInnerHits, reco::TrackBase::ndof(), pat::PackedCandidate::noLostInnerHits, reco::TrackBase::normalizedChi2(), reco::HitPattern::numberOfLostHits(), reco::HitPattern::numberOfValidHits(), reco::HitPattern::numberOfValidPixelHits(), pat::PackedCandidate::oneLostInnerHit, reco::TrackBase::phi(), reco::TrackBase::phiError(), GeomDetEnumerators::PixelBarrel, reco::HitPattern::pixelLayersWithMeasurement(), reco::Vertex::position(), reco::TrackBase::pt(), reco::TrackBase::ptError(), MetAnalyzer::pv(), reco::TrackBase::quality(), sf_AllTracks, sf_AssociatedToPC, sf_NoMissingInnerHits, sf_PCHasHits, sf_PCHasTrack, sf_PCIsCharged, sf_PCIsNotElectron, sf_PCNdofNot0, reco::HitPattern::stripLayersWithMeasurement(), HLT_FULL_cff::track, reco::HitPattern::trackerLayersWithMeasurement(), pat::PackedCandidate::trackPixelHitsMask, tracks, tracksToken_, pat::PackedCandidate::trackStripHitsMask, trackToPackedCandidateToken_, heppy_batch::val, pat::PackedCandidate::validHitInFirstPixelBarrelLayer, pwdgSkimBPark_cfi::vertices, verticesToken_, reco::TrackBase::vx(), reco::TrackBase::vy(), and reco::TrackBase::vz().

bookHistograms()

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 525 of file PackedCandidateTrackValidator.cc.

                                                                         {
  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);
}

References dqm::implementation::IBooker::book1D(), 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().

fillDescriptions()

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

static

Definition at line 513 of file PackedCandidateTrackValidator.cc.

                                                                                               {
  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);
}

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, HLT_FULL_cff::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

Member Data Documentation

debug_

bool PackedCandidateTrackValidator::debug_

private

Definition at line 416 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().

h_diffCharge

MonitorElement* PackedCandidateTrackValidator::h_diffCharge

private

Definition at line 437 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovDszDsz

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDszDsz

private

Definition at line 458 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovDxyDsz

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDxyDsz

private

Definition at line 457 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovDxyDxy

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDxyDxy

private

Definition at line 456 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovLambdaDsz

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovLambdaDsz

private

Definition at line 453 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovLambdaLambda

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovLambdaLambda

private

Definition at line 452 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovPhiDxy

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovPhiDxy

private

Definition at line 455 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovPhiPhi

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovPhiPhi

private

Definition at line 454 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffCovQoverpQoverp

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovQoverpQoverp

private

Definition at line 451 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDszError

MonitorElement* PackedCandidateTrackValidator::h_diffDszError

private

Definition at line 461 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDxyAssocPV

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffDxyAssocPV

private

Definition at line 443 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDxyError

MonitorElement* PackedCandidateTrackValidator::h_diffDxyError

private

Definition at line 460 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDxyPV

MonitorElement* PackedCandidateTrackValidator::h_diffDxyPV

private

Definition at line 445 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDzAssocPV

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffDzAssocPV

private

Definition at line 444 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDzError

MonitorElement* PackedCandidateTrackValidator::h_diffDzError

private

Definition at line 462 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffDzPV

MonitorElement* PackedCandidateTrackValidator::h_diffDzPV

private

Definition at line 446 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffEta

MonitorElement* PackedCandidateTrackValidator::h_diffEta

private

Definition at line 441 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffEtaError

MonitorElement* PackedCandidateTrackValidator::h_diffEtaError

private

Definition at line 468 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternHasValidHitInFirstPixelBarrel

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternHasValidHitInFirstPixelBarrel

private

Definition at line 482 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternNumberOfLostInnerHits

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfLostInnerHits

private

Definition at line 481 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternNumberOfValidHits

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidHits

private

Definition at line 480 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternNumberOfValidPixelHits

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidPixelHits

private

Definition at line 479 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternPixelLayersWithMeasurement

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternPixelLayersWithMeasurement

private

Definition at line 476 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternStripLayersWithMeasurement

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternStripLayersWithMeasurement

private

Definition at line 478 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffHitPatternTrackerLayersWithMeasurement

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternTrackerLayersWithMeasurement

private

Definition at line 477 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffIsHighPurity

MonitorElement* PackedCandidateTrackValidator::h_diffIsHighPurity

private

Definition at line 438 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffLostInnerHits

MonitorElement* PackedCandidateTrackValidator::h_diffLostInnerHits

private

Definition at line 474 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNdof

MonitorElement* PackedCandidateTrackValidator::h_diffNdof

private

Definition at line 435 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNormalizedChi2

MonitorElement* PackedCandidateTrackValidator::h_diffNormalizedChi2

private

Definition at line 434 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNumberOfHits

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfHits

private

Definition at line 473 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNumberOfPixelHits

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfPixelHits

private

Definition at line 472 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNumberOfPixelLayers

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfPixelLayers

private

Definition at line 470 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffNumberOfStripLayers

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfStripLayers

private

Definition at line 471 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffPhi

MonitorElement* PackedCandidateTrackValidator::h_diffPhi

private

Definition at line 442 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffPt

MonitorElement* PackedCandidateTrackValidator::h_diffPt

private

Definition at line 440 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffPtError

MonitorElement* PackedCandidateTrackValidator::h_diffPtError

private

Definition at line 467 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffTrackDxyAssocPV

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDxyAssocPV

private

Definition at line 448 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffTrackDxyError

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDxyError

private

Definition at line 464 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffTrackDzAssocPV

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDzAssocPV

private

Definition at line 449 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffTrackDzError

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDzError

private

Definition at line 465 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffVx

MonitorElement* PackedCandidateTrackValidator::h_diffVx

private

Definition at line 430 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffVy

MonitorElement* PackedCandidateTrackValidator::h_diffVy

private

Definition at line 431 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_diffVz

MonitorElement* PackedCandidateTrackValidator::h_diffVz

private

Definition at line 432 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberHitsOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberHitsOverMax

private

Definition at line 489 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberLayersOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberLayersOverMax

private

Definition at line 486 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberPixelHitsOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberPixelHitsOverMax

private

Definition at line 487 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberPixelLayersOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberPixelLayersOverMax

private

Definition at line 484 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberStripHitsOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberStripHitsOverMax

private

Definition at line 488 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_numberStripLayersOverMax

MonitorElement* PackedCandidateTrackValidator::h_numberStripLayersOverMax

private

Definition at line 485 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

h_selectionFlow

MonitorElement* PackedCandidateTrackValidator::h_selectionFlow

private

Definition at line 428 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

rootFolder_

std::string PackedCandidateTrackValidator::rootFolder_

private

Definition at line 415 of file PackedCandidateTrackValidator.cc.

Referenced by bookHistograms().

tracksToken_

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

private

Definition at line 411 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().

trackToPackedCandidateToken_

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

private

Definition at line 413 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().

verticesToken_

edm::EDGetTokenT<reco::VertexCollection> PackedCandidateTrackValidator::verticesToken_

private

Definition at line 412 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().