Point.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 "Instance.hpp"
#include "Seafloor.hpp"
#include "Util/CFL.hpp"
#include "leanvtk/leanvtk.hpp"
#include <utility>
 
using namespace std;
 
namespace moordyn {
 
class Line;
class Waves;
typedef std::shared_ptr<Waves> WavesRef;
 
class DECLDIR Point final
  : public Instance
  , public SuperCFL
{
  public:
    Point(moordyn::Log* log, size_t id);
 
    ~Point();
 
    typedef struct _attachment
    {
        Line* line;
        EndPoints end_point;
    } attachment;
 
  private:
    // ENVIRONMENTAL STUFF
    EnvCondRef env;
    moordyn::WavesRef waves;
    moordyn::SeafloorRef seafloor;
 
    std::vector<attachment> attached;
 
    real pointM;
    real pointV;
    vec pointF;
    real pointCdA;
    real pointCa;
 
    vec r;
    vec rd;
 
    vec r_ves;
    vec rd_ves;
 
    vec Fnet;
 
    // time
    moordyn::real t;
 
    mat M;
 
    vec acc;
 
  public:
    typedef enum
    {
        COUPLED = -1,
        FREE = 0,
        FIXED = 1,
        // Some aliases
        VESSEL = COUPLED,
        FAIRLEAD = COUPLED,
        POINT = FREE,
        ANCHOR = FIXED,
    } types;
 
    static string TypeName(types t)
    {
        switch (t) {
            case COUPLED:
                return "COUPLED";
            case FREE:
                return "FREE";
            case FIXED:
                return "FIXED";
        }
        return "UNKNOWN";
    }
 
    size_t pointId;
 
    int number;
    types type;
 
    inline void setTime(real time) { t = time; }
 
    void setup(int number_in,
               types type_in,
               vec r0_in,
               double M_in,
               double V_in,
               vec F_in,
               double CdA_in,
               double Ca_in,
               EnvCondRef env_in);
 
    void addLine(moordyn::Line* theLine, EndPoints end_point);
 
    EndPoints removeLine(Line* line);
 
    inline std::vector<attachment> getLines() const { return attached; }
 
    std::pair<vec, vec> initialize();
 
    inline void initialize(InstanceStateVarView r)
    {
        const auto [pos, vel] = initialize();
        r.row(0).head<3>() = pos;
        r.row(0).tail<3>() = vel;
    }
    inline const vec& getPosition() const { return r; }
 
    inline const vec& getVelocity() const { return rd; }
 
    inline void getState(vec& r_out, vec& rd_out)
    {
        r_out = r;
        rd_out = rd;
    };
 
    inline std::pair<vec, vec> getState() { return std::make_pair(r, rd); }
 
    inline void getFnet(vec& Fnet_out) const { Fnet_out = Fnet; }
 
    inline const vec& getFnet() const { return Fnet; }
 
    inline void getM(mat& M_out) const { M_out = M; }
 
    inline const mat& getM() const { return M; };
 
    real GetPointOutput(OutChanProps outChan);
 
    inline void setWaves(moordyn::WavesRef waves_in,
                         moordyn::SeafloorRef seafloor_in)
    {
        waves = waves_in; // set pointer to Waves  object
        seafloor = seafloor_in;
    }
 
    inline void scaleDrag(real scaler) { pointCdA *= scaler; }
 
    void initiateStep(vec rFairIn, vec rdFairIn);
 
    void updateFairlead(real time);
 
    void setKinematics(vec r_in, vec rd_in);
 
    void setState(vec pos, vec vel);
 
    inline void setState(const InstanceStateVarView r)
    {
        setState(r.row(0).head<3>(),
                 r.row(0).tail<3>()); // TODO: when working on line failures,
                                      // make this setState call match rods,
                                      // bodies, and lines structure
    }
 
    void getStateDeriv(InstanceStateVarView drdt);
 
    void getNetForceAndMass(vec6& Fnet_out,
                            mat6& M_out,
                            vec rBody = vec::Zero(),
                            vec6 vBody = vec6::Zero());
 
    moordyn::error_id doRHS();
 
    inline const size_t stateN() const { return 1; }
 
    inline const size_t stateDims() const { return 6; }
 
    std::vector<uint64_t> Serialize(void);
 
    uint64_t* Deserialize(const uint64_t* data);
 
    void saveVTK(const char* filename);
 
    const leanvtk::VTPWriter* getVTK() const { return &vtk; }
 
  private:
    leanvtk::VTPWriter vtk;
 
    inline vec getCentripetalForce(vec r, vec w) const
    {
        return -M * (w.cross(w.cross(this->r - r)));
    }
};
 
} // ::moordyn