LagrangeMultipliersFitter.cc

Go to the documentation of this file.

/* From SimpleFits Package
 * Designed an written by
 * author: Ian M. Nugent
 * Humboldt Foundations
 */
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "RecoTauTag/ImpactParameter/interface/LagrangeMultipliersFitter.h"
#include "TDecompBK.h"
#include <iostream>
 
using namespace tauImpactParameter;
 
LagrangeMultipliersFitter::LagrangeMultipliersFitter()
    : isConfigured_(false),
      isFit_(false),
      epsilon_(0.00001),
      weight_(1.0),
      maxDelta_(0.1),
      nitermax_(100),
      chi2_(1e10),
      D_(1, 1),
      V_D_(1, 1) {}
 
bool LagrangeMultipliersFitter::fit() {
  if (cov_.GetNrows() != par_0_.GetNrows()) {
    // set cov to cov_0 until value is computed
    cov_.ResizeTo(par_0_.GetNrows(), par_0_.GetNrows());
    cov_ = cov_0_;
  }
  if (!isConfigured_)
    return false;
  if (isFit_)
    return isConverged();
  isFit_ = true;
  niter_ = 0;
  for (niter_ = 0; niter_ <= nitermax_; niter_++) {
    bool passed = applyLagrangianConstraints();
    if (!passed || (niter_ == nitermax_ && delta_ >= 4.0 * maxDelta_)) {
      edm::LogWarning("LagrangeMultipliersFitter::Fit")
          << "Reached Maximum number of iterations..." << niter_ << std::endl;
      return false;
    }
    if (isConverged())
      break;
  }
  computeVariance();
  return true;
}
 
bool LagrangeMultipliersFitter::applyLagrangianConstraints() {
  if (V_D_.GetNrows() != nConstraints())
    V_D_.ResizeTo(nConstraints(), nConstraints());
  if (D_.GetNrows() != nConstraints() || D_.GetNcols() != par_.GetNrows())
    D_.ResizeTo(nConstraints(), par_.GetNrows());
 
  // Setup intial values
  TVectorT<double> alpha_A = par_;
  TVectorT<double> alpha_0 = par_0_;
  TVectorT<double> delta_alpha_A = alpha_A - alpha_0;
  D_ = derivative();
  TVectorT<double> d = value(par_);
  TVectorT<double> C = D_ * delta_alpha_A - d;
  TMatrixTSym<double> V_alpha0 = cov_0_;
  TMatrixTSym<double> V_D_inv = V_alpha0;
  V_D_inv.Similarity(D_);
  double det = V_D_inv.Determinant();
  TDecompBK Inverter(V_D_inv);
  if (fabs(det) > 1e40) {
    edm::LogWarning("LagrangeMultipliersFitter::Fit")
        << "Fit failed: unable to invert SYM gain matrix LARGE Determinant" << det << " \n"
        << std::endl;
    return false;
  }
  if (!Inverter.Decompose()) {
    edm::LogWarning("LagrangeMultipliersFitter::Fit") << "Fit failed: unable to invert SYM gain matrix " << det << " \n"
                                                      << std::endl;
    return false;
  }
  V_D_ = Inverter.Invert();
 
  // solve equations
  TVectorT<double> lambda = -1.0 * V_D_ * C;
  TMatrixT<double> DT = D_;
  DT.T();
  TVectorT<double> alpha = alpha_0 - V_alpha0 * DT * lambda;
 
  // do while loop to see if the convergance criteria are satisfied
  double s(1), stepscale(0.01);
  chi2prev_ = chi2_;
  double currentchi2(chiSquareUsingInitalPoint(alpha_A, lambda)), currentdelta(constraintDelta(par_));
  TVectorT<double> alpha_s = alpha;
  // convergence in 2 step procedure to minimize chi2 within MaxDelta_ of the constriants
  // 1) Get within 5x MaxDelta_
  // 2) converge based on improving chi2 and constrianed delta
  unsigned int Proc = ConstraintMin;
  if (constraintDelta(par_) < 5 * maxDelta_)
    Proc = Chi2AndConstaintMin;
  int NIter = (int)(1.0 / stepscale);
  for (int iter = 0; iter < NIter; iter++) {
    // compute safty cutoff for numberical constraint
    double diff = 0;
    for (int l = 0; l < alpha_s.GetNrows(); l++) {
      if (diff < alpha_s(l) - alpha_A(l))
        diff = alpha_s(l) - alpha_A(l);
    }
    double delta_alpha_s = constraintDelta(alpha_s);
    if (Proc == ConstraintMin) {
      if (delta_alpha_s < currentdelta || iter == NIter || diff < 100 * epsilon_) {
        currentchi2 = chiSquareUsingInitalPoint(alpha_s, lambda);
        currentdelta = delta_alpha_s;
        ScaleFactor_ = s;
        break;
      }
    } else if (Proc == Chi2AndConstaintMin) {
      double chi2_s = chiSquareUsingInitalPoint(alpha_s, lambda);
      if ((delta_alpha_s < currentdelta /*+maxDelta_*/ && chi2_s < currentchi2) || iter == NIter ||
          diff < 100 * epsilon_) {
        currentchi2 = chi2_s;
        currentdelta = delta_alpha_s;
        ScaleFactor_ = s;
        break;
      }
    }
    s -= stepscale;
    alpha_s = alpha_A + s * (alpha - alpha_A);
  }
  // set chi2
  chi2_ = currentchi2;
  //set delta
  delta_ = currentdelta;
  par_ = alpha_s;
  return true;
}
 
TMatrixD LagrangeMultipliersFitter::derivative() {  // alway evaluated at current par
  TMatrixD Derivatives(nConstraints(), par_.GetNrows());
  TVectorD par_plus(par_.GetNrows());
  TVectorD value_par(nConstraints());
  TVectorD value_par_plus(nConstraints());
  for (int j = 0; j < par_.GetNrows(); j++) {
    for (int i = 0; i < par_.GetNrows(); i++) {
      par_plus(i) = par_(i);
      if (i == j)
        par_plus(i) = par_(i) + epsilon_;
    }
    value_par = value(par_);
    value_par_plus = value(par_plus);
    for (int i = 0; i < nConstraints(); i++) {
      Derivatives(i, j) = (value_par_plus(i) - value_par(i)) / epsilon_;
    }
  }
  return Derivatives;
}
 
bool LagrangeMultipliersFitter::isConverged() {
  if (delta_ < maxDelta_) {
    return true;
  }
  return false;
}
 
double LagrangeMultipliersFitter::chiSquare(const TVectorT<double>& delta_alpha,
                                            const TVectorT<double>& lambda,
                                            const TMatrixT<double>& D,
                                            const TVectorT<double>& d) {
  double c2 = lambda * (D * delta_alpha + d);
  return c2;
}
 
double LagrangeMultipliersFitter::chiSquareUsingInitalPoint(const TVectorT<double>& alpha,
                                                            const TVectorT<double>& lambda) {
  if (cov_0_.GetNrows() != V_alpha0_inv_.GetNrows()) {
    TMatrixTSym<double> V_alpha0 = cov_0_;
    V_alpha0_inv_.ResizeTo(cov_0_.GetNrows(), cov_0_.GetNrows());
    TDecompBK Inverter(V_alpha0);
    if (!Inverter.Decompose()) {  // handle rare case where inversion is not possible (ie assume diagonal)
      edm::LogWarning("LagrangeMultipliersFitter::chiSquareUsingInitalPoint")
          << "Error non-invertable Matrix... Calculating under assumption that correlations can be neglected!!!"
          << std::endl;
      for (int j = 0; j < par_.GetNrows(); j++) {
        for (int i = 0; i < par_.GetNrows(); i++) {
          if (i == j)
            V_alpha0_inv_(i, j) = 1.0 / V_alpha0(i, j);
          else
            V_alpha0_inv_(i, j) = 0.0;
        }
      }
    } else {
      V_alpha0_inv_ = Inverter.Invert();
    }
  }
 
  TVectorT<double> alpha_0 = par_0_;
  TVectorT<double> dalpha = alpha - alpha_0;
  double c2_var = dalpha * (V_alpha0_inv_ * dalpha);
  const TVectorT<double>& alpha_v = alpha;
  double c2_constraints = lambda * value(alpha_v);
  double c2 = c2_var + c2_constraints;
  return c2;
}
 
double LagrangeMultipliersFitter::constraintDelta(const TVectorT<double>& par) {
  TVectorD d_par = value(par);
  double delta_d(0);
  for (int i = 0; i < d_par.GetNrows(); i++) {
    delta_d += fabs(d_par(i));
  }
  return delta_d;
}
 
TMatrixT<double> LagrangeMultipliersFitter::computeVariance() {
  TMatrixTSym<double> V_alpha0 = cov_0_;
  TMatrixTSym<double> DTV_DD = V_D_.SimilarityT(D_);
  TMatrixT<double> DTV_DDV = DTV_DD * V_alpha0;
  TMatrixT<double> VDTV_DDV = V_alpha0 * DTV_DDV;
  TMatrixT<double> CovCor = VDTV_DDV;
  //CovCor*=ScaleFactor_;
  if (V_corr_prev_.GetNrows() != V_alpha0.GetNrows()) {
    V_corr_prev_.ResizeTo(V_alpha0.GetNrows(), V_alpha0.GetNrows());
    V_corr_prev_ = CovCor;
  } else {
    V_corr_prev_ *= (1 - ScaleFactor_);
    CovCor += V_corr_prev_;
    V_corr_prev_ = CovCor;
  }
 
  TMatrixT<double> V_alpha = V_alpha0 - CovCor;
  for (int i = 0; i < cov_.GetNrows(); i++) {
    for (int j = 0; j <= i; j++) {
      cov_(i, j) = V_alpha(i, j);
    }
  }
  return cov_;
}