tria_description.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2019 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#ifndef dealii_grid_construction_utilities_h
#define dealii_grid_construction_utilities_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_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
 
/*------------------------------------------------------------------------*/
 
template <int structdim>
struct CellData
{
  std::vector<unsigned int> vertices;
 
  union
  {
    types::material_id material_id;
 
    types::boundary_id boundary_id;
  };
 
  types::manifold_id manifold_id;
 
  CellData(const unsigned int n_vertices =
             ReferenceCells::get_hypercube<structdim>().n_vertices());
 
  bool
  operator==(const CellData<structdim> &other) const;
 
  template <class Archive>
  void
  serialize(Archive &ar, const unsigned int version);
 
  static_assert(structdim > 0,
                "The class CellData can only be used for structdim>0.");
};
 
 
 
struct SubCellData
{
  std::vector<CellData<1>> boundary_lines;
 
  std::vector<CellData<2>> boundary_quads;
 
  bool
  check_consistency(const unsigned int dim) const;
};
 
 
template <int structdim>
template <class Archive>
void
CellData<structdim>::serialize(Archive &ar, const unsigned int /*version*/)
{
  ar &vertices;
  ar &material_id;
  ar &boundary_id;
  ar &manifold_id;
}
 
namespace TriangulationDescription
{
  enum Settings
  {
    default_setting = 0x0,
    construct_multigrid_hierarchy = 0x1
  };
 
  template <int dim>
  struct 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>
  struct 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>
  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>
  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