JAcoustics/JEvt.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JEVT__
#define __JACOUSTICS__JEVT__

#include <string>
#include <ostream>
#include <iomanip>
#include <vector>

#include <TROOT.h>
#include <TObject.h>

#include "JLang/JManip.hh"
#include "JAcoustics/JTimeRange.hh"


/**
 * \file
 *
 * Acoustic event fit.
 * \author mdejong
 */
namespace JACOUSTICS {}
namespace JPP { using namespace JACOUSTICS; }

namespace JACOUSTICS {

  /**
   * Acoustic single fit.
   */
  struct JFit :
    public TObject
  {
    /**
     * Default constructor.
     */
    JFit() :
      id (-1),
      tx (0.0),
      ty (0.0),
      tx2(0.0),
      ty2(0.0),
      vs (0.0)
    {}


    /**
     * Constructor.
     *
     * \param  id                       string identifier
     * \param  tx                       slope dx/dz
     * \param  ty                       slope dy/dz
     * \param  tx2                      2nd order correction of slope dx/dz
     * \param  ty2                      2nd order correction of slope dy/dz
     * \param  vs                       stretching factor
     */
    JFit(const int    id,
         const double tx,
         const double ty,
         const double tx2,
         const double ty2,
         const double vs) :
      id (id),
      tx (tx),
      ty (ty),
      tx2(tx2),
      ty2(ty2),
      vs (vs)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JFit()
    {}


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

      out << setw(4)          << fit.id  << ' '
          << FIXED(10,7)      << fit.tx  << ' '
          << FIXED(10,7)      << fit.ty  << ' '
          << SCIENTIFIC(12,3) << fit.tx2 << ' '
          << SCIENTIFIC(12,3) << fit.ty2 << ' '
          << FIXED(8,5)       << fit.vs;

      return out;
    }


    ClassDef(JFit, 2);

    int     id;                        ///< string identifier
    double  tx;                        ///< slope dx/dz
    double  ty;                        ///< slope dy/dz
    double  tx2;                       ///< 2nd order correction of slope dx/dz
    double  ty2;                       ///< 2nd order correction of slope dy/dz
    double  vs;                        ///< stretching factor
  };


  /**
   * Acoustic event header.
   */
  struct JHead {
    /**
     * Default constructor.
     */
    JHead() :
      oid (),
      UNIXTimeStart(0.0),
      UNIXTimeStop (0.0),
      nhit(0),
      npar(0),
      ndf (0.0),
      chi2(0.0)
    {}


    /**
     * Constructor.
     *
     * \param  oid                      detector identifer
     * \param  range                    UNIX start and stop time [s]
     * \param  nhit                     number of hits
     * \param  npar                     number of fit parameters
     * \param  ndf                      weighed number of degrees of freedom
     * \param  chi2                     chi2
     */
    JHead(const std::string& oid,
          const JTimeRange&  range,
          const int    nhit,
          const int    npar,
          const double ndf,
          const double chi2) :
      oid (oid),
      UNIXTimeStart(range.getLowerLimit()),
      UNIXTimeStop (range.getUpperLimit()),
      nhit(nhit),
      npar(npar),
      ndf (ndf),
      chi2(chi2)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JHead()
    {}


    ClassDef(JHead, 4);

    std::string oid;                   ///< detector identifier
    double  UNIXTimeStart;             ///< start time
    double  UNIXTimeStop;              ///< stop  time
    int     nhit;                      ///< number of hits
    int     npar;                      ///< number of fit parameters
    double  ndf;                       ///< weighed number of degrees of freedom
    double  chi2;                      ///< chi2
  };


  /**
   * Less than operator for acoustics event headers.
   *
   * The less than operator is applied to the object identifier,
   * the UNIX start time and the UNIX stop time, respectively.
   *
   * \param  first          first  header
   * \param  second         second header
   * \return                true if first event header earliear than second; else false
   */
  inline bool operator<(const JHead& first, const JHead& second)
  {
    if (first.oid == second.oid) {

      if (first.UNIXTimeStart == second.UNIXTimeStart) {

        return first.UNIXTimeStop  < second.UNIXTimeStop;

      } else {

        return first.UNIXTimeStart < second.UNIXTimeStart;
      }

    } else {

      return first.oid < second.oid;
    }
  }


  /**
   * Acoustic event fit.
   */
  struct JEvt :
    public JHead,
    public std::vector<JFit>,
    public TObject
  {
    /**
     * Auxiliary class to determine value of acoustic events.\n
     * This class can be used with JSUPPORT::JTreeScanner so to read acoustics events in order of start time.
     */
    struct JEvaluator {
      /**
       * Default constructor.
       */
      JEvaluator()
      {}


      /**
       * Get value of object.
       *
       * \param  event           event
       * \return                 value
       */
      inline double operator()(const JEvt& event) const
      {
        return event.UNIXTimeStart;
      }
    };


    /**
     * Default constructor.
     */
    JEvt() :
      JHead()
    {}


    /**
     * Constructor.
     *
     * \param  header                   header
     */
    JEvt(const JHead& header) :
      JHead(header)
    {}


    /**
     * Virtual destructor.
     */
    virtual ~JEvt()
    {}


    /**
     * 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.oid                          << endl
          << FIXED(20,5) << event.UNIXTimeStart << endl
          << FIXED(20,5) << event.UNIXTimeStop  << endl
          << setw(5)     << event.nhit          << ' '
          << setw(4)     << event.npar          << endl
          << FIXED(12,3) << event.chi2          << ' '
          << FIXED(7,1)  << event.ndf           << endl;
        
      for (JEvt::const_iterator fit = event.begin(); fit != event.end(); ++fit) {
        out << *fit << endl;
      }

      return out;
    }


    ClassDef(JEvt, 6);
  };
}

#endif