BPHBdToJPsiKxBuilder.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/BPHBdToJPsiKxBuilder.h"

//-------------------------------
// Collaborating Class Headers --
//-------------------------------
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoBuilder.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHPlusMinusCandidate.h"
#include "HeavyFlavorAnalysis/RecoDecay/interface/BPHRecoCandidate.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMassSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHChi2Select.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHMassFitSelect.h"
#include "HeavyFlavorAnalysis/SpecificDecay/interface/BPHParticleMasses.h"

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

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

//----------------
// Constructors --
//----------------
BPHBdToJPsiKxBuilder::BPHBdToJPsiKxBuilder(const edm::EventSetup& es,
                                           const std::vector<BPHPlusMinusConstCandPtr>& jpsiCollection,
                                           const std::vector<BPHPlusMinusConstCandPtr>& kx0Collection)
    : jPsiName("JPsi"), kx0Name("Kx0"), evSetup(&es), jCollection(&jpsiCollection), kCollection(&kx0Collection) {
  jpsiSel = new BPHMassSelect(2.80, 3.40);
  mkx0Sel = new BPHMassSelect(0.80, 1.00);
  massSel = new BPHMassSelect(3.50, 8.00);
  chi2Sel = new BPHChi2Select(0.02);
  mFitSel = new BPHMassFitSelect(jPsiName, BPHParticleMasses::jPsiMass, BPHParticleMasses::jPsiMWidth, 5.00, 6.00);
  massConstr = true;
  minPDiff = 1.0e-4;
  updated = false;
}

//--------------
// Destructor --
//--------------
BPHBdToJPsiKxBuilder::~BPHBdToJPsiKxBuilder() {
  delete jpsiSel;
  delete mkx0Sel;
  delete massSel;
  delete chi2Sel;
  delete mFitSel;
}

//--------------
// Operations --
//--------------
vector<BPHRecoConstCandPtr> BPHBdToJPsiKxBuilder::build() {
  if (updated)
    return bdList;

  BPHRecoBuilder bBd(*evSetup);
  bBd.setMinPDiffererence(minPDiff);
  bBd.add(jPsiName, *jCollection);
  bBd.add(kx0Name, *kCollection);
  bBd.filter(jPsiName, *jpsiSel);
  bBd.filter(kx0Name, *mkx0Sel);

  bBd.filter(*massSel);
  bBd.filter(*chi2Sel);
  if (massConstr)
    bBd.filter(*mFitSel);

  bdList = BPHRecoCandidate::build(bBd);
  //
  //  Apply kinematic constraint on the JPsi mass.
  //  The operation is already performed when apply the mass selection,
  //  so it's not repeated. The following code is left as example
  //  for similar operations
  //
  //  int iBd;
  //  int nBd = ( massConstr ? bdList.size() : 0 );
  //  for ( iBd = 0; iBd < nBd; ++iBd ) {
  //    BPHRecoCandidate* cptr( const_cast<BPHRecoCandidate*>(
  //                            bdList[iBd].get() ) );
  //    BPHRecoConstCandPtr jpsi = cptr->getComp( jPsiName );
  //    double jMass = jpsi->constrMass();
  //    if ( jMass < 0 ) continue;
  //    double sigma = jpsi->constrSigma();
  //    cptr->kinematicTree( jPsiName, jMass, sigma );
  //  }
  updated = true;

  return bdList;
}

void BPHBdToJPsiKxBuilder::setJPsiMassMin(double m) {
  updated = false;
  jpsiSel->setMassMin(m);
  return;
}

void BPHBdToJPsiKxBuilder::setJPsiMassMax(double m) {
  updated = false;
  jpsiSel->setMassMax(m);
  return;
}

void BPHBdToJPsiKxBuilder::setKxMassMin(double m) {
  updated = false;
  mkx0Sel->setMassMin(m);
  return;
}

void BPHBdToJPsiKxBuilder::setKxMassMax(double m) {
  updated = false;
  mkx0Sel->setMassMax(m);
  return;
}

void BPHBdToJPsiKxBuilder::setMassMin(double m) {
  updated = false;
  massSel->setMassMin(m);
  return;
}

void BPHBdToJPsiKxBuilder::setMassMax(double m) {
  updated = false;
  massSel->setMassMax(m);
  return;
}

void BPHBdToJPsiKxBuilder::setProbMin(double p) {
  updated = false;
  chi2Sel->setProbMin(p);
  return;
}

void BPHBdToJPsiKxBuilder::setMassFitMin(double m) {
  updated = false;
  mFitSel->setMassMin(m);
  return;
}

void BPHBdToJPsiKxBuilder::setMassFitMax(double m) {
  updated = false;
  mFitSel->setMassMax(m);
  return;
}

void BPHBdToJPsiKxBuilder::setConstr(bool flag) {
  updated = false;
  massConstr = flag;
  return;
}

double BPHBdToJPsiKxBuilder::getJPsiMassMin() const { return jpsiSel->getMassMin(); }

double BPHBdToJPsiKxBuilder::getJPsiMassMax() const { return jpsiSel->getMassMax(); }

double BPHBdToJPsiKxBuilder::getKxMassMin() const { return mkx0Sel->getMassMin(); }

double BPHBdToJPsiKxBuilder::getKxMassMax() const { return mkx0Sel->getMassMax(); }

double BPHBdToJPsiKxBuilder::getMassMin() const { return massSel->getMassMin(); }

double BPHBdToJPsiKxBuilder::getMassMax() const { return massSel->getMassMax(); }

double BPHBdToJPsiKxBuilder::getProbMin() const { return chi2Sel->getProbMin(); }

double BPHBdToJPsiKxBuilder::getMassFitMin() const { return mFitSel->getMassMin(); }

double BPHBdToJPsiKxBuilder::getMassFitMax() const { return mFitSel->getMassMax(); }

bool BPHBdToJPsiKxBuilder::getConstr() const { return massConstr; }