ShipSimObject.h

#ifndef _CSHIP_SIM_OBJECT_H_
#define _CSHIP_SIM_OBJECT_H_
 
#include <fhsim/simobject/ISimObjectCreator.h>
#include <fhsim/FhSimMgr.h>
#include <fhsim/PrintDuringExec.h>
#include <string>
#include <queue>
#include <string>
#include <iostream>
#include <locale>
 
#ifdef FH_VISUALIZATION
#pragma warning(push)
#pragma warning( disable : 4251 )
    #include <Ogre.h>
#pragma warning(pop)
    //#include <fhsim/visual/renderer/FhVisualization.h>
    #include "sfh/ogre/C3DArrow.h"
    #include "sfh/ogre/DotSceneLoader.h"
#endif
 
#include <fhsim_environment/EnvironmentProvider.h>
 
#include <sfh/math/interpolation/SplineInterp.h>
 
// TODO: this will not work if someone inherits the simobject externally
#include "Ship/Resistance/ShipResistance.h"
#include "Ship/ViscousShip.h"
#include "Ship/HullData/HullData.h"
#include "Ship/HullData/VeresHullData.h"
#include "Ship/HullData/NapaCGALHullData.h"
#include "Ship/PotentialData/PotentialData.h"
#include "Ship/PotentialData/VeresData.h"
 
namespace Ship{
    class ShipSimObject:public SimObject, public ViscousShip/*, public ICurrentField*/
    {
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW;
 
    #ifdef FH_VISUALIZATION
        enum RenderType
        {
            BOX,
            STATIONS,
            SLICED,
            INTERPOLATED
        };
    #endif
 
        ShipSimObject( const std::string simObjectName, ISimObjectCreator* const creator);
 
        ~ShipSimObject();
 
        void FinalSetup( const double T, const double *const X, ISimObjectCreator* const creator );
 
        void GetCurrent(const double T, const double* const X, const double position[3], double* currentVelocity);
 
        virtual void PreOdeFcn(const double T, const double *const X);
 
        virtual void OdeFcn(const double T, const double* const X, double* const XDot) const;
 
        void AcceptedStep(double T, const double* X) override;
 
    #ifdef FH_VISUALIZATION
 
        virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
 
        virtual void RenderUpdate( const double T, const double* const X );
    #endif
 
 
    public:
 
        const double* PositionNED(const double T, const double* const X);
 
        const double* PositionZeroCrossNED(const double T, const double* const X);
 
        const double* PositionAPNED(const double T, const double* const X);
 
        const double* VelocityNED(const double T, const double* const X);
 
        const double* QuaternionNED(const double T, const double* const X);
 
        const double* EulerAnglesNED(const double T, const double* const X);
 
        const double* RotationBody(const double T, const double* const X);
 
        const double* OmegaNED(const double T, const double* const X);
 
 
        void ComputeRollPitchYaw(const double T, const double* const X) const;
        void ComputeRelativeVelocity(const double T, const double* const X) const;
 
        const double* BodyForce(const double T, const double* const X);
 
        const double* VelocityBody(const double T, const double* const X);
 
        const double* FirstOrderWaveBody(const double T, const double* const X);
 
        const double* WaveDriftBody(const double T, const double* const X);
 
        const double* const FluidMemForceBody(const double T, const double* const X);
 
        const double* RestoringForceBody(const double T, const double* const X);
 
        const double* RelativeVelocityBody(const double T, const double* const X);
 
        const double* ViscousForceBody(const double T, const double* const X);
 
        const double* Encounter(const double T, const double* const X);
 
        const double* CoriolisRigidBody(const double T, const double* const X);
 
        const double* CoriolisFluidBody(const double T, const double* const X);
 
        const double* SpeedInfo( const double T, const double *const X);
 
        const double* RotationForceFrame( const double T, const double *const X);
 
        const double * KineticEnergy(const double T, const double* const X);
 
        const double * FluidEnergy(const double T, const double* const X);
        const double * FluidEnergy2(const double T, const double* const X);
        const double * UFluidMemSpeed(const double T, const double* const X);
 
        const double* FluidForceBySpeedBody(const double T, const double* const X, int index);
        const double* FluidMemoryForceBody( const double T, const double *const X);
 
        const double * CrossFlowBody(const double T, const double* const X);
 
        const double * ResistanceBody(const double T, const double* const X);
 
        const double * AdditionalDampeningBody(const double T, const double* const X);
 
        const double* ExternalForceNED(const double T, const double* const X);
 
        const double* ExternalForceBody(const double T, const double* const X);
        // TODO: Documentation. Output viscous roll damping as calculated in components,
        // 1) friciton damping
        // 2) eddie damping
        // 3) lift damping
        // 4) bilge keel damping
        // 5) skeg damping
        // 6) skeg lift damping
        const double * ViscousRoll(const double T, const double* const X);
        double m_ViscousRoll[6];
 
        const double* SteadyStateControlBODY( const double T, const double *const X);
        const double* SteadyStateControlNED( const double T, const double *const X);
 
        const double * DriftSpeed(const double T, const double* const X);
 
 
        double m_waveElevation;
        double m_waveSlope;
        /*const double * WaveElevation(const double T, const double* const X);
        const double * WaveSlope(const double T, const double* const X);*/
 
    private:
        void printShipInfo();
 
        PrintDuringExec* m_logg;
 
        Eigen::Vector3d m_forceExtNED;
        Eigen::Vector3d m_forceExtBody;
 
        Eigen::Vector3d m_PositionMidpoint;
        Eigen::Vector3d m_PositionAP;
        Eigen::Vector3d m_angles;
 
        Eigen::Matrix<double,6,6> m_mrb;
        Eigen::Matrix<double,6,6> m_invMrb;
 
        HullData        *m_Hull;
        HullData        *m_Hull2;
        ShipResistance      *m_resitance;
                environment::EnvironmentProvider     *m_environment = nullptr;
 
 
        Eigen::Matrix<double,1,20> Horener_X;// { 0.00035500000000000001, 0.15313099999999999, 0.34123700000000001, 0.44641399999999998, 0.46219700000000002, 0.47891400000000001, 0.48653999999999997, 0.53628799999999999, 0.63426800000000005, 0.822828, 0.99002500000000004, 1.2892699999999999, 1.6440900000000001, 1.84578, 2.3112900000000001, 2.5824500000000001, 2.9922499999999999, 3.4575800000000001, 3.7147000000000001, 4.0064099999999998 };
        Eigen::Matrix<double,1,20> Horener_Y;// { 1.9617800000000001, 1.9448000000000001, 1.8584499999999999, 1.73767, 1.5313699999999999, 1.2240599999999999, 1.14958, 1.02132, 0.92861700000000003, 0.79312000000000005, 0.71726999999999996, 0.61583900000000003, 0.50550499999999998, 0.45036799999999999, 0.37409900000000001, 0.30851600000000001, 0.254801, 0.19764300000000001, 0.14998300000000001, 0.11211599999999999 };
        std::vector<double> hx, hy;
        sfh::math::SplineInterp *hoerner;
 
 
        ISignalPort *m_InForceNED;
 
        ISignalPort *m_InMomentNED;
 
        ISignalPort *m_InForceBODY;
 
        ISignalPort *m_InMomentBODY;
 
        ICommonComputation *m_computeRelativeVelocity;
        ICommonComputation *m_computeRotationAngles;
 
        PotentialData *m_TheoryData;
 
        std::vector<double> m_waveHeight;
        std::vector<double> m_waveFreq;
        std::vector<double> m_wavePhase;
        std::vector<double> m_waveDirection;
        std::vector<double> m_waveNumber;
 
        std::vector<double> m_uHistory;
        std::vector<double> m_psiHistory;
        std::vector<double> m_tHistory;
 
        double **m_fluidForce;
        double m_fluidForceExperienced[6];
        double m_rotationForceFrame[4];
        double m_speedInformation[5];
        double m_kinetic;
        double m_fluid;
        double m_fluid2[36];
 
        double m_steadyStateBody[6];
        double m_steadyStateNED[6];
 
        double m_damping[6];
 
        mutable double m_rollPitchYaw[3];
        double m_speed[6];
        mutable double m_relativeSpeed[6];
 
        double m_firstOrderForce[6];
        double m_waveDriftForce[6];
        double m_CforcesBody[6];
        double m_CforcesFluid[6];
 
        double m_crossFlowBody[6];
        double m_resistance[6];
 
        double m_fluidMemForce[6];
        double m_restoringForce[6];
        mutable double m_sumBodyForce[6];
        double m_encounterFreq[52];
        double m_viscous[6];
 
        double m_hydrostaticSpring[3];
 
        double m_driftSpeed;
 
        bool    m_zeroSpeedRadiation;
        bool    m_hydroStaticsType;
        bool    m_useCrossFlow;
        bool    m_waveforceHframe;
        int     m_waveForceType;
        int     m_DOFFree[6];
        double  m_alfaN;
        double  m_alfaE;
        double  m_alfaD;
        double  m_surgeVelocity;
        double  m_wakeFraction;
        double  m_hydroStaticsStationVerticalStep;
        double  m_hydroStaticsStationHorizontalStep;
        double  m_hydroStaticsStationTop;
        double  m_hydroStaticsStationBottom;
        double  m_bilgeKeelStartPosition;
        double  m_bilgeKeelEndPosition;
        double m_bilgeKeelHeight;
        double  m_damperLinear[3];
        double  m_damperQuadratic[3];
        double  m_damperRotLinear[3];
        double  m_damperRotQuadratic[3];
        double m_dampingBlendSpeed;
        double m_dampingBlendFraction;
 
        double m_waveForceTransient;
 
        double  m_ForceScale[11];
        std::string m_ForceInput;
        std::string m_PotentialFileLocation;
        std::string m_PotentialFileName;
        std::string m_PotentialType;
        double m_stablizeDOF[6];
 
        bool m_coriolisRollOnly;
        Eigen::Matrix<double, 6,1> m_coriolisDOFmangler;
 
        static inline Eigen::Matrix3d S(const Eigen::Vector3d &v){
            Eigen::Matrix3d retval = Eigen::Matrix3d::Zero();
            retval(0,1)=-v(2);
            retval(0,2)=v(1);
            retval(1,0)=v(2);
            retval(1,2)=-v(0);
            retval(2,0)=-v(1);
            retval(2,1)=v(0);
            return retval;
        }
 
#ifdef FH_VISUALIZATION
        bool m_ShowForceArrows = false;
        std::string m_Material;
        std::string m_Mesh;
        std::string m_Scene;
        RenderType m_RenderAs;
        std::string m_RenderType;
 
    #endif
 
        int ***m_IFluidState;
        int ***m_FluidStateSize;
 
        unsigned int m_ISR;
        unsigned int m_ISV;
        unsigned int m_ISQ;
        unsigned int m_ISW;
 
 
    #ifdef FH_VISUALIZATION
 
    public:
        void DrawShip(Ogre::SceneNode* renderNode, Ogre::SceneManager* sceneMgr);
        void DrawStations( Ogre::SceneNode* m_RenderNode, Ogre::SceneManager * sceneMgr );
    private:
        Ogre::ManualObject *manual ;
        Ogre::SceneNode*    m_RenderNodeHull;
        Ogre::SceneNode*    m_RenderNodeZeroCross;
        Ogre::SceneNode*    m_RenderNodeStations;
        Ogre::SceneNode**   m_RenderNodeSkegPoint;
        double m_HideUntill;
        double m_NodeOffset[3];
        C3DArrow *FKF_u,*FKF_v,*FKF_w;
        C3DArrow *FKT_u,*FKT_v,*FKT_w;
 
        C3DArrow *FMF_u,*FMF_v,*FMF_w;
        C3DArrow *FMT_u,*FMT_v,*FMT_w;
 
        C3DArrow *RSF_u,*RSF_v,*RSF_w;
        C3DArrow *RST_u,*RST_v,*RST_w;
 
        C3DArrow *FKArrow;
        C3DArrow *FMArrow;
        C3DArrow *RArrow;
        C3DArrow *Res;
 
        C3DArrow *FKArrow_M;
        C3DArrow *FMArrow_M;
        C3DArrow *RArrow_M;
        C3DArrow *Res_M;
 
        C3DArrow *VArrow;
    #endif
 
        double m_maxWavePeriod;
    };
}
 
#endif