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>
 
#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;
};