Waves.hpp

Go to the documentation of this file.

/*
 * Copyright (c) 2022, Matt Hall
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 * 1. Redistributions of source code must retain the above copyright notice,
 * this list of conditions and the following disclaimer.
 *
 * 2. Redistributions in binary form must reproduce the above copyright notice,
 *    this list of conditions and the following disclaimer in the documentation
 *    and/or other materials provided with the distribution.
 *
 * 3. Neither the name of the copyright holder nor the names of its
 *    contributors may be used to endorse or promote products derived from
 *    this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#pragma once
 
#include "Misc.hpp"
#include "Log.hpp"
#include "Line.hpp"
#include "Point.hpp"
#include "Body.hpp"
#include "Rod.hpp"
#include "Waves/SpectrumKin.hpp"
#include <vector>
 
namespace moordyn {
 
namespace time {
class Scheme;
}
 
class Seafloor;
typedef std::shared_ptr<Seafloor> SeafloorRef;
 
template<class T>
using Vec2D = std::vector<std::vector<T>>;
 
template<class T>
using Vec3D = std::vector<std::vector<std::vector<T>>>;
 
template<class T>
using Vec4D = std::vector<std::vector<std::vector<std::vector<T>>>>;
 
static inline Vec2D<real>
init2DArray(unsigned int nx, unsigned int ny)
{
    return Vec2D<real>(nx, std::vector<real>(ny, 0.0));
}
 
static inline Vec3D<real>
init3DArray(unsigned int nx, unsigned int ny, unsigned int nz)
{
    return Vec3D<real>(nx, init2DArray(ny, nz));
}
 
static inline Vec4D<vec3>
init4DArrayVec(unsigned int nx,
               unsigned int ny,
               unsigned int nz,
               unsigned int nw)
{
    return Vec4D<vec3>(
        nx,
        Vec3D<vec3>(ny, Vec2D<vec3>(nz, std::vector<vec3>(nw, vec3::Zero()))));
}
static inline Vec4D<real>
init4DArray(unsigned int nx, unsigned int ny, unsigned int nz, unsigned int nw)
{
    return Vec4D<real>(nx, init3DArray(ny, nz, nw));
}
 
struct SeafloorProvider
{
    real waterDepth;
    SeafloorRef seafloor{};
    real getAverageDepth() const;
    real getDepth(const vec2& pos) const;
};
 
class AbstractCurrentKin
{
  public:
    virtual ~AbstractCurrentKin() {};
    virtual void getCurrentKin(const vec3& pos,
                               real time,
                               const SeafloorProvider& seafloor,
                               vec3* vel,
                               vec3* acc) = 0;
};
 
class AbstractWaveKin
{
  public:
    virtual ~AbstractWaveKin() {};
    virtual void getWaveKin(const vec3& pos,
                            real time,
                            const SeafloorProvider& seafloor,
                            real* zeta,
                            vec3* vel,
                            vec3* acc,
                            real* pdyn) = 0;
};
 
class SpectrumKinWrapper : public AbstractWaveKin
{
    waves::SpectrumKin spectrumKin;
 
  public:
    SpectrumKinWrapper(waves::SpectrumKin&& spectrum)
      : spectrumKin(spectrum)
    {
    }
 
    ~SpectrumKinWrapper() override = default;
 
    void getWaveKin(const vec3& pos,
                    real time,
                    const SeafloorProvider& seafloor,
                    real* zeta,
                    vec3* vel,
                    vec3* acc,
                    real* pdyn) override
    {
        if (pdyn) {
            *pdyn = 0.0;
        }
 
        real avgDepth = seafloor.getAverageDepth();
        real actualDepth = seafloor.getDepth(pos.head<2>());
        spectrumKin.getWaveKin(
            pos, time, avgDepth, actualDepth, zeta, vel, acc);
    }
};
class GridXYZT
{
  public:
    GridXYZT(const std::vector<real>& px,
             const std::vector<real>& py,
             const std::vector<real>& pz,
             unsigned int nt,
             real dt)
      : nx(static_cast<unsigned int>(px.size()))
      , ny(static_cast<unsigned int>(py.size()))
      , nz(static_cast<unsigned int>(pz.size()))
      , nt(nt)
      , dtWave(dt)
      , px(px)
      , py(py)
      , pz(pz)
    {
    }
    unsigned int nx;
    unsigned int ny;
    unsigned int nz;
    unsigned int nt = 0;
    real dtWave;
 
  protected:
    std::vector<real> px;
    std::vector<real> py;
    std::vector<real> pz;
};
 
class WaveGrid
  : public AbstractWaveKin
  , public GridXYZT
  , LogUser
{
  public:
    WaveGrid(moordyn::Log* log,
             const std::vector<real>& px,
             const std::vector<real>& py,
             const std::vector<real>& pz,
             unsigned int nt,
             real dt)
      : GridXYZT(px, py, pz, nt, dt)
      , LogUser(log)
    {
    }
    ~WaveGrid() override = default;
 
    void allocateKinematicArrays();
 
    void getWaveKin(const vec3& pos,
                    real time,
                    const SeafloorProvider& seafloor,
                    real* zeta,
                    vec3* vel,
                    vec3* acc,
                    real* pdyn) override;
 
    inline Vec3D<real>& Zetas() { return zetas; }
    inline const Vec3D<real>& getZetas() const { return zetas; }
 
    inline Vec4D<real>& PDyn() { return pDyn; }
    inline const Vec4D<real>& getPDyn() const { return pDyn; }
 
    inline Vec4D<vec3>& WaveVel() { return wave_vel; }
    inline const Vec4D<vec3>& getWaveVel() const { return wave_vel; }
 
    inline Vec4D<vec3>& WaveAcc() { return wave_acc; }
    inline const Vec4D<vec3>& getWaveAcc() const { return wave_acc; }
 
    inline const std::vector<real>& Px() const { return px; }
    inline const std::vector<real>& Py() const { return py; }
    inline const std::vector<real>& Pz() const { return pz; }
 
  private:
    Vec3D<real> zetas;
    Vec4D<real> pDyn;
    Vec4D<vec3> wave_vel;
    Vec4D<vec3> wave_acc;
};
 
class CurrentGrid
  : public AbstractCurrentKin
  , public GridXYZT
  , LogUser
{
  public:
    CurrentGrid(moordyn::Log* log,
                const std::vector<real>& px,
                const std::vector<real>& py,
                const std::vector<real>& pz,
                unsigned int nt,
                real dt)
      : GridXYZT(px, py, pz, nt, dt)
      , LogUser(log)
    {
    }
 
    ~CurrentGrid() override = default;
 
    void allocateKinematicArrays();
 
    void getCurrentKin(const vec3& pos,
                       real time,
                       const SeafloorProvider& seafloor,
                       vec3* vel,
                       vec3* acc) override;
 
    inline Vec4D<vec3>& CurrentVel() { return current_vel; }
    inline const Vec4D<vec3>& getCurrentVel() const { return current_vel; }
 
    inline Vec4D<vec3>& CurrentAcc() { return current_acc; }
    inline const Vec4D<vec3>& getCurrentAcc() const { return current_acc; }
 
    inline const std::vector<real>& Px() const { return px; }
    inline const std::vector<real>& Py() const { return py; }
    inline const std::vector<real>& Pz() const { return pz; }
 
  private:
    Vec4D<vec3> current_vel;
    Vec4D<vec3> current_acc;
};
 
class Waves : public LogUser
{
  public:
    Waves(moordyn::Log* log);
    ~Waves();
 
    std::vector<vec3> getWaveKinematicsPoints();
 
    void setWaveKinematics(std::vector<vec> const& U,
                           std::vector<vec> const& Ud);
 
    void updateWaves();
 
    void addLine(moordyn::Line* line);
 
    void addRod(moordyn::Rod* rod);
 
    void addBody(moordyn::Body* body);
 
    void addPoint(moordyn::Point* point);
 
    using NodeKinReturnType = std::tuple<const std::vector<real>&,
                                         const std::vector<vec3>&,
                                         const std::vector<vec3>&,
                                         const std::vector<real>&>;
    NodeKinReturnType getWaveKinLine(size_t lineId);
 
    NodeKinReturnType getWaveKinRod(size_t rodId);
 
    NodeKinReturnType getWaveKinBody(size_t bodyId);
 
    NodeKinReturnType getWaveKinPoint(size_t pointId);
 
    real getWaveHeightPoint(vec2 point);
 
    void getWaveKin(const vec3& pos,
                    real& zeta,
                    vec3& vel,
                    vec3& acc,
                    real& pdyn,
                    Seafloor* seafloor = nullptr);
 
  private:
    template<class C>
    struct NodeKinematics
    {
        std::vector<const C*> structures;
        std::vector<std::vector<real>> zetas;
        std::vector<std::vector<vec3>> U;
        std::vector<std::vector<vec3>> Ud;
        std::vector<std::vector<real>> Pdyn;
 
        NodeKinReturnType operator[](size_t idx)
        {
 
            return { zetas[idx], U[idx], Ud[idx], Pdyn[idx] };
        }
    };
 
    struct AllNodesKin
    {
        NodeKinematics<moordyn::Line> lines;
        NodeKinematics<moordyn::Body> bodies;
        NodeKinematics<moordyn::Rod> rods;
        NodeKinematics<moordyn::Point> points;
    };
 
    AllNodesKin nodeKin;
    AllNodesKin waveKin;
    template<class C>
    void genericAdd(const C* const structure,
                    unsigned int num_nodes,
                    NodeKinematics<C>& nodeKinematics)
    {
        nodeKinematics.structures.push_back(structure);
        nodeKinematics.zetas.emplace_back(num_nodes, 0.0);
        nodeKinematics.U.emplace_back(num_nodes, vec3::Zero());
        nodeKinematics.Ud.emplace_back(num_nodes, vec3::Zero());
        nodeKinematics.Pdyn.emplace_back(num_nodes, 0.0);
    }
 
    template<typename F>
    void kinematicsForAllNodes(AllNodesKin& nodeKinematics, F f);
 
    std::unique_ptr<AbstractWaveKin> waveKinematics{};
    std::unique_ptr<AbstractCurrentKin> currentKinematics{};
 
    std::unique_ptr<WaveGrid> waveGrid{};
 
    EnvCondRef env{};
    // Keep a reference to any potential 3d seafloor
    SeafloorRef seafloor{};
    real g;
    real rho_w;
 
    moordyn::time::Scheme* _t_integrator;
 
    // ------------ from Line object... -----------
    // new additions for handling waves in-object and precalculating them   (not
    // necessarily used right now)
    //  int WaveMod;
    //  int WaveStMod;
    //  double Hs;
    //  double Tp;
    //  double gamma;
    //  float beta;             // wave heading
    //
    //  vector< double > Ucurrent; // constant uniform current to add (three
    // components)
 
  public:
    typedef enum
    {
        GRID_SINGLE = 0,
        GRID_LIST = 1,
        GRID_LATTICE = 2,
    } coordtypes;
 
    void setup(EnvCondRef env,
               SeafloorRef seafloor,
               time::Scheme* t,
               const char* folder = "Mooring/");
};
 
// other relevant functions being thrown into this file for now (should move to
// Misc?) <<<<
 
std::vector<real>
gridAxisCoords(Waves::coordtypes coordtype, vector<string>& entries);
 
typedef std::shared_ptr<Waves> WavesRef;
} // ::moordyn