boundary.hpp File Reference

Boundary treatment. More...

#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#include <bspline.hpp>

Go to the source code of this file.

Classes
class	iganet::BoundaryCommon< BoundaryCore >
	Boundary (common high-level functionality) More...
class	iganet::BoundaryCore< Spline, 1 >
	BoundaryCore (1d specialization) More...
class	iganet::BoundaryCore< Spline, 2 >
	BoundaryCore (2d specialization) More...
class	iganet::BoundaryCore< Spline, 3 >
	BoundaryCore (3d specialization) More...
class	iganet::BoundaryCore< Spline, 4 >
	BoundaryCore (4d specialization) More...
class	iganet::detail::BoundaryType
	Boundary type. More...

Namespaces
namespace	iganet
namespace	iganet::detail

Macros
#define	GENERATE_EXPR_MACRO(r, data, name)
#define	GENERATE_IEXPR_MACRO(r, data, name)
	Auto-generated functions.

Typedefs
template<typename Spline >
using	iganet::Boundary = BoundaryCommon< BoundaryCore< Spline, Spline::parDim()> >
	Boundary.
template<typename... T>
using	iganet::is_BoundaryType = std::conjunction< std::is_base_of< detail::BoundaryType, T >... >
	Type trait to check if T is a valid Boundary type.

Enumerations
enum	iganet::side {   iganet::west = 1 , iganet::east = 2 , iganet::south = 3 , iganet::north = 4 ,   iganet::front = 5 , iganet::back = 6 , iganet::stime = 7 , iganet::etime = 8 ,   iganet::left = 1 , iganet::right = 2 , iganet::down = 3 , iganet::up = 4 ,   iganet::none = 0 }
	Identifiers for topological sides. More...

Functions
template<typename Spline >
std::ostream &	iganet::operator<< (std::ostream &os, const Boundary< Spline > &obj)
	Print (as string) a Boundary object.

Variables
template<typename... T>
constexpr bool	iganet::is_BoundaryType_v = is_BoundaryType<T...>::value
	Alias to the value of is_BoundaryType.

Detailed Description

Boundary treatment.

Author

Matthias Moller

Copyright

This file is part of the IgANet project

This Source Code Form is subject to the terms of the Mozilla Public License, v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain one at http://mozilla.org/MPL/2.0/.

Macro Definition Documentation

GENERATE_EXPR_MACRO

#define GENERATE_EXPR_MACRO	(		r,
			data,
			name
	)

Value:

private:                                                                       \
  template <bool memory_optimized = false, size_t... Is, typename... Xi>       \
  inline auto BOOST_PP_CAT(name, _)(std::index_sequence<Is...>,                \
                                    const std::tuple<Xi...> &xi) const {       \
    return std::tuple(                                                         \
        std::get<Is>(BoundaryCore::bdr_)                                       \
            .template name<memory_optimized>(std::get<Is>(xi))...);            \
  }                                                                            \
                                                                               \
  template <bool memory_optimized = false, size_t... Is, typename... Xi,       \
            typename... Indices>                                               \
  inline auto BOOST_PP_CAT(name, _)(std::index_sequence<Is...>,                \
                                    const std::tuple<Xi...> &xi,               \
                                    const std::tuple<Indices...> &indices)     \
      const {                                                                  \
    return std::tuple(std::get<Is>(BoundaryCore::bdr_)                         \
                          .template name<memory_optimized>(                    \
                              std::get<Is>(xi), std::get<Is>(indices))...);    \
  }                                                                            \
                                                                               \
  template <bool memory_optimized = false, size_t... Is, typename... Xi,       \
            typename... Indices, typename... Coeff_Indices>                    \
  inline auto BOOST_PP_CAT(name, _)(                                           \
      std::index_sequence<Is...>, const std::tuple<Xi...> &xi,                 \
      const std::tuple<Indices...> &indices,                                   \
      const std::tuple<Coeff_Indices...> &coeff_indices) const {               \
    return std::tuple(std::get<Is>(BoundaryCore::bdr_)                         \
                          .template name<memory_optimized>(                    \
                              std::get<Is>(xi), std::get<Is>(indices),         \
                              std::get<Is>(coeff_indices))...);                \
  }                                                                            \
                                                                               \
public:                                                                        \
  template <bool memory_optimized = false, typename... Args>                   \
  inline auto name(const Args &...args) const {                                \
    return BOOST_PP_CAT(name, _)<memory_optimized>(                            \
        std::make_index_sequence<BoundaryCore::nsides()>{}, args...);          \
  }

GENERATE_IEXPR_MACRO

#define GENERATE_IEXPR_MACRO	(		r,
			data,
			name
	)

Value:

private:                                                                       \
  template <bool memory_optimized = false, size_t... Is, typename... Geometry, \
            typename... Xi>                                                    \
  inline auto BOOST_PP_CAT(name, _)(std::index_sequence<Is...>,                \
                                    const std::tuple<Geometry...> &G,          \
                                    const std::tuple<Xi...> &xi) const {       \
    return std::tuple(std::get<Is>(BoundaryCore::bdr_)                         \
                          .template name<memory_optimized>(                    \
                              std::get<Is>(G), std::get<Is>(xi))...);          \
  }                                                                            \
                                                                               \
  template <bool memory_optimized = false, size_t... Is, typename... Geometry, \
            typename... Xi, typename... Indices>                               \
  inline auto BOOST_PP_CAT(name, _)(                                           \
      std::index_sequence<Is...>, const std::tuple<Geometry...> &G,            \
      const std::tuple<Xi...> &xi, const std::tuple<Indices...> &indices)      \
      const {                                                                  \
    return std::tuple(                                                         \
        std::get<Is>(BoundaryCore::bdr_)                                       \
            .template name<memory_optimized>(                                  \
                std::get<Is>(G), std::get<Is>(xi), std::get<Is>(indices))...); \
  }                                                                            \
                                                                               \
  template <bool memory_optimized = false, size_t... Is, typename... Geometry, \
            typename... Xi, typename... Indices, typename... Coeff_Indices>    \
  inline auto BOOST_PP_CAT(name, _)(                                           \
      std::index_sequence<Is...>, const std::tuple<Geometry...> &G,            \
      const std::tuple<Xi...> &xi, const std::tuple<Indices...> &indices,      \
      const std::tuple<Coeff_Indices...> &coeff_indices) const {               \
    return std::tuple(std::get<Is>(BoundaryCore::bdr_)                         \
                          .template name<memory_optimized>(                    \
                              std::get<Is>(G), std::get<Is>(xi),               \
                              std::get<Is>(indices),                           \
                              std::get<Is>(coeff_indices))...);                \
  }                                                                            \
                                                                               \
public:                                                                        \
  template <bool memory_optimized = false, typename... Args>                   \
  inline auto name(const Args &...args) const {                                \
    return BOOST_PP_CAT(name, _)<memory_optimized>(                            \
        std::make_index_sequence<BoundaryCore::nsides()>{}, args...);          \
  }

Auto-generated functions.