XYFrontalDelaunayGenerator.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "SurfaceDelaunayGeneratorBase.h"
 
#include "XYCrossFieldSolver.h"
#include "XYIncrementalDelaunay.h"
#include "MeshTriangulationUtils.h"
 
#include "libmesh/mesh_triangle_holes.h"
#include "libmesh/parsed_function.h"
#include "libmesh/point_locator_base.h"
 
#include <map>
#include <memory>
#include <set>
#include <utility>
#include <vector>
 
class XYFrontalDelaunayGenerator : public SurfaceDelaunayGeneratorBase
{
public:
  static InputParameters validParams();
 
  XYFrontalDelaunayGenerator(const InputParameters & parameters);
 
  std::unique_ptr<MeshBase> generate() override;
 
protected:
  struct FrontEdge
  {
    std::size_t start;
    std::size_t end;
    Real excess;
  };
 
  std::unique_ptr<MeshBase>
  buildBackgroundMesh(const MeshBase & boundary_mesh,
                      const std::vector<std::unique_ptr<MeshBase>> & holes,
                      const MeshTriangulationUtils::XYDelaunayOptions & opts);
 
  static std::map<dof_id_type, Real> boundaryTangentAngles(const MeshBase & mesh);
 
  void appendLoop(const std::vector<Point> & loop,
                  bool refine,
                  unsigned int extra_nodes,
                  boundary_id_type bcid,
                  std::vector<Point> & points,
                  std::vector<XYIncrementalDelaunay::Segment> & segments);
 
  Real targetArea(const Point & point) const;
 
  Real targetSize(Real area) const;
 
  Real targetCircumradius(Real size) const;
 
  void buildBoundarySegmentGrid();
 
  std::pair<Point, Point> localFrame(const Point & point) const;
 
  Real metricDistance(const Point & first,
                      const Point & second,
                      const std::pair<Point, Point> & frame) const;
 
  bool insideDomain(const Point & point) const;
 
  std::pair<long, long> gridKey(const Point & point, Real cell) const;
 
  void addToGrid(std::size_t vertex, const Point & point);
 
  bool hasVertexWithin(const XYIncrementalDelaunay & delaunay,
                       const Point & point,
                       Real distance,
                       const std::pair<Point, Point> & frame) const;
 
  bool
  placePoint(const XYIncrementalDelaunay & delaunay, const FrontEdge & edge, Point & point) const;
 
  std::vector<FrontEdge>
  collectFront(const XYIncrementalDelaunay & delaunay,
               const std::vector<XYIncrementalDelaunay::Triangle> & triangles,
               const std::vector<bool> & inside) const;
 
  void recordSplitBoundaryIds(const XYIncrementalDelaunay & delaunay, std::size_t vertex);
 
  void advanceFront(XYIncrementalDelaunay & delaunay);
 
  std::unique_ptr<MeshBase> buildTriangleMesh(const XYIncrementalDelaunay & delaunay);
 
  std::unique_ptr<MeshBase> & _bdy_ptr;
 
  const std::vector<std::unique_ptr<MeshBase> *> _hole_ptrs;
 
  const unsigned int _add_nodes_per_boundary_segment;
 
  const bool _refine_bdy;
 
  const std::vector<bool> _stitch_holes;
 
  const std::vector<bool> _refine_holes;
 
  const Real _desired_area;
 
  const std::string _desired_area_func;
 
  const std::vector<Point> _interior_points;
 
  const MooseEnum _metric;
 
  const MooseEnum _orientation;
 
  std::unique_ptr<libMesh::TriangulatorInterface::MeshedHole> _outer_outline;
 
  std::vector<std::unique_ptr<libMesh::TriangulatorInterface::MeshedHole>> _hole_outlines;
 
  std::unique_ptr<MeshBase> _background_mesh;
 
  std::unique_ptr<libMesh::PointLocatorBase> _background_locator;
 
  Real _background_mean_area;
 
  std::unique_ptr<libMesh::ParsedFunction<Real>> _area_function;
 
  std::unique_ptr<XYCrossFieldSolver> _cross_field;
 
  std::vector<std::pair<Point, Point>> _boundary_segments;
 
  Real _boundary_cell;
 
  std::map<std::pair<long, long>, std::vector<std::size_t>> _boundary_segment_grid;
 
  Real _grid_cell;
 
  std::map<std::pair<long, long>, std::vector<std::size_t>> _vertex_grid;
 
  std::map<XYIncrementalDelaunay::Segment, boundary_id_type> _segment_boundary_ids;
 
  static constexpr Real _background_area_factor = 16.0;
 
  static constexpr Real _size_tolerance = 1.2;
 
  static constexpr Real _rejection_factor = 0.7;
};