Rod.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 <vector>
#include <utility>
 
using namespace std;
 
namespace moordyn {
 
class Waves;
typedef std::shared_ptr<Waves> WavesRef;
class Line;
 
class DECLDIR Rod final
  : public Instance
  , public SuperCFL
{
  public:
    Rod(moordyn::Log* log, size_t rodId);
 
    ~Rod();
 
  private:
    // ENVIRONMENTAL STUFF
    EnvCondRef env;
    moordyn::WavesRef waves;
    moordyn::SeafloorRef seafloor;
 
    typedef struct _attachment
    {
        Line* line;
        EndPoints end_point;
    } attachment;
 
    std::vector<attachment> attachedA;
 
    std::vector<attachment> attachedB;
 
    // ROD STUFF
 
    // parameters
    unsigned int N;
    moordyn::real UnstrLen;
    vec q0;
    moordyn::real d;
    moordyn::real rho;
    moordyn::real Can;
    moordyn::real Cat;
    moordyn::real Cdn;
    moordyn::real Cdt;
    // values from input files
    moordyn::real CdEnd;
    // values from input files
    moordyn::real CaEnd;
 
    // vec6 r6;
    XYZQuat r7;
    vec6 v6;
    XYZQuat vel7;
    vec6 acc6;
 
    // kinematics
    std::vector<vec> r;
    std::vector<vec> rd;
    vec q;
    std::vector<moordyn::real> l;
 
    std::vector<mat> M;
    // line segment volumes
    std::vector<moordyn::real> V;
 
    vec FextA;
    vec FextB;
    vec Mext;
    vec6 F6net;
    mat6 M6net;
 
    // forces
    std::vector<vec> W;
    std::vector<vec> Bo;
    std::vector<vec> Pd;
    std::vector<vec> Dp;
    std::vector<vec> Dq;
    std::vector<vec> Ap;
    std::vector<vec> Aq;
    std::vector<vec> B;
    std::vector<vec> Fnet;
 
    // wave things
    std::vector<moordyn::real> VOF; // TODO: This doesn't need to be a vector,
                                    // can be a double reused for each node
    real h0;
 
    // time
    moordyn::real t;
 
    vec6 r_ves;
    vec6 rd_ves;
    vec6 rdd_ves;
 
    // file stuff
    ofstream* outfile;
    string channels;
    int openedoutfile;
 
    inline real getWaterDepth(real x, real y)
    {
        return seafloor ? seafloor->getDepthAt(x, y) : -env->WtrDpth;
    }
 
  public:
    typedef enum
    {
        COUPLED = -2,
        CPLDPIN = -1,
        FREE = 0,
        PINNED = 1,
        FIXED = 2,
        // Some aliases
        VESSEL = COUPLED,
        VESPIN = CPLDPIN,
        POINT = FREE,
        ANCHOR = FIXED,
    } types;
 
    static string TypeName(types t)
    {
        switch (t) {
            case COUPLED:
                return "COUPLED";
            case CPLDPIN:
                return "CPLDPIN";
            case FREE:
                return "FREE";
            case PINNED:
                return "PINNED";
            case FIXED:
                return "FIXED";
        }
        return "UNKNOWN";
    }
 
    size_t rodId;
    int number;
    types type;
 
    real roll;
    real pitch;
 
    void setup(int number,
               types type,
               RodProps* props,
               vec6 endCoords,
               unsigned int n,
               EnvCondRef env_in,
               shared_ptr<ofstream> outfile,
               string channels);
 
    void addLine(Line* line, EndPoints line_end_point, EndPoints rod_end_point);
 
    EndPoints removeLine(EndPoints end_point, Line* line);
 
    inline void setWaves(moordyn::WavesRef waves_in,
                         moordyn::SeafloorRef seafloor_in)
    {
        waves = waves_in;
        seafloor = seafloor_in;
    }
 
    inline void openoutput();
 
    std::pair<XYZQuat, vec6> initialize();
 
    inline void initialize(InstanceStateVarView r)
    {
        const auto [pos, vel] = initialize();
        r.row(0).head<7>() = pos.toVec7();
        r.row(0).tail<6>() = vel;
    }
    inline unsigned int getN() const { return N; }
 
    inline vec getNodePos(unsigned int i) const
    {
        if (i > N) {
            LOGERR << "Asking node " << i << " of rod " << number
                   << ", which only has " << N + 1 << " nodes" << std::endl;
            throw moordyn::invalid_value_error("Invalid node index");
        }
        if (isnan(r[i].sum())) {
            stringstream s;
            s << "NaN detected" << endl
              << "Rod " << number << " node positions:" << endl;
            for (unsigned int j = 0; j <= N; j++)
                s << j << " : " << r[j] << ";" << endl;
            throw moordyn::nan_error(s.str().c_str());
        }
        return r[i];
    }
 
    inline vec getNodeVel(unsigned int i) const
    {
        if (i > N) {
            LOGERR << "Asking node " << i << " of rod " << number
                   << ", which only has " << N + 1 << " nodes" << std::endl;
            throw moordyn::invalid_value_error("Invalid node index");
        }
        return rd[i];
    }
 
    real GetRodOutput(OutChanProps outChan);
 
    inline std::pair<real, real> getDrag() const { return make_pair(Cdn, Cdt); }
 
    inline void setDrag(real cdn, real cdt)
    {
        Cdn = cdn;
        Cdt = cdt;
    }
 
    inline void scaleDrag(real scaler)
    {
        Cdn = Cdn * scaler;
        Cdt = Cdt * scaler;
        CdEnd = CdEnd * scaler;
    }
 
    inline void setTime(real time) { t = time; }
 
    inline void getState(XYZQuat& pos, vec6& vel) const
    {
        pos = r7;
        vel = v6;
    }
 
    inline std::pair<XYZQuat, vec6> getState() const
    {
        return std::make_pair(r7, v6);
    }
 
    void setState(const InstanceStateVarView r);
 
    void initiateStep(vec6 r, vec6 rd, vec6 rdd);
 
    inline vec6 getUnfreeVel() const { return rd_ves; }
 
    void updateFairlead(real time);
 
    void setKinematics(vec6 r, vec6 rd);
 
    void setDependentStates();
 
    void getStateDeriv(InstanceStateVarView drdt);
 
    const vec6 getFnet() const;
 
    inline const mat6 getM() const { return M6net; }
 
    void getNetForceAndMass(vec6& Fnet_out, mat6& M_out, vec rBody, vec6 vBody);
 
    inline void getNetForceAndMass(vec6& Fnet_out, mat6& M_out)
    {
        getNetForceAndMass(Fnet_out, M_out, r[0], vec6::Zero());
    }
 
    void doRHS();
 
    void Output(real);
 
    inline const size_t stateN() const { return 1; }
 
    inline const size_t stateDims() const { return 13; }
 
    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
    {
        if (!N)
            return vec::Zero();
 
        vec F = vec::Zero();
        for (unsigned int i = 0; i <= N; i++) {
            F -= M[i] * (w.cross(w.cross(this->r[i] - r)));
        }
        return F;
    }
};
 
} // ::moordyn