doc/CNetCageScreen_8h_source.html

#ifndef CNetCageScreen_H

#define CNetCageScreen_H


#include <stdio.h>

#include <string>


#include <ISimObjectCreator.h>

#include <SimObject.h>

#include <Eigen/Eigen>

#include <CEnvironment.h>

#include <ICurrentVel.h>

#include <IBasicBottom.h>

#include "sfh/timers/ProfilerWallclock.h"

#include "net/CNetCableElementSpec.h"

#include "net/CNetCableElement.h"

#include "net/CScreenElementDef.h"

#include <environment/DeepSeaGravityWaves.h>

//#include <net/CNetStructureSpec.h>

#include "net/CScreenStructureSpec.h"

#include "net/CScreenElement3N.h"

#include "net/CNetBottomContactFilter.h"


#pragma once

#ifdef FH_VISUALIZATION

//#include "CFhVis.h"

#include "sfh/ogre/NMeshGenerators.h"

#include "sfh/ogre/C3DLine.h"

#include <CTextRenderer.h>

#endif


namespace Netcage {


class CNetCageScreen : public SimObject

{

public:

    CNetCageScreen(const string& simobjectname, ISimObjectCreator* const creator);

    virtual ~CNetCageScreen();

    virtual void OdeFcn(const double dT, const double* const adX, double* const adXDot, const bool bIsMajorTimeStep);

    virtual void InitialConditionSetup(const double dT, const double *const adCurrentIC, double *const adUpdatedIC, ISimObjectCreator *const pCreator);

    virtual void FinalSetup(const double dT, const double *const adX, ISimObjectCreator *const pCreator);       // NEW: overridden to test new approach where pos and vel for selected nodes are set by external objects

    const double * outExternalNodeForce(const double dT, const double *const adX, int iExtNode);

    //virtual void OdeFcn(const double T, const double *const X, double *const XDot, const bool bIsMajorTimeStep);


#ifdef FH_VISUALIZATION

    virtual 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

    void CreateCapsule( Ogre::ManualObject *capsule_manual);

    C3DLine *myline;


#endif


    virtual const double * NodePos(const double dT, const double *const adX, int iExtNode);

    virtual const double * NodeVel(const double dT, const double *const adX, int iExtNode);

    virtual const double * BottomContact(const double dT, const double *const adX);

    void SetAddedDragPerMPS(double AddedDragPerMPS);


    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 * InternalNodeForce(const double dT, const double *const adX, int iExtNode);               // NEW: added to test new approach where pos and vel for selected nodes are set by external objects

    const double * NodeForce(const double T, const double *const X, int iNode);

    //const double *const outExternalNodeForce(const double dT, const double *const adX, int iExtNode);

    //const double* const outCurrentVel(const double T, const double* const X);


    // Overloads the function in CNetStructure

    //void AddNetForces(const double dT, const double* const adX);


    void GetNodePositionIndices( std::vector<int> &NodePositions);

    void GetNodeVelocityIndices( std::vector<int> &NodeVelocities);

    vector<CScreenElement3N*> getNetElements();

    void getNetElementConnections(vector<int*> &ElementConnections);

    void setTraversedElements(vector<bool> TraversedElements);


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;


    // 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


    virtual void    CreateNetPanels(std::vector<const CScreenElementDef*> VNetElementDefs, ISimObjectCreator *pCreator);

    virtual void    CreateNetCables(std::vector<const CNetCableElementSpec*> VCableElements, ISimObjectCreator *pCreator);

    void            AddExternalForces(const double dT, const double *const adX);

    void            AddBottomForces(const double *const adX);

    VSPairStrInt    CreateExternalNodeMap( std::string sTag, int* piUsed, CScreenStructureSpec & ScreenSpec, ISimObjectCreator *pCreator);

    void            PRINTALLNODEFORCES(std::string spec, double dT);


    int             m_iNumNodeOutputs;

    int**           m_aaiCableConn;

    bool            m_UseActualElementSizeInWakeEffect;

    int             m_NElementBarsInWakeEffectCalc;

    bool            m_useReynoldsDependentDragCoefficients;


    float*      m_afInertia;

    double*     m_adNodeForce;

    double*     m_NodeExternalForces;

    double      m_adBottomContact[6];

    int*        m_aIStateVel;

    int         m_iNumNodesCalc;

    int         m_iNumNodesOriginal;

    int         m_iNumNodesOutputPosAndVel;

    int         m_iNumPanelsCalc;

    int         m_iNumCablesCalc;

    int         m_iNumNodesInputForce;

    int*        m_aiNetConn;

    int*        m_aIStatePos;

    bool        m_bUseTagForExternalNodes;

    bool        m_InternalElementWakeEffectsActive;

    bool        m_bFoldingPointRefinementUsed;

    bool        m_ExternalElementWakeEffectsActive;


    double      m_harmForceCoeff[4];


    ISignalPort**       m_apInExternalForces;


    CNetBottomContactFilter m_BottomContactFilter;

    SAdaptationSpec_t   m_SAdaptations;

    CEnvironment*       m_pEnvironment;

    ICurrentVel**       m_ppCurrentVel;

    VSPairStrInt        m_VsNodesOutputPosAndVel;

    VSPairStrInt        m_VsNodesInputForce;

    IBasicBottom**      m_ppBottom;


    std::vector<CNetCableElement*>          m_VpCableElements;

    sfh::timers::StopWatch                  m_OdeTimer;

    //std::vector<CScreenElement3N*>            m_VpNetElements;

    std::vector<CScreenElement3N*>          m_VpScreenElements;


#ifdef FH_VISUALIZATION

/*

    double                  m_Scale; ///< Scale factor for the visualization.

    const Ogre::Root*               m_OgreRoot;

    Ogre::SceneNode* m_renderNode;

*/

#endif


#ifdef CNetStructureWakeEffect_DO_PROFILE

    sfh::timers::ProfilerWallclock m_Profiler;

#endif


};


} // namespace

#endif

CEnvironment
Definition: CEnvironment.h:10

CNetBottomContactFilter
Definition: CNetBottomContactFilter.h:7

CScreenStructureSpec
Class containing the specification for a net object.
Definition: CScreenStructureSpec.h:42

IBasicBottom
Interface for calculating the bottom force on various objects.
Definition: IBasicBottom.h:23

ICurrentVel
Definition: ICurrentVel.h:12

Netcage::CNetCageScreen
Definition: CNetCageScreen.h:43

Netcage::CNetCageScreen::CreateNetPanels
virtual void CreateNetPanels(std::vector< const CScreenElementDef * > VNetElementDefs, ISimObjectCreator *pCreator)
VARIABLES NEEDED AFTER REMOVING NETSTRUCTURE — START.

Netcage::CNetCageScreen::~CNetCageScreen
virtual ~CNetCageScreen()
The destructor cleans up.

Netcage::CNetCageScreen::m_apInExternalForces
ISignalPort ** m_apInExternalForces
Harmonic coeffisients in drag and lift force calculations (a3,a5,b4,b6) for CD/cd=a1*cos(Theta)+a3*co...
Definition: CNetCageScreen.h:210

Netcage::CNetCageScreen::m_harmForceCoeff
double m_harmForceCoeff[4]
Spesific for screen model.
Definition: CNetCageScreen.h:208

Netcage::CNetCageScreen::outSumHydDynForce
const double * outSumHydDynForce(const double T, const double *const X)
VARIABLES NEEDED AFTER REMOVING NETSTRUCTURE — END.

Netcage::CNetCageScreen::m_UseActualElementSizeInWakeEffect
bool m_UseActualElementSizeInWakeEffect
Set to true if actual size (number of u and v bars) of net element shall be used in wake effect calcu...
Definition: CNetCageScreen.h:185

Netcage::CNetCageScreen::m_NElementBarsInWakeEffectCalc
int m_NElementBarsInWakeEffectCalc
Number of u and v bars in calculation of wake effect if m_UseActualElementSizeInWakeEffect is set to ...
Definition: CNetCageScreen.h:186

Netcage::CNetCageScreen::CNetCageScreen
CNetCageScreen(const string &simobjectname, ISimObjectCreator *const creator)
The constructor sets the pointer to the output object and the parser object.

Netcage::CNetCageScreen::NodePos
virtual const double * NodePos(const double dT, const double *const adX, int iExtNode)
Calculates the state derivatives.

Netcage
Class modelling a Net cage.
Definition: CBottomRing.h:35

SAdaptationSpec_t
Class containing the specification for a net object.
Definition: CNetStructureSpec.h:22