PosteriorWeightsCalculator Class Reference

#include <PosteriorWeightsCalculator.h>

Public Member Functions
	PosteriorWeightsCalculator (const std::vector< TSOS > &mixture)
std::vector< double >	weights (const TrackingRecHit &tsos) const
	Create random state. More...
template<unsigned int D>
std::vector< double >	weights (const TrackingRecHit &tsos) const
	~PosteriorWeightsCalculator ()

Private Types
typedef TrajectoryStateOnSurface	TSOS

Private Attributes
std::vector< TSOS >	predictedComponents

Detailed Description

Helper class which calculates the posterior weights of a Gaussian mixture given a prior (predicted) mixture and a RecHit. The prior is specified during construction time in the form of a vector of trajectory states.

Definition at line 13 of file PosteriorWeightsCalculator.h.

Member Typedef Documentation

TSOS

typedef TrajectoryStateOnSurface PosteriorWeightsCalculator::TSOS

private

Definition at line 15 of file PosteriorWeightsCalculator.h.

Constructor & Destructor Documentation

PosteriorWeightsCalculator()

PosteriorWeightsCalculator::PosteriorWeightsCalculator ( const std::vector< TSOS > &  mixture )

inline

Definition at line 18 of file PosteriorWeightsCalculator.h.

: predictedComponents(mixture) {}

~PosteriorWeightsCalculator()

PosteriorWeightsCalculator::~PosteriorWeightsCalculator ( )

inline

Definition at line 20 of file PosteriorWeightsCalculator.h.

{}

Member Function Documentation

weights() [1/2]

std::vector< double > PosteriorWeightsCalculator::weights

(

const TrackingRecHit &

tsos

)

const

Create random state.

Definition at line 11 of file PosteriorWeightsCalculator.cc.

References Exception, and rpcPointValidation_cfi::recHit.

Referenced by GsfChi2MeasurementEstimator::estimate(), GsfMultiStateUpdator::update(), and weights().

                                                                                        {
  switch (recHit.dimension()) {
    case 1:
      return weights<1>(recHit);
    case 2:
      return weights<2>(recHit);
    case 3:
      return weights<3>(recHit);
    case 4:
      return weights<4>(recHit);
    case 5:
      return weights<5>(recHit);
  }
  throw cms::Exception("Error: rechit of size not 1,2,3,4,5");
}

weights() [2/2]

template<unsigned int D>

std::vector< double > PosteriorWeightsCalculator::weights

(

const TrackingRecHit &

tsos

)

const

Definition at line 28 of file PosteriorWeightsCalculator.cc.

References nano_mu_local_reco_cff::chi2, muonRecoAnalyzer_cfi::chi2Min, JetChargeProducer_cfi::exp, mps_fire::i, invertPosDefMatrix(), LogDebug, convertSQLiteXML::ok, AlCaHLTBitMon_ParallelJobs::p, predictedComponents, dttmaxenums::R, alignCSCRings::r, rpcPointValidation_cfi::recHit, mathSSE::sqrt(), cms::cuda::V, w(), weights(), and x.

                                                                                        {
  typedef typename AlgebraicROOTObject<D, 5>::Matrix MatD5;
  typedef typename AlgebraicROOTObject<5, D>::Matrix Mat5D;
  typedef typename AlgebraicROOTObject<D, D>::SymMatrix SMatDD;
  typedef typename AlgebraicROOTObject<D>::Vector VecD;
  using ROOT::Math::SMatrixNoInit;

  std::vector<double> weights;
  if (predictedComponents.empty()) {
    edm::LogError("EmptyPredictedComponents") << "a multi state is empty. cannot compute any weight.";
    return weights;
  }
  weights.reserve(predictedComponents.size());

  std::vector<double> detRs;
  detRs.reserve(predictedComponents.size());
  std::vector<double> chi2s;
  chi2s.reserve(predictedComponents.size());

  VecD r, rMeas;
  SMatDD V(SMatrixNoInit{}), R(SMatrixNoInit{});
  ProjectMatrix<double, 5, D> p;
  //
  // calculate chi2 and determinant / component and find
  //   minimum / maximum of chi2
  //
  double chi2Min(DBL_MAX);
  for (unsigned int i = 0; i < predictedComponents.size(); i++) {
    KfComponentsHolder holder;
    auto const& x = predictedComponents[i].localParameters().vector();
    holder.template setup<D>(&r, &V, &p, &rMeas, &R, x, predictedComponents[i].localError().matrix());
    recHit.getKfComponents(holder);

    r -= rMeas;
    R += V;

    double detR;
    if (!R.Det2(detR)) {
      edm::LogError("PosteriorWeightsCalculator") << "PosteriorWeightsCalculator: determinant failed";
      return std::vector<double>();
    }
    detRs.push_back(detR);

    bool ok = invertPosDefMatrix(R);
    if (!ok) {
      edm::LogError("PosteriorWeightsCalculator") << "PosteriorWeightsCalculator: inversion failed";
      return std::vector<double>();
    }
    double chi2 = ROOT::Math::Similarity(r, R);
    chi2s.push_back(chi2);
    if (chi2 < chi2Min)
      chi2Min = chi2;
  }

  if (detRs.size() != predictedComponents.size() || chi2s.size() != predictedComponents.size()) {
    edm::LogError("PosteriorWeightsCalculator") << "Problem in vector sizes";
    return std::vector<double>();
  }

  //
  // calculate weights (extracting a common factor
  //   exp(-0.5*chi2Min) to avoid numerical problems
  //   during exponentation
  //
  double sumWeights(0.);
  for (unsigned int i = 0; i < predictedComponents.size(); i++) {
    double priorWeight = predictedComponents[i].weight();

    double chi2 = chi2s[i] - chi2Min;

    double tempWeight(0.);
    if (detRs[i] > FLT_MIN) {
      //
      // Calculation of (non-normalised) weight. Common factors exp(-chi2Norm/2.) and
      // 1./sqrt(2*pi*recHit.dimension()) have been omitted
      //
      tempWeight = priorWeight * std::sqrt(1. / detRs[i]) * std::exp(-0.5 * chi2);
    } else {
      LogDebug("GsfTrackFitters") << "PosteriorWeightsCalculator: detR < FLT_MIN !!";
    }
    weights.push_back(tempWeight);
    sumWeights += tempWeight;
  }

  if (sumWeights < DBL_MIN) {
    LogDebug("GsfTrackFitters") << "PosteriorWeightsCalculator: sumWeight < DBL_MIN";
    edm::LogError("PosteriorWeightsCalculator") << "PosteriorWeightsCalculator: sumWeight < DBL_MIN";
    return std::vector<double>();
  }

  if (weights.size() != predictedComponents.size()) {
    edm::LogError("PosteriorWeightsCalculator") << "Problem in vector sizes (2)";
    return std::vector<double>();
  }
  sumWeights = 1. / sumWeights;
  for (auto& w : weights)
    w *= sumWeights;
  return weights;
}

Member Data Documentation

predictedComponents

std::vector<TSOS> PosteriorWeightsCalculator::predictedComponents

private

Definition at line 27 of file PosteriorWeightsCalculator.h.

Referenced by weights().