mesh_quality_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/geometry/export_vtk.hpp>
#include <kernel/geometry/mesh_node.hpp>
#include <kernel/lafem/dense_vector_blocked.hpp>
#include <kernel/meshopt/base.hpp>
#include <kernel/space/lagrange1/element.hpp>
#include <kernel/trafo/standard/mapping.hpp>
 
namespace FEAT
{
  namespace Meshopt
  {
 
    template<typename MeshType_>
    class MeshQualityFunctional
    {
      public:
        typedef MeshType_ MeshType;
        typedef typename MeshType::CoordType CoordType;
        typedef typename MeshType::ShapeType ShapeType;
        typedef LAFEM::DenseVectorBlocked<CoordType, Index, MeshType::world_dim> CoordsBufferType;
 
      public:
        Geometry::RootMeshNode<MeshType>* _mesh_node;
        CoordsBufferType _coords_buffer;
 
      protected:
        Index _num_func_evals;
        Index _num_grad_evals;
        Index _num_hess_evals;
 
      public:
        explicit MeshQualityFunctional(Geometry::RootMeshNode<MeshType>* mesh_node_) :
          _mesh_node(mesh_node_),
          _coords_buffer(mesh_node_->get_mesh()->get_num_entities(0), CoordType(0)),
          _num_func_evals(0),
          _num_grad_evals(0),
          _num_hess_evals(0)
          {
            XASSERTM(mesh_node_ != nullptr, "MeshNode must not be nullptr.");
 
            mesh_to_buffer();
          }
 
        explicit MeshQualityFunctional():
          _mesh_node(nullptr),
          _coords_buffer(),
          _num_func_evals(0),
          _num_grad_evals(0),
          _num_hess_evals(0)
          {
          }
 
        virtual ~MeshQualityFunctional()
        {
          // Just set it to nullptr since we did not allocate the memory for this
          _mesh_node = nullptr;
          _coords_buffer.clear();
        }
 
        static String name()
        {
          return "MeshQualityFunctional<"+MeshType_::name()+">";
        }
 
        virtual void add_to_vtk_exporter(Geometry::ExportVTK<MeshType>& DOXY(exporter)) const
        {
        }
 
        MeshType* get_mesh()
        {
          XASSERT(_mesh_node != nullptr);
          return _mesh_node->get_mesh();
        }
 
        const MeshType* get_mesh() const
        {
          XASSERT(_mesh_node != nullptr);
          return _mesh_node->get_mesh();
        }
 
        Geometry::RootMeshNode<MeshType>* get_mesh_node() const
        {
          return _mesh_node;
        }
 
        virtual void mesh_to_buffer()
        {
          const typename MeshType::VertexSetType& vertex_set = get_mesh()->get_vertex_set();
 
          for(Index i(0); i < get_mesh()->get_num_entities(0); ++i)
            _coords_buffer(i, vertex_set[i]);
        }
 
        virtual void buffer_to_mesh()
        {
          typename MeshType::VertexSetType& vertex_set = get_mesh()->get_vertex_set();
 
          for(Index i(0); i < get_mesh()->get_num_entities(0); ++i)
            vertex_set[i] = _coords_buffer(i);
        }
 
        CoordsBufferType& get_coords()
        {
          return _coords_buffer;
        }
 
        const CoordsBufferType& get_coords() const
        {
          return _coords_buffer;
        }
 
        Index get_num_func_evals() const
        {
          return _num_func_evals;
        }
 
        Index get_num_grad_evals() const
        {
          return _num_grad_evals;
        }
 
        Index get_num_hess_evals() const
        {
          return _num_hess_evals;
        }
 
        void reset_num_evals()
        {
          _num_func_evals = Index(0);
          _num_grad_evals = Index(0);
          _num_hess_evals = Index(0);
        }
 
        virtual void init() = 0;
 
        //virtual void prepare(VectorTypeR&) = 0;
 
        virtual CoordType compute_cell_size_defect(CoordType& DOXY(lambda_min), CoordType& DOXY(lambda_max),
        CoordType& DOXY(vol_min), CoordType& DOXY(vol_max), CoordType& DOXY(vol)) const = 0;
 
    }; // class MeshQualityFunctional
 
  } // namespace Meshopt
} // namespace FEAT