JGeometry.hh

Go to the documentation of this file.

#ifndef __JACOUSTICS__JGEOMETRY__
#define __JACOUSTICS__JGEOMETRY__

#include <ostream>
#include <iomanip>

#include "JLang/JException.hh"
#include "JGeometry3D/JPosition3D.hh"
#include "JTools/JHashMap.hh"
#include "Jeep/JPrint.hh"

#include "JAcoustics/JAcousticsSupportkit.hh"
#include "JAcoustics/JModel.hh"


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

namespace JACOUSTICS {

  using JLANG::JValueOutOfRange;
  using JGEOMETRY3D::JVector3D;
  using JGEOMETRY3D::JPosition3D;
  using JTOOLS::JHashMap;


  /**
   * Auxiliary data structure to encapsulate different geometries.\n
   * This data structure provides for the implementation of the model dependent geometry of a detector string.
   */
  struct JGeometry {

    /**
     * Floor geometry.
     */
    struct JFloor {
      /**
       * Default constructor.
       */
      JFloor() :
        height(0.0)
      {}


      /**
       * Constructor.\n
       * The height refers to the maximal distance from
       * the fixed reference point of the parent string.
       *
       * \param  height                   height
       */
      JFloor(const double height) :
        height(height)
      {}


      /**
       * Get height of this floor.\n
       * The height refers to the maximal distance from
       * the fixed reference point of the parent string.
       *
       * \return                          height
       */
      double getHeight() const
      {
        return height;
      }


      /**
       * Write floor parameters to output stream.
       *
       * \param  out                      output stream
       * \param  floor                    floor
       * \return                          output stream
       */
      friend inline std::ostream& operator<<(std::ostream& out, const JFloor& floor)
      {
        return out << FIXED(7,2) << floor.getHeight();
      }


    protected:
      double height;
    };


    /**
     * String geometry.
     *
     * A piezo sensor is mounted in each optical module.\n 
     * The position of the piezo is determined from the actual string parameters and the floor number of the optical module.\n
     * A hydrophone is mounted on the anchor which corresponds to floor zero.\n
     * It has a fixed position which is relative to the reference position of the string.
     */
    struct JString :
      public JPosition3D,
      public JHashMap<int, JFloor>
    {
      using JPosition3D::getPosition;
      using JPosition3D::getDistance;

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


      /**
       * Constructor.
       *
       * The given position corresponds to the reference point of the string from
       * which the positions of the piezo sensors and hydrophone are calculated.
       *
       * \param  position                 position
       */
      JString(const JVector3D& position) :
        JPosition3D(position)
      {}


      /**
       * Constructor.
       *
       * The template parameter should correspond to a data type which implements the following policy methods.
       * <pre>
       *     int          getFloor();
       *     JPosition3D  getPosition();
       * </pre>
       *
       * The given position corresponds to the reference point of the string from
       * which the positions of the piezo sensors and hydrophone are calculated.
       *
       * Note that the position of the piezo is offset by JACOUSTICS::getPiezoPosition and
       * that the position of the hydrophone should manually be set.
       *
       * \param  position                 position
       * \param  __begin                  begin of optical modules
       * \param  __end                    end   of optical modules
       */
      template<class T>
      JString(const JVector3D& position,
              T __begin, 
              T __end) :
        JPosition3D(position)
      {
        for (T i = __begin; i != __end; ++i) {
          (*this)[i->getFloor()] = this->getDistance(i->getPosition() + getPiezoPosition());
        }
      }


      /**
       * Get position at given height according to actual string parameters.
       *
       * \param  parameters               parameters
       * \param  height                   height
       * \return                          position
       */
      JPosition3D getPosition(const JModel::JString& parameters,
                              const double           height) const
      {
        const double tx = parameters.tx;
        const double ty = parameters.ty;
        const double tz = sqrt(1.0 - tx*tx - ty*ty);

        return JPosition3D(this->getX()  +  tx * height,
                           this->getY()  +  ty * height,
                           this->getZ()  +  tz * height);
      }


      /**
       * Get position of given floor according to actual string parameters.
       *
       * \param  parameters               parameters
       * \param  floor                    floor
       * \return                          position
       */
      JPosition3D getPosition(const JModel::JString& parameters,
                              const int              floor) const
      {
        if (floor == 0)
          return getPosition() + hydrophone.getPosition();
        else if (this->has(floor))
          return getPosition(parameters, this->get(floor).getHeight());
        else
          THROW(JValueOutOfRange, "Invalid floor " << floor);
      }


      /**
       * Get position at given height according to default string parameters.
       *
       * \param  height                   height
       * \return                          position
       */
      JPosition3D getPosition(const double height) const
      {
        return getPosition(JModel::JString(), height);
      }


      /**
       * Get position of given floor according to default string parameters.
       *
       * \param  floor                    floor
       * \return                          position
       */
      JPosition3D getPosition(const int floor) const
      {
        return getPosition(JModel::JString(), floor);
      }


      /**
       * Get distance between given position and floor according to actual string parameters.
       *
       * \param  parameters               parameters
       * \param  position                 position
       * \param  floor                    floor
       * \return                          distance
       */
      double getDistance(const JModel::JString& parameters,
                         const JVector3D&       position,
                         const int              floor) const
      {
        return this->getPosition(parameters, floor).getDistance(position);
      }


      /**
       * Get model gradient of distance between given position and floor according to actual string parameters.
       *
       * \param  parameters               parameters
       * \param  position                 position
       * \param  floor                    floor
       * \return                          gradient
       */
      JModel::JString getGradient(const JModel::JString& parameters,
                                  const JVector3D&       position,
                                  const int              floor) const
      {
        if (floor == 0) {

          return JModel::JString();

        } else if (this->has(floor)) {

          const double      height = this->get(floor).getHeight();
          const JPosition3D pos    = this->getPosition(parameters, height);

          const double tx = parameters.tx;
          const double ty = parameters.ty;
          const double tz = sqrt(1.0 - tx*tx - ty*ty);

          const double dx = pos.getX() - position.getX();
          const double dy = pos.getY() - position.getY();
          const double dz = pos.getZ() - position.getZ();

          const double D  = sqrt(dx*dx + dy*dy + dz*dz);

          return JModel::JString(height * dx / D  -  (tx / tz) * dz / D,
                                 height * dy / D  -  (ty / tz) * dz / D);

        } else {

          THROW(JValueOutOfRange, "Invalid floor " << floor);
        }       
      }


      /**
       * 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;

        for (JString::const_iterator i = string.begin(); i != string.end(); ++i) {
          out << setw(2) << i->first << ' ' << i->second << " | " << string.getPosition(i->first) << endl;
        }

        return out;
      }


      /**
       * Hydrophone.
       *
       * The position of the hydrophone is relative to the reference position of the string.
       */
      JPosition3D hydrophone;
    };


    /**
     * Detector geometry.
     */
    struct JDetector :
      public JHashMap<int, JString>
    {
      /**
       * Default constructor.
       */
      JDetector()
      {}


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

        for (JDetector::const_iterator i = detector.begin(); i != detector.end(); ++i) {
          out << setw(4) << i->first << endl << i->second;
        }

        return out;
      }
    };
  };
}

#endif