dof_level.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2003 - 2015 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 at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii__hp_dof_level_h
#define dealii__hp_dof_level_h


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

#include <vector>


DEAL_II_NAMESPACE_OPEN

namespace hp
{
  template <int, int> class DoFHandler;
  template <int, int> class FECollection;
}


namespace internal
{
  namespace hp
  {
    namespace DoFHandler
    {
      struct Implementation;
    }
  }
  namespace DoFCellAccessor
  {
    struct Implementation;
  }
}


namespace internal
{
  namespace hp
  {
    class DoFLevel
    {
    private:
      typedef unsigned int offset_type;

      typedef unsigned short int active_fe_index_type;

      typedef signed short int signed_active_fe_index_type;

      std::vector<active_fe_index_type> active_fe_indices;

      std::vector<offset_type> dof_offsets;

      std::vector<types::global_dof_index> dof_indices;

      std::vector<offset_type> cell_cache_offsets;

      std::vector<types::global_dof_index> cell_dof_indices_cache;

    public:

      void
      set_dof_index (const unsigned int               obj_index,
                     const unsigned int               fe_index,
                     const unsigned int               local_index,
                     const types::global_dof_index    global_index);

      types::global_dof_index
      get_dof_index (const unsigned int               obj_index,
                     const unsigned int               fe_index,
                     const unsigned int               local_index) const;

      unsigned int
      active_fe_index (const unsigned int obj_index) const;

      bool
      fe_index_is_active (const unsigned int               obj_index,
                          const unsigned int               fe_index) const;

      void
      set_active_fe_index (const unsigned int obj_index,
                           const unsigned int fe_index);

      const types::global_dof_index *
      get_cell_cache_start (const unsigned int obj_index,
                            const unsigned int dofs_per_cell) const;

      std::size_t memory_consumption () const;

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

    private:
      template <int dim, int spacedim>
      void compress_data (const ::hp::FECollection<dim,spacedim> &fe_collection);

      template <int dim, int spacedim>
      void uncompress_data (const ::hp::FECollection<dim,spacedim> &fe_collection);

      template <int, int> friend class ::hp::DoFHandler;
      friend struct ::internal::hp::DoFHandler::Implementation;
      friend struct ::internal::DoFCellAccessor::Implementation;
    };


    // -------------------- template functions --------------------------------

    inline
    types::global_dof_index
    DoFLevel::
    get_dof_index (const unsigned int                obj_index,
                   const unsigned int                fe_index,
                   const unsigned int                local_index) const
    {
      (void)fe_index;
      Assert (obj_index < dof_offsets.size(),
              ExcIndexRange (obj_index, 0, dof_offsets.size()));

      // make sure we are on an
      // object for which DoFs have
      // been allocated at all
      Assert (dof_offsets[obj_index] != (offset_type)(-1),
              ExcMessage ("You are trying to access degree of freedom "
                          "information for an object on which no such "
                          "information is available"));

      Assert (fe_index == active_fe_indices[obj_index],
              ExcMessage ("FE index does not match that of the present cell"));

      // see if the dof_indices array has been compressed for this
      // particular cell
      if ((signed_active_fe_index_type)active_fe_indices[obj_index]>=0)
        return dof_indices[dof_offsets[obj_index]+local_index];
      else
        return dof_indices[dof_offsets[obj_index]]+local_index;
    }



    inline
    void
    DoFLevel::
    set_dof_index (const unsigned int                obj_index,
                   const unsigned int                fe_index,
                   const unsigned int                local_index,
                   const types::global_dof_index     global_index)
    {
      (void)fe_index;
      Assert (obj_index < dof_offsets.size(),
              ExcIndexRange (obj_index, 0, dof_offsets.size()));

      // make sure we are on an
      // object for which DoFs have
      // been allocated at all
      Assert (dof_offsets[obj_index] != (offset_type)(-1),
              ExcMessage ("You are trying to access degree of freedom "
                          "information for an object on which no such "
                          "information is available"));
      Assert ((signed_active_fe_index_type)active_fe_indices[obj_index]>=0,
              ExcMessage ("This function can no longer be called after compressing the dof_indices array"));
      Assert (fe_index == active_fe_indices[obj_index],
              ExcMessage ("FE index does not match that of the present cell"));
      dof_indices[dof_offsets[obj_index]+local_index] = global_index;
    }



    inline
    unsigned int
    DoFLevel::
    active_fe_index (const unsigned int obj_index) const
    {
      Assert (obj_index < active_fe_indices.size(),
              ExcIndexRange (obj_index, 0, active_fe_indices.size()));

      if (((signed_active_fe_index_type)active_fe_indices[obj_index]) >= 0)
        return active_fe_indices[obj_index];
      else
        return (active_fe_index_type)~(signed_active_fe_index_type)active_fe_indices[obj_index];
    }



    inline
    bool
    DoFLevel::
    fe_index_is_active (const unsigned int                obj_index,
                        const unsigned int                fe_index) const
    {
      return (fe_index == active_fe_index(obj_index));
    }


    inline
    void
    DoFLevel::
    set_active_fe_index (const unsigned int obj_index,
                         const unsigned int fe_index)
    {
      Assert (obj_index < active_fe_indices.size(),
              ExcIndexRange (obj_index, 0, active_fe_indices.size()));

      active_fe_indices[obj_index] = fe_index;
    }



    inline
    const types::global_dof_index *
    DoFLevel::get_cell_cache_start (const unsigned int obj_index,
                                    const unsigned int dofs_per_cell) const
    {
      (void)dofs_per_cell;
      Assert (obj_index < cell_cache_offsets.size(),
              ExcInternalError());
      Assert (cell_cache_offsets[obj_index]+dofs_per_cell
              <=
              cell_dof_indices_cache.size(),
              ExcInternalError());

      return &cell_dof_indices_cache[cell_cache_offsets[obj_index]];
    }

    template <class Archive>
    inline
    void
    DoFLevel::serialize(Archive &ar,
                        const unsigned int)
    {
      ar &this->active_fe_indices;
      ar &this->cell_cache_offsets;
      ar &this->cell_dof_indices_cache;
      ar &this->dof_indices;
      ar &this->dof_offsets;
    }
  } // namespace hp

} // namespace internal

DEAL_II_NAMESPACE_CLOSE

#endif