patch.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <core/core.hpp>
 
#include <utils/blocktensor.hpp>
#include <utils/tensorarray.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:
  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;
 
  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