scholarly journals A Simple Parallel Solution Method for the Navier–Stokes Cahn–Hilliard Equations

Mathematics ◽  
2020 ◽  
Vol 8 (8) ◽  
pp. 1224
Author(s):  
Nadja Adam ◽  
Florian Franke ◽  
Sebastian Aland
Keyword(s):  
Message Passing ◽  
Message Passing Interface ◽  
Solution Method ◽  
Euler Method ◽  
Navier Stokes ◽  
Parallel Solution ◽  
Rising Bubble ◽  
Simple Implementation ◽  
Parallel Code ◽  
Pressure Projection

We present a discretization method of the Navier–Stokes Cahn–Hilliard equations which offers an impressing simplicity, making it easy to implement a scalable parallel code from scratch. The method is based on a special pressure projection scheme with incomplete pressure iterations. The resulting scheme admits solution by an explicit Euler method. Hence, all unknowns decouple, which enables a very simple implementation. This goes along with the opportunity of a straightforward parallelization, for example, by few lines of Open Multi-Processing (OpenMP) or Message Passing Interface (MPI) routines. Using a standard benchmark case of a rising bubble, we show that the method provides accurate results and good parallel scalability.

scholarly journals HPC simulations of brownout: A noninteracting particles dynamic model

2020 ◽  
Vol 34 (3) ◽  
pp. 267-281
Author(s):  
Roberto Porcù ◽  
Edie Miglio ◽  
Nicola Parolini ◽  
Mattia Penati ◽  
Noemi Vergopolan
Keyword(s):  
Message Passing ◽  
High Performance ◽  
Message Passing Interface ◽  
Graphics Processing Unit ◽  
Time Integration ◽  
Computational Cost ◽  
Aircraft Design ◽  
Euler Method ◽  
Processing Unit ◽  
Integration Algorithm

Helicopters can experience brownout when flying close to a dusty surface. The uplifting of dust in the air can remarkably restrict the pilot’s visibility area. Consequently, a brownout can disorient the pilot and lead to the helicopter collision against the ground. Given its risks, brownout has become a high-priority problem for civil and military operations. Proper helicopter design is thus critical, as it has a strong influence over the shape and density of the cloud of dust that forms when brownout occurs. A way forward to improve aircraft design against brownout is the use of particle simulations. For simulations to be accurate and comparable to the real phenomenon, billions of particles are required. However, using a large number of particles, serial simulations can be slow and too computationally expensive to be performed. In this work, we investigate an message passing interface (MPI) + graphics processing unit (multi-GPU) approach to simulate brownout. In specific, we use a semi-implicit Euler method to consider the particle dynamics in a Lagrangian way, and we adopt a precomputed aerodynamic field. Here, we do not include particle–particle collisions in the model; this allows for independent trajectories and effective model parallelization. To support our methodology, we provide a speedup analysis of the parallelization concerning the serial and pure-MPI simulations. The results show (i) very high speedups of the MPI + multi-GPU implementation with respect to the serial and pure-MPI ones, (ii) excellent weak and strong scalability properties of the implemented time-integration algorithm, and (iii) the possibility to run realistic simulations of brownout with billions of particles at a relatively small computational cost. This work paves the way toward more realistic brownout simulations, and it highlights the potential of high-performance computing for aiding and advancing aircraft design for brownout mitigation.

scholarly journals Asynchronous Parallelization of a CFD Solver

2015 ◽  
Vol 2015 ◽  
pp. 1-10 ◽  
Author(s):  
Daniel S. Abdi ◽  
Girma T. Bitsuamlak
Keyword(s):  
Message Passing ◽  
Message Passing Interface ◽  
Stokes Equations ◽  
Domain Decomposition Method ◽  
Asynchronous Communication ◽  
Navier Stokes ◽  
Navier Stokes Equations ◽  
Asynchronous Iterations ◽  
Alternative Approach ◽  
Asynchronous Methods

A Navier-Stokes equations solver is parallelized to run on a cluster of computers using the domain decomposition method. Two approaches of communication and computation are investigated, namely, synchronous and asynchronous methods. Asynchronous communication between subdomains is not commonly used in CFD codes; however, it has a potential to alleviate scaling bottlenecks incurred due to processors having to wait for each other at designated synchronization points. A common way to avoid this idle time is to overlap asynchronous communication with computation. For this to work, however, there must be something useful and independent a processor can do while waiting for messages to arrive. We investigate an alternative approach of computation, namely, conducting asynchronous iterations to improve local subdomain solution while communication is in progress. An in-house CFD code is parallelized using message passing interface (MPI), and scalability tests are conducted that suggest asynchronous iterations are a viable way of parallelizing CFD code.

Vortex core identification in viscous hydrodynamics

2005 ◽  
Vol 363 (1833) ◽  
pp. 1937-1948 ◽  
Author(s):  
Lucas I Finn ◽  
Bruce M Boghosian ◽  
Christopher N Kottke
Keyword(s):  
Software Package ◽  
Message Passing ◽  
Message Passing Interface ◽  
Stokes Equations ◽  
Navier Stokes ◽  
Computational Steering ◽  
Navier Stokes Equations ◽  
Viscous Hydrodynamics ◽  
Knots And Links ◽  
User Intervention

We describe a software package designed for the investigation of topological fluid dynamics with a novel algorithm for locating and tracking vortex cores. The package is equipped with modules for generating desired vortex knots and links and evolving them according to the Navier–Stokes equations, while tracking and visualizing them. The package is parallelized using a message passing interface for a multiprocessor environment and makes use of a computational steering library for dynamic user intervention.

Evaluation of a Parallel Agglomeration Multigrid Finite-Volume Algorithm, Named Galatea-I, for the Simulation of Incompressible Flows on 3D Hybrid Unstructured Grids

2014 ◽  
Author(s):  
Sotirios S. Sarakinos ◽  
Georgios N. Lygidakis ◽  
Ioannis K. Nikolos
Keyword(s):  
Finite Volume ◽  
Message Passing ◽  
Data Exchange ◽  
Message Passing Interface ◽  
Incompressible Flows ◽  
Navier Stokes ◽  
Finite Volume Scheme ◽  
Computational Domain ◽  
Naca0012 Airfoil ◽  
Computational Performance

In this study an academic Computational Fluid Dynamics (CFD) code, named Galatea-I, is described, which employs the Reynolds Averaged Navier–Stokes (RANS) equations along with the artificial compressibility method and the SST (Shear Stress Transport) turbulence model for the prediction of incompressible viscous flows. For the representation of the computational domain unstructured hybrid grids are utilized, composed of tetrahedral, prismatic and pyramidical elements, while for its discretization a node-centered finite-volume scheme is implemented. Galatea-I is enhanced with a parallelization method, which employs spatial domain decomposition, while the data exchange between processors/processes is performed with the use of the Message Passing Interface (MPI) protocol. In addition, a parallel agglomeration multigrid methodology has been incorporated to improve further its computational performance. The proposed code is validated against steady-state flow benchmark test cases, concerning laminar flow over a cubic cavity and a cylindrical surface, as well as turbulent flow over a rectangular wing with a NACA0012 airfoil. The obtained results, compared with these of corresponding reference solvers, reveal Galatea-I’s potential for simulation of inviscid, viscous laminar and turbulent incompressible flows.

Numerical Solution of 2-D Water Entry Problems Based on a CIP Method and a Parallel Computing Algorithm

2015 ◽  
Author(s):  
Peng Wen ◽  
Wei Qiu
Keyword(s):  
Parallel Computing ◽  
Message Passing ◽  
Message Passing Interface ◽  
Water Entry ◽  
Navier Stokes ◽  
Cip Method ◽  
Constrained Interpolation ◽  
Decomposition Scheme ◽  
Computing Algorithm ◽  
Speed Up

A constrained interpolation profile (CIP) method has been developed to solve 2-D water entry problems. This paper presents the further development of the numerical method using staggered grids and a parallel computing algorithm. In this work, the multi-phase slamming problems, governed by the Navier-Stokes (N-S) equations, are solved by a CIP-based finite difference method. The interfaces between different phases (solid, water and air) are captured using density functions. A parallel computing algorithm based on the Message Passing Interface (MPI) method and the domain decomposition scheme was implemented to speed up the computations. The effect of decomposition scheme on the solution and the speed-up were studied. Validation studies were carried out for the water entry of various 2-D wedges and a ship section. The predicted slamming force, pressure distribution and free surface elevation are compared with experimental results and other numerical results.

scholarly journals MPI to Coarray Fortran: Experiences with a CFD Solver for Unstructured Meshes

2017 ◽  
Vol 2017 ◽  
pp. 1-12 ◽  
Author(s):  
Anuj Sharma ◽  
Irene Moulitsas
Keyword(s):  
High Resolution ◽  
Message Passing ◽  
Message Passing Interface ◽  
Parallel Implementation ◽  
Unstructured Meshes ◽  
Navier Stokes ◽  
Performance Measurements ◽  
Partitioned Global Address Space ◽  
Computational Fluid Dynamics Cfd ◽  
And Performance

High-resolution numerical methods and unstructured meshes are required in many applications of Computational Fluid Dynamics (CFD). These methods are quite computationally expensive and hence benefit from being parallelized. Message Passing Interface (MPI) has been utilized traditionally as a parallelization strategy. However, the inherent complexity of MPI contributes further to the existing complexity of the CFD scientific codes. The Partitioned Global Address Space (PGAS) parallelization paradigm was introduced in an attempt to improve the clarity of the parallel implementation. We present our experiences of converting an unstructured high-resolution compressible Navier-Stokes CFD solver from MPI to PGAS Coarray Fortran. We present the challenges, methodology, and performance measurements of our approach using Coarray Fortran. With the Cray compiler, we observe Coarray Fortran as a viable alternative to MPI. We are hopeful that Intel and open-source implementations could be utilized in the future.

Reynolds-Averaged Navier-Stokes Simulations for High-Speed Wigley Hull in Deep and Shallow Water

2007 ◽  
Vol 51 (03) ◽  
pp. 187-203
Author(s):  
Nobuaki Sakamoto ◽  
Robert Vance Wilson ◽  
Frederick Stern
Keyword(s):  
Shallow Water ◽  
Message Passing ◽  
High Speed ◽  
High Performance ◽  
Message Passing Interface ◽  
Iterative Solvers ◽  
Verification And Validation ◽  
Navier Stokes ◽  
Wigley Hull ◽  
Reynolds Averaged Navier Stokes

Reynolds-averaged Navier-Stokes simulations and verification and validation studies for a high-speed Wigley hull in deep and shallow water are presented using CFD-SHIP-IOWA Version 4.00, which is a general-purpose ship hydrodynamics computational fluid dynamics code: single-phase level set free surface and k-w turbulence modeling; higher-order conservative discretization, embedded overset grids, advanced iterative solvers, and implicit coupling flow field and predicted motions numerical methods; and high-performance computing for message-passing interface (MPI)-based domain decomposition. The results are presented for low to high speed and deep to shallow water. The investigation is exploratory in nature using an idealized geometry and relatively coarse grids. Based on the verification and validation results, modifications for increased grid resolution at the bow for high speed and improved grid orthogonality for shallow water are made to obtain better solutions. The flow physics observations provide both integral and differential views of the highspeed and shallow-water flow fields, including resistance, pressure variation, wave pattern, boundary layer, and vortices.

Parallel Speed-Up of Preconditioned Fractional Step Navier-Stokes Solvers

2014 ◽  
Vol 493 ◽  
pp. 215-220
Author(s):  
Vivien Djanali ◽  
Steven W. Armfield ◽  
Michael P. Kirkpatrick ◽  
Stuart Norris
Keyword(s):  
Message Passing ◽  
Message Passing Interface ◽  
Navier Stokes ◽  
Fractional Step ◽  
Computational Domain ◽  
Step Method ◽  
Fractional Step Method ◽  
Pressure Poisson Equation ◽  
Approximate Inverses ◽  
Speed Up

Parallel performance of a fractional step Navier-Stokes solver is investigated. Parallelisation is performed using Message Passing Interface, with domain partitioning. Block preconditioning is applied to the solution of the pressure Poisson equation, which is often the bottleneck in the computation of the fractional step method. Preconditioners tested are classes of incomplete matrix decompositions and sparse approximate inverses. The computational domain is decomposed into eight parts of about equal size in terms of the number of cells, and solved on eight parallel processors. Several aspects of the parallelisation, such as domain splitting directions, speed-up and scalability of the preconditioners, are discussed.

scholarly journals Development of a Parallel 3D Navier–Stokes Solver for Sediment Transport Calculations in Channels

Computation ◽  
2020 ◽  
Vol 8 (4) ◽  
pp. 84
Author(s):  
Gokhan Kirkil
Keyword(s):  
Sediment Transport ◽  
Message Passing ◽  
Message Passing Interface ◽  
Curvilinear Coordinates ◽  
Staggered Grid ◽  
Navier Stokes ◽  
Step Method ◽  
Fractional Step Method ◽  
Fully Implicit ◽  
Parallel Version

We propose a method to parallelize a 3D incompressible Navier–Stokes solver that uses a fully implicit fractional-step method to simulate sediment transport in prismatic channels. The governing equations are transformed into generalized curvilinear coordinates on a non-staggered grid. To develop a parallel version of the code that can run on various platforms, in particular on PC clusters, it was decided to parallelize the code using Message Passing Interface (MPI) which is one of the most flexible parallel programming libraries. Code parallelization is accomplished by “message passing” whereby the computer explicitly uses library calls to accomplish communication between the individual processors of the machine (e.g., PC cluster). As a part of the parallelization effort, besides the Navier–Stokes solver, the deformable bed module used in simulations with loose beds are also parallelized. The flow, sediment transport, and bathymetry at equilibrium conditions were computed with the parallel and serial versions of the code for the case of a 140-degree curved channel bend of rectangular section. The parallel simulation conducted on eight processors gives exactly the same results as the serial solver. The parallel version of the solver showed good scalability.

Multi-level Parallelization of Genotype Imputation on Supercomputers

2020 ◽  
Vol 15 ◽  
Author(s):  
Weiwen Zhang ◽  
Long Wang ◽  
Theint Theint Aye ◽  
Juniarto Samsudin ◽  
Yongqing Zhu
Keyword(s):  
Association Study ◽  
Message Passing ◽  
High Performance ◽  
Message Passing Interface ◽  
Genome Wide Association Study ◽  
Job Scheduling ◽  
Genotype Imputation ◽  
Job Level ◽  
Multi Level ◽  
High Performance Requirement

Background: Genotype imputation as a service is developed to enable researchers to estimate genotypes on haplotyped data without performing whole genome sequencing. However, genotype imputation is computation intensive and thus it remains a challenge to satisfy the high performance requirement of genome wide association study (GWAS). Objective: In this paper, we propose a high performance computing solution for genotype imputation on supercomputers to enhance its execution performance. Method: We design and implement a multi-level parallelization that includes job level, process level and thread level parallelization, enabled by job scheduling management, message passing interface (MPI) and OpenMP, respectively. It involves job distribution, chunk partition and execution, parallelized iteration for imputation and data concatenation. Due to the design of multi-level parallelization, we can exploit the multi-machine/multi-core architecture to improve the performance of genotype imputation. Results: Experiment results show that our proposed method can outperform the Hadoop-based implementation of genotype imputation. Moreover, we conduct the experiments on supercomputers to evaluate the performance of the proposed method. The evaluation shows that it can significantly shorten the execution time, thus improving the performance for genotype imputation. Conclusion: The proposed multi-level parallelization, when deployed as an imputation as a service, will facilitate bioinformatics researchers in Singapore to conduct genotype imputation and enhance the association study.

Sign in / Sign up

Export Citation Format

Share Document