def test_3d_4b():
"""Alfven operator."""
x, y, z = symbols('x y z')
u = IndexedBase('u')
v = IndexedBase('v')
bx = Constant('bx')
by = Constant('by')
bz = Constant('bz')
b = Tuple(bx, by, bz)
c0, c1, c2 = symbols('c0 c1 c2')
a = Lambda((x, y, z, v, u),
(c0 * Dot(u, v) - c1 * Div(u) * Div(v) +
c2 * Dot(Curl(Cross(b, u)), Curl(Cross(b, v)))))
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=True, verbose=True)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_3d_3():
x, y, z = symbols('x y z')
u = IndexedBase('u')
v = IndexedBase('v')
a = Lambda((x, y, z, v, u), Dot(Curl(u), Curl(v)) + 0.2 * Dot(u, v))
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=True, verbose=True)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_3d_1():
x, y, z = symbols('x y z')
u = Symbol('u')
v = Symbol('v')
a = Lambda((x, y, z, v, u), Dot(Grad(u), Grad(v)))
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_1d_3():
x = Symbol('x')
u0, u1 = symbols('u0 u1')
v0, v1 = symbols('v0 v1')
a = Lambda((x,v0,v1,u0,u1), dx(u0)*dx(v0) + dx(u1)*v0 + u0*dx(v1) + u1*v1)
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=True)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_2d_3():
x, y = symbols('x y')
u = Symbol('u')
v = Symbol('v')
a = Lambda((x, y, v, u), Cross(Curl(u), Curl(v)) + 0.2 * u * v)
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=True)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_2d_2():
x, y = symbols('x y')
u = IndexedBase('u')
v = IndexedBase('v')
a = Lambda((x, y, v, u),
Rot(u) * Rot(v) + Div(u) * Div(v) + 0.2 * Dot(u, v))
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=True, verbose=True)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_1d_4():
x = Symbol('x')
u = Symbol('u')
v = Symbol('v')
b = Function('b')
a = Lambda((x,v,u), Dot(Grad(u), Grad(v)) + b(x)*u*v)
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM)
print('> weak form := {0}'.format(expr))
# ...
print('')
def test_2d_4():
x, y = symbols('x y')
u = Symbol('u')
v = Symbol('v')
bx = Constant('bx')
by = Constant('by')
b = Tuple(bx, by)
a = Lambda((x, y, v, u), 0.2 * u * v + Dot(b, Grad(v)) * u)
print('> input := {0}'.format(a))
# ...
expr = construct_weak_form(a, dim=DIM, is_block=False)
print('> weak form := {0}'.format(expr))
# ...
print('')
def glt_symbol(expr,
n_deriv=1,
space=None,
verbose=False,
evaluate=False,
is_block=False,
discretization=None,
instructions=[],
**settings):
"""
computes the glt symbol of a weak formulation given as a sympy expression.
expr: sympy.Expression
a sympy expression or a text
space: spl.fem.SplineSpace, spl.fem.TensorFemSpace, spl.fem.VectorFemSpace
a Finite elements space from spl. Default: None
n_deriv: int
maximum derivatives that appear in the weak formulation.
verbose: bool
talk more
evaluate: bool
causes the evaluation of the atomic symbols, if true
is_block: bool
treat a block prolbem if True. Must be supplied only when using
discretization. Otherwise, the fem space should be consistent with the
weak formulation.
discretization: dict
a dictionary that contains the used discretization
instructions: list
a list to keep track of the applied instructions.
settings: dict
dictionary for different settings
"""
# ...
if not isinstance(expr, Lambda):
raise TypeError('Expecting a Lambda expression')
# ...
# ...
if not (discretization is None):
dim = len(discretization['n_elements'])
elif not (space is None):
dim = space.pdim
n_elements = space.ncells
if not (isinstance(n_elements, (list, tuple))):
n_elements = [n_elements]
degrees = space.degree
if not (isinstance(degrees, (list, tuple))): degrees = [degrees]
discretization = {'n_elements': n_elements, 'degrees': degrees}
from spl.fem.vector import VectorFemSpace
is_block = isinstance(space, VectorFemSpace)
if is_block:
# TODO make sure all degrees are the same?
# or remove discretization and use only the space
discretization['degrees'] = degrees[0]
# TODO check that the weak form is consistent with the space (both are blocks)
else:
raise ValueError('discretization (dict) or fem space must be given')
# ...
# ...
expr = construct_weak_form(expr,
dim=dim,
is_block=is_block,
verbose=verbose)
# ...
# ...
if verbose:
print("*** Input expression : ", expr)
# ...
# ...
if type(expr) == dict:
d_expr = {}
for key, txt in list(expr.items()):
# ... when using vale, we may get also a coefficient.
if type(txt) == list:
txt = str(txt[0]) + " * (" + txt[1] + ")"
# ...
# ...
title = "Computing the GLT symbol for the block " + str(key)
instructions.append(latex_title_as_paragraph(title))
# ...
# ...
d_expr[key] = glt_symbol(txt,
n_deriv=n_deriv,
verbose=verbose,
evaluate=evaluate,
discretization=discretization,
instructions=instructions,
**settings)
# ...
if len(d_expr) == 1:
key = d_expr.keys()[0]
return d_expr[key]
return dict_to_matrix(d_expr, instructions=instructions, **settings)
else:
# ...
ns = {}
# ...
# ...
d = basis_symbols(dim, n_deriv)
for key, item in list(d.items()):
ns[key] = item
# ...
# ...
if isinstance(expr, Lambda):
expr = normalize_weak_from(expr)
# ...
# ...
expr = sympify(expr, locals=ns)
expr = expr.expand()
# ...
# ...
# ...
if verbose:
# ...
instruction = "We consider the following weak formulation:"
instructions.append(instruction)
instructions.append(glt_latex(expr, **settings))
# ...
print(">>> weak formulation: ", expr)
# ...
# ...
expr = apply_mapping(expr, dim=dim, \
instructions=instructions, \
**settings)
if verbose:
print('>>> apply mapping: ', expr)
# ...
# ...
expr = apply_tensor(expr, dim=dim, \
instructions=instructions, \
**settings)
if verbose:
print('>>> apply tensor: ', expr)
# ...
# ...
expr = apply_factor(expr, dim, \
instructions=instructions, \
**settings)
if verbose:
print('>>> apply factor: ', expr)
# ...
# ...
if not evaluate:
return expr
# ...
# ...
if not discretization:
return expr
# ...
# ...
expr = glt_update_atoms(expr, discretization)
# ...
return expr
def compile_kernel(name,
expr,
V,
namespace=globals(),
verbose=False,
d_constants={},
d_args={},
context=None,
backend='python',
export_pyfile=True):
"""returns a kernel from a Lambda expression on a Finite Elements space."""
from spl.fem.vector import VectorFemSpace
from spl.fem.splines import SplineSpace
from spl.fem.tensor import TensorFemSpace
# ... parametric dimension
dim = V.pdim
# ...
# ... number of partial derivatives
# TODO must be computed from the weak form then we re-initialize the
# space
if isinstance(V, SplineSpace):
nderiv = V.nderiv
elif isinstance(V, TensorFemSpace):
nderiv = max(W.nderiv for W in V.spaces)
elif isinstance(V, VectorFemSpace):
nds = []
for W in V.spaces:
if isinstance(W, SplineSpace):
nderiv = W.nderiv
elif isinstance(W, TensorFemSpace):
nderiv = max(X.nderiv for X in W.spaces)
nds.append(nderiv)
nderiv = max(nds)
# ...
# ...
if verbose:
print('> input := {0}'.format(expr))
# ...
# ...
fields = [i for i in expr.free_symbols if isinstance(i, Field)]
if verbose:
print('> Fields = ', fields)
# ...
# ...
expr = construct_weak_form(expr,
dim=dim,
is_block=isinstance(V, VectorFemSpace))
if verbose:
print('> weak form := {0}'.format(expr))
# ...
# ... contants
# for each argument, we compute its datatype (needed for Pyccel)
# case of Numeric Native Python types
# this means that a has a given value (1, 1.0 etc)
if d_constants:
for k, a in list(d_constants.items()):
if not isinstance(a, Number):
raise TypeError('Expecting a Python Numeric object')
# update the weak formulation using the given arguments
_d = {}
for k, v in list(d_constants.items()):
if isinstance(k, str):
_d[Constant(k)] = v
else:
_d[k] = v
expr = expr.subs(_d)
args = ''
dtypes = ''
if d_args:
# ... additional arguments
# for each argument, we compute its datatype (needed for Pyccel)
for k, a in list(d_args.items()):
# otherwise it can be a string, that specifies its type
if not isinstance(a, str):
raise TypeError('Expecting a string')
if not a in ['int', 'double', 'complex']:
raise TypeError('Wrong type for {} :: {}'.format(k, a))
# we convert the dictionaries to OrderedDict, to avoid wrong ordering
d_args = OrderedDict(sorted(list(d_args.items())))
names = []
dtypes = []
for n, d in list(d_args.items()):
names.append(n)
dtypes.append(d)
args = ', '.join('{}'.format(a) for a in names)
dtypes = ', '.join('{}'.format(a) for a in dtypes)
args = ', {}'.format(args)
dtypes = ', {}'.format(dtypes)
# TODO check what are the free_symbols of expr,
# to make sure the final code will compile
# the remaining free symbols must be the trial/test basis functions,
# and the coordinates
# ...
# ...
if isinstance(V, VectorFemSpace) and not (V.is_block):
raise NotImplementedError(
'We only treat the case of a block space, for '
'which all components have are identical.')
# ...
# ...
pattern = 'scalar'
if isinstance(V, VectorFemSpace):
if V.is_block:
pattern = 'block'
else:
raise NotImplementedError(
'We only treat the case of a block space, for '
'which all components have are identical.')
# ...
# ...
template_str = 'template_{dim}d_{pattern}'.format(dim=dim, pattern=pattern)
try:
template = eval(template_str)
except:
raise ValueError('Could not find the corresponding template {}'.format(
template_str))
# ...
# ... identation (def function body)
tab = ' ' * 4
# ...
# ... field coeffs
if fields:
field_coeffs = OrderedDict()
for f in fields:
coeffs = 'coeff_{}'.format(f.name)
field_coeffs[str(f.name)] = coeffs
ls = [v for v in list(field_coeffs.values())]
field_coeffs_str = ', '.join(i for i in ls)
# add ',' for kernel signature
field_coeffs_str = ', {}'.format(field_coeffs_str)
eval_field_str = print_eval_field(expr,
V.pdim,
fields,
verbose=verbose)
# ...
if dim == 1:
e_pattern = '{field}{deriv} = {field}{deriv}_values[g1]'
elif dim == 2:
e_pattern = '{field}{deriv} = {field}{deriv}_values[g1,g2]'
elif dim == 3:
e_pattern = '{field}{deriv} = {field}{deriv}_values[g1,g2,g3]'
else:
raise NotImplementedError('only 1d, 2d and 3d are available')
field_values = OrderedDict()
free_names = [str(f.name) for f in expr.free_symbols]
for f in fields:
ls = []
if f.name in free_names:
ls.append(f.name)
for deriv in BASIS_PREFIX:
f_d = '{field}_{deriv}'.format(field=f.name, deriv=deriv)
if f_d in free_names:
ls.append(f_d)
field_values[f.name] = ls
tab_base = tab
# ... update identation to be inside the loop
for i in range(0, 3 * dim):
tab += ' ' * 4
lines = []
for k, fs in list(field_values.items()):
coeff = field_coeffs[k]
for f in fs:
ls = f.split('_')
if len(ls) == 1:
deriv = ''
else:
deriv = '_{}'.format(ls[-1])
line = e_pattern.format(field=k, deriv=deriv)
line = tab + line
lines.append(line)
field_value_str = '\n'.join(line for line in lines)
tab = tab_base
# ...
# ...
field_types = []
slices = ','.join(':' for i in range(0, dim))
for v in list(field_coeffs.values()):
field_types.append('double [{slices}]'.format(slices=slices))
field_types_str = ', '.join(i for i in field_types)
field_types_str = ', {}'.format(field_types_str)
# ...
else:
field_coeffs_str = ''
eval_field_str = ''
field_value_str = ''
field_types_str = ''
# ...
# ... compute indentation
tab_base = tab
for i in range(0, 3 * dim):
tab += ' ' * 4
# ...
# ... print test functions
d_test_basis = construct_test_functions(nderiv, dim)
test_names = [i.name for i in expr.free_symbols if is_test_function(i)]
test_names.sort()
lines = []
for a in test_names:
if a == 'Ni':
basis = ' * '.join(d_test_basis[k, 0] for k in range(1, dim + 1))
line = 'Ni = {basis}'.format(basis=basis)
else:
deriv = a.split('_')[-1]
nx = _count_letter(deriv, 'x')
ny = _count_letter(deriv, 'y')
nz = _count_letter(deriv, 'z')
basis = ' * '.join(d_test_basis[k, d]
for k, d in zip(range(1, dim +
1), [nx, ny, nz]))
line = 'Ni_{deriv} = {basis}'.format(deriv=deriv, basis=basis)
lines.append(tab + line)
test_function_str = '\n'.join(l for l in lines)
# ...
# ... print trial functions
d_trial_basis = construct_trial_functions(nderiv, dim)
trial_names = [i.name for i in expr.free_symbols if is_trial_function(i)]
trial_names.sort()
lines = []
for a in trial_names:
if a == 'Nj':
basis = ' * '.join(d_trial_basis[k, 0] for k in range(1, dim + 1))
line = 'Nj = {basis}'.format(basis=basis)
else:
deriv = a.split('_')[-1]
nx = _count_letter(deriv, 'x')
ny = _count_letter(deriv, 'y')
nz = _count_letter(deriv, 'z')
basis = ' * '.join(d_trial_basis[k, d]
for k, d in zip(range(1, dim +
1), [nx, ny, nz]))
line = 'Nj_{deriv} = {basis}'.format(deriv=deriv, basis=basis)
lines.append(tab + line)
trial_function_str = '\n'.join(l for l in lines)
# ...
# ...
tab = tab_base
# ...
# ...
if isinstance(V, VectorFemSpace):
if V.is_block:
n_components = len(V.spaces)
# ... - initializing element matrices
# - define arguments
lines = []
mat_args = []
slices = ','.join(':' for i in range(0, 2 * dim))
for i in range(0, n_components):
for j in range(0, n_components):
mat = 'mat_{i}{j}'.format(i=i, j=j)
mat_args.append(mat)
line = '{mat}[{slices}] = 0.0'.format(mat=mat,
slices=slices)
line = tab + line
lines.append(line)
mat_args_str = ', '.join(mat for mat in mat_args)
mat_init_str = '\n'.join(line for line in lines)
# ...
# ... update identation to be inside the loop
for i in range(0, 2 * dim):
tab += ' ' * 4
tab_base = tab
# ...
# ... initializing accumulation variables
lines = []
for i in range(0, n_components):
for j in range(0, n_components):
line = 'v_{i}{j} = 0.0'.format(i=i, j=j)
line = tab + line
lines.append(line)
accum_init_str = '\n'.join(line for line in lines)
# ...
# .. update indentation
for i in range(0, dim):
tab += ' ' * 4
# ...
# ... accumulation contributions
lines = []
for i in range(0, n_components):
for j in range(0, n_components):
line = 'v_{i}{j} += ({__WEAK_FORM__}) * wvol'
e = _convert_int_to_float(expr[i, j].evalf())
# we call evalf to avoid having fortran doing the evaluation of rational
# division
line = line.format(i=i, j=j, __WEAK_FORM__=e)
line = tab + line
lines.append(line)
accum_str = '\n'.join(line for line in lines)
# ...
# ... assign accumulated values to element matrix
if dim == 1:
e_pattern = 'mat_{i}{j}[il_1, p1 + jl_1 - il_1] = v_{i}{j}'
elif dim == 2:
e_pattern = 'mat_{i}{j}[il_1, il_2, p1 + jl_1 - il_1, p2 + jl_2 - il_2] = v_{i}{j}'
elif dim == 3:
e_pattern = 'mat_{i}{j}[il_1, il_2, il_3, p1 + jl_1 - il_1, p2 + jl_2 - il_2, p3 + jl_3 - il_3] = v_{i}{j}'
else:
raise NotImplementedError('only 1d, 2d and 3d are available')
tab = tab_base
lines = []
for i in range(0, n_components):
for j in range(0, n_components):
line = e_pattern.format(i=i, j=j)
line = tab + line
lines.append(line)
accum_assign_str = '\n'.join(line for line in lines)
# ...
code = template.format(__KERNEL_NAME__=name,
__MAT_ARGS__=mat_args_str,
__FIELD_COEFFS__=field_coeffs_str,
__FIELD_EVALUATION__=eval_field_str,
__MAT_INIT__=mat_init_str,
__ACCUM_INIT__=accum_init_str,
__FIELD_VALUE__=field_value_str,
__TEST_FUNCTION__=test_function_str,
__TRIAL_FUNCTION__=trial_function_str,
__ACCUM__=accum_str,
__ACCUM_ASSIGN__=accum_assign_str,
__ARGS__=args)
else:
raise NotImplementedError(
'We only treat the case of a block space, for '
'which all components have are identical.')
else:
e = _convert_int_to_float(expr.evalf())
# we call evalf to avoid having fortran doing the evaluation of rational
# division
code = template.format(__KERNEL_NAME__=name,
__FIELD_COEFFS__=field_coeffs_str,
__FIELD_EVALUATION__=eval_field_str,
__FIELD_VALUE__=field_value_str,
__TEST_FUNCTION__=test_function_str,
__TRIAL_FUNCTION__=trial_function_str,
__WEAK_FORM__=e,
__ARGS__=args)
# ...
# print('--------------')
# print(code)
# print('--------------')
# ...
if context:
from pyccel.epyccel import ContextPyccel
if isinstance(context, ContextPyccel):
context = [context]
elif isinstance(context, (list, tuple)):
for i in context:
assert (isinstance(i, ContextPyccel))
else:
raise TypeError(
'Expecting a ContextPyccel or list/tuple of ContextPyccel')
# append functions to the namespace
for c in context:
for k, v in list(c.functions.items()):
namespace[k] = v[0]
# ...
# ...
exec(code, namespace)
kernel = namespace[name]
# ...
# ... export the python code of the module
if export_pyfile:
write_code(name, code, ext='py', folder='.pyccel')
# ...
# ...
if backend == 'fortran':
# try:
# import epyccel function
from pyccel.epyccel import epyccel
# ... define a header to specify the arguments types for kernel
try:
template = eval('template_header_{dim}d_{pattern}'.format(
dim=dim, pattern=pattern))
except:
raise ValueError('Could not find the corresponding template')
# ...
# ...
if isinstance(V, VectorFemSpace):
if V.is_block:
# ... declare element matrices dtypes
mat_types = []
for i in range(0, n_components):
for j in range(0, n_components):
if dim == 1:
mat_types.append('double [:,:]')
elif dim == 2:
mat_types.append('double [:,:,:,:]')
elif dim == 3:
mat_types.append('double [:,:,:,:,:,:]')
else:
raise NotImplementedError(
'only 1d, 2d and 3d are available')
mat_types_str = ', '.join(mat for mat in mat_types)
# ...
header = template.format(__KERNEL_NAME__=name,
__MAT_TYPES__=mat_types_str,
__FIELD_TYPES__=field_types_str,
__TYPES__=dtypes)
else:
raise NotImplementedError(
'We only treat the case of a block space, for '
'which all components have are identical.')
else:
header = template.format(__KERNEL_NAME__=name,
__FIELD_TYPES__=field_types_str,
__TYPES__=dtypes)
# ...
# compile the kernel
kernel = epyccel(code, header, name=name, context=context)
# except:
# print('> COULD NOT CONVERT KERNEL TO FORTRAN')
# print(' THE PYTHON BACKEND WILL BE USED')
# ...
return kernel
