Inheritance diagram for PrimaryVertexResolution:

Classes
struct	BinningX

struct	BinningY

class	DiffPlots

class	Plots

class	Resolution

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

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

	PrimaryVertexResolution (const edm::ParameterSet &iConfig)

	~PrimaryVertexResolution () override

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

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

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

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

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

	DQMEDAnalyzer ()

	DQMEDAnalyzer (DQMEDAnalyzer const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer &&)=delete

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

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

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

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

	~DQMEDAnalyzer () override=default

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

SerialTaskQueue *	globalLuminosityBlocksQueue () final

SerialTaskQueue *	globalRunsQueue () final

bool	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () const final

bool	wantsGlobalLuminosityBlocks () const final

bool	wantsGlobalRuns () const final

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

ModuleDescription const &	moduleDescription () const

bool	wantsStreamLuminosityBlocks () const

bool	wantsStreamRuns () const

	~EDProducerBase () override

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

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

	ProducerBase ()

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

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

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

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

	~ProducerBase () noexcept(false) override

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

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

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

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

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

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

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

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

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

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

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const

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

virtual	~EDConsumerBase () noexcept(false)

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Private Member Functions
std::vector< reco::TransientTrack >	sortTracksByPt (const reco::Vertex &thePV, const TransientTrackBuilder &ttBuilder, const reco::BeamSpot &beamspot)

Private Attributes
edm::EDGetTokenT< reco::BeamSpot >	beamspotSrc_

BinningX	binningX_

BinningY	binningY_

std::mt19937	engine_

AdaptiveVertexFitter	fitter_

Plots	hOtherV_

Plots	hPV_

edm::EDGetTokenT< LumiScalersCollection >	lumiScalersSrc_

std::string	rootFolder_

std::string	transientTrackBuilder_

edm::EDGetTokenT< reco::VertexCollection >	vertexSrc_

Additional Inherited Members
Public Types inherited from edm::one::EDProducerBase
typedef EDProducerBase	ModuleType

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

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Protected Member Functions inherited from edm::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)

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

edm::EDPutTokenT< DQMToken >	runToken_

Detailed Description

Definition at line 47 of file PrimaryVertexResolution.cc.

Constructor & Destructor Documentation

PrimaryVertexResolution::PrimaryVertexResolution ( const edm::ParameterSet & iConfig )

Definition at line 274 of file PrimaryVertexResolution.cc.

                                                                               :
   vertexSrc_(consumes<reco::VertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("vertexSrc"))),
   beamspotSrc_(consumes<reco::BeamSpot>(iConfig.getUntrackedParameter<edm::InputTag>("beamspotSrc"))),
   lumiScalersSrc_(consumes<LumiScalersCollection>(iConfig.getUntrackedParameter<edm::InputTag>("lumiScalersSrc"))),
   rootFolder_(iConfig.getUntrackedParameter<std::string>("rootFolder")),
   transientTrackBuilder_(iConfig.getUntrackedParameter<std::string>("transientTrackBuilder")),
   binningX_(iConfig),
   binningY_(iConfig),
   hPV_(binningX_, binningY_),
   hOtherV_(binningX_, binningY_)
 {}

PrimaryVertexResolution::~PrimaryVertexResolution ( )

override

Definition at line 286 of file PrimaryVertexResolution.cc.

286 {}

Member Function Documentation

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

override

Definition at line 329 of file PrimaryVertexResolution.cc.

References beamspotSrc_, PrimaryVertexResolution::Plots::calculateAndFillResolution(), engine_, edm::EventID::event(), fitter_, edm::EventSetup::get(), edm::Event::getByToken(), hOtherV_, hPV_, edm::EventBase::id(), edm::EventID::luminosityBlock(), lumiScalersSrc_, edm::EventID::run(), reco::Vertex::size, sortTracksByPt(), reco::Vertex::tracksSize(), transientTrackBuilder_, vertexSrc_, and electrons_cff::vertices.

                                                                                          {
   edm::Handle<reco::VertexCollection> hvertices;
   iEvent.getByToken(vertexSrc_, hvertices);
   const reco::VertexCollection& vertices = *hvertices;
   if(vertices.empty())
     return;
 
   edm::Handle<reco::BeamSpot> hbeamspot;
   iEvent.getByToken(beamspotSrc_, hbeamspot);
   const reco::BeamSpot& beamspot = *hbeamspot;
 
   edm::Handle<LumiScalersCollection> hscalers;
   iEvent.getByToken(lumiScalersSrc_, hscalers);
   const LumiScalersCollection& lumiScalers = *hscalers;
 
   edm::ESHandle<TransientTrackBuilder> ttBuilderHandle;
   iSetup.get<TransientTrackRecord>().get(transientTrackBuilder_, ttBuilderHandle);
   const TransientTrackBuilder& ttBuilder = *ttBuilderHandle;
 
   // deterministic seed from the event number
   // should not bias the result as the event number is already
   // assigned randomly-enough
   engine_.seed( iEvent.id().event() + (iEvent.id().luminosityBlock()<<10) + (iEvent.id().run()<<20) );
 
   // The PV
   auto iPV = cbegin(vertices);
   const reco::Vertex& thePV = *iPV;
   const auto nvertices = vertices.size();
   if(thePV.tracksSize() >= 4) {
     auto sortedTracks = sortTracksByPt(thePV, ttBuilder, beamspot);
     hPV_.calculateAndFillResolution(sortedTracks, nvertices, lumiScalers, engine_, fitter_);
   }
   ++iPV;
 
   // Other vertices
   for(auto endPV = cend(vertices); iPV != endPV; ++iPV) {
     if(iPV->tracksSize() >= 4) {
       auto sortedTracks = sortTracksByPt(*iPV, ttBuilder, beamspot);
       hOtherV_.calculateAndFillResolution(sortedTracks, nvertices, lumiScalers, engine_, fitter_);
     }
   }
 }

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 321 of file PrimaryVertexResolution.cc.

References PrimaryVertexResolution::Plots::book(), hOtherV_, hPV_, rootFolder_, and DQMStore::IBooker::setCurrentFolder().

                                                                                                           {
   iBooker.setCurrentFolder(rootFolder_+"/PV");
   hPV_.book(iBooker);
 
   iBooker.setCurrentFolder(rootFolder_+"/OtherV");
   hOtherV_.book(iBooker);
 }

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

static

Definition at line 288 of file PrimaryVertexResolution.cc.

References edm::ConfigurationDescriptions::add(), edm::ParameterSetDescription::addUntracked(), SiPixelPhase1TrackClustersV_cfi::e3, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                          {
   edm::ParameterSetDescription desc;
   desc.addUntracked<edm::InputTag>("vertexSrc", edm::InputTag("trackingDQMgoodOfflinePrimaryVertices"));
   desc.addUntracked<edm::InputTag>("beamspotSrc", edm::InputTag("offlineBeamSpot"));
   desc.addUntracked<edm::InputTag>("lumiScalersSrc", edm::InputTag("scalersRawToDigi"));
   desc.addUntracked<std::string>("rootFolder", "OfflinePV/Resolution");
   desc.addUntracked<std::string>("transientTrackBuilder", "TransientTrackBuilder");
 
   // Y axes
   desc.addUntracked<double>("maxResol", 0.02);
   desc.addUntracked<int>("binsResol", 100);
 
   desc.addUntracked<double>("maxPull", 5);
   desc.addUntracked<int>("binsPull", 100);
 
   // X axes
   desc.addUntracked<double>("minNtracks", -0.5);
   desc.addUntracked<double>("maxNtracks", 119.5);
   desc.addUntracked<int>("binsNtracks", 60);
 
   desc.addUntracked<double>("minNvertices", -0.5);
   desc.addUntracked<double>("maxNvertices", 199.5);
   desc.addUntracked<int>("binsNvertices", 100);
 
   desc.addUntracked<double>("minPt", 1);
   desc.addUntracked<double>("maxPt", 1e3);
 
   desc.addUntracked<double>("minLumi", 200.);
   desc.addUntracked<double>("maxLumi", 20000.);
 
   descriptions.add("primaryVertexResolution", desc);
 }

std::vector< reco::TransientTrack > PrimaryVertexResolution::sortTracksByPt	(	const reco::Vertex &	thePV,
		const TransientTrackBuilder &	ttBuilder,
		const reco::BeamSpot &	beamspot
	)

private

Definition at line 372 of file PrimaryVertexResolution.cc.

References a, b, TransientTrackBuilder::build(), reco::TrackBase::pt(), HiIsolationCommonParameters_cff::track, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::tracksSize(), create_public_lumi_plots::transform, and groupFilesInBlocks::tt.

Referenced by analyze().

                                                                                                         {
   std::vector<const reco::Track *> sortedTracks;
   sortedTracks.reserve(thePV.tracksSize());
   std::transform(thePV.tracks_begin(), thePV.tracks_end(), std::back_inserter(sortedTracks), [](const reco::TrackBaseRef& ref) {
       return &(*ref);
     });
   std::sort(sortedTracks.begin(), sortedTracks.end(), [](const reco::Track *a, const reco::Track *b) {
       return a->pt() > b->pt();
     });
 
   std::vector<reco::TransientTrack> ttracks;
   ttracks.reserve(sortedTracks.size());
   std::transform(sortedTracks.begin(), sortedTracks.end(), std::back_inserter(ttracks), [&](const reco::Track *track) {
       auto tt =  ttBuilder.build(track);
       tt.setBeamSpot(beamspot);
       return tt;
     });
   return ttracks;
 }