JAcoustics/JEvent.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JEVENT__
#define __JACOUSTICS__JEVENT__
 
#include <string>
#include <istream>
#include <ostream>
#include <iomanip>
#include <vector>
#include <algorithm>
 
#include <TROOT.h>
#include <TObject.h>
 
#include "JIO/JSerialisable.hh"
#include "JIO/JSTDIO.hh"
 
#include "JAcoustics/JCounter.hh"
#include "JAcoustics/JTransmission.hh"
 
 
/**
 * \file
 *
 * Acoustic event.
 * \author mdejong
 */
namespace JACOUSTICS {}
namespace JPP { using namespace JACOUSTICS; }
 
namespace JACOUSTICS {
 
  using JIO::JSerialisable;
  using JIO::JReader;
  using JIO::JWriter;
 
  /**
   * Acoustic event.
   */
  struct JEvent :
    public JSerialisable,
    public JCounter,
    public std::vector<JTransmission>,
    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 time-of-emission.
     */
    struct JEvaluator {
      /**
       * Type definition of time value.
       */
      typedef double  value_type;
 
 
      /**
       * Default constructor.
       */
      JEvaluator()
      {}
 
 
      /**
       * Get value of object.
       *
       * \param  event           event
       * \return                 value
       */
      inline value_type operator()(const JEvent& event) const
      {
        return event.begin()->getToE();
      }
    };
 
 
    /**
     * 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  detid          detector identifier
     * \param  counter        counter
     * \param  id             identifier
     * \param  __begin        begin of data
     * \param  __end          end   of data
     */
    template<class T>
    JEvent(const int detid,
           const int counter,
           const int id,
           T         __begin,
           T         __end) :   
      JCounter(counter),
      detid   (detid),
      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 detector identifier.
     *
     * \return                detector identifier.
     */
    const int getDetectorID() const
    {
      return detid;
    }
 
 
    /**
     * Get number of overlayed events.
     *
     * \return                overlays
     */
    int getOverlays() const
    {
      return overlays;
    }
 
 
    /**
     * Get emitter identifier.
     *
     * \return                identifier
     */
    int getID() const
    {
      return id;
    }
 
 
    /**
     * Merge event.
     *
     * It is assumed that the transmissions in both events are ordered
     * according the default less-than operator.
     *
     * \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;
    }
 
 
    /**
     * Swap events.
     *
     * \param  first          first  event
     * \param  second         second event
     */
    friend inline void swap(JEvent& first, JEvent& second)
    {
      std::swap(first.counter,  second.counter);
      std::swap(first.detid,    second.detid);
      std::swap(first.overlays, second.overlays);
      std::swap(first.id,       second.id);
 
      static_cast<std::vector<JTransmission>&>(first).swap(static_cast<std::vector<JTransmission>&>(second));
    }
 
 
    /**
     * Empty overlapping events.
     *
     * The events should be time sorted on input.\n
     * The time window applies to the difference between the first transmission
     * of an event and the last transmission of the previous event.
     *
     * \param  p              begin of events
     * \param  q              end   of events
     * \param  Tmax_s         time window [s]
     *
     */
    template<class T>
    static inline void overlap(T p, T q, const double Tmax_s)
    {
      for (T __q = p, __p = __q++; __p != q && __q != q; __p = __q++) {
 
        if (!__p->empty()                                            &&
            !__q->empty()                                            &&
            __q->begin()->getToE() < __p->rbegin()->getToE() + Tmax_s) {
 
          __p->clear();                            // clear first
 
          for (__p = __q++; __p != q && __q != q; __p = __q++) {
 
            if (__q->begin()->getToE() < __p->rbegin()->getToE() + Tmax_s)
              __p->clear();                        // clear intermediate
            else
              break;
          }
 
          __p->clear();                            // clear last
        }
      }
    }
 
 
    /**
     * 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
     */
    friend 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();
    }
 
 
    /**
     * 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 << event.getDetectorID()          << endl;
      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()        << ' ' 
            << setw(10) << i->getRunNumber() << ' ' 
            << fixed << setw(12) << setprecision(6) << i->getToA()  << ' '
            << fixed << setw(12) << setprecision(6) << i->getToE()  << ' '
            << fixed << setw(8)  << setprecision(0) << i->getQ()    << ' '
            << fixed << setw(8)  << setprecision(0) << i->getW()    << endl;
      }
 
      return out;
    }
 
 
    /**
     * Read from input.
     *
     * \param  in             reader
     * \return                reader
     */
    virtual JReader& read(JReader& in) override
    {
      in >> static_cast<JCounter&>(*this);
      in >> this->detid;
      in >> this->overlays;
      in >> this->id;
      in >> static_cast<std::vector<JTransmission>&>(*this);
  
      return in;
    }
 
 
    /**
     * Write to output.
     *
     * \param  out           writer
     * \return               writer
     */
    virtual JWriter& write(JWriter& out) const override
    {
      out << static_cast<const JCounter&>(*this);
      out << this->detid;
      out << this->overlays;
      out << this->id;
      out << static_cast<const std::vector<JTransmission>&>(*this);
 
      return out;
    }
 
    ClassDefOverride(JEvent, 4);
 
  protected:
    int         detid;
    int         overlays;
    int         id;
  };
}
 
#endif