Base_Constrainer.h

Go to the documentation of this file.

//
//
// File: hitfit/Base_Constrainer.h
// Purpose: Abstract base for the chisq fitter classes.
//          This allows for different algorithms to be used.
// Created: Jul, 2000, sss, based on run 1 mass analysis code.
//
// CMSSW File      : interface/Base_Constrainer.h
// Original Author : Scott Stuart Snyder <snyder@bnl.gov> for D0
// Imported to CMSSW by Haryo Sumowidagdo <Suharyo.Sumowidagdo@cern.ch>

#ifndef HITFIT_BASE_CONSTRAINER_H
#define HITFIT_BASE_CONSTRAINER_H

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

namespace hitfit {

  class Defaults;

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

  class Base_Constrainer_Args
  //
  // Purpose: Hold on to parameters for the Base_Constrainer class.
  //
  // Parameters:
  //   bool test_gradient - If true, check the constraint gradient calculations
  //                        by also doing them numerically.
  //   float test_step    - When test_gradient is true, the step size to use
  //                        for numeric differentiation.
  //   float test_eps     - When test_gradient is true, the maximum relative
  //                        difference permitted between returned and
  //                        numerically calculated gradients.
  //
  {
  public:
    // Constructor.  Initialize from a Defaults object.

    Base_Constrainer_Args(const Defaults& defs);

    // Retrieve parameter values.
    bool test_gradient() const;

    double test_step() const;

    double test_eps() const;

  private:
    // Hold on to parameter values.

    bool _test_gradient;

    double _test_step;

    double _test_eps;
  };

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

  class Constraint_Calculator
  //
  // Purpose: Abstract base class for evaluating constraints.
  //          Derive from this and implement the eval() method.
  //
  {
  public:
    // Constructor, destructor.  Pass in the number of constraints.

    Constraint_Calculator(int nconstraints);

    virtual ~Constraint_Calculator() {}

    // Get back the number of constraints.
    int nconstraints() const;

    // Evaluate constraints at the point described by X and Y (well-measured
    // and poorly-measured variables, respectively).  The results should
    // be stored in F.  BX and BY should be set to the gradients of F with
    // respect to X and Y, respectively.
    //
    // Return true if the point X, Y is accepted.
    // Return false if it is rejected (i.e., in an unphysical region).
    // The constraints need not be evaluated in that case.

    virtual bool eval(const Column_Vector& x, const Column_Vector& y, Row_Vector& F, Matrix& Bx, Matrix& By) = 0;

  private:
    // The number of constraint functions.
    int _nconstraints;
  };

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

  class Base_Constrainer
  //
  // Purpose: Base class for chisq constrained fitter.
  //
  {
  public:
    // Constructor, destructor.
    // ARGS holds the parameter settings for this instance.

    Base_Constrainer(const Base_Constrainer_Args& args);

    virtual ~Base_Constrainer() {}

    // 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.

    virtual 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) = 0;

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

    // Print out internal state to S.
    friend std::ostream& operator<<(std::ostream& s, const Base_Constrainer& f);

  private:
    // Parameter settings.

    const Base_Constrainer_Args _args;

  protected:
    // Helper function to evaluate the constraints.
    // This takes care of checking what the user function returns against
    // numerical derivatives, if that was requested.

    bool call_constraint_fcn(Constraint_Calculator& constraint_calculator,
                             const Column_Vector& x,
                             const Column_Vector& y,
                             Row_Vector& F,
                             Matrix& Bx,
                             Matrix& By) const;
  };

}  // namespace hitfit

#endif  // not HITFIT_BASE_CONSTRAINER_H