collocation.hpp

Go to the documentation of this file.

 
#pragma once
 
namespace iganet {
 
//  clang-format off
enum class collPts : short_t {
  greville               = 0, 
  greville_interior      = 1, 
  greville_ref1          = 2, 
  greville_interior_ref1 = 3, 
  greville_ref2          = 4, 
  greville_interior_ref2 = 5, 
  greville_ref3          = 6, 
  greville_interior_ref3 = 7, 
};
//  clang-format on
 
template<typename> class CollPtsHelper;
 
template <detail::HasAsTensor CollPts>  
class CollPtsHelper<CollPts> {
 
public:
  using type = std::pair<typename CollPts::eval_type,
                         typename CollPts::boundary_eval_type>;
 
private:
  template <typename FunctionSpace, std::size_t... Is>
  static auto collPts(enum collPts collPts, const FunctionSpace& space, std::index_sequence<Is...>) {
 
    type collPts_;
 
    switch (collPts) {
 
    case collPts::greville:
      // Get Greville abscissae inside the domain and at the boundary
      ((std::get<Is>(collPts_.first) =
            space.template space<Is>().greville(
                /* interior */ false)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) =
            space.template boundary<Is>().greville()),
       ...);
      break;
 
    case collPts::greville_interior:
      // Get Greville abscissae inside the domain
      ((std::get<Is>(collPts_.first) =
            space.template space<Is>().greville(
                /* interior */ true)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) =
            space.template boundary<Is>().greville()),
       ...);
      break;
 
    case collPts::greville_ref1:
      // Get Greville abscissae inside the domain and at the boundary
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine()
                                          .greville(
                                              /* interior */ false)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine()
                                           .greville()),
       ...);
      break;
 
    case collPts::greville_interior_ref1:
      // Get Greville abscissae inside the domain
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine()
                                          .greville(
                                              /* interior */ true)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine()
                                           .greville()),
       ...);
      break;
 
    case collPts::greville_ref2:
      // Get Greville abscissae inside the domain and at the boundary
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine(2, -1)
                                          .greville(
                                              /* interior */ false)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine(2, -1)
                                           .greville()),
       ...);
      break;
 
    case collPts::greville_interior_ref2:
      // Get Greville abscissae inside the domain
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine(2, -1)
                                          .greville(
                                              /* interior */ true)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine(2, -1)
                                           .greville()),
       ...);
      break;
      
    case collPts::greville_ref3:
      // Get Greville abscissae inside the domain and at the boundary
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine(3, -1)
                                          .greville(
                                              /* interior */ false)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine(3, -1)
                                           .greville()),
       ...);
      break;
 
    case collPts::greville_interior_ref3:
      // Get Greville abscissae inside the domain
      ((std::get<Is>(collPts_.first) = space
                                          .template space<Is>()
                                          .clone()
                                          .uniform_refine(3, -1)
                                          .greville(
                                              /* interior */ true)),
       ...);
 
      // Get Greville abscissae at the domain
      ((std::get<Is>(collPts_.second) = space
                                           .template boundary<Is>()
                                           .clone()
                                           .uniform_refine(3, -1)
                                           .greville()),
       ...);
      break;      
 
    default:
      throw std::runtime_error("Invalid collocation point specifier");
    }
 
    return collPts_;
  }
 
public:
  template<typename FunctionSpace>
  static auto collPts(enum collPts collPts, const FunctionSpace& space) {
    if constexpr (FunctionSpace::nspaces() == 1)
 
      switch (collPts) {
 
      case collPts::greville:
        return type{
            space.space().greville(/* interior */ false),
            space.boundary().greville()};
 
      case collPts::greville_interior:
        return type{space.space().greville(/* interior */ true),
                space.boundary().greville()};
 
      case collPts::greville_ref1:
        return type{
            space.space().clone().uniform_refine().greville(
                /* interior */ false),
            space
                .boundary()
                .clone()
                .uniform_refine()
                .greville()};
 
      case collPts::greville_interior_ref1:
        return type{
            space.space().clone().uniform_refine().greville(
                /* interior */ true),
            space
                .boundary()
                .clone()
                .uniform_refine()
                .greville()};
 
      case collPts::greville_ref2:
        return type{space
                    .space()
                    .clone()
                    .uniform_refine(2, -1)
                    .greville(
                        /* interior */ false),
                space
                    .boundary()
                    .clone()
                    .uniform_refine(2, -1)
                    .greville()};
 
      case collPts::greville_interior_ref2:
        return type{space
                    .space()
                    .clone()
                    .uniform_refine(2, -1)
                    .greville(
                        /* interior */ true),
                space
                    .boundary()
                    .clone()
                    .uniform_refine(2, -1)
                .greville()};
 
      case collPts::greville_ref3:
        return type{space
                    .space()
                    .clone()
                    .uniform_refine(3, -1)
                    .greville(
                        /* interior */ false),
                space
                    .boundary()
                    .clone()
                    .uniform_refine(3, -1)
                    .greville()};
 
      case collPts::greville_interior_ref3:
        return type{space
                    .space()
                    .clone()
                    .uniform_refine(3, -1)
                    .greville(
                        /* interior */ true),
                space
                    .boundary()
                    .clone()
                    .uniform_refine(3, -1)
                    .greville()};        
 
      default:
        throw std::runtime_error("Invalid collocation point specifier");
      }
 
    else
      return collPts(collPts, space, std::make_index_sequence<type::nspaces()>{});
  }
};
  
} // namespace iganet