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

void	calculateAndFillResolution (const std::vector< reco::TransientTrack > &tracks, size_t nvertices, const LumiScalersCollection &lumiScalers, 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_

MonitorElement *	hDiffX_ = 0

MonitorElement *	hDiffY_ = 0

MonitorElement *	hDiffZ_ = 0

MonitorElement *	hPullX_ = 0

MonitorElement *	hPullY_ = 0

MonitorElement *	hPullZ_ = 0

Detailed Description

Definition at line 206 of file PrimaryVertexResolution.cc.

Constructor & Destructor Documentation

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

inline

Definition at line 208 of file PrimaryVertexResolution.cc.

                                                      :
       binningX_(binX),
       binningY_(binY),
       hDiff_Ntracks_("ntracks", binY),
       hDiff_sumPt_("sumpt", binY),
       hDiff_Nvertices_("nvertices", binY),
       hDiff_instLumiScal_("instLumiScal", binY)
     {}

Member Function Documentation

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

inline

Definition at line 217 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_);
 
       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_));
     }

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

Definition at line 394 of file PrimaryVertexResolution.cc.

References DEFINE_FWK_MODULE, end, mps_fire::i, PrimaryVertexResolution::Resolution::pullx(), PrimaryVertexResolution::Resolution::pully(), PrimaryVertexResolution::Resolution::pullz(), PrimaryVertexResolution::Resolution::resx(), PrimaryVertexResolution::Resolution::resy(), PrimaryVertexResolution::Resolution::resz(), 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(!lumiScalers.empty()) {
     hDiff_instLumiScal_.fill(res, lumiScalers.front().instantLumi());
   }
 }