element_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/dof_mapping_base.hpp>
#include <kernel/space/evaluator_base.hpp>
 
namespace FEAT
{
  namespace Space
  {
    template<typename Trafo_>
    class ElementBase
    {
    public:
      typedef Trafo_ TrafoType;
      typedef typename TrafoType::MeshType MeshType;
      typedef typename TrafoType::ShapeType ShapeType;
 
      static constexpr int shape_dim = ShapeType::dimension;
      static constexpr int world_dim = MeshType::world_dim;
 
      /*
       * \brief Specifies whether the element has node functionals
       *
       * If this value is 1, the element implements node functionals, i.e. the Type member of the
       * nested NodeFunctional class template is defined.
       */
      static constexpr bool have_node_func = false;
 
      // Note:
      // The following block serves as an element interface documentation and is therefore only
      // visible to doxygen. The actual functionality has to be supplied by the implementation.
#ifdef DOXYGEN
      template<
        typename TrafoEvaluator_,
        typename DataType_ = typename TrafoEvaluator_::DataType>
      class Evaluator
      {
      public:
        typedef ... Type;
      };
 
      static constexpr int local_degree = ...;
 
      typedef ... DofMappingType;
 
      template<
        int shape_dim_,
        typename DataType_ = Real>
      class DofAssignment
      {
      public:
        typedef ... Type;
      };
 
      template<
        int shape_dim_,
        typename DataType_ = Real>
      class NodeFunctional
      {
      public:
        typedef ... Type;
      };
 
      Index get_num_dofs() const;
 
      String name() const;
#endif // DOXYGEN
 
    private:
      ElementBase(const ElementBase&);
      ElementBase& operator=(const ElementBase&);
 
    protected:
      TrafoType& _trafo;
 
      explicit ElementBase(TrafoType& trafo)
        : _trafo(trafo)
      {
      }
 
    public:
      TrafoType& get_trafo()
      {
        return _trafo;
      }
 
      const TrafoType& get_trafo() const
      {
        return _trafo;
      }
 
      MeshType& get_mesh()
      {
        return get_trafo().get_mesh();
      }
 
      const MeshType& get_mesh() const
      {
        return get_trafo().get_mesh();
      }
 
      bool operator==(const ElementBase& other) const
      {
        return this == &other;
      }
    }; // class ElementBase<...>
  } // namespace Space
} // namespace FEAT