JSuperEvt.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JSUPEREVT__
#define __JACOUSTICS__JSUPEREVT__

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

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

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


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

namespace JACOUSTICS {

  /**
   * Acoustic super event fit.
   */
  struct JSuperEvt :
    public JEvt
  {
    /**
     * Default constructor.
     */
    JSuperEvt() :
      JEvt()
    {}


    /**
     * Constructor.
     *
     * \param  event                    event
     */
    JSuperEvt(const JEvt& event) :
      JEvt(event)
    {}


    /**
     * Acoustics emission.
     */
    struct tx_t {
      tx_t() :
        id     (-1),
        counter(-1),
        toe    (0.0)
      {}

      tx_t(const int    id,
           const int    counter,
           const double toe) :
        id     (id),
        counter(counter),
        toe    (toe)
      {}

      int    id;
      int    counter;
      double toe;
    };

    /**
     * Acoustics transmission.
     */
    struct rx_t {
      rx_t() :
        id     (-1),
        counter(-1),
        string (-1),
        floor  (-1),
        toa    (0.0),
        weight (0.0)
      {}

      rx_t(const int    id,
           const int    counter,
           const int    string,
           const int    floor,
           const double toa,
           const double weight) :
        id     (id),
        counter(counter),
        string (string),
        floor  (floor),
        toa    (toa),
        weight (weight)
      {}
      
      int    id;
      int    counter;
      int    string;
      int    floor;
      double toa;
      double weight;
    };

    typedef std::vector<tx_t> tx_type;
    typedef std::vector<rx_t> rx_type;
    
    tx_type  tx;
    rx_type  rx;

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

      out << static_cast<const JEvt&>(event);

      for (JSuperEvt::tx_type::const_iterator i = event.tx.begin(); i != event.tx.end(); ++i) {
        out << setw(2)     << i->id       << ' '
            << setw(6)     << i->counter  << ' '
            << FIXED(20,6) << i->toe      << endl;
      }

      for (JSuperEvt::rx_type::const_iterator i = event.rx.begin(); i != event.rx.end(); ++i) {
        out << setw(2)     << i->id       << ' '
            << setw(6)     << i->counter  << ' '
            << setw(4)     << i->string   << ' '
            << setw(2)     << i->floor    << ' '
            << FIXED(20,6) << i->toa      << ' '
            << FIXED( 5,2) << i->weight   << endl;
      }
      
      return out;
    }
    
    ClassDef(JSuperEvt, 1);
  };
}

#endif