#include <PrimaryVertexMonitor.h>

Inheritance diagram for PrimaryVertexMonitor:

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

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

	PrimaryVertexMonitor (const edm::ParameterSet &pSet)

	~PrimaryVertexMonitor () 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)

Private Types
using	VertexScore = edm::ValueMap< float >

Private Member Functions
void	pvTracksPlots (const reco::Vertex &v)

void	vertexPlots (const reco::Vertex &v, const reco::BeamSpot &beamSpot, int i)

Private Attributes
std::string	AlignmentLabel_

edm::InputTag	beamSpotInputTag_

edm::EDGetTokenT< reco::BeamSpot >	beamspotToken_

MonitorElement *	bsBeamWidthX

MonitorElement *	bsBeamWidthY

MonitorElement *	bsDxdz

MonitorElement *	bsDydz

MonitorElement *	bsSigmaZ

MonitorElement *	bsType

MonitorElement *	bsX

MonitorElement *	bsY

MonitorElement *	bsZ

MonitorElement *	chi2ndf

MonitorElement *	chi2prob

edm::ParameterSet	conf_

std::string	dqmLabel

MonitorElement *	dxy

MonitorElement *	dxy2

MonitorElement *	dxyErr

MonitorElement *	dxyVsEta_pt1

MonitorElement *	dxyVsEta_pt10

MonitorElement *	dxyVsPhi_pt1

MonitorElement *	dxyVsPhi_pt10

MonitorElement *	dz

MonitorElement *	dzErr

MonitorElement *	dzVsEta_pt1

MonitorElement *	dzVsEta_pt10

MonitorElement *	dzVsPhi_pt1

MonitorElement *	dzVsPhi_pt10

bool	errorPrinted_

MonitorElement *	nans [2]

MonitorElement *	nbgvtx

MonitorElement *	nbtksinvtx [2]

MonitorElement *	nbvtx

int	ndof_

MonitorElement *	ntracks

MonitorElement *	ntracksVsZ [2]

MonitorElement *	score [2]

edm::EDGetTokenT< VertexScore >	scoreToken_

MonitorElement *	sumpt

std::string	TopFolderName_

MonitorElement *	trksWeight [2]

MonitorElement *	tt [2]

MonitorElement *	type [2]

edm::InputTag	vertexInputTag_

edm::EDGetTokenT< reco::VertexCollection >	vertexToken_

MonitorElement *	vtxchi2 [2]

MonitorElement *	vtxndf [2]

MonitorElement *	vtxprob [2]

MonitorElement *	weight

MonitorElement *	xDiff [2]

MonitorElement *	xerr [2]

MonitorElement *	xerrVsTrks [2]

MonitorElement *	xrec [2]

MonitorElement *	yDiff [2]

MonitorElement *	yerr [2]

MonitorElement *	yerrVsTrks [2]

MonitorElement *	yrec [2]

MonitorElement *	zerr [2]

MonitorElement *	zerrVsTrks [2]

MonitorElement *	zrec [2]

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

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

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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 27 of file PrimaryVertexMonitor.h.

Member Typedef Documentation

using PrimaryVertexMonitor::VertexScore = edm::ValueMap<float>

private

Definition at line 43 of file PrimaryVertexMonitor.h.

Constructor & Destructor Documentation

PrimaryVertexMonitor::PrimaryVertexMonitor ( const edm::ParameterSet & pSet )

explicit

Definition at line 16 of file PrimaryVertexMonitor.cc.

References beamSpotInputTag_, beamspotToken_, edm::ParameterSet::getParameter(), scoreToken_, vertexInputTag_, and vertexToken_.

   : conf_          ( pSet )
   , TopFolderName_ ( pSet.getParameter<std::string>("TopFolderName")  )
   , AlignmentLabel_( pSet.getParameter<std::string>("AlignmentLabel") )
   , ndof_          ( pSet.getParameter<int>        ("ndof")           )
   , errorPrinted_  ( false )
   , nbvtx(nullptr)
   , bsX(nullptr)
   , bsY(nullptr)
   , bsZ(nullptr)
   , bsSigmaZ(nullptr)
   , bsDxdz(nullptr)
   , bsDydz(nullptr)
   , bsBeamWidthX(nullptr)
   , bsBeamWidthY(nullptr)
   , bsType(nullptr)
   , sumpt(nullptr)
   , ntracks(nullptr)
   , weight(nullptr)
   , chi2ndf(nullptr)
   , chi2prob(nullptr)
   , dxy(nullptr)
   , dxy2(nullptr)
   , dz(nullptr)
   , dxyErr(nullptr)
   , dzErr(nullptr)
   , dxyVsPhi_pt1(nullptr)
   , dzVsPhi_pt1(nullptr)
   , dxyVsEta_pt1(nullptr)
   , dzVsEta_pt1(nullptr)
   , dxyVsPhi_pt10(nullptr)
   , dzVsPhi_pt10(nullptr)
   , dxyVsEta_pt10(nullptr)
   , dzVsEta_pt10(nullptr)
 {
   //  dqmStore_ = edm::Service<DQMStore>().operator->();
 
 
   vertexInputTag_   = pSet.getParameter<InputTag>("vertexLabel");
   beamSpotInputTag_ = pSet.getParameter<InputTag>("beamSpotLabel");
   vertexToken_   = consumes<reco::VertexCollection>(vertexInputTag_);
   scoreToken_    = consumes<VertexScore>           (vertexInputTag_);
   beamspotToken_ = consumes<reco::BeamSpot>        (beamSpotInputTag_);
 
 }

PrimaryVertexMonitor::~PrimaryVertexMonitor ( )

override

Definition at line 242 of file PrimaryVertexMonitor.cc.

243 {}

Member Function Documentation

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

override

Definition at line 245 of file PrimaryVertexMonitor.cc.

References ecalDrivenElectronSeedsParameters_cff::beamSpot, beamSpotInputTag_, beamspotToken_, reco::BeamSpot::BeamWidthX(), reco::BeamSpot::BeamWidthY(), bsBeamWidthX, bsBeamWidthY, bsDxdz, bsDydz, bsSigmaZ, bsX, bsY, bsZ, reco::BeamSpot::dxdz(), reco::BeamSpot::dydz(), errorPrinted_, MonitorElement::Fill(), HcalObjRepresent::Fill(), edm::Event::getByToken(), mps_fire::i, edm::HandleBase::isValid(), nbgvtx, nbvtx, ndof_, convertSQLiteXML::ok, pvTracksPlots(), score, scoreToken_, reco::BeamSpot::sigmaZ(), mathSSE::sqrt(), findQualityFiles::v, vertexInputTag_, vertexPlots(), vertexToken_, reco::BeamSpot::x0(), reco::BeamSpot::y0(), and reco::BeamSpot::z0().

 {
 
   Handle<reco::VertexCollection> recVtxs;
   iEvent.getByToken(vertexToken_, recVtxs);
 
   Handle<VertexScore> scores;
   iEvent.getByToken(scoreToken_, scores);
 
 
   edm::Handle<reco::BeamSpot> beamSpotHandle;
   iEvent.getByToken(beamspotToken_,beamSpotHandle);
 
   //
   // check for absent products and simply "return" in that case
   //
   if (recVtxs.isValid() == false || beamSpotHandle.isValid()== false){
     edm::LogWarning("PrimaryVertexMonitor")
       <<" Some products not available in the event: VertexCollection "
       <<vertexInputTag_<<" " 
       <<recVtxs.isValid() <<" BeamSpot "
       <<beamSpotInputTag_<<" "
       <<beamSpotHandle.isValid()<<". Skipping plots for this event";
     return;
   }
 
   // check upfront that refs to track are (likely) to be valid
   {
     bool ok = true;
     for(const auto& v: *recVtxs) {
       if(v.tracksSize() > 0) {
     const auto& ref = v.trackRefAt(0);
     if(ref.isNull() || !ref.isAvailable()) {
       if (!errorPrinted_)
         edm::LogWarning("PrimaryVertexMonitor")
           << "Skipping vertex collection: " << vertexInputTag_ << " since likely the track collection the vertex has refs pointing to is missing (at least the first TrackBaseRef is null or not available)";
       else 
         errorPrinted_ = true;
       ok = false;
     }
       }
     }
     if(!ok)
       return;
   }
 
   BeamSpot beamSpot = *beamSpotHandle;
 
   nbvtx->Fill(recVtxs->size()*1.);
   int ng=0;
   for (auto const & vx : (*recVtxs) )
     if (vx.isValid() && !vx.isFake()  && vx.ndof()>=ndof_) ++ng;
   nbgvtx->Fill(ng*1.);
 
   if (scores.isValid() && !(*scores).empty()) {
     auto pvScore = (*scores).get(0);
     score[1]->Fill(std::sqrt(pvScore));
     for (unsigned int i=1; i<(*scores).size(); ++i) 
       score[0]->Fill(std::sqrt((*scores).get(i)));
   }
 
   // fill PV tracks MEs (as now, for alignment)
   if (!recVtxs->empty()) {
 
     vertexPlots  (recVtxs->front(), beamSpot, 1);
     pvTracksPlots(recVtxs->front());
     
     for(reco::VertexCollection::const_iterator v=recVtxs->begin()+1; 
     v!=recVtxs->end(); ++v)
       vertexPlots(*v, beamSpot, 0);
   }
 
   // Beamline plots:
   bsX->Fill(beamSpot.x0());
   bsY->Fill(beamSpot.y0());
   bsZ->Fill(beamSpot.z0());
   bsSigmaZ->Fill(beamSpot.sigmaZ());
   bsDxdz->Fill(beamSpot.dxdz());
   bsDydz->Fill(beamSpot.dydz());
   bsBeamWidthX->Fill(beamSpot.BeamWidthX()*10000);
   bsBeamWidthY->Fill(beamSpot.BeamWidthY()*10000);
   // bsType->Fill(beamSpot.type());
 
 }

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

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 65 of file PrimaryVertexMonitor.cc.

References AlignmentLabel_, beamSpotInputTag_, DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), bsBeamWidthX, bsBeamWidthY, bsDxdz, bsDydz, bsSigmaZ, bsType, bsX, bsY, bsZ, chi2ndf, chi2prob, conf_, dqmLabel, dxy, dxy2, dxyErr, dxyVsEta_pt1, dxyVsEta_pt10, dxyVsPhi_pt1, dxyVsPhi_pt10, dz, dzErr, dzVsEta_pt1, dzVsEta_pt10, dzVsPhi_pt1, dzVsPhi_pt10, Gflash::EtaMax, Gflash::EtaMin, edm::ParameterSet::getParameter(), MonitorElement::getTH1F(), mps_fire::i, edm::InputTag::label(), nans, nbgvtx, nbtksinvtx, nbvtx, ntracks, ntracksVsZ, score, MonitorElement::setAxisTitle(), DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, sumpt, TopFolderName_, trksWeight, vertexInputTag_, vtxchi2, vtxndf, vtxprob, xDiff, xerr, xerrVsTrks, xrec, yDiff, yerr, yerrVsTrks, yrec, zerr, zerrVsTrks, and zrec.

                                          {
 
   std::string dqmLabel = "";
 
   //
   // Book all histograms.
   //
 
   //  get the store
   dqmLabel = TopFolderName_+"/"+vertexInputTag_.label();
   iBooker.setCurrentFolder(dqmLabel);
 
 //   xPos = iBooker.book1D ("xPos","x Coordinate" ,100, -0.1, 0.1);
 
   nbvtx      = iBooker.book1D("vtxNbr","Reconstructed Vertices in Event",80,-0.5,79.5);
   nbgvtx      = iBooker.book1D("goodvtxNbr","Reconstructed Good Vertices in Event",80,-0.5,79.5);
 
   // to be configured each year...
   auto vposx = conf_.getParameter<double>("Xpos");
   auto vposy = conf_.getParameter<double>("Ypos");
 
   nbtksinvtx[0] = iBooker.book1D("otherVtxTrksNbr","Reconstructed Tracks in Vertex (other Vtx)",40,-0.5,99.5);
   ntracksVsZ[0]  = iBooker.bookProfile("otherVtxTrksVsZ","Reconstructed Tracks in Vertex (other Vtx) vs Z",80,-20.,20.,50,0,100,"");
   ntracksVsZ[0]->setAxisTitle("z-bs",1);
   ntracksVsZ[0]->setAxisTitle("#tracks",2);
 
   score[0]      = iBooker.book1D("otherVtxScore","sqrt(score) (other Vtx)",100,0.,400.); 
   trksWeight[0] = iBooker.book1D("otherVtxTrksWeight","Total weight of Tracks in Vertex (other Vtx)",40,0,100.); 
   vtxchi2[0]    = iBooker.book1D("otherVtxChi2","#chi^{2} (other Vtx)",100,0.,200.);
   vtxndf[0]     = iBooker.book1D("otherVtxNdf","ndof (other Vtx)",100,0.,200.);
   vtxprob[0]    = iBooker.book1D("otherVtxProb","#chi^{2} probability (other Vtx)",100,0.,1.);
   nans[0]       = iBooker.book1D("otherVtxNans","Illegal values for x,y,z,xx,xy,xz,yy,yz,zz (other Vtx)",9,0.5,9.5);
 
   nbtksinvtx[1] = iBooker.book1D("tagVtxTrksNbr","Reconstructed Tracks in Vertex (tagged Vtx)",100,-0.5,99.5);
   ntracksVsZ[1]  = iBooker.bookProfile("tagVtxTrksVsZ","Reconstructed Tracks in Vertex (tagged Vtx) vs Z",80,-20.,20.,50,0,100,"");
   ntracksVsZ[1]->setAxisTitle("z-bs",1);
   ntracksVsZ[1]->setAxisTitle("#tracks",2);
  
   score[1]      = iBooker.book1D("tagVtxScore","sqrt(score) (tagged Vtx)",100,0.,400.);
   trksWeight[1] = iBooker.book1D("tagVtxTrksWeight","Total weight of Tracks in Vertex (tagged Vtx)",100,0,100.); 
   vtxchi2[1]    = iBooker.book1D("tagVtxChi2","#chi^{2} (tagged Vtx)",100,0.,200.);
   vtxndf[1]     = iBooker.book1D("tagVtxNdf","ndof (tagged Vtx)",100,0.,200.);
   vtxprob[1]    = iBooker.book1D("tagVtxProb","#chi^{2} probability (tagged Vtx)",100,0.,1.);
   nans[1]       = iBooker.book1D("tagVtxNans","Illegal values for x,y,z,xx,xy,xz,yy,yz,zz (tagged Vtx)",9,0.5,9.5);
 
   xrec[0]    = iBooker.book1D("otherPosX","Position x Coordinate (other Vtx)",100,vposx-0.1,vposx+0.1);
   yrec[0]    = iBooker.book1D("otherPosY","Position y Coordinate (other Vtx)",100,vposy-0.1,vposy+0.1);
   zrec[0]        = iBooker.book1D("otherPosZ","Position z Coordinate (other Vtx)",100,-20.,20.);
   xDiff[0]   = iBooker.book1D("otherDiffX","X distance from BeamSpot (other Vtx)",100,-500,500);
   yDiff[0]   = iBooker.book1D("otherDiffY","Y distance from BeamSpot (other Vtx)",100,-500,500);
   xerr[0]    = iBooker.book1D("otherErrX","Uncertainty x Coordinate (other Vtx)",100,0.,100);
   yerr[0]    = iBooker.book1D("otherErrY","Uncertainty y Coordinate (other Vtx)",100,0.,100);
   zerr[0]        = iBooker.book1D("otherErrZ","Uncertainty z Coordinate (other Vtx)",100,0.,100);
   xerrVsTrks[0]  = iBooker.book2D("otherErrVsWeightX","Uncertainty x Coordinate vs. track weight (other Vtx)",100,0,100.,100,0.,100);
   yerrVsTrks[0]  = iBooker.book2D("otherErrVsWeightY","Uncertainty y Coordinate vs. track weight (other Vtx)",100,0,100.,100,0.,100);
   zerrVsTrks[0]  = iBooker.book2D("otherErrVsWeightZ","Uncertainty z Coordinate vs. track weight (other Vtx)",100,0,100.,100,0.,100);
 
 
   xrec[1]     = iBooker.book1D("tagPosX","Position x Coordinate (tagged Vtx)",100,vposx-0.1,vposx+0.1);
   yrec[1]     = iBooker.book1D("tagPosY","Position y Coordinate (tagged Vtx)",100,vposy-0.1,vposy+0.1);
   zrec[1]     = iBooker.book1D("tagPosZ","Position z Coordinate (tagged Vtx)",100,-20.,20.);
   xDiff[1]    = iBooker.book1D("tagDiffX","X distance from BeamSpot (tagged Vtx)",100,-500, 500);
   yDiff[1]    = iBooker.book1D("tagDiffY","Y distance from BeamSpot (tagged Vtx)",100,-500, 500);
   xerr[1]     = iBooker.book1D("tagErrX","Uncertainty x Coordinate (tagged Vtx)",100,0.,100);
   yerr[1]     = iBooker.book1D("tagErrY","Uncertainty y Coordinate (tagged Vtx)",100,0.,100);
   zerr[1]     = iBooker.book1D("tagErrZ","Uncertainty z Coordinate (tagged Vtx)",100,0.,100);
   xerrVsTrks[1]  = iBooker.book2D("tagErrVsWeightX","Uncertainty x Coordinate vs. track weight (tagged Vtx)",100,0,100.,100,0.,100);
   yerrVsTrks[1]  = iBooker.book2D("tagErrVsWeightY","Uncertainty y Coordinate vs. track weight (tagged Vtx)",100,0,100.,100,0.,100);
   zerrVsTrks[1]  = iBooker.book2D("tagErrVsWeightZ","Uncertainty z Coordinate vs. track weight (tagged Vtx)",100,0,100.,100,0.,100);
 
   type[0] = iBooker.book1D("otherType","Vertex type (other Vtx)",3,-0.5,2.5);
   type[1] = iBooker.book1D("tagType","Vertex type (tagged Vtx)",3,-0.5,2.5);
   for (int i=0;i<2;++i){
     type[i]->getTH1F()->GetXaxis()->SetBinLabel(1,"Valid, real");
     type[i]->getTH1F()->GetXaxis()->SetBinLabel(2,"Valid, fake");
     type[i]->getTH1F()->GetXaxis()->SetBinLabel(3,"Invalid");
   }
 
 
   //  get the store
   dqmLabel = TopFolderName_+"/"+beamSpotInputTag_.label();
   iBooker.setCurrentFolder(dqmLabel);
   
   bsX       = iBooker.book1D("bsX", "BeamSpot x0", 100,-0.1,0.1);
   bsY       = iBooker.book1D("bsY", "BeamSpot y0", 100,-0.1,0.1);
   bsZ       = iBooker.book1D("bsZ", "BeamSpot z0", 100,-2.,2.);
   bsSigmaZ  = iBooker.book1D("bsSigmaZ", "BeamSpot sigmaZ", 100, 0., 10. );
   bsDxdz    = iBooker.book1D("bsDxdz", "BeamSpot dxdz", 100, -0.0003, 0.0003);
   bsDydz    = iBooker.book1D("bsDydz", "BeamSpot dydz", 100, -0.0003, 0.0003);
   bsBeamWidthX  = iBooker.book1D("bsBeamWidthX", "BeamSpot BeamWidthX", 100, 0., 100.);
   bsBeamWidthY  = iBooker.book1D("bsBeamWidthY", "BeamSpot BeamWidthY", 100, 0., 100.);
   bsType    = iBooker.book1D("bsType", "BeamSpot type", 4, -1.5, 2.5);
   bsType->getTH1F()->GetXaxis()->SetBinLabel(1,"Unknown");
   bsType->getTH1F()->GetXaxis()->SetBinLabel(2,"Fake");
   bsType->getTH1F()->GetXaxis()->SetBinLabel(3,"LHC");
   bsType->getTH1F()->GetXaxis()->SetBinLabel(4,"Tracker");
 
   
   //  get the store
   dqmLabel = TopFolderName_+"/"+AlignmentLabel_;
   iBooker.setCurrentFolder(dqmLabel);
 
   int    TKNoBin    = conf_.getParameter<int>(   "TkSizeBin");
   double TKNoMin    = conf_.getParameter<double>("TkSizeMin");
   double TKNoMax    = conf_.getParameter<double>("TkSizeMax");
 
   int    DxyBin     = conf_.getParameter<int>(   "DxyBin");
   double DxyMin     = conf_.getParameter<double>("DxyMin");
   double DxyMax     = conf_.getParameter<double>("DxyMax");
   
   int    DzBin      = conf_.getParameter<int>(   "DzBin");
   double DzMin      = conf_.getParameter<double>("DzMin");
   double DzMax      = conf_.getParameter<double>("DzMax");
   
   int    PhiBin     = conf_.getParameter<int>(   "PhiBin");
   double PhiMin     = conf_.getParameter<double>("PhiMin");
   double PhiMax     = conf_.getParameter<double>("PhiMax");
 
   int    EtaBin     = conf_.getParameter<int>(   "EtaBin");
   double EtaMin     = conf_.getParameter<double>("EtaMin");
   double EtaMax     = conf_.getParameter<double>("EtaMax");
   
       
   ntracks = iBooker.book1D("ntracks","number of PV tracks (p_{T} > 1 GeV)", TKNoBin, TKNoMin, TKNoMax);
   ntracks->setAxisTitle("Number of PV Tracks (p_{T} > 1 GeV) per Event", 1);
   ntracks->setAxisTitle("Number of Event", 2);
 
   weight = iBooker.book1D("weight","weight of PV tracks (p_{T} > 1 GeV)", 100, 0., 1.);
   weight->setAxisTitle("weight of PV Tracks (p_{T} > 1 GeV) per Event", 1);
   weight->setAxisTitle("Number of Event", 2);
 
   sumpt    = iBooker.book1D("sumpt",   "#Sum p_{T} of PV tracks (p_{T} > 1 GeV)",       100,-0.5,249.5); 
   chi2ndf  = iBooker.book1D("chi2ndf", "PV tracks (p_{T} > 1 GeV) #chi^{2}/ndof",       100, 0., 20. );
   chi2prob = iBooker.book1D("chi2prob","PV tracks (p_{T} > 1 GeV) #chi^{2} probability",100, 0.,   1. );
  
   dxy      = iBooker.book1D("dxy",     "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum)",       DxyBin, DxyMin, DxyMax);
   dxy2     = iBooker.book1D("dxyzoom", "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum)",       DxyBin, DxyMin/5., DxyMax/5.);
   dxyErr   = iBooker.book1D("dxyErr",  "PV tracks (p_{T} > 1 GeV) d_{xy} error (#mum)", 100, 0.,   2000. );
   dz       = iBooker.book1D("dz",      "PV tracks (p_{T} > 1 GeV) d_{z} (#mum)",        DzBin,  DzMin,  DzMax );
   dzErr    = iBooker.book1D("dzErr",   "PV tracks (p_{T} > 1 GeV) d_{z} error(#mum)",   100, 0.,   10000. );
 
   dxyVsPhi_pt1 = iBooker.bookProfile("dxyVsPhi_pt1", "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum) VS track #phi",PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
   dxyVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi",  1);
   dxyVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{xy} (#mum)",2);
 
   dzVsPhi_pt1  = iBooker.bookProfile("dzVsPhi_pt1",  "PV tracks (p_{T} > 1 GeV) d_{z} (#mum) VS track #phi", PhiBin, PhiMin, PhiMax, DzBin,  DzMin,  DzMax, "");  
   dzVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #phi", 1);
   dzVsPhi_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{z} (#mum)",2);
 
   dxyVsEta_pt1 = iBooker.bookProfile("dxyVsEta_pt1", "PV tracks (p_{T} > 1 GeV) d_{xy} (#mum) VS track #eta",EtaBin, EtaMin, EtaMax, DxyBin, DxyMin, DxyMax,"");
   dxyVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta",  1);
   dxyVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{xy} (#mum)",2);
 
   dzVsEta_pt1  = iBooker.bookProfile("dzVsEta_pt1",  "PV tracks (p_{T} > 1 GeV) d_{z} (#mum) VS track #eta", EtaBin, EtaMin, EtaMax, DzBin,  DzMin,  DzMax, "");
   dzVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) #eta", 1);
   dzVsEta_pt1->setAxisTitle("PV track (p_{T} > 1 GeV) d_{z} (#mum)",2);
 
   dxyVsPhi_pt10 = iBooker.bookProfile("dxyVsPhi_pt10", "PV tracks (p_{T} > 10 GeV) d_{xy} (#mum) VS track #phi",PhiBin, PhiMin, PhiMax, DxyBin, DxyMin, DxyMax,"");
   dxyVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi",  1);
   dxyVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{xy} (#mum)",2);
 
   dzVsPhi_pt10  = iBooker.bookProfile("dzVsPhi_pt10",  "PV tracks (p_{T} > 10 GeV) d_{z} (#mum) VS track #phi", PhiBin, PhiMin, PhiMax, DzBin,  DzMin,  DzMax, "");  
   dzVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #phi", 1);
   dzVsPhi_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{z} (#mum)",2);
 
   dxyVsEta_pt10 = iBooker.bookProfile("dxyVsEta_pt10", "PV tracks (p_{T} > 10 GeV) d_{xy} (#mum) VS track #eta",EtaBin, EtaMin, EtaMax, DxyBin, DxyMin, DxyMax,"");
   dxyVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta",  1);
   dxyVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{xy} (#mum)",2);
 
   dzVsEta_pt10  = iBooker.bookProfile("dzVsEta_pt10",  "PV tracks (p_{T} > 10 GeV) d_{z} (#mum) VS track #eta", EtaBin, EtaMin, EtaMax, DzBin,  DzMin,  DzMax, "");
   dzVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) #eta", 1);
   dzVsEta_pt10->setAxisTitle("PV track (p_{T} > 10 GeV) d_{z} (#mum)",2);
 
 }

void PrimaryVertexMonitor::pvTracksPlots ( const reco::Vertex & v )

private

Definition at line 331 of file PrimaryVertexMonitor.cc.

References chi2ndf, chi2prob, AlignmentPI::cmToUm, dxy, dxy2, dxyErr, dxyVsEta_pt1, dxyVsEta_pt10, dxyVsPhi_pt1, dxyVsPhi_pt10, dz, dzErr, dzVsEta_pt1, dzVsEta_pt10, dzVsPhi_pt1, dzVsPhi_pt10, PVValHelper::eta, HcalObjRepresent::Fill(), reco::TrackBase::highPurity, createfilelist::int, reco::Vertex::isFake(), reco::Vertex::isValid(), nTracks(), ntracks, phi, reco::Vertex::position(), EnergyCorrector::pt, sumpt, lumiQTWidget::t, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::tracksSize(), reco::Vertex::trackWeight(), and w.

Referenced by analyze().

 {
 
   if ( !v.isValid() ) return;
   if (  v.isFake()  ) return;
 
   if ( v.tracksSize() == 0 ) {
     ntracks -> Fill ( 0 );
     return;
   }
 
   const math::XYZPoint myVertex(v.position().x(),v.position().y(),v.position().z());
 
   size_t nTracks = 0;
   float sumPT = 0.;
   const int cmToUm = 10000;
 
   for (reco::Vertex::trackRef_iterator t = v.tracks_begin(); t != v.tracks_end(); t++) {
 
     bool isHighPurity = (**t).quality(reco::TrackBase::highPurity);
     if ( !isHighPurity ) continue;
 
     float pt = (**t).pt();    
     if ( pt < 1. ) continue;
 
     nTracks++;
 
     float eta      = (**t).eta();
     float phi      = (**t).phi();
 
     float w        = v.trackWeight(*t);
     float chi2NDF  = (**t).normalizedChi2();
     float chi2Prob = TMath::Prob((**t).chi2(),(int)(**t).ndof());
     float Dxy      = (**t).dxy(myVertex)*cmToUm;  // is it needed ?
     float Dz       = (**t).dz(myVertex)*cmToUm;   // is it needed ?
     float DxyErr   = (**t).dxyError()*cmToUm;
     float DzErr    = (**t).dzError()*cmToUm;
 
     sumPT += pt*pt;
 
     // fill MEs
     weight   -> Fill (w);
     chi2ndf  -> Fill (chi2NDF);
     chi2prob -> Fill (chi2Prob);
     dxy      -> Fill (Dxy);
     dxy2     -> Fill (Dxy); 
     dz       -> Fill (Dz);
     dxyErr   -> Fill (DxyErr);
     dzErr    -> Fill (DzErr);
     
     dxyVsPhi_pt1 -> Fill (phi,Dxy);
     dzVsPhi_pt1  -> Fill (phi,Dz);
     dxyVsEta_pt1 -> Fill (eta,Dxy);
     dzVsEta_pt1  -> Fill (eta,Dz);
 
     if ( pt < 10. ) continue;
     dxyVsPhi_pt10 -> Fill (phi,Dxy);
     dzVsPhi_pt10  -> Fill (phi,Dz);
     dxyVsEta_pt10 -> Fill (eta,Dxy);
     dzVsEta_pt10  -> Fill (eta,Dz);
   }
   ntracks -> Fill (float(nTracks));
   sumpt   -> Fill (sumPT);
 
 }

void PrimaryVertexMonitor::vertexPlots	(	const reco::Vertex &	v,
		const reco::BeamSpot &	beamSpot,
		int	i
	)

private

Definition at line 397 of file PrimaryVertexMonitor.cc.

References reco::Vertex::chi2(), ChiSquaredProbability(), reco::Vertex::covariance(), DEFINE_FWK_MODULE, reco::BeamSpot::dxdz(), reco::BeamSpot::dydz(), MonitorElement::Fill(), HcalObjRepresent::Fill(), mps_fire::i, reco::Vertex::isFake(), edm::isNotFinite(), reco::Vertex::isValid(), gen::k, nans, nbtksinvtx, reco::Vertex::ndof(), ntracksVsZ, reco::Vertex::position(), lumiQTWidget::t, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), reco::Vertex::tracksSize(), reco::Vertex::trackWeight(), trksWeight, vtxchi2, vtxndf, vtxprob, reco::BeamSpot::x0(), xDiff, xerr, reco::Vertex::xError(), xerrVsTrks, xrec, reco::BeamSpot::y0(), yDiff, yerr, reco::Vertex::yError(), yerrVsTrks, yrec, reco::BeamSpot::z0(), zerr, reco::Vertex::zError(), zerrVsTrks, and zrec.

Referenced by analyze().

 {
 
     if (i < 0 || i > 1) return;
     if (!v.isValid()) type[i]->Fill(2.);
     else if (v.isFake()) type[i]->Fill(1.);
     else type[i]->Fill(0.);
 
     if (v.isValid() && !v.isFake()) {
       float weight = 0;
       for(reco::Vertex::trackRef_iterator t = v.tracks_begin(); 
       t!=v.tracks_end(); t++) weight+= v.trackWeight(*t);
       trksWeight[i]->Fill(weight);
       nbtksinvtx[i]->Fill(v.tracksSize());
       ntracksVsZ[i]->Fill(v.position().z()- beamSpot.z0(),v.tracksSize());
   
       vtxchi2[i]->Fill(v.chi2());
       vtxndf[i]->Fill(v.ndof());
       vtxprob[i]->Fill(ChiSquaredProbability(v.chi2() ,v.ndof()));
 
       xrec[i]->Fill(v.position().x());
       yrec[i]->Fill(v.position().y());
       zrec[i]->Fill(v.position().z());
 
       float xb = beamSpot.x0() + beamSpot.dxdz() * (v.position().z() - beamSpot.z0());
       float yb = beamSpot.y0() + beamSpot.dydz() * (v.position().z() - beamSpot.z0());
       xDiff[i]->Fill((v.position().x() - xb)*10000);
       yDiff[i]->Fill((v.position().y() - yb)*10000);
 
       xerr[i]->Fill(v.xError()*10000);
       yerr[i]->Fill(v.yError()*10000);
       zerr[i]->Fill(v.zError()*10000);
       xerrVsTrks[i]->Fill(weight, v.xError()*10000);
       yerrVsTrks[i]->Fill(weight, v.yError()*10000);
       zerrVsTrks[i]->Fill(weight, v.zError()*10000);
 
       nans[i]->Fill(1.,edm::isNotFinite(v.position().x())*1.);
       nans[i]->Fill(2.,edm::isNotFinite(v.position().y())*1.);
       nans[i]->Fill(3.,edm::isNotFinite(v.position().z())*1.);
 
       int index = 3;
       for (int k = 0; k != 3; k++) {
     for (int j = k; j != 3; j++) {
       index++;
       nans[i]->Fill(index*1., edm::isNotFinite(v.covariance(k, j))*1.);
       // in addition, diagonal element must be positive
       if (j == k && v.covariance(k, j) < 0) {
         nans[i]->Fill(index*1., 1.);
       }
     }
       }
     }
 }