tpms_lib.hpp

Go to the documentation of this file.

// --------------------------------------------------------------------------
//
// Copyright (C) 2025-present by Pablo Antolin
//
// This file is part of the QUGaR library.
//
// SPDX-License-Identifier:    MIT
//
// --------------------------------------------------------------------------
 
#ifndef QUGAR_IMPL_TPMS_LIB_HPP
#define QUGAR_IMPL_TPMS_LIB_HPP
 
 
#include <qugar/domain_function.hpp>
#include <qugar/vector.hpp>
 
#include <qugar/types.hpp>
 
namespace qugar::impl::tpms {
 
template<int dim> class TPMSBase : public qugar::impl::ImplicitFunc<dim>
{
protected:
  explicit TPMSBase(const Vector<real, dim> &mnq);
 
  Vector<real, 3> mnq_;
};
 
// NOLINTNEXTLINE (cppcoreguidelines-macro-usage)
#define declare_tpms(TPMS_NAME)                                                                 \
  template<int dim> class TPMS_NAME : public TPMSBase<dim>                                      \
  {                                                                                             \
    template<typename T> using Gradient = qugar::impl::ImplicitFunc<dim>::template Gradient<T>; \
    template<typename T> using Hessian = qugar::impl::ImplicitFunc<dim>::template Hessian<T>;   \
                                                                                                \
  public:                                                                                       \
    explicit TPMS_NAME(const Vector<real, dim> &mnq);                                           \
                                                                                                \
    TPMS_NAME();                                                                                \
                                                                                                \
    [[nodiscard]] virtual real operator()(const Point<dim> &point) const final;                 \
                                                                                                \
    [[nodiscard]] virtual ::algoim::Interval<dim> operator()(                                   \
      const Point<dim, ::algoim::Interval<dim>> &point) const final;                            \
                                                                                                \
    [[nodiscard]] virtual Gradient<real> grad(const Point<dim> &point) const final;             \
                                                                                                \
    [[nodiscard]] virtual Gradient<::algoim::Interval<dim>> grad(                               \
      const Point<dim, ::algoim::Interval<dim>> &point) const final;                            \
                                                                                                \
    [[nodiscard]] virtual Hessian<real> hessian(const Point<dim> &point) const final;           \
                                                                                                \
  private:                                                                                      \
    template<typename T> [[nodiscard]] T eval_(const Point<dim, T> &point) const;               \
                                                                                                \
    template<typename T> [[nodiscard]] Gradient<T> grad_(const Point<dim, T> &point) const;     \
                                                                                                \
    template<typename T> [[nodiscard]] Hessian<T> hessian_(const Point<dim, T> &point) const;   \
  };
 
declare_tpms(Schoen);
 
declare_tpms(SchoenIWP);
 
declare_tpms(SchoenFRD);
 
declare_tpms(FischerKochS);
 
declare_tpms(SchwarzDiamond);
 
declare_tpms(SchwarzPrimitive);
 
}// namespace qugar::impl::tpms
 
 
#endif// QUGAR_IMPL_TPMS_LIB_HPP