Implementation Of Solvers Research Articles

Analysis for integrated energy system: Benchmarking methods and implementation

AbstractThe selection of suitable models and solutions is a fundamental requirement for conducting energy flow analysis in integrated energy systems (IES). However, this task is challenging due to the vast number of existing models and solutions, making it difficult to comprehensively compare scholars' studies with current work. In this paper, we aim to address this issue by presenting a comprehensive overview of mainstream IES models and clarifying their relationships, thereby providing guidance for scholars in selecting appropriate models. Additionally, we introduce several widely used solvers for solving algebraic and differential equations, along with their detailed implementations in the energy flow analysis of IES. Furthermore, we conduct extensive testing and demonstration of these models and methods in various cases to establish benchmarking datasets. To facilitate reproducibility, verification and comparisons, we provide open‐source access to these datasets, including system data, analysis settings and implementations of the various solvers in the mainstream models. Scholars can utilise the provided datasets to reproduce the results, verify the findings and perform comparative analyses. Moreover, they have the flexibility to customise these settings according to their specific requirements.

Implementation and validation of a generalized wall stress function

The generalized wall function by Shih et al. [Report No. M-1999-209398 (1999)], which accounts for non-equilibrium effects by the presence of favorable and adverse pressure gradients in turbulent flows, is addressed with the aim of performing high Reynolds number large-eddy simulations of the wall-bounded flow. The model uses a corrected law of the wall with a pressure gradient contribution to approximate the wall stress and applies to the entire viscous layer, buffer layer, and inertial region. A fully developed channel flow is first tested to validate the solver and model implementation, and then the wall function is assessed for the flow over a periodic hill. Wall-resolved simulations are in good agreement with reference results. A priori investigation with own experimental results corroborates the mathematical form of the model and suggests using different coefficients. The wall-modeled simulations show that the implemented wall model is able to improve the wall shear stress predictions compared to a standard equilibrium wall model. It corrects the underestimation of wall shear stresses by equilibrium models in the favorable pressure gradient region and the overestimation of wall shear stresses in the adverse pressure gradient region. The positions of the separation and reattachment points are also in good agreement with reference results. Furthermore, the prediction of the wall shear stress maximum in the favorable pressure gradient zone at the windward side of the hill is quite robust against coarsening the wall-normal grid spacing.

Fast solution of incompressible flow problems with two-level pressure approximation

This paper develops efficient preconditioned iterative solvers for incompressible flow problems discretised by an enriched Taylor–Hood mixed approximation, in which the usual pressure space is augmented by a piecewise constant pressure to ensure local mass conservation. This enrichment process causes over-specification of the pressure when the pressure space is defined by the union of standard Taylor–Hood basis functions and piecewise constant pressure basis functions, which complicates the design and implementation of efficient solvers for the resulting linear systems. We first describe the impact of this choice of pressure space specification on the matrices involved. Next, we show how to recover effective solvers for Stokes problems, with preconditioners based on the singular pressure mass matrix, and for Oseen systems arising from linearised Navier–Stokes equations, by using a two-stage pressure convection–diffusion strategy. The codes used to generate the numerical results are available online.

Design and implementation of modern CDCL ASP solvers

Answer Set Programming (ASP) is a declarative language oriented towards solving complex combinatorial problems. In fact, ASP has been successfully used to address problems in various academic and industrial domains. The success of ASP can be attributed to its concise syntax, intuitive semantics, and the availability of several efficient solvers based on the Conflict-Driven Clause Learning (CDCL) algorithm. This paper details the design and implementation of contemporary CDCL solvers, emphasizing both algorithmic descriptions and their effective and efficientimplementation.

Hybrid programming-model strategies for GPU offloading of electronic structure calculation kernels.

To address the challenge of performance portability and facilitate the implementation of electronic structure solvers, we developed the basic matrix library (BML) and Parallel, Rapid O(N), and Graph-based Recursive Electronic Structure Solver (PROGRESS) library. The BML implements linear algebra operations necessary for electronic structure kernels using a unified user interface for various matrix formats (dense and sparse) and architectures (CPUs and GPUs). Focusing on density functional theory and tight-binding models, PROGRESS implements several solvers for computing the single-particle density matrix and relies on BML. In this paper, we describe the general strategies used for these implementations on various computer architectures, using OpenMP target functionalities on GPUs, in conjunction with third-party libraries to handle performance critical numerical kernels. We demonstrate the portability of this approach and its performance in benchmark problems.

Imaging Upper-Mantle Anisotropy with Transdimensional Bayesian Monte Carlo Sampling

ABSTRACT Underdetermination is a condition affecting all problems in seismic imaging. It manifests mainly in the nonuniqueness of the models inferred from the data. This condition is exacerbated if simplifying hypotheses like isotropy are discarded in favor of more realistic anisotropic models that, although supported by seismological evidence, require more free parameters. Investigating the connections between underdetermination and anisotropy requires the implementation of solvers which explore the whole family of possibilities behind nonuniqueness and allow for more informed conclusions about the interpretation of the seismic models. Because these aspects cannot be investigated using traditional iterative linearized inversion schemes with regularization constraints that collapse the infinite possible models into a unique solution, we explore the application of transdimensional Bayesian Monte Carlo sampling to address the consequences of underdetermination in anisotropic seismic imaging. We show how teleseismic waves of P and S phases can constrain upper-mantle anisotropy and the amount of additional information these data provide in terms of uncertainty and trade-offs among multiple fields.

Mathematical solutions in internal dose assessment: A comparison of Python-based differential equation solvers in biokinetic modeling

In biokinetic modeling systems employed for radiation protection, biological retention and excretion have been modeled as a series of discretized compartments representing the organs and tissues of the human body. Fractional retention and excretion in these organ and tissue systems have been mathematically governed by a series of coupled first-order ordinary differential equations (ODEs). The coupled ODE systems comprising the biokinetic models are usually stiff due to the severe difference between rapid and slow transfers between compartments. In this study, the capabilities of solving a complex coupled system of ODEs for biokinetic modeling were evaluated by comparing different Python programming language solvers and solving methods with the motivation of establishing a framework that enables multi-level analysis. The stability of the solvers was analyzed to select the best performers for solving the biokinetic problems. A Python-based linear algebraic method was also explored to examine how the numerical methods deviated from an analytical or semi-analytical method. Results demonstrated that customized implicit methods resulted in an enhanced stable solution for the inhaled 60Co (Type M) and 131I (Type F) exposure scenarios for the inhalation pathway of the International Commission on Radiological Protection (ICRP) Publication 130 Human Respiratory Tract Model (HRTM). The customized implementation of the Python-based implicit solvers resulted in approximately consistent solutions with the Python-based matrix exponential method (expm). The differences generally observed between the implicit solvers and expm are attributable to numerical precision and the order of numerical approximation of the numerical solvers. This study provides the first analysis of a list of Python ODE solvers and methods by comparing their usage for solving biokinetic models using the ICRP Publication 130 HRTM and provides a framework for the selection of the most appropriate ODE solvers and methods in Python language to implement for modeling the distribution of internal radioactivity.

Making applications faster by asynchronous execution: Slowing down processes or relaxing MPI collectives

Comprehending the performance bottlenecks at the core of the intricate hardware–software interactions exhibited by highly parallel programs on HPC clusters is crucial. This paper sheds light on the issue of automatically asynchronous MPI communication in memory-bound parallel programs on multicore clusters and how it can be facilitated. For instance, slowing down MPI processes by deliberate injection of delays can improve performance if certain conditions are met. This leads to the counter-intuitive conclusion that noise, independent of its source, is not always detrimental but can be leveraged for performance improvements. We employ phase-space graphs as a new tool to visualize parallel program dynamics. They are useful in spotting certain patterns in parallel execution that will easily go unnoticed with traditional tracing tools. We investigate five different microbenchmarks and applications on different supercomputer platforms: an MPI-augmented STREAM Triad, two implementations of Lattice-Boltzmann fluid solvers (D3Q19 and SPEChpc D2Q37), the LULESH and HPCG proxy applications.

Predicting continuum breakdown with deep neural networks

The multi-scale nature of gaseous flows poses tremendous difficulties for theoretical and numerical analysis. The Boltzmann equation, while possessing a wider applicability than hydrodynamic equations, requires significantly more computational resources due to the increased degrees of freedom in the model. The success of a hybrid fluid-kinetic flow solver for the study of multi-scale flows relies on accurate prediction of flow regimes. In this paper, we draw on binary classification in machine learning and propose the first neural network classifier to detect near-equilibrium and non-equilibrium flow regimes based on local flow conditions. Compared with classical semi-empirical criteria of continuum breakdown, the current method provides a data-driven alternative where the parameterized implicit function is trained by solutions of the Boltzmann equation. The ground-truth labels are derived rigorously from the deviation of particle distribution functions and the approximations based on the Chapman-Enskog ansatz. Therefore, no tunable parameter is needed in the criterion. Following the entropy closure of the Boltzmann moment system, a data generation strategy is developed to produce training and test sets. Numerical analysis shows its superiority over simulation-based samplings. A hybrid Boltzmann-Navier-Stokes flow solver is built correspondingly with an adaptive partition of local flow regimes. Numerical experiments including the one-dimensional Riemann problem, shear flow layer, and hypersonic flow around a circular cylinder are presented to validate the current scheme for simulating cross-scale and non-equilibrium flow physics. The quantitative comparison with a semi-empirical criterion and benchmark results demonstrates the capability of the current neural classifier to accurately predict continuum breakdown. The code for the data generator, hybrid solver, and neural network implementation is available in the open source repositories [1,2].

The Athena++ Adaptive Mesh Refinement Framework: Multigrid Solvers for Self-gravity

We describe the implementation of multigrid solvers in the Athena++ adaptive mesh refinement (AMR) framework and their application to the solution of the Poisson equation for self-gravity. The new solvers are built on top of the AMR hierarchy and TaskList framework of Athena++ for efficient parallelization. We adopt a conservative formulation for the Laplacian operator that avoids artificial accelerations at level boundaries. Periodic, fixed, and zero-gradient boundary conditions are implemented, as well as open boundary conditions based on a multipole expansion. Hybrid parallelization using both Message Passing Interface and OpenMP is adopted, and we present results of tests demonstrating the accuracy and scaling of the methods. On a uniform grid, we show that multigrid significantly outperforms methods based on fast Fourier transforms, and requires only a small fraction of the computing time required by the (highly optimized) magnetohydrodynamic solver in Athena++. As a demonstration of the capabilities of the methods, we present the results of a test calculation of magnetized protostellar collapse on an adaptive mesh.

Monolithic Friction and Contact Handling for Rigid Bodies and Fluids Using SPH

AbstractWe propose a novel monolithic pure SPH formulation to simulate fluids strongly coupled with rigid bodies. This includes fluid incompressibility, fluid–rigid interface handling and rigid–rigid contact handling with a viable implicit particle‐based dry friction formulation. The resulting global system is solved using a new accelerated solver implementation that outperforms existing fluid and coupled rigid–fluid simulation approaches. We compare results of our simulation method to analytical solutions, show performance evaluations of our solver and present a variety of new and challenging simulation scenarios.

Computational Fluid Dynamics Analyses of a Wing with Distributed Electric Propulsion

The efficiency increase that distributed propulsion could deliver for future hybrid-electric aircraft is in line with the urgent demand for higher aerodynamic performances and a lower environmental impact. Several consolidated proprietary tools (not always available) are developed worldwide for distributed propulsion simulation. Therefore, prediction and comparisons of propeller performances, with computational fluid dynamic codes featuring different implementation of solvers, numerical schemes, and turbulence models, is of interest to a wider audience of research end-users. In this framework, the paper presents a cross-comparison study among different CFD solvers, the SU2 Multiphysics Simulation and Design Software, the CIRA proprietary flow solver UZEN, and the commercial ANSYS-FLUENT code, for the simulation of a wing section with a tractor propeller at different flow attitudes. The propeller is modelled as an actuator disk according to the general momentum theory and is accounted for in the flow solvers as a boundary condition, for the momentum and energy equations. In this study, a propeller with a fixed advance ratio J=0.63 is considered, while propeller performances are assumed variable along with the radius. To perform the comparisons among the solvers, an in-house procedure, which provides the input thrust and torque distributions in a unified format among the three solvers, is developed. Steady RANS simulations are performed at Re∞=1.7×106 and M∞=0.11, for the flowfield of an isolated propeller. Successively, a wing section with a fixed forward-mounted propeller configuration with no nacelle, is studied at α=0∘,4∘, and 8∘ angles of attack. The comparisons in terms of the lift coefficient show a good agreement among the three flow solvers both in power-off and power-on conditions. Simulations also evidenced the strong stability preserving property of upwind schemes, applied to propeller simulation at low-Mach number. Some discrepancies in the drag coefficient are observed and related to different levels of numerical diffusion between the three codes, which affects the downstream wake. Differences in flow properties in near disk region are observed and explained considering the different hub implementations.

Efficient GPU Implementation of Multidimensional Incomplete Riemann Solvers for Hyperbolic Nonconservative Systems: Applications to Shallow Water Systems with Topography and Dry Areas

Efficient GPU Implementation of Multidimensional Incomplete Riemann Solvers for Hyperbolic Nonconservative Systems: Applications to Shallow Water Systems with Topography and Dry Areas

CoronaChargingFoam: An OpenFOAM based solver for multi-physical simulations of direct unipolar diffusion charging of aerosol particles

Diffusion charging of ultrafine aerosol particles is widely used in various fields and understanding the multi-physical phenomena during the charging processes is critical to the optimization of chargers and prediction of particle evolution in particulate systems. In this work, a numerical algorithm of unipolar aerosol diffusion charging is coupled with corona discharge, a combination of electric field, current continuity and heat transfer, and fluid flow enabling the modelling of multi-physics in direct charging processes. The governing equations are discretized based on the finite volume schemes. Methods of numerically calculating the ion-particle attachment coefficients are proposed and a class named niMixedFvPatchField describing the boundary condition of ion injection on the anode is defined on the basis of OpenFOAM libraries. Iteratively strategies are applied to uncouple the governing equations and the PISO (Pressure Implicit with Splitting of Operators) algorithm is used to solve the aerosol flow equations. A new solver labelled as coronaChargingFoam in the OpenFOAM framework is developed to implement the numerical algorithm and it is further validated by comparing four test cases: Laplacian electric field, electric field-charge coupling effect, ion-particle attachment coefficients, and charging efficiencies. Acceptable agreement level in all these comparisons verifies the fidelity of the solver implementation. Program summaryProgram Title: coronaChargingFoamCPC Library link to program files:https://doi.org/10.17632/vrfky24b8m.1Licensing provisions: GNU General Public License (either version 3 or any later version)Programming language: C++External routines/libraries: OpenFOAM (http://www.openfoam.org)Nature of problem: coronaChargingFoam solves the problem of aerosol charging dynamics in direct unipolar diffusion chargers in which the equations of diffusion charging are coupled with corona discharge, a combination of electric field, current continuity and heat transfer, and fluid flow enabling the modelling of multi-physics in direct charging processes.Solution method: coronaChargingFoam employs the Finite-volume method to discretize the governing equations. Iteratively strategies are applied to uncouple the multi-physical equations and the PISO algorithm is used to solve the flow fields. Simpson method and Fibonacci approach are employed in the calculation of ion-particle attachment coefficients. A new class, niMixedFvPatchField, is defined to describe the ion-injection boundary condition on the anode.Additional comments including restrictions and unusual features: The current version of the solver can only be applied in diffusion charging for monodisperse aerosol particles. This restriction will be relaxed in near future by adopting models for polydisperse particles and incorporating field charging mechanism.

Efficient Stochastic Programming in Julia

We present StochasticPrograms.jl, a user-friendly and powerful open-source framework for stochastic programming written in the Julia language. The framework includes both modeling tools and structure-exploiting optimization algorithms. Stochastic programming models can be efficiently formulated using an expressive syntax, and models can be instantiated, inspected, and analyzed interactively. The framework scales seamlessly to distributed environments. Small instances of a model can be run locally to ensure correctness, whereas larger instances are automatically distributed in a memory-efficient way onto supercomputers or clouds and solved using parallel optimization algorithms. These structure-exploiting solvers are based on variations of the classical L-shaped, progressive-hedging, and quasi-gradient algorithms. We provide a concise mathematical background for the various tools and constructs available in the framework along with code listings exemplifying their usage. Both software innovations related to the implementation of the framework and algorithmic innovations related to the structured solvers are highlighted. We conclude by demonstrating strong scaling properties of the distributed algorithms on numerical benchmarks in a multinode setup. Summary of Contribution: This paper presents StochasticPrograms.jl, an open-source framework for stochastic programming implemented in the Julia programming language. The framework includes an expressive syntax for formulating stochastic programming models as well as versatile analysis tools and parallel optimization algorithms. The framework will prove useful to researchers, educators, and industrial users alike. Researchers will benefit from the readily extensible open-source framework, in which they can formulate complex stochastic models or quickly typeset and test novel optimization algorithms. Educators of stochastic programming will benefit from the clean and expressive syntax. Moreover, the framework supports analysis tools and stochastic programming constructs from classical theory and leading textbooks. We strongly believe that the StochasticPrograms.jl framework can reduce the barrier to entry for incoming practitioners of stochastic programming. Industrial practitioners can make use of StochasticPrograms.jl to rapidly formulate complex models, analyze small instances locally, and then run large-scale instances in production. In doing so, they get distributed capabilities for free without changing the code and access to well-tested state-of-the-art implementations of parallel structure-exploiting solvers. As the framework is open-source, anyone from these target audiences can contribute with new functionality to the framework. In conclusion, by providing both an intuitive interface for new users and an extensive development environment for expert users, StochasticPrograms.jl has strong potential to further the field of stochastic programming.

Multi-objective, multi-project scheduling solver implementation using SAP ABAP language

Projects became part of the daily business in many functional areas, across many industries and services. Despite of the variety of project execution implementation of the different domains it is visible that projects are sharing fundamental similiarities. Based on experiment the success of a project exuecution depends - next to maintained data quality and execution follow-up - on the ability to schedule the activities in an optimized way. Scheduling of the activities is even more complicated if an organization is executing more than one project at the same time. This paper presents our conceptual and implementation work in area of multi-project scheduling.

Scalable Graphics Processing Unit–Based Multiscale Linear Solvers for Reservoir Simulation

Summary In this work, the scalability of two key multiscale solvers for the pressure equation arising from incompressible flow in heterogeneous porous media, namely, the multiscale finite volume (MSFV) solver, and the restriction-smoothed basis multiscale (MsRSB) solver, are investigated on the graphics processing unit (GPU) massively parallel architecture. The robustness and scalability of both solvers are compared against their corresponding carefully optimized implementation on the shared-memory multicore architecture in a structured problem setting. Although several components in MSFV and MsRSB algorithms are directly parallelizable, their scalability on the GPU architecture depends heavily on the underlying algorithmic details and data-structure design of every step, where one needs to ensure favorable control and data flow on the GPU, while extracting enough parallel work for a massively parallel environment. In addition, the type of algorithm chosen for each step greatly influences the overall robustness of the solver. Thus, we extend the work on the parallel multiscale methods of Manea et al. (2016) to map the MSFV and MsRSB special kernels to the massively parallel GPU architecture. The scalability of our optimized parallel MSFV and MsRSB GPU implementations are demonstrated using highly heterogeneous structured 3D problems derived from the SPE10 Benchmark (Christie and Blunt 2001). Those problems range in size from millions to tens of millions of cells. For both solvers, the multicore implementations are benchmarked on a shared-memory multicore architecture consisting of two packages of Intel® Cascade Lake Xeon Gold 6246 central processing unit (CPU), whereas the GPU implementations are benchmarked on a massively parallel architecture consisting of NVIDIA Volta V100 GPUs. We compare the multicore implementations to the GPU implementations for both the setup and solution stages. Finally, we compare the parallel MsRSB scalability to the scalability of MSFV on the multicore (Manea et al. 2016) and GPU architectures. To the best of our knowledge, this is the first parallel implementation and demonstration of these versatile multiscale solvers on the GPU architecture. NOTE: This paper is also published as part of the 2021 SPE Reservoir Simulation Conference Special Issue.

A new entropy-variable-based discretization method for minimum entropy moment approximations of linear kinetic equations

In this contribution we derive and analyze a new numerical method for kinetic equations based on a variable transformation of the moment approximation. Classical minimum-entropy moment closures are a class of reduced models for kinetic equations that conserve many of the fundamental physical properties of solutions. However, their practical use is limited by their high computational cost, as an optimization problem has to be solved for every cell in the space-time grid. In addition, implementation of numerical solvers for these models is hampered by the fact that the optimization problems are only well-defined if the moment vectors stay within the realizable set. For the same reason, further reducing these models by, e.g., reduced-basis methods is not a simple task. Our new method overcomes these disadvantages of classical approaches. The transformation is performed on the semi-discretized level which makes them applicable to a wide range of kinetic schemes and replaces the nonlinear optimization problems by inversion of the positive-definite Hessian matrix. As a result, the new scheme gets rid of the realizability-related problems. Moreover, a discrete entropy law can be enforced by modifying the time stepping scheme. Our numerical experiments demonstrate that our new method is often several times faster than the standard optimization-based scheme.

Data-Oriented Language Implementation of the Lattice–Boltzmann Method for Dense and Sparse Geometries

The performance of lattice–Boltzmann solver implementations usually depends mainly on memory access patterns. Achieving high performance requires then complex code which handles careful data placement and ordering of memory transactions. In this work, we analyse the performance of an implementation based on a new approach called the data-oriented language, which allows the combination of complex memory access patterns with simple source code. As a use case, we present and provide the source code of a solver for D2Q9 lattice and show its performance on GTX Titan Xp GPU for dense and sparse geometries up to 40962 nodes. The obtained results are promising, around 1000 lines of code allowed us to achieve performance in the range of 0.6 to 0.7 of maximum theoretical memory bandwidth (over 2.5 and 5.0 GLUPS for double and single precision, respectively) for meshes of sizes above 10242 nodes, which is close to the current state-of-the-art. However, we also observed relatively high and sometimes difficult to predict overheads, especially for sparse data structures. The additional issue was also a rather long compilation, which extended the time of short simulations, and a lack of access to low-level optimisation mechanisms.

Thallo – Scheduling for High-Performance Large-Scale Non-Linear Least-Squares Solvers

Large-scale optimization problems at the core of many graphics, vision, and imaging applications are often implemented by hand in tedious and error-prone processes in order to achieve high performance (in particular on GPUs), despite recent developments in libraries and DSLs. At the same time, these hand-crafted solver implementations reveal that the key for high performance is a problem-specific schedule that enables efficient usage of the underlying hardware. In this work, we incorporate this insight into Thallo, a domain-specific language for large-scale non-linear least squares optimization problems. We observe various code reorganizations performed by implementers of high-performance solvers in the literature, and then define a set of basic operations that span these scheduling choices, thereby defining a large scheduling space. Users can either specify code transformations in a scheduling language or use an autoscheduler. Thallo takes as input a compact, shader-like representation of an energy function and a (potentially auto-generated) schedule, translating the combination into high-performance GPU solvers. Since Thallo can generate solvers from a large scheduling space, it can handle a large set of large-scale non-linear and non-smooth problems with various degrees of non-locality and compute-to-memory ratios, including diverse applications such as bundle adjustment, face blendshape fitting, and spatially-varying Poisson deconvolution, as seen in Figure 1. Abstracting schedules from the optimization, we outperform state-of-the-art GPU-based optimization DSLs by an average of 16× across all applications introduced in this work, and even some published hand-written GPU solvers by 30%+.