#include <Validation/RecoVertex/src/PrimaryVertexAnalyzer4PUSlimmed.cc>

Inheritance diagram for PrimaryVertexAnalyzer4PUSlimmed:

Classes
struct	recoPrimaryVertex

struct	simPrimaryVertex

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

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

	PrimaryVertexAnalyzer4PUSlimmed (const edm::ParameterSet &)

	~PrimaryVertexAnalyzer4PUSlimmed ()

Public Member Functions inherited from DQMEDAnalyzer
virtual void	beginRun (edm::Run const &, edm::EventSetup const &) final

virtual void	beginStream (edm::StreamID id) final

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

	DQMEDAnalyzer (void)

virtual void	endLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

virtual void	endRunSummary (edm::Run const &, edm::EventSetup const &, dqmDetails::NoCache *) const final

uint32_t	streamId () const

Public Member Functions inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
	EDAnalyzer ()=default

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

	EDAnalyzerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDAnalyzerBase ()

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

	EDConsumerBase ()

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

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

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

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

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

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef math::XYZTLorentzVector	LorentzVector

enum	SignalVertexKind { HIGHEST_PT = 0, IS_ASSOC2FIRST_RECO = 1, IS_ASSOC2ANY_RECO = 2 }

Private Member Functions
void	calculatePurityAndFillHistograms (const std::string &, std::vector< recoPrimaryVertex > &, int, bool)

template<class T >
void	computePairDistance (const T &collection, MonitorElement *me)

void	fillGenAssociatedRecoVertexHistograms (const std::string &, int, recoPrimaryVertex &v)

void	fillGenericGenVertexHistograms (const simPrimaryVertex &v)

void	fillRecoAssociatedGenVertexHistograms (const std::string &, const simPrimaryVertex &v)

void	fillResolutionAndPullHistograms (const std::string &, int, recoPrimaryVertex &v)

std::vector < PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex >	getRecoPVs (const edm::Handle< edm::View< reco::Vertex >> &)

std::vector < PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex >	getSimPVs (const edm::Handle< TrackingVertexCollection > &)

void	matchReco2SimVertices (std::vector< recoPrimaryVertex > &, const reco::VertexRecoToSimCollection &, const std::vector< simPrimaryVertex > &)

bool	matchRecoTrack2SimSignal (const reco::TrackBaseRef &)

void	matchSim2RecoVertices (std::vector< simPrimaryVertex > &, const reco::VertexSimToRecoCollection &)

void	resetSimPVAssociation (std::vector< simPrimaryVertex > &)

Private Attributes
double	abs_z_match_

edm::EDGetTokenT< edm::View < reco::Track > >	edmView_recoTrack_Token_

std::map< std::string, std::map< std::string, MonitorElement * > >	mes_

const reco::RecoToSimCollection *	r2s_

std::vector< edm::EDGetTokenT < edm::View< reco::Vertex > > >	reco_vertex_collection_tokens_

std::vector< edm::InputTag >	reco_vertex_collections_

edm::EDGetTokenT < reco::RecoToSimCollection >	recoToSimAssociationToken_

edm::EDGetTokenT < reco::TrackCollection >	recoTrackCollectionToken_

std::string	root_folder_

const reco::SimToRecoCollection *	s2r_

double	sigma_z_match_

edm::EDGetTokenT < reco::SimToRecoCollection >	simToRecoAssociationToken_

edm::EDGetTokenT < TrackingParticleCollection >	trackingParticleCollectionToken_

edm::EDGetTokenT < TrackingVertexCollection >	trackingVertexCollectionToken_

bool	use_only_charged_tracks_

edm::EDGetTokenT< std::vector < PileupSummaryInfo > >	vecPileupSummaryInfoToken_

bool	verbose_

edm::EDGetTokenT < reco::VertexToTrackingVertexAssociator >	vertexAssociatorToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDAnalyzer< edm::RunSummaryCache< dqmDetails::NoCache >, edm::LuminosityBlockSummaryCache< dqmDetails::NoCache > >
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDAnalyzerBase
typedef EDAnalyzerAdaptorBase	ModuleType

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from DQMEDAnalyzer
static std::shared_ptr < dqmDetails::NoCache >	globalBeginLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const *)

static std::shared_ptr < dqmDetails::NoCache >	globalBeginRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const *)

static void	globalEndLuminosityBlockSummary (edm::LuminosityBlock const &, edm::EventSetup const &, LuminosityBlockContext const , dqmDetails::NoCache )

static void	globalEndRunSummary (edm::Run const &, edm::EventSetup const &, RunContext const , dqmDetails::NoCache )

Static Public Member Functions inherited from edm::stream::EDAnalyzerBase
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)

Detailed Description

Description: primary vertex analyzer for events with pile-up

Implementation: <Notes on="" implementation>="">

Definition at line 63 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Member Typedef Documentation

typedef math::XYZTLorentzVector PrimaryVertexAnalyzer4PUSlimmed::LorentzVector

private

Definition at line 64 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Member Enumeration Documentation

enum PrimaryVertexAnalyzer4PUSlimmed::SignalVertexKind

private

Enumerator
HIGHEST_PT
IS_ASSOC2FIRST_RECO
IS_ASSOC2ANY_RECO

Definition at line 66 of file PrimaryVertexAnalyzer4PUSlimmed.h.

                         {
     HIGHEST_PT = 0,
     IS_ASSOC2FIRST_RECO = 1,
     IS_ASSOC2ANY_RECO = 2
   };

Constructor & Destructor Documentation

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

explicit

Definition at line 28 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References edm::EDConsumerBase::consumes(), edm::ParameterSet::getParameter(), prof2calltree::l, reco_vertex_collection_tokens_, and reco_vertex_collections_.

     : verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
       use_only_charged_tracks_(iConfig.getUntrackedParameter<bool>(
           "use_only_charged_tracks", true)),
       sigma_z_match_(
           iConfig.getUntrackedParameter<double>("sigma_z_match", 3.0)),
       abs_z_match_(
           iConfig.getUntrackedParameter<double>("abs_z_match", 0.1)),
       root_folder_(
           iConfig.getUntrackedParameter<std::string>("root_folder",
                                                 "Validation/Vertices")),
       vecPileupSummaryInfoToken_(consumes<std::vector<PileupSummaryInfo> >(
           edm::InputTag(std::string("addPileupInfo")))),
       recoTrackCollectionToken_(consumes<reco::TrackCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("recoTrackProducer"))),
       edmView_recoTrack_Token_(consumes<edm::View<reco::Track> >(
           iConfig.getUntrackedParameter<edm::InputTag>("recoTrackProducer"))),
       trackingParticleCollectionToken_(consumes<TrackingParticleCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleCollection"))),
       trackingVertexCollectionToken_(consumes<TrackingVertexCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackingVertexCollection"))),
       simToRecoAssociationToken_(consumes<reco::SimToRecoCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
       recoToSimAssociationToken_(consumes<reco::RecoToSimCollection>(
           iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
       vertexAssociatorToken_(consumes<reco::VertexToTrackingVertexAssociator>(
           iConfig.getUntrackedParameter<edm::InputTag>("vertexAssociator"))) {
   reco_vertex_collections_ = iConfig.getParameter<std::vector<edm::InputTag> >(
       "vertexRecoCollections");
   for (auto const& l : reco_vertex_collections_) {
     reco_vertex_collection_tokens_.push_back(
         edm::EDGetTokenT<edm::View<reco::Vertex>>(
             consumes<edm::View<reco::Vertex>>(l)));
   }
 }

PrimaryVertexAnalyzer4PUSlimmed::~PrimaryVertexAnalyzer4PUSlimmed ( )

Definition at line 65 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

65 {}

Member Function Documentation

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

overridevirtual

Implements edm::stream::EDAnalyzerBase.

Definition at line 1194 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References begin, calculatePurityAndFillHistograms(), computePairDistance(), gather_cfg::cout, edmView_recoTrack_Token_, end, HcalObjRepresent::Fill(), fillGenAssociatedRecoVertexHistograms(), fillGenericGenVertexHistograms(), fillRecoAssociatedGenVertexHistograms(), spr::find(), edm::Event::getByToken(), getRecoPVs(), getSimPVs(), HIGHEST_PT, IS_ASSOC2ANY_RECO, IS_ASSOC2FIRST_RECO, diffTwoXMLs::label, matchReco2SimVertices(), matchSim2RecoVertices(), mes_, AlCaHLTBitMon_ParallelJobs::p, edm::Handle< T >::product(), r2s_, dt_dqm_sourceclient_common_cff::reco, reco_vertex_collection_tokens_, reco_vertex_collections_, recoToSimAssociationToken_, recoTrackCollectionToken_, resetSimPVAssociation(), s2r_, simToRecoAssociationToken_, AlCaHLTBitMon_QueryRunRegistry::string, trackingParticleCollectionToken_, trackingVertexCollectionToken_, findQualityFiles::v, vecPileupSummaryInfoToken_, verbose_, and vertexAssociatorToken_.

                                                                            {
   using std::vector;
   using std::cout;
   using std::endl;
   using edm::Handle;
   using edm::View;
   using edm::LogInfo;
   using namespace reco;
 
   std::vector<float> pileUpInfo_z;
 
   // get the pileup information
   edm::Handle<std::vector<PileupSummaryInfo> > puinfoH;
   if (iEvent.getByToken(vecPileupSummaryInfoToken_, puinfoH)) {
     for (auto const& pu_info : *puinfoH.product()) {
       mes_["root_folder"]["GenVtx_vs_BX"]
           ->Fill(pu_info.getBunchCrossing(), pu_info.getPU_NumInteractions());
       if (pu_info.getBunchCrossing() == 0) {
         pileUpInfo_z = pu_info.getPU_zpositions();
         if (verbose_) {
           for (auto const& p : pileUpInfo_z) {
             std::cout << "PileUpInfo on Z vertex: " << p << std::endl;
           }
         }
         break;
       }
     }
   }
 
   Handle<reco::TrackCollection> recTrks;
   iEvent.getByToken(recoTrackCollectionToken_, recTrks);
 
   // for the associator
   Handle<View<Track> > trackCollectionH;
   iEvent.getByToken(edmView_recoTrack_Token_, trackCollectionH);
 
   edm::Handle<TrackingParticleCollection> TPCollectionH;
   iEvent.getByToken(trackingParticleCollectionToken_, TPCollectionH);
 
   edm::Handle<TrackingVertexCollection> TVCollectionH;
   iEvent.getByToken(trackingVertexCollectionToken_, TVCollectionH);
 
   // TODO(rovere) the idea is to put in case a track-selector in front
   // of this module and then use its label to get the selected tracks
   // out of the event instead of making an hard-coded selection in the
   // code.
 
   edm::Handle<reco::SimToRecoCollection> simToRecoH;
   iEvent.getByToken(simToRecoAssociationToken_, simToRecoH);
 
   edm::Handle<reco::RecoToSimCollection> recoToSimH;
   iEvent.getByToken(recoToSimAssociationToken_, recoToSimH);
 
   s2r_ = simToRecoH.product();
   r2s_ = recoToSimH.product();
 
   // Vertex associator
   edm::Handle<reco::VertexToTrackingVertexAssociator> vertexAssociatorH;
   iEvent.getByToken(vertexAssociatorToken_, vertexAssociatorH);
   const reco::VertexToTrackingVertexAssociator& vertexAssociator = *(vertexAssociatorH.product());
 
   std::vector<simPrimaryVertex> simpv;  // a list of simulated primary
                                         // MC vertices
   // TODO(rovere) use move semantic?
   simpv = getSimPVs(TVCollectionH);
   // TODO(rovere) 1 vertex is not, by definition, pileup, and should
   // probably be subtracted?
   int kind_of_signal_vertex = 0;
   int num_pileup_vertices = simpv.size();
   mes_["root_folder"]["GenAllV_NumVertices"]->Fill(simpv.size());
   bool signal_is_highest_pt = std::max_element(simpv.begin(), simpv.end(),
                                                [](const simPrimaryVertex& lhs,
                                                   const simPrimaryVertex& rhs) {
                                                  return lhs.ptsq < rhs.ptsq;
                                                }) == simpv.begin();
   kind_of_signal_vertex |= (signal_is_highest_pt << HIGHEST_PT);
   mes_["root_folder"]["SignalIsHighestPt2"]->Fill(
       signal_is_highest_pt ? 1. : 0.);
   computePairDistance(simpv,
                       mes_["root_folder"]["GenAllV_PairDistanceZ"]);
 
   int label_index = -1;
   for (auto const& vertex_token : reco_vertex_collection_tokens_) {
     std::vector<recoPrimaryVertex> recopv;  // a list of reconstructed
                                             // primary MC vertices
     std::string label = reco_vertex_collections_[++label_index].label();
     edm::Handle<edm::View<reco::Vertex>> recVtxs;
     if (!iEvent.getByToken(vertex_token, recVtxs)) {
       LogInfo("PrimaryVertexAnalyzer4PUSlimmed")
           << "Skipping vertex collection: " << label << " since it is missing."
           << std::endl;
       continue;
     }
 
     reco::VertexRecoToSimCollection vertex_r2s = vertexAssociator.associateRecoToSim(recVtxs, TVCollectionH);
     reco::VertexSimToRecoCollection vertex_s2r = vertexAssociator.associateSimToReco(recVtxs, TVCollectionH);
 
     resetSimPVAssociation(simpv);
     matchSim2RecoVertices(simpv, vertex_s2r);
     recopv = getRecoPVs(recVtxs);
     computePairDistance(recopv,
                         mes_[label]["RecoAllAssoc2Gen_PairDistanceZ"]);
     matchReco2SimVertices(recopv, vertex_r2s, simpv);
 
     int num_total_gen_vertices_assoc2reco = 0;
     int num_total_reco_vertices_assoc2gen = 0;
     int num_total_gen_vertices_multiassoc2reco = 0;
     int num_total_reco_vertices_multiassoc2gen = 0;
     int num_total_reco_vertices_duplicate = 0;
     int genpv_position_in_reco_collection = -1;
     for (auto const& v : simpv) {
       float mistag = 1.;
       // TODO(rovere) put selectors here in front of fill* methods.
       if (v.eventId.event() == 0) {
         if (!recVtxs->empty() &&
             std::find(v.rec_vertices.begin(), v.rec_vertices.end(),
                       &((*recVtxs.product())[0])) != v.rec_vertices.end()) {
           mistag = 0.;
           kind_of_signal_vertex |= (1 << IS_ASSOC2FIRST_RECO);
         } else {
           if (v.rec_vertices.size()) {
             kind_of_signal_vertex |= (1 << IS_ASSOC2ANY_RECO);
           }
         }
         mes_[label]["KindOfSignalPV"]->Fill(kind_of_signal_vertex);
         mes_[label]["MisTagRate"]->Fill(mistag);
         mes_[label]["MisTagRate_vs_PU"]->Fill(simpv.size(), mistag);
         mes_[label]["MisTagRate_vs_sum-pt2"]->Fill(v.ptsq, mistag);
         mes_[label]["MisTagRate_vs_Z"]->Fill(v.z, mistag);
         mes_[label]["MisTagRate_vs_R"]->Fill(v.r, mistag);
         mes_[label]["MisTagRate_vs_NumTracks"]->Fill(v.nGenTrk, mistag);
         if (signal_is_highest_pt) {
           mes_[label]["MisTagRateSignalIsHighest"]->Fill(mistag);
           mes_[label]["MisTagRateSignalIsHighest_vs_PU"]->Fill(simpv.size(),
                                                                mistag);
           mes_[label]["MisTagRateSignalIsHighest_vs_sum-pt2"]->Fill(v.ptsq,
                                                                     mistag);
           mes_[label]["MisTagRateSignalIsHighest_vs_Z"]->Fill(v.z, mistag);
           mes_[label]["MisTagRateSignalIsHighest_vs_R"]->Fill(v.r, mistag);
           mes_[label]["MisTagRateSignalIsHighest_vs_NumTracks"]->Fill(v.nGenTrk,
                                                                       mistag);
         } else {
           mes_[label]["MisTagRateSignalIsNotHighest"]->Fill(mistag);
           mes_[label]["MisTagRateSignalIsNotHighest_vs_PU"]->Fill(simpv.size(),
                                                                   mistag);
           mes_[label]["MisTagRateSignalIsNotHighest_vs_sum-pt2"]->Fill(v.ptsq,
                                                                        mistag);
           mes_[label]["MisTagRateSignalIsNotHighest_vs_Z"]->Fill(v.z, mistag);
           mes_[label]["MisTagRateSignalIsNotHighest_vs_R"]->Fill(v.r, mistag);
           mes_[label]["MisTagRateSignalIsNotHighest_vs_NumTracks"]->
               Fill(v.nGenTrk, mistag);
         }
         // Now check at which location the Simulated PV has been
         // reconstructed in the primary vertex collection
         // at-hand. Mark it with fake index -1 if it was not
         // reconstructed at all.
 
         auto iv = (*recVtxs.product()).begin();
         for (int pv_position_in_reco_collection = 0;
              iv != (*recVtxs.product()).end();
              ++pv_position_in_reco_collection, ++iv) {
           if (std::find(v.rec_vertices.begin(), v.rec_vertices.end(),
                         &(*iv)) != v.rec_vertices.end()) {
             mes_[label]["TruePVLocationIndex"]
                 ->Fill(pv_position_in_reco_collection);
             mes_[label]["TruePVLocationIndexCumulative"]
                 ->Fill(pv_position_in_reco_collection > 0 ? 1 : 0);
 
             if (signal_is_highest_pt) {
               mes_[label]["TruePVLocationIndexSignalIsHighest"]
                 ->Fill(pv_position_in_reco_collection);
             } else {
               mes_[label]["TruePVLocationIndexSignalIsNotHighest"]
                 ->Fill(pv_position_in_reco_collection);
             }
 
             genpv_position_in_reco_collection = pv_position_in_reco_collection;
             break;
           }
         }
 
         // If we reached the end, it means that the Simulated PV has not
         // been associated to any reconstructed vertex: mark it as
         // missing in the reconstructed vertex collection using the fake
         // index -1.
         if (iv == (*recVtxs.product()).end()) {
           mes_[label]["TruePVLocationIndex"]->Fill(-1.);
           mes_[label]["TruePVLocationIndexCumulative"]->Fill(-1.);
           if (signal_is_highest_pt)
             mes_[label]["TruePVLocationIndexSignalIsHighest"]->Fill(-1.);
           else
             mes_[label]["TruePVLocationIndexSignalIsNotHighest"]->Fill(-1.);
         }
       }
 
       if (v.rec_vertices.size()) num_total_gen_vertices_assoc2reco++;
       if (v.rec_vertices.size() > 1) num_total_gen_vertices_multiassoc2reco++;
       // No need to N-tplicate the Gen-related cumulative histograms:
       // fill them only at the first iteration
       if (label_index == 0) fillGenericGenVertexHistograms(v);
       fillRecoAssociatedGenVertexHistograms(label, v);
     }
     calculatePurityAndFillHistograms(label, recopv, genpv_position_in_reco_collection, signal_is_highest_pt);
 
     mes_[label]["GenAllAssoc2Reco_NumVertices"]
         ->Fill(simpv.size(), simpv.size());
     mes_[label]["GenAllAssoc2RecoMatched_NumVertices"]
         ->Fill(simpv.size(), num_total_gen_vertices_assoc2reco);
     mes_[label]["GenAllAssoc2RecoMultiMatched_NumVertices"]
         ->Fill(simpv.size(), num_total_gen_vertices_multiassoc2reco);
     for (auto & v : recopv) {
       fillGenAssociatedRecoVertexHistograms(label, num_pileup_vertices, v);
       if (v.sim_vertices.size()) {
         num_total_reco_vertices_assoc2gen++;
         if (v.sim_vertices_internal[0]->rec_vertices.size() > 1) {
           num_total_reco_vertices_duplicate++;
         }
       }
       if (v.sim_vertices.size() > 1) num_total_reco_vertices_multiassoc2gen++;
     }
     mes_[label]["RecoAllAssoc2Gen_NumVertices"]
         ->Fill(recopv.size(), recopv.size());
     mes_[label]["RecoAllAssoc2GenMatched_NumVertices"]
         ->Fill(recopv.size(), num_total_reco_vertices_assoc2gen);
     mes_[label]["RecoAllAssoc2GenMultiMatched_NumVertices"]
         ->Fill(recopv.size(), num_total_reco_vertices_multiassoc2gen);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_NumVertices"]
         ->Fill(recopv.size(), num_total_reco_vertices_duplicate);
     mes_[label]["RecoVtx_vs_GenVtx"]->Fill(simpv.size(), recopv.size());
     mes_[label]["MatchedRecoVtx_vs_GenVtx"]
         ->Fill(simpv.size(), num_total_reco_vertices_assoc2gen);
 
   }
 }  // end of analyze

void PrimaryVertexAnalyzer4PUSlimmed::bookHistograms	(	DQMStore::IBooker &	i,
		edm::Run const &	iRun,
		edm::EventSetup const &	iSetup
	)

overridevirtual

Implements DQMEDAnalyzer.

Definition at line 70 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References DQMStore::IBooker::book1D(), DQMStore::IBooker::book2D(), DQMStore::IBooker::bookProfile(), MonitorElement::getTH2F(), prof2calltree::l, diffTwoXMLs::label, bookConverter::max, mes_, min(), mergeVDriftHistosByStation::name, reco_vertex_collections_, root_folder_, DQMStore::IBooker::setCurrentFolder(), AlCaHLTBitMon_QueryRunRegistry::string, fw3dlego::xbins, SiStripMonitorClusterAlca_cfi::xmax, SiStripMonitorClusterAlca_cfi::xmin, SiStripMonitorClusterAlca_cfi::ymax, and SiStripMonitorClusterAlca_cfi::ymin.

                                                                          {
   // TODO(rovere) make this booking method shorter and smarter,
   // factorizing similar histograms with different prefix in a single
   // method call.
   float log_bins[31] = {
     0.0, 0.0002, 0.0004, 0.0006, 0.0008, 0.001, 0.002,
     0.004, 0.006, 0.008, 0.01, 0.02,
     0.04, 0.06, 0.08, 0.1, 0.2,
     0.4, 0.6, 0.8, 1.0, 2.0,
     4.0, 6.0, 8.0, 10.0, 20.0,
     40.0, 60.0, 80.0, 100.0
   };
   float log_mergez_bins[18] = {
     0.0, 0.0025, 0.005, 0.0075, 0.01, 0.025, 0.05, 0.075, 0.1,
     0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0
   };
   float log_pt2_bins[16] = {
     0.0, 0.1, 0.5, 
     1.0, 2.0, 5.0,
     10.0, 20.0, 50.0,
     100.0, 200.0, 500.0, 
     1000.0, 2000.0, 5000.0,10000.0
   };
   float log_ntrk_bins[25] = {
     0., 2.0,  4.0,  6.0,  8.0,  10.,
     12.0, 14.0, 16.0, 18.0, 22.0,
     26.0, 30.0, 35.0, 40.0,
     45.0, 50.0, 55.0, 60.0, 70.0,
     80.0, 90.0, 100.0, 150.0, 200.0
   };
   // TODO(rovere) Possibly change or add the main DQMStore booking
   // interface to allow booking a TProfile with variable bin-width
   // using an array of floats, as done for the TH1F case, not of
   // doubles.
   double log_pt2_bins_double[16] = {
     0.0, 0.1, 0.5, 
     1.0, 2.0, 5.0,
     10.0, 20.0, 50.0,
     100.0, 200.0, 500.0, 
     1000.0, 2000.0, 5000.0,10000.0
   };
 
   i.setCurrentFolder(root_folder_);
   mes_["root_folder"]["GenVtx_vs_BX"] =
       i.book2D("GenVtx_vs_BX", "GenVtx_vs_BX", 16, -12.5, 3.5, 200, 0., 200.);
   // Generated Primary Vertex Plots
   mes_["root_folder"]["GenPV_X"] =
       i.book1D("GenPV_X", "GeneratedPV_X", 120, -0.6, 0.6);
   mes_["root_folder"]["GenPV_Y"] =
       i.book1D("GenPV_Y", "GeneratedPV_Y", 120, -0.6, 0.6);
   mes_["root_folder"]["GenPV_Z"] =
       i.book1D("GenPV_Z", "GeneratedPV_Z", 120, -60., 60.);
   mes_["root_folder"]["GenPV_R"] =
       i.book1D("GenPV_R", "GeneratedPV_R", 120, 0, 0.6);
   mes_["root_folder"]["GenPV_Pt2"] =
       i.book1D("GenPV_Pt2", "GeneratedPV_Sum-pt2", 15, &log_pt2_bins[0]);
   mes_["root_folder"]["GenPV_NumTracks"] =
       i.book1D("GenPV_NumTracks", "GeneratedPV_NumTracks", 24, &log_ntrk_bins[0]);
   mes_["root_folder"]["GenPV_ClosestDistanceZ"] =
       i.book1D("GenPV_ClosestDistanceZ", "GeneratedPV_ClosestDistanceZ", 30,
                &log_bins[0]);
 
   // All Generated Vertices, used for efficiency plots
   mes_["root_folder"]["GenAllV_NumVertices"] = i.book1D(
       "GenAllV_NumVertices", "GeneratedAllV_NumVertices", 100, 0., 200.);
   mes_["root_folder"]["GenAllV_X"] =
       i.book1D("GenAllV_X", "GeneratedAllV_X", 120, -0.6, 0.6);
   mes_["root_folder"]["GenAllV_Y"] =
       i.book1D("GenAllV_Y", "GeneratedAllV_Y", 120, -0.6, 0.6);
   mes_["root_folder"]["GenAllV_Z"] =
       i.book1D("GenAllV_Z", "GeneratedAllV_Z", 120, -60, 60);
   mes_["root_folder"]["GenAllV_R"] =
       i.book1D("GenAllV_R", "GeneratedAllV_R", 120, 0, 0.6);
   mes_["root_folder"]["GenAllV_Pt2"] =
       i.book1D("GenAllV_Pt2", "GeneratedAllV_Sum-pt2", 15, &log_pt2_bins[0]);
   mes_["root_folder"]["GenAllV_NumTracks"] =
       i.book1D("GenAllV_NumTracks", "GeneratedAllV_NumTracks", 24, &log_ntrk_bins[0]);
   mes_["root_folder"]["GenAllV_ClosestDistanceZ"] =
       i.book1D("GenAllV_ClosestDistanceZ", "GeneratedAllV_ClosestDistanceZ", 30,
                &log_bins[0]);
   mes_["root_folder"]["GenAllV_PairDistanceZ"] =
       i.book1D("GenAllV_PairDistanceZ", "GeneratedAllV_PairDistanceZ",
                1000, 0, 20);
   mes_["root_folder"]["SignalIsHighestPt2"] =
         i.book1D("SignalIsHighestPt2", "SignalIsHighestPt2", 2, -0.5, 1.5);
 
   for (auto const& l : reco_vertex_collections_) {
     std::string label = l.label();
     std::string current_folder = root_folder_ + "/" + label;
     i.setCurrentFolder(current_folder);
 
     mes_[label]["RecoVtx_vs_GenVtx"] = i.bookProfile(
         "RecoVtx_vs_GenVtx", "RecoVtx_vs_GenVtx", 125, 0., 250., 250, 0., 250.);
     mes_[label]["MatchedRecoVtx_vs_GenVtx"] =
         i.bookProfile("MatchedRecoVtx_vs_GenVtx", "MatchedRecoVtx_vs_GenVtx",
                       125, 0., 250., 250, 0., 250.);
     mes_[label]["KindOfSignalPV"] =
         i.book1D("KindOfSignalPV", "KindOfSignalPV", 9, -0.5, 8.5);
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(1, "!Highest!Assoc2Any");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(2, "Highest!Assoc2Any");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(3, "!HighestAssoc2First");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(4, "HighestAssoc2First");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(5, "!HighestAssoc2!First");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(6, "HighestAssoc2!First");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(7, "!HighestAssoc2First");
     mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(8, "HighestAssoc2First");
     mes_[label]["MisTagRate"] =
         i.book1D("MisTagRate", "MisTagRate", 2, -0.5, 1.5);
     mes_[label]["MisTagRate_vs_PU"] =
         i.bookProfile("MisTagRate_vs_PU", "MisTagRate_vs_PU", 125, 0., 250.,
                       2, 0., 1.);
     mes_[label]["MisTagRate_vs_sum-pt2"] =
         i.bookProfile("MisTagRate_vs_sum-pt2", "MisTagRate_vs_sum-pt2",
                       15, &log_pt2_bins_double[0], 2, 0., 1.);
     mes_[label]["MisTagRate_vs_Z"] =
         i.bookProfile("MisTagRate_vs_Z", "MisTagRate_vs_Z",
                       120, -60., 60., 2, 0., 1.);
     mes_[label]["MisTagRate_vs_R"] =
         i.bookProfile("MisTagRate_vs_R", "MisTagRate_vs_R",
                       120, 0., 0.6, 2, 0., 1.);
     mes_[label]["MisTagRate_vs_NumTracks"] =
         i.bookProfile("MisTagRate_vs_NumTracks", "MisTagRate_vs_NumTracks",
                       100, 0., 200, 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsHighest"] =
         i.book1D("MisTagRateSignalIsHighest",
                  "MisTagRateSignalIsHighest", 2, -0.5, 1.5);
     mes_[label]["MisTagRateSignalIsHighest_vs_PU"] =
         i.bookProfile("MisTagRateSignalIsHighest_vs_PU",
                       "MisTagRateSignalIsHighest_vs_PU", 125, 0., 250.,
                       2, 0., 1.);
     mes_[label]["MisTagRateSignalIsHighest_vs_sum-pt2"] =
         i.bookProfile("MisTagRateSignalIsHighest_vs_sum-pt2",
                       "MisTagRateSignalIsHighest_vs_sum-pt2",
                       15, &log_pt2_bins_double[0], 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsHighest_vs_Z"] =
         i.bookProfile("MisTagRateSignalIsHighest_vs_Z",
                       "MisTagRateSignalIsHighest_vs_Z",
                       120, -60., 60., 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsHighest_vs_R"] =
         i.bookProfile("MisTagRateSignalIsHighest_vs_R",
                       "MisTagRateSignalIsHighest_vs_R",
                       120, 0., 0.6, 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsHighest_vs_NumTracks"] =
         i.bookProfile("MisTagRateSignalIsHighest_vs_NumTracks",
                       "MisTagRateSignalIsHighest_vs_NumTracks",
                       100, 0., 200, 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsNotHighest"] =
         i.book1D("MisTagRateSignalIsNotHighest",
                  "MisTagRateSignalIsNotHighest", 2, -0.5, 1.5);
     mes_[label]["MisTagRateSignalIsNotHighest_vs_PU"] =
         i.bookProfile("MisTagRateSignalIsNotHighest_vs_PU",
                       "MisTagRateSignalIsNotHighest_vs_PU", 125, 0., 250.,
                       2, 0., 1.);
     mes_[label]["MisTagRateSignalIsNotHighest_vs_sum-pt2"] =
         i.bookProfile("MisTagRateSignalIsNotHighest_vs_sum-pt2",
                       "MisTagRateSignalIsNotHighest_vs_sum-pt2",
                       15, &log_pt2_bins_double[0], 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsNotHighest_vs_Z"] =
         i.bookProfile("MisTagRateSignalIsNotHighest_vs_Z",
                       "MisTagRateSignalIsNotHighest_vs_Z",
                       120, -60., 60., 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsNotHighest_vs_R"] =
         i.bookProfile("MisTagRateSignalIsNotHighest_vs_R",
                       "MisTagRateSignalIsNotHighest_vs_R",
                       120, 0., 0.6, 2, 0., 1.);
     mes_[label]["MisTagRateSignalIsNotHighest_vs_NumTracks"] =
         i.bookProfile("MisTagRateSignalIsNotHighest_vs_NumTracks",
                       "MisTagRateSignalIsNotHighest_vs_NumTracks",
                       100, 0., 200, 2, 0., 1.);
     mes_[label]["TruePVLocationIndex"] =
         i.book1D("TruePVLocationIndex",
                  "TruePVLocationIndexInRecoVertexCollection", 12, -1.5, 10.5);
     mes_[label]["TruePVLocationIndexCumulative"] =
         i.book1D("TruePVLocationIndexCumulative",
                  "TruePVLocationIndexInRecoVertexCollectionCumulative",
                  3, -1.5, 1.5);
     mes_[label]["TruePVLocationIndexSignalIsHighest"] =
         i.book1D("TruePVLocationIndexSignalIsHighest",
                  "TruePVLocationIndexSignalIsHighestInRecoVertexCollection",
                  12, -1.5, 10.5);
     mes_[label]["TruePVLocationIndexSignalIsNotHighest"] =
         i.book1D("TruePVLocationIndexSignalIsNotHighest",
                  "TruePVLocationIndexSignalIsNotHighestInRecoVertexCollection",
                  12, -1.5, 10.5);
     // All Generated Vertices. Used for Efficiency plots We kind of
     // duplicate plots here in case we want to perform more detailed
     // studies on a selection of generated vertices, not on all of them.
     mes_[label]["GenAllAssoc2Reco_NumVertices"] =
         i.book1D("GenAllAssoc2Reco_NumVertices",
                  "GeneratedAllAssoc2Reco_NumVertices", 100, 0., 200.);
     mes_[label]["GenAllAssoc2Reco_X"] = i.book1D(
         "GenAllAssoc2Reco_X", "GeneratedAllAssoc2Reco_X", 120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2Reco_Y"] = i.book1D(
         "GenAllAssoc2Reco_Y", "GeneratedAllAssoc2Reco_Y", 120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2Reco_Z"] = i.book1D(
         "GenAllAssoc2Reco_Z", "GeneratedAllAssoc2Reco_Z", 120, -60, 60);
     mes_[label]["GenAllAssoc2Reco_R"] =
         i.book1D("GenAllAssoc2Reco_R", "GeneratedAllAssoc2Reco_R", 120, 0, 0.6);
     mes_[label]["GenAllAssoc2Reco_Pt2"] =
         i.book1D("GenAllAssoc2Reco_Pt2", "GeneratedAllAssoc2Reco_Sum-pt2", 15,
                  &log_pt2_bins[0]);
     mes_[label]["GenAllAssoc2Reco_NumTracks"] =
         i.book1D("GenAllAssoc2Reco_NumTracks",
                  "GeneratedAllAssoc2Reco_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["GenAllAssoc2Reco_ClosestDistanceZ"] =
         i.book1D("GenAllAssoc2Reco_ClosestDistanceZ",
                  "GeneratedAllAssoc2Reco_ClosestDistanceZ", 30, &log_bins[0]);
 
     // All Generated Vertices Matched to a Reconstructed vertex. Used
     // for Efficiency plots
     mes_[label]["GenAllAssoc2RecoMatched_NumVertices"] =
         i.book1D("GenAllAssoc2RecoMatched_NumVertices",
                  "GeneratedAllAssoc2RecoMatched_NumVertices", 100, 0., 200.);
     mes_[label]["GenAllAssoc2RecoMatched_X"] =
         i.book1D("GenAllAssoc2RecoMatched_X", "GeneratedAllAssoc2RecoMatched_X",
                  120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2RecoMatched_Y"] =
         i.book1D("GenAllAssoc2RecoMatched_Y", "GeneratedAllAssoc2RecoMatched_Y",
                  120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2RecoMatched_Z"] =
         i.book1D("GenAllAssoc2RecoMatched_Z", "GeneratedAllAssoc2RecoMatched_Z",
                  120, -60, 60);
     mes_[label]["GenAllAssoc2RecoMatched_R"] =
         i.book1D("GenAllAssoc2RecoMatched_R", "GeneratedAllAssoc2RecoMatched_R",
                  120, 0, 0.6);
     mes_[label]["GenAllAssoc2RecoMatched_Pt2"] =
         i.book1D("GenAllAssoc2RecoMatched_Pt2",
                  "GeneratedAllAssoc2RecoMatched_Sum-pt2", 15, &log_pt2_bins[0]);
     mes_[label]["GenAllAssoc2RecoMatched_NumTracks"] =
         i.book1D("GenAllAssoc2RecoMatched_NumTracks",
                  "GeneratedAllAssoc2RecoMatched_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["GenAllAssoc2RecoMatched_ClosestDistanceZ"] = i.book1D(
         "GenAllAssoc2RecoMatched_ClosestDistanceZ",
         "GeneratedAllAssoc2RecoMatched_ClosestDistanceZ", 30, &log_bins[0]);
 
     // All Generated Vertices Multi-Matched to a Reconstructed vertex. Used
     // for Duplicate rate plots
     mes_[label]["GenAllAssoc2RecoMultiMatched_NumVertices"] = i.book1D(
         "GenAllAssoc2RecoMultiMatched_NumVertices",
         "GeneratedAllAssoc2RecoMultiMatched_NumVertices", 100, 0., 200.);
     mes_[label]["GenAllAssoc2RecoMultiMatched_X"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_X",
                  "GeneratedAllAssoc2RecoMultiMatched_X", 120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Y"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_Y",
                  "GeneratedAllAssoc2RecoMultiMatched_Y", 120, -0.6, 0.6);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Z"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_Z",
                  "GeneratedAllAssoc2RecoMultiMatched_Z", 120, -60, 60);
     mes_[label]["GenAllAssoc2RecoMultiMatched_R"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_R",
                  "GeneratedAllAssoc2RecoMultiMatched_R", 120, 0, 0.6);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Pt2"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_Pt2",
                  "GeneratedAllAssoc2RecoMultiMatched_Sum-pt2",
                  15, &log_pt2_bins[0]);
     mes_[label]["GenAllAssoc2RecoMultiMatched_NumTracks"] =
         i.book1D("GenAllAssoc2RecoMultiMatched_NumTracks",
                  "GeneratedAllAssoc2RecoMultiMatched_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["GenAllAssoc2RecoMultiMatched_ClosestDistanceZ"] = i.book1D(
         "GenAllAssoc2RecoMultiMatched_ClosestDistanceZ",
         "GeneratedAllAssoc2RecoMultiMatched_ClosestDistanceZ",
         30, &log_bins[0]);
 
     // All Reco Vertices. Used for {Fake,Duplicate}-Rate plots
     mes_[label]["RecoAllAssoc2Gen_NumVertices"] =
         i.book1D("RecoAllAssoc2Gen_NumVertices",
                  "ReconstructedAllAssoc2Gen_NumVertices", 100, 0., 200.);
     mes_[label]["RecoAllAssoc2Gen_X"] = i.book1D(
         "RecoAllAssoc2Gen_X", "ReconstructedAllAssoc2Gen_X", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2Gen_Y"] = i.book1D(
         "RecoAllAssoc2Gen_Y", "ReconstructedAllAssoc2Gen_Y", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2Gen_Z"] = i.book1D(
         "RecoAllAssoc2Gen_Z", "ReconstructedAllAssoc2Gen_Z", 120, -60, 60);
     mes_[label]["RecoAllAssoc2Gen_R"] = i.book1D(
         "RecoAllAssoc2Gen_R", "ReconstructedAllAssoc2Gen_R", 120, 0, 0.6);
     mes_[label]["RecoAllAssoc2Gen_Pt2"] =
         i.book1D("RecoAllAssoc2Gen_Pt2", "ReconstructedAllAssoc2Gen_Sum-pt2",
                  15, &log_pt2_bins[0]);
     mes_[label]["RecoAllAssoc2Gen_Ndof"] =
         i.book1D("RecoAllAssoc2Gen_Ndof",
                  "ReconstructedAllAssoc2Gen_Ndof", 120, 0., 240.);
     mes_[label]["RecoAllAssoc2Gen_NumTracks"] =
         i.book1D("RecoAllAssoc2Gen_NumTracks",
                  "ReconstructedAllAssoc2Gen_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["RecoAllAssoc2Gen_PU"] =
         i.book1D("RecoAllAssoc2Gen_PU",
                  "ReconstructedAllAssoc2Gen_PU", 125, 0., 250.);
     mes_[label]["RecoAllAssoc2Gen_ClosestDistanceZ"] =
         i.book1D("RecoAllAssoc2Gen_ClosestDistanceZ",
                  "ReconstructedAllAssoc2Gen_ClosestDistanceZ",
                  30, &log_bins[0]);
     mes_[label]["RecoAllAssoc2GenProperties"] =
         i.book1D("RecoAllAssoc2GenProperties",
                  "ReconstructedAllAssoc2Gen_Properties", 8, -0.5, 7.5);
     mes_[label]["RecoAllAssoc2Gen_PairDistanceZ"] =
         i.book1D("RecoAllAssoc2Gen_PairDistanceZ",
                  "RecoAllAssoc2Gen_PairDistanceZ", 1000, 0, 20);
 
     // All Reconstructed Vertices Matched to a Generated vertex. Used
     // for Fake-Rate plots
     mes_[label]["RecoAllAssoc2GenMatched_NumVertices"] =
         i.book1D("RecoAllAssoc2GenMatched_NumVertices",
                  "ReconstructedAllAssoc2GenMatched_NumVertices", 100, 0., 200.);
     mes_[label]["RecoAllAssoc2GenMatched_X"] =
         i.book1D("RecoAllAssoc2GenMatched_X",
                  "ReconstructedAllAssoc2GenMatched_X", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2GenMatched_Y"] =
         i.book1D("RecoAllAssoc2GenMatched_Y",
                  "ReconstructedAllAssoc2GenMatched_Y", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2GenMatched_Z"] =
         i.book1D("RecoAllAssoc2GenMatched_Z",
                  "ReconstructedAllAssoc2GenMatched_Z", 120, -60, 60);
     mes_[label]["RecoAllAssoc2GenMatched_R"] =
         i.book1D("RecoAllAssoc2GenMatched_R",
                  "ReconstructedAllAssoc2GenMatched_R", 120, 0, 0.6);
     mes_[label]["RecoAllAssoc2GenMatched_Pt2"] =
         i.book1D("RecoAllAssoc2GenMatched_Pt2",
                  "ReconstructedAllAssoc2GenMatched_Sum-pt2",
                  15, &log_pt2_bins[0]);
     mes_[label]["RecoAllAssoc2GenMatched_Ndof"] =
         i.book1D("RecoAllAssoc2GenMatched_Ndof",
                  "ReconstructedAllAssoc2GenMatched_Ndof", 120, 0., 240.);
     mes_[label]["RecoAllAssoc2GenMatched_NumTracks"] =
         i.book1D("RecoAllAssoc2GenMatched_NumTracks",
                  "ReconstructedAllAssoc2GenMatched_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["RecoAllAssoc2GenMatched_PU"] =
         i.book1D("RecoAllAssoc2GenMatched_PU",
                  "ReconstructedAllAssoc2GenMatched_PU", 125, 0., 250.);
     mes_[label]["RecoAllAssoc2GenMatched_ClosestDistanceZ"] = i.book1D(
         "RecoAllAssoc2GenMatched_ClosestDistanceZ",
         "ReconstructedAllAssoc2GenMatched_ClosestDistanceZ", 30, &log_bins[0]);
 
     // All Reconstructed Vertices  Multi-Matched to a Generated vertex. Used
     // for Merge-Rate plots
     mes_[label]["RecoAllAssoc2GenMultiMatched_NumVertices"] = i.book1D(
         "RecoAllAssoc2GenMultiMatched_NumVertices",
         "ReconstructedAllAssoc2GenMultiMatched_NumVertices", 100, 0., 200.);
     mes_[label]["RecoAllAssoc2GenMultiMatched_X"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_X",
                  "ReconstructedAllAssoc2GenMultiMatched_X", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Y"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_Y",
                  "ReconstructedAllAssoc2GenMultiMatched_Y", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Z"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_Z",
                  "ReconstructedAllAssoc2GenMultiMatched_Z", 120, -60, 60);
     mes_[label]["RecoAllAssoc2GenMultiMatched_R"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_R",
                  "ReconstructedAllAssoc2GenMultiMatched_R", 120, 0, 0.6);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Pt2"] = i.book1D(
         "RecoAllAssoc2GenMultiMatched_Pt2",
         "ReconstructedAllAssoc2GenMultiMatched_Sum-pt2", 15, &log_pt2_bins[0]);
     mes_[label]["RecoAllAssoc2GenMultiMatched_NumTracks"] = i.book1D(
         "RecoAllAssoc2GenMultiMatched_NumTracks",
         "ReconstructedAllAssoc2GenMultiMatched_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["RecoAllAssoc2GenMultiMatched_PU"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_PU",
                  "ReconstructedAllAssoc2GenMultiMatched_PU", 125, 0., 250.);
     mes_[label]["RecoAllAssoc2GenMultiMatched_ClosestDistanceZ"] =
         i.book1D("RecoAllAssoc2GenMultiMatched_ClosestDistanceZ",
                  "ReconstructedAllAssoc2GenMultiMatched_ClosestDistanceZ",
                  17, &log_mergez_bins[0]);
 
     // All Reconstructed Vertices Matched to a Multi-Matched Gen
     // Vertex. Used for Duplicate rate plots done w.r.t. Reco
     // Quantities. We basically want to ask how many times a RecoVTX
     // has been reconstructed and associated to a SimulatedVTX that
     // has been linked to at least another RecoVTX. In this sense this
     // RecoVTX is a duplicate of the same, real GenVTX.
     mes_[label]["RecoAllAssoc2MultiMatchedGen_NumVertices"] = i.book1D(
         "RecoAllAssoc2MultiMatchedGen_NumVertices",
         "RecoAllAssoc2MultiMatchedGen_NumVertices", 100, 0., 200.);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_X"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_X",
                  "RecoAllAssoc2MultiMatchedGen_X", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_Y"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_Y",
                  "RecoAllAssoc2MultiMatchedGen_Y", 120, -0.6, 0.6);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_Z"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_Z",
                  "RecoAllAssoc2MultiMatchedGen_Z", 120, -60, 60);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_R"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_R",
                  "RecoAllAssoc2MultiMatchedGen_R", 120, 0, 0.6);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_Pt2"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_Pt2",
                  "RecoAllAssoc2MultiMatchedGen_Sum-pt2", 15, &log_pt2_bins[0]);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_NumTracks"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_NumTracks",
                  "RecoAllAssoc2MultiMatchedGen_NumTracks", 24, &log_ntrk_bins[0]);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_PU"] =
         i.book1D("RecoAllAssoc2MultiMatchedGen_PU",
                  "RecoAllAssoc2MultiMatchedGen_PU", 125, 0., 250.);
     mes_[label]["RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ"] = i.book1D(
         "RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ",
         "RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ", 30, &log_bins[0]);
     mes_[label]["RecoAllAssoc2GenSimForMerge_ClosestDistanceZ"] = i.book1D(
         "RecoAllAssoc2GenSimForMerge_ClosestDistanceZ",
         "RecoAllAssoc2GenSimForMerge_ClosestDistanceZ",
         17, &log_mergez_bins[0]);
 
 
     // Resolution and pull histograms
     auto book1d = [&](const char *name, int bins, double min, double max) {
       mes_[label][name] = i.book1D(name, name, bins, min, max);
     };
     auto book1dlogx = [&](const char *name, int bins, float *xbinedges) {
       mes_[label][name] = i.book1D(name, name, bins, xbinedges);
     };
     auto book2d = [&](const char *name,
                       int xbins, double xmin, double xmax,
                       int ybins, double ymin, double ymax) {
       mes_[label][name] = i.book2D(name, name, xbins,xmin,xmax, ybins,ymin,ymax);
     };
     auto book2dlogx = [&](const char *name,
                           int xbins, float *xbinedges,
                           int ybins, double ymin, double ymax) {
       auto me = i.book2D(name, name, xbins,xbinedges[0],xbinedges[xbins], ybins,ymin,ymax);
       me->getTH2F()->GetXaxis()->Set(xbins, xbinedges);
       mes_[label][name] = me;
     };
 
     const double resolx = 0.1;
     const double resoly = 0.1;
     const double resolz = 0.1;
     const double resolpt2 = 10;
 
     // Non-merged vertices
     book1d("RecoAllAssoc2GenMatched_ResolX",   100,-resolx,resolx);
     book1d("RecoAllAssoc2GenMatched_ResolY",   100,-resoly,resoly);
     book1d("RecoAllAssoc2GenMatched_ResolZ",   100,-resolz,resolz);
     book1d("RecoAllAssoc2GenMatched_ResolPt2", 100,-resolpt2,resolpt2);
 
     book2d("RecoAllAssoc2GenMatched_ResolX_vs_PU",   125,0.,250., 100,-resolx,resolx);
     book2d("RecoAllAssoc2GenMatched_ResolY_vs_PU",   125,0.,250., 100,-resoly,resoly);
     book2d("RecoAllAssoc2GenMatched_ResolZ_vs_PU",   125,0.,250., 100,-resolz,resolz);
     book2d("RecoAllAssoc2GenMatched_ResolPt2_vs_PU", 125,0.,250., 100,-resolpt2,resolpt2);
 
     book2dlogx("RecoAllAssoc2GenMatched_ResolX_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resolx,resolx);
     book2dlogx("RecoAllAssoc2GenMatched_ResolY_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resoly,resoly);
     book2dlogx("RecoAllAssoc2GenMatched_ResolZ_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resolz,resolz);
     book2dlogx("RecoAllAssoc2GenMatched_ResolPt2_vs_NumTracks", 24,&log_ntrk_bins[0], 100,-resolpt2,resolpt2);
 
     book1d("RecoAllAssoc2GenMatched_PullX", 250,-25,25);
     book1d("RecoAllAssoc2GenMatched_PullY", 250,-25,25);
     book1d("RecoAllAssoc2GenMatched_PullZ", 250,-25,25);
 
     // Merged vertices
     book1d("RecoAllAssoc2GenMatchedMerged_ResolX",   100,-resolx,resolx);
     book1d("RecoAllAssoc2GenMatchedMerged_ResolY",   100,-resoly,resoly);
     book1d("RecoAllAssoc2GenMatchedMerged_ResolZ",   100,-resolz,resolz);
     book1d("RecoAllAssoc2GenMatchedMerged_ResolPt2", 100,-resolpt2,resolpt2);
 
     book2d("RecoAllAssoc2GenMatchedMerged_ResolX_vs_PU",   125,0.,250., 100,-resolx,resolx);
     book2d("RecoAllAssoc2GenMatchedMerged_ResolY_vs_PU",   125,0.,250., 100,-resoly,resoly);
     book2d("RecoAllAssoc2GenMatchedMerged_ResolZ_vs_PU",   125,0.,250., 100,-resolz,resolz);
     book2d("RecoAllAssoc2GenMatchedMerged_ResolPt2_vs_PU", 125,0.,250., 100,-resolpt2,resolpt2);
 
     book2dlogx("RecoAllAssoc2GenMatchedMerged_ResolX_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resolx,resolx);
     book2dlogx("RecoAllAssoc2GenMatchedMerged_ResolY_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resoly,resoly);
     book2dlogx("RecoAllAssoc2GenMatchedMerged_ResolZ_vs_NumTracks",   24,&log_ntrk_bins[0], 100,-resolz,resolz);
     book2dlogx("RecoAllAssoc2GenMatchedMerged_ResolPt2_vs_NumTracks", 24,&log_ntrk_bins[0], 100,-resolpt2,resolpt2);
 
     book1d("RecoAllAssoc2GenMatchedMerged_PullX", 250,-25,25);
     book1d("RecoAllAssoc2GenMatchedMerged_PullY", 250,-25,25);
     book1d("RecoAllAssoc2GenMatchedMerged_PullZ", 250,-25,25);
 
 
     // Purity histograms
     // Reco PV (vtx0) matched to hard-scatter gen vertex
     book1d("RecoPVAssoc2GenPVMatched_Purity", 50, 0, 1);
     book1d("RecoPVAssoc2GenPVMatched_Missing", 50, 0, 1);
     book2d("RecoPVAssoc2GenPVMatched_Purity_vs_Index", 100,0,100, 50,0,1);
 
     // RECO PV (vtx0) not matched to hard-scatter gen vertex
     book1d("RecoPVAssoc2GenPVNotMatched_Purity", 50, 0, 1);
     book1d("RecoPVAssoc2GenPVNotMatched_Missing", 50, 0, 1);
     book2d("RecoPVAssoc2GenPVNotMatched_Purity_vs_Index", 100,0,100, 50,0,1);
 
     // Purity vs. fake rate
     book1d("RecoAllAssoc2Gen_Purity", 50, 0, 1); // denominator
     book1d("RecoAllAssoc2GenMatched_Purity", 50, 0, 1); // 1-numerator
 
     // Vertex sum(pt2)
     // The first two are orthogonal (i.e. their sum includes all reco vertices)
     book1dlogx("RecoAssoc2GenPVMatched_Pt2", 15, &log_pt2_bins[0]);
     book1dlogx("RecoAssoc2GenPVNotMatched_Pt2", 15, &log_pt2_bins[0]);
 
     book1dlogx("RecoAssoc2GenPVMatchedNotHighest_Pt2", 15, &log_pt2_bins[0]);
     book1dlogx("RecoAssoc2GenPVNotMatched_GenPVTracksRemoved_Pt2", 15, &log_pt2_bins[0]);
 
     // Shared tracks
     book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionReco", 50, 0, 1);
     book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionReco", 50, 0, 1);
     book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionRecoMatched", 50, 0, 1);
     book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionRecoMatched", 50, 0, 1);
 
     book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionSim", 50, 0, 1);
     book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionSim", 50, 0, 1);
     book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionSimMatched", 50, 0, 1);
     book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionSimMatched", 50, 0, 1);
   }
 }

void PrimaryVertexAnalyzer4PUSlimmed::calculatePurityAndFillHistograms	(	const std::string &	label,
		std::vector< recoPrimaryVertex > &	recopvs,
		int	genpv_position_in_reco_collection,
		bool	signal_is_highest_pt
	)

private

Definition at line 791 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References i, diffTwoXMLs::label, matchRecoTrack2SimSignal(), mes_, combine::missing, prof2calltree::prefix, EnergyCorrector::pt, AlCaHLTBitMon_QueryRunRegistry::string, reco::Vertex::tracks_begin(), reco::Vertex::tracks_end(), and findQualityFiles::v.

Referenced by analyze().

                                {
   if(recopvs.empty()) return;
 
   std::vector<double> vtx_sumpt_sigmatched;
   std::vector<double> vtx_sumpt2_sigmatched;
 
   vtx_sumpt_sigmatched.reserve(recopvs.size());
   vtx_sumpt2_sigmatched.reserve(recopvs.size());
 
   // Calculate purity
   for(auto& v: recopvs) {
     double sumpt_all = 0;
     double sumpt_sigmatched = 0;
     double sumpt2_sigmatched = 0;
     const reco::Vertex *vertex = v.recVtx;
     for(auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) {
       double pt = (*iTrack)->pt();
       sumpt_all += pt;
       if(matchRecoTrack2SimSignal(*iTrack)) {
         sumpt_sigmatched += pt;
         sumpt2_sigmatched += pt*pt;
       }
     }
     v.purity = sumpt_sigmatched / sumpt_all;
 
     vtx_sumpt_sigmatched.push_back(sumpt_sigmatched);
     vtx_sumpt2_sigmatched.push_back(sumpt2_sigmatched);
   }
 
   const double vtxAll_sumpt_sigmatched = std::accumulate(vtx_sumpt_sigmatched.begin(), vtx_sumpt_sigmatched.end(), 0.0);
   const double vtxNot0_sumpt_sigmatched = vtxAll_sumpt_sigmatched - vtx_sumpt_sigmatched[0];
   const double missing = vtxNot0_sumpt_sigmatched / vtxAll_sumpt_sigmatched;
 
   // Fill purity
   std::string prefix = "RecoPVAssoc2GenPVNotMatched_";
   if(genpv_position_in_reco_collection == 0)
     prefix = "RecoPVAssoc2GenPVMatched_";
 
   mes_[label][prefix+"Purity"]->Fill(recopvs[0].purity);
   mes_[label][prefix+"Missing"]->Fill(missing);
   auto hpurity = mes_[label][prefix+"Purity_vs_Index"];
   for(size_t i=0; i<recopvs.size(); ++i) {
     hpurity->Fill(i, recopvs[i].purity);
   }
 
   // Fill sumpt2
   for(size_t i=0; i<recopvs.size(); ++i) {
     if(static_cast<int>(i) == genpv_position_in_reco_collection) {
       mes_[label]["RecoAssoc2GenPVMatched_Pt2"]->Fill(recopvs[i].ptsq);
     }
     else {
       double pt2 = recopvs[i].ptsq;
       mes_[label]["RecoAssoc2GenPVNotMatched_Pt2"]->Fill(pt2);
       // Subtract hard-scatter track pt2 from the pileup pt2
       double pt2_pu = pt2-vtx_sumpt2_sigmatched[i];
       mes_[label]["RecoAssoc2GenPVNotMatched_GenPVTracksRemoved_Pt2"]->Fill(pt2_pu);
     }
   }
   if(!signal_is_highest_pt && genpv_position_in_reco_collection >= 0)
     mes_[label]["RecoAssoc2GenPVMatchedNotHighest_Pt2"]->Fill(recopvs[genpv_position_in_reco_collection].ptsq);
 }

template<class T >

void PrimaryVertexAnalyzer4PUSlimmed::computePairDistance	(	const T &	collection,
		MonitorElement *	me
	)

private

Definition at line 1431 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References funct::abs(), MonitorElement::Fill(), i, j, and z.

Referenced by analyze().

                                                                               {
   for (unsigned int i = 0; i < collection.size(); ++i) {
     for (unsigned int j = i+1; j < collection.size(); ++j) {
       me->Fill(
           std::abs(collection[i].z-collection[j].z));
     }
   }
 }

void PrimaryVertexAnalyzer4PUSlimmed::fillGenAssociatedRecoVertexHistograms	(	const std::string &	label,
		int	num_pileup_vertices,
		PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex &	v
	)

private

Definition at line 636 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

Referenced by analyze().

                                                          {
   mes_[label]["RecoAllAssoc2Gen_X"]->Fill(v.x);
   mes_[label]["RecoAllAssoc2Gen_Y"]->Fill(v.y);
   mes_[label]["RecoAllAssoc2Gen_Z"]->Fill(v.z);
   mes_[label]["RecoAllAssoc2Gen_R"]->Fill(v.r);
   mes_[label]["RecoAllAssoc2Gen_Pt2"]->Fill(v.ptsq);
   mes_[label]["RecoAllAssoc2Gen_Ndof"]->Fill(v.recVtx->ndof());
   mes_[label]["RecoAllAssoc2Gen_NumTracks"]->Fill(v.nRecoTrk);
   mes_[label]["RecoAllAssoc2Gen_PU"]->Fill(num_pileup_vertices);
   mes_[label]["RecoAllAssoc2Gen_Purity"]->Fill(v.purity);
   if (v.closest_vertex_distance_z > 0.)
     mes_[label]["RecoAllAssoc2Gen_ClosestDistanceZ"]
         ->Fill(v.closest_vertex_distance_z);
   if (v.sim_vertices.size()) {
     v.kind_of_vertex |= recoPrimaryVertex::MATCHED;
     mes_[label]["RecoAllAssoc2GenMatched_X"]->Fill(v.x);
     mes_[label]["RecoAllAssoc2GenMatched_Y"]->Fill(v.y);
     mes_[label]["RecoAllAssoc2GenMatched_Z"]->Fill(v.z);
     mes_[label]["RecoAllAssoc2GenMatched_R"]->Fill(v.r);
     mes_[label]["RecoAllAssoc2GenMatched_Pt2"]->Fill(v.ptsq);
     mes_[label]["RecoAllAssoc2GenMatched_Ndof"]->Fill(v.recVtx->ndof());
     mes_[label]["RecoAllAssoc2GenMatched_NumTracks"]->Fill(v.nRecoTrk);
     mes_[label]["RecoAllAssoc2GenMatched_PU"]->Fill(num_pileup_vertices);
     mes_[label]["RecoAllAssoc2GenMatched_Purity"]->Fill(v.purity);
     if (v.closest_vertex_distance_z > 0.)
       mes_[label]["RecoAllAssoc2GenMatched_ClosestDistanceZ"]
           ->Fill(v.closest_vertex_distance_z);
 
     // Fill resolution and pull plots here (as in MultiTrackValidator)
     fillResolutionAndPullHistograms(label, num_pileup_vertices, v);
 
     // Now keep track of all RecoVTX associated to a SimVTX that
     // itself is associated to more than one RecoVTX, for
     // duplicate-rate plots on reco quantities.
     if (v.sim_vertices_internal[0]->rec_vertices.size() > 1) {
       v.kind_of_vertex |= recoPrimaryVertex::DUPLICATE;
       mes_[label]["RecoAllAssoc2MultiMatchedGen_X"]->Fill(v.x);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_Y"]->Fill(v.y);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_Z"]->Fill(v.z);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_R"]->Fill(v.r);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_Pt2"]->Fill(v.ptsq);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_NumTracks"]->Fill(v.nRecoTrk);
       mes_[label]["RecoAllAssoc2MultiMatchedGen_PU"]->Fill(num_pileup_vertices);
       if (v.closest_vertex_distance_z > 0.)
         mes_[label]["RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ"]
             ->Fill(v.closest_vertex_distance_z);
     }
     // This is meant to be used as "denominator" for the merge-rate
     // plots produced starting from reco quantities. We   enter here
     // only if the reco vertex has been associated, since we need info
     // from the SimVTX associated to it. In this regard, the final
     // merge-rate plot coming from reco is not to be intended as a
     // pure efficiency-like plot, since the normalization is biased.
     if (v.sim_vertices_internal[0]->closest_vertex_distance_z > 0.)
       mes_[label]["RecoAllAssoc2GenSimForMerge_ClosestDistanceZ"]
           ->Fill(v.sim_vertices_internal[0]->closest_vertex_distance_z);
   }
   // this plots are meant to be used to compute the merge rate
   if (v.sim_vertices.size() > 1) {
     v.kind_of_vertex |= recoPrimaryVertex::MERGED;
     mes_[label]["RecoAllAssoc2GenMultiMatched_X"]->Fill(v.x);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Y"]->Fill(v.y);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Z"]->Fill(v.z);
     mes_[label]["RecoAllAssoc2GenMultiMatched_R"]->Fill(v.r);
     mes_[label]["RecoAllAssoc2GenMultiMatched_Pt2"]->Fill(v.ptsq);
     mes_[label]["RecoAllAssoc2GenMultiMatched_NumTracks"]->Fill(v.nRecoTrk);
     mes_[label]["RecoAllAssoc2GenMultiMatched_PU"]->Fill(num_pileup_vertices);
     if (v.sim_vertices_internal[0]->closest_vertex_distance_z > 0.)
       mes_[label]["RecoAllAssoc2GenMultiMatched_ClosestDistanceZ"]
           ->Fill(v.sim_vertices_internal[0]->closest_vertex_distance_z);
   }
   mes_[label]["RecoAllAssoc2GenProperties"]->Fill(v.kind_of_vertex);
 
 
   std::string prefix;
   if(v.sim_vertices.size() == 1) {
     prefix = "RecoAllAssoc2GenSingleMatched_SharedTrackFraction";
   }
   else if(v.sim_vertices.size() > 1) {
     prefix = "RecoAllAssoc2GenMultiMatched_SharedTrackFraction";
   }
 
   for(size_t i=0; i<v.sim_vertices.size(); ++i) {
     const double sharedTracks = v.sim_vertices_num_shared_tracks[i];
     const simPrimaryVertex *simV = v.sim_vertices_internal[i];
     mes_[label][prefix+"Reco"]->Fill(sharedTracks/v.nRecoTrk);
     mes_[label][prefix+"RecoMatched"]->Fill(sharedTracks/v.num_matched_sim_tracks);
     mes_[label][prefix+"Sim"]->Fill(sharedTracks/simV->nGenTrk);
     mes_[label][prefix+"SimMatched"]->Fill(sharedTracks/simV->num_matched_reco_tracks);
   }
 }

void PrimaryVertexAnalyzer4PUSlimmed::fillGenericGenVertexHistograms ( const simPrimaryVertex & v )

private

Definition at line 576 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

Referenced by analyze().

                                {
   if (v.eventId.event() == 0) {
     mes_["root_folder"]["GenPV_X"]->Fill(v.x);
     mes_["root_folder"]["GenPV_Y"]->Fill(v.y);
     mes_["root_folder"]["GenPV_Z"]->Fill(v.z);
     mes_["root_folder"]["GenPV_R"]->Fill(v.r);
     mes_["root_folder"]["GenPV_Pt2"]->Fill(v.ptsq);
     mes_["root_folder"]["GenPV_NumTracks"]->Fill(v.nGenTrk);
     if (v.closest_vertex_distance_z > 0.)
       mes_["root_folder"]["GenPV_ClosestDistanceZ"]
           ->Fill(v.closest_vertex_distance_z);
   }
   mes_["root_folder"]["GenAllV_X"]->Fill(v.x);
   mes_["root_folder"]["GenAllV_Y"]->Fill(v.y);
   mes_["root_folder"]["GenAllV_Z"]->Fill(v.z);
   mes_["root_folder"]["GenAllV_R"]->Fill(v.r);
   mes_["root_folder"]["GenAllV_Pt2"]->Fill(v.ptsq);
   mes_["root_folder"]["GenAllV_NumTracks"]->Fill(v.nGenTrk);
   if (v.closest_vertex_distance_z > 0.)
     mes_["root_folder"]["GenAllV_ClosestDistanceZ"]
         ->Fill(v.closest_vertex_distance_z);
 }

void PrimaryVertexAnalyzer4PUSlimmed::fillRecoAssociatedGenVertexHistograms	(	const std::string &	label,
		const simPrimaryVertex &	v
	)

private

Definition at line 600 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

Referenced by analyze().

                                                               {
   mes_[label]["GenAllAssoc2Reco_X"]->Fill(v.x);
   mes_[label]["GenAllAssoc2Reco_Y"]->Fill(v.y);
   mes_[label]["GenAllAssoc2Reco_Z"]->Fill(v.z);
   mes_[label]["GenAllAssoc2Reco_R"]->Fill(v.r);
   mes_[label]["GenAllAssoc2Reco_Pt2"]->Fill(v.ptsq);
   mes_[label]["GenAllAssoc2Reco_NumTracks"]->Fill(v.nGenTrk);
   if (v.closest_vertex_distance_z > 0.)
     mes_[label]["GenAllAssoc2Reco_ClosestDistanceZ"]
         ->Fill(v.closest_vertex_distance_z);
   if (v.rec_vertices.size()) {
     mes_[label]["GenAllAssoc2RecoMatched_X"]->Fill(v.x);
     mes_[label]["GenAllAssoc2RecoMatched_Y"]->Fill(v.y);
     mes_[label]["GenAllAssoc2RecoMatched_Z"]->Fill(v.z);
     mes_[label]["GenAllAssoc2RecoMatched_R"]->Fill(v.r);
     mes_[label]["GenAllAssoc2RecoMatched_Pt2"]->Fill(v.ptsq);
     mes_[label]["GenAllAssoc2RecoMatched_NumTracks"]->Fill(v.nGenTrk);
     if (v.closest_vertex_distance_z > 0.)
       mes_[label]["GenAllAssoc2RecoMatched_ClosestDistanceZ"]
           ->Fill(v.closest_vertex_distance_z);
   }
   if (v.rec_vertices.size() > 1) {
     mes_[label]["GenAllAssoc2RecoMultiMatched_X"]->Fill(v.x);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Y"]->Fill(v.y);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Z"]->Fill(v.z);
     mes_[label]["GenAllAssoc2RecoMultiMatched_R"]->Fill(v.r);
     mes_[label]["GenAllAssoc2RecoMultiMatched_Pt2"]->Fill(v.ptsq);
     mes_[label]["GenAllAssoc2RecoMultiMatched_NumTracks"]->Fill(v.nGenTrk);
     if (v.closest_vertex_distance_z > 0.)
       mes_[label]["GenAllAssoc2RecoMultiMatched_ClosestDistanceZ"]
           ->Fill(v.closest_vertex_distance_z);
   }
 }

void PrimaryVertexAnalyzer4PUSlimmed::fillResolutionAndPullHistograms	(	const std::string &	label,
		int	num_pileup_vertices,
		PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex &	v
	)

private

Definition at line 731 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

Referenced by fillGenAssociatedRecoVertexHistograms().

                                                          {
 
   std::string prefix = "RecoAllAssoc2GenMatched";
   if(v.sim_vertices_internal.size() > 1) {
     prefix += "Merged";
   }
 
   // Use the best match as defined by the vertex truth associator
   // reco-tracks as the best match
   const simPrimaryVertex& bestMatch = *(v.sim_vertices_internal[0]);
   const double xres = v.x - bestMatch.x;
   const double yres = v.y - bestMatch.y;
   const double zres = v.z - bestMatch.z;
   const double pt2res = v.ptsq - bestMatch.ptsq;
 
   const double xresol = xres;
   const double yresol = yres;
   const double zresol = zres;
   const double pt2resol = pt2res/v.ptsq;
 
   mes_[label][prefix+"_ResolX"]->Fill(xresol);
   mes_[label][prefix+"_ResolY"]->Fill(yresol);
   mes_[label][prefix+"_ResolZ"]->Fill(zresol);
   mes_[label][prefix+"_ResolPt2"]->Fill(pt2resol);
 
   mes_[label][prefix+"_ResolX_vs_PU"]->Fill(num_pileup_vertices, xresol);
   mes_[label][prefix+"_ResolY_vs_PU"]->Fill(num_pileup_vertices, yresol);
   mes_[label][prefix+"_ResolZ_vs_PU"]->Fill(num_pileup_vertices, zresol);
   mes_[label][prefix+"_ResolPt2_vs_PU"]->Fill(num_pileup_vertices, pt2resol);
 
   mes_[label][prefix+"_ResolX_vs_NumTracks"]->Fill(v.nRecoTrk, xresol);
   mes_[label][prefix+"_ResolY_vs_NumTracks"]->Fill(v.nRecoTrk, yresol);
   mes_[label][prefix+"_ResolZ_vs_NumTracks"]->Fill(v.nRecoTrk, zresol);
   mes_[label][prefix+"_ResolPt2_vs_NumTracks"]->Fill(v.nRecoTrk, pt2resol);
 
   mes_[label][prefix+"_PullX"]->Fill(xres/v.recVtx->xError());
   mes_[label][prefix+"_PullY"]->Fill(yres/v.recVtx->yError());
   mes_[label][prefix+"_PullZ"]->Fill(zres/v.recVtx->zError());
 }

std::vector< PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex > PrimaryVertexAnalyzer4PUSlimmed::getRecoPVs ( const edm::Handle< edm::View< reco::Vertex >> & tVC )

private

Definition at line 1029 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References funct::abs(), gather_cfg::cout, HLT_25ns14e33_v1_cff::distance, edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), min(), PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::nRecoTrk, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::num_matched_sim_tracks, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::ptsq, r2s_, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::recVtx, findQualityFiles::v, and verbose_.

Referenced by analyze().

                                                {
   std::vector<PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex> recopv;
 
   if (verbose_) {
     std::cout << "getRecoPVs TrackingVertexCollection " << std::endl;
   }
 
   for (auto v = tVC->begin(); v != tVC->end(); ++v) {
     if (verbose_) {
       std::cout << " Position: " << v->position() << std::endl;
     }
 
     // Skip junk vertices
     if (fabs(v->z()) > 1000) continue;
     if (v->isFake() || !v->isValid()) continue;
 
     recoPrimaryVertex sv(v->position().x(), v->position().y(),
                          v->position().z());
     sv.recVtx = &(*v);
     sv.recVtxRef = reco::VertexBaseRef(tVC, std::distance(tVC->begin(), v));
     // this is a new vertex, add it to the list of reco-vertices
     recopv.push_back(sv);
     PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex* vp = &recopv.back();
 
     // Loop over daughter track(s)
     for (auto iTrack = v->tracks_begin(); iTrack != v->tracks_end(); ++iTrack) {
       auto momentum = (*(*iTrack)).innerMomentum();
       // TODO(rovere) better handle the pixelVertices, whose tracks
       // do not have the innerMomentum defined. This is a temporary
       // hack to overcome this problem.
       if (momentum.mag2() == 0)
         momentum = (*(*iTrack)).momentum();
       if (verbose_) {
         std::cout << "  Daughter momentum:      " << momentum;
         std::cout << std::endl;
       }
       vp->ptsq += (momentum.perp2());
       vp->nRecoTrk++;
 
       auto matched = r2s_->find(*iTrack);
       if(matched != r2s_->end()) {
         vp->num_matched_sim_tracks++;
       }
 
     }  // End of for loop on daughters reconstructed tracks
   }    // End of for loop on tracking vertices
 
   if (verbose_) {
     std::cout << "------- PrimaryVertexAnalyzer4PUSlimmed recoPVs from "
                  "VertexCollection "
                  "-------" << std::endl;
     for (std::vector<recoPrimaryVertex>::iterator v0 = recopv.begin();
          v0 != recopv.end(); v0++) {
       std::cout << "z=" << v0->z << std::endl;
     }
     std::cout << "-----------------------------------------------" << std::endl;
   }  // End of for summary on reconstructed primary vertices.
 
   // In case of no reco vertices, break here
   if(recopv.empty())
     return recopv;
 
   // Now compute the closest distance in z between all reconstructed vertex
   // first initialize
   auto prev_z = recopv.back().z;
   for(recoPrimaryVertex& vreco: recopv) {
     vreco.closest_vertex_distance_z = std::abs(vreco.z - prev_z);
     prev_z = vreco.z;
   }
   for (std::vector<recoPrimaryVertex>::iterator vreco = recopv.begin();
        vreco != recopv.end(); vreco++) {
     std::vector<recoPrimaryVertex>::iterator vreco2 = vreco;
     vreco2++;
     for (; vreco2 != recopv.end(); vreco2++) {
       double distance = std::abs(vreco->z - vreco2->z);
       // need both to be complete
       vreco->closest_vertex_distance_z = std::min(vreco->closest_vertex_distance_z, distance);
       vreco2->closest_vertex_distance_z = std::min(vreco2->closest_vertex_distance_z, distance);
     }
   }
   return recopv;
 }

std::vector< PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex > PrimaryVertexAnalyzer4PUSlimmed::getSimPVs ( const edm::Handle< TrackingVertexCollection > & tVC )

private

Definition at line 861 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References funct::abs(), assert(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::average_match_quality, gather_cfg::cout, HLT_25ns14e33_v1_cff::distance, alignCSCRings::e, edm::AssociationMap< Tag >::end(), event(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::eventId, edm::AssociationMap< Tag >::find(), min(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::nGenTrk, NULL, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::num_matched_reco_tracks, benchmark_cfg::pdgId, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::ptot, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::ptsq, s2r_, use_only_charged_tracks_, findQualityFiles::v, and verbose_.

Referenced by analyze().

                                                     {
   std::vector<PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex> simpv;
   int current_event = -1;
 
   if (verbose_) {
     std::cout << "getSimPVs TrackingVertexCollection " << std::endl;
   }
 
   for (TrackingVertexCollection::const_iterator v = tVC->begin();
        v != tVC->end(); ++v) {
     if (verbose_) {
       std::cout << "BunchX.EventId: " << v->eventId().bunchCrossing() << "."
                 << (v->eventId()).event() << " Position: " << v->position()
                 << " G4/HepMC Vertices: " << v->g4Vertices().size() << "/"
                 << v->genVertices().size()
                 << "   t = " << v->position().t() * 1.e12
                 << "    == 0:" << (v->position().t() > 0) << std::endl;
       for (TrackingVertex::g4v_iterator gv = v->g4Vertices_begin();
            gv != v->g4Vertices_end(); gv++) {
         std::cout << *gv << std::endl;
       }
       std::cout << "----------" << std::endl;
     }  // end of verbose_ session
 
     // I'd rather change this and select only vertices that come from
     // BX=0.  We should keep only the first vertex from all the events
     // at BX=0.
     if (v->eventId().bunchCrossing() != 0) continue;
     if (v->eventId().event() != current_event) {
       current_event = v->eventId().event();
     } else {
       continue;
     }
     // TODO(rovere) is this really necessary?
     if (fabs(v->position().z()) > 1000) continue;  // skip funny junk vertices
 
     // could be a new vertex, check  all primaries found so far to avoid
     // multiple entries
     simPrimaryVertex sv(v->position().x(), v->position().y(),
                         v->position().z());
     sv.eventId = v->eventId();
     sv.sim_vertex = TrackingVertexRef(tVC, std::distance(tVC->begin(), v));
 
     for (TrackingParticleRefVector::iterator iTrack = v->daughterTracks_begin();
          iTrack != v->daughterTracks_end(); ++iTrack) {
       // TODO(rovere) isn't it always the case? Is it really worth
       // checking this out?
       // sv.eventId = (**iTrack).eventId();
       assert((**iTrack).eventId().bunchCrossing() == 0);
     }
     // TODO(rovere) maybe get rid of this old logic completely ... ?
     simPrimaryVertex* vp = NULL;  // will become non-NULL if a vertex
                                   // is found and then point to it
     for (std::vector<simPrimaryVertex>::iterator v0 = simpv.begin();
          v0 != simpv.end(); v0++) {
       if ((sv.eventId == v0->eventId) && (fabs(sv.x - v0->x) < 1e-5) &&
           (fabs(sv.y - v0->y) < 1e-5) && (fabs(sv.z - v0->z) < 1e-5)) {
         vp = &(*v0);
         break;
       }
     }
     if (!vp) {
       // this is a new vertex, add it to the list of sim-vertices
       simpv.push_back(sv);
       vp = &simpv.back();
       if (verbose_) {
         std::cout << "this is a new vertex " << sv.eventId.event() << "   "
                   << sv.x << " " << sv.y << " " << sv.z << std::endl;
       }
     } else {
       if (verbose_) {
         std::cout << "this is not a new vertex" << sv.x << " " << sv.y << " "
                   << sv.z << std::endl;
       }
     }
 
     // Loop over daughter track(s) as Tracking Particles
     for (TrackingVertex::tp_iterator iTP = v->daughterTracks_begin();
          iTP != v->daughterTracks_end(); ++iTP) {
       auto momentum = (*(*iTP)).momentum();
       const reco::Track* matched_best_reco_track = nullptr;
       double match_quality = -1;
       if (use_only_charged_tracks_ && (**iTP).charge() == 0)
           continue;
       if (s2r_->find(*iTP) != s2r_->end()) {
         matched_best_reco_track = (*s2r_)[*iTP][0].first.get();
         match_quality = (*s2r_)[*iTP][0].second;
       }
       if (verbose_) {
         std::cout << "  Daughter momentum:      " << momentum;
         std::cout << "  Daughter type     " << (*(*iTP)).pdgId();
         std::cout << "  matched: " << (matched_best_reco_track != nullptr);
         std::cout << "  match-quality: " << match_quality;
         std::cout << std::endl;
       }
       vp->ptot.setPx(vp->ptot.x() + momentum.x());
       vp->ptot.setPy(vp->ptot.y() + momentum.y());
       vp->ptot.setPz(vp->ptot.z() + momentum.z());
       vp->ptot.setE(vp->ptot.e() + (**iTP).energy());
       vp->ptsq += ((**iTP).pt() * (**iTP).pt());
       // TODO(rovere) only select charged sim-particles? If so, maybe
       // put it as a configuration parameter?
       if (matched_best_reco_track) {
         vp->num_matched_reco_tracks++;
         vp->average_match_quality += match_quality;
       }
       // TODO(rovere) get rid of cuts on sim-tracks
       // TODO(rovere) be consistent between simulated tracks and
       // reconstructed tracks selection
       // count relevant particles
       if (((**iTP).pt() > 0.2) && (fabs((**iTP).eta()) < 2.5) &&
           (**iTP).charge() != 0) {
         vp->nGenTrk++;
       }
     }  // End of for loop on daughters sim-particles
     if (vp->num_matched_reco_tracks)
       vp->average_match_quality /=
           static_cast<float>(vp->num_matched_reco_tracks);
     if (verbose_) {
       std::cout << "average number of associated tracks: "
                 << vp->num_matched_reco_tracks / static_cast<float>(vp->nGenTrk)
                 << " with average quality: " << vp->average_match_quality
                 << std::endl;
     }
   }  // End of for loop on tracking vertices
 
   if (verbose_) {
     std::cout << "------- PrimaryVertexAnalyzer4PUSlimmed simPVs from "
                  "TrackingVertices "
                  "-------" << std::endl;
     for (std::vector<simPrimaryVertex>::iterator v0 = simpv.begin();
          v0 != simpv.end(); v0++) {
       std::cout << "z=" << v0->z << "  event=" << v0->eventId.event()
                 << std::endl;
     }
     std::cout << "-----------------------------------------------" << std::endl;
   }  // End of for summary on discovered simulated primary vertices.
 
   // In case of no simulated vertices, break here
   if(simpv.empty())
     return simpv;
 
   // Now compute the closest distance in z between all simulated vertex
   // first initialize
   auto prev_z = simpv.back().z;
   for(simPrimaryVertex& vsim: simpv) {
     vsim.closest_vertex_distance_z = std::abs(vsim.z - prev_z);
     prev_z = vsim.z;
   }
   // then calculate
   for (std::vector<simPrimaryVertex>::iterator vsim = simpv.begin();
        vsim != simpv.end(); vsim++) {
     std::vector<simPrimaryVertex>::iterator vsim2 = vsim;
     vsim2++;
     for (; vsim2 != simpv.end(); vsim2++) {
       double distance = std::abs(vsim->z - vsim2->z);
       // need both to be complete
       vsim->closest_vertex_distance_z = std::min(vsim->closest_vertex_distance_z, distance);
       vsim2->closest_vertex_distance_z = std::min(vsim2->closest_vertex_distance_z, distance);
     }
   }
   return simpv;
 }

void PrimaryVertexAnalyzer4PUSlimmed::matchReco2SimVertices	(	std::vector< recoPrimaryVertex > &	recopv,
		const reco::VertexRecoToSimCollection &	vertex_r2s,
		const std::vector< simPrimaryVertex > &	simpv
	)

private

Definition at line 1155 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References calculateVertexSharedTracks(), gather_cfg::cout, edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), r2s_, findQualityFiles::v, and verbose_.

Referenced by analyze().

                                               {
   for (std::vector<recoPrimaryVertex>::iterator vrec = recopv.begin();
        vrec != recopv.end(); vrec++) {
 
     auto matched = vertex_r2s.find(vrec->recVtxRef);
     if(matched != vertex_r2s.end()) {
       for(const auto vertexRefQuality: matched->val) {
         const auto tvPtr = &(*(vertexRefQuality.first));
         vrec->sim_vertices.push_back(tvPtr);
       }
 
       for(const TrackingVertex *tv: vrec->sim_vertices) {
         // Set pointers to internal simVertex objects
         for(const auto& vv: simpv) {
           if (&(*(vv.sim_vertex)) == tv) {
             vrec->sim_vertices_internal.push_back(&vv);
             continue;
           }
         }
 
         // Calculate number of shared tracks
         vrec->sim_vertices_num_shared_tracks.push_back(calculateVertexSharedTracks(*(vrec->recVtx), *tv, *r2s_));
       }
     }
 
     if (verbose_) {
       for (auto v : vrec->sim_vertices) {
         std::cout << "Found a matching vertex for reco: " << vrec->z
                   << " at gen:" << v->position().z() << " with sign: "
                   << fabs(vrec->z - v->position().z()) / vrec->recVtx->zError()
                   << std::endl;
       }
     }
   }  // end for loop on reconstructed vertices
 }

bool PrimaryVertexAnalyzer4PUSlimmed::matchRecoTrack2SimSignal ( const reco::TrackBaseRef & recoTrack )

private

Definition at line 774 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), newFWLiteAna::found, and r2s_.

Referenced by calculatePurityAndFillHistograms().

                                                                                                 {
   auto found = r2s_->find(recoTrack);
 
   // reco track not matched to any TP
   if(found == r2s_->end())
     return false;
 
   // reco track matched to some TP from signal vertex
   for(const auto& tp: found->val) {
     if(tp.first->eventId().bunchCrossing() == 0 && tp.first->eventId().event() == 0)
       return true;
   }
 
   // reco track not matched to any TP from signal vertex
   return false;
 }

void PrimaryVertexAnalyzer4PUSlimmed::matchSim2RecoVertices	(	std::vector< simPrimaryVertex > &	simpv,
		const reco::VertexSimToRecoCollection &	vertex_s2r
	)

private

Definition at line 1121 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References gather_cfg::cout, edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), findQualityFiles::v, and verbose_.

Referenced by analyze().

                                                      {
   if (verbose_) {
     std::cout << "PrimaryVertexAnalyzer4PUSlimmed::matchSim2RecoVertices " << std::endl;
   }
   for (std::vector<simPrimaryVertex>::iterator vsim = simpv.begin();
        vsim != simpv.end(); vsim++) {
 
     auto matched = vertex_s2r.find(vsim->sim_vertex);
     if(matched != vertex_s2r.end()) {
       for(const auto vertexRefQuality: matched->val) {
         vsim->rec_vertices.push_back(&(*(vertexRefQuality.first)));
       }
     }
 
     if (verbose_) {
       if (vsim->rec_vertices.size()) {
         for (auto const& v : vsim->rec_vertices) {
           std::cout << "Found a matching vertex for genVtx "
                     << vsim->z << " at " << v->z()
                     << " with sign: " << fabs(v->z() - vsim->z) / v->zError()
                     << std::endl;
         }
       } else {
         std::cout << "No matching vertex for " << vsim->z << std::endl;
       }
     }
   }  // end for loop on simulated vertices
   if (verbose_) {
     std::cout << "Done with matching sim vertices" << std::endl;
   }
 }

void PrimaryVertexAnalyzer4PUSlimmed::resetSimPVAssociation ( std::vector< simPrimaryVertex > & simpv )

private

Definition at line 1113 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

References findQualityFiles::v.

Referenced by analyze().

                                          {
   for (auto & v : simpv) {
     v.rec_vertices.clear();
   }
 }

Member Data Documentation

double PrimaryVertexAnalyzer4PUSlimmed::abs_z_match_

private

Definition at line 177 of file PrimaryVertexAnalyzer4PUSlimmed.h.

edm::EDGetTokenT< edm::View<reco::Track> > PrimaryVertexAnalyzer4PUSlimmed::edmView_recoTrack_Token_

private

Definition at line 188 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

std::map<std::string, std::map<std::string, MonitorElement*> > PrimaryVertexAnalyzer4PUSlimmed::mes_

private

Definition at line 180 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), bookHistograms(), calculatePurityAndFillHistograms(), fillGenAssociatedRecoVertexHistograms(), fillGenericGenVertexHistograms(), fillRecoAssociatedGenVertexHistograms(), and fillResolutionAndPullHistograms().

const reco::RecoToSimCollection* PrimaryVertexAnalyzer4PUSlimmed::r2s_

private

Definition at line 181 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), getRecoPVs(), matchReco2SimVertices(), and matchRecoTrack2SimSignal().

std::vector<edm::EDGetTokenT<edm::View<reco::Vertex> > > PrimaryVertexAnalyzer4PUSlimmed::reco_vertex_collection_tokens_

private

Definition at line 185 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and PrimaryVertexAnalyzer4PUSlimmed().

std::vector<edm::InputTag > PrimaryVertexAnalyzer4PUSlimmed::reco_vertex_collections_

private

Definition at line 186 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), bookHistograms(), and PrimaryVertexAnalyzer4PUSlimmed().

edm::EDGetTokenT<reco::RecoToSimCollection> PrimaryVertexAnalyzer4PUSlimmed::recoToSimAssociationToken_

private

Definition at line 192 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

edm::EDGetTokenT<reco::TrackCollection> PrimaryVertexAnalyzer4PUSlimmed::recoTrackCollectionToken_

private

Definition at line 187 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

std::string PrimaryVertexAnalyzer4PUSlimmed::root_folder_

private

Definition at line 178 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by bookHistograms().

const reco::SimToRecoCollection* PrimaryVertexAnalyzer4PUSlimmed::s2r_

private

Definition at line 182 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and getSimPVs().

double PrimaryVertexAnalyzer4PUSlimmed::sigma_z_match_

private

Definition at line 176 of file PrimaryVertexAnalyzer4PUSlimmed.h.

edm::EDGetTokenT<reco::SimToRecoCollection> PrimaryVertexAnalyzer4PUSlimmed::simToRecoAssociationToken_

private

Definition at line 191 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

edm::EDGetTokenT<TrackingParticleCollection> PrimaryVertexAnalyzer4PUSlimmed::trackingParticleCollectionToken_

private

Definition at line 189 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

edm::EDGetTokenT<TrackingVertexCollection> PrimaryVertexAnalyzer4PUSlimmed::trackingVertexCollectionToken_

private

Definition at line 190 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

bool PrimaryVertexAnalyzer4PUSlimmed::use_only_charged_tracks_

private

Definition at line 175 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by getSimPVs().

edm::EDGetTokenT< std::vector<PileupSummaryInfo> > PrimaryVertexAnalyzer4PUSlimmed::vecPileupSummaryInfoToken_

private

Definition at line 184 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

bool PrimaryVertexAnalyzer4PUSlimmed::verbose_

private

Definition at line 174 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), getRecoPVs(), getSimPVs(), matchReco2SimVertices(), and matchSim2RecoVertices().

edm::EDGetTokenT<reco::VertexToTrackingVertexAssociator> PrimaryVertexAnalyzer4PUSlimmed::vertexAssociatorToken_

private

Definition at line 193 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

Classes

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation