def test_gelatize_2d_4(): print('============ test_gelatize_2d_4 =============') V = H1Space('V', ldim=2) v = TestFunction(V, name='v') u = TestFunction(V, name='u') expr = BilinearForm((v, u), dot(grad(v), grad(u))) print('> input >>> {0}'.format(expr)) print('> gelatized >>> {0}'.format(gelatize(expr)))
def test_gelatize_1d_1(): print('============ test_gelatize_1d_1 =============') V = H1Space('V', ldim=1) v = TestFunction(V, name='v') u = TestFunction(V, name='u') nx = symbols('nx', integer=True) px = symbols('px', integer=True) tx = symbols('tx') c1 = Constant('c1') c2 = Constant('c2') c3 = Constant('c3') c4 = Constant('c4') # ... expected = Mass(px, tx) / nx assert (gelatize(BilinearForm((v, u), u * v)) == expected) # ... # ... expected = nx * Stiffness(px, tx) assert (gelatize(BilinearForm((v, u), dot(grad(v), grad(u)))) == expected) # ... # ... expected = I * Advection(px, tx) assert (gelatize(BilinearForm((v, u), dx(u) * v)) == expected) # ... # ... expected = c1 * Mass(px, tx) / nx + c2 * I * Advection( px, tx) - c3 * I * Advection(px, tx) + c4 * nx * Stiffness(px, tx) assert (gelatize( BilinearForm((v, u), c1 * v * u + c2 * dx(u) * v + c3 * dx(v) * u + c4 * dx(v) * dx(u))) == expected)
def test_gelatize_2d_3(): print('============ test_gelatize_2d_3 =============') V = H1Space('V', ldim=2, is_block=True, shape=2) v = VectorTestFunction(V, name='v') u = VectorTestFunction(V, name='u') c = Constant('c') # a = BilinearForm((v,u), div(v) * div(u) + rot(v) * rot(u)) degrees = None expr = div(v) * div(u) + c * rot(v) * rot(u) expr = BilinearForm((v, u), expr) print('> input >>> {0}'.format(expr)) print('> gelatized >>> {0}'.format(gelatize(expr, degrees=degrees)))
def compile_symbol(name, a, degrees, n_elements=None, verbose=False, namespace=globals(), context=None, backend='python', export_pyfile=True): """.""" if not isinstance(a, BilinearForm): raise TypeError('Expecting a BilinearForm') # TODO: nderiv must be computed from the weak form nderiv = 1 # ... weak form attributs dim = a.ldim fields = a.fields # TODO improve is_block = False is_vector = False if verbose: print('> dim = ', dim) print('> Fields = ', fields) # ... # ... contants d_args = arguments_datatypes_as_dict(a.constants) args, dtypes = arguments_datatypes_split(d_args) # ... # 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 is_vector and not (is_block): raise NotImplementedError( 'We only treat the case of a block space, for ' 'which all components have are identical.') # ... # ... if is_block: pattern = 'block' elif is_vector: raise NotImplementedError('TODO.') else: pattern = 'scalar' # ... # ... get name of the template to be used template_str = '_symbol_{dim}d_{pattern}'.format(dim=dim, pattern=pattern) # ... # ... import the variable from the templates module # NOTE: THE PATH IS HARD CODED HERE! try: package = importlib.import_module("gelato.codegen.templates.symbol") except: raise ImportError('could not import {0}'.format(name)) template = getattr(package, template_str) # ... # ... expr = gelatize(a, degrees=degrees, n_elements=n_elements) # ... # ... TODO add an attribute called symbol_expr to the BilinearForm? # setattr(a, 'symbol_expr', expr) # ... # ... identation (def function body) tab_base = ' ' * 4 tab = tab_base # ... # ... append n_elements as argument of the generated symbol function if n_elements: n_elements_str = '' n_elements_types_str = '' else: ns = ['nx', 'ny', 'nz'][:dim] n_elements_str = ', '.join(n for n in ns) n_elements_str = ', {}'.format(n_elements_str) n_elements_types_str = ', '.join('int' for n in ns) n_elements_types_str = ', {}'.format(n_elements_types_str) # ... # ... field coeffs if fields: raise NotImplementedError() field_coeffs = construct_field_coeffs_names(fields) field_coeffs_str = print_field_coeffs(field_coeffs) field_types_str = print_field_coeffs_types(field_coeffs, dim) field_values = construct_field_values_names(expr, fields) eval_field_str = print_eval_field(expr, dim, fields, field_coeffs, field_values, verbose=verbose) # ... update identation to be inside the loop if is_bilinear_form: for i in range(0, 3 * dim): tab += ' ' * 4 elif is_linear_form: for i in range(0, 2 * dim): tab += ' ' * 4 elif is_function_form: for i in range(0, dim): tab += ' ' * 4 field_value_str = print_assign_field(expr, dim, fields, field_coeffs, field_values, tab, verbose=verbose) tab = tab_base # ... else: field_coeffs_str = '' eval_field_str = '' field_value_str = '' field_types_str = '' # ... # ... if fields: raise NotImplementedError() # we call normalize a second time, and activate the modification of the # fields, this will turn terms like dx(F) into F_x if F is a field expr = normalize(expr, enable_fields=True) # ... # ... x_args = construct_x_args_names(dim) t_args = construct_t_args_names(dim) x_args_str = print_position_args(x_args) t_args_str = print_fourier_args(t_args) # ... # ... TODO be careful of conflict when adding block case mat_args_str = print_mat_args() # ... # ... compute indentation # TODO # tab += ' '*4 # ... # ... tab = tab_base # ... # ... if is_block: raise NotImplementedError('') # ... - initializing element matrices # - define arguments # test functions and trial functions if is_bilinear_form: size = 2 * dim # test functions elif is_linear_form: size = dim elif is_function_form: raise NotImplementedError('') n_rows = test_n_components n_cols = trial_n_components mat_args = construct_element_matrix_names(n_rows, n_cols) mat_args_str = print_element_matrix_args(n_rows, n_cols, mat_args) mat_init_str = print_element_matrix_init(n_rows, n_cols, mat_args, size, tab) # ... update identation to be inside the loop for i in range(0, size): tab += ' ' * 4 tab_base = tab # ... # ... initializing accumulation variables accum_init_str = print_accumulation_var_init(n_rows, n_cols, tab) # ... # .. update indentation for i in range(0, dim): tab += ' ' * 4 # ... # ... accumulation contributions accum_str = print_accumulation_var(n_rows, n_cols, expr, tab) # ... # ... assign accumulated values to element matrix if is_bilinear_form: accum_assign_str = print_bilinear_accumulation_assign( n_rows, n_cols, dim, tab_base) elif is_linear_form: accum_assign_str = print_linear_accumulation_assign( n_rows, n_cols, dim, tab_base) # ... code = template.format(__KERNEL_NAME__=name, __X_ARGS__=x_args_str, __T_ARGS__=t_args_str, __MAT_ARGS__=mat_args_str, __N_ELEMENTS__=n_elements_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: # we call evalf to avoid having fortran doing the evaluation of rational # division e = _convert_int_to_float(expr.evalf()) code = template.format(__SYMBOL_NAME__=name, __SYMBOL_EXPR__=e.evalf(), __X_ARGS__=x_args_str, __T_ARGS__=t_args_str, __MAT_ARGS__=mat_args_str, __N_ELEMENTS__=n_elements_str, __FIELD_COEFFS__=field_coeffs_str, __FIELD_EVALUATION__=eval_field_str, __FIELD_VALUE__=field_value_str, __ARGS__=args) # ... # print('--------------') # print(code) # print('--------------') # import sys; sys.exit(0) # ... 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') # ... return kernel
def test_gelatize_3d_1(): print('============ test_gelatize_3d_1 =============') V = H1Space('V', ldim=3) v = TestFunction(V, name='v') u = TestFunction(V, name='u') nx, ny, nz = symbols('nx ny nz', integer=True) px, py, pz = symbols('px py pz', integer=True) tx, ty, tz = symbols('tx ty tz') c = Constant('c') bx = Constant('bx') by = Constant('by') bz = Constant('bz') b = Tuple(bx, by, bz) # ... expected = Mass(px, tx) * Mass(py, ty) * Mass(pz, tz) / (nx * ny * nz) assert (gelatize(BilinearForm((v, u), u * v)) == expected) # ... # ... expected = nx * Mass(py, ty) * Mass(pz, tz) * Stiffness(px, tx) / (ny * nz) assert (gelatize(BilinearForm((v, u), dx(u) * dx(v))) == expected) # ... # ... expected = I * Advection(py, ty) * Mass(px, tx) * Mass(pz, tz) / (nx * nz) assert (gelatize(BilinearForm((v, u), dy(u) * v)) == expected) # ... # ... expected = I * Advection(px, tx) * Mass(py, ty) * Mass(pz, tz) / (ny * nz) assert (gelatize(BilinearForm((v, u), dx(u) * v)) == expected) # ... # ... expected = (nx * Mass(py, ty) * Mass(pz, tz) * Stiffness(px, tx) / (ny * nz) + ny * Mass(px, tx) * Mass(pz, tz) * Stiffness(py, ty) / (nx * nz) + nz * Mass(px, tx) * Mass(py, ty) * Stiffness(pz, tz) / (nx * ny)) assert (gelatize(BilinearForm((v, u), dot(grad(v), grad(u)))) == expected) # ... # ... expected = ( nx * Mass(py, ty) * Mass(pz, tz) * Stiffness(px, tx) / (ny * nz) + I * Advection(px, tx) * Mass(py, ty) * Mass(pz, tz) / (ny * nz) + ny * Mass(px, tx) * Mass(pz, tz) * Stiffness(py, ty) / (nx * nz) + I * Advection(py, ty) * Mass(px, tx) * Mass(pz, tz) / (nx * nz) + nz * Mass(px, tx) * Mass(py, ty) * Stiffness(pz, tz) / (nx * ny)) assert (gelatize( BilinearForm( (v, u), dot(grad(v), grad(u)) + dx(u) * v + dy(u) * v)) == expected) # ... # ... expected = (-bx * I * Advection(px, tx) * Mass(py, ty) * Mass(pz, tz) / (ny * nz) - by * I * Advection(py, ty) * Mass(px, tx) * Mass(pz, tz) / (nx * nz) - bz * I * Advection(pz, tz) * Mass(px, tx) * Mass(py, ty) / (nx * ny)) assert (gelatize(BilinearForm((v, u), dot(b, grad(v)) * u)) == expected) # ... # ... expected = (bx**2 * nx * Mass(py, ty) * Mass(pz, tz) * Stiffness(px, tx) / (ny * nz) + 2 * bx * by * Advection(px, tx) * Advection(py, ty) * Mass(pz, tz) / nz + 2 * bx * bz * Advection(px, tx) * Advection(pz, tz) * Mass(py, ty) / ny + by**2 * ny * Mass(px, tx) * Mass(pz, tz) * Stiffness(py, ty) / (nx * nz) + 2 * by * bz * Advection(py, ty) * Advection(pz, tz) * Mass(px, tx) / nx + bz**2 * nz * Mass(px, tx) * Mass(py, ty) * Stiffness(pz, tz) / (nx * ny)) assert (gelatize(BilinearForm( (v, u), dot(b, grad(v)) * dot(b, grad(u)))) == expected) # ... degrees = None # degrees = [2, 1, 1] # evaluate = True evaluate = False
def test_gelatize_2d_1(): print('============ test_gelatize_2d_1 =============') V = H1Space('V', ldim=2) v = TestFunction(V, name='v') u = TestFunction(V, name='u') nx, ny = symbols('nx ny', integer=True) px, py = symbols('px py', integer=True) tx, ty = symbols('tx ty') c = Constant('c') bx = Constant('bx') by = Constant('by') b = Tuple(bx, by) # ... expected = Mass(px, tx) * Mass(py, ty) / (nx * ny) assert (gelatize(BilinearForm((v, u), u * v)) == expected) # ... # ... expected = Mass(py, ty) * nx * Stiffness(px, tx) / ny assert (gelatize(BilinearForm((v, u), dx(u) * dx(v))) == expected) # ... # ... expected = I * Advection(py, ty) * Mass(px, tx) / nx assert (gelatize(BilinearForm((v, u), dy(u) * v)) == expected) # ... # ... expected = I * Advection(px, tx) * Mass(py, ty) / ny assert (gelatize(BilinearForm((v, u), dx(u) * v)) == expected) # ... # ... expected = Mass(px, tx) * ny * Stiffness(py, ty) / nx + Mass( py, ty) * nx * Stiffness(px, tx) / ny assert (gelatize(BilinearForm((v, u), dot(grad(v), grad(u)))) == expected) # ... # ... expected = (nx * Mass(py, ty) * Stiffness(px, tx) / ny + I * Advection(px, tx) * Mass(py, ty) / ny + ny * Mass(px, tx) * Stiffness(py, ty) / nx + I * Advection(py, ty) * Mass(px, tx) / nx) assert (gelatize( BilinearForm( (v, u), dot(grad(v), grad(u)) + dx(u) * v + dy(u) * v)) == expected) # ... # ... expected = -bx * I * Advection(px, tx) * Mass( py, ty) / ny - by * I * Advection(py, ty) * Mass(px, tx) / nx assert (gelatize(BilinearForm((v, u), dot(b, grad(v)) * u)) == expected) # ... # ... expected = bx**2 * nx * Mass(py, ty) * Stiffness( px, tx) / ny + 2 * bx * by * Advection(px, tx) * Advection( py, ty) + by**2 * ny * Mass(px, tx) * Stiffness(py, ty) / nx assert (gelatize(BilinearForm( (v, u), dot(b, grad(v)) * dot(b, grad(u)))) == expected) # ... degrees = None # degrees = [2, 1] # evaluate = True evaluate = False