Public Member Functions
void	book (DQMStore::IBooker &iBooker)

void	calculateAndFillResolution (const std::vector< reco::TransientTrack > &tracks, size_t nvertices, float lumi, std::mt19937 &engine, AdaptiveVertexFitter &fitter)

	Plots (const BinningX &binX, const BinningY &binY)

Private Attributes
const BinningX &	binningX_

const BinningY &	binningY_

DiffPlots	hDiff_instLumiScal_

DiffPlots	hDiff_Ntracks_

DiffPlots	hDiff_Nvertices_

DiffPlots	hDiff_sumPt_

DiffPlots	hDiff_X_

DiffPlots	hDiff_Y_

DiffPlots	hDiff_Z_

MonitorElement *	hDiffX_ = nullptr

MonitorElement *	hDiffY_ = nullptr

MonitorElement *	hDiffZ_ = nullptr

MonitorElement *	hPullX_ = nullptr

MonitorElement *	hPullY_ = nullptr

MonitorElement *	hPullZ_ = nullptr

Detailed Description

Definition at line 252 of file PrimaryVertexResolution.cc.

Constructor & Destructor Documentation

◆ Plots()

PrimaryVertexResolution::Plots::Plots	(	const BinningX &	binX,
		const BinningY &	binY
	)

inline

Definition at line 254 of file PrimaryVertexResolution.cc.

         : binningX_(binX),
           binningY_(binY),
           hDiff_Ntracks_("ntracks", binY),
           hDiff_sumPt_("sumpt", binY),
           hDiff_Nvertices_("nvertices", binY),
           hDiff_X_("X", binY),
           hDiff_Y_("Y", binY),
           hDiff_Z_("Z", binY),
           hDiff_instLumiScal_("instLumiScal", binY) {}

Member Function Documentation

◆ book()

void PrimaryVertexResolution::Plots::book ( DQMStore::IBooker & iBooker )

inline

Definition at line 265 of file PrimaryVertexResolution.cc.

Referenced by PrimaryVertexResolution::bookHistograms().

                                         {
       const auto binsResol = binningY_.binsResol_;
       const auto maxResol = binningY_.maxResol_;
       hDiffX_ = iBooker.book1D("res_x", "Resolution of X", binsResol, -maxResol, maxResol);
       hDiffY_ = iBooker.book1D("res_y", "Resolution of Y", binsResol, -maxResol, maxResol);
       hDiffZ_ = iBooker.book1D("res_z", "Resolution of Z", binsResol, -maxResol, maxResol);
 
       const auto binsPull = binningY_.binsPull_;
       const auto maxPull = binningY_.maxPull_;
       hPullX_ = iBooker.book1D(+"pull_x", "Pull of X", binsPull, -maxPull, maxPull);
       hPullY_ = iBooker.book1D(+"pull_y", "Pull of Y", binsPull, -maxPull, maxPull);
       hPullZ_ = iBooker.book1D(+"pull_z", "Pull of Z", binsPull, -maxPull, maxPull);
 
       hDiff_Ntracks_.book(iBooker, binningX_.binsNtracks_, binningX_.minNtracks_, binningX_.maxNtracks_);
       hDiff_Nvertices_.book(iBooker, binningX_.binsNvertices_, binningX_.minNvertices_, binningX_.maxNvertices_);
       hDiff_X_.book(iBooker, binningX_.binsXY_, -binningX_.maxXY_, binningX_.maxXY_);
       hDiff_Y_.book(iBooker, binningX_.binsXY_, -binningX_.maxXY_, binningX_.maxXY_);
       hDiff_Z_.book(iBooker, binningX_.binsZ_, -binningX_.maxZ_, binningX_.maxZ_);
 
       constexpr int binsPt = 30;
       hDiff_sumPt_.bookLogX(iBooker, makeLogBins<float, binsPt>(binningX_.minPt_, binningX_.maxPt_));
 
       constexpr int binsLumi = 100;
       hDiff_instLumiScal_.bookLogX(iBooker, makeLogBins<float, binsLumi>(binningX_.minLumi_, binningX_.maxLumi_));
     }

◆ calculateAndFillResolution()

void PrimaryVertexResolution::Plots::calculateAndFillResolution	(	const std::vector< reco::TransientTrack > &	tracks,
		size_t	nvertices,
		float	lumi,
		std::mt19937 &	engine,
		AdaptiveVertexFitter &	fitter
	)

Definition at line 463 of file PrimaryVertexResolution.cc.

References mps_fire::end, PrimaryVertexResolution::DiffPlots::fill(), dqm::impl::MonitorElement::Fill(), hDiff_instLumiScal_, hDiff_Ntracks_, hDiff_Nvertices_, hDiff_sumPt_, hDiff_X_, hDiff_Y_, hDiff_Z_, hDiffX_, hDiffY_, hDiffZ_, hPullX_, hPullY_, hPullZ_, mps_fire::i, TransientVertex::isValid(), tracks, and AdaptiveVertexFitter::vertex().

Referenced by PrimaryVertexResolution::analyze().

                                                                                               {
   const size_t end = tracks.size() % 2 == 0 ? tracks.size() : tracks.size() - 1;
 
   std::vector<reco::TransientTrack> set1, set2;
   set1.reserve(end / 2);
   set2.reserve(end / 2);
 
   auto dis = std::uniform_int_distribution<>(0, 1);  // [0, 1]
 
   double sumpt1 = 0, sumpt2 = 0;
   for (size_t i = 0; i < end; i += 2) {
     const size_t set1_i = dis(engine);
     const size_t set2_i = 1 - set1_i;
 
     set1.push_back(tracks[i + set1_i]);
     set2.push_back(tracks[i + set2_i]);
 
     sumpt1 += set1.back().track().pt();
     sumpt2 += set2.back().track().pt();
   }
 
   // For resolution we only fit
   TransientVertex vertex1 = fitter.vertex(set1);
   TransientVertex vertex2 = fitter.vertex(set2);
 
   Resolution res(vertex1, vertex2);
   hDiffX_->Fill(res.resx());
   hDiffY_->Fill(res.resy());
   hDiffZ_->Fill(res.resz());
   hPullX_->Fill(res.pullx());
   hPullY_->Fill(res.pully());
   hPullZ_->Fill(res.pullz());
 
   hDiff_Ntracks_.fill(res, set1.size());
   hDiff_sumPt_.fill(
       res,
       (sumpt1 + sumpt2) /
           2.0);  // taking average is probably the best we can do, anyway they should be close to each other
   hDiff_Nvertices_.fill(res, nvertices);
 
   if (vertex1.isValid() && vertex2.isValid()) {
     hDiff_X_.fill(res, res.avgx());
     hDiff_Y_.fill(res, res.avgy());
     hDiff_Z_.fill(res, res.avgz());
   }
 
   hDiff_instLumiScal_.fill(res, lumi);
 }