CMS 3D CMS Logo
BPHHistoSpecificDecay.cc
Go to the documentation of this file.
1 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"
2 #include "DataFormats/PatCandidates/interface/Muon.h"
3 #include "FWCore/Common/interface/TriggerNames.h"
4 #include "FWCore/Framework/interface/ESHandle.h"
5 #include "FWCore/Framework/interface/MakerMacros.h"
6 #include "FWCore/MessageLogger/interface/MessageLogger.h"
7 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"
8 #include "HeavyFlavorAnalysis/SpecificDecay/plugins/BPHHistoSpecificDecay.h"
9 #include "RecoVertex/VertexTools/interface/VertexDistanceXY.h"
10 
11 #include "TFile.h"
12 #include "TH1.h"
13 #include "TMath.h"
14 #include "TTree.h"
15 #include "TVector3.h"
16 
17 #include "Math/VectorUtil.h"
18 #include <set>
19 #include <string>
20 #include <iostream>
21 #include <fstream>
22 #include <cmath>
23 
24 using namespace std;
25 
26 #define SET_LABEL(NAME, PSET) (NAME = PSET.getParameter<string>(#NAME))
27 // SET_LABEL(xyz,ps);
28 // is equivalent to
29 // xyz = ps.getParameter<string>( "xyx" );
30 
31 #define CAT3(A, B, C) A##B##C
32 #define STRING_NX(A) #A
33 #define STRING(A) STRING_NX(A)
34 #define CHK_TRIG(RESULTS, NAMES, INDEX, PATH) \
35  if (NAMES[INDEX].find(STRING(CAT3(HLT_, PATH, _v))) == 0) { \
36  flag_##PATH = RESULTS->accept(INDEX); \
37  continue; \
38  }
39 // CHK_TRIG( trigResults, names, i, xyz );
40 // is equivalent to
41 // if ( names[i].find( "HLT_xyz_v" ) == 0 ) { flag_xyz = trigResults->accept( i ); break; }
42 
43 class VertexAnalysis {
44 public:
45  static double cAlpha(const reco::Vertex* pvtx, const reco::Vertex* svtx, float px, float py) {
46  TVector3 disp(svtx->x() - pvtx->x(), svtx->y() - pvtx->y(), 0);
47  TVector3 cmom(px, py, 0);
48  return disp.Dot(cmom) / (disp.Perp() * cmom.Perp());
49  }
50  static double cAlpha(const reco::Vertex* pvtx, const reco::Vertex* svtx, const TVector3& cmom) {
51  TVector3 disp(svtx->x() - pvtx->x(), svtx->y() - pvtx->y(), 0);
52  return disp.Dot(cmom) / (disp.Perp() * cmom.Perp());
53  }
54  static void dist2D(const reco::Vertex* pvtx,
55  const reco::Vertex* svtx,
56  float px,
57  float py,
58  float mass,
59  double& ctauPV,
60  double& ctauErrPV) {
61  dist2D(pvtx, svtx, px, py, cAlpha(pvtx, svtx, px, py), mass, ctauPV, ctauErrPV);
62  return;
63  }
64  static void dist2D(const reco::Vertex* pvtx,
65  const reco::Vertex* svtx,
66  float px,
67  float py,
68  double cosAlpha,
69  float mass,
70  double& ctauPV,
71  double& ctauErrPV) {
72  TVector3 cmom(px, py, 0);
73  AlgebraicVector3 vmom(px, py, 0);
74  VertexDistanceXY vdistXY;
75  Measurement1D distXY = vdistXY.distance(*svtx, *pvtx);
76  ctauPV = distXY.value() * cosAlpha * mass / cmom.Perp();
77  GlobalError sve = svtx->error();
78  GlobalError pve = pvtx->error();
79  AlgebraicSymMatrix33 vXYe = sve.matrix() + pve.matrix();
80  ctauErrPV = sqrt(ROOT::Math::Similarity(vmom, vXYe)) * mass / cmom.Perp2();
81  return;
82  }
83 };
84 
85 class BPHUserData {
86 public:
87  template <class T>
88  static const T* get(const pat::CompositeCandidate& cand, const string& name) {
89  if (cand.hasUserData(name))
90  return cand.userData<T>(name);
91  return nullptr;
92  }
93  static float get(const pat::CompositeCandidate& cand, const string& name, float d = 0.0) {
94  if (cand.hasUserFloat(name))
95  return cand.userFloat(name);
96  return d;
97  }
98  template <class T>
99  static const T* getByRef(const pat::CompositeCandidate& cand, const string& name) {
100  if (cand.hasUserData(name)) {
101  typedef edm::Ref<std::vector<T>> objRef;
102  const objRef* ref = cand.userData<objRef>(name);
103  if (ref == nullptr)
104  return nullptr;
105  if (ref->isNull())
106  return nullptr;
107  return ref->get();
108  }
109  return nullptr;
110  }
111 };
112 
113 class BPHDaughters {
114 public:
115  static vector<const reco::Candidate*> get(const pat::CompositeCandidate& cand, float massMin, float massMax) {
116  int i;
117  int n = cand.numberOfDaughters();
118  vector<const reco::Candidate*> v;
119  v.reserve(n);
120  for (i = 0; i < n; ++i) {
121  const reco::Candidate* dptr = cand.daughter(i);
122  float mass = dptr->mass();
123  if ((mass > massMin) && (mass < massMax))
124  v.push_back(dptr);
125  }
126  return v;
127  }
128 };
129 
130 class BPHSoftMuonSelect {
131 public:
132  BPHSoftMuonSelect(int cutTrackerLayers = 5,
133  int cutPixelLayers = 0,
134  float maxDxy = 0.3,
135  float maxDz = 20.0,
136  bool goodMuon = true,
137  bool highPurity = true)
138  : cutTL(cutTrackerLayers), cutPL(cutPixelLayers), maxXY(maxDxy), maxZ(maxDz), gM(goodMuon), hP(highPurity) {}
139  ~BPHSoftMuonSelect() {}
140  bool accept(const reco::Candidate& cand, const reco::Vertex* pv) const {
141  const pat::Muon* p = dynamic_cast<const pat::Muon*>(&cand);
142  if (p == nullptr)
143  return false;
144  if (gM && !muon::isGoodMuon(*p, muon::TMOneStationTight))
145  return false;
146  if (p->innerTrack()->hitPattern().trackerLayersWithMeasurement() <= cutTL)
147  return false;
148  if (p->innerTrack()->hitPattern().pixelLayersWithMeasurement() <= cutPL)
149  return false;
150  if (hP && !p->innerTrack()->quality(reco::TrackBase::highPurity))
151  return false;
152  if (pv == nullptr)
153  return true;
154  const reco::Vertex::Point& pos = pv->position();
155  if (fabs(p->innerTrack()->dxy(pos)) >= maxXY)
156  return false;
157  if (fabs(p->innerTrack()->dz(pos)) >= maxZ)
158  return false;
159  return true;
160  }
161 
162 private:
163  const reco::Vertex* pv;
164  int cutTL;
165  int cutPL;
166  float maxXY;
167  float maxZ;
168  bool gM;
169  bool hP;
170 };
171 
172 class BPHDaughterSelect : public BPHHistoSpecificDecay::CandidateSelect {
173 public:
174  BPHDaughterSelect(float ptMinLoose,
175  float ptMinTight,
176  float etaMaxLoose,
177  float etaMaxTight,
178  const BPHSoftMuonSelect* softMuonselector = nullptr)
179  : pLMin(ptMinLoose), pTMin(ptMinTight), eLMax(etaMaxLoose), eTMax(etaMaxTight), sms(softMuonselector) {}
180  ~BPHDaughterSelect() override {}
181  bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
182  return accept(cand, pLMin, pTMin, eLMax, eTMax, pv, sms);
183  }
184  static bool accept(const pat::CompositeCandidate& cand,
185  float ptMinLoose,
186  float ptMinTight,
187  float etaMaxLoose,
188  float etaMaxTight,
189  const reco::Vertex* pv = nullptr,
190  const BPHSoftMuonSelect* softMuonselector = nullptr) {
191  const reco::Candidate* dptr0 = cand.daughter(0);
192  const reco::Candidate* dptr1 = cand.daughter(1);
193  if (dptr0 == nullptr)
194  return false;
195  if (dptr1 == nullptr)
196  return false;
197  float pt0 = dptr0->pt();
198  float pt1 = dptr1->pt();
199  if ((pt0 < ptMinLoose) || (pt1 < ptMinLoose))
200  return false;
201  if ((pt0 < ptMinTight) && (pt1 < ptMinTight))
202  return false;
203  float eta0 = fabs(dptr0->eta());
204  float eta1 = fabs(dptr1->eta());
205  if ((etaMaxLoose > 0) && ((eta0 > etaMaxLoose) || (eta1 > etaMaxLoose)))
206  return false;
207  if ((etaMaxTight > 0) && ((eta0 > etaMaxTight) && (eta1 > etaMaxTight)))
208  return false;
209  if (softMuonselector != nullptr) {
210  const reco::Vertex* pvtx = BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex");
211  if (pvtx == nullptr)
212  return false;
213  if (!softMuonselector->accept(*dptr0, pvtx))
214  return false;
215  if (!softMuonselector->accept(*dptr1, pvtx))
216  return false;
217  }
218  return true;
219  }
220 
221 private:
222  float pLMin;
223  float pTMin;
224  float eLMax;
225  float eTMax;
226  const BPHSoftMuonSelect* sms;
227 };
228 
229 class BPHCompositeBasicSelect : public BPHHistoSpecificDecay::CandidateSelect {
230 public:
231  BPHCompositeBasicSelect(
232  float massMin, float massMax, float ptMin = -1.0, float etaMax = -1.0, float rapidityMax = -1.0)
233  : mMin(massMin), mMax(massMax), pMin(ptMin), eMax(etaMax), yMax(rapidityMax) {}
234  ~BPHCompositeBasicSelect() override {}
235  bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
236  if (((mMin > 0) && (mMax < 0)) || ((mMin < 0) && (mMax > 0)) || ((mMin > 0) && (mMax > 0) && (mMin < mMax))) {
237  float mass = cand.mass();
238  if (mass < mMin)
239  return false;
240  if ((mMax > 0) && (mass > mMax))
241  return false;
242  }
243  if (cand.pt() < pMin)
244  return false;
245  if ((eMax > 0) && (fabs(cand.eta()) > eMax))
246  return false;
247  if ((yMax > 0) && (fabs(cand.rapidity()) > yMax))
248  return false;
249  return true;
250  }
251 
252 private:
253  float mMin;
254  float mMax;
255  float pMin;
256  float eMax;
257  float yMax;
258 };
259 
260 class BPHFittedBasicSelect : public BPHHistoSpecificDecay::CandidateSelect {
261 public:
262  BPHFittedBasicSelect(float massMin, float massMax, float ptMin = -1.0, float etaMax = -1.0, float rapidityMax = -1.0)
263  : mMin(massMin), mMax(massMax), pMin(ptMin), eMax(etaMax), yMax(rapidityMax) {}
264  ~BPHFittedBasicSelect() override {}
265  bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
266  if (!cand.hasUserFloat("fitMass"))
267  return false;
268  float mass = cand.userFloat("fitMass");
269  if (((mMin > 0) && (mMax < 0)) || ((mMin < 0) && (mMax > 0)) || ((mMin > 0) && (mMax > 0) && (mMin < mMax))) {
270  if (mass < mMin)
271  return false;
272  if ((mMax > 0) && (mass > mMax))
273  return false;
274  }
275  const Vector3DBase<float, GlobalTag>* fmom = BPHUserData::get<Vector3DBase<float, GlobalTag>>(cand, "fitMomentum");
276  if (fmom == nullptr)
277  return false;
278  if (pMin > 0) {
279  if (fmom->transverse() < pMin)
280  return false;
281  }
282  if (eMax > 0) {
283  if (fabs(fmom->eta()) > eMax)
284  return false;
285  }
286  if (yMax > 0) {
287  float x = fmom->x();
288  float y = fmom->y();
289  float z = fmom->z();
290  float e = sqrt((x * x) + (y * y) + (z * z) + (mass * mass));
291  float r = log((e + z) / (e - z)) / 2;
292  if (fabs(r) > yMax)
293  return false;
294  }
295  return true;
296  }
297 
298 private:
299  float mMin;
300  float mMax;
301  float pMin;
302  float eMax;
303  float yMax;
304 };
305 
306 class BPHGenericVertexSelect : public BPHHistoSpecificDecay::CandidateSelect {
307 public:
308  BPHGenericVertexSelect(char vType, float probMin, float cosMin = -2.0, float sigMin = -1.0, char dMode = 'r')
309  : type(vType), pMin(probMin), cMin(cosMin), sMin(sigMin), mode(dMode) {}
310  ~BPHGenericVertexSelect() override {}
311  bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pvtx) const override {
312  if (pvtx == nullptr)
313  return false;
314  const reco::Vertex* svtx = nullptr;
315  float px;
316  float py;
317  float mass;
318  switch (type) {
319  case 'c':
320  svtx = BPHUserData::get<reco::Vertex>(cand, "vertex");
321  px = cand.px();
322  py = cand.py();
323  mass = cand.mass();
324  break;
325  case 'f':
326  svtx = BPHUserData::get<reco::Vertex>(cand, "fitVertex");
327  {
328  const Vector3DBase<float, GlobalTag>* fmom =
329  BPHUserData::get<Vector3DBase<float, GlobalTag>>(cand, "fitMomentum");
330  if (fmom == nullptr)
331  return false;
332  px = fmom->x();
333  py = fmom->y();
334  }
335  if (!cand.hasUserFloat("fitMass"))
336  return false;
337  mass = cand.userFloat("fitMass");
338  break;
339  default:
340  return false;
341  }
342  if (svtx == nullptr)
343  return false;
344  if (pMin > 0) {
345  if (ChiSquaredProbability(svtx->chi2(), svtx->ndof()) < pMin)
346  return false;
347  }
348  if ((cMin > -1.0) || (sMin > 0)) {
349  float cosAlpha = VertexAnalysis::cAlpha(pvtx, svtx, px, py);
350  if (cosAlpha < cMin)
351  return false;
352  if (sMin < 0)
353  return true;
354  double ctauPV;
355  double ctauErrPV;
356  VertexAnalysis::dist2D(pvtx, svtx, px, py, cosAlpha, mass, ctauPV, ctauErrPV);
357  float dTest;
358  switch (mode) {
359  case 'a':
360  case 'd':
361  dTest = ctauPV;
362  break;
363  case 'r':
364  case 's':
365  default:
366  dTest = ctauPV / ctauErrPV;
367  break;
368  }
369  if (dTest < sMin)
370  return false;
371  }
372  return true;
373  }
374 
375 private:
376  char type;
377  float pMin;
378  float cMin;
379  float sMin;
380  char mode;
381 };
382 
383 BPHHistoSpecificDecay::BPHHistoSpecificDecay(const edm::ParameterSet& ps) {
384  useTrig = (!SET_LABEL(trigResultsLabel, ps).empty());
385  useOnia = (!SET_LABEL(oniaCandsLabel, ps).empty());
386  useSd = (!SET_LABEL(sdCandsLabel, ps).empty());
387  useSs = (!SET_LABEL(ssCandsLabel, ps).empty());
388  useBu = (!SET_LABEL(buCandsLabel, ps).empty());
389  useBd = (!SET_LABEL(bdCandsLabel, ps).empty());
390  useBs = (!SET_LABEL(bsCandsLabel, ps).empty());
391  useK0 = (!SET_LABEL(k0CandsLabel, ps).empty());
392  useL0 = (!SET_LABEL(l0CandsLabel, ps).empty());
393  useB0 = (!SET_LABEL(b0CandsLabel, ps).empty());
394  useLb = (!SET_LABEL(lbCandsLabel, ps).empty());
395  useBc = (!SET_LABEL(bcCandsLabel, ps).empty());
396  useX3872 = (!SET_LABEL(x3872CandsLabel, ps).empty());
397  if (useTrig)
398  consume<edm::TriggerResults>(trigResultsToken, trigResultsLabel);
399  if (useOnia)
400  consume<vector<pat::CompositeCandidate>>(oniaCandsToken, oniaCandsLabel);
401  if (useSd)
402  consume<vector<pat::CompositeCandidate>>(sdCandsToken, sdCandsLabel);
403  if (useSs)
404  consume<vector<pat::CompositeCandidate>>(ssCandsToken, ssCandsLabel);
405  if (useBu)
406  consume<vector<pat::CompositeCandidate>>(buCandsToken, buCandsLabel);
407  if (useBd)
408  consume<vector<pat::CompositeCandidate>>(bdCandsToken, bdCandsLabel);
409  if (useBs)
410  consume<vector<pat::CompositeCandidate>>(bsCandsToken, bsCandsLabel);
411  if (useK0)
412  consume<vector<pat::CompositeCandidate>>(k0CandsToken, k0CandsLabel);
413  if (useL0)
414  consume<vector<pat::CompositeCandidate>>(l0CandsToken, l0CandsLabel);
415  if (useB0)
416  consume<vector<pat::CompositeCandidate>>(b0CandsToken, b0CandsLabel);
417  if (useLb)
418  consume<vector<pat::CompositeCandidate>>(lbCandsToken, lbCandsLabel);
419  if (useBc)
420  consume<vector<pat::CompositeCandidate>>(bcCandsToken, bcCandsLabel);
421  if (useX3872)
422  consume<vector<pat::CompositeCandidate>>(x3872CandsToken, x3872CandsLabel);
423 
424  static const BPHSoftMuonSelect* sms = new BPHSoftMuonSelect;
425 
427 
428  double phiIMassMin = 0.85;
429  double phiIMassMax = 1.20;
430  double phiIPtMin = 18.0;
431  double phiIEtaMax = -1.0;
432  double phiIYMax = -1.0;
433  double phiBMassMin = 0.85;
434  double phiBMassMax = 1.20;
435  double phiBPtMin = 14.0;
436  double phiBEtaMax = -1.0;
437  double phiBYMax = 1.25;
438  double jPsiIMassMin = 2.80;
439  double jPsiIMassMax = 3.40;
440  double jPsiIPtMin = 25.0;
441  double jPsiIEtaMax = -1.0;
442  double jPsiIYMax = -1.0;
443  double jPsiBMassMin = 2.80;
444  double jPsiBMassMax = 3.40;
445  double jPsiBPtMin = 20.0;
446  double jPsiBEtaMax = -1.0;
447  double jPsiBYMax = 1.25;
448  double psi2IMassMin = 3.40;
449  double psi2IMassMax = 4.00;
450  double psi2IPtMin = 18.0;
451  double psi2IEtaMax = -1.0;
452  double psi2IYMax = -1.0;
453  double psi2BMassMin = 3.40;
454  double psi2BMassMax = 4.00;
455  double psi2BPtMin = 10.0;
456  double psi2BEtaMax = -1.0;
457  double psi2BYMax = 1.25;
458  double upsIMassMin = 8.50;
459  double upsIMassMax = 11.0;
460  double upsIPtMin = 15.0;
461  double upsIEtaMax = -1.0;
462  double upsIYMax = -1.0;
463  double upsBMassMin = 8.50;
464  double upsBMassMax = 11.0;
465  double upsBPtMin = 12.0;
466  // double upsBEtaMax = 1.5; // 2017
467  // double upsBYMax = -1.0; // 2017
468  double upsBEtaMax = -1.0; // 2018
469  double upsBYMax = 1.4; // 2018
470 
471  double oniaProbMin = 0.005;
472  double oniaCosMin = -2.0;
473  double oniaSigMin = -1.0;
474 
475  double oniaMuPtMinLoose = 2.0;
476  double oniaMuPtMinTight = -1.0;
477  double oniaMuEtaMaxLoose = -1.0;
478  double oniaMuEtaMaxTight = -1.0;
479 
480  phiIBasicSelect = new BPHCompositeBasicSelect(phiIMassMin, phiIMassMax, phiIPtMin, phiIEtaMax, phiIYMax);
481  phiBBasicSelect = new BPHCompositeBasicSelect(phiBMassMin, phiBMassMax, phiBPtMin, phiBEtaMax, phiBYMax);
482  jPsiIBasicSelect = new BPHCompositeBasicSelect(jPsiIMassMin, jPsiIMassMax, jPsiIPtMin, jPsiIEtaMax, jPsiIYMax);
483  jPsiBBasicSelect = new BPHCompositeBasicSelect(jPsiBMassMin, jPsiBMassMax, jPsiBPtMin, jPsiBEtaMax, jPsiBYMax);
484  psi2IBasicSelect = new BPHCompositeBasicSelect(psi2IMassMin, psi2IMassMax, psi2IPtMin, psi2IEtaMax, psi2IYMax);
485  psi2BBasicSelect = new BPHCompositeBasicSelect(psi2BMassMin, psi2BMassMax, psi2BPtMin, psi2BEtaMax, psi2BYMax);
486  upsIBasicSelect = new BPHCompositeBasicSelect(upsIMassMin, upsIMassMax, upsIPtMin, upsIEtaMax, upsIYMax);
487  upsBBasicSelect = new BPHCompositeBasicSelect(upsBMassMin, upsBMassMax, upsBPtMin, upsBEtaMax, upsBYMax);
488  // oniaVertexSelect = new BPHCompositeVertexSelect(
489  oniaVertexSelect = new BPHGenericVertexSelect('c', oniaProbMin, oniaCosMin, oniaSigMin);
490  oniaDaughterSelect =
491  new BPHDaughterSelect(oniaMuPtMinLoose, oniaMuPtMinTight, oniaMuEtaMaxLoose, oniaMuEtaMaxTight, sms);
492 
493  double npJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
494  double npJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
495  double npJPsiPtMin = 8.0;
496  double npJPsiEtaMax = -1.0;
497  double npJPsiYMax = -1.0;
498  double npMuPtMinLoose = 4.0;
499  double npMuPtMinTight = -1.0;
500  double npMuEtaMaxLoose = 2.2;
501  double npMuEtaMaxTight = -1.0;
502 
503  npJPsiBasicSelect = new BPHCompositeBasicSelect(npJPsiMassMin, npJPsiMassMax, npJPsiPtMin, npJPsiEtaMax, npJPsiYMax);
504  npJPsiDaughterSelect = new BPHDaughterSelect(npMuPtMinLoose, npMuPtMinTight, npMuEtaMaxLoose, npMuEtaMaxTight, sms);
505 
507 
508  double buIMassMin = 0.0;
509  double buIMassMax = 999999.0;
510  double buIPtMin = 27.0;
511  double buIEtaMax = -1.0;
512  double buIYMax = -1.0;
513  double buIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
514  double buIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
515  double buIJPsiPtMin = 25.0;
516  double buIJPsiEtaMax = -1.0;
517  double buIJPsiYMax = -1.0;
518  double buIProbMin = 0.15;
519  double buICosMin = -2.0;
520  double buISigMin = -1.0;
521  // double buIMuPtMinLoose = -1.0;
522  // double buIMuPtMinTight = -1.0;
523  // double buIMuEtaMaxLoose = -1.0;
524  // double buIMuEtaMaxTight = -1.0;
525 
526  buIKPtMin = 2.0;
527 
528  buIBasicSelect = new BPHFittedBasicSelect(buIMassMin, buIMassMax, buIPtMin, buIEtaMax, buIYMax);
529  buIJPsiBasicSelect =
530  new BPHCompositeBasicSelect(buIJPsiMassMin, buIJPsiMassMax, buIJPsiPtMin, buIJPsiEtaMax, buIJPsiYMax);
531  buIVertexSelect = new BPHGenericVertexSelect('f', buIProbMin, buICosMin, buISigMin);
532  buIJPsiDaughterSelect = nullptr;
533  // buIJPsiDaughterSelect = new BPHDaughterSelect(
534  // buIMuPtMinLoose , buIMuPtMinTight ,
535  // buIMuEtaMaxLoose, buMuEtaMaxTight, sms );
536 
537  double buDMassMin = 0.0;
538  double buDMassMax = 999999.0;
539  double buDPtMin = 10.0;
540  double buDEtaMax = -1.0;
541  double buDYMax = -1.0;
542  double buDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
543  double buDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
544  double buDJPsiPtMin = 8.0;
545  double buDJPsiEtaMax = -1.0;
546  double buDJPsiYMax = -1.0;
547  double buDProbMin = 0.10;
548  double buDCosMin = 0.99;
549  double buDSigMin = 3.0;
550  // double buDMuPtMinLoose = -1.0;
551  // double buDMuPtMinTight = -1.0;
552  // double buDMuEtaMaxLoose = -1.0;
553  // double buDMuEtaMaxTight = -1.0;
554 
555  buDKPtMin = 1.6;
556 
557  buDBasicSelect = new BPHFittedBasicSelect(buDMassMin, buDMassMax, buDPtMin, buDEtaMax, buDYMax);
558  buDJPsiBasicSelect =
559  new BPHCompositeBasicSelect(buDJPsiMassMin, buDJPsiMassMax, buDJPsiPtMin, buDJPsiEtaMax, buDJPsiYMax);
560  buDVertexSelect = new BPHGenericVertexSelect('f', buDProbMin, buDCosMin, buDSigMin);
561  buDJPsiDaughterSelect = nullptr;
562  // buDJPsiDaughterSelect = new BPHDaughterSelect(
563  // buDMuPtMinLoose , buDMuPtMinTight ,
564  // buDMuEtaMaxLoose, buDMuEtaMaxTight, sms );
565 
567 
568  double bdIMassMin = 0.0;
569  double bdIMassMax = 999999.0;
570  double bdIPtMin = 27.0;
571  double bdIEtaMax = -1.0;
572  double bdIYMax = -1.0;
573  double bdIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
574  double bdIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
575  double bdIJPsiPtMin = 25.0;
576  double bdIJPsiEtaMax = -1.0;
577  double bdIJPsiYMax = -1.0;
578  double bdIKx0MassMin = BPHParticleMasses::kx0Mass - 0.100;
579  double bdIKx0MassMax = BPHParticleMasses::kx0Mass + 0.100;
580  double bdIKx0PtMin = -1.0;
581  double bdIKx0EtaMax = -1.0;
582  double bdIKx0YMax = -1.0;
583  double bdIProbMin = 0.15;
584  double bdICosMin = -2.0;
585  double bdISigMin = -1.0;
586  // double bdIMuPtMinLoose = -1.0;
587  // double bdIMuPtMinTight = -1.0;
588  // double bdIMuEtaMaxLoose = -1.0;
589  // double bdIMuEtaMaxTight = -1.0;
590 
591  bdIBasicSelect = new BPHFittedBasicSelect(bdIMassMin, bdIMassMax, bdIPtMin, bdIEtaMax, bdIYMax);
592  bdIJPsiBasicSelect =
593  new BPHCompositeBasicSelect(bdIJPsiMassMin, bdIJPsiMassMax, bdIJPsiPtMin, bdIJPsiEtaMax, bdIJPsiYMax);
594  bdIKx0BasicSelect = new BPHCompositeBasicSelect(bdIKx0MassMin, bdIKx0MassMax, bdIKx0PtMin, bdIKx0EtaMax, bdIKx0YMax);
595  bdIVertexSelect = new BPHGenericVertexSelect('f', bdIProbMin, bdICosMin, bdISigMin);
596  bdIJPsiDaughterSelect = nullptr;
597  // bdIJPsiDaughterSelect = new BPHDaughterSelect(
598  // bdIMuPtMinLoose , bdIMuPtMinTight ,
599  // bdIMuEtaMaxLoose, bdIMuEtaMaxTight, sms );
600 
601  double bdDMassMin = 0.0;
602  double bdDMassMax = 999999.0;
603  double bdDPtMin = 10.0;
604  double bdDEtaMax = -1.0;
605  double bdDYMax = -1.0;
606  double bdDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
607  double bdDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
608  double bdDJPsiPtMin = 8.0;
609  double bdDJPsiEtaMax = -1.0;
610  double bdDJPsiYMax = -1.0;
611  double bdDKx0MassMin = BPHParticleMasses::kx0Mass - 0.100;
612  double bdDKx0MassMax = BPHParticleMasses::kx0Mass + 0.100;
613  double bdDKx0PtMin = -1.0;
614  double bdDKx0EtaMax = -1.0;
615  double bdDKx0YMax = -1.0;
616  double bdDProbMin = 0.10;
617  double bdDCosMin = 0.99;
618  double bdDSigMin = 3.0;
619  // double bdDMuPtMinLoose = -1.0;
620  // double bdDMuPtMinTight = -1.0;
621  // double bdDMuEtaMaxLoose = -1.0;
622  // double bdDMuEtaMaxTight = -1.0;
623 
624  bdDBasicSelect = new BPHFittedBasicSelect(bdDMassMin, bdDMassMax, bdDPtMin, bdDEtaMax, bdDYMax);
625  bdDJPsiBasicSelect =
626  new BPHCompositeBasicSelect(bdDJPsiMassMin, bdDJPsiMassMax, bdDJPsiPtMin, bdDJPsiEtaMax, bdDJPsiYMax);
627  bdDKx0BasicSelect = new BPHCompositeBasicSelect(bdDKx0MassMin, bdDKx0MassMax, bdDKx0PtMin, bdDKx0EtaMax, bdDKx0YMax);
628  bdDVertexSelect = new BPHGenericVertexSelect('f', bdDProbMin, bdDCosMin, bdDSigMin);
629  bdDJPsiDaughterSelect = nullptr;
630  // bdDJPsiDaughterSelect = new BPHDaughterSelect(
631  // bdDMuPtMinLoose , bdDMuPtMinTight ,
632  // bdDMuEtaMaxLoose, bdDMuEtaMaxTight, sms );
633 
635 
636  double bsIMassMin = 0.0;
637  double bsIMassMax = 999999.0;
638  double bsIPtMin = 27.0;
639  double bsIEtaMax = -1.0;
640  double bsIYMax = -1.0;
641  double bsIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
642  double bsIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
643  double bsIJPsiPtMin = 25.0;
644  double bsIJPsiEtaMax = -1.0;
645  double bsIJPsiYMax = -1.0;
646  double bsIPhiMassMin = BPHParticleMasses::phiMass - 0.010;
647  double bsIPhiMassMax = BPHParticleMasses::phiMass + 0.010;
648  double bsIPhiPtMin = -1.0;
649  double bsIPhiEtaMax = -1.0;
650  double bsIPhiYMax = -1.0;
651  double bsIProbMin = 0.15;
652  double bsICosMin = -2.0;
653  double bsISigMin = -1.0;
654  // double bsIMuPtMinLoose = -1.0;
655  // double bsIMuPtMinTight = -1.0;
656  // double bsIMuEtaMaxLoose = -1.0;
657  // double bsIMuEtaMaxTight = -1.0;
658 
659  bsIBasicSelect = new BPHFittedBasicSelect(bsIMassMin, bsIMassMax, bsIPtMin, bsIEtaMax, bsIYMax);
660  bsIJPsiBasicSelect =
661  new BPHCompositeBasicSelect(bsIJPsiMassMin, bsIJPsiMassMax, bsIJPsiPtMin, bsIJPsiEtaMax, bsIJPsiYMax);
662  bsIPhiBasicSelect = new BPHCompositeBasicSelect(bsIPhiMassMin, bsIPhiMassMax, bsIPhiPtMin, bsIPhiEtaMax, bsIPhiYMax);
663  bsIVertexSelect = new BPHGenericVertexSelect('f', bsIProbMin, bsICosMin, bsISigMin);
664  bsIJPsiDaughterSelect = nullptr;
665  // bsIJPsiDaughterSelect = new BPHDaughterSelect(
666  // bsIMuPtMinLoose , bsIMuPtMinTight ,
667  // bsIMuEtaMaxLoose, bsIMuEtaMaxTight, sms );
668 
669  double bsDMassMin = 0.0;
670  double bsDMassMax = 999999.0;
671  double bsDPtMin = 10.0;
672  double bsDEtaMax = -1.0;
673  double bsDYMax = -1.0;
674  double bsDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
675  double bsDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
676  double bsDJPsiPtMin = 8.0;
677  double bsDJPsiEtaMax = -1.0;
678  double bsDJPsiYMax = -1.0;
679  double bsDPhiMassMin = BPHParticleMasses::phiMass - 0.010;
680  double bsDPhiMassMax = BPHParticleMasses::phiMass + 0.010;
681  double bsDPhiPtMin = -1.0;
682  double bsDPhiEtaMax = -1.0;
683  double bsDPhiYMax = -1.0;
684  double bsDProbMin = 0.10;
685  double bsDCosMin = 0.99;
686  double bsDSigMin = 3.0;
687  // double bsDMuPtMinLoose = -1.0;
688  // double bsDMuPtMinTight = -1.0;
689  // double bsDMuEtaMaxLoose = -1.0;
690  // double bsDMuEtaMaxTight = -1.0;
691 
692  bsDBasicSelect = new BPHFittedBasicSelect(bsDMassMin, bsDMassMax, bsDPtMin, bsDEtaMax, bsDYMax);
693  bsDJPsiBasicSelect =
694  new BPHCompositeBasicSelect(bsDJPsiMassMin, bsDJPsiMassMax, bsDJPsiPtMin, bsDJPsiEtaMax, bsDJPsiYMax);
695  bsDPhiBasicSelect = new BPHCompositeBasicSelect(bsDPhiMassMin, bsDPhiMassMax, bsDPhiPtMin, bsDPhiEtaMax, bsDPhiYMax);
696  bsDVertexSelect = new BPHGenericVertexSelect('f', bsDProbMin, bsDCosMin, bsDSigMin);
697  bsDJPsiDaughterSelect = nullptr;
698  // bsDJPsiDaughterSelect = new BPHDaughterSelect(
699  // bsDMuPtMinLoose , bsDMuPtMinTight ,
700  // bsDMuEtaMaxLoose, bsDMuEtaMaxTight, sms );
701 
703 
704  double b0IMassMin = 0.0;
705  double b0IMassMax = 999999.0;
706  double b0IPtMin = 27.0;
707  double b0IEtaMax = -1.0;
708  double b0IYMax = -1.0;
709  double b0IJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
710  double b0IJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
711  double b0IJPsiPtMin = 25.0;
712  double b0IJPsiEtaMax = -1.0;
713  double b0IJPsiYMax = -1.0;
714  double b0IK0sMassMin = BPHParticleMasses::k0sMass - 0.010;
715  double b0IK0sMassMax = BPHParticleMasses::k0sMass + 0.010;
716  double b0IK0sPtMin = -1.0;
717  double b0IK0sEtaMax = -1.0;
718  double b0IK0sYMax = -1.0;
719  double b0IProbMin = 0.15;
720  double b0ICosMin = -2.0;
721  double b0ISigMin = -1.0;
722  // double b0IMuPtMinLoose = -1.0;
723  // double b0IMuPtMinTight = -1.0;
724  // double b0IMuEtaMaxLoose = -1.0;
725  // double b0IMuEtaMaxTight = -1.0;
726 
727  b0IBasicSelect = new BPHFittedBasicSelect(b0IMassMin, b0IMassMax, b0IPtMin, b0IEtaMax, b0IYMax);
728  b0IJPsiBasicSelect =
729  new BPHCompositeBasicSelect(b0IJPsiMassMin, b0IJPsiMassMax, b0IJPsiPtMin, b0IJPsiEtaMax, b0IJPsiYMax);
730  b0IK0sBasicSelect = new BPHFittedBasicSelect(b0IK0sMassMin, b0IK0sMassMax, b0IK0sPtMin, b0IK0sEtaMax, b0IK0sYMax);
731  b0IVertexSelect = new BPHGenericVertexSelect('f', b0IProbMin, b0ICosMin, b0ISigMin);
732  b0IJPsiDaughterSelect = nullptr;
733  // b0IJPsiDaughterSelect = new BPHDaughterSelect(
734  // b0IMuPtMinLoose , b0IMuPtMinTight ,
735  // b0IMuEtaMaxLoose, b0IMuEtaMaxTight, sms );
736 
737  double b0DMassMin = 0.0;
738  double b0DMassMax = 999999.0;
739  double b0DPtMin = 10.0;
740  double b0DEtaMax = -1.0;
741  double b0DYMax = -1.0;
742  double b0DJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
743  double b0DJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
744  double b0DJPsiPtMin = 8.0;
745  double b0DJPsiEtaMax = -1.0;
746  double b0DJPsiYMax = -1.0;
747  double b0DK0sMassMin = BPHParticleMasses::k0sMass - 0.010;
748  double b0DK0sMassMax = BPHParticleMasses::k0sMass + 0.010;
749  double b0DK0sPtMin = -1.0;
750  double b0DK0sEtaMax = -1.0;
751  double b0DK0sYMax = -1.0;
752  double b0DProbMin = 0.10;
753  double b0DCosMin = 0.99;
754  double b0DSigMin = 3.0;
755  // double b0DMuPtMinLoose = -1.0;
756  // double b0DMuPtMinTight = -1.0;
757  // double b0DMuEtaMaxLoose = -1.0;
758  // double b0DMuEtaMaxTight = -1.0;
759 
760  b0DBasicSelect = new BPHFittedBasicSelect(b0DMassMin, b0DMassMax, b0DPtMin, b0DEtaMax, b0DYMax);
761  b0DJPsiBasicSelect =
762  new BPHCompositeBasicSelect(b0DJPsiMassMin, b0DJPsiMassMax, b0DJPsiPtMin, b0DJPsiEtaMax, b0DJPsiYMax);
763  b0DK0sBasicSelect = new BPHFittedBasicSelect(b0DK0sMassMin, b0DK0sMassMax, b0DK0sPtMin, b0DK0sEtaMax, b0DK0sYMax);
764  b0DVertexSelect = new BPHGenericVertexSelect('f', b0DProbMin, b0DCosMin, b0DSigMin);
765  b0DJPsiDaughterSelect = nullptr;
766  // b0DJPsiDaughterSelect = new BPHDaughterSelect(
767  // b0DMuPtMinLoose , b0DMuPtMinTight ,
768  // b0DMuEtaMaxLoose, b0DMuEtaMaxTight, sms );
769 
771 
772  double lbIMassMin = 0.0;
773  double lbIMassMax = 999999.0;
774  double lbIPtMin = 27.0;
775  double lbIEtaMax = -1.0;
776  double lbIYMax = -1.0;
777  double lbIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
778  double lbIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
779  double lbIJPsiPtMin = 25.0;
780  double lbIJPsiEtaMax = -1.0;
781  double lbIJPsiYMax = -1.0;
782  double lbILambda0MassMin = BPHParticleMasses::lambda0Mass - 0.006;
783  double lbILambda0MassMax = BPHParticleMasses::lambda0Mass + 0.006;
784  double lbILambda0PtMin = -1.0;
785  double lbILambda0EtaMax = -1.0;
786  double lbILambda0YMax = -1.0;
787  double lbIProbMin = 0.10;
788  double lbICosMin = -2.0;
789  double lbISigMin = -1.0;
790  // double lbIMuPtMinLoose = -1.0;
791  // double lbIMuPtMinTight = -1.0;
792  // double lbIMuEtaMaxLoose = -1.0;
793  // double lbIMuEtaMaxTight = -1.0;
794 
795  lbIBasicSelect = new BPHFittedBasicSelect(lbIMassMin, lbIMassMax, lbIPtMin, lbIEtaMax, lbIYMax);
796  lbIJPsiBasicSelect =
797  new BPHCompositeBasicSelect(lbIJPsiMassMin, lbIJPsiMassMax, lbIJPsiPtMin, lbIJPsiEtaMax, lbIJPsiYMax);
798  lbILambda0BasicSelect =
799  new BPHFittedBasicSelect(lbILambda0MassMin, lbILambda0MassMax, lbILambda0PtMin, lbILambda0EtaMax, lbILambda0YMax);
800  lbIVertexSelect = new BPHGenericVertexSelect('f', lbIProbMin, lbICosMin, lbISigMin);
801  lbIJPsiDaughterSelect = nullptr;
802  // lbIJPsiDaughterSelect = new BPHDaughterSelect(
803  // lbIMuPtMinLoose , lbIMuPtMinTight ,
804  // lbIMuEtaMaxLoose, lbIMuEtaMaxTight, sms );
805 
806  double lbDMassMin = 0.0;
807  double lbDMassMax = 999999.0;
808  double lbDPtMin = 10.0;
809  double lbDEtaMax = -1.0;
810  double lbDYMax = -1.0;
811  double lbDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
812  double lbDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
813  double lbDJPsiPtMin = 8.0;
814  double lbDJPsiEtaMax = -1.0;
815  double lbDJPsiYMax = -1.0;
816  double lbDLambda0MassMin = BPHParticleMasses::lambda0Mass - 0.006;
817  double lbDLambda0MassMax = BPHParticleMasses::lambda0Mass + 0.006;
818  double lbDLambda0PtMin = -1.0;
819  double lbDLambda0EtaMax = -1.0;
820  double lbDLambda0YMax = -1.0;
821  double lbDProbMin = 0.10;
822  double lbDCosMin = 0.99;
823  double lbDSigMin = 3.0;
824  // double lbDMuPtMinLoose = -1.0;
825  // double lbDMuPtMinTight = -1.0;
826  // double lbDMuEtaMaxLoose = -1.0;
827  // double lbDMuEtaMaxTight = -1.0;
828 
829  lbDBasicSelect = new BPHFittedBasicSelect(lbDMassMin, lbDMassMax, lbDPtMin, lbDEtaMax, lbDYMax);
830  lbDJPsiBasicSelect =
831  new BPHCompositeBasicSelect(lbDJPsiMassMin, lbDJPsiMassMax, lbDJPsiPtMin, lbDJPsiEtaMax, lbDJPsiYMax);
832  lbDLambda0BasicSelect =
833  new BPHFittedBasicSelect(lbDLambda0MassMin, lbDLambda0MassMax, lbDLambda0PtMin, lbDLambda0EtaMax, lbDLambda0YMax);
834  lbDVertexSelect = new BPHGenericVertexSelect('f', lbDProbMin, lbDCosMin, lbDSigMin);
835  lbDJPsiDaughterSelect = nullptr;
836  // lbDJPsiDaughterSelect = new BPHDaughterSelect(
837  // lbDMuPtMinLoose , lbDMuPtMinTight ,
838  // lbDMuEtaMaxLoose, lbDMuEtaMaxTight, sms );
839 
841 
842  double bcIMassMin = 0.0;
843  double bcIMassMax = 999999.0;
844  double bcIPtMin = 27.0;
845  double bcIEtaMax = -1.0;
846  double bcIYMax = -1.0;
847  double bcIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
848  double bcIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
849  double bcIJPsiPtMin = 25.0;
850  double bcIJPsiEtaMax = -1.0;
851  double bcIJPsiYMax = -1.0;
852  double bcIJPsiProbMin = 0.005;
853  double bcIProbMin = 0.10;
854  double bcICosMin = -2.0;
855  double bcISigMin = -1.0;
856  double bcIDistMin = 0.01;
857  // double bcIMuPtMinLoose = -1.0;
858  // double bcIMuPtMinTight = -1.0;
859  // double bcIMuEtaMaxLoose = -1.0;
860  // double bcIMuEtaMaxTight = -1.0;
861 
862  bcIPiPtMin = 3.5;
863 
864  bcIBasicSelect = new BPHFittedBasicSelect(bcIMassMin, bcIMassMax, bcIPtMin, bcIEtaMax, bcIYMax);
865  bcIJPsiBasicSelect =
866  new BPHCompositeBasicSelect(bcIJPsiMassMin, bcIJPsiMassMax, bcIJPsiPtMin, bcIJPsiEtaMax, bcIJPsiYMax);
867  bcIJPsiVertexSelect = new BPHGenericVertexSelect('c', bcIJPsiProbMin);
868  bcIVertexSelect = new BPHGenericVertexSelect('f', bcIProbMin, bcICosMin, bcISigMin, bcIDistMin);
869  bcIJPsiDaughterSelect = nullptr;
870  // bcIJPsiDaughterSelect = new BPHDaughterSelect(
871  // bcIMuPtMinLoose , bcIMuPtMinTight ,
872  // bcIMuEtaMaxLoose, bcMuEtaMaxTight, sms );
873 
874  double bcDMassMin = 0.0;
875  double bcDMassMax = 999999.0;
876  double bcDPtMin = 8.0;
877  double bcDEtaMax = -1.0;
878  double bcDYMax = -1.0;
879  double bcDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
880  double bcDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
881  double bcDJPsiPtMin = 7.0;
882  double bcDJPsiEtaMax = -1.0;
883  double bcDJPsiYMax = -1.0;
884  double bcDJPsiProbMin = 0.005;
885  double bcDProbMin = 0.10;
886  double bcDCosMin = 0.99;
887  double bcDSigMin = 3.0;
888  // double bcDMuPtMinLoose = -1.0;
889  // double bcDMuPtMinTight = -1.0;
890  // double bcDMuEtaMaxLoose = -1.0;
891  // double bcDMuEtaMaxTight = -1.0;
892 
893  bcJPsiDcaMax = 0.5;
894  bcDPiPtMin = 3.5;
895 
896  bcDBasicSelect = new BPHFittedBasicSelect(bcDMassMin, bcDMassMax, bcDPtMin, bcDEtaMax, bcDYMax);
897  bcDJPsiBasicSelect =
898  new BPHCompositeBasicSelect(bcDJPsiMassMin, bcDJPsiMassMax, bcDJPsiPtMin, bcDJPsiEtaMax, bcDJPsiYMax);
899  bcDJPsiVertexSelect = new BPHGenericVertexSelect('c', bcDJPsiProbMin);
900  bcDVertexSelect = new BPHGenericVertexSelect('f', bcDProbMin, bcDCosMin, bcDSigMin);
901  bcDJPsiDaughterSelect = nullptr;
902  // bcDJPsiDaughterSelect = new BPHDaughterSelect(
903  // bcDMuPtMinLoose , bcDMuPtMinTight ,
904  // bcDMuEtaMaxLoose, bcDMuEtaMaxTight, sms );
905 
907 
908  double x3872IMassMin = 0.0;
909  double x3872IMassMax = 999999.0;
910  double x3872IPtMin = 27.0;
911  double x3872IEtaMax = -1.0;
912  double x3872IYMax = -1.0;
913  double x3872IJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
914  double x3872IJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
915  double x3872IJPsiPtMin = 25.0;
916  double x3872IJPsiEtaMax = -1.0;
917  double x3872IJPsiYMax = -1.0;
918  double x3872IJPsiProbMin = 0.10;
919  double x3872IProbMin = 0.10;
920  double x3872ICosMin = -2.0;
921  double x3872ISigMin = -1.0;
922  double x3872IDistMin = 0.01;
923  // double x3872IMuPtMinLoose = -1.0;
924  // double x3872IMuPtMinTight = -1.0;
925  // double x3872IMuEtaMaxLoose = -1.0;
926  // double x3872IMuEtaMaxTight = -1.0;
927 
928  x3872JPsiDcaMax = 0.5;
929  x3872IPiPtMin = 1.2;
930 
931  x3872IBasicSelect = new BPHFittedBasicSelect(x3872IMassMin, x3872IMassMax, x3872IPtMin, x3872IEtaMax, x3872IYMax);
932  x3872IJPsiBasicSelect = new BPHCompositeBasicSelect(
933  x3872IJPsiMassMin, x3872IJPsiMassMax, x3872IJPsiPtMin, x3872IJPsiEtaMax, x3872IJPsiYMax);
934  x3872IJPsiVertexSelect = new BPHGenericVertexSelect('c', x3872IJPsiProbMin);
935  x3872IVertexSelect = new BPHGenericVertexSelect('f', x3872IProbMin, x3872ICosMin, x3872ISigMin, x3872IDistMin);
936  x3872IJPsiDaughterSelect = nullptr;
937  // x3872IJPsiDaughterSelect = new BPHDaughterSelect(
938  // x3872IMuPtMinLoose , x3872IMuPtMinTight,
939  // x3872IMuEtaMaxLoose, x3872MuEtaMaxTight,
940  // sms );
941 
942  double x3872DMassMin = 0.0;
943  double x3872DMassMax = 999999.0;
944  double x3872DPtMin = 8.0;
945  double x3872DEtaMax = -1.0;
946  double x3872DYMax = -1.0;
947  double x3872DJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
948  double x3872DJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
949  double x3872DJPsiPtMin = 7.0;
950  double x3872DJPsiEtaMax = -1.0;
951  double x3872DJPsiYMax = -1.0;
952  double x3872DJPsiProbMin = 0.10;
953  double x3872DProbMin = 0.10;
954  double x3872DCosMin = 0.99;
955  double x3872DSigMin = 3.0;
956  // double x3872DMuPtMinLoose = -1.0;
957  // double x3872DMuPtMinTight = -1.0;
958  // double x3872DMuEtaMaxLoose = -1.0;
959  // double x3872DMuEtaMaxTight = -1.0;
960 
961  x3872DPiPtMin = 1.2;
962 
963  x3872DBasicSelect = new BPHFittedBasicSelect(x3872DMassMin, x3872DMassMax, x3872DPtMin, x3872DEtaMax, x3872DYMax);
964  x3872DJPsiBasicSelect = new BPHCompositeBasicSelect(
965  x3872DJPsiMassMin, x3872DJPsiMassMax, x3872DJPsiPtMin, x3872DJPsiEtaMax, x3872DJPsiYMax);
966  x3872DJPsiVertexSelect = new BPHGenericVertexSelect('c', x3872DJPsiProbMin);
967  x3872DVertexSelect = new BPHGenericVertexSelect('f', x3872DProbMin, x3872DCosMin, x3872DSigMin);
968  x3872DJPsiDaughterSelect = nullptr;
969  // x3872DJPsiDaughterSelect = new BPHDaughterSelect(
970  // x3872DMuPtMinLoose , x3872DMuPtMinTight ,
971  // x3872DMuEtaMaxLoose, x3872DMuEtaMaxTight,,
972  // sms );
973 }
974 
975 BPHHistoSpecificDecay::~BPHHistoSpecificDecay() {
976  delete phiIBasicSelect;
977  delete phiBBasicSelect;
978  delete jPsiIBasicSelect;
979  delete jPsiBBasicSelect;
980  delete psi2IBasicSelect;
981  delete psi2BBasicSelect;
982  delete upsIBasicSelect;
983  delete upsBBasicSelect;
984  delete oniaVertexSelect;
985  delete oniaDaughterSelect;
986 
987  delete npJPsiBasicSelect;
988  delete npJPsiDaughterSelect;
989 
990  delete buIBasicSelect;
991  delete buIJPsiBasicSelect;
992  delete buIVertexSelect;
993  delete buIJPsiDaughterSelect;
994  delete buDBasicSelect;
995  delete buDJPsiBasicSelect;
996  delete buDVertexSelect;
997  delete buDJPsiDaughterSelect;
998 
999  delete bdIBasicSelect;
1000  delete bdIJPsiBasicSelect;
1001  delete bdIKx0BasicSelect;
1002  delete bdIVertexSelect;
1003  delete bdIJPsiDaughterSelect;
1004  delete bdDBasicSelect;
1005  delete bdDJPsiBasicSelect;
1006  delete bdDKx0BasicSelect;
1007  delete bdDVertexSelect;
1008  delete bdDJPsiDaughterSelect;
1009 
1010  delete bsIBasicSelect;
1011  delete bsIJPsiBasicSelect;
1012  delete bsIPhiBasicSelect;
1013  delete bsIVertexSelect;
1014  delete bsIJPsiDaughterSelect;
1015  delete bsDBasicSelect;
1016  delete bsDJPsiBasicSelect;
1017  delete bsDPhiBasicSelect;
1018  delete bsDVertexSelect;
1019  delete bsDJPsiDaughterSelect;
1020 
1021  delete b0IBasicSelect;
1022  delete b0IJPsiBasicSelect;
1023  delete b0IK0sBasicSelect;
1024  delete b0IVertexSelect;
1025  delete b0IJPsiDaughterSelect;
1026  delete b0DBasicSelect;
1027  delete b0DJPsiBasicSelect;
1028  delete b0DK0sBasicSelect;
1029  delete b0DVertexSelect;
1030  delete b0DJPsiDaughterSelect;
1031 
1032  delete lbIBasicSelect;
1033  delete lbIJPsiBasicSelect;
1034  delete lbILambda0BasicSelect;
1035  delete lbIVertexSelect;
1036  delete lbIJPsiDaughterSelect;
1037  delete lbDBasicSelect;
1038  delete lbDJPsiBasicSelect;
1039  delete lbDLambda0BasicSelect;
1040  delete lbDVertexSelect;
1041  delete lbDJPsiDaughterSelect;
1042 
1043  delete bcIBasicSelect;
1044  delete bcIJPsiBasicSelect;
1045  delete bcIJPsiVertexSelect;
1046  delete bcIVertexSelect;
1047  delete bcIJPsiDaughterSelect;
1048  delete bcDBasicSelect;
1049  delete bcDJPsiBasicSelect;
1050  delete bcDJPsiVertexSelect;
1051  delete bcDVertexSelect;
1052  delete bcDJPsiDaughterSelect;
1053 
1054  delete x3872IBasicSelect;
1055  delete x3872IJPsiBasicSelect;
1056  delete x3872IJPsiVertexSelect;
1057  delete x3872IVertexSelect;
1058  delete x3872IJPsiDaughterSelect;
1059  delete x3872DBasicSelect;
1060  delete x3872DJPsiBasicSelect;
1061  delete x3872DJPsiVertexSelect;
1062  delete x3872DVertexSelect;
1063  delete x3872DJPsiDaughterSelect;
1064 }
1065 
1066 void BPHHistoSpecificDecay::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1067  edm::ParameterSetDescription desc;
1068  desc.add<string>("trigResultsLabel", "");
1069  desc.add<string>("oniaCandsLabel", "");
1070  desc.add<string>("sdCandsLabel", "");
1071  desc.add<string>("ssCandsLabel", "");
1072  desc.add<string>("buCandsLabel", "");
1073  desc.add<string>("bdCandsLabel", "");
1074  desc.add<string>("bsCandsLabel", "");
1075  desc.add<string>("k0CandsLabel", "");
1076  desc.add<string>("l0CandsLabel", "");
1077  desc.add<string>("b0CandsLabel", "");
1078  desc.add<string>("lbCandsLabel", "");
1079  desc.add<string>("bcCandsLabel", "");
1080  desc.add<string>("x3872CandsLabel", "");
1081  descriptions.add("process.bphHistoSpecificDecay", desc);
1082  return;
1083 }
1084 
1085 void BPHHistoSpecificDecay::beginJob() {
1086  createHisto("massDIPhi", 50, 0.90, 1.15); // Phi mass inclusive
1087  createHisto("massTIPhi", 50, 0.90, 1.15); // Phi mass inclusive
1088  createHisto("massDBPhi", 50, 0.90, 1.15); // Phi mass barrel
1089  createHisto("massTBPhi", 50, 0.90, 1.15); // Phi mass barrel
1090  createHisto("massDIJPsi", 35, 2.95, 3.30); // JPsi mass inclusive
1091  createHisto("massTIJPsi", 35, 2.95, 3.30); // JPsi mass inclusive
1092  createHisto("massDBJPsi", 35, 2.95, 3.30); // JPsi mass barrel
1093  createHisto("massTBJPsi", 35, 2.95, 3.30); // JPsi mass barrel
1094  createHisto("massDIPsi2", 60, 3.40, 4.00); // Psi2 mass inclusive
1095  createHisto("massTIPsi2", 60, 3.40, 4.00); // Psi2 mass inclusive
1096  createHisto("massDBPsi2", 60, 3.40, 4.00); // Psi2 mass barrel
1097  createHisto("massTBPsi2", 60, 3.40, 4.00); // Psi2 mass barrel
1098  createHisto("massDIUps123", 115, 8.70, 11.0); // Ups mass inclusive
1099  createHisto("massTIUps123", 115, 8.70, 11.0); // Ups mass inclusive
1100  createHisto("massDBUps123", 115, 8.70, 11.0); // Ups mass barrel
1101  createHisto("massTBUps123", 115, 8.70, 11.0); // Ups mass barrel
1102  createHisto("massDIBu", 100, 5.00, 6.00); // Bu mass inclusive
1103  createHisto("massTIBu", 100, 5.00, 6.00); // Bu mass inclusive
1104  createHisto("massDDBu", 100, 5.00, 6.00); // Bu mass displaced
1105  createHisto("massTDBu", 100, 5.00, 6.00); // Bu mass displaced
1106  createHisto("massDIBd", 100, 5.00, 6.00); // Bd mass inclusive
1107  createHisto("massTIBd", 100, 5.00, 6.00); // Bd mass inclusive
1108  createHisto("massDDBd", 100, 5.00, 6.00); // Bd mass displaced
1109  createHisto("massTDBd", 100, 5.00, 6.00); // Bd mass displaced
1110  createHisto("massDIBs", 100, 5.00, 6.00); // Bs mass inclusive
1111  createHisto("massTIBs", 100, 5.00, 6.00); // Bs mass inclusive
1112  createHisto("massDDBs", 100, 5.00, 6.00); // Bs mass displaced
1113  createHisto("massTDBs", 100, 5.00, 6.00); // Bs mass displaced
1114  createHisto("massDIBc", 100, 6.00, 7.00); // Bc mass inclusive
1115  createHisto("massTIBc", 100, 6.00, 7.00); // Bc mass inclusive
1116  createHisto("massDDBc", 100, 6.00, 7.00); // Bc mass displaced
1117  createHisto("massTDBc", 100, 6.00, 7.00); // Bc mass displaced
1118  createHisto("massDIX3872", 40, 3.60, 4.00); // X3872 mass inclusive
1119  createHisto("massTIX3872", 40, 3.60, 4.00); // X3872 mass inclusive
1120  createHisto("massDDX3872", 40, 3.60, 4.00); // X3872 mass displaced
1121  createHisto("massTDX3872", 40, 3.60, 4.00); // X3872 mass displaced
1122  createHisto("mfitDIBu", 100, 5.00, 6.00); // Bu mass, with constr.
1123  createHisto("mfitTIBu", 100, 5.00, 6.00); // Bu mass, with constr.
1124  createHisto("mfitDDBu", 100, 5.00, 6.00); // Bu mass, with constr.
1125  createHisto("mfitTDBu", 100, 5.00, 6.00); // Bu mass, with constr.
1126  createHisto("mfitDIBd", 100, 5.00, 6.00); // Bd mass, with constr.
1127  createHisto("mfitTIBd", 100, 5.00, 6.00); // Bd mass, with constr.
1128  createHisto("mfitDDBd", 100, 5.00, 6.00); // Bd mass, with constr.
1129  createHisto("mfitTDBd", 100, 5.00, 6.00); // Bd mass, with constr.
1130  createHisto("mfitDIBs", 100, 5.00, 6.00); // Bs mass, with constr.
1131  createHisto("mfitTIBs", 100, 5.00, 6.00); // Bs mass, with constr.
1132  createHisto("mfitDDBs", 100, 5.00, 6.00); // Bs mass, with constr.
1133  createHisto("mfitTDBs", 100, 5.00, 6.00); // Bs mass, with constr.
1134  createHisto("mfitDIBc", 100, 6.00, 7.00); // Bc mass, with constr.
1135  createHisto("mfitTIBc", 100, 6.00, 7.00); // Bc mass, with constr.
1136  createHisto("mfitDDBc", 100, 6.00, 7.00); // Bc mass, with constr.
1137  createHisto("mfitTDBc", 100, 6.00, 7.00); // Bc mass, with constr.
1138  createHisto("mfitDIX3872", 40, 3.60, 4.00); // X3872 mass, with constr.
1139  createHisto("mfitTIX3872", 40, 3.60, 4.00); // X3872 mass, with constr.
1140  createHisto("mfitDDX3872", 40, 3.60, 4.00); // X3872 mass, with constr.
1141  createHisto("mfitTDX3872", 40, 3.60, 4.00); // X3872 mass, with constr.
1142  createHisto("massDIBuJPsi", 35, 2.95, 3.30); // JPsi mass in Bu decay
1143  createHisto("massTIBuJPsi", 35, 2.95, 3.30); // JPsi mass in Bu decay
1144  createHisto("massDDBuJPsi", 35, 2.95, 3.30); // JPsi mass in Bu decay
1145  createHisto("massTDBuJPsi", 35, 2.95, 3.30); // JPsi mass in Bu decay
1146  createHisto("massDIBdJPsi", 35, 2.95, 3.30); // JPsi mass in Bd decay
1147  createHisto("massTIBdJPsi", 35, 2.95, 3.30); // JPsi mass in Bd decay
1148  createHisto("massDDBdJPsi", 35, 2.95, 3.30); // JPsi mass in Bd decay
1149  createHisto("massTDBdJPsi", 35, 2.95, 3.30); // JPsi mass in Bd decay
1150  createHisto("massDIBdKx0", 50, 0.80, 1.05); // Kx0 mass in Bd decay
1151  createHisto("massTIBdKx0", 50, 0.80, 1.05); // Kx0 mass in Bd decay
1152  createHisto("massDDBdKx0", 50, 0.80, 1.05); // Kx0 mass in Bd decay
1153  createHisto("massTDBdKx0", 50, 0.80, 1.05); // Kx0 mass in Bd decay
1154  createHisto("massDIBsJPsi", 35, 2.95, 3.30); // JPsi mass in Bs decay
1155  createHisto("massTIBsJPsi", 35, 2.95, 3.30); // JPsi mass in Bs decay
1156  createHisto("massDDBsJPsi", 35, 2.95, 3.30); // JPsi mass in Bs decay
1157  createHisto("massTDBsJPsi", 35, 2.95, 3.30); // JPsi mass in Bs decay
1158  createHisto("massDIBsPhi", 50, 1.01, 1.03); // Phi mass in Bs decay
1159  createHisto("massTIBsPhi", 50, 1.01, 1.03); // Phi mass in Bs decay
1160  createHisto("massDDBsPhi", 50, 1.01, 1.03); // Phi mass in Bs decay
1161  createHisto("massTDBsPhi", 50, 1.01, 1.03); // Phi mass in Bs decay
1162  createHisto("massDIBcJPsi", 35, 2.95, 3.30); // JPsi mass in Bc decay
1163  createHisto("massTIBcJPsi", 35, 2.95, 3.30); // JPsi mass in Bc decay
1164  createHisto("massDDBcJPsi", 35, 2.95, 3.30); // JPsi mass in Bc decay
1165  createHisto("massTDBcJPsi", 35, 2.95, 3.30); // JPsi mass in Bc decay
1166  createHisto("massDIX3JPsi", 35, 2.95, 3.30); // JPsi mass in X3872 decay
1167  createHisto("massTIX3JPsi", 35, 2.95, 3.30); // JPsi mass in X3872 decay
1168  createHisto("massDDX3JPsi", 35, 2.95, 3.30); // JPsi mass in X3872 decay
1169  createHisto("massTDX3JPsi", 35, 2.95, 3.30); // JPsi mass in X3872 decay
1170  createHisto("massDK0s", 50, 0.40, 0.60); // K0s mass
1171  createHisto("mfitDK0s", 50, 0.40, 0.60); // K0s mass
1172  createHisto("massDLambda0", 60, 1.00, 1.30); // Lambda0 mass
1173  createHisto("mfitDLambda0", 60, 1.00, 1.30); // Lambda0 mass
1174  createHisto("massDIB0", 50, 5.00, 6.00); // B0 mass inclusive
1175  createHisto("massTIB0", 50, 5.00, 6.00); // B0 mass inclusive
1176  createHisto("massDDB0", 50, 5.00, 6.00); // B0 mass displaced
1177  createHisto("massTDB0", 50, 5.00, 6.00); // B0 mass displaced
1178  createHisto("mfitDIB0", 50, 5.00, 6.00); // B0 mass, with constr.
1179  createHisto("mfitTIB0", 50, 5.00, 6.00); // B0 mass, with constr.
1180  createHisto("mfitDDB0", 50, 5.00, 6.00); // B0 mass, with constr.
1181  createHisto("mfitTDB0", 50, 5.00, 6.00); // B0 mass, with constr.
1182  createHisto("massDIB0JPsi", 35, 2.95, 3.30); // JPsi mass in B0 decay
1183  createHisto("massTIB0JPsi", 35, 2.95, 3.30); // JPsi mass in B0 decay
1184  createHisto("massDDB0JPsi", 35, 2.95, 3.30); // JPsi mass in B0 decay
1185  createHisto("massTDB0JPsi", 35, 2.95, 3.30); // JPsi mass in B0 decay
1186  createHisto("massDIB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1187  createHisto("massTIB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1188  createHisto("massDDB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1189  createHisto("massTDB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1190  createHisto("mfitDIB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1191  createHisto("mfitTIB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1192  createHisto("mfitDDB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1193  createHisto("mfitTDB0K0s", 50, 0.40, 0.60); // K0s mass in B0 decay
1194  createHisto("massDILambdab", 25, 5.00, 6.00); // Lambdab mass inclusive
1195  createHisto("massTILambdab", 25, 5.00, 6.00); // Lambdab mass inclusive
1196  createHisto("massDDLambdab", 25, 5.00, 6.00); // Lambdab mass displaced
1197  createHisto("massTDLambdab", 25, 5.00, 6.00); // Lambdab mass displaced
1198  createHisto("mfitDILambdab", 25, 5.00, 6.00); // Lambdab mass, with constr.
1199  createHisto("mfitTILambdab", 25, 5.00, 6.00); // Lambdab mass, with constr.
1200  createHisto("mfitDDLambdab", 25, 5.00, 6.00); // Lambdab mass, with constr.
1201  createHisto("mfitTDLambdab", 25, 5.00, 6.00); // Lambdab mass, with constr.
1202  createHisto("massDILbJPsi", 35, 2.95, 3.30); // JPsi mass in Lambdab decay
1203  createHisto("massTILbJPsi", 35, 2.95, 3.30); // JPsi mass in Lambdab decay
1204  createHisto("massDDLbJPsi", 35, 2.95, 3.30); // JPsi mass in Lambdab decay
1205  createHisto("massTDLbJPsi", 35, 2.95, 3.30); // JPsi mass in Lambdab decay
1206  createHisto("massDILbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1207  createHisto("massTILbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1208  createHisto("massDDLbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1209  createHisto("massTDLbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1210  createHisto("mfitDILbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1211  createHisto("mfitTILbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1212  createHisto("mfitDDLbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1213  createHisto("mfitTDLbL0", 60, 1.00, 1.30); // L0 mass in Lambdab decay
1214 
1215  createHisto("massFull", 200, 2.00, 12.0); // Full onia mass
1216 
1217  createHisto("ctauDIJPsi", 60, -0.05, 0.25); // JPsi ctau inclusive
1218  createHisto("ctauTIJPsi", 60, -0.05, 0.25); // JPsi ctau inclusive
1219  createHisto("ctauDBJPsi", 60, -0.05, 0.25); // JPsi ctau barrel
1220  createHisto("ctauTBJPsi", 60, -0.05, 0.25); // JPsi ctau barrel
1221  createHisto("ctauDIBu", 60, -0.05, 0.25); // Bu ctau inclusive
1222  createHisto("ctauTIBu", 60, -0.05, 0.25); // Bu ctau inclusive
1223  createHisto("ctauDDBu", 60, -0.05, 0.25); // Bu ctau displaced
1224  createHisto("ctauTDBu", 60, -0.05, 0.25); // Bu ctau displaced
1225  createHisto("ctauDIBd", 60, -0.05, 0.25); // Bd ctau inclusive
1226  createHisto("ctauTIBd", 60, -0.05, 0.25); // Bd ctau inclusive
1227  createHisto("ctauDDBd", 60, -0.05, 0.25); // Bd ctau displaced
1228  createHisto("ctauTDBd", 60, -0.05, 0.25); // Bd ctau displaced
1229  createHisto("ctauDIBs", 60, -0.05, 0.25); // Bs ctau inclusive
1230  createHisto("ctauTIBs", 60, -0.05, 0.25); // Bs ctau inclusive
1231  createHisto("ctauDDBs", 60, -0.05, 0.25); // Bs ctau displaced
1232  createHisto("ctauTDBs", 60, -0.05, 0.25); // Bs ctau displaced
1233  createHisto("ctauDIB0", 60, -0.05, 0.25); // B0 ctau inclusive
1234  createHisto("ctauTIB0", 60, -0.05, 0.25); // B0 ctau inclusive
1235  createHisto("ctauDDB0", 60, -0.05, 0.25); // B0 ctau displaced
1236  createHisto("ctauTDB0", 60, -0.05, 0.25); // B0 ctau displaced
1237  createHisto("ctauDILambdab", 60, -0.05, 0.25); // Lambdab ctau inclusive
1238  createHisto("ctauTILambdab", 60, -0.05, 0.25); // Lambdab ctau inclusive
1239  createHisto("ctauDDLambdab", 60, -0.05, 0.25); // Lambdab ctau displaced
1240  createHisto("ctauTDLambdab", 60, -0.05, 0.25); // Lambdab ctau displaced
1241 
1242  recoName = new string;
1243  tree = fs->make<TTree>("BPHReco", "BPHReco");
1244  b_runNumber = tree->Branch("runNumber", &runNumber, "runNumber/i");
1245  b_lumiSection = tree->Branch("lumiSection", &lumiSection, "lumiSection/i");
1246  b_eventNumber = tree->Branch("eventNumber", &eventNumber, "eventNumber/i");
1247  b_recoName = tree->Branch("recoName", &recoName, 8192, 99);
1248  b_recoMass = tree->Branch("recoMass", &recoMass, "recoMass/F");
1249  b_recoTime = tree->Branch("recoTime", &recoTime, "recoTime/F");
1250  b_recoErrT = tree->Branch("recoErrT", &recoErrT, "recoErrT/F");
1251 
1252  return;
1253 }
1254 
1255 void BPHHistoSpecificDecay::analyze(const edm::Event& ev, const edm::EventSetup& es) {
1256  // if ( ev.id().run () != 316239 ) return;
1257  // if ( ev.id().event() != 170736782 ) return;
1258  static map<string, ofstream*> ofMap;
1259  if (ofMap.empty()) {
1260  ofMap["BarPhi"] = nullptr;
1261  ofMap["IncJPsi"] = nullptr;
1262  ofMap["BarJPsi"] = nullptr;
1263  ofMap["IncPsi2"] = nullptr;
1264  ofMap["BarPsi2"] = nullptr;
1265  ofMap["BarUpsilon123"] = nullptr;
1266  ofMap["InclusiveBu"] = nullptr;
1267  ofMap["DisplacedBu"] = nullptr;
1268  ofMap["InclusiveBd"] = nullptr;
1269  ofMap["DisplacedBd"] = nullptr;
1270  ofMap["InclusiveBs"] = nullptr;
1271  ofMap["DisplacedBs"] = nullptr;
1272  ofMap["K0s"] = nullptr;
1273  ofMap["Lambda0"] = nullptr;
1274  ofMap["InclusiveB0"] = nullptr;
1275  ofMap["DisplacedB0"] = nullptr;
1276  ofMap["InclusiveLambdab"] = nullptr;
1277  ofMap["DisplacedLambdab"] = nullptr;
1278  ofMap["InclusiveBc"] = nullptr;
1279  ofMap["DisplacedBc"] = nullptr;
1280  ofMap["InclusiveX3872"] = nullptr;
1281  ofMap["DisplacedX3872"] = nullptr;
1282  map<string, ofstream*>::iterator iter = ofMap.begin();
1283  map<string, ofstream*>::iterator iend = ofMap.end();
1284  string name = "list";
1285  while (iter != iend) {
1286  iter->second = new ofstream(name + iter->first);
1287  ++iter;
1288  }
1289  }
1290 
1291  // event number
1292  runNumber = ev.id().run();
1293  lumiSection = ev.id().luminosityBlock();
1294  eventNumber = ev.id().event();
1295 
1296  // get object collections
1297  // collections are got through "BPHTokenWrapper" interface to allow
1298  // uniform access in different CMSSW versions
1299 
1301 
1302  edm::Handle<edm::TriggerResults> trigResults;
1303  const edm::TriggerNames* trigNames = nullptr;
1304  if (useTrig) {
1305  trigResultsToken.get(ev, trigResults);
1306  if (trigResults.isValid())
1307  trigNames = &ev.triggerNames(*trigResults);
1308  }
1309 
1310  bool flag_Dimuon25_Jpsi = false;
1311  bool flag_Dimuon20_Jpsi_Barrel_Seagulls = false;
1312  bool flag_Dimuon14_Phi_Barrel_Seagulls = false;
1313  bool flag_Dimuon18_PsiPrime = false;
1314  bool flag_Dimuon10_PsiPrime_Barrel_Seagulls = false;
1315  bool flag_Dimuon12_Upsilon_eta1p5 = false;
1316  bool flag_Dimuon12_Upsilon_y1p4 = false;
1317  bool flag_DoubleMu4_JpsiTrk_Displaced = false;
1318  if (trigNames != nullptr) {
1319  const edm::TriggerNames::Strings& names = trigNames->triggerNames();
1320  int iObj;
1321  int nObj = names.size();
1322  for (iObj = 0; iObj < nObj; ++iObj) {
1323  // cout << names[iObj] << endl;
1324  CHK_TRIG(trigResults, names, iObj, Dimuon25_Jpsi)
1325  CHK_TRIG(trigResults, names, iObj, Dimuon20_Jpsi_Barrel_Seagulls)
1326  CHK_TRIG(trigResults, names, iObj, Dimuon14_Phi_Barrel_Seagulls)
1327  CHK_TRIG(trigResults, names, iObj, Dimuon18_PsiPrime)
1328  CHK_TRIG(trigResults, names, iObj, Dimuon10_PsiPrime_Barrel_Seagulls)
1329  CHK_TRIG(trigResults, names, iObj, Dimuon12_Upsilon_eta1p5)
1330  CHK_TRIG(trigResults, names, iObj, Dimuon12_Upsilon_y1p4)
1331  CHK_TRIG(trigResults, names, iObj, DoubleMu4_JpsiTrk_Displaced)
1332  }
1333  }
1334 
1335  // cout << "Dimuon25_Jpsi "
1336  // << ( flag_Dimuon25_Jpsi ? 'A' : 'R' ) << endl;
1337  // cout << "Dimuon20_Jpsi_Barrel_Seagulls "
1338  // << ( flag_Dimuon20_Jpsi_Barrel_Seagulls ? 'A' : 'R' ) << endl;
1339  // cout << "Dimuon14_Phi_Barrel_Seagulls "
1340  // << ( flag_Dimuon14_Phi_Barrel_Seagulls ? 'A' : 'R' ) << endl;
1341  // cout << "Dimuon18_PsiPrime "
1342  // << ( flag_Dimuon18_PsiPrime ? 'A' : 'R' ) << endl;
1343  // cout << "Dimuon10_PsiPrime_Barrel_Seagulls "
1344  // << ( flag_Dimuon10_PsiPrime_Barrel_Seagulls ? 'A' : 'R' ) << endl;
1345  // cout << "Dimuon12_Upsilon_eta1p5 "
1346  // << ( flag_Dimuon12_Upsilon_eta1p5 ? 'A' : 'R' ) << endl;
1347  // cout << "DoubleMu4_JpsiTrk_Displaced "
1348  // << ( flag_DoubleMu4_JpsiTrk_Displaced ? 'A' : 'R' ) << endl;
1349 
1351 
1352  edm::Handle<vector<pat::CompositeCandidate>> oniaCands;
1353  int iqo;
1354  int nqo = 0;
1355  if (useOnia) {
1356  oniaCandsToken.get(ev, oniaCands);
1357  nqo = oniaCands->size();
1358  }
1359 
1360  for (iqo = 0; iqo < nqo; ++iqo) {
1361  LogTrace("DataDump") << "*********** quarkonium " << iqo << "/" << nqo << " ***********";
1362  const pat::CompositeCandidate& cand = oniaCands->at(iqo);
1363  if (!oniaVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex")))
1364  continue;
1365  if (!oniaDaughterSelect->accept(cand))
1366  continue;
1367  fillHisto("Full", cand, 'c');
1368  if (phiBBasicSelect->accept(cand)) {
1369  fillHisto("DBPhi", cand, 'c');
1370  if (flag_Dimuon14_Phi_Barrel_Seagulls)
1371  fillHisto("TBPhi", cand, 'c');
1372  if (flag_Dimuon14_Phi_Barrel_Seagulls)
1373  *ofMap["BarPhi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1374  << cand.mass() << endl;
1375  }
1376  if (jPsiIBasicSelect->accept(cand)) {
1377  fillHisto("DIJPsi", cand, 'c');
1378  if (flag_Dimuon25_Jpsi)
1379  fillHisto("TIJPsi", cand, 'c');
1380  if (flag_Dimuon25_Jpsi)
1381  *ofMap["IncJPsi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1382  << cand.mass() << endl;
1383  }
1384  if (jPsiBBasicSelect->accept(cand)) {
1385  fillHisto("DBJPsi", cand, 'c');
1386  if (flag_Dimuon20_Jpsi_Barrel_Seagulls)
1387  fillHisto("TBJPsi", cand, 'c');
1388  if (flag_Dimuon20_Jpsi_Barrel_Seagulls)
1389  *ofMap["BarJPsi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1390  << cand.mass() << endl;
1391  }
1392  if (psi2IBasicSelect->accept(cand)) {
1393  fillHisto("DIPsi2", cand, 'c');
1394  if (flag_Dimuon18_PsiPrime)
1395  fillHisto("TIPsi2", cand, 'c');
1396  if (flag_Dimuon18_PsiPrime)
1397  *ofMap["IncPsi2"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1398  << cand.mass() << endl;
1399  }
1400  if (psi2BBasicSelect->accept(cand)) {
1401  fillHisto("DBPsi2", cand, 'c');
1402  if (flag_Dimuon10_PsiPrime_Barrel_Seagulls)
1403  fillHisto("TBPsi2", cand, 'c');
1404  if (flag_Dimuon10_PsiPrime_Barrel_Seagulls)
1405  *ofMap["BarPsi2"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1406  << cand.mass() << endl;
1407  }
1408  if (upsBBasicSelect->accept(cand)) {
1409  fillHisto("DBUps123", cand, 'c');
1410  if (flag_Dimuon12_Upsilon_eta1p5 || flag_Dimuon12_Upsilon_y1p4)
1411  fillHisto("TBUps123", cand, 'c');
1412  if (flag_Dimuon12_Upsilon_eta1p5 || flag_Dimuon12_Upsilon_y1p4)
1413  *ofMap["BarUpsilon123"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1414  << cand.mass() << endl;
1415  }
1416  }
1417 
1419 
1420  edm::Handle<vector<pat::CompositeCandidate>> buCands;
1421  int ibu;
1422  int nbu = 0;
1423  if (useBu) {
1424  buCandsToken.get(ev, buCands);
1425  nbu = buCands->size();
1426  }
1427 
1428  for (ibu = 0; ibu < nbu; ++ibu) {
1429  LogTrace("DataDump") << "*********** Bu " << ibu << "/" << nbu << " ***********";
1430  const pat::CompositeCandidate& cand = buCands->at(ibu);
1431  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1432  LogTrace("DataDump") << "JPsi: " << jPsi;
1433  if (jPsi == nullptr)
1434  continue;
1435  if (!npJPsiBasicSelect->accept(*jPsi))
1436  continue;
1437  if (!npJPsiDaughterSelect->accept(*jPsi))
1438  continue;
1439  const reco::Candidate* kptr = BPHDaughters::get(cand, 0.49, 0.50).front();
1440  if (kptr == nullptr)
1441  continue;
1442  if (buIBasicSelect->accept(cand) && buIJPsiBasicSelect->accept(*jPsi) &&
1443  // buIJPsiDaughterSelect->accept( *jPsi ) &&
1444  buIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1445  (kptr->pt() > buIKPtMin)) {
1446  fillHisto("DIBu", cand, 'f');
1447  fillHisto("DIBuJPsi", *jPsi, 'c');
1448  if (flag_Dimuon25_Jpsi) {
1449  fillHisto("TIBu", cand, 'f');
1450  fillHisto("TIBuJPsi", *jPsi, 'c');
1451  *ofMap["InclusiveBu"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1452  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1453  }
1454  }
1455  if (buDBasicSelect->accept(cand) && buDJPsiBasicSelect->accept(*jPsi) &&
1456  // buDJPsiDaughterSelect->accept( *jPsi ) &&
1457  buDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1458  (kptr->pt() > buDKPtMin)) {
1459  fillHisto("DDBu", cand, 'f');
1460  fillHisto("DDBuJPsi", *jPsi, 'c');
1461  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1462  fillHisto("TDBu", cand, 'f');
1463  fillHisto("TDBuJPsi", *jPsi, 'c');
1464  *ofMap["DisplacedBu"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1465  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1466  }
1467  }
1468  }
1469 
1471 
1472  edm::Handle<vector<pat::CompositeCandidate>> bdCands;
1473  int ibd;
1474  int nbd = 0;
1475  if (useBd) {
1476  bdCandsToken.get(ev, bdCands);
1477  nbd = bdCands->size();
1478  }
1479 
1480  for (ibd = 0; ibd < nbd; ++ibd) {
1481  LogTrace("DataDump") << "*********** Bd " << ibd << "/" << nbd << " ***********";
1482  const pat::CompositeCandidate& cand = bdCands->at(ibd);
1483  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1484  LogTrace("DataDump") << "JPsi: " << jPsi;
1485  if (jPsi == nullptr)
1486  continue;
1487  if (!npJPsiBasicSelect->accept(*jPsi))
1488  continue;
1489  if (!npJPsiDaughterSelect->accept(*jPsi))
1490  continue;
1491  const pat::CompositeCandidate* kx0 = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToKx0");
1492  LogTrace("DataDump") << "Kx0: " << kx0;
1493  if (kx0 == nullptr)
1494  continue;
1495  if (bdIBasicSelect->accept(cand) && bdIJPsiBasicSelect->accept(*jPsi) && bdIKx0BasicSelect->accept(*kx0) &&
1496  // bdIJPsiDaughterSelect->accept( *jPsi ) &&
1497  bdIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1498  fillHisto("DIBd", cand, 'f');
1499  fillHisto("DIBdJPsi", *jPsi, 'c');
1500  fillHisto("DIBdKx0", *kx0, 'c');
1501  if (flag_Dimuon25_Jpsi) {
1502  fillHisto("TIBd", cand, 'f');
1503  fillHisto("TIBdJPsi", *jPsi, 'c');
1504  fillHisto("TIBdKx0", *kx0, 'c');
1505  *ofMap["InclusiveBd"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1506  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1507  }
1508  }
1509  if (bdDBasicSelect->accept(cand) && bdDJPsiBasicSelect->accept(*jPsi) && bdDKx0BasicSelect->accept(*kx0) &&
1510  // bdDJPsiDaughterSelect->accept( *jPsi ) &&
1511  bdDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1512  fillHisto("DDBd", cand, 'f');
1513  fillHisto("DDBdJPsi", *jPsi, 'c');
1514  fillHisto("DDBdKx0", *kx0, 'c');
1515  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1516  fillHisto("TDBd", cand, 'f');
1517  fillHisto("TDBdJPsi", *jPsi, 'c');
1518  fillHisto("TDBdKx0", *kx0, 'c');
1519  *ofMap["DisplacedBd"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1520  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1521  }
1522  }
1523  }
1524 
1526 
1527  edm::Handle<vector<pat::CompositeCandidate>> bsCands;
1528  int ibs;
1529  int nbs = 0;
1530  if (useBs) {
1531  bsCandsToken.get(ev, bsCands);
1532  nbs = bsCands->size();
1533  }
1534 
1535  for (ibs = 0; ibs < nbs; ++ibs) {
1536  LogTrace("DataDump") << "*********** Bs " << ibs << "/" << nbs << " ***********";
1537  const pat::CompositeCandidate& cand = bsCands->at(ibs);
1538  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1539  LogTrace("DataDump") << "JPsi: " << jPsi;
1540  if (jPsi == nullptr)
1541  continue;
1542  if (!npJPsiBasicSelect->accept(*jPsi))
1543  continue;
1544  if (!npJPsiDaughterSelect->accept(*jPsi))
1545  continue;
1546  const pat::CompositeCandidate* phi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToPhi");
1547  LogTrace("DataDump") << "Phi: " << phi;
1548  if (phi == nullptr)
1549  continue;
1550  if (bsIBasicSelect->accept(cand) && bsIJPsiBasicSelect->accept(*jPsi) && bsIPhiBasicSelect->accept(*phi) &&
1551  // bsIJPsiDaughterSelect->accept( *jPsi ) &&
1552  bsIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1553  fillHisto("DIBs", cand, 'f');
1554  fillHisto("DIBsJPsi", *jPsi, 'c');
1555  fillHisto("DIBsPhi", *phi, 'c');
1556  if (flag_Dimuon25_Jpsi) {
1557  fillHisto("TIBs", cand, 'f');
1558  fillHisto("TIBsJPsi", *jPsi, 'c');
1559  fillHisto("TIBsPhi", *phi, 'c');
1560  *ofMap["InclusiveBs"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1561  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1562  }
1563  }
1564  if (bsDBasicSelect->accept(cand) && bsDJPsiBasicSelect->accept(*jPsi) && bsDPhiBasicSelect->accept(*phi) &&
1565  // bsDJPsiDaughterSelect->accept( *jPsi ) &&
1566  bsDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1567  fillHisto("DDBs", cand, 'f');
1568  fillHisto("DDBsJPsi", *jPsi, 'c');
1569  fillHisto("DDBsPhi", *phi, 'c');
1570  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1571  fillHisto("TDBs", cand, 'f');
1572  fillHisto("TDBsJPsi", *jPsi, 'c');
1573  fillHisto("TDBsPhi", *phi, 'c');
1574  *ofMap["DisplacedBs"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1575  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1576  }
1577  }
1578  }
1579 
1581 
1582  edm::Handle<vector<pat::CompositeCandidate>> k0Cands;
1583  int ik0;
1584  int nk0 = 0;
1585  if (useK0) {
1586  k0CandsToken.get(ev, k0Cands);
1587  nk0 = k0Cands->size();
1588  }
1589 
1590  for (ik0 = 0; ik0 < nk0; ++ik0) {
1591  LogTrace("DataDump") << "*********** K0 " << ik0 << "/" << nk0 << " ***********";
1592  const pat::CompositeCandidate& cand = k0Cands->at(ik0);
1593  fillHisto("DK0s", cand, 'f');
1594  *ofMap["K0s"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1595  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1596  }
1597 
1599 
1600  edm::Handle<vector<pat::CompositeCandidate>> l0Cands;
1601  int il0;
1602  int nl0 = 0;
1603  if (useL0) {
1604  l0CandsToken.get(ev, l0Cands);
1605  nl0 = l0Cands->size();
1606  }
1607 
1608  for (il0 = 0; il0 < nl0; ++il0) {
1609  LogTrace("DataDump") << "*********** Lambda0 " << il0 << "/" << nl0 << " ***********";
1610  const pat::CompositeCandidate& cand = l0Cands->at(il0);
1611  fillHisto("DLambda0", cand, 'f');
1612  *ofMap["Lambda0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1613  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1614  }
1615 
1617 
1618  edm::Handle<vector<pat::CompositeCandidate>> b0Cands;
1619  int ib0;
1620  int nb0 = 0;
1621  if (useB0) {
1622  b0CandsToken.get(ev, b0Cands);
1623  nb0 = b0Cands->size();
1624  }
1625 
1626  // cout << nb0 << ' ' << ev.id().run() << ' ' << ev.id().event();
1627  // if ( nb0 ) cout << " *************************";
1628  // cout << endl;
1629 
1630  for (ib0 = 0; ib0 < nb0; ++ib0) {
1631  LogTrace("DataDump") << "*********** B0 " << ib0 << "/" << nb0 << " ***********";
1632  const pat::CompositeCandidate& cand = b0Cands->at(ib0);
1633  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1634  LogTrace("DataDump") << "JPsi: " << jPsi;
1635  if (jPsi == nullptr)
1636  continue;
1637  if (!npJPsiBasicSelect->accept(*jPsi))
1638  continue;
1639  if (!npJPsiDaughterSelect->accept(*jPsi))
1640  continue;
1641  const pat::CompositeCandidate* k0s = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToK0s");
1642  LogTrace("DataDump") << "K0s: " << k0s;
1643  if (k0s == nullptr)
1644  continue;
1645  if (b0IBasicSelect->accept(cand) && b0IJPsiBasicSelect->accept(*jPsi) && b0IK0sBasicSelect->accept(*k0s) &&
1646  // b0IJPsiDaughterSelect->accept( *jPsi ) &&
1647  b0IVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1648  fillHisto("DIB0", cand, 'f');
1649  fillHisto("DIB0JPsi", *jPsi, 'c');
1650  fillHisto("DIB0K0s", *k0s, 'c');
1651  if (flag_Dimuon25_Jpsi) {
1652  fillHisto("TIB0", cand, 'f');
1653  fillHisto("TIB0JPsi", *jPsi, 'c');
1654  fillHisto("TIB0K0s", *k0s, 'c');
1655  *ofMap["InclusiveB0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1656  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1657  }
1658  }
1659  if (b0DBasicSelect->accept(cand) && b0DJPsiBasicSelect->accept(*jPsi) && b0DK0sBasicSelect->accept(*k0s) &&
1660  // b0DJPsiDaughterSelect->accept( *jPsi ) &&
1661  b0DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1662  fillHisto("DDB0", cand, 'f');
1663  fillHisto("DDB0JPsi", *jPsi, 'c');
1664  fillHisto("DDB0K0s", *k0s, 'c');
1665  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1666  fillHisto("TDB0", cand, 'f');
1667  fillHisto("TDB0JPsi", *jPsi, 'c');
1668  fillHisto("TDB0K0s", *k0s, 'c');
1669  *ofMap["DisplacedB0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1670  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1671  }
1672  }
1673  }
1674 
1676 
1677  edm::Handle<vector<pat::CompositeCandidate>> lbCands;
1678  int ilb;
1679  int nlb = 0;
1680  if (useLb) {
1681  lbCandsToken.get(ev, lbCands);
1682  nlb = lbCands->size();
1683  }
1684 
1685  for (ilb = 0; ilb < nlb; ++ilb) {
1686  LogTrace("DataDump") << "*********** Lambdab " << ilb << "/" << nlb << " ***********";
1687  const pat::CompositeCandidate& cand = lbCands->at(ilb);
1688  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1689  LogTrace("DataDump") << "JPsi: " << jPsi;
1690  if (jPsi == nullptr)
1691  continue;
1692  if (!npJPsiBasicSelect->accept(*jPsi))
1693  continue;
1694  if (!npJPsiDaughterSelect->accept(*jPsi))
1695  continue;
1696  const pat::CompositeCandidate* l0 = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToLambda0");
1697  LogTrace("DataDump") << "Lambda0: " << l0;
1698  if (l0 == nullptr)
1699  continue;
1700  if (lbIBasicSelect->accept(cand) && lbIJPsiBasicSelect->accept(*jPsi) && lbILambda0BasicSelect->accept(*l0) &&
1701  // lbIJPsiDaughterSelect->accept( *jPsi ) &&
1702  lbIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1703  fillHisto("DILambdab", cand, 'f');
1704  fillHisto("DILbJPsi", *jPsi, 'c');
1705  fillHisto("DILbL0", *l0, 'c');
1706  if (flag_Dimuon25_Jpsi) {
1707  fillHisto("TILambdab", cand, 'f');
1708  fillHisto("TILbJPsi", *jPsi, 'c');
1709  fillHisto("TILbL0", *l0, 'c');
1710  *ofMap["InclusiveLambdab"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1711  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1712  }
1713  }
1714  if (lbDBasicSelect->accept(cand) && lbDJPsiBasicSelect->accept(*jPsi) && lbDLambda0BasicSelect->accept(*l0) &&
1715  // lbDJPsiDaughterSelect->accept( *jPsi ) &&
1716  lbDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1717  fillHisto("DDLambdab", cand, 'f');
1718  fillHisto("DDLbJPsi", *jPsi, 'c');
1719  fillHisto("DDLbL0", *l0, 'c');
1720  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1721  fillHisto("TDLambdab", cand, 'f');
1722  fillHisto("TDLbJPsi", *jPsi, 'c');
1723  fillHisto("TDLbL0", *l0, 'c');
1724  *ofMap["DisplacedLambdab"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1725  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1726  }
1727  }
1728  }
1729 
1731 
1732  edm::Handle<vector<pat::CompositeCandidate>> bcCands;
1733  int ibc;
1734  int nbc = 0;
1735  if (useBc) {
1736  bcCandsToken.get(ev, bcCands);
1737  nbc = bcCands->size();
1738  }
1739 
1740  for (ibc = 0; ibc < nbc; ++ibc) {
1741  LogTrace("DataDump") << "*********** Bc " << ibc << "/" << nbc << " ***********";
1742  const pat::CompositeCandidate& cand = bcCands->at(ibc);
1743  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1744  LogTrace("DataDump") << "JPsi: " << jPsi;
1745  if (jPsi == nullptr)
1746  continue;
1747  // if ( BPHUserData::get( *jPsi, "dca", -1.0 ) < bcJPsiDcaMax ) continue;
1748  if (!npJPsiBasicSelect->accept(*jPsi))
1749  continue;
1750  if (!npJPsiDaughterSelect->accept(*jPsi))
1751  continue;
1752  const reco::Candidate* pptr = BPHDaughters::get(cand, 0.13, 0.14).front();
1753  if (pptr == nullptr)
1754  continue;
1755 
1756  if (bcIBasicSelect->accept(cand) && bcIJPsiBasicSelect->accept(*jPsi) &&
1757  // bcIJPsiDaughterSelect->accept( *jPsi ) &&
1758  bcIJPsiVertexSelect->accept(*jPsi, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1759  bcIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1760  (pptr->pt() > bcIPiPtMin)) {
1761  fillHisto("DIBc", cand, 'f');
1762  fillHisto("DIBcJPsi", *jPsi, 'c');
1763  if (flag_Dimuon25_Jpsi) {
1764  fillHisto("TIBc", cand, 'f');
1765  fillHisto("TIBcJPsi", *jPsi, 'c');
1766  *ofMap["InclusiveBc"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1767  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1768  }
1769  }
1770  if (bcDBasicSelect->accept(cand) && bcDJPsiBasicSelect->accept(*jPsi) &&
1771  // bcDJPsiDaughterSelect->accept( *jPsi ) &&
1772  bcDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1773  bcDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1774  (pptr->pt() > bcDPiPtMin)) {
1775  fillHisto("DDBc", cand, 'f');
1776  fillHisto("DDBcJPsi", *jPsi, 'c');
1777  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1778  fillHisto("TDBc", cand, 'f');
1779  fillHisto("TDBcJPsi", *jPsi, 'c');
1780  *ofMap["DisplacedBc"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1781  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1782  }
1783  }
1784  }
1785 
1787 
1788  edm::Handle<vector<pat::CompositeCandidate>> x3872Cands;
1789  int ix3872;
1790  int nx3872 = 0;
1791  if (useX3872) {
1792  x3872CandsToken.get(ev, x3872Cands);
1793  nx3872 = x3872Cands->size();
1794  }
1795 
1796  for (ix3872 = 0; ix3872 < nx3872; ++ix3872) {
1797  LogTrace("DataDump") << "*********** X3872 " << ix3872 << "/" << nx3872 << " ***********";
1798  const pat::CompositeCandidate& cand = x3872Cands->at(ix3872);
1799  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1800  LogTrace("DataDump") << "JPsi: " << jPsi;
1801  if (jPsi == nullptr)
1802  continue;
1803  // if ( BPHUserData::get( *jPsi, "dca", -1.0 ) < x3872JPsiDcaMax ) continue;
1804  if (!npJPsiBasicSelect->accept(*jPsi))
1805  continue;
1806  if (!npJPsiDaughterSelect->accept(*jPsi))
1807  continue;
1808  const reco::Candidate* ppt1 = BPHDaughters::get(cand, 0.13, 0.14)[0];
1809  const reco::Candidate* ppt2 = BPHDaughters::get(cand, 0.13, 0.14)[1];
1810  if (ppt1 == nullptr)
1811  continue;
1812  if (ppt2 == nullptr)
1813  continue;
1814  if (x3872IBasicSelect->accept(cand) && x3872IJPsiBasicSelect->accept(*jPsi) &&
1815  // x3872IJPsiDaughterSelect->accept( *jPsi ) &&
1816  x3872IJPsiVertexSelect->accept(*jPsi, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1817  x3872IVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1818  (ppt1->pt() > x3872IPiPtMin) && (ppt2->pt() > x3872IPiPtMin)) {
1819  fillHisto("DIX3872", cand, 'f');
1820  fillHisto("DIX3872JPsi", *jPsi, 'c');
1821  if (flag_Dimuon25_Jpsi) {
1822  fillHisto("TIX3872", cand, 'f');
1823  fillHisto("TIX3872JPsi", *jPsi, 'c');
1824  *ofMap["InclusiveX3872"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1825  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1826  }
1827  }
1828  if (x3872DBasicSelect->accept(cand) && x3872DJPsiBasicSelect->accept(*jPsi) &&
1829  // x3872DJPsiDaughterSelect->accept( *jPsi ) &&
1830  x3872DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1831  x3872DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1832  (ppt1->pt() > x3872DPiPtMin) && (ppt2->pt() > x3872DPiPtMin)) {
1833  fillHisto("DDX3872", cand, 'f');
1834  fillHisto("DDX3872JPsi", *jPsi, 'c');
1835  if (flag_DoubleMu4_JpsiTrk_Displaced) {
1836  fillHisto("TDX3872", cand, 'f');
1837  fillHisto("TDX3872JPsi", *jPsi, 'c');
1838  *ofMap["DisplacedX3872"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1839  << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1840  }
1841  }
1842  }
1843 
1844  return;
1845 }
1846 
1847 void BPHHistoSpecificDecay::endJob() {
1848  // tree->Write();
1849  return;
1850 }
1851 
1852 void BPHHistoSpecificDecay::fillHisto(const string& name, const pat::CompositeCandidate& cand, char svType) {
1853  *recoName = name;
1854  float mass = (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1);
1855  fillHisto("mass" + name, cand.mass());
1856  fillHisto("mfit" + name, mass);
1857  recoMass = mass;
1858  recoTime = -999999.0;
1859  recoErrT = -999999.0;
1860 
1861  const reco::Vertex* pvtx = BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex");
1862  if (pvtx == nullptr) {
1863  const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1864  if (jPsi == nullptr)
1865  return;
1866  pvtx = BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex");
1867  }
1868  // if ( pvtx == nullptr ) return;
1869 
1870  if (pvtx != nullptr) {
1871  const reco::Vertex* svtx = nullptr;
1872  if (svType == 'f')
1873  svtx = BPHUserData::get<reco::Vertex>(cand, "fitVertex");
1874  if (svtx == nullptr)
1875  svtx = BPHUserData::get<reco::Vertex>(cand, "vertex");
1876  // if ( svtx == nullptr ) return;
1877  if (svtx != nullptr) {
1878  float px;
1879  float py;
1880  const Vector3DBase<float, GlobalTag>* fmom =
1881  BPHUserData::get<Vector3DBase<float, GlobalTag>>(cand, "fitMomentum");
1882  if (fmom != nullptr) {
1883  px = fmom->x();
1884  py = fmom->y();
1885  } else {
1886  px = cand.px();
1887  py = cand.py();
1888  }
1889  double ctauPV2;
1890  double ctauErrPV2;
1891  VertexAnalysis::dist2D(pvtx, svtx, px, py, mass, ctauPV2, ctauErrPV2);
1892  recoTime = ctauPV2;
1893  recoErrT = ctauErrPV2;
1894  fillHisto("ctau" + name, ctauPV2);
1895  }
1896  }
1897  tree->Fill();
1898  return;
1899 }
1900 
1901 void BPHHistoSpecificDecay::fillHisto(const string& name, float x) {
1902  map<string, TH1F*>::iterator iter = histoMap.find(name);
1903  map<string, TH1F*>::iterator iend = histoMap.end();
1904  if (iter == iend)
1905  return;
1906  iter->second->Fill(x);
1907  return;
1908 }
1909 
1910 void BPHHistoSpecificDecay::createHisto(const string& name, int nbin, float hmin, float hmax) {
1911  histoMap[name] = fs->make<TH1F>(name.c_str(), name.c_str(), nbin, hmin, hmax);
1912  return;
1913 }
1914 
1915 #include "FWCore/Framework/interface/MakerMacros.h"
1916 
1917 DEFINE_FWK_MODULE(BPHHistoSpecificDecay);
pat::CompositeCandidate
Analysis-level particle class.
Definition: CompositeCandidate.h:31
CosmicsPD_Skims.maxZ
maxZ
Definition: CosmicsPD_Skims.py:136
BPHDaughterSelect::BPHDaughterSelect
BPHDaughterSelect(float ptMinLoose, float ptMinTight, float etaMaxLoose, float etaMaxTight, const BPHSoftMuonSelect *softMuonselector=nullptr)
Definition: BPHHistoSpecificDecay.cc:174
CHK_TRIG
#define CHK_TRIG(RESULTS, NAMES, INDEX, PATH)
Definition: BPHHistoSpecificDecay.cc:34
BPHDaughterSelect::accept
static bool accept(const pat::CompositeCandidate &cand, float ptMinLoose, float ptMinTight, float etaMaxLoose, float etaMaxTight, const reco::Vertex *pv=nullptr, const BPHSoftMuonSelect *softMuonselector=nullptr)
Definition: BPHHistoSpecificDecay.cc:184
BPHSoftMuonSelect::pv
const reco::Vertex * pv
Definition: BPHHistoSpecificDecay.cc:163
mps_fire.i
i
Definition: mps_fire.py:428
VertexAnalysis::dist2D
static void dist2D(const reco::Vertex *pvtx, const reco::Vertex *svtx, float px, float py, float mass, double &ctauPV, double &ctauErrPV)
Definition: BPHHistoSpecificDecay.cc:54
BPHHistoSpecificDecay::BPHHistoSpecificDecay
BPHHistoSpecificDecay(const edm::ParameterSet &ps)
Definition: BPHHistoSpecificDecay.cc:383
BPHCompositeBasicSelect::BPHCompositeBasicSelect
BPHCompositeBasicSelect(float massMin, float massMax, float ptMin=-1.0, float etaMax=-1.0, float rapidityMax=-1.0)
Definition: BPHHistoSpecificDecay.cc:231
recoSelectForWrite_cfi.probMin
probMin
Definition: recoSelectForWrite_cfi.py:8
VertexDistanceXY::distance
Measurement1D distance(const GlobalPoint &vtx1Position, const GlobalError &vtx1PositionError, const GlobalPoint &vtx2Position, const GlobalError &vtx2PositionError) const override
Definition: VertexDistanceXY.cc:19
BPHUserData::getByRef
static const T * getByRef(const pat::CompositeCandidate &cand, const string &name)
Definition: BPHHistoSpecificDecay.cc:99
recoSelectForWrite_cfi.massMin
massMin
Definition: recoSelectForWrite_cfi.py:6
edm::TriggerNames::Strings
std::vector< std::string > Strings
Definition: TriggerNames.h:58
reco::Candidate::pt
virtual double pt() const =0
transverse momentum
DEFINE_FWK_MODULE
#define DEFINE_FWK_MODULE(type)
Definition: MakerMacros.h:16
reco::Candidate::mass
virtual double mass() const =0
mass
ptMin
constexpr float ptMin
Definition: PhotonIDValueMapProducer.cc:155
VertexAnalysis::dist2D
static void dist2D(const reco::Vertex *pvtx, const reco::Vertex *svtx, float px, float py, double cosAlpha, float mass, double &ctauPV, double &ctauErrPV)
Definition: BPHHistoSpecificDecay.cc:64
HLT_2022v11_cff.eta1
eta1
Definition: HLT_2022v11_cff.py:12752
BPHFittedBasicSelect::accept
bool accept(const pat::CompositeCandidate &cand, const reco::Vertex *pv=nullptr) const override
Definition: BPHHistoSpecificDecay.cc:265
HLT_2022v11_cff.pt1
pt1
Definition: HLT_2022v11_cff.py:11716
BPHParticleMasses::jPsiMass
static const double jPsiMass
Definition: BPHParticleMasses.h:40
MillePedeFileConverter_cfg.e
e
Definition: MillePedeFileConverter_cfg.py:37
BPHParticleMasses::k0sMass
static const double k0sMass
Definition: BPHParticleMasses.h:36
reco::Vertex::ndof
double ndof() const
Definition: Vertex.h:123
type
type
Definition: SiPixelVCal_PayloadInspector.cc:39
accept
bool accept(const edm::Event &event, const edm::TriggerResults &triggerTable, const std::string &triggerPath)
Definition: TopDQMHelpers.h:31
names
const std::string names[nVars_]
Definition: PhotonIDValueMapProducer.cc:124
AlCaHLTBitMon_QueryRunRegistry.string
string string
Definition: AlCaHLTBitMon_QueryRunRegistry.py:256
LogTrace
#define LogTrace(id)
Definition: MessageLogger.h:234
beam_dqm_sourceclient-live_cfg.maxDz
maxDz
Definition: beam_dqm_sourceclient-live_cfg.py:151
reco::Vertex::error
Error error() const
return SMatrix
Definition: Vertex.h:163
BPHHistoSpecificDecay::analyze
void analyze(const edm::Event &ev, const edm::EventSetup &es) override
Definition: BPHHistoSpecificDecay.cc:1255
recoSelectForWrite_cfi.massMax
massMax
Definition: recoSelectForWrite_cfi.py:7
BPHParticleMasses::kx0Mass
static const double kx0Mass
Definition: BPHParticleMasses.h:38
ALCARECOPromptCalibProdSiPixelAli0T_cff.mode
mode
Definition: ALCARECOPromptCalibProdSiPixelAli0T_cff.py:96
BPHCompositeBasicSelect::accept
bool accept(const pat::CompositeCandidate &cand, const reco::Vertex *pv=nullptr) const override
Definition: BPHHistoSpecificDecay.cc:235
ALCARECOTkAlMinBias_cff.pMin
pMin
GeV.
Definition: ALCARECOTkAlMinBias_cff.py:35
mathSSE::sqrt
T sqrt(T t)
Definition: SSEVec.h:19
BPHHistoSpecificDecay::createHisto
void createHisto(const std::string &name, int nbin, float hmin, float hmax)
Definition: BPHHistoSpecificDecay.cc:1910
MetAnalyzer.pv
def pv(vc)
Definition: MetAnalyzer.py:7
reco::Vertex::Point
math::XYZPoint Point
point in the space
Definition: Vertex.h:40
ChiSquaredProbability
float ChiSquaredProbability(double chiSquared, double nrDOF)
Definition: ChiSquaredProbability.cc:13
GlobalErrorBase::matrix
const AlgebraicSymMatrix33 matrix() const
Definition: GlobalErrorBase.h:121
BPHFittedBasicSelect::BPHFittedBasicSelect
BPHFittedBasicSelect(float massMin, float massMax, float ptMin=-1.0, float etaMax=-1.0, float rapidityMax=-1.0)
Definition: BPHHistoSpecificDecay.cc:262
BPHHistoSpecificDecay::fillHisto
void fillHisto(const std::string &name, const pat::CompositeCandidate &cand, char svType)
reco::Vertex::x
double x() const
x coordinate
Definition: Vertex.h:129
ALCARECOTkAlBeamHalo_cff.etaMax
etaMax
Definition: ALCARECOTkAlBeamHalo_cff.py:33
ztail.d
d
Definition: ztail.py:151
reco::Vertex::y
double y() const
y coordinate
Definition: Vertex.h:131
muon::isGoodMuon
bool isGoodMuon(const reco::Muon &muon, SelectionType type, reco::Muon::ArbitrationType arbitrationType=reco::Muon::SegmentAndTrackArbitration)
main GoodMuon wrapper call
Definition: MuonSelectors.cc:649
EgHLTOffHistBins_cfi.mass
mass
Definition: EgHLTOffHistBins_cfi.py:34
gather_cfg.maxDxy
maxDxy
Definition: gather_cfg.py:53
BPHParticleMasses::lambda0Mass
static const double lambda0Mass
Definition: BPHParticleMasses.h:37
BPHParticleMasses::phiMass
static const double phiMass
Definition: BPHParticleMasses.h:39
VertexAnalysis::cAlpha
static double cAlpha(const reco::Vertex *pvtx, const reco::Vertex *svtx, float px, float py)
Definition: BPHHistoSpecificDecay.cc:45
trigNames
static const char *const trigNames[]
Definition: EcalDumpRaw.cc:57
BPHGenericVertexSelect::accept
bool accept(const pat::CompositeCandidate &cand, const reco::Vertex *pvtx) const override
Definition: BPHHistoSpecificDecay.cc:311
BPHGenericVertexSelect::BPHGenericVertexSelect
BPHGenericVertexSelect(char vType, float probMin, float cosMin=-2.0, float sigMin=-1.0, char dMode='r')
Definition: BPHHistoSpecificDecay.cc:308
cosmicPhotonAnalyzer_cfi.eMax
eMax
Definition: cosmicPhotonAnalyzer_cfi.py:10
edm::ConfigurationDescriptions::add
void add(std::string const &label, ParameterSetDescription const &psetDescription)
Definition: ConfigurationDescriptions.cc:57
multPhiCorr_741_25nsDY_cfi.py
py
Definition: multPhiCorr_741_25nsDY_cfi.py:12
edm::HandleBase::isValid
bool isValid() const
Definition: HandleBase.h:70
Measurement1D::value
double value() const
Definition: Measurement1D.h:25
multPhiCorr_741_25nsDY_cfi.px
px
Definition: multPhiCorr_741_25nsDY_cfi.py:10
reco::Vertex::chi2
double chi2() const
chi-squares
Definition: Vertex.h:116
multiplicitycorr_cfi.yMax
yMax
Definition: multiplicitycorr_cfi.py:6
AlgebraicVector3
ROOT::Math::SVector< double, 3 > AlgebraicVector3
Definition: AlgebraicROOTObjects.h:12
BPHSoftMuonSelect::BPHSoftMuonSelect
BPHSoftMuonSelect(int cutTrackerLayers=5, int cutPixelLayers=0, float maxDxy=0.3, float maxDz=20.0, bool goodMuon=true, bool highPurity=true)
Definition: BPHHistoSpecificDecay.cc:132
BPHDaughters::get
static vector< const reco::Candidate * > get(const pat::CompositeCandidate &cand, float massMin, float massMax)
Definition: BPHHistoSpecificDecay.cc:115
x
float x
Definition: beamSpotDipStandalone.cc:55
AlgebraicSymMatrix33
ROOT::Math::SMatrix< double, 3, 3, ROOT::Math::MatRepSym< double, 3 > > AlgebraicSymMatrix33
Definition: AlgebraicROOTObjects.h:21
tree
Definition: tree.py:1
BPHSoftMuonSelect::accept
bool accept(const reco::Candidate &cand, const reco::Vertex *pv) const
Definition: BPHHistoSpecificDecay.cc:140
T
long double T
Definition: Basic3DVectorLD.h:48
BPHHistoSpecificDecay::fillDescriptions
static void fillDescriptions(edm::ConfigurationDescriptions &descriptions)
Definition: BPHHistoSpecificDecay.cc:1066
BPHDaughterSelect::sms
const BPHSoftMuonSelect * sms
Definition: BPHHistoSpecificDecay.cc:226
pat::Muon
Analysis-level muon class.
Definition: Muon.h:51
VertexAnalysis::cAlpha
static double cAlpha(const reco::Vertex *pvtx, const reco::Vertex *svtx, const TVector3 &cmom)
Definition: BPHHistoSpecificDecay.cc:50
SET_LABEL
#define SET_LABEL(NAME, PSET)
Definition: BPHHistoSpecificDecay.cc:26
BPHDaughterSelect::accept
bool accept(const pat::CompositeCandidate &cand, const reco::Vertex *pv=nullptr) const override
Definition: BPHHistoSpecificDecay.cc:181
AlCaHLTBitMon_ParallelJobs.p
def p
Definition: AlCaHLTBitMon_ParallelJobs.py:153
reco::Candidate::eta
virtual double eta() const =0
momentum pseudorapidity
Skims_PA_cff.name
name
Definition: Skims_PA_cff.py:17
Generated for CMSSW Reference Manual by doxygen 1.8.14