CMS 3D CMS Logo
List of all members | Classes | Public Member Functions | Private Types | Private Member Functions | Private Attributes
PrimaryVertexAnalyzer4PUSlimmed Class Reference

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

Inheritance diagram for PrimaryVertexAnalyzer4PUSlimmed:
DQMEDAnalyzer edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >

Classes

struct  recoPrimaryVertex
 
struct  simPrimaryVertex
 

Public Member Functions

void analyze (const edm::Event &, const edm::EventSetup &) override
 
void bookHistograms (DQMStore::IBooker &i, edm::Run const &, edm::EventSetup const &) override
 
 PrimaryVertexAnalyzer4PUSlimmed (const edm::ParameterSet &)
 
 ~PrimaryVertexAnalyzer4PUSlimmed () override
 
- Public Member Functions inherited from DQMEDAnalyzer
void accumulate (edm::Event const &event, edm::EventSetup const &setup) final
 
void beginLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void beginRun (edm::Run const &run, edm::EventSetup const &setup) final
 
void beginStream (edm::StreamID id) final
 
virtual void dqmBeginRun (edm::Run const &, edm::EventSetup const &)
 
 DQMEDAnalyzer ()
 
void endLuminosityBlock (edm::LuminosityBlock const &lumi, edm::EventSetup const &setup) final
 
void endRun (edm::Run const &run, edm::EventSetup const &setup) final
 
virtual bool getCanSaveByLumi ()
 
- Public Member Functions inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
 EDProducer ()=default
 
bool hasAbilityToProduceInBeginLumis () const final
 
bool hasAbilityToProduceInBeginRuns () const final
 
bool hasAbilityToProduceInEndLumis () const final
 
bool hasAbilityToProduceInEndRuns () const final
 

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 fillRecoAssociatedGenPVHistograms (const std::string &label, const PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex &v, bool genPVMatchedToRecoPV)
 
void fillRecoAssociatedGenVertexHistograms (const std::string &, const simPrimaryVertex &v)
 
void fillResolutionAndPullHistograms (const std::string &, int, recoPrimaryVertex &v, bool)
 
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

const bool do_generic_sim_plots_
 
std::vector< bool > errorPrintedForColl_
 
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_
 
std::string root_folder_
 
const reco::SimToRecoCollection * s2r_
 
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 DQMEDAnalyzer
typedef dqm::reco::DQMStore DQMStore
 
typedef dqm::reco::MonitorElement MonitorElement
 
- Public Types inherited from edm::stream::EDProducer< edm::GlobalCache< DQMEDAnalyzerGlobalCache >, edm::EndRunProducer, edm::EndLuminosityBlockProducer, edm::Accumulator >
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
 
- Static Public Member Functions inherited from DQMEDAnalyzer
static void globalEndJob (DQMEDAnalyzerGlobalCache const *)
 
static void globalEndLuminosityBlockProduce (edm::LuminosityBlock &lumi, edm::EventSetup const &setup, LuminosityBlockContext const *context)
 
static void globalEndRunProduce (edm::Run &run, edm::EventSetup const &setup, RunContext const *context)
 
static std::unique_ptr< DQMEDAnalyzerGlobalCache > initializeGlobalCache (edm::ParameterSet const &)
 
- Protected Member Functions inherited from DQMEDAnalyzer
uint64_t meId () const
 
- Protected Attributes inherited from DQMEDAnalyzer
edm::EDPutTokenT< DQMToken > lumiToken_
 
edm::EDPutTokenT< DQMToken > runToken_
 
unsigned int streamId_
 

Detailed Description

Description: primary vertex analyzer for events with pile-up

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

Definition at line 61 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Member Typedef Documentation

◆ LorentzVector

typedef math::XYZTLorentzVector PrimaryVertexAnalyzer4PUSlimmed::LorentzVector
private

Definition at line 62 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Member Enumeration Documentation

◆ SignalVertexKind

enum PrimaryVertexAnalyzer4PUSlimmed::SignalVertexKind
private
Enumerator
HIGHEST_PT 
IS_ASSOC2FIRST_RECO 
IS_ASSOC2ANY_RECO 

Definition at line 64 of file PrimaryVertexAnalyzer4PUSlimmed.h.

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

Constructor & Destructor Documentation

◆ PrimaryVertexAnalyzer4PUSlimmed()

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

Definition at line 44 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

45  : verbose_(iConfig.getUntrackedParameter<bool>("verbose", false)),
46  use_only_charged_tracks_(iConfig.getUntrackedParameter<bool>("use_only_charged_tracks", true)),
47  do_generic_sim_plots_(iConfig.getUntrackedParameter<bool>("do_generic_sim_plots")),
48  root_folder_(iConfig.getUntrackedParameter<std::string>("root_folder", "Validation/Vertices")),
49  vecPileupSummaryInfoToken_(consumes<std::vector<PileupSummaryInfo>>(edm::InputTag(std::string("addPileupInfo")))),
50  trackingParticleCollectionToken_(consumes<TrackingParticleCollection>(
51  iConfig.getUntrackedParameter<edm::InputTag>("trackingParticleCollection"))),
52  trackingVertexCollectionToken_(
53  consumes<TrackingVertexCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackingVertexCollection"))),
54  simToRecoAssociationToken_(
55  consumes<reco::SimToRecoCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
56  recoToSimAssociationToken_(
57  consumes<reco::RecoToSimCollection>(iConfig.getUntrackedParameter<edm::InputTag>("trackAssociatorMap"))),
58  vertexAssociatorToken_(consumes<reco::VertexToTrackingVertexAssociator>(
59  iConfig.getUntrackedParameter<edm::InputTag>("vertexAssociator"))) {
60  reco_vertex_collections_ = iConfig.getParameter<std::vector<edm::InputTag>>("vertexRecoCollections");
61  for (auto const& l : reco_vertex_collections_) {
62  reco_vertex_collection_tokens_.push_back(
63  edm::EDGetTokenT<edm::View<reco::Vertex>>(consumes<edm::View<reco::Vertex>>(l)));
64  }
65  errorPrintedForColl_.resize(reco_vertex_collections_.size(), false);
66 }

References errorPrintedForColl_, edm::ParameterSet::getParameter(), cmsLHEtoEOSManager::l, reco_vertex_collection_tokens_, and reco_vertex_collections_.

◆ ~PrimaryVertexAnalyzer4PUSlimmed()

PrimaryVertexAnalyzer4PUSlimmed::~PrimaryVertexAnalyzer4PUSlimmed ( )
override

Definition at line 68 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

68 {}

Member Function Documentation

◆ analyze()

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

Reimplemented from DQMEDAnalyzer.

Definition at line 1108 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

1108  {
1109  using edm::Handle;
1110  using edm::View;
1111  using std::cout;
1112  using std::endl;
1113  using std::vector;
1114  using namespace reco;
1115 
1116  std::vector<float> pileUpInfo_z;
1117 
1118  // get the pileup information
1119  edm::Handle<std::vector<PileupSummaryInfo>> puinfoH;
1120  if (iEvent.getByToken(vecPileupSummaryInfoToken_, puinfoH)) {
1121  for (auto const& pu_info : *puinfoH.product()) {
1122  if (do_generic_sim_plots_) {
1123  mes_["root_folder"]["GenVtx_vs_BX"]->Fill(pu_info.getBunchCrossing(), pu_info.getPU_NumInteractions());
1124  }
1125  if (pu_info.getBunchCrossing() == 0) {
1126  pileUpInfo_z = pu_info.getPU_zpositions();
1127  if (verbose_) {
1128  for (auto const& p : pileUpInfo_z) {
1129  std::cout << "PileUpInfo on Z vertex: " << p << std::endl;
1130  }
1131  }
1132  break;
1133  }
1134  }
1135  }
1136 
1137  edm::Handle<TrackingParticleCollection> TPCollectionH;
1138  iEvent.getByToken(trackingParticleCollectionToken_, TPCollectionH);
1139  if (!TPCollectionH.isValid())
1140  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed") << "TPCollectionH is not valid";
1141 
1142  edm::Handle<TrackingVertexCollection> TVCollectionH;
1143  iEvent.getByToken(trackingVertexCollectionToken_, TVCollectionH);
1144  if (!TVCollectionH.isValid())
1145  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed") << "TVCollectionH is not valid";
1146 
1147  // TODO(rovere) the idea is to put in case a track-selector in front
1148  // of this module and then use its label to get the selected tracks
1149  // out of the event instead of making an hard-coded selection in the
1150  // code.
1151 
1152  edm::Handle<reco::SimToRecoCollection> simToRecoH;
1153  iEvent.getByToken(simToRecoAssociationToken_, simToRecoH);
1154  if (simToRecoH.isValid())
1155  s2r_ = simToRecoH.product();
1156  else
1157  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed") << "simToRecoH is not valid";
1158 
1159  edm::Handle<reco::RecoToSimCollection> recoToSimH;
1160  iEvent.getByToken(recoToSimAssociationToken_, recoToSimH);
1161  if (recoToSimH.isValid())
1162  r2s_ = recoToSimH.product();
1163  else
1164  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed") << "recoToSimH is not valid";
1165 
1166  // Vertex associator
1167  edm::Handle<reco::VertexToTrackingVertexAssociator> vertexAssociatorH;
1168  iEvent.getByToken(vertexAssociatorToken_, vertexAssociatorH);
1169  if (!vertexAssociatorH.isValid()) {
1170  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed") << "vertexAssociatorH is not valid";
1171  return;
1172  }
1173  const reco::VertexToTrackingVertexAssociator& vertexAssociator = *(vertexAssociatorH.product());
1174 
1175  std::vector<simPrimaryVertex> simpv; // a list of simulated primary
1176  // MC vertices
1177  // TODO(rovere) use move semantic?
1178  simpv = getSimPVs(TVCollectionH);
1179  // TODO(rovere) 1 vertex is not, by definition, pileup, and should
1180  // probably be subtracted?
1181  int kind_of_signal_vertex = 0;
1182  int num_pileup_vertices = simpv.size();
1183  if (do_generic_sim_plots_)
1184  mes_["root_folder"]["GenAllV_NumVertices"]->Fill(simpv.size());
1185  bool signal_is_highest_pt =
1186  std::max_element(simpv.begin(), simpv.end(), [](const simPrimaryVertex& lhs, const simPrimaryVertex& rhs) {
1187  return lhs.ptsq < rhs.ptsq;
1188  }) == simpv.begin();
1189  kind_of_signal_vertex |= (signal_is_highest_pt << HIGHEST_PT);
1190  if (do_generic_sim_plots_) {
1191  mes_["root_folder"]["SignalIsHighestPt2"]->Fill(signal_is_highest_pt ? 1. : 0.);
1192  computePairDistance(simpv, mes_["root_folder"]["GenAllV_PairDistanceZ"]);
1193  }
1194 
1195  int label_index = -1;
1196  for (size_t iToken = 0, endToken = reco_vertex_collection_tokens_.size(); iToken < endToken; ++iToken) {
1197  auto const& vertex_token = reco_vertex_collection_tokens_[iToken];
1198  std::vector<recoPrimaryVertex> recopv; // a list of reconstructed
1199  // primary MC vertices
1200  std::string label = reco_vertex_collections_[++label_index].label();
1201  edm::Handle<edm::View<reco::Vertex>> recVtxs;
1202  if (!iEvent.getByToken(vertex_token, recVtxs)) {
1203  if (!errorPrintedForColl_[iToken]) {
1204  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed")
1205  << "Skipping vertex collection: " << label << " since it is missing.";
1206  errorPrintedForColl_[iToken] = true;
1207  }
1208  continue;
1209  }
1210 
1211  {
1212  // check upfront that refs to track are (likely) to be valid
1213  bool ok = true;
1214  for (const auto& v : *recVtxs) {
1215  if (v.tracksSize() > 0) {
1216  const auto& ref = v.trackRefAt(0);
1217  if (ref.isNull() || !ref.isAvailable()) {
1218  if (!errorPrintedForColl_[iToken]) {
1219  edm::LogWarning("PrimaryVertexAnalyzer4PUSlimmed")
1220  << "Skipping vertex collection: " << label
1221  << " since likely the track collection the vertex has refs pointing to is missing (at least the "
1222  "first TrackBaseRef is null or not available)";
1223  errorPrintedForColl_[iToken] = true;
1224  }
1225  ok = false;
1226  }
1227  }
1228  }
1229  if (!ok)
1230  continue;
1231  }
1232 
1233  reco::VertexRecoToSimCollection vertex_r2s = vertexAssociator.associateRecoToSim(recVtxs, TVCollectionH);
1234  reco::VertexSimToRecoCollection vertex_s2r = vertexAssociator.associateSimToReco(recVtxs, TVCollectionH);
1235 
1236  resetSimPVAssociation(simpv);
1237  matchSim2RecoVertices(simpv, vertex_s2r);
1238  recopv = getRecoPVs(recVtxs);
1239  computePairDistance(recopv, mes_[label]["RecoAllAssoc2Gen_PairDistanceZ"]);
1240  matchReco2SimVertices(recopv, vertex_r2s, simpv);
1241 
1242  int num_total_gen_vertices_assoc2reco = 0;
1243  int num_total_reco_vertices_assoc2gen = 0;
1244  int num_total_gen_vertices_multiassoc2reco = 0;
1245  int num_total_reco_vertices_multiassoc2gen = 0;
1246  int num_total_reco_vertices_duplicate = 0;
1247  int genpv_position_in_reco_collection = -1;
1248  for (auto const& v : simpv) {
1249  float mistag = 1.;
1250  // TODO(rovere) put selectors here in front of fill* methods.
1251  if (v.eventId.event() == 0) {
1252  if (!recVtxs->empty() && std::find(v.rec_vertices.begin(), v.rec_vertices.end(), &((*recVtxs.product())[0])) !=
1253  v.rec_vertices.end()) {
1254  mistag = 0.;
1255  kind_of_signal_vertex |= (1 << IS_ASSOC2FIRST_RECO);
1256  } else {
1257  if (!v.rec_vertices.empty()) {
1258  kind_of_signal_vertex |= (1 << IS_ASSOC2ANY_RECO);
1259  }
1260  }
1261  mes_[label]["KindOfSignalPV"]->Fill(kind_of_signal_vertex);
1262  mes_[label]["MisTagRate"]->Fill(mistag);
1263  mes_[label]["MisTagRate_vs_PU"]->Fill(simpv.size(), mistag);
1264  mes_[label]["MisTagRate_vs_sum-pt2"]->Fill(v.ptsq, mistag);
1265  mes_[label]["MisTagRate_vs_Z"]->Fill(v.z, mistag);
1266  mes_[label]["MisTagRate_vs_R"]->Fill(v.r, mistag);
1267  mes_[label]["MisTagRate_vs_NumTracks"]->Fill(v.nGenTrk, mistag);
1268  if (signal_is_highest_pt) {
1269  mes_[label]["MisTagRateSignalIsHighest"]->Fill(mistag);
1270  mes_[label]["MisTagRateSignalIsHighest_vs_PU"]->Fill(simpv.size(), mistag);
1271  mes_[label]["MisTagRateSignalIsHighest_vs_sum-pt2"]->Fill(v.ptsq, mistag);
1272  mes_[label]["MisTagRateSignalIsHighest_vs_Z"]->Fill(v.z, mistag);
1273  mes_[label]["MisTagRateSignalIsHighest_vs_R"]->Fill(v.r, mistag);
1274  mes_[label]["MisTagRateSignalIsHighest_vs_NumTracks"]->Fill(v.nGenTrk, mistag);
1275  } else {
1276  mes_[label]["MisTagRateSignalIsNotHighest"]->Fill(mistag);
1277  mes_[label]["MisTagRateSignalIsNotHighest_vs_PU"]->Fill(simpv.size(), mistag);
1278  mes_[label]["MisTagRateSignalIsNotHighest_vs_sum-pt2"]->Fill(v.ptsq, mistag);
1279  mes_[label]["MisTagRateSignalIsNotHighest_vs_Z"]->Fill(v.z, mistag);
1280  mes_[label]["MisTagRateSignalIsNotHighest_vs_R"]->Fill(v.r, mistag);
1281  mes_[label]["MisTagRateSignalIsNotHighest_vs_NumTracks"]->Fill(v.nGenTrk, mistag);
1282  }
1283  // Now check at which location the Simulated PV has been
1284  // reconstructed in the primary vertex collection
1285  // at-hand. Mark it with fake index -1 if it was not
1286  // reconstructed at all.
1287 
1288  auto iv = (*recVtxs.product()).begin();
1289  for (int pv_position_in_reco_collection = 0; iv != (*recVtxs.product()).end();
1290  ++pv_position_in_reco_collection, ++iv) {
1291  if (std::find(v.rec_vertices.begin(), v.rec_vertices.end(), &(*iv)) != v.rec_vertices.end()) {
1292  mes_[label]["TruePVLocationIndex"]->Fill(pv_position_in_reco_collection);
1293  const bool genPVMatchedToRecoPV = (pv_position_in_reco_collection == 0);
1294  mes_[label]["TruePVLocationIndexCumulative"]->Fill(genPVMatchedToRecoPV ? 0 : 1);
1295 
1296  if (signal_is_highest_pt) {
1297  mes_[label]["TruePVLocationIndexSignalIsHighest"]->Fill(pv_position_in_reco_collection);
1298  } else {
1299  mes_[label]["TruePVLocationIndexSignalIsNotHighest"]->Fill(pv_position_in_reco_collection);
1300  }
1301 
1302  fillRecoAssociatedGenPVHistograms(label, v, genPVMatchedToRecoPV);
1303  if (genPVMatchedToRecoPV) {
1304  auto pv = recopv[0];
1305  assert(pv.recVtx == &(*iv));
1306  fillResolutionAndPullHistograms(label, num_pileup_vertices, pv, true);
1307  }
1308  genpv_position_in_reco_collection = pv_position_in_reco_collection;
1309  break;
1310  }
1311  }
1312 
1313  // If we reached the end, it means that the Simulated PV has not
1314  // been associated to any reconstructed vertex: mark it as
1315  // missing in the reconstructed vertex collection using the fake
1316  // index -1.
1317  if (iv == (*recVtxs.product()).end()) {
1318  mes_[label]["TruePVLocationIndex"]->Fill(-1.);
1319  mes_[label]["TruePVLocationIndexCumulative"]->Fill(-1.);
1320  if (signal_is_highest_pt)
1321  mes_[label]["TruePVLocationIndexSignalIsHighest"]->Fill(-1.);
1322  else
1323  mes_[label]["TruePVLocationIndexSignalIsNotHighest"]->Fill(-1.);
1324  }
1325  }
1326 
1327  if (!v.rec_vertices.empty())
1328  num_total_gen_vertices_assoc2reco++;
1329  if (v.rec_vertices.size() > 1)
1330  num_total_gen_vertices_multiassoc2reco++;
1331  // No need to N-tplicate the Gen-related cumulative histograms:
1332  // fill them only at the first iteration
1333  if (do_generic_sim_plots_ && label_index == 0)
1334  fillGenericGenVertexHistograms(v);
1335  fillRecoAssociatedGenVertexHistograms(label, v);
1336  }
1337  calculatePurityAndFillHistograms(label, recopv, genpv_position_in_reco_collection, signal_is_highest_pt);
1338 
1339  mes_[label]["GenAllAssoc2Reco_NumVertices"]->Fill(simpv.size(), simpv.size());
1340  mes_[label]["GenAllAssoc2RecoMatched_NumVertices"]->Fill(simpv.size(), num_total_gen_vertices_assoc2reco);
1341  mes_[label]["GenAllAssoc2RecoMultiMatched_NumVertices"]->Fill(simpv.size(), num_total_gen_vertices_multiassoc2reco);
1342  for (auto& v : recopv) {
1343  fillGenAssociatedRecoVertexHistograms(label, num_pileup_vertices, v);
1344  if (!v.sim_vertices.empty()) {
1345  num_total_reco_vertices_assoc2gen++;
1346  if (v.sim_vertices_internal[0]->rec_vertices.size() > 1) {
1347  num_total_reco_vertices_duplicate++;
1348  }
1349  }
1350  if (v.sim_vertices.size() > 1)
1351  num_total_reco_vertices_multiassoc2gen++;
1352  }
1353  mes_[label]["RecoAllAssoc2Gen_NumVertices"]->Fill(recopv.size(), recopv.size());
1354  mes_[label]["RecoAllAssoc2GenMatched_NumVertices"]->Fill(recopv.size(), num_total_reco_vertices_assoc2gen);
1355  mes_[label]["RecoAllAssoc2GenMultiMatched_NumVertices"]->Fill(recopv.size(),
1356  num_total_reco_vertices_multiassoc2gen);
1357  mes_[label]["RecoAllAssoc2MultiMatchedGen_NumVertices"]->Fill(recopv.size(), num_total_reco_vertices_duplicate);
1358  mes_[label]["RecoVtx_vs_GenVtx"]->Fill(simpv.size(), recopv.size());
1359  mes_[label]["MatchedRecoVtx_vs_GenVtx"]->Fill(simpv.size(), num_total_reco_vertices_assoc2gen);
1360  }
1361 } // end of analyze

References cms::cuda::assert(), begin, calculatePurityAndFillHistograms(), computePairDistance(), gather_cfg::cout, do_generic_sim_plots_, end, errorPrintedForColl_, fillGenAssociatedRecoVertexHistograms(), fillGenericGenVertexHistograms(), fillRecoAssociatedGenPVHistograms(), fillRecoAssociatedGenVertexHistograms(), fillResolutionAndPullHistograms(), spr::find(), getRecoPVs(), getSimPVs(), HIGHEST_PT, iEvent, IS_ASSOC2ANY_RECO, IS_ASSOC2FIRST_RECO, edm::HandleBase::isValid(), label, matchReco2SimVertices(), matchSim2RecoVertices(), mes_, convertSQLiteXML::ok, AlCaHLTBitMon_ParallelJobs::p, edm::Handle< T >::product(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::ptsq, MetAnalyzer::pv(), r2s_, reco_vertex_collection_tokens_, reco_vertex_collections_, recoToSimAssociationToken_, resetSimPVAssociation(), s2r_, simToRecoAssociationToken_, AlCaHLTBitMon_QueryRunRegistry::string, trackingParticleCollectionToken_, trackingVertexCollectionToken_, findQualityFiles::v, vecPileupSummaryInfoToken_, verbose_, packedPFCandidates_cfi::vertexAssociator, and vertexAssociatorToken_.

◆ bookHistograms()

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

Implements DQMEDAnalyzer.

Definition at line 73 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

75  {
76  // TODO(rovere) make this booking method shorter and smarter,
77  // factorizing similar histograms with different prefix in a single
78  // method call.
79  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,
80  0.02, 0.04, 0.06, 0.08, 0.1, 0.2, 0.4, 0.6, 0.8, 1.0, 2.0,
81  4.0, 6.0, 8.0, 10.0, 20.0, 40.0, 60.0, 80.0, 100.0};
82  auto const log_mergez_bins = makeLogBins<float, 16>(1e-4, 1); // 4 bins / 10x
83 
84  auto const log_pt_bins = makeLogBins<float, 100>(0.1, 1e4);
85  float log_pt2_bins[16] = {
86  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};
87  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,
88  35.0, 40.0, 45.0, 50.0, 55.0, 60.0, 70.0, 80.0, 90.0, 100.0, 150.0, 200.0};
89 
90  // TODO(rovere) Possibly change or add the main DQMStore booking
91  // interface to allow booking a TProfile with variable bin-width
92  // using an array of floats, as done for the TH1F case, not of
93  // doubles.
94  double log_pt2_bins_double[16] = {
95  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};
96 
97  i.setCurrentFolder(root_folder_);
98  if (do_generic_sim_plots_) {
99  mes_["root_folder"]["GenVtx_vs_BX"] = i.book2D("GenVtx_vs_BX", "GenVtx_vs_BX", 16, -12.5, 3.5, 200, 0., 200.);
100  // Generated Primary Vertex Plots
101  mes_["root_folder"]["GenPV_X"] = i.book1D("GenPV_X", "GeneratedPV_X", 120, -0.6, 0.6);
102  mes_["root_folder"]["GenPV_Y"] = i.book1D("GenPV_Y", "GeneratedPV_Y", 120, -0.6, 0.6);
103  mes_["root_folder"]["GenPV_Z"] = i.book1D("GenPV_Z", "GeneratedPV_Z", 120, -60., 60.);
104  mes_["root_folder"]["GenPV_R"] = i.book1D("GenPV_R", "GeneratedPV_R", 120, 0, 0.6);
105  mes_["root_folder"]["GenPV_Pt2"] = i.book1D("GenPV_Pt2", "GeneratedPV_Sum-pt2", 15, &log_pt2_bins[0]);
106  mes_["root_folder"]["GenPV_NumTracks"] =
107  i.book1D("GenPV_NumTracks", "GeneratedPV_NumTracks", 24, &log_ntrk_bins[0]);
108  mes_["root_folder"]["GenPV_ClosestDistanceZ"] =
109  i.book1D("GenPV_ClosestDistanceZ", "GeneratedPV_ClosestDistanceZ", 30, &log_bins[0]);
110 
111  // All Generated Vertices, used for efficiency plots
112  mes_["root_folder"]["GenAllV_NumVertices"] =
113  i.book1D("GenAllV_NumVertices", "GeneratedAllV_NumVertices", 100, 0., 200.);
114  mes_["root_folder"]["GenAllV_X"] = i.book1D("GenAllV_X", "GeneratedAllV_X", 120, -0.6, 0.6);
115  mes_["root_folder"]["GenAllV_Y"] = i.book1D("GenAllV_Y", "GeneratedAllV_Y", 120, -0.6, 0.6);
116  mes_["root_folder"]["GenAllV_Z"] = i.book1D("GenAllV_Z", "GeneratedAllV_Z", 120, -60, 60);
117  mes_["root_folder"]["GenAllV_R"] = i.book1D("GenAllV_R", "GeneratedAllV_R", 120, 0, 0.6);
118  mes_["root_folder"]["GenAllV_Pt2"] = i.book1D("GenAllV_Pt2", "GeneratedAllV_Sum-pt2", 15, &log_pt2_bins[0]);
119  mes_["root_folder"]["GenAllV_NumTracks"] =
120  i.book1D("GenAllV_NumTracks", "GeneratedAllV_NumTracks", 24, &log_ntrk_bins[0]);
121  mes_["root_folder"]["GenAllV_ClosestDistanceZ"] =
122  i.book1D("GenAllV_ClosestDistanceZ", "GeneratedAllV_ClosestDistanceZ", 30, &log_bins[0]);
123  mes_["root_folder"]["GenAllV_PairDistanceZ"] =
124  i.book1D("GenAllV_PairDistanceZ", "GeneratedAllV_PairDistanceZ", 1000, 0, 20);
125  mes_["root_folder"]["SignalIsHighestPt2"] = i.book1D("SignalIsHighestPt2", "SignalIsHighestPt2", 2, -0.5, 1.5);
126  }
127 
128  for (auto const& l : reco_vertex_collections_) {
129  std::string label = l.label();
130  std::string current_folder = root_folder_ + "/" + label;
131  i.setCurrentFolder(current_folder);
132 
133  auto book1d = [&](const char* name, int bins, double min, double max) {
134  mes_[label][name] = i.book1D(name, name, bins, min, max);
135  };
136  auto book1dlogx = [&](const char* name, int bins, const float* xbinedges) {
137  mes_[label][name] = i.book1D(name, name, bins, xbinedges);
138  };
139  auto book2d = [&](const char* name, int xbins, double xmin, double xmax, int ybins, double ymin, double ymax) {
140  mes_[label][name] = i.book2D(name, name, xbins, xmin, xmax, ybins, ymin, ymax);
141  };
142  auto book2dlogx = [&](const char* name, int xbins, const float* xbinedges, int ybins, double ymin, double ymax) {
143  auto me = i.book2D(name, name, xbins, xbinedges[0], xbinedges[xbins], ybins, ymin, ymax);
144  me->getTH2F()->GetXaxis()->Set(xbins, xbinedges);
145  mes_[label][name] = me;
146  };
147 
148  mes_[label]["RecoVtx_vs_GenVtx"] =
149  i.bookProfile("RecoVtx_vs_GenVtx", "RecoVtx_vs_GenVtx", 125, 0., 250., 250, 0., 250.);
150  mes_[label]["MatchedRecoVtx_vs_GenVtx"] =
151  i.bookProfile("MatchedRecoVtx_vs_GenVtx", "MatchedRecoVtx_vs_GenVtx", 125, 0., 250., 250, 0., 250.);
152  mes_[label]["KindOfSignalPV"] = i.book1D("KindOfSignalPV", "KindOfSignalPV", 9, -0.5, 8.5);
153  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(1, "!Highest!Assoc2Any");
154  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(2, "Highest!Assoc2Any");
155  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(3, "!HighestAssoc2First");
156  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(4, "HighestAssoc2First");
157  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(5, "!HighestAssoc2!First");
158  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(6, "HighestAssoc2!First");
159  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(7, "!HighestAssoc2First");
160  mes_[label]["KindOfSignalPV"]->getTH1()->GetXaxis()->SetBinLabel(8, "HighestAssoc2First");
161  mes_[label]["MisTagRate"] = i.book1D("MisTagRate", "MisTagRate", 2, -0.5, 1.5);
162  mes_[label]["MisTagRate_vs_PU"] = i.bookProfile("MisTagRate_vs_PU", "MisTagRate_vs_PU", 125, 0., 250., 2, 0., 1.);
163  mes_[label]["MisTagRate_vs_sum-pt2"] =
164  i.bookProfile("MisTagRate_vs_sum-pt2", "MisTagRate_vs_sum-pt2", 15, &log_pt2_bins_double[0], 2, 0., 1.);
165  mes_[label]["MisTagRate_vs_Z"] = i.bookProfile("MisTagRate_vs_Z", "MisTagRate_vs_Z", 120, -60., 60., 2, 0., 1.);
166  mes_[label]["MisTagRate_vs_R"] = i.bookProfile("MisTagRate_vs_R", "MisTagRate_vs_R", 120, 0., 0.6, 2, 0., 1.);
167  mes_[label]["MisTagRate_vs_NumTracks"] =
168  i.bookProfile("MisTagRate_vs_NumTracks", "MisTagRate_vs_NumTracks", 100, 0., 200, 2, 0., 1.);
169  mes_[label]["MisTagRateSignalIsHighest"] =
170  i.book1D("MisTagRateSignalIsHighest", "MisTagRateSignalIsHighest", 2, -0.5, 1.5);
171  mes_[label]["MisTagRateSignalIsHighest_vs_PU"] =
172  i.bookProfile("MisTagRateSignalIsHighest_vs_PU", "MisTagRateSignalIsHighest_vs_PU", 125, 0., 250., 2, 0., 1.);
173  mes_[label]["MisTagRateSignalIsHighest_vs_sum-pt2"] = i.bookProfile("MisTagRateSignalIsHighest_vs_sum-pt2",
174  "MisTagRateSignalIsHighest_vs_sum-pt2",
175  15,
176  &log_pt2_bins_double[0],
177  2,
178  0.,
179  1.);
180  mes_[label]["MisTagRateSignalIsHighest_vs_Z"] =
181  i.bookProfile("MisTagRateSignalIsHighest_vs_Z", "MisTagRateSignalIsHighest_vs_Z", 120, -60., 60., 2, 0., 1.);
182  mes_[label]["MisTagRateSignalIsHighest_vs_R"] =
183  i.bookProfile("MisTagRateSignalIsHighest_vs_R", "MisTagRateSignalIsHighest_vs_R", 120, 0., 0.6, 2, 0., 1.);
184  mes_[label]["MisTagRateSignalIsHighest_vs_NumTracks"] = i.bookProfile(
185  "MisTagRateSignalIsHighest_vs_NumTracks", "MisTagRateSignalIsHighest_vs_NumTracks", 100, 0., 200, 2, 0., 1.);
186  mes_[label]["MisTagRateSignalIsNotHighest"] =
187  i.book1D("MisTagRateSignalIsNotHighest", "MisTagRateSignalIsNotHighest", 2, -0.5, 1.5);
188  mes_[label]["MisTagRateSignalIsNotHighest_vs_PU"] = i.bookProfile(
189  "MisTagRateSignalIsNotHighest_vs_PU", "MisTagRateSignalIsNotHighest_vs_PU", 125, 0., 250., 2, 0., 1.);
190  mes_[label]["MisTagRateSignalIsNotHighest_vs_sum-pt2"] = i.bookProfile("MisTagRateSignalIsNotHighest_vs_sum-pt2",
191  "MisTagRateSignalIsNotHighest_vs_sum-pt2",
192  15,
193  &log_pt2_bins_double[0],
194  2,
195  0.,
196  1.);
197  mes_[label]["MisTagRateSignalIsNotHighest_vs_Z"] = i.bookProfile(
198  "MisTagRateSignalIsNotHighest_vs_Z", "MisTagRateSignalIsNotHighest_vs_Z", 120, -60., 60., 2, 0., 1.);
199  mes_[label]["MisTagRateSignalIsNotHighest_vs_R"] = i.bookProfile(
200  "MisTagRateSignalIsNotHighest_vs_R", "MisTagRateSignalIsNotHighest_vs_R", 120, 0., 0.6, 2, 0., 1.);
201  mes_[label]["MisTagRateSignalIsNotHighest_vs_NumTracks"] =
202  i.bookProfile("MisTagRateSignalIsNotHighest_vs_NumTracks",
203  "MisTagRateSignalIsNotHighest_vs_NumTracks",
204  100,
205  0.,
206  200,
207  2,
208  0.,
209  1.);
210  mes_[label]["TruePVLocationIndex"] =
211  i.book1D("TruePVLocationIndex", "TruePVLocationIndexInRecoVertexCollection", 12, -1.5, 10.5);
212  mes_[label]["TruePVLocationIndexCumulative"] =
213  i.book1D("TruePVLocationIndexCumulative", "TruePVLocationIndexInRecoVertexCollectionCumulative", 3, -1.5, 1.5);
214  mes_[label]["TruePVLocationIndexSignalIsHighest"] =
215  i.book1D("TruePVLocationIndexSignalIsHighest",
216  "TruePVLocationIndexSignalIsHighestInRecoVertexCollection",
217  12,
218  -1.5,
219  10.5);
220  mes_[label]["TruePVLocationIndexSignalIsNotHighest"] =
221  i.book1D("TruePVLocationIndexSignalIsNotHighest",
222  "TruePVLocationIndexSignalIsNotHighestInRecoVertexCollection",
223  12,
224  -1.5,
225  10.5);
226  // All Generated Vertices. Used for Efficiency plots We kind of
227  // duplicate plots here in case we want to perform more detailed
228  // studies on a selection of generated vertices, not on all of them.
229  mes_[label]["GenAllAssoc2Reco_NumVertices"] =
230  i.book1D("GenAllAssoc2Reco_NumVertices", "GeneratedAllAssoc2Reco_NumVertices", 100, 0., 200.);
231  mes_[label]["GenAllAssoc2Reco_X"] = i.book1D("GenAllAssoc2Reco_X", "GeneratedAllAssoc2Reco_X", 120, -0.6, 0.6);
232  mes_[label]["GenAllAssoc2Reco_Y"] = i.book1D("GenAllAssoc2Reco_Y", "GeneratedAllAssoc2Reco_Y", 120, -0.6, 0.6);
233  mes_[label]["GenAllAssoc2Reco_Z"] = i.book1D("GenAllAssoc2Reco_Z", "GeneratedAllAssoc2Reco_Z", 120, -60, 60);
234  mes_[label]["GenAllAssoc2Reco_R"] = i.book1D("GenAllAssoc2Reco_R", "GeneratedAllAssoc2Reco_R", 120, 0, 0.6);
235  mes_[label]["GenAllAssoc2Reco_Pt2"] =
236  i.book1D("GenAllAssoc2Reco_Pt2", "GeneratedAllAssoc2Reco_Sum-pt2", 15, &log_pt2_bins[0]);
237  mes_[label]["GenAllAssoc2Reco_NumTracks"] =
238  i.book1D("GenAllAssoc2Reco_NumTracks", "GeneratedAllAssoc2Reco_NumTracks", 24, &log_ntrk_bins[0]);
239  mes_[label]["GenAllAssoc2Reco_ClosestDistanceZ"] =
240  i.book1D("GenAllAssoc2Reco_ClosestDistanceZ", "GeneratedAllAssoc2Reco_ClosestDistanceZ", 30, &log_bins[0]);
241  book1d("GenPVAssoc2RecoPV_X", 120, -0.6, 0.6);
242  book1d("GenPVAssoc2RecoPV_Y", 120, -0.6, 0.6);
243  book1d("GenPVAssoc2RecoPV_Z", 120, -60, 60);
244 
245  // All Generated Vertices Matched to a Reconstructed vertex. Used
246  // for Efficiency plots
247  mes_[label]["GenAllAssoc2RecoMatched_NumVertices"] =
248  i.book1D("GenAllAssoc2RecoMatched_NumVertices", "GeneratedAllAssoc2RecoMatched_NumVertices", 100, 0., 200.);
249  mes_[label]["GenAllAssoc2RecoMatched_X"] =
250  i.book1D("GenAllAssoc2RecoMatched_X", "GeneratedAllAssoc2RecoMatched_X", 120, -0.6, 0.6);
251  mes_[label]["GenAllAssoc2RecoMatched_Y"] =
252  i.book1D("GenAllAssoc2RecoMatched_Y", "GeneratedAllAssoc2RecoMatched_Y", 120, -0.6, 0.6);
253  mes_[label]["GenAllAssoc2RecoMatched_Z"] =
254  i.book1D("GenAllAssoc2RecoMatched_Z", "GeneratedAllAssoc2RecoMatched_Z", 120, -60, 60);
255  mes_[label]["GenAllAssoc2RecoMatched_R"] =
256  i.book1D("GenAllAssoc2RecoMatched_R", "GeneratedAllAssoc2RecoMatched_R", 120, 0, 0.6);
257  mes_[label]["GenAllAssoc2RecoMatched_Pt2"] =
258  i.book1D("GenAllAssoc2RecoMatched_Pt2", "GeneratedAllAssoc2RecoMatched_Sum-pt2", 15, &log_pt2_bins[0]);
259  mes_[label]["GenAllAssoc2RecoMatched_NumTracks"] =
260  i.book1D("GenAllAssoc2RecoMatched_NumTracks", "GeneratedAllAssoc2RecoMatched_NumTracks", 24, &log_ntrk_bins[0]);
261  mes_[label]["GenAllAssoc2RecoMatched_ClosestDistanceZ"] = i.book1D(
262  "GenAllAssoc2RecoMatched_ClosestDistanceZ", "GeneratedAllAssoc2RecoMatched_ClosestDistanceZ", 30, &log_bins[0]);
263  book1d("GenPVAssoc2RecoPVMatched_X", 120, -0.6, 0.6);
264  book1d("GenPVAssoc2RecoPVMatched_Y", 120, -0.6, 0.6);
265  book1d("GenPVAssoc2RecoPVMatched_Z", 120, -60, 60);
266 
267  // All Generated Vertices Multi-Matched to a Reconstructed vertex. Used
268  // for Duplicate rate plots
269  mes_[label]["GenAllAssoc2RecoMultiMatched_NumVertices"] = i.book1D(
270  "GenAllAssoc2RecoMultiMatched_NumVertices", "GeneratedAllAssoc2RecoMultiMatched_NumVertices", 100, 0., 200.);
271  mes_[label]["GenAllAssoc2RecoMultiMatched_X"] =
272  i.book1D("GenAllAssoc2RecoMultiMatched_X", "GeneratedAllAssoc2RecoMultiMatched_X", 120, -0.6, 0.6);
273  mes_[label]["GenAllAssoc2RecoMultiMatched_Y"] =
274  i.book1D("GenAllAssoc2RecoMultiMatched_Y", "GeneratedAllAssoc2RecoMultiMatched_Y", 120, -0.6, 0.6);
275  mes_[label]["GenAllAssoc2RecoMultiMatched_Z"] =
276  i.book1D("GenAllAssoc2RecoMultiMatched_Z", "GeneratedAllAssoc2RecoMultiMatched_Z", 120, -60, 60);
277  mes_[label]["GenAllAssoc2RecoMultiMatched_R"] =
278  i.book1D("GenAllAssoc2RecoMultiMatched_R", "GeneratedAllAssoc2RecoMultiMatched_R", 120, 0, 0.6);
279  mes_[label]["GenAllAssoc2RecoMultiMatched_Pt2"] = i.book1D(
280  "GenAllAssoc2RecoMultiMatched_Pt2", "GeneratedAllAssoc2RecoMultiMatched_Sum-pt2", 15, &log_pt2_bins[0]);
281  mes_[label]["GenAllAssoc2RecoMultiMatched_NumTracks"] = i.book1D("GenAllAssoc2RecoMultiMatched_NumTracks",
282  "GeneratedAllAssoc2RecoMultiMatched_NumTracks",
283  24,
284  &log_ntrk_bins[0]);
285  mes_[label]["GenAllAssoc2RecoMultiMatched_ClosestDistanceZ"] =
286  i.book1D("GenAllAssoc2RecoMultiMatched_ClosestDistanceZ",
287  "GeneratedAllAssoc2RecoMultiMatched_ClosestDistanceZ",
288  30,
289  &log_bins[0]);
290 
291  // All Reco Vertices. Used for {Fake,Duplicate}-Rate plots
292  mes_[label]["RecoAllAssoc2Gen_NumVertices"] =
293  i.book1D("RecoAllAssoc2Gen_NumVertices", "ReconstructedAllAssoc2Gen_NumVertices", 100, 0., 200.);
294  mes_[label]["RecoAllAssoc2Gen_X"] = i.book1D("RecoAllAssoc2Gen_X", "ReconstructedAllAssoc2Gen_X", 120, -0.6, 0.6);
295  mes_[label]["RecoAllAssoc2Gen_Y"] = i.book1D("RecoAllAssoc2Gen_Y", "ReconstructedAllAssoc2Gen_Y", 120, -0.6, 0.6);
296  mes_[label]["RecoAllAssoc2Gen_Z"] = i.book1D("RecoAllAssoc2Gen_Z", "ReconstructedAllAssoc2Gen_Z", 120, -60, 60);
297  mes_[label]["RecoAllAssoc2Gen_R"] = i.book1D("RecoAllAssoc2Gen_R", "ReconstructedAllAssoc2Gen_R", 120, 0, 0.6);
298  mes_[label]["RecoAllAssoc2Gen_Pt2"] =
299  i.book1D("RecoAllAssoc2Gen_Pt2", "ReconstructedAllAssoc2Gen_Sum-pt2", 15, &log_pt2_bins[0]);
300  mes_[label]["RecoAllAssoc2Gen_Ndof"] =
301  i.book1D("RecoAllAssoc2Gen_Ndof", "ReconstructedAllAssoc2Gen_Ndof", 120, 0., 240.);
302  mes_[label]["RecoAllAssoc2Gen_NumTracks"] =
303  i.book1D("RecoAllAssoc2Gen_NumTracks", "ReconstructedAllAssoc2Gen_NumTracks", 24, &log_ntrk_bins[0]);
304  mes_[label]["RecoAllAssoc2Gen_PU"] = i.book1D("RecoAllAssoc2Gen_PU", "ReconstructedAllAssoc2Gen_PU", 125, 0., 250.);
305  mes_[label]["RecoAllAssoc2Gen_ClosestDistanceZ"] =
306  i.book1D("RecoAllAssoc2Gen_ClosestDistanceZ", "ReconstructedAllAssoc2Gen_ClosestDistanceZ", 30, &log_bins[0]);
307  mes_[label]["RecoAllAssoc2GenProperties"] =
308  i.book1D("RecoAllAssoc2GenProperties", "ReconstructedAllAssoc2Gen_Properties", 8, -0.5, 7.5);
309  mes_[label]["RecoAllAssoc2Gen_PairDistanceZ"] =
310  i.book1D("RecoAllAssoc2Gen_PairDistanceZ", "RecoAllAssoc2Gen_PairDistanceZ", 1000, 0, 20);
311 
312  // All Reconstructed Vertices Matched to a Generated vertex. Used
313  // for Fake-Rate plots
314  mes_[label]["RecoAllAssoc2GenMatched_NumVertices"] =
315  i.book1D("RecoAllAssoc2GenMatched_NumVertices", "ReconstructedAllAssoc2GenMatched_NumVertices", 100, 0., 200.);
316  mes_[label]["RecoAllAssoc2GenMatched_X"] =
317  i.book1D("RecoAllAssoc2GenMatched_X", "ReconstructedAllAssoc2GenMatched_X", 120, -0.6, 0.6);
318  mes_[label]["RecoAllAssoc2GenMatched_Y"] =
319  i.book1D("RecoAllAssoc2GenMatched_Y", "ReconstructedAllAssoc2GenMatched_Y", 120, -0.6, 0.6);
320  mes_[label]["RecoAllAssoc2GenMatched_Z"] =
321  i.book1D("RecoAllAssoc2GenMatched_Z", "ReconstructedAllAssoc2GenMatched_Z", 120, -60, 60);
322  mes_[label]["RecoAllAssoc2GenMatched_R"] =
323  i.book1D("RecoAllAssoc2GenMatched_R", "ReconstructedAllAssoc2GenMatched_R", 120, 0, 0.6);
324  mes_[label]["RecoAllAssoc2GenMatched_Pt2"] =
325  i.book1D("RecoAllAssoc2GenMatched_Pt2", "ReconstructedAllAssoc2GenMatched_Sum-pt2", 15, &log_pt2_bins[0]);
326  mes_[label]["RecoAllAssoc2GenMatched_Ndof"] =
327  i.book1D("RecoAllAssoc2GenMatched_Ndof", "ReconstructedAllAssoc2GenMatched_Ndof", 120, 0., 240.);
328  mes_[label]["RecoAllAssoc2GenMatched_NumTracks"] = i.book1D(
329  "RecoAllAssoc2GenMatched_NumTracks", "ReconstructedAllAssoc2GenMatched_NumTracks", 24, &log_ntrk_bins[0]);
330  mes_[label]["RecoAllAssoc2GenMatched_PU"] =
331  i.book1D("RecoAllAssoc2GenMatched_PU", "ReconstructedAllAssoc2GenMatched_PU", 125, 0., 250.);
332  mes_[label]["RecoAllAssoc2GenMatched_ClosestDistanceZ"] =
333  i.book1D("RecoAllAssoc2GenMatched_ClosestDistanceZ",
334  "ReconstructedAllAssoc2GenMatched_ClosestDistanceZ",
335  30,
336  &log_bins[0]);
337 
338  // All Reconstructed Vertices Multi-Matched to a Generated vertex. Used
339  // for Merge-Rate plots
340  mes_[label]["RecoAllAssoc2GenMultiMatched_NumVertices"] = i.book1D(
341  "RecoAllAssoc2GenMultiMatched_NumVertices", "ReconstructedAllAssoc2GenMultiMatched_NumVertices", 100, 0., 200.);
342  mes_[label]["RecoAllAssoc2GenMultiMatched_X"] =
343  i.book1D("RecoAllAssoc2GenMultiMatched_X", "ReconstructedAllAssoc2GenMultiMatched_X", 120, -0.6, 0.6);
344  mes_[label]["RecoAllAssoc2GenMultiMatched_Y"] =
345  i.book1D("RecoAllAssoc2GenMultiMatched_Y", "ReconstructedAllAssoc2GenMultiMatched_Y", 120, -0.6, 0.6);
346  mes_[label]["RecoAllAssoc2GenMultiMatched_Z"] =
347  i.book1D("RecoAllAssoc2GenMultiMatched_Z", "ReconstructedAllAssoc2GenMultiMatched_Z", 120, -60, 60);
348  mes_[label]["RecoAllAssoc2GenMultiMatched_R"] =
349  i.book1D("RecoAllAssoc2GenMultiMatched_R", "ReconstructedAllAssoc2GenMultiMatched_R", 120, 0, 0.6);
350  mes_[label]["RecoAllAssoc2GenMultiMatched_Pt2"] = i.book1D(
351  "RecoAllAssoc2GenMultiMatched_Pt2", "ReconstructedAllAssoc2GenMultiMatched_Sum-pt2", 15, &log_pt2_bins[0]);
352  mes_[label]["RecoAllAssoc2GenMultiMatched_NumTracks"] = i.book1D("RecoAllAssoc2GenMultiMatched_NumTracks",
353  "ReconstructedAllAssoc2GenMultiMatched_NumTracks",
354  24,
355  &log_ntrk_bins[0]);
356  mes_[label]["RecoAllAssoc2GenMultiMatched_PU"] =
357  i.book1D("RecoAllAssoc2GenMultiMatched_PU", "ReconstructedAllAssoc2GenMultiMatched_PU", 125, 0., 250.);
358  mes_[label]["RecoAllAssoc2GenMultiMatched_ClosestDistanceZ"] =
359  i.book1D("RecoAllAssoc2GenMultiMatched_ClosestDistanceZ",
360  "ReconstructedAllAssoc2GenMultiMatched_ClosestDistanceZ",
361  log_mergez_bins.size() - 1,
362  &log_mergez_bins[0]);
363 
364  // All Reconstructed Vertices Matched to a Multi-Matched Gen
365  // Vertex. Used for Duplicate rate plots done w.r.t. Reco
366  // Quantities. We basically want to ask how many times a RecoVTX
367  // has been reconstructed and associated to a SimulatedVTX that
368  // has been linked to at least another RecoVTX. In this sense this
369  // RecoVTX is a duplicate of the same, real GenVTX.
370  mes_[label]["RecoAllAssoc2MultiMatchedGen_NumVertices"] =
371  i.book1D("RecoAllAssoc2MultiMatchedGen_NumVertices", "RecoAllAssoc2MultiMatchedGen_NumVertices", 100, 0., 200.);
372  mes_[label]["RecoAllAssoc2MultiMatchedGen_X"] =
373  i.book1D("RecoAllAssoc2MultiMatchedGen_X", "RecoAllAssoc2MultiMatchedGen_X", 120, -0.6, 0.6);
374  mes_[label]["RecoAllAssoc2MultiMatchedGen_Y"] =
375  i.book1D("RecoAllAssoc2MultiMatchedGen_Y", "RecoAllAssoc2MultiMatchedGen_Y", 120, -0.6, 0.6);
376  mes_[label]["RecoAllAssoc2MultiMatchedGen_Z"] =
377  i.book1D("RecoAllAssoc2MultiMatchedGen_Z", "RecoAllAssoc2MultiMatchedGen_Z", 120, -60, 60);
378  mes_[label]["RecoAllAssoc2MultiMatchedGen_R"] =
379  i.book1D("RecoAllAssoc2MultiMatchedGen_R", "RecoAllAssoc2MultiMatchedGen_R", 120, 0, 0.6);
380  mes_[label]["RecoAllAssoc2MultiMatchedGen_Pt2"] =
381  i.book1D("RecoAllAssoc2MultiMatchedGen_Pt2", "RecoAllAssoc2MultiMatchedGen_Sum-pt2", 15, &log_pt2_bins[0]);
382  mes_[label]["RecoAllAssoc2MultiMatchedGen_NumTracks"] = i.book1D(
383  "RecoAllAssoc2MultiMatchedGen_NumTracks", "RecoAllAssoc2MultiMatchedGen_NumTracks", 24, &log_ntrk_bins[0]);
384  mes_[label]["RecoAllAssoc2MultiMatchedGen_PU"] =
385  i.book1D("RecoAllAssoc2MultiMatchedGen_PU", "RecoAllAssoc2MultiMatchedGen_PU", 125, 0., 250.);
386  mes_[label]["RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ"] =
387  i.book1D("RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ",
388  "RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ",
389  30,
390  &log_bins[0]);
391  mes_[label]["RecoAllAssoc2GenSimForMerge_ClosestDistanceZ"] =
392  i.book1D("RecoAllAssoc2GenSimForMerge_ClosestDistanceZ",
393  "RecoAllAssoc2GenSimForMerge_ClosestDistanceZ",
394  log_mergez_bins.size() - 1,
395  &log_mergez_bins[0]);
396 
397  // Resolution and pull histograms
398  const double resolpt2 = 10;
399 
400  const double minPull = -10;
401  const double maxPull = 10;
402  const double nPull = 100;
403 
404  auto bookResolPull = [&](const std::string& prefix, const double resolx, const double resoly, const double resolz) {
405  book1d((prefix + "_ResolX").c_str(), 100, -resolx, resolx);
406  book1d((prefix + "_ResolY").c_str(), 100, -resoly, resoly);
407  book1d((prefix + "_ResolZ").c_str(), 100, -resolz, resolz);
408  book1d((prefix + "_ResolPt2").c_str(), 100, -resolpt2, resolpt2);
409  book1d((prefix + "_PullX").c_str(), 250, -25, 25);
410  book1d((prefix + "_PullY").c_str(), 250, -25, 25);
411  book1d((prefix + "_PullZ").c_str(), 250, -25, 25);
412 
413  book2d((prefix + "_ResolX_vs_PU").c_str(), 125, 0., 250., 100, -resolx, resolx);
414  book2d((prefix + "_ResolY_vs_PU").c_str(), 125, 0., 250., 100, -resoly, resoly);
415  book2d((prefix + "_ResolZ_vs_PU").c_str(), 125, 0., 250., 100, -resolz, resolz);
416  book2d((prefix + "_ResolPt2_vs_PU").c_str(), 125, 0., 250., 100, -resolpt2, resolpt2);
417  book2d((prefix + "_PullX_vs_PU").c_str(), 125, 0., 250., nPull, minPull, maxPull);
418  book2d((prefix + "_PullY_vs_PU").c_str(), 125, 0., 250., nPull, minPull, maxPull);
419  book2d((prefix + "_PullZ_vs_PU").c_str(), 125, 0., 250., nPull, minPull, maxPull);
420 
421  book2dlogx((prefix + "_ResolX_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], 100, -resolx, resolx);
422  book2dlogx((prefix + "_ResolY_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], 100, -resoly, resoly);
423  book2dlogx((prefix + "_ResolZ_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], 100, -resolz, resolz);
424  book2dlogx((prefix + "_ResolPt2_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], 100, -resolpt2, resolpt2);
425  book2dlogx((prefix + "_PullX_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], nPull, minPull, maxPull);
426  book2dlogx((prefix + "_PullY_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], nPull, minPull, maxPull);
427  book2dlogx((prefix + "_PullZ_vs_NumTracks").c_str(), 24, &log_ntrk_bins[0], nPull, minPull, maxPull);
428 
429  book2d((prefix + "_ResolX_vs_Z").c_str(), 120, -60, 60, 100, -resolx, resolx);
430  book2d((prefix + "_ResolY_vs_Z").c_str(), 120, -60, 60, 100, -resoly, resoly);
431  book2d((prefix + "_ResolZ_vs_Z").c_str(), 120, -60, 60, 100, -resolz, resolz);
432  book2d((prefix + "_ResolPt2_vs_Z").c_str(), 120, -60, 60, 100, -resolpt2, resolpt2);
433  book2d((prefix + "_PullX_vs_Z").c_str(), 120, -60, 60, nPull, minPull, maxPull);
434  book2d((prefix + "_PullY_vs_Z").c_str(), 120, -60, 60, nPull, minPull, maxPull);
435  book2d((prefix + "_PullZ_vs_Z").c_str(), 120, -60, 60, nPull, minPull, maxPull);
436 
437  book2dlogx((prefix + "_ResolX_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], 100, -resolx, resolx);
438  book2dlogx((prefix + "_ResolY_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], 100, -resoly, resoly);
439  book2dlogx((prefix + "_ResolZ_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], 100, -resolz, resolz);
440  book2dlogx(
441  (prefix + "_ResolPt2_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], 100, -resolpt2, resolpt2);
442  book2dlogx((prefix + "_PullX_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], nPull, minPull, maxPull);
443  book2dlogx((prefix + "_PullY_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], nPull, minPull, maxPull);
444  book2dlogx((prefix + "_PullZ_vs_Pt").c_str(), log_pt_bins.size() - 1, &log_pt_bins[0], nPull, minPull, maxPull);
445  };
446 
447  bookResolPull("RecoAllAssoc2GenMatched", 0.1, 0.1, 0.1); // Non-merged vertices
448  bookResolPull("RecoAllAssoc2GenMatchedMerged", 0.1, 0.1, 0.1); // Merged vertices
449  bookResolPull(
450  "RecoPVAssoc2GenPVMatched", 0.01, 0.01, 0.01); // PV, when correctly matched, regardless if merged or not
451 
452  // Purity histograms
453  // Reco PV (vtx0) matched to hard-scatter gen vertex
454  book1d("RecoPVAssoc2GenPVMatched_Purity", 50, 0, 1);
455  book1d("RecoPVAssoc2GenPVMatched_Missing", 50, 0, 1);
456  book2d("RecoPVAssoc2GenPVMatched_Purity_vs_Index", 100, 0, 100, 50, 0, 1);
457 
458  // RECO PV (vtx0) not matched to hard-scatter gen vertex
459  book1d("RecoPVAssoc2GenPVNotMatched_Purity", 50, 0, 1);
460  book1d("RecoPVAssoc2GenPVNotMatched_Missing", 50, 0, 1);
461  book2d("RecoPVAssoc2GenPVNotMatched_Purity_vs_Index", 100, 0, 100, 50, 0, 1);
462 
463  // Purity vs. fake rate
464  book1d("RecoAllAssoc2Gen_Purity", 50, 0, 1); // denominator
465  book1d("RecoAllAssoc2GenMatched_Purity", 50, 0, 1); // 1-numerator
466 
467  // Vertex sum(pt2)
468  // The first two are orthogonal (i.e. their sum includes all reco vertices)
469  book1dlogx("RecoAssoc2GenPVMatched_Pt2", 15, &log_pt2_bins[0]);
470  book1dlogx("RecoAssoc2GenPVNotMatched_Pt2", 15, &log_pt2_bins[0]);
471 
472  book1dlogx("RecoAssoc2GenPVMatchedNotHighest_Pt2", 15, &log_pt2_bins[0]);
473  book1dlogx("RecoAssoc2GenPVNotMatched_GenPVTracksRemoved_Pt2", 15, &log_pt2_bins[0]);
474 
475  // Shared tracks
476  book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionReco", 50, 0, 1);
477  book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionReco", 50, 0, 1);
478  book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionRecoMatched", 50, 0, 1);
479  book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionRecoMatched", 50, 0, 1);
480 
481  book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionSim", 50, 0, 1);
482  book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionSim", 50, 0, 1);
483  book1d("RecoAllAssoc2GenSingleMatched_SharedTrackFractionSimMatched", 50, 0, 1);
484  book1d("RecoAllAssoc2GenMultiMatched_SharedTrackFractionSimMatched", 50, 0, 1);
485  }
486 }

References trigObjTnPSource_cfi::bins, do_generic_sim_plots_, MillePedeFileConverter_cfg::e, vertexPlots::e4, mps_fire::i, cmsLHEtoEOSManager::l, label, SiStripPI::max, hlt_dqm_clientPB-live_cfg::me, mes_, min(), Skims_PA_cff::name, ZMuMuAnalysisNtupler_cff::prefix, reco_vertex_collections_, root_folder_, AlCaHLTBitMon_QueryRunRegistry::string, fw3dlego::xbins, TrackerOfflineValidation_Dqm_cff::xmax, TrackerOfflineValidation_Dqm_cff::xmin, L1TOccupancyClient_cfi::ymax, and L1TOccupancyClient_cfi::ymin.

◆ calculatePurityAndFillHistograms()

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 728 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

731  {
732  if (recopvs.empty())
733  return;
734 
735  std::vector<double> vtx_sumpt_sigmatched;
736  std::vector<double> vtx_sumpt2_sigmatched;
737 
738  vtx_sumpt_sigmatched.reserve(recopvs.size());
739  vtx_sumpt2_sigmatched.reserve(recopvs.size());
740 
741  // Calculate purity
742  for (auto& v : recopvs) {
743  double sumpt_all = 0;
744  double sumpt_sigmatched = 0;
745  double sumpt2_sigmatched = 0;
746  const reco::Vertex* vertex = v.recVtx;
747  for (auto iTrack = vertex->tracks_begin(); iTrack != vertex->tracks_end(); ++iTrack) {
748  double pt = (*iTrack)->pt();
749  sumpt_all += pt;
750  if (matchRecoTrack2SimSignal(*iTrack)) {
751  sumpt_sigmatched += pt;
752  sumpt2_sigmatched += pt * pt;
753  }
754  }
755  v.purity = sumpt_sigmatched / sumpt_all;
756 
757  vtx_sumpt_sigmatched.push_back(sumpt_sigmatched);
758  vtx_sumpt2_sigmatched.push_back(sumpt2_sigmatched);
759  }
760 
761  const double vtxAll_sumpt_sigmatched = std::accumulate(vtx_sumpt_sigmatched.begin(), vtx_sumpt_sigmatched.end(), 0.0);
762  const double vtxNot0_sumpt_sigmatched = vtxAll_sumpt_sigmatched - vtx_sumpt_sigmatched[0];
763  const double missing = vtxNot0_sumpt_sigmatched / vtxAll_sumpt_sigmatched;
764 
765  // Fill purity
766  std::string prefix = "RecoPVAssoc2GenPVNotMatched_";
767  if (genpv_position_in_reco_collection == 0)
768  prefix = "RecoPVAssoc2GenPVMatched_";
769 
770  mes_[label][prefix + "Purity"]->Fill(recopvs[0].purity);
771  mes_[label][prefix + "Missing"]->Fill(missing);
772  auto hpurity = mes_[label][prefix + "Purity_vs_Index"];
773  for (size_t i = 0; i < recopvs.size(); ++i) {
774  hpurity->Fill(i, recopvs[i].purity);
775  }
776 
777  // Fill sumpt2
778  for (size_t i = 0; i < recopvs.size(); ++i) {
779  if (static_cast<int>(i) == genpv_position_in_reco_collection) {
780  mes_[label]["RecoAssoc2GenPVMatched_Pt2"]->Fill(recopvs[i].ptsq);
781  } else {
782  double pt2 = recopvs[i].ptsq;
783  mes_[label]["RecoAssoc2GenPVNotMatched_Pt2"]->Fill(pt2);
784  // Subtract hard-scatter track pt2 from the pileup pt2
785  double pt2_pu = pt2 - vtx_sumpt2_sigmatched[i];
786  mes_[label]["RecoAssoc2GenPVNotMatched_GenPVTracksRemoved_Pt2"]->Fill(pt2_pu);
787  }
788  }
789  if (!signal_is_highest_pt && genpv_position_in_reco_collection >= 0)
790  mes_[label]["RecoAssoc2GenPVMatchedNotHighest_Pt2"]->Fill(recopvs[genpv_position_in_reco_collection].ptsq);
791 }

References mps_fire::i, label, matchRecoTrack2SimSignal(), mes_, combine::missing, ZMuMuAnalysisNtupler_cff::prefix, DiDispStaMuonMonitor_cfi::pt, HLT_2018_cff::pt2, AlCaHLTBitMon_QueryRunRegistry::string, findQualityFiles::v, and bphysicsOniaDQM_cfi::vertex.

Referenced by analyze().

◆ computePairDistance()

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

Definition at line 1364 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

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

References funct::abs(), universalConfigTemplate::collection, mps_fire::i, dqmiolumiharvest::j, hlt_dqm_clientPB-live_cfg::me, and z.

Referenced by analyze().

◆ fillGenAssociatedRecoVertexHistograms()

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

Definition at line 553 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

554  {
555  mes_[label]["RecoAllAssoc2Gen_X"]->Fill(v.x);
556  mes_[label]["RecoAllAssoc2Gen_Y"]->Fill(v.y);
557  mes_[label]["RecoAllAssoc2Gen_Z"]->Fill(v.z);
558  mes_[label]["RecoAllAssoc2Gen_R"]->Fill(v.r);
559  mes_[label]["RecoAllAssoc2Gen_Pt2"]->Fill(v.ptsq);
560  mes_[label]["RecoAllAssoc2Gen_Ndof"]->Fill(v.recVtx->ndof());
561  mes_[label]["RecoAllAssoc2Gen_NumTracks"]->Fill(v.nRecoTrk);
562  mes_[label]["RecoAllAssoc2Gen_PU"]->Fill(num_pileup_vertices);
563  mes_[label]["RecoAllAssoc2Gen_Purity"]->Fill(v.purity);
564  if (v.closest_vertex_distance_z > 0.)
565  mes_[label]["RecoAllAssoc2Gen_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
566  if (!v.sim_vertices.empty()) {
567  v.kind_of_vertex |= recoPrimaryVertex::MATCHED;
568  mes_[label]["RecoAllAssoc2GenMatched_X"]->Fill(v.x);
569  mes_[label]["RecoAllAssoc2GenMatched_Y"]->Fill(v.y);
570  mes_[label]["RecoAllAssoc2GenMatched_Z"]->Fill(v.z);
571  mes_[label]["RecoAllAssoc2GenMatched_R"]->Fill(v.r);
572  mes_[label]["RecoAllAssoc2GenMatched_Pt2"]->Fill(v.ptsq);
573  mes_[label]["RecoAllAssoc2GenMatched_Ndof"]->Fill(v.recVtx->ndof());
574  mes_[label]["RecoAllAssoc2GenMatched_NumTracks"]->Fill(v.nRecoTrk);
575  mes_[label]["RecoAllAssoc2GenMatched_PU"]->Fill(num_pileup_vertices);
576  mes_[label]["RecoAllAssoc2GenMatched_Purity"]->Fill(v.purity);
577  if (v.closest_vertex_distance_z > 0.)
578  mes_[label]["RecoAllAssoc2GenMatched_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
579 
580  // Fill resolution and pull plots here (as in MultiTrackValidator)
581  fillResolutionAndPullHistograms(label, num_pileup_vertices, v, false);
582 
583  // Now keep track of all RecoVTX associated to a SimVTX that
584  // itself is associated to more than one RecoVTX, for
585  // duplicate-rate plots on reco quantities.
586  if (v.sim_vertices_internal[0]->rec_vertices.size() > 1) {
587  v.kind_of_vertex |= recoPrimaryVertex::DUPLICATE;
588  mes_[label]["RecoAllAssoc2MultiMatchedGen_X"]->Fill(v.x);
589  mes_[label]["RecoAllAssoc2MultiMatchedGen_Y"]->Fill(v.y);
590  mes_[label]["RecoAllAssoc2MultiMatchedGen_Z"]->Fill(v.z);
591  mes_[label]["RecoAllAssoc2MultiMatchedGen_R"]->Fill(v.r);
592  mes_[label]["RecoAllAssoc2MultiMatchedGen_Pt2"]->Fill(v.ptsq);
593  mes_[label]["RecoAllAssoc2MultiMatchedGen_NumTracks"]->Fill(v.nRecoTrk);
594  mes_[label]["RecoAllAssoc2MultiMatchedGen_PU"]->Fill(num_pileup_vertices);
595  if (v.closest_vertex_distance_z > 0.)
596  mes_[label]["RecoAllAssoc2MultiMatchedGen_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
597  }
598  // This is meant to be used as "denominator" for the merge-rate
599  // plots produced starting from reco quantities. We enter here
600  // only if the reco vertex has been associated, since we need info
601  // from the SimVTX associated to it. In this regard, the final
602  // merge-rate plot coming from reco is not to be intended as a
603  // pure efficiency-like plot, since the normalization is biased.
604  if (v.sim_vertices_internal[0]->closest_vertex_distance_z > 0.)
605  mes_[label]["RecoAllAssoc2GenSimForMerge_ClosestDistanceZ"]->Fill(
606  v.sim_vertices_internal[0]->closest_vertex_distance_z);
607  }
608  // this plots are meant to be used to compute the merge rate
609  if (v.sim_vertices.size() > 1) {
610  v.kind_of_vertex |= recoPrimaryVertex::MERGED;
611  mes_[label]["RecoAllAssoc2GenMultiMatched_X"]->Fill(v.x);
612  mes_[label]["RecoAllAssoc2GenMultiMatched_Y"]->Fill(v.y);
613  mes_[label]["RecoAllAssoc2GenMultiMatched_Z"]->Fill(v.z);
614  mes_[label]["RecoAllAssoc2GenMultiMatched_R"]->Fill(v.r);
615  mes_[label]["RecoAllAssoc2GenMultiMatched_Pt2"]->Fill(v.ptsq);
616  mes_[label]["RecoAllAssoc2GenMultiMatched_NumTracks"]->Fill(v.nRecoTrk);
617  mes_[label]["RecoAllAssoc2GenMultiMatched_PU"]->Fill(num_pileup_vertices);
618  if (v.sim_vertices_internal[0]->closest_vertex_distance_z > 0.)
619  mes_[label]["RecoAllAssoc2GenMultiMatched_ClosestDistanceZ"]->Fill(
620  v.sim_vertices_internal[0]->closest_vertex_distance_z);
621  }
622  mes_[label]["RecoAllAssoc2GenProperties"]->Fill(v.kind_of_vertex);
623 
624  std::string prefix;
625  if (v.sim_vertices.size() == 1) {
626  prefix = "RecoAllAssoc2GenSingleMatched_SharedTrackFraction";
627  } else if (v.sim_vertices.size() > 1) {
628  prefix = "RecoAllAssoc2GenMultiMatched_SharedTrackFraction";
629  }
630 
631  for (size_t i = 0; i < v.sim_vertices.size(); ++i) {
632  const double sharedTracks = v.sim_vertices_num_shared_tracks[i];
633  const simPrimaryVertex* simV = v.sim_vertices_internal[i];
634  mes_[label][prefix + "Reco"]->Fill(sharedTracks / v.nRecoTrk);
635  mes_[label][prefix + "RecoMatched"]->Fill(sharedTracks / v.num_matched_sim_tracks);
636  mes_[label][prefix + "Sim"]->Fill(sharedTracks / simV->nGenTrk);
637  mes_[label][prefix + "SimMatched"]->Fill(sharedTracks / simV->num_matched_reco_tracks);
638  }
639 }

References PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::DUPLICATE, fillResolutionAndPullHistograms(), mps_fire::i, label, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::MATCHED, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::MERGED, mes_, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::nGenTrk, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::num_matched_reco_tracks, ZMuMuAnalysisNtupler_cff::prefix, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by analyze().

◆ fillGenericGenVertexHistograms()

void PrimaryVertexAnalyzer4PUSlimmed::fillGenericGenVertexHistograms ( const simPrimaryVertex &  v)
private

Definition at line 488 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

488  {
489  if (v.eventId.event() == 0) {
490  mes_["root_folder"]["GenPV_X"]->Fill(v.x);
491  mes_["root_folder"]["GenPV_Y"]->Fill(v.y);
492  mes_["root_folder"]["GenPV_Z"]->Fill(v.z);
493  mes_["root_folder"]["GenPV_R"]->Fill(v.r);
494  mes_["root_folder"]["GenPV_Pt2"]->Fill(v.ptsq);
495  mes_["root_folder"]["GenPV_NumTracks"]->Fill(v.nGenTrk);
496  if (v.closest_vertex_distance_z > 0.)
497  mes_["root_folder"]["GenPV_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
498  }
499  mes_["root_folder"]["GenAllV_X"]->Fill(v.x);
500  mes_["root_folder"]["GenAllV_Y"]->Fill(v.y);
501  mes_["root_folder"]["GenAllV_Z"]->Fill(v.z);
502  mes_["root_folder"]["GenAllV_R"]->Fill(v.r);
503  mes_["root_folder"]["GenAllV_Pt2"]->Fill(v.ptsq);
504  mes_["root_folder"]["GenAllV_NumTracks"]->Fill(v.nGenTrk);
505  if (v.closest_vertex_distance_z > 0.)
506  mes_["root_folder"]["GenAllV_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
507 }

References mes_, and findQualityFiles::v.

Referenced by analyze().

◆ fillRecoAssociatedGenPVHistograms()

void PrimaryVertexAnalyzer4PUSlimmed::fillRecoAssociatedGenPVHistograms ( const std::string &  label,
const PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex &  v,
bool  genPVMatchedToRecoPV 
)
private

Definition at line 541 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

542  {
543  mes_[label]["GenPVAssoc2RecoPV_X"]->Fill(v.x);
544  mes_[label]["GenPVAssoc2RecoPV_Y"]->Fill(v.y);
545  mes_[label]["GenPVAssoc2RecoPV_Z"]->Fill(v.z);
546  if (genPVMatchedToRecoPV) {
547  mes_[label]["GenPVAssoc2RecoPVMatched_X"]->Fill(v.x);
548  mes_[label]["GenPVAssoc2RecoPVMatched_Y"]->Fill(v.y);
549  mes_[label]["GenPVAssoc2RecoPVMatched_Z"]->Fill(v.z);
550  }
551 }

References label, mes_, and findQualityFiles::v.

Referenced by analyze().

◆ fillRecoAssociatedGenVertexHistograms()

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

Definition at line 509 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

510  {
511  mes_[label]["GenAllAssoc2Reco_X"]->Fill(v.x);
512  mes_[label]["GenAllAssoc2Reco_Y"]->Fill(v.y);
513  mes_[label]["GenAllAssoc2Reco_Z"]->Fill(v.z);
514  mes_[label]["GenAllAssoc2Reco_R"]->Fill(v.r);
515  mes_[label]["GenAllAssoc2Reco_Pt2"]->Fill(v.ptsq);
516  mes_[label]["GenAllAssoc2Reco_NumTracks"]->Fill(v.nGenTrk);
517  if (v.closest_vertex_distance_z > 0.)
518  mes_[label]["GenAllAssoc2Reco_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
519  if (!v.rec_vertices.empty()) {
520  mes_[label]["GenAllAssoc2RecoMatched_X"]->Fill(v.x);
521  mes_[label]["GenAllAssoc2RecoMatched_Y"]->Fill(v.y);
522  mes_[label]["GenAllAssoc2RecoMatched_Z"]->Fill(v.z);
523  mes_[label]["GenAllAssoc2RecoMatched_R"]->Fill(v.r);
524  mes_[label]["GenAllAssoc2RecoMatched_Pt2"]->Fill(v.ptsq);
525  mes_[label]["GenAllAssoc2RecoMatched_NumTracks"]->Fill(v.nGenTrk);
526  if (v.closest_vertex_distance_z > 0.)
527  mes_[label]["GenAllAssoc2RecoMatched_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
528  }
529  if (v.rec_vertices.size() > 1) {
530  mes_[label]["GenAllAssoc2RecoMultiMatched_X"]->Fill(v.x);
531  mes_[label]["GenAllAssoc2RecoMultiMatched_Y"]->Fill(v.y);
532  mes_[label]["GenAllAssoc2RecoMultiMatched_Z"]->Fill(v.z);
533  mes_[label]["GenAllAssoc2RecoMultiMatched_R"]->Fill(v.r);
534  mes_[label]["GenAllAssoc2RecoMultiMatched_Pt2"]->Fill(v.ptsq);
535  mes_[label]["GenAllAssoc2RecoMultiMatched_NumTracks"]->Fill(v.nGenTrk);
536  if (v.closest_vertex_distance_z > 0.)
537  mes_[label]["GenAllAssoc2RecoMultiMatched_ClosestDistanceZ"]->Fill(v.closest_vertex_distance_z);
538  }
539 }

References label, mes_, and findQualityFiles::v.

Referenced by analyze().

◆ fillResolutionAndPullHistograms()

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

Definition at line 641 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

645  {
646  std::string prefix = "RecoAllAssoc2GenMatched";
647  if (v.sim_vertices_internal.size() > 1) {
648  prefix += "Merged";
649  }
650  if (isPV) {
651  prefix = "RecoPVAssoc2GenPVMatched";
652  }
653 
654  // Use the best match as defined by the vertex truth associator
655  // reco-tracks as the best match
656  const simPrimaryVertex& bestMatch = *(v.sim_vertices_internal[0]);
657  const double xres = v.x - bestMatch.x;
658  const double yres = v.y - bestMatch.y;
659  const double zres = v.z - bestMatch.z;
660  const double pt2res = v.ptsq - bestMatch.ptsq;
661 
662  const double xresol = xres;
663  const double yresol = yres;
664  const double zresol = zres;
665  const double pt2resol = pt2res / v.ptsq;
666  const double xpull = xres / v.recVtx->xError();
667  const double ypull = yres / v.recVtx->yError();
668  const double zpull = zres / v.recVtx->zError();
669 
670  mes_[label][prefix + "_ResolX"]->Fill(xresol);
671  mes_[label][prefix + "_ResolY"]->Fill(yresol);
672  mes_[label][prefix + "_ResolZ"]->Fill(zresol);
673  mes_[label][prefix + "_ResolPt2"]->Fill(pt2resol);
674  mes_[label][prefix + "_PullX"]->Fill(xpull);
675  mes_[label][prefix + "_PullY"]->Fill(ypull);
676  mes_[label][prefix + "_PullZ"]->Fill(zpull);
677 
678  mes_[label][prefix + "_ResolX_vs_PU"]->Fill(num_pileup_vertices, xresol);
679  mes_[label][prefix + "_ResolY_vs_PU"]->Fill(num_pileup_vertices, yresol);
680  mes_[label][prefix + "_ResolZ_vs_PU"]->Fill(num_pileup_vertices, zresol);
681  mes_[label][prefix + "_ResolPt2_vs_PU"]->Fill(num_pileup_vertices, pt2resol);
682  mes_[label][prefix + "_PullX_vs_PU"]->Fill(num_pileup_vertices, xpull);
683  mes_[label][prefix + "_PullY_vs_PU"]->Fill(num_pileup_vertices, ypull);
684  mes_[label][prefix + "_PullZ_vs_PU"]->Fill(num_pileup_vertices, zpull);
685 
686  mes_[label][prefix + "_ResolX_vs_NumTracks"]->Fill(v.nRecoTrk, xresol);
687  mes_[label][prefix + "_ResolY_vs_NumTracks"]->Fill(v.nRecoTrk, yresol);
688  mes_[label][prefix + "_ResolZ_vs_NumTracks"]->Fill(v.nRecoTrk, zresol);
689  mes_[label][prefix + "_ResolPt2_vs_NumTracks"]->Fill(v.nRecoTrk, pt2resol);
690  mes_[label][prefix + "_PullX_vs_NumTracks"]->Fill(v.nRecoTrk, xpull);
691  mes_[label][prefix + "_PullY_vs_NumTracks"]->Fill(v.nRecoTrk, ypull);
692  mes_[label][prefix + "_PullZ_vs_NumTracks"]->Fill(v.nRecoTrk, zpull);
693 
694  mes_[label][prefix + "_ResolX_vs_Z"]->Fill(v.z, xresol);
695  mes_[label][prefix + "_ResolY_vs_Z"]->Fill(v.z, yresol);
696  mes_[label][prefix + "_ResolZ_vs_Z"]->Fill(v.z, zresol);
697  mes_[label][prefix + "_ResolPt2_vs_Z"]->Fill(v.z, pt2resol);
698  mes_[label][prefix + "_PullX_vs_Z"]->Fill(v.z, xpull);
699  mes_[label][prefix + "_PullY_vs_Z"]->Fill(v.z, ypull);
700  mes_[label][prefix + "_PullZ_vs_Z"]->Fill(v.z, zpull);
701 
702  mes_[label][prefix + "_ResolX_vs_Pt"]->Fill(v.pt, xresol);
703  mes_[label][prefix + "_ResolY_vs_Pt"]->Fill(v.pt, yresol);
704  mes_[label][prefix + "_ResolZ_vs_Pt"]->Fill(v.pt, zresol);
705  mes_[label][prefix + "_ResolPt2_vs_Pt"]->Fill(v.pt, pt2resol);
706  mes_[label][prefix + "_PullX_vs_Pt"]->Fill(v.pt, xpull);
707  mes_[label][prefix + "_PullY_vs_Pt"]->Fill(v.pt, ypull);
708  mes_[label][prefix + "_PullZ_vs_Pt"]->Fill(v.pt, zpull);
709 }

References deltar::bestMatch(), label, mes_, ZMuMuAnalysisNtupler_cff::prefix, AlCaHLTBitMon_QueryRunRegistry::string, and findQualityFiles::v.

Referenced by analyze(), and fillGenAssociatedRecoVertexHistograms().

◆ getRecoPVs()

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

Definition at line 953 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

954  {
955  std::vector<PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex> recopv;
956 
957  if (verbose_) {
958  std::cout << "getRecoPVs TrackingVertexCollection " << std::endl;
959  }
960 
961  for (auto v = tVC->begin(); v != tVC->end(); ++v) {
962  if (verbose_) {
963  std::cout << " Position: " << v->position() << std::endl;
964  }
965 
966  // Skip junk vertices
967  if (fabs(v->z()) > 1000)
968  continue;
969  if (v->isFake() || !v->isValid())
970  continue;
971 
972  recoPrimaryVertex sv(v->position().x(), v->position().y(), v->position().z());
973  sv.recVtx = &(*v);
974  sv.recVtxRef = reco::VertexBaseRef(tVC, std::distance(tVC->begin(), v));
975  // this is a new vertex, add it to the list of reco-vertices
976  recopv.push_back(sv);
977  PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex* vp = &recopv.back();
978 
979  // Loop over daughter track(s)
980  for (auto iTrack = v->tracks_begin(); iTrack != v->tracks_end(); ++iTrack) {
981  auto momentum = (*(*iTrack)).innerMomentum();
982  // TODO(rovere) better handle the pixelVertices, whose tracks
983  // do not have the innerMomentum defined. This is a temporary
984  // hack to overcome this problem.
985  if (momentum.mag2() == 0)
986  momentum = (*(*iTrack)).momentum();
987  if (verbose_) {
988  std::cout << " Daughter momentum: " << momentum;
989  std::cout << std::endl;
990  }
991  vp->pt += std::sqrt(momentum.perp2());
992  vp->ptsq += (momentum.perp2());
993  vp->nRecoTrk++;
994 
995  auto matched = r2s_->find(*iTrack);
996  if (matched != r2s_->end()) {
997  vp->num_matched_sim_tracks++;
998  }
999 
1000  } // End of for loop on daughters reconstructed tracks
1001  } // End of for loop on tracking vertices
1002 
1003  if (verbose_) {
1004  std::cout << "------- PrimaryVertexAnalyzer4PUSlimmed recoPVs from "
1005  "VertexCollection "
1006  "-------"
1007  << std::endl;
1008  for (std::vector<recoPrimaryVertex>::iterator v0 = recopv.begin(); v0 != recopv.end(); v0++) {
1009  std::cout << "z=" << v0->z << std::endl;
1010  }
1011  std::cout << "-----------------------------------------------" << std::endl;
1012  } // End of for summary on reconstructed primary vertices.
1013 
1014  // In case of no reco vertices, break here
1015  if (recopv.empty())
1016  return recopv;
1017 
1018  // Now compute the closest distance in z between all reconstructed vertex
1019  // first initialize
1020  auto prev_z = recopv.back().z;
1021  for (recoPrimaryVertex& vreco : recopv) {
1022  vreco.closest_vertex_distance_z = std::abs(vreco.z - prev_z);
1023  prev_z = vreco.z;
1024  }
1025  for (std::vector<recoPrimaryVertex>::iterator vreco = recopv.begin(); vreco != recopv.end(); vreco++) {
1026  std::vector<recoPrimaryVertex>::iterator vreco2 = vreco;
1027  vreco2++;
1028  for (; vreco2 != recopv.end(); vreco2++) {
1029  double distance = std::abs(vreco->z - vreco2->z);
1030  // need both to be complete
1031  vreco->closest_vertex_distance_z = std::min(vreco->closest_vertex_distance_z, distance);
1032  vreco2->closest_vertex_distance_z = std::min(vreco2->closest_vertex_distance_z, distance);
1033  }
1034  }
1035  return recopv;
1036 }

References funct::abs(), gather_cfg::cout, HLT_2018_cff::distance, edm::AssociationMap< Tag >::end(), edm::AssociationMap< Tag >::find(), muonTagProbeFilters_cff::matched, min(), PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::nRecoTrk, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::num_matched_sim_tracks, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::pt, PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::ptsq, r2s_, mathSSE::sqrt(), pfDeepBoostedJetPreprocessParams_cfi::sv, findQualityFiles::v, V0Monitor_cff::v0, and verbose_.

Referenced by analyze().

◆ getSimPVs()

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

Definition at line 796 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

797  {
798  std::vector<PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex> simpv;
799  int current_event = -1;
800 
801  if (verbose_) {
802  std::cout << "getSimPVs TrackingVertexCollection " << std::endl;
803  }
804 
805  for (TrackingVertexCollection::const_iterator v = tVC->begin(); v != tVC->end(); ++v) {
806  if (verbose_) {
807  std::cout << "BunchX.EventId: " << v->eventId().bunchCrossing() << "." << (v->eventId()).event()
808  << " Position: " << v->position() << " G4/HepMC Vertices: " << v->g4Vertices().size() << "/"
809  << v->genVertices().size() << " t = " << v->position().t() * 1.e12
810  << " == 0:" << (v->position().t() > 0) << std::endl;
811  for (TrackingVertex::g4v_iterator gv = v->g4Vertices_begin(); gv != v->g4Vertices_end(); gv++) {
812  std::cout << *gv << std::endl;
813  }
814  std::cout << "----------" << std::endl;
815 
816  } // end of verbose_ session
817 
818  // I'd rather change this and select only vertices that come from
819  // BX=0. We should keep only the first vertex from all the events
820  // at BX=0.
821  if (v->eventId().bunchCrossing() != 0)
822  continue;
823  if (v->eventId().event() != current_event) {
824  current_event = v->eventId().event();
825  } else {
826  continue;
827  }
828  // TODO(rovere) is this really necessary?
829  if (fabs(v->position().z()) > 1000)
830  continue; // skip funny junk vertices
831 
832  // could be a new vertex, check all primaries found so far to avoid
833  // multiple entries
834  simPrimaryVertex sv(v->position().x(), v->position().y(), v->position().z());
835  sv.eventId = v->eventId();
836  sv.sim_vertex = TrackingVertexRef(tVC, std::distance(tVC->begin(), v));
837 
838  for (TrackingParticleRefVector::iterator iTrack = v->daughterTracks_begin(); iTrack != v->daughterTracks_end();
839  ++iTrack) {
840  // TODO(rovere) isn't it always the case? Is it really worth
841  // checking this out?
842  // sv.eventId = (**iTrack).eventId();
843  assert((**iTrack).eventId().bunchCrossing() == 0);
844  }
845  // TODO(rovere) maybe get rid of this old logic completely ... ?
846  simPrimaryVertex* vp = nullptr; // will become non-NULL if a vertex
847  // is found and then point to it
848  for (std::vector<simPrimaryVertex>::iterator v0 = simpv.begin(); v0 != simpv.end(); v0++) {
849  if ((sv.eventId == v0->eventId) && (fabs(sv.x - v0->x) < 1e-5) && (fabs(sv.y - v0->y) < 1e-5) &&
850  (fabs(sv.z - v0->z) < 1e-5)) {
851  vp = &(*v0);
852  break;
853  }
854  }
855  if (!vp) {
856  // this is a new vertex, add it to the list of sim-vertices
857  simpv.push_back(sv);
858  vp = &simpv.back();
859  if (verbose_) {
860  std::cout << "this is a new vertex " << sv.eventId.event() << " " << sv.x << " " << sv.y << " " << sv.z
861  << std::endl;
862  }
863  } else {
864  if (verbose_) {
865  std::cout << "this is not a new vertex" << sv.x << " " << sv.y << " " << sv.z << std::endl;
866  }
867  }
868 
869  // Loop over daughter track(s) as Tracking Particles
870  for (TrackingVertex::tp_iterator iTP = v->daughterTracks_begin(); iTP != v->daughterTracks_end(); ++iTP) {
871  auto momentum = (*(*iTP)).momentum();
872  const reco::Track* matched_best_reco_track = nullptr;
873  double match_quality = -1;
874  if (use_only_charged_tracks_ && (**iTP).charge() == 0)
875  continue;
876  if (s2r_->find(*iTP) != s2r_->end()) {
877  matched_best_reco_track = (*s2r_)[*iTP][0].first.get();
878  match_quality = (*s2r_)[*iTP][0].second;
879  }
880  if (verbose_) {
881  std::cout << " Daughter momentum: " << momentum;
882  std::cout << " Daughter type " << (*(*iTP)).pdgId();
883  std::cout << " matched: " << (matched_best_reco_track != nullptr);
884  std::cout << " match-quality: " << match_quality;
885  std::cout << std::endl;
886  }
887  vp->ptot.setPx(vp->ptot.x() + momentum.x());
888  vp->ptot.setPy(vp->ptot.y() + momentum.y());
889  vp->ptot.setPz(vp->ptot.z() + momentum.z());
890  vp->ptot.setE(vp->ptot.e() + (**iTP).energy());
891  vp->ptsq += ((**iTP).pt() * (**iTP).pt());
892  // TODO(rovere) only select charged sim-particles? If so, maybe
893  // put it as a configuration parameter?
894  if (matched_best_reco_track) {
895  vp->num_matched_reco_tracks++;
896  vp->average_match_quality += match_quality;
897  }
898  // TODO(rovere) get rid of cuts on sim-tracks
899  // TODO(rovere) be consistent between simulated tracks and
900  // reconstructed tracks selection
901  // count relevant particles
902  if (((**iTP).pt() > 0.2) && (fabs((**iTP).eta()) < 2.5) && (**iTP).charge() != 0) {
903  vp->nGenTrk++;
904  }
905  } // End of for loop on daughters sim-particles
906  if (vp->num_matched_reco_tracks)
907  vp->average_match_quality /= static_cast<float>(vp->num_matched_reco_tracks);
908  if (verbose_) {
909  std::cout << "average number of associated tracks: "
910  << vp->num_matched_reco_tracks / static_cast<float>(vp->nGenTrk)
911  << " with average quality: " << vp->average_match_quality << std::endl;
912  }
913  } // End of for loop on tracking vertices
914 
915  if (verbose_) {
916  std::cout << "------- PrimaryVertexAnalyzer4PUSlimmed simPVs from "
917  "TrackingVertices "
918  "-------"
919  << std::endl;
920  for (std::vector<simPrimaryVertex>::iterator v0 = simpv.begin(); v0 != simpv.end(); v0++) {
921  std::cout << "z=" << v0->z << " event=" << v0->eventId.event() << std::endl;
922  }
923  std::cout << "-----------------------------------------------" << std::endl;
924  } // End of for summary on discovered simulated primary vertices.
925 
926  // In case of no simulated vertices, break here
927  if (simpv.empty())
928  return simpv;
929 
930  // Now compute the closest distance in z between all simulated vertex
931  // first initialize
932  auto prev_z = simpv.back().z;
933  for (simPrimaryVertex& vsim : simpv) {
934  vsim.closest_vertex_distance_z = std::abs(vsim.z - prev_z);
935  prev_z = vsim.z;
936  }
937  // then calculate
938  for (std::vector<simPrimaryVertex>::iterator vsim = simpv.begin(); vsim != simpv.end(); vsim++) {
939  std::vector<simPrimaryVertex>::iterator vsim2 = vsim;
940  vsim2++;
941  for (; vsim2 != simpv.end(); vsim2++) {
942  double distance = std::abs(vsim->z - vsim2->z);
943  // need both to be complete
944  vsim->closest_vertex_distance_z = std::min(vsim->closest_vertex_distance_z, distance);
945  vsim2->closest_vertex_distance_z = std::min(vsim2->closest_vertex_distance_z, distance);
946  }
947  }
948  return simpv;
949 }

References funct::abs(), cms::cuda::assert(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::average_match_quality, gather_cfg::cout, HLT_2018_cff::distance, MillePedeFileConverter_cfg::e, edm::AssociationMap< Tag >::end(), event(), edm::AssociationMap< Tag >::find(), min(), PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::nGenTrk, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::num_matched_reco_tracks, EgammaValidation_cff::pdgId, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::ptot, PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex::ptsq, s2r_, pfDeepBoostedJetPreprocessParams_cfi::sv, use_only_charged_tracks_, findQualityFiles::v, V0Monitor_cff::v0, and verbose_.

Referenced by analyze().

◆ matchReco2SimVertices()

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

Definition at line 1074 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

1076  {
1077  for (std::vector<recoPrimaryVertex>::iterator vrec = recopv.begin(); vrec != recopv.end(); vrec++) {
1078  auto matched = vertex_r2s.find(vrec->recVtxRef);
1079  if (matched != vertex_r2s.end()) {
1080  for (const auto& vertexRefQuality : matched->val) {
1081  const auto tvPtr = &(*(vertexRefQuality.first));
1082  vrec->sim_vertices.push_back(tvPtr);
1083  }
1084 
1085  for (const TrackingVertex* tv : vrec->sim_vertices) {
1086  // Set pointers to internal simVertex objects
1087  for (const auto& vv : simpv) {
1088  if (&(*(vv.sim_vertex)) == tv) {
1089  vrec->sim_vertices_internal.push_back(&vv);
1090  continue;
1091  }
1092  }
1093 
1094  // Calculate number of shared tracks
1095  vrec->sim_vertices_num_shared_tracks.push_back(calculateVertexSharedTracks(*(vrec->recVtx), *tv, *r2s_));
1096  }
1097  }
1098 
1099  if (verbose_) {
1100  for (auto v : vrec->sim_vertices) {
1101  std::cout << "Found a matching vertex for reco: " << vrec->z << " at gen:" << v->position().z()
1102  << " with sign: " << fabs(vrec->z - v->position().z()) / vrec->recVtx->zError() << std::endl;
1103  }
1104  }
1105  } // end for loop on reconstructed vertices
1106 }

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

Referenced by analyze().

◆ matchRecoTrack2SimSignal()

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

Definition at line 711 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

711  {
712  auto found = r2s_->find(recoTrack);
713 
714  // reco track not matched to any TP
715  if (found == r2s_->end())
716  return false;
717 
718  // reco track matched to some TP from signal vertex
719  for (const auto& tp : found->val) {
720  if (tp.first->eventId().bunchCrossing() == 0 && tp.first->eventId().event() == 0)
721  return true;
722  }
723 
724  // reco track not matched to any TP from signal vertex
725  return false;
726 }

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

Referenced by calculatePurityAndFillHistograms().

◆ matchSim2RecoVertices()

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

Definition at line 1045 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

1046  {
1047  if (verbose_) {
1048  std::cout << "PrimaryVertexAnalyzer4PUSlimmed::matchSim2RecoVertices " << std::endl;
1049  }
1050  for (std::vector<simPrimaryVertex>::iterator vsim = simpv.begin(); vsim != simpv.end(); vsim++) {
1051  auto matched = vertex_s2r.find(vsim->sim_vertex);
1052  if (matched != vertex_s2r.end()) {
1053  for (const auto& vertexRefQuality : matched->val) {
1054  vsim->rec_vertices.push_back(&(*(vertexRefQuality.first)));
1055  }
1056  }
1057 
1058  if (verbose_) {
1059  if (!vsim->rec_vertices.empty()) {
1060  for (auto const& v : vsim->rec_vertices) {
1061  std::cout << "Found a matching vertex for genVtx " << vsim->z << " at " << v->z()
1062  << " with sign: " << fabs(v->z() - vsim->z) / v->zError() << std::endl;
1063  }
1064  } else {
1065  std::cout << "No matching vertex for " << vsim->z << std::endl;
1066  }
1067  }
1068  } // end for loop on simulated vertices
1069  if (verbose_) {
1070  std::cout << "Done with matching sim vertices" << std::endl;
1071  }
1072 }

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

Referenced by analyze().

◆ resetSimPVAssociation()

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

Definition at line 1038 of file PrimaryVertexAnalyzer4PUSlimmed.cc.

1038  {
1039  for (auto& v : simpv) {
1040  v.rec_vertices.clear();
1041  }
1042 }

References findQualityFiles::v.

Referenced by analyze().

Member Data Documentation

◆ do_generic_sim_plots_

const bool PrimaryVertexAnalyzer4PUSlimmed::do_generic_sim_plots_
private

Definition at line 167 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and bookHistograms().

◆ errorPrintedForColl_

std::vector<bool> PrimaryVertexAnalyzer4PUSlimmed::errorPrintedForColl_
private

Definition at line 183 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and PrimaryVertexAnalyzer4PUSlimmed().

◆ mes_

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

Definition at line 170 of file PrimaryVertexAnalyzer4PUSlimmed.h.

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

◆ r2s_

const reco::RecoToSimCollection* PrimaryVertexAnalyzer4PUSlimmed::r2s_
private

Definition at line 171 of file PrimaryVertexAnalyzer4PUSlimmed.h.

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

◆ reco_vertex_collection_tokens_

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

Definition at line 175 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and PrimaryVertexAnalyzer4PUSlimmed().

◆ reco_vertex_collections_

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

Definition at line 176 of file PrimaryVertexAnalyzer4PUSlimmed.h.

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

◆ recoToSimAssociationToken_

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

Definition at line 180 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

◆ root_folder_

std::string PrimaryVertexAnalyzer4PUSlimmed::root_folder_
private

Definition at line 168 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by bookHistograms().

◆ s2r_

const reco::SimToRecoCollection* PrimaryVertexAnalyzer4PUSlimmed::s2r_
private

Definition at line 172 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze(), and getSimPVs().

◆ simToRecoAssociationToken_

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

Definition at line 179 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

◆ trackingParticleCollectionToken_

edm::EDGetTokenT<TrackingParticleCollection> PrimaryVertexAnalyzer4PUSlimmed::trackingParticleCollectionToken_
private

Definition at line 177 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

◆ trackingVertexCollectionToken_

edm::EDGetTokenT<TrackingVertexCollection> PrimaryVertexAnalyzer4PUSlimmed::trackingVertexCollectionToken_
private

Definition at line 178 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

◆ use_only_charged_tracks_

bool PrimaryVertexAnalyzer4PUSlimmed::use_only_charged_tracks_
private

Definition at line 166 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by getSimPVs().

◆ vecPileupSummaryInfoToken_

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

Definition at line 174 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

◆ verbose_

bool PrimaryVertexAnalyzer4PUSlimmed::verbose_
private

Definition at line 165 of file PrimaryVertexAnalyzer4PUSlimmed.h.

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

◆ vertexAssociatorToken_

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

Definition at line 181 of file PrimaryVertexAnalyzer4PUSlimmed.h.

Referenced by analyze().

muonTagProbeFilters_cff.matched
matched
Definition: muonTagProbeFilters_cff.py:62
PrimaryVertexAnalyzer4PUSlimmed::matchRecoTrack2SimSignal
bool matchRecoTrack2SimSignal(const reco::TrackBaseRef &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:711
V0Monitor_cff.v0
v0
Definition: V0Monitor_cff.py:7
fw3dlego::xbins
const double xbins[]
Definition: fw3dlego_xbins.cc:16
edm::AssociationMap::find
const_iterator find(const key_type &k) const
find element with specified reference key
Definition: AssociationMap.h:173
mps_fire.i
i
Definition: mps_fire.py:355
HLT_2018_cff.pt2
pt2
Definition: HLT_2018_cff.py:8552
PrimaryVertexAnalyzer4PUSlimmed::mes_
std::map< std::string, std::map< std::string, MonitorElement * > > mes_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:170
PrimaryVertexAnalyzer4PUSlimmed::HIGHEST_PT
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:64
edm::Handle::product
T const * product() const
Definition: Handle.h:70
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::MATCHED
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:99
sistrip::View
View
Definition: ConstantsForView.h:26
PrimaryVertexAnalyzer4PUSlimmed::use_only_charged_tracks_
bool use_only_charged_tracks_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:166
PrimaryVertexAnalyzer4PUSlimmed::trackingParticleCollectionToken_
edm::EDGetTokenT< TrackingParticleCollection > trackingParticleCollectionToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:177
DiDispStaMuonMonitor_cfi.pt
pt
Definition: DiDispStaMuonMonitor_cfi.py:39
min
T min(T a, T b)
Definition: MathUtil.h:58
edm::EDGetTokenT
Definition: EDGetToken.h:33
AlCaHLTBitMon_ParallelJobs.p
p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
PrimaryVertexAnalyzer4PUSlimmed::do_generic_sim_plots_
const bool do_generic_sim_plots_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:167
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::num_matched_sim_tracks
int num_matched_sim_tracks
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:120
gather_cfg.cout
cout
Definition: gather_cfg.py:144
TrackingVertex::g4v_iterator
std::vector< SimVertex >::const_iterator g4v_iterator
Definition: TrackingVertex.h:30
cms::cuda::assert
assert(be >=bs)
HLT_2018_cff.distance
distance
Definition: HLT_2018_cff.py:6417
PrimaryVertexAnalyzer4PUSlimmed::calculatePurityAndFillHistograms
void calculatePurityAndFillHistograms(const std::string &, std::vector< recoPrimaryVertex > &, int, bool)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:728
edm::ParameterSet::getUntrackedParameter
T getUntrackedParameter(std::string const &, T const &) const
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::nRecoTrk
int nRecoTrk
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:119
reco
fixed size matrix
Definition: AlignmentAlgorithmBase.h:45
findQualityFiles.v
v
Definition: findQualityFiles.py:179
spr::find
void find(edm::Handle< EcalRecHitCollection > &hits, DetId thisDet, std::vector< EcalRecHitCollection::const_iterator > &hit, bool debug=false)
Definition: FindCaloHit.cc:19
convertSQLiteXML.ok
bool ok
Definition: convertSQLiteXML.py:98
newFWLiteAna.found
found
Definition: newFWLiteAna.py:118
deltar.bestMatch
def bestMatch(object, matchCollection)
Definition: deltar.py:138
edm::Handle
Definition: AssociativeIterator.h:50
end
#define end
Definition: vmac.h:39
PrimaryVertexAnalyzer4PUSlimmed::fillGenericGenVertexHistograms
void fillGenericGenVertexHistograms(const simPrimaryVertex &v)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:488
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::ptsq
double ptsq
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:116
edm::AssociationMap::end
const_iterator end() const
last iterator over the map (read only)
Definition: AssociationMap.h:171
packedPFCandidates_cfi.vertexAssociator
vertexAssociator
Definition: packedPFCandidates_cfi.py:8
PrimaryVertexAnalyzer4PUSlimmed::fillResolutionAndPullHistograms
void fillResolutionAndPullHistograms(const std::string &, int, recoPrimaryVertex &v, bool)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:641
L1TOccupancyClient_cfi.ymax
ymax
Definition: L1TOccupancyClient_cfi.py:43
PrimaryVertexAnalyzer4PUSlimmed::trackingVertexCollectionToken_
edm::EDGetTokenT< TrackingVertexCollection > trackingVertexCollectionToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:178
PrimaryVertexAnalyzer4PUSlimmed::reco_vertex_collections_
std::vector< edm::InputTag > reco_vertex_collections_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:176
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
pfDeepBoostedJetPreprocessParams_cfi.sv
sv
Definition: pfDeepBoostedJetPreprocessParams_cfi.py:226
PrimaryVertexAnalyzer4PUSlimmed::vecPileupSummaryInfoToken_
edm::EDGetTokenT< std::vector< PileupSummaryInfo > > vecPileupSummaryInfoToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:174
DDAxes::z
PrimaryVertexAnalyzer4PUSlimmed::fillRecoAssociatedGenVertexHistograms
void fillRecoAssociatedGenVertexHistograms(const std::string &, const simPrimaryVertex &v)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:509
reco::Track
Definition: Track.h:27
TrackingVertexRef
edm::Ref< TrackingVertexCollection > TrackingVertexRef
Definition: TrackingVertexContainer.h:9
PrimaryVertexAnalyzer4PUSlimmed::getSimPVs
std::vector< PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex > getSimPVs(const edm::Handle< TrackingVertexCollection > &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:796
cmsswSequenceInfo.tp
tp
Definition: cmsswSequenceInfo.py:17
AlCaHLTBitMon_QueryRunRegistry.string
string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
edm::LogWarning
Definition: MessageLogger.h:141
edm::View
Definition: CaloClusterFwd.h:14
bphysicsOniaDQM_cfi.vertex
vertex
Definition: bphysicsOniaDQM_cfi.py:7
PrimaryVertexAnalyzer4PUSlimmed::s2r_
const reco::SimToRecoCollection * s2r_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:172
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::DUPLICATE
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:99
SiStripPI::max
Definition: SiStripPayloadInspectorHelper.h:169
PrimaryVertexAnalyzer4PUSlimmed::reco_vertex_collection_tokens_
std::vector< edm::EDGetTokenT< edm::View< reco::Vertex > > > reco_vertex_collection_tokens_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:175
edm::AssociationMap< edm::OneToManyWithQuality< edm::View< reco::Vertex >, TrackingVertexCollection, double > >
TrackingVertex
Definition: TrackingVertex.h:22
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::pt
double pt
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:115
PrimaryVertexAnalyzer4PUSlimmed::IS_ASSOC2ANY_RECO
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:64
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
iEvent
int iEvent
Definition: GenABIO.cc:224
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:98
universalConfigTemplate.collection
collection
Definition: universalConfigTemplate.py:81
PrimaryVertexAnalyzer4PUSlimmed::r2s_
const reco::RecoToSimCollection * r2s_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:171
EgammaValidation_cff.pdgId
pdgId
Definition: EgammaValidation_cff.py:118
reco::VertexToTrackingVertexAssociator
Definition: VertexToTrackingVertexAssociator.h:9
PrimaryVertexAnalyzer4PUSlimmed::matchSim2RecoVertices
void matchSim2RecoVertices(std::vector< simPrimaryVertex > &, const reco::VertexSimToRecoCollection &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:1045
cmsLHEtoEOSManager.l
l
Definition: cmsLHEtoEOSManager.py:193
PrimaryVertexAnalyzer4PUSlimmed::getRecoPVs
std::vector< PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex > getRecoPVs(const edm::Handle< edm::View< reco::Vertex >> &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:953
PrimaryVertexAnalyzer4PUSlimmed::matchReco2SimVertices
void matchReco2SimVertices(std::vector< recoPrimaryVertex > &, const reco::VertexRecoToSimCollection &, const std::vector< simPrimaryVertex > &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:1074
edm::ParameterSet::getParameter
T getParameter(std::string const &) const
L1TOccupancyClient_cfi.ymin
ymin
Definition: L1TOccupancyClient_cfi.py:43
TrackerOfflineValidation_Dqm_cff.xmax
xmax
Definition: TrackerOfflineValidation_Dqm_cff.py:11
edm::RefVectorIterator
Definition: EDProductfwd.h:33
PrimaryVertexAnalyzer4PUSlimmed::vertexAssociatorToken_
edm::EDGetTokenT< reco::VertexToTrackingVertexAssociator > vertexAssociatorToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:181
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
PrimaryVertexAnalyzer4PUSlimmed::errorPrintedForColl_
std::vector< bool > errorPrintedForColl_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:183
calculateVertexSharedTracks
unsigned int calculateVertexSharedTracks(const reco::Vertex &recoV, const TrackingVertex &simV, const reco::RecoToSimCollection &trackRecoToSimAssociation)
funct::abs
Abs< T >::type abs(const T &t)
Definition: Abs.h:22
trigObjTnPSource_cfi.bins
bins
Definition: trigObjTnPSource_cfi.py:20
combine.missing
missing
Definition: combine.py:5
TrackerOfflineValidation_Dqm_cff.xmin
xmin
Definition: TrackerOfflineValidation_Dqm_cff.py:10
dqmiolumiharvest.j
j
Definition: dqmiolumiharvest.py:66
hlt_dqm_clientPB-live_cfg.me
me
Definition: hlt_dqm_clientPB-live_cfg.py:61
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
PrimaryVertexAnalyzer4PUSlimmed::verbose_
bool verbose_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:165
PrimaryVertexAnalyzer4PUSlimmed::recoToSimAssociationToken_
edm::EDGetTokenT< reco::RecoToSimCollection > recoToSimAssociationToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:180
event
How EventSelector::AcceptEvent() decides whether to accept an event for output otherwise it is excluding the probing of A single or multiple positive and the trigger will pass if any such matching triggers are PASS or EXCEPTION[A criterion thatmatches no triggers at all is detected and causes a throw.] A single negative with an expectation of appropriate bit checking in the decision and the trigger will pass if any such matching triggers are FAIL or EXCEPTION A wildcarded negative criterion that matches more than one trigger in the trigger but the state exists so we define the behavior If all triggers are the negative crieriion will lead to accepting the event(this again matches the behavior of "!*" before the partial wildcard feature was incorporated). The per-event "cost" of each negative criterion with multiple relevant triggers is about the same as ! *was in the past
PrimaryVertexAnalyzer4PUSlimmed::simToRecoAssociationToken_
edm::EDGetTokenT< reco::SimToRecoCollection > simToRecoAssociationToken_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:179
PrimaryVertexAnalyzer4PUSlimmed::resetSimPVAssociation
void resetSimPVAssociation(std::vector< simPrimaryVertex > &)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:1038
edm::InputTag
Definition: InputTag.h:15
begin
#define begin
Definition: vmac.h:32
label
const char * label
Definition: PFTauDecayModeTools.cc:11
reco::Vertex
Definition: Vertex.h:35
vertexPlots.e4
e4
Definition: vertexPlots.py:64
PrimaryVertexAnalyzer4PUSlimmed::fillGenAssociatedRecoVertexHistograms
void fillGenAssociatedRecoVertexHistograms(const std::string &, int, recoPrimaryVertex &v)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:553
PrimaryVertexAnalyzer4PUSlimmed::computePairDistance
void computePairDistance(const T &collection, MonitorElement *me)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:1364
reco::VertexBaseRef
edm::RefToBase< reco::Vertex > VertexBaseRef
persistent reference to a Vertex, using views
Definition: VertexFwd.h:21
PrimaryVertexAnalyzer4PUSlimmed::recoPrimaryVertex::MERGED
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:99
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
ZMuMuAnalysisNtupler_cff.prefix
prefix
Definition: ZMuMuAnalysisNtupler_cff.py:14
PrimaryVertexAnalyzer4PUSlimmed::fillRecoAssociatedGenPVHistograms
void fillRecoAssociatedGenPVHistograms(const std::string &label, const PrimaryVertexAnalyzer4PUSlimmed::simPrimaryVertex &v, bool genPVMatchedToRecoPV)
Definition: PrimaryVertexAnalyzer4PUSlimmed.cc:541
PrimaryVertexAnalyzer4PUSlimmed::IS_ASSOC2FIRST_RECO
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:64
PrimaryVertexAnalyzer4PUSlimmed::root_folder_
std::string root_folder_
Definition: PrimaryVertexAnalyzer4PUSlimmed.h:168
Generated for CMSSW Reference Manual by doxygen 1.8.16