evaluator_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/eval_data.hpp>
#include <kernel/trafo/eval_data.hpp>
 
namespace FEAT
{
  namespace Space
  {
    namespace Intern
    {
      template<bool _enable>
      struct BasisEvalHelper;
    } // namespace Intern
 
    template<
      typename SpaceEvaluator_,
      typename TrafoEvaluator_,
      typename SpaceEvalTraits_>
    class EvaluatorBase
    {
    public:
      typedef SpaceEvaluator_ SpaceEvaluator;
 
      typedef TrafoEvaluator_ TrafoEvaluator;
 
      typedef SpaceEvalTraits_ SpaceEvalTraits;
 
      typedef typename TrafoEvaluator::EvalTraits TrafoEvalTraits;
 
      static constexpr int domain_dim = SpaceEvalTraits::domain_dim;
      static constexpr int image_dim = SpaceEvalTraits::image_dim;
      static constexpr int max_local_dofs = SpaceEvalTraits::max_local_dofs;
 
      template<SpaceTags cfg_>
      struct ConfigTraits
      {
        static constexpr SpaceTags config = cfg_;
 
        static constexpr TrafoTags trafo_config = TrafoTags::none;
 
        typedef Space::EvalData<SpaceEvalTraits, config> EvalDataType;
      };
 
#ifdef DOXYGEN
      static constexpr SpaceTags eval_caps = ...;
#endif
 
    protected:
      SpaceEvaluator& cast()
      {
        return static_cast<SpaceEvaluator&>(*this);
      }
 
      const SpaceEvaluator& cast() const
      {
        return static_cast<const SpaceEvaluator&>(*this);
      }
 
    public:
      void prepare(const TrafoEvaluator& DOXY(trafo_eval))
      {
      }
 
      void finish()
      {
      }
 
      template<SpaceTags space_cfg_, TrafoTags trafo_cfg_>
      void operator()(
        EvalData<SpaceEvalTraits, space_cfg_>& space_data,
        const Trafo::EvalData<TrafoEvalTraits, trafo_cfg_>& trafo_data) const
      {
        // typedef mumbo-jumbo
        typedef EvalData<SpaceEvalTraits, space_cfg_> EvalDataType;
 
 
        // \compilerhack GCC 6.1 template compiler bug
        // The following static constexpr bool variables are required to
        // circumvent a compiler bug in GCC 6.1
#if defined(FEAT_COMPILER_GNU) && (FEAT_COMPILER_GNU < 70000)
        // compute basis values
        static constexpr bool want_value = *(EvalDataType::config & SpaceTags::value);
        Intern::BasisEvalHelper<want_value>::eval_values(space_data, cast(), trafo_data);
        // compute basis gradients
        static constexpr bool want_grad = *(EvalDataType::config & SpaceTags::grad);
        Intern::BasisEvalHelper<want_grad>::eval_gradients(space_data, cast(), trafo_data);
        // compute basis hessians
        static constexpr bool want_hess = *(EvalDataType::config & SpaceTags::hess);
        Intern::BasisEvalHelper<want_hess>::eval_hessians(space_data, cast(), trafo_data);
#else
        // compute basis values
        Intern::BasisEvalHelper<*(EvalDataType::config & SpaceTags::value)>::eval_values(space_data, cast(), trafo_data);
        // compute basis gradients
        Intern::BasisEvalHelper<*(EvalDataType::config & SpaceTags::grad)>::eval_gradients(space_data, cast(), trafo_data);
        // compute basis hessians
        Intern::BasisEvalHelper<*(EvalDataType::config & SpaceTags::hess)>::eval_hessians(space_data, cast(), trafo_data);
#endif
      }
 
      template<SpaceTags space_cfg_, TrafoTags trafo_cfg_>
      void eval_values(
        EvalData<SpaceEvalTraits, space_cfg_>& DOXY(space_data),
        const Trafo::EvalData<TrafoEvalTraits, trafo_cfg_>& DOXY(trafo_data)) const
      {
        XABORTM("space evaluator does not support basis function values");
      }
 
      template<SpaceTags space_cfg_, TrafoTags trafo_cfg_>
      void eval_gradients(
        EvalData<SpaceEvalTraits, space_cfg_>& DOXY(space_data),
        const Trafo::EvalData<TrafoEvalTraits, trafo_cfg_>& DOXY(trafo_data)) const
      {
        XABORTM("space evaluator does not support basis function gradients");
      }
 
      template<SpaceTags space_cfg_, TrafoTags trafo_cfg_>
      void eval_hessians(
        EvalData<SpaceEvalTraits, space_cfg_>& DOXY(space_data),
        const Trafo::EvalData<TrafoEvalTraits, trafo_cfg_>& DOXY(trafo_data)) const
      {
        XABORTM("space evaluator does not support basis function hessians");
      }
    }; // class EvaluatorBase<...>
 
    namespace Intern
    {
      template<bool _enable>
      struct BasisEvalHelper
      {
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_values(SpaceData_&, const Evaluator_&, const TrafoData_&) {}
 
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_gradients(SpaceData_&, const Evaluator_&, const TrafoData_&) {}
 
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_hessians(SpaceData_&, const Evaluator_&, const TrafoData_&) {}
      };
 
      template<>
      struct BasisEvalHelper<true>
      {
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_values(SpaceData_& space_data, const Evaluator_& evaluator, const TrafoData_& trafo_data)
        {
          if(!*(Evaluator_::eval_caps & SpaceTags::value))
            XABORTM("space evaluator does not support basis function values");
          evaluator.eval_values(space_data, trafo_data);
        }
 
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_gradients(SpaceData_& space_data, const Evaluator_& evaluator, const TrafoData_& trafo_data)
        {
          if(!*(Evaluator_::eval_caps & SpaceTags::grad))
            XABORTM("space evaluator does not support basis function gradients");
          evaluator.eval_gradients(space_data, trafo_data);
        }
 
        template<typename SpaceData_, typename Evaluator_, typename TrafoData_>
        static void eval_hessians(SpaceData_& space_data, const Evaluator_& evaluator, const TrafoData_& trafo_data)
        {
          if(!*(Evaluator_::eval_caps & SpaceTags::hess))
            XABORTM("space evaluator does not support basis function hessians");
          evaluator.eval_hessians(space_data, trafo_data);
        }
      };
    } // namespace Intern
  } // namespace Space
} // namespace FEAT