oomph::TriangleMeshClosedCurve Class Reference

Base class defining a closed curve for the Triangle mesh generation. More...

#include <unstructured_two_d_mesh_geometry_base.h>

Inheritance diagram for oomph::TriangleMeshClosedCurve:

Public Member Functions
	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...
virtual unsigned	ncurve_section () const
	Number of constituent 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
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...

Detailed Description

Base class defining a closed curve for the Triangle mesh generation.

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

Constructor & Destructor Documentation

TriangleMeshClosedCurve()

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.

Class defining a closed curve for the Triangle mesh generation.

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

    : TriangleMeshCurve(curve_section_pt),
      Internal_point_pt(internal_point_pt),
      Is_internal_point_fixed(is_internal_point_fixed)
  {
    // Matching of curve sections i.e. the last vertex of the i curve
    // section should match with the first vertex of the i+1 curve
    // section
 
    // Total number of boundaries
    const unsigned n_boundaries = Curve_section_pt.size();
 
    // Need at least two
    if (n_boundaries < 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 CurveSections.\n"
                   << "You've only specified (" << n_boundaries << ")"
                   << std::endl;
      throw OomphLibError(
        error_stream.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
 
    // Check last point of each boundary bit coincides with first point
    // on next one
    for (unsigned i = 0; i < n_boundaries - 1; i++)
    {
      // Auxiliary vertex for storing the vertex values of contiguous curves
      Vector<double> v1(2);
 
      // This is for getting the final coordinates of the i curve section
      curve_section_pt[i]->final_vertex_coordinate(v1);
 
      // Auxiliary vertex for storing the vertex values of contiguous curves
      Vector<double> v2(2);
 
      // This is for the start coordinates of the i+1 curve section
      curve_section_pt[i + 1]->initial_vertex_coordinate(v2);
 
      // Work out error
      double error = sqrt(pow(v1[0] - v2[0], 2) + pow(v1[1] - v2[1], 2));
 
      if (error > ToleranceForVertexMismatchInPolygons::Tolerable_error)
      {
        std::ostringstream error_stream;
        error_stream
          << "The start and end points of curve section boundary parts\n"
          << i << " and " << i + 1
          << " don't match when judged with the tolerance of "
          << ToleranceForVertexMismatchInPolygons::Tolerable_error
          << " which\nis specified in the namespace variable\n"
          << "ToleranceForVertexMismatchInPolygons::Tolerable_error.\n\n"
          << "These are the vertices coordinates:\n"
          << "Curve section (" << i << ") final vertex: (" << v1[0] << ", "
          << v1[1] << ")\n"
          << "Curve section (" << i + 1 << ") initial vertex: (" << v2[0]
          << ", " << v2[1] << ")\n"
          << "The distance between the vertices is (" << error << ")\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(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
      else
      {
        // Aligns (only implemented for polylines)
        TriangleMeshPolyLine* current_polyline =
          dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[i]);
        TriangleMeshPolyLine* next_polyline =
          dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[i + 1]);
 
        // Was it able to do the cast?
        if (current_polyline && next_polyline)
        {
          unsigned last_vertex = current_polyline->nvertex() - 1;
          next_polyline->vertex_coordinate(0) =
            current_polyline->vertex_coordinate(last_vertex);
        }
      }
 
    } // For n_boundaries - 1
 
    // Check wrap around
    // Auxiliary vertex for storing the vertex values of contiguous curves
    Vector<double> v1(2);
 
    // This is for getting the first coordinates of the first curve section
    Curve_section_pt[0]->initial_vertex_coordinate(v1);
 
    // Auxiliary vertex for storing the vertex values of contiguous curves
    Vector<double> v2(2);
 
    // This is for getting the last coordinates of the last curve section
    Curve_section_pt[n_boundaries - 1]->final_vertex_coordinate(v2);
 
    double error = sqrt(pow(v2[0] - v1[0], 2) + pow(v2[1] - v1[1], 2));
 
    if (error > ToleranceForVertexMismatchInPolygons::Tolerable_error)
    {
      std::ostringstream error_stream;
      error_stream
        << "The start and end points of the first and last curve segment\n"
        << "boundary parts don't match 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(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
    else
    {
      // Aligns (only implemented for polylines)
      TriangleMeshPolyLine* first_polyline =
        dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[0]);
      TriangleMeshPolyLine* last_polyline =
        dynamic_cast<TriangleMeshPolyLine*>(Curve_section_pt[n_boundaries - 1]);
 
      // Was it able to do the cast?
      if (first_polyline && last_polyline)
      {
        unsigned last_vertex = last_polyline->nvertex() - 1;
        first_polyline->vertex_coordinate(0) =
          last_polyline->vertex_coordinate(last_vertex);
      }
    }
  }

References oomph::TriangleMeshCurve::curve_section_pt(), oomph::TriangleMeshCurve::Curve_section_pt, calibrate::error, oomph::TriangleMeshCurveSection::final_vertex_coordinate(), i, oomph::TriangleMeshCurveSection::initial_vertex_coordinate(), oomph::TriangleMeshPolyLine::nvertex(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Eigen::bfloat16_impl::pow(), sqrt(), oomph::ToleranceForVertexMismatchInPolygons::Tolerable_error, v1(), v2(), and oomph::TriangleMeshPolyLine::vertex_coordinate().

~TriangleMeshClosedCurve()

virtual oomph::TriangleMeshClosedCurve::~TriangleMeshClosedCurve ( )

inlinevirtual

Empty destructor.

{}

Member Function Documentation

fix_internal_point()

void oomph::TriangleMeshClosedCurve::fix_internal_point ( )

inline

Fix the internal point (i.e. do not allow our automatic machinery to update it)

    {
      Is_internal_point_fixed = true;
    }

References Is_internal_point_fixed.

internal_point() [1/2]

Vector<double>& oomph::TriangleMeshClosedCurve::internal_point ( )

inline

Coordinates of the internal point.

    {
      return Internal_point_pt;
    }

References Internal_point_pt.

internal_point() [2/2]

Vector<double> oomph::TriangleMeshClosedCurve::internal_point ( ) const

inline

Coordinates of the internal point.

    {
      return Internal_point_pt;
    }

References Internal_point_pt.

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

is_internal_point_fixed()

bool oomph::TriangleMeshClosedCurve::is_internal_point_fixed ( ) const

inline

Test whether the internal point is fixed.

    {
      return Is_internal_point_fixed;
    }

References Is_internal_point_fixed.

nsegments()

unsigned oomph::TriangleMeshClosedCurve::nsegments ( ) const

inlinevirtual

Total number of segments.

Implements oomph::TriangleMeshCurve.

    {
      unsigned n_curve_section = ncurve_section();
      unsigned nseg = 0;
      for (unsigned j = 0; j < n_curve_section; j++)
      {
        nseg += Curve_section_pt[j]->nsegment();
      }
      // If there's just one boundary poly line we have another segment
      // connecting the last vertex to the first one
      if (n_curve_section == 1)
      {
        nseg += 1;
      }
      return nseg;
    }

References oomph::TriangleMeshCurve::Curve_section_pt, j, and oomph::TriangleMeshCurve::ncurve_section().

nvertices()

unsigned oomph::TriangleMeshClosedCurve::nvertices ( ) const

inlinevirtual

Number of vertices.

Implements oomph::TriangleMeshCurve.

    {
      unsigned n_curve_section = ncurve_section();
      unsigned n_vertices = 0;
      for (unsigned j = 0; j < n_curve_section; j++)
      {
        // Storing the number of the vertices
        n_vertices += Curve_section_pt[j]->nvertex() - 1;
      }
      // If there's just one boundary. All the vertices should be counted
      if (n_curve_section == 1)
      {
        n_vertices += 1;
      }
      return n_vertices;
    }

References oomph::TriangleMeshCurve::Curve_section_pt, j, and oomph::TriangleMeshCurve::ncurve_section().

output()

void oomph::TriangleMeshClosedCurve::output ( std::ostream &  outfile, const unsigned &  n_sample = 50  )

inlinevirtual

Output each sub-boundary at n_sample (default: 50) points.

Implements oomph::TriangleMeshCurve.

    {
      unsigned nb = Curve_section_pt.size();
      for (unsigned i = 0; i < nb; i++)
      {
        Curve_section_pt[i]->output(outfile, n_sample);
      }
 
      if (!Internal_point_pt.empty())
      {
        outfile << "ZONE T=\"Internal point\"\n";
        outfile << Internal_point_pt[0] << " " << Internal_point_pt[1] << "\n";
      }
    }

References oomph::TriangleMeshCurve::Curve_section_pt, i, Internal_point_pt, and nb.

unfix_internal_point()

void oomph::TriangleMeshClosedCurve::unfix_internal_point ( )

inline

Unfix the internal point (i.e. allow our automatic machinery to update it)

    {
      Is_internal_point_fixed = false;
    }

References Is_internal_point_fixed.

Member Data Documentation

Internal_point_pt

Vector<double> oomph::TriangleMeshClosedCurve::Internal_point_pt

protected

Vector of vertex coordinates.

Referenced by internal_point(), output(), and oomph::TriangleMeshPolygon::TriangleMeshPolygon().

Is_internal_point_fixed

bool oomph::TriangleMeshClosedCurve::Is_internal_point_fixed

protected

Indicate whether the internal point should be updated automatically.

Referenced by fix_internal_point(), is_internal_point_fixed(), and unfix_internal_point().

---

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