mesh_function_global.h

 
#ifndef INCG1323b89d2f584608940fcb37657142cc
#define INCG1323b89d2f584608940fcb37657142cc
#include <lf/mesh/mesh.h>
 
#include <vector>
 
namespace lf::mesh::utils {
 
template <class F>
class MeshFunctionGlobal {
  using F_return_type =
      decltype(std::declval<F>()(std::declval<Eigen::Vector2d>()));
 
  // The following is needed because otherwise
  // MeshFunctionGlobal(MeshFunctionGlobal&&) is not noexcept!
  // Once http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1286r2.html
  // has been implemented by compilers, we can drop this requirement.
  static_assert(std::is_nothrow_move_constructible_v<F>,
                "The functor F must be noexcept move constructible!");
 
 public:
  MeshFunctionGlobal(const MeshFunctionGlobal&) = default;
  MeshFunctionGlobal(MeshFunctionGlobal&&) noexcept = default;
  MeshFunctionGlobal& operator=(const MeshFunctionGlobal&) = delete;
  MeshFunctionGlobal& operator=(MeshFunctionGlobal&&) = delete;
 
  explicit MeshFunctionGlobal(F f) : f_(std::move(f)) {}
 
  std::vector<F_return_type> operator()(const mesh::Entity& e,
                                        const Eigen::MatrixXd& local) const {
    LF_ASSERT_MSG(e.RefEl().Dimension() == local.rows(),
                  "mismatch between entity dimension and local.rows()");
    std::vector<F_return_type> result;
    result.reserve(local.cols());
    auto global_points = e.Geometry()->Global(local);
    for (long i = 0; i < local.cols(); ++i) {
      result.push_back(f_(global_points.col(i)));
    }
    return result;
  }
 
  virtual ~MeshFunctionGlobal() = default;
 
 private:
  F f_;
};
 
}  // namespace lf::mesh::utils
 
#endif  // INCG1323b89d2f584608940fcb37657142cc