polynomial_tp.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_POLYNOMIAL_TP_HPP
#define QUGAR_IMPL_POLYNOMIAL_TP_HPP
 
 
#include <qugar/bbox.hpp>
#include <qugar/domain_function.hpp>
#include <qugar/point.hpp>
#include <qugar/tensor_index_tp.hpp>
#include <qugar/types.hpp>
 
#include <cassert>
#include <vector>
 
namespace qugar::impl {
 
template<int dim, int range> class PolynomialTP : public DomainFunc<dim, range>
{
public:
  using CoefsType = std::conditional_t<range == 1, real, Point<range>>;
 
  explicit PolynomialTP(const TensorSizeTP<dim> &order);
 
  PolynomialTP(const TensorSizeTP<dim> &order, const CoefsType &value);
 
  PolynomialTP(const TensorSizeTP<dim> &order, const std::vector<CoefsType> &coefs);
 
protected:
  TensorSizeTP<dim> order_;
 
  std::vector<CoefsType> coefs_;
 
public:
  [[nodiscard]] std::size_t get_num_coefs() const;
 
  [[nodiscard]] const std::vector<CoefsType> &get_coefs() const;
 
  [[nodiscard]] const TensorSizeTP<dim> &get_order() const;
 
  [[nodiscard]] int get_order(int dir) const;
 
  [[nodiscard]] const CoefsType &get_coef(int index) const;
 
  [[nodiscard]] CoefsType &get_coef(int index);
 
  [[nodiscard]] const CoefsType &get_coef(const TensorIndexTP<dim> &index) const;
 
  [[nodiscard]] CoefsType &get_coef(const TensorIndexTP<dim> &index);
 
  [[nodiscard]] int get_degree(int dir) const;
 
  void transform_image(const BoundBox<range> &old_domain, const BoundBox<range> &new_domain);
 
  void coefs_linear_transform(const real scale, const CoefsType &shift);
};
 
//   /**
//    * @brief Iterator for edges of tensor product elements.
//    *
//    * @tparam N Dimension of the parametric domain.
//    */
//   template<int N> struct PolynomialTPEdgeIt
//   {
//     /**
//      * @brief Constructor.
//      *
//      * @param _order Order of the element along all the parametric directions.
//      * @param _edge_id Id of the element's edge (following lexicographical convention).
//      */
//     PolynomialTPEdgeIt(const Vector<int, N> &_order, const int _edge_id)
//       : act_dir(getActiveDir(_edge_id)), order(_order), i(), min(), max(), valid(true)
//     {
//       this->setMinMax(_order, _edge_id);
//     }
 
//     /**
//      * @brief Increments the iterator position.
//      */
//     PolynomialTPEdgeIt &operator++()
//     {
//       if (++i(act_dir) < max(act_dir))
//         return *this;
//       valid = false;
//       return *this;
//     }
 
//     /**
//      * @brief Returns a reference to the current tensor index.
//      *
//      * @return Current tensor index.
//      */
//     const Vector<int, N> &operator()() const { return i; }
 
//     /**
//      * @brief Gets the flat index of the current iterator's position.
//      * @return Flat index of the position.
//      */
//     int getFlatIndex() const
//     {
//       assert(valid && "Iterator is not in a valid state");
//       return util::toFlatIndex(this->order, i);
//     }
 
//     /**
//      * @brief Checks whether or not the iteration is valid
//      * of not (reached the end).
//      *
//      * @return True if the iterator is in a valid state, false otherwise.
//      */
//     bool operator~() const { return valid; }
 
//     /**
//      * @brief Resets the iterator to a valid state setting its tensor
//      * index to the beginning of the edge.
//      */
//     void reset()
//     {
//       this->i(act_dir) = 0;
//       this->valid = true;
//     }
 
//     /// Active parametric direction of the edge.
//     const int act_dir;
 
//   private:
//     /// Order of the element along all the parametric directions.
//     const Vector<int, N> order;
//     /// Tensor index of the iterator.
//     Vector<int, N> i;
//     /// Minimum and maximum tensor dimensions of the edge.
//     Vector<int, N> min, max;
//     /// Flag indicating if the iterator is in a valid state.
//     bool valid;
 
 
//     /**
//      * @brief Sets the minimum and maximum tensor dimensions of the edge.
//      *
//      * @param _order Polynomial order of the element along the parametric directions.
//      * @param _edge_id If of the edge.
//      */
//     void setMinMax(const Vector<int, N> &_order, const int _edge_id)
//     {
//       if constexpr (N == 2) {
//         if (_edge_id < 2) {
//           min(0) = _edge_id == 0 ? 0 : (_order(0) - 1);
//         } else {
//           min(1) = _edge_id == 2 ? 0 : (_order(1) - 1);
//         }
//       } else// if constexpr (N == 3)
//       {
//         if (_edge_id < 4) {
//           min(0) = (_edge_id % 2) == 0 ? 0 : (_order(0) - 1);
//           min(1) = (_edge_id / 2) == 0 ? 0 : (_order(1) - 1);
//         } else if (_edge_id < 8) {
//           min(0) = ((_edge_id - 4) % 2) == 0 ? 0 : (_order(0) - 1);
//           min(2) = ((_edge_id - 4) / 2) == 0 ? 0 : (_order(2) - 1);
//         } else {
//           min(1) = ((_edge_id - 8) % 2) == 0 ? 0 : (_order(1) - 1);
//           min(2) = ((_edge_id - 8) / 2) == 0 ? 0 : (_order(2) - 1);
//         }
//       }
//       this->max = this->min;
 
//       this->min(act_dir) = 0;
//       this->max(act_dir) = _order(act_dir);
 
//       this->i = this->min;
//     }
 
//     /**
//      * @brief Gets the number of edge in an element of dimension N.
//      * @return Number of edge.
//      */
//     static int getNumEdges()
//     {
//       static_assert(N == 2 || N == 3, "Not implemented.");
//       return N == 2 ? 4 : 12;
//     }
 
//     /**
//      * @brief Gets the active parametric direction of an edge.
//      *
//      * @param _edge_id If of the edge.
//      * @return Active parametric direction index.
//      */
//     static int getActiveDir(const int _edge_id)
//     {
//       static_assert(N == 2 || N == 3, "Not implemented.");
//       assert(0 <= _edge_id && _edge_id < getNumEdges());
 
//       int act_dir{ -1 };
//       if constexpr (N == 2) {
//         if (_edge_id < 2)
//           return 1;
//         else
//           return 0;
//       } else// if constexpr (N == 3)
//       {
//         if (_edge_id < 4)
//           return 2;
//         else if (_edge_id < 8)
//           return 1;
//         else
//           return 0;
//       }
//     }
//   };
 
 
}// namespace qugar::impl
 
#endif// QUGAR_IMPL_POLYNOMIAL_TP_HPP