quad_rule.h

 
#ifndef INCGa7241ee797424d98ad339341b02bca70
#define INCGa7241ee797424d98ad339341b02bca70
 
#include <lf/base/base.h>
 
#include <iostream>
#include <utility>
 
namespace lf::quad {
 
using quadDegree_t = unsigned int;
 
class QuadRule {
 public:
  QuadRule(const QuadRule&) = default;
  QuadRule(QuadRule&&) = default;
  QuadRule& operator=(const QuadRule&) = default;
  QuadRule& operator=(QuadRule&&) = default;
  ~QuadRule() = default;
  QuadRule() : ref_el_(lf::base::RefEl::kPoint()), points_(0, 0), weights_(0) {}
 
  explicit QuadRule(base::RefEl ref_el, Eigen::MatrixXd points,
                    Eigen::VectorXd weights, quadDegree_t degree)
      : ref_el_(std::move(ref_el)),
        degree_(degree),
        points_(std::move(points)),
        weights_(std::move(weights)) {
    LF_ASSERT_MSG(points_.rows() == ref_el_.Dimension(), "Dimension mismatch");
    LF_ASSERT_MSG(weights_.size() == points_.cols(), "Dimension mismatch");
  }
 
  [[nodiscard]] base::RefEl RefEl() const { return ref_el_; }
 
  [[nodiscard]] quadDegree_t Degree() const { return degree_; }
 
  [[nodiscard]] unsigned int Order() const { return Degree() + 1; }
 
  [[nodiscard]] const Eigen::MatrixXd& Points() const { return points_; }
 
  [[nodiscard]] const Eigen::VectorXd& Weights() const { return weights_; }
 
  [[nodiscard]] base::size_type NumPoints() const { return points_.cols(); }
 
  void PrintInfo(std::ostream& o, int out_ctrl = 0) const {
    o << weights_.size() << "-point QR";
    if (out_ctrl > 0) {
      o << ", weights = " << weights_.transpose() << ", nodes = \n" << points_;
    }
  }
 
 private:
  base::RefEl ref_el_;
  quadDegree_t degree_{0};
  Eigen::MatrixXd points_;
  Eigen::VectorXd weights_;
 
 public:
};
 
std::ostream& operator<<(std::ostream& stream,
                         const lf::quad::QuadRule& quadrule);
 
}  // namespace lf::quad
 
 
template <>
struct fmt::formatter<lf::quad::QuadRule> : ostream_formatter {};
 
#endif  // INCGa7241ee797424d98ad339341b02bca70