ElementBases.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/basis/Basis.hpp>
#include <polyfem/quadrature/Quadrature.hpp>
#include <polyfem/mesh/Mesh.hpp>
 
#include <polyfem/assembler/AssemblyValues.hpp>
 
#include <vector>
 
namespace polyfem
{
    namespace basis
    {
        class ElementBases
        {
        public:
            typedef std::function<Eigen::VectorXi(const int local_index, const mesh::Mesh &mesh)> LocalNodeFromPrimitiveFunc;
            
            // function type that evaluates bases at given points and saves them in basis_values
            typedef std::function<void(const Eigen::MatrixXd &uv, std::vector<assembler::AssemblyValues> &basis_values)> EvalBasesFunc;
            
            // function type that computes quadrature points and saves them in quadrature
            typedef std::function<void(quadrature::Quadrature &quadrature)> QuadratureFunction;
 
            std::vector<Basis> bases; 
 
            Eigen::MatrixXd nodes() const;
 
            void compute_quadrature(quadrature::Quadrature &quadrature) const { quadrature_builder_(quadrature); }
            void compute_mass_quadrature(quadrature::Quadrature &quadrature) const { mass_quadrature_builder_(quadrature); }
            Eigen::VectorXi local_nodes_for_primitive(const int local_index, const mesh::Mesh &mesh) const { return local_node_from_primitive_(local_index, mesh); }
 
            // whether the basis functions should be evaluated in the parametric domain (FE bases),
            // or directly in the object domain (harmonic bases)
            bool has_parameterization = true;
 
            void eval_geom_mapping(const Eigen::MatrixXd &samples, Eigen::MatrixXd &mapped) const;
 
            void eval_geom_mapping_grads(const Eigen::MatrixXd &samples, std::vector<Eigen::MatrixXd> &grads) const;
 
            bool is_complete() const;
 
            friend std::ostream &operator<<(std::ostream &os, const ElementBases &obj)
            {
                for (std::size_t i = 0; i < obj.bases.size(); ++i)
                    os << "local base " << i << ":\n"
                       << obj.bases[i] << "\n";
 
                return os;
            }
 
            void set_quadrature(const QuadratureFunction &fun) { quadrature_builder_ = fun; }
            void set_mass_quadrature(const QuadratureFunction &fun) { mass_quadrature_builder_ = fun; }
 
            void evaluate_bases(const Eigen::MatrixXd &uv, std::vector<assembler::AssemblyValues> &basis_values) const
            {
                if (eval_bases_func_)
                {
                    eval_bases_func_(uv, basis_values);
                }
                else
                {
                    evaluate_bases_default(uv, basis_values);
                }
            }
            void evaluate_grads(const Eigen::MatrixXd &uv, std::vector<assembler::AssemblyValues> &basis_values) const
            {
                if (eval_grads_func_)
                {
                    eval_grads_func_(uv, basis_values);
                }
                else
                {
                    evaluate_grads_default(uv, basis_values);
                }
            }
 
            void set_bases_func(EvalBasesFunc fun) { eval_bases_func_ = fun; }
            void set_grads_func(EvalBasesFunc fun) { eval_grads_func_ = fun; }
 
            void set_local_node_from_primitive_func(LocalNodeFromPrimitiveFunc fun) { local_node_from_primitive_ = fun; }
 
        private:
            void evaluate_bases_default(const Eigen::MatrixXd &uv, std::vector<assembler::AssemblyValues> &basis_values) const;
            void evaluate_grads_default(const Eigen::MatrixXd &uv, std::vector<assembler::AssemblyValues> &basis_values) const;
 
        private:
            EvalBasesFunc eval_bases_func_;
            EvalBasesFunc eval_grads_func_;
            QuadratureFunction quadrature_builder_;
            QuadratureFunction mass_quadrature_builder_;
 
            LocalNodeFromPrimitiveFunc local_node_from_primitive_;
        };
    } // namespace basis
} // namespace polyfem