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 "Jeep/JPrint.hh"
#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. We keep it inside of JFit in order to restrict the ROOT-TObject participation in the software
     * Whether this is related to a Position or a real fit can be obtained via JFitApplication_t    
     * \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 JFitApplication_t& 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 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;
    }


    /**
     * Write fit results to output.
     *
     * \param  out      output stream
     * \param  fit      fit results
     * \return          output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JFit& fit)
    {
      using namespace std;
    
      const JHistory& history = fit.getHistory();

      out << "history:";

      for (JHistory::const_reverse_iterator i = history.rbegin(); i != history.rend(); ++i) {
        out << ' ' << i->type;
      }

      out << endl;
      
      out << "x    " << FIXED(7,2) << fit.getX()  << endl;
      out << "y    " << FIXED(7,2) << fit.getY()  << endl;
      out << "z    " << FIXED(7,2) << fit.getZ()  << endl;
      out << "dx   " << FIXED(7,3) << fit.getDX() << endl;
      out << "dy   " << FIXED(7,3) << fit.getDY() << endl;
      out << "dz   " << FIXED(7,3) << fit.getDZ() << endl;

      out << "Q    " << FIXED(12,5) << fit.getQ()   << endl;
      out << "NDF  " << setw(5)     << fit.getNDF() << endl;

      out << "status " << fit.getStatus() << endl;

      for (int i = 0; i != fit.getN(); ++i) {
        out << "W[" << i << "] = " << FIXED(10,5) << fit.getW(i) << endl;
      }
    
      return out;
    }


    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);
  };
}


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