CycloidalPropeller.h

#ifndef CycloidalPropeller_h_
#define CycloidalPropeller_h_
#include <cmath>
#include <memory>
 
#include <Eigen/Eigen>
#include <sfh/constants.h>
 
#include <SimObject.h>
#include <EnvironmentProvider.h>
 
namespace Ship{
 
   class CycloidalPropeller;
 
   class CycloidalPropellerCurrentField : public marenv::current::CurrentField {
   public:
      CycloidalPropellerCurrentField() = default;
      virtual ~CycloidalPropellerCurrentField() = default;
      void inline setPropeller(CycloidalPropeller* propeller){ m_propeller = propeller; }
      [[deprecated("This may not use up-to-date state info")]]
      marenv::Status GetCurrent(const double T, const double position[3], double currentVelocity[3]);
   private:
      CycloidalPropeller* m_propeller;
   };
 
    class CycloidalPropeller: public SimObject{
        friend class CycloidalPropellerCurrentField;
    public:
        EIGEN_MAKE_ALIGNED_OPERATOR_NEW
        CycloidalPropeller(const string simObjectName, ISimObjectCreator* const creator);
                virtual ~CycloidalPropeller();
        void Compute(const double T, const double * const X);
        void OdeFcn(const double T, const double *const X, double *const XDot, const bool IsMajorTimeStep);
           void PreOdeFcn(const double T, const double *const X, IStateUpdater* updater);
 
        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* 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 FinalSetup(const double T, const double *const X, ISimObjectCreator* const creator);
    #ifdef FH_VISUALIZATION
        void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
        void RenderUpdate(const double T, const double* const X);
    #endif
    private:
 
        double Ct ( double intensity )const{
            return std::pow(std::sin( intensity*sfh::pi/2 ),2.0);
        }
 
    #ifdef FH_VISUALIZATION
        int m_rotationState;
        bool m_reverseRotationDirection;
 
        Ogre::SceneNode *m_RenderNode;
        Ogre::SceneNode *m_RenderNodeFoil;
    #endif
 
        int m_currentState;
        double m_ct;
        double m_ct_angle;
        double m_cq;
        double m_cq_angle;
        double m_D;
        double m_b;
 
        double m_shaftTorque;
        double m_shaftPower;
 
 
        double m_torqueScale;
        double m_thrustScale;
 
                double m_current;
                Eigen::Vector3d m_thrustVectorBody;
                Eigen::Vector3d m_posNED;
                Eigen::Quaterniond m_Q;
        Eigen::Vector3d m_force;
        Eigen::Vector3d m_torque;
 
        Eigen::Vector3d m_forceBody;
        Eigen::Vector3d m_torqueBody;
 
        ICommonComputation * m_compute;
 
        ISignalPort * m_inRPM;
        ISignalPort * m_inThrustIntensity;
        ISignalPort * m_inThrustVectorBody;
 
        ISignalPort * m_inPositionNED;
        ISignalPort * m_inVelocityNED;
        ISignalPort * m_inOrientationNED;
 
        environment::EnvironmentProvider *m_environment;
                std::shared_ptr<CycloidalPropellerCurrentField> m_currentField = std::make_shared<CycloidalPropellerCurrentField>();
 
    };
}
#endif // CycloidalPropeller_h__