From 09c1cbc9457542ddf2705f4b1de86ed11c5a039f Mon Sep 17 00:00:00 2001 From: Andreas Kloeckner Date: Wed, 10 Jul 2024 20:00:02 -0500 Subject: [PATCH] Switch to ruff, fix issues --- .github/workflows/ci.yml | 13 ++-- .gitlab-ci.yml | 6 +- doc/conf.py | 3 + examples/advection/surface.py | 22 +++--- examples/advection/var-velocity.py | 12 ++-- examples/advection/weak.py | 8 +-- examples/euler/acoustic_pulse.py | 28 +++----- examples/euler/vortex.py | 19 ++--- examples/hello-grudge.py | 15 ++-- examples/maxwell/cavities.py | 12 ++-- examples/wave/var-propagation-speed.py | 15 ++-- examples/wave/wave-min-mpi.py | 18 ++--- examples/wave/wave-op-mpi.py | 34 ++++----- examples/wave/wave-op-var-velocity.py | 24 +++---- grudge/__init__.py | 5 +- grudge/array_context.py | 57 +++++++++------ grudge/discretization.py | 96 ++++++++++++++------------ grudge/dof_desc.py | 15 ++-- grudge/dt_utils.py | 33 +++++---- grudge/geometry/__init__.py | 17 ++--- grudge/geometry/metrics.py | 27 +++----- grudge/models/__init__.py | 2 +- grudge/models/advection.py | 18 +++-- grudge/models/em.py | 16 ++--- grudge/models/euler.py | 20 ++---- grudge/models/wave.py | 12 ++-- grudge/op.py | 83 +++++++++++----------- grudge/projection.py | 8 ++- grudge/reductions.py | 27 ++++---- grudge/shortcuts.py | 7 +- grudge/tools.py | 5 +- grudge/trace_pair.py | 46 ++++++------ pyproject.toml | 53 ++++++++++++++ setup.cfg | 22 ------ setup.py | 2 +- test/mesh_data.py | 8 ++- test/test_dt_utils.py | 16 +++-- test/test_euler_model.py | 25 +++---- test/test_grudge.py | 56 +++++++-------- test/test_metrics.py | 32 +++++---- test/test_modal_connections.py | 18 ++--- test/test_mpi_communication.py | 34 +++++---- test/test_op.py | 30 ++++---- test/test_reductions.py | 20 +++--- test/test_tools.py | 12 ++-- test/test_trace_pair.py | 13 ++-- 46 files changed, 568 insertions(+), 496 deletions(-) create mode 100644 pyproject.toml delete mode 100644 setup.cfg diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index d0fa02903..362da1c9e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -8,20 +8,15 @@ on: - cron: '17 3 * * 0' jobs: - flake8: - name: Flake8 + ruff: + name: Ruff runs-on: ubuntu-latest steps: - uses: actions/checkout@v4 - - - uses: actions/setup-python@v5 - with: - # matches compat target in setup.py - python-version: '3.8' - name: "Main Script" run: | - curl -L -O https://gitlab.tiker.net/inducer/ci-support/raw/main/prepare-and-run-flake8.sh - . ./prepare-and-run-flake8.sh "$(basename $GITHUB_REPOSITORY)" examples test + pipx install ruff + ruff check pylint: name: Pylint diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index 078b5777d..e46fce855 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -106,10 +106,10 @@ Documentation: Flake8: script: - - curl -L -O https://gitlab.tiker.net/inducer/ci-support/raw/main/prepare-and-run-flake8.sh - - . ./prepare-and-run-flake8.sh "$CI_PROJECT_NAME" examples test + - pipx install ruff + - ruff check tags: - - python3 + - docker-runner except: - tags diff --git a/doc/conf.py b/doc/conf.py index 4758cd713..d21bde2a9 100644 --- a/doc/conf.py +++ b/doc/conf.py @@ -1,5 +1,6 @@ from urllib.request import urlopen + _conf_url = \ "https://raw.githubusercontent.com/inducer/sphinxconfig/main/sphinxconfig.py" with urlopen(_conf_url) as _inf: @@ -40,5 +41,7 @@ def get_version(): # index-page demo uses pyopencl via plot_directive import os + + # switch to "port:cpu" once we're firmly migrated to pocl 4.0 os.environ["PYOPENCL_TEST"] = "port:0" diff --git a/examples/advection/surface.py b/examples/advection/surface.py index 9e3d8682d..0b9ddcdd7 100644 --- a/examples/advection/surface.py +++ b/examples/advection/surface.py @@ -25,24 +25,23 @@ THE SOFTWARE. """ +import logging import os import numpy as np + import pyopencl as cl import pyopencl.tools as cl_tools - -from grudge.array_context import PyOpenCLArrayContext - -from meshmode.dof_array import flatten from meshmode.discretization.connection import FACE_RESTR_INTERIOR - +from meshmode.dof_array import flatten from pytools.obj_array import make_obj_array import grudge.dof_desc as dof_desc -import grudge.op as op import grudge.geometry as geo +import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext + -import logging logger = logging.getLogger(__name__) @@ -129,7 +128,7 @@ def main(ctx_factory, dim=2, order=4, use_quad=False, visualize=False): # {{{ discretization if dim == 2: - from meshmode.mesh.generation import make_curve_mesh, ellipse + from meshmode.mesh.generation import ellipse, make_curve_mesh mesh = make_curve_mesh( lambda t: radius * ellipse(1.0, t), np.linspace(0.0, 1.0, resolution + 1), @@ -147,9 +146,10 @@ def main(ctx_factory, dim=2, order=4, use_quad=False, visualize=False): else: qtag = None - from meshmode.discretization.poly_element import \ - default_simplex_group_factory, \ - QuadratureSimplexGroupFactory + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) discr_tag_to_group_factory[dof_desc.DISCR_TAG_BASE] = \ default_simplex_group_factory(base_dim=dim-1, order=order) diff --git a/examples/advection/var-velocity.py b/examples/advection/var-velocity.py index cd9f1c867..6e8b45d98 100644 --- a/examples/advection/var-velocity.py +++ b/examples/advection/var-velocity.py @@ -23,23 +23,22 @@ THE SOFTWARE. """ +import logging import os + import numpy as np import pyopencl as cl import pyopencl.tools as cl_tools - -from grudge.array_context import PyOpenCLArrayContext - from meshmode.dof_array import flatten from meshmode.mesh import BTAG_ALL - from pytools.obj_array import flat_obj_array import grudge.dof_desc as dof_desc import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext + -import logging logger = logging.getLogger(__name__) @@ -131,8 +130,7 @@ def main(ctx_factory, dim=2, order=4, use_quad=False, visualize=False, npoints_per_axis=(npoints,)*dim, order=order) - from meshmode.discretization.poly_element import \ - QuadratureSimplexGroupFactory + from meshmode.discretization.poly_element import QuadratureSimplexGroupFactory if use_quad: discr_tag_to_group_factory = { diff --git a/examples/advection/weak.py b/examples/advection/weak.py index 3470fdd60..e831c4a67 100644 --- a/examples/advection/weak.py +++ b/examples/advection/weak.py @@ -23,22 +23,22 @@ THE SOFTWARE. """ +import logging import os + import numpy as np import numpy.linalg as la import pyopencl as cl import pyopencl.tools as cl_tools - -from grudge.array_context import PyOpenCLArrayContext - from meshmode.dof_array import flatten from meshmode.mesh import BTAG_ALL import grudge.dof_desc as dof_desc import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext + -import logging logger = logging.getLogger(__name__) diff --git a/examples/euler/acoustic_pulse.py b/examples/euler/acoustic_pulse.py index 779062910..e126abe76 100644 --- a/examples/euler/acoustic_pulse.py +++ b/examples/euler/acoustic_pulse.py @@ -23,29 +23,21 @@ """ +import logging + import numpy as np import pyopencl as cl import pyopencl.tools as cl_tools - -from grudge.array_context import ( - PyOpenCLArrayContext, - PytatoPyOpenCLArrayContext -) -from grudge.models.euler import ( - ConservedEulerField, - EulerOperator, - InviscidWallBC -) -from grudge.shortcuts import rk4_step - from meshmode.mesh import BTAG_ALL - from pytools.obj_array import make_obj_array import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext, PytatoPyOpenCLArrayContext +from grudge.models.euler import ConservedEulerField, EulerOperator, InviscidWallBC +from grudge.shortcuts import rk4_step + -import logging logger = logging.getLogger(__name__) @@ -129,11 +121,13 @@ def run_acoustic_pulse(actx, b=(box_ur,)*dim, nelements_per_axis=(resolution,)*dim) + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) + from grudge import DiscretizationCollection from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD - from meshmode.discretization.poly_element import \ - (default_simplex_group_factory, - QuadratureSimplexGroupFactory) exp_name = f"fld-acoustic-pulse-N{order}-K{resolution}" if overintegration: diff --git a/examples/euler/vortex.py b/examples/euler/vortex.py index 9f00743e5..07c23f31b 100644 --- a/examples/euler/vortex.py +++ b/examples/euler/vortex.py @@ -23,19 +23,17 @@ """ +import logging + import pyopencl as cl import pyopencl.tools as cl_tools -from grudge.array_context import PytatoPyOpenCLArrayContext, PyOpenCLArrayContext -from grudge.models.euler import ( - vortex_initial_condition, - EulerOperator -) +import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext, PytatoPyOpenCLArrayContext +from grudge.models.euler import EulerOperator, vortex_initial_condition from grudge.shortcuts import rk4_step -import grudge.op as op -import logging logger = logging.getLogger(__name__) @@ -71,10 +69,13 @@ def run_vortex(actx, order=3, resolution=8, final_time=5, nelements_per_axis=(2*resolution, resolution), periodic=(True, True)) + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) + from grudge import DiscretizationCollection from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD - from meshmode.discretization.poly_element import \ - default_simplex_group_factory, QuadratureSimplexGroupFactory exp_name = f"fld-vortex-N{order}-K{resolution}-{flux_type}" diff --git a/examples/hello-grudge.py b/examples/hello-grudge.py index cbf4b98cf..5d6c08833 100644 --- a/examples/hello-grudge.py +++ b/examples/hello-grudge.py @@ -9,14 +9,15 @@ # BEGINEXAMPLE import numpy as np + import pyopencl as cl -from grudge.discretization import make_discretization_collection -import grudge.op as op -import grudge.geometry as geo -from grudge.dof_desc import as_dofdesc -from meshmode.mesh.generation import generate_box_mesh from meshmode.array_context import PyOpenCLArrayContext -from grudge.dof_desc import BoundaryDomainTag, FACE_RESTR_INTERIOR +from meshmode.mesh.generation import generate_box_mesh + +import grudge.geometry as geo +import grudge.op as op +from grudge.discretization import make_discretization_collection +from grudge.dof_desc import FACE_RESTR_INTERIOR, BoundaryDomainTag, as_dofdesc ctx = cl.create_some_context() @@ -114,6 +115,8 @@ def u_exact(x, t): uh - u_exact(x_vol, t_final), p=2) <= 0.1 import matplotlib.pyplot as plt + + plt.plot(actx.to_numpy(actx.np.ravel(x_vol[0][0])), actx.to_numpy(actx.np.ravel(uh[0])), label="Numerical") plt.plot(actx.to_numpy(actx.np.ravel(x_vol[0][0])), diff --git a/examples/maxwell/cavities.py b/examples/maxwell/cavities.py index 3d581c18a..0376a0a00 100644 --- a/examples/maxwell/cavities.py +++ b/examples/maxwell/cavities.py @@ -24,20 +24,20 @@ """ +import logging + import numpy as np + import pyopencl as cl import pyopencl.tools as cl_tools -from grudge.array_context import PyOpenCLArrayContext - -from grudge.shortcuts import set_up_rk4 +import grudge.op as op from grudge import DiscretizationCollection - +from grudge.array_context import PyOpenCLArrayContext from grudge.models.em import get_rectangular_cavity_mode +from grudge.shortcuts import set_up_rk4 -import grudge.op as op -import logging logger = logging.getLogger(__name__) diff --git a/examples/wave/var-propagation-speed.py b/examples/wave/var-propagation-speed.py index dfcf9d6f1..0fa11616c 100644 --- a/examples/wave/var-propagation-speed.py +++ b/examples/wave/var-propagation-speed.py @@ -24,20 +24,20 @@ """ +import logging + import numpy as np + import pyopencl as cl import pyopencl.tools as cl_tools +from pytools.obj_array import flat_obj_array +import grudge.op as op +from grudge import DiscretizationCollection from grudge.array_context import PyOpenCLArrayContext - from grudge.shortcuts import set_up_rk4 -from grudge import DiscretizationCollection -from pytools.obj_array import flat_obj_array - -import grudge.op as op -import logging logger = logging.getLogger(__name__) @@ -78,9 +78,10 @@ def source_f(actx, dcoll, t=0): ones = dcoll.zeros(actx) + 1 c = actx.np.where(np.dot(x, x) < 0.15, 0.1 * ones, 0.2 * ones) - from grudge.models.wave import VariableCoefficientWeakWaveOperator from meshmode.mesh import BTAG_ALL, BTAG_NONE + from grudge.models.wave import VariableCoefficientWeakWaveOperator + wave_op = VariableCoefficientWeakWaveOperator( dcoll, actx.freeze(c), diff --git a/examples/wave/wave-min-mpi.py b/examples/wave/wave-min-mpi.py index 370a82ecf..c4e5c66a2 100644 --- a/examples/wave/wave-min-mpi.py +++ b/examples/wave/wave-min-mpi.py @@ -24,22 +24,21 @@ """ +import logging + import numpy as np +from mpi4py import MPI + import pyopencl as cl import pyopencl.tools as cl_tools +from pytools.obj_array import flat_obj_array +import grudge.op as op +from grudge import make_discretization_collection from grudge.array_context import MPIPyOpenCLArrayContext - from grudge.shortcuts import set_up_rk4 -from grudge import make_discretization_collection -from mpi4py import MPI - -from pytools.obj_array import flat_obj_array - -import grudge.op as op -import logging logger = logging.getLogger(__name__) @@ -101,9 +100,10 @@ def source_f(actx, dcoll, t=0): ) ) - from grudge.models.wave import WeakWaveOperator from meshmode.mesh import BTAG_ALL, BTAG_NONE + from grudge.models.wave import WeakWaveOperator + wave_op = WeakWaveOperator( dcoll, 0.1, diff --git a/examples/wave/wave-op-mpi.py b/examples/wave/wave-op-mpi.py index 6f2f1cdaf..367d0fff4 100644 --- a/examples/wave/wave-op-mpi.py +++ b/examples/wave/wave-op-mpi.py @@ -24,32 +24,27 @@ """ +import logging +from dataclasses import dataclass + import numpy as np import numpy.linalg as la # noqa + import pyopencl as cl import pyopencl.tools as cl_tools - -from arraycontext import ( - with_container_arithmetic, - dataclass_array_container -) - -from dataclasses import dataclass - -from pytools.obj_array import flat_obj_array, make_obj_array - +from arraycontext import dataclass_array_container, with_container_arithmetic from meshmode.dof_array import DOFArray from meshmode.mesh import BTAG_ALL, BTAG_NONE # noqa +from pytools.obj_array import flat_obj_array, make_obj_array -from grudge.dof_desc import as_dofdesc, DISCR_TAG_BASE, DISCR_TAG_QUAD -from grudge.trace_pair import TracePair +import grudge.geometry as geo +import grudge.op as op from grudge.discretization import make_discretization_collection -from grudge.shortcuts import make_visualizer, compiled_lsrk45_step +from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD, as_dofdesc +from grudge.shortcuts import compiled_lsrk45_step, make_visualizer +from grudge.trace_pair import TracePair -import grudge.op as op -import grudge.geometry as geo -import logging logger = logging.getLogger(__name__) from mpi4py import MPI @@ -232,9 +227,10 @@ def main(ctx_factory, dim=2, order=3, else: local_mesh = comm.scatter(None) - from meshmode.discretization.poly_element import \ - QuadratureSimplexGroupFactory, \ - default_simplex_group_factory + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) dcoll = make_discretization_collection( actx, local_mesh, discr_tag_to_group_factory={ diff --git a/examples/wave/wave-op-var-velocity.py b/examples/wave/wave-op-var-velocity.py index 932c48051..06456bcd4 100644 --- a/examples/wave/wave-op-var-velocity.py +++ b/examples/wave/wave-op-var-velocity.py @@ -24,25 +24,24 @@ """ +import logging + import numpy as np import numpy.linalg as la # noqa + import pyopencl as cl import pyopencl.tools as cl_tools - -from grudge.array_context import PyOpenCLArrayContext - -from pytools.obj_array import flat_obj_array - from meshmode.mesh import BTAG_ALL, BTAG_NONE # noqa +from pytools.obj_array import flat_obj_array +import grudge.geometry as geo +import grudge.op as op +from grudge.array_context import PyOpenCLArrayContext from grudge.discretization import DiscretizationCollection from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD, DOFDesc from grudge.shortcuts import make_visualizer, rk4_step -import grudge.op as op -import grudge.geometry as geo -import logging logger = logging.getLogger(__name__) @@ -98,7 +97,7 @@ def wave_operator(actx, dcoll, c, w): dcoll, flat_obj_array( -op.weak_local_div(dcoll, dd_quad, c_quad*v_quad), - -op.weak_local_grad(dcoll, dd_quad, c_quad*u_quad) \ + -op.weak_local_grad(dcoll, dd_quad, c_quad*u_quad) # pylint: disable=invalid-unary-operand-type ) + op.face_mass( dcoll, @@ -167,9 +166,10 @@ def main(ctx_factory, dim=2, order=3, visualize=False): logger.info("%d elements", mesh.nelements) - from meshmode.discretization.poly_element import \ - QuadratureSimplexGroupFactory, \ - default_simplex_group_factory + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) dcoll = DiscretizationCollection( actx, mesh, discr_tag_to_group_factory={ diff --git a/grudge/__init__.py b/grudge/__init__.py index fa4a2b3b7..b3189bb7a 100644 --- a/grudge/__init__.py +++ b/grudge/__init__.py @@ -21,7 +21,10 @@ """ from grudge.discretization import ( - DiscretizationCollection, make_discretization_collection) + DiscretizationCollection, + make_discretization_collection, +) + __all__ = [ "DiscretizationCollection", "make_discretization_collection" diff --git a/grudge/array_context.py b/grudge/array_context.py index 2cd265b94..8bd51c972 100644 --- a/grudge/array_context.py +++ b/grudge/array_context.py @@ -31,18 +31,28 @@ # {{{ imports -from typing import ( - TYPE_CHECKING, Mapping, Tuple, Any, Callable, Optional, Type, - FrozenSet) +import logging from dataclasses import dataclass +from typing import ( + TYPE_CHECKING, + Any, + Callable, + FrozenSet, + Mapping, + Optional, + Tuple, + Type, +) +from warnings import warn + +from meshmode.array_context import ( + PyOpenCLArrayContext as _PyOpenCLArrayContextBase, + PytatoPyOpenCLArrayContext as _PytatoPyOpenCLArrayContextBase, +) from pytools import to_identifier from pytools.tag import Tag -from meshmode.array_context import ( - PyOpenCLArrayContext as _PyOpenCLArrayContextBase, - PytatoPyOpenCLArrayContext as _PytatoPyOpenCLArrayContextBase) -from warnings import warn -import logging + logger = logging.getLogger(__name__) try: @@ -81,7 +91,7 @@ warn("Your loopy and meshmode branches are mismatched. " "Please make sure that you have the " "https://github.com/kaushikcfd/loopy/tree/pytato-array-context-transforms " # noqa - "branch of loopy.") + "branch of loopy.", stacklevel=1) _HAVE_FUSION_ACTX = False else: _HAVE_FUSION_ACTX = True @@ -90,21 +100,24 @@ _HAVE_FUSION_ACTX = False -from arraycontext.pytest import ( - _PytestPyOpenCLArrayContextFactoryWithClass, - _PytestPytatoPyOpenCLArrayContextFactory, - register_pytest_array_context_factory) from arraycontext import ArrayContext from arraycontext.container import ArrayContainer from arraycontext.impl.pytato.compile import LazilyPyOpenCLCompilingFunctionCaller +from arraycontext.pytest import ( + _PytestPyOpenCLArrayContextFactoryWithClass, + _PytestPytatoPyOpenCLArrayContextFactory, + register_pytest_array_context_factory, +) + if TYPE_CHECKING: import pytato as pt - from pytato.partition import PartId + from mpi4py import MPI from pytato import DistributedGraphPartition + from pytato.partition import PartId + import pyopencl import pyopencl.tools - from mpi4py import MPI class PyOpenCLArrayContext(_PyOpenCLArrayContextBase): @@ -120,7 +133,7 @@ def __init__(self, queue: "pyopencl.CommandQueue", if allocator is None: warn("No memory allocator specified, please pass one. " "(Preferably a pyopencl.tools.MemoryPool in order " - "to reduce device allocations)") + "to reduce device allocations)", stacklevel=2) super().__init__(queue, allocator, wait_event_queue_length, force_device_scalars) @@ -150,7 +163,7 @@ def __init__(self, queue, allocator=None, if allocator is None: warn("No memory allocator specified, please pass one. " "(Preferably a pyopencl.tools.MemoryPool in order " - "to reduce device allocations)") + "to reduce device allocations)", stacklevel=2) super().__init__(queue, allocator, compile_trace_callback=compile_trace_callback) @@ -353,8 +366,8 @@ def __call__(self, arg_id_to_arg) -> ArrayContainer: representation. """ - from arraycontext.impl.pytato.compile import _args_to_device_buffers from arraycontext.impl.pyopencl.taggable_cl_array import to_tagged_cl_array + from arraycontext.impl.pytato.compile import _args_to_device_buffers from arraycontext.impl.pytato.utils import get_cl_axes_from_pt_axes input_args_for_prg = _args_to_device_buffers( self.actx, self.input_id_to_name_in_program, arg_id_to_arg) @@ -395,7 +408,7 @@ def __init__( if allocator is None: warn("No memory allocator specified, please pass one. " "(Preferably a pyopencl.tools.MemoryPool in order " - "to reduce device allocations)") + "to reduce device allocations)", stacklevel=2) super().__init__(queue, allocator, compile_trace_callback=compile_trace_callback) @@ -526,7 +539,8 @@ def _get_single_grid_pytato_actx_class(distributed: bool) -> Type[ArrayContext]: "Please make sure you have the right branches for loopy " "(https://github.com/kaushikcfd/loopy/tree/pytato-array-context-transforms) " # noqa "and meshmode " - "(https://github.com/kaushikcfd/meshmode/tree/pytato-array-context-transforms).") # noqa + "(https://github.com/kaushikcfd/meshmode/tree/pytato-array-context-transforms).", + stacklevel=1) # noqa # lazy, non-distributed if not distributed: if _HAVE_SINGLE_GRID_WORK_BALANCING: @@ -557,7 +571,8 @@ def get_reasonable_array_context_class( "Please make sure you have the right branches for loopy " "(https://github.com/kaushikcfd/loopy/tree/pytato-array-context-transforms) " # noqa "and meshmode " - "(https://github.com/kaushikcfd/meshmode/tree/pytato-array-context-transforms).") # noqa + "(https://github.com/kaushikcfd/meshmode/tree/pytato-array-context-transforms).", + stacklevel=1) # noqa # lazy+fusion, non-distributed if _HAVE_FUSION_ACTX: diff --git a/grudge/discretization.py b/grudge/discretization.py index 8b67ecff6..61423a967 100644 --- a/grudge/discretization.py +++ b/grudge/discretization.py @@ -33,40 +33,42 @@ THE SOFTWARE. """ -from typing import Mapping, Optional, Union, TYPE_CHECKING, Any -from meshmode.discretization.poly_element import ( - InterpolatoryEdgeClusteredGroupFactory, ModalGroupFactory) +from typing import TYPE_CHECKING, Any, Mapping, Optional, Union +from warnings import warn +import numpy as np # noqa: F401 + +from arraycontext import ArrayContext +from meshmode.discretization import Discretization, ElementGroupFactory +from meshmode.discretization.connection import ( + FACE_RESTR_ALL, + FACE_RESTR_INTERIOR, + DiscretizationConnection, + make_face_restriction, +) +from meshmode.discretization.poly_element import ( + InterpolatoryEdgeClusteredGroupFactory, + ModalGroupFactory, +) +from meshmode.dof_array import DOFArray +from meshmode.mesh import BTAG_PARTITION, Mesh from pytools import memoize_method, single_valued from grudge.dof_desc import ( - VTAG_ALL, DD_VOLUME_ALL, DISCR_TAG_BASE, DISCR_TAG_MODAL, - VolumeDomainTag, BoundaryDomainTag, - DOFDesc, - VolumeTag, DomainTag, + VTAG_ALL, + BoundaryDomainTag, + ConvertibleToDOFDesc, DiscretizationTag, + DOFDesc, + DomainTag, + VolumeDomainTag, + VolumeTag, as_dofdesc, - ConvertibleToDOFDesc ) -import numpy as np # noqa: F401 - -from arraycontext import ArrayContext - -from meshmode.discretization import ElementGroupFactory, Discretization -from meshmode.discretization.connection import ( - FACE_RESTR_INTERIOR, - FACE_RESTR_ALL, - make_face_restriction, - DiscretizationConnection -) -from meshmode.mesh import Mesh, BTAG_PARTITION -from meshmode.dof_array import DOFArray - -from warnings import warn if TYPE_CHECKING: import mpi4py.MPI @@ -378,17 +380,19 @@ def _base_to_geoderiv_connection(self, dd: DOFDesc) -> DiscretizationConnection: if not self._has_affine_groups(dd.domain_tag): # no benefit to having another discretization that takes # advantage of affine-ness - from meshmode.discretization.connection import \ - IdentityDiscretizationConnection + from meshmode.discretization.connection import ( + IdentityDiscretizationConnection, + ) return IdentityDiscretizationConnection(base_discr) base_group_factory = self.group_factory_for_discretization_tag( dd.discretization_tag) def geo_group_factory(megrp): + from meshmode.discretization.poly_element import ( + PolynomialEquidistantSimplexElementGroup, + ) from modepy.shapes import Simplex - from meshmode.discretization.poly_element import \ - PolynomialEquidistantSimplexElementGroup if megrp.is_affine and issubclass(megrp._modepy_shape_cls, Simplex): return PolynomialEquidistantSimplexElementGroup( megrp, order=0) @@ -400,8 +404,9 @@ def geo_group_factory(megrp): self._setup_actx, base_discr.mesh, geo_group_factory) - from meshmode.discretization.connection.same_mesh import \ - make_same_mesh_connection + from meshmode.discretization.connection.same_mesh import ( + make_same_mesh_connection, + ) return make_same_mesh_connection( self._setup_actx, to_discr=geo_deriv_discr, @@ -456,8 +461,9 @@ def connection_from_dds( DISCR_TAG_BASE), from_dd.with_discr_tag(DISCR_TAG_BASE)) - from meshmode.discretization.connection import \ - make_face_to_all_faces_embedding + from meshmode.discretization.connection import ( + make_face_to_all_faces_embedding, + ) return make_face_to_all_faces_embedding( self._setup_actx, @@ -470,8 +476,9 @@ def connection_from_dds( and from_discr_tag is DISCR_TAG_BASE and to_discr_tag is not DISCR_TAG_BASE): - from meshmode.discretization.connection import \ - ChainedDiscretizationConnection + from meshmode.discretization.connection import ( + ChainedDiscretizationConnection, + ) intermediate_dd = to_dd.with_discr_tag(DISCR_TAG_BASE) return ChainedDiscretizationConnection( [ @@ -495,8 +502,9 @@ def connection_from_dds( and from_discr_tag is DISCR_TAG_BASE and to_discr_tag is not DISCR_TAG_BASE): - from meshmode.discretization.connection.same_mesh import \ - make_same_mesh_connection + from meshmode.discretization.connection.same_mesh import ( + make_same_mesh_connection, + ) return make_same_mesh_connection( self._setup_actx, @@ -529,8 +537,7 @@ def connection_from_dds( "volumes of different tags: requested " f"'{from_dd.domain_tag}' -> '{to_dd.domain_tag}'") - from meshmode.discretization.connection import \ - make_same_mesh_connection + from meshmode.discretization.connection import make_same_mesh_connection return make_same_mesh_connection( self._setup_actx, self._volume_discr_from_dd(to_dd), @@ -565,7 +572,7 @@ def _volume_discr_from_dd(self, dd: DOFDesc) -> Discretization: base_volume_discr = self._volume_discrs[dd.domain_tag.tag] except KeyError: raise ValueError("a volume discretization with volume tag " - f"'{dd.domain_tag.tag}' is not known") + f"'{dd.domain_tag.tag}' is not known") from None # Refuse to re-make the volume discretization if dd.discretization_tag is DISCR_TAG_BASE: @@ -598,8 +605,9 @@ def _modal_to_nodal_connection(self, to_dd: DOFDesc) -> DiscretizationConnection describing the dofs corresponding to the *to_discr* """ - from meshmode.discretization.connection import \ - ModalToNodalDiscretizationConnection + from meshmode.discretization.connection import ( + ModalToNodalDiscretizationConnection, + ) return ModalToNodalDiscretizationConnection( from_discr=self._modal_discr(to_dd.domain_tag), @@ -614,8 +622,9 @@ def _nodal_to_modal_connection( describing the dofs corresponding to the *from_discr* """ - from meshmode.discretization.connection import \ - NodalToModalDiscretizationConnection + from meshmode.discretization.connection import ( + NodalToModalDiscretizationConnection, + ) return NodalToModalDiscretizationConnection( from_discr=self.discr_from_dd(from_dd), @@ -666,8 +675,7 @@ def opposite_face_connection( to the exterior boundary restriction on a neighboring element. This does not take into account parallel partitions. """ - from meshmode.discretization.connection import \ - make_opposite_face_connection + from meshmode.discretization.connection import make_opposite_face_connection assert domain_tag.tag is FACE_RESTR_INTERIOR diff --git a/grudge/dof_desc.py b/grudge/dof_desc.py index 10c7e2e3f..16232a541 100644 --- a/grudge/dof_desc.py +++ b/grudge/dof_desc.py @@ -76,15 +76,18 @@ THE SOFTWARE. """ -from warnings import warn -from typing import Hashable, Union, Type, Optional, Any, Tuple from dataclasses import dataclass, replace +from typing import Any, Hashable, Optional, Tuple, Type, Union +from warnings import warn -from meshmode.discretization.connection import ( - FACE_RESTR_INTERIOR, FACE_RESTR_ALL) +from meshmode.discretization.connection import FACE_RESTR_ALL, FACE_RESTR_INTERIOR from meshmode.mesh import ( - BTAG_PARTITION, BTAG_ALL, BTAG_REALLY_ALL, BTAG_NONE, BoundaryTag) - + BTAG_ALL, + BTAG_NONE, + BTAG_PARTITION, + BTAG_REALLY_ALL, + BoundaryTag, +) from pytools import to_identifier diff --git a/grudge/dt_utils.py b/grudge/dt_utils.py index 54a9343e8..c956e412f 100644 --- a/grudge/dt_utils.py +++ b/grudge/dt_utils.py @@ -44,24 +44,29 @@ from typing import Optional, Sequence + import numpy as np from arraycontext import ArrayContext, Scalar, tag_axes from arraycontext.metadata import NameHint -from meshmode.transform_metadata import (FirstAxisIsElementsTag, - DiscretizationDOFAxisTag, - DiscretizationFaceAxisTag, - DiscretizationElementAxisTag) - -from grudge.dof_desc import ( - DD_VOLUME_ALL, DOFDesc, as_dofdesc, BoundaryDomainTag, FACE_RESTR_ALL) -from grudge.discretization import DiscretizationCollection - -import grudge.op as op - from meshmode.dof_array import DOFArray +from meshmode.transform_metadata import ( + DiscretizationDOFAxisTag, + DiscretizationElementAxisTag, + DiscretizationFaceAxisTag, + FirstAxisIsElementsTag, +) +from pytools import memoize_in, memoize_on_first_arg -from pytools import memoize_on_first_arg, memoize_in +import grudge.op as op +from grudge.discretization import DiscretizationCollection +from grudge.dof_desc import ( + DD_VOLUME_ALL, + FACE_RESTR_ALL, + BoundaryDomainTag, + DOFDesc, + as_dofdesc, +) def characteristic_lengthscales( @@ -177,7 +182,7 @@ def h_max_from_volume( Defaults to the base volume discretization if not provided. :returns: a scalar denoting the maximum characteristic length. """ - from grudge.reductions import nodal_max, elementwise_sum + from grudge.reductions import elementwise_sum, nodal_max if dd is None: dd = DD_VOLUME_ALL @@ -209,7 +214,7 @@ def h_min_from_volume( Defaults to the base volume discretization if not provided. :returns: a scalar denoting the minimum characteristic length. """ - from grudge.reductions import nodal_min, elementwise_sum + from grudge.reductions import elementwise_sum, nodal_min if dd is None: dd = DD_VOLUME_ALL diff --git a/grudge/geometry/__init__.py b/grudge/geometry/__init__.py index a8a2f4d07..ae0a393c3 100644 --- a/grudge/geometry/__init__.py +++ b/grudge/geometry/__init__.py @@ -24,26 +24,23 @@ from grudge.geometry.metrics import ( - forward_metric_nth_derivative, - forward_metric_derivative_mat, - inverse_metric_derivative_mat, - + area_element, first_fundamental_form, + forward_metric_derivative_mat, + forward_metric_nth_derivative, inverse_first_fundamental_form, - + inverse_metric_derivative_mat, inverse_surface_metric_derivative, inverse_surface_metric_derivative_mat, - pseudoscalar, - area_element, - mv_normal, normal, - + pseudoscalar, second_fundamental_form, shape_operator, - summed_curvature + summed_curvature, ) + __all__ = ( "forward_metric_nth_derivative", "forward_metric_derivative_mat", diff --git a/grudge/geometry/metrics.py b/grudge/geometry/metrics.py index 260f219b3..e1fbe8f47 100644 --- a/grudge/geometry/metrics.py +++ b/grudge/geometry/metrics.py @@ -59,30 +59,25 @@ from typing import Optional, Tuple, Union + import numpy as np -from arraycontext import ArrayContext, tag_axes +from arraycontext import ArrayContext, register_multivector_as_array_container, tag_axes from arraycontext.metadata import NameHint from meshmode.dof_array import DOFArray - -from grudge import DiscretizationCollection -import grudge.dof_desc as dof_desc - -from grudge.dof_desc import ( - DD_VOLUME_ALL, DOFDesc, DISCR_TAG_BASE +from meshmode.transform_metadata import ( + DiscretizationAmbientDimAxisTag, + DiscretizationTopologicalDimAxisTag, ) - -from meshmode.transform_metadata import (DiscretizationAmbientDimAxisTag, - DiscretizationTopologicalDimAxisTag) - - from pymbolic.geometric_algebra import MultiVector - -from pytools.obj_array import make_obj_array from pytools import memoize_in +from pytools.obj_array import make_obj_array + +import grudge.dof_desc as dof_desc +from grudge import DiscretizationCollection +from grudge.dof_desc import DD_VOLUME_ALL, DISCR_TAG_BASE, DOFDesc -from arraycontext import register_multivector_as_array_container register_multivector_as_array_container() @@ -429,7 +424,7 @@ def inverse_metric_derivative( for rst in range(dim)] # Yay Cramer's rule! - from functools import reduce, partial + from functools import partial, reduce from operator import xor as outerprod_op outerprod = partial(reduce, outerprod_op) diff --git a/grudge/models/__init__.py b/grudge/models/__init__.py index 8998492b5..b2385bc14 100644 --- a/grudge/models/__init__.py +++ b/grudge/models/__init__.py @@ -63,8 +63,8 @@ def estimate_rk4_timestep(self, actx, dcoll, **kwargs): max characteristic velocity of the operator. These are passed to :meth:`max_characteristic_velocity`. """ - from grudge.dt_utils import characteristic_lengthscales import grudge.op as op + from grudge.dt_utils import characteristic_lengthscales wavespeeds = self.max_characteristic_velocity(actx, **kwargs) local_timesteps = ( diff --git a/grudge/models/advection.py b/grudge/models/advection.py index a80b94823..999fc2c9d 100644 --- a/grudge/models/advection.py +++ b/grudge/models/advection.py @@ -26,11 +26,12 @@ """ -import numpy as np -import grudge.op as op import types -import grudge.geometry as geo +import numpy as np + +import grudge.geometry as geo +import grudge.op as op from grudge.models import HyperbolicOperator @@ -221,9 +222,10 @@ def flux(self, u_tpair): return advection_weak_flux(self.dcoll, self.flux_type, u_tpair, surf_v) def operator(self, t, u): - from grudge.dof_desc import DOFDesc, DD_VOLUME_ALL, DTAG_VOLUME_ALL - from meshmode.mesh import BTAG_ALL from meshmode.discretization.connection import FACE_RESTR_ALL + from meshmode.mesh import BTAG_ALL + + from grudge.dof_desc import DD_VOLUME_ALL, DTAG_VOLUME_ALL, DOFDesc face_dd = DOFDesc(FACE_RESTR_ALL, self.quad_tag) boundary_dd = DOFDesc(BTAG_ALL, self.quad_tag) @@ -280,9 +282,10 @@ def to_quad(arg): # {{{ closed surface advection def v_dot_n_tpair(actx, dcoll, velocity, trace_dd): + from meshmode.discretization.connection import FACE_RESTR_INTERIOR + from grudge.dof_desc import BoundaryDomainTag from grudge.trace_pair import TracePair - from meshmode.discretization.connection import FACE_RESTR_INTERIOR normal = geo.normal(actx, dcoll, trace_dd.with_discr_tag(None)) v_dot_n = velocity.dot(normal) @@ -335,9 +338,10 @@ def flux(self, u_tpair): surf_v) def operator(self, t, u): - from grudge.dof_desc import DOFDesc, DD_VOLUME_ALL, DTAG_VOLUME_ALL from meshmode.discretization.connection import FACE_RESTR_ALL + from grudge.dof_desc import DD_VOLUME_ALL, DTAG_VOLUME_ALL, DOFDesc + face_dd = DOFDesc(FACE_RESTR_ALL, self.quad_tag) quad_dd = DOFDesc(DTAG_VOLUME_ALL, self.quad_tag) diff --git a/grudge/models/em.py b/grudge/models/em.py index 05859a3d6..67884a54b 100644 --- a/grudge/models/em.py +++ b/grudge/models/em.py @@ -28,18 +28,16 @@ """ -from arraycontext import get_container_context_recursively - -from grudge.models import HyperbolicOperator +import numpy as np +from arraycontext import get_container_context_recursively from meshmode.mesh import BTAG_ALL, BTAG_NONE - -from pytools import memoize_method, levi_civita +from pytools import levi_civita, memoize_method from pytools.obj_array import flat_obj_array, make_obj_array -import grudge.op as op import grudge.geometry as geo -import numpy as np +import grudge.op as op +from grudge.models import HyperbolicOperator # {{{ helpers @@ -263,13 +261,13 @@ def flux(self, wtpair): 1/2*( -self.space_cross_h(normal, h.ext-h.int) # multiplication by epsilon undoes material divisor below - #-max_c*(epsilon*e.int - epsilon*e.ext) + # -max_c*(epsilon*e.int - epsilon*e.ext) ), # flux h 1/2*( self.space_cross_e(normal, e.ext-e.int) # multiplication by mu undoes material divisor below - #-max_c*(mu*h.int - mu*h.ext) + # -max_c*(mu*h.int - mu*h.ext) )) elif isinstance(self.flux_type, (int, float)): # see doc/maxima/maxwell.mac diff --git a/grudge/models/euler.py b/grudge/models/euler.py index 1b6eb569c..a288b486e 100644 --- a/grudge/models/euler.py +++ b/grudge/models/euler.py @@ -44,28 +44,22 @@ THE SOFTWARE. """ -import numpy as np - from abc import ABCMeta, abstractmethod - from dataclasses import dataclass -from arraycontext import ( - dataclass_array_container, - with_container_arithmetic -) +import numpy as np + +from arraycontext import dataclass_array_container, with_container_arithmetic from meshmode.dof_array import DOFArray +from pytools.obj_array import make_obj_array +import grudge.geometry as geo +import grudge.op as op from grudge.discretization import DiscretizationCollection -from grudge.dof_desc import DOFDesc, DISCR_TAG_BASE, as_dofdesc +from grudge.dof_desc import DISCR_TAG_BASE, DOFDesc, as_dofdesc from grudge.models import HyperbolicOperator from grudge.trace_pair import TracePair -from pytools.obj_array import make_obj_array - -import grudge.op as op -import grudge.geometry as geo - # {{{ Array containers for the Euler model diff --git a/grudge/models/wave.py b/grudge/models/wave.py index 4fc726870..a7e484c7c 100644 --- a/grudge/models/wave.py +++ b/grudge/models/wave.py @@ -28,15 +28,13 @@ import numpy as np -from grudge.dof_desc import DISCR_TAG_BASE, as_dofdesc -from grudge.models import HyperbolicOperator - from meshmode.mesh import BTAG_ALL, BTAG_NONE - from pytools.obj_array import flat_obj_array -import grudge.op as op import grudge.geometry as geo +import grudge.op as op +from grudge.dof_desc import DISCR_TAG_BASE, as_dofdesc +from grudge.models import HyperbolicOperator # {{{ constant-velocity @@ -125,7 +123,7 @@ def operator(self, t, w): # FIXME from warnings import warn warn("Inhomogeneous Dirichlet conditions on the wave equation " - "are still having issues.") + "are still having issues.", stacklevel=1) dir_g = self.dirichlet_bc_f dir_bc = flat_obj_array(2*dir_g - dir_u, dir_v) @@ -289,7 +287,7 @@ def operator(self, t, w): # FIXME from warnings import warn warn("Inhomogeneous Dirichlet conditions on the wave equation " - "are still having issues.") + "are still having issues.", stacklevel=1) dir_g = self.dirichlet_bc_f dir_bc = flat_obj_array(dir_c, 2*dir_g - dir_u, dir_v) diff --git a/grudge/op.py b/grudge/op.py index 0d9844066..c640e71c1 100644 --- a/grudge/op.py +++ b/grudge/op.py @@ -45,6 +45,7 @@ from meshmode.discretization import InterpolatoryElementGroupBase, NodalElementGroupBase + __copyright__ = """ Copyright (C) 2021 Andreas Kloeckner Copyright (C) 2021 University of Illinois Board of Trustees @@ -71,60 +72,58 @@ """ -from arraycontext import (ArrayContext, map_array_container, tag_axes, - ArrayOrContainer) - from functools import partial -from meshmode.dof_array import DOFArray -from meshmode.transform_metadata import (FirstAxisIsElementsTag, - DiscretizationDOFAxisTag, - DiscretizationElementAxisTag, - DiscretizationFaceAxisTag) -import modepy as mp - -from grudge.discretization import DiscretizationCollection -from grudge.dof_desc import as_dofdesc +import numpy as np +import modepy as mp +from arraycontext import ArrayContext, ArrayOrContainer, map_array_container, tag_axes +from meshmode.dof_array import DOFArray +from meshmode.transform_metadata import ( + DiscretizationDOFAxisTag, + DiscretizationElementAxisTag, + DiscretizationFaceAxisTag, + FirstAxisIsElementsTag, +) from pytools import keyed_memoize_in from pytools.obj_array import make_obj_array -import numpy as np - import grudge.dof_desc as dof_desc +from grudge.discretization import DiscretizationCollection from grudge.dof_desc import ( - DD_VOLUME_ALL, FACE_RESTR_ALL, DISCR_TAG_BASE, - DOFDesc, VolumeDomainTag + DD_VOLUME_ALL, + DISCR_TAG_BASE, + FACE_RESTR_ALL, + DOFDesc, + VolumeDomainTag, + as_dofdesc, ) - from grudge.interpolation import interp from grudge.projection import project - from grudge.reductions import ( - norm, - nodal_sum, - nodal_min, - nodal_max, - nodal_sum_loc, - nodal_min_loc, - nodal_max_loc, - integral, - elementwise_sum, + elementwise_integral, elementwise_max, elementwise_min, - elementwise_integral, + elementwise_sum, + integral, + nodal_max, + nodal_max_loc, + nodal_min, + nodal_min_loc, + nodal_sum, + nodal_sum_loc, + norm, ) - from grudge.trace_pair import ( - project_tracepair, - tracepair_with_discr_tag, + bdry_trace_pair, + bv_trace_pair, + connected_ranks, + cross_rank_trace_pairs, interior_trace_pair, interior_trace_pairs, local_interior_trace_pair, - connected_ranks, - cross_rank_trace_pairs, - bdry_trace_pair, - bv_trace_pair + project_tracepair, + tracepair_with_discr_tag, ) @@ -297,9 +296,9 @@ def _strong_scalar_grad(dcoll, dd_in, vec): def _strong_scalar_div(dcoll, dd, vecs): + from arraycontext import get_container_context_recursively, serialize_container + from grudge.geometry import inverse_surface_metric_derivative_mat - from arraycontext import (get_container_context_recursively, - serialize_container) assert isinstance(vecs, np.ndarray) assert vecs.shape == (dcoll.ambient_dim,) @@ -445,8 +444,7 @@ def _reference_stiffness_transpose_matrices( in_grp.discretization_key())) def get_ref_stiffness_transpose_mat(out_grp, in_grp): if in_grp == out_grp: - from meshmode.discretization.poly_element import \ - mass_matrix, diff_matrices + from meshmode.discretization.poly_element import diff_matrices, mass_matrix mmat = mass_matrix(out_grp) return actx.freeze( @@ -498,9 +496,9 @@ def _weak_scalar_grad(dcoll, dd_in, vec): def _weak_scalar_div(dcoll, dd_in, vecs): + from arraycontext import get_container_context_recursively, serialize_container + from grudge.geometry import inverse_surface_metric_derivative_mat - from arraycontext import (get_container_context_recursively, - serialize_container) assert isinstance(vecs, np.ndarray) assert vecs.shape == (dcoll.ambient_dim,) @@ -899,8 +897,7 @@ def get_ref_face_mass_mat(face_grp, vol_grp): import modepy as mp from meshmode.discretization import ElementGroupWithBasis - from meshmode.discretization.poly_element import \ - QuadratureSimplexElementGroup + from meshmode.discretization.poly_element import QuadratureSimplexElementGroup n = vol_grp.order m = face_grp.order diff --git a/grudge/projection.py b/grudge/projection.py index 0907f227a..abd37b65e 100644 --- a/grudge/projection.py +++ b/grudge/projection.py @@ -9,6 +9,7 @@ from __future__ import annotations + __copyright__ = """ Copyright (C) 2021 University of Illinois Board of Trustees """ @@ -38,10 +39,11 @@ from grudge.discretization import DiscretizationCollection from grudge.dof_desc import ( - as_dofdesc, - VolumeDomainTag, BoundaryDomainTag, - ConvertibleToDOFDesc) + ConvertibleToDOFDesc, + VolumeDomainTag, + as_dofdesc, +) def project( diff --git a/grudge/reductions.py b/grudge/reductions.py index 9d68aff9e..45b7e1507 100644 --- a/grudge/reductions.py +++ b/grudge/reductions.py @@ -34,6 +34,7 @@ from __future__ import annotations + __copyright__ = """ Copyright (C) 2021 University of Illinois Board of Trustees """ @@ -59,27 +60,27 @@ """ -from functools import reduce, partial +from functools import partial, reduce + +import numpy as np from arraycontext import ( + ArrayOrContainer, + Scalar, make_loopy_program, map_array_container, serialize_container, tag_axes, - Scalar, ArrayOrContainer ) - -from grudge.discretization import DiscretizationCollection - -from pytools import memoize_in - from meshmode.dof_array import DOFArray from meshmode.transform_metadata import ( + DiscretizationDOFAxisTag, DiscretizationElementAxisTag, - DiscretizationDOFAxisTag) +) +from pytools import memoize_in -import numpy as np import grudge.dof_desc as dof_desc +from grudge.discretization import DiscretizationCollection # {{{ Nodal reductions @@ -158,9 +159,9 @@ def nodal_sum_loc(dcoll: DiscretizationCollection, dd, vec) -> Scalar: actx = vec.array_context - return sum([ + return sum( actx.np.sum(grp_ary) if grp_ary.size else actx.from_numpy(np.array(0.)) - for grp_ary in vec]) + for grp_ary in vec) def nodal_min(dcoll: DiscretizationCollection, dd, vec, *, initial=None) -> Scalar: @@ -367,7 +368,9 @@ def elementwise_prg(): ) import loopy as lp from meshmode.transform_metadata import ( - ConcurrentElementInameTag, ConcurrentDOFInameTag) + ConcurrentDOFInameTag, + ConcurrentElementInameTag, + ) return lp.tag_inames(t_unit, { "iel": ConcurrentElementInameTag(), "idof": ConcurrentDOFInameTag()}) diff --git a/grudge/shortcuts.py b/grudge/shortcuts.py index e6e62cc55..0c9f63848 100644 --- a/grudge/shortcuts.py +++ b/grudge/shortcuts.py @@ -20,11 +20,10 @@ THE SOFTWARE. """ -from grudge.dof_desc import DD_VOLUME_ALL - - from pytools import memoize_in +from grudge.dof_desc import DD_VOLUME_ALL + def rk4_step(y, t, h, f): k1 = f(t, y) @@ -63,8 +62,8 @@ def get_state_updater(): def set_up_rk4(field_var_name, dt, fields, rhs, t_start=0.0): - from leap.rk import LSRK4MethodBuilder from dagrt.codegen import PythonCodeGenerator + from leap.rk import LSRK4MethodBuilder dt_method = LSRK4MethodBuilder(component_id=field_var_name) dt_code = dt_method.generate() diff --git a/grudge/tools.py b/grudge/tools.py index 8640456bb..69fd56fad 100644 --- a/grudge/tools.py +++ b/grudge/tools.py @@ -6,6 +6,7 @@ from __future__ import annotations + __copyright__ = "Copyright (C) 2007 Andreas Kloeckner" __license__ = """ @@ -29,12 +30,12 @@ """ from functools import partial -from typing import Tuple, Callable, Optional, Union, Any +from typing import Any, Callable, Optional, Tuple, Union import numpy as np -from pytools import product from arraycontext import ArrayContext, ArrayOrContainer, ArrayOrContainerT +from pytools import product # {{{ build_jacobian diff --git a/grudge/trace_pair.py b/grudge/trace_pair.py index c6ee83726..d92b3e561 100644 --- a/grudge/trace_pair.py +++ b/grudge/trace_pair.py @@ -51,40 +51,39 @@ """ +from dataclasses import dataclass +from numbers import Number +from typing import Any, Hashable, List, Optional, Type from warnings import warn -from typing import List, Hashable, Optional, Type, Any -from pytools.persistent_dict import KeyBuilder +import numpy as np from arraycontext import ( ArrayContainer, - with_container_arithmetic, + ArrayOrContainer, dataclass_array_container, + flatten, + from_numpy, get_container_context_recursively, - flatten, to_numpy, - unflatten, from_numpy, - ArrayOrContainer + to_numpy, + unflatten, + with_container_arithmetic, ) - -from dataclasses import dataclass - -from numbers import Number - -from pytools import memoize_on_first_arg - -from grudge.discretization import DiscretizationCollection -from grudge.projection import project - from meshmode.mesh import BTAG_PARTITION - -import numpy as np +from pytools import memoize_on_first_arg +from pytools.persistent_dict import KeyBuilder import grudge.dof_desc as dof_desc +from grudge.discretization import DiscretizationCollection from grudge.dof_desc import ( - DOFDesc, DD_VOLUME_ALL, FACE_RESTR_INTERIOR, DISCR_TAG_BASE, - VolumeDomainTag, - ConvertibleToDOFDesc, - ) + DD_VOLUME_ALL, + DISCR_TAG_BASE, + FACE_RESTR_INTERIOR, + ConvertibleToDOFDesc, + DOFDesc, + VolumeDomainTag, +) +from grudge.projection import project # {{{ trace pair container class @@ -393,7 +392,8 @@ def _sym_tag_to_num_tag(comm_tag: Optional[Hashable]) -> Optional[int]: warn("Encountered unknown symbolic tag " f"'{comm_tag}', assigning a value of '{num_tag}'. " "This is a temporary workaround, please ensure that " - "tags are sufficiently distinct for your use case.") + "tags are sufficiently distinct for your use case.", + stacklevel=1) return num_tag diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 000000000..2a2578210 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,53 @@ +[tool.ruff] +preview = true + +[tool.ruff.lint] +extend-select = [ + "B", # flake8-bugbear + "C", # flake8-comprehensions + "E", # pycodestyle + "F", # pyflakes + "I", # flake8-isort + "N", # pep8-naming + "NPY", # numpy + "Q", # flake8-quotes + "W", # pycodestyle +] +extend-ignore = [ + "C90", # McCabe complexity + "E221", # multiple spaces before operator + "E226", # missing whitespace around arithmetic operator + "E241", # multiple spaces after comma + "E242", # tab after comma + "E402", # module level import not at the top of file +] +[tool.ruff.lint.per-file-ignores] +"test/test_grudge.py" = ["B023"] +"test/test_op.py" = ["B023"] +"test/test_euler_model.py" = ["B023"] + +[tool.ruff.lint.flake8-quotes] +docstring-quotes = "double" +inline-quotes = "double" +multiline-quotes = "double" + +[tool.ruff.lint.isort] +combine-as-imports = true +known-first-party = [ + "pytools", + "pymbolic", + "meshmode", + "modepy", + "pyopencl", + "loopy", + "arraycontext", +] +known-local-folder = [ + "grudge", +] +lines-after-imports = 2 + +[tool.mypy] +warn_unused_ignores = true + + diff --git a/setup.cfg b/setup.cfg deleted file mode 100644 index da67c8630..000000000 --- a/setup.cfg +++ /dev/null @@ -1,22 +0,0 @@ -[flake8] -ignore = E126,E127,E128,E123,E226,E241,E242,E265,W503,E402,N818 -max-line-length=85 -exclude= - grudge/dt_finding.py - -inline-quotes = " -docstring-quotes = """ -multiline-quotes = """ -per-file-ignores = - test/test_grudge.py:B023 - test/test_op.py:B023 - test/test_euler_model.py:B023 - -# enable-flake8-bugbear - -[mypy] -ignore_missing_imports = True - -[mypy-grudge.models.gas_dynamics] -ignore_errors = True - diff --git a/setup.py b/setup.py index 0eb7025de..17d6f8959 100644 --- a/setup.py +++ b/setup.py @@ -2,7 +2,7 @@ def main(): - from setuptools import setup, find_packages + from setuptools import find_packages, setup version_dict = {} init_filename = "grudge/version.py" diff --git a/test/mesh_data.py b/test/mesh_data.py index c71950bb9..4190f2f0b 100644 --- a/test/mesh_data.py +++ b/test/mesh_data.py @@ -1,9 +1,11 @@ -from abc import abstractmethod, ABC +from abc import ABC, abstractmethod from typing import ClassVar, Hashable, Optional, Sequence -from meshmode.mesh import Mesh -from meshmode.mesh.io import read_gmsh + import numpy as np + import meshmode.mesh.generation as mgen +from meshmode.mesh import Mesh +from meshmode.mesh.io import read_gmsh class MeshBuilder(ABC): diff --git a/test/test_dt_utils.py b/test/test_dt_utils.py index 92d47dcdf..a05ce54db 100644 --- a/test/test_dt_utils.py +++ b/test/test_dt_utils.py @@ -24,23 +24,25 @@ import numpy as np +from arraycontext import pytest_generate_tests_for_array_contexts + from grudge.array_context import ( PytestPyOpenCLArrayContextFactory, - PytestPytatoPyOpenCLArrayContextFactory + PytestPytatoPyOpenCLArrayContextFactory, ) -from arraycontext import pytest_generate_tests_for_array_contexts + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory, PytestPytatoPyOpenCLArrayContextFactory]) -from grudge import DiscretizationCollection -import grudge.op as op +import logging import mesh_data - import pytest -import logging +import grudge.op as op +from grudge import DiscretizationCollection logger = logging.getLogger(__name__) @@ -178,8 +180,8 @@ def test_wave_dt_estimate(actx_factory, dim, degree, visualize=False): assert (eigvals.real <= 1e-12).all() - from leap.rk import stability_function, RK4MethodBuilder import sympy as sp + from leap.rk import RK4MethodBuilder, stability_function stab_func = sp.lambdify(*stability_function( RK4MethodBuilder.a_explicit, RK4MethodBuilder.output_coeffs)) diff --git a/test/test_euler_model.py b/test/test_euler_model.py index 13a479d48..5ef1c54dd 100644 --- a/test/test_euler_model.py +++ b/test/test_euler_model.py @@ -24,39 +24,40 @@ import pytest -from grudge.array_context import PytestPyOpenCLArrayContextFactory from arraycontext import ( pytest_generate_tests_for_array_contexts, ) + +from grudge.array_context import PytestPyOpenCLArrayContextFactory + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) +import logging + import grudge.op as op -import logging + logger = logging.getLogger(__name__) @pytest.mark.parametrize("order", [1, 2, 3]) def test_euler_vortex_convergence(actx_factory, order): + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) from meshmode.mesh.generation import generate_regular_rect_mesh + from pytools.convergence import EOCRecorder from grudge import DiscretizationCollection from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD from grudge.dt_utils import h_max_from_volume - from grudge.models.euler import ( - vortex_initial_condition, - EulerOperator - ) + from grudge.models.euler import EulerOperator, vortex_initial_condition from grudge.shortcuts import rk4_step - from meshmode.discretization.poly_element import \ - (default_simplex_group_factory, - QuadratureSimplexGroupFactory) - - from pytools.convergence import EOCRecorder - actx = actx_factory() eoc_rec = EOCRecorder() quad_tag = DISCR_TAG_QUAD diff --git a/test/test_grudge.py b/test/test_grudge.py index a65b16e3e..21097d462 100644 --- a/test/test_grudge.py +++ b/test/test_grudge.py @@ -23,39 +23,38 @@ THE SOFTWARE. """ +import mesh_data import numpy as np import numpy.linalg as la +from arraycontext import pytest_generate_tests_for_array_contexts from meshmode.discretization.poly_element import ( InterpolatoryEdgeClusteredGroupFactory, - QuadratureGroupFactory) + QuadratureGroupFactory, +) from meshmode.mesh import TensorProductElementGroup + from grudge.array_context import PytestPyOpenCLArrayContextFactory -from arraycontext import pytest_generate_tests_for_array_contexts -import mesh_data pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) -from meshmode import _acf # noqa: F401 +import logging -from meshmode.dof_array import flat_norm -import meshmode.mesh.generation as mgen +import pytest +import meshmode.mesh.generation as mgen +from meshmode import _acf # noqa: F401 +from meshmode.dof_array import flat_norm from pytools.obj_array import flat_obj_array -from grudge import DiscretizationCollection, make_discretization_collection - import grudge.dof_desc as dof_desc -import grudge.op as op import grudge.geometry as geo +import grudge.op as op +from grudge import DiscretizationCollection, make_discretization_collection -import pytest - -import logging - logger = logging.getLogger(__name__) @@ -141,7 +140,7 @@ def _ellipse_surface_area(radius, aspect_ratio): # NOTE: hardcoded value so we don't need scipy for the test ellip_e = 1.2110560275684594 else: - from scipy.special import ellipe # pylint: disable=no-name-in-module + from scipy.special import ellipe # pylint: disable=no-name-in-module ellip_e = ellipe(eccentricity) return 4.0 * radius * ellip_e @@ -363,6 +362,7 @@ def test_face_normal_surface(actx_factory, mesh_name): # {{{ Compute surface and face normals from meshmode.discretization.connection import FACE_RESTR_INTERIOR + from grudge.geometry import normal dv = dof_desc.DD_VOLUME @@ -383,7 +383,7 @@ def test_face_normal_surface(actx_factory, mesh_name): )(face_normal_i) if ambient_dim == 3: - from grudge.geometry import pseudoscalar, area_element + from grudge.geometry import area_element, pseudoscalar # NOTE: there's only one face tangent in 3d face_tangent = ( pseudoscalar(actx, dcoll, dd=df) / area_element(actx, dcoll, dd=df) @@ -474,7 +474,7 @@ def test_gauss_theorem(actx_factory, case, visualize=False): use_overint = False if case == "circle": - from meshpy.geometry import make_circle, GeometryBuilder + from meshpy.geometry import GeometryBuilder, make_circle from meshpy.triangle import MeshInfo, build geob = GeometryBuilder() @@ -567,7 +567,7 @@ def f(x): int_2 = op.integral(dcoll, dd_quad_bd, f_dot_n) if visualize: - from grudge.shortcuts import make_visualizer, make_boundary_visualizer + from grudge.shortcuts import make_boundary_visualizer, make_visualizer vis = make_visualizer(dcoll) bvis = make_boundary_visualizer(dcoll) @@ -648,14 +648,13 @@ def f(x): mesh_offset = np.array([0.33, -0.21, 0.0])[:ambient_dim] for i, resolution in enumerate(builder.resolutions): - from meshmode.mesh.processing import affine_map from meshmode.discretization.connection import FACE_RESTR_ALL + from meshmode.mesh.processing import affine_map mesh = builder.get_mesh(resolution, order) mesh = affine_map(mesh, A=mesh_rotation, b=mesh_offset) - from meshmode.discretization.poly_element import \ - QuadratureSimplexGroupFactory + from meshmode.discretization.poly_element import QuadratureSimplexGroupFactory qtag = dof_desc.DISCR_TAG_QUAD dcoll = DiscretizationCollection( @@ -766,7 +765,7 @@ def test_convergence_advec(actx_factory, mesh_name, mesh_pars, op_type, flux_typ elif mesh_name == "disk": pytest.importorskip("meshpy") - from meshpy.geometry import make_circle, GeometryBuilder + from meshpy.geometry import GeometryBuilder, make_circle from meshpy.triangle import MeshInfo, build geob = GeometryBuilder() @@ -814,10 +813,12 @@ def f(x): def u_analytic(x, t=0): return f(-v.dot(x)/norm_v + t*norm_v) + from meshmode.mesh import BTAG_ALL + from grudge.models.advection import ( - StrongAdvectionOperator, WeakAdvectionOperator + StrongAdvectionOperator, + WeakAdvectionOperator, ) - from meshmode.mesh import BTAG_ALL dcoll = DiscretizationCollection(actx, mesh, order=order) op_class = {"strong": StrongAdvectionOperator, @@ -850,7 +851,7 @@ def rhs(t, u): tol = 1e-14 dt = final_time/nsteps + tol - from grudge.shortcuts import make_visualizer, compiled_lsrk45_step + from grudge.shortcuts import compiled_lsrk45_step, make_visualizer vis = make_visualizer(dcoll) step = 0 @@ -978,10 +979,11 @@ def rhs(t, w): @pytest.mark.parametrize("order", [2, 3, 4]) def test_improvement_quadrature(actx_factory, order): """Test whether quadrature improves things and converges""" - from grudge.models.advection import VariableCoefficientAdvectionOperator - from pytools.convergence import EOCRecorder from meshmode.discretization.poly_element import QuadratureSimplexGroupFactory from meshmode.mesh import BTAG_ALL + from pytools.convergence import EOCRecorder + + from grudge.models.advection import VariableCoefficientAdvectionOperator actx = actx_factory() @@ -1078,7 +1080,7 @@ def test_bessel(actx_factory): # FIXME: Bessel functions need to brought out of the symbolic # layer. Related issue: https://github.com/inducer/grudge/issues/93 def bessel_j(actx, n, r): - from grudge import sym, bind # pylint: disable=no-name-in-module + from grudge import bind, sym # pylint: disable=no-name-in-module return bind(dcoll, sym.bessel_j(n, sym.var("r")))(actx, r=r) # https://dlmf.nist.gov/10.6.1 diff --git a/test/test_metrics.py b/test/test_metrics.py index 586b093a5..f26778e29 100644 --- a/test/test_metrics.py +++ b/test/test_metrics.py @@ -25,23 +25,27 @@ import numpy as np +from arraycontext import pytest_generate_tests_for_array_contexts + from grudge.array_context import ( PytestPyOpenCLArrayContextFactory, - PytestPytatoPyOpenCLArrayContextFactory + PytestPytatoPyOpenCLArrayContextFactory, ) -from arraycontext import pytest_generate_tests_for_array_contexts + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory, PytestPytatoPyOpenCLArrayContextFactory]) -from meshmode.dof_array import flat_norm +import logging + +import pytest + import meshmode.mesh.generation as mgen +from meshmode.dof_array import flat_norm from grudge import DiscretizationCollection -import pytest - -import logging logger = logging.getLogger(__name__) @@ -74,10 +78,12 @@ def m(x): from meshmode.mesh.processing import map_mesh mesh = map_mesh(mesh, m) - from grudge.dof_desc import as_dofdesc, DISCR_TAG_BASE, DISCR_TAG_QUAD - from meshmode.discretization.poly_element import \ - QuadratureSimplexGroupFactory, \ - default_simplex_group_factory + from meshmode.discretization.poly_element import ( + QuadratureSimplexGroupFactory, + default_simplex_group_factory, + ) + + from grudge.dof_desc import DISCR_TAG_BASE, DISCR_TAG_QUAD, as_dofdesc dcoll = DiscretizationCollection( actx, mesh, @@ -87,8 +93,10 @@ def m(x): } ) - from grudge.geometry import \ - forward_metric_derivative_mat, inverse_metric_derivative_mat + from grudge.geometry import ( + forward_metric_derivative_mat, + inverse_metric_derivative_mat, + ) dd = as_dofdesc("vol") if use_quad: diff --git a/test/test_modal_connections.py b/test/test_modal_connections.py index a5af92164..d6bebdbd5 100644 --- a/test/test_modal_connections.py +++ b/test/test_modal_connections.py @@ -21,31 +21,33 @@ """ -from grudge.array_context import PytestPyOpenCLArrayContextFactory from arraycontext import pytest_generate_tests_for_array_contexts +from grudge.array_context import PytestPyOpenCLArrayContextFactory from grudge.discretization import make_discretization_collection + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) +import pytest + +import meshmode.mesh.generation as mgen from meshmode.discretization.poly_element import ( # Simplex group factories InterpolatoryQuadratureSimplexGroupFactory, - ModalGroupFactory, - PolynomialWarpAndBlend2DRestrictingGroupFactory, - PolynomialEquidistantSimplexGroupFactory, # Tensor product group factories LegendreGaussLobattoTensorProductGroupFactory, + ModalGroupFactory, + PolynomialEquidistantSimplexGroupFactory, + PolynomialWarpAndBlend2DRestrictingGroupFactory, # Quadrature-based (non-interpolatory) group factories - QuadratureSimplexGroupFactory + QuadratureSimplexGroupFactory, ) from meshmode.dof_array import flat_norm -import meshmode.mesh.generation as mgen import grudge.dof_desc as dof_desc -import pytest - @pytest.mark.parametrize("nodal_group_factory", [ InterpolatoryQuadratureSimplexGroupFactory, diff --git a/test/test_mpi_communication.py b/test/test_mpi_communication.py index 4be934588..9998a1b0a 100644 --- a/test/test_mpi_communication.py +++ b/test/test_mpi_communication.py @@ -24,28 +24,29 @@ THE SOFTWARE. """ -import pytest +import logging import os +import sys + import numpy as np +import pytest + import pyopencl as cl -import logging -import sys from grudge.array_context import MPIPyOpenCLArrayContext, MPIPytatoArrayContext + logger = logging.getLogger(__name__) logging.basicConfig() logger.setLevel(logging.INFO) -from grudge import DiscretizationCollection -from grudge.shortcuts import rk4_step - from meshmode.dof_array import flat_norm - from pytools.obj_array import flat_obj_array -import grudge.op as op import grudge.dof_desc as dof_desc +import grudge.op as op +from grudge import DiscretizationCollection +from grudge.shortcuts import rk4_step class SimpleTag: @@ -61,8 +62,8 @@ def run_test_with_mpi(num_ranks, f, *args): import pytest pytest.importorskip("mpi4py") - from pickle import dumps from base64 import b64encode + from pickle import dumps invocation_info = b64encode(dumps((f, args))).decode() from subprocess import check_call @@ -76,8 +77,8 @@ def run_test_with_mpi(num_ranks, f, *args): def run_test_with_mpi_inner(): - from pickle import loads from base64 import b64decode + from pickle import loads f, (actx_class, *args) = loads(b64decode(os.environ["INVOCATION_INFO"].encode())) cl_context = cl.create_some_context() @@ -115,8 +116,7 @@ def _test_func_comparison_mpi_communication_entrypoint(actx): comm = actx.mpi_communicator - from meshmode.distributed import ( - get_partition_by_pymetis, membership_list_to_map) + from meshmode.distributed import get_partition_by_pymetis, membership_list_to_map from meshmode.mesh import BTAG_ALL from meshmode.mesh.processing import partition_mesh @@ -192,8 +192,7 @@ def _test_mpi_wave_op_entrypoint(actx, visualize=False): comm = actx.mpi_communicator num_parts = comm.size - from meshmode.distributed import ( - get_partition_by_pymetis, membership_list_to_map) + from meshmode.distributed import get_partition_by_pymetis, membership_list_to_map from meshmode.mesh.processing import partition_mesh dim = 2 @@ -233,9 +232,10 @@ def source_f(actx, dcoll, t=0): ) ) - from grudge.models.wave import WeakWaveOperator from meshmode.mesh import BTAG_ALL, BTAG_NONE + from grudge.models.wave import WeakWaveOperator + wave_op = WeakWaveOperator( dcoll, 0.1, @@ -257,9 +257,7 @@ def source_f(actx, dcoll, t=0): wave_op.check_bc_coverage(local_mesh) - from logpyle import LogManager, \ - add_general_quantities, \ - add_run_info + from logpyle import LogManager, add_general_quantities, add_run_info log_filename = None # NOTE: LogManager hangs when using a file on a shared directory. # log_filename = "grudge_log.dat" diff --git a/test/test_op.py b/test/test_op.py index 0f8dc3163..41c7776b5 100644 --- a/test/test_op.py +++ b/test/test_op.py @@ -21,31 +21,37 @@ """ -from meshmode.discretization.poly_element import ( - InterpolatoryEdgeClusteredGroupFactory, QuadratureGroupFactory) import numpy as np +import pytest -from meshmode.mesh import BTAG_ALL import meshmode.mesh.generation as mgen - +from arraycontext import pytest_generate_tests_for_array_contexts +from meshmode.discretization.poly_element import ( + InterpolatoryEdgeClusteredGroupFactory, + QuadratureGroupFactory, +) +from meshmode.mesh import BTAG_ALL from pytools.obj_array import make_obj_array -from grudge import op, geometry as geo, DiscretizationCollection +from grudge import DiscretizationCollection, geometry as geo, op +from grudge.array_context import PytestPyOpenCLArrayContextFactory from grudge.discretization import make_discretization_collection -from grudge.dof_desc import (DISCR_TAG_BASE, DISCR_TAG_QUAD, DTAG_VOLUME_ALL, - DOFDesc, as_dofdesc) +from grudge.dof_desc import ( + DISCR_TAG_BASE, + DISCR_TAG_QUAD, + DTAG_VOLUME_ALL, + DOFDesc, + as_dofdesc, +) +from grudge.trace_pair import bv_trace_pair -import pytest -from grudge.array_context import PytestPyOpenCLArrayContextFactory -from arraycontext import pytest_generate_tests_for_array_contexts - -from grudge.trace_pair import bv_trace_pair pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) import logging + logger = logging.getLogger(__name__) diff --git a/test/test_reductions.py b/test/test_reductions.py index ff858b47c..33f98b417 100644 --- a/test/test_reductions.py +++ b/test/test_reductions.py @@ -22,35 +22,33 @@ THE SOFTWARE. """ -import numpy as np - from dataclasses import dataclass +import numpy as np + from arraycontext import ( - with_container_arithmetic, dataclass_array_container, - pytest_generate_tests_for_array_contexts + pytest_generate_tests_for_array_contexts, + with_container_arithmetic, ) - from meshmode.dof_array import DOFArray from grudge.array_context import PytestPyOpenCLArrayContextFactory + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) -from grudge import DiscretizationCollection +import logging -import grudge.op as op import mesh_data +import pytest from meshmode.dof_array import flatten - from pytools.obj_array import make_obj_array -import pytest - -import logging +import grudge.op as op +from grudge import DiscretizationCollection logger = logging.getLogger(__name__) diff --git a/test/test_tools.py b/test/test_tools.py index fb1785faf..efd5747d5 100644 --- a/test/test_tools.py +++ b/test/test_tools.py @@ -22,21 +22,25 @@ THE SOFTWARE. """ +from dataclasses import dataclass + import numpy as np import numpy.linalg as la # noqa -from dataclasses import dataclass +from arraycontext import pytest_generate_tests_for_array_contexts from grudge.array_context import PytestPyOpenCLArrayContextFactory -from arraycontext import pytest_generate_tests_for_array_contexts + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) -from pytools.obj_array import make_obj_array +import logging import pytest -import logging +from pytools.obj_array import make_obj_array + logger = logging.getLogger(__name__) diff --git a/test/test_trace_pair.py b/test/test_trace_pair.py index 4e4773acf..5bfbb0eb9 100644 --- a/test/test_trace_pair.py +++ b/test/test_trace_pair.py @@ -22,19 +22,22 @@ import numpy as np -from grudge.trace_pair import TracePair + import meshmode.mesh.generation as mgen +from arraycontext import pytest_generate_tests_for_array_contexts from meshmode.dof_array import DOFArray from grudge import DiscretizationCollection - from grudge.array_context import PytestPyOpenCLArrayContextFactory -from arraycontext import pytest_generate_tests_for_array_contexts +from grudge.trace_pair import TracePair + + pytest_generate_tests = pytest_generate_tests_for_array_contexts( [PytestPyOpenCLArrayContextFactory]) import logging + logger = logging.getLogger(__name__) @@ -51,11 +54,13 @@ def test_trace_pair(actx_factory): dcoll = DiscretizationCollection(actx, mesh, order=order) + rng = np.random.default_rng(1234) + def rand(): return DOFArray( actx, tuple(actx.from_numpy( - np.random.rand(grp.nelements, grp.nunit_dofs)) + rng.uniform(size=(grp.nelements, grp.nunit_dofs))) for grp in dcoll.discr_from_dd("vol").groups)) interior = rand()