NetStructure.h

#pragma once
 
#include <limits>
#include <vector>
#include "CommonTypes.h"
 
// #define CNetStructure_DO_PROFILE
 
// Includes
#include "NetBottomContactFilter.h"
#include "NetCableElement.h"
#include "NetCableElementSpec.h"
#include "NetElement3N.h"
#include "NetElementDef.h"
#include "NetPanelSetup.h"
#include "NetStructureSpec.h"
#include "NetFlowInteraction.h"
 
#include "sfh/math/math.h"
#include "sfh/timers/ProfilerWallclock.h"
 
#include <fhsim/simobject/SimObject.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/SeafloorForcesInterface.h>
#include <memory>
#include <string>
 
 
#ifdef FH_VISUALIZATION
#   include "sfh/ogre/C3DLine.h"
#   include "sfh/ogre/NMeshGenerators.h"
#endif
 
 
// Class definition
class NetStructure : public SimObject
{
public:
   NetStructure(std::string simObjectName, ISimObjectCreator* creator);
   virtual ~NetStructure();
   virtual void  OdeFcn(const double dT, const double* const adX, double* const adXDot) const;
   virtual void  InitialConditionSetup(const double dT, const double* const adCurrentIC, double* const adUpdatedIC, ISimObjectCreator* const creator);
   virtual void  FinalSetup(const double dT, const double* const adX, ISimObjectCreator* const creator);
   void          PreOdeFcn(double T, const double* X, IStateUpdater* updater) override;
   const double* outExternalNodeForce(const double dT, const double* const adX, int extNode);
 
 
   bool HasJacobians() const override;
   void OdeJacobian(double T, const double* X, double* J, int nStates) override;
   int  GetJacobianSparsity(int nStates, int* rowPtr, int* colIdx) override;
 
   bool HasPortJacobians() const override;
   void InputPortJacobian(const std::string& portName, double T, const double* X,
         double* dF_dInput, int portSize, int nStates) override;
   void OutputPortJacobian(const std::string& portName, double T, const double* X,
         double* dPort_dX, int portSize, int nStates, int index) override;
 
#ifdef FH_VISUALIZATION
   virtual void RenderInit(Ogre::Root* const ogreRoot, ISimObjectCreator* const creator);
   virtual void RenderUpdate(const double dT, const double* const adX);
#endif
   const virtual double* NodePos(const double dT, const double* const adX, int extNode);
   const virtual double* NodeVel(const double dT, const double* const adX, int extNode);
   const virtual double* BottomContact(const double dT, const double* const adX);
 
   const virtual double* StrainEnergy(const double dT, const double* const adX);
   const virtual double* VelNorm(const double dT, const double* const adX);
   double                m_velNorm;
 
   void SetAddedDragPerMPS(double AddedDragPerMPS);
 
protected:
   virtual void   CalcStateDerivatives(const double* const adX, double* const adXDot) const;
   virtual void   AddExternalForces(const double dT, const double* const adX) const;
   virtual void   AddNetForces(const double dT, const double* const adX) const;
   virtual void   AddCableForces(const double dT, const double* const adX) const;
   void           AddNetForceRange(double T, const double* X, int begin, int end, double* nodeForce) const;
   void           AddCableForceRange(double T, const double* X, int begin, int end, double* nodeForce, bool waterFollowsElement = false) const;
   void           CableHydrodynamicForce(double T, const double* X, double force[3]) const;
   void           AddNetAndCableForcesInParallel(double T, const double* X) const;
   void           FlowAt(double T, int point, const double pos[3], double vel[3]) const;
   void           UpdateNodeWaveVelocities(double T, const double* X, int stateBase, int begin, int end) const;
   virtual bool   AddNodeBottomForce(const double* const adX, int node, double diam, double adForceInOut[3]) const;
   virtual void   AddBottomForces(const double* const adX) const;
   bool           HasJacobianConfiguration() const;
   virtual void   AddInputPorts(ISimObjectCreator* creator);
   virtual void   CreateNetPanels(std::vector<const NetElementDef*> VNetElementDefs, ISimObjectCreator* creator);
   virtual void   CreateNetCables(std::vector<const NetCableElementSpec*> VCableElements, ISimObjectCreator* creator);
   virtual void   CreateDataStructures();
   virtual void   CreateOutputPorts(ISimObjectCreator* creator);
   std::string    PosPortName(int extNode) const;
   std::string    VelPortName(int extNode) const;
   void           VelNormJacobian(const double* X, double* dPort_dX) const;
   void           StrainEnergyJacobian(const double* X, double* dPort_dX) const;
   VSPairStrInt   CreateExternalNodeMap(std::string tag, int* piUsed, NetStructureSpec& NetSpec, ISimObjectCreator* creator);
   void           PRINTALLNODEFORCES(std::string spec, double dT);
 
   void ComputeCableStructuralJacobian(
         const NetCableElement* cable,
         const double pA[3], const double pB[3],
         const double vA[3], const double vB[3],
         double dFA_dpA[9], double dFA_dpB[9],
         double dFA_dvA[9], double dFA_dvB[9]) const;
 
   void ComputeCableDragVelocityJacobian(
         const NetCableElement* cable,
         const double pA[3], const double pB[3],
         const double vA[3], const double vB[3],
         const double vFluid[3], double rhoWater,
         double dFA_dvA[9], double dFA_dvB[9],
         double dFB_dvA[9], double dFB_dvB[9]) const;
 
   void ComputeCableDragPositionJacobian(
         const NetCableElement* cable,
         const double pA[3], const double pB[3],
         const double vA[3], const double vB[3],
         const double vFluid[3], double rhoWater,
         double dFA_dpA[9], double dFA_dpB[9],
         double dFB_dpA[9], double dFB_dpB[9]) const;
 
   void ComputePanelJacobianAD(
         const NetElement3N* panel,
         const double pA[3], const double pB[3], const double pC[3],
         const double vA[3], const double vB[3], const double vC[3],
         const double vWater[3], double addedLinearDrag,
         double dFA_dpA[9], double dFA_dpB[9], double dFA_dpC[9],
         double dFB_dpA[9], double dFB_dpB[9], double dFB_dpC[9],
         double dFC_dpA[9], double dFC_dpB[9], double dFC_dpC[9],
         double dFA_dvA[9], double dFA_dvB[9], double dFA_dvC[9],
         double dFB_dvA[9], double dFB_dvB[9], double dFB_dvC[9],
         double dFC_dvA[9], double dFC_dvB[9], double dFC_dvC[9]) const;
 
   double m_StrainEnergy;
 
 
   net_panel_setup::PanelHydrodynamics m_panelHydrodynamics; 
   net_solidity::SolidityModel         m_solidityModel = net_solidity::kDefaultSolidityModel;
 
 
   template<class> friend class NetWakePanels; 
   const double* NodePositionState(const double* X, int node) const { return X + m_iStatePos[node]; }
   const double* NodeVelocityState(const double* X, int node) const { return X + m_iStateVel[node]; }
   std::unique_ptr<NetFlowInteraction> m_flow;            
   ISimObjectLogger*                   m_logger = nullptr; 
   hydrodynamics::PanelClampLog        m_clampLog;         
 
 
   ISignalPort** m_inExternalForces;
   int*          m_iStatePos;
   int*          m_iStateVel;
   int           m_iStateBase = 0; 
 
   int LocalIndex(int globalStateIndex) const { return globalStateIndex - m_iStateBase; }
   // double*           m_NodeExternalForces;
 
   int m_numNodesInputForce;
   int m_numNodesOutputPosAndVel;
   int m_numPanelsCalc;
   int m_numCablesCalc;
   int m_numNodesOriginal;
   int m_numNodesCalc;
   int m_numNodeOutputs;
 
 
   NetBottomContactFilter m_BottomContactFilter;
   mutable double         m_bottomContact[6]; 
 
   environment::EnvironmentProvider*     m_environment;
   environment::SeafloorForcesInterface* m_seafloor;
   mutable bool                          m_inBottomContact = false; 
 
 
   std::vector<NetCableElement*> m_VpCableElements;
   std::vector<NetElement3N*>    m_VpNetElements;
   float*                        m_inertia;
   int*                          m_netConn;
   int**                         m_aaiCableConn;
   SAdaptationSpec_t             m_SAdaptations;
   bool                          m_foldingPointRefinementUsed;
 
 
 
   VSPairStrInt m_VsNodesOutputPosAndVel;
   VSPairStrInt m_VsNodesInputForce;
   bool         m_useTagForExternalNodes;
 
   double*                        m_nodeForce;
   int                            m_numThreads = 1;    
   mutable std::vector<double>    m_threadNodeForces;  
   mutable std::vector<double>    m_nodeWaveVelocity;  
   double m_meanTensionTime = std::numeric_limits<double>::quiet_NaN();
 
#ifdef CNetStructure_DO_PROFILE
   sfh::timers::ProfilerWallclock m_Profiler;
#endif
 
#ifdef FH_VISUALIZATION
   bool     m_lineVisualization;
   C3DLine* m_LineVisualizationPressure;
   C3DLine* m_LineVisualizationStrain;
#endif
};