nurbs.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <iganet/splines/bspline.hpp>
 
namespace iganet {
 
//
//
template <typename real_t, short_t GeoDim, short_t... Degrees>
class UniformNurbsCore
    : public UniformBSplineCore<real_t, GeoDim + 1, Degrees...> {
private:
  using Base = UniformBSplineCore<real_t, GeoDim + 1, Degrees...>;
 
public:
  using value_type = real_t;
 
  template <template <typename, short_t, short_t...> class BSpline,
            std::make_signed_t<short_t> degree_elevate = 0>
  using derived_type =
      BSpline<real_t, GeoDim + 1, (Degrees + degree_elevate)...>;
 
  template <std::make_signed_t<short_t> degree_elevate = 0>
  using self_type =
      Base::template derived_type<UniformNurbsCore, degree_elevate>;
 
  template <typename other_t, short_t GeoDim_, short_t... Degrees_>
  using derived_self_type = UniformNurbsCore<other_t, GeoDim_, Degrees_...>;
 
  template <typename other_t>
  using real_derived_self_type = UniformNurbsCore<other_t, GeoDim, Degrees...>;
 
  static constexpr bool is_uniform() { return true; }
 
  static constexpr bool is_nonuniform() { return false; }
 
  explicit UniformNurbsCore(Options<real_t> options = Options<real_t>{})
      : Base(options) {}
 
  explicit UniformNurbsCore(const std::array<int64_t, Base::parDim_> &ncoeffs,
                            enum init init = init::greville,
                            Options<real_t> options = Options<real_t>{})
      : Base(ncoeffs, init, options) {
    if (Base::coeffs_[GeoDim].defined())
      Base::coeffs_[GeoDim] = torch::ones_like(Base::coeffs_[GeoDim]);
  }
 
  UniformNurbsCore(const std::array<int64_t, Base::parDim_> &ncoeffs,
                   const utils::TensorArray<Base::geoDim_> &coeffs,
                   bool clone = false,
                   Options<real_t> options = Options<real_t>{})
      : Base(ncoeffs, coeffs, clone, options) {}
 
  UniformNurbsCore(const std::array<int64_t, Base::parDim_> &ncoeffs,
                   utils::TensorArray<Base::geoDim_> &&coeffs,
                   Options<real_t> options = Options<real_t>{})
      : Base(ncoeffs, coeffs, options) {}
 
  template <typename other_t>
  explicit UniformNurbsCore(
      const UniformNurbsCore<other_t, GeoDim + 1, Degrees...> &other,
      Options<real_t> options = Options<real_t>{})
      : Base(static_cast<UniformBSplineCore<other_t, GeoDim + 1, Degrees...>>(
            other)) {}
 
  inline static constexpr short_t geoDim() noexcept { return GeoDim; }
 
  [[nodiscard]] inline const torch::Tensor &weights() const noexcept {
    return Base::coeffs_[GeoDim];
  }
 
  inline torch::Tensor &weights() noexcept { return Base::coeffs_[GeoDim]; }
};
 
template <typename real_t, short_t GeoDim, short_t... Degrees>
class NonUniformNurbsCore
    : public NonUniformBSplineCore<real_t, GeoDim, Degrees...> {
private:
  using Base = NonUniformBSplineCore<real_t, GeoDim, Degrees...>;
 
protected:
  torch::Tensor weights_;
 
public:
  using value_type = real_t;
 
  template <template <typename, short_t, short_t...> class BSpline,
            std::make_signed_t<short_t> degree_elevate = 0>
  using derived_type = BSpline<real_t, GeoDim, (Degrees + degree_elevate)...>;
 
  template <std::make_signed_t<short_t> degree_elevate = 0>
  using self_type =
      Base::template derived_type<NonUniformNurbsCore, degree_elevate>;
 
  template <typename other_t, short_t GeoDim_, short_t... Degrees_>
  using derived_self_type = NonUniformNurbsCore<other_t, GeoDim_, Degrees_...>;
 
  template <typename other_t>
  using real_derived_self_type =
      NonUniformNurbsCore<other_t, GeoDim, Degrees...>;
 
  static constexpr bool is_uniform() { return false; }
 
  static constexpr bool is_nonuniform() { return true; }
};
 
template <typename real_t, short_t GeoDim, short_t... Degrees>
using UniformNurbs =
    BSplineCommon<UniformNurbsCore<real_t, GeoDim, Degrees...>>;
 
template <typename real_t, short_t GeoDim, short_t... Degrees>
inline std::ostream &
operator<<(std::ostream &os,
           const UniformNurbs<real_t, GeoDim, Degrees...> &obj) {
  obj.pretty_print(os);
  return os;
}
 
template <typename real_t, short_t GeoDim, short_t... Degrees>
using NonUniformNurbs =
    BSplineCommon<NonUniformNurbsCore<real_t, GeoDim, Degrees...>>;
 
template <typename real_t, short_t GeoDim, short_t... Degrees>
inline std::ostream &
operator<<(std::ostream &os,
           const NonUniformNurbs<real_t, GeoDim, Degrees...> &obj) {
  obj.pretty_print(os);
  return os;
}
} // namespace iganet