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 one::DQMEDAnalyzer< T >
	DQMEDAnalyzer ()=default

	DQMEDAnalyzer (DQMEDAnalyzer< T... > const &)=delete

	DQMEDAnalyzer (DQMEDAnalyzer< T... > &&)=delete

	~DQMEDAnalyzer () override=default

Static Public Member Functions
static void	fillDescriptions (edm::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_

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 &
	)

override

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(), jetUpdater_cfi::sort, 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;
 }