Search

• An efficient and reliable three-dimensional (3D) ghost cell method is presented for complex rigid and flexible boundary flows. • An improved implicit interface representation method is developed to track the arbitrary complex interfaces. • A GPU-CUDA parallel framework is developed to greatly accelerate the present solver. • The present solver can achieve hundreds of acceleration ratio for 2D grids and thousands of acceleration ratio for 3D grids. • Uniform flows around an 3D body with arbitrary geometries are simulated, and salient 3D wake structures are captured. This paper presents an efficient and reliable three-dimensional (3D) ghost cell method for complex rigid or flexible boundary flows. An improved implicit interface representation method is developed to treat the arbitrary complex interfaces including the thin or sharp boundaries. This method is robust and avoids the solving of a large dense matrix, and thus the computational efficiency is greatly enhanced. The ghost cell method with a unified eight-node interpolation scheme is adopted to enforce the no-slip boundary conditions on complex boundaries. To perform 3D high-resolution simulation on a desktop computer, a GPU parallel framework in CUDA environment is developed to significantly accelerate the computational efficiency of the present solver. The horizontal oscillations of a two-dimensional (2D) cylinder and a 3D sphere in the rest fluid are simulated to validate the accuracy and computational performance of the present model. Spatial accuracy of near second-order on the boundary treatment and good grid convergence are confirmed. Also, the present solver can achieve hundreds of acceleration ratios for 2D grids and thousands of acceleration ratios for 3D grids. Then, uniform flows around a 3D arbitrary rigid or flexible object such as a stationary cylindrical cylinder, a stationary square cylinder, an oscillating airfoil, and a swimming carangiform are simulated. The accuracy and capability of the present model for 3D complex geometries with large-amplitude movement or deformation is satisfactorily validated. Moreover, typical 3D wake structures are well captured. [ABSTRACT FROM AUTHOR]

The present paper deals with the problem of improving the efficiency of large scale turbulent flow simulations. The high-fidelity methods for modelling turbulent flows become available for a wider range of applications thanks to the constant growth of the supercomputers performance, however, they are still unattainable for lots of real-life problems. The key shortcoming of these methods is related to the need of simulating a long time integration interval to collect reliable statistics, while the time integration process is inherently sequential. The novel approach with modelling of multiple flow states is discussed in the paper. The suggested numerical procedure allows to parallelize the integration in time by the cost of additional computations. Multiple realizations of the same turbulent flow are performed simultaneously. This allows to use more efficient implementations of numerical methods for solving systems of linear algebraic equations with multiple right-hand sides, operating with blocks of vectors. The simple theoretical estimate for the expected simulation speedup, accounting the penalty of additional computations and the linear solver performance improvement, is presented. The two problems of modelling turbulent flows in a plain channel and in a channel with a matrix of wall-mounted cubes are used to demonstrate the correctness of the proposed estimates and efficiency of the suggested approach as a whole. The simulation speedup by a factor of 2 is shown. [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 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 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 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 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]

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]

An enhanced fully-Lagrangian meshfree computational method is developed for simulating incompressible fluid–elastic structure interactions. The developed method corresponds to a SPH (Smoothed Particle Hydrodynamics)-based coupled FSI (Fluid–Structure Interaction) solver. Coupling is conducted in between a projection-based ISPH (Incompressible SPH) fluid model and a newly developed SPH-based structure model in a mathematically–physically consistent manner. Fluid model is founded on the solution of Navier–Stokes and continuity equations while structure model is set on conservation laws for linear and angular momenta corresponding to an isotropic elastic solid. A set of previously developed enhanced schemes are incorporated for the ISPH fluid model, hence, the developed coupled method is referred to as Enhanced ISPH–SPH. The performance of SPH-based structure model is first validated in reproduction of benchmark tests including dynamic response of a free oscillating cantilever plate and stress distribution inside an isotropic plate with a circular opening. Then the Enhanced ISPH–SPH is scrupulously verified through simulations of FSI problems including hydrostatic water column on an elastic plate, dam break with an elastic gate, sloshing in tanks with elastic baffles and hydroelastic slammings of an elastic aluminum wedge and a marine panel. To the best knowledge of the authors, this paper presents the first semi-implicit/explicit ISPH–SPH coupled method for FSI related to deformable elastic structures with comprehensive validations and performance investigations. [ABSTRACT FROM AUTHOR]

Simflowny is an open platform for scientific dynamical models which automatically generates parallel code for different simulation frameworks. Here we present major upgrades on this software to support an extended set of model families, in particular: (i) a new family for the evolution of partial differential equations, which can include spatial derivatives of any order, (ii) a new family for agent based models to study complex phenomena — either on a spatial domain or on a graph. Additionally we introduce an upgraded flexible graphical user interface to accommodate these and future families of equations and models. This paper describes the new architecture and summarizes the formal representation and implementation of these new families, providing several validation results. Program summary Program Title: Simflowny Program Files doi: http://dx.doi.org/10.17632/g9mcw8s64f.1 Licensing provisions: Apache License, 2.0 Programming language: Java, C++ and JavaScript Journal Reference of previous version: Comput. Phys. Comm. 184 (2013) 2321–2331 Does the new version supersede the previous version?: Yes Reasons for the new version: Additional features Summary of revisions: Expanded support for Partial Differential Equations, Support for Agent Based Models, New Graphical User Interface. Nature of problem: Simflowny generates numerical simulation code for a wide range of models. Solution method: Any discretization scheme based on either Finite Volume Methods, Finite Difference Methods, or meshless methods for Partial Differential Equations. Agent Based Model simulations execute their own algorithm as set in their models. Additional comments: The software architecture is easily extensible for future additional model families and simulation frameworks. Full documentation is available in the wiki home of the Simflowny project [2]. References: [1] https://www.docker.com/ [online] (2017) [1] https://bitbucket.org/iac3/simflowny/wiki/Home [online] (2017) [ABSTRACT FROM AUTHOR]

This paper reports on the successful implementation of a massively parallel GPU-accelerated algorithm for the direct numerical simulation of turbulent mixing at high Schmidt number. The work stems from a recent development ( Comput. Phys. Commun. , vol. 219, 2017, 313–328), in which a low-communication algorithm was shown to attain high degrees of scalability on the Cray XE6 architecture when overlapping communication and computation via dedicated communication threads. An even higher level of performance has now been achieved using OpenMP 4.5 on the Cray XK7 architecture, where on each node the 16 integer cores of an AMD Interlagos processor share a single Nvidia K20X GPU accelerator. In the new algorithm, data movements are minimized by performing virtually all of the intensive scalar field computations in the form of combined compact finite difference (CCD) operations on the GPUs. A memory layout in departure from usual practices is found to provide much better performance for a specific kernel required to apply the CCD scheme. Asynchronous execution enabled by adding the OpenMP 4.5 NOWAIT clause to TARGET constructs improves scalability when used to overlap computation on the GPUs with computation and communication on the CPUs. On the 27-petaflops supercomputer Titan at Oak Ridge National Laboratory, USA, a GPU-to-CPU speedup factor of approximately 5 is consistently observed at the largest problem size of 819 2 3 grid points for the scalar field computed with 8192 XK7 nodes. [ABSTRACT FROM AUTHOR]

This paper presents a fast incompressible SPH (ISPH) solver implemented to run entirely on a graphics processing unit (GPU) capable of simulating several millions of particles in three dimensions on a single GPU. The ISPH algorithm is implemented by converting the highly optimised open-source weakly-compressible SPH (WCSPH) code DualSPHysics to run ISPH on the GPU, combining it with the open-source linear algebra library ViennaCL for fast solutions of the pressure Poisson equation (PPE). Several challenges are addressed with this research: constructing a PPE matrix every timestep on the GPU for moving particles, optimising the limited GPU memory, and exploiting fast matrix solvers. The ISPH pressure projection algorithm is implemented as 4 separate stages, each with a particle sweep, including an algorithm for the population of the PPE matrix suitable for the GPU, and mixed precision storage methods. An accurate and robust ISPH boundary condition ideal for parallel processing is also established by adapting an existing WCSPH boundary condition for ISPH. A variety of validation cases are presented: an impulsively started plate, incompressible flow around a moving square in a box, and dambreaks (2-D and 3-D) which demonstrate the accuracy, flexibility, and speed of the methodology. Fragmentation of the free surface is shown to influence the performance of matrix preconditioners and therefore the PPE matrix solution time. The Jacobi preconditioner demonstrates robustness and reliability in the presence of fragmented flows. For a dambreak simulation, GPU speed ups demonstrate up to 10–18 times and 1.1–4.5 times compared to single-threaded and 16-threaded CPU run times respectively. [ABSTRACT FROM AUTHOR]

A symplectic multi-particle tracking model is implemented on the Graphic Processing Units (GPUs) using the Compute Unified Device Architecture (CUDA) language. The symplectic tracking model can preserve phase space structure and reduce non-physical effects in long term simulation, which is important for beam property evaluation in particle accelerators. Though this model is computationally expensive, it is very suitable for parallelization and can be accelerated significantly by using GPUs. In this paper, we optimized the implementation of the symplectic tracking model on both single GPU and multiple GPUs. Using a single GPU processor, the code achieves a factor of 2–10 speedup for a range of problem sizes compared with the time on a single state-of-the-art Central Processing Unit (CPU) node with similar power consumption and semiconductor technology. It also shows good scalability on a multi-GPU cluster at Oak Ridge Leadership Computing Facility. In an application to beam dynamics simulation, the GPU implementation helps save more than a factor of two total computing time in comparison to the CPU implementation. [ABSTRACT FROM AUTHOR]

For highly complex problems, such as the post-Newtonian formulation of compact binaries, the two-particle method may be a better, or even the only, choice to compute the Lyapunov characteristic exponent (LCE). This method avoids the complex calculations of variational equations compared with the variational method. However, the two-particle method sometimes provides spurious estimates to LCEs. In this paper, we first analyze the equivalence in the definition of LCE between the variational and two-particle methods for Hamiltonian systems. Then, we develop a criterion to determine the reliability of LCEs computed by the two-particle method by considering the magnitude of the initial tangent (or separation) vector ξ 0 (or δ 0 ), renormalization time interval τ , machine precision ε , and global truncation error ϵ T . The reliable Lyapunov characteristic indicators estimated by the two-particle method form a V-shaped region, which is restricted by d 0 , ε , and ϵ T . Finally, the numerical experiments with the Hénon–Heiles system, the spinning compact binaries, and the post-Newtonian circular restricted three-body problem strongly support the theoretical results. [ABSTRACT FROM AUTHOR]

Computational Fluid Dynamics (CFD) is one of the most powerful simulation methods, which is used for temporally and spatially resolved solutions of fluid flow, heat transfer, mass transfer, etc. One of the challenges of Computational Fluid Dynamics is the extreme hardware demand. Nowadays super-computers (e.g. High Performance Computing, HPC) featuring multiple CPU cores are applied for solving—the simulation domain is split into partitions for each core. Some of the different methods for partitioning are investigated in this paper. As a practical example, a new open source based solver was utilized for simulating packed bed adsorption, a common separation method within the field of thermal process engineering. Adsorption can for example be applied for removal of trace gases from a gas stream or pure gases production like Hydrogen. For comparing the performance of the partitioning methods, a 60 million cell mesh for a packed bed of spherical adsorbents was created; one second of the adsorption process was simulated. Different partitioning methods available in OpenFOAM ® ( Scotch , Simple , and Hierarchical ) have been used with different numbers of sub-domains. The effect of the different methods and number of processor cores on the simulation speedup and also energy consumption were investigated for two different hardware infrastructures (Vienna Scientific Clusters VSC 2 and VSC 3). As a general recommendation an optimum number of cells per processor core was calculated. Optimized simulation speed, lower energy consumption and consequently the cost effects are reported here. [ABSTRACT FROM AUTHOR]

Abstract: Focusing on the local geometric properties of the shockpeakon for the Degasperis–Procesi equation, a multi-symplectic method for the quasi-Degasperis–Procesi equation is proposed to reveal the jump discontinuity of the shockpeakon for the Degasperis–Procesi equation numerically in this paper. The main contribution of this paper lies in the following: (1) the uniform multi-symplectic structure of the b-family equation is constructed; (2) the stable jump discontinuity of the shockpeakon for the Degasperis–Procesi equation is reproduced by simulating the peakon–antipeakon collision process of the quasi-Degasperis–Procesi equation. First, the multi-symplectic structure and several local conservation laws are presented for the b-family equation with two exceptions ( and ). And then, the Preissman Box multi-symplectic scheme for the multi-symplectic structure is constructed and the mathematical proofs for the discrete local conservation laws of the multi-symplectic structure are given. Finally, the numerical experiments on the peakon–antipeakon collision of the quasi-Degasperis–Procesi equation are reported to investigate the jump discontinuity of shockpeakon of the Degasperis–Procesi equation. From the numerical results, it can be concluded that the peakon–antipeakon collision of the quasi-Degasperis–Procesi equation can be simulated well by the multi-symplectic method and the simulation results can reveal the jump discontinuity of shockpeakon of the Degasperis–Procesi equation approximately. [Copyright &y& Elsevier]

Abstract: This paper describes the architecture, the development and the implementation of Janus II, a new generation application-driven number cruncher optimized for Monte Carlo simulations of spin systems (mainly spin glasses). This domain of computational physics is a recognized grand challenge of high-performance computing: the resources necessary to study in detail theoretical models that can make contact with experimental data are by far beyond those available using commodity computer systems. On the other hand, several specific features of the associated algorithms suggest that unconventional computer architectures–that can be implemented with available electronics technologies–may lead to order of magnitude increases in performance, reducing to acceptable values on human scales the time needed to carry out simulation campaigns that would take centuries on commercially available machines. Janus II is one such machine, recently developed and commissioned, that builds upon and improves on the successful JANUS machine, which has been used for physics since 2008 and is still in operation today. This paper describes in detail the motivations behind the project, the computational requirements, the architecture and the implementation of this new machine and compares its expected performances with those of currently available commercial systems. [Copyright &y& Elsevier]

Abstract: A marker removal optimization technique is developed for particle simulations. The technique uses the linear eigenmode structure in the equilibrium constant-of-motion space to construct an importance function, then removes some markers based on the importance function and adjusts the weights of the leftover markers to optimize the marker distribution function, so as to save markers and computing time. The technique can be directly applied to single-mode linear simulations. For multi-mode or nonlinear simulations, the technique can still be directly applied if there is one most unstable mode that dominates the simulation and does not change too much in the nonlinear stage, otherwise special care is needed, which is discussed in detail in this paper. The technique’s effectiveness, e.g., marker saving factor, depends on how localized is. The technique can be used for a phase space of arbitrary dimension, as long as the constants of motion in equilibrium can be found. In this paper, the technique is tested in a 2D bump-on-tail simulation and a 5D gyrokinetic toroidal Alfvén eigenmode (TAE) simulation and saves markers by factors of 4 and 19, respectively. The technique is not limited to particle-in-cell (PIC) simulations but could be applied to other approaches of marker particle simulations such as particle-in-wavelet (PIW) and grid-free treecode simulations. [Copyright &y& Elsevier]

We consider the relativistic Vlasov–Maxwell (RVM) equations in the limit when the light velocity c goes to infinity. In this regime, the RVM system converges towards the Vlasov–Poisson system and the aim of this paper is to construct asymptotic preserving numerical schemes that are robust with respect to this limit. Our approach relies on a time splitting approach for the RVM system employing an implicit time integrator for Maxwell’s equations in order to damp the higher and higher frequencies present in the numerical solution. A number of numerical simulations are conducted in order to investigate the performances of our numerical scheme both in the relativistic as well as in the classical limit regime. In addition, we derive the dispersion relation of the Weibel instability for the continuous and the discretized problem. [ABSTRACT FROM AUTHOR]

Abstract: Computer modeling is a powerful instructional tool which can be used to engage students in the design of physical models to describe, explain, and predict physics phenomena. Because implementing a model is difficult for researchers and teachers as well as for students, professionals almost always use discipline-specific code libraries to access a needed functionality in a platform independent manner. For example, although three-dimensional (3D) visualization is of great importance when displaying computer-generated data or showing complex motion, few users are prepared to deal with hardware accelerated video cards to graphically display a visualization. This paper describes a Java-based 3D framework which is based on physics principles. Our framework is defined using abstract Java interfaces that are implemented in the Open Source Physics (OSP) code library. The library contains a Simple 3D implementation that uses only the standard Java distribution and will run on any Java-enabled computer. This paper introduces a new implementation that makes use of Java 3D to improve both the performance and the appearance of implemented models. Examples are presented using both pure Java code and the Easy Java Simulations authoring tool and these examples are available through the ComPADRE OSP digital library. [Copyright &y& Elsevier]

Abstract: This paper explores that the different prime moduli can affect both the number of primitive root and the spectral test performance for 64-bit linear congruential generators (LCGs). Three forms of prime modulus and two types restriction on multiplier are considered in this paper. We perform computerized experiments that indicate significant differences exist among the number of primitive root of three forms of prime modulus. These differences can affect the performance of the spectral test. Two good 64-bit LCGs with significantly better spectral values and excellent empirical performance are presented. They are suitable for the requirements of todayʼs computer simulation studies. [Copyright &y& Elsevier]

Abstract: In this paper we describe a HepML format and a corresponding C++ library developed for keeping complete description of parton level events in a unified and flexible form. HepML tags contain enough information to understand what kind of physics the simulated events describe and how the events have been prepared. A HepML block can be included into event files in the LHEF format. The structure of the HepML block is described by means of several XML Schemas. The Schemas define necessary information for the HepML block and how this information should be located within the block. The library libhepml is a C++ library intended for parsing and serialization of HepML tags, and representing the HepML block in computer memory. The library is an API for external software. For example, Matrix Element Monte Carlo event generators can use the library for preparing and writing a header of an LHEF file in the form of HepML tags. In turn, Showering and Hadronization event generators can parse the HepML header and get the information in the form of C++ classes. libhepml can be used in C++, C, and Fortran programs. All necessary parts of HepML have been prepared and we present the project to the HEP community. Program summary: Program title: libhepml Catalogue identifier: AEGL_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEGL_v1_0.html Program obtainable from: CPC Program Library, Queen''s University, Belfast, N. Ireland Licensing provisions: GNU GPLv3 No. of lines in distributed program, including test data, etc.: 138 866 No. of bytes in distributed program, including test data, etc.: 613 122 Distribution format: tar.gz Programming language: C++, C Computer: PCs and workstations Operating system: Scientific Linux CERN 4/5, Ubuntu 9.10 RAM: 1 073 741 824 bytes (1 Gb) Classification: 6.2, 11.1, 11.2 External routines: Xerces XML library (http://xerces.apache.org/xerces-c/), Expat XML Parser (http://expat.sourceforge.net/) Nature of problem: Monte Carlo simulation in high energy physics is divided into several stages. Various programs exist for these stages. In this article we are interested in interfacing different Monte Carlo event generators via data files, in particular, Matrix Element (ME) generators and Showering and Hadronization (SH) generators. There is a widely accepted format for data files for such interfaces – Les Houches Event Format (LHEF). Although information kept in an LHEF file is enough for proper working of SH generators, it is insufficient for understanding how events in the LHEF file have been prepared and which physical model has been applied. In this paper we propose an extension of the format for keeping additional information available in generators. We propose to add a new information block, marked up with XML tags, to the LHEF file. This block describes events in the file in more detail. In particular, it stores information about a physical model, kinematical cuts, generator, etc. This helps to make LHEF files self-documented. Certainly, HepML can be applied in more general context, not in LHEF files only. Solution method: In order to overcome drawbacks of the original LHEF accord we propose to add a new information block of HepML tags. HepML is an XML-based markup language. We designed several XML Schemas for all tags in the language. Any HepML document should follow rules of the Schemas. The language is equipped with a library for operation with HepML tags and documents. This C++ library, called libhepml, consists of classes for HepML objects, which represent a HepML document in computer memory, parsing classes, serializating classes, and some auxiliary classes. Restrictions: The software is adapted for solving problems, described in the article. There are no additional restrictions. Running time: Tests have been done on a computer with Intel(R) Core(TM)2 Solo, 1.4 GHz. Parsing of a HepML file: 6 ms (size of the HepML files is 12.5 Kb) Writing of a HepML block to file: 14 ms (file size 12.5 Kb) Merging of two HepML blocks and writing to file: 18 ms (file size – 25.0 Kb). [Copyright &y& Elsevier]

Abstract: In this paper we present FeynRules, a new Mathematica package that facilitates the implementation of new particle physics models. After the user implements the basic model information (e.g., particle content, parameters and Lagrangian), FeynRules derives the Feynman rules and stores them in a generic form suitable for translation to any Feynman diagram calculation program. The model can then be translated to the format specific to a particular Feynman diagram calculator via FeynRules translation interfaces. Such interfaces have been written for CalcHEP/CompHEP, FeynArts/FormCalc, MadGraph/MadEvent and Sherpa, making it possible to write a new model once and have it work in all of these programs. In this paper, we describe how to implement a new model, generate the Feynman rules, use a generic translation interface, and write a new translation interface. We also discuss the details of the FeynRules code. Program summary: Program title: FeynRules Catalogue identifier: AEDI_v1_0 Program summary URL:: http://cpc.cs.qub.ac.uk/summaries/AEDI_v1_0.html Program obtainable from: CPC Program Library, Queen''s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 15 980 No. of bytes in distributed program, including test data, etc.: 137 383 Distribution format: tar.gz Programming language: Mathematica Computer: Platforms on which Mathematica is available Operating system: Operating systems on which Mathematica is available Classification: 11.1, 11.2, 11.6 Nature of problem: Automatic derivation of Feynman rules from a Lagrangian. Implementation of new models into Monte Carlo event generators and FeynArts. Solution method: FeynRules works in two steps: Restrictions: The Lagrangian must fulfill basic QFT requirements, such as Lorentz and gauge invariance. Only fields with spin 0, 1/2, 1 and 2 are implemented. Unusual features: Translation interfaces to FeynArts, CalcHEP/CompHEP, MadGraph and Sherpa exist. Running time: The running time depends on the complexity of the Lagrangian, and varies from seconds (Standard Model) to minutes (more complicated models, like the 3-Site Model). [Copyright &y& Elsevier]

Abstract: This paper presents a fast algorithm to compute the global clear-sky irradiation, appropriate for extended high-resolution Digital Elevation Models (DEMs). The latest equations published in the European Solar Radiation Atlas (ESRA) have been used as a starting point for the proposed model and solved using a numerical method. A new calculation reordering has been performed to (1) substantially diminish the computational requirements, and (2) to reduce dependence on both, the DEM size and the simulated period, i.e., the period during which the irradiation is calculated. All relevant parameters related to shadowing, atmospheric, and climatological factors have been considered. The computational results demonstrate that the obtained implementation is faster by many orders of magnitude than all existing advanced irradiation models while maintaining accuracy. Although this paper focuses on the clear-sky irradiation, the developed software also computes the global irradiation applying a filter that considers the clear-sky index. [Copyright &y& Elsevier]

Abstract: In some recent papers Li, Voskoboynikov, Lee, Sze and Tretyak suggested an iterative scheme for computing the electronic states of quantum dots and quantum rings taking into account an electron effective mass which depends on the position and electron energy level. In this paper we prove that this method converges globally and linearly in an alternating way, i.e. yielding lower and upper bounds of a predetermined energy level in turn. Moreover, taking advantage of the Rayleigh functional of the governing nonlinear eigenproblem, we propose a variant which converges even quadratically thereby reducing the computational cost substantially. Two examples of finite element models of quantum dots of different shapes demonstrate the efficiency of the method. [Copyright &y& Elsevier]

This paper describes m2rc3, a program that calculates Van Vleck second moments for solids with internal rotation of molecules, ions or their structural parts. Only rotations about C3 axes of symmetry are allowed, but up to 15 axes of rotation per crystallographic unit cell are permitted. The program is very useful in interpreting NMR measurements in solids.Program summary: Title of the program: m2rc3Catalogue number: ADUCProgram summary URL: Program obtainable from: CPC Program Library, Queen''s University of Belfast, N. IrelandLicense provisions: noneComputers: Cray SV1, Cray T3E-900, PCsInstallation: Poznań Supercomputing and Networking Center () and Faculty of Physics, A. Mickiewicz University, Poznań, Poland ()Operating system under which program has been tested: UNICOS ver. 10.0.0.6 on Cray SV1; UNICOS/mk on Cray T3E-900; Windows98 and Windows XP on PCs.Programming language: FORTRAN 90No. of lines in distributed program, including test data, etc.: 757No. of bytes in distributed program, including test data, etc.: 9730Distribution format: tar.gzNature of physical problem: The NMR second moment reflects the strength of the nuclear magnetic dipole–dipole interaction in solids. This value can be extracted from the appropriate experiment and can be calculated on the basis of Van Vleck formula. The internal rotation of molecules or their parts averages this interaction decreasing the measured value of the NMR second moment. The analysis of the internal dynamics based on the NMR second moment measurements is as follows. The second moment is measured at different temperatures. On the other hand it is also calculated for different models and frequencies of this motion. Comparison of experimental and calculated values permits the building of the most probable model of internal dynamics in the studied material. The program described in this paper calculates the second moment for solids with rotation of different groups of spins with C3 symmetry.Method of solution: The rotation of molecules or their parts, for example CH3 groups, is simulated as a random walk process by rotating each individual group of spins about its symmetry axis by an angle allowed by the type of symmetry. It is not a continuous rotation, but is in the form of jumps between consecutive positions allowed by the symmetry of the rotating group. Such a model of rotation fulfills assumptions on which theoretical equations used in NMR are derived. The value of Van Vleck''s second moment averaged by this rotation is evaluated. The degree of averaging depends on the number of rotational jumps simulated during calculation. This number is then expressed in terms of the frequency of rotation and finally into the temperature. As a result we obtain simulated values of the NMR second moment as a function of temperature.Restrictions on the complexity of the problem: The only restriction is the number of spins for which calculations can be performed in a reasonable amount of CPU time. This restriction is therefore a combination of the number of spins in the unit cell, number of unit cells included in the calculation, and the speed of the computer used. The tested version of the program was compiled for a maximum number of 6250 spins, arranged in 125 unit cells. There are 15 axes of rotation allowed per unit cell. Any of these restrictions can be overcome by increasing the dimensions of the appropriate arrays in the program. The dimensions given in the program are sufficient for analysis of most of the NMR data which one can find in the scientific literature. This is due to the fact that the magnetic dipole–dipole interaction decreases with the third power of distance between spins, and calculations including spins up to a distance of about 2.0 nm give a final accuracy of the second moment equal to about 1%, while experimental values are determined with 5% accuracy or even worse. The program was designed to handle any combination of complex rotations, but only about C3 axes. Overcoming this restriction by introducing the possibility of C6 or C4 rotations would require some changes in the program. They may be quite easily introduced by an experienced programmer. [Copyright &y& Elsevier]

Direct Numerical Simulations (DNS) of the Navier Stokes equations is an invaluable research tool in fluid dynamics. Still, there are few publicly available research codes and, due to the heavy number crunching implied, available codes are usually written in low-level languages such as C/C++ or Fortran. In this paper we describe a pure scientific Python pseudo-spectral DNS code that nearly matches the performance of C++ for thousands of processors and billions of unknowns. We also describe a version optimized through Cython, that is found to match the speed of C++. The solvers are written from scratch in Python, both the mesh, the MPI domain decomposition, and the temporal integrators. The solvers have been verified and benchmarked on the Shaheen supercomputer at the KAUST supercomputing laboratory, and we are able to show very good scaling up to several thousand cores. A very important part of the implementation is the mesh decomposition (we implement both slab and pencil decompositions) and 3D parallel Fast Fourier Transforms (FFT). The mesh decomposition and FFT routines have been implemented in Python using serial FFT routines (either NumPy, pyFFTW or any other serial FFT module), NumPy array manipulations and with MPI communications handled by MPI for Python ( mpi4py ). We show how we are able to execute a 3D parallel FFT in Python for a slab mesh decomposition using 4 lines of compact Python code, for which the parallel performance on Shaheen is found to be slightly better than similar routines provided through the FFTW library. For a pencil mesh decomposition 7 lines of code is required to execute a transform. [ABSTRACT FROM AUTHOR]

This paper introduces two new modified fourth-order exponential time differencing Runge–Kutta (ETDRK) schemes in combination with a global fourth-order compact finite difference scheme (in space) for direct integration of nonlinear coupled viscous Burgers’ equations in their original form without using any transformations or linearization techniques. One scheme is a modification of the Cox and Matthews ETDRK4 scheme based on ( 1 , 3 ) -Padé approximation and other is a modification of Krogstad’s ETDRK4-B scheme based on ( 2 , 2 ) -Padé approximation. Efficient versions of the proposed schemes are obtained by using a partial fraction splitting technique of rational functions. The stability properties of the proposed schemes are studied by plotting the stability regions, which provide an explanation of their behavior for dispersive and dissipative problems. The order of convergence of the schemes is examined empirically and found that the modification of ETDRK4 converges with the expected rate even if the initial data are nonsmooth. On the other hand, modification of ETDRK4-B suffers with order reduction if the initial data are nonsmooth. Several numerical experiments are carried out in order to demonstrate the performance and adaptability of the proposed schemes. The numerical results indicate that the proposed schemes provide better accuracy than other schemes available in the literature. Moreover, the results show that the modification of ETDRK4 is reliable and yields more accurate results than modification of ETDRK4-B, while solving problems with nonsmooth data or with high Reynolds number. [ABSTRACT FROM AUTHOR]

Numerical kinetic models of plasma turbulence require careful treatment of conserved quantities. In the collisionless limit, numerical dissipation can impact entropy in a non-controlled manner. In this paper, the impact of the error in entropy conservation is investigated. In a simulation of ion-acoustic turbulence, a large error ( 15 % ) in entropy conservation is found. Surprisingly, this error is independent of the numerical method, scheme, or number of grid points. Adding a collision operator resolves this issue, but only if the collision frequency is large enough that it modifies the qualitative time evolution of observables, such as electric field amplitude, anomalous resistivity, or phase-space structures. [ABSTRACT FROM AUTHOR]

Predictions of plasma parameters in the edge and scrape-off layer of tokamaks is difficult since most modern tokamaks have a divertor and the associated separatrix causes the usually employed field/flux-aligned coordinates to become singular on the separatrix/X-point. The presented field line map approach avoids such problems as it is based on a cylindrical grid: standard finite-difference methods can be used for the discretisation of perpendicular (w.r.t. magnetic field) operators, and the characteristic flute mode property ( k ∥ ≪ k ⊥ ) of structures is exploited computationally via a field line following discretisation of parallel operators which leads to grid sparsification in the toroidal direction. This paper is devoted to the discretisation of the parallel diffusion operator (the approach taken is very similar to the flux-coordinate independent (FCI) approach which has already been adopted to a hyperbolic problem (Ottaviani, 2011; Hariri, 2013)). Based on the support operator method, schemes are derived which maintain the self-adjointness property of the parallel diffusion operator on the discrete level. These methods have very low numerical perpendicular diffusion compared to a naive discretisation which is a critical issue since magnetically confined plasmas exhibit a very strong anisotropy. Two different versions of the discrete parallel diffusion operator are derived: the first is based on interpolation where the order of interpolation and therefore the numerical diffusion is adjustable; the second is based on integration and is advantageous in cases where the field line map is strongly distorted. The schemes are implemented in the new code GRILLIX, and extensive benchmarks and numerous examples are presented which show the validity of the approach in general and GRILLIX in particular. [ABSTRACT FROM AUTHOR]

Calculating the solution of Poisson’s equation relating to space charge force is still the major time consumption in beam dynamics simulations and calls for further improvement. In this paper, we summarize a classical fast Poisson solver in beam dynamics simulations: the integrated Green’s function method. We introduce three optimization steps of the classical Poisson solver routine: using the reduced integrated Green’s function instead of the integrated Green’s function; using the discrete cosine transform instead of discrete Fourier transform for the Green’s function; using a novel fast convolution routine instead of an explicitly zero-padded convolution. The new Poisson solver routine preserves the advantages of fast computation and high accuracy. This provides a fast routine for high performance calculation of the space charge effect in accelerators. [ABSTRACT FROM AUTHOR]

In order to predict the turbulent transport in magnetic fusion experiments, global (i.e., full-torus) gyrokinetic simulations are often carried out. In this context, one frequently encounters situations in which the plasma temperature varies by large factors across the radial simulation domain. In grid-based Eulerian codes, this enforces the use of a very large number of grid points in the two-dimensional velocity space, and, thus, an enormous computational effort. To minimize the computational requirements, one may employ block-structured grids, adapted to the radial changes of the temperature. As the block-structured grids rely on a general approach, they can be applied to different Eulerian gyrokinetic implementations. In this paper, we explain the construction and implementation of such grids in the gyrokinetic code GENE, F. Jenko et al. (2000), and present corresponding simulation results. [ABSTRACT FROM AUTHOR]

This paper presents the numerical methods for the nonlinear simulations of cyclokinetic [Waltz and Zhao Deng (2013)] equations in Fourier harmonics of the gyro-phase. A parallel processed, implicit time advanced, Eulerian (or continuum) code (rCYCLO) is developed. A novel numerical treatment of the magnetic moment velocity space derivative operator guarantees accurate conservation of the incremental entropy. By comparing the cyclokinetic simulations with the corresponding gyrokinetics, we quantitatively test the breakdown of gyrokinetics at high turbulence levels over a range of large relative ion cyclotron frequency ( 10 < Ω ∗ < 100 where Ω ∗ = 1 / ρ ∗ , and ρ ∗ is the relative ion gyroradius). As an important code verification, the rCYCLO gyrokinetic transport recovers cyclokinetic transport at high relative ion cyclotron frequency ( Ω ∗ ⩾ 50 ) and low turbulence levels. In the case of linearly stable ion cyclotron modes, the cyclokinetic transport is lower (not higher) than the gyrokinetic transport at high turbulence levels and low- Ω ∗ values. [ABSTRACT FROM AUTHOR]

The simulation of the emission of beta-delayed gamma rays following nuclear fission and the calculation of time-dependent energy spectra is a computational challenge. The widely used radiation transport code MCNPX includes a delayed gamma-ray routine that is inefficient and not suitable for simulating complex problems. This paper describes the code “MMAPDNG” (Memory-Mapped Delayed Neutron and Gamma), an optimized delayed gamma module written in C, discusses usage and merits of the code, and presents results. The approach is based on storing required Fission Product Yield (FPY) data, decay data, and delayed particle data in a memory-mapped file. When compared to the original delayed gamma-ray code in MCNPX, memory utilization is reduced by two orders of magnitude and the ray sampling is sped up by three orders of magnitude. Other delayed particles such as neutrons and electrons can be implemented in future versions of MMAPDNG code using its existing framework. [ABSTRACT FROM AUTHOR]

This paper presents a new version Java code for the three-dimensional simulation of Cluster–Cluster Aggregation (CCA) model to replace the previous version. Many redundant traverses of clusters-list in the program were totally avoided, so that the consumed simulation time is significantly reduced. In order to show the aggregation process in a more intuitive way, we have labeled different clusters with varied colors. Besides, a new function is added for outputting the particle’s coordinates of aggregates in file to benefit coupling our model with other models. New version program summary Program Title: CCA v04 Program Files doi: http://dx.doi.org10.17632/zwz37tvjny.1 Licensing provisions: Apache-2.0 Programming language: Java Journal reference of previous version: Computer Physics Communications 207 (2016) 547–548 Does the new version supersede the previous version?: Yes Nature of problem: The previous program for CCA model can be optimized for yielding better operation efficiency and visualization effects. Besides, it can be extended for coupling with other models by adding some new functions. Solution method: Some redundant traverses of the clusters-list for updating an important variable were removed technically. Furthermore, displaying different clusters with distinct colors can benefit to the effectiveness of visualization. We have also introduced a new function for outputting the aggregated clusters, so that this model can be easily coupled with other models. Reasons for the new version: 1. In the previous versions [1–3], the global variable of D m a x , which means the maximum diffusion coefficient of clusters, is supposed to be calculated when aggregation occurs. In fact, this variable is critical to determine whether the currently selected cluster carries out diffusion or not. In the previous version, we had to traverse the clusters-list to update D m a x , even though it may keep unchanged after a round of aggregation. But, we have explored that it is not necessary to traverse all clusters, if we compare the previous variable of D m a x with the diffusion coefficient of the new cluster, which is formed by aggregating two clusters. In the case of the new one is larger, D m a x will be updated to it; otherwise, D m a x keep unchanged. Obviously, removing redundant traverses can enhance algorithm efficiency, and the time complexity of the algorithm is closely related to the loop in it. As a result, the new version of code can greatly cut down the simulation time, in contrast to the previous codes. 2. The old versions paint all particles with same color, which does not help to identify different clusters. In order to show the visualization of the 3D aggregate process in different states intuitively, we introduce labeling different clusters with different colors. Consequently, the particles belong to one cluster are painted with the same color. 3. A new function is added to record intermediate or final state of clusters so that it can be used for further research when using other relevant models. Summary of revisions: 1. Reduce unnecessary traverses of the clusters-list for speeding up simulation. 2. Paint clusters with different colors to pursuit better visualization effects. 3. Add a new function of exporting the coordinates of clusters to a text file for benefiting other models. Additional comments: To test the optimization effects offered by the new version of code, we have carried out a comparison experimentto measure the simulation time with different initial particles, by using the new and the previous version 3.0 of code. In the experiments, we set concentration C to 0.01, diffusion exponent γ to 0, sticking probability exponent σ to 1, the sticking probability P 1 to 0.1, absolute temperature T to 298 K, and the side length L of cube was respectively set to 30, 40, 50, 60, 70 and 80 to yield different initial particles, as the number of particles N can be calculated by the formula N = C ∗ L 3 [1]. To avoid the influences of hardware and software, we use Monte Carlo steps ( MCS ) as our simulation time [4–6]. As shown in Fig. 1 , the slope coefficient caused by this new version of code is about 1.3813, it is close to line complexity, as for the previous version, it is 1.5703, larger than the new one. It is obvious the new one has a faster running speed than the previous one. More importantly, the reduction of simulation time becomes more obvious when the number of simulated particles is getting larger. The changed visualization of our program is shownin Fig. 2 . We can clearly see how much clusters in simulation system, and how they distribute. And the button “save” marked red in Fig. 2 can help realize our new function by exporting the particle coordinates to a text file, which also store the related initial conditions. Acknowledgments This work was partially supported by “ National Natural Science Foundation of China (Nos. 41271292 , 61303038 )”. References [1] C. Li, H. Xiong, 3D simulation of the Cluster-Cluster aggregation model, Computer Physics Communications 185 (12) (2014) 3424–3429. [2] K. Zhang, H. Xiong, C. Li, A new version of code Java for 3D simulation of the CCA model, Computer Physics Communications 204 (2016) 214–215. [3] K. Zhang, J. Zuo, Y. Dou, C. Li, H. Xiong, Version 3.0 of code Java for 3D simulation of the CCA model, Computer Physics Communications 207 (2016) 547–548. [4] T. Vicsek, Dynamic scaling for aggregation of clusters, Physical Review Letters 52 (19) (1984) 1669–1672. [5] P. A. Netz, D. Samios, The study of network formation as a cluster-cluster diffusion-limited aggregation process: Modelling of the curing of an epoxy-resin using the Monte Carlo method, Macromolecular Theory Simulations 3 (3) (1994) 607–621. [6] H. Xiong, H. Li, W. Chen, L. Wu, Data structure for on-lattice cluster-cluster aggregation model performance optimization, Computer Physics Communications 185 (3) (2014) 836–840. [ABSTRACT FROM AUTHOR]

OpenSMOKE++ is a general framework for numerical simulations of reacting systems with detailed kinetic mechanisms, including thousands of chemical species and reactions. The framework is entirely written in object-oriented C++ and can be easily extended and customized by the user for specific systems, without having to modify the core functionality of the program. The OpenSMOKE++ framework can handle simulations of ideal chemical reactors (plug-flow, batch, and jet stirred reactors), shock-tubes, rapid compression machines, and can be easily incorporated into multi-dimensional CFD codes for the modeling of reacting flows. OpenSMOKE++ provides useful numerical tools such as the sensitivity and rate of production analyses, needed to recognize the main chemical paths and to interpret the numerical results from a kinetic point of view. Since simulations involving large kinetic mechanisms are very time consuming, OpenSMOKE++ adopts advanced numerical techniques able to reduce the computational cost, without sacrificing the accuracy and the robustness of the calculations. In the present paper we give a detailed description of the framework features, the numerical models available, and the implementation of the code. The possibility of coupling the OpenSMOKE++ functionality with existing numerical codes is discussed. The computational performances of the framework are presented, and the capabilities of OpenSMOKE++ in terms of integration of stiff ODE systems are discussed and analyzed with special emphasis. Some examples demonstrating the ability of the OpenSMOKE++ framework to successfully manage large kinetic mechanisms are eventually presented. Program summary Program title: OpenSMOKE++ Catalogue identifier: AEVY_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEVY_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: GNU General Public License, version 3 No. of lines in distributed program, including test data, etc.: 146353 No. of bytes in distributed program, including test data, etc.: 4890534 Distribution format: tar.gz Programming language: C++. Computer: Any computer that can run a C++ Compiler. Operating system: Tested on Microsoft Windows 7, Ubuntu 14.4. RAM: From a few Mb to several Gb depending on the size of the system being simulated. Classification: 22. External routines: Eigen, Boost C++ Libraries, RapidXML Nature of problem: Evolution of reacting gas mixtures with detailed description of thermodynamic, kinetic and transport data. Solution method: Stiff systems of Ordinary differential Equations, whose solution is obtained using methods based on the Backward Differentiation Formulas (BDF) (LU factorization of dense matrices is required). Additional comments: The code was specifically conceived for managing homogeneous, reacting mixtures including thousands of species and reactions. Running time: Problem-dependent, from seconds (small kinetics) to hours [ABSTRACT FROM AUTHOR]

In this paper, AQUAgpusph, a new free Smoothed Particle Hydrodynamics (SPH) software accelerated with OpenCL, is described. The main differences and progress with respect to other existing alternatives are considered. These are the use of the Open Computing Language (OpenCL) framework instead of the Compute Unified Device Architecture (CUDA), the implementation of the most popular boundary conditions, the easy customization of the code to different problems, the extensibility with regard to Python scripts, and the runtime output which allows the tracking of simulations in real time, or a higher frequency in saving some results without a significant performance lost. These modifications are shown to improve the solver speed, the results quality, and allow for a wider areas of application. AQUAgpusph has been designed trying to provide researchers and engineers with a valuable tool to test and apply the SPH method. Three practical applications are discussed in detail. The evolution of a dam break is used to quantify and compare the computational performance and modeling accuracy with the most popular SPH Graphics Processing Unit (GPU) accelerated alternatives. The dynamics of a coupled system, a Tuned Liquid Damper (TLD), is discussed in order to show the integration capabilities of the solver with external dynamics. Finally, the sloshing flow inside a nuclear reactor is simulated in order to show the capabilities of the solver to treat 3-D problems with complex geometries and of industrial interest. Program summary Program title: AQUAgpusph 1.5 Catalogue identifier: AEVG_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEVG_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: GNU General Public License, version 3 No. of lines in distributed program, including test data, etc.: 1702666 No. of bytes in distributed program, including test data, etc.: 75117178 Distribution format: tar.gz Programming language: C++, OpenCL, Python. Computer: Linux based computers with OpenCL support. Operating system: Linux. Has the code been vectorized or parallelized?: Code is parallelized with OpenCL. Classification: 1.5. Nature of problem: Complex geometry or heavily fragmented free surface fluid dynamics problems where mesh based method cannot be successfully applied. Solution method: SPH is a meshless method where the fluid domain is discretized as a set of fluid particles. The fields in the fluid domain are smoothed using a kernel function, that allows to develop differential operators from the flow field values in scattered sets of particles. Running time: Using an AMD HD-7970 graphic device 2×10 5 time steps of a 2-D simulation, with 10 5 particles and 8×10 2 neighs per particle, is requiring around 9 h of computation. A more detailed performance analysis will be carried out in the practical application section herein. [ABSTRACT FROM AUTHOR]

This paper presents GPELab (Gross–Pitaevskii Equation Laboratory), an advanced easy-to-use and flexible Matlab toolbox for numerically simulating many complex physics situations related to Bose–Einstein condensation. The model equation that GPELab solves is the Gross–Pitaevskii equation. The aim of this first part is to present the physical problems and the robust and accurate numerical schemes that are implemented for computing stationary solutions, to show a few computational examples and to explain how the basic GPELab functions work. Problems that can be solved include: 1d, 2d and 3d situations, general potentials, large classes of local and nonlocal nonlinearities, multi-components problems, and fast rotating gases. The toolbox is developed in such a way that other physics applications that require the numerical solution of general Schrödinger-type equations can be considered. Program summary Program title: GPELab Catalogue identifier: AETU_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AETU_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 26 552 No. of bytes in distributed program, including test data, etc.: 611 289 Distribution format: tar.gz Programming language: Matlab. Computer: PC, Mac. Operating system: Windows, Mac OS, Linux. Has the code been vectorized or parallelized?: Yes RAM: 4000 Megabytes Classification: 2.7, 4.6, 7.7. Nature of problem: Computing stationary solutions for a class of systems (multi-components) of Gross–Pitaevskii equations in 1d, 2d and 3d. This program is particularly well designed for the computation of ground states of Bose–Einstein condensates as well as dynamics. Solution method: We use the imaginary-time method with a Semi-Implicit Backward Euler scheme, a pseudo-spectral approximation and a Krylov subspace method. Running time: From a few minutes for simple problems to a week for more complex situations on a medium computer. [ABSTRACT FROM AUTHOR]

The Crank-Nicolson scheme as well as its modified schemes is widely used in numerical simulations for the nonlinear Schrödinger equation. In this paper, we prove the multisymplecticity and symplecticity of this scheme. Firstly, we reconstruct the scheme by the concatenating method and present the corresponding discrete multisymplectic conservation law. Based on the discrete variational principle, we derive a new variational integrator which is equivalent to the Crank-Nicolson scheme. Therefore, we prove the multisymplecticity again from the Lagrangian framework. Symplecticity comes from the proper discrete Hamiltonian structure and symplectic integration in time. We also analyze this scheme on stability and convergence including the discrete mass conservation law. Numerical experiments are presented to verify the efficiency and invariant-preserving property of this scheme. Comparisons with the multisymplectic Preissmann scheme are made to show the superiority of this scheme. [ABSTRACT FROM AUTHOR]

Abstract: Modern graphics processing units (GPUs) have been widely utilized in magnetohydrodynamic (MHD) simulations in recent years. Due to the limited memory of a single GPU, distributed multi-GPU systems are needed to be explored for large-scale MHD simulations. However, the data transfer between GPUs bottlenecks the efficiency of the simulations on such systems. In this paper we propose a novel GPU Direct–MPI hybrid approach to address this problem for overall performance enhancement. Our approach consists of two strategies: (1) We exploit GPU Direct 2.0 to speedup the data transfers between multiple GPUs in a single node and reduce the total number of message passing interface (MPI) communications; (2) We design Compute Unified Device Architecture (CUDA) kernels instead of using memory copy to speedup the fragmented data exchange in the three-dimensional (3D) decomposition. 3D decomposition is usually not preferable for distributed multi-GPU systems due to its low efficiency of the fragmented data exchange. Our approach has made a breakthrough to make 3D decomposition available on distributed multi-GPU systems. As a result, it can reduce the memory usage and computation time of each partition of the computational domain. Experiment results show twice the FLOPS comparing to common 2D decomposition MPI-only implementation method. The proposed approach has been developed in an efficient implementation for MHD simulations on distributed multi-GPU systems, called MGPU–MHD code. The code realizes the GPU parallelization of a total variation diminishing (TVD) algorithm for solving the multidimensional ideal MHD equations, extending our work from single GPU computation (Wong et al., 2011) to multiple GPUs. Numerical tests and performance measurements are conducted on the TSUBAME 2.0 supercomputer at the Tokyo Institute of Technology. Our code achieves 2 TFLOPS in double precision for the problem with 12003 grid points using 216 GPUs. [Copyright &y& Elsevier]

Abstract: The European Space Agency’s Gaia mission will create the largest and most precise three dimensional chart of our galaxy (the Milky Way), by providing unprecedented position, parallax, proper motion, and radial velocity measurements for about one billion stars. The resulting catalog will be made available to the scientific community and will be analyzed in many different ways, including the production of a variety of statistics. The latter will often entail the generation of multidimensional histograms and hypercubes as part of the precomputed statistics for each data release, or for scientific analysis involving either the final data products or the raw data coming from the satellite instruments. In this paper we present and analyze a generic framework that allows the hypercube generation to be easily done within a MapReduce infrastructure, providing all the advantages of the new Big Data analysis paradigm but without dealing with any specific interface to the lower level distributed system implementation (Hadoop). Furthermore, we show how executing the framework for different data storage model configurations (i.e. row or column oriented) and compression techniques can considerably improve the response time of this type of workload for the currently available simulated data of the mission. In addition, we put forward the advantages and shortcomings of the deployment of the framework on a public cloud provider, benchmark against other popular solutions available (that are not always the best for such ad-hoc applications), and describe some user experiences with the framework, which was employed for a number of dedicated astronomical data analysis techniques workshops. [Copyright &y& Elsevier]

Abstract: In this paper, we discuss the progress in the numerical simulation of the so-called ‘whispering gallery’ modes (WGMs) occurring inside a prolate spheroidal cavity. These modes are mainly concentrated in a narrow domain along the equatorial line of a spheroid and they are famous because of their extremely high quality factor. The scalar Helmholtz equation provides a sufficient accuracy for WGM simulation and (in a contrary to its vector version) is separable in spheroidal coordinates. However, the numerical simulation of ‘whispering gallery’ phenomena is not straightforward. The separation of variables yields two spheroidal wave ordinary differential equations (ODEs), first only depending on the angular, second on the radial coordinate. Though separated, these equations remain coupled through the separation constant and the eigenfrequency, so that together with the boundary conditions they form a singular self-adjoint two-parameter Sturm–Liouville problem. We discuss an efficient and reliable technique for the numerical solution of this problem which enables calculation of highly localized WGMs inside a spheroid. The presented approach is also applicable to other separable geometries. We illustrate the performance of the method by means of numerical experiments. [Copyright &y& Elsevier]

Abstract: Global magnetohydrodynamic (MHD) models play the major role in investigating the solar wind–magnetosphere interaction. However, the huge computation requirement in global MHD simulations is also the main problem that needs to be solved. With the recent development of modern graphics processing units (GPUs) and the Compute Unified Device Architecture (CUDA), it is possible to perform global MHD simulations in a more efficient manner. In this paper, we present a global magnetohydrodynamic (MHD) simulator on multiple GPUs using CUDA 4.0 with GPUDirect 2.0. Our implementation is based on the modified leapfrog scheme, which is a combination of the leapfrog scheme and the two-step Lax–Wendroff scheme. GPUDirect 2.0 is used in our implementation to drive multiple GPUs. All data transferring and kernel processing are managed with CUDA 4.0 API instead of using MPI or OpenMP. Performance measurements are made on a multi-GPU system with eight NVIDIA Tesla M2050 (Fermi architecture) graphics cards. These measurements show that our multi-GPU implementation achieves a peak performance of 97.36 GFLOPS in double precision. [Copyright &y& Elsevier]

Abstract: In the coming era of exascale supercomputing, in-situ visualization will be a crucial approach for reducing the output data size. A problem of in-situ visualization is that it loses interactivity if a steering method is not adopted. In this paper, we propose a new method for the interactive analysis of in-situ visualization images produced by a batch simulation job. A key idea is to apply numerous (thousands to millions) in-situ visualizations simultaneously. The viewer then analyzes the image database interactively during postprocessing. If each movie can be compressed to 100 MB, one million movies will only require 100 TB, which is smaller than the size of the raw numerical data in exascale supercomputing. We performed a feasibility study using the proposed method. Multiple movie files were produced by a simulation and they were analyzed using a specially designed movie player. The user could change the viewing angle, the visualization method, and the parameters interactively by retrieving an appropriate sequence of images from the movie dataset. [Copyright &y& Elsevier]

In this paper, an atomistic geometrical model for the B-DNA configuration is explained. This model accounts for five organization levels of the DNA, up to the 30 nm chromatin fiber. However, fragments of this fiber can be used to construct the whole genome. The algorithm developed in this work is capable to determine which is the closest atom with respect to an arbitrary point in space. It can be used in any application in which a DNA geometrical model is needed, for instance, in investigations related to the effects of ionizing radiations on the human genetic material. Successful consistency checks were carried out to test the proposed model. Program summary: Program title: FindClosestAtom Catalogue identifier: AEPZ_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEPZ_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 1245 No. of bytes in distributed program, including test data, etc.: 6574 Distribution format: tar.gz Programming language: FORTRAN. Computer: Any. Operating system: Multi-platform. RAM: 2 Gb Classification: 3. Nature of problem: The Monte Carlo method is used to simulate the interaction of ionizing radiation with the human genetic material in order to determine DNA damage yields per unit absorbed dose. To accomplish this task, an algorithm to determine if a given energy deposition lies within a given target is needed. This target can be an atom or any other structure of the genetic material. Solution method: This is a stand-alone subroutine describing an atomic-resolution geometrical model of the B-DNA configuration. It is able to determine the closest atom to an arbitrary point in space. This model accounts for five organization levels of the human genetic material, from the nucleotide pair up to the 30 nm chromatin fiber. This subroutine carries out a series of coordinate transformations to find which is the closest atom containing an arbitrary point in space. Atom sizes are according to the corresponding van der Waals radii. Restrictions: The geometrical model presented here does not include the chromosome organization level but it could be easily build up by using fragments of the 30 nm chromatin fiber. Unusual features: To our knowledge, this is the first open source atomic-resolution DNA geometrical model developed for DNA–radiation interaction Monte Carlo simulations. In our tests, the current model took into account the explicit position of about 56×106 atoms, although the user may enhance this amount according to the necessities. Running time: This subroutine can process about 2 million points within a few minutes in a typical current computer. [ABSTRACT FROM AUTHOR]

Abstract: Molecular dynamics simulation, as a complementary tool to experimentation, has become an important methodology for the understanding and design of molecular systems as it provides access to properties that are difficult, impossible or prohibitively expensive to obtain experimentally. Many of the available software packages have been parallelized to take advantage of modern massively concurrent processing resources. The challenge in achieving parallel efficiency is commonly attributed to the fact that molecular dynamics algorithms are communication intensive. This paper illustrates how an appropriately chosen data distribution and asynchronous one-sided communication approach can be used to effectively deal with the data movement within the Global Arrays/ARMCI programming model framework. A new put_notify capability is presented here, allowing the implementation of the molecular dynamics algorithm without any explicit global or local synchronization or global data reduction operations. In addition, this push-data model is shown to very effectively allow hiding data communication behind computation. Rather than data movement or explicit global reductions, the implicit synchronization of the algorithm becomes the primary challenge for scalability. Without any explicit synchronous operations, the scalability of molecular simulations is shown to depend only on the ability to evenly balance computational load. [Copyright &y& Elsevier]

ZKCM is a C++ library developed for the purpose of multiprecision matrix computation, on the basis of the GNU MP and MPFR libraries. It provides an easy-to-use syntax and convenient functions for matrix manipulations including those often used in numerical simulations in quantum physics. Its extension library, ZKCM_QC, is developed for simulating quantum computing using the time-dependent matrix-product-state simulation method. This paper gives an introduction about the libraries with practical sample programs. Program Summary : Program title: ZKCM Catalogue identifier: AEPI_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEPI_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: GNU Lesser General Public License, version 3 No. of lines in distributed program, including test data, etc.: 95600 No. of bytes in distributed program, including test data, etc.: 1133481 Distribution format: tar.gz Programming language: C++. Computer: General computers. Operating system: Unix-like systems, such as Linux, Free BSD, Cygwin on Windows OS, etc. RAM: Several mega bytes–several giga bytes, dependent on the problem instance Classification: 4.8, 4.15. External routines: GNU MP (GMP) [1], MPFR [2] Ver. 3.0.0 or later Nature of problem: Multiprecision computation is helpful to guarantee and/or evaluate the accuracy of simulation results in numerical physics. There is a potential demand for a programming library focusing on matrix computation usable for this purpose with a user-friendly syntax. Solution method: A C++ library ZKCM has been developed for multiprecision matrix computation. It provides matrix operations useful for numerical studies of physics, e.g., the tensor product (Kronecker product), the tracing-out operation, the inner product, the LU decomposition, the Hermitian-matrix diagonalization, the singular-value decomposition, and the discrete Fourier transform. For basic floating-point operations, GMP and MPFR libraries are used. An extension library ZKCM QC has also been developed, which employs the time-dependent matrix-product-state method to simulate quantum computing. Restrictions: Multiprecision computation with more than a half thousand bit precision is often a thousand times slower than double-precision computation for any kind of matrix computation. Additional comments: A user’s manual is placed in the directory “doc” of the package. Each function is explained in a reference manual found in the directories “doc/html” and “doc/latex”. Sample programs are placed in the directory “samples”. Running time: It takes less than thirty seconds to obtain a DFT spectrum for data points of a time evolution of a quantum system described by a matrix Hamiltonian for 256-bit precision when we use recent AMD or Intel CPU with 2.5 GHz or more CPU frequency. It takes three to five minutes to diagonalize a Hermitian matrix for 512-bit precision using the aforementioned CPU. References: [1] The GNU Multiple Precision Arithmetic Library, http://gmplib.org/. [2] L. Fousse et al., MPFR: A multiple-precision binary floating-point library with correct rounding, ACM Trans. Math. Software 33 (2007) 13, http://www.mpfr.org/. [ABSTRACT FROM AUTHOR]

Abstract: The effective delayed neutron fraction plays an important role in kinetics and static analysis of the reactor physics experiments. It is used as reactivity unit referred to as “dollar”. Usually, it is obtained by computer simulation due to the difficulty in measuring it experimentally. In 1965, Keepin proposed a method, widely used in the literature, for the calculation of the effective delayed neutron fraction . This method requires calculation of the adjoint neutron flux as a weighting function of the phase space inner products and is easy to implement by deterministic codes. With Monte Carlo codes, the solution of the adjoint neutron transport equation is much more difficult because of the continuous-energy treatment of nuclear data. Consequently, alternative methods, which do not require the explicit calculation of the adjoint neutron flux, have been proposed. In 1997, Bretscher introduced the -ratio method for calculating the effective delayed neutron fraction; this method is based on calculating the multiplication factor of a nuclear reactor core with and without the contribution of delayed neutrons. The multiplication factor set by the delayed neutrons (the delayed multiplication factor) is obtained as the difference between the total and the prompt multiplication factors. Using Monte Carlo calculation Bretscher evaluated the as the ratio between the delayed and total multiplication factors (therefore the method is often referred to as the -ratio method). In the present work, the -ratio method is applied by Monte Carlo (MCNPX) and deterministic (PARTISN) codes. In the latter case, the ENDF/B nuclear data library of the fuel isotopes (235U and 238U) has been processed by the NJOY code with and without the delayed neutron data to prepare multi-group WIMSD neutron libraries for the lattice physics code DRAGON, which was used to generate the PARTISN macroscopic cross sections. In recent years Meulekamp and van der Marck in 2006 and Nauchi and Kameyama in 2005 proposed new methods for the effective delayed neutron fraction calculation with only one Monte Carlo computer simulation, compared with the -ratio method which require two criticality calculations. In this paper, the Meulekamp/Marck and Nauchi/Kameyama methods are applied for the first time by the MCNPX computer code and the results obtained by all different methods are compared. [Copyright &y& Elsevier]