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"


/**
 * \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)
    {}


    /**
     * Constructor.
     *
     * \param  id                       string identifier
     * \param  tx                       slope dx/dz
     * \param  ty                       slope dy/dz
     */
    JFit(const int    id,
         const double tx,
         const double ty) :
      id(id),
      tx(tx),
      ty(ty)
    {}


    /**
     * 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(9,6) << fit.tx << ' '
          << FIXED(9,6) << fit.ty;

      return out;
    }


    ClassDef(JFit, 1);

    int     id;                        ///< string identifier
    double  tx;                        ///< slope dx/dz
    double  ty;                        ///< slope dy/dz
  };


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


    /**
     * Constructor.
     *
     * \param  oid                      detector identifer
     * \param  t0                       UNIX start time
     * \param  t1                       UNIX stop  time
     * \param  ndf                      number of degrees of freedom
     * \param  weight                   total weight of hits
     * \param  chi2                     chi2
     */
    JHead(const std::string& oid,
          const double t0,
          const double t1,
          const int    ndf,
          const double weight,
          const double chi2) :
      oid (oid),
      UNIXTimeStart(t0),
      UNIXTimeStop (t1),
      ndf   (ndf),
      weight(weight),
      chi2  (chi2)
    {}


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


    ClassDef(JHead, 3);

    std::string oid;                   ///< detector identifier
    double  UNIXTimeStart;             ///< start time
    double  UNIXTimeStop;              ///< stop  time
    int     ndf;                       ///< number of degrees of freedom
    double  weight;                    ///< total weight of hits
    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.ndf           << endl
          << FIXED(12,3) << event.chi2          << endl;
        
      for (JEvt::const_iterator fit = event.begin(); fit != event.end(); ++fit) {
        out << *fit << endl;
      }

      return out;
    }


    ClassDef(JEvt, 3);
  };
}

#endif