CTrawlNetAssembler.h

 
#ifndef C_TRAWL_NET_ASSEMBLER_H
#define C_TRAWL_NET_ASSEMBLER_H
 
#include "CModelWriter.h"
#include "CTrawlNetPrinter.h"
#include "CTrawlNetSpec.h"
#include "SCableSectionData.h"
#include "SNetPanel.h"
#include "net/NetElementDef.h"
#include "net/NTrawlSpec.h"
#include "net/SNetSectionData.h"
 
#include <assert.h>
#include <float.h>
#include <limits.h>
#include <vector>
#include <set>
#include <string>
 
 
class CTrawlNetAssembler : public CTrawlNetSpec, public CModelWriter
{
public:
    CTrawlNetAssembler(std::string outDir, std::string sNetName,bool usePlaceholders = false);
 
    ~CTrawlNetAssembler(void);
 
    void ResetOutput(bool bResetError);
 
    void ClearOutput();
 
    void CreatePanelDefinitions();
 
    bool SetRefineFactor(double dRefineFactor);
   
 
    bool SetRefineFactor(TrawlSpec::EPanel_t EPanel, int iSecNo, double dRefineFactor);
 
    double GetScale();
 
    void SetScale(double dScale);
 
    void Scale(double dScaleMultiplier);
 
    void SetMaxNumPanels(int iMaxNumPanels);
 
    void SetMaxEdgeLengthFactor(double dEdgeLengthFactor);
 
    void SetAdaptation(double dMaxStepLength, double dAdaptationPeriod = 0,
        double dMeanCableTension = 0, double dStepSafetyFactor = 50);
 
    int GetNumOriginalNodes();
 
    struct SNetSimOptions
    {
        int NumNodes; 
        int NumPanels; 
        int NumCables; 
        double MaxElementLength; 
        double MinElementLength; 
        int MaxNumNodes; 
        int MaxNumPanels; 
        int MaxNumCables; 
        double MaxElementLengthFactor; 
        int NumExternalNodes; 
        double MinCableLength; 
        double MaxCableTension; 
 
        SNetSimOptions(); 
    };
 
    struct SNetIntegratorOptions
    {
        double MaxStepLength; 
        double AdaptationPeriod; 
        double StepSafetyFactor; 
        double MeanCableTension; 
        SNetIntegratorOptions();
    };
 
    SNetSimOptions GetSimoptions();
 
    struct SLineVisualizationOptions
    {
        std::string sMaterial;
        double DrawScale;
    };
 
    virtual std::string ToFile(std::string filename = "");
 
    std::string NetText();
 
    std::string LibLine(const std::string& fileName);
 
    std::vector<std::string> NodesInputForce();
 
    std::vector<std::string> NodesOutputPosAndVel();
 
    void SetWriteSideFiles(bool write) { m_writeSideFiles = write; }
 
 
    const std::vector<TrawlSpec::SPanelNodes>& PanelNodes() const { return m_VSNodes; }
 
    const std::vector<NetElementDef>& NetElements() const { return m_VSNetSections; }
 
    const std::vector<SCableSectionData>& SimulationLines() const { return m_VSSimLines; }
 
    const TrawlSpec::SNetExternalNodes& ExternalNodes() const { return m_SExternalNodes; }
 
    void SectionSpecToFile(std::string sSectionSpecFileName);
 
protected:
    friend class CTrawlNetPrinter;
 
    void SetSimOptions();
 
    void CreatePanelNodes();
 
    void CreateUnconnectedPanelNodes();
 
    void ConnectPanelNodes();
 
    TrawlSpec::SPanelNodes CreateUnconnectedPanelNodes(TrawlSpec::EPanel_t EWhichPanel, int& iNextNode);
 
    void ConnectNodes(std::vector<TrawlSpec::SNodeSpec> VSConn);
 
    void ConnectNodes(TrawlSpec::SNodeSpec SConn1, TrawlSpec::SNodeSpec SConn2);
 
    void ConnectNodes(TrawlSpec::EPanel_t Panel1, TrawlSpec::EPanelNodes NodePlacement1, int Section1,
        TrawlSpec::EPanel_t Panel2, TrawlSpec::EPanelNodes NodePlacement2, int Section2);
 
    bool IsSectionConnected(TrawlSpec::EPanel_t EWhichPanel, TrawlSpec::EPanelEdge_t EWhichEdge,
        int iGlobalSection);
 
    bool SetNodeNumber(TrawlSpec::SNodeSpec SNode, int iNodeNum);
 
    int GetNodeNumber(TrawlSpec::SNodeSpec SNode);
 
    std::vector<int> FindUnUsedNodes();
 
    void CondenseNodes(std::vector<int> ViUnUsedNodes);
 
    void MakeAllNodesCW();
 
    void CreateCableElements();
 
    bool VerifyCableNodes();
 
    void CreateSimulationElements(TrawlSpec::EPanel_t EWhichPanel);
 
    void CreateNodePosXY(TrawlSpec::EPanel_t EWhichPanel);
 
    void CreateNodeNumbers();
 
    void AssignNodeNumbers(TrawlSpec::EPanel_t EWhichPanel, int iSecNo, int iElementNo,
        NetElementDef* pNetElement);
 
    std::vector<int> FindEdgeNodes(int iSecNo, TrawlSpec::EPanel_t EWhichPanel, TrawlSpec::ESectionSide_t EWhichSide, bool* pbDivide);
 
    std::vector<int> FindEdgeNodesHP(int iSecNo, TrawlSpec::ESectionSide_t EWhichSide, TrawlSpec::EPanel_t EWhichPanel, bool* pbDivide);
 
    std::vector<int> FindEdgeNodesSP(int iSecNo, TrawlSpec::ESectionSide_t EWhichSide, bool* pbDivide);
 
    sfh::linalg::Vec2 GetNodePosUV(TrawlSpec::EPanel_t EWhichPanel, TrawlSpec::ESectionNode_t EWhichNode, int iSec);
 
    TrawlSpec::SPosXY GetNodePosXY(TrawlSpec::EPanel_t EWhichPanel,
        TrawlSpec::ESectionNode_t EWhichNode,
        int iSec);
 
    void SetExternalNodes();
 
    int ReplaceNodes(int iOldNode, int iNewNode);
 
    std::vector<std::string> CreateNodeStringsFromIndices(std::set<TrawlSpec::ENetExternalNodes_t> ViExternalConnections);
 
    std::vector<NetElementDef> m_VSNetSections; 
    std::vector<TrawlSpec::SPanelNodes> m_VSNodes; 
 
    bool m_bAllNodesCW; 
    SNetSimOptions m_SimOptions; 
    double m_Scale; 
    SNetIntegratorOptions m_IntegratorOptions; 
    SLineVisualizationOptions m_SCableVisOptions; 
    std::vector<SCableSectionData> m_VSSimLines; 
    std::vector<std::vector<TrawlSpec::SNodeSpec>> m_VVSConnectedNodes;
 
    TrawlSpec::SNetExternalNodes m_SExternalNodes;
    bool m_writeSideFiles = true; 
};
 
#endif