MortarSegmentHelper.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 "MortarSegmentInfo.h"

#include "libmesh/point.h"
#include "libmesh/int_range.h"

#include <array>
#include <optional>
#include <string>
#include <vector>

using libMesh::Point;
using libMesh::Real;

#ifdef MOOSE_UNIT_TEST
class MortarSegmentHelperTest;
#endif

class MortarSegmentHelper
{
public:
  MortarSegmentHelper(std::vector<Point> secondary_nodes,
                      const Point & center,
                      const Point & normal,
                      const MortarSegmentTriangulationMode triangulation_mode,
                      const bool triangulate_triangles);

  MortarSegmentHelper(std::vector<Point> secondary_nodes,
                      std::vector<Point> secondary_reference_points,
                      const Point & center,
                      const Point & normal,
                      const MortarSegmentTriangulationMode triangulation_mode,
                      const bool triangulate_triangles);

  Point getIntersection(
      const Point & p1, const Point & p2, const Point & q1, const Point & q2, Real & s) const;

  bool isInsideSecondary(const Point & pt) const;

  bool isDisjoint(const std::vector<Point> & poly) const;

  std::vector<Point> projectPrimaryPoly(const std::vector<Point> & primary_nodes) const;

  std::vector<Point> clipPoly(const std::vector<Point> & primary_nodes) const;

  void triangulatePoly(std::vector<Point> & poly_nodes,
                       std::vector<std::vector<unsigned int>> & tri_map) const;

  void getMortarSegments(const std::vector<Point> & primary_nodes,
                         std::vector<Point> & nodes,
                         std::vector<std::vector<unsigned int>> & elem_to_nodes);

  void getMortarSegments(const std::vector<Point> & primary_nodes,
                         const std::vector<Point> & primary_reference_points,
                         std::vector<Point> & nodes,
                         std::vector<std::vector<unsigned int>> & elem_to_nodes,
                         std::vector<std::array<Point, 3>> & elem_to_secondary_reference_points,
                         std::vector<std::array<Point, 3>> & elem_to_primary_reference_points,
                         Real minimum_segment_area = 0.);

  Real area(const std::vector<Point> & nodes) const;

  const Point & center() const { return _center; }

  const Point & normal() const { return _normal; }

  Real remainder() const { return _remaining_area_fraction; }

  Point point(unsigned int i) const
  {
    return (_secondary_poly[i](0) * _u) + (_secondary_poly[i](1) * _v) + _center;
  }

private:
  struct ReferenceMappingData
  {
    const std::vector<Point> & primary_reference_points;
    std::vector<std::array<Point, 3>> & elem_to_secondary_reference_points;
    std::vector<std::array<Point, 3>> & elem_to_primary_reference_points;
    Real minimum_segment_area;
  };

  void getMortarSegmentsImpl(const std::vector<Point> & primary_nodes,
                             std::vector<Point> & nodes,
                             std::vector<std::vector<unsigned int>> & elem_to_nodes,
                             ReferenceMappingData * reference_mapping);

  std::vector<Point> clipProjectedPoly(const std::vector<Point> & primary_poly) const;

  std::optional<Point> referencePoint(const Point & point,
                                      const std::vector<Point> & poly,
                                      const std::vector<Point> & reference_points,
                                      std::string * failure_reason = nullptr) const;

#ifdef MOOSE_UNIT_TEST
  friend class MortarSegmentHelperTest;
#endif

  Point _center;

  Point _normal;

  Point _u, _v;

  Real _secondary_area;

  Real _remaining_area_fraction;

  bool _debug;

  Real _tolerance = 1e-8;

  const MortarSegmentTriangulationMode _triangulation_mode;

  const bool _triangulate_triangles;

  Real _area_tol;

  Real _length_tol;

  std::vector<Point> _secondary_poly;

  std::vector<Point> _secondary_reference_points;
};