JAcoustics/JHit.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JHIT__
#define __JACOUSTICS__JHIT__

#include <ostream>

#include "JDetector/JLocation.hh"
#include "JGeometry3D/JVector3D.hh"
#include "JMath/JGauss.hh"
#include "JLang/JManip.hh"

#include "JAcoustics/JEmitter.hh"
#include "JAcoustics/JCounter.hh"
#include "JAcoustics/JEKey.hh"


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

namespace JACOUSTICS {

  using JMATH::JGauss;
  using JDETECTOR::JLocation;
  using JGEOMETRY3D::JVector3D;


  /**
   * Custom probability density function of time-of-arrival.
   */
  struct JPDFGauss :
    public JGauss
  {
    using JGauss::getValue;

    /**
     * Default constructor.
     */
    JPDFGauss() :
      JGauss()
    {}


    /**
     * Constructor.
     *
     * \param  t1_s                     time-of-arrival [s]
     * \param  sigma_s                  resolution      [s]
     * \param  signal                   signal
     * \param  background               background probability \[0,1>
     */
    JPDFGauss(const double t1_s,
              const double sigma_s,
              const double signal     = 1.0,
              const double background = 0.0) :
      JGauss(t1_s, sigma_s, signal, background)
    {}


    /**
     * Get expectation value of time-of-arrival.
     *
     * \return                          time-of-arrival [s]
     */
    double getValue() const
    {
      return mean;
    }


    /**
     * Get weight.
     *
     * \return                          weight
     */
    double getWeight() const
    {
      return signal;
    }
  };


  /**
   * Acoustics hit.
   *
   * The template parameter should correspond to a data type which provides for the following policy methods.
   * <pre>
   *    double getValue() const;
   *    double getValue(double) const;
   *    double getDerivative(double) const;
   * </pre>
   * These should return
   * the expectation value,
   * the probability to observe a hit at a given time and
   * the derivative thereof, respectively.
   */
  template<class JPDF_t = JPDFGauss>
  struct JHit :
    public JEmitter,
    public JCounter,
    public JLocation,
    public JPDF_t
  {
    /**
     * Default constructor.
     */
    JHit()
    {}


    /**
     * Constructor.
     *
     * \param  emitter                  emitter
     * \param  counter                  counter
     * \param  location                 receiver location
     * \param  pdf                      probability density function
     */
    JHit(const JEmitter&  emitter,
         const JCounter&  counter,
         const JLocation& location,
         const JPDF_t&    pdf) :
      JEmitter(emitter),
      JCounter(counter),
      JLocation(location),
      JPDF_t(pdf)
    {}


    /**
     * Constructor.
     *
     * \param  key                      emitter key
     * \param  position                 emitter position
     * \param  location                 receiver location
     * \param  pdf                      probability density function
     */
    JHit(const JEKey&     key,
         const JVector3D& position,
         const JLocation& location,
         const JPDF_t&    pdf) :
      JEmitter(key.getID(), position),
      JCounter(key.getCounter()),
      JLocation(location),
      JPDF_t(pdf)
    {}


    /**
     * Get emitter hash key of this hit.
     *
     * \return                          hash key
     */
    JEKey getEKey() const
    {
      return JEKey(getID(), getCounter());
    }


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

      out << setw(3)     << hit.getID()      << ' ' 
          << setw(8)     << hit.getCounter() << ' '
          << getLabel(hit.getLocation())     
          << FIXED(20,5) << hit.getValue()   << ' '
          << FIXED(6,2)  << hit.getWeight();

      return out;
    }
  };
}

#endif