components.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2022 by Luca Heltai
//
// This file is part of the FSI-suite platform, based on the deal.II library.
//
// The FSI-suite platform 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 3.0 of the License,
// or (at your option) any later version. The full text of the license can be
// found in the file LICENSE at the top level of the FSI-suite platform
// distribution.
//
// ---------------------------------------------------------------------
 
#ifndef parsed_tools_components_h
#define parsed_tools_components_h
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/quadrature.h>
#include <deal.II/base/quadrature_lib.h>
#include <deal.II/base/utilities.h>
 
#include <deal.II/fe/component_mask.h>
#include <deal.II/fe/fe_dgq.h>
#include <deal.II/fe/fe_q.h>
#include <deal.II/fe/fe_simplex_p.h>
#include <deal.II/fe/fe_system.h>
 
#include <deal.II/grid/tria.h>
 
#include "parsed_tools/enum.h"
 
namespace ParsedTools
{
  namespace Components
  {
    enum class Type
    {
      all        = 0, 
      scalar     = 1, 
      vector     = 2, 
      normal     = 3, 
      tangential = 4, 
    };
 
    template <int dim, int spacedim>
    std::unique_ptr<dealii::FiniteElement<dim, spacedim>>
    get_lagrangian_finite_element(
      const dealii::Triangulation<dim, spacedim> &tria,
      const unsigned int                          degree     = 1,
      const int                                   continuity = 0);
 
    template <int dim, int spacedim>
    dealii::Quadrature<dim>
    get_cell_quadrature(const dealii::Triangulation<dim, spacedim> &tria,
                        const unsigned int                          degree);
 
    template <int dim, int spacedim>
    dealii::Quadrature<dim - 1>
    get_face_quadrature(const dealii::Triangulation<dim, spacedim> &tria,
                        const unsigned int                          degree);
 
    template <typename Container>
    std::string
    join(const Container &strings, const std::string &separator);
 
    unsigned int
    n_components(const std::string &component_names);
 
    unsigned int
    n_blocks(const std::string &component_names);
 
 
    std::string
    blocks_to_names(const std::vector<std::string>  &components,
                    const std::vector<unsigned int> &multiplicities);
 
    std::pair<std::vector<std::string>, std::vector<unsigned int>>
    names_to_blocks(const std::string &component_names);
 
    std::vector<unsigned int>
    block_indices(const std::string &component_names,
                  const std::string &selected_components);
 
    std::vector<unsigned int>
    component_indices(const std::string &component_names,
                      const std::string &selected_components);
 
    std::pair<unsigned int, unsigned int>
    component_to_indices(const std::string &component_names,
                         const std::string &selected_component);
 
    std::string
    component_name(const std::string &component_names,
                   const std::string &selected_component);
 
    Type
    type(const std::string &component_name,
         const std::string &selected_component);
 
    dealii::ComponentMask
    mask(const std::string &component_names,
         const std::string &selected_component);
 
 
 
#ifndef DOXYGEN
    // Template implementation
    template <typename Container>
    std::string
    join(const Container &strings, const std::string &separator)
    {
      std::string result;
      std::string sep = "";
      for (const auto &s : strings)
        {
          result += sep + s;
          sep = separator;
        }
      return result;
    }
 
 
 
    template <int dim, int spacedim>
    std::unique_ptr<dealii::FiniteElement<dim, spacedim>>
    get_lagrangian_finite_element(
      const dealii::Triangulation<dim, spacedim> &tria,
      const unsigned int                          degree,
      const int                                   continuity)
    {
      const auto ref_cells = tria.get_reference_cells();
      AssertThrow(
        ref_cells.size() == 1,
        dealii::ExcMessage(
          "This function does nots support mixed simplx/hex grid types."));
      AssertThrow(continuity == -1 || continuity == 0,
                  dealii::ExcMessage(
                    "only -1 and 0 are supported for continuity"));
      std::unique_ptr<dealii::FiniteElement<dim, spacedim>> result;
      if (ref_cells[0].is_simplex())
        {
          if (continuity == 0)
            result.reset(new dealii::FE_SimplexP<dim, spacedim>(degree));
          else
            result.reset(new dealii::FE_SimplexDGP<dim, spacedim>(degree));
        }
      else
        {
          Assert(ref_cells[0].is_hyper_cube(),
                 dealii::ExcMessage(
                   "Only simplex and hex cells are supported"));
          if (continuity == 0)
            result.reset(new dealii::FE_Q<dim, spacedim>(degree));
          else
            result.reset(new dealii::FE_DGQ<dim, spacedim>(degree));
        }
      return result;
    }
 
 
 
    template <int dim, int spacedim>
    dealii::Quadrature<dim>
    get_cell_quadrature(const dealii::Triangulation<dim, spacedim> &tria,
                        const unsigned int                          degree)
    {
      const auto ref_cells = tria.get_reference_cells();
 
      AssertThrow(
        ref_cells.size() == 1,
        dealii::ExcMessage(
          "This function does nots support mixed simplx/hex grid types."));
      return ref_cells[0].template get_gauss_type_quadrature<dim>(degree);
    }
 
 
 
    template <int dim, int spacedim>
    dealii::Quadrature<dim - 1>
    get_face_quadrature(const dealii::Triangulation<dim, spacedim> &tria,
                        const unsigned int                          degree)
    {
      if constexpr (dim == 1)
        {
          return dealii::QGauss<dim - 1>(degree);
        }
      else
        {
          const auto ref_cells = tria.get_reference_cells();
 
          AssertThrow(
            ref_cells.size() == 1,
            dealii::ExcMessage(
              "This function does nots support mixed simplx/hex grid types."));
 
          const dealii::ReferenceCell face_type =
            ref_cells[0].face_reference_cell(0);
          return face_type.template get_gauss_type_quadrature<dim - 1>(degree);
        }
    }
#endif
  } // namespace Components
} // namespace ParsedTools
#endif