mesh_classifier.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2021 - 2021 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_non_matching_mesh_classifier
#define dealii_non_matching_mesh_classifier
 
#include <deal.II/base/config.h>
 
#include <deal.II/dofs/dof_handler.h>
 
#include <deal.II/grid/tria.h>
#include <deal.II/grid/tria_accessor.h>
 
#include <deal.II/lac/lapack_full_matrix.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
namespace NonMatching
{
  namespace internal
  {
    namespace MeshClassifierImplementation
    {
      template <int dim>
      class LevelSetDescription;
    } // namespace MeshClassifierImplementation
  }   // namespace internal
 
 
  enum class LocationToLevelSet
  {
    inside,
    outside,
    intersected,
    unassigned
  };
 
 
  template <int dim>
  class MeshClassifier : public Subscriptor
  {
  public:
    template <class VectorType>
    MeshClassifier(const DoFHandler<dim> &level_set_dof_handler,
                   const VectorType &     level_set);
 
    MeshClassifier(const Triangulation<dim> &triangulation,
                   const Function<dim> &     level_set,
                   const FiniteElement<dim> &element);
 
    void
    reclassify();
 
    LocationToLevelSet
    location_to_level_set(
      const typename Triangulation<dim>::cell_iterator &cell) const;
 
    LocationToLevelSet
    location_to_level_set(
      const typename Triangulation<dim>::cell_iterator &cell,
      const unsigned int                                face_index) const;
 
  private:
    void
    initialize();
 
    LocationToLevelSet
    determine_face_location_to_levelset(
      const typename Triangulation<dim>::active_cell_iterator &cell,
      const unsigned int                                       face_index);
 
    const SmartPointer<const Triangulation<dim>> triangulation;
 
    const std::unique_ptr<
      internal::MeshClassifierImplementation::LevelSetDescription<dim>>
      level_set_description;
 
    std::vector<LocationToLevelSet> cell_locations;
 
    std::vector<LocationToLevelSet> face_locations;
 
    std::vector<
      std::array<LAPACKFullMatrix<double>, GeometryInfo<dim>::faces_per_cell>>
      lagrange_to_bernstein_face;
  };
 
 
  namespace internal
  {
    namespace MeshClassifierImplementation
    {
      template <int dim>
      class LevelSetDescription
      {
      public:
        virtual ~LevelSetDescription() = default;
 
        virtual const hp::FECollection<dim> &
        get_fe_collection() const = 0;
 
        virtual unsigned int
        active_fe_index(const typename Triangulation<dim>::active_cell_iterator
                          &cell) const = 0;
 
        virtual void
        get_local_level_set_values(
          const typename Triangulation<dim>::active_cell_iterator &cell,
          const unsigned int                                       face_index,
          Vector<double> &local_dofs) = 0;
      };
 
    } // namespace MeshClassifierImplementation
  }   // namespace internal
} // namespace NonMatching
DEAL_II_NAMESPACE_CLOSE
 
#endif