feectools 0.1.0__py3-none-any.whl

feectools/fem/tests/analytical_profiles_1d.py

@@ -0,0 +1,100 @@
+# coding: utf-8
+# Copyright 2018 Yaman Güçlü
+
+import math
+import numpy as np
+
+from feectools.fem.tests.analytical_profiles_base import AnalyticalProfile
+from feectools.fem.tests.utilities                import horner, falling_factorial
+
+__all__ = ('AnalyticalProfile_1d_cos', 'AnalyticalProfile1D_Poly')
+
+#===============================================================================
+class AnalyticalProfile1D_Cos( AnalyticalProfile ):
+
+    def __init__( self, n=1, c=0.0 ):
+        twopi     = 2.0*math.pi
+        self._k   = twopi * n
+        self._phi = twopi * c
+
+    @property
+    def ndims( self ):
+        return 1
+
+    @property
+    def domain( self ):
+        return (0.0, 1.0)
+
+    @property
+    def poly_order( self ):
+        return -1
+
+    def eval( self, x, diff=0 ):
+        return self._k**diff * np.cos( 0.5*math.pi*diff + self._k*x + self._phi )
+
+    def max_norm( self, diff=0 ):
+        return self._k**diff
+
+#===============================================================================
+class AnalyticalProfile1D_Sin( AnalyticalProfile ):
+
+    def __init__( self, n=1, c=0.0 ):
+        twopi     = 2.0*math.pi
+        self._k   = twopi * n
+        self._phi = twopi * c
+
+    @property
+    def ndims( self ):
+        return 1
+
+    @property
+    def domain( self ):
+        return (0.0, 1.0)
+
+    @property
+    def poly_order( self ):
+        return -1
+
+    def eval( self, x, diff=0 ):
+        return self._k**diff * np.sin( 0.5*math.pi*diff + self._k*x + self._phi )
+
+    def max_norm( self, diff=0 ):
+        return self._k**diff
+#===============================================================================
+class AnalyticalProfile1D_Poly( AnalyticalProfile ):
+
+    def __init__( self, deg ):
+
+        coeffs = np.random.random_sample( 1+deg )  # 0 <= c < 1
+        coeffs = 1.0 - coeffs                      # 0 < c <= 1
+
+        self._deg    = deg
+        self._coeffs = coeffs
+
+    @property
+    def ndims( self ):
+        return 1
+
+    @property
+    def domain( self ):
+        return (-1.0, 1.0)
+
+    @property
+    def poly_order( self ):
+        return self_deg
+
+    def eval( self, x, diff=0 ):
+        d = diff
+        coeffs = [c * falling_factorial( i+d, d ) \
+                  for i,c in enumerate( self._coeffs[d:] )]
+        return horner( x, *coeffs )
+
+    def max_norm( self, diff=0 ):
+        xmin, xmax = self.domain
+
+        if xmax < abs(xmin):
+            raise NotImplementedError( "General formula not implemented" )
+
+        # For xmax >= |xmin|:
+        # max(|f^(d)(x)|) = f^(d)(xmax)
+        return self.eval( xmax, diff )

feectools/fem/tests/analytical_profiles_base.py

@@ -0,0 +1,34 @@
+# coding: utf-8
+# Copyright 2018 Yaman Güçlü
+
+from abc import ABCMeta, abstractmethod
+
+__all__ = ('AnalyticalProfile',)
+
+#===============================================================================
+class AnalyticalProfile( metaclass=ABCMeta ):
+
+    @property
+    @abstractmethod
+    def ndims(self):
+        """ Number of dimensions. """
+
+    @property
+    @abstractmethod
+    def domain(self):
+        """ Domain limits in each dimension. """
+
+    @property
+    @abstractmethod
+    def poly_order(self):
+        """ If profile is polynomial, poly_order=degree;
+            otherwise poly_order=-1.
+        """
+
+    @abstractmethod
+    def eval(self, x, diff=0):
+        """ Evaluate profile (or its derivative) at position x. """
+
+    @abstractmethod
+    def max_norm(self, diff=0):
+        """ Compute max-norm of profile (or its derivative) over domain. """

feectools/fem/tests/splines_error_bounds.py

@@ -0,0 +1,155 @@
+# coding: utf-8
+# Copyright 2018 Yaman Güçlü
+#
+# This file is the Python translation of a Selalib Fortran module:
+# 'selalib/src/splines/tests/m_splines_error_bounds.F90'
+
+__all__ = ('spline_1d_error_bound', 'spline_1d_error_bound_on_deriv',
+           'spline_2d_error_bound', 'spline_2d_error_bounds_on_grad')
+
+#===============================================================================
+
+k = (     1 /          2.0,
+          1 /          8.0,
+          1 /         24.0,
+          5 /        384.0,
+          1 /        240.0,
+         61 /      46080.0,
+         17 /      40320.0,
+        277 /    2064384.0,
+         31 /     725760.0,
+      50521 / 3715891200.0 )
+
+def tihomirov_error_bound( h, deg, norm_f ):
+    """
+    Error bound in max norm for spline interpolation of periodic functions from:
+
+    V M Tihomirov 1969 Math. USSR Sb. 9 275
+    https://doi.org/10.1070/SM1969v009n02ABEH002052 (page 286, bottom)
+
+    Yu. S. Volkov and Yu. N. Subbotin
+    https://doi.org/10.1134/S0081543815020236 (equation 14)
+
+    Also applicable to first derivative by passing deg-1 instead of deg
+    Volkov & Subbotin 2015, eq. 15
+
+    Parameters
+    ----------
+    h : float
+        Cell width
+
+    deg : int
+        Degree of spline S
+
+    norm_f : float
+        Max of function f(x) (or its derivative) over domain
+
+    Result
+    ------
+    norm_e : float
+        Max of error $E(x):=f(x)-S(x)$ over domain
+
+    """
+    norm_e = k[deg] * h**deg * norm_f
+
+    return norm_e
+
+#===============================================================================
+def spline_1d_error_bound( profile_1d, dx, deg ):
+    """
+    Compute error bound for spline approximation of 1D analytical profile.
+
+    Parameters
+    ----------
+    profile_1d : 1D analytical profile
+        Must provide 'max_norm( n )' method to compute max norm of n-th
+        derivative of profile over domain.
+
+    dx : float
+        Grid spacing.
+
+    deg : int
+        Spline degree.
+
+    Result
+    ------
+    max_error : float
+        Error bound: max-norm of error over domain should be smaller than this.
+
+    """
+    max_norm  = profile_1d.max_norm( deg+1 )
+    max_error = tihomirov_error_bound( dx, deg, max_norm )
+    return max_error
+
+#===============================================================================
+def spline_1d_error_bound_on_deriv( profile_1d, dx, deg ):
+    """ Compute error bound on first derivative, for spline approximation of 1D
+        analytical profile. Signature is identical to 'spline_1d_error_bound'.
+    """
+    max_norm  = profile_1d.max_norm( deg+1 )
+    max_error = tihomirov_error_bound( dx, deg-1, max_norm )
+    return max_error
+
+#===============================================================================
+def spline_2d_error_bound( profile_2d, dx1, dx2, deg1, deg2 ):
+    """
+    Compute error bound for spline approximation of 2D analytical profile.
+
+    Parameters
+    ----------
+    profile_2d : 2D analytical profile
+        Must provide 'max_norm( n1,n2 )' method to compute max norm of its
+        mixed derivative of degree (n1,n2) over domain.
+
+    dx1 : float
+        Grid spacing along 1st dimension.
+
+    dx2 : float
+        Grid spacing along 2nd dimension.
+
+    deg1 : int
+        Spline degree along 1st dimension.
+
+    deg2 : int
+        Spline degree along 2nd dimension.
+
+    Result
+    ------
+    max_error : float
+        Error bound: max-norm of error over domain should be smaller than this.
+
+    """
+    # Max norm of highest partial derivatives in x1 and x2 of analytical profile
+    max_norm1 = profile_2d.max_norm( deg1+1, 0      )
+    max_norm2 = profile_2d.max_norm( 0     , deg2+1 )
+
+    # Error bound on function value
+    max_error = f_tihomirov_error_bound( dx1, deg1, max_norm1 ) \
+              + f_tihomirov_error_bound( dx2, deg2, max_norm2 )
+
+    # Empirical correction: for linear interpolation increase estimate by 5%
+    if (deg1 == 1 or deg2 == 1):
+        max_error = 1.05 * max_error
+
+    return max_error
+
+#===============================================================================
+def spline_2d_error_bounds_on_grad( profile_2d, dx1, dx2, deg1, deg2 ):
+    """
+    Compute error bound on gradient, for spline approximation of 2D
+    analytical profile. Signature is identical to 'spline_2d_error_bound'.
+
+    """
+    # Max norm of highest partial derivatives in x1 and x2 of analytical profile
+    max_norm1 = profile_2d.max_norm( deg1+1, 0      )
+    max_norm2 = profile_2d.max_norm( 0     , deg2+1 )
+
+    # Error bound on x1-derivative
+    max_error1 = f_tihomirov_error_bound( dx1, deg1-1, max_norm1 ) \
+               + f_tihomirov_error_bound( dx2, deg2  , max_norm2 )
+
+    # Error bound on x2-derivative
+    max_error2 = f_tihomirov_error_bound( dx1, deg1  , max_norm1 ) \
+               + f_tihomirov_error_bound( dx2, deg2-1, max_norm2 )
+
+    return (max_error1, max_error2)

feectools/fem/tests/test_spline_histopolation.py

@@ -0,0 +1,120 @@
+import pytest
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.integrate import quad
+
+from feectools.fem.basic   import FemField
+from feectools.fem.splines import SplineSpace
+#from feectools.fem.tensor  import TensorFemSpace
+
+from feectools.fem.tests.utilities              import horner, random_grid
+from feectools.fem.tests.splines_error_bounds   import spline_1d_error_bound
+from feectools.fem.tests.analytical_profiles_1d import AnalyticalProfile1D_Cos
+
+#==============================================================================
+def histopolate_polynomial(basis, ncells, degree):
+
+    domain   = (-1.0, 1.0)
+    periodic = False
+
+    # Polynomial to be approximated
+    poly_coeffs = np.random.random_sample( degree+1 ) # 0 <= c < 1
+    poly_coeffs = 1.0 - poly_coeffs                   # 0 < c <= 1
+    f = lambda x : horner( x, *poly_coeffs )
+
+    # Define spline space and field
+    grid = random_grid( domain, ncells, 0.5 )
+    Vh = SplineSpace( degree=degree, grid=grid, periodic=periodic, basis=basis )
+    fh = FemField( Vh )
+
+    # Compute histopolant
+    xg = Vh.ext_greville
+    Ig = np.array([quad(f, xg[i], xg[i+1])[0] for i in range(len(xg)-1)])
+    Vh.compute_histopolant(Ig, fh)
+
+    return domain, f, fh
+
+#==============================================================================
+@pytest.mark.parametrize('basis', ['B', 'M'])
+@pytest.mark.parametrize('ncells', [10, 20, 33])
+@pytest.mark.parametrize('degree', [2, 5, 7])
+def test_histopolation_exact(basis, ncells, degree, num_pts=100, tol=1e-11):
+
+    domain, f, fh = histopolate_polynomial(basis, ncells, degree)
+
+    # Compare to exact solution
+    x  = np.linspace(*domain, num=num_pts)
+    y  = f(x)
+    yh = np.array([fh(xi) for xi in x])
+
+    assert np.allclose(yh, y, rtol=tol, atol=tol)
+
+#==============================================================================
+@pytest.mark.parametrize('basis', ['B', 'M'])
+@pytest.mark.parametrize('ncells', [10, 20, 33])
+@pytest.mark.parametrize('degree', [2, 5, 7])
+@pytest.mark.parametrize('periodic', [True, False])
+def test_histopolation_cosine(basis, ncells, degree, periodic, num_pts=100):
+
+    # Function to be approximated
+    # TODO: write function and domain explicitly
+    f = AnalyticalProfile1D_Cos()
+
+    # Define spline space and field
+    grid, dx = np.linspace(*f.domain, num=ncells+1, retstep=True)
+    Vh = SplineSpace(degree=degree, grid=grid, periodic=periodic)
+    fh = FemField(Vh)
+
+    # Compute histopolant
+    xg = Vh.histopolation_grid
+    Ig = np.array([quad(f.eval, xl, xr)[0] for xl, xr in zip(xg[:-1], xg[1:])])
+    Vh.compute_histopolant(Ig, fh)
+
+    # Compare to exact solution
+    x  = np.linspace(*f.domain, num=num_pts)
+    y  = f.eval(x)
+    yh = np.array([fh(xi) for xi in x])
+
+    max_norm_err = np.max(abs(y - yh))
+    err_bound    = spline_1d_error_bound(f, dx, degree)
+
+    assert max_norm_err < err_bound
+
+#==============================================================================
+# Diagnostics
+#==============================================================================
+def compare_and_plot(domain, f, fh, num_pts=100):
+
+    x  = np.linspace(*domain, num=num_pts)
+    y  = f(x)
+    yh = np.array([fh(xi) for xi in x])
+
+    max_norm_err = np.max(abs(yh - y))
+    print("Maximum error on evaluation grid: {}".format(max_norm_err))
+
+    fig, ax = plt.subplots(1, 1)
+    ax.plot(x, y, label='f(x)')
+    ax.plot(x, yh, '.', label='f1_h(x)')
+    ax.grid(True)
+    ax.set_xlabel('x')
+    ax.set_ylabel('y')
+    fig.legend()
+    fig.show()
+
+#==============================================================================
+# Diagnostics
+#==============================================================================
+if __name__ == '__main__':
+
+    domain, f, fh = histopolate_polynomial(basis='B', ncells=10, degree=7)
+    compare_and_plot(domain, f, fh)
+
+    domain, f, fh = histopolate_polynomial(basis='M', ncells=10, degree=7)
+    compare_and_plot(domain, f, fh)
+
+    import __main__ as main
+    if hasattr( main, '__file__' ):
+        try:
+           __IPYTHON__
+        except NameError:
+            plt.show()

feectools/fem/tests/test_spline_interpolation.py

@@ -0,0 +1,182 @@
+# coding: utf-8
+# Copyright 2018 Yaman Güçlü
+
+from feectools.ddm.mpi import mpi as MPI
+    
+import numpy as np
+import pytest
+import time
+
+from feectools.core.bsplines import make_knots
+from feectools.fem.basic     import FemField
+from feectools.fem.splines   import SplineSpace
+from feectools.fem.tensor    import TensorFemSpace
+from feectools.ddm.cart      import DomainDecomposition
+
+from feectools.fem.tests.utilities              import horner, random_grid
+from feectools.fem.tests.splines_error_bounds   import spline_1d_error_bound
+from feectools.fem.tests.analytical_profiles_1d import (AnalyticalProfile1D_Cos, AnalyticalProfile1D_Poly)
+#===============================================================================
+@pytest.mark.serial
+@pytest.mark.parametrize( "ncells", [1,5,10,23] )
+@pytest.mark.parametrize( "degree", range(1,11) )
+
+def test_SplineInterpolation1D_exact( ncells, degree ):
+
+    domain   = [-1.0, 1.0]
+    periodic = False
+
+    poly_coeffs = np.random.random_sample( degree+1 ) # 0 <= c < 1
+    poly_coeffs = 1.0 - poly_coeffs                   # 0 < c <= 1
+    f = lambda x : horner( x, *poly_coeffs )
+
+    grid  = random_grid( domain, ncells, 0.5 )
+    space = SplineSpace( degree=degree, grid=grid, periodic=periodic )
+    field = FemField( space )
+
+    xg = space.greville
+    ug = f( xg )
+
+    space.compute_interpolant( ug, field )
+
+    xt  = np.linspace( *domain, num=100 )
+    err = np.array( [field( x ) - f( x ) for x in xt] )
+
+    max_norm_err = np.max( abs( err ) )
+    assert max_norm_err < 1.0e-13
+
+#===============================================================================
+def args_SplineInterpolation1D_cosine():
+    for ncells in [5,10,23]:
+        for periodic in [True, False]:
+            pmax = min(ncells,9) if periodic else 9
+            for degree in range(1,pmax+1):
+                yield (ncells, degree, periodic)
+
+@pytest.mark.serial
+@pytest.mark.parametrize( "ncells,degree,periodic",
+    args_SplineInterpolation1D_cosine() )
+
+def test_SplineInterpolation1D_cosine( ncells, degree, periodic ):
+
+    f = AnalyticalProfile1D_Cos()
+
+    grid, dx = np.linspace( *f.domain, num=ncells+1, retstep=True )
+    space = SplineSpace( degree=degree, grid=grid, periodic=periodic )
+    field = FemField( space )
+
+    xg = space.greville
+    ug = f.eval( xg )
+
+    space.compute_interpolant( ug, field )
+    xt  = np.linspace( *f.domain, num=100 )
+    err = np.array( [field( x ) - f.eval( x ) for x in xt] )
+
+    max_norm_err = np.max( abs( err ) )
+    err_bound    = spline_1d_error_bound( f, dx, degree )
+
+    assert max_norm_err < err_bound
+
+#===============================================================================
+@pytest.mark.parallel
+@pytest.mark.parametrize( "nc1", [7,10,23] )
+@pytest.mark.parametrize( "nc2", [7,10,23] )
+@pytest.mark.parametrize( "deg1", range(1,5) )
+@pytest.mark.parametrize( "deg2", range(1,5) )
+
+def test_SplineInterpolation2D_parallel_exact( nc1, nc2, deg1, deg2 ):
+
+    # Communicator, size, rank
+    mpi_comm = MPI.COMM_WORLD
+    mpi_size = mpi_comm.Get_size()
+    mpi_rank = mpi_comm.Get_rank()
+
+    domain1   = [-1.0, 0.8]
+    periodic1 = False
+
+    domain2   = [-0.9, 1.0]
+    periodic2 = False
+
+    # Random coefficients of 1D polynomial (identical on all processes!)
+    poly_coeffs = np.random.random_sample( min(deg1,deg2)+1 ) # 0 <= c < 1
+    poly_coeffs = 1.0 - poly_coeffs                           # 0 < c <= 1
+    mpi_comm.Bcast( poly_coeffs, root=0 )
+
+    # 2D exact solution: 1D polynomial of linear combination z=x1-x2/2
+    f = lambda x1,x2 : horner( x1-0.5*x2, *poly_coeffs )
+
+    # Random 1D grids (identical on all processes!)
+    grid1 = random_grid( domain1, nc1, 0.1 )
+    grid2 = random_grid( domain2, nc2, 0.1 )
+    mpi_comm.Bcast( grid1, root=0 )
+    mpi_comm.Bcast( grid2, root=0 )
+
+    # 1D spline spaces along x1 and x2
+    space1 = SplineSpace( degree=deg1, grid=grid1, periodic=periodic1 )
+    space2 = SplineSpace( degree=deg2, grid=grid2, periodic=periodic2 )
+
+    domain_decomposition = DomainDecomposition([nc1, nc2], [periodic1, periodic2], comm=mpi_comm)
+    # Tensor-product 2D spline space, distributed, and field
+    tensor_space = TensorFemSpace( domain_decomposition, space1, space2 )
+    tensor_field = FemField( tensor_space )
+
+    # Coordinates of Greville points (global)
+    x1g = space1.greville
+    x2g = space2.greville
+
+    # Interpolation data on Greville points (distributed)
+    V     = tensor_space.coeff_space
+    ug    = V.zeros()
+    s1,s2 = V.starts
+    e1,e2 = V.ends
+    n1,n2 = V.npts
+    for i1 in range( s1, e1+1 ):
+        for i2 in range( s2, e2+1 ):
+            ug[i1,i2] = f( x1g[i1], x2g[i2] )
+
+    ug.update_ghost_regions()
+
+    # Compute 2D spline interpolant
+    tensor_space.compute_interpolant( ug, tensor_field )
+
+    #------------
+    # DIAGNOSTICS
+    #------------
+
+    # Verify that solution is exact at Greville points
+    err = V.zeros()
+    for i1 in range( s1, e1+1 ):
+        for i2 in range( s2, e2+1 ):
+            err[i1,i2] = ug[i1,i2] - tensor_field( x1g[i1], x2g[i2] )
+    interp_error = abs( err[:,:] ).max()
+
+    # Compute L2 norm of error
+    integrand = lambda x1,x2: (f(x1,x2)-tensor_field(x1,x2))**2
+    l2_error  = np.sqrt( tensor_space.integral( integrand ) )
+
+    # Print some information to terminal
+    for i in range( mpi_size ):
+        if i == mpi_rank:
+            print( '--------------------------------------------------' )
+            print( ' RANK = {}'.format( mpi_rank ) )
+            print( '--------------------------------------------------' )
+            print( '> Degree        :: [{:2d},{:2d}]'.format( deg1, deg2 ) )
+            print( '> Ncells        :: [{:2d},{:2d}]'.format(  nc1,  nc2 ) )
+            print( '> Nbasis        :: [{:2d},{:2d}]'.format(   n1,   n2 ) )
+            print( '> Starts        :: [{:2d},{:2d}]'.format(   s1,   s2 ) )
+            print( '> Ends          :: [{:2d},{:2d}]'.format(   e1,   e2 ) )
+            print( '> Interp. error :: {:.2e}'.format( interp_error ) )
+            print( '> L2 error      :: {:.2e}'.format( l2_error ) )
+            print( '', flush=True )
+            time.sleep( 0.1 )
+        mpi_comm.Barrier()
+
+    # Verify that error is only caused by finite precision arithmetic
+    assert interp_error < 1.0e-13
+    assert     l2_error < 1.0e-13
+
+#===============================================================================
+# SCRIPT FUNCTIONALITY
+#===============================================================================
+if __name__ == '__main__':
+    test_SplineInterpolation2D_parallel_exact( 10, 16, 3, 5 )