reparam_mesh.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_REPARAM_MESH_HPP
#define QUGAR_REPARAM_MESH_HPP
 
 
#include <qugar/bbox.hpp>
#include <qugar/cart_grid_tp.hpp>
#include <qugar/point.hpp>
#include <qugar/tolerance.hpp>
#include <qugar/unfitted_domain.hpp>
 
#include <cstddef>
#include <memory>
#include <span>
#include <string>
#include <vector>
 
 
namespace qugar {
 
template<int dim, int range> class ReparamMesh
{
public:
  static const int chebyshev_order = 7;
 
  explicit ReparamMesh(int order);
 
  virtual ~ReparamMesh() = default;
 
protected:
  int order_;
  std::vector<Point<range>> points_;
  std::vector<std::size_t> connectivity_;
  std::vector<std::size_t> wires_connectivity_;
 
public:
  void merge(const ReparamMesh<dim, range> &mesh);
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim == range)
  void add_full_cell(const BoundBox<dim> &domain, bool wirebasket);
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && dim == range)
  void add_full_cells(const CartGridTP<dim> &grid, const std::vector<int> &cell_ids, bool wirebasket);
 
  [[nodiscard]] bool use_Chebyshev() const;
 
  [[nodiscard]] static bool use_Chebyshev(int order);
 
  void insert_cell_point(const Point<range> &point, int cell_id, int pt_id);
 
  void merge_coincident_points(const Tolerance &tol);
 
  void scale_points(const std::vector<int> &point_ids,
    const BoundBox<range> &old_domain,
    const BoundBox<range> &new_domain);
 
  void scale_points(const BoundBox<range> &old_domain, const BoundBox<range> &new_domain);
 
  [[nodiscard]] const std::vector<Point<range>> &get_points() const;
 
  [[nodiscard]] const std::vector<std::size_t> &get_connectivity() const;
 
  [[nodiscard]] const std::vector<std::size_t> &get_wires_connectivity() const;
 
  [[nodiscard]] int get_order() const;
 
  [[nodiscard]] std::size_t get_num_cells() const;
 
  [[nodiscard]] std::size_t get_num_points() const;
 
  [[nodiscard]] std::size_t get_num_points_per_cell() const;
 
  void write_VTK_file(const std::string &filename) const;
 
  void permute_cell_directions(std::size_t cell_id);
 
  void reserve_cells(std::size_t n_new_cells);
 
  int allocate_cells(std::size_t n_new_cells);
 
protected:
  template<int sub_dim>
  [[nodiscard]] bool check_edge_in_subdomain(const std::vector<std::size_t> &edge_points_ids,
    const BoundBox<range> &domain,
    const Tolerance &tol) const;
 
  [[nodiscard]] bool check_subentity_degenerate(const std::vector<std::size_t> &points_ids, const Tolerance &tol) const;
 
  template<int aux_dim = dim>
    requires(aux_dim == dim && 1 < dim)
  [[nodiscard]] std::vector<std::size_t> get_edge_points(int cell_id, int edge_id) const;
 
  void sort_edge_points(std::span<std::size_t> edge_points_ids) const;
 
  void sort_wirebasket_edges();
 
  void purge_duplicate_wirebasket_edges();
};
 
template<int dim, bool levelset>
std::shared_ptr<const ReparamMesh<levelset ? dim - 1 : dim, dim>>
  create_reparameterization(const UnfittedDomain<dim> &unf_domain, int n_pts_dir);
 
template<int dim, bool levelset>
std::shared_ptr<const ReparamMesh<levelset ? dim - 1 : dim, dim>>
  create_reparameterization(const UnfittedDomain<dim> &unf_domain, const std::vector<int> &cells, int n_pts_dir);
 
 
}// namespace qugar
 
#endif// QUGAR_REPARAM_MESH_HPP