Body.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 "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 Point;
class Rod;
 
class DECLDIR Body final
  : public Instance
  , public SuperCFL
{
  public:
    Body(moordyn::Log* log, size_t id);
 
    ~Body();
 
    // ENVIRONMENTAL STUFF
    EnvCondRef env;
    WavesRef waves;
 
    // unique to Body:
    std::vector<moordyn::Point*> attachedP;
    std::vector<Rod*> attachedR;
 
    std::vector<vec> rPointRel;
    std::vector<vec6> r6RodRel;
 
    // Constants set at startup from input file
 
    vec6 body_r6;
    vec body_rCG;
    real bodyM;
    real bodyV;
    vec bodyI;
    vec6 bodyCdA;
    vec6 bodyCa;
 
    // degrees of freedom (or states)
    XYZQuat r7;
    // vec6 r6;
    vec6 v6;
    vec6 a6;
 
    vec6 r_ves;
    vec6 rd_ves;
    vec6 rdd_ves;
 
    vec6 F6net;
 
    mat6 M;
    mat6 M0;
 
    mat OrMat;
 
    ofstream* outfile;
 
    typedef enum
    {
        COUPLED = -1,
        FREE = 0,
        FIXED = 1,
        CPLDPIN = 2,
        // Some aliases
        VESSEL = COUPLED,
        ANCHOR = FIXED,
    } types;
 
    static string TypeName(types t)
    {
        switch (t) {
            case COUPLED:
                return "COUPLED";
            case CPLDPIN:
                return "CPLDPIN";
            case FREE:
                return "FREE";
            case FIXED:
                return "FIXED";
        }
        return "UNKNOWN";
    }
 
    size_t bodyId;
    int number;
    types type;
 
    void setup(int number,
               types type,
               vec6 r6,
               vec rCG,
               real M,
               real V,
               vec I,
               vec6 CdA,
               vec6 Ca,
               EnvCondRef env_in,
               shared_ptr<ofstream> outfile);
 
    void addPoint(moordyn::Point* point, vec coords);
 
    void addRod(Rod* rod, vec6 coords);
 
    void initializeUnfreeBody(vec6 r = vec6::Zero(),
                              vec6 rd = vec6::Zero(),
                              vec6 rdd = vec6::Zero());
 
    inline vec6 getUnfreeVel() const { return rd_ves; }
 
    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;
    }
    void initializeBody(XYZQuat r = XYZQuat::Zero(), vec6 rd = vec6::Zero());
 
    inline void setWaves(moordyn::WavesRef waves_in) { waves = waves_in; }
 
    void setDependentStates();
 
    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);
    }
 
    inline const vec getPosition() const { return r7.pos; }
 
    inline const vec getAngles() const { return Quat2Euler(r7.quat); }
    // inline vec getAngles() const { return r6(Eigen::seqN(3, 3)); }
 
    inline const vec getVelocity() const { return v6(Eigen::seqN(0, 3)); }
 
    inline const vec getAngularVelocity() const
    {
        return v6(Eigen::seqN(3, 3));
    }
 
    const vec6 getFnet() const;
 
    inline const mat6& getM() const { return M; };
 
    real GetBodyOutput(OutChanProps outChan);
 
    inline void scaleDrag(real scaler) { bodyCdA *= scaler; }
 
    void initiateStep(vec6 r, vec6 rd, vec6 rdd);
 
    void updateFairlead(real time);
 
    void setState(const InstanceStateVarView r);
 
    void getStateDeriv(InstanceStateVarView drdt);
 
    void doRHS();
 
    void Output(real time);
 
    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;
 
    void defaultVTK();
};
 
} // ::moordyn