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 47 of file LagrangeMultipliersFitter.cc.

References alpha, funct::C, chi2_, Chi2AndConstaintMin, chi2prev_, chiSquareUsingInitalPoint(), constraintDelta(), ConstraintMin, cov_0_, D_, delta_, derivative(), diffTreeTool::diff, GeomDetEnumerators::DT, epsilon_, prof2calltree::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 140 of file LagrangeMultipliersFitter.cc.

References counter::c2.

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

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

private

Definition at line 145 of file LagrangeMultipliersFitter.cc.

References alpha, counter::c2, cov_0_, i, 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);
  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 181 of file LagrangeMultipliersFitter.cc.

References cov_, cov_0_, D_, i, 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 172 of file LagrangeMultipliersFitter.cc.

References 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 114 of file LagrangeMultipliersFitter.cc.

References epsilon_, i, 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 25 of file LagrangeMultipliersFitter.cc.

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

                                   {
  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

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

pure virtual

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 133 of file LagrangeMultipliersFitter.cc.

References delta_, and maxDelta_.

Referenced by fit().

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

virtual double tauImpactParameter::LagrangeMultipliersFitter::nConstraints ( )

pure virtual

Referenced by applyLagrangianConstraints(), and derivative().

virtual int tauImpactParameter::LagrangeMultipliersFitter::nDaughters ( )

pure virtual

virtual double tauImpactParameter::LagrangeMultipliersFitter::ndf ( )

pure virtual

virtual double tauImpactParameter::LagrangeMultipliersFitter::nIter ( )

inlinevirtual

Definition at line 36 of file LagrangeMultipliersFitter.h.

References niter_.

{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 nitermax_.

{nitermax_=Nitermax;}

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

inlinevirtual

Definition at line 27 of file LagrangeMultipliersFitter.h.

References histoStyle::weight, and weight_.

{weight_=weight;}

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

protectedpure virtual

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

Member Data Documentation

double tauImpactParameter::LagrangeMultipliersFitter::chi2_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and chiSquare().

double tauImpactParameter::LagrangeMultipliersFitter::chi2prev_

private

Definition at line 66 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 70 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

double tauImpactParameter::LagrangeMultipliersFitter::delta_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

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

double tauImpactParameter::LagrangeMultipliersFitter::epsilon_

private

Definition at line 63 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 63 of file LagrangeMultipliersFitter.h.

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

double tauImpactParameter::LagrangeMultipliersFitter::niter_

private

Definition at line 66 of file LagrangeMultipliersFitter.h.

Referenced by fit(), and nIter().

double tauImpactParameter::LagrangeMultipliersFitter::nitermax_

private

Definition at line 63 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 72 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::V_alpha0_inv_

private

Definition at line 69 of file LagrangeMultipliersFitter.h.

Referenced by chiSquareUsingInitalPoint().

TMatrixT<double> tauImpactParameter::LagrangeMultipliersFitter::V_corr_prev_

private

Definition at line 73 of file LagrangeMultipliersFitter.h.

Referenced by computeVariance().

TMatrixTSym<double> tauImpactParameter::LagrangeMultipliersFitter::V_D_

private

Definition at line 71 of file LagrangeMultipliersFitter.h.

Referenced by applyLagrangianConstraints(), and computeVariance().

double tauImpactParameter::LagrangeMultipliersFitter::weight_

private

Definition at line 63 of file LagrangeMultipliersFitter.h.

Referenced by setWeight().