CNetCageWakeEffect.h

#pragma once
 
#include <stdio.h>
#include <string>
 
#include <ISimObjectCreator.h>
#include <SimObject.h>
#include <Eigen/Eigen>
#include <net/CNetStructureWakeEffect.h>
#include <environment/DeepSeaGravityWaves.h>
 
#ifdef FH_VISUALIZATION
//#include "CFhVis.h"
#endif
 
namespace Netcage {
class CNetCageWakeEffect : public CNetStructureWakeEffect
{
public:
    CNetCageWakeEffect(const string& simObjectName, ISimObjectCreator* const creator);
 
    virtual void FinalSetup(const double dT, const double *const adX, ISimObjectCreator *const pCreator);
    ~CNetCageWakeEffect();
 
    virtual void OdeFcn(const double T, const double* const X, double* const XDot, const bool IsMajorTimeStep);
 
    const double* outSumHydDynForce(const double T, const double* const X);
    const double* outNodeSumForce(const double T, const double* const X);
    const double* outNodeSumDragForceAbs(const double T, const double* const X);
    const double* outNodeSumDragForceDirection(const double T, const double* const X);
    const double* outNodeSumLiftForce(const double T, const double* const X);
    const double* outBottomPosition(const double T, const double* const X);
    const double* outSteadyStateEst_Tau(const double T, const double* const X);
    const double* outSteadyStateEst_K(const double T, const double* const X);
    const double* LowerMembranePosition(const double dT, const double* const adX);
    const double* outMiddleCurrentVelocity(const double dT, const double* const adX);
    const double* outNetPosition(const double T, const double* const X, int iNode);
 
    const virtual double * InternalNodeForce(const double T, const double *const X, int iExtNode);
    const virtual double * NodeForce(const double T, const double *const X, int iNode);
    void GetNodePositionIndices( std::vector<int> &NodePositions);
    void GetNodeVelocityIndices( std::vector<int> &NodeVelocities);
    vector<CNetElement3NWakeEffect*> getNetElements();
    void getNetElementConnections(vector<int*> &ElementConnections);
    void setTraversedElements(vector<bool> TraversedElements);
        void calculations(const double T, const double* const X);
#ifdef FH_VISUALIZATION
 
    void RenderInit(Ogre::Root* const pOgreRoot, ISimObjectCreator* const pCreator); // Overridden to be able to run two NetCageSim simobjects.
    virtual void RenderUpdate(const double T, const double* const X);                                           // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
 
#endif
 
protected:
    void DecomposeDragForcesInCurrentDirection(double* const DragForcesProjected, const double T, const double* const X);
    bool SteadyStateEstimator(const double T, const double* const X);
    void AddDeadFishWeightForce(const double T, const double* const X);
 
    void SetExternalPos(const double dT, const double *const adX);                                      // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    void SetExternalVel(const double dT, const double *const adX);                                      // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    virtual void CreateDataStructures();                                                                        // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual void AddInputPorts(ISimObjectCreator *pCreator);                                                    // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual void CreateOutputPorts(ISimObjectCreator *pCreator);                                                // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual void CalcStateDerivatives(const double *const adX, double *const adXDot);                           // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual double AddNodeBottomForce(const double *const adX, int iNode, double dDiam, double adForceInOut[3]);// NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual void AddNetForces(const double dT, const double *const adX);                                        // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
    virtual void AddCableForces(const double dT, const double *const adX);                                      // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects
 
    //ISignalPort*  m_CurrentVel;       // Current velocity input
    ISignalPort **m_InExternalPos;                                                                              // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    ISignalPort **m_InExternalVel;                                                                              // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    ISignalPort *m_MembraneDepth;                                                                               // Depth of membrane (Perma skirt.)
 
    double*         m_NodeExternalPos;                                                                          // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    double*         m_NodeExternalVel;                                                                          // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    double          m_adNodeSumForce[3];
    double          m_adSumHydDynForce[3];
    double          m_dNodeSumDragForceAbs;
    double          m_dNodeSumDragDirection;
    double          m_dNodeSumLiftForce;
    double          m_MiddleCurrentVelocity[3];
 
    double*         m_adNodeHydDynForce;
 
    double*         m_NodeInternalForces;                                                                       // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    int(*           m_hasPosAndVelStates)[2];                                                                   // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    int m_NumNodesInputPosAndVel;                                                                               // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    int m_NumNodesOutputForce;                                                                                  // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    VSPairStrInt            m_VsNodesInputPosAndVel;                                                            // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
    VSPairStrInt            m_VsNodesOutputForce;                                                               // NEW: added to test new approach where pos and vel for selected nodes are set by external objects
 
    Eigen::MatrixXd         m_SSPhi;                                                                            // Regression matrix for steady state estimation
    Eigen::MatrixXd         m_SSY;                                                                              // Output matrix for steady state estimation
    double                  m_SS_Tau;                                                                           // Estimated first order time constant
    double                  m_SS_K;                                                                             // Estimated gain
    sfh::timers::StopWatch m_SSCalcIntervalWatch;                                                               // Stop watch for timing of steady state calculations
 
    int m_IsMembrane;                                                                                               // True if simobject is (membrane)
    int m_MembraneIsInSystem;                                                                                   // True if membrane is added
    double m_LowerMembraneDepth;
    std::string m_simobjectname; // for debug
    bool m_TerminateAtSteadyState;                                                                              // True if automatic termination at predefied steady state level
 
    double m_PI;
 
    // VARIABLES FOR SCREEN METHOD
 
    // Net position output
    int     m_outNetPosNum;
    int*    m_outNetPosIndex;
 
    // NEW VARIABLES ASSOCIATED WITH WAKE EFFECT
    std::string     m_CageShape;
    /*
    double          m_TopDiameter;
    double          m_BottomDiameter;
    double          m_WallDepth;
    double          m_ConeDepth;
    */
    double*         m_CageCentre;
 
    int             m_BottomNodeIndex;
    double          m_DeadFishInertia[3]; // Inertia for dead fish
    double          m_DeadFishWeigthForce;
    bool            m_HasDeadFish;
    sfh::timers::StopWatch m_RealTimeWatch; // For calculation of elapsedtime in simulation
    ICommonComputation* m_calcDynamics;
#ifdef FH_VISUALIZATION
/*
    double                  m_Scale; ///< Scale factor for the visualization.
    const Ogre::Root*               m_OgreRoot;
    Ogre::SceneNode* m_renderNode;
*/
#endif
};
 
} // namespace