Merge branch 'master' into fix_macroscopic_value_kernels

cb632b10 · Frederik Hennig · 84ce16ba · e7823f08 · cb632b10 · cb632b10
Commit cb632b10 authored 3 years ago by Frederik Hennig
--- a/lbmpy_tests/centeredcumulant/test_equilibrium.py
+++ b/lbmpy_tests/centeredcumulant/test_equilibrium.py
--- a/lbmpy_tests/centeredcumulant/test_flow_around_sphere.py
+++ b/lbmpy_tests/centeredcumulant/test_flow_around_sphere.py
--- a/lbmpy_tests/centeredcumulant/test_periodic_pipe_flow.ipynb
+++ b/lbmpy_tests/centeredcumulant/test_periodic_pipe_flow.ipynb
--- a/lbmpy_tests/full_scenarios/rod/scenario_rod.py
+++ b/lbmpy_tests/full_scenarios/rod/scenario_rod.py
--- a/lbmpy_tests/phasefield/test_entropic_model.ipynb
+++ b/lbmpy_tests/phasefield/test_entropic_model.ipynb
--- a/lbmpy_tests/phasefield/test_n_phase_boyer_noncoupled.ipynb
+++ b/lbmpy_tests/phasefield/test_n_phase_boyer_noncoupled.ipynb
@@ -73,7 +73,7 @@
   "metadata": {},
   "outputs": [],
   "source": [
-    "dh = create_data_handling(domain_size, periodicity=True, default_target='gpu')\n",
+    "dh = create_data_handling(domain_size, periodicity=True, default_target=ps.Target.GPU)\n",
    "c = dh.add_array('c', values_per_cell=n)\n",
    "c_tmp = dh.add_array_like('c_tmp', 'c')\n",
    "\n",
@@ -171,8 +171,11 @@
    "μ_sync = dh.synchronization_function(μ.name)\n",
    "c_sync = dh.synchronization_function(c.name)\n",
    "optimization = {'cpu_openmp': 4, 'cpu_vectorize_info': None}\n",
-    "μ_kernel = create_kernel(μ_assignments, target=dh.default_target, **optimization).compile()\n",
-    "c_kernel = create_kernel(c_assignments, target=dh.default_target, **optimization).compile()\n",
+    "\n",
+    "config = ps.CreateKernelConfig(cpu_openmp=4, target=dh.default_target)\n",
+    "\n",
+    "μ_kernel = create_kernel(μ_assignments, config=config).compile()\n",
+    "c_kernel = create_kernel(c_assignments, config=config).compile()\n",
    "\n",
    "def set_c(slice_obj, values):\n",
    "    for block in dh.iterate(slice_obj):\n",
@@ -367,7 +370,7 @@
 ],
 "metadata": {
  "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
@@ -381,7 +384,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.8.2"
+   "version": "3.9.7"
  }
 },
 "nbformat": 4,

 %% Cell type:code id: tags:

 ``` python
 import pytest
 pytest.importorskip('pycuda')
 ```

 %% Output

    <module 'pycuda' from '/home/markus/miniconda3/envs/pystencils/lib/python3.8/site-packages/pycuda/__init__.py'>

 %% Cell type:code id: tags:

 ``` python
 from lbmpy.session import *
 from lbmpy.phasefield.n_phase_boyer import *
 from lbmpy.phasefield.kerneleqs import *
 from lbmpy.phasefield.contact_angle_circle_fitting import *
 from scipy.ndimage.filters import gaussian_filter
 from pystencils.simp import sympy_cse_on_assignment_list
 one = sp.sympify(1)

 import pyximport
 pyximport.install(language_level=3)
 from lbmpy.phasefield.simplex_projection import simplex_projection_2d  # NOQA
 ```

 %% Cell type:markdown id: tags:

 # Simulation arbitrary surface tension case

 %% Cell type:code id: tags:

 ``` python
 n = 4
 dx, dt = 1, 1
 mobility = 2e-3
 domain_size = (150, 150)
 ε = one * 4
 penalty_factor = 0
 stabilization_factor = 10

 κ = (one,  one/2, one/3, one/4)
 sigma_factor = one / 15
 σ = sp.ImmutableDenseMatrix(n, n, lambda i,j: sigma_factor* (κ[i] + κ[j]) if i != j else 0 )
 #σ
 ```

 %% Cell type:code id: tags:

 ``` python
-dh = create_data_handling(domain_size, periodicity=True, default_target='gpu')
+dh = create_data_handling(domain_size, periodicity=True, default_target=ps.Target.GPU)
 c = dh.add_array('c', values_per_cell=n)
 c_tmp = dh.add_array_like('c_tmp', 'c')

 μ = dh.add_array('mu', values_per_cell=n)

 cvec = c.center_vector
 μvec = μ.center_vector
 ```

 %% Cell type:code id: tags:

 ``` python
 α, _ = diffusion_coefficients(σ)

 f = lambda c: c**2 * ( 1 - c ) **2
 a, b = compute_ab(f)

 capital_f = capital_f0(cvec, σ) + correction_g(cvec, σ) + stabilization_factor * stabilization_term(cvec, α)

 f_bulk = free_energy_bulk(capital_f, b, ε) + penalty_factor * (one - sum(cvec))
 f_if = free_energy_interfacial(cvec, σ, a, ε)
 f = f_bulk + f_if
 ```

 %% Cell type:code id: tags:

 ``` python
 #f_bulk
 ```

 %% Cell type:code id: tags:

 ``` python
 μ_assignments = mu_kernel(f, cvec, c, μ)
 μ_assignments = [Assignment(a.lhs, a.rhs.doit()) for a in μ_assignments]
 μ_assignments = sympy_cse_on_assignment_list(μ_assignments)
 ```

 %% Cell type:code id: tags:

 ``` python
 discretize = fd.Discretization2ndOrder(dx=dx, dt=dt)
 ```

 %% Cell type:code id: tags:

 ``` python
 def lapl(e):
    return sum(ps.fd.diff(e, d, d) for d in range(dh.dim))
 ```

 %% Cell type:code id: tags:

 ``` python
 rhs = α * μvec
 discretized_rhs = [discretize(fd.expand_diff_full( lapl(mobility * rhs_i) + fd.transient(cvec[i], idx=i), functions=μvec))
                   for i, rhs_i in enumerate(rhs)]
 c_assignments = [Assignment(lhs, rhs)
                 for lhs, rhs in zip(c_tmp.center_vector, discretized_rhs)]
 ```

 %% Cell type:code id: tags:

 ``` python
 #c_assignments
 ```

 %% Cell type:code id: tags:

 ``` python
 μ_sync = dh.synchronization_function(μ.name)
 c_sync = dh.synchronization_function(c.name)
 optimization = {'cpu_openmp': 4, 'cpu_vectorize_info': None}
-μ_kernel = create_kernel(μ_assignments, target=dh.default_target, **optimization).compile()
-c_kernel = create_kernel(c_assignments, target=dh.default_target, **optimization).compile()
+
+config = ps.CreateKernelConfig(cpu_openmp=4, target=dh.default_target)
+
+μ_kernel = create_kernel(μ_assignments, config=config).compile()
+c_kernel = create_kernel(c_assignments, config=config).compile()

 def set_c(slice_obj, values):
    for block in dh.iterate(slice_obj):
        arr = block[c.name]
        arr[..., : ] = values

 def smooth():
    for block in dh.iterate(ghost_layers=True):
        c_arr = block[c.name]
        for i in range(n):
            gaussian_filter(c_arr[..., i], sigma=2, output=c_arr[..., i])

 def time_loop(steps):
    dh.all_to_gpu()
    for t in range(steps):
        c_sync()
        dh.run_kernel(μ_kernel)
        μ_sync()
        dh.run_kernel(c_kernel)
        dh.swap(c.name, c_tmp.name)
        #simplex_projection_2d(dh.cpu_arrays[c.name])
    dh.all_to_cpu()
 ```

 %% Cell type:code id: tags:

 ``` python
 set_c(make_slice[:, :], [0, 0, 0, 0])
 set_c(make_slice[:, 0.5:], [1, 0, 0, 0])
 set_c(make_slice[:, :0.5], [0, 1, 0, 0])
 set_c(make_slice[0.3:0.7, 0.3:0.7], [0, 0, 1, 0])
 smooth()
 ```

 %% Cell type:code id: tags:

 ``` python
 #dh.load_all('n_phases_state_size200_stab10.npz')
 ```

 %% Cell type:code id: tags:

 ``` python
 plt.phase_plot(dh.gather_array(c.name))
 ```

 %% Output



 %% Cell type:code id: tags:

 ``` python
 neumann_angles_from_surface_tensions(lambda i, j: float(σ[i, j]))
 ```

 %% Output


    $\displaystyle \left[ 146.442690238079, \  117.818139284654, \  95.7391704772668\right]$
    [146.44269023807928, 117.81813928465394, 95.73917047726678]

 %% Cell type:code id: tags:

 ``` python
 import time
 for i in range(10):
    start = time.perf_counter()
    time_loop(1_000)
    end = time.perf_counter()

    try:
        print(i, end - start, liquid_lens_neumann_angles(dh.gather_array(c.name)))
    except Exception:
        print(i, end - start, "none found")
 ```

 %% Output

    0 0.336687609999899 [75.97322089603733, 106.74183196592085, 177.28494713804187]
    1 0.26290948200039566 [75.82906362273266, 106.85098913683895, 177.3199472404283]
    2 0.2779139079993911 [75.63430957957638, 107.00770302824824, 177.3579873921755]
    3 0.26703732999976637 [75.41332394977111, 107.18964653942447, 177.39702951080454]
    4 0.26817269299954205 [75.1826458194294, 107.38183806648352, 177.43551611408705]
    5 0.26151279999976396 [74.95847110720459, 107.5698167786542, 177.47171211414116]
    6 0.2587056009997468 [74.75276623427364, 107.74235960736014, 177.5048741583663]
    7 0.2577263920002224 [74.58423615358463, 107.88207793021803, 177.53368591619756]
    8 0.2616421119992083 [74.4468008687682, 107.99262930599151, 177.56056982524032]
    9 0.2715399830003662 [64.84732273461297, 118.54619924713631, 176.60647801825087]

 %% Cell type:code id: tags:

 ``` python
 plt.subplot(1,3,1)
 t = dh.gather_array(c.name, make_slice[25, :]).squeeze()
 plt.plot(t);

 plt.subplot(1,3,2)
 plt.phase_plot(dh.gather_array(c.name), linewidth=1)

 plt.subplot(1,3,3)
 plt.scalar_field(dh.gather_array(μ.name)[:, :, 2])
 plt.colorbar();
 ```

 %% Output



 %% Cell type:code id: tags:

 ``` python
 assert not np.isnan(dh.max(c.name))
 ```

 %% Cell type:code id: tags:

 ``` python
 t = dh.gather_array(c.name, make_slice[25, 55:90]).squeeze()
 plt.hlines(0.5, 0, 30)
 plt.plot(t);
 ```

 %% Output



--- a/lbmpy_tests/phasefield/test_n_phase_paper_boyer_lbm.ipynb
+++ b/lbmpy_tests/phasefield/test_n_phase_paper_boyer_lbm.ipynb
--- a/lbmpy_tests/phasefield/test_numerical_1D_3phase_model.ipynb
+++ b/lbmpy_tests/phasefield/test_numerical_1D_3phase_model.ipynb
--- a/lbmpy_tests/phasefield/test_phase_field_scenarios.py
+++ b/lbmpy_tests/phasefield/test_phase_field_scenarios.py
 import os
-import warnings
 from tempfile import TemporaryDirectory

-import numpy as np
-import sympy as sp
-
 from lbmpy.boundaries import NoSlip
-from lbmpy.phasefield.analytical import free_energy_functional_n_phases_penalty_term
 from lbmpy.phasefield.experiments2D import (
    create_two_drops_between_phases, write_phase_field_picture_sequence,
    write_phase_velocity_picture_sequence)
-from lbmpy.phasefield.phasefieldstep import PhaseFieldStep
 from lbmpy.phasefield.scenarios import *
 from pystencils import make_slice

@@ -55,11 +49,11 @@ def test_setup():

    scenarios = [
        create_three_phase_model(domain_size=domain_size, include_rho=True),
-        #create_three_phase_model(domain_size=domain_size, include_rho=False),
+        # create_three_phase_model(domain_size=domain_size, include_rho=False),
        create_n_phase_model_penalty_term(domain_size=domain_size, num_phases=4),
    ]
    for i, sc in enumerate(scenarios):
-        print("Testing scenario", i)
+        print(f"Testing scenario {i}")
        sc.set_concentration(make_slice[:, :0.5], [1, 0, 0])
        sc.set_concentration(make_slice[:, 0.5:], [0, 1, 0])
        sc.set_concentration(make_slice[0.4:0.6, 0.4:0.6], [0, 0, 1])

--- a/lbmpy_tests/phasefield/test_phasefield.py
+++ b/lbmpy_tests/phasefield/test_phasefield.py
@@ -14,6 +14,7 @@ from lbmpy.phasefield.experiments2D import liquid_lens_setup
 from lbmpy.phasefield.contact_angle_circle_fitting import liquid_lens_neumann_angles
 from lbmpy.phasefield.post_processing import analytic_neumann_angles

+
 def test_analytic_interface_solution():
    """Ensures that the tanh is an analytical solution for the prescribed free energy / chemical potential
    """

--- a/lbmpy_tests/phasefield/test_phasefieldstep_direct.ipynb
+++ b/lbmpy_tests/phasefield/test_phasefieldstep_direct.ipynb
--- a/lbmpy_tests/phasefield/test_phasefieldstep_direct_boyer.ipynb
+++ b/lbmpy_tests/phasefield/test_phasefieldstep_direct_boyer.ipynb
--- a/lbmpy_tests/phasefield_allen_cahn/test_analytical.py
+++ b/lbmpy_tests/phasefield_allen_cahn/test_analytical.py
@@ -6,7 +6,6 @@ from lbmpy.phasefield_allen_cahn.parameter_calculation import calculate_dimensio
 from lbmpy.phasefield_allen_cahn.analytical import analytic_rising_speed


-
 def test_analytical():
    parameters = calculate_dimensionless_rising_bubble(reference_time=18000,
                                                       density_heavy=1.0,
@@ -30,8 +29,9 @@ def test_analytical():
                                          viscosity_ratio=3)

    np.isclose(parameters["density_light"], 1/3, rtol=1e-05, atol=1e-08, equal_nan=False)
-    np.isclose(parameters["gravitational_acceleration"], -3.9506172839506174e-07, rtol=1e-05, atol=1e-08, equal_nan=False)
+    np.isclose(parameters["gravitational_acceleration"], -3.9506172839506174e-07,
+               rtol=1e-05, atol=1e-08, equal_nan=False)
    np.isclose(parameters["mobility"], 0.0012234169653524492, rtol=1e-05, atol=1e-08, equal_nan=False)

    rs = analytic_rising_speed(1-6, 20, 0.01)
-    np.isclose(rs, 16666.666666666668, rtol=1e-05, atol=1e-08, equal_nan=False)
\ No newline at end of file
+    np.isclose(rs, 16666.666666666668, rtol=1e-05, atol=1e-08, equal_nan=False)
--- a/lbmpy_tests/phasefield_allen_cahn/test_codegen_3d.py
+++ b/lbmpy_tests/phasefield_allen_cahn/test_codegen_3d.py
--- a/lbmpy_tests/phasefield_allen_cahn/test_contact_angle.py
+++ b/lbmpy_tests/phasefield_allen_cahn/test_contact_angle.py
 import math

 import pystencils as ps
-from pystencils.boundaries.boundaryconditions import Neumann
 from pystencils.boundaries.boundaryhandling import BoundaryHandling

+from lbmpy.enums import Stencil
 from lbmpy.phasefield_allen_cahn.contact_angle import ContactAngle
-from lbmpy.stencils import get_stencil
+from lbmpy.stencils import LBStencil

 import numpy as np


 def test_contact_angle():
-    stencil = get_stencil("D2Q9")
+    stencil = LBStencil(Stencil.D2Q9)
    contact_angle = 45
    phase_value = 0.5


--- a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_allen_cahn_2d.ipynb
+++ b/lbmpy_tests/phasefield_allen_cahn/test_phase_field_allen_cahn_2d.ipynb
--- a/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb
+++ b/lbmpy_tests/phasefield_allen_cahn/test_phase_field_derivatives.ipynb
--- a/lbmpy_tests/poiseuille.py
+++ b/lbmpy_tests/poiseuille.py
--- a/lbmpy_tests/test_boundary_handling.py
+++ b/lbmpy_tests/test_boundary_handling.py
--- a/lbmpy_tests/test_central_moment.py
+++ b/lbmpy_tests/test_central_moment.py