dof_objects.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2006 - 2019 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_dof_objects_h
#define dealii_dof_objects_h


#include <deal.II/base/config.h>

#include <deal.II/base/exceptions.h>

#include <vector>

DEAL_II_NAMESPACE_OPEN

template <int, int>
class DoFHandler;

namespace internal
{
  namespace DoFHandlerImplementation
  {
    template <int>
    class DoFLevel;
    template <int>
    class DoFFaces;


    template <int dim>
    class DoFObjects
    {
    public:
      std::vector<types::global_dof_index> dofs;

    public:
      template <int dh_dim, int spacedim>
      void
      set_dof_index(const ::DoFHandler<dh_dim, spacedim> &dof_handler,
                    const unsigned int                          obj_index,
                    const unsigned int                          fe_index,
                    const unsigned int                          local_index,
                    const types::global_dof_index               global_index);

      template <int dh_dim, int spacedim>
      types::global_dof_index
      get_dof_index(const ::DoFHandler<dh_dim, spacedim> &dof_handler,
                    const unsigned int                          obj_index,
                    const unsigned int                          fe_index,
                    const unsigned int local_index) const;

      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 unsigned int                          fe_index) const;

      std::size_t
      memory_consumption() const;

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

      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 unsigned int fe_index) const
    {
      (void)fe_index;
      Assert(fe_index == 0,
             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>::get_dof_index(
      const ::DoFHandler<dh_dim, spacedim> &dof_handler,
      const unsigned int                          obj_index,
      const unsigned int                          fe_index,
      const unsigned int                          local_index) const
    {
      (void)fe_index;
      Assert(
        (fe_index == ::DoFHandler<dh_dim, spacedim>::default_fe_index),
        ExcMessage(
          "Only the default FE index is allowed for non-hp DoFHandler objects"));
      Assert(
        local_index < dof_handler.get_fe().template n_dofs_per_object<dim>(),
        ExcIndexRange(local_index,
                      0,
                      dof_handler.get_fe().template n_dofs_per_object<dim>()));
      Assert(obj_index *
                   dof_handler.get_fe().template n_dofs_per_object<dim>() +
                 local_index <
               dofs.size(),
             ExcInternalError());

      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