Basis.hpp

Go to the documentation of this file.

#pragma once
 
#include <polyfem/quadrature/Quadrature.hpp>
#include <polyfem/utils/Types.hpp>
 
#include <Eigen/Dense>
#include <functional>
 
#include <vector>
 
namespace polyfem
{
    namespace basis
    {
        class Local2Global
        {
        public:
            int index;  
            double val; 
 
            RowVectorNd node; 
 
            Local2Global()
                : index(-1), val(0)
            {
            }
 
            Local2Global(const int _index, const RowVectorNd &_node, const double _val)
                : index(_index), val(_val), node(_node)
            {
            }
        };
 
        class Basis
        {
 
        public:
            typedef std::function<void(const Eigen::MatrixXd &uv, Eigen::MatrixXd &val)> Fun;
 
            Basis();
 
            void init(const int order, const int global_index, const int local_index, const RowVectorNd &node);
 
            inline bool is_complete() const { return !global_.empty(); }
 
            void eval_basis(const Eigen::MatrixXd &uv, Eigen::MatrixXd &val) const
            {
                assert(basis_);
                basis_(uv, val);
            }
 
            Eigen::MatrixXd operator()(const Eigen::MatrixXd &uv) const
            {
                Eigen::MatrixXd val;
                eval_basis(uv, val);
                return val;
            }
 
            void eval_grad(const Eigen::MatrixXd &uv, Eigen::MatrixXd &val) const
            {
                assert(grad_);
                grad_(uv, val);
            }
 
            // list of local to global mappings
            inline const std::vector<Local2Global> &global() const { return global_; }
            inline std::vector<Local2Global> &global() { return global_; }
 
            // setting the basis lambda and its gradient
            inline void set_basis(const Fun &fun) { basis_ = fun; }
            inline void set_grad(const Fun &fun) { grad_ = fun; }
 
            inline bool is_defined() const { return (basis_ ? true : false); }
            inline int order() const { return order_; }
 
            // output
            friend std::ostream &operator<<(std::ostream &os, const Basis &obj)
            {
                os << obj.local_index_ << ":\n";
                for (auto l2g : obj.global_)
                    os << "\tl2g: " << l2g.index << " (" << l2g.node << ") " << l2g.val << "\n";
 
                return os;
            }
 
        private:
            std::vector<Local2Global> global_; 
            int local_index_;                  
            int order_;
 
            Fun basis_; 
            Fun grad_;
        };
    } // namespace basis
} // namespace polyfem