CandKinResolution.cc

Go to the documentation of this file.

#include <DataFormats/PatCandidates/interface/CandKinResolution.h>
#include <DataFormats/PatCandidates/interface/ResolutionHelper.h>
#include <DataFormats/PatCandidates/interface/ParametrizationHelper.h>

pat::CandKinResolution::CandKinResolution() : parametrization_(Invalid), covariances_(), constraints_(), covmatrix_() {}

pat::CandKinResolution::CandKinResolution(Parametrization parametrization,
                                          const std::vector<Scalar> &covariances,
                                          const std::vector<Scalar> &constraints)
    : parametrization_(parametrization), covariances_(covariances), constraints_(constraints), covmatrix_() {
  fillMatrix();
}

pat::CandKinResolution::CandKinResolution(Parametrization parametrization,
                                          const AlgebraicSymMatrix44 &covariance,
                                          const std::vector<Scalar> &constraints)
    : parametrization_(parametrization), covariances_(), constraints_(constraints), covmatrix_(covariance) {
  fillVector();
  if (sizeof(double) != sizeof(Scalar)) {  // should become boost::mpl::if_c
    fillMatrix();                          // forcing double => float => double conversion
  }
}

pat::CandKinResolution::~CandKinResolution() {}

double pat::CandKinResolution::resolEta(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolEta(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolTheta(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolTheta(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPhi(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPhi(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolE(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolE(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolEt(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolEt(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolM(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolM(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolP(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolP(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPt(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPt(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPInv(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPInv(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPx(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPx(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPy(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPy(parametrization_, covmatrix_, p4);
}
double pat::CandKinResolution::resolPz(const pat::CandKinResolution::LorentzVector &p4) const {
  return pat::helper::ResolutionHelper::getResolPz(parametrization_, covmatrix_, p4);
}

void pat::CandKinResolution::fillVector() {
  if (dimension() == 3) {
    AlgebraicSymMatrix33 sub = covmatrix_.Sub<AlgebraicSymMatrix33>(0, 0);
    covariances_.insert(covariances_.end(), sub.begin(), sub.end());
  } else {
    covariances_.insert(covariances_.end(), covmatrix_.begin(), covmatrix_.end());
  }
}

void pat::CandKinResolution::fillMatrixFrom(Parametrization parametrization,
                                            const std::vector<Scalar> &covariances,
                                            AlgebraicSymMatrix44 &covmatrix) {
  int dimension = dimensionFrom(parametrization);
  if (dimension == 3) {
    if (covariances.size() == 3) {
      for (int i = 0; i < 3; ++i)
        covmatrix(i, i) = covariances[i];
    } else {
      covmatrix.Place_at(AlgebraicSymMatrix33(covariances.begin(), covariances.end()), 0, 0);
    }
  } else if (dimension == 4) {
    if (covariances.size() == 4) {
      for (int i = 0; i < 4; ++i)
        covmatrix(i, i) = covariances[i];
    } else {
      covmatrix = AlgebraicSymMatrix44(covariances.begin(), covariances.end());
    }
  }
}

void pat::CandKinResolution::fillMatrix() { fillMatrixFrom(parametrization_, covariances_, covmatrix_); }