JAcoustics/JEvent.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JEVENT__
#define __JACOUSTICS__JEVENT__

#include <iostream>
#include <iomanip>
#include <vector>
#include <algorithm>

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

#include "JAcoustics/JCounter.hh"
#include "JAcoustics/JTransmission.hh"


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

namespace JACOUSTICS {

  /**
   * Acoustic event.
   */
  struct JEvent :
    public JCounter,
    public std::vector<JTransmission>,
    public TObject
  {
    /**
     * Default constructor.
     */
    JEvent() :
      JCounter(),
      overlays(0),
      id      (-1)
    {}


    /**
     * Constructor.
     *
     * The transmissions will be sorted to ensure proper functioning of method JEvent::merge and class JEventOverlap.
     * 
     * \param  counter        counter
     * \param  id             identifier
     * \param  __begin        begin of data
     * \param  __end          end   of data
     */
    template<class T>
    JEvent(const int counter,
           const int id,
           T         __begin,
           T         __end) :   
      JCounter(counter),
      overlays(0),
      id      (id)
    {
      using namespace std;

      for (T i = __begin; i != __end; ++i) {
        push_back(*i);
      }

      sort(this->begin(), this->end());
    }


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


    /**
     * Get counter.
     *
     * \return                counter
     */
    int getCounter() const
    {
      return counter;
    }


    /**
     * Get overlays.
     *
     * \return                overlays
     */
    int getOverlays() const
    {
      return overlays;
    }


    /**
     * Get identifier.
     *
     * \return                identifier
     */
    int getID() const
    {
      return id;
    }


    /**
     * Merge event.
     *
     * \param  event          event
     */
    void merge(const JEvent& event)
    {
      using namespace std;

      vector<JTransmission> buffer;

      const_iterator __hit1 = this ->begin();
      const_iterator __end1 = this ->end();

      const_iterator __hit2 = event.begin();
      const_iterator __end2 = event.end();

      buffer.resize(this->size() + event.size());

      iterator out = buffer.begin();

      while (__hit1 != __end1 && __hit2 != __end2) {

        if        (*__hit1 < *__hit2) {

          *out = *__hit1;
          ++__hit1;

        } else if (*__hit2 < *__hit1) {

          *out = *__hit2;
          ++__hit2;

        } else {

          *out  = *__hit1;

          ++__hit1;
          ++__hit2;
        }

        ++out;
      }

      // append remaining hits from either set

      out = copy(__hit1, __end1, out);
      out = copy(__hit2, __end2, out);

      buffer.resize(distance(buffer.begin(), out));

      this->swap(buffer);

      ++overlays;
    }


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

      out << setw(8) << event.getCounter()  << endl;
      out << setw(2) << event.getOverlays() << endl;
      out << setw(3) << event.getID()       << endl;

      for (const_iterator i = event.begin(); i != event.end(); ++i) {

        out << setw(10) << i->getID()    << ' ' 
            << fixed << setw(9) << setprecision(3) << i->getToA()  << ' '
            << fixed << setw(9) << setprecision(3) << i->getToE()  << ' '
            << fixed << setw(6) << setprecision(0) << i->getQ()    << endl;
      }

      return out;
    }

    ClassDef(JEvent, 1);
    
  protected:
    int    counter;
    int    overlays;
    int    id;
  };


  /**
   * Less than operator for acoustics events.
   *
   * The less than operator is applied to the first hit in the events.\n
   * If there are no hits in either event, the counter of the events is used.
   *
   * \param  first          first  event
   * \param  second         second event
   * \return                true if first event earliear than second; else false
   */
  inline bool operator<(const JEvent& first, const JEvent& second)
  {
    if (!first.empty() && !second.empty())
      return first.begin()->getToE() < second.begin()->getToE();
    else
      return first.getCounter() < second.getCounter();
  }
}

#endif