NetSpecReport.h

#pragma once
 
#include "CTrawlNetAssembler.h"
#include "SCableSectionData.h"
 
#include <array>
#include <marenv/marenv.h>
#include <string>
#include <utility>
#include <vector>
 
namespace netspec
{
namespace report
{
constexpr double kRhoWater = marenv::seawaterDensity;
constexpr double kGravity  = marenv::gravity;
 
// The thresholds of the warnings; README, "trawlwriter report", explains each.
constexpr double kMaxLineToEdge = 1.1;
constexpr double kMinLineToEdge = 0.2;
constexpr double kMaxJoinMismatch = 0.1;
constexpr double kPointEdge = 20;
constexpr double kMeantAsPoint = 5;
constexpr double kMaxElementMeshes = 200;
 
struct NetTotals
{
    double twineLength         = 0; 
    double twineWeightInWater  = 0; 
    int numFloats              = 0;
    int numSinkingFloats       = 0; 
    double floatBuoyancy       = 0; 
    int numBobbins             = 0;
    double bobbinWeightInWater = 0; 
    double stretchedArea       = 0; 
    double squareMeshArea      = 0; 
    double solidity            = 0; 
    int elements               = 0; 
    int nodes                  = 0;
    int cables                 = 0; 
    int refinedElements        = 0; 
    int refinedNodes           = 0;
    int refinedCables          = 0;
};
 
struct Point
{
    double x;
    double y;
};
 
Point Along(Point a, Point b, double fraction);
 
struct SectionShape
{
    int number          = 0;     
    bool mirrored       = false; 
    TrawlSpec::ESectionType_t type = TrawlSpec::SECTIONTYPE_BELLY;
    double refine       = 1;
    std::array<Point, TrawlSpec::SectionNode_NUM> corners {};
    std::array<int, TrawlSpec::SectionNode_NUM> nodes {};
};
 
struct PanelShape
{
    TrawlSpec::EPanel_t panel  = TrawlSpec::PANEL_UPPER;
    int aftMost     = 0; 
    int behindWings = 0; 
    int wings       = 0; 
    std::vector<SectionShape> sections;
 
    const SectionShape* Copy(int index) const
    {
        const int copy = index + wings;
        return sections[index].type == TrawlSpec::SECTIONTYPE_WING && copy < static_cast<int>(sections.size()) ? &sections[copy] : nullptr;
    }
};
 
struct LineEdge
{
    std::vector<std::pair<Point, Point>> segments;
    bool divided     = false;
    double stretched = 0; 
};
 
struct Item
{
    bool isFloat;
    double size;     
    double at;       
    int segment;     
    double fraction; 
};
 
std::vector<Item> ItemsOf(const SCableSectionData& line, bool divided);
 
double SphereVolume(double d);
 
double DiskVolume(double d, double thickness);
 
bool IsRefined(CTrawlNetAssembler& net);
 
std::string Fixed(double value, int decimals);
 
std::string Trimmed(double value, int decimals);
 
std::string PanelName(TrawlSpec::EPanel_t panel);
 
std::string SideName(TrawlSpec::ESectionSide_t side);
 
} // namespace report
 
struct NetSpecReport
{
    CTrawlNetAssembler net; 
    std::string name;       
    report::NetTotals totals;
    std::vector<std::string> warnings;
    std::vector<report::PanelShape> panels; 
    std::vector<std::vector<std::pair<SCableSectionData, report::LineEdge>>> panelLines;
};
 
NetSpecReport MakeNetSpecReport(const std::string& specPath);
} // namespace netspec