Fourvec_Constrainer.h

Go to the documentation of this file.

//
//
// File: hitfit/Fourvec_Constrainer.h
// Purpose: Do a kinematic fit for a set of 4-vectors, given a set
//          of mass constraints.
// Created: Jul, 2000, sss, based on run 1 mass analysis code.
//
// Do a constrained fit on a set of 4-vectors.
// The input is in a Fourvec_Event instance.  This consists
// of a collection of objects, each of which has a 4-momentum
// and an integer label.  (Also uncertainties, etc.)
//
// We also have a set of mass constraints, based on sums of objects
// with specified labels.  A constraint can either require that the
// invariant mass of a set of objects is constant, or that the masses
// of two sets be equal to each other.  For example, the constraint
//
//    (1 2) = 80
//
// says that the sum of all objects with labels 1 and 2 should have
// a mass of 80.  And the constraint
//
//    (1 2) = (3 4)
//
// says that the sum of all objects with labels 1 and 2 should
// have an invariant mass the same as the sum of all objects with
// labels 3 and 4.
//
// All the objects are fixed to constant masses for the fit.
// (These masses are attributes of the objects in the Fourvec_Event.)
// This is done by scaling either the 4-vector's 3-momentum or energy,
// depending on the setting of the `use_e' parameter.
//
// If there is no neutrino present in the event, two additional constraints
// are automatically added for total pt balance, unless the parameter
// ignore_met has been set.
//
// When the fit completes, this object can compute an invariant mass
// out of some combination of the objects, including an uncertainty.
// The particular combination is specified through the method mass_contraint();
// it gets a constraint string like normal; the lhs of the constraint
// is the mass that will be calculated.  (The rhs should be zero.)
//
// CMSSW File      : interface/Fourvec_Constrainer.h
// Original Author : Scott Stuart Snyder <snyder@bnl.gov> for D0
// Imported to CMSSW by Haryo Sumowidagdo <Suharyo.Sumowidagdo@cern.ch>
//


#ifndef HITFIT_FOURVEC_CONSTRAINER_H
#define HITFIT_FOURVEC_CONSTRAINER_H


#include <string>
#include <vector>
#include <iosfwd>
#include "TopQuarkAnalysis/TopHitFit/interface/Constraint.h"
#include "TopQuarkAnalysis/TopHitFit/interface/Chisq_Constrainer.h"
#include "TopQuarkAnalysis/TopHitFit/interface/matutil.h"


namespace hitfit {


class Defaults;
class Fourvec_Event;
class Pair_Table;


class Fourvec_Constrainer_Args
//
// Purpose: Hold on to parameters for the Fourvec_Constrainer class.
//
// Parameters controlling the operation of the fitter:
//   bool use_e         - If true, then when rescaling the 4-vectors
//                        for a given mass, keep the measured energy
//                        and scale the 3-momentum.  Otherwise, keep
//                        the 3-momentum and scale the energy.
//   float e_com        - The center-of-mass energy.
//                        (Used only to keep the fit from venturing
//                        into completely unphysical regions.)
//   bool ignore_met    - If this is true and the event does not
//                        have a neutrino, then the fit will be done
//                        without the overall transverse momentum
//                        constraint (and thus the missing Et information
//                        will be ignored).  If the event does have
//                        a neutrino, this parameter is ignored.
//
{
public:
  // Constructor.  Initialize from a Defaults object.
  Fourvec_Constrainer_Args (const Defaults& defs);

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

  double e_com () const;

  bool ignore_met () const;


  // Arguments for subobjects.
  const Chisq_Constrainer_Args& chisq_constrainer_args () const;


private:
  // Hold on to parameter values.
  bool _use_e;

  double _e_com;

  bool _ignore_met;

  Chisq_Constrainer_Args _chisq_constrainer_args;
};


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


class Fourvec_Constrainer
//
// Purpose: Do a kinematic fit for a set of 4-vectors, given a set
//          of mass constraints.
//
{
public:
  // Constructor.
  // ARGS holds the parameter settings for this instance.
  Fourvec_Constrainer (const Fourvec_Constrainer_Args& args);

  // Specify an additional constraint S for the problem.
  // The format for S is described above.
  void add_constraint (std::string s);

  // Specify the combination of objects that will be returned by
  // constrain() as the mass.  The format of S is the same as for
  // normal constraints.  The LHS specifies the mass to calculate;
  // the RHS should be zero.
  // This should only be called once.
  void mass_constraint (std::string s);

  // Do a constrained fit for EV.  Returns the requested mass and
  // its error in M and SIGM, and the pull quantities in PULLX and
  // PULLY.  Returns the chisq; this will be < 0 if the fit failed
  // to converge.
  double constrain (Fourvec_Event& ev,
                    double& m,
                    double& sigm,
                    Column_Vector& pullx,
                    Column_Vector& pully);

  // Dump the internal state.
  friend std::ostream& operator<< (std::ostream& s,
                                   const Fourvec_Constrainer& c);


private:
  // Parameter settings.
  const Fourvec_Constrainer_Args _args;

  // The constraints for this problem.
  std::vector<Constraint> _constraints;

  // The constraint giving the mass to be calculated.  This
  // should have no more than one entry.
  std::vector<Constraint> _mass_constraint;
};


} // namespace hitfit


#endif // not HITFIT_FOURVEC_CONSTRAINER_H