NetPanelSetup.h

#pragma once
 
#include "../hydrodynamics/PanelLoadLaw.h"
#include "NetElement3NForces.h"
#include "NetElementDef.h"
#include "NetSolidity.h"
 
#include <algorithm>
#include <fhsim/ISimObjectLogger.h>
#include <fhsim/simobject/ISimObjectCreator.h>
#include <stdexcept>
#include <string>
#include <variant>
#include <vector>
 
namespace net_panel_setup
{
 
struct PanelHydrodynamics
{
   hydrodynamics::PanelLoadLaw law;   
   hydrodynamics::Fluid        fluid; 
};
 
inline PanelHydrodynamics ReadPanelHydrodynamics(ISimObjectCreator* creator, const std::string& structureName)
{
   PanelHydrodynamics hydrodynamics {hydrodynamics::ReadPanelLoadLaw(creator), hydrodynamics::ReadFluid(creator)};
   if (!hydrodynamics::Accepts(hydrodynamics.law, net_element_forces::kFlowReference)) {
      const std::string message = "The HydroModel does not accept the free-stream velocity that " + structureName + " supplies.";
      creator->ReportParameterError("HydroModel", message);
      throw std::invalid_argument(message);
   }
   return hydrodynamics;
}
 
inline net_solidity::PanelSolidity ReadSolidityRule(ISimObjectCreator* creator, double& solidityParameter)
{
   net_solidity::PanelSolidity rule;
   std::string                 modelName;
   creator->GetStringParam("SolidityModel", modelName, "MeshOpening");
   if (!net_solidity::ParseSolidityModel(modelName, rule.model)) {
      const std::string message = "Unknown SolidityModel \"" + modelName + "\"; expected Fixed or MeshOpening.";
      creator->ReportParameterError("SolidityModel", message);
      throw std::invalid_argument(message);
   }
   creator->GetDoubleParam("KnotFactor", &rule.knotFactor, net_solidity::kDefaultKnotFactor);
   creator->GetDoubleParam("Solidity", &solidityParameter, 0.0);
   if (!(rule.knotFactor > 0.0)) {
      const std::string message = "KnotFactor must be positive, not " + std::to_string(rule.knotFactor) + "; the mesh opening solidity would be negative.";
      creator->ReportParameterError("KnotFactor", message);
      throw std::invalid_argument(message);
   }
   if (!(solidityParameter >= 0.0 && solidityParameter < 1.0)) {
      const std::string message = "Solidity must be in (0, 1), or absent, not " + std::to_string(solidityParameter) + ".";
      creator->ReportParameterError("Solidity", message);
      throw std::invalid_argument(message);
   }
   return rule;
}
 
inline net_solidity::PanelSolidity ElementSolidityRule(const net_solidity::PanelSolidity& rule,
      double solidityParameter, const NetElementDef& panel, int element, ISimObjectCreator* creator)
{
   net_solidity::PanelSolidity elementRule = rule;
   if (elementRule.model != net_solidity::SolidityModel::Fixed) {
      return elementRule;
   }
   const bool fromSn = panel.solidity > 0;
   elementRule.fixed = fromSn ? panel.solidity : solidityParameter;
   if (!(elementRule.fixed > 0 && elementRule.fixed < 1)) {
      const std::string element1 = "element " + std::to_string(element + 1);
      const std::string found    = fromSn ? element1 + " has Sn = " + std::to_string(elementRule.fixed) + ", outside (0, 1)."
                                          : (solidityParameter > 0 ? element1 + " has no Sn, and Solidity = " + std::to_string(solidityParameter) + " is outside (0, 1)."
                                                                   : element1 + " has neither.");
      const std::string message  = "SolidityModel Fixed needs the Solidity parameter or an Sn attribute in (0, 1) on every net element; " + found;
      creator->ReportParameterError("Solidity", message);
      throw std::invalid_argument(message);
   }
   return elementRule;
}
 
inline void RequireBarDirections(bool hasBarDirections, int element, ISimObjectCreator* creator)
{
   if (hasBarDirections) {
      return;
   }
   const std::string message = "Net panel " + std::to_string(element + 1) + " has collinear mesh coordinates (zero mesh determinant), so it has no bar directions; every HydroModel needs them.";
   creator->ReportParameterError("HydroModel", message);
   throw std::invalid_argument(message);
}
 
inline void WarnIfSolidityOutsideFitRange(const hydrodynamics::PanelLoadLaw& law,
      std::vector<double> solidities, ISimObjectLogger& logger)
{
   std::sort(solidities.begin(), solidities.end());
   solidities.erase(std::unique(solidities.begin(), solidities.end()), solidities.end());
   for (const double solidity : solidities)
      hydrodynamics::WarnIfOutsideFitRange(law, solidity, logger);
}
 
inline void WarnIfSolidityExtremesOutsideFitRange(const hydrodynamics::PanelLoadLaw& law,
      const std::vector<double>& solidities, ISimObjectLogger& logger)
{
   if (solidities.empty()) {
      return;
   }
   const auto extremes = std::minmax_element(solidities.begin(), solidities.end());
   WarnIfSolidityOutsideFitRange(law, {*extremes.first, *extremes.second}, logger);
}
 
} // namespace net_panel_setup