Fourvec_Event.h

Go to the documentation of this file.

//
//
// File: hitfit/Fourvec_Event.h
// Purpose: Represent an event for kinematic fitting as a collection
//           of 4-vectors.
// Created: Jul, 2000, sss, based on run 1 mass analysis code.
//
// This class represents an `event' for kinematic fitting by
// Fourvec_Constrainer.  Each object in the event has the following
// attributes:
//
//   4-vector
//   mass
//     The kinematic fit assumes a fixed mass for each object.
//     That is specified by the `mass' attribute here.
//
//   p, phi, eta uncertainties
//   muon flag
//     If this is set, the `p' uncertainty is really in 1/p.
//
//   label
//     An integer that can be used to identify the object type.
//     I.e., lepton, b-jet from hadronic top, etc.
//
// There may be an object for a neutrino.
// If so, it is always at the end of the object list.
// It is not included in the count returned by nobjs() (but is included
// in nobjs_all()).
//
// We can also record one other `x' momentum, that will be added
// into the kt sum.  This can be used to store a missing Et that
// is not attributed to a neutrino (but is instead due to mismeasurement).
// Typically, this will be set to zero in events that have a neutrino,
// and to the measured missing Et in events that do not.
//
// CMSSW File      : interface/Fourvec_Event.h
// Original Author : Scott Stuart Snyder <snyder@bnl.gov> for D0
// Imported to CMSSW by Haryo Sumowidagdo <Suharyo.Sumowidagdo@cern.ch>
//
 
#ifndef HITFIT_FOURVEC_EVENT_H
#define HITFIT_FOURVEC_EVENT_H
 
#include "TopQuarkAnalysis/TopHitFit/interface/fourvec.h"
#include <vector>
#include <iosfwd>
 
namespace hitfit {
 
  struct FE_Obj
  //
  // Purpose: Represent a single object in a Fourvec_Event.
  //          This is just a dumb data container.
  //
  {
    // The 4-momentum of the object.
    Fourvec p;
 
    // The mass of the object.
    // The kinematic fit will fix the mass to this.
    double mass;
 
    // A label to identify the object type.
    int label;
 
    // p, phi, and eta uncertainties.
    double p_error;
 
    double phi_error;
 
    double eta_error;
 
    // If this is true, then p_error is really an uncertainty in 1/p,
    // rather than p (and we should use 1/p as the fit variable).
    bool muon_p;
 
    // Constructor, for convenience.
    FE_Obj(const Fourvec& the_p,
           double the_mass,
           int the_label,
           double the_p_error,
           double the_phi_error,
           double the_eta_error,
           bool the_muon_p);
  };
 
  // Print it out.
  std::ostream& operator<<(std::ostream& s, const FE_Obj& o);
 
  //************************************************************************
 
  // The special label used for a neutrino.
  const int nu_label = -1;
 
  class Fourvec_Event
  //
  // Purpose: Represent an event for kinematic fitting as a collection
  //           of 4-vectors.
  //
  {
  public:
    // Constructor.
    Fourvec_Event();
 
    //****************************
    // Accessors.
    //
 
    // Return true if this event contains a neutrino.
    bool has_neutrino() const;
 
    // Return the number of objects in the event, not including any neutrino.
    int nobjs() const;
 
    // Return the number of objects in the event, including any neutrino.
    int nobjs_all() const;
 
    // Access object I.  (Indexing starts with 0.)
    const FE_Obj& obj(std::vector<FE_Obj>::size_type i) const;
 
    // Access the neutrino 4-momentum.
    const Fourvec& nu() const;
 
    // Access the kt 4-momentum.
    const Fourvec& kt() const;
 
    // Access the X 4-momentum.
    const Fourvec& x() const;
 
    // Access the kt uncertainties.
    double kt_x_error() const;
 
    double kt_y_error() const;
 
    double kt_xy_covar() const;
 
    // Print out the contents.
    friend std::ostream& operator<<(std::ostream& s, const Fourvec_Event& fe);
 
    //****************************
    // Modifiers.
    //
 
    // Add an object to the event.
    // (This should not be a neutrino --- use set_nu_p for that.)
    void add(const FE_Obj& obj);
 
    // Set the neutrino 4-momentum to P.
    // This adds a neutrino if there wasn't already one.
    void set_nu_p(const Fourvec& p);
 
    // Set the 4-momentum of object I to P.
    void set_obj_p(std::vector<FE_Obj>::size_type i, const Fourvec& p);
 
    // Set the 4-momentum of the X object.
    void set_x_p(const Fourvec& p);
 
    // Set the kt uncertainties.
    void set_kt_error(double kt_x_error, double kt_y_error, double kt_xy_covar);
 
  private:
    // The list of contained objects.
    std::vector<FE_Obj> _objs;
 
    // Cached kt.  This should always be equal to the sum of all the
    // object momenta, including x.
    Fourvec _kt;
 
    // Momemtum of the X object.
    Fourvec _x;
 
    // The kt uncertainties.
    double _kt_x_error;
 
    double _kt_y_error;
 
    double _kt_xy_covar;
 
    // Flag that a neutrino has been added.
    bool _has_neutrino;
  };
 
}  // namespace hitfit
 
#endif  // not HITFIT_FOURVEC_EVENT_H