def test_3d_block_2(): print('============== test_3d_block_2 ================') 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)) # ... create a finite element space p1 = 2 p2 = 2 p3 = 2 ne1 = 2 ne2 = 2 ne3 = 2 # ... print('> Grid :: [{},{},{}]'.format(ne1, ne2, ne3)) print('> Degree :: [{},{},{}]'.format(p1, p2, p3)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) grid_3 = linspace(0., 1., ne3 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V3 = SplineSpace(p3, grid=grid_3) Vx = TensorFemSpace(V1, V2, V3) Vy = TensorFemSpace(V1, V2, V3) Vz = TensorFemSpace(V1, V2, V3) V = VectorFemSpace(Vx, Vy, Vz) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_block_2', a, V, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) t3 = linspace(-pi, pi, ne3 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) x3 = linspace(0., 1., ne3 + 1) e = zeros((3, 3, ne1 + 1, ne2 + 1, ne3 + 1), order='F') symbol_f90(x1, x2, x3, t1, t2, t3, e) # ... print('')
def test_3d_scalar_4(): print('============== test_3d_scalar_4 ================') x, y, z = symbols('x y z') u = Symbol('u') v = Symbol('v') a = Lambda( (x, y, z, v, u), dx(dx(u)) * dx(dx(v)) + dy(dy(u)) * dy(dy(v)) + dz(dz(u)) * dz(dz(v))) print('> input := {0}'.format(a)) # ... create a finite element space p1 = 2 p2 = 2 p3 = 2 ne1 = 2 ne2 = 2 ne3 = 2 # ... print('> Grid :: [{},{},{}]'.format(ne1, ne2, ne3)) print('> Degree :: [{},{},{}]'.format(p1, p2, p3)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) grid_3 = linspace(0., 1., ne3 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V3 = SplineSpace(p3, grid=grid_3) V = TensorFemSpace(V1, V2, V3) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_scalar_4', a, V, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) t3 = linspace(-pi, pi, ne3 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) x3 = linspace(0., 1., ne3 + 1) e = zeros((ne1 + 1, ne2 + 1, ne3 + 1), order='F') symbol_f90(x1, x2, x3, t1, t2, t3, e) # ... print('')
def test_2d_block_1(): print('============== test_2d_block_1 ================') 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)) # ... create a finite element space p1 = 2 p2 = 2 ne1 = 8 ne2 = 8 print('> Grid :: [{ne1},{ne2}]'.format(ne1=ne1, ne2=ne2)) print('> Degree :: [{p1},{p2}]'.format(p1=p1, p2=p2)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) Vx = TensorFemSpace(V1, V2) Vy = TensorFemSpace(V1, V2) V = VectorFemSpace(Vx, Vy) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_block_2', a, V, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) e = zeros((2, 2, ne1 + 1, ne2 + 1), order='F') symbol_f90(x1, x2, t1, t2, e) # ... print('')
def test_2d_scalar_5(): print('============== test_2d_scalar_5 ================') x, y = symbols('x y') u = Symbol('u') v = Symbol('v') a = Lambda((x, y, v, u), dx(dx(u)) * dx(dx(v)) + dy(dy(u)) * dy(dy(v))) print('> input := {0}'.format(a)) # ... create a finite element space p1 = 2 p2 = 2 ne1 = 8 ne2 = 8 print('> Grid :: [{ne1},{ne2}]'.format(ne1=ne1, ne2=ne2)) print('> Degree :: [{p1},{p2}]'.format(p1=p1, p2=p2)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V = TensorFemSpace(V1, V2) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_scalar_5', a, V, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) e = zeros((ne1 + 1, ne2 + 1), order='F') symbol_f90(x1, x2, t1, t2, e) # ... print('')
def test_1d_scalar_2(): print('============== test_1d_scalar_2 ================') x = Symbol('x') u = Symbol('u') v = Symbol('v') b = Constant('b') a = Lambda((x, v, u), Dot(Grad(b * u), Grad(v)) + u * v) print('> input := {0}'.format(a)) # ... create a finite element space p = 3 ne = 64 print('> Grid :: {ne}'.format(ne=ne)) print('> Degree :: {p}'.format(p=p)) grid = linspace(0., 1., ne + 1) V = SplineSpace(p, grid=grid) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_scalar_2', a, V, d_constants={'b': 0.1}, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne + 1) x1 = linspace(0., 1., ne + 1) e = zeros(ne + 1) symbol_f90(x1, t1, e) # ... print('')
def test_1d_block_1(): print('============== test_1d_block_1 ================') 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)) # ... create a finite element space p = 3 ne = 64 print('> Grid :: {ne}'.format(ne=ne)) print('> Degree :: {p}'.format(p=p)) grid = linspace(0., 1., ne + 1) V1 = SplineSpace(p, grid=grid) V2 = SplineSpace(p, grid=grid) V = VectorFemSpace(V1, V2) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_block_1', a, V, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne + 1) x1 = linspace(0., 1., ne + 1) e = zeros((2, 2, ne + 1)) symbol_f90(x1, t1, e) # ... print('')
def test_2d_scalar_2(): print('============== test_2d_scalar_2 ================') x, y = symbols('x y') u = Symbol('u') v = Symbol('v') c = Constant('c') b0 = Constant('b0') b1 = Constant('b1') b = Tuple(b0, b1) a = Lambda((x, y, v, u), c * u * v + Dot(b, Grad(v)) * u + Dot(b, Grad(u)) * v) print('> input := {0}'.format(a)) # ... create a finite element space p1 = 2 p2 = 2 ne1 = 8 ne2 = 8 print('> Grid :: [{ne1},{ne2}]'.format(ne1=ne1, ne2=ne2)) print('> Degree :: [{p1},{p2}]'.format(p1=p1, p2=p2)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V = TensorFemSpace(V1, V2) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_scalar_2', a, V, d_constants={ 'b0': 0.1, 'b1': 1., 'c': 0.2 }, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) e = zeros((ne1 + 1, ne2 + 1), order='F') symbol_f90(x1, x2, t1, t2, e) # ... print('')
def test_2d_block_2(): print('============== test_2d_block_2 ================') x, y = symbols('x y') u = Symbol('u') v = Symbol('v') epsilon = Constant('epsilon') Laplace = lambda v, u: Dot(Grad(v), Grad(u)) Mass = lambda v, u: v * u u1, u2, p = symbols('u1 u2 p') v1, v2, q = symbols('v1 v2 q') a = Lambda((x, y, v1, v2, q, u1, u2, p), Laplace(v1, u1) - dx(v1) * p + Laplace(v2, u2) - dy(v2) * p + q * (dx(u1) + dy(u2)) + epsilon * Mass(q, p)) print('> input := {0}'.format(a)) # ... create a finite element space p1 = 2 p2 = 2 ne1 = 8 ne2 = 8 print('> Grid :: [{ne1},{ne2}]'.format(ne1=ne1, ne2=ne2)) print('> Degree :: [{p1},{p2}]'.format(p1=p1, p2=p2)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V = TensorFemSpace(V1, V2) V = VectorFemSpace(V, V, V) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # TODO not working yet => need complex numbers # # ... # symbol_f90 = compile_symbol('symbol_block_2', a, V, # d_constants={'epsilon': 0.1}, # backend='fortran') # # ... # # # ... example of symbol evaluation # t1 = linspace(-pi,pi, ne1+1) # t2 = linspace(-pi,pi, ne2+1) # x1 = linspace(0.,1., ne1+1) # x2 = linspace(0.,1., ne2+1) # e = zeros((2, 2, ne1+1, ne2+1), order='F') # symbol_f90(x1,x2,t1,t2, e) # # ... print('')
def test_2d_scalar_3(): print('============== test_2d_scalar_3 ================') x, y = symbols('x y') u = Symbol('u') v = Symbol('v') b = Function('b') a = Lambda((x, y, v, u), Dot(Grad(u), Grad(v)) + b(x, y) * u * v) print('> input := {0}'.format(a)) # ... create a finite element space p1 = 2 p2 = 2 ne1 = 8 ne2 = 8 print('> Grid :: [{ne1},{ne2}]'.format(ne1=ne1, ne2=ne2)) print('> Degree :: [{p1},{p2}]'.format(p1=p1, p2=p2)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V = TensorFemSpace(V1, V2) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... user defined function def b(x, y): r = 1. + x * y return r # ... # ... create an interactive pyccel context from pyccel.epyccel import ContextPyccel context = ContextPyccel(name='context_scalar_3') context.insert_function(b, ['double', 'double'], kind='function', results=['double']) context.compile() # ... # ... symbol_f90 = compile_symbol('symbol_scalar_3', a, V, context=context, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) e = zeros((ne1 + 1, ne2 + 1), order='F') symbol_f90(x1, x2, t1, t2, e) # ... print('')
def test_3d_block_4(): print('============== test_3d_block_4 ================') """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 = Constant('c0') c1 = Constant('c1') c2 = Constant('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)) # ... create a finite element space p1 = 2 p2 = 2 p3 = 2 ne1 = 2 ne2 = 2 ne3 = 2 # ... print('> Grid :: [{},{},{}]'.format(ne1, ne2, ne3)) print('> Degree :: [{},{},{}]'.format(p1, p2, p3)) grid_1 = linspace(0., 1., ne1 + 1) grid_2 = linspace(0., 1., ne2 + 1) grid_3 = linspace(0., 1., ne3 + 1) V1 = SplineSpace(p1, grid=grid_1) V2 = SplineSpace(p2, grid=grid_2) V3 = SplineSpace(p3, grid=grid_3) Vx = TensorFemSpace(V1, V2, V3) Vy = TensorFemSpace(V1, V2, V3) Vz = TensorFemSpace(V1, V2, V3) V = VectorFemSpace(Vx, Vy, Vz) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... symbol_f90 = compile_symbol('symbol_block_4', a, V, d_constants={ 'bx': 0.1, 'by': 1., 'bz': 0.2, 'c0': 0.1, 'c1': 1., 'c2': 1. }, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne1 + 1) t2 = linspace(-pi, pi, ne2 + 1) t3 = linspace(-pi, pi, ne3 + 1) x1 = linspace(0., 1., ne1 + 1) x2 = linspace(0., 1., ne2 + 1) x3 = linspace(0., 1., ne3 + 1) e = zeros((3, 3, ne1 + 1, ne2 + 1, ne3 + 1), order='F') symbol_f90(x1, x2, x3, t1, t2, t3, e) # ... print('')
def test_1d_scalar_3(): print('============== test_1d_scalar_3 ================') 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)) # ... create a finite element space p = 3 ne = 64 print('> Grid :: {ne}'.format(ne=ne)) print('> Degree :: {p}'.format(p=p)) grid = linspace(0., 1., ne + 1) V = SplineSpace(p, grid=grid) # ... # ... create a glt symbol from a string without evaluation expr = glt_symbol(a, space=V) print('> glt symbol := {0}'.format(expr)) # ... # ... user defined function def b(s): r = 1. + s * (1. - s) return r # ... # ... create an interactive pyccel context from pyccel.epyccel import ContextPyccel context = ContextPyccel(name='context_scalar_3') context.insert_function(b, ['double'], kind='function', results=['double']) context.compile() # ... # ... symbol_f90 = compile_symbol('symbol_scalar_3', a, V, context=context, backend='fortran') # ... # ... example of symbol evaluation t1 = linspace(-pi, pi, ne + 1) x1 = linspace(0., 1., ne + 1) e = zeros(ne + 1) symbol_f90(x1, t1, e) # ... print('')
def compile_symbol(name, expr, V, namespace=globals(), verbose=False, d_constants={}, d_args={}, context=None, backend='python', export_pyfile=True): """returns a lmabdified function for the GLT symbol.""" from spl.fem.vector import VectorFemSpace # ... parametric dimension dim = V.pdim # ... # ... 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 = glt_symbol(expr, space=V, evaluate=True) 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 glt symbol 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) # print(expr) # import sys; sys.exit(0) 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 = 'symbol_{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)) # ... # ... if fields: raise NotImplementedError('TODO') else: field_coeffs_str = '' eval_field_str = '' field_value_str = '' field_types_str = '' # ... # ... if isinstance(V, VectorFemSpace): if V.is_block: n_components = len(V.spaces) # ... identation (def function body) tab = ' ' * 4 # ... # ... update identation to be inside the loop for i in range(0, dim): tab += ' ' * 4 tab_base = tab # ... # ... lines = [] indices = ','.join('i{}'.format(i) for i in range(1, dim + 1)) for i in range(0, n_components): for j in range(0, n_components): s_ij = 'symbol[{i},{j},{indices}]'.format(i=i, j=j, indices=indices) e_ij = _convert_int_to_float(expr.expr[i, j]) # we call evalf to avoid having fortran doing the evaluation of rational # division line = '{s_ij} = {e_ij}'.format(s_ij=s_ij, e_ij=e_ij.evalf()) line = tab + line lines.append(line) symbol_expr = '\n'.join(line for line in lines) # ... code = template.format(__SYMBOL_NAME__=name, __SYMBOL_EXPR__=symbol_expr, __FIELD_COEFFS__=field_coeffs_str, __FIELD_EVALUATION__=eval_field_str, __FIELD_VALUE__=field_value_str, __ARGS__=args) else: raise NotImplementedError('TODO') else: # we call evalf to avoid having fortran doing the evaluation of rational # division e = _convert_int_to_float(expr.expr) code = template.format(__SYMBOL_NAME__=name, __SYMBOL_EXPR__=e.evalf(), __FIELD_COEFFS__=field_coeffs_str, __FIELD_EVALUATION__=eval_field_str, __FIELD_VALUE__=field_value_str, __ARGS__=args) # ... # ... export the python code of the module if export_pyfile: write_code(name, code, ext='py', folder='.pyccel') # ... # ... 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] # ... # print(code) # import sys; sys.exit(0) # ... exec(code, namespace) kernel = namespace[name] # ... # ... if backend == 'fortran': # try: # import epyccel function from pyccel.epyccel import epyccel # ... define a header to specify the arguments types for kernel template_str = 'symbol_header_{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)) # ... # ... header = template.format(__SYMBOL_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