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]

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]

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]