shear layer quickfix

examples/shear_layer/shear_layer.py

@@ -11,7 +11,7 @@ def compute(args):
     from hysop.symbolic.field import curl
     from hysop.tools.sympy_utils import greak
     from hysop.parameters.scalar_parameter import ScalarParameter
-    from hysop.constants import Backend, AutotunerFlags, Implementation, AdvectionCriteria
+    from hysop.constants import Backend, AdvectionCriteria, Implementation
     from hysop.tools.contexts import printoptions
 
     from hysop.operators import DirectionalAdvection, DirectionalDiffusion, \
@@ -19,8 +19,7 @@ def compute(args):
                                 MinMaxFieldStatistics
 
     from hysop.methods import StrangOrder, SpaceDiscretization, Remesh, \
-                              TimeIntegrator, ComputeGranularity,       \
-                              OpenClKernelConfig, OpenClKernelAutotunerConfig
+                              TimeIntegrator, ComputeGranularity
 
     from hysop.numerics.splitting.strang import StrangSplitting
     from hysop.numerics.odesolvers.runge_kutta import Euler, RK2, RK3, RK4
@@ -39,7 +38,10 @@ def compute(args):
     
     # Setup usual implementation specific variables
     impl = args.impl
-    extra_op_kwds = {}
+    extra_op_kwds = {'mpi_params': mpi_params}
+    method = { ComputeGranularity:  0,
+               SpaceDiscretization: 4,
+               TimeIntegrator:      RK2 }
     if (impl is Implementation.PYTHON):
         pass
     elif (impl is Implementation.OPENCL_CODEGEN):
@@ -53,7 +55,7 @@ def compute(args):
         
         # Configure OpenCL kernel generation and tuning (already done by HysopArgParser)
         from hysop.methods import OpenClKernelConfig
-        method = {OpenClKernelConfig: args.opencl_kernel_config}
+        method[OpenClKernelConfig] = args.opencl_kernel_config
         
         # Setup opencl specific extra operator keyword arguments
         extra_op_kwds['cl_env'] = cl_env
@@ -95,12 +97,13 @@ def compute(args):
             velocity_cfl = args.cfl,
             variables = {velo: npts, vorti: npts},
             method = {Remesh: Remesh.L4_2},
-            dt=dt)
+            dt=dt, **extra_op_kwds)
     #> Directional diffusion
     diffusion = DirectionalDiffusion(implementation=impl,
             name='diffusion',
             fields=vorti, coeffs=nu, 
-            variables={vorti: npts}, dt=dt)
+            variables={vorti: npts}, dt=dt,
+            **extra_op_kwds)
     #> Directional splitting operator graph
     splitting = StrangSplitting(splitting_dim=dim, 
                     order=StrangOrder.STRANG_SECOND_ORDER)
@@ -111,16 +114,18 @@ def compute(args):
     #> Poisson operator to recover the velocity from the vorticity
     poisson = PoissonRotational(name='poisson', velocity=velo, vorticity=vorti, 
                             variables={velo:npts, vorti: npts}, projection=None,
-                            implementation=impl)
+                            implementation=impl, **extra_op_kwds)
     #> We ask to dump the inputs and the outputs of this operator
     poisson.dump_outputs(fields=(vorti,), frequency=args.dump_freq)
     poisson.dump_outputs(fields=(velo,),  frequency=args.dump_freq)
     #> Operator to compute the infinite norm of the velocity
     min_max_U = MinMaxFieldStatistics(name='min_max_U', field=velo,
-            Finf=True, implementation=impl, variables={velo:npts})
+            Finf=True, implementation=impl, variables={velo:npts},
+            **extra_op_kwds)
     #> Operator to compute the infinite norm of the vorticity
     min_max_W = MinMaxFieldStatistics(name='min_max_W', field=vorti,
-            Finf=True, implementation=impl, variables={vorti:npts})
+            Finf=True, implementation=impl, variables={vorti:npts},
+            **extra_op_kwds)
     
     ### Adaptive timestep operator
     adapt_dt = AdaptiveTimeStep(dt)
@@ -132,9 +137,6 @@ def compute(args):
     # directional splitting subgraph and the standard operators.
     # The method dictionnary passed to this graph will be dispatched
     # accrossed all operators contained in the graph.
-    method = { ComputeGranularity:  0,
-               SpaceDiscretization: 4,
-               TimeIntegrator:      RK2 }
     problem = Problem(method=method)
     problem.insert(poisson, splitting, min_max_U, min_max_W, adapt_dt)
     problem.build()

hysop/backend/device/opencl/operator/poisson.py

@@ -27,7 +27,7 @@ class OpenClPoisson(PoissonOperatorBase, OpenClSymbolic):
             factors = tuple( primefac.primefac(int(Ni)) )
             invalid_factors = set(factors) - valid_factors
             if invalid_factors:
-                factorization = ' + '.join('{}^{}'.format(factor, factors.count(factor)) 
+                factorization = ' * '.join('{}^{}'.format(factor, factors.count(factor)) 
                                                                 for factor in set(factors))
                 candidates = ', '.join(str(vf) for vf in valid_factors)
                 msg ='\nInvalid transform shape {} for clFFT:'

hysop/backend/device/opencl/operator/poisson_rotational.py

@@ -26,7 +26,7 @@ class OpenClPoissonRotational(PoissonRotationalOperatorBase, OpenClSymbolic):
             factors = tuple( primefac.primefac(int(Ni)) )
             invalid_factors = set(factors) - valid_factors
             if invalid_factors:
-                factorization = ' + '.join('{}^{}'.format(factor, factors.count(factor)) 
+                factorization = ' * '.join('{}^{}'.format(factor, factors.count(factor)) 
                                                                 for factor in set(factors))
                 candidates = ', '.join(str(vf) for vf in valid_factors)
                 msg ='\nInvalid transform shape {} for clFFT:'