Search

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]

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: 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]

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]

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: The library RNGSSELIB for random number generators (RNGs) based upon the SSE2 command set is presented. The library contains realization of a number of modern and most reliable generators. Usage of SSE2 command set allows to substantially improve performance of the generators. Three new RNG realizations are also constructed. We present detailed analysis of the speed depending on compiler usage and associated optimization level, as well as results of extensive statistical testing for all generators using available test packages. Fast SSE implementations produce exactly the same output sequence as the original algorithms. Program summary: Program title: RNGSSELIB Catalogue identifier: AEIT_v1_0 Program summary URL: http://cpc.cs.qub.ac.uk/summaries/AEIT_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.: 4177 No. of bytes in distributed program, including test data, etc.: 21 228 Distribution format: tar.gz Programming language: C. Computer: PC. Operating system: UNIX, Windows. RAM: 1 Mbytes Classification: 4.13. Nature of problem: Any calculation requiring uniform pseudorandom number generator, in particular, Monte Carlo calculations. Solution method: The library contains realization of a number of modern and reliable generators: mt19937, mrg32k3a and lfsr113. Also new realizations for the method based on parallel evolution of an ensemble of dynamical systems are constructed: GM19, GM31 and GM61. The library contains both usual realizations and realizations based on SSE command set. Usage of SSE commands allows the performance of all generators to be substantially improved. Restrictions: For SSE realizations of the generators, Intel or AMD CPU supporting SSE2 command set is required. In order to use the realization lfsr113sse, CPU must support SSE4 command set. Running time: Running time is of the order of 20 sec for generating 109 pseudorandom numbers with a PC based on Intel Core i7-940 CPU. Running time is analysed in detail in Section 5 of the paper. [Copyright &y& Elsevier]

We provide a detailed description of the Fortran code CPsuperH, a newly-developed computational package that calculates the mass spectrum and decay widths of the neutral and charged Higgs bosons in the Minimal Supersymmetric Standard Model with explicit CP violation. The program is based on recent renormalization-group-improved diagrammatic calculations that include dominant higher-order logarithmic and threshold corrections, b-quark Yukawa-coupling resummation effects and Higgs-boson pole-mass shifts. The code CPsuperH is self-contained (with all subroutines included), is easy and fast to run, and is organized to allow further theoretical developments to be easily implemented.11The program may be obtained from http://theory.ph.man.ac.uk/~jslee/CPsuperH.html. The fact that the masses and couplings of the charged and neutral Higgs bosons are computed at a similar high-precision level makes it an attractive tool for Tevatron, LHC and LC studies, also in the CP-conserving case.: Program summaryTitle of program: CPsuperHCatalogue number: ADSRProgram summary URL:http://cpc.cs.qub.ac.uk/summaries/ADSRProgram obtainable from: CPC Program Library, Queen''s University of Belfast, N. IrelandComputer for which the program is designed and others on which it is operable: PC running under Linux and computers in Unix environmentProgramming Language used: Fortran77High-speed storage required: NoNo. of bytes in distributed program, including test data, etc.: 49 729Distribution format: tar gzip fileNo. of lines in combined program and test case: 7417Separate documentation available: The program and the paper may be obtainable from http://theory.ph.man.ac.uk/~jslee/CPsuperH.htmlKeywords: Higgs bosons, supersymmetry, CPNature of physical problem: The mass spectrum, decay widths and branching ratios of the neutral and charged Higgs bosons in the Minimal Supersymmetric Standard Model with explicit CP violation are calculated. The program is based on recent renormalization-group-improved diagrammatic calculations that include dominant higher-order logarithmic and threshold corrections, b-quark Yukawa-coupling resummation effects and Higgs-boson pole-mass shifts. The couplings of the Higgs bosons to the Standard Model gauge bosons and fermions, to their supersymmetric partners and all the trilinear and quartic Higgs-boson self-couplings are also calculated.Method of solution: One-dimensional numerical integration for the Higgs-decay modes involving more than one massive gauge boson, iterative treatment of the threshold corrections, and the numerical diagonalization of the neutralino mass matrix.Restrictions on the complexity of the problem: Only the dominant leading-order QCD corrections which remain unaffected by CP violation have been included in this version.Typical running time: Less than 0.1 sUnusual features of the program: NoReferences: No [Copyright &y& Elsevier]

The calculation of overlaps between many-electron wave functions at different nuclear geometries during nonadiabatic dynamics simulations requires the evaluation of a large number of determinants of matrices that differ only in a few rows/columns. While this calculation is fast for small systems, its cost grows faster than the alternative electronic structure calculation used to obtain the wave functions. For wave functions that can be written as a CIS expansion, all determinants can be computed using the set of level-2 minors of the reference matrix. However, this is still a costly computation for large systems. In this paper, we provide an algorithm for efficiently calculating all level-2 minors of a matrix by re-utilizing and updating the LU factorization for the determinants of the minors. This approach results in a parallel version of the algorithm that is up to an order of magnitude faster then the current best parallel implementation. The algorithm thus allows the computation of exact wave function overlaps for relatively large systems, with a high density of states, at virtually no cost compared with the electronic structure calculations. Furthermore, the new algorithm opens the path to further investigations in efficient computing of the exact wave function overlaps for complex wave functions such as MR-CIS and MR-CISD. Program Title: CIS Overlap Licensing provisions: MIT Programming language: FORTRAN 2008, C Nature of problem: Calculation of overlaps between CIS type wave functions at different nuclear geometries during nonadiabatic dynamics simulation requires calculating a large number of connected determinants and scales with the seventh power of the size of the system being studied. Without additional approximations, for large systems this computation becomes more costly than the electronic structure calculation used to obtain the wave functions. Solution method: All of the determinants required for a CIS wave function overlap calculation can be derived from the set of all level-2 minors of the matrix of overlaps between the reference Slater determinants. We developed an algorithm for efficiently computing all level-2 minors of a matrix. This part of the computational process was the bottleneck in previous solutions to the problem and is now an order of magnitude faster resulting in significantly faster overall calculation of the wave function overlaps. • MEWF calculation is computationally expensive. • Efficient computing of these functions is highly beneficial. • Updating the LU factorization opens the path to obtain the level-2 minors of a matrix. • High performance computing can help accelerate these computations. [ABSTRACT FROM AUTHOR]

This paper presents the new version of our code Maxis (Lin et al., 2011). Maxis is a local rezoning and remapping code in two dimensional cylindrical geometry, which can be employed to address the grid distortion problem of unstructured meshes. The new version of Maxis is mostly programmed in the C language which considerably improves its computational efficiency with respect to the former Matlab version. A new algorithm for determining the intersection of two arbitrary convex polygons is also incorporated into the new version. Some additional linking functions are further provided in the new version for the purpose of combining Maxis and MULTI2D. New version program summary Program title: Maxis Program files doi: http://dx.doi.org/10.17632/nnxvbg9pbz.1 Licensing provisions: GPLv3 Programming language: C and Matlab Subprograms used: MULTI2D CPC 180 (2009) 977 Journal reference of previous version: Zhiwei Lin, Comput. Phys. Commun. 182 (2011) 1361–1376 Does the new version supersede the previous version?: Yes Nature of problem: Although the large distortion of mesh zones moving with fluid velocities causes the shortening of time step and the increasing of computational error, and thus makes it indispensable that the rezoning of distorted zones and the remapping of physical variables are performed, it should be noted that rezoning and remapping can also bring in the loss of the Lagrangian motion information of the original mesh. Therefore the essential problem is how to minimize the loss caused by rezoning and remapping and to improve the mesh quality concurrently. Solution method: We employ the local rezoning and remapping technique to confine the loss within the worse or insignificant regions, that is, only those worse regions determined by the mesh-closure or mesh-union methods are rezoned. Reasons for the new version: Due to the multi loops of the remapping algorithm, the former version of Maxis [1] in the Matlab language is quite inefficient. Moreover, the linking functions for combining Maxis and MULTI2D [2] are not present in the previous version. Summary of revisions: The new version of Maxis is mostly programmed in the C language and its computational efficiency is greatly increased. The remapping algorithm of the new version is based on a new scheme for determining the intersection of two arbitrary convex polygons. Some linking functions are also provided along. The detailed new features of Maxis are as follows. (1) The development of Maxis in C The former version of Maxis is developed in the Matlab language and is quite inefficient due to the multi loops of the remapping algorithm. Hence we programme the time consuming part of Maxis in the C language because of its high efficiency, that is, the following C functions are developed: closure_of_polygon.c : which can be used to compute mesh closure; new_topology.c : which can be used to compute the topology of the new mesh; cell_remapping.c : which can be used to compute the zone/cell centered physical variables of the new mesh such as mass densities; node_remapping.c : which can be used to compute the node centered physical variables of the new mesh such as nodal velocities; convex_polygon_intersection.c : which can be used to compute the intersection of two arbitrary convex polygons. But the top level of the code Maxis still uses the Matlab language, since Matlab is easy to use and makes it rather convenient to visualize and analyze numerical results. The advantages of the C and Matlab languages can be fully exploited by doing so. The thought of combining two computer languages is also adopted by MULTI2D in which the C and r94 languages are utilized at different computing levels. (2) A new scheme for determining the intersection of two arbitrary convex polygons Both cell_remapping.c and node_remapping.c are based on a new algorithm for computing the intersection of two arbitrary convex polygons as follows. Let P 1 and P 2 be two convex polygons. Then it holds that P 1 = ∩ i = 1 n 1 l i , where l i is the half plane determined by the i th edge of P 1 and n 1 is the number of the edges of P 1 . Then we can have that P 1 ∩ P 2 = P 2 ∩ l 1 ∩ l 2 ∩ ⋯ ∩ l n 1 . Hence the calculation of the intersection of two convex polygons can be reduced to a series of calculations of the intersection between a convex polygon and a half plane, which can be readily programmed. Such an example is given in Fig. 1 . (3) Some linking functions The new version of Maxis comprises some linking functions for the purpose of combining Maxis and MULTI2D. For example, the r94 function readremap.r is supplied to import the data of the Maxis remap.out into MULTI2D so that the Lagrangian calculation of an ALE simulation [3,4] can proceed. (4) New Maxis manual A new Maxis manual for detailed operations is provided along. Restrictions: It appears that there is no uniform criterion to distinguish the worse mesh zones from the good ones. Unusual features: The time consuming part of Maxis is developed in the C language, whereas the top level of the code still utilizes the Matlab language, which takes full advantage of both languages. References [1] Z.W. Lin, S.E. Jiang, S.C. Wu, L.Y. Kuang, Comput. Phys. Commun. 182 (2011) 1361. [2] R. Ramis, J. Meyer-ter-Vehn, J. Ramirez, Comput. Phys. Commun. 180 (2009) 977. [3] C.W. Hirt, A.A. Amsden, J. Cook, J. Comput. Phys. 14 (1974) 227, reprinted in 135 (1997) 203. [4] M. Kenamond, M. Bement, M. Shashkov, J. Comput. Phys. 268 (2014) 154. [ABSTRACT FROM AUTHOR]