NTrawlSpec.h

#ifndef N_TRAWL_SPEC_H
#define N_TRAWL_SPEC_H
 
#include <vector>
//"
#include <sfh/linalg.h>
 
#ifdef FH_VISUALIZATION
    #include "OgreColourValue.h"
#endif
namespace TrawlSpec
{
 
    enum EBottomContact
    {
        BottomContact_ForceP = 0,
        BottomContact_ForceS,
        BottomContact_ForceC,
        BottomContact_DistanceP,
        BottomContact_DistanceS,
        BottomContact_DistanceC
    };
 
    enum ENetExternalNodes_t
    {
        NetExternalNodes_Wing1 = 0,
        NetExternalNodes_Wing2,
        NetExternalNodes_Wing3,
        NetExternalNodes_Wing4,
        NetExternalNodes_Wing5,
        NetExternalNodes_Wing6,
        NetExternalNodes_Wing7,
        NetExternalNodes_Wing8,
        NetExternalNodes_HeadlineSide,
        NetExternalNodes_HeadlineC,
        NetExternalNodes_FishlineSide,
        NetExternalNodes_FishlineC,
        NetExternalNodes_Codend,
        NetExternalNodes_NumNodes,
    };
 
    struct SNetExternalNodes
    {
        std::vector<int> ViPrtNodes;
        std::vector<int> ViStbNodes;
        void Reset()
        {
            ViPrtNodes.clear();
            ViStbNodes.clear();
            ViPrtNodes.resize(NetExternalNodes_NumNodes);
            ViStbNodes.resize(NetExternalNodes_NumNodes);
        };
    };
 
    struct SNetNode_t
    {
        int iConn;
        sfh::linalg::Vec2   SMeshPos;
 
        SNetNode_t()
        {
            iConn = -1;
        }
 
        SNetNode_t(double xPos, double yPos, unsigned long iConnection = (unsigned long) -1)
        {
            iConn       = iConnection;
            SMeshPos.x  = xPos;
            SMeshPos.y  = yPos;
        }
 
        SNetNode_t(const sfh::linalg::Vec2 SMeshPosition, unsigned long iConnection = (unsigned long) -1)
        {
            iConn       = iConnection;
            SMeshPos    = SMeshPosition;
        }
    };
    struct SMeshBar
    {
        double  D;
        double  L;
        double  E;
        double  Rho;
 
        SMeshBar(double diam = 0, double length = 0, double stiffness = 0, double rho = 0)
        {
            D   = diam;
            L   = length;
            E   = stiffness;
            Rho = rho;
        }
    };
 
    struct SPanelCut
    {
        double  N;
        double  T1;
        double  T2;
        double  T3;
        double  cutN;
        double  cutB;
        double  cutT;
 
        void Reset()
        {
            N       = 0;
            T1      = 0;
            T2      = 0;
            T3      = -1;
            cutN    = 0;
            cutB    = 0;
            cutT    = 0;
        }
        SPanelCut(double N_in = 0, double T1_in = 0, double T2_in = 0, double T3_in = -1, 
            double cutN_in = 0, double cutB_in = 0, double cutT_in = 0)
        {
            N       = N_in;
            T1      = T1_in;
            T2      = T2_in;
            T3      = T3_in;
            cutN    = cutN_in;
            cutB    = cutB_in;
            cutT    = cutT_in;
        }
    };
 
    struct SNetSection
    {
        int         ID;
        SMeshBar    Bar;    
        SPanelCut   Cutting;
        double      reinforcementRatio;
        double      refineFactor;
        bool        IsOtherWing;        
#ifdef FH_VISUALIZATION
        Ogre::ColourValue twineColour;
#endif
 
        SNetSection()
        {
            IsOtherWing = false;
        }
 
        double GetThreadArea() const 
        {
            return (Cutting.T1 + Cutting.T2) * Cutting.N * Bar.L * Bar.D; // The knots should *maybe* be accounted for.
        }
    };
 
 
    enum ESectionSide_t
    {
        SectionSide_Front = 0,
        SectionSide_Back,
        SectionSide_Outer,
        SectionSide_Inner,
        SectionSide_T3,
        SectionSide_Upper,
        SectionSide_Lower
    };
 
    enum ESectionNode_t
    {
        SectionNode_FRONTPRT = 0,
        SectionNode_FRONTSTB,
        SectionNode_FRONTCENTER,
        SectionNode_FRONTPRTWING,
        SectionNode_FRONTSTBWING,
        SectionNode_BACKPRT,
        SectionNode_BACKSTB,
        SectionNode_BACKCENTER,
        SectionNode_NUM
    };
 
    enum EPanelEdge_t
    {
        Paneledge_DEFAULT   = 0                 ,
        Paneledge_OTHER                         ,
        Paneledge_PRT       = Paneledge_DEFAULT ,
        Paneledge_STB       = Paneledge_OTHER   ,
        Paneledge_UPPER     = Paneledge_DEFAULT ,
        Paneledge_LOWER     = Paneledge_OTHER   ,
    };
 
    enum EPanel_t
    {
        PANEL_UPPER = 0,
        PANEL_LOWER,
        PANEL_PRTSIDE,
        PANEL_STBSIDE,
        PANEL_SIDE = PANEL_PRTSIDE,
    };
 
    enum EPanelNodes
    {
        PanelNodes_PRT = 0,
        PanelNodes_STB,
        PanelNodes_CENTER,
        PanelNodes_PRTWING,
        PanelNodes_STBWING,
        PanelNodes_NUMPANELS,
        PanelNodes_UPPER        = PanelNodes_PRT,
        PanelNodes_LOWER        = PanelNodes_STB,
        PanelNodes_UPPERWING    = PanelNodes_PRTWING,
        PanelNodes_LOWERWING    = PanelNodes_STBWING,
    };
 
 
    enum ESectionType_t
    {
        SECTIONTYPE_WING,           // A wing section.
        SECTIONTYPE_BELLY,          // A belly section not connected to wings.
        SECTIONTYPE_SPLITTER,       // A Belly section connected to two wings.
    };
 
    struct SSectionType
    {
        EPanel_t        PanelType;
        ESectionType_t  SectionType;
        int             SectionNumber;
    };
 
    struct SSectionPlacement
    {
        SSectionPlacement()
        {
            sectionNum = 0;
            panel = PANEL_UPPER;
            side = SectionSide_Front;
        }
        int             sectionNum;
        EPanel_t        panel;
        ESectionSide_t  side;
    };
 
    struct SSectionLine_t
    {
        int             sectionNum;
        EPanel_t        panel;
        ESectionSide_t  side;
        double          L;
        double          D;
        double          E;
        double          rho;
        int             nodes[2];
 
    };
 
    struct SNodeSpec
    {
        TrawlSpec::EPanel_t     Panel;
        TrawlSpec::EPanelNodes  NodePlacement;
        int                     Section;
        SNodeSpec(TrawlSpec::EPanel_t PanelIn, TrawlSpec::EPanelNodes NodePlacementIn, int SectionIn)
        {
            Panel = PanelIn;
            NodePlacement = NodePlacementIn;
            Section = SectionIn;
        }
    };
    struct SPosXY
    {
        double x;
        double y;
    };
 
 
    struct SPanelNodes
    {
        std::vector<std::vector<int> >      VViPanelNodes; 
        //std::vector<std::vector<SPosXY> > VVSPanelNodePos; 
        std::vector<std::vector<SPosXY> >   VVSectionNodePos;
 
        bool                bFrontElementIsTriangular;
        bool                bAftElementIsTriangular;
        //int                   iNumConnectedNodes;
        //int                   iAftSection;
        SPanelNodes()
        {
            VViPanelNodes.resize(5);
        }
        void Reset()
        {
            for (int i = 0; i < 5; i++)
            {
                VViPanelNodes[i].clear();
            }
            bFrontElementIsTriangular   = false;
            bAftElementIsTriangular     = false;
            VVSectionNodePos.clear();
            //iNumConnectedNodes            = 0;
            //iAftSection                   = 0;
        }
    };
}
 
#endif