JEvt.hh

Go to the documentation of this file.

#ifndef __JFIT__JEVT__
#define __JFIT__JEVT__
 
#include <istream>
#include <ostream>
#include <iomanip>
#include <vector>
#include <limits>
 
#include <TROOT.h>
#include <TObject.h>
 
#include "JLang/JType.hh"
#include "JROOT/JRoot.hh"
#include "JROOT/JTreeParameters.hh"
 
#include "JFit/JHistory.hh"
 
/**
 * \author mdejong
 */
 
namespace JFIT {}
namespace JPP { using namespace JFIT; }
 
namespace JFIT {
 
  /**
   * Data structure for track fit results.
   */
  class JFit : 
    public TObject,
    public JHistory
  {
  public:
    /**
     * Default constructor.
     * Parameters are initialized with non physical values
     */
    JFit():
      __x( -std::numeric_limits<double>::max() ),
      __y( -std::numeric_limits<double>::max() ),
      __z( -std::numeric_limits<double>::max() ),
      __dx(0.0),
      __dy(0.0),
      __dz(0.0),
      __t( -std::numeric_limits<double>::max() ),
      __Q( -std::numeric_limits<double>::max() ),
      __NDF(-1),
      __E(0.0),
      __status(-1)
    {}
 
 
    /**
     * Constructor.
     * 
     * \param  history  history
     * \param  x        X-position
     * \param  y        Y-position
     * \param  z        Z-position
     * \param  dx       X-slope
     * \param  dy       Y-slope
     * \param  dz       Z-slope
     * \param  t        time
     * \param  Q        quality
     * \param  NDF      number of degrees of freedom
     * \param  E        energy
     * \param  status   status
     */
    JFit(const JHistory& history,
         const double x,
         const double y,
         const double z,
         const double dx,
         const double dy,
         const double dz,
         const double t,
         const double Q,
         const int    NDF,
         const double E      = 0.0,
         const int    status = -1) :
      JHistory(history)
    {
      __x      = x;
      __y      = y;
      __z      = z;
      __dx     = dx;
      __dy     = dy;
      __dz     = dz;
      __t      = t;
      __Q      = Q;
      __NDF    = NDF;
      __E      = E;
      __status = status;
    }
 
 
    /**
     * Constructor for storing position only.\n
     * Note that the type of fit can be obtained via the history information.
     *
     * \param  history  history
     * \param  x        X-position
     * \param  y        Y-position
     * \param  z        Z-position 
     * \param  status   status
     */
    JFit(const JHistory& history,
         const double x,
         const double y,
         const double z,
         const int    status = -1):
      JHistory(history)
    {
      __x      = x;
      __y      = y;
      __z      = z;
      __dx     = 0.0;
      __dy     = 0.0;
      __dz     = 0.0;
      __t      = 0.0;
      __Q      = 0.0;
      __NDF    = -1;
      __E      = 0.0;
     __status  = status;
    }
    
 
    /**
     * Add event to history.
     *
     * \param  type          application type
     * \return               this fit
     */
    JFit& add(const int type)
    {
      getHistory().add(type);
 
      return *this;
    }
 
 
    double getX()       const { return __x; }           //!< Get X-position.
    double getY()       const { return __y; }           //!< Get Y-position.
    double getZ()       const { return __z; }           //!< Get Z-position.
    double getDX()      const { return __dx; }          //!< Get X-slope.
    double getDY()      const { return __dy; }          //!< Get Y-slope.
    double getDZ()      const { return __dz; }          //!< Get Z-slope.
    double getT()       const { return __t; }           //!< Get time.
    double getQ()       const { return __Q; }           //!< Get quality.
    int    getNDF()     const { return __NDF; }         //!< Get number of degrees of freedom.
    double getE()       const { return __E; }           //!< Get energy.
    int    getStatus()  const { return __status; }      //!< Get status of the fit; negative values should refer to a bad fit.
 
 
    /**
     * Move vertex along this track with given velocity.
     *
     * \param  step          step
     * \param  velocity      velocity
     */
    void move(const double step, const double velocity)
    {
      __x += step * __dx;
      __y += step * __dy;
      __z += step * __dz;
      __t += step / velocity;
    }
 
 
    /**
     * Set energy.
     *
     * \param  E        energy
     */
    void setE(const double E)
    {
      __E = E;
    }
 
 
    /**
     * Get values.
     *
     * \return          values
     */
    const std::vector<double>& getW() const
    {
      return this->W;
    }
 
 
    /**
     * Set values.
     *
     * \param  W          values
     */
    void setW(const std::vector<double>& W)
    {
      this->W = W;
    }
 
 
    /**
     * Get number of values.
     *
     * \return          number of values
     */
    int getN() const 
    { 
      return W.size();
    }
  
 
    /**
     * Check availability of value.
     *
     * \param  i        index
     * \return          true if available; else false
     */
    bool hasW(const int i) const
    { 
      return (i >= 0 && i < (int) W.size());
    }
  
 
    /**
     * Get value.
     *
     * \param  i        index
     * \return          value
     */
    double getW(const int i) const
    { 
      return W.at(i);
    }
  
 
    /**
     * Get value.
     *
     * \param  i        index
     * \param  value    default value
     * \return          value
     */
    double getW(const int i, const double value) const
    { 
      if (hasW(i))
        return W.at(i);
      else
        return value;
    }
 
 
    /**
     * Set value.
     *
     * \param  i        index
     * \param  value    value
     */
    void setW(const int i, const double value)
    { 
      if (i >= (int) W.size()) {
        W.resize(i + 1, 0.0);
      }
 
      W[i] = value;
    }
 
 
    ClassDef(JFit, 5);
 
  protected:
    double  __x;
    double  __y;
    double  __z;
    double  __dx;
    double  __dy;
    double  __dz;
    double  __t;
    double  __Q;
    int     __NDF;
    std::vector<double> W;
    double  __E;
    int __status;
  };
 
 
  /**
   * Data structure for set of track fit results.
   */
  class JEvt : 
    public TObject,
    public std::vector<JFit>
  {
  public:
    /**
     * Default constructor.
     */
    JEvt()
    {}
 
 
    /**
     * Select fits.
     *
     * \param  select   fit selection
     */
    template<class JPredicate_t>
    void partition(JPredicate_t select)
    {
      this->erase(std::partition(this->begin(), this->end(), select), this->end());
    }
      
    
    /**
     * Write event to output.
     *
     * \param  out      output stream
     * \param  event    event
     * \return          output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JEvt& event)
    {
      using namespace std;
    
      out << "Event: " << endl;
 
      for (JEvt::const_iterator fit = event.begin(); fit != event.end(); ++fit) {
        out << *fit;
      }
    
      return out;
    }
 
 
    ClassDef(JEvt, 3);
  };
}
 
 
/**
 * Write fit results to output.
 *
 * \param  out      output stream
 * \param  fit      fit results
 * \return          output stream
 */
std::ostream& operator<<(std::ostream& out, const JFIT::JFit& fit);
 
 
/**
 * Get TTree parameters for given data type.
 *
 * \return          TTree parameters
 */
inline JROOT::JTreeParameters getTreeParameters(JLANG::JType<JFIT::JEvt>)
{
  return JROOT::JTreeParameters("EVT", "evt", "", 0);
}
 
 
#endif