Search

Abstract: In this paper we present a new effective algorithm for the Schrödinger equation. This new method differs from the original Numerov method only in one simple coefficient, by which we can extend the interval of periodicity from 6 to infinity and obtain an embedded correct factor to improve the accuracy. We compare the new method with the original Numerov method by the well-known problem of Woods–Saxon potential. The numerical results show that the new method has great advantage in accuracy over the original. Particularly for the resonant state, the accuracy is improved with four orders overall, and even six to seven orders for the highest oscillatory solution. Surely, this method will replace the original Numerov method and be widely used in various area. [Copyright &y& Elsevier]

Cluster counting in drift chamber is the most promising breakthrough in particle identification (PID) technique in particle physics experiment. Reconstruction algorithm is one of the key challenges in cluster counting. In this paper, a semi-supervised domain adaptation (DA) algorithm is developed and applied on the peak finding problem in cluster counting. The algorithm uses optimal transport (OT), which provides geometric metric between distributions, to align the samples between the source (simulation) and target (data) samples, and performs semi-supervised learning with the samples in target domain that are partially labeled with the continuous wavelet transform (CWT) algorithm. The model is validated by the pseudo data with labels, which achieves performance close to the fully supervised model. When applying the algorithm on real experimental data, taken at CERN with a 180 GeV/c muon beam, it shows better classification power than the traditional derivative-based algorithm, and the performance is stable for experimental data samples across varying track lengths. [ABSTRACT FROM AUTHOR]

The amount of data coming from modern acquisition systems, especially working in extreme experimental conditions, is significantly rising over the years. Combined with complex algorithms, the computation time and power consumption are considerably increasing. The issue usually occurs in many world laboratories, such as CERN, Brookhaven National Laboratory, GSI Helmholtzzentrum für Schwerionenforschung, and tokamak devices (JET, WEST, MAST, and more). Often well verified, but legacy codes are used as a main computational engine, resulting in weak performance unsuitable for current needs. The paper presents a methodology to appropriately adapt the legacy C/C++ high-energy physics (HEP) algorithms for computation acceleration using FPGAs, which may improve the designing of real-time systems based on verified codes. The main idea is to separate the HLS-FPGA code work areas between groups of experts: physicists and electronics. The methodology consists of several parts: interfacing, storage, verification methods, defining the algorithm and data structures, program refactoring in the scope of CPU and FPGA, performance and results analysis, FPGA verification methods, FPGA performance estimation, and automatization of the process. The methodology has been successfully tested by implementing a legacy, complex HEP algorithm for femtoscopy correlations in the HLS framework for FPGA. It works with extensive input data from international experiments, like STAR at RHIC. The implementation and verification were done successfully on the FPGA hardware platform. Following the methodology results in a clearer to analyze and debug HEP code than a machine-generated version by tools. We also confirmed that it is possible to make a working, HLS-compliant program designed by non-FPGA experts. Using the modern implementation tools, FPGA resource usage is low despite unoptimized syntax. It gives a large field for further significant optimizations and good performance. The proposed approach should be interesting to introduce in devices like tokamaks, synchrotrons, and similar, where the real-time monitoring of the experimental processes is essential. • Methodology of complex algorithms conversion from legacy code to FPGA accelerated using High-Level Synthesis languages. • Preliminary hardware FPGA laboratory tests of the Monte-Carlo HEP algorithm for heavy-ion collisions using presented approach. • Guidelines to achieve the performance improvement of legacy high-energy physics algorithms. • Elaboration on High-Level Synthesis (HLS) languages usage for complex algorithms acceleration used in physics experiments. [ABSTRACT FROM AUTHOR]

This paper describes our approach to developing a simulation software application for the fully kinetic 6D-Vlasov equation, which will be used to explore physics beyond the reduced gyrokinetic model. Simulating the fully kinetic Vlasov equation requires efficient utilization of compute and storage capabilities due to the high dimensionality of the problem. In addition, the implementation needs to be extensible regarding the physical model and flexible regarding the hardware for production runs. We start on the algorithmic background to simulate the 6-D Vlasov equation using a semi-Lagrangian algorithm. The performance portable software stack, which enables production runs on pure CPU as well as AMD or Nvidia GPU accelerated nodes, is presented. The extensibility of our implementation is guaranteed through the described software architecture of the main kernel, which achieves a memory bandwidth of almost 500 GB/s on a V100 Nvidia GPU and around 100 GB/s on an Intel Xeon Gold CPU using a single code base. We provide performance data on multiple node-level architectures discussing utilized and further available hardware capabilities. Finally, the network communication bottleneck of 6-D grid-based algorithms is quantified. A verification of physics beyond gyrokinetic theory, for the example of ion Bernstein waves, concludes the work. • Performance portable implementation of a semi-Lagrangian algorithm for full kinetics. • Software architecture for Lagrange interpolation stencils using design patterns. • Node level performance analysis for OpenMP, HIP and CUDA using a single code base. • Quantification of the network communication bottleneck for 6D distributed grids. [ABSTRACT FROM AUTHOR]

Nowadays, the interoperability and interfacing of codes and libraries have become crucial aspects of software development and engineering, and the basis for enabling and simplifying the sharing of methods and tools, both within and among communities. One of the most important bottlenecks that arises when developing and maintaining an interface of a library with an already existing software, is to keep it aligned with the development route of the latter. This might include significant changes, such as changes in the data structures used by the library, which are communicated through the interface. In this paper, an approach for inserting a new algorithm into existing software is presented, through a minimally invasive interface, that takes over an already present algorithm, and thus changes its original purpose. The approach is applied to the well-established Activation-Relaxation Technique nouveau (ARTn) algorithm, that is revisited and re-engineered to bias and take over the FIRE minimization algorithm, as presently implemented in two community codes for atomistic simulations, namely Quantum ESPRESSO (PWscf) and LAMMPS. ARTn is a well established single-ended saddle-point search algorithm that allows for the exploration of potential energy surfaces. The resulting algorithm acts as a plugin, and is distributed in the form of an external library (pARTn). Program Title: plugin Activation Relaxation Technique nouveau (pARTn) CPC Library link to program files: https://doi.org/10.17632/xpwr56d2yk.1 Developer's repository link: https://gitlab.com/mammasmias/artn-plugin Licensing provisions: Apache-2.0/GPLv3 Programming language: Modern Fortran and C++ Nature of problem: Original ARTn implementation was difficult to interface, port and maintain. Solution method: Full refactoring and re-engineering into a library, which utilizes and biases a minimization algorithm already implemented in the engine, to make it behave as ARTn. The biasing is done by reverse-engineering specific external conditions that drive the displacement of atoms. [ABSTRACT FROM AUTHOR]

Abstract This paper demonstrates how the solutions to conventional radioactive decay equations can be derived using results from matrix analysis. In particular, we draw on results for the matrix exponential function when the matrix is triangular. By applying key theorems, the paper explains how the solutions to these equations can be presented in algorithmic form and in terms of divided differences of the exponential function. Furthermore, with little additional effort, the approach yields solutions to more general variations of these equations. [ABSTRACT FROM AUTHOR]

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

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

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

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

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

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

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

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

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

We describe MESH ( M ultilayer E lectromagnetic S olver for H eat transfer), a free software that combines rigorous coupled wave analysis (RCWA) and scattering matrix formalism to simulate the radiative heat transfer both in the near-field and far-field regimes for layered three-dimensional structures made of planar layers. Each layer can have in-plane one-dimensional or two-dimensional periodicity. In this paper, we provide detailed discussions of the algorithms of MESH, which enables it to be a flexible tool for different types of radiative heat transfer simulations. We also discuss aspects of the codes related to parallelization and user scripting. Program summary Program Title: MESH Program Files doi: http://dx.doi.org/10.17632/zx9v3bf3hf.1 Licensing provisions: GNU General Public License 3 (GPL) Programming language: C, C++. External routines: Lua[1], Python[2] and LAPACK and BLAS linear-algebra software[3], and optionally MPI message-passing interface[4]. Armadillo[5] is already contained in MESH. Nature of problem: Far-field and near-field radiative heat transfer in layered periodic structures. Solution method: Fourier modal method (rigorous coupled wave analysis) and the scattering matrix method. [1] R. Ierusalimschy, L.H. de Figueiredo, W.C. Filho, Lua an extensible extension language, Software: Practice and Experience 26 (1996) 635652. http://www.lua.org . [2] Python Software Foundation. Available at http://www.python.org [3] MKL: https://software.intel.com/en-us/intel-mkl [4] T.M. Forum, MPI: A Message Passing Interface, in: Supercomputing 93, Portland, OR, 878883, 1993 [5] Conrad Sanderson and Ryan Curtin. Armadillo: a template-based C++ library for linear algebra. Journal of Open Source Software, Vol. 1, pp. 26, 2016. http://dx.doi.org/10.21105/joss.00026 [ABSTRACT FROM AUTHOR]

This paper describes the main features of a state-of-the-art Monte Carlo solver for radiation transport which has been implemented within COOLFluiD, a world-class open source object-oriented platform for scientific simulations. The Monte Carlo code makes use of efficient ray tracing algorithms (for 2D, axisymmetric and 3D arbitrary unstructured meshes) which are described in detail. The solver accuracy is first verified in testcases for which analytical solutions are available, then validated for a space re-entry flight experiment (i.e. FIRE II) for which comparisons against both experiments and reference numerical solutions are provided. Through the flexible design of the physical models, ray tracing and parallelization strategy (fully reusing the mesh decomposition inherited by the fluid simulator), the implementation was made efficient and reusable. Program summary Program title: COOLFluiD-MC Catalogue identifier: AEZG_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEZG_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: GNU General Public License, version 3 No. of lines in distributed program, including test data, etc.: 1990165 No. of bytes in distributed program, including test data, etc.: 149533288 Distribution format: tar.gz Programming language: C++. Computer: From desktops to large HPC distributed systems. Operating system: Mac OS X, Linux. Has the code been vectorized or parallelized?: Parallelized through MPI RAM: Depending on the problem size from a few Megabytes to several Gigabytes. Classification: 21.2. External routines: MPI, boost, PETSc, ParMETIS, cmake Nature of problem: Radiative processes play a fundamental role in countless science and engineering contexts, including combustion, astrophysics, atmospheric space re-entry, experiments in plasma facilities (e.g. shock tubes, arc jets). The problem we are interested in is the computation of radiative heat transfer on arbitrarily complex geometries, in particular to characterize thermal loads acting on the surface of space vehicles. Solution method: Our C++ code implements a flexible and efficient Monte Carlo algorithm making use of state-of-the-art ray tracing techniques designed for and validated on arbitrary unstructured meshes. The code is organized as a collection of dynamically linked libraries connected to the computational kernel of the open source COOLFluiD platform. The Monte Carlo method is parallelized through mesh decomposition, while reusing the same partitioned mesh (and associated data structures) on which fluid dynamics equations are solved. Unusual features: The radiation transfer code of COOLFluiD-MC offers a unique combination of ray tracing algorithms suitable for handling 2D, 2D axisymmetric and 3D simulations on arbitrary unstructured grids. The parallelization strategy is scalable and based on domain decomposition. The overall object-oriented design allows for easy integration of new models and algorithms which can be plugged in dynamically through self-registration techniques. Additional comments: The code is part of a much larger set of COOLFluiD libraries, which are fully available on Github at https://github.com/andrealani/COOLFluiD and include multiple numerical solvers, physico-chemical models, processing algorithms and interfaces to third party scientific software. The CPC distribution also includes a state-of-the-art fully implicit Finite Volume solver for Euler and Navier–Stokes systems which is used to produce the flow solution for the radiative transport algorithm described in the paper. The aerothermodynamic solver, which is used for the final testcase (FIREII) in our paper, is based on the same core Finite Volume modules but on different physico-chemical and radiation models. The latter cannot be made available through the CPC library since they rely on third party libraries (MUTATION version 2.0 and PARADE version 3.1) which cannot be distributed due to NDA. !!!!! The distribution file for this program is over 149 Mbytes and therefore is not delivered directly when download or Email is requested. Instead a html file giving details of how the program can be obtained is sent. !!!!! Running time: Depending on the size of the computational grid, if it is 2D or 3D, on the number of processors used, the running time can vary from a few seconds up to hours or days. The testcases that are included with this version of the code, all using relatively small 2D or 3D meshes, run in 1–10 s each on 8 CPU-cores. The user is, however, totally free to run the same cases on a different number of cores (more or less, according to his/her convenience). [ABSTRACT FROM AUTHOR]

In this paper, a generalized Allen–Cahn-type phase-field crystal model with face-centered-cubic ordering structure is presented. By introducing a space-time dependent Lagrange multiplier, the mass conservation is enforced and the local effect can be reflected. Moreover, the proposed model is lower-order in space and will be more efficient for numerical computation. For the simulation of crystallization, the main challenge is to design practical and stable algorithm which meanwhile guarantees the high-order accuracy. To resolve this problem, we propose a temporally high-order (up to third-order) accurate and linear multi-stage scheme based on implicit-explicit Runge–Kutta approach. The nonlinear term is explicitly treated and the appropriate stabilizer is added to balance the stiffness. By utilizing the Fourier spectral method in space, the numerical calculation is easy to implement. We analytically proved the discrete mass conservation property based on the fully discrete scheme. Extensive numerical experiments are performed to validate the accuracy, efficiency, and capability for phase transition. The effects of parameters and local interaction are investigated in detail. To facilitate the interested readers, we provide MATLAB codes of our proposed method in Appendix A. • Generalized AC-type PFC model with FCC ordering is proposed. • High-order time-accurate linear algorithm is developed. • The discrete mass conservation law is strictly satisfied. • Effects of parameter and local multiplier are investigated. [ABSTRACT FROM AUTHOR]

In the framework of open source CFD code OpenFOAM, a density-based solver for all speeds flow field is developed. In this solver the preconditioned all speeds AUSM+(P) scheme is adopted and the dual time scheme is implemented to complete the unsteady process. Parallel computation could be implemented to accelerate the solving process. Different interface reconstruction algorithms are implemented, and their accuracy with respect to convection is compared. Three benchmark tests of lid-driven cavity flow, flow crossing over a bump, and flow over a forward-facing step are presented to show the accuracy of the AUSM+(P) solver for low-speed incompressible flow, transonic flow, and supersonic/hypersonic flow. Firstly, for the lid driven cavity flow, the computational results obtained by different interface reconstruction algorithms are compared. It is indicated that the one dimensional reconstruction scheme adopted in this solver possesses high accuracy and the solver developed in this paper can effectively catch the features of low incompressible flow. Then via the test cases regarding the flow crossing over bump and over forward step, the ability to capture characteristics of the transonic and supersonic/hypersonic flows are confirmed. The forward-facing step proves to be the most challenging for the preconditioned solvers with and without the dual time scheme. Nonetheless, the solvers described in this paper reproduce the main features of this flow, including the evolution of the initial transient. [ABSTRACT FROM AUTHOR]

The general FDTD method cannot calculate a complex object because of limit of the CFL conditions. CN-FDTD is an improvement on the FDTD method, and it can get rid of the CFL conditions and become wholly unconditional stable form. The advantage of the ICCG method for solving large sparse matrix will be taken in the CN-FDTD equation solving. ICCG method can accelerate iteration for numerical calculation, reduce memory overhead and be easy to be programmed at the same time. CN-ICCG-FDTD method researches the object model of plasma photonic crystals. Plasma photo crystals have unique properties. They can show mainly characteristics of plasma, or have the main properties of photonic crystals. Combination of plasma and photonic crystals makes it possible to adjust the plasma parameters to control the properties of photonic crystals. In this paper, it calculates characteristic parameters of plasma photonic crystals under different conditions, such as the reflection electric field, the transmission electric field, the transmission coefficient, to verify accuracy of CN-ICCG-FDTD method. The results of this paper prove the method is accurate, performs stably, and has certain advantages. [ABSTRACT FROM AUTHOR]

A computation-oriented representation of uncertain kinetic systems is introduced and analysed in this paper. It is assumed that the monomial coefficients of the ODEs belong to a polytopic set, which defines a set of dynamical systems for an uncertain model. An optimization-based computation model is proposed for the structural analysis of uncertain models. It is shown that the so-called dense realization containing the maximal number of reactions (directed edges) is computable in polynomial time, and it forms a superstructure among all the possible reaction graphs corresponding to an uncertain kinetic model, assuming a fixed set of complexes. The set of core reactions present in all reaction graphs of an uncertain model is also studied. Most importantly, an algorithm is proposed to compute all possible reaction graph structures for an uncertain kinetic model. [ABSTRACT FROM AUTHOR]

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

The periodic signals tracking algorithm has been used to determine the revolution times of ions stored in storage rings in isochronous mass spectrometry (IMS) experiments. It has been a challenge to perform real-time data analysis by using the periodic signals tracking algorithm in the IMS experiments. In this paper, a parallelization scheme of the periodic signals tracking algorithm is introduced and a new program is developed. The computing time of data analysis can be reduced by a factor of ∼ 71 and of ∼ 346 by using our new program on Tesla C1060 GPU and Tesla K20c GPU, compared to using old program on Xeon E5540 CPU. We succeed in performing real-time data analysis for the IMS experiments by using the new program on Tesla K20c GPU. [ABSTRACT FROM AUTHOR]

Conical functions appear in a large number of applications in physics and engineering. In this paper we describe an extension of our module Conical (Gil et al., 2012) for the computation of conical functions. Specifically, the module includes now a routine for computing the function R − 1 2 + i τ m ( x ) , a real-valued numerically satisfactory companion of the function P − 1 2 + i τ m ( x ) for x > 1 . In this way, a natural basis for solving Dirichlet problems bounded by conical domains is provided. The module also improves the performance of our previous algorithm for the conical function P − 1 2 + i τ m ( x ) and it includes now the computation of the first order derivative of the function. This is also considered for the function R − 1 2 + i τ m ( x ) in the extended algorithm. Program summary Program Title: Module Conical Program Files doi: http://dx.doi.org/10.17632/rpw5d8gdkg.1 Licensing provisions: CC by 4.0 Programming language: Fortran 90 External routines/libraries: The module Conical uses a Fortran 90 version of the routine dkia (developed by the authors) for computing the modified Bessel functions K i a ( x ) and its derivative. This routine is available at http://toms.calgo.org . Nature of problem: These functions are the natural function basis for solving, for example, the Laplace’s problem in spherical coordinates for two intersecting cones or for regions bounded by two intersecting spheres, or by one or two confocal hyperboloids of revolution when using toroidal coordinates. The conical function P − 1 2 + i τ m ( x ) is also used in the Mehler–Fock integral transform for problems in potential and heat theory, Solution method: The algorithm uses different methods of computation depending on the function under consideration ( P − 1 2 + i τ m ( x ) or R − 1 2 + i τ m ( x ) ) and the values of x , τ and m : numerical quadrature, asymptotic expansions in terms of elementary functions, asymptotic expansions in terms of Bessel functions, asymptotic expansions for tau large and backward/forward recursion of three-term recurrence relations. Restrictions: In order to avoid underflow/overflow problems in standard IEEE double precision arithmetic, the admissible parameter ranges for computing the conical function P − 1 2 + i τ m ( x ) in the routine conicp are: − 1 < x < 1 , 0 < τ < = 100 , 0 ≤ m ≤ 40 1 < x ≤ 100 , 0 < τ ≤ 100 , 0 ≤ m ≤ 100 . When using the routines conicr and conicpr , the admissible parameter ranges for computing the functions P − 1 2 + i τ m ( x ) and R − 1 2 + i τ m ( x ) are 1 < x ≤ 100 , 0 < τ ≤ 100 , 0 ≤ m ≤ 100 . [ABSTRACT FROM AUTHOR]

Since the classical molecular dynamics simulator LAMMPS was released as an open source code in 2004, it has become a widely-used tool for particle-based modeling of materials at length scales ranging from atomic to mesoscale to continuum. Reasons for its popularity are that it provides a wide variety of particle interaction models for different materials, that it runs on any platform from a single CPU core to the largest supercomputers with accelerators, and that it gives users control over simulation details, either via the input script or by adding code for new interatomic potentials, constraints, diagnostics, or other features needed for their models. As a result, hundreds of people have contributed new capabilities to LAMMPS and it has grown from fifty thousand lines of code in 2004 to a million lines today. In this paper several of the fundamental algorithms used in LAMMPS are described along with the design strategies which have made it flexible for both users and developers. We also highlight some capabilities recently added to the code which were enabled by this flexibility, including dynamic load balancing, on-the-fly visualization, magnetic spin dynamics models, and quantum-accuracy machine learning interatomic potentials. Program Title: Large-scale Atomic/Molecular Massively Parallel Simulator (LAMMPS) CPC Library link to program files: https://doi.org/10.17632/cxbxs9btsv.1 Developer's repository link: https://github.com/lammps/lammps Licensing provisions: GPLv2 Programming language: C++, Python, C, Fortran Supplementary material: https://www.lammps.org Nature of problem: Many science applications in physics, chemistry, materials science, and related fields require parallel, scalable, and efficient generation of long, stable classical particle dynamics trajectories. Within this common problem definition, there lies a great diversity of use cases, distinguished by different particle interaction models, external constraints, as well as timescales and lengthscales ranging from atomic to mesoscale to macroscopic. Solution method: The LAMMPS code uses parallel spatial decomposition, distributed neighbor lists, and parallel FFTs for long-range Coulombic interactions [1]. The time integration algorithm is based on the Størmer-Verlet symplectic integrator [2], which provides better stability than higher-order non-symplectic methods. In addition, LAMMPS supports a wide range of interatomic potentials, constraints, diagnostics, software interfaces, and pre- and post-processing features. Additional comments including restrictions and unusual features: This paper serves as the definitive reference for the LAMMPS code. [1] S. Plimpton, Fast parallel algorithms for short-range molecular dynamics. J. Comp. Phys. 117 (1995) 1–19. [2] L. Verlet, Computer experiments on classical fluids: I. Thermodynamical properties of Lennard–Jones molecules, Phys. Rev. 159 (1967) 98–103. [ABSTRACT FROM AUTHOR]

Abstract: In this paper, a scheme for the canonical ensemble simulation of the coarse-grained articulated polymers is discussed. In this coarse-graining strategy, different subdomains of the system are considered as rigid and/or flexible bodies connected to each other via kinematic joints instead of stiff, but elastic bonds. Herein, the temperature of the simulation is controlled by a Nosé–Hoover thermostat. The dynamics of this feedback control system in the context of multibody dynamics may be represented and solved using traditional methods with computational complexity of where denotes the number of degrees of freedom of the system. In this paper, we extend the divide-and-conquer algorithm (DCA), and apply it to constant temperature molecular simulations. The DCA in its original form uses spatial forces to formulate the equations of motion. The Generalized-DCA applied here properly accommodates the thermostat generalized forces (from the thermostat), which control the temperature of the simulation, in the equations of motion. This algorithm can be implemented in serial and parallel with computational complexity of and , respectively. [Copyright &y& Elsevier]

Abstract: This paper examines the feasibility of high-level Python based utilities for numerically intensive applications via an example of a multidimensional integration for the evaluation of the statistical characteristics of a random variable. We discuss the approaches to the implementation of mathematically formulated incremental expressions using high-level scripting code and low-level compiled code. Due to the dynamic typing of the Python language, components of the algorithm can be easily coded in a generic way as algorithmic templates. Using the Enthought Development Suite they can be effectively assembled into a flexible computational framework that can be configured to execute the code for arbitrary combinations of integration schemes and versions of instantiated code. The paper describes the development cycle using a simple running example involving averaging of a random two-parametric function that includes discontinuity. This example is also used to compare the performance of the available algorithmic and executional features. The implemented package including further examples and the results of performance studies have been made available via the free repository [1] and CPCP library. Program summary: Program title: spirrid Catalogue identifier: AENL_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AENL_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Special licence provided by the author No. of lines in distributed program, including test data, etc.: 10722 No. of bytes in distributed program, including test data, etc.: 157099 Distribution format: tar.gz Programming language: Python and C. Computer: PC. Operating system: LINUX, UNIX, Windows. Classification: 4.13, 6.2. External routines: NumPy (http://numpy.scipy.org/), SciPy (http://www.scipy.com) Nature of problem: Evaluation of the statistical moments of a function of random variables. Solution method: Direct multidimensional integration. Running time: Depending on the number of random variables the time needed for the numerical estimation of the mean value of a function with a sufficiently low level of numerical error varies. For orientation, the time needed for two included examples: examples/fiber_tt_2p/fiber_tt_2p.py with 2 random variables: few milliseconds examples/fiber_po_8p/fiber_po_8p.py with 8 random variables: few seconds [Copyright &y& Elsevier]

In the paper, a problem of improving efficiency of the particle–particle– particle-mesh (P 3 M) algorithm in computing the inter-particle electrostatic forces is considered. The particle-mesh (PM) part of the algorithm is modified in such a way that the space field equation is solved by the direct method of summation of potentials over the ensemble of particles lying not too close to a reference particle. For this purpose, a specific matrix “pattern” is introduced to describe the spatial field distribution of a single point charge, so the “pattern” contains pre-calculated potential values. This approach allows to reduce a set of arithmetic operations performed at the innermost of nested loops down to an addition and assignment operators and, therefore, to decrease the running time substantially. The simulation model developed in C++ substantiates this view, showing the descent accuracy acceptable in particle beam calculations together with the improved speed performance. [ABSTRACT FROM AUTHOR]

The research and development of metallic materials are playing an important role in today’s society, and in the meanwhile lots of metallic materials knowledge is generated and available on the Web (e.g., Wikipedia) for materials experts. However, due to the diversity and complexity of metallic materials knowledge, the knowledge utilization may encounter much inconvenience. The idea of knowledge graph (e.g., DBpedia) provides a good way to organize the knowledge into a comprehensive entity network. Therefore, the motivation of our work is to generate a metallic materials knowledge graph (MMKG) using available knowledge on the Web. In this paper, an approach is proposed to build MMKG based on DBpedia and Wikipedia. First, we use an algorithm based on directly linked sub-graph semantic distance (DLSSD) to preliminarily extract metallic materials entities from DBpedia according to some predefined seed entities; then based on the results of the preliminary extraction, we use an algorithm, which considers both semantic distance and string similarity (SDSS), to achieve the further extraction. Second, due to the absence of materials properties in DBpedia, we use an ontology-based method to extract properties knowledge from the HTML tables of corresponding Wikipedia Web pages for enriching MMKG. Materials ontology is used to locate materials properties tables as well as to identify the structure of the tables. The proposed approach is evaluated by precision, recall, F1 and time performance, and meanwhile the appropriate thresholds for the algorithms in our approach are determined through experiments. The experimental results show that our approach returns expected performance. A tool prototype is also designed to facilitate the process of building the MMKG as well as to demonstrate the effectiveness of our approach. [ABSTRACT FROM AUTHOR]

We consider a one-dimensional system of particles with strong zero-range interactions. This system can be mapped onto a spin chain of the Heisenberg type with exchange coefficients that depend on the external trap. In this paper, we present an algorithm that can be used to compute these exchange coefficients. We introduce an open source code CONAN (Coefficients of One-dimensional N -Atom Networks) which is based on this algorithm. CONAN works with arbitrary external potentials and we have tested its reliability for system sizes up to around 35 particles. As illustrative examples, we consider a harmonic trap and a box trap with a superimposed asymmetric tilted potential. For these examples, the computation time typically scales with the number of particles as O ( N 3.5 ± 0.4 ) . Computation times are around 10 s for N = 10 particles and less than 10 min for N = 20 particles. Program summary Program title: CONAN Program Files doi: http://dx.doi.org/10.17632/tw87vdy68b.1 Licensing provisions: GNU General Public License 3 (GPL) Programming language: C Nature of problem: A system of N atoms (fermions or bosons) with a strong zero-range interaction confined in a one-dimensional potential V ( x ) can be described using a spin chain Heisenberg type Hamiltonian. This effective spin chain Hamiltonian is defined through N − 1 exchange coefficients (also called geometric coefficients, α k ). The exchange coefficients depend only on the integer N and the function V ( x ) , but each coefficient is formally given as an ( N − 1 )-dimensional integral. Given a number of particles N and a confining potential V ( x ) , we wish to compute the exchange coefficients, but carrying out the ( N − 1 )-dimensional integral numerically is not, to say the least, a method that scales well with the system size. Solution method: We wish to compute the exchange coefficients for a given system, but to do this we need to express them in a way that is more well-suited for a numerical implementation, i.e. in a way that does not involve an ( N − 1 )-dimensional integral. In the submitted manuscript, we derive such an expression for the exchange coefficients. Our program, CONAN, is the numerical implementation of this formula for the exchange coefficients. Thus, CONAN takes as physical inputs the system size N and a smooth potential V ( x ) , and returns the corresponding N − 1 exchange coefficients appearing in the spin chain Hamiltonian. [ABSTRACT FROM AUTHOR]

Abstract: Differential Matrix Riccati Equations (DMREs) appear in several branches of science such as applied physics and engineering. For example, these equations play a fundamental role in control theory, optimal control, filtering and estimation, decoupling and order reduction, etc. In this paper a new method based on a theorem proved in this paper is described for solving DMREs by a piecewise-linearized approach. This method is applied for developing two block-oriented algorithms based on diagonal Padé approximants. MATLAB versions of the above algorithms are developed, comparing, under equal conditions, accuracy and computational costs with other piecewise-linearized algorithms implemented by the authors. Experimental results show the advantages of solving stiff or non-stiff DMREs by the implemented algorithms. [ABSTRACT FROM AUTHOR]

Abstract: Parallel code presents a non-trivial problem of load balancing computational workload throughout a system of hardware and software resources. The task of load balancing is further complicated when the number of allowable processors changes through time. This paper presents a two-component load-balancing mechanism using optimal initial workload distribution and dynamic load maintenance. The initial guess is provided by inversion of the workload distribution function. Workload distribution inversion enables efficient domain decomposition for arbitrary workloads and easily compensates for changes in system resources. Dynamic load balancing is provided by process feedback control as used, for example, in control mechanisms of physical processes. Proportional, integral, and differential (PID) feedback readily allows controls to compensate for runtime-changes of the workload distribution function. This paper demonstrates a one-dimensional realization of the ideas presented here. We apply this load-balancing technique to our gridless direct simulation Monte Carlo algorithm. We demonstrate that the method does indeed maintain uniform workload distribution across available resources as the workload and usable system resources undergo change through time. [ABSTRACT FROM AUTHOR]

Abstract: The objectives of this paper are twofold. First, the paper developed an improved algorithm to perform light scattering calculations by coated spheres. The improved algorithm was implemented in FORTRAN90 as a subroutine to allow flexible application of the code. Second, the new program was applied to the characterization of composite aluminum nanoparticles. In this application, multiple elements of the Mueller scattering matrix were measured at multiple angles to infer the properties of the nanoparticles, including the size distribution function and the thickness of the coating. The new program played a key role in the fitting of the measured data, and this application demonstrated the advantages of the new program in situations that demand high efficiency and reliability. Program summary: Program title: CMIE Catalogue identifier: AEFX_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEFX_v1_0.html Program obtainable from: CPC Program Library, Queen''s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 1065 No. of bytes in distributed program, including test data, etc.: 12 933 Distribution format: tar.gz Programming language: FORTRAN90/95 Computer: Any machine running standard FORTRAN90/95 Operating system: Windows XP (Intel FORTRAN compiler 9.1) RAM: 1–100 Mbyte Classification: 16.7, 18 Nature of problem: Among various scientific and engineering applications, it is highly desirable to have an efficient, reliable, and flexible program to perform scattering calculations for coated spherical particles. Though several programs are publicly available and can perform such calculations, they are designed for more complicated scatterers (non-spherical, multilayered particles, etc.). As a result, their efficiency and reliability are usually not satisfactory when applied to coated spheres. Therefore, this paper aims at developing an improved program to provide efficient and reliable scattering calculations for coated spheres. Such virtues were demonstrated to be invaluable in applications where scattering calculations need to be performed for a great number of times over a wide range of conditions. Solution method: A new algorithm is developed to directly calculate the pre-factor of the scattering coefficients. This new technique provides reliable calculation of the pre-factor for arbitrarily large size parameters, and offers better control of the termination of the calculation. Based on this algorithm, an improved program was developed to perform light scattering calculations by coated spheres. Restrictions: Only applicable to single scattering, single layer coating, and unity permeability Running time: Several seconds–several minutes [Copyright &y& Elsevier]

Abstract: The simulated annealing (SA) algorithm has been recognized as a powerful technique for minimizing complicated functions. However, a critical disadvantage of the SA algorithm is its high computational cost. Therefore, it is the goal of this paper to investigate the use of the critical temperature in SA to reduce its computational cost. This paper presents a systematic study of the critical temperature and its applications in the minimization of functions of continuous variables with the SA algorithm. Based on this study, a new algorithm was developed to exploit the unique feature of the critical temperature in SA. The new algorithm combines SA and local search to determine global minimum effectively. Extensive tests on a variety of functions demonstrated that the new algorithm provides comparable performance to well-established SA techniques. Furthermore, the new algorithm also improves the determination of the starting temperature for the SA algorithm. The results obtained in this study are expected to be useful for improving the efficiency of SA algorithms, and for facilitating the development of temperature parallel SA algorithms. [Copyright &y& Elsevier]

Abstract: The computational costs of calculating the matrix sign function of the overlap operator together with fundamental numerical problems related to the discontinuity of the sign function in the kernel eigenvalues are the major obstacle towards simulations with dynamical overlap fermions using the Hybrid Monte Carlo algorithm. In a previous paper of the present series we introduced optimal numerical approximation of the sign function and have developed highly advanced preconditioning and relaxation techniques which speed up the inversion of the overlap operator by nearly an order of magnitude. In this fourth paper of the series we construct an HMC algorithm for overlap fermions. We approximate the matrix sign function using the Zolotarev rational approximation, treating the smallest eigenvalues of the Wilson operator exactly within the fermionic force. Based on this we derive the fermionic force for the overlap operator. We explicitly solve the problem of the Dirac delta-function terms arising through zero crossings of eigenvalues of the Wilson operator. The main advantage of scheme is that its energy violations scale better than and thus are comparable with the violations of the standard leapfrog algorithm over the course of a trajectory. We explicitly prove that our algorithm satisfies reversibility and area conservation. We present test results from our algorithm on 44, 64, and 84 lattices. [Copyright &y& Elsevier]

Abstract: In a recent paper [ETMC, P. Boucaud et al., Phys. Lett. B 650 (2007) 304, hep-lat/0701012] we presented precise lattice QCD results of our European Twisted Mass Collaboration (ETMC). They were obtained by employing two mass-degenerate flavours of twisted mass fermions at maximal twist. In the present paper we give details on our simulations and the computation of physical observables. In particular, we discuss the problem of tuning to maximal twist, the techniques we have used to compute correlators and error estimates. In addition, we provide more information on the algorithm used, the autocorrelation times and scale determination, the evaluation of disconnected contributions and the description of our data by means of chiral perturbation theory formulae. [Copyright &y& Elsevier]

We present in this paper an analytical calculation algorithm of the collisions integrals for the Maxwell''s particles. This algorithm is tested by a program written in Maple V and carried out on a personal computer. The formulas obtained of these integrals whose order is lower or equal to 5 are identical to those of Truesdell (1980), those whose order is equal to 6, 7 and 8 are presented at the end of this paper. Even if the resulting formulas for high orders become large, they remain always short and handy compared to those which correspond to the original formula given by the theorem of Truesdell–Muncaster (1980). However, the limits of this algorithm depend only on the capacities of the treating machine. [Copyright &y& Elsevier]

In this paper, the open source multiscale flow solver dugksFoam is optimized with a newly proposed parallelization strategy and conserved algorithm. A novel X-space parallel framework is introduced. In contrast to traditional discrete physical/velocity space decomposition parallelization methods, it can decompose each space in a hybrid manner and efficiently parallelize the computation. For better conservation of the macroscopic physical variables, flow properties in each cell are updated by moments of microscopic variable fluxes, which preserves particle multiscale information under sparse velocity space mesh. Several test cases, which include 2D lid-driven cavity flow in the transition flow regime, hypersonic rarefied flow past a 3D sphere, are carried out to verify the accuracy of the conserved discrete unified gas kinetic scheme to simulate the flows in all flow regimes. A large-scale parallel computational test case of 3D sphere with 101,600 physical mesh cells and 62,744 velocity mesh cells is conducted to measure the parallel efficiency of the conserved dugksFoam code. A significant superlinear speedup of 1631.87 has been achieved on 1120 cores. [ABSTRACT FROM AUTHOR]

This paper describes a quantitative approach to approximate multiple scattering through an isotropic turbid slab based on Markov Chain theorem. There is an increasing need to utilize multiple scattering for optical diagnostic purposes; however, existing methods are either inaccurate or computationally expensive. Here, we develop a novel Markov Chain approximation approach to solve multiple scattering angular distribution (AD) that can accurately calculate AD while significantly reducing computational cost compared to Monte Carlo simulation. We expect this work to stimulate ongoing multiple scattering research and deterministic reconstruction algorithm development with AD measurements. [ABSTRACT FROM AUTHOR]

We present an implementation of explicit solvent particle mesh Ewald (PME) classical molecular dynamics (MD) within the PMEMD molecular dynamics engine, that forms part of the AMBER v14 MD software package, that makes use of Intel Xeon Phi coprocessors by offloading portions of the PME direct summation and neighbor list build to the coprocessor. We refer to this implementation as pmemd MIC offload and in this paper present the technical details of the algorithm, including basic models for MPI and OpenMP configuration, and analyze the resultant performance. The algorithm provides the best performance improvement for large systems ( > 400,000 atoms), achieving a ∼35% performance improvement for satellite tobacco mosaic virus (1,067,095 atoms) when 2 Intel E5-2697 v2 processors (2 ×12 cores, 30M cache, 2.7 GHz) are coupled to an Intel Xeon Phi coprocessor (Model 7120P—1.238/1.333 GHz, 61 cores). The implementation utilizes a two-fold decomposition strategy: spatial decomposition using an MPI library and thread-based decomposition using OpenMP. We also present compiler optimization settings that improve the performance on Intel Xeon processors, while retaining simulation accuracy. [ABSTRACT FROM AUTHOR]

Replica Exchange with Solute Tempering (REST2) is a powerful sampling enhancement algorithm of molecular dynamics (MD) in that it needs significantly smaller number of replicas but achieves higher sampling efficiency relative to standard temperature exchange algorithm. In this paper, we extend the applicability of REST2 for quantitative biophysical simulations through a robust and generic implementation in greatly scalable MD software NAMD. The rescaling procedure of force field parameters controlling REST2 “hot region” is implemented into NAMD at the source code level. A user can conveniently select hot region through VMD and write the selection information into a PDB file. The rescaling keyword/parameter is written in NAMD Tcl script interface that enables an on-the-fly simulation parameter change. Our implementation of REST2 is within communication-enabled Tcl script built on top of Charm++, thus communication overhead of an exchange attempt is vanishingly small. Such a generic implementation facilitates seamless cooperation between REST2 and other modules of NAMD to provide enhanced sampling for complex biomolecular simulations. Three challenging applications including native REST2 simulation for peptide folding–unfolding transition, free energy perturbation/REST2 for absolute binding affinity of protein–ligand complex and umbrella sampling/REST2 Hamiltonian exchange for free energy landscape calculation were carried out on IBM Blue Gene/Q supercomputer to demonstrate efficacy of REST2 based on the present implementation. Program summary Program title: REST2-NAMD Catalogue identifier: AEXX_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEXX_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 240886 No. of bytes in distributed program, including test data, etc.: 8474342 Distribution format: tar.gz Programming language: C/C++, Tcl8.5. Computer: Not computer specific. Operating system: Any. Has the code been vectorized or parallelized?: Yes, MPI and/or PAMI parallelized depending on machine system software; ≥ 8192 cores used on IBM Blue Gene/Q Classification: 3. External routines: NAMD 2.10 ( http://www.ks.uiuc.edu/Research/namd/ ) Nature of problem: A generic implementation providing user-friendly API including input file preparation and performing replica exchange, and high frequency exchange attempt frequency with minimal communication overhead. Solution method: The rescaling procedure of force field parameters controlling REST2 is implemented into NAMD at the source code level. A user can conveniently select hot region through VMD and write the selection information into a PDB file. The rescaling keyword/parameter is written in NAMD Tcl script interface that enables an on-the-fly simulation parameter change. The implementation of REST2 is within communication-enabled Tcl script built on top of Charm++, thus communication overhead of an exchange attempt is vanishingly small. Running time: 30 min–60 min [ABSTRACT FROM AUTHOR]

In this paper the numerical integration of non conservative perturbations of differential systems that possess a first integral, as for example slowly dissipative Hamiltonian systems, is considered. Numerical methods that are able to reproduce appropriately the evolution of the first integral are proposed. These algorithms are based on a combination of standard numerical integration methods and certain projection techniques. Some conditions under which known conservative methods reproduce that desirable evolution in the invariant are analysed. Finally, some numerical experiments in which we compare the behaviour of the new proposed methods, the averaged vector field method AVF proposed by Quispel and McLaren and standard RK methods of orders 3 and 5 are presented. The results confirm the theory and show a good qualitative and quantitative performance of the new projection methods. [ABSTRACT FROM AUTHOR]

This paper presents a segregated algorithm to solve numerically the superfluid helium (He II) equations using the two-fluid model. In order to validate the resulting code and illustrate its potential, different simulations have been performed. First, the flow through a capillary filled with He II with a heated area on one side is simulated and results are compared to analytical solutions in both Landau and Gorter–Mellink flow regimes. Then, transient heat transfer of a forced flow of He II is investigated. Finally, some two-dimensional simulations in a porous medium model are carried out. [ABSTRACT FROM AUTHOR]

Computing scattering rates of electrons and phonons stands at the core of studies of electron transport properties. In the high field regime, the interactions between all electron bands with all phonon bands need to be considered. This full band interaction implies a huge computational burden in calculating scattering rates. In this study, a new accelerated algorithm is presented for this task, which speeds up the computation by two orders of magnitude (100 times) and dramatically simplifies the coding. At the same time, it visually demonstrates the physical process of scattering more clearly. Program summary Program title: Scattering_band_by_band Catalogue identifier: AEUH_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEUH_v1_0.html Program obtainable from: CPC Program Library, Queen’s University, Belfast, N. Ireland Licensing provisions: Standard CPC licence, http://cpc.cs.qub.ac.uk/licence/licence.html No. of lines in distributed program, including test data, etc.: 22914 No. of bytes in distributed program, including test data, etc.: 5785964 Distribution format: tar.gz Programming language: Matlab. Computer: All. Operating system: All. RAM: Depends on problem, ∼kB to MB Classification: 16.5. Nature of problem: Electron–phonon scattering is a fundamental problem in studying electron transport in condensed matters. There are situations where the scattering rates need to be updated frequently during a simulation, e.g. when hot phonon effects are considered. The speed of scattering calculation is very important in such cases. Solution method: In searching for possible scattering events, we propose here a band-by-band method, instead of the traditional point by point method. The whole calculation is parallelized in this sense and dramatically accelerated. Moreover, we proposed a representation method for all scattering mechanisms, which greatly simplified the coding task. Also, the additional animation part of this program demonstrates many insights into the scattering process. Restrictions: To use the code directly, electron band and phonon band should have the same mesh size. In other words, for each phonon band and electron band, they should have the same number of data points. Additional comments: If high speed is desired, it is best to turn off the animation function. Running time: Running time depends on the problem size. For the example used in this paper, it takes about 144 seconds by 1 CPU on Dell PowerEdge 610 (A dual quad core server with CPU frequency of 3.0 GHz). [ABSTRACT FROM AUTHOR]

The efficient operation and in-core fuel management of PWRs are of utmost importance. In the present work, a core reload optimization using Shuffled Frog Leaping (SFL) algorithm is addressed and mapped on nuclear fuel loading pattern optimization. SFL is one of the latest meta-heuristic optimization algorithms which is used for solving the discrete optimization problems and inspired from social behavior of frogs. The algorithm initiates the search from an initial population and carries forward to draw out an optimum result. This algorithm employs the use of memetic evolution by exchanging ideas between the members of the population in each local search. The local search of SFL is similar to particle swarm optimization (PSO) and applying shuffling process accomplishes the information exchange between several local searches to obtain an overall optimum result. To evaluate the proposed technique, Shekel's Foxholes and a VVER-1000 reactor are used as test cases to illustrate performance of SFL. Among numerous neutronic and thermal-hydraulic objectives necessary for a fuel management problem to reach an overall optimum, this paper deals with two neutronic objectives, i.e., maximizing effective multiplication factor and flattening power distribution in the core, to evaluate the capability of applying SFL algorithm for a fuel management problem. The results, convergence rate and reliability of the method are quite promising and show the potential and efficiency of the technique for other optimization applications in the nuclear engineering field. [ABSTRACT FROM AUTHOR]

We report fast computation of computer-generated holograms (CGHs) using Xeon Phi coprocessors, which have massively x86-based processors on one chip, recently released by Intel. CGHs can generate arbitrary light wavefronts, and therefore, are promising technology for many applications: for example, three-dimensional displays, diffractive optical elements, and the generation of arbitrary beams. CGHs incur enormous computational cost. In this paper, we describe the implementations of several CGH generating algorithms on the Xeon Phi, and the comparisons in terms of the performance and the ease of programming between the Xeon Phi, a CPU and graphics processing unit (GPU). [ABSTRACT FROM AUTHOR]

AutoPas is an open-source C++ library delivering optimal node-level performance by providing the ideal algorithmic configuration for an arbitrary scenario in a given short-range particle simulation. It acts as a black-box container, internally implementing an extensive set of algorithms, parallelization strategies, and optimizations that are combined dynamically according to the state of the simulation via auto-tuning. This paper gives an overview of the high-level user perspective, as well as the internal view, covering the implemented techniques and features. The library is showcased by incorporating it into the codes LAMMPS and ls1 mardyn, and by investigating various applications. We further outline node-level shared-memory performance and scalability of our auto-tuning software which is comparable to LAMMPS. Program Title: AutoPas CPC Library link to program files: https://doi.org/10.17632/9kdb2p76hv.1 Developer's repository link: https://github.com/AutoPas/AutoPas Code Ocean capsule: https://codeocean.com/capsule/0391732 Licensing provisions: BSD 2-clause Programming language: C++17, CMake 3.14 Nature of problem: The evaluation of the short-range pairwise interactions in an N-Body simulation can be achieved using many different algorithms and parallelization techniques. Depending on the nature of the scenario, its current state, and the forces of interest, the optimal algorithm configuration can differ greatly. Choosing this optimum is a non-trivial task even for experts. Furthermore, this optimum can change over the course of a simulation. Typically, a particle simulation software only implements one algorithm for force computation and is thus specialized for a certain type of simulation. It is up to the user to choose the program suitable for his needs. Solution method: The AutoPas library implements a range of state of the art algorithms to find the relevant neighbors for the N-Body pairwise force calculation. It provides multiple shared-memory parallelization strategies using OpenMP and further algorithm optimization parameters that can all be set at run-time. A big burden for users persists in requiring the expert knowledge to pick the optimal solution procedure for a simulation. AutoPas removes this burden by tuning all aforementioned options automatically and dynamically. This way, simulation programs that make use of AutoPas give every domain scientist the possibility to make use of the most suitable algorithm configuration for arbitrary scenarios. [ABSTRACT FROM AUTHOR]

UnDiFi-2D , an open source (free software) Un structured-grid, Di scontinuity Fi tting code, is presented. The aim of UnDiFi-2D is to model gas-dynamic discontinuities in two-dimensional (2D) flows as if they were true discontinuities of null thickness that bound regions of the flow-field where a smooth solution to the governing PDEs exists. UnDiFi-2D therefore needs to be coupled with an unstructured CFD solver that is used to discretize the governing PDEs within the smooth regions of the flow-field. Two different, in-house developed, CFD solvers are also included in the current distribution. The main features of the UnDiFi-2D software can be summarized as follows: Programming language UnDiFi-2D is written in standard Fortran 77/95; its design is highly modular in order to enhance simplicity of use, maintenance and allow coupling with virtually any existing CFD solver; Usability, maintenance and enhancement In order to improve the usability, maintenance and enhancement of the code also the documentation has been carefully taken into account. The git distributed versioning system has been adopted to facilitate collaborative maintenance and code development; Copyrights UnDiFi-2D is a free software that anyone can use, copy, distribute, change and improve under the GNU Public License version 3. The present paper is a manifesto of the first public release of the UnDiFi-2D code. It describes the currently implemented features, which are the result of more than a decade of still ongoing CFD developments. This work is focused on the computational techniques adopted and a detailed description of the main characteristics is reported. UnDiFi-2D capabilities are demonstrated by means of examples test cases. The design of the code allows to easily include existing CFD codes and is aimed at ease code reuse and readability. Program title: UnDiFi-2D CPC Library link to program files: https://doi.org/10.17632/5hwssmc2mx.1 Licensing provisions: GNU General Public License, version 3 Programming language: Fortran; developed and tested with Intel Fortran Compiler v. 18.0.3 and GNU gfortran. External routines: The code depends on several libraries and third-party packages which are detailed in the corpus of the text. Nature of problem: Numerical computation of flows with discontinuities. Solution method: Shock-fitting technique. Additional comments including restrictions and unusual features: • At present, UnDiFi-2D is validated for inviscid steady and unsteady two-dimensional flows without changes in the number of discontinuity lines and interaction points. • UnDiFi-2D implements a shock-fitting algorithm and can be coupled with unstructured cell-vertex solvers, with an Arbitrary Lagrangian-Eulerian (ALE) formulation. • UnDiFi-2D project adopts git [1], a free and open source distributed version control system. A public repository dedicated to UnDiFi-2D project [2] has been created on github [3], a web-based hosting service for software development projects using git versioning system. Finally, a comprehensive documentation is provided in the form of user manual developed in Pandoc [4]. [1] Git, a free and open source distributed version control system, http://git-scm.com. [2] UnDiFi-2D documentation, https://github.com/UnDiFi/UnDiFi-2D. [3] Github, a web-based hosting service for software development projects using git versioning system, https://github.com. [4] M. Dominici, TUGboat 35(1) (2014) 44-50. [ABSTRACT FROM AUTHOR]

Abstract: This work suggests a new analytical technique called the fractional homotopy analysis transform method (FHATM) for solving nonlinear homogeneous and nonhomogeneous time-fractional gas dynamics equations. The FHATM is an innovative adjustment in Laplace transform algorithm (LTA) and makes the calculation much simpler. The proposed technique solves the nonlinear problems without using Adomian polynomials and He’s polynomials which can be considered as a clear advantage of this new algorithm over decomposition and the homotopy perturbation transform method. In this paper, it can be observed that the auxiliary parameter , which controls the convergence of the HATM approximate series solutions, also can be used in predicting and calculating multiple solutions. This is a basic and more qualitative difference in analysis between HATM and other methods. The solutions obtained by the proposed method indicate that the approach is easy to implement and computationally very attractive. The proposed method is illustrated by solving some numerical examples. [Copyright &y& Elsevier]

Abstract: The nonlinear gyrokinetic equations describe plasma turbulence in laboratory and astrophysical plasmas. To solve these equations, massively parallel codes have been developed and run on present-day supercomputers. This paper describes measures to improve the efficiency of such computations, thereby making them more realistic. Explicit Runge–Kutta schemes are considered to be well suited for time-stepping. Although the numerical algorithms are often highly optimized, performance can still be improved by a suitable choice of the time-stepping scheme, based on the spectral analysis of the underlying operator. Here, an operator splitting technique is introduced to combine first-order Runge–Kutta–Chebychev schemes for the collision term with fourth-order schemes for the remaining terms. In the nonlinear regime, based on the observation of eigenvalue shifts due to the (generalized) advection term, an accurate and robust estimate for the nonlinear timestep is developed. The presented techniques can reduce simulation times by factors of up to three in realistic cases. This substantial speedup encourages the use of similar timestep optimized explicit schemes not only for the gyrokinetic equation, but also for other applications with comparable properties. [Copyright &y& Elsevier]