patch.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <iganet/core/core.hpp>
 
#include <iganet/utils/blocktensor.hpp>
#include <iganet/utils/tensorarray.hpp>
 
#include <nlohmann/json.hpp>
#include <pugixml.hpp>
 
namespace iganet {
 
namespace detail {
 
// @brief Concept to identify template parameters that have an
// as_tensor function
template <typename T>
concept HasAsTensor = requires(T a) {
  { a.as_tensor() };
};
 
// @brief Concept to identify template parameters that have an
// as_tensor_size function
template <typename T>
concept HasAsTensorSize = requires(T a) {
  { a.as_tensor_size() };
};
 
// @brief Concept to identify template parameters that have a
// from_tensor function
template <typename T>
concept HasFromTensor = requires(T a) {
  { a.from_tensor() };
};
 
} // namespace detail
 
template <typename real_t, short_t GeoDim, short_t ParDim> class BSplinePatch {
public:
  using value_type = real_t;
 
  inline static constexpr short_t geoDim() noexcept { return GeoDim; }
 
  inline static constexpr short_t parDim() noexcept { return ParDim; }
 
  virtual ~BSplinePatch() = default;
 
  virtual torch::Device device() const noexcept = 0;
 
  virtual int32_t device_index() const noexcept = 0;
 
  virtual torch::Dtype dtype() const noexcept = 0;
 
  virtual torch::Layout layout() const noexcept = 0;
 
  virtual bool requires_grad() const noexcept = 0;
 
  virtual bool pinned_memory() const noexcept = 0;
 
  virtual bool is_sparse() const noexcept = 0;
 
  virtual BSplinePatch &set_requires_grad(bool requires_grad) noexcept = 0;
 
  // @brief Returns all coefficients as a single tensor
  virtual torch::Tensor as_tensor() const noexcept = 0;
 
  virtual BSplinePatch &from_tensor(const torch::Tensor &tensor) noexcept = 0;
 
  virtual int64_t as_tensor_size() const noexcept = 0;
 
  virtual utils::BlockTensor<torch::Tensor, 1, GeoDim>
  eval_from_precomputed(const torch::Tensor &basfunc,
                        const torch::Tensor &coeff_indices, int64_t numeval,
                        torch::IntArrayRef sizes) const = 0;
 
  virtual utils::BlockTensor<torch::Tensor, 1, GeoDim>
  eval_from_precomputed(const utils::TensorArray<ParDim> &basfunc,
                        const torch::Tensor &coeff_indices, int64_t numeval,
                        torch::IntArrayRef sizes) const = 0;
 
  [[nodiscard]] virtual nlohmann::json to_json() const = 0;
 
  virtual BSplinePatch &from_json(const nlohmann::json &json) = 0;
 
  [[nodiscard]] virtual pugi::xml_document
  to_xml(int id = 0, const std::string &label = "", int index = -1) const = 0;
 
  virtual pugi::xml_node &to_xml(pugi::xml_node &root, int id = 0,
                                 const std::string &label = "",
                                 int index = -1) const = 0;
 
  virtual BSplinePatch &from_xml(const pugi::xml_document &doc, int id = 0,
                                 const std::string &label = "",
                                 int index = -1) = 0;
 
  virtual BSplinePatch &from_xml(const pugi::xml_node &root, int id = 0,
                                 const std::string &label = "",
                                 int index = -1) = 0;
 
  virtual void
  pretty_print(std::ostream &os = Log(log::info)) const noexcept = 0;
};
 
template <typename real_t, short_t GeoDim, short_t ParDim>
inline std::ostream &
operator<<(std::ostream &os, const BSplinePatch<real_t, GeoDim, ParDim> &obj) {
  obj.pretty_print(os);
  return os;
}
 
} // namespace iganet