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)

virtual	~PackedCandidateTrackValidator ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual 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

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

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_diffIsHighPurity

MonitorElement *	h_diffLostInnerHits

MonitorElement *	h_diffNdof

MonitorElement *	h_diffNormalizedChi2

MonitorElement *	h_diffNumberOfHits

MonitorElement *	h_diffNumberOfPixelHits

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_numberPixelHitsOverMax

MonitorElement *	h_numberStripHitsOverMax

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 423 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 441 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 508 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 ( )

virtual

Definition at line 525 of file PackedCandidateTrackValidator.cc.

525 {}

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 628 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 int pixelOverflow = trackNumberOfPixelHits > pat::PackedCandidate::trackPixelHitsMask ? trackNumberOfPixelHits - pat::PackedCandidate::trackPixelHitsMask : 0;
     const int stripOverflow = trackNumberOfStripHits > pat::PackedCandidate::trackStripHitsMask ? trackNumberOfStripHits - pat::PackedCandidate::trackStripHitsMask : 0;
     const int hitsOverflow = trackNumberOfHits > (pat::PackedCandidate::trackPixelHitsMask+pat::PackedCandidate::trackStripHitsMask) ? trackNumberOfHits - (pat::PackedCandidate::trackPixelHitsMask+pat::PackedCandidate::trackStripHitsMask) : 0;
     // PackedCandidate counts overflow pixel hits as strip
     const int pixelInducedStripOverflow = (trackNumberOfStripHits+pixelOverflow) > pat::PackedCandidate::trackStripHitsMask ? (trackNumberOfStripHits+pixelOverflow-stripOverflow) - pat::PackedCandidate::trackStripHitsMask : 0;
     h_numberPixelHitsOverMax->Fill(pixelOverflow);
     h_numberStripHitsOverMax->Fill(stripOverflow);
     h_numberHitsOverMax->Fill(hitsOverflow);
 
     int diffNumberOfPixelHits = 0;
     int diffNumberOfHits = 0;
     if(pixelOverflow) {
       diffNumberOfPixelHits = pcNumberOfPixelHits - pat::PackedCandidate::trackPixelHitsMask;
     }
     else {
       diffNumberOfPixelHits = pcNumberOfPixelHits - trackNumberOfPixelHits;
     }
     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);
 
     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 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().hasValidHitInFirstPixelBarrel()) - static_cast<int>(track.hitPattern().hasValidHitInFirstPixelBarrel());
       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 "
                                                     << " numberOfHits " << 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().hasValidHitInFirstPixelBarrel() << " " << track.hitPattern().hasValidHitInFirstPixelBarrel()
                                                     << "\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 538 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_diffIsHighPurity, h_diffLostInnerHits, h_diffNdof, h_diffNormalizedChi2, h_diffNumberOfHits, h_diffNumberOfPixelHits, h_diffPhi, h_diffPt, h_diffPtError, h_diffTrackDxyAssocPV, h_diffTrackDxyError, h_diffTrackDzAssocPV, h_diffTrackDzError, h_diffVx, h_diffVy, h_diffVz, h_numberHitsOverMax, h_numberPixelHitsOverMax, h_numberStripHitsOverMax, 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_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_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_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 527 of file PackedCandidateTrackValidator.cc.

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

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