more tests skipped if depenencies missing

d7527773 · Michael Kuron · a8636b7f · d7527773 · d7527773 · d7527773
Commit d7527773 authored 5 years ago by Michael Kuron
--- a/lbmpy_tests/full_scenarios/shear_wave/scenario_shear_wave.py
+++ b/lbmpy_tests/full_scenarios/shear_wave/scenario_shear_wave.py
@@ -7,6 +7,8 @@
 import numpy as np
 import sympy as sp
+import pytest
 from lbmpy.creationfunctions import update_with_default_parameters
 from lbmpy.relaxationrates import (
    relaxation_rate_from_lattice_viscosity, relaxation_rate_from_magic_number)
@@ -212,6 +214,7 @@ def create_full_parameter_study():
 def test_shear_wave():
+    pytest.importorskip('pycuda')
    params = {
        'l_0': 32,
        'u_0': 0.096,

--- a/lbmpy_tests/test_html_output.py
+++ b/lbmpy_tests/test_html_output.py
+import pytest
 from lbmpy.creationfunctions import create_lb_method
 from lbmpy.methods.creationfunctions import compare_moment_based_lb_methods
 from lbmpy.moments import (
@@ -6,6 +8,7 @@ from lbmpy.stencils import get_stencil
 def test_moment_comparison_table():
+    pytest.importorskip('ipy_table')
    new = create_lb_method(stencil='D3Q19', maxwellian_moments=True)
    old = create_lb_method(stencil='D3Q19', maxwellian_moments=False)
@@ -25,6 +28,7 @@ def test_moment_comparison_table():
 def test_moment_equality_table():
+    pytest.importorskip('ipy_table')
    d3q19 = get_stencil('D3Q19')
    table1 = moment_equality_table(d3q19, max_order=3)
    assert len(table1.array) == 5

--- a/lbmpy_tests/test_n_phase_boyer_noncoupled.ipynb
+++ b/lbmpy_tests/test_n_phase_boyer_noncoupled.ipynb
 {
 "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pytest\n",
+    "pytest.importorskip('pycuda')"
+   ]
+  },
  {
   "cell_type": "code",
   "execution_count": 1,
@@ -360,7 +370,7 @@
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
-   "version": "3.6.8"
+   "version": "3.6.9"
  }
 },
 "nbformat": 4,

 %% Cell type:code id: tags:
 ``` python
+import pytest
+pytest.importorskip('pycuda')
+```
+%% 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')
 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()
 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.44269023807928, \  117.81813928465394, \  95.73917047726678\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.30607624700132874 [83.97888710273061, 100.48794346625529, 175.5331694310141]
    1 0.2600655169990205 [83.73094685534376, 100.65854574856168, 175.6105073960945]
    2 0.2601136189987301 [83.49914818603683, 100.82173327601079, 175.67911853795226]
    3 0.25987518599868054 [83.31519592224448, 100.94468140501989, 175.74012267273554]
    4 0.2651959220020217 [83.14239972296966, 101.06100094405181, 175.79659933297853]
    5 0.25910847799968906 [82.984481834461, 101.16731750637399, 175.8482006591651]
    6 0.259863024999504 [82.84781128433397, 101.2570276449976, 175.89516107066834]
    7 0.2606479199966998 [82.7456965110742, 101.31687551766585, 175.93742797125986]
    8 0.25991897900166805 [82.67010885583116, 101.35099855297112, 175.97889259119805]
    9 0.2590353729974595 [75.9000280154447, 108.9652166787719, 175.1347553057833]
 %% 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