Chisq_Constrainer.h

Go to the documentation of this file.

//
//
// File: hitfit/Chisq_Constrainer.h
// Purpose: Minimize a chisq subject to a set of constraints.
//          Based on the SQUAW algorithm.
// Created: Jul, 2000, sss, based on run 1 mass analysis code.
//
// For full details on the algorithm, see
//
//    @phdthesis{sssthesis,
//      author =       "Scott Snyder",
//      school =       "State University of New York at Stony Brook",
//      month =        may,
//      year =         "1995 (unpublished)"}
//    @comment{  note =         "available from {\tt http://www-d0.fnal.gov/publications\_talks/thesis/ snyder/thesis-ps.html}"
//    }
//
// CMSSW File      : interface/Chisq_Constrainer.h
// Original Author : Scott Stuart Snyder <snyder@bnl.gov> for D0
// Imported to CMSSW by Haryo Sumowidagdo <Suharyo.Sumowidagdo@cern.ch>

#ifndef HITFIT_CHISQ_CONSTRAINER_H
#define HITFIT_CHISQ_CONSTRAINER_H

#include "TopQuarkAnalysis/TopHitFit/interface/Base_Constrainer.h"
#include "TopQuarkAnalysis/TopHitFit/interface/matutil.h"
#include <iosfwd>


namespace hitfit {


class Defaults;


class Chisq_Constrainer_Args
//
// Purpose: Hold on to parameters for the Chisq_Constrainer class.
//
// Parameters controlling the operation of the fitter:
//   bool printfit      - If true, print a trace of the fit to cout.
//   bool use_G         - If true, check the chisq formula by computing
//                        chisq directly from G.  This requires that G_i
//                        be invertable.
//
// Parameters affecting the fit:
//   float constraint_sum_eps - Convergence threshold for sum of constraints.
//   float chisq_diff_eps - onvergence threshold for change in chisq.
//   int maxit          - Maximum number of iterations permitted.
//   int max_cut        - Maximum number of cut steps permitted.
//   float cutsize      - Fraction by which to cut steps.
//   float min_tot_cutsize - Smallest fractional cut step permitted.
//
// Parameters affecting testing modes:
//   float chisq_test_eps - When use_G is true, the maximum relative
//                          difference permitted between the two chisq
//                          calculations.
//
{
public:
  // Constructor.  Initialize from a Defaults object.

  Chisq_Constrainer_Args (const Defaults& defs);

  // Retrieve parameter values.

  bool printfit () const;

  bool use_G () const;

  double constraint_sum_eps () const;

  double chisq_diff_eps () const;

  unsigned  maxit () const;

  unsigned  max_cut () const;

  double cutsize () const;

  double min_tot_cutsize () const;

  double chisq_test_eps () const;

  // Arguments for subobjects.

  const Base_Constrainer_Args& base_constrainer_args () const;


private:
  // Hold on to parameter values.

  bool _printfit;

  bool _use_G;

  double _constraint_sum_eps;

  double _chisq_diff_eps;

  int  _maxit;

  int  _max_cut;

  double _cutsize;

  double _min_tot_cutsize;

  double _chisq_test_eps;


  const Base_Constrainer_Args _base_constrainer_args;
};


//*************************************************************************


class Chisq_Constrainer
//
// Purpose: Minimize a chisq subject to a set of constraints.
//          Based on the SQUAW algorithm.
//
  : public Base_Constrainer
{
public:
  // Constructor, destructor.
  // ARGS holds the parameter settings for this instance.

  Chisq_Constrainer (const Chisq_Constrainer_Args& args);

  ~Chisq_Constrainer () override {}

  // Do the fit.
  // Call the number of well-measured variables Nw, the number of
  // poorly-measured variables Np, and the number of constraints Nc.
  // Inputs:
  //   CONSTRAINT_CALCULATOR is the object that will be used to evaluate
  //     the constraints.
  //   XM(Nw) and YM(Np) are the measured values of the well- and
  //     poorly-measured variables, respectively.
  //   X(Nw) and Y(Np) are the starting values for the fit.
  //   G_I(Nw,Nw) is the error matrix for the well-measured variables.
  //   Y(Np,Np) is the inverse error matrix for the poorly-measured variables.
  //
  // Outputs:
  //   X(Nw) and Y(Np) is the point at the minimum.
  //   PULLX(Nw) and PULLY(Np) are the pull quantities.
  //   Q(Nw,Nw), R(Np,Np), and S(Nw,Np) are the final error matrices
  //     between all the variables.
  //
  // The return value is the final chisq.  Returns a value < 0 if the
  // fit failed to converge.

  double fit (Constraint_Calculator& constraint_calculator,
                      const Column_Vector& xm,
                      Column_Vector& x,
                      const Column_Vector& ym,
                      Column_Vector& y,
                      const Matrix& G_i,
                      const Diagonal_Matrix& Y,
                      Column_Vector& pullx,
                      Column_Vector& pully,
                      Matrix& Q,
                      Matrix& R,
                      Matrix& S) override;

  // Print out any internal state to S.
  std::ostream& print (std::ostream& s) const override;


private:
  // Parameter settings.
  const Chisq_Constrainer_Args _args;
};

} // namespace hitfit


#endif // not HITFIT_CHISQ_CONSTRAINER_H