dof_assignment_base.hpp

// FEAT3: Finite Element Analysis Toolbox, Version 3
// Copyright (C) 2010 by Stefan Turek & the FEAT group
// FEAT3 is released under the GNU General Public License version 3,
// see the file 'copyright.txt' in the top level directory for details.
 
#pragma once
 
// includes, FEAT
#include <kernel/space/base.hpp>
 
namespace FEAT
{
  namespace Space
  {
    template<
      typename Space_,
      int shape_dim_,
      typename DataType_>
    class DofAssignmentBase
    {
    public:
      typedef Space_ SpaceType;
 
    protected:
      const SpaceType& _space;
      Index _cell_index;
 
      explicit DofAssignmentBase(const SpaceType& space) :
        _space(space),
        _cell_index(~Index(0))
      {
      }
 
    public:
      void prepare(Index cell_index)
      {
        _cell_index = cell_index;
      }
 
      void finish()
      {
        _cell_index = ~Index(0);
      }
 
#ifdef DOXYGEN
      int get_max_assigned_dofs() const;
 
      int get_num_assigned_dofs() const;
 
      Index get_index(int assign_idx) const;
#endif // DOXYGEN
    }; // class DofAssignmentBase
 
    namespace Intern
    {
      template<typename Tag_, template<typename, int> class Traits_, int cell_dim_>
      struct UniformDofAssignHelper
      {
        template<typename Mesh_>
        static Index dof_offset(const Mesh_& mesh)
        {
          return UniformDofAssignHelper<Tag_, Traits_, cell_dim_ - 1>::dof_offset(mesh)
            + mesh.get_num_entities(cell_dim_-1) * Index(Traits_<Tag_, cell_dim_ - 1>::count);
        }
      };
 
      template<typename Tag_, template<typename, int> class Traits_>
      struct UniformDofAssignHelper<Tag_, Traits_, 0>
      {
        template<typename Mesh_>
        static Index dof_offset(const Mesh_&)
        {
          return Index(0);
        }
      };
    } // namespace Intern
 
    template<
      typename Space_,
      int shape_dim_,
      typename DataType_,
      template<typename Tag_, int dim_> class DofTraits_,
      typename DofTag_>
    class DofAssignmentUniform
      : public DofAssignmentBase<Space_, shape_dim_, DataType_>
    {
    public:
      typedef DofAssignmentBase<Space_, shape_dim_, DataType_> BaseClass;
      typedef Space_ SpaceType;
      typedef typename SpaceType::ShapeType ShapeType;
 
      // number of dofs for each cell
      static constexpr int dofs_per_cell = DofTraits_<DofTag_, shape_dim_>::count;
 
    protected:
      Index _dof_offset;
 
    public:
      explicit DofAssignmentUniform(const SpaceType& space) :
        BaseClass(space),
        _dof_offset(Intern::UniformDofAssignHelper<DofTag_, DofTraits_, shape_dim_>::dof_offset(space.get_mesh()))
      {
      }
 
      int get_max_assigned_dofs() const
      {
        return dofs_per_cell;
      }
 
      int get_num_assigned_dofs() const
      {
        return dofs_per_cell;
      }
 
      Index get_index(int assign_idx) const
      {
        return _dof_offset + Index(dofs_per_cell) * this->_cell_index + Index(assign_idx);
      }
    };
  } // namespace Space
} // namespace FEAT