NetWakePanels.h

#pragma once
 
#include "NetCore.h"
 
#include <fhsim_environment/PanelSourceSet.h>
 
class NetWakePanels final : public environment::wake::WakePanelSource
{
public:
   explicit NetWakePanels(const NetCore& core)
       : m_core(core)
   {
   }
 
   int NumNodes() const override { return m_core.NumNodes(); }
   int NumPanels() const override { return m_core.NumPanels(); }
 
   void PanelNodes(int panel, int nodes[3]) const override
   {
      const int* panelNodes = m_core.PanelNodes(panel);
      for (int k = 0; k < 3; k++)
         nodes[k] = panelNodes[k];
   }
 
   void NodePosition(const double* X, int node, double pos[3]) const override
   {
      const double* state = m_core.View(X).Position(node);
      for (int k = 0; k < 3; k++)
         pos[k] = state[k];
   }
 
   void NodeVelocity(const double* X, int node, double vel[3]) const override
   {
      const double* state = m_core.View(X).Velocity(node);
      for (int k = 0; k < 3; k++)
         vel[k] = state[k];
   }
 
   int NumCables() const override { return m_core.NumCables(); }
 
   void CableNodes(int cable, int nodes[2]) const override
   {
      for (int k = 0; k < 2; k++)
         nodes[k] = m_core.Cable(cable).m_conn[k];
   }
 
   environment::wake::PanelEvaluation EvaluatePanel(const double* X, int panel, const double elementVel[3], const double waterVel[3]) const override
   {
      const NetNodeView                  view    = m_core.View(X);
      const int*                         nodes   = m_core.PanelNodes(panel);
      const double*                      posA    = view.Position(nodes[0]);
      const double*                      posB    = view.Position(nodes[1]);
      const double*                      posC    = view.Position(nodes[2]);
      const NetElement3N&                element = m_core.Panel(panel);
      environment::wake::PanelEvaluation evaluation;
      evaluation.load     = element.EvaluatePanelLoad(m_core.PanelHydrodynamics().law, m_core.PanelHydrodynamics().fluid, posA, posB, posC, elementVel, waterVel, evaluation.area);
      evaluation.solidity = element.WakeSolidity(posA, posB, posC);
      return evaluation;
   }
 
   void CableHydrodynamicForce(double T, const double* X, double force[3]) const override { m_core.CableHydrodynamicForce(T, X, force); }
 
private:
   const NetCore& m_core; 
};