tauImpactParameter::LagrangeMultipliersFitter Class Reference

#include <LagrangeMultipliersFitter.h>

Public Types
enum	ConvergeProc { ConstraintMin = 0, Chi2Min, Chi2AndConstaintMin }
enum	Parameters {   par_vx = 0, par_vy, par_vz, par_px,   par_py, par_pz, par_m, npardim }
enum	Position { pos_x = 0, pos_y, pos_z, nposdim }

Public Member Functions
virtual double	chiSquare ()
virtual double	cSum ()
virtual bool	fit ()
virtual LorentzVectorParticle	getMother ()=0
virtual std::vector< LorentzVectorParticle >	getRefitDaughters ()=0
virtual bool	isConfigured ()
virtual bool	isConverged ()
	LagrangeMultipliersFitter ()
virtual double	nConstraints ()=0
virtual int	nDaughters ()=0
virtual double	ndf ()=0
virtual double	nIter ()
virtual void	setMaxDelta (double MaxDelta)
virtual void	setNIterMax (int Nitermax)
virtual void	setWeight (double weight)
virtual	~LagrangeMultipliersFitter ()

Protected Member Functions
virtual TVectorD	value (const TVectorD &v)=0

Protected Attributes
TMatrixTSym< double >	cov_
TMatrixTSym< double >	cov_0_
bool	isConfigured_
bool	isFit_
TVectorD	par_
TVectorD	par_0_

Private Member Functions
bool	applyLagrangianConstraints ()
double	chiSquare (const TVectorT< double > &delta_alpha, const TVectorT< double > &lambda, const TMatrixT< double > &D, const TVectorT< double > &d)
double	chiSquareUsingInitalPoint (const TVectorT< double > &alpha, const TVectorT< double > &lambda)
TMatrixT< double >	computeVariance ()
double	constraintDelta (const TVectorT< double > &par)
TMatrixT< double >	derivative ()

Private Attributes
double	chi2_
double	chi2prev_
TMatrixT< double >	D_
double	delta_
double	epsilon_
double	maxDelta_
double	niter_
double	nitermax_
double	ScaleFactor_
TMatrixTSym< double >	V_alpha0_inv_
TMatrixT< double >	V_corr_prev_
TMatrixTSym< double >	V_D_
double	weight_

Detailed Description

Definition at line 18 of file LagrangeMultipliersFitter.h.

Member Enumeration Documentation

enum tauImpactParameter::LagrangeMultipliersFitter::ConvergeProc

Enumerator
ConstraintMin
Chi2Min
Chi2AndConstaintMin

Definition at line 22 of file LagrangeMultipliersFitter.h.

{ ConstraintMin = 0, Chi2Min, Chi2AndConstaintMin };

enum tauImpactParameter::LagrangeMultipliersFitter::Parameters

Enumerator
par_vx
par_vy
par_vz
par_px
par_py
par_pz
par_m
npardim

Definition at line 21 of file LagrangeMultipliersFitter.h.

{ par_vx = 0, par_vy, par_vz, par_px, par_py, par_pz, par_m, npardim };

enum tauImpactParameter::LagrangeMultipliersFitter::Position

Enumerator
pos_x
pos_y
pos_z
nposdim

Definition at line 20 of file LagrangeMultipliersFitter.h.

{ pos_x = 0, pos_y, pos_z, nposdim };

Constructor & Destructor Documentation

LagrangeMultipliersFitter::LagrangeMultipliersFitter

(

)

Definition at line 13 of file LagrangeMultipliersFitter.cc.

    : isConfigured_(false),
      isFit_(false),
      epsilon_(0.00001),
      weight_(1.0),
      maxDelta_(0.1),
      nitermax_(100),
      chi2_(1e10),
      D_(1, 1),
      V_D_(1, 1) {}

virtual tauImpactParameter::LagrangeMultipliersFitter::~LagrangeMultipliersFitter ( )

inlinevirtual

Definition at line 25 of file LagrangeMultipliersFitter.h.

{};

Member Function Documentation

bool LagrangeMultipliersFitter::applyLagrangianConstraints ( )

private

Definition at line 50 of file LagrangeMultipliersFitter.cc.

References zMuMuMuonUserData::alpha, gen::C, chi2_, Chi2AndConstaintMin, chi2prev_, chiSquareUsingInitalPoint(), constraintDelta(), ConstraintMin, cov_0_, ztail::d, D_, delta_, derivative(), change_name::diff, GeomDetEnumerators::DT, epsilon_, createfilelist::int, cmsLHEtoEOSManager::l, maxDelta_, nConstraints(), par_, par_0_, alignCSCRings::s, ScaleFactor_, V_D_, and value().

Referenced by fit().

                                                           {
  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;
}

virtual double tauImpactParameter::LagrangeMultipliersFitter::chiSquare ( )

inlinevirtual

Definition at line 34 of file LagrangeMultipliersFitter.h.

References chi2_.

{ return chi2_; }

double LagrangeMultipliersFitter::chiSquare ( const TVectorT< double > &  delta_alpha, const TVectorT< double > &  lambda, const TMatrixT< double > &  D, const TVectorT< double > &  d  )

private

Definition at line 162 of file LagrangeMultipliersFitter.cc.

References ztail::d.

                                                                       {
  double c2 = lambda * (D * delta_alpha + d);
  return c2;
}

double LagrangeMultipliersFitter::chiSquareUsingInitalPoint ( const TVectorT< double > &  alpha, const TVectorT< double > &  lambda  )

private

Definition at line 170 of file LagrangeMultipliersFitter.cc.

References zMuMuMuonUserData::alpha, cov_0_, mps_fire::i, dqmiolumiharvest::j, par_, par_0_, V_alpha0_inv_, and value().

Referenced by applyLagrangianConstraints().

                                                                                            {
  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;
}

TMatrixT< double > LagrangeMultipliersFitter::computeVariance ( )

private

Definition at line 211 of file LagrangeMultipliersFitter.cc.

References cov_, cov_0_, D_, mps_fire::i, dqmiolumiharvest::j, ScaleFactor_, V_corr_prev_, and V_D_.

Referenced by fit().

                                                            {
  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_;
}

double LagrangeMultipliersFitter::constraintDelta ( const TVectorT< double > &  par )

private

Definition at line 202 of file LagrangeMultipliersFitter.cc.

References mps_fire::i, and value().

Referenced by applyLagrangianConstraints().

                                                                             {
  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;
}

virtual double tauImpactParameter::LagrangeMultipliersFitter::cSum ( )

inlinevirtual

Definition at line 35 of file LagrangeMultipliersFitter.h.

References delta_.

{ return delta_; };

TMatrixD LagrangeMultipliersFitter::derivative ( )

private

Definition at line 135 of file LagrangeMultipliersFitter.cc.

References epsilon_, mps_fire::i, dqmiolumiharvest::j, nConstraints(), par_, and value().

Referenced by applyLagrangianConstraints().

                                               {  // 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::fit ( void  )

virtual

Definition at line 24 of file LagrangeMultipliersFitter.cc.

References applyLagrangianConstraints(), computeVariance(), cov_, cov_0_, delta_, isConfigured_, isConverged(), isFit_, maxDelta_, niter_, nitermax_, par_0_, and TriggerAnalyzer::passed.

Referenced by trackingPlots.Iteration::modules(), and setNIterMax().

                                    {
  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;
}

virtual LorentzVectorParticle tauImpactParameter::LagrangeMultipliersFitter::getMother ( )

pure virtual

Referenced by nIter().

virtual std::vector<LorentzVectorParticle> tauImpactParameter::LagrangeMultipliersFitter::getRefitDaughters ( )

pure virtual

Referenced by nIter().

virtual bool tauImpactParameter::LagrangeMultipliersFitter::isConfigured ( )

inlinevirtual

Definition at line 33 of file LagrangeMultipliersFitter.h.

References isConfigured_.

{ return isConfigured_; }

bool LagrangeMultipliersFitter::isConverged ( )

virtual

Definition at line 155 of file LagrangeMultipliersFitter.cc.

References delta_, and maxDelta_.

Referenced by fit(), and setNIterMax().

                                            {
  if (delta_ < maxDelta_) {
    return true;
  }
  return false;
}

virtual double tauImpactParameter::LagrangeMultipliersFitter::nConstraints ( )

pure virtual

Referenced by applyLagrangianConstraints(), derivative(), and nIter().

virtual int tauImpactParameter::LagrangeMultipliersFitter::nDaughters ( )

pure virtual

Referenced by nIter().

virtual double tauImpactParameter::LagrangeMultipliersFitter::ndf ( )

pure virtual

Referenced by nIter().

virtual double tauImpactParameter::LagrangeMultipliersFitter::nIter ( )

inlinevirtual

Definition at line 36 of file LagrangeMultipliersFitter.h.

References getMother(), getRefitDaughters(), nConstraints(), nDaughters(), ndf(), niter_, findQualityFiles::v, and value().

{ return niter_; };

virtual void tauImpactParameter::LagrangeMultipliersFitter::setMaxDelta ( double  MaxDelta )

inlinevirtual

Definition at line 28 of file LagrangeMultipliersFitter.h.

References maxDelta_.

{ maxDelta_ = MaxDelta; }

virtual void tauImpactParameter::LagrangeMultipliersFitter::setNIterMax ( int  Nitermax )

inlinevirtual

Definition at line 29 of file LagrangeMultipliersFitter.h.

References fit(), isConverged(), and nitermax_.

{ nitermax_ = Nitermax; }

virtual void tauImpactParameter::LagrangeMultipliersFitter::setWeight ( double  weight )

inlinevirtual

Definition at line 27 of file LagrangeMultipliersFitter.h.

References mps_merge::weight, and weight_.

{ weight_ = weight; }

virtual TVectorD tauImpactParameter::LagrangeMultipliersFitter::value ( const TVectorD &  v )

protectedpure virtual

Referenced by applyLagrangianConstraints(), chiSquareUsingInitalPoint(), constraintDelta(), derivative(), and nIter().

Member Data Documentation

double tauImpactParameter::LagrangeMultipliersFitter::chi2_

private

Definition at line 69 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and chiSquare().

double tauImpactParameter::LagrangeMultipliersFitter::chi2prev_

private

Definition at line 69 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::cov_

protected

Definition at line 50 of file LagrangeMultipliersFitter.h.

Referenced by computeVariance(), and fit().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::cov_0_

protected

Definition at line 49 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), chiSquareUsingInitalPoint(), computeVariance(), and fit().

TMatrixT<double> tauImpactParameter::LagrangeMultipliersFitter::D_

private

Definition at line 73 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

double tauImpactParameter::LagrangeMultipliersFitter::delta_

private

Definition at line 69 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), cSum(), fit(), and isConverged().

double tauImpactParameter::LagrangeMultipliersFitter::epsilon_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and derivative().

bool tauImpactParameter::LagrangeMultipliersFitter::isConfigured_

protected

Definition at line 51 of file LagrangeMultipliersFitter.h.

Referenced by fit(), and isConfigured().

bool tauImpactParameter::LagrangeMultipliersFitter::isFit_

protected

Definition at line 52 of file LagrangeMultipliersFitter.h.

Referenced by fit().

double tauImpactParameter::LagrangeMultipliersFitter::maxDelta_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), fit(), isConverged(), and setMaxDelta().

double tauImpactParameter::LagrangeMultipliersFitter::niter_

private

Definition at line 69 of file LagrangeMultipliersFitter.h.

Referenced by fit(), and nIter().

double tauImpactParameter::LagrangeMultipliersFitter::nitermax_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by fit(), and setNIterMax().

TVectorD tauImpactParameter::LagrangeMultipliersFitter::par_

protected

Definition at line 48 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), chiSquareUsingInitalPoint(), and derivative().

TVectorD tauImpactParameter::LagrangeMultipliersFitter::par_0_

protected

Definition at line 47 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), chiSquareUsingInitalPoint(), and fit().

double tauImpactParameter::LagrangeMultipliersFitter::ScaleFactor_

private

Definition at line 75 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::V_alpha0_inv_

private

Definition at line 72 of file LagrangeMultipliersFitter.h.

Referenced by chiSquareUsingInitalPoint().

TMatrixT<double> tauImpactParameter::LagrangeMultipliersFitter::V_corr_prev_

private

Definition at line 76 of file LagrangeMultipliersFitter.h.

Referenced by computeVariance().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::V_D_

private

Definition at line 74 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

double tauImpactParameter::LagrangeMultipliersFitter::weight_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by setWeight().