element.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/element_base.hpp>
#include <kernel/space/dof_assignment_base.hpp>
#include <kernel/space/dof_mapping_common.hpp>
#include <kernel/space/discontinuous/dof_traits.hpp>
#include <kernel/space/discontinuous/evaluator.hpp>
#include <kernel/space/discontinuous/node_functional.hpp>
 
namespace FEAT
{
  namespace Space
  {
    namespace Discontinuous
    {
      template<
        typename Trafo_,
        typename Variant_ = Variant::StdPolyP<0> >
      class Element :
        public ElementBase<Trafo_>
      {
      public:
        typedef ElementBase<Trafo_> BaseClass;
        typedef Trafo_ TrafoType;
        typedef typename TrafoType::MeshType MeshType;
        typedef typename TrafoType::ShapeType ShapeType;
        typedef Variant_ VariantTag;
 
        static constexpr bool have_node_func = true;
 
        static constexpr int local_degree = VariantTag::local_degree;
 
        static constexpr int num_local_dofs = DofTraits<DofTag<ShapeType, VariantTag>, ShapeType::dimension>::count;
 
        template<
          typename TrafoEvaluator_,
          typename DataType_ = typename TrafoEvaluator_::DataType>
        class Evaluator
        {
        private:
          typedef typename TrafoEvaluator_::EvalPolicy EvalPolicy;
 
          typedef StandardScalarEvalTraits<EvalPolicy, num_local_dofs, DataType_> Traits;
 
        public:
          typedef Discontinuous::Evaluator<Element, TrafoEvaluator_, Traits, VariantTag> Type;
        };
 
        typedef DofMappingSingleEntity<Element, 0, num_local_dofs> DofMappingType;
 
        template<
          int shape_dim_,
          typename DataType_ = Real>
        class DofAssignment
        {
        public:
          //typedef DofAssignmentSingleEntity<Element, shape_dim_, DataType_, ShapeType::dimension> Type;
          typedef DofAssignmentUniform<Element, shape_dim_, DataType_, DofTraits, DofTag<ShapeType, VariantTag> > Type;
        };
 
        template<
          int shape_dim_,
          typename DataType_ = Real>
        class NodeFunctional
        {
        private:
          static constexpr int codim = ShapeType::dimension - shape_dim_;
 
        public:
          typedef Discontinuous::NodeFunctional<Element, codim, VariantTag, DataType_> Type;
        };
 
      public:
        explicit Element(TrafoType& trafo)
          : BaseClass(trafo)
        {
        }
 
        virtual ~Element()
        {
        }
 
        Index get_num_dofs() const
        {
          // number of DOFs = number of cells in the mesh
          return this->get_mesh().get_num_entities(ShapeType::dimension) * Index(num_local_dofs);
        }
 
        static String name()
        {
          return String("Discontinuous<") + Variant_::name() + ">";
        }
 
      }; // class Element
 
      template<typename Trafo_>
      using ElementP0 = Element<Trafo_, Variant::StdPolyP<0> >;
 
      template<typename Trafo_>
      using ElementP1 = Element<Trafo_, Variant::StdPolyP<1> >;
    } // namespace Discontinuous
  } // namespace Space
} // namespace FEAT