rumpf_functional.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
 
#include <kernel/base_header.hpp>
#include <kernel/util/dist.hpp>
#include <kernel/util/math.hpp>
#include <kernel/util/tiny_algebra.hpp>
#include <iostream>
 
namespace FEAT
{
  namespace Meshopt
  {
    template<typename DataType_>
    class RumpfFunctionalBase
    {
      public:
        typedef DataType_ DataType;
      public:
        DataType _fac_frobenius;
        DataType _fac_det;
        DataType _fac_rec_det;
        DataType _fac_cof;
        DataType _fac_reg;
 
        explicit RumpfFunctionalBase(
          const DataType_ fac_frobenius_,
          const DataType_ fac_det_,
          const DataType_ fac_rec_det_,
          const DataType_ fac_cof_,
          const DataType_ fac_reg_) :
          _fac_frobenius(fac_frobenius_),
          _fac_det(fac_det_),
          _fac_rec_det(fac_rec_det_),
          _fac_cof(fac_cof_),
          _fac_reg(fac_reg_)
          {
            XASSERTM(_fac_frobenius >= DataType_(0), "_fac_frobenius must be >= 0!\n");
            XASSERTM(_fac_det >= DataType_(0), "_fac_det must be >= 0!\n");
            XASSERTM(_fac_rec_det >= DataType_(0), "_fac_rec_det must be >= 0!\n");
            XASSERTM(_fac_cof >= DataType_(0), "_fac_cof must be >= 0!\n");
            XASSERTM(_fac_reg >= DataType_(0), "_fac_reg must be >= 0!\n");
          }
 
        virtual ~RumpfFunctionalBase()
        {
        }
 
        static String name()
        {
          return "RumpfFunctionalBase";
        }
 
        String info() const
        {
          const Index pad_width(30);
          String msg;
          msg += String("fac_frobenius").pad_back(pad_width, '.') + String(": ") + stringify_fp_sci(_fac_frobenius) + "\n";
          msg += String("fac_cof").pad_back(pad_width, '.') + String(": ") + stringify_fp_sci(_fac_cof) + "\n";
          msg += String("fac_det").pad_back(pad_width, '.') + String(": ") + stringify_fp_sci(_fac_det) + "\n";
          msg += String("fac_rec_det").pad_back(pad_width, '.') + String(": ") + stringify_fp_sci(_fac_rec_det) + "\n";
          msg += String("fac_reg").pad_back(pad_width, '.') + String(": ") + stringify_fp_sci(_fac_reg) + "\n";
          return msg;
        }
 
    };
 
#ifndef DOXYGEN
    template<typename DataType_, typename TrafoType_>
    class RumpfFunctional;
    // 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.
#else
    template<typename DataType_, typename TrafoType_>
    class RumpfFunctional
    {
      public:
        typedef RumpfFunctionalBase<DataType_> BaseClass;
 
        typedef DataType_ DataType;
        static constexpr int shape_dim = shape_dim_;
        static constexpr int world_dim = shape_dim;
        typedef Shape::Hypercube<shape_dim_> ShapeType;
        typedef Trafo::Standard::Mapping<Geometry::ConformalMesh<ShapeType, world_dim, DataType_>> TrafoType;
        typedef typename Intern::TrafoFE<TrafoType>::Space TrafoSpace;
 
        typedef Tiny::Matrix<DataType_, Shape::FaceTraits<ShapeType,0>::count, world_dim> Tx;
        typedef Tiny::Vector<DataType_, Shape::FaceTraits<ShapeType,0>::count*world_dim> Tgradh;
 
        typedef Tiny::Matrix<DataType_, shape_dim, world_dim> TgradR;
 
        typedef typename TrafoType::template Evaluator<ShapeType, DataType>::Type TrafoEvaluator;
        typedef typename TrafoSpace::template Evaluator<TrafoEvaluator>::Type SpaceEvaluator;
 
        static constexpr TrafoTags trafo_config = TrafoTags::img_point | TrafoTags::jac_mat | TrafoTags::jac_det;
        static constexpr SpaceTags space_config = SpaceTags::ref_grad;
 
        typedef typename TrafoEvaluator::template ConfigTraits<trafo_config>::EvalDataType TrafoEvalData;
        typedef typename SpaceEvaluator::template ConfigTraits<space_config>::EvalDataType SpaceEvalData;
 
      RumpfFunctional(
        const DataType_ fac_frobenius_,
        const DataType_ fac_det_,
        const DataType_ fac_cof_,
        const DataType_ fac_reg_,
        const int exponent_det_);
 
      void eval_fval_grad( DataType& DOXY(fval), Tx& DOXY(grad), const TgradR& DOXY(mat_tensor),
      const TrafoEvaluator& DOXY(trafo_eval), const SpaceEvaluator& DOXY(space_eval),
      const Tx& DOXY(x), const DataType& DOXY(h));
 
      void eval_fval_cellwise( DataType& DOXY(fval), const TgradR& DOXY(mat_tensor),
      const TrafoEvaluator& DOXY(trafo_eval), const SpaceEvaluator& DOXY(space_eval),
      const Tx& DOXY(x), const DataType& DOXY(h),
      DataType& DOXY(fval_frobenius), DataType& DOXY(fval_cof), DataType& DOXY(fval_det));
 
       void add_grad_h_part(Tx& grad, const TgradR& mat_tensor,
       const TrafoEvaluator& trafo_eval, const SpaceEvaluator& space_eval,
       const Tx& DOXY(x), const DataType& h, const Tgradh& grad_h);
 
    };
#endif
 
    // These functionals are kept only for debugging purposes
    template<typename DataType_, typename TrafoType_>
    class RumpfFunctionalUnrolled;
  } // namespace Meshopt
 
} // namespace FEAT