oomph::TriangleMeshPolygon Class Reference

Class defining a closed polygon for the Triangle mesh generation. More...

#include <unstructured_two_d_mesh_geometry_base.h>

Inheritance diagram for oomph::TriangleMeshPolygon:

Public Member Functions
	TriangleMeshPolygon (const Vector< TriangleMeshCurveSection * > &boundary_polyline_pt, const Vector< double > &internal_point_pt=Vector< double >(0), const bool &is_internal_point_fixed=false)
virtual	~TriangleMeshPolygon ()
	Empty virtual destructor. More...
unsigned	ncurve_section () const
	Number of constituent curves. More...
unsigned	npolyline () const
	Number of constituent polylines. More...
TriangleMeshPolyLine *	polyline_pt (const unsigned &i) const
	Pointer to i-th constituent polyline. More...
TriangleMeshPolyLine *	polyline_pt (const unsigned &i)
	Pointer to i-th constituent polyline. More...
Vector< unsigned >	polygon_boundary_id ()
	Return vector of boundary ids of associated polylines. More...
bool	is_redistribution_of_segments_between_polylines_enabled ()
void	enable_redistribution_of_segments_between_polylines ()
void	disable_redistribution_of_segments_between_polylines ()
bool	can_update_reference_configuration () const
	Test whether curve can update reference. More...
virtual void	reset_reference_configuration ()
bool	is_fixed () const
	Test whether the polygon is fixed or not. More...
void	set_fixed ()
	Set the polygon to be fixed. More...
void	set_unfixed ()
	Set the polygon to be allowed to move (default) More...
Public Member Functions inherited from oomph::TriangleMeshClosedCurve
	TriangleMeshClosedCurve (const Vector< TriangleMeshCurveSection * > &curve_section_pt, const Vector< double > &internal_point_pt=Vector< double >(0), const bool &is_internal_point_fixed=false)
	Constructor prototype. More...
virtual	~TriangleMeshClosedCurve ()
	Empty destructor. More...
unsigned	nvertices () const
	Number of vertices. More...
unsigned	nsegments () const
	Total number of segments. More...
void	output (std::ostream &outfile, const unsigned &n_sample=50)
	Output each sub-boundary at n_sample (default: 50) points. More...
Vector< double >	internal_point () const
	Coordinates of the internal point. More...
Vector< double > &	internal_point ()
	Coordinates of the internal point. More...
void	fix_internal_point ()
void	unfix_internal_point ()
bool	is_internal_point_fixed () const
	Test whether the internal point is fixed. More...
Public Member Functions inherited from oomph::TriangleMeshCurve
	TriangleMeshCurve (const Vector< TriangleMeshCurveSection * > &curve_section_pt)
	Empty constructor. More...
virtual	~TriangleMeshCurve ()
	Empty destructor. More...
unsigned	max_boundary_id ()
	Return max boundary id of associated curves. More...
void	enable_polyline_refinement (const double &tolerance=0.08)
void	set_polyline_refinement_tolerance (const double &tolerance)
double	polyline_refinement_tolerance ()
void	disable_polyline_refinement ()
	Disable refinement of polylines. More...
void	enable_polyline_unrefinement (const double &tolerance=0.04)
void	set_polyline_unrefinement_tolerance (const double &tolerance)
double	polyline_unrefinement_tolerance ()
void	disable_polyline_unrefinement ()
	Disable unrefinement of polylines. More...
virtual TriangleMeshCurveSection *	curve_section_pt (const unsigned &i) const
	Pointer to i-th constituent curve section. More...
virtual TriangleMeshCurveSection *&	curve_section_pt (const unsigned &i)
	Pointer to i-th constituent curve section. More...

Protected Attributes
bool	Enable_redistribution_of_segments_between_polylines
bool	Can_update_configuration
Protected Attributes inherited from oomph::TriangleMeshClosedCurve
Vector< double >	Internal_point_pt
	Vector of vertex coordinates. More...
bool	Is_internal_point_fixed
	Indicate whether the internal point should be updated automatically. More...
Protected Attributes inherited from oomph::TriangleMeshCurve
Vector< TriangleMeshCurveSection * >	Curve_section_pt
	Vector of curve sections. More...

Private Attributes
bool	Polygon_fixed

Detailed Description

Class defining a closed polygon for the Triangle mesh generation.

//////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////

Constructor & Destructor Documentation

TriangleMeshPolygon()

oomph::TriangleMeshPolygon::TriangleMeshPolygon	(	const Vector< TriangleMeshCurveSection * > &	boundary_polyline_pt,
		const Vector< double > &	internal_point_pt = Vector<double>(0),
		const bool &	is_internal_point_fixed = false
	)

Constructor: Specify vector of pointers to TriangleMeshCurveSection that define the boundary of the segments of the polygon. Each TriangleMeshCurveSection has its own boundary ID and can contain multiple (straight-line) segments. For consistency across the various uses of this class, we insist that the closed boundary is represented by at least two separate TriangleMeshCurveSection whose joint vertices must be specified in both. (This is to allow the setup of unique boundary coordinate(s) around the polygon.) This may seem slightly annoying in cases where a polygon really only represents a single boundary, but... Note: The specified vector of pointers must consist of only TriangleMeshPolyLine elements. There is a checking on the PARANOID mode for this constraint

////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////// Constructor: Specify vector of pointers to TriangleMeshCurveSection that define the boundary of the segments of the polygon. Each TriangleMeshCurveSection has its own boundary ID and can contain multiple (straight-line) segments. For consistency across the various uses of this class, we insist that the closed boundary is represented by at least two separate TriangleMeshCurveSection whose joint vertices must be specified in both. (This is to allow the setup of unique boundary coordinate(s) around the polygon.) This may seem slightly annoying in cases where a polygon really only represents a single boundary, but... Note: The specified vector of pointers must consist of only TriangleMeshPolyLine elements. There is a checking on the PARANOID mode for this constraint

    : TriangleMeshCurve(boundary_polyline_pt),
      TriangleMeshClosedCurve(
        boundary_polyline_pt, internal_point_pt, is_internal_point_fixed),
      Enable_redistribution_of_segments_between_polylines(false),
      Can_update_configuration(false),
      Polygon_fixed(false)
  {
    // Get the number of polylines
    const unsigned n_bound = boundary_polyline_pt.size();
 
    // Check that all the constituent TriangleMeshCurveSection are
    // instance of TriangleMeshPolyLine
    for (unsigned p = 0; p < n_bound; p++)
    {
      TriangleMeshPolyLine* tmp_polyline_pt =
        dynamic_cast<TriangleMeshPolyLine*>(boundary_polyline_pt[p]);
      if (tmp_polyline_pt == 0)
      {
        std::ostringstream error_stream;
        error_stream << "The (" << p << ") TriangleMeshCurveSection is not a "
                     << "TriangleMeshPolyLine.\nThe TriangleMeshPolygon object"
                     << "is constituent of only TriangleMeshPolyLine objects.\n"
                     << "Verify that all the constituent elements of the "
                     << "TriangleMeshPolygon\nare instantiated as "
                     << "TriangleMeshPolyLines." << std::endl;
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
    }
 
    // Check that the polylines are contiguous
    bool contiguous = true;
    unsigned i_offensive = 0;
 
    // Need at least two
    if (n_bound < 2)
    {
      std::ostringstream error_stream;
      error_stream
        << "Sorry -- I'm afraid we insist that a closed curve is\n"
        << "specified by at least two separate TriangleMeshPolyLines.\n"
        << "You've only specified (" << n_bound << ")" << std::endl;
      throw OomphLibError(error_stream.str(),
                          "TriangleMeshPolygon::TriangleMeshPolygon()",
                          OOMPH_EXCEPTION_LOCATION);
    } // if (n_bound<2)
 
    // Does the last node of the polyline connect to the first one of the
    // next one (only up the last but one!)
    for (unsigned i = 0; i < n_bound - 1; i++)
    {
      // Get vector last vertex in current polyline
      unsigned last_vertex = (polyline_pt(i)->nvertex()) - 1;
      Vector<double> v1 = polyline_pt(i)->vertex_coordinate(last_vertex);
 
      // Get vector to first vertex in next polyline
      Vector<double> v2 = polyline_pt(i + 1)->vertex_coordinate(0);
 
      // Work out error
      double error = sqrt(pow(v1[0] - v2[0], 2) + pow(v1[1] - v2[1], 2));
 
      // Is error accetable?
      if (error > ToleranceForVertexMismatchInPolygons::Tolerable_error)
      {
        contiguous = false;
        i_offensive = i;
        break;
      }
      // Align
      else
      {
        polyline_pt(i + 1)->vertex_coordinate(0) =
          polyline_pt(i)->vertex_coordinate(last_vertex);
      }
    }
 
    // Does the last one connect to the first one?
 
    // Get vector last vertex last polyline
    unsigned last_vertex = (polyline_pt(n_bound - 1)->nvertex()) - 1;
    Vector<double> v1 =
      polyline_pt(n_bound - 1)->vertex_coordinate(last_vertex);
 
    // Get vector first vertex first polyline
    Vector<double> v2 = polyline_pt(0)->vertex_coordinate(0);
    double error = sqrt(pow(v1[0] - v2[0], 2) + pow(v1[1] - v2[1], 2));
 
    if (error > ToleranceForVertexMismatchInPolygons::Tolerable_error)
    {
      contiguous = false;
      i_offensive = n_bound - 1;
    }
    else
    {
      polyline_pt(0)->vertex_coordinate(0) =
        polyline_pt(n_bound - 1)->vertex_coordinate(last_vertex);
    }
 
    if (!contiguous)
    {
      std::ostringstream error_stream;
      error_stream
        << "The polylines specified \n"
        << "should define a closed geometry, i.e. the first/last vertex of\n"
        << "adjacent polylines should match.\n\n"
        << "Your polyline number " << i_offensive
        << " has no contiguous neighbour, when judged \nwith the tolerance of "
        << ToleranceForVertexMismatchInPolygons::Tolerable_error
        << " which is specified in the namespace \nvariable "
        << "ToleranceForVertexMismatchInPolygons::Tolerable_error.\n\n"
        << "Feel free to adjust this or to recompile the code without\n"
        << "paranoia if you think this is OK...\n"
        << std::endl;
      throw OomphLibError(error_stream.str(),
                          "TriangleMeshPolygon::TriangleMeshPolygon()",
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    // Check if internal point is actually located in bounding polygon
    // Reference: http://paulbourke.net/geometry/insidepoly/
 
    // Only checked if there is an internal hole
    if (!Internal_point_pt.empty())
    {
      // Vertex coordinates
      Vector<Vector<double>> polygon_vertex;
 
      // Total number of vertices
      unsigned nvertex = 0;
 
      // Storage for first/last point on polyline for contiguousness check
      Vector<double> last_vertex(2);
      Vector<double> first_vertex(2);
 
      // Get vertices
      unsigned npolyline = boundary_polyline_pt.size();
      for (unsigned i = 0; i < npolyline; i++)
      {
        // Number of vertices
        unsigned nvert = boundary_polyline_pt[i]->nvertex();
        for (unsigned j = 0; j < nvert; j++)
        {
          // Check contiguousness
          if ((i > 1) && (j == 0))
          {
            first_vertex = polyline_pt(i)->vertex_coordinate(j);
            double dist = sqrt(pow(first_vertex[0] - last_vertex[0], 2) +
                               pow(first_vertex[1] - last_vertex[1], 2));
            if (dist > ToleranceForVertexMismatchInPolygons::Tolerable_error)
            {
              std::ostringstream error_stream;
              error_stream
                << "The start and end points of polylines " << i << " and "
                << i + 1 << " don't match when judged\n"
                << "with the tolerance ("
                << ToleranceForVertexMismatchInPolygons::Tolerable_error
                << ") which is specified in the namespace \nvariable "
                << "ToleranceForVertexMismatchInPolygons::"
                << "Tolerable_error.\n\n"
                << "Feel free to adjust this or to recompile the "
                << "code without\n"
                << "paranoia if you think this is OK...\n"
                << std::endl;
              throw OomphLibError(error_stream.str(),
                                  "TriangleMeshPolygon::TriangleMeshPolygon()",
                                  OOMPH_EXCEPTION_LOCATION);
            }
          }
          // Get vertex (ignore end point)
          if (j < nvert - 1)
          {
            polygon_vertex.push_back(polyline_pt(i)->vertex_coordinate(j));
          }
          // Prepare for check of contiguousness
          else
          {
            last_vertex = polyline_pt(i)->vertex_coordinate(j);
          }
        }
      }
 
      // Total number of vertices
      nvertex = polygon_vertex.size();
 
      // Counter for number of intersections
      unsigned intersect_counter = 0;
 
      // Get first vertex
      Vector<double> p1 = polygon_vertex[0];
      for (unsigned i = 1; i <= nvertex; i++)
      {
        // Get second vertex by wrap-around
        Vector<double> p2 = polygon_vertex[i % nvertex];
 
        if (Internal_point_pt[1] > std::min(p1[1], p2[1]))
        {
          if (Internal_point_pt[1] <= std::max(p1[1], p2[1]))
          {
            if (Internal_point_pt[0] <= std::max(p1[0], p2[0]))
            {
              if (p1[1] != p2[1])
              {
                double xintersect = (Internal_point_pt[1] - p1[1]) *
                                      (p2[0] - p1[0]) / (p2[1] - p1[1]) +
                                    p1[0];
                if ((p1[0] == p2[0]) || (Internal_point_pt[0] <= xintersect))
                {
                  intersect_counter++;
                }
              }
            }
          }
        }
        p1 = p2;
      }
 
      // Even number of intersections: outside
      if (intersect_counter % 2 == 0)
      {
        std::ostringstream error_stream;
        error_stream
          << "The internal point at " << Internal_point_pt[0] << " "
          << Internal_point_pt[1]
          << " isn't in the polygon that describes the internal closed "
          << "curve!\nPolygon vertices are at: \n";
        for (unsigned i = 0; i < nvertex; i++)
        {
          error_stream << polygon_vertex[i][0] << " " << polygon_vertex[i][1]
                       << "\n";
        }
        error_stream
          << "This may be because the internal point is defined by a\n"
          << "GeomObject that has deformed so much that it's \n"
          << "swept over the (initial) internal point.\n"
          << "If so, you should update the position of the internal point. \n"
          << "This could be done automatically by generating \n"
          << "an internal mesh inside the polygon and using one\n"
          << "of its internal nodes as the internal point. Actually not \n"
          << "why triangle doesn't do that automatically....\n";
        throw OomphLibError(error_stream.str(),
                            "TriangleMeshPolygon::TriangleMeshPolygon()",
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
  }

References calibrate::error, i, oomph::TriangleMeshClosedCurve::Internal_point_pt, j, max, min, npolyline(), oomph::TriangleMeshPolyLine::nvertex(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, p, p1, polyline_pt(), Eigen::bfloat16_impl::pow(), sqrt(), oomph::ToleranceForVertexMismatchInPolygons::Tolerable_error, v1(), v2(), and oomph::TriangleMeshPolyLine::vertex_coordinate().

~TriangleMeshPolygon()

virtual oomph::TriangleMeshPolygon::~TriangleMeshPolygon ( )

inlinevirtual

Empty virtual destructor.

{}

Member Function Documentation

can_update_reference_configuration()

bool oomph::TriangleMeshPolygon::can_update_reference_configuration ( ) const

inline

Test whether curve can update reference.

    {
      return Can_update_configuration;
    }

References Can_update_configuration.

disable_redistribution_of_segments_between_polylines()

void oomph::TriangleMeshPolygon::disable_redistribution_of_segments_between_polylines ( )

inline

Disable re-distribution of polyline segments in the curve between different boundaries during adaptation

    {
      Enable_redistribution_of_segments_between_polylines = false;
    }

References Enable_redistribution_of_segments_between_polylines.

enable_redistribution_of_segments_between_polylines()

void oomph::TriangleMeshPolygon::enable_redistribution_of_segments_between_polylines ( )

inline

Enable re-distribution of polyline segments in the curve between different boundaries during adaptation

    {
      Enable_redistribution_of_segments_between_polylines = true;
    }

References Enable_redistribution_of_segments_between_polylines.

is_fixed()

bool oomph::TriangleMeshPolygon::is_fixed ( ) const

inline

Test whether the polygon is fixed or not.

    {
      return Polygon_fixed;
    }

References Polygon_fixed.

is_redistribution_of_segments_between_polylines_enabled()

bool oomph::TriangleMeshPolygon::is_redistribution_of_segments_between_polylines_enabled ( )

inline

Is re-distribution of polyline segments in the curve between different boundaries during adaptation enabled?

    {
      return Enable_redistribution_of_segments_between_polylines;
    }

References Enable_redistribution_of_segments_between_polylines.

ncurve_section()

unsigned oomph::TriangleMeshPolygon::ncurve_section ( ) const

inlinevirtual

Number of constituent curves.

Reimplemented from oomph::TriangleMeshCurve.

    {
      return npolyline();
    }

References npolyline().

Referenced by oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration().

npolyline()

unsigned oomph::TriangleMeshPolygon::npolyline ( ) const

inline

Number of constituent polylines.

    {
      return Curve_section_pt.size();
    }

References oomph::TriangleMeshCurve::Curve_section_pt.

Referenced by oomph::ImmersedRigidBodyTriangleMeshPolygon::assign_zeta(), oomph::ImmersedRigidBodyTriangleMeshPolygon::get_initial_position(), ncurve_section(), polygon_boundary_id(), and TriangleMeshPolygon().

polygon_boundary_id()

Vector<unsigned> oomph::TriangleMeshPolygon::polygon_boundary_id ( )

inline

Return vector of boundary ids of associated polylines.

    {
      // Get the number of polylines
      unsigned nline = npolyline();
      Vector<unsigned> boundary_id(nline);
 
      // Loop over the polyline to get the id
      for (unsigned iline = 0; iline < nline; iline++)
      {
        boundary_id[iline] = Curve_section_pt[iline]->boundary_id();
      }
      return boundary_id;
    }

References oomph::TriangleMeshCurve::Curve_section_pt, and npolyline().

polyline_pt() [1/2]

TriangleMeshPolyLine* oomph::TriangleMeshPolygon::polyline_pt ( const unsigned &  i )

inline

Pointer to i-th constituent polyline.

    {
      TriangleMeshPolyLine* tmp_polyline =
        dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[i]);
#ifdef PARANOID
      if (tmp_polyline == NULL)
      {
        std::ostringstream error_stream;
        error_stream
          << "The (" << i << ") TriangleMeshCurveSection is not a "
          << "TriangleMeshPolyLine\nThe TriangleMeshPolygon object"
          << "is constituent of only TriangleMeshPolyLine objects.\n"
          << "The problem could be generated when changing the constituent "
          << "objects of the TriangleMeshPolygon.\nCheck where you got "
          << "access to this objects and review that you are not introducing "
          << "any other objects than TriangleMeshPolyLines" << std::endl;
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return tmp_polyline;
    }

References oomph::TriangleMeshCurve::Curve_section_pt, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

polyline_pt() [2/2]

TriangleMeshPolyLine* oomph::TriangleMeshPolygon::polyline_pt ( const unsigned &  i ) const

inline

Pointer to i-th constituent polyline.

    {
      TriangleMeshPolyLine* tmp_polyline =
        dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[i]);
#ifdef PARANOID
      if (tmp_polyline == NULL)
      {
        std::ostringstream error_stream;
        error_stream
          << "The (" << i << ") TriangleMeshCurveSection is not a "
          << "TriangleMeshPolyLine\nThe TriangleMeshPolygon object"
          << "is constituent of only TriangleMeshPolyLine objects.\n"
          << "The problem could be generated when changing the constituent "
          << "objects of the TriangleMeshPolygon.\nCheck where you got "
          << "access to this objects and review that you are not introducing "
          << "any other objects than TriangleMeshPolyLines" << std::endl;
        throw OomphLibError(
          error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return tmp_polyline;
    }

References oomph::TriangleMeshCurve::Curve_section_pt, i, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by oomph::ImmersedRigidBodyTriangleMeshPolygon::assign_zeta(), oomph::ImmersedRigidBodyTriangleMeshPolygon::get_initial_position(), oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon(), oomph::ImmersedRigidBodyTriangleMeshPolygon::reset_reference_configuration(), and TriangleMeshPolygon().

reset_reference_configuration()

virtual void oomph::TriangleMeshPolygon::reset_reference_configuration ( )

inlinevirtual

Virtual function that should be overloaded to update the polygons reference configuration

Reimplemented in oomph::ImmersedRigidBodyTriangleMeshPolygon.

    {
      std::ostringstream error_stream;
      error_stream
        << "Broken Default Called\n"
        << "This function should be overloaded if Can_update_configuration = "
           "true,"
        << "\nwhich indicates that the curve in it polylines parts can update "
           "its "
        << "own position (i.e. it\n"
        << "may be a rigid body. Otherwise the update will be via a FaceMesh \n"
        << "representation of the boundary which is appropriate for \n"
        << "general deforming surfaces\n";
 
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

set_fixed()

void oomph::TriangleMeshPolygon::set_fixed ( )

inline

Set the polygon to be fixed.

    {
      Polygon_fixed = true;
    }

References Polygon_fixed.

set_unfixed()

void oomph::TriangleMeshPolygon::set_unfixed ( )

inline

Set the polygon to be allowed to move (default)

    {
      Polygon_fixed = false;
    }

References Polygon_fixed.

Member Data Documentation

Can_update_configuration

bool oomph::TriangleMeshPolygon::Can_update_configuration

protected

Boolean flag to indicate whether the polygon can update its own reference configuration after it has moved i.e. if it is upgraded to a rigid body rather than being a free surface (default false)

Referenced by can_update_reference_configuration(), and oomph::ImmersedRigidBodyTriangleMeshPolygon::ImmersedRigidBodyTriangleMeshPolygon().

Enable_redistribution_of_segments_between_polylines

bool oomph::TriangleMeshPolygon::Enable_redistribution_of_segments_between_polylines

protected

Is re-distribution of polyline segments between different boundaries during adaptation enabled? (Default: false)

Referenced by disable_redistribution_of_segments_between_polylines(), enable_redistribution_of_segments_between_polylines(), and is_redistribution_of_segments_between_polylines_enabled().

Polygon_fixed

bool oomph::TriangleMeshPolygon::Polygon_fixed

private

Boolean flag to indicate whether the polygon can move (default false because if it doesn't move this will just lead to wasted work)

Referenced by is_fixed(), set_fixed(), and set_unfixed().

---

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

• unstructured_two_d_mesh_geometry_base.h
• unstructured_two_d_mesh_geometry_base.cc