feectools 0.1.0__py3-none-any.whl

feectools/fem/tests/test_splines.py

@@ -0,0 +1,184 @@
+# -*- coding: UTF-8 -*-
+
+from feectools.fem.basic   import FemField
+from feectools.fem.splines import SplineSpace
+from feectools.fem.tensor  import TensorFemSpace
+from feectools.fem.vector  import VectorFemSpace
+from feectools.ddm.cart    import DomainDecomposition
+
+from numpy import linspace
+
+
+def test_1d_1():
+    print ('>>> test_1d_1')
+
+    knots = [0., 0., 0., 1., 1., 1.]
+    p = 2
+    V = SplineSpace(p, knots=knots)
+    print (V)
+    F = FemField(V)
+
+def test_1d_2():
+    print ('>>> test_1d_2')
+
+    p = 2
+    grid = linspace(0., 1., 5)
+    V = SplineSpace(p, grid=grid)
+    print (V)
+    F = FemField(V)
+
+def test_1d_3():
+    print ('>>> test_1d_3')
+
+    p = 2
+    grid = linspace(0., 1., 5)
+    V1 = SplineSpace(p, grid=grid)
+    V2 = SplineSpace(p+1, grid=grid)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False])
+    V = TensorFemSpace(domain_decomposition, V1, V2)
+    print (V)
+
+def test_2d_1():
+    print ('>>> test_2d_1')
+
+    knots_1 = [0., 0., 0., 1., 1., 1.]
+    knots_2 = [0., 0., 0., 0.5, 1., 1., 1.]
+    p_1 = 2
+    p_2 = 2
+    V1 = SplineSpace(p_1, knots=knots_1)
+    V2 = SplineSpace(p_2, knots=knots_2)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False])
+    V = TensorFemSpace(domain_decomposition, V1, V2)
+    print (V)
+    F = FemField(V)
+
+def test_2d_2():
+    print ('>>> test_2d_2')
+
+    p_1 = 2
+    p_2 = 2
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+    V1 = SplineSpace(p_1, grid=grid_1)
+    V2 = SplineSpace(p_2, grid=grid_2)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False])
+    V = TensorFemSpace(domain_decomposition, V1, V2)
+    print (V)
+    F = FemField(V)
+
+def test_2d_3():
+    print ('>>> test_2d_3')
+
+    p = 2
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+
+    # ... first component
+    V1 = SplineSpace(p-1, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False])
+    Vx = TensorFemSpace(domain_decomposition, V1, V2)
+    # ...
+
+    # ... second component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p-1, grid=grid_2)
+
+
+    Vy = TensorFemSpace(domain_decomposition, V1, V2)
+    # ...
+
+    V = VectorFemSpace(Vx, Vy)
+    print (V)
+
+def test_3d_1():
+    print ('>>> test_3d_1')
+
+    knots_1 = [0., 0., 0., 1., 1., 1.]
+    knots_2 = [0., 0., 0., 0.5, 1., 1., 1.]
+    knots_3 = [0., 0., 0.5, 1., 1.]
+    p_1 = 2
+    p_2 = 2
+    p_3 = 1
+    V1 = SplineSpace(p_1, knots=knots_1)
+    V2 = SplineSpace(p_2, knots=knots_2)
+    V3 = SplineSpace(p_3, knots=knots_3)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells, V3.ncells], [False, False, False])
+    V = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    print (V)
+    F = FemField(V)
+
+def test_3d_2():
+    print ('>>> test_3d_2')
+
+    p_1 = 2
+    p_2 = 2
+    p_3 = 1
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+    grid_3 = linspace(0., 1., 7)
+    V1 = SplineSpace(p_1, grid=grid_1)
+    V2 = SplineSpace(p_2, grid=grid_2)
+    V3 = SplineSpace(p_3, grid=grid_3)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells, V3.ncells], [False, False, False])
+    V = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    print (V)
+    F = FemField(V)
+
+def test_3d_3():
+    print ('>>> test_3d_3')
+
+    p = 2
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+    grid_3 = linspace(0., 1., 7)
+
+    # ... first component
+    V1 = SplineSpace(p-1, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+    V3 = SplineSpace(p, grid=grid_3)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells, V3.ncells], [False, False, False])
+    Vx = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    # ... second component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p-1, grid=grid_2)
+    V3 = SplineSpace(p, grid=grid_3)
+
+    Vy = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    # ... third component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+    V3 = SplineSpace(p-1, grid=grid_3)
+
+    Vz = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    V = VectorFemSpace(Vx, Vy, Vz)
+    print (V)
+
+
+###############################################
+if __name__ == '__main__':
+
+    test_1d_1()
+    test_1d_2()
+    test_1d_3()
+
+    test_2d_1()
+    test_2d_2()
+    test_2d_3()
+
+    test_3d_1()
+    test_3d_2()
+    test_3d_3()

feectools/fem/tests/test_splines_par.py

@@ -0,0 +1,46 @@
+# -*- coding: UTF-8 -*-
+
+import pytest
+
+from feectools.fem.basic   import FemField
+from feectools.fem.splines import SplineSpace
+from feectools.fem.tensor  import TensorFemSpace
+from feectools.fem.vector  import VectorFemSpace
+from feectools.ddm.cart    import DomainDecomposition
+from feectools.ddm.mpi import mpi as MPI
+
+from numpy  import linspace
+
+def test_2d_1():
+
+    p_1 = 2
+    p_2 = 2
+    grid_1 = linspace(0., 1., 10)
+    grid_2 = linspace(0., 1., 15)
+    comm = MPI.COMM_WORLD
+    rank = comm.Get_rank()
+
+    V1 = SplineSpace(p_1, grid=grid_1)
+    V2 = SplineSpace(p_2, grid=grid_2)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False], comm=comm)
+    V = TensorFemSpace(domain_decomposition, V1, V2)
+
+    if rank == 0:
+        print(V.coeff_space.cart.nprocs)
+    for i in range(comm.Get_size()):
+        if rank == i:
+            print('rank ', rank)
+            print('TensorFemSpace ', V)
+            print('VectorSpace ')
+            print('> npts ::', V.coeff_space.npts)
+            print('> starts ::', V.coeff_space.starts)
+            print('> ends ::', V.coeff_space.ends)
+            print('', flush=True)
+        comm.Barrier()
+
+    F = FemField(V)
+
+###############################################
+if __name__ == '__main__':
+    test_2d_2()

feectools/fem/tests/test_vector_spaces.py

@@ -0,0 +1,150 @@
+# -*- coding: UTF-8 -*-
+
+import pytest
+from numpy import linspace
+
+from feectools.fem.basic   import FemField
+from feectools.fem.splines import SplineSpace
+from feectools.fem.tensor  import TensorFemSpace
+from feectools.fem.vector  import VectorFemSpace
+from feectools.ddm.cart    import DomainDecomposition
+from feectools.linalg.block import BlockVector, BlockVectorSpace
+
+
+def test_vector_space_2d():
+    p = 2
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+
+    # ... first component
+    V1 = SplineSpace(p-1, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells], [False, False])
+    Vx = TensorFemSpace(domain_decomposition, V1, V2)
+    # ...
+
+    # ... second component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p-1, grid=grid_2)
+
+    Vy = TensorFemSpace(domain_decomposition, V1, V2)
+    # ...
+
+    V = VectorFemSpace(Vx, Vy)
+    F = FemField(V)
+
+    # Check properties of V from abstract interface
+    assert V.ldim == 2
+    assert V.periodic == (False, False)
+    assert V.mapping is None
+    assert isinstance(V.coeff_space, BlockVectorSpace)
+    assert not V.is_multipatch
+    assert V.is_vector_valued
+    assert V.symbolic_space is None
+    assert V.patch_spaces == (V,)
+    assert V.component_spaces == (Vx, Vy)
+    with pytest.raises(NotImplementedError):
+        getattr(V, 'axis_spaces')
+    assert V.is_multipatch == False
+    assert V.is_vector_valued == True
+
+    # Check other properties of V
+    assert V.nbasis == Vx.nbasis + Vy.nbasis
+    assert V.degree == [Vx.degree, Vy.degree]
+    assert V.multiplicity == [Vx.multiplicity, Vy.multiplicity]
+    assert V.pads == [Vx.pads, Vy.pads]
+    assert V.ncells == Vx.ncells == Vy.ncells
+    assert V.spaces == (Vx, Vy)
+
+    # Check properties of F
+    assert F.space == V
+    assert isinstance(F.coeffs, BlockVector)
+    assert len(F.fields) == 2
+    assert isinstance(F.fields[0], FemField)
+    assert isinstance(F.fields[1], FemField)
+    assert F.fields[0].space == Vx
+    assert F.fields[1].space == Vy
+    assert F.patch_fields == (F,)
+    assert F.component_fields == F.fields
+
+
+def test_vector_space_3d():
+    p = 2
+    grid_1 = linspace(0., 1., 3)
+    grid_2 = linspace(0., 1., 5)
+    grid_3 = linspace(0., 1., 7)
+
+    # ... first component
+    V1 = SplineSpace(p-1, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+    V3 = SplineSpace(p, grid=grid_3)
+
+    domain_decomposition = DomainDecomposition([V1.ncells, V2.ncells, V3.ncells], [False, False, False])
+
+    Vx = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    # ... second component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p-1, grid=grid_2)
+    V3 = SplineSpace(p, grid=grid_3)
+
+    Vy = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    # ... third component
+    V1 = SplineSpace(p, grid=grid_1)
+    V2 = SplineSpace(p, grid=grid_2)
+    V3 = SplineSpace(p-1, grid=grid_3)
+
+    Vz = TensorFemSpace(domain_decomposition, V1, V2, V3)
+    # ...
+
+    V = VectorFemSpace(Vx, Vy, Vz)
+    F = FemField(V)
+
+    # Check properties of V from abstract interface
+    assert V.ldim == 3
+    assert V.periodic == (False, False, False)
+    assert V.mapping is None
+    assert isinstance(V.coeff_space, BlockVectorSpace)
+    assert not V.is_multipatch
+    assert V.is_vector_valued
+    assert V.symbolic_space is None
+    assert V.patch_spaces == (V,)
+    assert V.component_spaces == (Vx, Vy, Vz)
+    with pytest.raises(NotImplementedError):
+        getattr(V, 'axis_spaces')
+    assert V.is_multipatch == False
+    assert V.is_vector_valued == True
+
+    # Check other properties of V
+    assert V.nbasis == Vx.nbasis + Vy.nbasis + Vz.nbasis
+    assert V.degree == [Vx.degree, Vy.degree, Vz.degree]
+    assert V.multiplicity == [Vx.multiplicity, Vy.multiplicity, Vz.multiplicity]
+    assert V.pads == [Vx.pads, Vy.pads, Vz.pads]
+    assert V.ncells == Vx.ncells == Vy.ncells == Vz.ncells
+    assert V.spaces == (Vx, Vy, Vz)
+
+    # Check properties of F
+    assert F.space == V
+    assert isinstance(F.coeffs, BlockVector)
+    assert len(F.fields) == 3
+    assert isinstance(F.fields[0], FemField)
+    assert isinstance(F.fields[1], FemField)
+    assert isinstance(F.fields[2], FemField)
+    assert F.fields[0].space == Vx
+    assert F.fields[1].space == Vy
+    assert F.fields[2].space == Vz
+    assert F.patch_fields == (F,)
+    assert F.component_fields == F.fields
+
+###############################################
+if __name__ == '__main__':
+
+    print('>>> test_vector_space_2d')
+    test_vector_space_2d()
+
+    print ('>>> test_vector_space_3d')
+    test_vector_space_3d()

feectools/fem/tests/utilities.py

@@ -0,0 +1,47 @@
+# coding: utf-8
+# Copyright 2018 Yaman Güçlü
+
+import numpy as np
+
+#===============================================================================
+def horner( x, *poly_coeffs ):
+    """ Use Horner's Scheme to evaluate a polynomial
+        of coefficients *poly_coeffs at location x.
+    """
+    p = 0
+    for c in poly_coeffs[::-1]:
+        p = p*x + c
+    return p
+
+#===============================================================================
+def random_grid( domain, ncells, random_fraction ):
+    """ Create random grid over 1D domain with given number of cells.
+    """
+    # Create uniform grid on [0,1]
+    x = np.linspace( 0.0, 1.0, ncells+1 )
+
+    # Apply random displacement to all points, then sort grid
+    x += (np.random.random_sample( ncells+1 )-0.5) * (random_fraction/ncells)
+    x.sort()
+
+    # Apply linear transformation y=m*x+q to match domain limits
+    xa, xb = x[0], x[-1]
+    ya, yb = domain
+    m = (   yb-ya   )/(xb-xa)
+    q = (xb*ya-xa*yb)/(xb-xa)
+    y = m*x + q
+
+    # Avoid possible round-off
+    y[0], y[-1] = domain
+
+    return y
+
+#===============================================================================
+def falling_factorial( x, n ):
+  """ Calculate falling factorial of x.
+      [https://en.wikipedia.org/wiki/Falling_and_rising_factorials]
+  """
+  c = 1
+  for k in range(n):
+      c *= x-k
+  return c