TriangularNetElement.h

#pragma once
 
#include "fish/eigen_matrix_defs.h"
#include "sfh/constants.h"
 
namespace Fish{
 
class TriangularNetElement {
public:
    struct NetData{
        double  CnLinearLimitAngle;     
        double  CnLinear;               
        double  CnTurb;                 
        double  CnLam;                  
        double  TurbLimit;              
        double  LamLimit;               
        double  Ct_nominal;             
        double  CnKnots_nominal;        
        double  DampingCoeff;           
        double  BarD;                   
        double  KnotD;                  
        double  BarL0;                  
        double  NodeAPos_mesh[2];       
        double  NodeBPos_mesh[2];       
        double  NodeCPos_mesh[2];       
        double  TwineEA;                
 
        void SetStandardValues(){
            CnLinearLimitAngle   = 4.0*sfh::pi/180.0;
            CnLinear             = 0.068;
            CnTurb               = 0.8;
            CnLam                = 1.15;
            TurbLimit            = 3.4e5;
            LamLimit             = 2.0e5;
            Ct_nominal           = 0.01;
            CnKnots_nominal      = 1.15;
        }
 
        double CalculateMeshVolume(double NodalDistribution[3] = nullptr){
            vec2 BC = vec2(NodeCPos_mesh)-vec2(NodeBPos_mesh);
            vec2 CA = vec2(NodeAPos_mesh)-vec2(NodeCPos_mesh);
            vec2 AB = vec2(NodeBPos_mesh)-vec2(NodeAPos_mesh);
            double N = std::abs(0.5*(CA.x()*AB.y() - CA.y()*AB.x()));
            double Volume = sfh::pi/4.0*BarD*BarD*BarL0*N;
            if(NodalDistribution){
                vec3 nDist(BC.norm(),CA.norm(),AB.norm());
                double MassDivider = nDist.squaredNorm();
                for(int i = 0; i < 3; ++i){
                    NodalDistribution[i] = nDist(i)*nDist(i)*Volume/MassDivider;
                }
            }
            return Volume;
        }
    };
 
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
    TriangularNetElement(NetData net/*, PointMass* PA, PointMass* PB, PointMass* PC, HorizontalFlowField* FlowField = nullptr*/);
    ~TriangularNetElement();
 
    //virtual bool ComputeOdeFunction(double Time, ConstVectorMap& States, VectorMap& StatesDot, TripletList& Jacobian);
    //virtual void AddProcessNoise(ConstVectorMap& States, TripletList& ProcessNoise){}
    //virtual void InitialConditionSetup( const double T, const double *const currentIC, double* const updatedIC, ConstVectorMap& CurrentStates, VectorMap& UpdatedStates, ConstMatrixMap& CurrentCovariance, MatrixMap& UpdatedCovariance ){}
    mat3 CalcForces(const mat32& TriangleVectors_ned/*, const vec3& Velocity_ned*/);
    mat3 CalcForces2(const mat32& TriangleVectors_ned);
private:
 
    //vec2 CalcDragCoefficients(const vec2& sin_hydDynAngle, double nominalReynoldsNumber);
    //vec3 CalcHydroDynamicForces(const mat2& MeshUV_panel,const vec3& relativeVelocity_panel);
    //vec3 CalcHydroDynamicForces(const mat2& MeshUV_panel,const vec3& relativeVelocity_panel, mat3& Jacobian);
 
    //PointMass* m_PA;
    //PointMass* m_PB;
    //PointMass* m_PC;
    NetData m_NetData;
 
    // Calculated element properties
    mat23 m_Vertices;           
    mat23 m_EdgeVector;         
    mat23 m_EdgePerpendicular;  
 
    mat2 m_MeshBarConverter;    
    double m_MeshDeterminant;   
    double m_Ct;                
    double m_kKnot;             
    double m_TwineDragNormal;   
    double m_CurrentCd;
 
};
};