NetWakePanels.h

#pragma once
 
#include <fhsim/simobject/ISimObjectCreator.h>
#include <fhsim_environment/EnvironmentProvider.h>
#include <fhsim_environment/PanelSourceSet.h>
#include <string>
 
template<class Net>
class NetWakePanels final : public environment::wake::WakePanelSource
{
public:
   explicit NetWakePanels(const Net& net)
       : m_net(net)
   {
   }
 
   int NumNodes() const override { return m_net.m_numNodesCalc; }
   int NumPanels() const override { return m_net.m_numPanelsCalc; }
 
   void PanelNodes(int panel, int nodes[3]) const override
   {
      for (int k = 0; k < 3; k++)
         nodes[k] = m_net.m_netConn[panel * 3 + k];
   }
 
   void NodePosition(const double* X, int node, double pos[3]) const override
   {
      const double* state = m_net.NodePositionState(X, 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_net.NodeVelocityState(X, node);
      for (int k = 0; k < 3; k++)
         vel[k] = state[k];
   }
 
   int NumCables() const override { return m_net.m_numCablesCalc; }
 
   void CableNodes(int cable, int nodes[2]) const override
   {
      for (int k = 0; k < 2; k++)
         nodes[k] = m_net.m_VpCableElements[cable]->m_conn[k];
   }
 
   environment::wake::PanelEvaluation EvaluatePanel(const double* X, int panel, const double elementVel[3], const double waterVel[3]) const override
   {
      int nodes[3];
      PanelNodes(panel, nodes);
      const double*                      posA    = m_net.NodePositionState(X, nodes[0]);
      const double*                      posB    = m_net.NodePositionState(X, nodes[1]);
      const double*                      posC    = m_net.NodePositionState(X, nodes[2]);
      const auto&                        element = *m_net.m_VpNetElements[panel];
      environment::wake::PanelEvaluation evaluation;
      evaluation.load     = element.EvaluatePanelLoad(m_net.m_panelHydrodynamics.law, m_net.m_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_net.CableHydrodynamicForce(T, X, force); }
 
private:
   const Net& m_net; 
};
 
namespace net_wake_panels
{
 
inline environment::EnvironmentProvider* FindEnvironment(ISimObjectCreator* creator, const std::string& className)
{
   auto* environment = static_cast<environment::EnvironmentProvider*>(creator->GetSharedResource("Environment"));
   if (!environment)
      creator->ReportError("No Environment shared resource found: " + className + " cannot continue without its current, waves and wakes");
   return environment;
}
 
} // namespace net_wake_panels