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	beginRun (edm::Run const &, edm::EventSetup const &) final
void	beginStream (edm::StreamID id) final
virtual void	dqmBeginRun (edm::Run const &, edm::EventSetup const &)
	DQMEDAnalyzer (void)
void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final
uint32_t	streamId () const
Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default
Public Member Functions inherited from edm::stream::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
	~EDAnalyzerBase () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr< dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)
static std::shared_ptr< dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)
static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *, dqmDetails::NoCache *)
static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *, dqmDetails::NoCache *)
Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Private Attributes
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 edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
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
Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Definition at line 434 of file PackedCandidateTrackValidator.cc.

Member Enumeration Documentation

anonymous enum

private

Enumerator
sf_AllTracks
sf_AssociatedToPC
sf_PCIsCharged
sf_PCHasTrack
sf_PCIsNotElectron
sf_PCHasHits
sf_PCNdofNot0
sf_NoMissingInnerHits

Definition at line 452 of file PackedCandidateTrackValidator.cc.

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

Constructor & Destructor Documentation

PackedCandidateTrackValidator::PackedCandidateTrackValidator

(

const edm::ParameterSet &

pset

)

Definition at line 527 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")),
  h_diffDxyAssocPV(RangeAbs(0.001)),
  h_diffDzAssocPV(RangeAbs(0.001)),
  h_diffCovQoverpQoverp(Range(-1e-6, 0.13), -15, 0),  // despite of ceil in pack, there is rounding in double->float
  h_diffCovLambdaLambda(Range(-1e-6, 0.13), -20, -5), // despite of ceil in pack, there is rounding in double->float
  h_diffCovLambdaDsz(RangeAbs(0.13), -17, -4),
  h_diffCovPhiPhi(RangeAbs(0.13), -15, 0),
  h_diffCovPhiDxy(RangeAbs(0.13), -17, -4),
  h_diffCovDxyDxy(RangeAbs(0.001)),
  h_diffCovDxyDsz(RangeAbs(0.001)),
  h_diffCovDszDsz(RangeAbs(0.001))
{}

PackedCandidateTrackValidator::~PackedCandidateTrackValidator ( )

override

Definition at line 544 of file PackedCandidateTrackValidator.cc.

{}

Member Function Documentation

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

override

Definition at line 655 of file PackedCandidateTrackValidator.cc.

References funct::abs(), reco::TrackBase::charge(), reco::TrackBase::chi2(), reco::TrackBase::covariance(), DEFINE_FWK_MODULE, reco::deltaPhi(), reco::TrackBase::dszError(), reco::TrackBase::dxy(), reco::TrackBase::dxyError(), reco::TrackBase::dz(), reco::TrackBase::dzError(), MillePedeFileConverter_cfg::e, reco::TrackBase::eta(), reco::TrackBase::etaError(), MonitorElement::Fill(), edm::Event::getByToken(), 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(), edm::Ref< C, T, F >::isNull(), 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(), reco::HitPattern::numberOfValidStripHits(), 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(), reco::TrackBase::referencePoint(), sf_AllTracks, sf_AssociatedToPC, sf_NoMissingInnerHits, sf_PCHasHits, sf_PCHasTrack, sf_PCIsCharged, sf_PCIsNotElectron, sf_PCNdofNot0, reco::HitPattern::stripLayersWithMeasurement(), HiIsolationCommonParameters_cff::track, reco::HitPattern::trackerLayersWithMeasurement(), pat::PackedCandidate::trackPixelHitsMask, l1t::tracks, tracksToken_, pat::PackedCandidate::trackStripHitsMask, trackToPackedCandidateToken_, heppy_batch::val, pat::PackedCandidate::validHitInFirstPixelBarrelLayer, electrons_cff::vertices, verticesToken_, reco::TrackBase::vx(), reco::TrackBase::vy(), and reco::TrackBase::vz().

                                                                                               {
  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(diffNormalizedChi2 < -1 || diffNormalizedChi2 > 0 || diffCharge != 0 || diffHP != 0
       || std::abs(diffPhi) > 5e-4
       || diffDxyAssocPV.outsideExpectedRange()
       || diffDzAssocPV.outsideExpectedRange()
       || std::abs(diffDxyPV) > 0.05 || std::abs(diffDzPV) > 0.05
       || diffCovQoverpQoverp.outsideExpectedRange() || diffCovLambdaLambda.outsideExpectedRange()
       || diffCovLambdaDsz.outsideExpectedRange() || diffCovPhiPhi.outsideExpectedRange()
       || diffCovPhiDxy.outsideExpectedRange() || diffCovDxyDxy.outsideExpectedRange()
       || diffCovDxyDsz.outsideExpectedRange() || diffCovDszDsz.outsideExpectedRange()
       || diffNumberOfPixelHits != 0 || diffNumberOfHits != 0 || diffLostInnerHits != 0
       || diffHitPatternHasValidHitInFirstPixelBarrel != 0
       ) {

      edm::LogInfo("PackedCandidateTrackValidator") << "Track " << i << " pt " << track.pt() << " eta " << track.eta() << " phi " << track.phi() << " chi2 " << track.chi2() << " ndof " << track.ndof()
                                                    << "\n"
                                                    << "  ptError " << track.ptError() << " etaError " << track.etaError() << " phiError " << track.phiError() << " dxyError " << track.dxyError() << " dzError " << track.dzError()
                                                    << "\n"
                                                    << "  refpoint " << track.referencePoint() << " momentum " << track.momentum()
                                                    << "\n"
                                                    << "  dxy " << track.dxy() << " dz " << track.dz()
                                                    << "\n"
                                                    << "  " << TrackAlgoPrinter(track)
                                                    << " lost inner hits " << trackLostInnerHits
                                                    << " lost outer hits " << track.hitPattern().numberOfLostHits(reco::HitPattern::MISSING_OUTER_HITS)
                                                    << " hitpattern " << HitPatternPrinter(track)
                                                    << " \n"
                                                    << " PC " << pcRef.id() << ":" << pcRef.key() << " track pt " << trackPc.pt() << " eta " << trackPc.eta() << " phi " << trackPc.phi() << " (PC " << pcRef->phi() << ") chi2 " << trackPc.chi2() << " ndof " << trackPc.ndof() << " pdgId " << pcRef->pdgId() << " mass " << pcRef->mass()
                                                    << "\n"
                                                    << "  ptError " << trackPc.ptError() << " etaError " << trackPc.etaError() << " phiError " << trackPc.phiError()
                                                    << "\n"
                                                    << "  pc.vertex " << pcRef->vertex() << " momentum " << pcRef->momentum() << " track " << trackPc.momentum()
                                                    << "\n"
                                                    << "  dxy " << trackPc.dxy() << " dz " << trackPc.dz() << " pc.dz " << pcRef->dz()
                                                    << " dxyError " << trackPc.dxyError() << " dzError " << trackPc.dzError()
                                                    << "\n"
                                                    << "  dxy(PV) " << trackPc.dxy(pv.position()) << " dz(PV) " << trackPc.dz(pv.position())
                                                    << " dxy(assocPV) " << trackPc.dxy(pcVertex.position()) << " dz(assocPV) " << trackPc.dz(pcVertex.position())
                                                    << "\n"
                                                    << " (diff PackedCandidate track)"
                                                    << " highPurity " << diffHP << " " << trackPc.quality(reco::TrackBase::highPurity) << " " << track.quality(reco::TrackBase::highPurity)
                                                    << " charge " << diffCharge << " " << trackPc.charge() << " " << track.charge()
                                                    << " normalizedChi2 " << diffNormalizedChi2 << " " << trackPc.normalizedChi2() << " " << track.normalizedChi2()
                                                    << "\n "
                                                    << " numberOfAllHits " << diffNumberOfHits << " " << pcNumberOfHits << " " << trackNumberOfHits
                                                    << " numberOfPixelHits " << diffNumberOfPixelHits << " " << pcNumberOfPixelHits << " " << trackNumberOfPixelHits
                                                    << " numberOfStripHits # " << pcNumberOfStripHits << " " << trackNumberOfStripHits
                                                    << "\n "
                                                    << " hitPattern.numberOfValidPixelHits " << diffHitPatternNumberOfValidPixelHits << " " << trackPc.hitPattern().numberOfValidPixelHits() << " " << track.hitPattern().numberOfValidPixelHits()
                                                    << " hitPattern.numberOfValidHits " << diffHitPatternNumberOfValidHits << " " << trackPc.hitPattern().numberOfValidHits() << " " << track.hitPattern().numberOfValidHits()
                                                    << " hitPattern.hasValidHitInFirstPixelBarrel " << diffHitPatternHasValidHitInFirstPixelBarrel << " " << trackPc.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1) << " " << track.hitPattern().hasValidHitInPixelLayer(PixelSubdetector::SubDetector::PixelBarrel, 1)
                                                    << "\n "
                                                    << " lostInnerHits  " << diffLostInnerHits << " " << pcRef->lostInnerHits() << " #"
                                                    << " phi (5e-4) " << diffPhi << " " << trackPc.phi() << " " << track.phi()
                                                    << "\n "
                                                    << " dxy(assocPV) " << diffDxyAssocPV
                                                    << "\n "
                                                    << " dz(assocPV) " << diffDzAssocPV
                                                    << "\n "
                                                    << " dxy(PV) (0.05) " << diffDxyPV << " " << pcRef->dxy(pv.position()) << " " << track.dxy(pv.position())
                                                    << "\n "
                                                    << " dz(PV) (0.05) " << diffDzPV << " " << pcRef->dz(pv.position()) << " " << track.dz(pv.position())
                                                    << "\n "
                                                    << " cov(qoverp, qoverp)  " << diffCovQoverpQoverp
                                                    << "\n "
                                                    << " cov(lambda, lambda) " << diffCovLambdaLambda
                                                    << "\n "
                                                    << " cov(lambda, dsz) " << diffCovLambdaDsz
                                                    << "\n "
                                                    << " cov(phi, phi) " << diffCovPhiPhi
                                                    << "\n "
                                                    << " cov(phi, dxy) " << diffCovPhiDxy
                                                    << "\n "
                                                    << " cov(dxy, dxy) " << diffCovDxyDxy
                                                    << "\n "
                                                    << " cov(dxy, dsz) " << diffCovDxyDsz
                                                    << "\n "
                                                    << " cov(dsz, dsz) " << diffCovDszDsz;
    }
  }
}

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 557 of file PackedCandidateTrackValidator.cc.

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

                                                                                                                {
  iBooker.setCurrentFolder(rootFolder_);

  h_selectionFlow = iBooker.book1D("selectionFlow", "Track selection flow", 8, -0.5, 7.5);
  h_selectionFlow->setBinLabel(1, "All tracks");
  h_selectionFlow->setBinLabel(2, "Associated to PackedCandidate");
  h_selectionFlow->setBinLabel(3, "PC is charged"),
  h_selectionFlow->setBinLabel(4, "PC has track");
  h_selectionFlow->setBinLabel(5, "PC is not electron");
  h_selectionFlow->setBinLabel(6, "PC has hits");
  h_selectionFlow->setBinLabel(7, "PC ndof != 0");
  h_selectionFlow->setBinLabel(8, "Track: no missing inner hits");

  constexpr int diffBins = 50;

  h_diffVx = iBooker.book1D("diffVx", "PackedCandidate::bestTrack() - reco::Track in vx()", diffBins, -0.2, 0.2); // not equal
  h_diffVy = iBooker.book1D("diffVy", "PackedCandidate::bestTrack() - reco::Track in vy()", diffBins, -0.2, 0.2); // not equal
  h_diffVz = iBooker.book1D("diffVz", "PackedCandidate::bestTrack() - reco::Track in vz()", diffBins, -0.4, 0.4); // not equal

  h_diffNormalizedChi2 = iBooker.book1D("diffNormalizedChi2", "PackedCandidate::bestTrack() - reco::Track in normalizedChi2()", 30, -1.5, 1.5); // expected difference in -1...0
  h_diffNdof = iBooker.book1D("diffNdof", "PackedCandidate::bestTrack() - reco::Track in ndof()", 33, -30.5, 2.5); // to monitor the difference

  h_diffCharge = iBooker.book1D("diffCharge", "PackedCandidate::bestTrack() - reco::Track in charge()", 5, -2.5, 2.5); // expect equality
  h_diffIsHighPurity = iBooker.book1D("diffIsHighPurity", "PackedCandidate::bestTrack() - reco::Track in quality(highPurity)", 3, -1.5, 1.5); // expect equality

  h_diffPt     = iBooker.book1D("diffPt",     "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in pt()",     diffBins, -1.1, 1.1); // not equal, keep
  h_diffEta    = iBooker.book1D("diffEta",    "PackedCandidate::bestTrack() - reco::Track in eta()",    diffBins, -0.001, 0.001); // not equal, keep
  h_diffPhi    = iBooker.book1D("diffPhi",    "PackedCandidate::bestTrack() - reco::Track in phi()",    diffBins, -0.0005, 0.0005); // expect equality within precision

  h_diffDxyAssocPV.book(iBooker, "diffDxyAssocPV", "(PackedCandidate::dxy() - reco::Track::dxy(assocPV))/reco::Track",
                        40, -0.001, 0.001, // expect equality within precision
                        50, -0.5, 0.5);
  h_diffDzAssocPV.book(iBooker, "diffDzAssocPV","(PackedCandidate::dzAssociatedPV() - reco::Track::dz(assocPV))/reco::Track",
                       40, -0.001, 0.001, // expect equality within precision
                       50, -0.5, 0.5);
  h_diffDxyPV      = iBooker.book1D("diffDxyPV",      "(PackedCandidate::dxy(PV) - reco::Track::dxy(PV))/reco::Track",              diffBins, -0.01, 0.01); // expect equality within precision (worse than assocPV)
  h_diffDzPV       = iBooker.book1D("diffDzPV",       "(PackedCandidate::dz(PV) - reco::Track::dz(PV))/reco::Track",                diffBins, -0.01, 0.01); // expect equality wihtin precision (worse than assocPV)
  h_diffTrackDxyAssocPV   = iBooker.book1D("diffTrackDxyAssocPV",   "(PackedCandidate::bestTrack()::dxy(assocPV)) - reco::Track::dxy(assocPV))/reco::Track",         diffBins, -0.01, 0.01); // not equal
  h_diffTrackDzAssocPV    = iBooker.book1D("diffTrackDzAssocPV",    "(PackedCandidate::bestTrack()::dz(assocPV)) - reco::Track::dz(assocPV))/reco::Track",           diffBins, -0.01, 0.01); // not equal

  h_diffCovQoverpQoverp.book(iBooker, "diffCovQoverpQoverp", "(PackedCandidate::bestTrack() - reco::Track)/reco::track in cov(qoverp, qoverp)",
                             40, -0.05, 0.15, // expect equality within precision (worst precision is exp(1/128*15) =~ 12 %
                             50, -0.5, 0.5); 
  h_diffCovLambdaLambda.book(iBooker, "diffCovLambdaLambda",  "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, lambda)",
                             40, -0.05, 0.15, // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
                             50, -0.5, 0.5); 
  h_diffCovLambdaDsz.book(iBooker, "diffCovLambdaDsz",     "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(lambda, dsz)",
                          60, -0.15, 0.15, // expect equality within precision, worst precision is exp(1/128*(17-4) =~ 11 %
                          50, -1, 1);
  h_diffCovPhiPhi.book(iBooker, "diffCovPhiPhi",    "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, phi)",
                       40, -0.05, 0.15, // expect equality within precision worst precision is exp(1/128*(20-5)) =~ 12 % (multiplied by pt^2 in packing & unpacking)
                       50, -0.5, 0.5); 
  h_diffCovPhiDxy.book(iBooker, "diffCovPhiDxy",       "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(phi, dxy)",
                       60, -0.15, 0.15, // expect equality within precision, wors precision is exp(1/128)*(17-4) =~ 11 %
                       50, -1, 1);
  h_diffCovDxyDxy.book(iBooker, "diffCovDxyDxy", "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dxy)",
                       40, -0.001, 0.001,
                       50, -0.1, 0.1);
  h_diffCovDxyDsz.book(iBooker, "diffCovDxyDsz", "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dxy, dsz)",
                       40, -0.001, 0.001, // expect equality within precision
                       50, -0.5, 0.5);
  h_diffCovDszDsz.book(iBooker, "diffCovDszDsz", "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in cov(dsz, dsz)",
                       40, -0.001, 0.001, // expect equality within precision
                       50, -0.1, 0.1);

  h_diffDxyError    = iBooker.book1D("diffDxyError", "(PackedCandidate::dxyError() - reco::Track::dxyError())/reco::Track", 40, -0.001, 0.001); // expect equality within precision
  h_diffDszError    = iBooker.book1D("diffDszError", "(PackedCandidate::dzError() - reco::Track::dszError())/reco::Track",  40, -0.001, 0.001);  // ideally, not equal, but for now they are
  h_diffDzError     = iBooker.book1D("diffDzError",  "(PackedCandidate::dzError() - reco::Track::dzError())/reco::Track",   40, -0.001, 0.001); // expect equality within precision (not currently the case)

  h_diffTrackDxyError    = iBooker.book1D("diffTrackDxyError",    "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dxyError()",    40, -0.001, 0.001); // expect equality within precision
  h_diffTrackDzError     = iBooker.book1D("diffTrackDzError",     "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in dzError()",     40, -0.05, 0.05); // not equal

  h_diffPtError     = iBooker.book1D("diffPtError",     "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in ptError()",     diffBins, -1.1, 1.1); // not equal
  h_diffEtaError    = iBooker.book1D("diffEtaError",    "(PackedCandidate::bestTrack() - reco::Track)/reco::Track in etaError()",    60, -0.15, 0.15); // not equal


  h_diffNumberOfPixelLayers = iBooker.book1D("diffNumberOfPixelLayers", "PackedCandidate::pixelLayersWithMeasurement() - reco::Track::hitPattern::pixelLayersWithMeasurement()", 5, -2.5, 2.5); // expect equality 
  h_diffNumberOfStripLayers = iBooker.book1D("diffNumberOfStripLayers", "PackedCandidate::stripLayersWithMeasurement() - reco::Track::hitPattern::stripLayersWithMeasurement()",             5, -2.5, 2.5); // expect equality
  h_diffNumberOfPixelHits = iBooker.book1D("diffNumberOfPixelHits", "PackedCandidate::numberOfPixelHits() - reco::Track::hitPattern::numberOfValidPixelHits()", 5, -2.5, 2.5); // expect equality 
  h_diffNumberOfHits      = iBooker.book1D("diffNumberOfHits",      "PackedCandidate::numberHits() - reco::Track::hitPattern::numberOfValidHits()",             5, -2.5, 2.5); // expect equality
  h_diffLostInnerHits     = iBooker.book1D("diffLostInnerHits",     "PackedCandidate::lostInnerHits() - reco::Track::hitPattern::numberOfLostHits(MISSING_INNER_HITS)",      5, -2.5, 2.5); // expect equality

  h_diffHitPatternPixelLayersWithMeasurement = iBooker.book1D("diffHitPatternPixelLayersWithMeasurement", "PackedCandidate::bestTrack() - reco::Track in hitPattern::pixelLayersWithMeasurement()",   13, -10.5, 2.5); // not equal
  h_diffHitPatternStripLayersWithMeasurement = iBooker.book1D("diffHitPatternStripLayersWithMeasurement", "PackedCandidate::bestTrack() - reco::Track in hitPattern::stripLayersWithMeasurement()",   13, -10.5, 2.5); // not equal
  h_diffHitPatternTrackerLayersWithMeasurement = iBooker.book1D("diffHitPatternTrackerLayersWithMeasurement", "PackedCandidate::bestTrack() - reco::Track in hitPattern::trackerLayersWithMeasurement()",   13, -10.5, 2.5); // not equal
  h_diffHitPatternNumberOfValidPixelHits = iBooker.book1D("diffHitPatternNumberOfValidPixelHits", "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidPixelHits()",   13, -10.5, 2.5); // not equal
  h_diffHitPatternNumberOfValidHits      = iBooker.book1D("diffHitPatternNumberOfValidHits",      "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfValidHits()",      13, -10.5, 2.5); // not equal
  h_diffHitPatternNumberOfLostInnerHits  = iBooker.book1D("diffHitPatternNumberOfLostPixelHits",  "PackedCandidate::bestTrack() - reco::Track in hitPattern::numberOfLostHits(MISSING_INNER_HITS)", 13, -10.5, 2.5); // not equal
  h_diffHitPatternHasValidHitInFirstPixelBarrel = iBooker.book1D("diffHitPatternHasValidHitInFirstPixelBarrel", "PackedCandidate::bestTrack() - reco::Track in hitPattern::hasValidHitInFirstPixelBarrel", 3, -1.5, 1.5); // expect equality

  h_numberPixelLayersOverMax = iBooker.book1D("numberPixelLayersOverMax", "Number of pixel layers over the maximum of PackedCandidate", 10, 0, 10);
  h_numberStripLayersOverMax = iBooker.book1D("numberStripLayersOverMax", "Number of strip layers over the maximum of PackedCandidate", 10, 0, 10);
  h_numberLayersOverMax = iBooker.book1D("numberLayersOverMax", "Number of layers over the maximum of PackedCandidate", 20, 0, 20);
  h_numberPixelHitsOverMax = iBooker.book1D("numberPixelHitsOverMax", "Number of pixel hits over the maximum of PackedCandidate", 10, 0, 10);
  h_numberStripHitsOverMax = iBooker.book1D("numberStripHitsOverMax", "Number of strip hits over the maximum of PackedCandidate", 10, 0, 10);
  h_numberHitsOverMax = iBooker.book1D("numberHitsOverMax", "Number of hits over the maximum of PackedCandidate", 20, 0, 20);
}

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

static

Definition at line 546 of file PackedCandidateTrackValidator.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), 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");

  descriptions.add("packedCandidateTrackValidator", desc);
}

Member Data Documentation

MonitorElement* PackedCandidateTrackValidator::h_diffCharge

private

Definition at line 471 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDszDsz

private

Definition at line 492 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDxyDsz

private

Definition at line 491 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffCovDxyDxy

private

Definition at line 490 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovLambdaDsz

private

Definition at line 487 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovLambdaLambda

private

Definition at line 486 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovPhiDxy

private

Definition at line 489 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovPhiPhi

private

Definition at line 488 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<LogIntHelper> PackedCandidateTrackValidator::h_diffCovQoverpQoverp

private

Definition at line 485 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffDszError

private

Definition at line 495 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffDxyAssocPV

private

Definition at line 477 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffDxyError

private

Definition at line 494 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffDxyPV

private

Definition at line 479 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

PackedValueCheck<Float16Helper> PackedCandidateTrackValidator::h_diffDzAssocPV

private

Definition at line 478 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffDzError

private

Definition at line 496 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffDzPV

private

Definition at line 480 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffEta

private

Definition at line 475 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffEtaError

private

Definition at line 502 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternHasValidHitInFirstPixelBarrel

private

Definition at line 517 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfLostInnerHits

private

Definition at line 516 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidHits

private

Definition at line 515 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternNumberOfValidPixelHits

private

Definition at line 514 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternPixelLayersWithMeasurement

private

Definition at line 511 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternStripLayersWithMeasurement

private

Definition at line 513 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffHitPatternTrackerLayersWithMeasurement

private

Definition at line 512 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffIsHighPurity

private

Definition at line 472 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffLostInnerHits

private

Definition at line 509 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNdof

private

Definition at line 469 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNormalizedChi2

private

Definition at line 468 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfHits

private

Definition at line 508 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfPixelHits

private

Definition at line 507 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfPixelLayers

private

Definition at line 505 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffNumberOfStripLayers

private

Definition at line 506 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffPhi

private

Definition at line 476 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffPt

private

Definition at line 474 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffPtError

private

Definition at line 501 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDxyAssocPV

private

Definition at line 482 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDxyError

private

Definition at line 498 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDzAssocPV

private

Definition at line 483 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffTrackDzError

private

Definition at line 499 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffVx

private

Definition at line 464 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffVy

private

Definition at line 465 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_diffVz

private

Definition at line 466 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberHitsOverMax

private

Definition at line 524 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberLayersOverMax

private

Definition at line 521 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberPixelHitsOverMax

private

Definition at line 522 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberPixelLayersOverMax

private

Definition at line 519 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberStripHitsOverMax

private

Definition at line 523 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_numberStripLayersOverMax

private

Definition at line 520 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

MonitorElement* PackedCandidateTrackValidator::h_selectionFlow

private

Definition at line 462 of file PackedCandidateTrackValidator.cc.

Referenced by analyze(), and bookHistograms().

std::string PackedCandidateTrackValidator::rootFolder_

private

Definition at line 450 of file PackedCandidateTrackValidator.cc.

Referenced by bookHistograms().

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

private

Definition at line 446 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().

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

private

Definition at line 448 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().

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

private

Definition at line 447 of file PackedCandidateTrackValidator.cc.

Referenced by analyze().