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]

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]

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]

The Cluster-Cluster Aggregation model (CCA) was often used to simulate the aggregation of colloids, in which the rapid and slow aggregation processes of colloids can be well characterized. In practical system, the movement of particles or clusters occurs in parallel. In the CCA model, in order to facilitate computer simulation, the movement of particles or clusters is processed serially by the method of Metropolis sampling. That is, randomly selecting one particle or cluster to move randomly, colliding with other cluster in the movement, and aggregating according to certain conditions, such aggregation would usually occur between a moving cluster and a static cluster, and this process is essentially a dimerization process. Based on this idea, this study proposes a cluster dichotomy model, in which the dispersion process can be regarded as the inverse process of cluster aggregation, that is, the randomly selected cluster always breaks up into two small clusters. This kind of dispersion is called dichotomy. Based on this model, the rapid and slow dispersion processes of colloidal clusters can be simulated by setting the relevant parameters. The dichotomy model proposed in this paper can be used to study colloidal stability by coupling with the traditional CCA model. [ABSTRACT FROM AUTHOR]

In this paper, we construct a novel linearized finite difference/spectral-Galerkin scheme for three-dimensional distributed-order time–space fractional nonlinear reaction–diffusion-wave equation. By using Gauss–Legendre quadrature rule to discretize the distributed integral terms in both the spatial and temporal directions, we first approximate the original distributed-order fractional problem by the multi-term time–space fractional differential equation. Then, we employ the finite difference method for the discretization of the multi-term Caputo fractional derivatives and apply the Legendre–Galerkin spectral method for the spatial approximation. The main advantage of the proposed scheme is that the implementation of the iterative method is avoided for the nonlinear term in the fractional problem. Additionally, numerical experiments are conducted to validate the accuracy and stability of the scheme. Our approach is show-cased by solving several three-dimensional Gordon-type models of practical interest, including the fractional versions of sine-, sinh-, and Klein–Gordon equations, together with the numerical simulations of the collisions of the Gordon-type solitons. The simulation results can provide a deeper understanding of the complicated nonlinear behaviors of the 3D Gordon-type solitons. [ABSTRACT FROM AUTHOR]

This paper presents a version of simulation program, which facilitates the calculation of changes to the intensity of RHEED oscillations in the function of the glancing angle of incidence of the electron beam, employing various models of scattering crystal potential for heteroepitaxial structure of hexagonal (0001) GaN film nucleated on a 3C-SiC surface, including the possible existence of various diffuse scattering models through the layer parallel to the surface. New version program summary Title of program: RHEED_DIFF_Z Program Files doi: http://dx.doi.org/10.17632/52nxmwzkxx.1 Licensing provisions: GNU General Public License 3 Programming language used: C++ Journal reference of previous version: Computer Physics Communications 207 (2016) 536–538 Does the new version supersede the previous version?: No. It is a supplement to the previous version. Reasons for new version: Responding to users’ feedback we present a practical procedure of construction of simulation program, which facilitates the calculation of changes to the intensity of RHEED rocking curves, employing various models of scattering crystal potential for heteroepitaxial structure of hexagonal (0001) GaN film nucleated on a 3C-SiC(111) surface. Nature of problem: Growth of GaN layers on SiC is of importance for potential electronic device applications. Silicon carbide crystallizes in numerous different modifications, so-called polytypes [1]. Among them, only hexagonal structure 4H-SiC and 6H-SiC have been thoroughly investigated while the cubic 3C-SiC polytype is lagging behind in technological developments. The 3C-SiC has a Zincblende crystal structure and is characterized by an identical orientation of all bilayers in the crystal, where the atomic geometry is repeated every three bilayers along the c-axis this crystal structure ( Fig. 1 ). For this reason, 3C-SiC has the high electron mobility and saturation velocity by reducing phonon scattering resulting from the high symmetry. The lattice mismatch between GaN(0001) and 3C-SiC(111) is about 3.3%, and is smaller than the mismatch between GaN(0001) and Si(111) [2]. Therefore progress in investigations on crystal growth of GaN on 3C-SiC is a key issue for device developments related to this heterostructure. Researchers and technologists manufacturing two-dimensional heterostructures frequently use RHEED rocking curves to control growth of samples at the atomistic level of accuracy. The fundamental scientific problem in such research is to specify both interface type and growth mechanism for subsequent layers. Method of solution: RHEED intensities are calculated within the general framework described in Refs. [2] and [3]. Summary of revisions: The presented version of the program implements an original algorithm of self-consistent calculations for scattering potentials GaN(0001)/3C-SiC(111) and solving a time-independent Schrödinger equation for high-energy electrons. During the numerical calculations of the changes in the intensity of the specular beam in the function of the glancing angle, it was assumed that the azimuth of the incident beam direction corresponds to the one-beam condition, the electron energy equals 10 keV, the glancing angle was increased from 0 . 5 ∘ to 6 . 5 ∘ , and the value of α parameter = 0 . 1 and β = 0 . 5 for the MODEL3 of the scattering potential [3] with the model of ideal SiC/GaN interface [4]. References [1] G. R. Fisher and P. Barnes, Phil. Mag. B 61(2) (1990) 217-236. [2] A. Daniluk, Comput. Phys. Commun. 207 (2016) 536-538. [3] A. Daniluk, Comput. Phys. Commun. 185 (2014) 3001-3009. [4] H. Morkoç, Handbook of Nitride Semiconductors and Devices, Vol. 1: Materials Properties, Physics and Growth, Wiley VCH 2008. [ABSTRACT FROM AUTHOR]

In this paper we present a new version of the program of CCA model. In order to benefit from the advantages involved in the latest technologies, we migrated the running environment from JDK1.6 to JDK1.7. And the old program was optimized into a new framework, so promoted extendibility. Program summary Program title: CCA v02 Catalogue identifier: AEUK_v2_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEUK_v2_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Apache-2.0 license No. of lines in distributed program, including test data, etc.: 822356 No. of bytes in distributed program, including test data, etc.: 41624349 Distribution format: tar.gz Programming language: Java. Computer: PC. Operating system: MS Windows. RAM: 2GB Classification: 14, 16.12. Catalogue identifier of previous version: AEUK_v1_0 Journal reference of previous version: Comput. Phys. Comm. 185(2014)3424 Does the new version supersede the previous version?: Yes Nature of problem: The old program code has some redundancy, the framework of the code is not optimized, and extendibility is not high enough. Solution method: Improved design scheme of the program code, removed some unnecessary or redundant code, optimized design framework, and promoted extendibility. Reasons for new version: 1. In order to benefit from the advantages involved in the latest technologies, we migrated the running environment from JDK1.6 to JDK1.7. 2. The old program code was not concise enough. We tried to make some necessary simplification, and removed redundant code. 3. We further increased the object-oriented programming design ideas, in order to facilitate the maintenance of the code. 4. Simplify some components of the user interface. Summary of revisions: 1. Migration from JDK1.6 to JDK1.7. 2. Optimized the code framework. Additional comments: In [1], the 3D simulation for the CCA model had been realized based on Java programming language. We restructured the code, and we simplified the installation, configuration, and operation of the application program. Running time: Determined by the initial parameters. References: [1] C. Li, H. Xiong, Computer Physics Communications 185 (2014) 3424–3429. [ABSTRACT FROM AUTHOR]