JAcoustics/JModel.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JMODEL__
#define __JACOUSTICS__JMODEL__

#include <ostream>
#include <iomanip>
#include <limits>
#include <cmath>

#include "JMath/JMath.hh"
#include "JMath/JZero.hh"
#include "JLang/JEquals.hh"
#include "JLang/JException.hh"
#include "JTools/JHashMap.hh"
#include "JTools/JHashMapToolkit.hh"
#include "Jeep/JPrint.hh"

#include "JAcoustics/JEKey.hh"


/**
 * \file
 *
 * Model for fit to acoutsics data.
 * \author mdejong
 */
namespace JACOUSTICS {}
namespace JPP { using namespace JACOUSTICS; }

namespace JACOUSTICS {

  using JLANG::JValueOutOfRange;
  using JLANG::JIndexOutOfRange;
  using JTOOLS::JHashMap;


  /**
   * Model for fit to acoustics data.
   *
   * The model consists of string parameters and emitter parameters.\n
   * These parameters relate to the string identifer and emitter key, respectively.
   */
  struct JModel :
    public JMATH::JMath  <JModel>,
    public JLANG::JEquals<JModel>,
    public JTOOLS::JHashMapToolkit
  {
    using JTOOLS::JHashMapToolkit::reset;
    using JTOOLS::JHashMapToolkit::set;
    using JTOOLS::JHashMapToolkit::equals;


    /**
     * Type definition of fit parameter.
     */
    typedef size_t  parameter_type;


    /**
     * String parameters.
     */
    struct JString :
      public JMATH::JMath  <JString>,
      public JLANG::JEquals<JString>
    {
      /**
       * Default constructor.
       */
      JString() :
        tx(0.0),
        ty(0.0)
      {}


      /**
       * Constructor.
       *
       * \param  tx                       slope dx/dz
       * \param  ty                       slope dy/dz
       */
      JString(const double tx,
              const double ty) :
        tx(tx),
        ty(ty)
      {}


      /**
       * Negate string.
       *
       * \return                          this string
       */
      JString& negate()
      {
        tx = -tx;
        ty = -ty;

        return *this;
      }


      /**
       * Add string.
       *
       * \param  string                   string
       * \return                          this string
       */
      JString& add(const JString& string)
      {
        tx += string.tx;
        ty += string.ty;

        return *this;
      }


      /**
       * Subtract string.
       *
       * \param  string                   string
       * \return                          this string
       */
      JString& sub(const JString& string)
      {
        tx -= string.tx;
        ty -= string.ty;

        return *this;
      }


      /**
       * Scale string.
       *
       * \param  factor                   multiplication factor
       * \return                          this string
       */
      JString& mul(const double factor)
      {
        tx *= factor;
        ty *= factor;

        return *this;
      }


      /**
       * Scale string.
       *
       * \param  factor                   division factor
       * \return                          this string
       */
      JString& div(const double factor)
      {
        tx /= factor;
        ty /= factor;

        return *this;
      }


      /**
       * Check equality.
       *
       * \param  string                   string
       * \param  precision                precision
       * \return                          true if strings are equal; else false
       */
      bool equals(const JString& string,
                  const double   precision = std::numeric_limits<double>::min()) const
      {
        return (fabs(tx - string.tx) <= precision &&
                fabs(ty - string.ty) <= precision);
      }


      /**
       * Get dot product.
       *
       * \param  string                   string
       * \return                          dot product
       */
      double getDot(const JString& string) const
      {
        return (tx * string.tx +
                ty * string.ty);
      }

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

        return out << FIXED(10,7) << string.tx << ' '
                   << FIXED(10,7) << string.ty;
      }


      double tx;
      double ty;
    };


    /**
     * Emitter parameters.
     */
    struct JEmitter :
      public JMATH::JMath  <JEmitter>,
      public JLANG::JEquals<JEmitter>
    {
      /**
       * Default constructor.
       */
      JEmitter() :
        t1(0.0)
      {}


      /**
       * Constructor.
       *
       * \param  t1                       time-of-emission [s]
       */
      JEmitter(const double t1) :
        t1(t1)
      {}


      /**
       * Negate emitter.
       *
       * \return                          this emitter
       */
      JEmitter& negate()
      {
        t1 = -t1;

        return *this;
      }


      /**
       * Add emitter.
       *
       * \param  emitter                  emitter
       * \return                          this emitter
       */
      JEmitter& add(const JEmitter& emitter)
      {
        t1 += emitter.t1;

        return *this;
      }


      /**
       * Subtract emitter.
       *
       * \param  emitter                  emitter
       * \return                          this emitter
       */
      JEmitter& sub(const JEmitter& emitter)
      {
        t1 -= emitter.t1;

        return *this;
      }


      /**
       * Scale emitter.
       *
       * \param  factor                   multiplication factor
       * \return                          this emitter
       */
      JEmitter& mul(const double factor)
      {
        t1 *= factor;

        return *this;
      }


      /**
       * Scale emitter.
       *
       * \param  factor                   division factor
       * \return                          this emitter
       */
      JEmitter& div(const double factor)
      {
        t1 /= factor;

        return *this;
      }


      /**
       * Check equality.
       *
       * \param  emitter                  emitter
       * \param  precision                precision
       * \return                          true if emitters are equal; else false
       */
      bool equals(const JEmitter& emitter,
                  const double    precision = std::numeric_limits<double>::min()) const
      {
        return (fabs(t1 - emitter.t1) <= precision);
      }


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

        return out << FIXED(20,6) << emitter.t1;
      }


      double t1;
    };


    /**
     * Default constructor.
     */
    JModel()
    {}


    /**
     * Constructor.
     *
     * This constructor can be used to set up a default model (i.e. all values at zero) for the given set of hits.\n
     * The data type corresponding to the hits should provide for the following policy methods.
     * <pre>
     *    int      getString();        // get string  identifier
     *    JEkey    getEKey();          // get emitter identifier
     * </pre>
     *
     * \param  __begin                  begin of hits
     * \param  __end                    end   of hits
     */
    template<class T>
    JModel(T __begin, T __end)
    {
      for (T hit = __begin; hit != __end; ++hit) {

        if (!this->string.has(hit->getString())) {
          this->string[hit->getString()] = JString();
        }

        if (!this->emitter.has(hit->getEKey())) {
          this->emitter[hit->getEKey()]  = JEmitter();
        }
      }
    }


    /**
     * Reset.
     *
     * \param  zero                     zero
     * \return                          this model
     */
    JModel& operator=(const JMATH::JZero& zero)
    {
      this->reset();

      return *this;
    }


    /**
     * Clear parameters.
     */
    void clear()
    {
      string .clear();
      emitter.clear();
    }


    /**
     * Reset parameters.
     */
    void reset()
    {
      reset(string);
      reset(emitter);
    }


    /**
     * Set parameters.
     *
     * \param  model                    model
     * \param  value                    value
     */
    template<class T>
    void set(const JModel& model, const T& value)
    {
      set(this->string,  model.string,  static_cast<const JString&> (value));
      set(this->emitter, model.emitter, static_cast<const JEmitter&>(value));
    }


    /**
     * Negate model.
     *
     * \return                          this model
     */
    JModel& negate()
    {
      evaluate(this->string,  &JString ::negate);
      evaluate(this->emitter, &JEmitter::negate);

      return *this;
    }


    /**
     * Add model.
     *
     * \param  model                    model
     * \return                          this model
     */
    JModel& add(const JModel& model)
    {
      evaluate(this->string,  model.string,  &JString ::add);
      evaluate(this->emitter, model.emitter, &JEmitter::add);

      return *this;
    }
    

    /**
     * Subtract model.
     *
     * \param  model                    model
     * \return                          this model
     */
    JModel& sub(const JModel& model)
    {
      evaluate(this->string,  model.string,  &JString ::sub);
      evaluate(this->emitter, model.emitter, &JEmitter::sub);

      return *this;
    }


    /**
     * Scale model.
     *
     * \param  factor                   multiplication factor
     * \return                          this model
     */
    JModel& mul(const double factor)
    {
      evaluate(this->string,  &JString ::mul, factor);
      evaluate(this->emitter, &JEmitter::mul, factor);

      return *this;
    }


    /**
     * Scale model.
     *
     * \param  factor                   division factor
     * \return                          this model
     */
    JModel& div(const double factor)
    {
      evaluate(this->string,  &JString ::div, factor);
      evaluate(this->emitter, &JEmitter::div, factor);

      return *this;
    }


    /**
     * Check equality.
     *
     * \param  model                    model
     * \param  precision                precision
     * \return                          true if models are equal; else false
     */
    bool equals(const JModel& model,
                const double  precision = std::numeric_limits<double>::min()) const
    {
      return (equals(this->string,  model.string,  precision) &&
              equals(this->emitter, model.emitter, precision));
    }


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

      for (JHashMap<int, JString>::const_iterator i = model.string.begin(); i != model.string.end(); ++i) {
        out << "string:  " << setw(4) << i->first << ' ' << i->second << endl;
      }

      for (JHashMap<JEKey, JEmitter>::const_iterator i = model.emitter.begin(); i != model.emitter.end(); ++i) {
        out << "emitter: " << setw(2) << i->first << ' ' << i->second << endl;
      }

      return out;
    }


    /**
     * Get number of fit parameters.
     *
     * \return                          number of parameters
     */
    size_t getN() const
    {
      return getN(string) + getN(emitter);
    }


    /**
     * Get index of fit parameter for given string.
     *
     * \param  id                       string identifier
     * \param  p                        pointer to data member
     * \return                          parameter
     */
    size_t getIndex(int id, double JString::*p) const
    {
      if (string.has(id))
        return string.getIndex(id) * getN<JString>()  +  getIndex(p);
      else
        THROW(JValueOutOfRange, "Invalid identifier " << id);
    }


    /**
     * Get index of fir parameter for given emitter.
     *
     * \param  id                       emitter identifier
     * \param  p                        pointer to data member
     * \return                          parameter
     */
    size_t getIndex(const JEKey& id, double JEmitter::*p) const
    {
      if (emitter.has(id))
        return getN(string)  +  emitter.getIndex(id) * getN<JEmitter>()  +  getIndex(p);
      else
        THROW(JValueOutOfRange, "Invalid identifier " << id);
    }


    /**
     * Read/write access to fit parameter value by index.
     *
     * \param  index                    index
     * \return                          value (zero if absent)
     */
    inline double operator[](const size_t index) const
    {
      size_t i = index;

      if (i < getN(string))  { return getParameter(string,  i); }

      i -= getN(string);

      if (i < getN(emitter)) { return getParameter(emitter, i); }

      THROW(JIndexOutOfRange, "Invalid index " << index << " >= " << getN());
    }


    /**
     * Read/write access to fit parameter value by index.
     *
     * \param  index                    index
     * \return                          value
     */
    inline double& operator[](const size_t index)
    {
      size_t i = index;

      if (i < getN(string))  { return getParameter(string,  i); }

      i -= getN(string);

      if (i < getN(emitter)) { return getParameter(emitter, i); }

      THROW(JIndexOutOfRange, "Invalid index " << index << " >= " << getN());
    }


    /**
     * Map string identifier to model parameters of string.
     */
    struct string_map :
      public JHashMap<int, JString>
    {} string;


    /**
     * Map emitter key to model parameters of emitter.
     */
    struct emitter_map :
      public JHashMap<JEKey, JEmitter>
    {
    private:
      /**
       * Auxiliary class for multiple associative map operators.
       */
      struct JHashMapHelper {
        /**
         * Constructor.
         *
         * \param  map                      map
         * \param  id                       emitter identifier
         */
        JHashMapHelper(JHashMap<JEKey, JEmitter>& map, int id) :
          map(map),
          id (id)
        {}


        /**
         * Get value corresponding to event counter (i.e.\ second part of JEKey).
         *
         * \param  counter                  event counter
         * \return                          emitter
         */
        JEmitter& operator[](const int counter)
        {
          return map[JEKey(id, counter)];
        }

      private:
        JHashMap<JEKey, JEmitter>& map;
        int id;
      };

    public:

      using JHashMap<JEKey, JEmitter>::operator[];


      /**
       * Get helper corresponding to emitter identifier (i.e.\ first part of JEKey).
       *
       * \param  id                       emitter identifier
       * \return                          helper
       */
      JHashMapHelper operator[](int id) 
      {
        return JHashMapHelper(*this, id);
      }

    } emitter;


  private:
    /**
     * Get number of fit parameters corresponding to given data structure.
     *
     * \return                          number of parameters
     */
    template<class T>
    static size_t getN()
    { 
      return sizeof(T) / sizeof(double);
    }


    /**
     * Get number of fit parameters corresponding to given buffer.
     *
     * \param  buffer                   buffer
     * \return                          number of parameters
     */
    template<class JKey_t, class JValue_t, class JEvaluator_t>
    static size_t getN(const JHashMap<JKey_t, JValue_t, JEvaluator_t>& buffer)
    {
      return buffer.size() * getN<JValue_t>();
    }


    /**
     * Get index of fit parameter in given data structure.
     *
     * \param  p                        pointer to data member
     * \return                          index
     */
    template<class T>
    static inline size_t getIndex(double T::*p) 
    {
      T* __p__ = NULL;

      return ((double*) &(__p__->*p) - (double*) __p__);
    }


    /**
     * Get fit parameter value at given index in buffer.
     *
     * \param  buffer                   buffer
     * \param  index                    index
     * \return                          value
     */
    template<class JKey_t, class JValue_t, class JEvaluator_t>
    static double getParameter(const JHashMap<JKey_t, JValue_t, JEvaluator_t>& buffer, const size_t index)
    {
      const size_t pos       = index / getN<JValue_t>();         // position of element in buffer
      const size_t offset    = index % getN<JValue_t>();         // offset of parameter in element

      const JValue_t& value  = buffer.data()[pos].second;        // value of element at given position

      return ((const double*) &value)[offset];                   // parameter at given offset
    }


    /**
     * Get fit parameter value at given index in buffer.
     *
     * \param  buffer                   buffer
     * \param  index                    index
     * \return                          value
     */
    template<class JKey_t, class JValue_t, class JEvaluator_t>
    static double& getParameter(JHashMap<JKey_t, JValue_t, JEvaluator_t>& buffer, const size_t index)
    {
      const size_t pos       = index / getN<JValue_t>();         // position of element in buffer
      const size_t offset    = index % getN<JValue_t>();         // offset of parameter in element

      JValue_t&    value     = buffer.data()[pos].second;        // value of element at given position

      return ((double*) &value)[offset];                         // parameter at given offset
    }
  };
}

#endif