NetCore.h

#pragma once
 
#include "NetCableElement.h"
#include "NetElement3N.h"
#include "NetFlowInteraction.h"
#include "NetNodeStates.h"
#include "NetPanelSetup.h"
#include "NetStructureSpec.h"
 
#include <fhsim/ISimObjectLogger.h>
#include <fhsim/PrintDuringExec.h>
#include <fhsim/simobject/ISimObjectCreator.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/SeafloorForcesInterface.h>
#include <fhsim_environment/hydrodynamics/PanelClampLog.h>
#include <limits>
#include <memory>
#include <string>
#include <vector>
 
struct NetCoreOptions
{
   std::string     structureName;        
   NetPanelOptions panel;                
   NetCableOptions cable;                
   bool            bottomContact = true; 
};
 
class NetCore
{
public:
   NetCore(const std::string& name, const NetStructureSpec& spec, const NetCoreOptions& options, ISimObjectCreator* creator);
   ~NetCore();
   NetCore(const NetCore&)            = delete;
   NetCore& operator=(const NetCore&) = delete;
 
   void FinalSetup(const NetNodeStates& nodes, const double* X, ISimObjectCreator* creator);
 
   void PreOdeFcn(double T, const double* X);
 
   void Evaluate(double T, const double* X, double* XDot) const;
 
   void AcceptedStep(double T);
 
   void SetAddedDragPerMPS(double addedDragPerMPS) { m_adaptations.addedDragPerMPS = addedDragPerMPS; }
 
   NetNodeView View(const double* X, int stateBase = 0) const { return NetNodeView {X, &m_layout, stateBase}; }
 
   int NumNodes() const { return m_numNodesCalc; }             
   int NumOriginalNodes() const { return m_numNodesOriginal; } 
   int NumPanels() const { return static_cast<int>(m_panels.size()); }
   int NumCables() const { return static_cast<int>(m_cables.size()); }
 
   const int*             PanelNodes(int panel) const { return m_panelNodes.data() + 3 * panel; }
   const NetElement3N&    Panel(int panel) const { return *m_panels[panel]; }
   NetElement3N&          Panel(int panel) { return *m_panels[panel]; }
   const NetCableElement& Cable(int cable) const { return *m_cables[cable]; }
   NetCableElement&       Cable(int cable) { return *m_cables[cable]; }
 
   float Inertia(int node) const { return m_inertia[node]; }
   const double* NodeForce(int node) const { return m_nodeForce.data() + 3 * node; }
 
   const SAdaptationSpec_t&                   Adaptations() const { return m_adaptations; } 
   bool                                       FoldingPointRefinementUsed() const { return m_foldingPointRefinementUsed; }
   const net_panel_setup::PanelHydrodynamics& PanelHydrodynamics() const { return m_panelHydrodynamics; }
   environment::EnvironmentProvider*          Environment() const { return m_environment; }
 
   bool InBottomContact() const { return m_inBottomContact; }
   const double* BottomContact() const { return m_bottomContactFiltered; }
 
   void PrepareFlow(double T, const double* X, int stateBase) const { UpdateNodeWaveVelocities(T, View(X, stateBase), 0, m_numNodesCalc); }
   void FlowAt(double T, int point, const double pos[3], double vel[3]) const;
   void CableHydrodynamicForce(double T, const double* X, double force[3]) const;
   const environment::wake::BodyWake* Wake() const { return m_flow->Wake(); }
 
private:
   void CreatePanels(std::vector<const NetElementDef*> definitions, ISimObjectCreator* creator);
   void CreateCables(std::vector<const NetCableElementSpec*> specs, ISimObjectCreator* creator);
   void UpdateNodeWaveVelocities(double T, const NetNodeView& nodes, int begin, int end) const;
   void AddPanelForceRange(double T, const NetNodeView& nodes, int begin, int end, double* nodeForce) const;
   void AddCableForceRange(double T, const NetNodeView& nodes, int begin, int end, double* nodeForce, bool waterFollowsElement = false) const;
   void AddBottomForces(const NetNodeView& nodes) const;
 
   std::string    m_name;    
   NetCoreOptions m_options; 
 
 
   int                                           m_numNodesCalc     = 0;
   int                                           m_numNodesOriginal = 0;
   std::vector<std::unique_ptr<NetElement3N>>    m_panels;     
   std::vector<int>                              m_panelNodes; 
   std::vector<std::unique_ptr<NetCableElement>> m_cables;     
   std::vector<float>                            m_inertia;    
   mutable std::vector<double>                   m_nodeForce;  
   SAdaptationSpec_t                             m_adaptations;
   bool                                          m_foldingPointRefinementUsed = false;
 
 
   const NetNodeStates* m_nodes = nullptr;
   NetNodeLayout        m_layout;
 
 
   net_panel_setup::PanelHydrodynamics m_panelHydrodynamics; 
   net_solidity::SolidityModel         m_solidityModel = net_solidity::kDefaultSolidityModel;
 
 
   environment::EnvironmentProvider*   m_environment = nullptr;
   std::unique_ptr<NetFlowInteraction> m_flow;             
   mutable std::vector<double>         m_nodeWaveVelocity; 
   ISimObjectLogger*                   m_logger = nullptr; 
   PrintDuringExec*                    m_print  = nullptr; 
   hydrodynamics::PanelClampLog        m_clampLog;         
 
   int                         m_numThreads = 1;   
   mutable std::vector<double> m_threadNodeForces; 
   double m_meanTensionTime = std::numeric_limits<double>::quiet_NaN();
 
 
   environment::SeafloorForcesInterface* m_seafloor                  = nullptr;
   double                                m_bottomContactTimeConstant = 0.01; 
   double                                m_bottomContactDiameter     = 0.5;  
   mutable double                        m_bottomContact[6]          = {};   
   double                                m_bottomContactFiltered[6]  = {};   
   double                                m_lastAcceptedTime          = 0.0;  
   bool                                  m_hasAcceptedStep           = false;
   mutable bool                          m_inBottomContact           = false; 
};