BPHOniaToMuMuBuilder.cc

Go to the documentation of this file.

/*
 *  See header file for a description of this class.
 *
 *  \author Paolo Ronchese INFN Padova
 *
 */

//-----------------------
// This Class' Header --
//-----------------------
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHOniaToMuMuBuilder.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoSelect.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHPlusMinusCandidate.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMuonPtSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMuonEtaSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMassSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHChi2Select.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHMultiSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"

//---------------
// C++ Headers --
//---------------
using namespace std;

//-------------------
// Initializations --
//-------------------

//----------------
// Constructors --
//----------------
BPHOniaToMuMuBuilder::BPHOniaToMuMuBuilder(const edm::EventSetup& es,
                                           const BPHRecoBuilder::BPHGenericCollection* muPosCollection,
                                           const BPHRecoBuilder::BPHGenericCollection* muNegCollection)
    : muPosName("MuPos"),
      muNegName("MuNeg"),
      evSetup(&es),
      posCollection(muPosCollection),
      negCollection(muNegCollection) {
  setParameters(Phi, 2.0, 10.0, 0.50, 1.50, 0.0, BPHParticleMasses::phiMass, BPHParticleMasses::phiMWidth);
  setParameters(Psi1, 2.0, 10.0, 2.00, 3.40, 0.0, BPHParticleMasses::jPsiMass, BPHParticleMasses::jPsiMWidth);
  setParameters(Psi2, 2.0, 10.0, 3.40, 6.00, 0.0, BPHParticleMasses::psi2Mass, BPHParticleMasses::psi2MWidth);
  setParameters(Ups, 2.0, 10.0, 6.00, 12.00, 0.0, -1.0, 0.0);
  setParameters(Ups1, 2.0, 10.0, 6.00, 9.75, 0.0, BPHParticleMasses::ups1Mass, BPHParticleMasses::ups1MWidth);
  setParameters(Ups2, 2.0, 10.0, 9.75, 10.20, 0.0, BPHParticleMasses::ups2Mass, BPHParticleMasses::ups2MWidth);
  setParameters(Ups3, 2.0, 10.0, 10.20, 12.00, 0.0, BPHParticleMasses::ups3Mass, BPHParticleMasses::ups3MWidth);
  updated = false;
}

//--------------
// Destructor --
//--------------
BPHOniaToMuMuBuilder::~BPHOniaToMuMuBuilder() {
  map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
  map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
  while (iter != iend) {
    OniaParameters& par = iter++->second;
    delete par.ptSel;
    delete par.etaSel;
    delete par.massSel;
    delete par.chi2Sel;
  }
}

//--------------
// Operations --
//--------------
vector<BPHPlusMinusConstCandPtr> BPHOniaToMuMuBuilder::build() {
  if (updated)
    return fullList;

  fullList.clear();

  BPHMultiSelect<BPHSlimSelect<BPHRecoSelect>> ptSel(BPHSelectOperation::or_mode);
  BPHMultiSelect<BPHSlimSelect<BPHRecoSelect>> etaSel(BPHSelectOperation::or_mode);
  BPHMultiSelect<BPHSlimSelect<BPHMomentumSelect>> mSel(BPHSelectOperation::or_mode);
  BPHMultiSelect<BPHSlimSelect<BPHVertexSelect>> vSel(BPHSelectOperation::or_mode);

  map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
  map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
  while (iter != iend) {
    OniaParameters& par = iter++->second;
    ptSel.include(*par.ptSel);
    etaSel.include(*par.etaSel);
    mSel.include(*par.massSel);
    vSel.include(*par.chi2Sel);
  }

  BPHRecoBuilder bOnia(*evSetup);
  bOnia.add(muPosName, posCollection, BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
  bOnia.add(muNegName, negCollection, BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
  bOnia.filter(muPosName, ptSel);
  bOnia.filter(muNegName, ptSel);
  bOnia.filter(muPosName, etaSel);
  bOnia.filter(muNegName, etaSel);
  bOnia.filter(mSel);
  bOnia.filter(vSel);

  fullList = BPHPlusMinusCandidate::build(bOnia, muPosName, muNegName);
  updated = true;
  return fullList;
}

vector<BPHPlusMinusConstCandPtr> BPHOniaToMuMuBuilder::getList(
    oniaType type, BPHRecoSelect* dSel, BPHMomentumSelect* mSel, BPHVertexSelect* vSel, BPHFitSelect* kSel) {
  extractList(type);
  vector<BPHPlusMinusConstCandPtr>& list = oniaList[type];
  int i;
  int n = list.size();
  vector<BPHPlusMinusConstCandPtr> lsub;
  lsub.reserve(n);
  for (i = 0; i < n; ++i) {
    BPHPlusMinusConstCandPtr ptr = list[i];
    const reco::Candidate* muPos = ptr->originalReco(ptr->getDaug(muPosName));
    const reco::Candidate* muNeg = ptr->originalReco(ptr->getDaug(muNegName));
    if ((dSel != nullptr) && (!dSel->accept(*muPos)))
      continue;
    if ((dSel != nullptr) && (!dSel->accept(*muNeg)))
      continue;
    if ((mSel != nullptr) && (!mSel->accept(*ptr)))
      continue;
    if ((vSel != nullptr) && (!vSel->accept(*ptr)))
      continue;
    if ((kSel != nullptr) && (!kSel->accept(*ptr)))
      continue;
    lsub.push_back(list[i]);
  }
  return lsub;
}

BPHPlusMinusConstCandPtr BPHOniaToMuMuBuilder::getOriginalCandidate(const BPHRecoCandidate& cand) {
  const reco::Candidate* mp = cand.originalReco(cand.getDaug(muPosName));
  const reco::Candidate* mn = cand.originalReco(cand.getDaug(muNegName));
  int nc = fullList.size();
  int ic;
  for (ic = 0; ic < nc; ++ic) {
    BPHPlusMinusConstCandPtr pmp = fullList[ic];
    const BPHPlusMinusCandidate* pmc = pmp.get();
    if (pmc->originalReco(pmc->getDaug(muPosName)) != mp)
      continue;
    if (pmc->originalReco(pmc->getDaug(muNegName)) != mn)
      continue;
    return pmp;
  }
  return BPHPlusMinusConstCandPtr(nullptr);
}

void BPHOniaToMuMuBuilder::setPtMin(oniaType type, double pt) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.ptSel->setPtMin(pt);
  return;
}

void BPHOniaToMuMuBuilder::setEtaMax(oniaType type, double eta) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.etaSel->setEtaMax(eta);
  return;
}

void BPHOniaToMuMuBuilder::setMassMin(oniaType type, double m) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.massSel->setMassMin(m);
  return;
}

void BPHOniaToMuMuBuilder::setMassMax(oniaType type, double m) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.massSel->setMassMax(m);
  return;
}

void BPHOniaToMuMuBuilder::setProbMin(oniaType type, double p) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.chi2Sel->setProbMin(p);
  return;
}

void BPHOniaToMuMuBuilder::setConstr(oniaType type, double mass, double sigma) {
  setNotUpdated();
  OniaParameters& par = oniaPar[type];
  par.mass = mass;
  par.sigma = sigma;
  return;
}

double BPHOniaToMuMuBuilder::getPtMin(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.ptSel->getPtMin();
}

double BPHOniaToMuMuBuilder::getEtaMax(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.etaSel->getEtaMax();
}

double BPHOniaToMuMuBuilder::getMassMin(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.massSel->getMassMin();
}

double BPHOniaToMuMuBuilder::getMassMax(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.massSel->getMassMax();
}

double BPHOniaToMuMuBuilder::getProbMin(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.chi2Sel->getProbMin();
}

double BPHOniaToMuMuBuilder::getConstrMass(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.mass;
}

double BPHOniaToMuMuBuilder::getConstrSigma(oniaType type) const {
  const OniaParameters& par = oniaPar.at(type);
  return par.sigma;
}

void BPHOniaToMuMuBuilder::setNotUpdated() {
  map<oniaType, OniaParameters>::iterator iter = oniaPar.begin();
  map<oniaType, OniaParameters>::iterator iend = oniaPar.end();
  while (iter != iend)
    iter++->second.updated = false;
  updated = false;
  return;
}

void BPHOniaToMuMuBuilder::setParameters(oniaType type,
                                         double ptMin,
                                         double etaMax,
                                         double massMin,
                                         double massMax,
                                         double probMin,
                                         double mass,
                                         double sigma) {
  OniaParameters& par = oniaPar[type];
  par.ptSel = new BPHMuonPtSelect(ptMin);
  par.etaSel = new BPHMuonEtaSelect(etaMax);
  par.massSel = new BPHMassSelect(massMin, massMax);
  par.chi2Sel = new BPHChi2Select(probMin);
  par.mass = mass;
  par.sigma = sigma;
  par.updated = false;
  return;
}

void BPHOniaToMuMuBuilder::extractList(oniaType type) {
  if (!updated)
    build();
  OniaParameters& par = oniaPar[type];
  vector<BPHPlusMinusConstCandPtr>& list = oniaList[type];
  if (par.updated)
    return;
  int i;
  int n = fullList.size();
  list.clear();
  list.reserve(n);
  for (i = 0; i < n; ++i) {
    BPHPlusMinusConstCandPtr ptr = fullList[i];
    const reco::Candidate* mcPos = ptr->getDaug("MuPos");
    const reco::Candidate* mcNeg = ptr->getDaug("MuNeg");
    const reco::Candidate* muPos = ptr->originalReco(mcPos);
    const reco::Candidate* muNeg = ptr->originalReco(mcNeg);
    if (!par.massSel->accept(*ptr))
      continue;
    if (!par.ptSel->accept(*muPos))
      continue;
    if (!par.etaSel->accept(*muPos))
      continue;
    if (!par.ptSel->accept(*muNeg))
      continue;
    if (!par.etaSel->accept(*muNeg))
      continue;
    if (!par.chi2Sel->accept(*ptr))
      continue;
    BPHPlusMinusCandidate* np = new BPHPlusMinusCandidate(evSetup);
    np->add("MuPos", muPos, ptr->getTrackSearchList(mcPos), BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
    np->add("MuNeg", muNeg, ptr->getTrackSearchList(mcNeg), BPHParticleMasses::muonMass, BPHParticleMasses::muonMSigma);
    if (par.mass > 0.0)
      np->setConstraint(par.mass, par.sigma);
    list.push_back(BPHPlusMinusConstCandPtr(np));
  }
  par.updated = true;
  return;
}