File indexing completed on 2024-04-06 12:15:36
0001
0002 #include "HeavyFlavorAnalysis/SpecificDecay/plugins/BPHHistoSpecificDecay.h"
0003
0004 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"
0005
0006 #include "FWCore/Framework/interface/MakerMacros.h"
0007
0008 #include "DataFormats/PatCandidates/interface/Muon.h"
0009
0010 #include "FWCore/Common/interface/TriggerNames.h"
0011 #include "FWCore/Framework/interface/ESHandle.h"
0012 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0013
0014 #include "CommonTools/Statistics/interface/ChiSquaredProbability.h"
0015
0016 #include "RecoVertex/VertexTools/interface/VertexDistanceXY.h"
0017 #include "TMath.h"
0018 #include "Math/VectorUtil.h"
0019 #include "TVector3.h"
0020
0021 #include "TH1.h"
0022 #include "TTree.h"
0023 #include "TFile.h"
0024
0025 #include <set>
0026 #include <string>
0027 #include <iostream>
0028 #include <fstream>
0029 #include <cmath>
0030
0031 using namespace std;
0032
0033 #define SET_LABEL(NAME, PSET) (NAME = PSET.getParameter<string>(#NAME))
0034
0035
0036
0037
0038 #define CAT3(A, B, C) A##B##C
0039 #define STRING_NX(A) #A
0040 #define STRING(A) STRING_NX(A)
0041 #define CHK_TRIG(RESULTS, NAMES, INDEX, PATH) \
0042 if (NAMES[INDEX].find(STRING(CAT3(HLT_, PATH, _v))) == 0) { \
0043 flag_##PATH = RESULTS->accept(INDEX); \
0044 continue; \
0045 }
0046
0047
0048
0049
0050 class VertexAnalysis {
0051 public:
0052 static double cAlpha(const reco::Vertex* pvtx, const reco::Vertex* svtx, float px, float py) {
0053 TVector3 disp(svtx->x() - pvtx->x(), svtx->y() - pvtx->y(), 0);
0054 TVector3 cmom(px, py, 0);
0055 return disp.Dot(cmom) / (disp.Perp() * cmom.Perp());
0056 }
0057 static double cAlpha(const reco::Vertex* pvtx, const reco::Vertex* svtx, const TVector3& cmom) {
0058 TVector3 disp(svtx->x() - pvtx->x(), svtx->y() - pvtx->y(), 0);
0059 return disp.Dot(cmom) / (disp.Perp() * cmom.Perp());
0060 }
0061 static void dist2D(const reco::Vertex* pvtx,
0062 const reco::Vertex* svtx,
0063 float px,
0064 float py,
0065 float mass,
0066 double& ctauPV,
0067 double& ctauErrPV) {
0068 dist2D(pvtx, svtx, px, py, cAlpha(pvtx, svtx, px, py), mass, ctauPV, ctauErrPV);
0069 return;
0070 }
0071 static void dist2D(const reco::Vertex* pvtx,
0072 const reco::Vertex* svtx,
0073 float px,
0074 float py,
0075 double cosAlpha,
0076 float mass,
0077 double& ctauPV,
0078 double& ctauErrPV) {
0079 TVector3 cmom(px, py, 0);
0080 AlgebraicVector3 vmom(px, py, 0);
0081 VertexDistanceXY vdistXY;
0082 Measurement1D distXY = vdistXY.distance(*svtx, *pvtx);
0083 ctauPV = distXY.value() * cosAlpha * mass / cmom.Perp();
0084 GlobalError sve = svtx->error();
0085 GlobalError pve = pvtx->error();
0086 AlgebraicSymMatrix33 vXYe = sve.matrix() + pve.matrix();
0087 ctauErrPV = sqrt(ROOT::Math::Similarity(vmom, vXYe)) * mass / cmom.Perp2();
0088 return;
0089 }
0090 };
0091
0092 class BPHUserData {
0093 public:
0094 template <class T>
0095 static const T* get(const pat::CompositeCandidate& cand, const string& name) {
0096 if (cand.hasUserData(name))
0097 return cand.userData<T>(name);
0098 return nullptr;
0099 }
0100 static float get(const pat::CompositeCandidate& cand, const string& name, float d = 0.0) {
0101 if (cand.hasUserFloat(name))
0102 return cand.userFloat(name);
0103 return d;
0104 }
0105 template <class T>
0106 static const T* getByRef(const pat::CompositeCandidate& cand, const string& name) {
0107 if (cand.hasUserData(name)) {
0108 typedef edm::Ref<vector<T> > objRef;
0109 const objRef* ref = cand.userData<objRef>(name);
0110 if (ref == nullptr)
0111 return nullptr;
0112 if (ref->isNull())
0113 return nullptr;
0114 return ref->get();
0115 }
0116 return nullptr;
0117 }
0118 };
0119
0120 class BPHDaughters {
0121 public:
0122 static vector<const reco::Candidate*> get(const pat::CompositeCandidate& cand, float massMin, float massMax) {
0123 int i;
0124 int n = cand.numberOfDaughters();
0125 vector<const reco::Candidate*> v;
0126 v.reserve(n);
0127 for (i = 0; i < n; ++i) {
0128 const reco::Candidate* dptr = cand.daughter(i);
0129 float mass = dptr->mass();
0130 if ((mass > massMin) && (mass < massMax))
0131 v.push_back(dptr);
0132 }
0133 return v;
0134 }
0135 };
0136
0137 class BPHSoftMuonSelect {
0138 public:
0139 BPHSoftMuonSelect(int cutTrackerLayers = 5,
0140 int cutPixelLayers = 0,
0141 float maxDxy = 0.3,
0142 float maxDz = 20.0,
0143 bool goodMuon = true,
0144 bool highPurity = true)
0145 : cutTL(cutTrackerLayers), cutPL(cutPixelLayers), maxXY(maxDxy), maxZ(maxDz), gM(goodMuon), hP(highPurity) {}
0146 ~BPHSoftMuonSelect() = default;
0147 bool accept(const reco::Candidate& cand, const reco::Vertex* pv) const {
0148 const pat::Muon* p = dynamic_cast<const pat::Muon*>(&cand);
0149 if (p == nullptr)
0150 return false;
0151 if (gM && !muon::isGoodMuon(*p, muon::TMOneStationTight))
0152 return false;
0153 if (p->innerTrack()->hitPattern().trackerLayersWithMeasurement() <= cutTL)
0154 return false;
0155 if (p->innerTrack()->hitPattern().pixelLayersWithMeasurement() <= cutPL)
0156 return false;
0157 if (hP && !p->innerTrack()->quality(reco::TrackBase::highPurity))
0158 return false;
0159 if (pv == nullptr)
0160 return true;
0161 const reco::Vertex::Point& pos = pv->position();
0162 if (fabs(p->innerTrack()->dxy(pos)) >= maxXY)
0163 return false;
0164 if (fabs(p->innerTrack()->dz(pos)) >= maxZ)
0165 return false;
0166 return true;
0167 }
0168
0169 private:
0170 const reco::Vertex* pv;
0171 int cutTL;
0172 int cutPL;
0173 float maxXY;
0174 float maxZ;
0175 bool gM;
0176 bool hP;
0177 };
0178
0179 class BPHDaughterSelect : public BPHHistoSpecificDecay::CandidateSelect {
0180 public:
0181 BPHDaughterSelect(float ptMinLoose,
0182 float ptMinTight,
0183 float etaMaxLoose,
0184 float etaMaxTight,
0185 const BPHSoftMuonSelect* softMuonselector = nullptr)
0186 : pLMin(ptMinLoose), pTMin(ptMinTight), eLMax(etaMaxLoose), eTMax(etaMaxTight), sms(softMuonselector) {}
0187 ~BPHDaughterSelect() override = default;
0188 bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
0189 return accept(cand, pLMin, pTMin, eLMax, eTMax, pv, sms);
0190 }
0191 static bool accept(const pat::CompositeCandidate& cand,
0192 float ptMinLoose,
0193 float ptMinTight,
0194 float etaMaxLoose,
0195 float etaMaxTight,
0196 const reco::Vertex* pv = nullptr,
0197 const BPHSoftMuonSelect* softMuonselector = nullptr) {
0198 const reco::Candidate* dptr0 = cand.daughter(0);
0199 const reco::Candidate* dptr1 = cand.daughter(1);
0200 if (dptr0 == nullptr)
0201 return false;
0202 if (dptr1 == nullptr)
0203 return false;
0204 float pt0 = dptr0->pt();
0205 float pt1 = dptr1->pt();
0206 if ((pt0 < ptMinLoose) || (pt1 < ptMinLoose))
0207 return false;
0208 if ((pt0 < ptMinTight) && (pt1 < ptMinTight))
0209 return false;
0210 float eta0 = fabs(dptr0->eta());
0211 float eta1 = fabs(dptr1->eta());
0212 if ((etaMaxLoose > 0) && ((eta0 > etaMaxLoose) || (eta1 > etaMaxLoose)))
0213 return false;
0214 if ((etaMaxTight > 0) && ((eta0 > etaMaxTight) && (eta1 > etaMaxTight)))
0215 return false;
0216 if (softMuonselector != nullptr) {
0217 const reco::Vertex* pvtx = BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex");
0218 if (pvtx == nullptr)
0219 return false;
0220 if (!softMuonselector->accept(*dptr0, pvtx))
0221 return false;
0222 if (!softMuonselector->accept(*dptr1, pvtx))
0223 return false;
0224 }
0225 return true;
0226 }
0227
0228 private:
0229 float pLMin;
0230 float pTMin;
0231 float eLMax;
0232 float eTMax;
0233 const BPHSoftMuonSelect* sms;
0234 };
0235
0236 class BPHCompositeBasicSelect : public BPHHistoSpecificDecay::CandidateSelect {
0237 public:
0238 BPHCompositeBasicSelect(
0239 float massMin, float massMax, float ptMin = -1.0, float etaMax = -1.0, float rapidityMax = -1.0)
0240 : mMin(massMin), mMax(massMax), pMin(ptMin), eMax(etaMax), yMax(rapidityMax) {}
0241 ~BPHCompositeBasicSelect() override = default;
0242 bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
0243 if (((mMin > 0) && (mMax < 0)) || ((mMin < 0) && (mMax > 0)) || ((mMin > 0) && (mMax > 0) && (mMin < mMax))) {
0244 float mass = cand.mass();
0245 if (mass < mMin)
0246 return false;
0247 if ((mMax > 0) && (mass > mMax))
0248 return false;
0249 }
0250 if (cand.pt() < pMin)
0251 return false;
0252 if ((eMax > 0) && (fabs(cand.eta()) > eMax))
0253 return false;
0254 if ((yMax > 0) && (fabs(cand.rapidity()) > yMax))
0255 return false;
0256 return true;
0257 }
0258
0259 private:
0260 float mMin;
0261 float mMax;
0262 float pMin;
0263 float eMax;
0264 float yMax;
0265 };
0266
0267 class BPHFittedBasicSelect : public BPHHistoSpecificDecay::CandidateSelect {
0268 public:
0269 BPHFittedBasicSelect(float massMin, float massMax, float ptMin = -1.0, float etaMax = -1.0, float rapidityMax = -1.0)
0270 : mMin(massMin), mMax(massMax), pMin(ptMin), eMax(etaMax), yMax(rapidityMax) {}
0271 ~BPHFittedBasicSelect() override = default;
0272 bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pv = nullptr) const override {
0273 if (!cand.hasUserFloat("fitMass"))
0274 return false;
0275 float mass = cand.userFloat("fitMass");
0276 if (((mMin > 0) && (mMax < 0)) || ((mMin < 0) && (mMax > 0)) || ((mMin > 0) && (mMax > 0) && (mMin < mMax))) {
0277 if (mass < mMin)
0278 return false;
0279 if ((mMax > 0) && (mass > mMax))
0280 return false;
0281 }
0282 const Vector3DBase<float, GlobalTag>* fmom = BPHUserData::get<Vector3DBase<float, GlobalTag> >(cand, "fitMomentum");
0283 if (fmom == nullptr)
0284 return false;
0285 if (pMin > 0) {
0286 if (fmom->transverse() < pMin)
0287 return false;
0288 }
0289 if (eMax > 0) {
0290 if (fabs(fmom->eta()) > eMax)
0291 return false;
0292 }
0293 if (yMax > 0) {
0294 float x = fmom->x();
0295 float y = fmom->y();
0296 float z = fmom->z();
0297 float e = sqrt((x * x) + (y * y) + (z * z) + (mass * mass));
0298 float r = log((e + z) / (e - z)) / 2;
0299 if (fabs(r) > yMax)
0300 return false;
0301 }
0302 return true;
0303 }
0304
0305 private:
0306 float mMin;
0307 float mMax;
0308 float pMin;
0309 float eMax;
0310 float yMax;
0311 };
0312
0313 class BPHGenericVertexSelect : public BPHHistoSpecificDecay::CandidateSelect {
0314 public:
0315 BPHGenericVertexSelect(char vType, float probMin, float cosMin = -2.0, float sigMin = -1.0, char dMode = 'r')
0316 : type(vType), pMin(probMin), cMin(cosMin), sMin(sigMin), mode(dMode) {}
0317 ~BPHGenericVertexSelect() override = default;
0318 bool accept(const pat::CompositeCandidate& cand, const reco::Vertex* pvtx) const override {
0319 if (pvtx == nullptr)
0320 return false;
0321 const reco::Vertex* svtx = nullptr;
0322 float px;
0323 float py;
0324 float mass;
0325 switch (type) {
0326 case 'c':
0327 svtx = BPHUserData::get<reco::Vertex>(cand, "vertex");
0328 px = cand.px();
0329 py = cand.py();
0330 mass = cand.mass();
0331 break;
0332 case 'f':
0333 svtx = BPHUserData::get<reco::Vertex>(cand, "fitVertex");
0334 {
0335 const Vector3DBase<float, GlobalTag>* fmom =
0336 BPHUserData::get<Vector3DBase<float, GlobalTag> >(cand, "fitMomentum");
0337 if (fmom == nullptr)
0338 return false;
0339 px = fmom->x();
0340 py = fmom->y();
0341 }
0342 if (!cand.hasUserFloat("fitMass"))
0343 return false;
0344 mass = cand.userFloat("fitMass");
0345 break;
0346 default:
0347 return false;
0348 }
0349 if (svtx == nullptr)
0350 return false;
0351 if (pMin > 0) {
0352 if (ChiSquaredProbability(svtx->chi2(), svtx->ndof()) < pMin)
0353 return false;
0354 }
0355 if ((cMin > -1.0) || (sMin > 0)) {
0356 float cosAlpha = VertexAnalysis::cAlpha(pvtx, svtx, px, py);
0357 if (cosAlpha < cMin)
0358 return false;
0359 if (sMin < 0)
0360 return true;
0361 double ctauPV;
0362 double ctauErrPV;
0363 VertexAnalysis::dist2D(pvtx, svtx, px, py, cosAlpha, mass, ctauPV, ctauErrPV);
0364 float dTest;
0365 switch (mode) {
0366 case 'a':
0367 case 'd':
0368 dTest = ctauPV;
0369 break;
0370 case 'r':
0371 case 's':
0372 default:
0373 dTest = ctauPV / ctauErrPV;
0374 break;
0375 }
0376 if (dTest < sMin)
0377 return false;
0378 }
0379 return true;
0380 }
0381
0382 private:
0383 char type;
0384 float pMin;
0385 float cMin;
0386 float sMin;
0387 char mode;
0388 };
0389
0390 BPHHistoSpecificDecay::BPHHistoSpecificDecay(const edm::ParameterSet& ps) {
0391 useTrig = (!SET_LABEL(trigResultsLabel, ps).empty());
0392 useOnia = (!SET_LABEL(oniaCandsLabel, ps).empty());
0393 useSd = (!SET_LABEL(sdCandsLabel, ps).empty());
0394 useSs = (!SET_LABEL(ssCandsLabel, ps).empty());
0395 useBu = (!SET_LABEL(buCandsLabel, ps).empty());
0396 useBd = (!SET_LABEL(bdCandsLabel, ps).empty());
0397 useBs = (!SET_LABEL(bsCandsLabel, ps).empty());
0398 useK0 = (!SET_LABEL(k0CandsLabel, ps).empty());
0399 useL0 = (!SET_LABEL(l0CandsLabel, ps).empty());
0400 useB0 = (!SET_LABEL(b0CandsLabel, ps).empty());
0401 useLb = (!SET_LABEL(lbCandsLabel, ps).empty());
0402 useBc = (!SET_LABEL(bcCandsLabel, ps).empty());
0403 useX3872 = (!SET_LABEL(x3872CandsLabel, ps).empty());
0404 if (useTrig)
0405 consume<edm::TriggerResults>(trigResultsToken, trigResultsLabel);
0406 if (useOnia)
0407 consume<vector<pat::CompositeCandidate> >(oniaCandsToken, oniaCandsLabel);
0408 if (useSd)
0409 consume<vector<pat::CompositeCandidate> >(sdCandsToken, sdCandsLabel);
0410 if (useSs)
0411 consume<vector<pat::CompositeCandidate> >(ssCandsToken, ssCandsLabel);
0412 if (useBu)
0413 consume<vector<pat::CompositeCandidate> >(buCandsToken, buCandsLabel);
0414 if (useBd)
0415 consume<vector<pat::CompositeCandidate> >(bdCandsToken, bdCandsLabel);
0416 if (useBs)
0417 consume<vector<pat::CompositeCandidate> >(bsCandsToken, bsCandsLabel);
0418 if (useK0)
0419 consume<vector<pat::CompositeCandidate> >(k0CandsToken, k0CandsLabel);
0420 if (useL0)
0421 consume<vector<pat::CompositeCandidate> >(l0CandsToken, l0CandsLabel);
0422 if (useB0)
0423 consume<vector<pat::CompositeCandidate> >(b0CandsToken, b0CandsLabel);
0424 if (useLb)
0425 consume<vector<pat::CompositeCandidate> >(lbCandsToken, lbCandsLabel);
0426 if (useBc)
0427 consume<vector<pat::CompositeCandidate> >(bcCandsToken, bcCandsLabel);
0428 if (useX3872)
0429 consume<vector<pat::CompositeCandidate> >(x3872CandsToken, x3872CandsLabel);
0430
0431 static const BPHSoftMuonSelect* sms = new BPHSoftMuonSelect;
0432
0433
0434
0435 double phiIMassMin = 0.85;
0436 double phiIMassMax = 1.20;
0437 double phiIPtMin = 18.0;
0438 double phiIEtaMax = -1.0;
0439 double phiIYMax = -1.0;
0440 double phiBMassMin = 0.85;
0441 double phiBMassMax = 1.20;
0442 double phiBPtMin = 14.0;
0443 double phiBEtaMax = -1.0;
0444 double phiBYMax = 1.25;
0445 double jPsiIMassMin = 2.80;
0446 double jPsiIMassMax = 3.40;
0447 double jPsiIPtMin = 25.0;
0448 double jPsiIEtaMax = -1.0;
0449 double jPsiIYMax = -1.0;
0450 double jPsiBMassMin = 2.80;
0451 double jPsiBMassMax = 3.40;
0452 double jPsiBPtMin = 20.0;
0453 double jPsiBEtaMax = -1.0;
0454 double jPsiBYMax = 1.25;
0455 double psi2IMassMin = 3.40;
0456 double psi2IMassMax = 4.00;
0457 double psi2IPtMin = 18.0;
0458 double psi2IEtaMax = -1.0;
0459 double psi2IYMax = -1.0;
0460 double psi2BMassMin = 3.40;
0461 double psi2BMassMax = 4.00;
0462 double psi2BPtMin = 10.0;
0463 double psi2BEtaMax = -1.0;
0464 double psi2BYMax = 1.25;
0465 double upsIMassMin = 8.50;
0466 double upsIMassMax = 11.0;
0467 double upsIPtMin = 15.0;
0468 double upsIEtaMax = -1.0;
0469 double upsIYMax = -1.0;
0470 double upsBMassMin = 8.50;
0471 double upsBMassMax = 11.0;
0472 double upsBPtMin = 12.0;
0473
0474
0475 double upsBEtaMax = -1.0;
0476 double upsBYMax = 1.4;
0477
0478 double oniaProbMin = 0.005;
0479 double oniaCosMin = -2.0;
0480 double oniaSigMin = -1.0;
0481
0482 double oniaMuPtMinLoose = 2.0;
0483 double oniaMuPtMinTight = -1.0;
0484 double oniaMuEtaMaxLoose = -1.0;
0485 double oniaMuEtaMaxTight = -1.0;
0486
0487 phiIBasicSelect = new BPHCompositeBasicSelect(phiIMassMin, phiIMassMax, phiIPtMin, phiIEtaMax, phiIYMax);
0488 phiBBasicSelect = new BPHCompositeBasicSelect(phiBMassMin, phiBMassMax, phiBPtMin, phiBEtaMax, phiBYMax);
0489 jPsiIBasicSelect = new BPHCompositeBasicSelect(jPsiIMassMin, jPsiIMassMax, jPsiIPtMin, jPsiIEtaMax, jPsiIYMax);
0490 jPsiBBasicSelect = new BPHCompositeBasicSelect(jPsiBMassMin, jPsiBMassMax, jPsiBPtMin, jPsiBEtaMax, jPsiBYMax);
0491 psi2IBasicSelect = new BPHCompositeBasicSelect(psi2IMassMin, psi2IMassMax, psi2IPtMin, psi2IEtaMax, psi2IYMax);
0492 psi2BBasicSelect = new BPHCompositeBasicSelect(psi2BMassMin, psi2BMassMax, psi2BPtMin, psi2BEtaMax, psi2BYMax);
0493 upsIBasicSelect = new BPHCompositeBasicSelect(upsIMassMin, upsIMassMax, upsIPtMin, upsIEtaMax, upsIYMax);
0494 upsBBasicSelect = new BPHCompositeBasicSelect(upsBMassMin, upsBMassMax, upsBPtMin, upsBEtaMax, upsBYMax);
0495 oniaVertexSelect = new BPHGenericVertexSelect('c', oniaProbMin, oniaCosMin, oniaSigMin);
0496 oniaDaughterSelect =
0497 new BPHDaughterSelect(oniaMuPtMinLoose, oniaMuPtMinTight, oniaMuEtaMaxLoose, oniaMuEtaMaxTight, sms);
0498
0499 double npJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0500 double npJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0501 double npJPsiPtMin = 8.0;
0502 double npJPsiEtaMax = -1.0;
0503 double npJPsiYMax = -1.0;
0504 double npMuPtMinLoose = 4.0;
0505 double npMuPtMinTight = -1.0;
0506 double npMuEtaMaxLoose = 2.2;
0507 double npMuEtaMaxTight = -1.0;
0508
0509 npJPsiBasicSelect = new BPHCompositeBasicSelect(npJPsiMassMin, npJPsiMassMax, npJPsiPtMin, npJPsiEtaMax, npJPsiYMax);
0510 npJPsiDaughterSelect = new BPHDaughterSelect(npMuPtMinLoose, npMuPtMinTight, npMuEtaMaxLoose, npMuEtaMaxTight, sms);
0511
0512
0513
0514 double buIMassMin = 0.0;
0515 double buIMassMax = 999999.0;
0516 double buIPtMin = 27.0;
0517 double buIEtaMax = -1.0;
0518 double buIYMax = -1.0;
0519 double buIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0520 double buIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0521 double buIJPsiPtMin = 25.0;
0522 double buIJPsiEtaMax = -1.0;
0523 double buIJPsiYMax = -1.0;
0524 double buIProbMin = 0.15;
0525 double buICosMin = -2.0;
0526 double buISigMin = -1.0;
0527
0528
0529
0530
0531
0532
0533 buIKPtMin = 2.0;
0534
0535 buIBasicSelect = new BPHFittedBasicSelect(buIMassMin, buIMassMax, buIPtMin, buIEtaMax, buIYMax);
0536 buIJPsiBasicSelect =
0537 new BPHCompositeBasicSelect(buIJPsiMassMin, buIJPsiMassMax, buIJPsiPtMin, buIJPsiEtaMax, buIJPsiYMax);
0538 buIVertexSelect = new BPHGenericVertexSelect('f', buIProbMin, buICosMin, buISigMin);
0539 buIJPsiDaughterSelect = nullptr;
0540
0541
0542
0543
0544
0545 double buDMassMin = 0.0;
0546 double buDMassMax = 999999.0;
0547 double buDPtMin = 10.0;
0548 double buDEtaMax = -1.0;
0549 double buDYMax = -1.0;
0550 double buDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0551 double buDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0552 double buDJPsiPtMin = 8.0;
0553 double buDJPsiEtaMax = -1.0;
0554 double buDJPsiYMax = -1.0;
0555 double buDProbMin = 0.10;
0556 double buDCosMin = 0.99;
0557 double buDSigMin = 3.0;
0558
0559
0560
0561
0562
0563
0564 buDKPtMin = 1.6;
0565
0566 buDBasicSelect = new BPHFittedBasicSelect(buDMassMin, buDMassMax, buDPtMin, buDEtaMax, buDYMax);
0567 buDJPsiBasicSelect =
0568 new BPHCompositeBasicSelect(buDJPsiMassMin, buDJPsiMassMax, buDJPsiPtMin, buDJPsiEtaMax, buDJPsiYMax);
0569 buDVertexSelect = new BPHGenericVertexSelect('f', buDProbMin, buDCosMin, buDSigMin);
0570 buDJPsiDaughterSelect = nullptr;
0571
0572
0573
0574
0575
0576
0577
0578 double bdIMassMin = 0.0;
0579 double bdIMassMax = 999999.0;
0580 double bdIPtMin = 27.0;
0581 double bdIEtaMax = -1.0;
0582 double bdIYMax = -1.0;
0583 double bdIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0584 double bdIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0585 double bdIJPsiPtMin = 25.0;
0586 double bdIJPsiEtaMax = -1.0;
0587 double bdIJPsiYMax = -1.0;
0588 double bdIKx0MassMin = BPHParticleMasses::kx0Mass - 0.100;
0589 double bdIKx0MassMax = BPHParticleMasses::kx0Mass + 0.100;
0590 double bdIKx0PtMin = -1.0;
0591 double bdIKx0EtaMax = -1.0;
0592 double bdIKx0YMax = -1.0;
0593 double bdIProbMin = 0.15;
0594 double bdICosMin = -2.0;
0595 double bdISigMin = -1.0;
0596
0597
0598
0599
0600
0601
0602 bdIBasicSelect = new BPHFittedBasicSelect(bdIMassMin, bdIMassMax, bdIPtMin, bdIEtaMax, bdIYMax);
0603 bdIJPsiBasicSelect =
0604 new BPHCompositeBasicSelect(bdIJPsiMassMin, bdIJPsiMassMax, bdIJPsiPtMin, bdIJPsiEtaMax, bdIJPsiYMax);
0605 bdIKx0BasicSelect = new BPHCompositeBasicSelect(bdIKx0MassMin, bdIKx0MassMax, bdIKx0PtMin, bdIKx0EtaMax, bdIKx0YMax);
0606 bdIVertexSelect = new BPHGenericVertexSelect('f', bdIProbMin, bdICosMin, bdISigMin);
0607 bdIJPsiDaughterSelect = nullptr;
0608
0609
0610
0611
0612
0613 double bdDMassMin = 0.0;
0614 double bdDMassMax = 999999.0;
0615 double bdDPtMin = 10.0;
0616 double bdDEtaMax = -1.0;
0617 double bdDYMax = -1.0;
0618 double bdDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0619 double bdDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0620 double bdDJPsiPtMin = 8.0;
0621 double bdDJPsiEtaMax = -1.0;
0622 double bdDJPsiYMax = -1.0;
0623 double bdDKx0MassMin = BPHParticleMasses::kx0Mass - 0.100;
0624 double bdDKx0MassMax = BPHParticleMasses::kx0Mass + 0.100;
0625 double bdDKx0PtMin = -1.0;
0626 double bdDKx0EtaMax = -1.0;
0627 double bdDKx0YMax = -1.0;
0628 double bdDProbMin = 0.10;
0629 double bdDCosMin = 0.99;
0630 double bdDSigMin = 3.0;
0631
0632
0633
0634
0635
0636
0637 bdDBasicSelect = new BPHFittedBasicSelect(bdDMassMin, bdDMassMax, bdDPtMin, bdDEtaMax, bdDYMax);
0638 bdDJPsiBasicSelect =
0639 new BPHCompositeBasicSelect(bdDJPsiMassMin, bdDJPsiMassMax, bdDJPsiPtMin, bdDJPsiEtaMax, bdDJPsiYMax);
0640 bdDKx0BasicSelect = new BPHCompositeBasicSelect(bdDKx0MassMin, bdDKx0MassMax, bdDKx0PtMin, bdDKx0EtaMax, bdDKx0YMax);
0641 bdDVertexSelect = new BPHGenericVertexSelect('f', bdDProbMin, bdDCosMin, bdDSigMin);
0642 bdDJPsiDaughterSelect = nullptr;
0643
0644
0645
0646
0647
0648
0649
0650 double bsIMassMin = 0.0;
0651 double bsIMassMax = 999999.0;
0652 double bsIPtMin = 27.0;
0653 double bsIEtaMax = -1.0;
0654 double bsIYMax = -1.0;
0655 double bsIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0656 double bsIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0657 double bsIJPsiPtMin = 25.0;
0658 double bsIJPsiEtaMax = -1.0;
0659 double bsIJPsiYMax = -1.0;
0660 double bsIPhiMassMin = BPHParticleMasses::phiMass - 0.010;
0661 double bsIPhiMassMax = BPHParticleMasses::phiMass + 0.010;
0662 double bsIPhiPtMin = -1.0;
0663 double bsIPhiEtaMax = -1.0;
0664 double bsIPhiYMax = -1.0;
0665 double bsIProbMin = 0.15;
0666 double bsICosMin = -2.0;
0667 double bsISigMin = -1.0;
0668
0669
0670
0671
0672
0673
0674 bsIBasicSelect = new BPHFittedBasicSelect(bsIMassMin, bsIMassMax, bsIPtMin, bsIEtaMax, bsIYMax);
0675 bsIJPsiBasicSelect =
0676 new BPHCompositeBasicSelect(bsIJPsiMassMin, bsIJPsiMassMax, bsIJPsiPtMin, bsIJPsiEtaMax, bsIJPsiYMax);
0677 bsIPhiBasicSelect = new BPHCompositeBasicSelect(bsIPhiMassMin, bsIPhiMassMax, bsIPhiPtMin, bsIPhiEtaMax, bsIPhiYMax);
0678 bsIVertexSelect = new BPHGenericVertexSelect('f', bsIProbMin, bsICosMin, bsISigMin);
0679 bsIJPsiDaughterSelect = nullptr;
0680
0681
0682
0683
0684
0685 double bsDMassMin = 0.0;
0686 double bsDMassMax = 999999.0;
0687 double bsDPtMin = 10.0;
0688 double bsDEtaMax = -1.0;
0689 double bsDYMax = -1.0;
0690 double bsDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0691 double bsDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0692 double bsDJPsiPtMin = 8.0;
0693 double bsDJPsiEtaMax = -1.0;
0694 double bsDJPsiYMax = -1.0;
0695 double bsDPhiMassMin = BPHParticleMasses::phiMass - 0.010;
0696 double bsDPhiMassMax = BPHParticleMasses::phiMass + 0.010;
0697 double bsDPhiPtMin = -1.0;
0698 double bsDPhiEtaMax = -1.0;
0699 double bsDPhiYMax = -1.0;
0700 double bsDProbMin = 0.10;
0701 double bsDCosMin = 0.99;
0702 double bsDSigMin = 3.0;
0703
0704
0705
0706
0707
0708
0709 bsDBasicSelect = new BPHFittedBasicSelect(bsDMassMin, bsDMassMax, bsDPtMin, bsDEtaMax, bsDYMax);
0710 bsDJPsiBasicSelect =
0711 new BPHCompositeBasicSelect(bsDJPsiMassMin, bsDJPsiMassMax, bsDJPsiPtMin, bsDJPsiEtaMax, bsDJPsiYMax);
0712 bsDPhiBasicSelect = new BPHCompositeBasicSelect(bsDPhiMassMin, bsDPhiMassMax, bsDPhiPtMin, bsDPhiEtaMax, bsDPhiYMax);
0713 bsDVertexSelect = new BPHGenericVertexSelect('f', bsDProbMin, bsDCosMin, bsDSigMin);
0714 bsDJPsiDaughterSelect = nullptr;
0715
0716
0717
0718
0719
0720
0721
0722 double b0IMassMin = 0.0;
0723 double b0IMassMax = 999999.0;
0724 double b0IPtMin = 27.0;
0725 double b0IEtaMax = -1.0;
0726 double b0IYMax = -1.0;
0727 double b0IJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0728 double b0IJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0729 double b0IJPsiPtMin = 25.0;
0730 double b0IJPsiEtaMax = -1.0;
0731 double b0IJPsiYMax = -1.0;
0732 double b0IK0sMassMin = BPHParticleMasses::k0sMass - 0.010;
0733 double b0IK0sMassMax = BPHParticleMasses::k0sMass + 0.010;
0734 double b0IK0sPtMin = -1.0;
0735 double b0IK0sEtaMax = -1.0;
0736 double b0IK0sYMax = -1.0;
0737 double b0IProbMin = 0.15;
0738 double b0ICosMin = -2.0;
0739 double b0ISigMin = -1.0;
0740
0741
0742
0743
0744
0745
0746 b0IBasicSelect = new BPHFittedBasicSelect(b0IMassMin, b0IMassMax, b0IPtMin, b0IEtaMax, b0IYMax);
0747 b0IJPsiBasicSelect =
0748 new BPHCompositeBasicSelect(b0IJPsiMassMin, b0IJPsiMassMax, b0IJPsiPtMin, b0IJPsiEtaMax, b0IJPsiYMax);
0749 b0IK0sBasicSelect = new BPHFittedBasicSelect(b0IK0sMassMin, b0IK0sMassMax, b0IK0sPtMin, b0IK0sEtaMax, b0IK0sYMax);
0750 b0IVertexSelect = new BPHGenericVertexSelect('f', b0IProbMin, b0ICosMin, b0ISigMin);
0751 b0IJPsiDaughterSelect = nullptr;
0752
0753
0754
0755
0756
0757 double b0DMassMin = 0.0;
0758 double b0DMassMax = 999999.0;
0759 double b0DPtMin = 10.0;
0760 double b0DEtaMax = -1.0;
0761 double b0DYMax = -1.0;
0762 double b0DJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0763 double b0DJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0764 double b0DJPsiPtMin = 8.0;
0765 double b0DJPsiEtaMax = -1.0;
0766 double b0DJPsiYMax = -1.0;
0767 double b0DK0sMassMin = BPHParticleMasses::k0sMass - 0.010;
0768 double b0DK0sMassMax = BPHParticleMasses::k0sMass + 0.010;
0769 double b0DK0sPtMin = -1.0;
0770 double b0DK0sEtaMax = -1.0;
0771 double b0DK0sYMax = -1.0;
0772 double b0DProbMin = 0.10;
0773 double b0DCosMin = 0.99;
0774 double b0DSigMin = 3.0;
0775
0776
0777
0778
0779
0780
0781 b0DBasicSelect = new BPHFittedBasicSelect(b0DMassMin, b0DMassMax, b0DPtMin, b0DEtaMax, b0DYMax);
0782 b0DJPsiBasicSelect =
0783 new BPHCompositeBasicSelect(b0DJPsiMassMin, b0DJPsiMassMax, b0DJPsiPtMin, b0DJPsiEtaMax, b0DJPsiYMax);
0784 b0DK0sBasicSelect = new BPHFittedBasicSelect(b0DK0sMassMin, b0DK0sMassMax, b0DK0sPtMin, b0DK0sEtaMax, b0DK0sYMax);
0785 b0DVertexSelect = new BPHGenericVertexSelect('f', b0DProbMin, b0DCosMin, b0DSigMin);
0786 b0DJPsiDaughterSelect = nullptr;
0787
0788
0789
0790
0791
0792
0793
0794 double lbIMassMin = 0.0;
0795 double lbIMassMax = 999999.0;
0796 double lbIPtMin = 27.0;
0797 double lbIEtaMax = -1.0;
0798 double lbIYMax = -1.0;
0799 double lbIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0800 double lbIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0801 double lbIJPsiPtMin = 25.0;
0802 double lbIJPsiEtaMax = -1.0;
0803 double lbIJPsiYMax = -1.0;
0804 double lbILambda0MassMin = BPHParticleMasses::lambda0Mass - 0.006;
0805 double lbILambda0MassMax = BPHParticleMasses::lambda0Mass + 0.006;
0806 double lbILambda0PtMin = -1.0;
0807 double lbILambda0EtaMax = -1.0;
0808 double lbILambda0YMax = -1.0;
0809 double lbIProbMin = 0.10;
0810 double lbICosMin = -2.0;
0811 double lbISigMin = -1.0;
0812
0813
0814
0815
0816
0817
0818 lbIBasicSelect = new BPHFittedBasicSelect(lbIMassMin, lbIMassMax, lbIPtMin, lbIEtaMax, lbIYMax);
0819 lbIJPsiBasicSelect =
0820 new BPHCompositeBasicSelect(lbIJPsiMassMin, lbIJPsiMassMax, lbIJPsiPtMin, lbIJPsiEtaMax, lbIJPsiYMax);
0821 lbILambda0BasicSelect =
0822 new BPHFittedBasicSelect(lbILambda0MassMin, lbILambda0MassMax, lbILambda0PtMin, lbILambda0EtaMax, lbILambda0YMax);
0823 lbIVertexSelect = new BPHGenericVertexSelect('f', lbIProbMin, lbICosMin, lbISigMin);
0824 lbIJPsiDaughterSelect = nullptr;
0825
0826
0827
0828
0829
0830 double lbDMassMin = 0.0;
0831 double lbDMassMax = 999999.0;
0832 double lbDPtMin = 10.0;
0833 double lbDEtaMax = -1.0;
0834 double lbDYMax = -1.0;
0835 double lbDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0836 double lbDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0837 double lbDJPsiPtMin = 8.0;
0838 double lbDJPsiEtaMax = -1.0;
0839 double lbDJPsiYMax = -1.0;
0840 double lbDLambda0MassMin = BPHParticleMasses::lambda0Mass - 0.006;
0841 double lbDLambda0MassMax = BPHParticleMasses::lambda0Mass + 0.006;
0842 double lbDLambda0PtMin = -1.0;
0843 double lbDLambda0EtaMax = -1.0;
0844 double lbDLambda0YMax = -1.0;
0845 double lbDProbMin = 0.10;
0846 double lbDCosMin = 0.99;
0847 double lbDSigMin = 3.0;
0848
0849
0850
0851
0852
0853
0854 lbDBasicSelect = new BPHFittedBasicSelect(lbDMassMin, lbDMassMax, lbDPtMin, lbDEtaMax, lbDYMax);
0855 lbDJPsiBasicSelect =
0856 new BPHCompositeBasicSelect(lbDJPsiMassMin, lbDJPsiMassMax, lbDJPsiPtMin, lbDJPsiEtaMax, lbDJPsiYMax);
0857 lbDLambda0BasicSelect =
0858 new BPHFittedBasicSelect(lbDLambda0MassMin, lbDLambda0MassMax, lbDLambda0PtMin, lbDLambda0EtaMax, lbDLambda0YMax);
0859 lbDVertexSelect = new BPHGenericVertexSelect('f', lbDProbMin, lbDCosMin, lbDSigMin);
0860 lbDJPsiDaughterSelect = nullptr;
0861
0862
0863
0864
0865
0866
0867
0868 double bcIMassMin = 0.0;
0869 double bcIMassMax = 999999.0;
0870 double bcIPtMin = 27.0;
0871 double bcIEtaMax = -1.0;
0872 double bcIYMax = -1.0;
0873 double bcIJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0874 double bcIJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0875 double bcIJPsiPtMin = 25.0;
0876 double bcIJPsiEtaMax = -1.0;
0877 double bcIJPsiYMax = -1.0;
0878 double bcIJPsiProbMin = 0.005;
0879 double bcIProbMin = 0.10;
0880 double bcICosMin = -2.0;
0881 double bcISigMin = -1.0;
0882 double bcIDistMin = 0.01;
0883
0884
0885
0886
0887
0888
0889 bcIPiPtMin = 3.5;
0890
0891 bcIBasicSelect = new BPHFittedBasicSelect(bcIMassMin, bcIMassMax, bcIPtMin, bcIEtaMax, bcIYMax);
0892 bcIJPsiBasicSelect =
0893 new BPHCompositeBasicSelect(bcIJPsiMassMin, bcIJPsiMassMax, bcIJPsiPtMin, bcIJPsiEtaMax, bcIJPsiYMax);
0894 bcIJPsiVertexSelect = new BPHGenericVertexSelect('c', bcIJPsiProbMin);
0895 bcIVertexSelect = new BPHGenericVertexSelect('f', bcIProbMin, bcICosMin, bcISigMin, bcIDistMin);
0896 bcIJPsiDaughterSelect = nullptr;
0897
0898
0899
0900
0901
0902 double bcDMassMin = 0.0;
0903 double bcDMassMax = 999999.0;
0904 double bcDPtMin = 8.0;
0905 double bcDEtaMax = -1.0;
0906 double bcDYMax = -1.0;
0907 double bcDJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0908 double bcDJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0909 double bcDJPsiPtMin = 7.0;
0910 double bcDJPsiEtaMax = -1.0;
0911 double bcDJPsiYMax = -1.0;
0912 double bcDJPsiProbMin = 0.005;
0913 double bcDProbMin = 0.10;
0914 double bcDCosMin = 0.99;
0915 double bcDSigMin = 3.0;
0916
0917
0918
0919
0920
0921
0922 bcJPsiDcaMax = 0.5;
0923 bcDPiPtMin = 3.5;
0924
0925 bcDBasicSelect = new BPHFittedBasicSelect(bcDMassMin, bcDMassMax, bcDPtMin, bcDEtaMax, bcDYMax);
0926 bcDJPsiBasicSelect =
0927 new BPHCompositeBasicSelect(bcDJPsiMassMin, bcDJPsiMassMax, bcDJPsiPtMin, bcDJPsiEtaMax, bcDJPsiYMax);
0928 bcDJPsiVertexSelect = new BPHGenericVertexSelect('c', bcDJPsiProbMin);
0929 bcDVertexSelect = new BPHGenericVertexSelect('f', bcDProbMin, bcDCosMin, bcDSigMin);
0930 bcDJPsiDaughterSelect = nullptr;
0931
0932
0933
0934
0935
0936
0937
0938 double x3872IMassMin = 0.0;
0939 double x3872IMassMax = 999999.0;
0940 double x3872IPtMin = 27.0;
0941 double x3872IEtaMax = -1.0;
0942 double x3872IYMax = -1.0;
0943 double x3872IJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0944 double x3872IJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0945 double x3872IJPsiPtMin = 25.0;
0946 double x3872IJPsiEtaMax = -1.0;
0947 double x3872IJPsiYMax = -1.0;
0948 double x3872IJPsiProbMin = 0.10;
0949 double x3872IProbMin = 0.10;
0950 double x3872ICosMin = -2.0;
0951 double x3872ISigMin = -1.0;
0952 double x3872IDistMin = 0.01;
0953
0954
0955
0956
0957
0958
0959 x3872JPsiDcaMax = 0.5;
0960 x3872IPiPtMin = 1.2;
0961
0962 x3872IBasicSelect = new BPHFittedBasicSelect(x3872IMassMin, x3872IMassMax, x3872IPtMin, x3872IEtaMax, x3872IYMax);
0963 x3872IJPsiBasicSelect = new BPHCompositeBasicSelect(
0964 x3872IJPsiMassMin, x3872IJPsiMassMax, x3872IJPsiPtMin, x3872IJPsiEtaMax, x3872IJPsiYMax);
0965 x3872IJPsiVertexSelect = new BPHGenericVertexSelect('c', x3872IJPsiProbMin);
0966 x3872IVertexSelect = new BPHGenericVertexSelect('f', x3872IProbMin, x3872ICosMin, x3872ISigMin, x3872IDistMin);
0967 x3872IJPsiDaughterSelect = nullptr;
0968
0969
0970
0971
0972
0973
0974 double x3872DMassMin = 0.0;
0975 double x3872DMassMax = 999999.0;
0976 double x3872DPtMin = 8.0;
0977 double x3872DEtaMax = -1.0;
0978 double x3872DYMax = -1.0;
0979 double x3872DJPsiMassMin = BPHParticleMasses::jPsiMass - 0.150;
0980 double x3872DJPsiMassMax = BPHParticleMasses::jPsiMass + 0.150;
0981 double x3872DJPsiPtMin = 7.0;
0982 double x3872DJPsiEtaMax = -1.0;
0983 double x3872DJPsiYMax = -1.0;
0984 double x3872DJPsiProbMin = 0.10;
0985 double x3872DProbMin = 0.10;
0986 double x3872DCosMin = 0.99;
0987 double x3872DSigMin = 3.0;
0988
0989
0990
0991
0992
0993
0994 x3872DPiPtMin = 1.2;
0995
0996 x3872DBasicSelect = new BPHFittedBasicSelect(x3872DMassMin, x3872DMassMax, x3872DPtMin, x3872DEtaMax, x3872DYMax);
0997 x3872DJPsiBasicSelect = new BPHCompositeBasicSelect(
0998 x3872DJPsiMassMin, x3872DJPsiMassMax, x3872DJPsiPtMin, x3872DJPsiEtaMax, x3872DJPsiYMax);
0999 x3872DJPsiVertexSelect = new BPHGenericVertexSelect('c', x3872DJPsiProbMin);
1000 x3872DVertexSelect = new BPHGenericVertexSelect('f', x3872DProbMin, x3872DCosMin, x3872DSigMin);
1001 x3872DJPsiDaughterSelect = nullptr;
1002
1003
1004
1005
1006
1007 }
1008
1009 BPHHistoSpecificDecay::~BPHHistoSpecificDecay() {
1010 delete phiIBasicSelect;
1011 delete phiBBasicSelect;
1012 delete jPsiIBasicSelect;
1013 delete jPsiBBasicSelect;
1014 delete psi2IBasicSelect;
1015 delete psi2BBasicSelect;
1016 delete upsIBasicSelect;
1017 delete upsBBasicSelect;
1018 delete oniaVertexSelect;
1019 delete oniaDaughterSelect;
1020
1021 delete npJPsiBasicSelect;
1022 delete npJPsiDaughterSelect;
1023
1024 delete buIBasicSelect;
1025 delete buIJPsiBasicSelect;
1026 delete buIVertexSelect;
1027 delete buIJPsiDaughterSelect;
1028 delete buDBasicSelect;
1029 delete buDJPsiBasicSelect;
1030 delete buDVertexSelect;
1031 delete buDJPsiDaughterSelect;
1032
1033 delete bdIBasicSelect;
1034 delete bdIJPsiBasicSelect;
1035 delete bdIKx0BasicSelect;
1036 delete bdIVertexSelect;
1037 delete bdIJPsiDaughterSelect;
1038 delete bdDBasicSelect;
1039 delete bdDJPsiBasicSelect;
1040 delete bdDKx0BasicSelect;
1041 delete bdDVertexSelect;
1042 delete bdDJPsiDaughterSelect;
1043
1044 delete bsIBasicSelect;
1045 delete bsIJPsiBasicSelect;
1046 delete bsIPhiBasicSelect;
1047 delete bsIVertexSelect;
1048 delete bsIJPsiDaughterSelect;
1049 delete bsDBasicSelect;
1050 delete bsDJPsiBasicSelect;
1051 delete bsDPhiBasicSelect;
1052 delete bsDVertexSelect;
1053 delete bsDJPsiDaughterSelect;
1054
1055 delete b0IBasicSelect;
1056 delete b0IJPsiBasicSelect;
1057 delete b0IK0sBasicSelect;
1058 delete b0IVertexSelect;
1059 delete b0IJPsiDaughterSelect;
1060 delete b0DBasicSelect;
1061 delete b0DJPsiBasicSelect;
1062 delete b0DK0sBasicSelect;
1063 delete b0DVertexSelect;
1064 delete b0DJPsiDaughterSelect;
1065
1066 delete lbIBasicSelect;
1067 delete lbIJPsiBasicSelect;
1068 delete lbILambda0BasicSelect;
1069 delete lbIVertexSelect;
1070 delete lbIJPsiDaughterSelect;
1071 delete lbDBasicSelect;
1072 delete lbDJPsiBasicSelect;
1073 delete lbDLambda0BasicSelect;
1074 delete lbDVertexSelect;
1075 delete lbDJPsiDaughterSelect;
1076
1077 delete bcIBasicSelect;
1078 delete bcIJPsiBasicSelect;
1079 delete bcIJPsiVertexSelect;
1080 delete bcIVertexSelect;
1081 delete bcIJPsiDaughterSelect;
1082 delete bcDBasicSelect;
1083 delete bcDJPsiBasicSelect;
1084 delete bcDJPsiVertexSelect;
1085 delete bcDVertexSelect;
1086 delete bcDJPsiDaughterSelect;
1087
1088 delete x3872IBasicSelect;
1089 delete x3872IJPsiBasicSelect;
1090 delete x3872IJPsiVertexSelect;
1091 delete x3872IVertexSelect;
1092 delete x3872IJPsiDaughterSelect;
1093 delete x3872DBasicSelect;
1094 delete x3872DJPsiBasicSelect;
1095 delete x3872DJPsiVertexSelect;
1096 delete x3872DVertexSelect;
1097 delete x3872DJPsiDaughterSelect;
1098 }
1099
1100 void BPHHistoSpecificDecay::fillDescriptions(edm::ConfigurationDescriptions& descriptions) {
1101 edm::ParameterSetDescription desc;
1102 desc.add<string>("trigResultsLabel", "");
1103 desc.add<string>("oniaCandsLabel", "");
1104 desc.add<string>("sdCandsLabel", "");
1105 desc.add<string>("ssCandsLabel", "");
1106 desc.add<string>("buCandsLabel", "");
1107 desc.add<string>("bdCandsLabel", "");
1108 desc.add<string>("bsCandsLabel", "");
1109 desc.add<string>("k0CandsLabel", "");
1110 desc.add<string>("l0CandsLabel", "");
1111 desc.add<string>("b0CandsLabel", "");
1112 desc.add<string>("lbCandsLabel", "");
1113 desc.add<string>("bcCandsLabel", "");
1114 desc.add<string>("x3872CandsLabel", "");
1115 descriptions.addWithDefaultLabel(desc);
1116 return;
1117 }
1118
1119 void BPHHistoSpecificDecay::beginJob() {
1120 createHisto("massDIPhi", 50, 0.90, 1.15);
1121 createHisto("massTIPhi", 50, 0.90, 1.15);
1122 createHisto("massDBPhi", 50, 0.90, 1.15);
1123 createHisto("massTBPhi", 50, 0.90, 1.15);
1124 createHisto("massDIJPsi", 35, 2.95, 3.30);
1125 createHisto("massTIJPsi", 35, 2.95, 3.30);
1126 createHisto("massDBJPsi", 35, 2.95, 3.30);
1127 createHisto("massTBJPsi", 35, 2.95, 3.30);
1128 createHisto("massDIPsi2", 60, 3.40, 4.00);
1129 createHisto("massTIPsi2", 60, 3.40, 4.00);
1130 createHisto("massDBPsi2", 60, 3.40, 4.00);
1131 createHisto("massTBPsi2", 60, 3.40, 4.00);
1132 createHisto("massDIUps123", 115, 8.70, 11.0);
1133 createHisto("massTIUps123", 115, 8.70, 11.0);
1134 createHisto("massDBUps123", 115, 8.70, 11.0);
1135 createHisto("massTBUps123", 115, 8.70, 11.0);
1136 createHisto("massDIBu", 100, 5.00, 6.00);
1137 createHisto("massTIBu", 100, 5.00, 6.00);
1138 createHisto("massDDBu", 100, 5.00, 6.00);
1139 createHisto("massTDBu", 100, 5.00, 6.00);
1140 createHisto("massDIBd", 100, 5.00, 6.00);
1141 createHisto("massTIBd", 100, 5.00, 6.00);
1142 createHisto("massDDBd", 100, 5.00, 6.00);
1143 createHisto("massTDBd", 100, 5.00, 6.00);
1144 createHisto("massDIBs", 100, 5.00, 6.00);
1145 createHisto("massTIBs", 100, 5.00, 6.00);
1146 createHisto("massDDBs", 100, 5.00, 6.00);
1147 createHisto("massTDBs", 100, 5.00, 6.00);
1148 createHisto("massDIBc", 100, 6.00, 7.00);
1149 createHisto("massTIBc", 100, 6.00, 7.00);
1150 createHisto("massDDBc", 100, 6.00, 7.00);
1151 createHisto("massTDBc", 100, 6.00, 7.00);
1152 createHisto("massDIX3872", 40, 3.60, 4.00);
1153 createHisto("massTIX3872", 40, 3.60, 4.00);
1154 createHisto("massDDX3872", 40, 3.60, 4.00);
1155 createHisto("massTDX3872", 40, 3.60, 4.00);
1156 createHisto("mfitDIBu", 100, 5.00, 6.00);
1157 createHisto("mfitTIBu", 100, 5.00, 6.00);
1158 createHisto("mfitDDBu", 100, 5.00, 6.00);
1159 createHisto("mfitTDBu", 100, 5.00, 6.00);
1160 createHisto("mfitDIBd", 100, 5.00, 6.00);
1161 createHisto("mfitTIBd", 100, 5.00, 6.00);
1162 createHisto("mfitDDBd", 100, 5.00, 6.00);
1163 createHisto("mfitTDBd", 100, 5.00, 6.00);
1164 createHisto("mfitDIBs", 100, 5.00, 6.00);
1165 createHisto("mfitTIBs", 100, 5.00, 6.00);
1166 createHisto("mfitDDBs", 100, 5.00, 6.00);
1167 createHisto("mfitTDBs", 100, 5.00, 6.00);
1168 createHisto("mfitDIBc", 100, 6.00, 7.00);
1169 createHisto("mfitTIBc", 100, 6.00, 7.00);
1170 createHisto("mfitDDBc", 100, 6.00, 7.00);
1171 createHisto("mfitTDBc", 100, 6.00, 7.00);
1172 createHisto("mfitDIX3872", 40, 3.60, 4.00);
1173 createHisto("mfitTIX3872", 40, 3.60, 4.00);
1174 createHisto("mfitDDX3872", 40, 3.60, 4.00);
1175 createHisto("mfitTDX3872", 40, 3.60, 4.00);
1176 createHisto("massDIBuJPsi", 35, 2.95, 3.30);
1177 createHisto("massTIBuJPsi", 35, 2.95, 3.30);
1178 createHisto("massDDBuJPsi", 35, 2.95, 3.30);
1179 createHisto("massTDBuJPsi", 35, 2.95, 3.30);
1180 createHisto("massDIBdJPsi", 35, 2.95, 3.30);
1181 createHisto("massTIBdJPsi", 35, 2.95, 3.30);
1182 createHisto("massDDBdJPsi", 35, 2.95, 3.30);
1183 createHisto("massTDBdJPsi", 35, 2.95, 3.30);
1184 createHisto("massDIBdKx0", 50, 0.80, 1.05);
1185 createHisto("massTIBdKx0", 50, 0.80, 1.05);
1186 createHisto("massDDBdKx0", 50, 0.80, 1.05);
1187 createHisto("massTDBdKx0", 50, 0.80, 1.05);
1188 createHisto("massDIBsJPsi", 35, 2.95, 3.30);
1189 createHisto("massTIBsJPsi", 35, 2.95, 3.30);
1190 createHisto("massDDBsJPsi", 35, 2.95, 3.30);
1191 createHisto("massTDBsJPsi", 35, 2.95, 3.30);
1192 createHisto("massDIBsPhi", 50, 1.01, 1.03);
1193 createHisto("massTIBsPhi", 50, 1.01, 1.03);
1194 createHisto("massDDBsPhi", 50, 1.01, 1.03);
1195 createHisto("massTDBsPhi", 50, 1.01, 1.03);
1196 createHisto("massDIBcJPsi", 35, 2.95, 3.30);
1197 createHisto("massTIBcJPsi", 35, 2.95, 3.30);
1198 createHisto("massDDBcJPsi", 35, 2.95, 3.30);
1199 createHisto("massTDBcJPsi", 35, 2.95, 3.30);
1200 createHisto("massDIX3JPsi", 35, 2.95, 3.30);
1201 createHisto("massTIX3JPsi", 35, 2.95, 3.30);
1202 createHisto("massDDX3JPsi", 35, 2.95, 3.30);
1203 createHisto("massTDX3JPsi", 35, 2.95, 3.30);
1204 createHisto("massDK0s", 50, 0.40, 0.60);
1205 createHisto("mfitDK0s", 50, 0.40, 0.60);
1206 createHisto("massDLambda0", 60, 1.00, 1.30);
1207 createHisto("mfitDLambda0", 60, 1.00, 1.30);
1208 createHisto("massDIB0", 50, 5.00, 6.00);
1209 createHisto("massTIB0", 50, 5.00, 6.00);
1210 createHisto("massDDB0", 50, 5.00, 6.00);
1211 createHisto("massTDB0", 50, 5.00, 6.00);
1212 createHisto("mfitDIB0", 50, 5.00, 6.00);
1213 createHisto("mfitTIB0", 50, 5.00, 6.00);
1214 createHisto("mfitDDB0", 50, 5.00, 6.00);
1215 createHisto("mfitTDB0", 50, 5.00, 6.00);
1216 createHisto("massDIB0JPsi", 35, 2.95, 3.30);
1217 createHisto("massTIB0JPsi", 35, 2.95, 3.30);
1218 createHisto("massDDB0JPsi", 35, 2.95, 3.30);
1219 createHisto("massTDB0JPsi", 35, 2.95, 3.30);
1220 createHisto("massDIB0K0s", 50, 0.40, 0.60);
1221 createHisto("massTIB0K0s", 50, 0.40, 0.60);
1222 createHisto("massDDB0K0s", 50, 0.40, 0.60);
1223 createHisto("massTDB0K0s", 50, 0.40, 0.60);
1224 createHisto("mfitDIB0K0s", 50, 0.40, 0.60);
1225 createHisto("mfitTIB0K0s", 50, 0.40, 0.60);
1226 createHisto("mfitDDB0K0s", 50, 0.40, 0.60);
1227 createHisto("mfitTDB0K0s", 50, 0.40, 0.60);
1228 createHisto("massDILambdab", 25, 5.00, 6.00);
1229 createHisto("massTILambdab", 25, 5.00, 6.00);
1230 createHisto("massDDLambdab", 25, 5.00, 6.00);
1231 createHisto("massTDLambdab", 25, 5.00, 6.00);
1232 createHisto("mfitDILambdab", 25, 5.00, 6.00);
1233 createHisto("mfitTILambdab", 25, 5.00, 6.00);
1234 createHisto("mfitDDLambdab", 25, 5.00, 6.00);
1235 createHisto("mfitTDLambdab", 25, 5.00, 6.00);
1236 createHisto("massDILbJPsi", 35, 2.95, 3.30);
1237 createHisto("massTILbJPsi", 35, 2.95, 3.30);
1238 createHisto("massDDLbJPsi", 35, 2.95, 3.30);
1239 createHisto("massTDLbJPsi", 35, 2.95, 3.30);
1240 createHisto("massDILbL0", 60, 1.00, 1.30);
1241 createHisto("massTILbL0", 60, 1.00, 1.30);
1242 createHisto("massDDLbL0", 60, 1.00, 1.30);
1243 createHisto("massTDLbL0", 60, 1.00, 1.30);
1244 createHisto("mfitDILbL0", 60, 1.00, 1.30);
1245 createHisto("mfitTILbL0", 60, 1.00, 1.30);
1246 createHisto("mfitDDLbL0", 60, 1.00, 1.30);
1247 createHisto("mfitTDLbL0", 60, 1.00, 1.30);
1248
1249 createHisto("massFull", 200, 2.00, 12.0);
1250
1251 createHisto("ctauDIJPsi", 60, -0.05, 0.25);
1252 createHisto("ctauTIJPsi", 60, -0.05, 0.25);
1253 createHisto("ctauDBJPsi", 60, -0.05, 0.25);
1254 createHisto("ctauTBJPsi", 60, -0.05, 0.25);
1255 createHisto("ctauDIBu", 60, -0.05, 0.25);
1256 createHisto("ctauTIBu", 60, -0.05, 0.25);
1257 createHisto("ctauDDBu", 60, -0.05, 0.25);
1258 createHisto("ctauTDBu", 60, -0.05, 0.25);
1259 createHisto("ctauDIBd", 60, -0.05, 0.25);
1260 createHisto("ctauTIBd", 60, -0.05, 0.25);
1261 createHisto("ctauDDBd", 60, -0.05, 0.25);
1262 createHisto("ctauTDBd", 60, -0.05, 0.25);
1263 createHisto("ctauDIBs", 60, -0.05, 0.25);
1264 createHisto("ctauTIBs", 60, -0.05, 0.25);
1265 createHisto("ctauDDBs", 60, -0.05, 0.25);
1266 createHisto("ctauTDBs", 60, -0.05, 0.25);
1267 createHisto("ctauDIB0", 60, -0.05, 0.25);
1268 createHisto("ctauTIB0", 60, -0.05, 0.25);
1269 createHisto("ctauDDB0", 60, -0.05, 0.25);
1270 createHisto("ctauTDB0", 60, -0.05, 0.25);
1271 createHisto("ctauDILambdab", 60, -0.05, 0.25);
1272 createHisto("ctauTILambdab", 60, -0.05, 0.25);
1273 createHisto("ctauDDLambdab", 60, -0.05, 0.25);
1274 createHisto("ctauTDLambdab", 60, -0.05, 0.25);
1275
1276 recoName = new string;
1277 tree = fs->make<TTree>("BPHReco", "BPHReco");
1278 b_runNumber = tree->Branch("runNumber", &runNumber, "runNumber/i");
1279 b_lumiSection = tree->Branch("lumiSection", &lumiSection, "lumiSection/i");
1280 b_eventNumber = tree->Branch("eventNumber", &eventNumber, "eventNumber/i");
1281 b_recoName = tree->Branch("recoName", &recoName, 8192, 99);
1282 b_recoMass = tree->Branch("recoMass", &recoMass, "recoMass/F");
1283 b_recoTime = tree->Branch("recoTime", &recoTime, "recoTime/F");
1284 b_recoErrT = tree->Branch("recoErrT", &recoErrT, "recoErrT/F");
1285
1286 return;
1287 }
1288
1289 void BPHHistoSpecificDecay::analyze(const edm::Event& ev, const edm::EventSetup& es) {
1290 static map<string, ofstream*> ofMap;
1291 if (ofMap.empty()) {
1292 ofMap["BarPhi"] = nullptr;
1293 ofMap["IncJPsi"] = nullptr;
1294 ofMap["BarJPsi"] = nullptr;
1295 ofMap["IncPsi2"] = nullptr;
1296 ofMap["BarPsi2"] = nullptr;
1297 ofMap["BarUpsilon123"] = nullptr;
1298 ofMap["InclusiveBu"] = nullptr;
1299 ofMap["DisplacedBu"] = nullptr;
1300 ofMap["InclusiveBd"] = nullptr;
1301 ofMap["DisplacedBd"] = nullptr;
1302 ofMap["InclusiveBs"] = nullptr;
1303 ofMap["DisplacedBs"] = nullptr;
1304 ofMap["K0s"] = nullptr;
1305 ofMap["Lambda0"] = nullptr;
1306 ofMap["InclusiveB0"] = nullptr;
1307 ofMap["DisplacedB0"] = nullptr;
1308 ofMap["InclusiveLambdab"] = nullptr;
1309 ofMap["DisplacedLambdab"] = nullptr;
1310 ofMap["InclusiveBc"] = nullptr;
1311 ofMap["DisplacedBc"] = nullptr;
1312 ofMap["InclusiveX3872"] = nullptr;
1313 ofMap["DisplacedX3872"] = nullptr;
1314 map<string, ofstream*>::iterator iter = ofMap.begin();
1315 map<string, ofstream*>::iterator iend = ofMap.end();
1316 string name = "list";
1317 while (iter != iend) {
1318 iter->second = new ofstream(name + iter->first);
1319 ++iter;
1320 }
1321 }
1322
1323
1324 runNumber = ev.id().run();
1325 lumiSection = ev.id().luminosityBlock();
1326 eventNumber = ev.id().event();
1327
1328
1329
1330
1331
1332
1333
1334 edm::Handle<edm::TriggerResults> trigResults;
1335 const edm::TriggerNames* trigNames = nullptr;
1336 if (useTrig) {
1337 trigResultsToken.get(ev, trigResults);
1338 if (trigResults.isValid())
1339 trigNames = &ev.triggerNames(*trigResults);
1340 }
1341
1342 bool flag_Dimuon25_Jpsi = false;
1343 bool flag_Dimuon20_Jpsi_Barrel_Seagulls = false;
1344 bool flag_Dimuon14_Phi_Barrel_Seagulls = false;
1345 bool flag_Dimuon18_PsiPrime = false;
1346 bool flag_Dimuon10_PsiPrime_Barrel_Seagulls = false;
1347 bool flag_Dimuon12_Upsilon_eta1p5 = false;
1348 bool flag_Dimuon12_Upsilon_y1p4 = false;
1349 bool flag_DoubleMu4_JpsiTrk_Displaced = false;
1350 if (trigNames != nullptr) {
1351 const edm::TriggerNames::Strings& names = trigNames->triggerNames();
1352 int iObj;
1353 int nObj = names.size();
1354 for (iObj = 0; iObj < nObj; ++iObj) {
1355
1356 CHK_TRIG(trigResults, names, iObj, Dimuon25_Jpsi)
1357 CHK_TRIG(trigResults, names, iObj, Dimuon20_Jpsi_Barrel_Seagulls)
1358 CHK_TRIG(trigResults, names, iObj, Dimuon14_Phi_Barrel_Seagulls)
1359 CHK_TRIG(trigResults, names, iObj, Dimuon18_PsiPrime)
1360 CHK_TRIG(trigResults, names, iObj, Dimuon10_PsiPrime_Barrel_Seagulls)
1361 CHK_TRIG(trigResults, names, iObj, Dimuon12_Upsilon_eta1p5)
1362 CHK_TRIG(trigResults, names, iObj, Dimuon12_Upsilon_y1p4)
1363 CHK_TRIG(trigResults, names, iObj, DoubleMu4_JpsiTrk_Displaced)
1364 }
1365 }
1366
1367
1368
1369 edm::Handle<vector<pat::CompositeCandidate> > oniaCands;
1370 int iqo;
1371 int nqo = 0;
1372 if (useOnia) {
1373 oniaCandsToken.get(ev, oniaCands);
1374 nqo = oniaCands->size();
1375 }
1376
1377 for (iqo = 0; iqo < nqo; ++iqo) {
1378 LogTrace("DataDump") << "*********** quarkonium " << iqo << "/" << nqo << " ***********";
1379 const pat::CompositeCandidate& cand = oniaCands->at(iqo);
1380 if (!oniaVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex")))
1381 continue;
1382 if (!oniaDaughterSelect->accept(cand))
1383 continue;
1384 fillHisto("Full", cand, 'c');
1385 if (phiBBasicSelect->accept(cand)) {
1386 fillHisto("DBPhi", cand, 'c');
1387 if (flag_Dimuon14_Phi_Barrel_Seagulls)
1388 fillHisto("TBPhi", cand, 'c');
1389 if (flag_Dimuon14_Phi_Barrel_Seagulls)
1390 *ofMap["BarPhi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1391 << cand.mass() << endl;
1392 }
1393 if (jPsiIBasicSelect->accept(cand)) {
1394 fillHisto("DIJPsi", cand, 'c');
1395 if (flag_Dimuon25_Jpsi)
1396 fillHisto("TIJPsi", cand, 'c');
1397 if (flag_Dimuon25_Jpsi)
1398 *ofMap["IncJPsi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1399 << cand.mass() << endl;
1400 }
1401 if (jPsiBBasicSelect->accept(cand)) {
1402 fillHisto("DBJPsi", cand, 'c');
1403 if (flag_Dimuon20_Jpsi_Barrel_Seagulls)
1404 fillHisto("TBJPsi", cand, 'c');
1405 if (flag_Dimuon20_Jpsi_Barrel_Seagulls)
1406 *ofMap["BarJPsi"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1407 << cand.mass() << endl;
1408 }
1409 if (psi2IBasicSelect->accept(cand)) {
1410 fillHisto("DIPsi2", cand, 'c');
1411 if (flag_Dimuon18_PsiPrime)
1412 fillHisto("TIPsi2", cand, 'c');
1413 if (flag_Dimuon18_PsiPrime)
1414 *ofMap["IncPsi2"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1415 << cand.mass() << endl;
1416 }
1417 if (psi2BBasicSelect->accept(cand)) {
1418 fillHisto("DBPsi2", cand, 'c');
1419 if (flag_Dimuon10_PsiPrime_Barrel_Seagulls)
1420 fillHisto("TBPsi2", cand, 'c');
1421 if (flag_Dimuon10_PsiPrime_Barrel_Seagulls)
1422 *ofMap["BarPsi2"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1423 << cand.mass() << endl;
1424 }
1425 if (upsBBasicSelect->accept(cand)) {
1426 fillHisto("DBUps123", cand, 'c');
1427 if (flag_Dimuon12_Upsilon_eta1p5 || flag_Dimuon12_Upsilon_y1p4)
1428 fillHisto("TBUps123", cand, 'c');
1429 if (flag_Dimuon12_Upsilon_eta1p5 || flag_Dimuon12_Upsilon_y1p4)
1430 *ofMap["BarUpsilon123"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1431 << cand.mass() << endl;
1432 }
1433 }
1434
1435
1436
1437 edm::Handle<vector<pat::CompositeCandidate> > buCands;
1438 int ibu;
1439 int nbu = 0;
1440 if (useBu) {
1441 buCandsToken.get(ev, buCands);
1442 nbu = buCands->size();
1443 }
1444
1445 for (ibu = 0; ibu < nbu; ++ibu) {
1446 LogTrace("DataDump") << "*********** Bu " << ibu << "/" << nbu << " ***********";
1447 const pat::CompositeCandidate& cand = buCands->at(ibu);
1448 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1449 LogTrace("DataDump") << "JPsi: " << jPsi;
1450 if (jPsi == nullptr)
1451 continue;
1452 if (!npJPsiBasicSelect->accept(*jPsi))
1453 continue;
1454 if (!npJPsiDaughterSelect->accept(*jPsi))
1455 continue;
1456 const reco::Candidate* kptr = BPHDaughters::get(cand, 0.49, 0.50).front();
1457 if (kptr == nullptr)
1458 continue;
1459 if (buIBasicSelect->accept(cand) && buIJPsiBasicSelect->accept(*jPsi) &&
1460
1461
1462 buIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1463 (kptr->pt() > buIKPtMin)) {
1464 fillHisto("DIBu", cand, 'f');
1465 fillHisto("DIBuJPsi", *jPsi, 'c');
1466 if (flag_Dimuon25_Jpsi) {
1467 fillHisto("TIBu", cand, 'f');
1468 fillHisto("TIBuJPsi", *jPsi, 'c');
1469 *ofMap["InclusiveBu"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1470 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1471 }
1472 }
1473 if (buDBasicSelect->accept(cand) && buDJPsiBasicSelect->accept(*jPsi) &&
1474
1475
1476 buDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1477 (kptr->pt() > buDKPtMin)) {
1478 fillHisto("DDBu", cand, 'f');
1479 fillHisto("DDBuJPsi", *jPsi, 'c');
1480 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1481 fillHisto("TDBu", cand, 'f');
1482 fillHisto("TDBuJPsi", *jPsi, 'c');
1483 *ofMap["DisplacedBu"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1484 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1485 }
1486 }
1487 }
1488
1489
1490
1491 edm::Handle<vector<pat::CompositeCandidate> > bdCands;
1492 int ibd;
1493 int nbd = 0;
1494 if (useBd) {
1495 bdCandsToken.get(ev, bdCands);
1496 nbd = bdCands->size();
1497 }
1498
1499 for (ibd = 0; ibd < nbd; ++ibd) {
1500 LogTrace("DataDump") << "*********** Bd " << ibd << "/" << nbd << " ***********";
1501 const pat::CompositeCandidate& cand = bdCands->at(ibd);
1502 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1503 LogTrace("DataDump") << "JPsi: " << jPsi;
1504 if (jPsi == nullptr)
1505 continue;
1506 if (!npJPsiBasicSelect->accept(*jPsi))
1507 continue;
1508 if (!npJPsiDaughterSelect->accept(*jPsi))
1509 continue;
1510 const pat::CompositeCandidate* kx0 = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToKx0");
1511 LogTrace("DataDump") << "Kx0: " << kx0;
1512 if (kx0 == nullptr)
1513 continue;
1514 if (bdIBasicSelect->accept(cand) && bdIJPsiBasicSelect->accept(*jPsi) && bdIKx0BasicSelect->accept(*kx0) &&
1515
1516
1517 bdIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1518 fillHisto("DIBd", cand, 'f');
1519 fillHisto("DIBdJPsi", *jPsi, 'c');
1520 fillHisto("DIBdKx0", *kx0, 'c');
1521 if (flag_Dimuon25_Jpsi) {
1522 fillHisto("TIBd", cand, 'f');
1523 fillHisto("TIBdJPsi", *jPsi, 'c');
1524 fillHisto("TIBdKx0", *kx0, 'c');
1525 *ofMap["InclusiveBd"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1526 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1527 }
1528 }
1529 if (bdDBasicSelect->accept(cand) && bdDJPsiBasicSelect->accept(*jPsi) && bdDKx0BasicSelect->accept(*kx0) &&
1530
1531
1532 bdDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1533 fillHisto("DDBd", cand, 'f');
1534 fillHisto("DDBdJPsi", *jPsi, 'c');
1535 fillHisto("DDBdKx0", *kx0, 'c');
1536 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1537 fillHisto("TDBd", cand, 'f');
1538 fillHisto("TDBdJPsi", *jPsi, 'c');
1539 fillHisto("TDBdKx0", *kx0, 'c');
1540 *ofMap["DisplacedBd"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1541 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1542 }
1543 }
1544 }
1545
1546
1547
1548 edm::Handle<vector<pat::CompositeCandidate> > bsCands;
1549 int ibs;
1550 int nbs = 0;
1551 if (useBs) {
1552 bsCandsToken.get(ev, bsCands);
1553 nbs = bsCands->size();
1554 }
1555
1556 for (ibs = 0; ibs < nbs; ++ibs) {
1557 LogTrace("DataDump") << "*********** Bs " << ibs << "/" << nbs << " ***********";
1558 const pat::CompositeCandidate& cand = bsCands->at(ibs);
1559 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1560 LogTrace("DataDump") << "JPsi: " << jPsi;
1561 if (jPsi == nullptr)
1562 continue;
1563 if (!npJPsiBasicSelect->accept(*jPsi))
1564 continue;
1565 if (!npJPsiDaughterSelect->accept(*jPsi))
1566 continue;
1567 const pat::CompositeCandidate* phi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToPhi");
1568 LogTrace("DataDump") << "Phi: " << phi;
1569 if (phi == nullptr)
1570 continue;
1571 if (bsIBasicSelect->accept(cand) && bsIJPsiBasicSelect->accept(*jPsi) && bsIPhiBasicSelect->accept(*phi) &&
1572
1573
1574 bsIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1575 fillHisto("DIBs", cand, 'f');
1576 fillHisto("DIBsJPsi", *jPsi, 'c');
1577 fillHisto("DIBsPhi", *phi, 'c');
1578 if (flag_Dimuon25_Jpsi) {
1579 fillHisto("TIBs", cand, 'f');
1580 fillHisto("TIBsJPsi", *jPsi, 'c');
1581 fillHisto("TIBsPhi", *phi, 'c');
1582 *ofMap["InclusiveBs"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1583 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1584 }
1585 }
1586 if (bsDBasicSelect->accept(cand) && bsDJPsiBasicSelect->accept(*jPsi) && bsDPhiBasicSelect->accept(*phi) &&
1587
1588
1589 bsDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1590 fillHisto("DDBs", cand, 'f');
1591 fillHisto("DDBsJPsi", *jPsi, 'c');
1592 fillHisto("DDBsPhi", *phi, 'c');
1593 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1594 fillHisto("TDBs", cand, 'f');
1595 fillHisto("TDBsJPsi", *jPsi, 'c');
1596 fillHisto("TDBsPhi", *phi, 'c');
1597 *ofMap["DisplacedBs"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1598 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1599 }
1600 }
1601 }
1602
1603
1604
1605 edm::Handle<vector<pat::CompositeCandidate> > k0Cands;
1606 int ik0;
1607 int nk0 = 0;
1608 if (useK0) {
1609 k0CandsToken.get(ev, k0Cands);
1610 nk0 = k0Cands->size();
1611 }
1612
1613 for (ik0 = 0; ik0 < nk0; ++ik0) {
1614 LogTrace("DataDump") << "*********** K0 " << ik0 << "/" << nk0 << " ***********";
1615 const pat::CompositeCandidate& cand = k0Cands->at(ik0);
1616 fillHisto("DK0s", cand, 'f');
1617 *ofMap["K0s"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1618 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1619 }
1620
1621
1622
1623 edm::Handle<vector<pat::CompositeCandidate> > l0Cands;
1624 int il0;
1625 int nl0 = 0;
1626 if (useL0) {
1627 l0CandsToken.get(ev, l0Cands);
1628 nl0 = l0Cands->size();
1629 }
1630
1631 for (il0 = 0; il0 < nl0; ++il0) {
1632 LogTrace("DataDump") << "*********** Lambda0 " << il0 << "/" << nl0 << " ***********";
1633 const pat::CompositeCandidate& cand = l0Cands->at(il0);
1634 fillHisto("DLambda0", cand, 'f');
1635 *ofMap["Lambda0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1636 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1637 }
1638
1639
1640
1641 edm::Handle<vector<pat::CompositeCandidate> > b0Cands;
1642 int ib0;
1643 int nb0 = 0;
1644 if (useB0) {
1645 b0CandsToken.get(ev, b0Cands);
1646 nb0 = b0Cands->size();
1647 }
1648
1649 for (ib0 = 0; ib0 < nb0; ++ib0) {
1650 LogTrace("DataDump") << "*********** B0 " << ib0 << "/" << nb0 << " ***********";
1651 const pat::CompositeCandidate& cand = b0Cands->at(ib0);
1652 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1653 LogTrace("DataDump") << "JPsi: " << jPsi;
1654 if (jPsi == nullptr)
1655 continue;
1656 if (!npJPsiBasicSelect->accept(*jPsi))
1657 continue;
1658 if (!npJPsiDaughterSelect->accept(*jPsi))
1659 continue;
1660 const pat::CompositeCandidate* k0s = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToK0s");
1661 LogTrace("DataDump") << "K0s: " << k0s;
1662 if (k0s == nullptr)
1663 continue;
1664 if (b0IBasicSelect->accept(cand) && b0IJPsiBasicSelect->accept(*jPsi) && b0IK0sBasicSelect->accept(*k0s) &&
1665
1666
1667 b0IVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1668 fillHisto("DIB0", cand, 'f');
1669 fillHisto("DIB0JPsi", *jPsi, 'c');
1670 fillHisto("DIB0K0s", *k0s, 'c');
1671 if (flag_Dimuon25_Jpsi) {
1672 fillHisto("TIB0", cand, 'f');
1673 fillHisto("TIB0JPsi", *jPsi, 'c');
1674 fillHisto("TIB0K0s", *k0s, 'c');
1675 *ofMap["InclusiveB0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1676 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1677 }
1678 }
1679 if (b0DBasicSelect->accept(cand) && b0DJPsiBasicSelect->accept(*jPsi) && b0DK0sBasicSelect->accept(*k0s) &&
1680
1681
1682 b0DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1683 fillHisto("DDB0", cand, 'f');
1684 fillHisto("DDB0JPsi", *jPsi, 'c');
1685 fillHisto("DDB0K0s", *k0s, 'c');
1686 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1687 fillHisto("TDB0", cand, 'f');
1688 fillHisto("TDB0JPsi", *jPsi, 'c');
1689 fillHisto("TDB0K0s", *k0s, 'c');
1690 *ofMap["DisplacedB0"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1691 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1692 }
1693 }
1694 }
1695
1696
1697
1698 edm::Handle<vector<pat::CompositeCandidate> > lbCands;
1699 int ilb;
1700 int nlb = 0;
1701 if (useLb) {
1702 lbCandsToken.get(ev, lbCands);
1703 nlb = lbCands->size();
1704 }
1705
1706 for (ilb = 0; ilb < nlb; ++ilb) {
1707 LogTrace("DataDump") << "*********** Lambdab " << ilb << "/" << nlb << " ***********";
1708 const pat::CompositeCandidate& cand = lbCands->at(ilb);
1709 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1710 LogTrace("DataDump") << "JPsi: " << jPsi;
1711 if (jPsi == nullptr)
1712 continue;
1713 if (!npJPsiBasicSelect->accept(*jPsi))
1714 continue;
1715 if (!npJPsiDaughterSelect->accept(*jPsi))
1716 continue;
1717 const pat::CompositeCandidate* l0 = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToLambda0");
1718 LogTrace("DataDump") << "Lambda0: " << l0;
1719 if (l0 == nullptr)
1720 continue;
1721 if (lbIBasicSelect->accept(cand) && lbIJPsiBasicSelect->accept(*jPsi) && lbILambda0BasicSelect->accept(*l0) &&
1722
1723
1724 lbIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1725 fillHisto("DILambdab", cand, 'f');
1726 fillHisto("DILbJPsi", *jPsi, 'c');
1727 fillHisto("DILbL0", *l0, 'c');
1728 if (flag_Dimuon25_Jpsi) {
1729 fillHisto("TILambdab", cand, 'f');
1730 fillHisto("TILbJPsi", *jPsi, 'c');
1731 fillHisto("TILbL0", *l0, 'c');
1732 *ofMap["InclusiveLambdab"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1733 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1734 }
1735 }
1736 if (lbDBasicSelect->accept(cand) && lbDJPsiBasicSelect->accept(*jPsi) && lbDLambda0BasicSelect->accept(*l0) &&
1737
1738
1739 lbDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex"))) {
1740 fillHisto("DDLambdab", cand, 'f');
1741 fillHisto("DDLbJPsi", *jPsi, 'c');
1742 fillHisto("DDLbL0", *l0, 'c');
1743 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1744 fillHisto("TDLambdab", cand, 'f');
1745 fillHisto("TDLbJPsi", *jPsi, 'c');
1746 fillHisto("TDLbL0", *l0, 'c');
1747 *ofMap["DisplacedLambdab"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1748 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1749 }
1750 }
1751 }
1752
1753
1754
1755 edm::Handle<vector<pat::CompositeCandidate> > bcCands;
1756 int ibc;
1757 int nbc = 0;
1758 if (useBc) {
1759 bcCandsToken.get(ev, bcCands);
1760 nbc = bcCands->size();
1761 }
1762
1763 for (ibc = 0; ibc < nbc; ++ibc) {
1764 LogTrace("DataDump") << "*********** Bc " << ibc << "/" << nbc << " ***********";
1765 const pat::CompositeCandidate& cand = bcCands->at(ibc);
1766 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1767 LogTrace("DataDump") << "JPsi: " << jPsi;
1768 if (jPsi == nullptr)
1769 continue;
1770
1771
1772 if (!npJPsiBasicSelect->accept(*jPsi))
1773 continue;
1774 if (!npJPsiDaughterSelect->accept(*jPsi))
1775 continue;
1776 const reco::Candidate* pptr = BPHDaughters::get(cand, 0.13, 0.14).front();
1777 if (pptr == nullptr)
1778 continue;
1779
1780 if (bcIBasicSelect->accept(cand) && bcIJPsiBasicSelect->accept(*jPsi) &&
1781
1782
1783 bcIJPsiVertexSelect->accept(*jPsi, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1784 bcIVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1785 (pptr->pt() > bcIPiPtMin)) {
1786 fillHisto("DIBc", cand, 'f');
1787 fillHisto("DIBcJPsi", *jPsi, 'c');
1788 if (flag_Dimuon25_Jpsi) {
1789 fillHisto("TIBc", cand, 'f');
1790 fillHisto("TIBcJPsi", *jPsi, 'c');
1791 *ofMap["InclusiveBc"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1792 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1793 }
1794 }
1795 if (bcDBasicSelect->accept(cand) && bcDJPsiBasicSelect->accept(*jPsi) &&
1796
1797
1798 bcDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1799 bcDVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1800 (pptr->pt() > bcDPiPtMin)) {
1801 fillHisto("DDBc", cand, 'f');
1802 fillHisto("DDBcJPsi", *jPsi, 'c');
1803 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1804 fillHisto("TDBc", cand, 'f');
1805 fillHisto("TDBcJPsi", *jPsi, 'c');
1806 *ofMap["DisplacedBc"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1807 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1808 }
1809 }
1810 }
1811
1812
1813
1814 edm::Handle<vector<pat::CompositeCandidate> > x3872Cands;
1815 int ix3872;
1816 int nx3872 = 0;
1817 if (useX3872) {
1818 x3872CandsToken.get(ev, x3872Cands);
1819 nx3872 = x3872Cands->size();
1820 }
1821
1822 for (ix3872 = 0; ix3872 < nx3872; ++ix3872) {
1823 LogTrace("DataDump") << "*********** X3872 " << ix3872 << "/" << nx3872 << " ***********";
1824 const pat::CompositeCandidate& cand = x3872Cands->at(ix3872);
1825 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1826 LogTrace("DataDump") << "JPsi: " << jPsi;
1827 if (jPsi == nullptr)
1828 continue;
1829
1830
1831 if (!npJPsiBasicSelect->accept(*jPsi))
1832 continue;
1833 if (!npJPsiDaughterSelect->accept(*jPsi))
1834 continue;
1835 const reco::Candidate* ppt1 = BPHDaughters::get(cand, 0.13, 0.14)[0];
1836 const reco::Candidate* ppt2 = BPHDaughters::get(cand, 0.13, 0.14)[1];
1837 if (ppt1 == nullptr)
1838 continue;
1839 if (ppt2 == nullptr)
1840 continue;
1841 if (x3872IBasicSelect->accept(cand) && x3872IJPsiBasicSelect->accept(*jPsi) &&
1842
1843
1844 x3872IJPsiVertexSelect->accept(*jPsi, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1845 x3872IVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1846 (ppt1->pt() > x3872IPiPtMin) && (ppt2->pt() > x3872IPiPtMin)) {
1847 fillHisto("DIX3872", cand, 'f');
1848 fillHisto("DIX3872JPsi", *jPsi, 'c');
1849 if (flag_Dimuon25_Jpsi) {
1850 fillHisto("TIX3872", cand, 'f');
1851 fillHisto("TIX3872JPsi", *jPsi, 'c');
1852 *ofMap["InclusiveX3872"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1853 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1854 }
1855 }
1856 if (x3872DBasicSelect->accept(cand) && x3872DJPsiBasicSelect->accept(*jPsi) &&
1857
1858
1859 x3872DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1860 x3872DVertexSelect->accept(cand, BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex")) &&
1861 (ppt1->pt() > x3872DPiPtMin) && (ppt2->pt() > x3872DPiPtMin)) {
1862 fillHisto("DDX3872", cand, 'f');
1863 fillHisto("DDX3872JPsi", *jPsi, 'c');
1864 if (flag_DoubleMu4_JpsiTrk_Displaced) {
1865 fillHisto("TDX3872", cand, 'f');
1866 fillHisto("TDX3872JPsi", *jPsi, 'c');
1867 *ofMap["DisplacedX3872"] << ev.id().run() << ' ' << ev.id().luminosityBlock() << ' ' << ev.id().event() << ' '
1868 << (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1) << endl;
1869 }
1870 }
1871 }
1872
1873 return;
1874 }
1875
1876 void BPHHistoSpecificDecay::endJob() { return; }
1877
1878 void BPHHistoSpecificDecay::fillHisto(const string& name, const pat::CompositeCandidate& cand, char svType) {
1879 *recoName = name;
1880 float mass = (cand.hasUserFloat("fitMass") ? cand.userFloat("fitMass") : -1);
1881 fillHisto("mass" + name, cand.mass());
1882 fillHisto("mfit" + name, mass);
1883 recoMass = mass;
1884 recoTime = -999999.0;
1885 recoErrT = -999999.0;
1886
1887 const reco::Vertex* pvtx = BPHUserData::getByRef<reco::Vertex>(cand, "primaryVertex");
1888 if (pvtx == nullptr) {
1889 const pat::CompositeCandidate* jPsi = BPHUserData::getByRef<pat::CompositeCandidate>(cand, "refToJPsi");
1890 if (jPsi == nullptr)
1891 return;
1892 pvtx = BPHUserData::getByRef<reco::Vertex>(*jPsi, "primaryVertex");
1893 }
1894
1895 if (pvtx != nullptr) {
1896 const reco::Vertex* svtx = nullptr;
1897 if (svType == 'f')
1898 svtx = BPHUserData::get<reco::Vertex>(cand, "fitVertex");
1899 if (svtx == nullptr)
1900 svtx = BPHUserData::get<reco::Vertex>(cand, "vertex");
1901 if (svtx != nullptr) {
1902 float px;
1903 float py;
1904 const Vector3DBase<float, GlobalTag>* fmom =
1905 BPHUserData::get<Vector3DBase<float, GlobalTag> >(cand, "fitMomentum");
1906 if (fmom != nullptr) {
1907 px = fmom->x();
1908 py = fmom->y();
1909 } else {
1910 px = cand.px();
1911 py = cand.py();
1912 }
1913 double ctauPV2;
1914 double ctauErrPV2;
1915 VertexAnalysis::dist2D(pvtx, svtx, px, py, mass, ctauPV2, ctauErrPV2);
1916 recoTime = ctauPV2;
1917 recoErrT = ctauErrPV2;
1918 fillHisto("ctau" + name, ctauPV2);
1919 }
1920 }
1921 tree->Fill();
1922 return;
1923 }
1924
1925 void BPHHistoSpecificDecay::fillHisto(const string& name, float x) {
1926 map<string, TH1F*>::iterator iter = histoMap.find(name);
1927 map<string, TH1F*>::iterator iend = histoMap.end();
1928 if (iter == iend)
1929 return;
1930 iter->second->Fill(x);
1931 return;
1932 }
1933
1934 void BPHHistoSpecificDecay::createHisto(const string& name, int nbin, float hmin, float hmax) {
1935 histoMap[name] = fs->make<TH1F>(name.c_str(), name.c_str(), nbin, hmin, hmax);
1936 return;
1937 }
1938
1939 #include "FWCore/Framework/interface/MakerMacros.h"
1940
1941 DEFINE_FWK_MODULE(BPHHistoSpecificDecay);