LCOV - code coverage report
Current view: top level - src/mesh - triangulator_interface.C (source / functions) Hit Total Coverage
Test: libMesh/libmesh: #4417 (f0ff5e) with base 9bbd75 Lines: 220 291 75.6 %
Date: 2026-11-16 16:30:47 Functions: 14 23 60.9 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : // The libMesh Finite Element Library.
       2             : // Copyright (C) 2002-2026 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
       3             : 
       4             : // This library is free software; you can redistribute it and/or
       5             : // modify it under the terms of the GNU Lesser General Public
       6             : // License as published by the Free Software Foundation; either
       7             : // version 2.1 of the License, or (at your option) any later version.
       8             : 
       9             : // This library is distributed in the hope that it will be useful,
      10             : // but WITHOUT ANY WARRANTY; without even the implied warranty of
      11             : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      12             : // Lesser General Public License for more details.
      13             : 
      14             : // You should have received a copy of the GNU Lesser General Public
      15             : // License along with this library; if not, write to the Free Software
      16             : // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      17             : 
      18             : 
      19             : #include "libmesh/libmesh_config.h"
      20             : 
      21             : // We'd like reproduceability here even when different FP rounding can
      22             : // lead to different triangle splitting decisions
      23             : #include "libmesh/enforce_ieee754.h"
      24             : 
      25             : // libmesh includes
      26             : #include "libmesh/mesh_triangle_interface.h"
      27             : #include "libmesh/unstructured_mesh.h"
      28             : #include "libmesh/face_tri3.h"
      29             : #include "libmesh/face_tri6.h"
      30             : #include "libmesh/mesh_generation.h"
      31             : #include "libmesh/mesh_smoother_laplace.h"
      32             : #include "libmesh/boundary_info.h"
      33             : #include "libmesh/mesh_triangle_holes.h"
      34             : #include "libmesh/mesh_triangle_wrapper.h"
      35             : #include "libmesh/enum_elem_type.h"
      36             : #include "libmesh/enum_order.h"
      37             : #include "libmesh/enum_to_string.h"
      38             : #include "libmesh/utility.h"
      39             : #include "libmesh/elem_range.h"
      40             : 
      41             : #include "libmesh/meshfree_interpolation.h"
      42             : 
      43             : // C/C++ includes
      44             : #include <limits>
      45             : #include <sstream>
      46             : 
      47             : 
      48             : namespace libMesh
      49             : {
      50             : //
      51             : // Function definitions for the AutoAreaFunction class
      52             : //
      53             : 
      54             : // Constructor
      55           0 : AutoAreaFunction::AutoAreaFunction (const Parallel::Communicator &comm,
      56             :                                     const unsigned int num_nearest_pts,
      57             :                                     const unsigned int power,
      58             :                                     const Real background_value,
      59           0 :                                     const Real  background_eff_dist):
      60           0 :   _comm(comm),
      61           0 :   _num_nearest_pts(num_nearest_pts),
      62           0 :   _power(power),
      63           0 :   _background_value(background_value),
      64           0 :   _background_eff_dist(background_eff_dist),
      65           0 :   _auto_area_mfi(std::make_unique<InverseDistanceInterpolation<3>>(_comm, _num_nearest_pts, _power, _background_value, _background_eff_dist))
      66             : {
      67           0 :   this->_initialized = false;
      68           0 :   this->_is_time_dependent = false;
      69           0 : }
      70             : 
      71             : // Destructor
      72           0 : AutoAreaFunction::~AutoAreaFunction () = default;
      73             : 
      74           0 : void AutoAreaFunction::init_mfi (const std::vector<Point> & input_pts,
      75             :                                  const std::vector<Real> & input_vals)
      76             : {
      77           0 :   std::vector<std::string> field_vars{"f"};
      78           0 :   _auto_area_mfi->set_field_variables(field_vars);
      79           0 :   _auto_area_mfi->get_source_points() = input_pts;
      80             : #ifdef LIBMESH_USE_COMPLEX_NUMBERS
      81             :   std::vector<Number> input_complex_vals;
      82           0 :   for (const auto & input_val : input_vals)
      83           0 :     input_complex_vals.push_back(Complex (input_val, 0.0));
      84           0 :   _auto_area_mfi->get_source_vals() = input_complex_vals;
      85             : #else
      86           0 :   _auto_area_mfi->get_source_vals() = input_vals;
      87             : #endif
      88           0 :   _auto_area_mfi->prepare_for_use();
      89           0 :   this->_initialized = true;
      90           0 : }
      91             : 
      92           0 : Real AutoAreaFunction::operator() (const Point & p,
      93             :                                    const Real /*time*/)
      94             : {
      95           0 :   libmesh_assert(this->_initialized);
      96             : 
      97           0 :   std::vector<Point> target_pts;
      98           0 :   std::vector<Number> target_vals;
      99             : 
     100           0 :   target_pts.push_back(p);
     101           0 :   target_vals.resize(1);
     102             : 
     103           0 :   _auto_area_mfi->interpolate_field_data(_auto_area_mfi->field_variables(), target_pts, target_vals);
     104             : 
     105           0 :   return libmesh_real(target_vals.front());
     106             : }
     107             : 
     108             : //
     109             : // Function definitions for the TriangulatorInterface class
     110             : //
     111             : 
     112             : // Constructor
     113        2332 : TriangulatorInterface::TriangulatorInterface(UnstructuredMesh & mesh)
     114        2144 :   : _mesh(mesh),
     115        2144 :     _holes(nullptr),
     116        2144 :     _markers(nullptr),
     117        2144 :     _regions(nullptr),
     118        2144 :     _elem_type(TRI3),
     119        2144 :     _desired_area(0.1),
     120        2144 :     _minimum_angle(20.0),
     121        2144 :     _triangulation_type(GENERATE_CONVEX_HULL),
     122        2144 :     _insert_extra_points(false),
     123        2144 :     _smooth_after_generating(true),
     124        2144 :     _quiet(true),
     125        2144 :     _fixup_tri7_center_nodes(false),
     126        2520 :     _auto_area_function(nullptr)
     127        2332 : {}
     128             : 
     129             : 
     130         221 : void TriangulatorInterface::set_interpolate_boundary_points (int n_points)
     131             : {
     132             :   // Maybe we'll reserve a meaning for negatives later?
     133          10 :   libmesh_assert(n_points >= 0);
     134             : 
     135         221 :   _interpolate_boundary_points = n_points;
     136             : 
     137             :   // backwards compatibility - someone (including us) might want to
     138             :   // query this via the old API.
     139         221 :   _insert_extra_points = n_points;
     140         221 : }
     141             : 
     142             : 
     143             : 
     144        2492 : int TriangulatorInterface::get_interpolate_boundary_points () const
     145             : {
     146             :   // backwards compatibility - someone might have turned this off via
     147             :   // the old API
     148        2492 :   if (!_insert_extra_points)
     149         298 :     return 0;
     150             : 
     151         221 :   return _interpolate_boundary_points;
     152             : }
     153             : 
     154             : 
     155             : 
     156        2705 : void TriangulatorInterface::elems_to_segments()
     157             : {
     158             :   // Don't try to override manually specified segments
     159        2705 :   if (!this->segments.empty())
     160           4 :     return;
     161             : 
     162             :   // If we have edges, they should form the polyline with the ordering
     163             :   // we want.  Let's turn them into segments for later use, because
     164             :   // we're going to delete the original elements to replace with our
     165             :   // triangulation.
     166        2630 :   if (_mesh.n_elem())
     167             :     {
     168             :       // Mapping from points to node ids, to back those out from
     169             :       // MeshedHole results later
     170          56 :       std::map<Point, dof_id_type> point_id_map;
     171             : 
     172        7393 :       for (Node * node : _mesh.node_ptr_range())
     173             :         {
     174             :           // We're not going to support overlapping nodes on the boundary
     175        5835 :           libmesh_error_msg_if
     176             :             (point_id_map.count(*node),
     177             :              "TriangulatorInterface does not support overlapping nodes found at "
     178             :              << static_cast<Point&>(*node));
     179             : 
     180        5835 :           point_id_map.emplace(*node, node->id());
     181         737 :         }
     182             : 
     183             :       // We don't support directly generating Tri6, so for
     184             :       // compatibility with future stitching we need to be working
     185             :       // with first-order elements.  Let's get rid of any non-vertex
     186             :       // nodes we just added.
     187        8802 :       for (Elem * elem : _mesh.element_ptr_range())
     188        5480 :         for (auto n : make_range(elem->n_vertices(), elem->n_nodes()))
     189         849 :           point_id_map.erase(elem->point(n));
     190             : 
     191             :       // We'll steal the ordering calculation from
     192             :       // the MeshedHole code
     193        1608 :       const TriangulatorInterface::MeshedHole mh { _mesh, this->_bdy_ids };
     194             : 
     195             :       // If we've specified only a subset of the mesh as our outer
     196             :       // boundary, then we may have nodes that don't actually fall
     197             :       // inside that boundary.  Triangulator code doesn't like Steiner
     198             :       // points that aren't inside the triangulation domain, so we
     199             :       // need to get rid of them.
     200             :       //
     201             :       // Also, if we're using Edge3 elements to define our outer
     202             :       // boundary, we're only dealing with their 2 end nodes and we'll
     203             :       // need to get rid of their central nodes.
     204          44 :       std::unordered_set<Node *> nodes_to_delete;
     205             : 
     206        6864 :       for (Elem * elem : _mesh.element_ptr_range())
     207        4699 :         for (auto n : make_range(elem->n_vertices(), elem->n_nodes()))
     208        2312 :           nodes_to_delete.insert(elem->node_ptr(n));
     209             : 
     210         580 :       if (!this->_bdy_ids.empty())
     211             :         {
     212        4048 :           for (auto & node : _mesh.node_ptr_range())
     213        1953 :             if (!mh.contains(*node))
     214         204 :               nodes_to_delete.insert(node);
     215             :         }
     216             : 
     217             :       // And now we're done with elements.  Delete them lest they have
     218             :       // dangling pointers to nodes we'll be deleting.
     219         580 :       _mesh.clear_elems();
     220             : 
     221             :       // Make segments from boundary nodes; also make sure we don't
     222             :       // delete them.
     223         580 :       const std::size_t np = mh.n_points();
     224        2829 :       for (auto i : make_range(np))
     225             :         {
     226        2249 :           const Point pt = mh.point(i);
     227        2249 :           const dof_id_type id0 = libmesh_map_find(point_id_map, pt);
     228        2249 :           nodes_to_delete.erase(_mesh.node_ptr(id0));
     229        2249 :           const Point next_pt = mh.point((np+i+1)%np);
     230        2249 :           const dof_id_type id1 = libmesh_map_find(point_id_map, next_pt);
     231        2249 :           this->segments.emplace_back(id0, id1);
     232        3614 :           for (auto m : make_range(mh.n_midpoints()))
     233             :           {
     234        1365 :             this->segment_midpoints.emplace_back(mh.midpoint(m, i));
     235        1365 :             this->segment_midpoints_keys.emplace_back(pt);
     236             :           }
     237             :         }
     238             : 
     239        3030 :       for (Node * node : nodes_to_delete)
     240        2450 :         _mesh.delete_node(node);
     241             : 
     242         580 :       if (this->_verify_hole_boundaries && _holes)
     243           0 :         this->verify_holes(mh);
     244         536 :     }
     245             : }
     246             : 
     247             : 
     248             : 
     249        2492 : void TriangulatorInterface::nodes_to_segments(dof_id_type max_node_id)
     250             : {
     251             :   // Don't try to override manually specified segments, or try to add
     252             :   // segments if we're doing a convex hull
     253        2492 :   if (!this->segments.empty() || _triangulation_type != PSLG)
     254         256 :     return;
     255             : 
     256        1429 :   for (auto node_it = _mesh.nodes_begin(),
     257        1429 :        node_end = _mesh.nodes_end();
     258        7745 :        node_it != node_end;)
     259             :     {
     260        6368 :       Node * node = *node_it;
     261             : 
     262             :       // If we're out of boundary nodes, the rest are going to be
     263             :       // Steiner points or hole points
     264        6368 :       if (node->id() >= max_node_id)
     265           0 :         break;
     266             : 
     267        6132 :       ++node_it;
     268             : 
     269       12500 :       Node * next_node = (node_it == node_end) ?
     270        1561 :         *_mesh.nodes_begin() : *node_it;
     271             : 
     272        6368 :       this->segments.emplace_back(node->id(), next_node->id());
     273             :     }
     274             : 
     275        1377 :   if (this->_verify_hole_boundaries && _holes)
     276             :     {
     277          56 :       std::vector<Point> outer_pts;
     278        4817 :       for (auto segment : this->segments)
     279        4024 :         outer_pts.push_back(_mesh.point(segment.first));
     280             : 
     281         849 :       ArbitraryHole ah(outer_pts);
     282         793 :       this->verify_holes(ah);
     283         737 :     }
     284             : }
     285             : 
     286             : 
     287             : 
     288        2492 : void TriangulatorInterface::insert_any_extra_boundary_points()
     289             : {
     290             :   // If the initial PSLG is really simple, e.g. an L-shaped domain or
     291             :   // a square/rectangle, the resulting triangulation may be very
     292             :   // "structured" looking.  Sometimes this is a problem if your
     293             :   // intention is to work with an "unstructured" looking grid.  We can
     294             :   // attempt to work around this limitation by inserting midpoints
     295             :   // into the original PSLG.  Inserting additional points into a
     296             :   // set of points meant to be a convex hull usually makes less sense.
     297             : 
     298        2492 :   const int n_interpolated = this->get_interpolate_boundary_points();
     299        2492 :   if ((_triangulation_type==PSLG) && n_interpolated)
     300             :     {
     301             :       // If we were lucky enough to start with contiguous node ids,
     302             :       // let's keep them that way.
     303         221 :       dof_id_type nn = _mesh.max_node_id();
     304             : 
     305             :       std::vector<std::pair<unsigned int, unsigned int>> old_segments =
     306         231 :         std::move(this->segments);
     307             : 
     308             :       // We expect to have converted any elems and/or nodes into
     309             :       // segments by now.
     310          10 :       libmesh_assert(!old_segments.empty());
     311             : 
     312          10 :       this->segments.clear();
     313             : 
     314             :       // Insert a new point on each segment at evenly spaced locations
     315             :       // between existing boundary points.
     316             :       // np=index into new points vector
     317             :       // n =index into original points vector
     318        1105 :       for (auto old_segment : old_segments)
     319             :         {
     320         884 :           Node * begin_node = _mesh.node_ptr(old_segment.first);
     321         884 :           Node * end_node = _mesh.node_ptr(old_segment.second);
     322         884 :           dof_id_type current_id = begin_node->id();
     323        2920 :           for (auto i : make_range(n_interpolated))
     324             :             {
     325             :               // new points are equispaced along the original segments
     326             :               const Point new_point =
     327        2036 :                 ((n_interpolated-i) * *(Point *)(begin_node) +
     328        2036 :                  (i+1) * *(Point *)(end_node)) /
     329        2116 :                 (n_interpolated + 1);
     330        2036 :               Node * next_node = _mesh.add_point(new_point, nn++);
     331        1876 :               this->segments.emplace_back(current_id,
     332        2036 :                                           next_node->id());
     333        2036 :               current_id = next_node->id();
     334             :             }
     335         804 :           this->segments.emplace_back(current_id,
     336         884 :                                       end_node->id());
     337             :         }
     338             :     }
     339        2492 : }
     340             : 
     341             : 
     342        1996 : void TriangulatorInterface::increase_triangle_order()
     343             : {
     344        1996 :   switch (_elem_type)
     345             :     {
     346          48 :     case TRI3:
     347             :     // Nothing to do if we're not requested to increase order
     348        1704 :       return;
     349         221 :     case TRI6:
     350         221 :       _mesh.all_second_order();
     351          10 :       break;
     352          71 :     case TRI7:
     353          71 :       _mesh.all_complete_order();
     354           2 :       break;
     355           0 :     default:
     356           0 :       libmesh_not_implemented();
     357             :     }
     358             : 
     359             :   // If we have any midpoint location data, we'll want to look it up
     360             :   // by point.  all_midpoints[{p, m}] will be the mth midpoint
     361             :   // location following after point p (when traversing a triangle
     362             :   // counter-clockwise)
     363          14 :   std::map<std::pair<Point, unsigned int>, Point> all_midpoints;
     364             :   unsigned int n_midpoints =
     365         316 :     this->segment_midpoints.size() / this->segments.size();
     366          12 :   libmesh_assert_equal_to(this->segments.size() * n_midpoints,
     367             :                           this->segment_midpoints.size());
     368         509 :   for (auto m : make_range(n_midpoints))
     369        1014 :     for (auto i : make_range(this->segments.size()))
     370             :       {
     371         797 :         const Point & p = segment_midpoints_keys[i*n_midpoints+m];
     372         864 :         all_midpoints[{p,m}] =
     373          60 :           this->segment_midpoints[i*n_midpoints+m];
     374             :       }
     375             : 
     376         292 :   if (_holes)
     377         150 :     for (const Hole * hole : *_holes)
     378             :       {
     379          75 :         if (!hole->n_midpoints())
     380           0 :           continue;
     381          75 :         if (!n_midpoints)
     382          75 :           n_midpoints = hole->n_midpoints();
     383           0 :         else if (hole->n_midpoints() != n_midpoints)
     384           0 :           libmesh_not_implemented_msg
     385             :             ("Differing boundary midpoint counts " <<
     386             :              hole->n_midpoints() << " and " << n_midpoints);
     387             : 
     388             :         // Our inner holes are expected to have points in
     389             :         // counter-clockwise order, which is backwards from how we
     390             :         // want to traverse them when iterating in counter-clockwise
     391             :         // order over a triangle, so we'll need to reverse our maps
     392             :         // carefully here.
     393          75 :         const auto n_hole_points = hole->n_points();
     394           4 :         libmesh_assert(n_hole_points);
     395         150 :         for (auto m : make_range(n_midpoints))
     396             :           {
     397         600 :             for (auto i : make_range(n_hole_points-1))
     398             :               {
     399         525 :                 const Point & p = hole->point(i+1);
     400         525 :                 all_midpoints[{p,m}] = hole->midpoint(n_midpoints-m-1, i);
     401             :               }
     402          75 :             const Point & p = hole->point(0);
     403          77 :             all_midpoints[{p,m}] = hole->midpoint(n_midpoints-m-1, n_hole_points-1);
     404             :           }
     405             :       }
     406             : 
     407             :   // The n_midpoints > 1 case is for future proofing, but in the
     408             :   // present we have EDGE4 and no TRI10 yet.
     409         292 :   if (n_midpoints > 1)
     410           0 :     libmesh_not_implemented_msg
     411             :       ("Cannot construct triangles with more than 1 midpoint per edge");
     412             : 
     413         292 :   if (!n_midpoints)
     414           0 :     return;
     415             : 
     416             :   Threads::parallel_for_each
     417         292 :     (_mesh.element_stored_range(),
     418        1899 :      [&all_midpoints](Elem * elem)
     419             :      {
     420             :        // This should only be called right after we've finished
     421             :        // converting a triangulation to higher order
     422          62 :        libmesh_assert_equal_to(elem->n_vertices(), 3);
     423          62 :        libmesh_assert_not_equal_to(elem->default_order(), FIRST);
     424             : 
     425        5052 :        for (auto n : make_range(3))
     426             :          {
     427             :            // Only hole/outer boundary segments need adjusted
     428             :            // midpoints
     429        3975 :            if (elem->neighbor_ptr(n))
     430        1984 :              continue;
     431             : 
     432         156 :            const Point & p = elem->point(n);
     433             : 
     434        1775 :            if (const auto it = all_midpoints.find({p,0});
     435          78 :                it != all_midpoints.end())
     436        1459 :              elem->point(n+3) = it->second;
     437             :          }
     438        1263 :      });
     439             : 
     440             :   // Moving boundary mid-edge nodes can displace the TRI7 interior node
     441             :   // and tangle the element map.  Repositioning the interior node is
     442             :   // opt-in (off by default); the validity check always runs.
     443         292 :   if (_elem_type == TRI7 && _fixup_tri7_center_nodes)
     444          71 :     this->fixup_tri7_center_nodes();
     445             : 
     446         292 :   this->verify_quadratic_elements();
     447             : }
     448             : 
     449             : 
     450          71 : void TriangulatorInterface::fixup_tri7_center_nodes()
     451             : {
     452           2 :   libmesh_assert_equal_to(_elem_type, TRI7);
     453             : 
     454             :   // Place the interior node at the image of the reference centroid
     455             :   // (xi, eta) = (1/3, 1/3) under the curved Tri6 map, using the Tri6
     456             :   // shape function values there as weights: -1/9 on the vertices and
     457             :   // 4/9 on the mid-edges.  This reduces to the straight-edge centroid
     458             :   // when no boundary midpoint has moved.
     459             :   static const Real wv = -Real(1)/9;
     460             :   static const Real wm =  Real(4)/9;
     461             : 
     462         416 :   for (Elem * elem : _mesh.element_ptr_range())
     463             :     {
     464           4 :       libmesh_assert_equal_to(elem->n_vertices(), 3);
     465           4 :       libmesh_assert_equal_to(elem->n_nodes(), 7u);
     466             : 
     467         142 :       elem->point(6) = wv * (elem->point(0) +
     468           4 :                              elem->point(1) +
     469           8 :                              elem->point(2)) +
     470           0 :                        wm * (elem->point(3) +
     471           8 :                              elem->point(4) +
     472          16 :                              elem->point(5));
     473          67 :     }
     474          71 : }
     475             : 
     476             : 
     477         292 : void TriangulatorInterface::verify_quadratic_elements()
     478             : {
     479         292 :   if (_elem_type != TRI6 && _elem_type != TRI7)
     480           0 :     return;
     481             : 
     482             :   // Once fixup_tri7_center_nodes() has placed node 6, the TRI6 and TRI7
     483             :   // mappings coincide and this Tri6 formula serves both.
     484             :   static const Real xi_samples[7]  = {Real(0),   Real(1),   Real(0),
     485             :                                       Real(1)/2, Real(1)/2, Real(0),
     486             :                                       Real(1)/3};
     487             :   static const Real eta_samples[7] = {Real(0),   Real(0),   Real(1),
     488             :                                       Real(0),   Real(1)/2, Real(1)/2,
     489             :                                       Real(1)/3};
     490             : 
     491        2909 :   for (Elem * elem : _mesh.element_ptr_range())
     492             :     {
     493          62 :       libmesh_assert_equal_to(elem->n_vertices(), 3);
     494          62 :       libmesh_assert_greater_equal(elem->n_nodes(), 6u);
     495             : 
     496         124 :       const Point & x0 = elem->point(0);
     497          62 :       const Point & x1 = elem->point(1);
     498          62 :       const Point & x2 = elem->point(2);
     499          62 :       const Point & x3 = elem->point(3);
     500          62 :       const Point & x4 = elem->point(4);
     501          62 :       const Point & x5 = elem->point(5);
     502             : 
     503             :       // Tri6 mapping derivative coefficients (see Tri6::volume()):
     504             :       // dx/dxi = xi*a1 + eta*b1 + c1, dx/deta = xi*b1 + eta*b2 + c2.
     505          62 :       const Point a1 =  4*x0 + 4*x1 - 8*x3;
     506          62 :       const Point b1 =  4*x0 - 4*x3 + 4*x4 - 4*x5;
     507          62 :       const Point c1 = -3*x0 - 1*x1 + 4*x3;
     508          62 :       const Point b2 =  4*x0 + 4*x2 - 8*x5;
     509          62 :       const Point c2 = -3*x0 - 1*x2 + 4*x5;
     510             : 
     511             :       // Scale the tolerance by the straight-edge triangle area, which
     512             :       // is strictly positive for the valid TRI3 poly2tri input.
     513        1263 :       const Real ref_area = 0.5 * cross_norm(x1 - x0, x2 - x0);
     514        1263 :       const Real jac_tol = TOLERANCE * ref_area;
     515             : 
     516          62 :       Real min_jac = std::numeric_limits<Real>::max();
     517          62 :       unsigned int worst_sample = 0;
     518       10104 :       for (unsigned int s = 0; s != 7; ++s)
     519             :         {
     520        8841 :           const Real xi  = xi_samples[s];
     521        8841 :           const Real eta = eta_samples[s];
     522         434 :           const Point dxi  = xi*a1 + eta*b1 + c1;
     523         434 :           const Point deta = xi*b1 + eta*b2 + c2;
     524             :           // z-component of the cross product; the elements are planar.
     525        8841 :           const Real jac = dxi(0)*deta(1) - dxi(1)*deta(0);
     526        8841 :           if (jac < min_jac)
     527             :             {
     528         100 :               min_jac = jac;
     529         100 :               worst_sample = s;
     530             :             }
     531             :         }
     532             : 
     533        1263 :       if (min_jac > jac_tol)
     534          60 :         continue;
     535             : 
     536             :       // Build a diagnostic naming every snapped boundary side on this
     537             :       // element so the user can immediately see which curved-boundary
     538             :       // input caused the tangle.
     539          75 :       std::ostringstream sides;
     540         284 :       for (unsigned int n = 0; n != 3; ++n)
     541         219 :         if (!elem->neighbor_ptr(n))
     542             :           {
     543             :             const Point straight =
     544         213 :               0.5 * (elem->point(n) + elem->point((n+1) % 3));
     545         207 :             sides << " (boundary side " << n
     546         207 :                   << ": straight midpoint " << straight
     547         219 :                   << ", snapped midpoint " << elem->point(n+3) << ")";
     548             :           }
     549             : 
     550         485 :       libmesh_error_msg(
     551             :         "TriangulatorInterface: snapping a boundary midpoint produced a "
     552             :         "tangled quadratic triangle (element " << elem->id()
     553             :         << ", non-positive Jacobian " << min_jac
     554             :         << " at reference sample (" << xi_samples[worst_sample] << ", "
     555             :         << eta_samples[worst_sample] << "); reference triangle area "
     556             :         << ref_area << ")." << sides.str()
     557             :         << " Refine the boundary discretization so that recorded "
     558             :         "midpoints lie closer to their straight-line midpoints, "
     559             :         "then retry.");
     560         335 :     }
     561             : }
     562             : 
     563             : 
     564         793 : void TriangulatorInterface::verify_holes(const Hole & outer_bdy)
     565             : {
     566        2225 :   for (const Hole * hole : *_holes)
     567             :     {
     568        8118 :       for (const Hole * hole2 : *_holes)
     569             :         {
     570        6686 :           if (hole == hole2)
     571        1386 :             continue;
     572             : 
     573       26270 :           for (auto i : make_range(hole2->n_points()))
     574       21016 :             if (hole->contains(hole2->point(i)))
     575           0 :               libmesh_error_msg
     576             :                 ("Found point " << hole2->point(i) <<
     577             :                  " on one hole boundary and another's interior");
     578             :         }
     579             : 
     580        7760 :       for (auto i : make_range(hole->n_points()))
     581        6328 :         if (!outer_bdy.contains(hole->point(i)))
     582           0 :           libmesh_error_msg
     583             :             ("Found point " << hole->point(i) <<
     584             :              " on hole boundary but outside outer boundary");
     585             :     }
     586         793 : }
     587             : 
     588             : 
     589         504 : unsigned int TriangulatorInterface::total_hole_points()
     590             : {
     591             :   // If the holes vector is non-nullptr (and non-empty) we need to determine
     592             :   // the number of additional points which the holes will add to the
     593             :   // triangulation.
     594             :   // Note that the number of points is always equal to the number of segments
     595             :   // that form the holes.
     596         252 :   unsigned int n_hole_points = 0;
     597             : 
     598         504 :   if (_holes)
     599          40 :     for (const auto & hole : *_holes)
     600             :     {
     601          24 :       n_hole_points += hole->n_points();
     602             :       // A hole at least has one enclosure.
     603             :       // Points on enclosures are ordered so that we can add segments implicitly.
     604             :       // Elements in segment_indices() indicates the starting points of all enclosures.
     605             :       // The last element in segment_indices() is the number of total points.
     606          12 :       libmesh_assert_greater(hole->segment_indices().size(), 1);
     607          12 :       libmesh_assert_equal_to(hole->segment_indices().back(), hole->n_points());
     608             :     }
     609             : 
     610         504 :   return n_hole_points;
     611             : }
     612             : 
     613           0 : void TriangulatorInterface::set_auto_area_function(const Parallel::Communicator &comm,
     614             :                                                    const unsigned int num_nearest_pts,
     615             :                                                    const unsigned int power,
     616             :                                                    const Real background_value,
     617             :                                                    const Real  background_eff_dist)
     618             : {
     619           0 :    _auto_area_function = std::make_unique<AutoAreaFunction>(comm, num_nearest_pts, power, background_value, background_eff_dist);
     620           0 : }
     621             : 
     622           0 : FunctionBase<Real> * TriangulatorInterface::get_auto_area_function()
     623             : {
     624           0 :   if (!_auto_area_function->initialized())
     625             :   {
     626             :     // Points and target element sizes for the interpolation
     627           0 :     std::vector<Point> function_points;
     628           0 :     std::vector<Real> function_sizes;
     629           0 :     calculate_auto_desired_area_samples(function_points, function_sizes);
     630           0 :     _auto_area_function->init_mfi(function_points, function_sizes);
     631             :   }
     632           0 :   return _auto_area_function.get();
     633             : }
     634             : 
     635           0 : void TriangulatorInterface::calculate_auto_desired_area_samples(std::vector<Point> & function_points,
     636             :                                                                 std::vector<Real> & function_sizes,
     637             :                                                                 const Real & area_factor)
     638             : {
     639             :   // Get the hole mesh of the outer boundary
     640             :   // Holes should already be attached if applicable when this function is called
     641           0 :   const TriangulatorInterface::MeshedHole bdry_mh { _mesh, this->_bdy_ids };
     642             :   // Collect all the centroid points of the outer boundary segments
     643             :   // and the corresponding element sizes
     644           0 :   for (unsigned int i = 0; i < bdry_mh.n_points(); i++)
     645             :   {
     646           0 :     function_points.push_back((bdry_mh.point(i) + bdry_mh.point((i + 1) % bdry_mh.n_points())) /
     647           0 :                               Real(2.0));
     648           0 :     function_sizes.push_back(
     649           0 :         (bdry_mh.point(i) - bdry_mh.point((i + 1) % bdry_mh.n_points())).norm());
     650             :   }
     651             :   // If holes are present, do the same for the hole boundaries
     652           0 :   if(_holes)
     653           0 :     for (const Hole * hole : *_holes)
     654             :     {
     655           0 :       for (unsigned int i = 0; i < hole->n_points(); i++)
     656             :       {
     657           0 :         function_points.push_back(
     658           0 :             (hole->point(i) + hole->point((i + 1) % hole->n_points())) / Real(2.0));
     659           0 :         function_sizes.push_back(
     660           0 :             (hole->point(i) - hole->point((i + 1) % hole->n_points())).norm());
     661             :       }
     662             :     }
     663             : 
     664           0 :   std::for_each(
     665           0 :       function_sizes.begin(), function_sizes.end(), [&area_factor](Real & a) { a = a * a * area_factor * std::sqrt(3.0) / 4.0; });
     666             : 
     667           0 : }
     668             : } // namespace libMesh
     669             : 
     670             : 
     671             : // Unnecessary at end of file, *except* maybe we'll do a unity build
     672             : // someday, and in the meantime test coverage is nice.
     673             : #include "libmesh/restore_ieee754.h"

Generated by: LCOV version 1.14