Propeller4Q.h

#ifndef Propeller4Q_h__
#define Propeller4Q_h__
#include <vector>
#include <memory>
#include <Eigen/Eigen>
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include "PropulsorWakeField.h"
#include <cstddef>
#include <string>
#include "Ship/AzimuthCurve.h"
 
#ifdef FH_VISUALIZATION
    #include "sfh/ogre/CDynamicLines.h"
#endif
 
namespace Ship{
 
   struct Propeller4QWakeState {
      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
      Eigen::Quaterniond orientationNED = Eigen::Quaterniond::Identity();
      Eigen::Vector3d    positionNED    = Eigen::Vector3d::Zero();
      Eigen::Vector3d    velocityNED    = Eigen::Vector3d::Zero();
      double             flowStateHigh  = 0;
      double             Rs             = 0;
   };
 
   marenv::Status Propeller4QJet(const Propeller4QWakeState& state, double T, const double position[3], double currentVelocity[3]);
 
   using Propeller4QCurrentField = PropulsorWakeField<Propeller4QWakeState>;
 
    class Propeller4Q:public SimObject{
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
        enum VentilationTheory{
            Ruth = 666,Smogeli
        };
 
        enum PropellerType{
            Open,Ducted,Tunnel
        };
 
        struct Curve4Q{
            std::unique_ptr<AzimuthCurve<double> > Ct;
            std::unique_ptr<AzimuthCurve<double> > Cq;
        };
 
        Propeller4Q(const std::string simObjectName, ISimObjectCreator* const creator);
 
 
        void FinalSetup( const double T, const double *const X, ISimObjectCreator* const creator );
        void OdeFcn(const double T, const double* const X, double* const XDot) const;
        void AcceptedStep(double T, const double* X) override;
 
 
#ifdef FH_VISUALIZATION
        void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
        void RenderUpdate( const double T, const double* const X);
#endif
 
        const double* Us(const double T, const double* const X);
        const double* Rs(const double T, const double* const X);
        const double* BetaT(const double T, const double* const X);
 
        const double* BetaQ(const double T, const double* const X);
 
        const double* Ct(const double T, const double* const X);
 
        const double* Cq(const double T, const double* const X);
 
        const double* ForceNED(const double T, const double* const X);
 
        const double* TorqueNED(const double T, const double* const X);
 
        const double* ForceBody(const double T, const double* const X);
 
        const double* TorqueBody(const double T, const double* const X);
 
        const double* BetaH(const double T, const double* const X);
 
        const double* PDCurrent(const double T, const double* const X);
 
        const double* ForceCorrectedBody(const double T, const double* const X);
 
        const double* TorqueCorrectedBody(const double T, const double* const X);
 
        const double* ForceCorrectedNED(const double T, const double* const X);
 
        const double* TorqueCorrectedNED(const double T, const double* const X);
 
        const double* ShaftTorqueCorrectedBody(const double T, const double* const X);
        const double* ShaftTorqueBody(const double T, const double* const X);
 
        const double* ShaftPowerCorrected(const double T, const double* const X);
 
        const double* ShaftPower(const double T, const double* const X);
 
        void Compute(const double T, const double* const X) const;
    protected:
        ICommonComputation *m_compute;
 
        mutable Eigen::Vector3d m_ForceNED;
        mutable Eigen::Vector3d m_ForceBody;
 
        mutable Eigen::Vector3d m_TorqueNED;
        mutable Eigen::Vector3d m_TorqueBody;
 
        mutable Eigen::Vector3d m_ForceCorrectedNED;
        mutable Eigen::Vector3d m_ForceCorrectedBody;
 
        mutable Eigen::Vector3d m_TorqueCorrectedNED;
        mutable Eigen::Vector3d m_TorqueCorrectedBody;
 
 
        mutable double m_shaftTorque;
 
        mutable double m_shaftTorqueCorrected;
 
        mutable double m_shaftPower;
 
        mutable double m_shaftPowerCorrected;
 
        double m_shaftPowerScaling;
 
        double m_propellerThrustScaling;
 
        double m_Us;
 
        mutable double m_Rs;
 
        mutable double m_betaT;
 
        mutable double m_betaQ;
 
        mutable double m_beta_h;
 
        mutable double m_PDcur;
 
        ISignalPort *m_InOrientationNED;
 
        ISignalPort *m_InMyRPM;
 
        ISignalPort *m_InMyPD;
 
        ISignalPort *m_InVelocityNED;
 
        ISignalPort *m_InPositionNED;
 
        environment::EnvironmentProvider *m_environment = nullptr;
 
               std::shared_ptr<Propeller4QCurrentField> m_currentField = std::make_shared<Propeller4QCurrentField>(Propeller4QJet);
 
        PropellerType m_PropellerType = Open;
 
        VentilationTheory m_VentilationTheory;
 
        int m_IndexVentialtionStateQ;
 
        int m_IndexVentialtionStateT;
 
        int m_IndexAxialFlowStateLow;
 
        int m_IndexAxialFlowStateHigh;
 
        int m_IndexRotationalFlowState1;
 
        int m_IndexRotationalFlowState2;
 
        double m_D;
 
        int m_numPD = 0;
 
        std::vector<double> m_PD;
 
        std::vector<Curve4Q> m_curve;
 
        mutable double m_Cq;
 
        mutable double m_Ct;
 
        double m_deltaBetaPlus;
 
        double m_deltaBetaMinus;
 
        mutable double m_U;
 
        double m_WakeFraction;
 
        double m_ThrustDeduction;
 
        bool m_azimuthinMainLoss;
 
#ifdef FH_VISUALIZATION
        int m_IndexPropellerRotationSatet;
 
        bool m_reverseRotationDirection;
 
        CDynamicLines * m_lines;
 
        Ogre::SceneNode* m_RenderNode;
 
        Ogre::SceneNode* m_RenderNodePropeller;
#endif
    };
}
#endif // Propeller4Q_h__