Search

Detailed radiation analysis of instruments flown in space is critical to ensure mission safety, often requiring the use of state-of-the-art particle transport simulation tools. Geant4 is one of the most powerful toolkits to simulate the interaction and the passage of particles through matter, but it is not prepared to receive Standard for The Exchange of Product data (STEP) files, the most versatile Computer-Aided Design (CAD) format, as input, requiring previous conversion to other CAD formats. This may lead to loss of detail and under or overestimation of the quantities under study, especially when the instruments have complex shapes, and/or a large number of volumes. Though several solutions have been proposed to import complex geometries from STEP files into Geant4, so far, only commercial options are available. In this paper we present a new tool, GUIMesh, that embeds FreeCAD libraries, an open-source CAD editor, to tessellate volumes, and convert them to Geometry Description Markup Language (GDML), a Geant4 readable format, in a straightforward way. Several degrees of freedom are given to the user regarding mesh precision and choice of material. Different geometries were tested for material definition, geometry and navigation errors, and the method used was successfully validated. Program Title : GUIMesh Program Files doi : http://dx.doi.org/10.17632/c3c9xbspzp.1 Licensing provisions : GNU General Public License 3 (GPLv3) Programming language : Python Nature of problem : No open-source software allows to import STEP geometries intro Geant4, one of the most powerful toolkits to simulate radiation interaction with matter. Since CAD software is extensively used in the design of particle and radiation detection instruments, it is highly desirable for physicists that STEP geometries can be imported to Geant4 with little effort instead of having to code structures made of a very large number of solid volumes which are difficult to accurately reproduce with Geant4 C++ classes. Solution method : STEP geometries are converted to tessellated volumes (with some margin of error) using FreeCAD libraries. A Python script then writes GDML files based on the results allowing users to import these geometries with Geant4. A graphical user interface provides several options to the user, including material assignment and mesh precision setting for each volume. [ABSTRACT FROM AUTHOR]

This paper describes the main features of a pioneering unsteady solver for simulating ideal two-fluid plasmas on unstructured grids, taking profit of GPGPU (General-purpose computing on graphics processing units). The code, which has been implemented within the open source COOLFluiD platform, is implicit, second-order in time and space, relying upon a Finite Volume method for the spatial discretization and a three-point backward Euler for the time integration. In particular, the convective fluxes are computed by a multi-fluid version of the AUSM+up scheme for the plasma equations, in combination with a modified Rusanov scheme with tunable dissipation for the Maxwell equations. Source terms are integrated with a one-point rule, using the cell-centered value. Some critical aspects of the porting to GPU's are discussed, as well as the performance of two open source linear system solvers (i.e. PETSc, PARALUTION). The code design allows for computing both flux and source terms on the GPU along with their Jacobian, giving a noticeable decrease in the computational time in comparison with the original CPU-based solver. The code has been tested in a wide range of mesh sizes and in three different systems, each one with a different GPU. The increased performance (up to 14x) is demonstrated in two representative 2D benchmarks: propagation of circularly polarized waves and the more challenging Geospace Environmental Modeling (GEM) magnetic reconnection challenge. [ABSTRACT FROM AUTHOR]

Magnetic quadrupoles are essential components of particle accelerators like the Large Hadron Collider. In order to study numerically the stability of the particle beam crossing a quadrupole, a large number of particle revolutions in the accelerator must be simulated. This requires to preserve numerically invariants of motion over a long time interval and entails a substantial computational cost, mostly related to the repeated evaluation of the magnetic vector potential. In this paper, in order to reduce this cost, we first consider a specific gauge transformation that allows to reduce significantly the number of vector potential evaluations. We then analyse the sensitivity of the numerical solution to the interpolation procedure required to compute magnetic vector potential data from gridded precomputed values at the locations required by high order time integration methods. Finally, we compare several high order integration techniques, in order to assess their accuracy and efficiency for these long term simulations. Explicit high order Lie methods are considered, along with implicit high order symplectic integrators and conventional explicit Runge–Kutta methods. Among symplectic methods, high order Lie integrators yield optimal results in terms of cost/accuracy ratios, but non-symplectic Runge–Kutta methods perform remarkably well even in very long term simulations. Furthermore, the accuracy of the field reconstruction and interpolation techniques appears to be the limiting factors for the accuracy of the particle tracking procedures. [ABSTRACT FROM AUTHOR]

FermiSurfer is a newly developed Fermi-surface viewer designed to facilitate the understanding of the physical properties of metals. It can display the Fermi surfaces of a material, color plots of arbitrary k -dependent quantities, the Fermi surface at arbitrary cross sections (Fermi lines), cross- or parallel-eye three-dimensional stereogram views, nodal lines, extremal orbits, and highlight the occupied or empty side of the Fermi surface. In addition, various first-principles software packages can produce input for FermiSurfer. This paper explains how to use FermiSurfer and demonstrates its usefulness by investigating the origin of the anisotropic superconductivity of YNi 2 B 2 C. Program Title: FermiSurfer Program Files doi: http://dx.doi.org/10.17632/36992zhpvk.1 Licensing provisions: MIT Programming language: C Nature of problem: The anisotropy of quantities on Fermi surfaces (the character of orbitals, etc.) strongly affects electronic properties, such as superconductivity or thermoelectricity, in metals. Observing the anisotropy, however, remains difficult. Thus, a graphical tool that can elucidate how quantities vary over complicated Fermi surfaces is highly desirable. Solution method: FermiSurfer uses the tetrahedron method to compute Fermi surfaces. The French-curve interpolation is used to display smooth Fermi surfaces. Additional comments including restrictions and unusual features : The parallel- and cross-eye stereograms are available to enhance the visibility of complicated Fermi surfaces. This program works on any operating system, such as Linux, UNIX, macOS, and Windows, in which OpenGL library is installed. [ABSTRACT FROM AUTHOR]

In this paper we develop a Lagrangian Inertial Centroidal Voronoi Particle (LICVP) method to extend the original CVP method (Fu et al., 2017) to dynamic load balancing in particle-based simulations. Two new concepts are proposed to address the additional problems encountered in repartitioning the system. First, a background velocity is introduced to transport Voronoi particles according to the local fluid field, which facilitates data reuse and lower data redistribution cost during rebalancing. Second, in order to handle problems with skew-aligned computational load and large void space, we develop an inertial-based partitioning strategy, where the inertial matrix is utilized to characterize the load distribution, and to confine the motion of Voronoi particles dynamically adapting to the physical simulation. Intensive numerical tests in fluid dynamics simulations reveal that the underlying LICVP method improves the incremental property remarkably without sacrifices on other objectives, i.e. the inter-processor communication is optimized simultaneously, and the repartitioning procedure is highly efficient. [ABSTRACT FROM AUTHOR]

In this paper, the effects of interpolation methodology on the accuracy of computed solutions are discussed in the context of unstructured overset grids. An in-house implementation of the overset method for OpenFOAM, OPERA (Chandar, 2015; Chandar et al., 2015) has been used. Several verification and validation studies reported previously used a simple interpolation technique such as inverse distance weighting and this was found to be adequate for prediction of forces. For closed problems however, the force history is plagued with unphysical oscillations. Also, a quantitative assessment of interpolation errors is lacking. The current work aims to understand the effects of interpolation error on conservation and how this error can be minimized by enforcing flux correction and/or better interpolation techniques. Apart from enforcing conservation, the pressure equation needs to be adjusted as well in an implicit manner to guarantee the transfer of fluxes correctly between overlapping regions. Importance of conservation and higher order interpolation are also discussed in the context of multiphase flows. [ABSTRACT FROM AUTHOR]

Understanding the dependency between plasma turbulence and overall transport is essential in predicting the performance of fusion devices. This dependency is not fully understood because of the highly disparate spatio-temporal scales involved, which prohibits a fully-resolved turbulence simulation at transport scales. The Computer Patterns for High Performance Multiscale Computing (ComPat) project takes the component based approach for multiscale simulations to connect existing single-scale models into a workflow. In this paper, we present the ComPat's approach in building a multiscale fusion application: it brings equilibrium, transport and turbulence models together, where the turbulence is described by a 3D gyrofluid code. Initial results and challenges encountered with such approach are also presented and discussed. One of the challenges is to ensure numerical stability, for which adaptive time step size and the search for quasi-steady state are implemented as possible solutions. Another challenge is to improve the overall performance of multiscale simulation, and that is addressed by increasing the level of parallelism to the workflow. [ABSTRACT FROM AUTHOR]

Abstract Atomistic modeling of nanostructures such as quantum dots or nanowires often involves numbers of atoms reaching and even exceeding well beyond 1 million. Such a large quantity of atoms presents a very complex computational challenge especially at a stage of many-body calculation where numerous Coulomb matrix elements need to be calculated. Here we present a practical solution to this problem by performing calculations in the momentum space and utilizing fast Fourier transform combined with a memory-efficient way to compute the convolution that overcomes the problem of spurious interactions with quasi-charges from other super-cells. Finally, calculation of multiple integrals is optimized by reducing the problem to finding a minimum vertex cover of a graph. All these algorithms are implemented and presented here in a self-contained and highly parallelized computer program named Coulombo. Coulombo demonstrates quasi-linear scaling of computational time of Coulomb matrix elements with respect to the number of points in the computational box and, at the same time, significantly reduced memory demand. The proposed solution can have potential applications not only in the realm of nano-physics, but could be applied to other mesoscopic simulations or large-scale quantum chemistry problems. Program summary Program Title: Coulombo Program Files doi: http://dx.doi.org/10.17632/98bhm5zbrd.1 Licensing provisions: CC BY 4.0 Programming language: C++ Nature of problem: Computing the Coulomb matrix elements (Coulomb and exchange integrals), while being a demanding computational task, is a necessary step in a range of quantum mechanical calculations. For example, in the field of nanostructures, such as quantum dots and nanowires, this stage of calculation even after numerous approximations is at least an O (N 2) operation (a summation over all pairs of N atoms or grid points in the analyzed system). Moreover, calculating the full Coulomb matrix usually requires computation of thousands of such elements, thus presenting a formidable computational challenge. Solution method: We provide a ready-to-use implementation for calculating Coulomb matrix elements for a given set of input wavefunctions. This implementation is based on the approach introduced in [1], by using a fast Fourier transform to compute the convolution. In this work we further significantly improved the method by eliminating the need to extend the computational domain with padding, thus reducing the memory consumption by a factor of 8. The optimal computational plan for each run is prepared by calculating a minimum vertex cover on a graph representing the subset of requested Coulomb matrix elements. Additional comments including restrictions and unusual features: The implementation is fully parallelized in a distributed-memory model, using MPI and parallel routines from FFTW [2]. A minimum vertex cover is computed by our greedy approximation algorithm, which we found to perform significantly better than the standard text-book heuristic. References: [1] P. T. Różański & M. Zieliński, "Linear scaling approach for atomistic calculation of excitonic properties of 10-million-atom nanostructures", Phys. Rev. B 94 (2016) 045440 [2] M. Frigo & Steven G. Johnson, "The Design and Implementation of FFTW3", Proceedings of the IEEE 93 (2), 216–231 (2005), Invited paper, Special Issue on Program Generation, Optimization, and Platform Adaptation [ABSTRACT FROM AUTHOR]

Abstract The finite-element time-domain method for elastic band-structure calculations is presented in this paper. The method is based on discretizing the appropriate equations of motion by finite elements, applying Bloch boundary conditions to reduce the analysis to a single unit cell, and conducting a simulation using a standard time-integration scheme. The unit cell is excited by a wide-band frequency signal designed to enable a large number of modes to be identified from the time-history response. By spanning the desired wave-vector space within the Brillouin zone, the band structure is then robustly generated. Bloch mode shapes are computed using the well-known concept of modal analysis, especially as implemented in an experimental setting. The performance of the method is analyzed in terms of accuracy, convergence, and computation time, and is compared to the finite-difference time-domain method as well as to a direct finite-element (FE) solution of the corresponding eigenvalue problem. The proposed method is advantageous over FD-based methods for unit cells with complex geometries, and over direct FE in situations where the formulation of an eigenvalue problem is not straightforward. For example, the new method makes it possible to accurately solve a time-dependent Bloch problem, such as the case of a complex unit cell model of a topological insulator where an internal fluid flow or other externally controlled physical fields are present. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we consider numerical approximations for the anisotropic Cahn–Hilliard equation. We develop two linear and second-order schemes that combine the IEQ approach with the stabilization technique, where several extra linear stabilization terms are added in and they can be shown to be crucial to suppress the non-physical spatial oscillations caused by the strong anisotropy. We show the well-posedness of the resulting linear systems and further prove their corresponding unconditional energy stabilities rigorously. Various 2D and 3D numerical simulations are presented to demonstrate the stability, accuracy, and efficiency of the proposed schemes. [ABSTRACT FROM AUTHOR]

Abstract Anisotropic ideal strength is a fundamental and important plasticity parameter in scaling the intrinsic strength of strong crystalline materials, and is a potential descriptor in searching and designing novel hard/superhard materials. However, to the best of our knowledge, an automatic derivation of anisotropic ideal strength has not been implemented in any open-source code available so far. In this paper, we present our developed ADAIS code, an automatic derivation of anisotropic ideal strength via high-throughput first-principles computations for both three-dimensional and two-dimensional crystalline materials with any symmetry, as well as for an ideal interface model. Several fundamental mechanical quantities can be automatically derived, including ideal tensile and shear strengths through affine deformation, universal binding energy and generalized stacking fault energy, as well as the ideal cleavage and slide stresses through alias deformation. The implementation of this code has been comprehensively demonstrated and critically validated by a lot of evaluations and tests of various crystalline materials with different symmetry, indicating that our code could provide a high-efficiency solution to quantify the strength of strong solids. Program summary Program title: ADAIS Program Files doi: http://dx.doi.org/10.17632/336hry5g66.1 Licensing provisions: BSD 3-Clause Programming language: Fortran90 Nature of problem: A scheme adapted to high-throughput first-principles computations is much necessary to automatically determine the anisotropic ideal strength along any crystallographic orientation under affine and alias deformations for crystalline solids with any symmetry. Solution method: To derive the ideal strength of a crystalline solid along a specific crystallographic orientation, a projection and/or redefinition of a lattice are firstly performed. The affine (alias) deformation is then applied to the projected (redefined) lattice, and a relaxation is done on the distorted structure by the simply modified VASP code optimizer with certain cell constraints. Afterwards, the resultant total energies and stresses vs strain are generated accordingly. Finally, the anisotropic ideal strengths are derived from the calculated stress/energy–strain relationship, and meanwhile the variation of bond length as a function of strain is revealed to illustrate the failure mode. Whenever an unexpected error happens, a message will be printed for further evaluation. [ABSTRACT FROM AUTHOR]

Abstract The paper presents a modification of the so-called adding probability used in the Monte Carlo cluster algorithms. Certainly, the probability formula was supplemented by an entropy factor, depending on the local disorder of some selected properties of the studied system. The idea bases on the fact that disorder of some physical properties may affect clusterization of the system. The proposed modification enhances effectiveness of the simulations that is especially important in analysis of magnetization processes of irregular multiphase systems. In order to prove correctness of our approach a set of reverse magnetization curves was simulated for the systems composed of magnetically hard and soft phases. [ABSTRACT FROM AUTHOR]

Abstract In the interior of neutron stars, the induction equation regulates the long-term evolution of the magnetic fields by means of resistivity, Hall dynamics and ambipolar diffusion. Despite the apparent simplicity and compactness of the equation, the dynamics it describes is not trivial and its understanding relies on accurate numerical simulations. While a few works in 2D have reached a mature stage and a consensus on the general dynamics at least for some simple initial data, only few attempts have been performed in 3D, due to the computational costs and the need for a proper numerical treatment of the intrinsic non-linearity of the equation. Here, we carefully analyze the general induction equation, studying its characteristic structure, and we present a new Cartesian 3D code, generated by the user-friendly, publicly available Simflowny platform. The code uses high-order numerical schemes for the time and spatial discretization, and relies on the highly-scalable SAMRAI architecture for the adaptive mesh refinement. We present the application of the code to several benchmark tests, showing the high order of convergence and accuracy achieved and the capabilities in terms of magnetic shock resolution and three-dimensionality. This paper paves the way for the applications to a realistic, 3D long-term evolution of neutron stars interior and, possibly, of other astrophysical sources. [ABSTRACT FROM AUTHOR]

Abstract Flame simulations are used to gain insight into combustion physics and to design combustion systems such as piston engines, gas–turbine engines, and process heaters. In these simulations, the balance between reaction and molecular mixing plays a key role. To model molecular mixing, using a full multicomponent approach leads to high accuracy at the expense of a hefty computational cost. Thus, the use of a mixture-averaged model is usually preferred. Hence, this paper presents and tests a new OpenFOAM®-based code that incorporates a detailed, mixture-averaged approach for calculating transport properties in reacting flows, and provides a capability to solve either fully-compressible or low-Mach-number governing equations. The code is made readily available on GitHub and is written completely in OpenFOAM®'s native code framework, making it highly portable and easy to maintain, enhance, and extend. It is tested by modeling two laminar flames, and two turbulent flames undergoing extinction and reignition. Overall, predictions with the present code are seen to be in good agreement with experimental and direct-numerical-simulation data. Program Summary Program Title: laminarReactingFoam &laminarReactingLMFoam Program Files doi: http://dx.doi.org/10.17632/h8hch3hs9p.1 Licensing provisions: GPLv3 Programming language: C++. Nature of problem: In high-resolution flame simulations it is important to calculate the transport properties without using simplified models in order to capture the physics of the problem. Assumptions such as unity Lewis number do not always provide an accurate answer, and in some cases may not be able to capture some of the relevant physics. Solution method: The present code adds the functionality to calculate the transport properties of the gas mixture using a detailed, mixture-averaged formulation. [ABSTRACT FROM AUTHOR]

Abstract In this paper, a predictor–corrector symmetric TVD scheme for nonlinear conservation laws is presented. The scheme does not necessitate the characteristic decomposition of the usual TVD schemes and employs component-wise limiting. We design two kinds of high accuracy flux limiters, obtain the TVD bounds and propose a hybrid approach. Then we apply it to solve magnetogasdynamic flow equations. A variety of test cases are provided, which are designed to test the robustness of the scheme and compare the results of both analytical and numerical results. According to the results, the new predictor–corrector symmetric TVD scheme is more accurate than two-step, component-wise TVD scheme (Yu and Liu, 2001) and explicit predictor–corrector TVD scheme (Xiaohua, 1990). [ABSTRACT FROM AUTHOR]

Abstract A MATLAB function GCforce is presented for the calculation of gradient and scattering parts of optical force (OF). The decomposition of OF into the gradient and scattering parts, or, equivalently, the conservative and nonconservative components, is of great importance to the physical understanding of optical micromanipulation. In this paper, we propose a formulation to decompose the OF acting on a spherical particle immersed in an arbitrary monochromatic optical field, based on the generalized Lorenz–Mietheory and the Cartesian multipole expansion approach. The expressions for the gradient and scattering forces are given explicitly in terms of the partial wave expansion coefficients of the optical field shining on the particle and the Mie coefficients of the particle. A MATLAB function GCforce.m is also presented for the calculation. The explicit and rigorous decomposition of the OF into conservative and nonconservative forces sheds light on the understanding of light–matter interaction as well as contributes significantly to the designing of optical fields to achieve various optical micromanipulation. Program summary Program Title: GCforce Program Files doi: http://dx.doi.org/10.17632/9ytk7bv3md.1 Licensing provisions: GPLv3 Programming language: MATLAB Nature of problem: Decomposition of optical force acting on an isotropic spherical particle of size comparable to optical wave length into conservative (gradient) and nonconservative (scattering) components. Solution method: By deriving the explicit expressions for computing the optical gradient force and scattering force exerting on the particle in terms of the partial wave expansion coefficients of the incident monochromatic optical field. [ABSTRACT FROM AUTHOR]

Abstract Supercomputer power has been doubling approximately every 14 months for several decades, increasing the capabilities of scientific modelling at a similar rate. However, to utilize these machines effectively for applications such as computational fluid dynamics, improvements to strong scalability are required. Here, the particular focus is on semi-implicit, viscous-flow CFD, where the largest bottleneck to strong scalability is the parallel solution of the linear pressure-correction equation — an elliptic Poisson equation. State-of-the-art linear solvers, such as Krylov subspace or multigrid methods, provide excellent numerical performance for elliptic equations, but do not scale efficiently due to frequent synchronization between processes. Complete desynchronization is possible for basic, Jacobi-like solvers using the theory of 'chaotic relaxations'. These non-deterministic, chaotic solvers scale superbly, as demonstrated herein, but lack the numerical performance to converge elliptic equations — even with the relatively lax convergence requirements of the example CFD application. However, these chaotic principles can also be applied to multigrid solvers. In this paper, a 'chaotic-cycle' algebraic multigrid method is described and implemented as an open-source library. It is tested on a model Poisson equation, and also within the context of CFD. Two CFD test cases are used: the canonical lid-driven cavity flow and the flow simulation of a ship (KVLCC2). The chaotic-cycle multigrid shows good scalability and numerical performance compared to classical V-, W- and F-cycles. On 2048 cores the chaotic-cycle multigrid solver performs up to 7. 7 × faster than Flexible-GMRES and 13. 3 × faster than classical V-cycle multigrid. Further improvements to chaotic-cycle multigrid can be made, relating to coarse-grid communications and desynchronized residual computations. It is expected that the chaotic-cycle multigrid could be applied to other scientific fields, wherever a scalable elliptic-equation solver is required. [ABSTRACT FROM AUTHOR]

Abstract This paper presents a numerical technique to model soft particle materials in which the particles can undergo large deformations. It combines an implicit finite strain formalism of the Material Point Method and the Contact Dynamics method. In this framework, the large deformations of individual particles as well as their collective interactions are treated consistently. In order to reduce the computational cost, this method is parallelised using the Message Passing Interface (MPI) strategy. Using this approach, we investigate the uniaxial compaction of 2D packings composed of particles governed by a Neo-Hookean material behaviour. We consider compressibility rates ranging from fully compressible to incompressible particles. The packing deformation mechanism is a combination of both particle rearrangements and large deformations, and leads to high packing fractions beyond the jamming state. We show that the packing strength declines when the particle compressibility decreases, and the packing can deform considerably. We also discuss the evolution of the connectivity of the particles and particle deformation distributions in the packing. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we describe parallel domain decomposition methods based on the restricted additive Schwarz (RAS) method for a quantum-corrected drift–diffusion (QCDD) model for MOSFET devices. We have developed hybrid Message Passing Interface (MPI)/OpenMP parallelization algorithms of the QCDD system. For internode parallelization, two extensions of the RAS method are newly developed for the QCDD model. For intranode parallelization, we combine the conjugate gradient (CG) and BiCGSTAB procedures with a splitting-up operator method to realize parallelization of the incomplete factorization. The parallel numerical results for a three-dimensional Si bulk n-MOSFET on a multi-core NEC SX-ACE parallel computer are demonstrated. The intranode parallel numerical results are further evaluated on a many-core Cray XC40 parallel computer. [ABSTRACT FROM AUTHOR]

Abstract Based on the previously developed Energy Conserving Semi Implicit Method (ECsim) code, we present its cylindrical implementation, called ECsim-CYL, to be used for axially symmetric problems. The main motivation for the development of the cylindrical version is to greatly improve the computational speed by utilizing cylindrical symmetry. The ECsim-CYL discretizes the field equations in two-dimensional cylindrical coordinates using the finite volume method. For the particle mover, it uses a modification of ECsim's mover for cylindrical coordinates by keeping track of all three components of velocity vectors, while only keeping radial and axial coordinates of particle positions. In this paper, we describe the details of the algorithm used in the ECsim-CYL and present a series of tests to validate the accuracy of the code including a wave spectrum in a homogeneous plasma inside a cylindrical waveguide and free expansion of a spherical plasma ball in vacuum. The ECsim-CYL retains the stability properties of ECsim and conserves the energy within machine precision, while accurately describing the plasma behavior in the test cases. [ABSTRACT FROM AUTHOR]

Abstract Both collisionless and collisional Landau fluid (LF) closure have been developed and implemented in two-fluid plasma simulation framework BOUT++, taking full advantage of the fast non-Fourier method (Dimits, 2014). The spectral range of good fit can be conveniently extended to larger domain by adding more Lorentzians. The scaling for upper limit of wavenumber resolved in collisionless LF operator and the fitting coefficients for the collisional LF operator, the later is extended to weakly collisional regime (ν e ∗ ∼ 0. 01), are presented in this paper. The flux limited expression q ∥ e FL is reduced to free streaming expression q ∥ e FS in collisionless limit and gives classical Spitzer–Härm result q ∥ e SH in collisional limit as we expected. The collisional LF closure recovers the classical Spitzer–Härm result q ∥ e SH in collisional limit and is same as the collisionless LF closure in collisionless limit. The test cases also obviously demonstrate the nonlocal effects from LF closures and responding to different boundary conditions in open surface region. This work will make it more applicable and possible to include the Landau damping kinetic effect in the fluid simulation of tokamak plasma. [ABSTRACT FROM AUTHOR]

Abstract In the present paper, we present an efficient continuous-time quantum Monte Carlo impurity solver termed CT-X with high acceptance rate at low temperature for multi-orbital quantum impurity models with general interaction. In this hybridization expansion impurity solver, the imaginary time evolution operator for the high energy multiplets, which decays very rapidly with the imaginary time, is approximated by a probability normalized δ -function. As the result, the virtual charge fluctuations of f n → f n ± 1 are well included on the same footing without applying Schrieffer–Wolff transformation (SWT) explicitly. CT-X is proven to be equivalent to SWT on the leading order of W/U, where W is half the conduction band width and U is the local interaction strength. As benchmarks, our algorithm perfectly reproduces the results for both Coqblin–Schriffeer model and Kondo lattice model obtained by CT-J method developed by Otsuki et al.. Furthermore, it allows capturing low energy physics of heavy-fermion materials directly without fitting the exchange coupling J in the Kondo model. Finally, we reformulate the dynamical mean-field theory loops using only the quasi-particle part of the f -electron Green's function measured in CT-X. Our benchmark calculations on CeIrIn5 at low temperature demonstrate a very reasonable low-energy f -electron density of states, which is in good agreement with the recent ARPES experiment. [ABSTRACT FROM AUTHOR]

Abstract Architectures are rapidly evolving, and exascale machines are expected to offer billion-way concurrency. We need to rethink algorithms, languages and programming models among other components in order to migrate large scale applications and explore parallelism on these machines. Although directive-based programming models allow programmers to worry less about programming and more about science, expressing complex parallel patterns in these models can be a daunting task especially when the goal is to match the performance that the hardware platforms can offer. One such pattern is wavefront. This paper extensively studies a wavefront-based miniapplication for Denovo, a production code for nuclear reactor modeling. We parallelize the Koch–Baker–Alcouffe (KBA) parallel-wavefront sweep algorithm in the main kernel of Minisweep (the miniapplication) using CUDA 9.0, OpenMP 4.0 (SIMD) and OpenACC 2.6. Our OpenACC implementation running on NVIDIA's next-generation Volta GPU boasts an 85.06x speedup over serial code, which is larger than CUDA's 83.72x speedup over the same serial implementation. We also explore the scalability of our solution using MPI to decompose our simulation domain, allowing us to run on many nodes and accelerators present in state-of-the-art HPC systems. Our parallelization effort across platforms also motivated us to define an abstract parallelism model that is architecture independent, with a goal of creating software abstractions that can be used by applications employing the wavefront sweep motif. Program summary Program Title: Minisweep Program Files doi: http://dx.doi.org/10.17632/cbcp37t8gf.1 Licensing provisions: BSD 2-clause Programming language: C Nature of problem: The Minisweep proxy application [1] is part of the Profugus radiation transport miniapp project [2] that reproduces the computational pattern of the sweep kernel of the Denovo S n radiation transport code [3]. The sweep kernel is responsible for most of the computational expense (80%–99%) of Denovo. Denovo, a production code for nuclear reactor neutronics modeling, is in use by a current DOE INCITE project to model the International Thermonuclear Experimental Reactor (ITER) fusion reactor [4]. The many runs of this code required to perform reactor simulations at high node counts make it an important target for efficient mapping to accelerated architectures. Solution method: This work proposes an abstract parallelism model for efficiently mapping wavefront application to modern HPC architectures. Minisweep is used as a case study for evaluating this technique. Our evaluation is performed using OpenACC to target many architectures. [ABSTRACT FROM AUTHOR]

Abstract We present an algorithm and its implementation to calculate the propertiesof electronic excitations in molecules and clusters from first principles, using time-dependent density functional theory (TDDFT). The algorithm assumes the use of some localized functions as a basis set to represent the spatial degrees of freedom. It relies on an iterative computation of the induced density according to the Dyson-like equation for the linear response function. The current implementation is built upon so-called numerical atomic orbitals. It is suitable for a wide variety of density functional theory (DFT) software. In this work, we demonstrate TDDFT calculations starting from preceding DFT runs with SIESTA, GPAW and PySCF packages, while a coupling with the other DFT packages such as Fireball and OpenMX is planned. The mentioned packages are capable of performing ab initio molecular dynamics simulations, and the speed of our TDDFT implementation makes feasible to perform a configuration average of the optical absorption spectra. Our code is written mostly in Python language allowing for a quick and compact implementation of most numerical methods and data-managing tasks with the help of NumPy/SciPy libraries and Python intrinsic constructs. Part of the code is written in C and Fortran to achieve a competitive speed in particular sections of the algorithm. Many parts of the current algorithm and implementation are useful in other ab initio methods for electronic excited states, such as Hedin's G W , Bethe–Salpeter equation and DFT with hybrid functionals. Corresponding proof-of-principles implementations are already part of the code. Program summary Program Title: PySCF-NAO Program Files doi: http://dx.doi.org/10.17632/9wgp6255hn.1 Licensing provisions: Apache License, Version 2.0 Programming language: Python (2 or 3), Fortran90 and C Supplementary material: We provide the source code and input files to organize example and benchmark calculations discussed in the paper. Nature of the problem: The study of the interaction of photons and charged particles with matter depends upon understanding of electronic excitations in matter. A description of the electronic excitations within time-dependent density functional theory (TDDFT) is popular due to the combination of its reasonable accuracy and its relatively low computational cost. Despite the relative simplicity of TDDFT, its application becomes difficult for quantum systems containing several hundreds of atoms. Such microscopically small systems are relevant in organic electronics, plasmonics and surface science. Therefore, much work has been devoted to the development of adequate electronic structure methods. Moreover, thermal motion of atoms and the presence of solvents affects the properties of electronic excited states in a decisive manner. Modeling of the electronic excited states including the system's dynamics within the Born–Oppenheimer approximation leads to even stronger efficiency requirements from the corresponding electronic structure methods. Solution method: We discretize the Kohn–Sham Hamiltonian using a basis of numerical atomic orbitals. The induced electronic density is determined in response to a dipolar external perturbation, according to linear response TDDFT, using an iterative algorithm. The method takes advantage of the sparsity generated by the finite support of the numerical atomic orbitals. This allows computing the dynamical polarizability of molecules and clusters containing up to several thousands of atoms. Additional comments including Restrictions and Unusual features: The current algorithm is formulated within the formalism of density response functions. Therefore, one needs to know explicitly an exchange–correlation kernel (second-derivative of energy with respect to variation of the density). The exchange–correlation kernel is analytically known for (semi-)local density functionals, but not for the hybrid density functionals. To date, we implemented only the local density approximation (LDA) for the exchange–correlation kernel to be used with the iterative TDDFT in PySCF-NAO. Spin-restricted formalism for finite systems is covered in the current implementation. Moreover, although our code is prepared to compute the electronic response of all-electron systems, our current implementation of an auxiliary product basis (density-fitting basis) is working best in combination with the use of pseudopotentials. [ABSTRACT FROM AUTHOR]

Abstract We present BHM, a tool for restoring a smooth function from a sampled histogram using the bin hierarchy method. It is particularly useful for the analysis of data from large-scale numerical simulations of physical systems, such as diagrammatic Monte Carlo simulations of quantum many-body problems. The theoretical background of the method is presented in Goulko et al., (2018). The code automatically generates a smooth polynomial spline with the minimal acceptable number of knots from the input data. It works universally for any sufficiently regular shaped distribution and any level of data quality (provided that the data are uncorrelated or correlations have been accounted for), requiring almost no external parameter specification. This paper explains the details of the implementation and the use of the program, including a physical example of the restoration of the Fröhlich polaron Green's function from data sampled with diagrammatic Monte Carlo. Program summary Program Title: BHM Program Files doi: http://dx.doi.org/10.17632/dvj8gxsxpk.1 Licensing provisions: GPLv3 Programming language: C++ External routines/libraries: CMake, GSL Nature of problem: Restoring a smooth function from a sampled histogram. Solution method: To make use of all information contained in the sampled data, the BHM algorithm generates a hierarchy of overlapping bins of different sizes from the initially supplied fine histogram. The bin hierarchy is fitted to a polynomial spline with the minimal acceptable number of knots, the positions of which are determined automatically. The output is a smooth function with error band. [ABSTRACT FROM AUTHOR]

Abstract In Fu et al. (2016), a family of high-order TENO shock-capturing schemes has been proposed for compressible fluid simulations within a finite-difference framework. With the TENO weighting strategy, each candidate stencil is either applied for the final reconstruction with its optimal weight or discarded completely when crossed by discontinuities. In this paper, with the observation that the local flow scales can be judged to be smooth or non-smooth explicitly, we propose a novel low-dissipation finite-volume method based on a new TENO reconstruction. Firstly, a new ENO-like stencil selection paradigm, which adapts between three three-point small stencils and a large candidate stencil, is proposed. The resulting TENO scheme inherits the low-dissipation advantage of original TENO schemes and can be extended to arbitrarily high-order reconstruction without significant complexity increase. The optimal background linear scheme on the three small stencils and that on the large stencil can be optimized either approaching high-order accuracy or better spectral properties separately. Secondly, within the finite-volume framework, a "low-dissipation" Riemann solver is applied for flux computing when the large candidate stencils for both the left- and right-side reconstruction are judged as smooth whereas a robust "dissipative" Riemann solver is adopted when one large candidate stencil crosses discontinuities. Since the numerical dissipation from both the reconstruction stage and the flux computing stage can be tuned according to the TENO weighting strategy, the proposed finite-volume method is less-dissipative and provides additional flexibility to handle challenging simulations. A set of benchmark cases is simulated to assess the performance of proposed method. [ABSTRACT FROM AUTHOR]

Abstract Elegant is an accelerator physics and particle-beam dynamics code widely used for modeling and design of a variety of high-energy particle accelerators and accelerator-based systems. In this paper we discuss a recently developed version of the code that can take advantage of CUDA-enabled graphics processing units (GPUs) to achieve significantly improved performance for a large class of simulations that are important in practice. The GPU version is largely defined by a framework that simplifies implementations of the fundamental kernel types that are used by Elegant: particle operations, reductions, particle loss, histograms, array convolutions and random number generation. Accelerated performance on the Titan Cray XK-7 supercomputer is approximately 6–10 times better with the GPU than all the CPU cores associated with the same node count. In addition to performance, the maintainability of the GPU-accelerated version of the code was considered a key design objective. Accuracy with respect to the CPU implementation is also a core consideration. Four different methods are used to ensure that the accelerated code faithfully reproduces the CPU results. Program summary Program Title: Kernels from the GPU-accelerated Elegant Program Files doi: http://dx.doi.org/10.17632/jc465zy7p5.1 Licensing provisions: MIT Programming language: C/C++/CUDA Nature of problem: The original design of the Elegant accelerator physics code was implemented on central processing units with message-passing interface parallelization. This implementation is not able to use next-generation multicore systems. Solution method: In this package we develop routines based on the CUDA language extensions to C++ that enable porting the Elegant code to be run on graphics processing units (GPUs). Special consideration is given to algorithms that require collective communication on the GPU. Additional comments including restrictions and unusual features: The full Elegant source code is freely available from Argonne National Laboratory and these distributions include the GPU code in the later releases. [ABSTRACT FROM AUTHOR]

Abstract SALMON (Scalable Ab-initio Light–Mattersimulator for Optics and Nanoscience, http://salmon-tddft.jp) is a software package for the simulation of electron dynamics and optical properties of molecules, nanostructures, and crystalline solids based on first-principles time-dependent density functional theory. The core part of the software is the real-time, real-space calculation of the electron dynamics induced in molecules and solids by an external electric field solving the time-dependent Kohn–Sham equation. Using a weak instantaneous perturbing field, linear response properties such as polarizabilities and photoabsorptions in isolated systems and dielectric functions in periodic systems are determined. Using an optical laser pulse, the ultrafast electronic response that may be highly nonlinear in the field strength is investigated in time domain. The propagation of the laser pulse in bulk solids and thin films can also be included in the simulation via coupling the electron dynamics in many microscopic unit cells using Maxwell's equations describing the time evolution of the electromagnetic fields. The code is efficiently parallelized so that it may describe the electron dynamics in large systems including up to a few thousand atoms. The present paper provides an overview of the capabilities of the software package showing several sample calculations. Program summary Program Title: SALMON: Scalable Ab-initio Light–Matter simulator for Optics and Nanoscience Program Files doi: http://dx.doi.org/10.17632/8pm5znxtsb.1 Licensing provisions: Apache-2.0 Programming language: Fortran 2003 Nature of problem: Electron dynamics in molecules, nanostructures, and crystalline solids induced by an external electric field is calculated based on first-principles time-dependent density functional theory. Using a weak impulsive field, linear optical properties such as polarizabilities, photoabsorptions, and dielectric functions are extracted. Using an optical laser pulse, the ultrafast electronic response that may be highly nonlinear with respect to the exciting field strength is described as well. The propagation of the laser pulse in bulk solids and thin films is considered by coupling the electron dynamics in many microscopic unit cells using Maxwell's equations describing the time evolution of the electromagnetic field. Solution method: Electron dynamics is calculated by solving the time-dependent Kohn–Sham equation in real time and real space. For this, the electronic orbitals are discretized on a uniform Cartesian grid in three dimensions. Norm-conserving pseudopotentials are used to account for the interactions between the valence electrons and the ionic cores. Grid spacings in real space and time, typically 0.02 nm and 1 as respectively, determine the spatial and temporal resolutions of the simulation results. In most calculations, the ground state is first calculated by solving the static Kohn–Sham equation, in order to prepare the initial conditions. The orbitals are evolved in time with an explicit integration algorithm such as a truncated Taylor expansion of the evolution operator, together with a predictor–corrector step when necessary. For the propagation of the laser pulse in a bulk solid, Maxwell's equations are solved using a finite-difference scheme. By this, the electric field of the laser pulse and the electron dynamics in many microscopic unit cells of the crystalline solid are coupled in a multiscale framework. [ABSTRACT FROM AUTHOR]

Abstract Numerical simulation of an electrodynamic system in empty space requires the implementation of open boundary conditions (BC) to terminate the solution of Maxwell's equations on the boundaries of the computational domain. The Perfectly Matched Layer (PML) has become the method of choice for open BC with wave equations, as it is straightforward and relatively easy to implement, and offers very efficient and user-adjustable absorption rates. PMLs are most often employed with the Finite-Difference Time-Domain (FDTD) algorithm, which in its most common implementation offers second-order accuracy in space and time on Cartesian grids. Yet, simulations (including some class of electromagnetic Particle-In-Cell simulations) that require higher precision may resort to higher-order Maxwell solvers employing extended finite-difference stencils, or even to pseudo-spectral Maxwell solvers, for which a general, versatile and efficient formulation of the PML has been missing so far. In this paper, we propose a novel "two-step" formulation of the PML that is simple, very versatile and can be used as is with any Maxwell solver. In particular, it is applicable to a large class of Maxwell solvers including the arbitrary-order Pseudo-Spectral Analytical Time-Domain (PSATD) solver, which offers arbitrarily low numerical dispersion when increasing solver order and becomes dispersion-free at infinite order. Analysis and numerical simulations demonstrate that the new formulation is as efficient as the standard PML formulation, both for the FDTD and the PSATD implementations. [ABSTRACT FROM AUTHOR]

Abstract This paper presents a performance examination of the Coarse Mesh Finite Difference (CMFD) method for a reduction of inter-cycle correlations in Monte Carlo (MC) active cycle simulations. Sensitivity tests using the UNIST in-house MC code 'MCS' reveal the characteristics of CMFD effectiveness depending on problem sizes, dimensions, and cross-section dependency on neutron energy (multi-group vs. continuous). Also, by applying this method to the three-dimensional BEAVRS whole core problem, it is successfully demonstrated that the CMFD can reduce the inter-cycle correlations of practical, large size, and high dominance ratio problems, and that the figure of merit of efficiency for a practical reactor problem increases by a factor of six. [ABSTRACT FROM AUTHOR]

Abstract In this paper we briefly discuss Rings — an efficient lightweight library for commutative algebra. Polynomial arithmetic, GCDs, polynomial factorization and Gröbner bases are implemented with the use of modern asymptotically fast algorithms. Rings can be easily interacted or embedded in applications in high-energy physics and other research areas via a simple API with fully typed hierarchy of algebraic structures and algorithms for commutative algebra. The use of the Scala language brings a quite novel powerful, strongly typed functional programming model allowing to write short, expressive, and fast code for applications. At the same time Rings shows one of the best performances among existing software for algebraic calculations. Program summary Program Title: Rings Program Files doi: http://dx.doi.org/10.17632/2k79hftjy9.1 Licensing provisions: Apache 2.0 Programming language: Java, Scala Nature of problem: Fast methods for rational function arithmetic, simplification of polynomial expressions, Gröbner bases and other related computer algebra methods naturally arising in physical applications Solution method: Efficient implementation of modern asymptotically fast algorithms in Java language External routines: Java 8 and higher, Scala 2.11 or 2.12 Additional comments: project page: https://github.com/PoslavskySV/rings , documentation: http://rings.readthedocs.io/en/latest/ [ABSTRACT FROM AUTHOR]

Abstract The paper describes QSWalk.jl package for Julia programming language, developed for the purpose of simulating the evolution of open quantum systems. The package enables the study of quantum procedures developed using stochastic quantum walks on arbitrary directed graphs. We provide a detailed description of the implemented functions, along with a number of usage examples. The package is compared with the existing software offering a similar functionality. Program summary Program Title: QSWalk.jl Program Files doi: http://dx.doi.org/10.17632/6x37kcvvrp.1 Licensing provisions: MIT Programming language: Julia Nature of problem: The package implements functions for simulating quantum stochastic walks, including local regime, global regime, and nonmoralizing global regime (Julia documentation, 2018). It can be used for arbitrary quantum continuous evolution based on GKSL master equation on arbitrary graphs. Solution method: We utilize Expokit routines for fast sparse matrix exponentials on vectors. For dense matrices, exponentiation is computed separately, which is faster for small matrices. Restrictions: Currently package requires Julia v0.6 or higher. [1] K. Domino, A. Glos, M. Ostaszewski, Superdiffusive quantum stochastic walk definable of arbitrary directed graph, Quantum Inform. Comput 17 (11-12) (2017) 973–986. [ABSTRACT FROM AUTHOR]

Abstract Many PDEs can be recast into the general multi-symplectic formulation possessing three local conservation laws. We devote the present paper to some systematic methods, which hold the discrete versions of the local conservation laws respectively, for the general multi-symplectic PDEs. For the original problem subjected to appropriate boundary conditions, the proposed methods are globally conservative. The proposed methods are successfully applied to many one-dimensional and multi-dimensional Hamiltonian PDEs, such as KdV equation, G–P equation, Maxwell's equations and so on. Numerical experiments are carried out to verify the theoretical analysis. [ABSTRACT FROM AUTHOR]

Abstract mVMC (many-variable Variational Monte Carlo) is an open-source software package based on the variational Monte Carlo method applicable for a wide range of Hamiltonians for interacting fermion systems. In mVMC, we introduce more than ten thousands variational parameters and simultaneously optimize them by using the stochastic reconfiguration (SR) method. In this paper, we explain basics and user interfaces of mVMC. By using mVMC, users can perform the calculation by preparing only one input file of about ten lines for widely studied quantum lattice models, and can also perform it for general Hamiltonians by preparing several additional input files. We show the benchmark results of mVMC for the Hubbard model, the Heisenberg model, and the Kondo-lattice model. These benchmark results demonstrate that mVMC provides ground-state and low-energy-excited-state wave functions for interacting fermion systems with high accuracy. Program summary Program title: mVMC Program Files doi: http://dx.doi.org/10.17632/xhgyp6ncvt.1 Licensing provisions: GNU General Public License version 3 Programming language: C External routines/libraries: MPI, BLAS, LAPACK, Pfapack, ScaLAPACK (optional) Nature of problem: Physical properties (such as the charge/spin structure factors) of strongly correlated electrons at zero temperature. Solution method: Application software based on the variational Monte Carlo method for quantum lattice model such as the Hubbard model, the Heisenberg model and the Kondo model. Unusual features: It is possible to perform the highly-accurate calculations for ground states in a wide range of theoretical Hamiltonians in quantum many-body systems. In addition to the conventional orders such as magnetic and/or charge orders, user can treat the anisotropic superconductivities within the same framework. This flexibility is the main advantage of mVMC. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we develop two second-order in time, linear and unconditionally energy stable time marching schemes for solving the nonlocal Cahn–Hilliard phase field model. The main challenge to construct efficient and unconditional energy stable schemes for this model is how to design proper temporal discretizations for the nonlocal term that is induced from a convolutional type potential and the nonlinear cubic term that is induced from the double-well bulk potential. We solve these issues by developing two efficient time-stepping schemes using the Invariant Energy Quadratization approach. Its novelty is that all nonlinear terms can be treated semi-explicitly to produce linear schemes. We further show the well-posedness of the resulting linear system as well as its unconditional energy stability rigorously. Various numerical simulations are presented to demonstrate the stability, accuracy, and efficiency of the proposed schemes. [ABSTRACT FROM AUTHOR]

Abstract This paper presents a number of optimisations for improving the performance of unstructured computational fluid dynamics codes on multicore and manycore architectures such as the Intel Sandy Bridge, Broadwell and Skylake CPUs and the Intel Xeon Phi Knights Corner and Knights Landing manycore processors. We discuss and demonstrate their implementation in two distinct classes of computational kernels: face-based loops represented by the computation of fluxes and cell-based loops representing updates to state vectors. We present the importance of making efficient use of the underlying vector units in both classes of computational kernels with special emphasis on the changes required for vectorising face-based loops and their intrinsic indirect and irregular access patterns. We demonstrate the advantage of different data layouts for cell-centred as well as face data structures and architectural specific optimisations for improving the performance of gather and scatter operations which are prevalent in unstructured mesh applications. The implementation of a software prefetching strategy based on auto-tuning is also shown along with an empirical evaluation on the importance of multithreading for in-order architectures such as Knights Corner. We explore the various memory modes available on the Intel Xeon Phi Knights Landing architecture and present an approach whereby both traditional DRAM as well as MCDRAM interfaces are exploited for maximum performance. We obtain significant full application speed-ups between 2.8 and 3X across the multicore CPUs in two-socket node configurations, 8.6X on the Intel Xeon Phi Knights Corner coprocessor and 5.6X on the Intel Xeon Phi Knights Landing processor in an unstructured finite volume CFD code representative in size and complexity to an industrial application. Program summary Program Title: some_opt_for_unstructured_cfd Program Files doi: http://dx.doi.org/10.17632/zyh2zkf3jw.1 Licensing provisions: GNU General Public License 3 (GPL) Programming language: C/C++ Nature of problem: The solution of fluid flow problems in the vicinity of complex geometries mandates the utilisation of unstructured grids. However, this flexibility of unstructured mesh methods in dealing with complicated geometries comes at a cost of increased difficulty in extracting high performance out of modern processors. We provide implementations for a number of optimisations useful for improving the performance of unstructured CFD codes on modern multicore and manycore architectures. Solution method: grid renumbering via Reverse Cuthill–Mckee, code transformations necessary for enabling vectorisation, face colouring/reordering for removing dependencies at the face end-points when accumulating residuals, data layout transformations for reducing cache misses, hand-tuned gather and scatter primitives for in-register transpositions, software prefetching via auto-tuning and multithreading for exploiting SMT features of modern processors. [ABSTRACT FROM AUTHOR]

Abstract With the approach of exascale computing era, particle-based models are becoming the focus of research due to their excellent scalability. We present a new code, Slurm, which implements the classic particle-in-cell algorithm for modeling magnetized fluids and plasmas. It features particle volume evolution which damps the numerical finite grid instability, and allows modeling of key physical instabilities such as Kelvin–Helmholtz and Rayleigh–Taylor. The magnetic field in Slurm is handled via the electromagnetic vector potential carried by particles. Numerical diffusion of the magnetic flux is extremely low, and the solenoidality of the magnetic field is preserved to machine precision. A double-linked list is used to carry particles, thus implementation of open boundary conditions is simple and efficient. The code is written in C++ with OpenMP multi-threading, and has no external dependencies except for Boost. It is easy to install and use on multi-core desktop computers as well as on large shared-memory machines. Slurm is an ideal tool for its primary goal, modeling of space weather events in the heliosphere. This article walks the reader through the physical model, the algorithm, and all important details of implementation. Ideally, after finishing this paper, the reader should be able to either use Slurm for solving the desired problem, or create a new fluid PIC code. [ABSTRACT FROM AUTHOR]

Abstract This paper explores the application of the parareal algorithm to simulations of ELMs in ITER plasma. The primary focus of this research is identifying the parameters that lead to optimum performance. Since the plasma dynamics vary extremely fast during an ELM cycle, a straightforward application of the algorithm is not possible and a modification to the standard parareal correction is implemented. The size of the time chunks also have an impact on the performance and needs to be optimized. A computational gain of 7.8 is obtained with 48 processors to illustrate that the parareal algorithm can be successfully applied to ELM plasma. [ABSTRACT FROM AUTHOR]

Abstract Computational simulations of blood flow contribute to our understanding of the interplay between vascular geometry and hemodynamics. With an improved understanding of this interplay from computational fluid dynamics (CFD), there is potential to improve basic research and the targeting of clinical care. One avenue for further analysis concerns the influence of time on the vascular geometries used in CFD simulations. The shape of blood vessels changes frequently, as in deformation within the cardiac cycle, and over long periods of time, such as the development of a stenotic plaque or an aneurysm. These changes in the vascular geometry will, in turn, influence flow within these blood vessels. By performing CFD simulations in geometries representing the blood vessels at different points in time, the interplay of these geometric changes with hemodynamics can be quantified. However, performing CFD simulations on different discrete grids leads to an additional challenge: how does one directly and quantitatively compare simulation results from different vascular geometries? In a previous study, we began to address this problem by proposing a method for the simplified case where the two geometries share a common centerline. In this companion paper, we generalize this method to address geometric changes which alter the vessel centerline. We demonstrate applications of this method to the study of wall shear stress in the left coronary artery. First, we compute the difference in wall shear stress between simulations using vascular geometries derived from patient imaging data at two points in the cardiac cycle. Second, we evaluate the relationship between changes in wall shear stress and the progressive development of a coronary aneurysm or stenosis. [ABSTRACT FROM AUTHOR]

Abstract To guarantee the availability and reliability of data source in Magnetic Confinement Fusion (MCF) devices, incorrect diagnostic data, which cannot reflect real physical properties of measured objects, should be sorted out before further analysis and study. Traditional data sorting cannot meet the growing demand of MCF research because of the low-efficiency, time-delay, and lack of objective criteria. In this paper, a Time-Domain Global Similarity (TDGS) method based on machine learning technologies is proposed for the automatic data cleaning of MCF devices. The aim of traditional data sorting is to classify original diagnostic data sequences. The lengths and evolution properties of the data sequences vary shot by shot. Hence the classification criteria are affected by many discharge parameters and are different in various discharges. The focus of the TDGS method is turned to the physical similarity between data sequences from different channels, which are more independent of discharge parameters. The complexity arisen from real discharge parameters during data cleaning is avoided in the TDGS method by transforming the general data sorting problem into a binary classification problem about the physical similarity between data sequences. As a demonstration of its application to multi-channel measurement systems, the TDGS method is applied to the EAST POlarimeter–INTerferometer (POINT) system. The optimal performance of the method evaluated by 24-fold cross-validation has reached 0.9871 ± 0.0385. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we present a parallel numerical algorithm for solving the phase field crystal equation. In the algorithm, a semi-implicit finite difference scheme is derived based on the discrete variational derivative method. Theoretical analysis is provided to show that the scheme is unconditionally energy stable and can achieve second-order accuracy in both space and time. An adaptive time step strategy is adopted such that the time step size can be flexibly controlled based on the dynamical evolution of the problem. At each time step, a nonlinear algebraic system is constructed from the discretization of the phase field crystal equation and solved by a domain decomposition based, parallel Newton–Krylov–Schwarz method with improved boundary conditions for subdomain problems. Numerical experiments with several two and three dimensional test cases show that the proposed algorithm is second-order accurate in both space and time, energy stable with large time steps, and highly scalable to over ten thousands processor cores on the Sunway TaihuLight supercomputer. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we develop an optimal particle setup method for initial condition with Centroidal Voronoi Particle (CVP) dynamics, which combines the Centroidal Voronoi Tessellation (CVT) and Voronoi Particle (VP) concept. CVT optimizes the energy function in terms of compactness and consequently ensures the isotropy of particle distribution. The CVT configuration is computed by Lloyd's algorithm, which decreases the energy function monotonically. A physics-motivated model equation with tailored equation of state (EOS) is employed to relax the Voronoi particle system such that the convergent equilibrium matches the target configuration. The resulting particle distribution approximates the given analytical profiles of spatially adaptive density, smoothing-length and mass distribution with high interpolation accuracy. The level-set method is introduced to describe arbitrarily complex geometries. A set of Smoothed Particle Hydrodynamics (SPH) simulations is computed to demonstrate the performances of the proposed method. Without parameter tuning, good performance is obtained for presented benchmarks implying its promising potential. [ABSTRACT FROM AUTHOR]

Abstract The computation of neutrino flavor transition amplitudes through inhomogeneous matter is a time-consuming step and thus could benefit from optimization and parallelization. Next to reliable parameter estimation of intrinsic physical quantities such as neutrino masses and mixing angles, these transition amplitudes are important in hypothesis testing of potential extensions of the standard model of elementary particle physics, such as additional neutrino flavors. Hence, fast yet precise implementations are of high importance to research. In the recent past, massively parallel accelerators such as CUDA-enabled GPUs featuring thousands of compute units have been widely adopted due to their superior memory bandwidth, vast compute capability, and highly competitive compute-to-energy ratio in comparison to traditional multi-core architectures with a few tens of monolithic cores. In this paper, we introduce two scalable multi-GPU extensions of common neutrino oscillation frameworks – namely Prob3++ and ν SQuIDS –allowing for the acceleration of oscillation dynamics computation by one to three orders-of-magnitude while preserving numerical accuracy. Our software is licensed under LGPLv3 and can be accessed at https://github.com/fkallen/CUDAProb3 and https://github.com/fkallen/CUDAnuSQuIDS. Program summary Program Title: CUDAProb3++ and CUDA ν SQuIDS Program Files doi: http://dx.doi.org/10.17632/j54yymmg5h.1 Licensing provisions: LGPLv3 Programming language: CUDA, C and C++ Nature of problem: Fast computation of neutrino oscillation probabilities in inhomogeneous matter using constant-coefficient or variable-coefficient ODE solvers. Solution method: Solving ordinary differential equations on CUDA-enabled GPUs. [ABSTRACT FROM AUTHOR]

Abstract A Full-Orbit CUDA Solver for particle simulations in plasmas, FOCUS, has been developed. The code follows exact particle trajectories by solving Newton's equations with the Lorentz force. The code can use fields calculated analytically or numerically and it is also possible to use the information provided by equilibrium reconstruction and transport codes. FOCUS has an elastic collisions module which covers the whole particle energy range in magnetic fusion devices. Moreover, an atomic collision module was also included to simulate the interaction of the test particles with neutral or partially ionized species. Regarding performance, the main feature is that the code runs on GPUs, allowing the simulation of a large number of particles using moderate computational resources. Different versions of the code have been used in several papers. Here we present a complete description of its capabilities, the basis physics included and detailed information about the numerical algorithms employed. Finally, some examples are presented. [ABSTRACT FROM AUTHOR]

Abstract In this paper, we propose a hybrid lattice Boltzmann method (HLBM) for solving fluid–structure interaction problems. The proposed numerical approach is applied to model the flow induced by a vibrating thin lamina submerged in a viscous quiescent fluid. The hydrodynamic force exerted by the fluid on the solid body is described by means of a complex hydrodynamic function, whose real and imaginary parts are determined via parametric analysis. Numerical results are validated by comparison with those from other numerical as well as experimental works available in the literature. The proposed hybrid approach enhances the capability of lattice Boltzmann methods to solve fluid dynamic problems involving moving geometries. [ABSTRACT FROM AUTHOR]

Abstract Numerical solutions for laser–matter interaction in Schrödinger equation has many applications in theoretical chemistry, quantum physics and condensed matter physics. In this paper we introduce a methodology which allows, with a small cost, to extend any fourth-order scheme for Schrödinger equation with time-independent potential to a fourth-order method for Schrödinger equation with laser potential. This is made possible due to the highly specific form of the time dependent potential which is linear in space in the case of laser–matter interaction. This leads to a highly amenable structure of the commutators in the Magnus expansion, where, in particular, the first commutator reduces to a scalar multiple of the gradient. In turn, this special structure allows us to split the Magnus expansion effectively via a variety of fourth-order splittings. Additionally, the error constant remains tiny because we keep the integrals of the potential intact to the very last stage of computations. This is particularly important in the case of highly oscillatory potentials. As demonstrated via numerical examples, these fourth-order methods improve upon many leading schemes of order six due to their low costs and small error constants. [ABSTRACT FROM AUTHOR]

Abstract Here we present a new approach to search for first order invariants (first integrals) of rational second order ordinary differential equations. This method is an alternative to the Darbouxian and symmetry approaches. Our procedure can succeed in many cases where these two approaches fail. We also present here a Maple implementation of the theoretical results and methods, hereby introduced, in a computational package — InSyDE. The package is designed, apart from materializing the algorithms presented, to provide a set of tools to allow the user to analyse the intermediary steps of the process. Computer programs in physics Program Title: InSyDE — Invariants and Symmetries of (racional second order ordinary) Differential Equations. Program Files doi: http://dx.doi.org/10.17632/4ytft6zgk7.1 Licensing provisions: GPLv3 Programming language: Maple 17. Nature of problem Search for first integrals of rational 2ODEs. Solution method: The method of solution is based on an algorithm described in this paper. Restrictions: If the rational 2ODE that is being analysed presents a very high degree in (x , y , z), then the method may not work well. Unusual features: Our implementation can find first integrals in many cases where the rational 2ODE under study cannot be reduced by other powerful solvers. Besides that, the package presents some useful research commands. [ABSTRACT FROM AUTHOR]

In this paper, we construct several linear, decoupled and energy stable schemes for a phase-field surfactant model, in which the free energy functional contains a fourth-order Ginzburg–Landau double well potential, a logarithmic Flory–Huggins potential and two nonlinear coupling terms. Several scalar auxiliary variables (SAV) are introduced to transform the governing system into an equivalent form, allowing the nonlinear potentials to be treated efficiently and semi-explicitly. At each time step, the schemes involve solving only two linear elliptic differential equations, and computations of two phase-field variables are totally decoupled. Moreover, the local concentration of surfactants can be obtained in an “explicit” way. We further establish a rigorous proof of unconditional energy stability for the semi-implicit schemes. Numerical results in both two and three dimensions are obtained, which demonstrate that the proposed schemes are accurate, efficient, easy-to-implement and unconditionally energy stable. [ABSTRACT FROM AUTHOR]

This note introduces CutLang , a domain specific language that aims to provide a clear, human readable way to define analyses in high energy particle physics (HEP) along with an interpretation framework of that language. A proof of principle (PoP) implementation of the CutLang interpreter, achieved using C + + as a layer over the CERN data analysis framework ROOT , is presently available. This PoP implementation permits writing HEP analyses in an unobfuscated manner, as a set of commands in human readable text files, which are interpreted by the framework at runtime. We describe the main features of CutLang and illustrate its usage with two analysis examples. Initial experience with CutLang has shown that a just-in-time interpretation of a human readable HEP specific language is a practical alternative to analysis writing using compiled languages such as C + + . Program summary Program title: CutLang Program Files doi: http://dx.doi.org/10.17632/pym39s7vy7.1 Licensing provisions: GNU General Public License 3 (GPL) Programming language: C++ Nature of problem: Obtaining a physics result from high energy collider (e.g. LHC) data typically involves complex software frameworks for data analysis. Operating such analysis frameworks usually demands high computational expertise from the physicists, which makes trying simple analysis ideas difficult. The difficulty can be overcome by decoupling the description of all physics components of an analysis from the software framework. Analyses would thus be fully and unambiguously described by a framework-independent domain specific language. Defining such a language, which would be text-based and human readable is the first problem this paper investigates. Once a text-based language is available, a major task is to write an interpreter (or compiler) that converts it into instructions that can actually be executed, perhaps in some framework. The second problem addressed here is to write an automated, just-in-time interpreter to perform this task. Solution method: CutLang addresses the above problems by first constructing a domain specific language which aims to provide a clear, human readable way to define high energy physics analyses. The language is capable of defining various components of the analysis like object selection, event selection, and allows analysis tools like variable definition, χ 2 minimization, multiple selection regions definition and many others. CutLang also provides an automated interpretation framework for the language, which is achieved using C++ classes as a layer over the CERN ROOT framework. The interpreter evaluates each component of the analysis description at runtime, without compilation. It handles event selection by classes which consist of a function that evaluates event-by-event object or event related quantities, a comparison operator, and one or two limit values, For each evaluation, the function result is compared to the limit values to find a boolean result of 0 or 1. Multiple selection criteria are combined together using logical operators. CutLang evaluates such expressions numerically by first converting them into Reverse Polish Notation, and then by parsing them with the Shunting Yard algorithm. Several properties of the interpreter are being able to work with multiple particle types, allowing particle combinations to make new particles, offering standard functions, histogramming, etc. Additional comments including restrictions and unusual features: The CutLang language and interpreter can work for a large number of physics analyses at the LHC. However it would benefit from some generalizations which would make it eligible for a larger variety of analysis. These generalizations could be achieved by inclusion of external functions for computing analysis-related variables, and allowing user-defined particle collections. [ABSTRACT FROM AUTHOR]

This paper presents general information about ARUZ, a scalable, fully parallel data processing system equipped with low-latency communication channels, designed for simulations of interactions among huge number of relatively simple elements. ARUZ consists of approximately 26 000 FPGAs and it can represent a system composed of several million elements consuming barely tens of kilowatts of power. It can be seen as a powerful machine for a wide range of applications. Currently, it implements the Dynamic Lattice Liquid algorithm, which enables studies of dynamic processes and phenomena in dense macromolecular systems. A performance estimation for liquid water shows that in one day ARUZ can model the diffusion of 1.5 million water molecules ongoing in reality for approximately 0.7 ms. [ABSTRACT FROM AUTHOR]