The (py)LIon package is a set of tools to simulate the classical trajectories of ensembles of ions in electrodynamic traps. Molecular dynamics simulations are performed using LAMMPS, an efficient and feature-rich program. (py)LIon has been validated by comparison with the analytic theory describing ion trap dynamics. Notable features include GPU-accelerated force calculations, and treating collections of ions as rigid bodies to enable investigations of the rotational dynamics of large, mesoscopic charged particles. Program summary Program Title: (py)LIon Program Files doi: http://dx.doi.org/10.17632/ywwd9nnxjh.1 Licensing provisions: MIT Programming language: Matlab, Python Subprograms used: LAMMPS Nature of problem: Simulating the dynamics of ions and mesoscopic charged particles confined in an electrodynamic trap using molecular dynamics methods Solution method: Provide a tested, feature-rich API to configure molecular dynamics calculations in LAMMPS Unusual features: (py)LIon can treat collections of ions as rigid bodies to simulate larger objects confined in electrodynamic traps. GPU acceleration is provided through the LAMMPS package.

SPHERA v.9.0.0 (RSE SpA) is a FOSS CFD-SPH research code validated on the following application fields: floods with transport of solid bodies and bed-load transport; fast landslides and their interactions with water reservoirs; sediment removal from water bodies; fuel sloshing tanks; hydrodynamic lubrication for energy efficiency actions in the industrial sector. SPHERA is featured by several numerical schemes dealing with: transport of solid bodies in fluid flows; treatment of fixed and mobile solid boundaries; dense granular flows and an erosion criterion. The source and executable codes, the input files and the free numerical chain of SPHERA v.9.0.0 are presented. Some reference validations and applications are also provided. SPHERA is developed and distributed on a GitHub public repository. Program summary Program title: SPHERA v.9.0.0 Licensing provisions: GNU General Public License 3 (GPL) Programming language: Fortran 95 Supplementary material: software documentation/guide, 34 tutorials Journal Reference of previous version: Amicarelli A., R. Albano, D. Mirauda, G. Agate, A. Sole, R. Guandalini; 2015; A Smoothed Particle Hydrodynamics model for 3D solid body transport in free surface flows; Computers & Fluids, 116:205–228. DOI 10.1016/j.compfluid.2015.04.018 Does the new version supersede the previous version?: Yes Reasons for the new version: scheme for dense granular flows (i.e. bed-load transport, fast landslides); reference Journal publication: Amicarelli A., B. Kocak, S. Sibilla, J. Grabe; 2017; A 3D Smoothed Particle Hydrodynamics model for erosional dam-break floods; International Journal of Computational Fluid Dynamics, 31(10):413-434; DOI 10.1080/10618562.2017.1422731 Nature of problem (approx. 50-250 words): SPHERA v.9.0.0 has been applied to free-surface and multi-phase flows involving the following application fields: floods (with transport of solid bodies, bed-load transport and a domain spatial coverage up to some hundreds of squared kilometres), fast landslides and wave motion, sediment removal from water reservoirs, fuel sloshing tanks, hydrodynamic lubrication. Solution method (approx. 50-250 words): SPHERA v.9.0.0 is a research FOSS (“Free/Libre and Open-Source Software”) code based on the SPH (“Smoothed Particle Hydrodynamics”) technique, a mesh-less Computational Fluid Dynamics numerical method for free surface and multi-phase flows. The five numerical schemes featuring SPHERA v.9.0.0 deal with: dense granular flows; transport of solid bodies in free surface flows; boundary treatment for both mobile and fixed frontiers; 2D erosion criterion. Additional comments including Restrictions and Unusual features (approx. 50-250 words): SPHERA v.9.0.0 is a 3D research FOSS (“Free/Libre and Open-Source Software”) code (developed under the subversion control system Git) with peculiar features for: floods (with transport of solid bodies, bed-load transport and a domain spatial coverage up to some hundreds of squared kilometres), fast landslides and wave motion, sediment removal from water reservoirs, fuel sloshing tanks, hydrodynamic lubrication. The whole numerical chain of SPHERA is made of FOSS, freeware and Open Data numerical tools. References: SPHERA (RSE SpA), https://github.com/AndreaAmicarelliRSE/SPHERA, last access on 28May2019 Amicarelli A., G. Agate, R. Guandalini; 2013; A 3D Fully Lagrangian Smoothed Particle Hydrodynamics model with both volume and surface discrete elements; International Journal for Numerical Methods in Engineering, 95: 419–450, DOI: 10.1002/nme.4514 Amicarelli A., R. Albano, D. Mirauda, G. Agate, A. Sole, R. Guandalini; 2015; A Smoothed Particle Hydrodynamics model for 3D solid body transport in free surface flows; Computers & Fluids, 116:205–228. DOI 10.1016/j.compfluid.2015.04.018 Amicarelli A., B. Kocak, S. Sibilla, J. Grabe; 2017; A 3D Smoothed Particle Hydrodynamics model for erosional dam-break floods; International Journal of Computational Fluid Dynamics, 31(10):413-434; DOI 10.1080/10618562.2017.1422731 Manenti S., S. Sibilla, M. Gallati, G. Agate, R. Guandalini; 2012; SPH Simulation of Sediment Flushing Induced by a Rapid Water Flow; Journal of Hydraulic Engineering ASCE 138(3): 227-311. Di Monaco A., S. Manenti, M. Gallati, S. Sibilla, G. Agate, R. Guandalini; 2011; SPH modeling of solid boundaries through a semi-analytic approach. Engineering Applications of Computational Fluid Mechanics, 5(1):1-15.

The DIRQFAM code calculates the multipole response of even-even axially symmetric deformed nuclei using the framework of relativistic self-consistent mean-field models. The response is calculated by implementing the finite amplitude method for relativistic quasiparticle random phase approximation. Program summary Program Title: DIRQFAM Program Files doi: http://dx.doi.org/10.17632/6gv8nxg4ns.1 Licensing provisions: GPLv3 Programming language: Fortran 90/95, easily downgradable to FORTRAN 77. External routines/libraries: BLAS/LAPACK, version 3.6.0. or higher. Nature of problem: Multipole response of deformed even-even open-shell nuclei can be calculated using the quasiparticle finite amplitude method (QFAM), based on the relativistic self-consistent mean-field models. The particle-hole channel is described by a zero-range relativistic effective interaction, while the particle–particle channel of the effective inter-nucleon interaction is described by a separable finite-range pairing force. The method can be applied to perform systematic studies of collective modes even in heavy deformed nuclei. Solution method: The current implementation computes the multipole response by solving the QFAM equations in a self-consistent iteration scheme. At each iteration the QFAM solutions are updated using the modified Broyden’s method. The QFAM amplitudes are expanded in the simplex-y harmonic oscillator basis. Restrictions: Open-shell even-even nuclei with axially symmetric ground states are considered. An electric multipole operator with J≤3 is used to calculate the response function. Unusual features: The code should be recompiled before running it with different values of one of the following input parameters: number of oscillator shells in the expansion of nucleon spinors (n0f), number of Gauss–Hermite (NGH) or Gauss–Laguerre nodes (NGL), the multipolarity values that define the external perturbation operator (J_multipole, K_multipole).

We present and distribute a new numerical system using classical finite elements with mesh adaptivity for computing two-dimensional liquid–solid phase-change systems involving natural convection. The programs are written as a toolbox for FreeFem++ (www3.freefem.org), a free finite-element software available for all existing operating systems. The code implements a single domain approach. The same set of equations is solved in both liquid and solid phases: the incompressible Navier–Stokes equations with Boussinesq approximation for thermal effects. This model describes naturally the evolution of the liquid flow which is dominated by convection effects. To make it valid also in the solid phase, a Carman-Kozeny-type penalty term is added to the momentum equations. The penalty term brings progressively (through an artificial mushy region) the velocity to zero into the solid. The energy equation is also modified to be valid in both phases using an enthalpy (temperature-transform) model introducing a regularized latent-heat term. Model equations are discretized using Galerkin triangular finite elements. Piecewise quadratic (P2) finite-elements are used for the velocity and piecewise linear (P1) for the pressure. For the temperature both P2 or P1 discretizations are possible. The coupled system of equations is integrated in time using a second-order Gear scheme. Non-linearities are treated implicitly and the resulting discrete equations are solved using a Newton algorithm. An efficient mesh adaptivity algorithm using metrics control is used to adapt the mesh every time step. This allows us to accurately capture multiple solid–liquid interfaces present in the domain, the boundary-layer structure at the walls and the unsteady convection cells in the liquid. We present several validations of the toolbox, by simulating benchmark cases of increasing difficulty: natural convection of air, natural convection of water, melting of a phase-change material, a melting-solidification cycle, and, finally, a water freezing case. Other similar cases could be easily simulated with this toolbox, since the code structure is extremely versatile and the syntax very close to the mathematical formulation of the model. Programm summary Program Title: PCM-Toolbox-2D Program Files doi: http://dx.doi.org/10.17632/phby62rhgv.1 Licensing provisions: Apache License, 2.0 Programming language: FreeFem++(free software, www3.freefem.org) Nature of problem: The software computes 2D configurations of liquid–solid phase-change problems with convection in the liquid phase. Natural convection, melting and solidification processes are illustrated in the paper. The software can be easily modified to take into account different related physical models. Solution method: We use a single domain approach, solving the incompressible Navier–Stokes equations with Boussinesq approximation in both liquid and solid phases. A Carman-Kozeny-type penalty term is added to the momentum equations to bring the velocity to zero into the solid phase. An enthalpy model is used in the energy equation to take into account the phase change. Discontinuous variables (latent heat, material properties) are regularized through an intermediate (mushy) region. Space discretization is based on Galerkin triangular finite elements. Piecewise quadratic (P2) finite-elements are used for the velocity and piecewise linear (P1) for the pressure. For the temperature both P2 or P1 discretizations are possible. A second order Gear scheme is used for the time integration of the coupled system of equations. Non-linear terms are treated implicitly and the resulting discrete equations are solved using a Newton algorithm. A mesh adaptivity algorithm is implemented to reduce the computational time and increase the local space accuracy when (multiple) interfaces are present.

A numerical method to build an orthonormal basis of properly symmetrized hyperspherical harmonic functions is developed. As a part of it, refined algorithms for calculating the transformation coefficients between hyperspherical harmonics constructed from different sets of Jacobi vectors are derived and discussed. Moreover, an algorithm to directly determine the numbers of independent symmetric hyperspherical states (in case of bosonic systems) and antisymmetric hyperspherical-spin–isospin states (in case of fermionic systems) entering the expansion of the A-body wave functions is presented. Numerical implementations for systems made with up to five bodies are reported.

The study of photon-induced reactions in collisions of heavy nuclei at RHIC and the LHC has become an important direction of the research program of these facilities in recent years. In particular, the production of vector mesons in ultra-peripheral collisions (UPC) has been intensively studied. Owing to the intense photon fluxes, the two nuclei participating in such processes undergo electromagnetic dissociation producing neutrons at beam rapidities. Here, we introduce the nOOn (pronounced noon) Monte Carlo program, which generates events containing such neutrons. nOOn is a ROOT based program that can be interfaced with existing generators of vector meson production in UPC or with theoretical calculations of such photonuclear processes. nOOn can also be easily integrated with the simulation programs of the experiments at RHIC and the LHC. Program summary Program Title: nOOn Program Files doi: http://dx.doi.org/10.17632/jynt6cvhjk.1 Licensing provisions: GNU GPLv3 Programming language: C++ External routines: The generator is based on ROOT. Nature of problem: The electromagnetic fields of nuclei at RHIC and the LHC can be described as a flux of quasi-real photons. These photons may interact with one of the nucleus in the opposite beam. There are events of interest where two independent interactions occur, one involving a hard scattering and one from the exchange of soft photons. As a result of the latter, the nucleus get excited and upon de-excitation it may emit neutrons, which are boosted to beam rapidities. The program computes the probability of neutron emission based on existing measurements and some mild modelling; it then generates neutrons in a per-event basis. Solution method: The break-up probabilities are computed using existing data and stored in ROOT objects (graphs and histograms). Photon energies from the accompanying hard process, e.g. vector meson production, are loaded into the program and a catalogue of specific break-up probabilities is constructed. The number of neutrons emitted in the event is generated and the neutrons are produced and boosted into the laboratory frame. The output is a TTree with a TClonesArray of TParticles per event, which can be easily interfaced to the simulation programs of the RHIC and LHC collaborations. Restrictions: At the moment only emission from Pb is available. References: https://github.com/mbroz84/noon

In electronic structure and quantum transport calculations, many physical quantities are integrations over the electron energy, weighted by the Fermi-Dirac distribution function. Green’s function based approaches commonly circumvent the numerically difficult real energy integration by extending the integrand analytically into the complex energy plane, and using a Gaussian quadrature integration over a complex energy contour for zero temperature. For finite temperatures, a much slower convergent sum over the Matsubara frequencies is necessary. We present a generalized quadrature method that uses orthogonal polynomials on the manifold of Matsubara frequencies to enable rapid convergence. Both Gaussian quadrature integration and Matsubara frequency summation methods are shown to be limiting cases of the generalized method. Tests on an all-electron ab initio code and total energy calculation of interacting Anderson impurity model show convergence with a small number of energy mesh points.

Accurate simulations of metal under heavy shocks, leading to fragmentation and ejection of particles, can not be achieved by simply hydrodynamic models and require to be performed at atomic scale using molecular dynamics methods. In order to cope with billions of particles exposed to short range interactions, such molecular dynamics methods need to be highly optimized over massively parallel supercomputers. In this paper, we propose to leverage Adaptive Mesh Refinement techniques to improve efficiency of molecular dynamics code on highly heterogeneous particle configurations. We introduce a series of techniques that optimize the force computation loop using multi-threading and vectorization-friendly data structures. Our design is guided by the need for load balancing and adaptivity raised by highly dynamic particle sets. We analyze performance results on several simulation scenarios, such as the production of an ejecta cloud from shock-loaded metallic surfaces, using a large number of nodes equipped by Intel Xeon Phi Knights Landing processors. Performance obtained with our new Molecular Dynamics code achieves speedups greater than 1.38 againt the state-of-the-art LAMMPS implementation.

A multi-GPGPU development for Mesoscale Simulations using the Dissipative Particle Dynamics method is presented. This distributed GPU acceleration development is an extension of the DL_MESO package to MPI+CUDA in order to exploit the computational power of the latest NVIDIA cards on hybrid CPU–GPU architectures. Details about the extensively applicable algorithm implementation and memory coalescing data structures are presented. The key algorithms’ optimizations for the nearest-neighbour list searching of particle pairs for short range forces, exchange of data and overlapping between computation and communications are also given. We have carried out strong and weak scaling performance analyses with up to 4096 GPUs. A two phase mixture separation test case with 1.8 billion particles has been run on the Piz Daint supercomputer from the Swiss National Supercomputer Center. With CUDA aware MPI, proper GPU affinity, communication and computation overlap optimizations for multi-GPU version, the final optimization results demonstrated more than 94% efficiency for weak scaling and more than 80% efficiency for strong scaling. As far as we know, this is the first report in the literature of DPD simulations being run on this large number of GPUs. The remaining challenges and future work are also discussed at the end of the paper.

We present a code for the large-scale data analysis of electron cyclotron emission (ECE) measurements from magnetized plasmas called ECRad – the Electron Cyclotron Radiation transport model for Advanced Data analysis. Its key features are low computational cost, high robustness and the capability to predict ECE spectra of plasmas with non-thermal electron populations. This is accomplished by combining the absorption coefficient given by Albajar et al. (2007) and a corresponding emissivity for the radiation transport with geometrical optics ray tracing for the computation of the diagnostic line of sight. Another important aspect of ECRad is that it has passed a large amount of verification tests against real measurements by conventional, oblique and ECE imaging diagnostics. This paper explains the physical model of ECRad and its implementation. Furthermore, it is discussed how the code can be used for the inference of the electron temperature from ECE measurements and how an oblique ECE diagnostic can be cross-calibrated with ECRad.

Generalised polylogarithms naturally appear in higher-order calculations of quantum field theories. We present handyG, a Fortran 90 library for the evaluation of such functions, by implementing the algorithm proposed by Vollinga and Weinzierl. This allows fast numerical evaluation of generalised polylogarithms with currently relevant weights, suitable for Monte Carlo integration. Program summary Program Title: handyG Program Files doi: http://dx.doi.org/10.17632/3257y97pj7.1 Licensing provisions: GPLv3 Programming language: Fortran 90 Nature of problem: Numerical evaluation routine for generalised (or Goncharov [1]) polylogarithms that is fast enough for Monte Carlo integration. Solution method: Implementing the algorithm presented by Vollinga and Weinzierl [2] in Fortran 90, providing a Fortran module and a Mathematica interface. Restrictions: There are no theoretical limitations of the weight through the algorithm. However, for arbitrary parameters there are limits through runtime for increasing weight. References [1] A.B. Goncharov, Multiple polylogarithms, cyclotomy and modular complexes, Math. Res. Lett 5 (1998) 497 [1105.2076]. [2] J. Vollinga and S. Weinzierl, Numerical evaluation of multiple polylogarithms, Comput. Phys. Commun. 167 (2005) 177 [hep-ph/0410259].

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.

Genarris is an open source Python package for generating random molecular crystal structures with physical constraints for seeding crystal structure prediction algorithms and training machine learning models. Here we present a new version of the code, containing several major improvements. A MPI-based parallelization scheme has been implemented, which facilitates the seamless sequential execution of user-defined workflows. A new method for estimating the unit cell volume based on the single molecule structure has been developed using a machine-learned model trained on experimental structures. A new algorithm has been implemented for generating crystal structures with molecules occupying special Wyckoff positions. A new hierarchical structure check procedure has been developed to detect unphysical close contacts efficiently and accurately. New intermolecular distance settings have been implemented for strong hydrogen bonds. To demonstrate these new features, we study two specific cases: benzene and glycine. For all polymorphs, the final pools contained the experimental structure. Program summary Program Title: Genarris 2.0 Program Files doi: http://dx.doi.org/10.17632/grx6mz4pjn.1 Licensing provisions: BSD-3 Clause Programming language: Python, C External routines/libraries: Spglib, ASE, pymatgen, SciPy, mpi4py, scikit-learn, PyTorch, FHI-aims. Nature of problem: Molecular crystal structure prediction. Solution method: Genarris 2.0 generates molecular crystal structures over the 230 space groups, on general and special Wyckoff positions, using physical constraints. Down-sampling of the generated structures may be performed subsequently, based on molecular crystal packing descriptors and an unsupervised machine learning algorithm. Lastly, ab initio structure relaxation may be performed for the final pool. Depending on the user-defined workflow implemented, Genarris may be used to generate diverse molecular crystal datasets to seed evolutionary algorithms or to train machine learning algorithms or as a standalone crystal structure prediction method. Restrictions: For crystal structure generation, the molecule of interest must be semi-rigid with no bond rotational degrees of freedom. Unusual features: Genarris 2.0 is a highly distributed program, making use of MPI for Python to implement bindings of the Message Passing Interface (MPI) and offers the user the ability to design and implement workflows by executing a user-defined list of procedures. Genarris 2.0 implements new features including a machine learning model for estimating the molecular volume in the solid state from the single molecule structure, structure generation in special Wyckoff positions of space groups, hierarchical structure checks including rigorous treatment of non-orthogonal structures, and clustering and down-selection workflows combining first principles simulations with machine learning.

In this paper, a linearly-implicit Fourier pseudo-spectral method which preserves discrete mass and energy is developed for the time-dependent 3D Gross–Pitaevskii equation with additional angular momentum rotation. By establishing several discrete semi-norm equivalences between the Fourier pseudo-spectral method and the finite difference method, we establish an optimal H1-error estimate for the proposed scheme without any restrictions on the grid ratio. The convergent rate of the numerical solution is proved to be of order O(N−r+τ2), where N is the number of spatial nodes and τ is the time step. Numerical results are reported to verify the efficiency and accuracy of our new method.

The approach used for computation of the convecting face fluxes and the cell face velocities results in different underlying numerical algorithms in finite volume collocated grid solvers for the incompressible Navier–Stokes equations. In this study, the effect of the following five numerical algorithms on the numerical dissipation rate and on the temporal consistency of a selection of Runge–Kutta schemes is analysed: (1) the original algorithm of Rhie and Chow (1983), (2) the standard OpenFOAM method, (3) the algorithm used by Vuorinen et al. (2014), (4) the Kazemi-Kamyab et al. (2015) method, and (5) the D’Alessandro et al. (2018) approach. The last three algorithms refer to recent implementations of low dissipative numerical methods in OpenFOAM®. No new computational methods are presented in this paper. Instead, the main scientific contributions of this paper are: (1) the systematic assessment of the effect of the considered five numerical approaches on the numerical dissipation rate and on the temporal consistency of the selected Runge–Kutta schemes within one unified framework which we have implemented in OpenFOAM, and (2) the application of the method of Komen et al. (2017) in order to quantify the numerical dissipation rate introduced by three of the five numerical methods in quasi-DNS and under-resolved DNS of fully-developed turbulent channel flow. In addition, we explain the effects of the introduced numerical dissipation on the observed trends in the corresponding numerical results. As one of the major conclusions, we found that the pressure error, which is introduced due to the application of a compact stencil in the pressure Poisson equation, causes a reduction of the order of accuracy of the temporal schemes for the test cases in this study. Consequently, application of higher order temporal schemes is not useful from an accuracy point of view, and the application of a second order temporal scheme appears to be sufficient.

We present JeLLyFysh-Version1.0, an open-source Python application for event-chain Monte Carlo (ECMC), an event-driven irreversible Markov-chain Monte Carlo algorithm for classical N-body simulations in statistical mechanics, biophysics and electrochemistry. The application’s architecture mirrors the mathematical formulation of ECMC. Local potentials, long-ranged Coulomb interactions and multi-body bending potentials are covered, as well as bounding potentials and cell systems including the cell-veto algorithm. Configuration files illustrate a number of specific implementations for interacting atoms, dipoles, and water molecules. Program summary Program title: JeLLyFysh-Version1.0 Program files doi: http://dx.doi.org/10.17632/srrjt9493d.1 Licensing provisions: GNU GPLv3 Programming language: Python 3 Nature of problem: Event-chain Monte Carlo (ECMC) simulations for classical N-body simulations in statistical mechanics, biophysics and electrochemistry. Solution method: Event-driven irreversible Markov-chain Monte Carlo algorithm. Additional comments: The application is complete with sample configuration files, docstrings, and unittests. The manuscript is accompanied by a frozen copy of JeLLyFysh-Version1.0 that is made publicly available on GitHub (repository https://github.com/jellyfysh/JeLLyFysh, commit hash d453d497256e7270e8babc8e04d20fb6d847dee4).

This paper presents the photon physics models used in Serpent 2 Monte Carlo particle transport code. The four main photon interactions – photoelectric effect, Rayleigh scattering, Compton scattering and electron-positron pair production – are included in Serpent, accompanied by three secondary photon production mechanisms (electron-positron annihilation, atomic relaxation and bremsstrahlung emitted by electrons and positrons). Models, algorithms and data used for these interaction mechanisms are described, including new efficient sampling algorithms for photoelectron direction and electron–positron pair production.

The version 3.01 of ELMAG, a Monte Carlo program for the simulation of electromagnetic cascades initiated by high-energy photons and electrons interacting with extragalactic background light (EBL), is presented. Pair production and inverse Compton scattering on EBL photons as well as synchrotron losses are implemented using weighted sampling of the cascade development. New features include, among others, the implementation of turbulent extragalactic magnetic fields and the calculation of three-dimensional electron and positron trajectories, solving the Lorentz force equation. As final result of the three-dimensional simulations, the program provides two-dimensional source images as function of the energy and the time delay of secondary cascade particles. Program summary Program Title: ELMAG 3.01 Program Files doi: http://dx.doi.org/10.17632/gsr7dfnyx6.1 Licensing provisions: CC by NC 3.0. Programming language: Fortran 90 Supplementary material: See http://elmag.sourceforge.net/ Nature of problem: Calculation of secondaries produced by electromagnetic cascades on the extragalactic background light (EBL), including deflections in magnetic fields. Solution method: Monte Carlo simulation of pair production and inverse Compton scattering on EBL photons; weighted sampling of the cascading secondaries; recording of energy, observation angle and time delay of secondary particles at the present epoch in a 1.5-dimensional approximation or of sky-maps in a three-dimensional approach. Restrictions: Using the three-dimensional approach, the energies of cascade photons should be above 1 GeV for Brms≲10−10 G.

We present the automatic code differentiation technique to perform derivative computations in nanoscale phonon transport simulations. This method exploits the concepts of templating and operator overloading in C++ and other similar programming languages to unintrusively convert existing codes into those yielding derivatives of arbitrary order. The idea is demonstrated through the computation of phonon properties such as second and third order force constants, the Gruneisen parameter, group velocities, and the temperature variation of specific heat for materials like graphene and graphene nanoribbons. Derivative values so computed are compared with those obtained using finite difference approaches or with analytical values. The method is found to yield derivative values to machine accuracy, with none of the round-off issues associated with finite difference approaches.

A simple theoretical method for deducing the effective bond-orbital model (EBOM) of III-nitride wurtzite (WZ) semiconductors is presented. In this model, the interaction parameters for zinc-blende (ZB) structures are used as an initial guess for WZ structure based on the two-center approximation. The electronic band structure of III-nitride WZ semiconductors can hence be produced by utilizing this set of parameters modified to include effects due to three-center integrals and fitting with first-principles calculations. Details of the semi-empirical fitting procedure for constructing the EBOM Hamiltonian for bulk III-nitride WZ semiconductors are presented. The electronic band structure of bulk AlN, GaN, and InN with WZ structure calculated by EBOM with modified interaction parameters are shown and compared to the results obtained from density functional (DFT) theory with meta-generalized gradient approximation (mGGA). The set of parameters are further optimized by using a genetic algorithm. In the end, electronic band structures and electron (hole) effective masses near the zone center calculated by the proposed model with best fitting parameters are analyzed and compared with the k⋅p model.

We introduce the open-source package MercuryDPM, which we have been developing over the last few years. MercuryDPM is a code for discrete particle simulations. It simulates the motion of particles by applying forces and torques that stem either from external body forces, (gravity, magnetic fields, etc.) or particle interactions. The code has been developed extensively for granular applications, and in this case these are typically (elastic, plastic, viscous, frictional) contact forces or (adhesive) short-range forces. However, it could be adapted to include long-range (molecular, self-gravity) interactions as well. MercuryDPM is an object-oriented algorithm with an easy-to-use user interface and a flexible core, allowing developers to quickly add new features. It is parallelised using MPI and released under the BSD 3-clause license. Its open-source developers’ community has developed many features, including moving and curved walls; state-of-the-art granular contact models; specialised classes for common geometries; non-spherical particles; general interfaces; restarting; visualisation; a large self-test suite; extensive documentation; and numerous tutorials and demos. In addition, MercuryDPM has three major components that were originally invented and developed by its team: an advanced contact detection method, which allows for the first time large simulations with wide size distributions; curved (non-triangulated) walls; and multicomponent, spatial and temporal coarse-graining, a novel way to extract continuum fields from discrete particle systems. We illustrate these tools and a selection of other MercuryDPM features via various applications, including size-driven segregation down inclined planes, rotating drums, and dosing silos. Program summary Program Title: MercuryDPM Program Files doi: http://dx.doi.org/10.17632/n7jmdrdc52.1 Licensing provisions: BSD 3-Clause Programming language: C++, Fortran Supplementary material: http://mercurydpm.org Nature of problem: Simulation of granular materials, i.e. conglomerations of discrete, macroscopic particles. The interaction between individual grains is characterised by a loss of energy, making the behaviour of granular materials distinct from atomistic materials, i.e. solids, liquids and gases. Solution method: MercuryDPM (Thornton et al., 2013, 2019; Weinhart et al., 2016, 2017, 2019) is an implementation of the Discrete Particle Method (DPM), also known as the Discrete Element Method (DEM) (Cundall and Strack, 1979) [1]. It simulates the motion of individual particles by applying forces and torques that stem either from external forces (gravity, magnetic fields, etc...) or from particle-pair and particle–wall interactions (typically elastic, plastic, dissipative, frictional, and adhesive contact forces). DPM simulations have been successfully used to understand the many unique granular phenomena – sudden phase transitions, jamming, force localisation, etc – that cannot be explained without considering the granular microstructure. Unusual features: MercuryDPM was designed ab initio with the aim of allowing the simulation of realistic geometries and materials found in industrial and geotechnical applications. It thus contains several bespoke features invented by the MercuryDPM team: (i) a neighbourhood detection algorithm (Krijgsman et al., 2014) that can efficiently simulate highly polydisperse packings, which are common in industry; (ii) curved walls (Weinhart et al., 2016) making it possible to model real industrial geometries exactly, without triangulation errors; and (iii) MercuryCG (Weinhart et al., 2012, 2013, 2016; Tunuguntla et al., 2016), a state-of-the-art analysis tool that extracts local continuum fields, providing accurate analytical/rheological information often not available from experiments or pilot plants. It further contains a large range of contact models to simulate complex interactions such as elasto-plastic deformation (Luding, 2008), sintering (Fuchs et al., 2017), melting (Weinhart et al., 2019) , breaking, wet and dry cohesion (Roy et al., 2016, 2017) [2], and liquid migration (Roy et al., 2018), all of which have important industrial applications.

A new method to locate, with millimetre uncertainty, in 3D, a γ-ray source emitting multiple γ-rays in a cascade, employing conventional LaBr3(Ce) scintillation detectors, has been developed. Using 16 detectors in a symmetrical configuration the detector energy and time signals, resulting from the γ-ray interactions, are fed into a new source position reconstruction algorithm. The Monte-Carlo based Geant4 framework has been used to simulate the detector array and a 60Co source located at two positions within the spectrometer central volume. For a source located at (0,0,0) the algorithm reports X, Y, Z values of −0.3 ± 2.5, −0.4 ± 2.4, and −0.6 ± 2.5 mm, respectively. For a source located at (20,20,20) mm, with respect to the array centre, the algorithm reports X, Y, Z values of 20.2 ± 1.0, 20.2 ± 0.9, and 20.1 ± 1.2 mm. The resulting precision of the reconstruction means that this technique could find application in a number of areas including nuclear medicine, national security, radioactive waste assay and proton beam therapy.

In this paper we describe and demonstrate a C++ code written to determine the trajectory of particles traversing oriented single crystals and a CUDA code written to evaluate the radiation spectra from charged particles with arbitrary trajectories. The CUDA/C++ code can evaluate both classical and quantum mechanical radiation spectra for spin 0 and 1/2 particles. We include multiple Coulomb scattering and energy loss due to radiation emission which produces radiation spectra in agreement with experimental spectra for both positrons and electrons. We also demonstrate how GPUs can be used to speed up calculations by several orders of magnitude. This will allow research groups with limited funding or sparse access to super computers to do numerical calculations as if it were a super computer. We show that one Titan V GPU can replace up to 100 Xeon 36 core CPUs running in parallel. We also show that choosing a GPU for a specific job will have great impact on the performance, as some GPUs have better double precision performance than others. Program summary Program Title: Radiation From Charged Particles Penetrating Oriented Crystals Program Files doi: http://dx.doi.org/10.17632/zp9gskrbvg.1 Licensing provisions: MIT license Programming language: C++ and CUDA Nature of problem: Solving the problem of calculating the radiation spectrum emitted from charged particles penetrating oriented single crystals. Exact solutions are not possible analytically, but with Monte Carlo simulations we achieve the closest agreements with experiments. This problem is particularly difficult because of the amount of integrals needed to evaluate the entire radiation spectrum. Solution method: By moving the evaluation of each radiation integral to a thread on a GPU, we are able to parallelize the problem massively, and thereby decrease computation times by several orders of magnitude. Each thread in a Kernel call to the GPU then handles one integral. As Kernel calls can be queued, and the time to evaluate the trajectory of a particle is relatively long, each thread on the CPU evaluates its own trajectory and calls a kernel to evaluate the radiation from that specific particle. In this way we minimize the downtime of the GPU, as there will always be a few CPU threads with a Kernel call ready to be evaluated on the GPU.

CALANIE (CALculation of ANIsotropic Elastic energy) computer program evaluates the elastic interaction correction to the total energy of a localized object, for example a defect in a material simulated using an ab initio or molecular statics approach, resulting from the use of periodic boundary conditions. The correction, computed using a fully elastically anisotropic Green’s function formalism, arises from the elastic interaction between a defect and its own periodically translated images. The long-range field of elastic displacements produced by the defect is described in the elastic dipole approximation. Applications of the method are illustrated by two case studies, one involving an ab initio investigation of point defects and vacancy migration in FCC gold, and another a molecular statics simulation of a dislocation loop. We explore the convergence of the method as a function of the simulation cell size, and note the significance of taking into account the elastic correction in the limit where the size of the defect is comparable with the size of the simulation cell. Program summary Program Title: CALANIE, version 2.0 Program Files doi: http://dx.doi.org/10.17632/3h6xffk9h6.1 Licensing provisions: Apache License, Version 2.0 Programming language: C/C++ Nature of problem: Periodic boundary conditions (PBCs) are often used in the context of ab initio and molecular statics atomic scale simulations. A localized defect in a crystalline material, simulated using PBCs, interacts elastically with its own periodically translated images, and this gives rise to a systematic error in the computed defect formation and migration energies. Evaluating the correction to the total energy resulting from effects of elastic interaction between a defect and its periodic images, to alleviate the contribution to the total energy arising from PBCs, is an essential aspect of any accurate total energy calculation performed using PBCs. Solution method: The energy of interaction between a localized defect and its periodically translated images is computed in the linear elasticity approximation. The energy of elastic interaction is expressed analytically in terms of the elastic dipole tensor of the defect and elastic Green’s function. Elements of the dipole tensor are computed as a part of the simulation evaluating the formation energy of the defect. Elastic Green’s function and its first and second derivatives are computed numerically from the elastic constants of the material. The method and the corresponding numerical procedures are implemented in the CALANIE computer program. The program evaluates matrix elements of the elastic dipole tensor of a localized defect and the elastic correction to the total energy arising from the use of periodic boundary conditions. Restrictions: The approach assumes the validity of the linear elasticity approximation. This limits the accuracy of evaluation of the elastic correction, which becomes less precise if the size of the defect is comparable with the size of the simulation cell. Unusual features: An open source code, containing full detail of the relevant theoretical concepts, algorithms and numerical implementation.

In this paper, we consider numerical approximations for a hydrodynamics coupled Cahn-Hilliard phase-field binary fluid-surfactant model. By adding a quartic form of the gradient potential, we first modify the total free energy for the commonly used phase-field surfactant model into a form which is bounded from below and establish the energy law for the new system. Then we combine the Invariant Energy Quadratization approach for the nonlinear potentials, the projection method for the Navier–Stokes equations, and a subtle implicit-explicit treatment for the stress and convective terms, to arrive at a linear and second-order time marching scheme for solving this system. Meanwhile, to enhance the stability, two crucial linear stabilization terms are added into the scheme thus large time steps are allowed in computations. We further prove the well-posedness of the linear system, and its unconditional energy stability rigorously. Various 2D and 3D numerical experiments are performed to validate the accuracy and energy stability of the proposed scheme.

Brownian Disks Lab (BDL) is a Java-based application for the real-time generation and visualization of the motion of two-dimensional Brownian disks using Brownian Dynamics (BD) simulations. This software is designed to emulate time-lapse microscopy experiments of colloidal fluids in quasi-2D situations, such as sedimented layers of particles, optical trap confinement, or fluid interfaces. Microrheology of bio-inspired fluids through optical-based techniques such as videomicroscopy is a classic tool for obtaining the mechanical properties and molecular behavior of these materials. The results obtained by microrheology notably depend of the time-lapse value of the videomicroscopy setup, therefore, a tool to test the influence of the lack of statistics by simulating Brownian objects in experimental-like situations is needed. We simulate a colloidal fluid by using Brownian Dynamics (BD) simulations, where the particles are subjected to different external applied forces and inter-particle interactions. This software has been tested for the analysis of the microrheological consequences of attractive forces between particles (Einstein, 1905), the influence of image analysis on experimental microrheological results (Xin et al., 2016), and to explore experimental diffusion with optical tweezers (Bevan and Eichmann, 2011). The output results of BDL are directly compatible with the format used by standard microrheological algorithms (Dinsmore et al., 2002). In a context of microrheology of complex bio-inspired fluids, we use this tool here to study if the lack of statistics may influence the observed potential of a bead trapped by optical tweezers. Program summary Program Title: Brownian Disks Lab (BDL) Program Files doi: http://dx.doi.org/10.17632/dbwzdkttkb.1 Licensing provisions: GPLv3 Programming language: Java (JDK 7 and above) Supplementary material: We provide a detailed user manual which describes how to use BDL, the theoretical basis of Brownian dynamics simulations, the particle–particle interactions implemented in this software, and additional details and explanations regarding the developed code. Nature of problem: By using time-lapse microscopy experiments (video-microscopy), we can observe the Brownian motion of colloidal particles under different particle–particle interactions and external forces. Sedimented quasi-two-dimensional layers, fluid interfaces, or optically trapped particles can be considered as two-dimensional colloidal systems. The centers of mass of the colloidal objects are subsequently obtained by the image analysis of the time-lapsed images stored. We need an application to generate an ideal real-time motion of colloidal objects in a simple fluid, providing the position of the particles without the need of image analysis. This software should allow to inspect, before the experiments, the general behavior of a colloidal fluid, including visual inspection of the particles’ movement. Using this application, we should be able to analyze the collective motion of the Brownian objects, the influence of different inter-particle forces, and the limitations of the experimental setup, e.g., the effect of image analysis in the results obtained. Solution method: BDL performs the simulation of Brownian 2D disks contained in a transparent medium with a constant viscosity value. The theoretical scheme allows us to introduce external forces in the disks for testing different experimental conditions, and the interactions observed in experiments on colloidal physics (Einstein, 1905; Xin et al., 2016). We use a computational multi-platform environment without high computing requirements since a small number of particles (n≤500) and small concentrations are typical of time-lapse microscopy experiments. The output data is analogous to a video-microscopy setup: the required statistical quantities can be later calculated from the particles’ positions using microrheology standard algorithms (Bevan and Eichmann, 2011). BDL has been developed using Easy Java/JavaScript Simulations (EjsS) (Dinsmore et al., 2002), a software which allows to simplify the code generation and the visualization of simulated objects. Java allows to run the software in any SO without compilation or installation as long as Java Runtime Environment (JRE) is previously installed in the computer. Additional comments including restrictions and unusual features: Requires SO with Java Runtime Environment (JRE) installed. [1] P. Domínguez-García, Europhys. J. E. Soft. Matter. 35, p. 73, 2012. [2] P. Domínguez-García and M. A. Rubio, Appl. Phys. Lett. 102, p. 074101, 2013. [3] M. Pancorbo, M. A. Rubio, P. Domínguez-García, Procedia Comp. Sci.. 108, p. 166–174, 2017. [4] J. C. Crocker and D. G. Grier, J. Colloid Interface Sci. 179, p. 298–310, 1996.

The article in CPC 185 (2014) 2322 contained errors in the one- and two-loop beta functions of the ξS parameter of the NMSSM. These errors are corrected here. New Version Program Summary Program Title: SOFTSUSY Program Files doi: http://dx.doi.org/10.17632/5d5bs49jxh.1 Licensing provisions: GNU General Public License 3 Programming language: C++, fortran Journal reference of previous version: B. C. Allanach, P. Athron, L. C. Tunstall, A. Voigt and A. G. Williams, Comput. Phys. Commun. 185 (2014) 2322. Does the new version supersede the previous version?: Yes. Reasons for the new version: On page 21 of the original publication, a spurious factor of μjl was introduced in Eq. (D.48); the correct expression should read: (1)βξS(1)=2(λ2+κ2)ξS+4(λaλ+κaκ)ξF+2μ′(2λm32+κmS′2)+4[λμ(mH22+mH12)+κμ′mS2]+4aλm32+2aκmS′2. There are also three types of error in Eq. (D.49), namely • On lines 1-3 the ξF factors in the O(λ2) terms should be brought within the {…} braces; • On lines 11-12, the coefficient of the O(m32) terms should be 2, not 3. • On line 12, the coefficient of the O(λg22) term should be 6, not 3. Thus the correct expression for Eq. (D.49) should read: (2)βξS(2)=−4λ4{ξS+4(aλ∕λ)ξF}−8κ4{ξS+4(aκ∕κ)ξF}−6λ2{ξSTr(YuYu†)+2[(aλ∕λ)Tr(YuYu†)+Tr(UAYu†)]ξF}−6λ2{ξSTr(YdYd†)+2[(aλ∕λ)Tr(YdYd†)+Tr(DAYd†)]ξF}−2λ2{ξSTr(YeYe†)+2[(aλ∕λ)Tr(YeYe†)+Tr(EAYe†)]ξF}−8λ2κ2{ξS+2[(aλ∕λ)+(aκ∕κ)]ξF}−12λ{m32[(aλ∕λ)+μ′]Tr(YuYu†)+m32Tr(UAYu†)+μ{Mu2+[(aλ∕λ)+μ′]Tr(UAYu†)+[mH12+mH22]Tr(YuYu†)}}−12λ{m32[(aλ∕λ)+μ′]Tr(YdYd†)+m32Tr(DAYd†)+μ{Md2+[(aλ∕λ)+μ′]Tr(DAYd†)+[mH12+mH22]Tr(YdYd†)}}−4λ{m32[(aλ∕λ)+μ′]Tr(YeYe†)+m32Tr(EAYe†)+μ{Me2+[(aλ∕λ)+μ′]Tr(EAYe†)+[mH12+mH22]Tr(YeYe†)}}−8λ3{m32[2(aλ∕λ)+μ′]+μ[Mλ2+(aλ∕λ)[(aλ∕λ)+μ′]+mH12+mH22]}−8λ2κ{mS′2[(aλ∕λ)+(aκ∕κ)+μ′]+μ′[Mλ2+(aλ∕λ)[(aκ∕κ)+μ′]+2mS2]}−8κ3{mS′2[2(aκ∕κ)+μ′]+μ′[Mκ2+(aκ∕κ)[(aκ∕κ)+μ′]+2mS2]}+65λg12{2m32[(aλ∕λ)+μ′−M1]+2μ[mH12+mH22−(aλ∕λ)M1−μ′M1+2M12]+λ[2ξF[(aλ∕λ)−M1]+ξS]}+6λg22{2m32[(aλ∕λ)+μ′−M2]+2μ[mH12+mH22−(aλ∕λ)M2−μ′M2+2M22]+λ[2ξF[(aλ∕λ)−M2]+ξS]}. Summary of revisions: See release 4.1.8 at https://softsusy.hepforge.org/. Declaration of competing interest: The authors declare that they have no known competing financial interests or personal relationships that could have appeared to influence the work reported in this paper.

Nektar++ is an open-source framework that provides a flexible, high-performance and scalable platform for the development of solvers for partial differential equations using the high-order spectral/hp element method. In particular, Nektar++ aims to overcome the complex implementation challenges that are often associated with high-order methods, thereby allowing them to be more readily used in a wide range of application areas. In this paper, we present the algorithmic, implementation and application developments associated with our Nektar++ version 5.0 release. We describe some of the key software and performance developments, including our strategies on parallel I/O, on in situ processing, the use of collective operations for exploiting current and emerging hardware, and interfaces to enable multi-solver coupling. Furthermore, we provide details on a newly developed Python interface that enables a more rapid introduction for new users unfamiliar with spectral/hp element methods, C++ and/or Nektar++. This release also incorporates a number of numerical method developments – in particular: the method of moving frames (MMF), which provides an additional approach for the simulation of equations on embedded curvilinear manifolds and domains; a means of handling spatially variable polynomial order; and a novel technique for quasi-3D simulations (which combine a 2D spectral element and 1D Fourier spectral method) to permit spatially-varying perturbations to the geometry in the homogeneous direction. Finally, we demonstrate the new application-level features provided in this release, namely: a facility for generating high-order curvilinear meshes called NekMesh; a novel new AcousticSolver for aeroacoustic problems; our development of a ‘thick’ strip model for the modelling of fluid–structure interaction (FSI) problems in the context of vortex-induced vibrations (VIV). We conclude by commenting on some lessons learned and by discussing some directions for future code development and expansion. Program summary Program Title: Nektar++ Program Files doi: http://dx.doi.org/10.17632/9drxd9d8nx.1 Code Ocean Capsule: https://doi.org/10.24433/CO.9865757.v1 Licensing provisions: MIT Programming language: C++ External routines/libraries: Boost, METIS, FFTW, MPI, Scotch, PETSc, TinyXML, HDF5, OpenCASCADE, CWIPI Nature of problem: The Nektar++ framework is designed to enable the discretisation and solution of time-independent or time-dependent partial differential equations. Solution method: spectral/hp element method

BSHF solves the Hartree–Fock equations in a B-spline basis for atoms, negatively charged ions, and systems of N electrons in arbitrary central potentials. In the B-spline basis the Hartree–Fock integro-differential equations are reduced to a computationally simpler eigenvalue problem. As well as solving this for the ground-state electronic structure self-consistently, the program can calculate discrete and/or continuum excited states of an additional electron or positron in the field of the frozen-target N-electron ground state. It thus provides an effectively complete orthonormal basis that can be used for higher-order many-body theory calculations. Robust and efficient convergence in the self-consistent iterations is achieved by a number of strategies, including by gradually increasing the strength of the electron–electron interaction by scaling the electron charge from a reduced value to its true value. The functionality and operation of the program is described in a tutorial style example. Program summary Program Title: BSHF Program Files doi: http://dx.doi.org/10.17632/fj3y6c58dy.1 Code Ocean Capsule: https://doi.org/10.24433/CO.1226817.v2 Licensing provisions: GPLv3 Programming language: Fortran 90. External routines/libraries: LAPACK. Nature of problem: Self-consistent solution of electronic structure for atoms and electrons in arbitrary central potentials in the Hartree–Fock approximation. Solution method: A B-spline basis is employed that transforms the Hartree–Fock integro-differential equations to a computationally simpler eigenvalue problem. The eigenvalue problem is solved iteratively until self-consistency is achieved. Unusual or notable features: 1. Robust and efficient convergence in the self-consistent iterations is achieved by gradually increasing the value of the electron charge from a reduced value to its true value, i.e., increasing the strength of the electron–electron interaction. In this way all orbitals are calculated simultaneously at every iteration of the self-consistency loop, i.e., without the need to successively fill the occupied shells from the core to valence (as most other Hartree–Fock codes require for convergence). 2. In addition to atoms and negative ions, the program solves the Hartree–Fock equations for systems of N electrons confined in an arbitrary central potential specified by the user: thus the program can be used to e.g., calculate the structure of electrons confined in harmonic potentials, which are known to approximate the electron gas. 3. In addition to calculating the ground state of the N-electron system, the program calculates the discrete and/or continuum excited states for an additional electron or positron in the field of the ‘frozen’ N-electron target. It thus provides an orthonormal basis that can be used as input for many-body theory calculations. Restrictions: The program solves non-relativistic Hartree–Fock equations for spherically symmetric systems only (in modelling systems other than atoms, e.g., harmonically confined electron gas or jellium-type models of clusters, relativistic effects can often be negligible and a non-relativistic treatment is perfectly suitable). For open-shell atoms the central-field approximation is used, i.e., the potential is angularly averaged.

Global linear stability analysis of open flows lead to difficulties associated to boundary conditions, leading to either spurious wave reflections (in compressible cases) or to non-local feedback due to the elliptic nature of the pressure equation (in incompressible cases). A novel approach is introduced to address both these problems. The approach consists of solving the problem using a complex mapping of the spatial coordinates, in a way that can be directly applicable in an existing code without any additional auxiliary variable. The efficiency of the method is first demonstrated for a simple 1D equation modeling incompressible Navier–Stokes, and for a linear acoustics problem. The application to full linearized Navier–Stokes equation is then discussed. A criterion on how to select the parameters of the mapping function is derived by analyzing the effect of the mapping on plane wave solutions. Finally, the method is demonstrated for three application cases, including an incompressible jet, a compressible hole-tone configuration and the flow past an airfoil. The examples allow to show that the method allows to suppress the artificial modes which otherwise dominate the spectrum and can possibly hide the physical modes. Finally, it is shown that the method is still efficient for small truncated domains, even in cases where the computational domain is comparable to the dominant wavelength.

This paper proposes some simple and accurate artificial boundary conditions in order to develop numerical methods to compute the rational solution of the nonlinear Schrödinger equation (NLSE) modelling the dynamics of rogue waves. To overcome the nonzero background condition and the algebraically slow decaying ratio at spatial infinity, we design the boundary conditions by means of a far field asymptotic expansion formulation of the rational solution and some transformations for resting the oscillation in time. Compared to the existing periodic boundary condition, the proposed boundary conditions can achieve fourth-order accuracy at most, i.e., O(L−4) with the interval length L, which means that for getting the presupposed accuracy, a smaller computational interval can be chosen. Meanwhile, their forms are simple, so there is hardly any additional computational cost to implement the numerical methods. Then we compare the proposed boundary conditions and numerical methods in terms of efficiency and accuracy, and identify the most efficient and accurate one for computing the rational solution of NLSE and numerically study their stability and interaction.

The geometry of atomic arrangement underpins the structural understanding of molecules in many fields. However, no general framework of mathematical/computational theory for the geometry of atomic arrangement exists. Here we present “Molecular Geometry (MG)” as a theoretical framework accompanied by “MG Operating System (MGOS)” which consists of callable functions implementing the MG theory. MG allows researchers to model complicated molecular structure problems in terms of elementary yet standard notions of volume, area, etc. and MGOS frees them from the hard and tedious task of developing/implementing geometric algorithms so that they can focus more on their primary research issues. MG facilitates simpler modeling of molecular structure problems; MGOS functions can be conveniently embedded in application programs for the efficient and accurate solution of geometric queries involving atomic arrangements. The use of MGOS in problems involving spherical entities is akin to the use of math libraries in general purpose programming languages in science and engineering. Program summary Program Title: Molecular Geometry Operating System (MGOS) Program Files doi: http://dx.doi.org/10.17632/hp2wmvxsfz.1 Licensing provisions: CC By 4.0 Programming language: C++ Supplementary material: (1) Supplementary Video 1, (2) Supplementary Video 2, (3) Supplementary Video 3, (4) Supplementary Video 4, (5) MGOS manual, and (6) 300 test PDB structure files Nature of problem: For both organic and inorganic molecules, structure determines molecular function and molecular structure is highly correlated with molecular shape or geometry. Hence, many studies were conducted for the analysis and evaluation of the geometry of atomic arrangement. However, most studies were based on Monte Carlo, grid-counting, or approximation methods and a high-quality solution requires heavy computational resources, not to mention about its dependency on computation environment. In this paper, we introduce a unified framework of computational library, Molecular Geometry Operating System (MGOS), based on an analytic method for the molecular geometry of atomic arrangements. We believe that the powerful MGOS application programming interface (API) functions will free scientists from developing and implementing complicated geometric algorithms and let them focus on more important scientific problems. Solution method: Molecular Geometry (MG) is a general framework of mathematical/computational methods for solving molecular structure problems using a geometry-priority philosophy and is implemented by MGOS which is a library of callable C++ API functions. MGOS is developed based on the Voronoi diagram of three-dimensional spheres and its two derivative constructs called the quasi-triangulation and beta-complex. Note that this Voronoi diagram is different from the ordinary Voronoi diagram of points where the points are atom centers. Being an analytic method, the solutions of many geometric queries on atomic arrangement, if not all, are obtained correctly and quickly. The MGOS architecture is carefully designed in a three-tier architecture so that future modifications and/or improvements can be reflected in the application programs with no additional programming by users.

We present an overview of the status and recent developments of FeynHiggs (current version: 2.14.3) since version 2.12.2. The main purpose of FeynHiggs is the calculation of the Higgs-boson masses and other physical observables in the MSSM. For a precise prediction of the Higgs-boson masses for low and high SUSY scales, state-of-the-art fixed-order and effective-field-theory calculations are combined. We first discuss improvements of the fixed-order calculation, namely an optional DR¯ renormalization of the stop sector and a renormalization of the Higgs sector ensuring the chosen input mass to be equivalent with the corresponding physical mass. Second, we describe improvements of the EFT calculation, i.e. an implementation of non-degenerate threshold corrections as well as an interpolation for complex parameters. Lastly, we highlight some improvements of the code structure easing future extensions of FeynHiggs to models beyond the MSSM. New version program summary Program Title: FeynHiggs Program Files doi: http://dx.doi.org/10.17632/drw4ywjb6g.1 Licensing provisions: GPLv3 Programming language: Fortran, C, Mathematica Journal reference of previous version: Comput. Phys. Comm. 180 (2009) 1426 Does the new version supersede the previous version? Yes. Reasons for the new version: Improved calculations and code structure. Summary of revisions: Apart from improvements discussed in other publications: implementation of optional DR¯ renormalization of stop sector, adapted two-loop Higgs sector renormalization, implementation of full non-degenerate threshold corrections, interpolation of EFT calculation for complex parameters, better code structure. Nature of problem: The Minimal Supersymmetric Standard Model (MSSM) allows predictions for the masses and mixings of the Higgs bosons in terms of a few relevant parameters. Therefore, comparisons to experimental data provide constraints on the parameter space. To fully profit from the experimental precision, a comparable level of precision is needed for the theoretical prediction. Solution method: State-of-the-art fixed-order and effective-field-theory calculations are combined to obtain a precise prediction for small as well as large supersymmetry scales.

The calculation of accurate photoelectron spectra (PES) for strong-field laser-atom experiments is a demanding computational task, even in single-active-electron approximation. The Qprop code, published in 2006, has been extended in 2016 in order to provide the possibility to calculate PES using the so-called t-SURFF approach [Tao and Scrinzi (2016)]. In t-SURFF, the flux through a surface while the laser is on is monitored. Calculating PES from this flux through a surface enclosing a relatively small computational grid is much more efficient than calculating it from the widely spread wavefunction at the end of the laser pulse on a much larger grid. However, the smaller the minimum photoelectron energy of interest is, the more post-propagation after the actual laser pulse is necessary. This drawback of t-SURFF has been overcome by Morales et al. [Morales et al. (2016)] by noticing that the propagation of the wavefunction from the end of the laser pulse to infinity can be performed very efficiently in a single step. In this work, we introduce Qprop 3.0, in which this single-step post-propagation (dubbed i-SURFV) is added. Examples, illustrating the new feature, are discussed. A few other improvements, concerning mainly the parameter files, are also explained. NEW VERSION PROGRAM SUMMARY Program Title: Qprop Program Files doi: http://dx.doi.org/10.17632/cxj2ygn4ph.2 Licensing provisions: GNU General Public License, version 3 Programming language: C++ External routines/libraries: GNU Scientific Library, Open MPI (optional). Journal reference of previous version: Comput. Phys. Comm. 207(2016) 452–463 Does the new version supersede the previous version?: Fully supports the functionality of Qprop 2.0. Nature of problem: Efficient calculation of PES for typical strong-field and attosecond physics ionization scenarios. Solution method: The time-dependent Schrödinger equation is solved by propagating the electronic wavefunction using a Crank–Nicolson propagator. The wavefunction is represented by an expansion in spherical harmonics. The t-SURFF method in combination with i-SURFV is used to calculate PES. Reasons for the new version: The i-SURFV method is employed to speed up the calculation of PES. Summary of revisions: The i-SURFV method is implemented. A set of examples is provided. Additional comments including restrictions and unusual features: The atomic potential needs to be of finite range in case of t-SURFF/i-SURFV usage (i.e., the Coulomb tail is truncated at sufficiently large distances). The laser-matter interaction is described in dipole approximation and velocity gauge. For additional information see www.qprop.de

UKRmol+ is a new implementation of the time-independent UK R-matrix electron-molecule scattering code. Key features of the implementation are the use of quantum chemistry codes such as Molpro to provide target molecular orbitals; the optional use of mixed Gaussian – B-spline basis functions to represent the continuum and improved configuration and Hamiltonian generation. The code is described, and examples covering electron collisions from a range of targets, positron collisions and photoionization are presented. The codes are freely available as a tarball from Zenodo. Program summary Program Title: UKRmol+ Program Files doi: http://dx.doi.org/10.17632/k3ny7zcfrb.1 Code Ocean Capsule: https://doi.org/10.24433/CO.2477858.v1 Licensing provisions: GNU GPLv3 Programming language: Fortran 95 with use of some Fortran 2003 features External routines/libraries: LAPACK, BLAS; optionally MPI, ScaLAPACK, Arpack, SLEPc Nature of problem: The computational study of electron and positron scattering from a molecule requires the determination of multicentric time-independent wavefunctions describing the target+projectile system. These wavefunctions can also be used to calculate photoionization cross sections (in this case the free particle is the ionized electron) or provide input for time-dependent calculations of laser-induced ultrafast processes. Solution method: We use the R-matrix method [1], that partitions space into an ‘inner’ and an ‘outer’ region. In the inner region (within a few tens of a0 of the nuclei at most) exchange and correlation are taken into account. In the outer region, where the free particle is distinguishable from the target electrons, a single-centre multipole potential describes its interaction with the molecule. The key computational step is the building and diagonalization of the target + free particle Hamiltonian in the inner region, making use of integrals generated using the GBTOlib library. The eigenpairs obtained are then used as input to the outer region suite to determine scattering quantities (K-matrices, etc.) or transition dipole moments and, from them, photoionization cross sections. The suite also generates input data for the R-matrix with time (RMT) suite [2]. Additional comments: CMake scripts for the configuration, compilation, testing and installation of the suite are provided. This article describes the release version UKRmol-in 3.0, that uses GBTOlib 2.0, and UKRmol-out 3.0. Program repository available at: https://gitlab.com/UK-AMOR/UKRmol References [1] P. G. Burke, R-Matrix Theory of Atomic Collisions: Application to Atomic, Molecular and Optical Processes. Springer, 2011. [2] A. Brown, et al RMT: R-matrix with time-dependence. Solving the semi-relativistic, time-dependent Schrödinger equation for general, multi-electron atoms and molecules in intense, ultrashort, arbitrarily polarized laser pulses., Computer Phys. Comm., in press.

AllScale is a programming environment targeting simplified development of highly scalable parallel applications by dividing development responsibilities into silos. The front-end AllScale API provides a simple C++ development environment through a suite of parallel constructs expressions denoting tasks operating concurrently. This interfaces with the other components of the toolchain (core-level API, compiler and runtime) which manages tasks related to the machine and system level, hidden to the user. The paper describes the development of two large-scale parallel applications within the AllScale API, namely, an advection- diffusion model with data assimilation and a Lagrangian space-weather simulation model based on a particle-in-cell method. We present mathematical formulations and implementations and evaluate parallel constructs developed using the AllScale API. The performance of the applications from the perspective of both parallel scalability, and more importantly productivity are assessed. We demonstrate how the AllScale API can greatly improve developer productivity while maintaining parallel performance in two applications with distinct numerical characteristics. Code complexity metrics demonstrate reduction in application specific implementations of up to 30% while performance tests on three different compute systems demonstrate comparable parallel scalability to an MPI version of the code.

ECOGEN, a new open-source computational fluid dynamics code is presented. It is a multi-model tool devoted to the simulation of compressible flows. A large range of problems can be solved, from single-phase gas dynamics to multiphase, multiphysics flows including interface problems between pure fluids. This code is suited for strongly unsteady flows. The numerical solver of ECOGEN is implemented in a flexible structure making the code able to compute such complex flows on different kind of discretization grids. The implemented hyperbolic solver is able to deal with Cartesian geometries as well as unstructured grids. A recent adaptive mesh refinement method is also implemented. Its numerical implementation is presented in details to help the enthusiastic developer to contribute to this open-source project. Representative test cases are presented to show the tool abilities and to open the gate for future developments. Program summary Program title: ECOGEN Program files doi: http://dx.doi.org/10.17632/5bvx4g39dw.1 Licensing provisions: GNU General Public License 3 Programming language: C++ and XML Supplementary material: MPI Library required Nature of problem: The code solves sets of partial differential equations of compressible, multiphase flows in the framework of diffuse-interface methods. It is dedicated to unsteady flows involving acoustic waves, shock waves and material interfaces between liquids and gases. Phase change problems (heating or cavitating flows) can be treated with respect of physical conservation principles and thermodynamics consistency. Solution method: The numerical method is based on finite volume discretization involving approximate Riemann solvers on different multi-dimensional grids: Cartesian (with or without AMR algorithms) or unstructured. Time and space integration scheme is based on first and second-order methods using the MUSCL approach. The time integration is explicit, the time step obeys a CFL condition. The algorithm is using Message Passing Interface library for the treatment of communications in parallel simulations. Geometrical domain decomposition is automatically generated for Cartesian grids. Additional comments: Official web site: https://code-mphi.github.io/ECOGEN/ Official documentation: https://code-mphi.github.io/ECOGEN/docs/sphinx_docs/index.html

The combination of positron emission tomography (PET) with magnetic resonance (MR) imaging opens the way to more accurate diagnosis and improved patient management. At present, the data acquired by PET-MR scanners are essentially processed separately, but the opportunity to improve accuracy of the tomographic reconstruction via synergy of the two imaging techniques is an active area of research. In this paper, we present Release 2.1.0 of the CCP-PETMR Synergistic Image Reconstruction Framework (SIRF) software suite, providing an open-source software platform for efficient implementation and validation of novel reconstruction algorithms. SIRF provides user-friendly Python and MATLAB interfaces built on top of C++ libraries. SIRF uses advanced PET and MR reconstruction software packages and tools. Currently, for PET this is Software for Tomographic Image Reconstruction (STIR); for MR, Gadgetron and ISMRMRD; and for image registration tools, NiftyReg. The software aims to be capable of reconstructing images from acquired scanner data, whilst being simple enough to be used for educational purposes. The most recent version of the software can be downloaded from http://www.ccppetmr.ac.uk/downloads and https://github.com/CCPPETMR/. Program summary Program Title: Synergistic Image Reconstruction Framework (SIRF) Program Files doi: http://dx.doi.org/10.17632/s45f5jh55j.1 Licensing provisions: GPLv3 and Apache-2.0 Programming languages: C++, C, Python, MATLAB Nature of problem: In current practice, data acquired by PET-MR scanners are processed separately. Methods for improving the accuracy of the tomographic reconstruction using the synergy of the two imaging techniques are actively being investigated by the PET-MR research and development community, however, practical application is heavily reliant on software. Open-source software available to the PET-MR community – such as the PET package (STIR) (Thielemans et al., 2012) and the MR package Gadgetron (Hansen and Sørensen, 2013) – provide a basis for new synergistic PET-MR software. However, these two software packages are independent and have very different software architectures. They are mostly written in C++ but many researchers in the PET-MR community are more familiar with script-style languages, such as Python and MATLAB, which enable rapid prototyping of novel reconstruction algorithms. In the current situation it is difficult for researchers to exploit any synergy between PET and MR data. Furthermore, techniques from one field cannot easily be applied in the other. Solution method: In SIRF, the bulk of computation is performed by available advanced open-source reconstruction and registration software (currently STIR, Gadgetron and NiftyReg) that can use multithreading and GPUs. The SIRF C++ code provides a thin layer on top of these existing libraries. The SIRF layer has unified data-containers and access mechanisms. This C++ layer provides the basis for a simple and intuitive Python and MATLAB interface, enabling users to quickly develop and test their reconstruction algorithms using these scripting languages only. At the same time, advanced users proficient in C++ can directly utilise wider SIRF functionality via the SIRF C++ libraries that we provide.

Atomistic modeling is important for studying physical and chemical properties of materials. Recently, machine learning interaction potentials have gained much more attentions as they can provide density functional theory level predictions within negligible time. The symmetry function descriptor based atomistic neural network is the most widely used model for modeling alloys. To precisely describe complex potential energy surfaces, integrating advanced metrics, such as force or virial stress, into training can be of great help. In this work, we propose a virtual-atom approach to model the total energy of symmetry function descriptors based atomistic neural network. Our approach creates the computation graph directly from atomic positions. Thus, the derivations of forces and virial can be handled by TensorFlow automatically and efficiently. The virtual atom approach with AutoGrad within TensorFlow allows for efficient training to not just energies and forces, but also virial stress. Thisnew approach is implemented in our open-source program TensorAlloy, which supports constructing machine learning interaction potentials for both molecules and solids. The QM7 and SNAP/Ni-Mo datasets are used to demostrate the performances of our program. Program summary Program Title: TensorAlloy Program Files doi: http://dx.doi.org/10.17632/w8htd7vmwh.1 Licensing provisions: LGPL Programming language: Python 3.7 Nature of problem: Modeling interatomic interactions with the symmetry function descriptor based atomistic neural networks. Solution method: The TensorAlloy program is built upon TensorFlow and the virtual-atom approach. TensorAlloy can build direct computation graph from atomic positions to total energy. Atomic forces and virial stress tensors are handled by TensorFlow automatically and efficiently. Additional comments including restrictions and unusual features: This program needs TensorFlow 1.13.*. Neither newer or older TensorFlow is supported.

Heavy-ion collisions at center-of-mass energies between 1 and 100 GeV/nucleon are essential to understand the phase diagram of QCD and search for its critical point. At these energies the net baryon density of the system can be high, and simulating its evolution becomes an indispensable part of theoretical modeling. We here present the (3+1)-dimensional diffusive relativistic hydrodynamic code BEShydro which solves the equations of motion of second-order Denicol-Niemi-Molnar-Rischke (DNMR) theory, including bulk and shear viscous currents and baryon diffusion currents. BEShydro features a modular structure that allows to easily turn on and off baryon evolution and different dissipative effects and thus to study their physical effects on the dynamical evolution individually. An extensive set of test protocols for the code, including several novel tests of the precision of baryon transport that can also be used to test other such codes, is documented here and supplied as a permanent part of the code package. Program summary Program Title: BEShydro Program Files doi: http://dx.doi.org/10.17632/xwywvb2psm.1 Licensing provisions: GPLv3 Programming language: C++ External routines/libraries: GNU Scientific Library (GSL) Nature of problem: (3+1)-dimensional dynamical evolution of hot and dense matter created in relativistic heavy-ion collisions using second-order dissipative relativistic fluid dynamics, including evolution of net baryon number and its dissipative diffusion current. Solution method: Runge–Kutta Kurganov-Tadmor algorithm.

MiTMoJCo (Microscopic Tunneling Model for Josephson Contacts) is C code which aims to assist modeling of superconducting Josephson contacts based on the microscopic tunneling theory. The code offers implementation of a computationally demanding part of this calculation, that is evaluation of superconducting pair and quasiparticle tunnel currents from the given tunnel current amplitudes (TCAs) which characterize the junction material. MiTMoJCo comes with a library of pre-calculated TCAs for frequently used Nb-AlOx-Nb and Nb-AlN-NbN junctions, a Python module for developing custom TCAs, supplementary optimum filtration module for extraction of a constant component of a sinusoidal signal and examples of modeling few common cases of superconducting Josephson contacts. Program summary Program Title: MiTMoJCo: Microscopic Tunneling Model for Josephson Contacts Program Files doi: http://dx.doi.org/10.17632/664k9g9zr7.1 Licensing provisions: GPLv3 Programming language: C, Python Nature of problem: Modeling superconducting Josephson contacts based on the microscopic tunneling theory; calculation and fitting of the tunnel current amplitudes. Solution method: Computationally efficient Odintsov-Semenov-Zorin algorithm is used to account for the memory effects in pair and quasiparticle tunnel currents.

A new approach for evaluating Hellmann–Feynman forces within a non-local potential is introduced. Particularly, the case of Hellmann–Feynman theorem applied within density functional theory in combination with nonlocal ab-initio pseudopotentials, discretized by the finite-element method, is discussed in detail. The validity of the new approach is verified using test calculations on simple molecules and the convergence properties (w.r.t. the DFT loop) are analyzed. A comparison to other previously published approaches to Hellmann–Feynman forces calculations is shown to document that the new approach mitigates, for l-dependent as well as for separable forms of nonlocal pseudopotentials, the efficiency and/or accuracy problems arising in the methods published so far.

This paper summarises the theory and functionality behind Questaal, an open-source suite of codes for calculating the electronic structure and related properties of materials from first principles. The formalism of the linearised muffin-tin orbital (LMTO) method is revisited in detail and developed further by the introduction of short-ranged tight-binding basis functions for full-potential calculations. The LMTO method is presented in both Green’s function and wave function formulations for bulk and layered systems. The suite’s full-potential LMTO code uses a sophisticated basis and augmentation method that allows an efficient and precise solution to the band problem at different levels of theory, most importantly density functional theory, LDA +U, quasi-particle self-consistent GW and combinations of these with dynamical mean field theory. This paper details the technical and theoretical bases of these methods, their implementation in Questaal, and provides an overview of the code’s design and capabilities. Program summary Program Title: Questaal Program Files doi: http://dx.doi.org/10.17632/35jxxtzpdn.1 Code Ocean Capsule: https://doi.org/10.24433/CO.3778701.v1 Licensing provisions: GNU General Public License, version 3 Programming language: Fortran, C, Python, Shell Nature of problem: Highly accurate ab initio calculation of the electronic structure of periodic solids and of the resulting physical, spectroscopic and magnetic properties for diverse material classes with different strengths and kinds of electronic correlation. Solution method: The many electron problem is considered at different levels of theory: density functional theory, many body perturbation theory in the GW approximation with different degrees of self consistency (notably quasiparticle self-consistent GW) and dynamical mean field theory. The solution to the single-particle band problem is achieved in the framework of an extension to the linear muffin-tin orbital (LMTO) technique including a highly precise and efficient full-potential implementation. An advanced fully-relativistic, non-collinear implementation based on the atomic sphere approximation is used for calculating transport and magnetic properties.

We have developed a symbolic algebra approach to automatically produce, verify, and optimize computer code for the Fast Multipole Method (FMM) operators. This approach allows for flexibility in choosing a basis set and kernel, and can generate computer code for any expansion order in multiple languages. The procedure is implemented in the publicly available Python program Mosaic. Optimizations performed at the symbolic level through algebraic manipulations significantly reduce the number of mathematical operations compared with a straightforward implementation of the equations. We find that the optimizer is able to eliminate 20%–80% of the floating-point operations and for the expansion orders p≤10 it changes the observed scaling properties. We present our approach using three variants of the operators with the Cartesian basis set for the harmonic potential kernel 1∕r, including the use of totally symmetric and traceless multipole tensors.

This paper presents the current state of the global gyrokinetic code Orb5 as an update of the previous reference (Jolliet et al., 2007). The Orb5 code solves the electromagnetic Vlasov-Maxwell system of equations using a PIC scheme and also includes collisions and strong flows. The code assumes multiple gyrokinetic ion species at all wavelengths for the polarization density and drift-kinetic electrons. Variants of the physical model can be selected for electrons such as assuming an adiabatic response or a “hybrid” model in which passing electrons are assumed adiabatic and trapped electrons are drift-kinetic. A Fourier filter as well as various control variates and noise reduction techniques enable simulations with good signal-to-noise ratios at a limited numerical cost. They are completed with different momentum and zonal flow-conserving heat sources allowing for temperature-gradient and flux-driven simulations. The code, which runs on both CPUs and GPUs, is well benchmarked against other similar codes and analytical predictions, and shows good scalability up to thousands of nodes.

We present a distributed memory many-GPU implementation of the Physalis method for resolving spherical particles in disperse multiphase flow simulations. The current work extends a previous single-GPU computational procedure by implementing a distributed memory Poisson solver and distributed finite-size particle methods using MPI. We document the changes required to move to a distributed memory model for both the fluid and solid phases. We benchmark the code with up to one million resolved particles in a domain size of 19203 on 216 GPUs at the Maryland Advanced Research Computing Center and present strong and weak scaling results. Finally, by taking advantage of the realization that the solution procedure for the pressure Poisson equation can be implemented using a symmetric matrix, we are able to replace the biconjugate gradient stabilized algorithm used in previous work with the conjugate gradient algorithm.

The PyProcar Python package plots the band structure and the Fermi surface as a function of site and/or s,p,d,f - projected wavefunctions obtained for each k-point in the Brillouin zone and band in an electronic structure calculation. This can be performed on top of any electronic structure code, as long as the band and projection information is written in the PROCAR format, as done by the VASP and ABINIT codes. PyProcar can be easily modified to read other formats as well. This package is particularly suitable for understanding atomic effects into the band structure, Fermi surface, spin texture, etc. PyProcar can be conveniently used in a command line mode, where each one of the parameters define a plot property. In the case of Fermi-surfaces, the package is able to plot the surface with colors depending on other properties such as the electron velocity or spin projection. The mesh used to calculate the property does not need to be the same as the one used to obtain the Fermi surface. A file with a specific property evaluated for each k-point in a k−mesh and for each band can be used to project other properties such as electron–phonon mean path, Fermi velocity, electron effective mass, etc. Another existing feature refers to the band unfolding of supercell calculations into predefined unit cells. Program summary Program Title: PyProcar Program Files doi: http://dx.doi.org/10.17632/d4rrfy3dy4.1 Licensing provisions: GPLv3 Programming language: Python Nature of problem: To automate, simplify and serialize the analysis of band structure and Fermi surface, especially for high throughput calculations. Solution method: Implementation of a Python library able to handle, combine, parse, extract, plot and even repair data from density functional calculations. PyProcar uses color maps on the band structures or Fermi surfaces to give a simple representation of the relevant characteristics of the electronic structure. Additional comments: Features: PyProcar can produce high-quality figures of band structures and Fermi surfaces (2D and 3D), projection of atomic orbitals, atoms, and/or spin components. Restrictions: Only the VASP package is currently fully supported, the latest version of Abinit is partially supported (it will be fully supported in the Abinit versions 9.x). The PROCAR file format can easily be implemented within any DFT code.

mDCThermalC is a program written in Python for computing lattice thermal conductivity of crystalline bulk materials using the modified Debye-Callaway model. Building upon the traditional Debye-Callaway theory, the modified model obtains the lattice thermal conductivity by averaging the contributions from acoustic and optical branches based on their specific heat. The only inputs of this program are the phonon spectrum, phonon velocity and Grüneisen parameter, all of which can be calculated using third-party ab initio packages, making the method fully parameter-free. This leads to a fast and accurate evaluation and enables high-throughput calculations of lattice thermal conductivity even in large and complex systems. In addition, this program calculates the specific heat and phonon relaxation times for different scattering processes, which will be beneficial for understanding the phonon transfer behavior. Program summary Program Title: mDCThermalC Program Files doi: http://dx.doi.org/10.17632/s9b8y8t92c.1 Licensing provisions: GPLv3 Programming language: Python External routines/libraries: Numpy, Scipy, spglib, pymatgen Nature of problem: The calculation of thermal conductivity from first principles method with an anharmonic approximation requires a large number of calculations to construct the third-order force constants matrix, which could be prohibitively long time. Solution method: Modified Debye-Callaway model, only phonon spectrum, phonon velocity and Grüneisen parameter are needed. The acoustic branch and optic branch are both considered to obtain the final lattice thermal conductivity.

We propose the ΘΦ package which address two of the most important extensions of the essentially single-particle mean-field paradigm of the computational solid state physics: the admission of the Bardeen-Cooper-Schrieffer electronic ground state and allowance of the magnetically ordered states with an arbitrary superstructure (pitch) wave vector. Both features are implemented in the context of multi-band systems which paves the way to an interplay with the solid state quantum physics packages eventually providing access to the first-principles estimates of the relevant matrix elements of the model Hamiltonians derived from the standard DFT calculations. Several examples showing the workability of the proposed code are given.

Precision measurements of charged cosmic rays have recently been carried out by space-born (e.g. AMS-02), or ground experiments (e.g. HESS). These measured data are important for the studies of astro-physical phenomena, including supernova remnants, cosmic ray propagation, solar physics and dark matter. Those scenarios usually contain a number of free parameters that need to be adjusted by observed data. Some techniques, such as Markov Chain Monte Carlo and MultiNest, are developed in order to solve the above problem. However, it is usually required a computing farm to apply those tools. In this paper, a genetic algorithm for finding the optimum parameters for cosmic ray injection and propagation is presented. We find that this algorithm gives us the same best fit results as the Markov Chain Monte Carlo but consuming less computing power by nearly 2 orders of magnitudes. Program summary Operating system: Linux Programming Language: C Software Package: ROOT Libraries: cmath, cstdio, cstdlib, ctime Optional Software Package: DRAGON

We present a simple, one-dimensional model of an atom exposed to a time-dependent intense, short-pulse EM field with the objective of teaching undergraduates how to apply various numerical methods to study the behavior of this system as it evolves in time using several time propagation schemes. In this model, the exact Coulomb potential is replaced by a soft-core interaction to avoid the singularity at the origin. While the model has some drawbacks, it has been shown to be a reasonable representation of what occurs in the fully three-dimensional hydrogen atom. The model can be used as a tool to train undergraduate physics majors in the art of computation and software development. Program summary Program Title: 1d hydrogen light interaction Program Files doi: http://dx.doi.org/10.17632/2275fmvdzc.1 Code Ocean Capsule: https://doi.org/10.24433/CO.1476487.v1 Licensing provisions: MIT license Programming language: FORTRAN90 Nature of problem: The one dimensional time dependent Schrödinger equation has been shown to be quite useful as a model to study the Hydrogen atom exposed to an intense, short pulse, electromagnetic field. We use a model potential that is cut-off near x=0 and avoids the singularity of the true 1-D potential, but retains the characteristic Rydberg series and continuum to study excitation and ionization of the true H atom. The code employs a number of numerical methods to understand and compare the efficacy and accuracy when applied to this model problem. Solution method: The program uses and contrasts a number of approaches; the Crank–Nicolson, Short Iterative Lanczos, various incarnations of the split-operator and the Chebychev method have been programmed. These methods have been compared using a 3-point finite difference (FD) discretization of the space coordinate. For completeness, some attention has also been given to using 5–9 FD formulas in order to show how higher order discretization affects the accuracy and efficiency of the methods but the primary focus of the method is the time propagation. Additional comments including restrictions and unusual features: The main purpose of this code is as a teaching tool for undergraduates interested in acquiring knowledge of numerical methods and programming skills useful to a practicing computational physicist.

We describe an open-source implementation of the continuous-time interaction-expansion quantum Monte Carlo method for cluster-type impurity models with onsite Coulomb interactions and complex Weiss functions. The code is based on the ALPS libraries. Program summary Program Title: ALPS CT-INT Program Files doi: http://dx.doi.org/10.17632/h2vsp2t84r.1 Licensing provisions: GPLv3 Programming language: C++, MPI for parallelization. External routines/libraries: ALPSCore libraries, Eigen3, Boost. Nature of problem: Quantum impurity problem Solution method: Continuous-time interaction expansion quantum Monte Carlo

HALO (HAgis LOcust) solves the initial value Vlasov–Maxwell problem perturbatively for application to certain nonlinear wave-particle problems in tokamak plasmas. It uses the same basic approach as the HAGIS code (Pinches et al., 1998) for wave evolution but is built on the LOCUST-GPU full-orbit code (Akers et al., 2012) for the solution of the Hamiltonian fast particle motion in cylindrical coordinates. The wave amplitude and particle evolution include all finite Larmor radius effects. We describe and benchmark the currently implemented Alfvén eigenmode workflow, demonstrating correct particle motion, linear and nonlinear power transfer. The formulation and numerical scheme are sufficiently general as to allow easy future implementation of different kinds of eigenmodes, such as modes close to the ion-cyclotron frequency. The code can model multiple eigenmodes and multiple fast ion species simultaneously, and supports the general form of the equilibrium distribution in constants of motion.

The steady-state fuel behavior prediction code FRAPCON has been coupled with the Monte Carlo code MCS to accomplish fuel performance analysis capability. The Monte Carlo based multi-physics coupling analysis for large-scale light water reactors (LWRs) with high fidelity has mostly focused on the inner coupling of the Monte Carlo neutronics analysis code and the thermal–hydraulics code. However, there are still some issues that cannot be considered precisely when predicting fuel thermal conductivity, and the gap thermal conductance between fuel pellets and cladding with the increase of burnup. Therefore, the FRAPCON has been chosen in this paper to be coupled with the MCS code to increase the accuracy of fuel temperature calculations and the corresponding fuel temperature feedback. A fixed-point iteration scheme is adopted for the coupling interface, which has been verified by a single rod case. In addition, the paper also depicts the application of the MCS/FRAPCON coupling system to the BEAVRS quarter core benchmark, by comparison with MCS internal one-dimension T/H solver — TH1D. The results clearly explain the necessity for considering the fuel performance in multi-physics coupling analysis and demonstrate the capability of the MCS/FRAPCON coupling system.

We present version 3.0 of the Mathematica package DoFun for the derivation of functional equations. In this version, the derivation of equations for correlation functions of composite operators was added. In the update, the general workflow was slightly modified taking into account experience with the previous version. In addition, various tools were included to improve the usage experience and the code was partially restructured for easier maintenance. Program summary Program Title: DoFun Program Files doi: http://dx.doi.org/10.17632/y7rwzywr6w.1 Licensing provisions: GPLv3 Programming language: Mathematica, developed in version 11.3 Nature of problem: Derivation of functional renormalization group equations, Dyson–Schwinger equations and equations for correlations functions of composite operators in symbolic form which can be translated into algebraic forms. Solution method: Implementation of algorithms for the derivations of these equations and tools to transform the symbolic to the algebraic form. Unusual features: The results can be plotted as Feynman diagrams in Mathematica. The output is compatible with the syntax of many other programs and is therefore suitable for further (algebraic) computations.

We present an open-source library for coupling particle codes, such as molecular dynamics (MD) or the discrete element method (DEM), and grid based computational fluid dynamics (CFD). The application is focused on domain decomposition coupling, where a particle and continuum software model different parts of a single simulation domain with information exchange. This focus allows a simple library to be developed, with core mapping and communication handled by just four functions. Emphasis is on scaling on supercomputers, a tested cross-language library, deployment with containers and well-documented simple examples. Building on this core, a template is provided to facilitate the user development of common features for coupling, such as averaging routines and functions to apply constraint forces. The interface code for LAMMPS and OpenFOAM is provided to both include molecular detail in a continuum solver and model fluids flowing through a granular system. Two novel development features are highlighted which will be useful in the development of the next generation of multi-scale software: (i) The division of coupled code into a smaller blocks with testing over a range of processor topologies. (ii) The use of coupled mocking to facilitate coverage of various parts of the code and allow rapid prototyping. These two features aim to help users develop coupled models in a test-driven manner and focus on the physics of the problem instead of just software development. All presented code is open-source with detailed documentation on the dedicated website (cpl-library.org) permitting useful aspects to be evaluated and adopted in other projects. Program summary Program Title: CPLLIBRARY Program Files doi: http://dx.doi.org/10.17632/9dh8w97d2x.1 Licensing provisions: GPLv3 Programming languages: Fortran/C/C++/Python External routines/libraries: Message Passing Interface (MPI) Nature of problem: Coupling of particle and continuum software to enable simulations not possible with either code alone. In particular, handling communication and interaction for computational fluid dynamics (CFD) software and either molecular dynamics (MD) or discrete element method (DEM) solvers on high performance computing (HPC) platforms. Solution method: A shared library with a minimal set of functions to enable coupling, together with an entire infrastructure to facilitate development of validated coupled software including minimal Python interface to encourage mock testing, libraries to help develop coupled tools along with a wealth of pre-coupled examples including OpenFOAM, LAMMPS, Flowmol (Smith, 2014) with interactive plotting using wxPython and matplotlib. Unusual features: Minimal interface with simple setup. A CPL_Mocks framework to facilitate debugging and test driven development. Communication established between independent executables using MPI_Open_Port, reducing required changes to core source code. Coupled codes track the git repository with validation through continuous integration testing and deployment on DockerHub. All communication based on MPI_Cart and MPI_Graph so optimisation is possible through MPI implementation on supercomputers.

RMT is a program which solves the time-dependent Schrödinger equation for general, multielectron atoms, ions and molecules interacting with laser light. As such it can be used to model ionization (single-photon, multiphoton and strong-field), recollision (high-harmonic generation, strong-field rescattering) and, more generally, absorption or scattering processes with a full account of the multielectron correlation effects in a time-dependent manner. Calculations can be performed for targets interacting with ultrashort, intense laser pulses of long wavelength and arbitrary polarization. Calculations for atoms can optionally include the Breit–Pauli correction terms for the description of relativistic (in particular, spin–orbit) effects. Program summary Program Title: (RMT) R-matrix with time-dependence Program Files doi: http://dx.doi.org/10.17632/3ptyfg2bmx.1 Licensing provisions: GPLv3 Programming language: Fortran Nature of problem: The interaction of laser light with matter can be modelled with the time-dependent Schrödinger equation (TDSE). The solution of the TDSE for general, multielectron atomic and molecular systems is computationally demanding, and has previously been limited to either particular laser wavelengths and intensities, or to simple, few-electron cases. RMT overcomes this limitation by using a general approach to modelling dynamics in atoms and molecules which is applicable to multi-electron systems and a wide range of perturbative and non-perturbative phenomena. Solution method: We use the R-matrix paradigm, partitioning the interaction region into an ‘inner’ and an ‘outer’ region. In the inner region (within some small radius of the nucleus/nuclei), full account is taken of all multielectron interactions including electron exchange and correlation. In the outer region, far from the nucleus/nuclei, these are neglected and a single, ionized electron moves in the long-range potential of the residual ionic system and the laser field. The key computational aspect of the RMT approach is the use of a different numerical scheme in each region, facilitating efficient parallelization without sacrificing accuracy. Given an initial wavefunction and the electric field of the driving laser pulse, the wavefunction for all subsequent times and the associated observables are computed using an explicit, Arnoldi propagator method. Additional comments including restrictions and unusual features: The description of the atomic/molecular structure is provided from other, time-independent R-matrix codes [1], [2], [3], and the capabilities (in terms of structure) are, in some sense, inherited therefrom. Thus, the atomic calculations can optionally include Breit–Pauli relativistic corrections to the Hamiltonian, in order to account for the spin–orbit effect. However, no such capability exists for the molecular case. Furthermore, the fixed-nuclei approximation is adopted in the molecular calculations (so nuclear motion is neglected). Similarly, all calculations are restricted to the description of a single electron in the outer region, and consequently the study of double-ionization phenomena is not yet within the capabilities of the method. Finally, the parallel strategy employed necessitates the use of at least two (and usually many more) computer cores. As a result, there is no option for serial calculations and, for most realistic cases, a massively parallel architecture (several hundred cores) will be required. Program repository available at: https://gitlab.com/Uk-amor/RMT References [1] C. P. Ballance Parallel R-matrix codes, http://connorb.freeshell.org. [2] R-matrix II codes, http://gitlab.com/uk-amor/rmt/rmatrixii [3] Z. Mašín et al UKRmol+: a suite for modelling of electronic processes in molecules interacting with electrons, positrons and photons using the R-matrix method, Comput. Phys. Commun., to be submitted.

This work is a user guide to the FEMPAR scientific software library. FEMPAR is an open-source object-oriented framework for the simulation of partial differential equations (PDEs) using finite element methods on distributed-memory platforms. It provides a rich set of tools for numerical discretization and built-in scalable solvers for the resulting linear systems of equations. An application expert that wants to simulate a PDE-governed problem has to extend the framework with a description of the weak form of the PDE at hand (and additional perturbation terms for non-conforming approximations). We show how to use the library by going through three different tutorials. The first tutorial simulates a linear PDE (Poisson equation) in a serial environment for a structured mesh using both continuous and discontinuous Galerkin finite element methods. The second tutorial extends it with adaptive mesh refinement on octree meshes. The third tutorial is a distributed-memory version of the previous one that combines a scalable octree handler and a scalable domain decomposition solver. The exposition is restricted to linear PDEs and simple geometries to keep it concise. The interested user can dive into more tutorials available in the FEMPAR public repository to learn about further capabilities of the library, e.g., nonlinear PDEs and nonlinear solvers, time integration, multi-field PDEs, block preconditioning, or unstructured mesh handling. Program summary Program Title: FEMPAR Program Files doi: http://dx.doi.org/10.17632/dtx487wp57.1 Licensing provisions: GNU General Public License 3 Programming language: MPI, Fortran2003/2008 (Object-Oriented Programming features) Nature of problem: Computational simulation of a broad range of large-scale application problems governed by Partial Differential Equations Solution method: Arbitrary-order grad-, curl-, and div-conforming finite elements on n-cube and n-simplex meshes. Continuous and Discontinuous Galerkin FEM. Adaptive Mesh Refinement and Coarsening via forests-of-octrees. Diagonally Implicit Runge–Kutta time integrators. Newton–Raphson linearization. Block preconditioning for multiphysics applications. Multilevel Balancing Domain Decomposition by Constraints preconditioning. Krylov subspace iterative solvers. Sparse direct solvers. Additional comments: Program Github repository https://github.com/fempar/fempar Program website http://www.fempar.org

X-ray absorption near-edge spectroscopy (XANES) is becoming an extremely popular tool for material science thanks to the development of new synchrotron radiation light sources. It provides information about charge state and local geometry around atoms of interest in operando and extreme conditions. However, in contrast to X-ray diffraction, a quantitative analysis of XANES spectra is rarely performed in the research papers. The reason must be found in the larger amount of time required for the calculation of a single spectrum compared to a diffractogram. For such time-consuming calculations, in the space of several structural parameters, we developed an interpolation approach proposed originally by Smolentsev and Soldatov (2007). The current version of this software, named PyFitIt, is a major upgrade version of FitIt and it is based on machine learning algorithms. We have chosen Jupyter Notebook framework to be friendly for users and at the same time being available for remastering. The analytical work is divided into two steps. First, the series of experimental spectra are analyzed statistically and decomposed into principal components. Second, pure spectral profiles, recovered by principal components, are fitted by theoretical interpolated spectra. We implemented different schemes of choice of nodes for approximation and learning algorithms including Gradient Boosting of Random Trees, Radial Basis Functions and Neural Networks. The fitting procedure can be performed both for a XANES spectrum or for a difference spectrum, thus minimizing the systematic errors of theoretical simulations. The problem of several local minima is addressed in the framework of direct and indirect approaches. Program summary Program title: PyFitIt. Licensing provisions: GNU General Public License 3 (GPL). Programming language: Python, Jupyther Notebook framework. Journal Reference of the previous version: J. Synch. Radiat., 13 (2006) 19-29 ; Comput. Mater. Sci., 39 (2007) 569-574. Does the new version supersede the previous version?: yes Reasons for the new version: we have rewritten the code in the Jupyter Notebooks to make it available for the use and modification by members of the XAS scientific community. When the number of structural parameters for fitting exceeds 3 the use of polynomial interpolation realized in the previous version was highly non-optimal and inaccurate. Therefore, in the new version, the approximation methods were revised in terms of the use of modern machine learning strategies. Finally, in the new version, an important step of analysis of a series of experimental spectra was added, named Principal Component Analysis and spectral un-mixing procedure. Summary of revisions: Development of a library of methods able to: (i) analyze the experimental set of data (PCA); (ii) construct the molecule deformations for a selected set of points in a multidimensional space (grid, random and IHS options are available); (iii) run the simulations locally or remotely; (iv) training the machine learning algorithms (ridge regression, Radial Basis Functions, Extra Trees, Neural Network, LightGBM … etc.) on the set of theoretical spectra and fitting the experimental spectra or their differences using inverse or direct approaches. Nature of problem: Quantitative structural refinements of the X-ray absorption near-edge structure spectra (XANES). Identification of the pure spectral and concentration profiles associated with an experimental XANES dataset. Solution method: The fitting procedure of the experimental XANES spectra or of their differences is realized by means of the inverse and direct approaches based on the training set and approximation machine learning algorithms. The spectral resolution method is based on the PCA technique involving the usage of a target transformation matrix. Additional comments including Restrictions and Unusual features: The current version is compatible with the free FDMNES program package for XANES simulations. However, users can prepare their own matrices of spectra calculated by an arbitrary software and the corresponding structural parameters to perform the fitting procedure in PyFitIt. The complete set of examples is distributed along with the program. References: PyFitIt web page: http://hpc.nano.sfedu.ru/pyfitit/