evaluator.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/parametric_evaluator.hpp>
#include <kernel/space/dof_mapping_common.hpp>
 
namespace FEAT
{
  namespace Space
  {
    namespace P2Bubble
    {
      static constexpr SpaceTags ref_caps = SpaceTags::ref_value | SpaceTags::ref_grad | SpaceTags::ref_hess;
 
      template<
        typename Space_,
        typename TrafoEvaluator_,
        typename SpaceEvalTraits_,
        typename Shape_ = typename Space_::ShapeType>
      class Evaluator DOXY({});
 
      template<
        typename Space_,
        typename TrafoEvaluator_,
        typename SpaceEvalTraits_>
      class Evaluator<Space_, TrafoEvaluator_, SpaceEvalTraits_, Shape::Simplex<2> > :
        public ParametricEvaluator<
          Evaluator<
            Space_,
            TrafoEvaluator_,
            SpaceEvalTraits_,
            Shape::Simplex<2> >,
          TrafoEvaluator_,
          SpaceEvalTraits_,
          ref_caps>
      {
      public:
        typedef ParametricEvaluator<Evaluator, TrafoEvaluator_, SpaceEvalTraits_, ref_caps> BaseClass;
 
        typedef Space_ SpaceType;
 
        typedef SpaceEvalTraits_ SpaceEvalTraits;
 
        typedef typename SpaceEvalTraits::EvalPolicy EvalPolicy;
 
        typedef typename EvalPolicy::DomainPointType DomainPointType;
 
        typedef typename SpaceEvalTraits::DataType DataType;
 
      public:
        explicit Evaluator(const SpaceType& DOXY(space))
        {
        }
 
        int get_num_local_dofs() const
        {
          return 7;
        }
 
        template<typename EvalData_>
        void eval_ref_values(
          EvalData_& data,
          const DomainPointType& point) const
        {
          const DataType x = point[0];
          const DataType y = point[1];
          // vertex dofs
          data.phi[0].ref_value = (DataType(1) + DataType(3)*x*y - DataType(2)*(x + y))*(DataType(1) - x - y);
          data.phi[1].ref_value = x*(DataType(2)*x + DataType(3)*y*(DataType(1) - x - y) - DataType(1));
          data.phi[2].ref_value = y*(DataType(2)*y + DataType(3)*x*(DataType(1) - x - y) - DataType(1));
          // edge dofs
          data.phi[3].ref_value = DataType(4)*x*y*(DataType(3)*(x+y)-DataType(2));
          data.phi[4].ref_value = DataType(4)*y*(DataType(3)*x-DataType(1))*(x+y-DataType(1));
          data.phi[5].ref_value = DataType(4)*x*(DataType(3)*y-DataType(1))*(x+y-DataType(1));
          // centre dof
          data.phi[6].ref_value = DataType(27)*x*y*(DataType(1)-x-y);
        }
 
        template<typename EvalData_>
        void eval_ref_gradients(
          EvalData_& data,
          const DomainPointType& point) const
        {
          const DataType x = point[0];
          const DataType y = point[1];
          // vertex dofs
          data.phi[0].ref_grad[0] = y*(DataType(7)-DataType(3)*y-DataType(6)*x)+DataType(4)*x-DataType(3);
          data.phi[0].ref_grad[1] = x*(DataType(7)-DataType(3)*x-DataType(6)*y)+DataType(4)*y-DataType(3);
          data.phi[1].ref_grad[0] = DataType(3)*y*(DataType(1)-y-DataType(2)*x)+DataType(4)*x-DataType(1);
          data.phi[1].ref_grad[1] = DataType(3)*x*(DataType(1)-x-DataType(2)*y);
          data.phi[2].ref_grad[0] = DataType(3)*y*(DataType(1)-y-DataType(2)*x);
          data.phi[2].ref_grad[1] = DataType(3)*x*(DataType(1)-x-DataType(2)*y)+DataType(4)*y-DataType(1);
          // edge dofs
          data.phi[3].ref_grad[0] = DataType(4)*y*(DataType(6)*x+DataType(3)*y-DataType(2));
          data.phi[3].ref_grad[1] = DataType(4)*x*(DataType(3)*x+DataType(6)*y-DataType(2));
          data.phi[4].ref_grad[0] = DataType(4)*y*(DataType(6)*x+DataType(3)*y-DataType(4));
          data.phi[4].ref_grad[1] = DataType(4)*(DataType(3)*x-DataType(1))*(x+DataType(2)*y-DataType(1));
          data.phi[5].ref_grad[0] = DataType(4)*(DataType(3)*y-DataType(1))*(y+DataType(2)*x-DataType(1));
          data.phi[5].ref_grad[1] = DataType(4)*x*(DataType(3)*x+DataType(6)*y-DataType(4));
          // centre dof
          data.phi[6].ref_grad[0] = DataType(27)*y*(DataType(1)-y-DataType(2)*x);
          data.phi[6].ref_grad[1] = DataType(27)*x*(DataType(1)-x-DataType(2)*y);
        }
 
        template<typename EvalData_>
        void eval_ref_hessians(
          EvalData_& data,
          const DomainPointType& point) const
        {
          const DataType x = point[0];
          const DataType y = point[1];
          // vertex dofs
          data.phi[0].ref_hess[0][0] = -DataType(6)*y+DataType(4);
          data.phi[0].ref_hess[1][1] =-DataType(6)*x+DataType(4);
          data.phi[0].ref_hess[0][1] = data.phi[0].ref_hess[1][0] = DataType(7)-DataType(6)*(x+y);
          data.phi[1].ref_hess[0][0] = -DataType(6)*y+DataType(4);
          data.phi[1].ref_hess[1][1] = -DataType(6)*x;
          data.phi[1].ref_hess[0][1] = data.phi[1].ref_hess[1][0] = DataType(3)-DataType(6)*(x+y);
          data.phi[2].ref_hess[0][0] = -DataType(6)*y;
          data.phi[2].ref_hess[1][1] = -DataType(6)*x+DataType(4);
          data.phi[2].ref_hess[0][1] = data.phi[2].ref_hess[1][0] = DataType(3)-DataType(6)*(x+y);
          // edge dofs
          data.phi[3].ref_hess[0][0] = DataType(24)*y;
          data.phi[3].ref_hess[1][1] = DataType(24)*x;
          data.phi[3].ref_hess[0][1] = data.phi[3].ref_hess[1][0] = DataType(8)*(DataType(3)*(x+y)-DataType(1));
          data.phi[4].ref_hess[0][0] = DataType(24)*y;
          data.phi[4].ref_hess[1][1] = DataType(24)*x-DataType(8);
          data.phi[4].ref_hess[0][1] = data.phi[4].ref_hess[1][0] = DataType(8)*(DataType(3)*(x+y)-DataType(2));
          data.phi[5].ref_hess[0][0] = DataType(24)*y-DataType(8);
          data.phi[5].ref_hess[1][1] = DataType(24)*x;
          data.phi[5].ref_hess[0][1] = data.phi[5].ref_hess[1][0] = DataType(8)*(DataType(3)*(x+y)-DataType(2));
          // centre dof
          data.phi[6].ref_hess[0][0] = -DataType(54)*y;
          data.phi[6].ref_hess[1][1] = -DataType(54)*x;
          data.phi[6].ref_hess[0][1] = data.phi[6].ref_hess[1][0] = DataType(27)*(DataType(1)-DataType(2)*(x+y));
        }
      }; // class Evaluator<...,Simplex<2>>
    } // namespace P2Bubble
  } // namespace Space
} // namespace FEAT