Beispiel #1
0
def test_2d_block_3():
    print('============== test_2d_block_3 ================')

    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)
    # ...

    # ...
    kernel_py = compile_kernel('kernel_block_3',
                               a,
                               V,
                               d_args={'epsilon': 'double'},
                               backend='python')
    kernel_f90 = compile_kernel('kernel_block_3',
                                a,
                                V,
                                d_args={'epsilon': 'double'},
                                backend='fortran')

    M_py = assemble_matrix(V, kernel_py, args={'epsilon': 1.e-3})
    M_f90 = assemble_matrix(V, kernel_f90, args={'epsilon': 1.e-3})
    # ...

    assert_identical_coo(M_py, M_f90)

    print('')
Beispiel #2
0
def test_1d_scalar_5():
    print('============== test_1d_scalar_5 ================')

    # ... define the weak formulation
    x = Symbol('x')

    u = Symbol('u')
    v = Symbol('v')

    a = Lambda((x, v, u), dx(dx(u)) * dx(dx(v)))
    # ...

    # ...  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, nderiv=2)
    # ...

    # ...
    kernel_py = compile_kernel('kernel_scalar_5', a, V, backend='python')
    kernel_f90 = compile_kernel('kernel_scalar_5', a, V, backend='fortran')

    M_py = assemble_matrix(V, kernel_py)
    M_f90 = assemble_matrix(V, kernel_f90)
    # ...

    assert_identical_coo(M_py, M_f90)
Beispiel #3
0
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('')
Beispiel #4
0
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('')
Beispiel #5
0
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('')
Beispiel #6
0
def test_1d_5():
    x,y = symbols('x y')

    u = Symbol('u')
    v = Symbol('v')

    a = Lambda((x,y,v,u), dx(dx(u))*dx(dx(dx(v))) + u*v)
    print('> input       := {0}'.format(a))

    expr = gelatize(a, dim=DIM)
    print('> gelatized   := {0}'.format(expr))

    expr = normalize_weak_from(expr)
    print('> normal form := {0}'.format(expr))

    print('')
Beispiel #7
0
def test_3d_scalar_5():
    print('============== test_3d_scalar_5 ================')

    # ... define the weak formulation
    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)) + Dot(Grad(u), Grad(v)) + u * v)
    # ...

    # ...  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, nderiv=2)
    V2 = SplineSpace(p2, grid=grid_2, nderiv=2)
    V3 = SplineSpace(p3, grid=grid_3, nderiv=2)

    V = TensorFemSpace(V1, V2, V3)
    # ...

    # ...
    kernel_py = compile_kernel('kernel_scalar_5', a, V, backend='python')
    kernel_f90 = compile_kernel('kernel_scalar_5', a, V, backend='fortran')

    M_py = assemble_matrix(V, kernel_py)
    M_f90 = assemble_matrix(V, kernel_f90)
    # ...

    assert_identical_coo(M_py, M_f90)
Beispiel #8
0
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('')
Beispiel #9
0
def test_2d_scalar_6():
    print('============== test_2d_scalar_6 ================')

    # ... define the weak formulation
    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)) +
               Dot(Grad(u), Grad(v)) + u * v)
    # ...

    # ...  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, nderiv=2)
    V2 = SplineSpace(p2, grid=grid_2, nderiv=2)

    V = TensorFemSpace(V1, V2)
    # ...

    # ...
    kernel_py = compile_kernel('kernel_scalar_6', a, V, backend='python')
    kernel_f90 = compile_kernel('kernel_scalar_6', a, V, backend='fortran')

    M_py = assemble_matrix(V, kernel_py)
    M_f90 = assemble_matrix(V, kernel_f90)
    # ...

    assert_identical_coo(M_py, M_f90)
Beispiel #10
0
def test_1d_scalar_4():
    print('============== test_1d_scalar_4 ================')

    x = Symbol('x')

    u = Symbol('u')
    v = Symbol('v')

    a = Lambda((x, v, u), dx(dx(u)) * dx(dx(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_4', a, V, 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('')
Beispiel #11
0
def test_1d_block_1():
    print('============== test_1d_block_1 ================')

    # ... define the weak formulation
    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)
    # ...

    # ...  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)
    # ...

    # ... Vector fem space
    V = VectorFemSpace(V, V)
    # ...

    # ...
    kernel_py = compile_kernel('kernel_block_1', a, V, backend='python')
    kernel_f90 = compile_kernel('kernel_block_1', backend='fortran')

    M_py = assemble_matrix(V, kernel_py)
    M_f90 = assemble_matrix(V, kernel_f90)
    # ...

    assert_identical_coo(M_py, M_f90)
Beispiel #12
0
def test_1d_6():
    x,y = symbols('x y')

    u = Symbol('u')
    v = Symbol('v')

    F = Field('F')

    a = Lambda((x,y,v,u), Dot(Grad(dx(F)*u), Grad(v)) + u*v)
    print('> input       := {0}'.format(a))

    expr = gelatize(a, dim=DIM)
    print('> gelatized   := {0}'.format(expr))

    expr = normalize_weak_from(expr)
    print('> normal form := {0}'.format(expr))

    print('')
Beispiel #13
0
def test_2d_scalar_4():
    print('============== test_2d_scalar_4 ================')

    # ... define the weak formulation
    x, y = symbols('x y')

    u = Symbol('u')
    v = Symbol('v')

    b0 = Function('b0')
    b1 = Function('b1')

    a = Lambda((x, y, v, u), (b0(x, y) * dx(v) + b1(x, y) * dy(v)) *
               (b0(x, y) * dx(u) + b1(x, y) * dy(u)))
    # ...

    # ...  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)

    # ...

    # ... user defined function
    def b0(x, y):
        from numpy import sin
        from scipy import pi

        r = 1.1659397624413860850012270020670 * (1.0 + 0.1 * sin(2 * pi * y))
        return r

    def b1(x, y):
        from numpy import sin
        from scipy import pi

        r = 1.0 * (1.0 + 0.1 * sin(2 * pi * y))
        return r

    # ...

    # ... create an interactive pyccel context
    from pyccel.epyccel import ContextPyccel

    context = ContextPyccel(name='context_4')
    context.insert_function(b0, ['double', 'double'],
                            kind='function',
                            results=['double'])
    context.insert_function(b1, ['double', 'double'],
                            kind='function',
                            results=['double'])

    context.compile()
    # ...

    # ...
    kernel_py = compile_kernel('kernel_scalar_4',
                               a,
                               V,
                               context=context,
                               verbose=True,
                               backend='python')

    kernel_f90 = compile_kernel('kernel_scalar_4',
                                a,
                                V,
                                context=context,
                                verbose=True,
                                backend='fortran')
    # ...

    # ...
    M_py = assemble_matrix(V, kernel_py)
    M_f90 = assemble_matrix(V, kernel_f90)
    # ...

    assert_identical_coo(M_py, M_f90)
Beispiel #14
0
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('')