Propeller4Q.h

#ifndef Propeller4Q_h__
#define Propeller4Q_h__
#include <memory>
#include <Eigen/Eigen>
#include <SimObject.h>
#include <EnvironmentProvider.h>
#include <cstddef>
#include "Ship/AzimuthCurve.h"
 
#ifdef FH_VISUALIZATION
    #include "sfh/ogre/CDynamicLines.h"
#endif
 
namespace Ship{
 
   class Propeller4Q;
 
   class Propeller4QCurrentField : public marenv::current::CurrentField {
   public:
      Propeller4QCurrentField() = default;
      virtual ~Propeller4QCurrentField() = default;
      void inline setPropeller(Propeller4Q* propeller){ m_propeller = propeller; }
      [[deprecated("This may not use up-to-date state info")]]
      marenv::Status GetCurrent(double T, const double position[3], double currentVelocity[3]);
   private:
      Propeller4Q* m_propeller;
   };
 
    class Propeller4Q:public SimObject{
        friend class Propeller4QCurrentField;
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
 
        enum VentilationTheory{
            Ruth = 666,Smogeli
        };
 
        enum PropellerType{
            Open,Ducted,Tunnel
        };
 
        struct Curve4Q{
            AzimuthCurve<double> *Ct;
            AzimuthCurve<double> *Cq;
        };
 
        Propeller4Q(const string simObjectName, ISimObjectCreator* const creator);
 
        ~Propeller4Q();
 
        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 bool bIsMajorTimeStep);
 
 
#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);
    protected:
        ICommonComputation *m_compute;
 
        Eigen::Vector3d m_ForceNED;
        Eigen::Vector3d m_ForceBody;
 
        Eigen::Vector3d m_TorqueNED;
        Eigen::Vector3d m_TorqueBody;
 
        Eigen::Vector3d m_ForceCorrectedNED;
        Eigen::Vector3d m_ForceCorrectedBody;
 
        Eigen::Vector3d m_TorqueCorrectedNED;
        Eigen::Vector3d m_TorqueCorrectedBody;
 
           Eigen::Quaterniond m_OrientationNED;
           Eigen::Vector3d m_PositionNED;
           Eigen::Vector3d m_VelocityNED;
           double m_flowStateHigh;
           double m_RPM;
 
        double m_shaftTorque;
 
        double m_shaftTorqueCorrected;
 
        double m_shaftPower;
 
        double m_shaftPowerCorrected;
 
        double m_shaftPowerScaling;
 
        double m_propellerThrustScaling;
 
        bool m_lowSpeedJet;
 
        double m_Us;
 
        double m_Rs;
 
        double m_betaT;
 
        double m_betaQ;
 
        double m_beta_h;
 
        double m_PDcur;
 
        ISignalPort *m_InOrientationNED;
 
        ISignalPort *m_InMyRPM;
 
        ISignalPort *m_InMyPD;
 
        ISignalPort *m_InVelocityNED;
 
        ISignalPort *m_InPositionNED;
 
        environment::EnvironmentProvider *m_environment;
 
               std::shared_ptr<Propeller4QCurrentField> m_currentField = std::make_shared<Propeller4QCurrentField>();
 
        PropellerType m_PropellerType;
 
        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;
 
        double *m_PD;
 
        Curve4Q *m_curve;
 
        double m_Cq;
 
        double m_Ct;
 
        double m_deltaBetaPlus;
 
        double m_deltaBetaMinus;
 
        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__