boundary.hpp File Reference

Boundary treatment. More...

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

Go to the source code of this file.

Classes
class	iganet::Boundary_
	Boundary base class. More...
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...

Namespaces
namespace	iganet

Concepts
concept	iganet::BoundaryType
	Concept to identify template parameters that are derived from iganet::Boundary_.

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.

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 > requires SplineType<Spline>
std::ostream &	iganet::operator<< (std::ostream &os, const Boundary< Spline > &obj)
	Print (as string) a Boundary object.

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.