FileIO::GMSH::GMSHPolygonTree Class Reference

Detailed Description

Definition at line 28 of file GMSHPolygonTree.h.

#include <GMSHPolygonTree.h>

Inheritance diagram for FileIO::GMSH::GMSHPolygonTree:

Collaboration diagram for FileIO::GMSH::GMSHPolygonTree:

Public Member Functions
	GMSHPolygonTree (GeoLib::PolygonWithSegmentMarker *polygon, GMSHPolygonTree *parent, GeoLib::GEOObjects &geo_objs, std::string const &geo_name, GMSHMeshDensityStrategy &mesh_density_strategy)
	~GMSHPolygonTree () override
void	markSharedSegments ()
bool	insertStation (GeoLib::Point const *station)
void	insertPolyline (GeoLib::PolylineWithSegmentMarker *ply)
void	initMeshDensityStrategy ()
void	createGMSHPoints (std::vector< GMSHPoint * > &gmsh_pnts) const
virtual void	writeLineLoop (std::size_t &line_offset, std::size_t &sfc_offset, std::ostream &out, bool const write_physical) const
void	writeSubPolygonsAsLineConstraints (std::size_t &line_offset, std::size_t sfc_number, std::ostream &out) const
virtual void	writeLineConstraints (std::size_t &line_offset, std::size_t sfc_number, std::ostream &out) const
void	writeStations (std::size_t &pnt_id_offset, std::size_t sfc_number, std::ostream &out) const
void	writeAdditionalPointData (std::size_t &pnt_id_offset, std::size_t sfc_number, std::ostream &out) const
Public Member Functions inherited from GeoLib::SimplePolygonTree
	SimplePolygonTree (Polygon *polygon, SimplePolygonTree *parent)
virtual	~SimplePolygonTree ()
bool	isRoot () const
bool	isPolygonInside (const SimplePolygonTree *polygon_hierarchy) const
void	insertSimplePolygonTree (SimplePolygonTree *polygon_hierarchy)
Polygon const &	polygon () const
Polygon &	polygon ()
const SimplePolygonTree *	parent () const
std::size_t	getNumberOfChildren () const
decltype(_children) ::const_iterator	begin () const
decltype(_children) ::const_iterator	end () const

Private Member Functions
void	getPointsFromSubPolygons (std::vector< GeoLib::Point const * > &pnts) const
void	getStationsInsideSubPolygons (std::vector< GeoLib::Point const * > &stations) const
void	checkIntersectionsSegmentExistingPolylines (GeoLib::PolylineWithSegmentMarker *ply, GeoLib::Polyline::SegmentIterator const &seg_it)

Private Attributes
GeoLib::GEOObjects &	_geo_objs
std::string const &	_geo_name
std::vector< GeoLib::Point const * >	_stations
std::vector< GeoLib::PolylineWithSegmentMarker * >	_plys
std::vector< GMSHLine * >	_gmsh_lines_for_constraints
GMSHMeshDensityStrategy &	_mesh_density_strategy

Constructor & Destructor Documentation

GMSHPolygonTree()

FileIO::GMSH::GMSHPolygonTree::GMSHPolygonTree	(	GeoLib::PolygonWithSegmentMarker *	polygon,
		GMSHPolygonTree *	parent,
		GeoLib::GEOObjects &	geo_objs,
		std::string const &	geo_name,
		GMSHMeshDensityStrategy &	mesh_density_strategy )

Definition at line 23 of file GMSHPolygonTree.cpp.

    : GeoLib::SimplePolygonTree(polygon, parent),
      _geo_objs(geo_objs),
      _geo_name(geo_name),
      _mesh_density_strategy(mesh_density_strategy)
{
}

References GMSHPolygonTree(), GeoLib::SimplePolygonTree::SimplePolygonTree(), _geo_name, _geo_objs, _mesh_density_strategy, GeoLib::SimplePolygonTree::parent(), and GeoLib::SimplePolygonTree::polygon().

Referenced by GMSHPolygonTree(), createGMSHPoints(), getPointsFromSubPolygons(), getStationsInsideSubPolygons(), insertPolyline(), insertStation(), and writeSubPolygonsAsLineConstraints().

~GMSHPolygonTree()

FileIO::GMSH::GMSHPolygonTree::~GMSHPolygonTree ( )

override

Definition at line 35 of file GMSHPolygonTree.cpp.

{
    // the polylines are processed also by the children, but the root is
    // responsible to cleanup up
    if (isRoot())
    {  // root
        BaseLib::cleanupVectorElements(_plys);
    }
}

References _plys, BaseLib::cleanupVectorElements(), and GeoLib::SimplePolygonTree::isRoot().

Member Function Documentation

checkIntersectionsSegmentExistingPolylines()

void FileIO::GMSH::GMSHPolygonTree::checkIntersectionsSegmentExistingPolylines ( GeoLib::PolylineWithSegmentMarker * ply, GeoLib::Polyline::SegmentIterator const & seg_it )

private

Definition at line 205 of file GMSHPolygonTree.cpp.

{
    std::size_t const ply_segment_number(seg_it.getSegmentNumber());
    for (GeoLib::PolylineWithSegmentMarker* const p : _plys)
    {
        GeoLib::PointVec& pnt_vec(*(_geo_objs.getPointVecObj(_geo_name)));
        for (auto seg_it_p(p->begin()); seg_it_p != p->end(); ++seg_it_p)
        {
            GeoLib::Point s;  // intersection point
            if (GeoLib::lineSegmentIntersect(*seg_it, *seg_it_p, s))
            {
                const std::size_t pnt_vec_size(pnt_vec.size());
                // point id of new point in GEOObjects instance
                const std::size_t pnt_id(
                    pnt_vec.push_back(new GeoLib::Point(s)));
                if (pnt_vec_size < pnt_vec.size())
                {  // case: new point
                    // modify polyline already in this node
                    p->insertPoint(seg_it_p.getSegmentNumber() + 1, pnt_id);
                    // modify polyline
                    ply->insertPoint(ply_segment_number + 1, pnt_id);
                }
                else
                {  // case: point exists already in geometry
                    // check if point is not already in polyline p
                    std::size_t const k(seg_it_p.getSegmentNumber());
                    if (p->getPointID(k) != pnt_id &&
                        p->getPointID(k + 1) != pnt_id)
                    {
                        p->insertPoint(k + 1, pnt_id);
                    }
                    // check if point is not already in polyline ply
                    if (ply->getPointID(ply_segment_number) != pnt_id &&
                        ply->getPointID(ply_segment_number + 1) != pnt_id)
                    {
                        ply->insertPoint(ply_segment_number + 1, pnt_id);
                    }
                }
            }
        }
    }
}

References _geo_name, _geo_objs, _plys, GeoLib::Polyline::getPointID(), GeoLib::Polyline::SegmentIterator::getSegmentNumber(), GeoLib::PolylineWithSegmentMarker::insertPoint(), GeoLib::lineSegmentIntersect(), GeoLib::PointVec::push_back(), and GeoLib::TemplateVec< T >::size().

Referenced by insertPolyline().

createGMSHPoints()

void FileIO::GMSH::GMSHPolygonTree::createGMSHPoints

(

std::vector< GMSHPoint * > &

gmsh_pnts

)

const

Method creates the gmsh point data structures - including the mesh density.

Parameters

gmsh_pnts

a vector of pointers to instances of class GMSHPoint

Definition at line 284 of file GMSHPolygonTree.cpp.

{
    const std::size_t n_pnts_polygon(polygon().getNumberOfPoints());
    for (std::size_t k(0); k < n_pnts_polygon - 1; k++)
    {
        const std::size_t id(polygon().getPointID(k));
        GeoLib::Point const* const pnt(polygon().getPoint(k));
        // if this point was already part of another polyline
        if (gmsh_pnts[id] != nullptr)
        {
            continue;
        }
        gmsh_pnts[id] = new GMSHPoint(
            *pnt, id, _mesh_density_strategy.getMeshDensityAtPoint(pnt));
    }
 
    const std::size_t n_plys(_plys.size());
    std::stringstream error_messages;
    error_messages.precision(std::numeric_limits<double>::max_digits10);
    for (std::size_t k(0); k < n_plys; k++)
    {
        const std::size_t n_pnts_in_ply(_plys[k]->getNumberOfPoints());
        for (std::size_t j(0); j < n_pnts_in_ply; j++)
        {
            if (polygon().isPntInPolygon(*(_plys[k]->getPoint(j))))
            {
                const std::size_t id(_plys[k]->getPointID(j));
                // if this point was already part of another polyline
                if (gmsh_pnts[id] != nullptr)
                {
                    continue;
                }
                GeoLib::Point const* const pnt(_plys[k]->getPoint(j));
                gmsh_pnts[id] = new GMSHPoint(
                    *pnt, id,
                    _mesh_density_strategy.getMeshDensityAtPoint(pnt));
            }
            else
            {
                auto const& p = *(_plys[k]->getPoint(j));
                error_messages << "\n\tpoint with id " << p.getID()
                               << " and coordinates (" << p[0] << ", " << p[1]
                               << ", " << p[2]
                               << ") is outside of the polygon.";
            }
        }
    }
    if (!parent())
    {
        auto const error_message = error_messages.str();
        if (!error_message.empty())
        {
            OGS_FATAL("{}", error_message);
        }
    }
 
    // walk through children
    for (auto* child : *this)
    {
        dynamic_cast<GMSHPolygonTree*>(child)->createGMSHPoints(gmsh_pnts);
    }
}

References GMSHPolygonTree(), _mesh_density_strategy, _plys, createGMSHPoints(), OGS_FATAL, GeoLib::SimplePolygonTree::parent(), and GeoLib::SimplePolygonTree::polygon().

Referenced by createGMSHPoints().

getPointsFromSubPolygons()

void FileIO::GMSH::GMSHPolygonTree::getPointsFromSubPolygons ( std::vector< GeoLib::Point const * > & pnts ) const

private

Definition at line 497 of file GMSHPolygonTree.cpp.

{
    for (auto const* child : *this)
    {
        dynamic_cast<GMSHPolygonTree const*>(child)->getPointsFromSubPolygons(
            pnts);
    }
}

References GMSHPolygonTree(), and getPointsFromSubPolygons().

Referenced by getPointsFromSubPolygons(), and initMeshDensityStrategy().

getStationsInsideSubPolygons()

void FileIO::GMSH::GMSHPolygonTree::getStationsInsideSubPolygons ( std::vector< GeoLib::Point const * > & stations ) const

private

Definition at line 507 of file GMSHPolygonTree.cpp.

{
    const std::size_t n_stations(_stations.size());
    for (std::size_t k(0); k < n_stations; k++)
    {
        stations.push_back(_stations[k]);
    }
 
    for (auto const* child : *this)
    {
        dynamic_cast<GMSHPolygonTree const*>(child)
            ->getStationsInsideSubPolygons(stations);
    }
}

References GMSHPolygonTree(), _stations, and getStationsInsideSubPolygons().

Referenced by getStationsInsideSubPolygons(), and initMeshDensityStrategy().

initMeshDensityStrategy()

void FileIO::GMSH::GMSHPolygonTree::initMeshDensityStrategy

(

)

Initialize the mesh density strategy with data. In case of GMSHAdaptiveMeshDensity an instance of class QuadTree will be set up with the points within the top level bounding polygon.

Definition at line 250 of file GMSHPolygonTree.cpp.

{
    if (auto* adaptive_mesh_density =
            dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
    {
        // collect points
        std::vector<GeoLib::Point const*> pnts;
        const std::size_t n_pnts_polygon(polygon().getNumberOfPoints());
        for (std::size_t k(0); k < n_pnts_polygon; k++)
        {
            pnts.push_back(polygon().getPoint(k));
        }
        getPointsFromSubPolygons(pnts);
 
        const std::size_t n_plys(_plys.size());
        for (std::size_t k(0); k < n_plys; k++)
        {
            const std::size_t n_pnts_in_kth_ply(_plys[k]->getNumberOfPoints());
            for (std::size_t j(0); j < n_pnts_in_kth_ply; j++)
            {
                pnts.push_back(_plys[k]->getPoint(j));
            }
        }
 
        // give collected points to the mesh density strategy
        adaptive_mesh_density->initialize(pnts);
        // insert constraints
        adaptive_mesh_density->addPoints(_stations);
        std::vector<GeoLib::Point const*> stations;
        getStationsInsideSubPolygons(stations);
        adaptive_mesh_density->addPoints(stations);
    }
}

References _mesh_density_strategy, _plys, _stations, getPointsFromSubPolygons(), getStationsInsideSubPolygons(), and GeoLib::SimplePolygonTree::polygon().

insertPolyline()

void FileIO::GMSH::GMSHPolygonTree::insertPolyline

(

GeoLib::PolylineWithSegmentMarker *

ply

)

If at least one (end) point (of a line segment) of the polyline is inside the polygon the polyline is inserted to the internal vector of polylines.

Intersection points are inserted into the points vector the polygon and the polyline are based on. The id of the intersection point is inserted in both the polygon and the polyline, i.e. the two intersecting line segments are splitt into four line segment.

Line segments of the polyline that are completely within the polygon are inserted into the internal vector _gmsh_lines_for_constraints. The children of this GMSHPolygonTree node are checked recursively.

Parameters

ply	the polyline that should be inserted

Definition at line 95 of file GMSHPolygonTree.cpp.

{
    if (!polygon().isPartOfPolylineInPolygon(*ply))
    {
        return;
    }
 
    // check if polyline segments are inside of the polygon, intersect the
    // polygon or are part of the boundary of the polygon
    for (auto* child : *this)
    {
        dynamic_cast<GMSHPolygonTree*>(child)->insertPolyline(ply);
    }
 
    // calculate possible intersection points between the node polygon and the
    // given polyline ply
    // pay attention: loop bound is not fix!
    GeoLib::Point tmp_pnt;
    GeoLib::PointVec& pnt_vec(*(_geo_objs.getPointVecObj(_geo_name)));
    for (auto segment_it(ply->begin()); segment_it != ply->end(); ++segment_it)
    {
        if (ply->isSegmentMarked(segment_it.getSegmentNumber()))
        {
            continue;
        }
 
        if (polygon().containsSegment(*segment_it))
        {
            ply->markSegment(segment_it.getSegmentNumber(), true);
            continue;
        }
 
        std::size_t seg_num(0);
        GeoLib::Point intersection_pnt;
        while (polygon().getNextIntersectionPointPolygonLine(
            *segment_it, intersection_pnt, seg_num))
        {
            // insert the intersection point to point vector of GEOObjects
            // instance
            const std::size_t pnt_vec_size(pnt_vec.size());
            std::size_t pnt_id(
                pnt_vec.push_back(new GeoLib::Point(intersection_pnt)));
            if (pnt_vec_size < pnt_vec.size())
            {  // case: new point
                // modify the polygon
                polygon().insertPoint(seg_num + 1, pnt_id);
                // modify the polyline
                ply->insertPoint(segment_it.getSegmentNumber(), pnt_id);
            }
            else
            {  // case: existing point
                // check if point id is within the polygon
                if (!polygon().isPointIDInPolyline(pnt_id))
                {
                    polygon().insertPoint(seg_num + 1, pnt_id);
                }
 
                // check if point id is in polyline
                if (!ply->isPointIDInPolyline(pnt_id))
                {
                    ply->insertPoint(segment_it.getSegmentNumber() + 1, pnt_id);
                }
            }
 
            std::size_t tmp_seg_num(seg_num + 1);
            if (!polygon().getNextIntersectionPointPolygonLine(
                    *segment_it, tmp_pnt, tmp_seg_num))
            {
                // check a point of the segment except the end points
                for (std::size_t i(0); i < 3; i++)
                {
                    tmp_pnt[i] = ((*segment_it).getBeginPoint()[i] +
                                  (*segment_it).getEndPoint()[i]) /
                                 2;
                }
                if (polygon().isPntInPolygon(tmp_pnt))
                {
                    ply->markSegment(segment_it.getSegmentNumber(), true);
                    // insert line segment as constraint
                    _gmsh_lines_for_constraints.push_back(
                        new GMSHLine((*segment_it).getBeginPoint().getID(),
                                     (*segment_it).getEndPoint().getID()));
                }
            }
            seg_num++;
 
            // check a point of the segment except the end points
            for (std::size_t i(0); i < 3; i++)
            {
                tmp_pnt[i] = ((*segment_it).getBeginPoint()[i] +
                              (*segment_it).getEndPoint()[i]) /
                             2;
            }
 
            checkIntersectionsSegmentExistingPolylines(ply, segment_it);
 
            if (polygon().isPntInPolygon(tmp_pnt))
            {
                ply->markSegment(segment_it.getSegmentNumber(), true);
                // insert line segment as constraint
                _gmsh_lines_for_constraints.push_back(
                    new GMSHLine((*segment_it).getBeginPoint().getID(),
                                 (*segment_it).getEndPoint().getID()));
            }
        }
    }
 
    _plys.push_back(ply);
}

References GMSHPolygonTree(), _geo_name, _geo_objs, _gmsh_lines_for_constraints, _plys, GeoLib::Polyline::begin(), checkIntersectionsSegmentExistingPolylines(), GeoLib::Polyline::end(), GeoLib::Polyline::insertPoint(), GeoLib::PolylineWithSegmentMarker::insertPoint(), insertPolyline(), GeoLib::Polyline::isPointIDInPolyline(), GeoLib::PolylineWithSegmentMarker::isSegmentMarked(), GeoLib::PolylineWithSegmentMarker::markSegment(), GeoLib::SimplePolygonTree::polygon(), GeoLib::PointVec::push_back(), and GeoLib::TemplateVec< T >::size().

Referenced by insertPolyline().

insertStation()

bool FileIO::GMSH::GMSHPolygonTree::insertStation

(

GeoLib::Point const *

station

)

If the station point is inside the polygon, the method inserts the station into the internal vector of stations. This method works recursive!

Parameters

station

the station point

Returns

true if the station is inside the polygon

Definition at line 68 of file GMSHPolygonTree.cpp.

{
    if (polygon().isPntInPolygon(*station))
    {
        // try to insert station into the child nodes
        for (auto* child : *this)
        {
            if (child->polygon().isPntInPolygon(*station))
            {
                bool rval(dynamic_cast<GMSHPolygonTree*>(child)->insertStation(
                    station));
                // stop recursion if sub SimplePolygonTree is a leaf
                if (rval && child->getNumberOfChildren() == 0)
                {
                    _stations.push_back(station);
                }
                return rval;
            }
        }
        // station did not fit into child nodes -> insert the station into this
        // node
        _stations.push_back(station);
        return true;
    }
    return false;
}

References GMSHPolygonTree(), _stations, insertStation(), and GeoLib::SimplePolygonTree::polygon().

Referenced by insertStation().

markSharedSegments()

void FileIO::GMSH::GMSHPolygonTree::markSharedSegments

(

)

Mark the segments shared by several polygons.

Definition at line 45 of file GMSHPolygonTree.cpp.

{
    if (isRoot())
    {
        return;
    }
 
    for (auto& child : *this)
    {
        std::size_t const n_pnts(child->polygon().getNumberOfPoints());
        for (std::size_t k(1); k < n_pnts; k++)
        {
            if (GeoLib::containsEdge(parent()->polygon(),
                                     polygon().getPointID(k - 1),
                                     polygon().getPointID(k)))
            {
                static_cast<GeoLib::PolygonWithSegmentMarker&>(polygon())
                    .markSegment(k, true);
            }
        }
    }
}

References GeoLib::containsEdge(), GeoLib::SimplePolygonTree::isRoot(), GeoLib::SimplePolygonTree::parent(), and GeoLib::SimplePolygonTree::polygon().

writeAdditionalPointData()

void FileIO::GMSH::GMSHPolygonTree::writeAdditionalPointData	(	std::size_t &	pnt_id_offset,
		std::size_t	sfc_number,
		std::ostream &	out ) const

Definition at line 452 of file GMSHPolygonTree.cpp.

{
    if (auto const* adaptive_mesh_density =
            dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
    {
        std::vector<GeoLib::Point*> steiner_pnts;
        adaptive_mesh_density->getSteinerPoints(steiner_pnts, 0);
        const std::size_t n(steiner_pnts.size());
        for (std::size_t k(0); k < n; k++)
        {
            if (polygon().isPntInPolygon(*(steiner_pnts[k])))
            {
                out << "Point(" << pnt_id_offset + k << ") = {"
                    << (*(steiner_pnts[k]))[0] << "," << (*(steiner_pnts[k]))[1]
                    << ", 0.0, ";
                out << _mesh_density_strategy.getMeshDensityAtPoint(
                           steiner_pnts[k])
                    << "};\n";
                out << "Point { " << pnt_id_offset + k << " } In Surface { "
                    << sfc_number << " };\n";
            }
            delete steiner_pnts[k];
        }
        pnt_id_offset += n;
    }
 
#ifndef NDEBUG
    if (auto* adaptive_mesh_density =
            dynamic_cast<GMSHAdaptiveMeshDensity*>(&_mesh_density_strategy))
    {
        auto const quad_tree_geo =
            adaptive_mesh_density->getQuadTreeGeometry(_geo_objs);
        std::vector<std::size_t> const& id_map(
            (_geo_objs.getPointVecObj(quad_tree_geo))->getIDMap());
        auto& plys = _geo_objs.getPolylineVecObj(quad_tree_geo)->getVector();
        for (std::size_t k(0); k < plys.size(); k++)
        {
            GeoLib::resetPointIDs(*plys[k], id_map);
        }
    }
#endif
}

References _geo_objs, _mesh_density_strategy, GeoLib::SimplePolygonTree::polygon(), and GeoLib::resetPointIDs().

writeLineConstraints()

void FileIO::GMSH::GMSHPolygonTree::writeLineConstraints ( std::size_t & line_offset, std::size_t sfc_number, std::ostream & out ) const

virtual

Definition at line 383 of file GMSHPolygonTree.cpp.

{
    for (auto polyline : _plys)
    {
        const std::size_t n_pnts(polyline->getNumberOfPoints());
        std::size_t first_pnt_id(polyline->getPointID(0));
        for (std::size_t k(1); k < n_pnts; k++)
        {
            auto const second_pnt_id = polyline->getPointID(k);
            if (polyline->isSegmentMarked(k - 1) &&
                polygon().isPntInPolygon(*(polyline->getPoint(k))) &&
                !GeoLib::containsEdge(polygon(), first_pnt_id, second_pnt_id))
            {
                out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id
                    << "," << second_pnt_id << "};\n";
                out << "Line { " << line_offset + k - 1 << " } In Surface { "
                    << sfc_number << " };\n";
            }
            first_pnt_id = second_pnt_id;
        }
        line_offset += n_pnts;
    }
}

References _plys, GeoLib::containsEdge(), and GeoLib::SimplePolygonTree::polygon().

writeLineLoop()

void FileIO::GMSH::GMSHPolygonTree::writeLineLoop ( std::size_t & line_offset, std::size_t & sfc_offset, std::ostream & out, bool const write_physical ) const

virtual

Definition at line 347 of file GMSHPolygonTree.cpp.

{
    const std::size_t n_pnts(polygon().getNumberOfPoints());
    for (std::size_t k(1), first_pnt_id(polygon().getPointID(0)); k < n_pnts;
         k++)
    {
        std::size_t const second_pnt_id = polygon().getPointID(k);
        out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id << ","
            << second_pnt_id << "};\n";
        first_pnt_id = second_pnt_id;
    }
    out << "Line Loop(" << line_offset + n_pnts - 1 << ") = {";
    for (std::size_t k(0); k < n_pnts - 2; k++)
    {
        out << line_offset + k << ",";
    }
    out << line_offset + n_pnts - 2 << "};\n";
    out << "Plane Surface(" << sfc_offset << ") = {" << line_offset + n_pnts - 1
        << "};\n";
    if (write_physical)
    {
        out << "Physical Curve(" << sfc_offset << ") = {";
        for (std::size_t k(0); k < n_pnts - 2; k++)
        {
            out << line_offset + k << ",";
        }
        out << line_offset + n_pnts - 2 << "};\n";
        out << "Physical Surface(" << sfc_offset << ") = {" << sfc_offset
            << "};\n";
    }
    line_offset += n_pnts;
    sfc_offset++;
}

References GeoLib::Polyline::getPointID(), and GeoLib::SimplePolygonTree::polygon().

writeStations()

void FileIO::GMSH::GMSHPolygonTree::writeStations	(	std::size_t &	pnt_id_offset,
		std::size_t	sfc_number,
		std::ostream &	out ) const

Definition at line 435 of file GMSHPolygonTree.cpp.

{
    for (auto const* station : _stations)
    {
        out << "Point(" << pnt_id_offset << ") = {" << (*station)[0] << ", "
            << (*station)[1] << ", 0.0, "
            << _mesh_density_strategy.getMeshDensityAtStation(station)
            << "}; // Station "
            << static_cast<GeoLib::Station const*>(station)->getName() << " \n";
        out << "Point { " << pnt_id_offset << " } In Surface { " << sfc_number
            << " };\n";
        ++pnt_id_offset;
    }
}

References _mesh_density_strategy, _stations, and getName().

writeSubPolygonsAsLineConstraints()

void FileIO::GMSH::GMSHPolygonTree::writeSubPolygonsAsLineConstraints	(	std::size_t &	line_offset,
		std::size_t	sfc_number,
		std::ostream &	out ) const

Definition at line 409 of file GMSHPolygonTree.cpp.

{
    for (auto* child : *this)
    {
        dynamic_cast<GMSHPolygonTree*>(child)
            ->writeSubPolygonsAsLineConstraints(line_offset, sfc_number, out);
    }
 
    if (!isRoot())
    {
        const std::size_t n_pnts(polygon().getNumberOfPoints());
        std::size_t first_pnt_id(polygon().getPointID(0));
        for (std::size_t k(1); k < n_pnts; k++)
        {
            auto const second_pnt_id = polygon().getPointID(k);
            out << "Line(" << line_offset + k - 1 << ") = {" << first_pnt_id
                << "," << second_pnt_id << "};\n";
            first_pnt_id = second_pnt_id;
            out << "Line { " << line_offset + k - 1 << " } In Surface { "
                << sfc_number << " };\n";
        }
        line_offset += n_pnts;
    }
}

References GMSHPolygonTree(), GeoLib::Polyline::getPointID(), GeoLib::SimplePolygonTree::isRoot(), GeoLib::SimplePolygonTree::polygon(), and writeSubPolygonsAsLineConstraints().

Referenced by writeSubPolygonsAsLineConstraints().

Member Data Documentation

_geo_name

std::string const& FileIO::GMSH::GMSHPolygonTree::_geo_name

private

Definition at line 93 of file GMSHPolygonTree.h.

Referenced by GMSHPolygonTree(), checkIntersectionsSegmentExistingPolylines(), and insertPolyline().

_geo_objs

GeoLib::GEOObjects& FileIO::GMSH::GMSHPolygonTree::_geo_objs

private

Definition at line 92 of file GMSHPolygonTree.h.

Referenced by GMSHPolygonTree(), checkIntersectionsSegmentExistingPolylines(), insertPolyline(), and writeAdditionalPointData().

_gmsh_lines_for_constraints

std::vector<GMSHLine*> FileIO::GMSH::GMSHPolygonTree::_gmsh_lines_for_constraints

private

Definition at line 96 of file GMSHPolygonTree.h.

Referenced by insertPolyline().

_mesh_density_strategy

GMSHMeshDensityStrategy& FileIO::GMSH::GMSHPolygonTree::_mesh_density_strategy

private

Definition at line 98 of file GMSHPolygonTree.h.

Referenced by GMSHPolygonTree(), createGMSHPoints(), initMeshDensityStrategy(), writeAdditionalPointData(), and writeStations().

_plys

std::vector<GeoLib::PolylineWithSegmentMarker*> FileIO::GMSH::GMSHPolygonTree::_plys

private

Definition at line 95 of file GMSHPolygonTree.h.

Referenced by ~GMSHPolygonTree(), checkIntersectionsSegmentExistingPolylines(), createGMSHPoints(), initMeshDensityStrategy(), insertPolyline(), and writeLineConstraints().

_stations

std::vector<GeoLib::Point const*> FileIO::GMSH::GMSHPolygonTree::_stations

private

Definition at line 94 of file GMSHPolygonTree.h.

Referenced by getStationsInsideSubPolygons(), initMeshDensityStrategy(), insertStation(), and writeStations().

---

The documentation for this class was generated from the following files:

• GMSHPolygonTree.h
• GMSHPolygonTree.cpp