Boundary condition

Defines

APPLY_AND_STENCIL_FUNCTIONS(STENCIL_SIZE)

INIT_BC(NAME, STENCIL_SIZE)

namespace samurai

Enums

enum class BCVType

Values:

enumerator constant

enumerator function

Functions

template<std::size_t dim, class TInterval, class F, class ...CT>
auto make_region(subset_operator<F, CT...> region)

template<std::size_t dim, class TInterval, class Func>
auto make_region(Func &&func)

template<std::size_t dim, class TInterval>
auto make_region(Everywhere<dim, TInterval>)

template<std::size_t dim, class TInterval, std::size_t nd>
auto make_region(const std::array<xt::xtensor_fixed<int, xt::xshape<dim>>, nd> &d)

template<std::size_t dim, class TInterval, class ...dir_t>
auto make_region(const dir_t&... d)

template<std::size_t dim, class TInterval>
auto make_region(const xt::xtensor_fixed<int, xt::xshape<dim>> &d)

template<template<class> class bc_type, class Field>
auto make_bc(Field &field, typename FunctionBc<Field>::function_t func)

Boundary condition as a function.

template<template<class> class bc_type, class Field>
auto make_bc(Field &field)

Boundary condition as a default constant.

template<template<class> class bc_type, class Field, class ...T>
auto make_bc(Field &field, typename Field::value_type v1, T... v)

Boundary condition as a constant.

template<class Field, class Subset, std::size_t stencil_size, class Vector>
void __apply_bc_on_subset(Bc<Field> &bc, Field &field, Subset &subset, const Stencil<stencil_size, Field::dim> &stencil, const Vector &direction)

template<class Field, std::size_t stencil_size>
void apply_bc_impl(Bc<Field> &bc, std::size_t level, Field &field)

template<std::size_t stencil_size, class Field, class Subset>
void __apply_extrapolation_bc_on_subset(Bc<Field> &bc, std::size_t level, Field &field, const DirectionVector<Field::dim> &direction, Subset &subset)

template<class Field, std::size_t stencil_size>
void apply_extrapolation_bc_impl(Bc<Field> &bc, std::size_t level, Field &field, bool diagonals_only)

template<class Field>
void update_bc(std::size_t level, Field &field)

template<class Field, class ...Fields>
void update_bc(std::size_t level, Field &field, Fields&... fields)

template<class Field>
void update_bc(Field &field)

template<class Field, class ...Fields>
void update_bc(Field &field, Fields&... fields)

template<class Field>
class Bc

Subclassed by samurai::DirichletImpl< order, Field >, samurai::NeumannImpl< order, Field >, samurai::PolynomialExtrapolation< Field, stencil_size_ >

Public Types

using mesh_t = typename Field::mesh_t

using interval_t = typename Field::interval_t

using bcvalue_t = BcValue<Field>

using bcvalue_impl = std::unique_ptr<bcvalue_t>

using direction_t = typename bcvalue_t::direction_t

using value_t = typename bcvalue_t::value_t

using coords_t = typename bcvalue_t::coords_t

using cell_t = typename bcvalue_t::cell_t

using bcregion_t = BcRegion<dim, interval_t>

using lca_t = typename bcregion_t::lca_t

using region_t = typename bcregion_t::region_t

using apply_function_1 = std::function<void(Field&, const std::array<cell_t, 1>&, const value_t&)>

using apply_function_2 = std::function<void(Field&, const std::array<cell_t, 2>&, const value_t&)>

using apply_function_3 = std::function<void(Field&, const std::array<cell_t, 3>&, const value_t&)>

using apply_function_4 = std::function<void(Field&, const std::array<cell_t, 4>&, const value_t&)>

using apply_function_5 = std::function<void(Field&, const std::array<cell_t, 5>&, const value_t&)>

using apply_function_6 = std::function<void(Field&, const std::array<cell_t, 6>&, const value_t&)>

using apply_function_7 = std::function<void(Field&, const std::array<cell_t, 7>&, const value_t&)>

using apply_function_8 = std::function<void(Field&, const std::array<cell_t, 8>&, const value_t&)>

using apply_function_9 = std::function<void(Field&, const std::array<cell_t, 9>&, const value_t&)>

using apply_function_10 = std::function<void(Field&, const std::array<cell_t, 10>&, const value_t&)>

Public Functions

virtual ~Bc() = default

Bc(const lca_t &domain, const bcvalue_t &bcv)

Bc(const lca_t &domain, const bcvalue_t &bcv, const bcregion_t &bcr)

Bc(const lca_t &domain, const bcvalue_t &bcv, bool dummy)

Bc(const Bc &bc)

Bc &operator=(const Bc &bc)

Bc(Bc &&bc) noexcept = default

Bc &operator=(Bc &&bc) noexcept = default

virtual std::unique_ptr<Bc> clone() const = 0

virtual std::size_t stencil_size() const = 0

inline virtual apply_function_1 get_apply_function(std::integral_constant<std::size_t, 1>, const direction_t&) const

inline virtual Stencil<1, dim> get_stencil(std::integral_constant<std::size_t, 1>) const

inline virtual apply_function_2 get_apply_function(std::integral_constant<std::size_t, 2>, const direction_t&) const

inline virtual Stencil<2, dim> get_stencil(std::integral_constant<std::size_t, 2>) const

inline virtual apply_function_3 get_apply_function(std::integral_constant<std::size_t, 3>, const direction_t&) const

inline virtual Stencil<3, dim> get_stencil(std::integral_constant<std::size_t, 3>) const

inline virtual apply_function_4 get_apply_function(std::integral_constant<std::size_t, 4>, const direction_t&) const

inline virtual Stencil<4, dim> get_stencil(std::integral_constant<std::size_t, 4>) const

inline virtual apply_function_5 get_apply_function(std::integral_constant<std::size_t, 5>, const direction_t&) const

inline virtual Stencil<5, dim> get_stencil(std::integral_constant<std::size_t, 5>) const

inline virtual apply_function_6 get_apply_function(std::integral_constant<std::size_t, 6>, const direction_t&) const

inline virtual Stencil<6, dim> get_stencil(std::integral_constant<std::size_t, 6>) const

inline virtual apply_function_7 get_apply_function(std::integral_constant<std::size_t, 7>, const direction_t&) const

inline virtual Stencil<7, dim> get_stencil(std::integral_constant<std::size_t, 7>) const

inline virtual apply_function_8 get_apply_function(std::integral_constant<std::size_t, 8>, const direction_t&) const

inline virtual Stencil<8, dim> get_stencil(std::integral_constant<std::size_t, 8>) const

inline virtual apply_function_9 get_apply_function(std::integral_constant<std::size_t, 9>, const direction_t&) const

inline virtual Stencil<9, dim> get_stencil(std::integral_constant<std::size_t, 9>) const

inline virtual apply_function_10 get_apply_function(std::integral_constant<std::size_t, 10>, const direction_t&) const

inline virtual Stencil<10, dim> get_stencil(std::integral_constant<std::size_t, 10>) const

template<class Region>
inline auto on(const Region &region)

template<class ...Regions>
inline auto on(const Regions&... regions)

inline const region_t &get_region() const

inline value_t constant_value()

inline value_t value(const direction_t &d, const cell_t &cell_in, const coords_t &coords) const

inline BCVType get_value_type() const

Public Static Attributes

static constexpr std::size_t dim = Field::dim

static constexpr std::size_t size = Field::size

static constexpr std::size_t max_stencil_size_implemented = 10

Private Members

bcvalue_impl p_bcvalue

const lca_t &m_domain

region_t m_region

xt::xtensor<typename Field::value_type, detail::return_type<typename Field::value_type, size>::dim> m_value

template<std::size_t dim, class TInterval>
struct BcRegion

Subclassed by samurai::CoordsRegion< dim, TInterval >, samurai::Everywhere< dim, TInterval >, samurai::OnDirection< dim, TInterval, nd >, samurai::SetRegion< dim, TInterval, Set >

Public Types

using direction_t = xt::xtensor_fixed<int, xt::xshape<dim>>

using lca_t = LevelCellArray<dim, TInterval>

using region_t = std::pair<std::vector<direction_t>, std::vector<lca_t>>

Public Functions

virtual ~BcRegion() = default

BcRegion(const BcRegion&) = delete

BcRegion &operator=(const BcRegion&) = delete

BcRegion(BcRegion&&) = delete

BcRegion &operator=(BcRegion&&) = delete

virtual region_t get_region(const lca_t&) const = 0

virtual std::unique_ptr<BcRegion> clone() const = 0

Protected Functions

BcRegion() = default

template<class Field>
struct BcValue

Subclassed by samurai::ConstantBc< Field >, samurai::FunctionBc< Field >

Public Types

using value_t = detail::return_type_t<typename Field::value_type, Field::size>

using coords_t = xt::xtensor_fixed<double, xt::xshape<dim>>

using direction_t = xt::xtensor_fixed<int, xt::xshape<dim>>

using cell_t = typename Field::cell_t

Public Functions

virtual ~BcValue() = default

BcValue(const BcValue&) = delete

BcValue &operator=(const BcValue&) = delete

BcValue(BcValue&&) = delete

BcValue &operator=(BcValue&&) = delete

virtual value_t get_value(const direction_t &d, const cell_t&, const coords_t&) const = 0

virtual std::unique_ptr<BcValue> clone() const = 0

virtual BCVType type() const = 0

Public Static Attributes

static constexpr std::size_t dim = Field::dim

Protected Functions

BcValue() = default

template<class Field>
class ConstantBc : public samurai::BcValue<Field>

Public Types

using base_t = BcValue<Field>

using value_t = typename base_t::value_t

using coords_t = typename base_t::coords_t

using direction_t = typename base_t::direction_t

using cell_t = typename base_t::cell_t

Public Functions

template<class ...CT>
ConstantBc(const CT... v)

ConstantBc()

inline virtual value_t get_value(const direction_t&, const cell_t&, const coords_t&) const override

virtual std::unique_ptr<base_t> clone() const override

inline virtual BCVType type() const override

Private Members

value_t m_v

template<std::size_t dim, class TInterval>
class CoordsRegion : public samurai::BcRegion<dim, TInterval>

Public Types

using base_t = BcRegion<dim, TInterval>

using direction_t = typename base_t::direction_t

using lca_t = typename base_t::lca_t

using region_t = typename base_t::region_t

using function_t = std::function<bool(const xt::xtensor_fixed<double, xt::xshape<dim>>&)>

Public Functions

CoordsRegion(const function_t &f)

virtual std::unique_ptr<base_t> clone() const override

inline virtual region_t get_region(const lca_t &domain) const override

Private Members

function_t m_func

template<std::size_t order = 1>
struct Dirichlet

Public Types

template<class Field>
using impl_t = DirichletImpl<order, Field>

template<std::size_t order, class Field>
struct DirichletImpl : public samurai::Bc<Field>

Public Types

using base_t = samurai::Bc<Field>

using cell_t = typename base_t::cell_t

using value_t = typename base_t::value_t

using direction_t = typename base_t::direction_t

using stencil_t = samurai::Stencil<2 * order, dim>

using constant_stencil_size_t = std::integral_constant<std::size_t, 2 * order>

using stencil_cells_t = std::array<cell_t, 2 * order>

using apply_function_t = std::function<void(Field&, const std::array<cell_t, 2 * order>&, const value_t&)>

Public Functions

inline virtual std::unique_ptr<base_t> clone() const override

inline virtual std::size_t stencil_size() const override

inline stencil_t get_stencil(constant_stencil_size_t) const override

inline apply_function_t get_apply_function(constant_stencil_size_t, const direction_t&) const override

inline virtual apply_function_1 get_apply_function(std::integral_constant<std::size_t, 1>, const direction_t&) const

inline virtual apply_function_2 get_apply_function(std::integral_constant<std::size_t, 2>, const direction_t&) const

inline virtual apply_function_3 get_apply_function(std::integral_constant<std::size_t, 3>, const direction_t&) const

inline virtual apply_function_4 get_apply_function(std::integral_constant<std::size_t, 4>, const direction_t&) const

inline virtual apply_function_5 get_apply_function(std::integral_constant<std::size_t, 5>, const direction_t&) const

inline virtual apply_function_6 get_apply_function(std::integral_constant<std::size_t, 6>, const direction_t&) const

inline virtual apply_function_7 get_apply_function(std::integral_constant<std::size_t, 7>, const direction_t&) const

inline virtual apply_function_8 get_apply_function(std::integral_constant<std::size_t, 8>, const direction_t&) const

inline virtual apply_function_9 get_apply_function(std::integral_constant<std::size_t, 9>, const direction_t&) const

inline virtual apply_function_10 get_apply_function(std::integral_constant<std::size_t, 10>, const direction_t&) const

inline virtual Stencil<1, dim> get_stencil(std::integral_constant<std::size_t, 1>) const

inline virtual Stencil<2, dim> get_stencil(std::integral_constant<std::size_t, 2>) const

inline virtual Stencil<3, dim> get_stencil(std::integral_constant<std::size_t, 3>) const

inline virtual Stencil<4, dim> get_stencil(std::integral_constant<std::size_t, 4>) const

inline virtual Stencil<5, dim> get_stencil(std::integral_constant<std::size_t, 5>) const

inline virtual Stencil<6, dim> get_stencil(std::integral_constant<std::size_t, 6>) const

inline virtual Stencil<7, dim> get_stencil(std::integral_constant<std::size_t, 7>) const

inline virtual Stencil<8, dim> get_stencil(std::integral_constant<std::size_t, 8>) const

inline virtual Stencil<9, dim> get_stencil(std::integral_constant<std::size_t, 9>) const

inline virtual Stencil<10, dim> get_stencil(std::integral_constant<std::size_t, 10>) const

Public Static Attributes

static constexpr std::size_t dim

template<std::size_t dim, class TInterval>
struct Everywhere : public samurai::BcRegion<dim, TInterval>

Public Types

using base_t = BcRegion<dim, TInterval>

using direction_t = typename base_t::direction_t

using lca_t = typename base_t::lca_t

using region_t = typename base_t::region_t

Public Functions

Everywhere() = default

inline virtual region_t get_region(const lca_t &domain) const override

virtual std::unique_ptr<base_t> clone() const override

template<class Field>
class FunctionBc : public samurai::BcValue<Field>

Public Types

using base_t = BcValue<Field>

using value_t = typename base_t::value_t

using coords_t = typename base_t::coords_t

using direction_t = typename base_t::direction_t

using cell_t = typename base_t::cell_t

using function_t = std::function<value_t(const direction_t&, const cell_t&, const coords_t&)>

Public Functions

FunctionBc(const function_t &f)

inline virtual value_t get_value(const direction_t &d, const cell_t &cell_in, const coords_t &coords) const override

virtual std::unique_ptr<base_t> clone() const override

inline virtual BCVType type() const override

Private Members

function_t m_func

template<std::size_t order = 1>
struct Neumann

Public Types

template<class Field>
using impl_t = NeumannImpl<order, Field>

template<std::size_t order, class Field>
struct NeumannImpl : public samurai::Bc<Field>

Public Types

using base_t = samurai::Bc<Field>

using cell_t = typename base_t::cell_t

using value_t = typename base_t::value_t

using direction_t = typename base_t::direction_t

using stencil_t = samurai::Stencil<2 * order, dim>

using constant_stencil_size_t = std::integral_constant<std::size_t, 2 * order>

using stencil_cells_t = std::array<cell_t, 2 * order>

using apply_function_t = std::function<void(Field&, const std::array<cell_t, 2 * order>&, const value_t&)>

Public Functions

inline virtual std::unique_ptr<base_t> clone() const override

inline virtual std::size_t stencil_size() const override

inline stencil_t get_stencil(constant_stencil_size_t) const override

inline apply_function_t get_apply_function(constant_stencil_size_t, const direction_t&) const override

inline virtual apply_function_1 get_apply_function(std::integral_constant<std::size_t, 1>, const direction_t&) const

inline virtual apply_function_2 get_apply_function(std::integral_constant<std::size_t, 2>, const direction_t&) const

inline virtual apply_function_3 get_apply_function(std::integral_constant<std::size_t, 3>, const direction_t&) const

inline virtual apply_function_4 get_apply_function(std::integral_constant<std::size_t, 4>, const direction_t&) const

inline virtual apply_function_5 get_apply_function(std::integral_constant<std::size_t, 5>, const direction_t&) const

inline virtual apply_function_6 get_apply_function(std::integral_constant<std::size_t, 6>, const direction_t&) const

inline virtual apply_function_7 get_apply_function(std::integral_constant<std::size_t, 7>, const direction_t&) const

inline virtual apply_function_8 get_apply_function(std::integral_constant<std::size_t, 8>, const direction_t&) const

inline virtual apply_function_9 get_apply_function(std::integral_constant<std::size_t, 9>, const direction_t&) const

inline virtual apply_function_10 get_apply_function(std::integral_constant<std::size_t, 10>, const direction_t&) const

inline virtual Stencil<1, dim> get_stencil(std::integral_constant<std::size_t, 1>) const

inline virtual Stencil<2, dim> get_stencil(std::integral_constant<std::size_t, 2>) const

inline virtual Stencil<3, dim> get_stencil(std::integral_constant<std::size_t, 3>) const

inline virtual Stencil<4, dim> get_stencil(std::integral_constant<std::size_t, 4>) const

inline virtual Stencil<5, dim> get_stencil(std::integral_constant<std::size_t, 5>) const

inline virtual Stencil<6, dim> get_stencil(std::integral_constant<std::size_t, 6>) const

inline virtual Stencil<7, dim> get_stencil(std::integral_constant<std::size_t, 7>) const

inline virtual Stencil<8, dim> get_stencil(std::integral_constant<std::size_t, 8>) const

inline virtual Stencil<9, dim> get_stencil(std::integral_constant<std::size_t, 9>) const

inline virtual Stencil<10, dim> get_stencil(std::integral_constant<std::size_t, 10>) const

Public Static Attributes

static constexpr std::size_t dim

template<std::size_t dim, class TInterval, std::size_t nd>
class OnDirection : public samurai::BcRegion<dim, TInterval>

Public Types

using base_t = BcRegion<dim, TInterval>

using direction_t = typename base_t::direction_t

using lca_t = typename base_t::lca_t

using region_t = typename base_t::region_t

Public Functions

OnDirection(const std::array<direction_t, nd> &d)

inline virtual region_t get_region(const lca_t &domain) const override

virtual std::unique_ptr<base_t> clone() const override

Private Members

std::array<direction_t, nd> m_d

template<class Field, std::size_t stencil_size_>
struct PolynomialExtrapolation : public samurai::Bc<Field>

Public Types

using base_t = samurai::Bc<Field>

using cell_t = typename base_t::cell_t

using value_t = typename base_t::value_t

using direction_t = typename base_t::direction_t

using stencil_t = samurai::Stencil<stencil_size_, dim>

using constant_stencil_size_t = std::integral_constant<std::size_t, stencil_size_>

using stencil_cells_t = std::array<cell_t, stencil_size_>

using apply_function_t = std::function<void(Field&, const std::array<cell_t, stencil_size_>&, const value_t&)>

Public Functions

inline virtual std::unique_ptr<base_t> clone() const override

inline virtual std::size_t stencil_size() const override

inline apply_function_t get_apply_function(constant_stencil_size_t, const direction_t&) const override

inline virtual apply_function_1 get_apply_function(std::integral_constant<std::size_t, 1>, const direction_t&) const

inline virtual apply_function_2 get_apply_function(std::integral_constant<std::size_t, 2>, const direction_t&) const

inline virtual apply_function_3 get_apply_function(std::integral_constant<std::size_t, 3>, const direction_t&) const

inline virtual apply_function_4 get_apply_function(std::integral_constant<std::size_t, 4>, const direction_t&) const

inline virtual apply_function_5 get_apply_function(std::integral_constant<std::size_t, 5>, const direction_t&) const

inline virtual apply_function_6 get_apply_function(std::integral_constant<std::size_t, 6>, const direction_t&) const

inline virtual apply_function_7 get_apply_function(std::integral_constant<std::size_t, 7>, const direction_t&) const

inline virtual apply_function_8 get_apply_function(std::integral_constant<std::size_t, 8>, const direction_t&) const

inline virtual apply_function_9 get_apply_function(std::integral_constant<std::size_t, 9>, const direction_t&) const

inline virtual apply_function_10 get_apply_function(std::integral_constant<std::size_t, 10>, const direction_t&) const

inline virtual Stencil<1, dim> get_stencil(std::integral_constant<std::size_t, 1>) const

inline virtual Stencil<2, dim> get_stencil(std::integral_constant<std::size_t, 2>) const

inline virtual Stencil<3, dim> get_stencil(std::integral_constant<std::size_t, 3>) const

inline virtual Stencil<4, dim> get_stencil(std::integral_constant<std::size_t, 4>) const

inline virtual Stencil<5, dim> get_stencil(std::integral_constant<std::size_t, 5>) const

inline virtual Stencil<6, dim> get_stencil(std::integral_constant<std::size_t, 6>) const

inline virtual Stencil<7, dim> get_stencil(std::integral_constant<std::size_t, 7>) const

inline virtual Stencil<8, dim> get_stencil(std::integral_constant<std::size_t, 8>) const

inline virtual Stencil<9, dim> get_stencil(std::integral_constant<std::size_t, 9>) const

inline virtual Stencil<10, dim> get_stencil(std::integral_constant<std::size_t, 10>) const

Public Static Attributes

static constexpr std::size_t max_stencil_size_implemented_PE = 6

static constexpr std::size_t dim

template<std::size_t dim, class TInterval, class Set>
class SetRegion : public samurai::BcRegion<dim, TInterval>

Public Types

using base_t = BcRegion<dim, TInterval>

using direction_t = typename base_t::direction_t

using lca_t = typename base_t::lca_t

using region_t = typename base_t::region_t

Public Functions

SetRegion(const Set &set)

virtual std::unique_ptr<base_t> clone() const override

inline virtual region_t get_region(const lca_t &domain) const override

Private Members

Set m_set

namespace detail

Typedefs

template<class T, std::size_t size>
using return_type_t = typename return_type<T, size>::type

Functions

template<class T, std::size_t size>
void fill(xt::xtensor_fixed<T, xt::xshape<size>> &data, T value)

template<class T>
void fill(T &data, T value)

template<std::size_t dim, class TInterval>
decltype(auto) get_mesh(const LevelCellArray<dim, TInterval> &mesh)

template<class D, class Config>
decltype(auto) get_mesh(const Mesh_base<D, Config> &mesh)

template<class Config>
decltype(auto) get_mesh(const UniformMesh<Config> &mesh)

template<class T, std::size_t size>
struct return_type

Public Types

using type = xt::xtensor_fixed<T, xt::xshape<size>>

Public Static Attributes

static constexpr std::size_t dim = 2

template<class T>
struct return_type<T, 1>

Public Types

using type = T

Public Static Attributes

static constexpr std::size_t dim = 1