SpecificDecay/src/BPHOniaToMuMuBuilder.cc

0001 /*
0002  *  See header file for a description of this class.
0003  *
0004  *  \author Paolo Ronchese INFN Padova
0005  *
0006  */
0007
0008 //-----------------------
0009 // This Class' Header --
0010 //-----------------------
0011 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHOniaToMuMuBuilder.h"
0012
0013 //-------------------------------
0014 // Collaborating Class Headers --
0015 //-------------------------------
0016 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMuonPtSelect.h"
0017 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMuonEtaSelect.h"
0018 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMassSelect.h"
0019 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHChi2Select.h"
0020 #include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"
0021 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
0022 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoSelect.h"
0023 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHPlusMinusCandidate.h"
0024 #include "HeavyFlavorAnalysis/RecoDecay/interface/BPHMultiSelect.h"
0025
0026 //---------------
0027 // C++ Headers --
0028 //---------------
0029 using namespace std;
0030
0031 //-------------------
0032 // Initializations --
0033 //-------------------
0034
0035 //----------------
0036 // Constructors --
0037 //----------------
0038 BPHOniaToMuMuBuilder::BPHOniaToMuMuBuilder(const BPHEventSetupWrapper& es,
0039                                            const BPHRecoBuilder::BPHGenericCollection* muPosCollection,
0040                                            const BPHRecoBuilder::BPHGenericCollection* muNegCollection)
0041     : BPHDecayGenericBuilderBase(es),
0042       muPosName("MuPos"),
0043       muNegName("MuNeg"),
0044       posCollection(muPosCollection),
0045       negCollection(muNegCollection) {
0046   setParameters(NRes, 2.0, 10.0, 0.01, 50.00, 2.0, -1.0, 0.0);
0047   setParameters(Phi, 2.0, 10.0, 0.50, 1.50, 0.0, BPHParticleMasses::phiMass, BPHParticleMasses::phiMWidth);
0048   setParameters(Psi1, 2.0, 10.0, 2.00, 3.40, 0.0, BPHParticleMasses::jPsiMass, BPHParticleMasses::jPsiMWidth);
0049   setParameters(Psi2, 2.0, 10.0, 3.40, 6.00, 0.0, BPHParticleMasses::psi2Mass, BPHParticleMasses::psi2MWidth);
0050   setParameters(Ups, 2.0, 10.0, 6.00, 12.00, 0.0, -1.0, 0.0);
0051   setParameters(Ups1, 2.0, 10.0, 6.00, 9.75, 0.0, BPHParticleMasses::ups1Mass, BPHParticleMasses::ups1MWidth);
0052   setParameters(Ups2, 2.0, 10.0, 9.75, 10.20, 0.0, BPHParticleMasses::ups2Mass, BPHParticleMasses::ups2MWidth);
0053   setParameters(Ups3, 2.0, 10.0, 10.20, 12.00, 0.0, BPHParticleMasses::ups3Mass, BPHParticleMasses::ups3MWidth);
0054   outdated = true;
0055 }
0056
0057 //--------------
0058 // Destructor --
0059 //--------------
0060 BPHOniaToMuMuBuilder::~BPHOniaToMuMuBuilder() {
0061   map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
0062   map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
0063   while (iter != iend) {
0064     OniaParameters& par = iter++->second;
0065     delete par.ptSel;
0066     delete par.etaSel;
0067     delete par.massSel;
0068     delete par.chi2Sel;
0069   }
0070 }
0071
0072 //--------------
0073 // Operations --
0074 //--------------
0075 void BPHOniaToMuMuBuilder::fillRecList() {
0076   double ptMin = 9.99e+30;
0077   double etaMax = -1.0;
0078   BPHMultiSelect<BPHSlimSelect<BPHMomentumSelect>> mSel(BPHSelectOperation::or_mode);
0079   BPHMultiSelect<BPHSlimSelect<BPHVertexSelect>> vSel(BPHSelectOperation::or_mode);
0080
0081   map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
0082   map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
0083   while (iter != iend) {
0084     OniaParameters& par = iter++->second;
0085     double ptCur = par.ptSel->getPtMin();
0086     double etaCur = par.etaSel->getEtaMax();
0087     if (ptCur < ptMin)
0088       ptMin = ptCur;
0089     if (etaCur > etaMax)
0090       etaMax = etaCur;
0091     mSel.include(*par.massSel);
0092     vSel.include(*par.chi2Sel);
0093   }
0094   BPHMuonPtSelect ptSel(ptMin);
0095   BPHMuonEtaSelect etaSel(etaMax);
0096
0097   BPHRecoBuilder bOnia(*evSetup);
0098   bOnia.add(muPosName, posCollection, BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
0099   bOnia.add(muNegName, negCollection, BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
0100   bOnia.filter(muPosName, ptSel);
0101   bOnia.filter(muNegName, ptSel);
0102   bOnia.filter(muPosName, etaSel);
0103   bOnia.filter(muNegName, etaSel);
0104   bOnia.filter(mSel);
0105   bOnia.filter(vSel);
0106
0107   recList = BPHPlusMinusCandidate::build(bOnia, muPosName, muNegName);
0108
0109   decltype(recList) tmpList;
0110   tmpList.reserve(recList.size());
0111   for (auto& c : recList) {
0112     auto p = c->originalReco(c->getDaug(muPosName));
0113     auto n = c->originalReco(c->getDaug(muNegName));
0114     bool accept = false;
0115     for (auto& e : oniaPar) {
0116       if (e.first == NRes)
0117         continue;
0118       auto& s = e.second;
0119       if ((s.ptSel->accept(*p)) && (s.ptSel->accept(*n)) && (s.etaSel->accept(*p)) && (s.etaSel->accept(*n)) &&
0120           (s.massSel->accept(*c)) && (s.chi2Sel->accept(*c))) {
0121         accept = true;
0122         break;
0123       }
0124     }
0125     if (accept)
0126       tmpList.push_back(c);
0127   }
0128   recList = tmpList;
0129
0130   return;
0131 }
0132
0133 vector<BPHPlusMinusConstCandPtr> BPHOniaToMuMuBuilder::getList(
0134     oniaType type, BPHRecoSelect* dSel, BPHMomentumSelect* mSel, BPHVertexSelect* vSel, BPHFitSelect* kSel) {
0135   extractList(type);
0136   vector<BPHPlusMinusConstCandPtr>& list = oniaList[type];
0137   int i;
0138   int n = list.size();
0139   vector<BPHPlusMinusConstCandPtr> lsub;
0140   lsub.reserve(n);
0141   for (i = 0; i < n; ++i) {
0142     BPHPlusMinusConstCandPtr ptr = list[i];
0143     const reco::Candidate* muPos = ptr->originalReco(ptr->getDaug(muPosName));
0144     const reco::Candidate* muNeg = ptr->originalReco(ptr->getDaug(muNegName));
0145     if ((dSel != nullptr) && (!dSel->accept(*muPos)))
0146       continue;
0147     if ((dSel != nullptr) && (!dSel->accept(*muNeg)))
0148       continue;
0149     if ((mSel != nullptr) && (!mSel->accept(*ptr)))
0150       continue;
0151     if ((vSel != nullptr) && (!vSel->accept(*ptr)))
0152       continue;
0153     if ((kSel != nullptr) && (!kSel->accept(*ptr)))
0154       continue;
0155     lsub.push_back(list[i]);
0156   }
0157   return lsub;
0158 }
0159
0160 BPHPlusMinusConstCandPtr BPHOniaToMuMuBuilder::getOriginalCandidate(const BPHRecoCandidate& cand) {
0161   const reco::Candidate* mp = cand.originalReco(cand.getDaug(muPosName));
0162   const reco::Candidate* mn = cand.originalReco(cand.getDaug(muNegName));
0163   int nc = recList.size();
0164   int ic;
0165   for (ic = 0; ic < nc; ++ic) {
0166     BPHPlusMinusConstCandPtr pmp = recList[ic];
0167     const BPHPlusMinusCandidate* pmc = pmp.get();
0168     if (pmc->originalReco(pmc->getDaug(muPosName)) != mp)
0169       continue;
0170     if (pmc->originalReco(pmc->getDaug(muNegName)) != mn)
0171       continue;
0172     return pmp;
0173   }
0174   return BPHPlusMinusConstCandPtr(nullptr);
0175 }
0176
0177 /// set cuts
0178 void BPHOniaToMuMuBuilder::setPtMin(oniaType type, double pt) {
0179   setNotUpdated();
0180   OniaParameters& par = oniaPar[type];
0181   par.ptSel->setPtMin(pt);
0182   return;
0183 }
0184
0185 void BPHOniaToMuMuBuilder::setEtaMax(oniaType type, double eta) {
0186   setNotUpdated();
0187   OniaParameters& par = oniaPar[type];
0188   par.etaSel->setEtaMax(eta);
0189   return;
0190 }
0191
0192 void BPHOniaToMuMuBuilder::setMassMin(oniaType type, double m) {
0193   setNotUpdated();
0194   OniaParameters& par = oniaPar[type];
0195   par.massSel->setMassMin(m);
0196   return;
0197 }
0198
0199 void BPHOniaToMuMuBuilder::setMassMax(oniaType type, double m) {
0200   setNotUpdated();
0201   OniaParameters& par = oniaPar[type];
0202   par.massSel->setMassMax(m);
0203   return;
0204 }
0205
0206 void BPHOniaToMuMuBuilder::setProbMin(oniaType type, double p) {
0207   setNotUpdated();
0208   OniaParameters& par = oniaPar[type];
0209   par.chi2Sel->setProbMin(p);
0210   return;
0211 }
0212
0213 void BPHOniaToMuMuBuilder::setConstr(oniaType type, double mass, double sigma) {
0214   setNotUpdated();
0215   OniaParameters& par = oniaPar[type];
0216   par.mass = mass;
0217   par.sigma = sigma;
0218   return;
0219 }
0220
0221 /// get current cuts
0222 double BPHOniaToMuMuBuilder::getPtMin(oniaType type) const {
0223   const OniaParameters& par = oniaPar.at(type);
0224   return par.ptSel->getPtMin();
0225 }
0226
0227 double BPHOniaToMuMuBuilder::getEtaMax(oniaType type) const {
0228   const OniaParameters& par = oniaPar.at(type);
0229   return par.etaSel->getEtaMax();
0230 }
0231
0232 double BPHOniaToMuMuBuilder::getMassMin(oniaType type) const {
0233   const OniaParameters& par = oniaPar.at(type);
0234   return par.massSel->getMassMin();
0235 }
0236
0237 double BPHOniaToMuMuBuilder::getMassMax(oniaType type) const {
0238   const OniaParameters& par = oniaPar.at(type);
0239   return par.massSel->getMassMax();
0240 }
0241
0242 double BPHOniaToMuMuBuilder::getProbMin(oniaType type) const {
0243   const OniaParameters& par = oniaPar.at(type);
0244   return par.chi2Sel->getProbMin();
0245 }
0246
0247 double BPHOniaToMuMuBuilder::getConstrMass(oniaType type) const {
0248   const OniaParameters& par = oniaPar.at(type);
0249   return par.mass;
0250 }
0251
0252 double BPHOniaToMuMuBuilder::getConstrSigma(oniaType type) const {
0253   const OniaParameters& par = oniaPar.at(type);
0254   return par.sigma;
0255 }
0256
0257 void BPHOniaToMuMuBuilder::setNotUpdated() {
0258   map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
0259   map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
0260   while (iter != iend)
0261     iter++->second.outdated = true;
0262   return;
0263 }
0264
0265 void BPHOniaToMuMuBuilder::setParameters(oniaType type,
0266                                          double ptMin,
0267                                          double etaMax,
0268                                          double massMin,
0269                                          double massMax,
0270                                          double probMin,
0271                                          double mass,
0272                                          double sigma) {
0273   OniaParameters& par = oniaPar[type];
0274   par.ptSel = new BPHMuonPtSelect(ptMin);
0275   par.etaSel = new BPHMuonEtaSelect(etaMax);
0276   par.massSel = new BPHMassSelect(massMin, massMax);
0277   par.chi2Sel = new BPHChi2Select(probMin);
0278   par.mass = mass;
0279   par.sigma = sigma;
0280   par.outdated = true;
0281   return;
0282 }
0283
0284 void BPHOniaToMuMuBuilder::extractList(oniaType type) {
0285   build();
0286   OniaParameters& par = oniaPar[type];
0287   vector<BPHPlusMinusConstCandPtr>& list = oniaList[type];
0288   if (!par.outdated)
0289     return;
0290   int i;
0291   int n = recList.size();
0292   list.clear();
0293   list.reserve(n);
0294   for (i = 0; i < n; ++i) {
0295     BPHPlusMinusConstCandPtr ptr = recList[i];
0296     const reco::Candidate* mcPos = ptr->getDaug("MuPos");
0297     const reco::Candidate* mcNeg = ptr->getDaug("MuNeg");
0298     const reco::Candidate* muPos = ptr->originalReco(mcPos);
0299     const reco::Candidate* muNeg = ptr->originalReco(mcNeg);
0300     if (!par.massSel->accept(*ptr))
0301       continue;
0302     if (!par.ptSel->accept(*muPos))
0303       continue;
0304     if (!par.etaSel->accept(*muPos))
0305       continue;
0306     if (!par.ptSel->accept(*muNeg))
0307       continue;
0308     if (!par.etaSel->accept(*muNeg))
0309       continue;
0310     if (!par.chi2Sel->accept(*ptr))
0311       continue;
0312     BPHPlusMinusCandidate* np = new BPHPlusMinusCandidate(evSetup);
0313     np->add("MuPos", muPos, ptr->getTrackSearchList(mcPos), BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
0314     np->add("MuNeg", muNeg, ptr->getTrackSearchList(mcNeg), BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
0315     if (par.mass > 0.0)
0316       np->setConstraint(par.mass, par.sigma);
0317     list.push_back(BPHPlusMinusConstCandPtr(np));
0318   }
0319   par.outdated = false;
0320   return;
0321 }