Search

Reaction-diffusion equations model various biological, physical, sociological, and environmental phenomena. Often, numerical simulations are used to understand and discover the dynamics of such systems. Following the extension of the nonlinear Lyapunov theory applied to some class of reaction-diffusion partial differential equations (PDEs), we develop the first fully discrete Lyapunov discretizations that are consistent with the stability properties of the continuous parabolic reaction-diffusion models. The proposed framework provides a systematic procedure to develop fully discrete schemes of arbitrary order in space and time for solving a broad class of equations equipped with a Lyapunov functional. The new schemes are applied to solve systems of PDEs, which arise in epidemiology and oncolytic M1 virotherapy. The new computational framework provides physically consistent and accurate results without exhibiting scheme-dependent instabilities and converging to unphysical solutions. The proposed approach represents a capstone for developing efficient, robust, and predictive technologies for simulating complex phenomena.

We study a temporal step size control of explicit Runge-Kutta (RK) methods for compressible computational fluid dynamics (CFD), including the Navier-Stokes equations and hyperbolic systems of conservation laws such as the Euler equations. We demonstrate that error-based approaches are convenient in a wide range of applications and compare them to more classical step size control based on a Courant-Friedrichs-Lewy (CFL) number. Our numerical examples show that the error-based step size control is easy to use, robust, and efficient, e.g., for (initial) transient periods, complex geometries, nonlinear shock capturing approaches, and schemes that use nonlinear entropy projections. We demonstrate these properties for problems ranging from well-understood academic test cases to industrially relevant large-scale computations with two disjoint code bases, the open source Julia packages Trixi.jl with OrdinaryDiffEq.jl and the C/Fortran code SSDC based on PETSc.

We present mpi4py.futures, a lightweight, asynchronous task execution framework targeting the Python programming language and using the Message Passing Interface (MPI) for interprocess communication. mpi4py.futures follows the interface of the concurrent.futures package from the Python standard library and can be used as its drop-in replacement, while allowing applications to scale over multiple compute nodes. We discuss the design, implementation, and feature set of mpi4py.futures and compare its performance to other solutions on both shared and distributed memory architectures. On a shared-memory system, we show mpi4py.futures to consistently outperform Python's concurrent.futures with speedup ratios between 1.4X and 3.7X in throughput (tasks per second) and between 1.9X and 2.9X in bandwidth. On a Cray XC40 system, we compare mpi4py.futures to Dask – a well-known Python parallel computing package. Although we note more varied results, we show mpi4py.futures to outperform Dask in most scenarios.

We develop error-control based time integration algorithms for compressible fluid dynamics (CFD) applications and show that they are efficient and robust in both the accuracy-limited and stability-limited regime. Focusing on discontinuous spectral element semidiscretizations, we design new controllers for existing methods and for some new embedded Runge-Kutta pairs. We demonstrate the importance of choosing adequate controller parameters and provide a means to obtain these in practice. We compare a wide range of error-control-based methods, along with the common approach in which step size control is based on the Courant-Friedrichs-Lewy (CFL) number. The optimized methods give improved performance and naturally adopt a step size close to the maximum stable CFL number at loose tolerances, while additionally providing control of the temporal error at tighter tolerances. The numerical examples include challenging industrial CFD applications.

In this paper we describe the history, performance, and design concepts of direct solvers for algebraic systems resulting from Galerkin discretizations of partial differential equations. Popular direct solver implementations of Gaussian elimination (also known as LU factorization) are introduced and briefly analyzed. We discuss three of the most relevant aspects influencing the performance of direct solvers on this kind of algebraic systems. First, the ordering of the degrees of freedom of the algebraic system has a significant impact on the solver performance, solution speed and memory requirements. The impact of unknowns ordering for elimination is exemplified and alternative ordering algorithms are described and compared. Second, the effect of round-off error on the simulation results is discussed. We detail this effect for uniform grids where the impact of round-off error on the solution is controlled by the condition number of the matrix in terms of the element size, but is independent of the polynomial order of approximation. Additionally, we discuss the link between unknown ordering and round-off error. Third, we describe the impact of the connectivity pattern (graph) of the basis functions on the performance of direct solvers. Variations in the connectivity structure of the resulting discrete system have severe impact on performance of the solver. That is, the resources needed to factorize the system strongly depend on its connectivity graph. Less connected graphs are cheaper to solve, that is, C0finite element discretizations are cheaper to solve with direct solvers than Cp-1discretizations.

Nonlinear entropy stability analysis is used to derive entropy stable no-slip wall boundary conditions for the Eulerian model proposed by Svärd (Phys A Stat Mech Appl 506:350–375, 2018). The spatial discretization is based on entropy stable collocated discontinuous Galerkin operators with the summation-by-parts property for unstructured grids. A set of viscous test cases of increasing complexity are simulated using both the Eulerian and the classic compressible Navier–Stokes models. The numerical results obtained with the two models are compared, and similarities and differences are then highlighted. However, the differences are very small and probably smaller than what the current experimental technology allows to measure.

In this paper, we extend the entropy conservative/stable algorithms presented by Del Rey Fernández et al. (2019) for the compressible Euler and Navier–Stokes equations on nonconforming p-refined/coarsened curvilinear grids to h/prefinement/coarsening. The main difficulty in developing nonconforming algorithms is the construction of appropriate coupling procedures across nonconforming interfaces. Here, we utilize a computationally simple and efficient approach based upon using decoupled interpolation operators. The resulting scheme is entropy conservative/stable and element-wise conservative. Numerical simulations of the isentropic vortex and viscous shock propagation confirm the entropy conservation/stability and accuracy properties of the method (achieving ∼p+1convergence), which are comparable to those of the original conforming scheme (Carpenter et al. in SIAM J Sci Comput 36(5):B835–B867, 2014; Parsani et al. in SIAM J Sci Comput 38(5):A3129–A3162, 2016). Simulations of the Taylor–Green vortex at Re=1600and turbulent flow past a sphere at Re∞=2000show the robustness and stability properties of the overall spatial discretization for unstructured grids. Finally, to demonstrate the entropy conservation property of a fully-discrete explicit entropy stable algorithm with h/prefinement/coarsening, we present the time evolution of the entropy function obtained by simulating the propagation of the isentropic vortex using a relaxation Runge–Kutta scheme.

We propose a parallel (distributed) version of the spectral proper orthogonal decomposition (SPOD) technique. The parallel SPOD algorithm distributes the spatial dimension of the dataset preserving time. This approach is adopted to preserve the non-distributed fast Fourier transform of the data in time, thereby avoiding the associated bottlenecks. The parallel SPOD algorithm is implemented in the PySPOD library and makes use of the standard message passing interface (MPI) library, implemented in Python via mpi4py. An extensive performance evaluation of the parallel package is provided, including strong and weak scalability analyses. The open-source library allows the analysis of large datasets of interest across the scientific community. Here, we present applications in fluid dynamics and geophysics, that are extremely difficult (if not impossible) to achieve without a parallel algorithm. This work opens the path toward modal analyses of big quasi-stationary data, helping to uncover new unexplored spatio-temporal patterns. Program Title: PySPOD CPC Library link to program files: https://doi.org/10.17632/jf5bf26jcj.1 Developer's repository link: https://github.com/MathEXLab/PySPOD Licensing provisions: MIT License Programming language: Python Nature of problem: Large spatio-temporal datasets may contain coherent patterns that can be leveraged to better understand, model, and possibly predict the behavior of complex dynamical systems. To this end, modal decomposition methods, such as the proper orthogonal decomposition (POD) and its spectral counterpart (SPOD), constitute powerful tools. The SPOD algorithm allows the systematic identification of space-time coherent patterns. This can be used to understand better the physics of the process of interest, and provide a path for mathematical modeling, including reduced order modeling. The SPOD algorithm has been successfully applied to fluid dynamics, geophysics and other domains. However, the existing open-source implementations are serial, and they prevent running on the increasingly large datasets that are becoming available, especially in computational physics. The inability to analyze via SPOD large dataset in turn prevents unlocking novel mechanisms and dynamical behaviors in complex systems. Solution method: We provide an open-source parallel (MPI distributed) code, namely PySPOD, that is able to run on large datasets (the ones considered in the present paper reach about 200 Terabytes). The code is built on the previous serial open-source code PySPOD that was published in https://joss.theoj.org/papers/10.21105/joss.02862.pdf. The new parallel implementation is able to scale on several nodes (we show both weak and strong scalability) and solve some of the bottlenecks that are commonly found at the I/O stage. The current parallel code allows running on datasets that was not easy or possible to analyze with serial SPOD algorithms, hence providing a path towards unlocking novel findings in computational physics. Additional comments including restrictions and unusual features: The code comes with a set of built-in postprocessing tools, for visualizing the results. It also comes with extensive continuous integration, documentation, and tutorials, as well as a dedicated website in addition to the associated GiHub repository. Within the package we also provide a parallel implementation of the proper orthogonal decomposition (POD), that leverages the I/O parallel capabilities of the SPOD algorithm. [ABSTRACT FROM AUTHOR]

Abstract: Graphic processing units have received much attention in last years. Compute-intensive algorithms operating on multidimensional arrays that have nearest neighbor dependency and/or exploit data locality can achieve massive speedups. Simulation of problems modeled by time-dependent Partial Differential Equations by using explicit time-stepping methods on structured grids is an instance of such GPU-friendly algorithms. Solvers for transient incompressible fluid flow cannot be developed in a fully explicit manner due to the incompressibility constraint. Segregated algorithms like the fractional step method require the solution of a Poisson problem for the pressure field at each time level. This stage is usually the most time-consuming one. This work discuss a solver for the pressure problem in applications using immersed boundary techniques in order to account for moving solid bodies. This solver is based on standard Conjugate Gradients iterations and depends on the availability of a fast Poisson solver on the whole domain to define a preconditioner. We provide a theoretical and numerical evidence on the advantages of our approach versus classical techniques based on fixed point iterations such as the Iterated Orthogonal Projection method. [Copyright &y& Elsevier]

• A p -nonconforming discretization of the compressible NS equations is presented. • The discretization is entropy stable, freestream preserving, and conservative. • A local discontinuous Galerkin interior-penalty approach is used for viscous terms. • Interface dissipation terms that maintain entropy stability are developed. The entropy-conservative/stable, curvilinear, nonconforming, p -refinement algorithm for hyperbolic conservation laws of Del Rey Fernández et al. (2019) is extended from the compressible Euler equations to the compressible Navier–Stokes equations. A simple and flexible coupling procedure with planar interpolation operators between adjoining nonconforming elements is used. Curvilinear volume metric terms are numerically approximated via a minimization procedure and satisfy the discrete geometric conservation law conditions. Distinct curvilinear surface metrics are used on the adjoining interfaces to construct the interface coupling terms, thereby localizing the discrete geometric conservation law constraints to each individual element. The resulting scheme is entropy conservative/stable, element-wise conservative, and freestream preserving. Viscous interface dissipation operators that retain the entropy stability of the base scheme are developed. The accuracy and stability of the resulting numerical scheme are shown to be comparable to those of the original conforming scheme in Carpenter et al. (2014) and Parsani et al. (2016), i.e., this scheme achieves ∼ p + 1 / 2 convergence on geometrically high-order distorted element grids; this is demonstrated in the context of the viscous shock problem, the Taylor–Green vortex problem at a Reynolds number of R e = 1 , 600 , and a subsonic turbulent flow past a sphere at R e = 2 , 000. [ABSTRACT FROM AUTHOR]