NetSolidity.h

#pragma once
 
#include <cmath>
#include <string>
 
namespace net_solidity
{
 
enum class SolidityModel
{
   Fixed,      
   MeshOpening 
};
 
const SolidityModel kDefaultSolidityModel = SolidityModel::MeshOpening;
 
const double kDefaultKnotFactor = 1.0;
 
inline bool ParseSolidityModel(const std::string& name, SolidityModel& model)
{
   if (name == "Fixed") {
      model = SolidityModel::Fixed;
      return true;
   }
   if (name == "MeshOpening") {
      model = SolidityModel::MeshOpening;
      return true;
   }
   return false;
}
 
template<class T>
T MeshOpeningSolidity(double knotFactor, double twineThickness, double barLength, const T& meshOpeningAngle)
{
   using std::cos;
   using std::sin;
 
   return knotFactor * twineThickness / (barLength * sin(meshOpeningAngle) * cos(meshOpeningAngle));
}
 
struct PanelSolidity
{
   SolidityModel model      = kDefaultSolidityModel; 
   double        fixed      = 0;                     
   double        knotFactor = kDefaultKnotFactor;    
};
 
template<class T>
T Solidity(const PanelSolidity& rule, double twineThickness, double barLength, const T& meshOpeningAngle)
{
   if (rule.model == SolidityModel::Fixed) {
      return T(rule.fixed);
   }
   return MeshOpeningSolidity(rule.knotFactor, twineThickness, barLength, meshOpeningAngle);
}
 
inline double CylinderSolidity(double twineThickness, double barLength, double meshOpeningAngle)
{
   const double coverage = twineThickness / (barLength * std::abs(std::sin(2 * meshOpeningAngle)));
   if (!(coverage < 1.0)) // Also a NaN and a closed mesh (sin 2φ = 0).
      return 1.0;
   return coverage * (2.0 - coverage);
}
 
inline double WakeSolidity(const PanelSolidity& rule, double twineThickness, double barLength, double meshOpeningAngle)
{
   if (rule.model == SolidityModel::Fixed)
      return rule.fixed;
   return CylinderSolidity(twineThickness, barLength, meshOpeningAngle);
}
 
} // namespace net_solidity