tria_description.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2020 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_grid_tria_description_h
#define dealii_grid_tria_description_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/memory_space.h>
#include <deal.II/base/mpi_stub.h>
 
#include <deal.II/grid/cell_data.h>
#include <deal.II/grid/cell_id.h>
#include <deal.II/grid/reference_cell.h>
#include <deal.II/grid/tria.h>
 
 
DEAL_II_NAMESPACE_OPEN
#ifndef DOXYGEN
namespace LinearAlgebra
{
  namespace distributed
  {
    template <typename Number, typename MemorySpace>
    class Vector;
  }
} // namespace LinearAlgebra
#endif
 
/*------------------------------------------------------------------------*/
 

namespace TriangulationDescription
{
  enum Settings
  {
    default_setting = 0x0,
    construct_multigrid_hierarchy = 0x1
  };

  template <int dim>
  struct CellData
  {
    CellData();

    template <class Archive>
    void
    serialize(Archive &ar, const unsigned int /*version*/);

    bool
    operator==(const CellData<dim> &other) const;

    CellId::binary_type id;

    types::subdomain_id subdomain_id;

    types::subdomain_id level_subdomain_id;

    types::manifold_id manifold_id;

    std::array<types::manifold_id, GeometryInfo<dim>::lines_per_cell>
      manifold_line_ids;

    std::array<types::manifold_id,
               dim == 1 ? 1 : GeometryInfo<3>::quads_per_cell>
      manifold_quad_ids;

    std::vector<std::pair<unsigned int, types::boundary_id>> boundary_ids;
  };
 

  template <int dim, int spacedim = dim>
  struct Description
  {
    Description();

    template <class Archive>
    void
    serialize(Archive &ar, const unsigned int /*version*/);

    bool
    operator==(const Description<dim, spacedim> &other) const;

    std::vector<::CellData<dim>> coarse_cells;

    std::vector<Point<spacedim>> coarse_cell_vertices;

    std::vector<types::coarse_cell_id> coarse_cell_index_to_coarse_cell_id;

    std::vector<std::vector<CellData<dim>>> cell_infos;

    MPI_Comm comm;

    Settings settings;

    typename Triangulation<dim, spacedim>::MeshSmoothing smoothing;
  };
 

  namespace Utilities
  {
    template <int dim, int spacedim = dim>
    Description<dim, spacedim>
    create_description_from_triangulation(
      const ::Triangulation<dim, spacedim> &tria,
      const MPI_Comm                              comm,
      const TriangulationDescription::Settings    settings =
        TriangulationDescription::Settings::default_setting,
      const unsigned int my_rank_in = numbers::invalid_unsigned_int);

    template <int dim, int spacedim>
    Description<dim, spacedim>
    create_description_from_triangulation(
      const Triangulation<dim, spacedim> &tria,
      const LinearAlgebra::distributed::Vector<double, MemorySpace::Host>
                                              &partition,
      const TriangulationDescription::Settings settings =
        TriangulationDescription::Settings::default_setting);

    template <int dim, int spacedim>
    Description<dim, spacedim>
    create_description_from_triangulation(
      const Triangulation<dim, spacedim> &tria,
      const LinearAlgebra::distributed::Vector<double, MemorySpace::Host>
        &partition,
      const std::vector<
        LinearAlgebra::distributed::Vector<double, MemorySpace::Host>>
                                              &mg_partitions,
      const TriangulationDescription::Settings settings =
        TriangulationDescription::Settings::default_setting);

    template <int dim, int spacedim = dim>
    Description<dim, spacedim>
    create_description_from_triangulation_in_groups(
      const std::function<void(::Triangulation<dim, spacedim> &)>
                                                    &serial_grid_generator,
      const std::function<void(::Triangulation<dim, spacedim> &,
                               const MPI_Comm,
                               const unsigned int)> &serial_grid_partitioner,
      const MPI_Comm                                 comm,
      const int                                      group_size = 1,
      const typename Triangulation<dim, spacedim>::MeshSmoothing smoothing =
        ::Triangulation<dim, spacedim>::none,
      const TriangulationDescription::Settings setting =
        TriangulationDescription::Settings::default_setting);
 
  } // namespace Utilities
 
 
 
  template <int dim>
  CellData<dim>::CellData()
    : subdomain_id(numbers::invalid_subdomain_id)
    , level_subdomain_id(numbers::invalid_subdomain_id)
    , manifold_id(numbers::flat_manifold_id)
  {
    std::fill(id.begin(), id.end(), numbers::invalid_unsigned_int);
    std::fill(manifold_line_ids.begin(),
              manifold_line_ids.end(),
              numbers::flat_manifold_id);
    std::fill(manifold_quad_ids.begin(),
              manifold_quad_ids.end(),
              numbers::flat_manifold_id);
  }
 
 
 
  template <int dim>
  template <class Archive>
  void
  CellData<dim>::serialize(Archive &ar, const unsigned int /*version*/)
  {
    ar &id;
    ar &subdomain_id;
    ar &level_subdomain_id;
    ar &manifold_id;
    if (dim >= 2)
      ar &manifold_line_ids;
    if (dim >= 3)
      ar &manifold_quad_ids;
    ar &boundary_ids;
  }
 
 
 
  template <int dim, int spacedim>
  Description<dim, spacedim>::Description()
    : comm(MPI_COMM_NULL)
    , settings(Settings::default_setting)
    , smoothing(Triangulation<dim, spacedim>::MeshSmoothing::none)
  {}
 
 
 
  template <int dim, int spacedim>
  template <class Archive>
  void
  Description<dim, spacedim>::serialize(Archive &ar,
                                        const unsigned int /*version*/)
  {
    ar &coarse_cells;
    ar &coarse_cell_vertices;
    ar &coarse_cell_index_to_coarse_cell_id;
    ar &cell_infos;
    ar &settings;
    ar &smoothing;
  }
 
 
 
  template <int dim>
  bool
  CellData<dim>::operator==(const CellData<dim> &other) const
  {
    if (this->id != other.id)
      return false;
    if (this->subdomain_id != other.subdomain_id)
      return false;
    if (this->level_subdomain_id != other.level_subdomain_id)
      return false;
    if (this->manifold_id != other.manifold_id)
      return false;
    if (dim >= 2 && this->manifold_line_ids != other.manifold_line_ids)
      return false;
    if (dim >= 3 && this->manifold_quad_ids != other.manifold_quad_ids)
      return false;
    if (this->boundary_ids != other.boundary_ids)
      return false;
 
    return true;
  }
 
 
 
  template <int dim, int spacedim>
  bool
  Description<dim, spacedim>::operator==(
    const Description<dim, spacedim> &other) const
  {
    if (this->coarse_cells != other.coarse_cells)
      return false;
    if (this->coarse_cell_vertices != other.coarse_cell_vertices)
      return false;
    if (this->coarse_cell_index_to_coarse_cell_id !=
        other.coarse_cell_index_to_coarse_cell_id)
      return false;
    if (this->cell_infos != other.cell_infos)
      return false;
    if (this->settings != other.settings)
      return false;
    if (this->smoothing != other.smoothing)
      return false;
 
    return true;
  }
} // namespace TriangulationDescription
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif