dof_objects.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2006 - 2023 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_dof_objects_h
#define dealii_dof_objects_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/template_constraints.h>
 
#include <vector>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class DoFHandler;
#endif
 
namespace internal
{
  namespace DoFHandlerImplementation
  {
#ifndef DOXYGEN
    template <int>
    class DoFLevel;
    template <int>
    class DoFFaces;
#endif
 
    template <int dim>
    class DoFObjects
    {
    public:
      std::vector<types::global_dof_index> dofs;
 
      template <int dh_dim, int spacedim>
      types::global_dof_index &
      access_dof_index(const DoFHandler<dh_dim, spacedim> &dof_handler,
                       const unsigned int                  obj_index,
                       const types::fe_index               fe_index,
                       const unsigned int                  local_index);
 
      template <int dh_dim, int spacedim>
      unsigned int
      n_active_fe_indices(const DoFHandler<dh_dim, spacedim> &dof_handler,
                          const types::global_dof_index       index) const;
 
      template <int dh_dim, int spacedim>
      bool
      fe_index_is_active(const DoFHandler<dh_dim, spacedim> &dof_handler,
                         const types::global_dof_index       index,
                         const types::fe_index               fe_index) const;
 
      std::size_t
      memory_consumption() const;
 
      template <class Archive>
      void
      serialize(Archive &ar, const unsigned int version);
 
      // Declare the classes that store levels and faces of DoFs friends so
      // that they can resize arrays.
      template <int>
      friend class DoFLevel;
      template <int>
      friend class DoFFaces;
    };
 
 
    // --------------------- template and inline functions ------------------
 
    template <int dim>
    template <int dh_dim, int spacedim>
    inline unsigned int
    DoFObjects<dim>::n_active_fe_indices(const DoFHandler<dh_dim, spacedim> &,
                                         const types::global_dof_index) const
    {
      return 1;
    }
 
 
 
    template <int dim>
    template <int dh_dim, int spacedim>
    inline bool
    DoFObjects<dim>::fe_index_is_active(const DoFHandler<dh_dim, spacedim> &,
                                        const types::global_dof_index,
                                        const types::fe_index fe_index) const
    {
      (void)fe_index;
      Assert((fe_index == DoFHandler<dh_dim, spacedim>::default_fe_index),
             ExcMessage("Only zero fe_index values are allowed for "
                        "non-hp-DoFHandlers."));
      return true;
    }
 
 
 
    template <int dim>
    template <int dh_dim, int spacedim>
    inline types::global_dof_index &
    DoFObjects<dim>::access_dof_index(
      const DoFHandler<dh_dim, spacedim> &dof_handler,
      const unsigned int                  obj_index,
      const types::fe_index               fe_index,
      const unsigned int                  local_index)
    {
      (void)fe_index;
      Assert((fe_index == DoFHandler<dh_dim, spacedim>::default_fe_index),
             ExcMessage("Only the default FE index is allowed for DoFHandler "
                        "objects without hp capability"));
      AssertIndexRange(local_index,
                       dof_handler.get_fe().template n_dofs_per_object<dim>());
      AssertIndexRange(
        obj_index * dof_handler.get_fe().template n_dofs_per_object<dim>() +
          local_index,
        dofs.size());
 
      return dofs[obj_index *
                    dof_handler.get_fe().template n_dofs_per_object<dim>() +
                  local_index];
    }
 
 
    template <int dim>
    template <class Archive>
    void
    DoFObjects<dim>::serialize(Archive &ar, const unsigned int)
    {
      ar &dofs;
    }
 
  } // namespace DoFHandlerImplementation
} // namespace internal
 
DEAL_II_NAMESPACE_CLOSE
 
#endif