MooringSystemCoribo3.h

#pragma once
 
#include <string>
#include <algorithm>
#include <iterator>
 
#include "MooringSystemCoribo2.h"
 
#include "./RingStructureGravityHydro.h"
#include "./Cable/LineStructureGravityHydro.h"
#include "./Cable/BridleCable.h"
#include "./Cable/FrameCable.h"
 
namespace Netcage {
    class MooringSystemCoRiBo3 : public MooringSystemCoRiBo2 {
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
        MooringSystemCoRiBo3(const std::string& name, ISimObjectCreator* const creator);
        ~MooringSystemCoRiBo3();
 
        virtual void OdeFcn(const double T, const double *const X, double *const XDot, const bool IsMajorTimeStep);
        virtual void InitialConditionSetup(const double, const double *const, double* const updatedIC, ISimObjectCreator* const);
        virtual void FinalSetup(const double T, const double *const X, ISimObjectCreator* const creator);
 
        virtual void compute(const double T, const double * const X);
 
#ifdef FH_VISUALIZATION
        virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
        virtual void RenderUpdate(const double T, const double* const X);
#endif
 
        virtual void PreOdeFcn(const double T, const double *const X, IStateUpdater* updater);
        const double *forceFloater(const double T, const double * const X, int index);
    protected:
 
        struct CellExternalBridle {
            CellExternalBridle(short _u, short _v) {
                u = _u;
                v = _v;
                for (int i = 0; i < 12; i++) {
                    bridle[i] = nullptr;
                    floaterPos[i] = nullptr;
                    floaterVel[i] = nullptr;
                    bridleconstraint[i] = -1;
                    bufferQ[i][0] = 1;
                    for (int j = 0; j < 3; j++) {
                        bufferP[i][j] = std::numeric_limits<double>::quiet_NaN();
                        bufferV[i][j] = 0;
                        bufferO[i][j] = 0;
                        bufferF[i][j] = 0;
                        bufferQ[i][j+1] = 0;
                    }
                }
            }
 
            void UpdateBuffersFromPorts(const double T, const double * const X) {
                for (int i = 0; i < 12; i++) {
                    if ( bridle[i] == nullptr) continue;
                    auto pos = floaterPos[i]->GetPortValue(T, X);
                    auto vel = floaterVel[i]->GetPortValue(T, X);
                    for (int j = 0; j < 3; j++) {
                        bufferP[i][j] = pos[j];
                        bufferV[i][j] = vel[j];
                    }
                }
            }
 
            unsigned short u, v;
            BridleCable*    bridle[12];
            ISignalPort*    floaterPos[12];
            ISignalPort*    floaterVel[12];
            double          bufferP[12][3];
            double          bufferV[12][3];
            double          bufferO[12][3];
            double          bufferQ[12][4];
            double          bufferF[12][3];
            int             bridleconstraint[12];
        };
        virtual void CreateCells(ISimObjectCreator* creator);
        std::vector<CellExternalBridle*> m_cell;
 
        ICommonComputation* m_compute3;
 
    };
}