"""
Methods to manage boundary conditions
"""
from pyro.util import msg
# keep track of whether the BCs are solid walls (passed into the
# Riemann solver).
bc_solid = {}
bc_solid["outflow"] = False
bc_solid["periodic"] = False
bc_solid["reflect"] = True
bc_solid["reflect-even"] = True
bc_solid["reflect-odd"] = True
bc_solid["dirichlet"] = True
bc_solid["neumann"] = False
ext_bcs = {}
[docs]
def define_bc(bc_type, function, is_solid=False):
"""
use this to extend the types of boundary conditions supported
on a solver-by-solver basis. Here we pass in the reference to
a function that can be called with the data that needs to be
filled. is_solid indicates whether it should be interpreted as
a solid wall (no flux through the BC)"
"""
bc_solid[bc_type] = is_solid
ext_bcs[bc_type] = function
def _set_reflect(odd_reflect_dir, dir_string):
if odd_reflect_dir == dir_string:
return "reflect-odd"
return "reflect-even"
[docs]
class BCProp:
"""
A simple container to hold properties of the boundary conditions.
"""
def __init__(self, xl_prop, xr_prop, yl_prop, yr_prop):
self.xl = xl_prop
self.xr = xr_prop
self.yl = yl_prop
self.yr = yr_prop
[docs]
def bc_is_solid(bc):
"""
return a container class indicating which boundaries are solid walls
"""
solid = BCProp(int(bc_solid[bc.xlb]),
int(bc_solid[bc.xrb]),
int(bc_solid[bc.ylb]),
int(bc_solid[bc.yrb]))
return solid
[docs]
class BC:
"""Boundary condition container -- hold the BCs on each boundary
for a single variable.
For Neumann and Dirichlet BCs, a function callback can be stored
for inhomogeous BCs. This function should provide the value on
the physical boundary (not cell center). This is evaluated on the
relevant edge when the __init__ routine is called. For this
reason, you need to pass in a grid object. Note: this only
ensures that the first ghost cells is consistent with the BC
value.
"""
def __init__(self, *,
xlb="outflow", xrb="outflow",
ylb="outflow", yrb="outflow",
xl_func=None, xr_func=None,
yl_func=None, yr_func=None,
grid=None,
odd_reflect_dir=""):
"""
Create the BC object.
Parameters
----------
xlb : {'outflow', 'periodic', 'reflect', 'reflect-even',
'reflect-odd', 'dirichlet', 'neumann',
user-defined}, optional
The type of boundary condition to enforce on the lower
x boundary. user-defined requires one to have defined
a new boundary condition type using define_bc()
xrb : {'outflow', 'periodic', 'reflect', 'reflect-even',
'reflect-odd', 'dirichlet', 'neumann',
user-defined}, optional
The type of boundary condition to enforce on the upper
x boundary. user-defined requires one to have defined
a new boundary condition type using define_bc()
ylb : {'outflow', 'periodic', 'reflect', 'reflect-even',
'reflect-odd', 'dirichlet', 'neumann',
user-defined}, optional
The type of boundary condition to enforce on the lower
y boundary. user-defined requires one to have defined
a new boundary condition type using define_bc()
yrb : {'outflow', 'periodic', 'reflect', 'reflect-even',
'reflect-odd', 'dirichlet', 'neumann',
user-defined}, optional
The type of boundary condition to enforce on the upper
y boundary. user-defined requires one to have defined
a new boundary condition type using define_bc()
odd_reflect_dir : {'x', 'y'}, optional
The direction along which reflection should be odd
(sign changes). If not specified, a boundary condition
of 'reflect' will always be set to 'reflect-even'
xl_func : function, optional
A function, f(y), that provides the value of the
Dirichlet or Neumann BC on the -x physical boundary.
xr_func : function, optional
A function, f(y), that provides the value of the
Dirichlet or Neumann BC on the +x physical boundary.
yl_func : function, optional
A function, f(x), that provides the value of the
Dirichlet or Neumann BC on the -y physical boundary.
yr_func : function, optional
A function, f(x), that provides the value of the
Dirichlet or Neumann BC on the +y physical boundary.
grid : a Grid2d object, optional
The grid object is used for evaluating the function
to define the boundary values for inhomogeneous
Dirichlet and Neumann BCs. It is required if
any functions are passed in.
"""
# note: "reflect" is ambiguous and will be converted into
# either reflect-even (the default) or reflect-odd if
# odd_reflect_dir specifies the corresponding direction ("x",
# "y")
valid = list(bc_solid.keys())
# -x boundary
if xlb in valid:
self.xlb = xlb
if self.xlb == "reflect":
self.xlb = _set_reflect(odd_reflect_dir, "x")
else:
msg.fail(f"ERROR: xlb = {xlb} invalid BC")
# +x boundary
if xrb in valid:
self.xrb = xrb
if self.xrb == "reflect":
self.xrb = _set_reflect(odd_reflect_dir, "x")
else:
msg.fail(f"ERROR: xrb = {xrb} invalid BC")
# -y boundary
if ylb in valid:
self.ylb = ylb
if self.ylb == "reflect":
self.ylb = _set_reflect(odd_reflect_dir, "y")
else:
msg.fail(f"ERROR: ylb = {ylb} invalid BC")
# +y boundary
if yrb in valid:
self.yrb = yrb
if self.yrb == "reflect":
self.yrb = _set_reflect(odd_reflect_dir, "y")
else:
msg.fail(f"ERROR: yrb = {yrb} invalid BC")
# periodic checks
if ((xlb == "periodic" and xrb != "periodic") or
(xrb == "periodic" and xlb != "periodic")):
msg.fail("ERROR: both xlb and xrb must be periodic")
if ((ylb == "periodic" and yrb != "periodic") or
(yrb == "periodic" and ylb != "periodic")):
msg.fail("ERROR: both ylb and yrb must be periodic")
# inhomogeneous functions for Dirichlet or Neumann
self.xl_value = self.xr_value = self.yl_value = self.yr_value = None
if xl_func is not None:
self.xl_value = xl_func(grid.y)
if xr_func is not None:
self.xr_value = xr_func(grid.y)
if yl_func is not None:
self.yl_value = yl_func(grid.x)
if yr_func is not None:
self.yr_value = yr_func(grid.x)
def __str__(self):
""" print out some basic information about the BC object """
string = f"BCs: -x: {self.xlb} +x: {self.xrb} -y: {self.ylb} +y: {self.yrb}"
return string
