Search

Computational fluid dynamics (CFD) is an important tool for the simulation of the cardiovascular function and dysfunction. Due to the complexity of the anatomy, the transitional regime of blood flow in the heart, and the strong mutual influence between the flow and the physical processes involved in the heart function, the development of accurate and efficient CFD solvers for cardiovascular flows is still a challenging task. In this paper we present life▪-cfd, an open-source CFD solver for cardiovascular simulations based on the life▪ finite element library, written in modern C++ and exploiting distributed memory parallelism. We model blood flow in both physiological and pathological conditions via the incompressible Navier-Stokes equations, accounting for moving cardiac valves, moving domains, and transition-to-turbulence regimes. In this paper, we provide an overview of the underlying mathematical formulation, numerical discretization, implementation details and examples on how to use life▪-cfd. We verify the code through rigorous convergence analyses, and we show its almost ideal parallel speedup. We demonstrate the accuracy and reliability of the numerical methods implemented through a series of idealized and patient-specific vascular and cardiac simulations, in different physiological flow regimes. The life▪-cfd source code is available under the LGPLv3 license, to ensure its accessibility and transparency to the scientific community, and to facilitate collaboration and further developments. Program Title: life▪-cfd CPC Library link to program files: https://doi.org/10.17632/hzsnc3jgds.1 Developer's repository link: https://gitlab.com/lifex/lifex-cfd Licensing provisions: LGPLv3 Programming language: C++ (standard ≥17) Supplementary material: https://doi.org/10.5281/zenodo.7852088 contains the application executable in binary form, compatible with any recent enough x86-64 Linux system, assuming that glibc version ≥ 2.28 is installed. Data and parameter files necessary to replicate the test cases described in this manuscript are also available. Nature of problem: The program allows to run computational fluid dynamics simulations of cardiovascular blood flows in physiological and pathological conditions, modeled through incompressible Navier-Stokes equations, including moving cardiac valves, moving domains (such as contracting cardiac chambers) in the arbitrary Lagrangian-Eulerian framework, and transition-to-turbulence flow. Given the scale of the typical applications, the program is designed for parallel execution. Solution method: The equations are discretized using the Finite Element method, on either tetrahedral or hexahedral meshes. The software builds on top of deal.II, implementing the mathematical models and numerical methods specific for CFD cardiovascular simulations. Parallel execution exploits the MPI paradigm. The software supports both Trilinos and PETSc as linear algebra backends. Additional comments including restrictions and unusual features: The program provides a general-purpose executable that can be used to run CFD simulations without having to access or modify the source code. The program allows to setup simulations through a user-friendly yet flexible interface, by means of readable and self-documenting parameter files. On top of that, more advanced users can modify the source code to implement more sophisticated test cases. life▪-cfd supports checkpointing, i.e. simulations can be stopped and restarted at a later time. [ABSTRACT FROM AUTHOR]

The search for new comparably light (well below the electroweak scale) feebly interacting particles is an exciting possibility to explain some mysterious phenomena in physics, among them the origin of Dark Matter. The sensitivity study through detailed simulation of projected experiments is a key point in estimating their potential for discovery. Several years ago we created the DMG4 package for the simulation of DM (Dark Matter) particles in fixed target experiments. The natural approach is to integrate this simulation into the same program that performs the full simulation of particles in the experiment setup. The Geant4 toolkit framework was chosen as the most popular and versatile solution nowadays. The simulation of DM particles production by this package accommodates several possible scenarios, employing electron, muon or photon beams and involving various mediators, such as vector, axial vector, scalar, pseudoscalar, or spin 2 particles. The bremsstrahlung, annihilation or Primakoff processes can be simulated. The package DMG4 contains a subpackage DarkMatter with cross section methods weakly connected to Geant4. It can be used in different frameworks. In this paper, we present the latest developments of the package, such as extending the list of possible mediator particle types, refining formulas for the simulation and extending the mediator mass range. The user interface is also made more flexible and convenient. In this work, we also demonstrate the usage of the package, the improvements in the simulation accuracy and some cross check validations. Program title: DMG4 CPC Library link to program files: https://doi.org/10.17632/cmr4bcrj6j.1 Licensing provisions: GNU General Public License 3 Programming language: c++ Journal reference of previous version: Comput. Phys. Commun. 269 (2021) 108129 Does the new version supersede the previous version?: Yes Reasons for the new version: Numerous developments, addition of new features Summary of revisions: WW approximation cross sections for the muon beam are implemented and cross-checked, models with semivisible A ′ (inelastic Dark Matter) and spin 2 mediators are added. The range of possible mediator masses is extended. Several important improvements for the annihilation processes are made, the number of possible annihilation processes is extended. User interface is improved. Several bugs are fixed. Nature of problem: For the simulation of Dark Matter production processes in fixed target experiments a code that can be easily integrated in programs for the full simulation of experimental setup is needed. Solution method: A fully Geant4 compatible DM simulation package DMG4 was presented in 2020. We present numerous further developments of this package. [ABSTRACT FROM AUTHOR]

Large linear systems play an important role in high-energy theory, appearing in amplitude bootstraps and during integral reduction. This paper introduces FiniteFieldSolve, a general-purpose toolkit for exactly solving large linear systems over the rationals. The solver interfaces directly with Mathematica, is straightforward to install, and seamlessly replaces Mathematica's native solvers. In testing, FiniteFieldSolve is approximately two orders of magnitude faster than Mathematica and uses an order of magnitude less memory. The package also compares favorably against other public solvers in FiniteFieldSolve's intended use cases. As the name of the package suggests, solutions are obtained via well-known finite field methods. These methods suffer from introducing an inordinate number of modulo (or integer division) operations with respect to different primes. By automatically recompiling itself for each prime, FiniteFieldSolve converts the division operations into much faster combinations of instructions, dramatically improving performance. The technique of compiling the prime can be applied to any finite field solver, where the time savings will be solver dependent. The operation of the package is illustrated through a detailed example of an amplitude bootstrap. Program Title: FiniteFieldSolve CPC Library link to program files: https://doi.org/10.17632/ntxvp58mjg.1 Developer's repository link: https://github.com/jfmangan/FiniteFieldSolve Licensing provisions: GPLv3 Programming language: Mathematica, C++ Nature of problem: Exactly solving large linear systems over the rationals occurs in various settings in high-energy theory, for example when performing integral reduction or bootstrapping an amplitude. Solution method: The linear system is solved by repeatedly row reducing over different finite fields (see Ref. [1] and references therein). Finite fields avoid the intermediary expression swell inherent to arbitrary precision rationals and bypass roundoff errors from floating point numbers. A downside to using modular arithmetic is that it introduces a tremendous number of integer divisions, but this can be mitigated by compiling the divisions down to simpler instructions. The solver is designed to handle arbitrarily dense systems such as those that appear in certain amplitudes bootstraps. [1] M. Kauers, Fast solvers for dense linear systems, Nucl. Phys. B Proc. Suppl. 183, 245–250 (2008), 10.1016/j.nuclphysbps.2008.09.111 [ABSTRACT FROM AUTHOR]

H-wave is an open-source software package for performing the Hartree–Fock approximation (HFA) and random phase approximation (RPA) for a wide range of Hamiltonians of interacting fermionic systems. In HFA calculations, H-wave examines the stability of several symmetry-broken phases, such as anti-ferromagnetic and charge-ordered phases, in the given Hamiltonians at zero and finite temperatures. Furthermore, H-wave calculates the dynamical susceptibilities using RPA to examine the instability toward the symmetry-broken phases. By preparing a simple input file for specifying the Hamiltonians, users can perform HFA and RPA for standard Hamiltonians in condensed matter physics, such as the Hubbard model and its extensions. Additionally, users can use a Wannier90 -like format to specify fermionic Hamiltonians. A Wannier90 format is implemented in RESPACK to derive ab initio Hamiltonians for solids. HFA and RPA for the ab initio Hamiltonians can be easily performed using H-wave. In this paper, we first explain the basis of HFA and RPA, and the basic usage of H-wave , including download and installation. Thereafter, the input file formats implemented in H-wave , including the Wannier90 -like format for specifying the interacting fermionic Hamiltonians, are discussed. Finally, we present several examples of H-wave such as zero-temperature HFA calculations for the extended Hubbard model on a square lattice, finite-temperature HFA calculations for the Hubbard model on a cubic lattice, and RPA in the extended Hubbard model on a square lattice. Program Title: H-wave CPC Library link to program files: https://doi.org/10.17632/9gr6pxhfjm.1 Developer's repository link: https://github.com/issp-center-dev/H-wave Code Ocean capsule: https://codeocean.com/capsule/6875177 Licensing provisions: GNU General Public License version 3 Programming language: Python3 External routines/libraries: NumPy, SciPy, Tomli, Requests. Nature of problem: Physical properties of strongly correlated electrons are examined such as ground state phase structure and response functions at zero and finite temperatures. Solution method: Calculations based on the unrestricted Hartree-Fock approximation and the random phase approximation are performed for the quantum lattice models such as the Hubbard model and its extensions. [ABSTRACT FROM AUTHOR]

This paper presents a comprehensive update to PyProcar, a versatile Python package for analyzing and visualizing density functional theory (DFT) calculations in materials science. The latest version introduces a modularized codebase, a centralized example data repository, and a robust testing framework, offering a more reliable, maintainable, and scalable platform. Expanded support for various DFT codes broadens its applicability across research environments. Enhanced documentation and an example gallery make the package more accessible to new and experienced users. Incorporating advanced features such as band unfolding, noncollinear calculations, and derivative calculations of band energies enriches its analytic capabilities, providing deeper insights into electronic and structural properties. The package also incorporates PyPoscar, a specialized toolkit for manipulating POSCAR files, broadening its utility in computational materials science. These advancements solidify PyProcar's position as a comprehensive and highly adaptable tool, effectively serving the evolving needs of the materials science community. Program title: PyProcar CPC Library link to program files: https://doi.org/10.17632/d4rrfy3dy4.2 Developer's repository link: https://github.com/romerogroup/pyprocar Licensing provisions: GPLv3 Programming language: Python Supplementary material: Pyprocar-Supplementary Information Journal reference of previous version: Comput. Phys. Commun. 251 (2020) 107080, https://doi.org/10.1016/j.cpc.2019.107080 Does the new version supersede the previous version?: Yes Reasons for the new version: Changes in the directory structure, the addition of new features, enhancement of the manual and user documentation, and generation of interfaces with other electronic structure packages. Summary of revisions: These updates enhance its capabilities and ensure developers' and users' maintainability, reliability, and ease of use. Nature of problem: To automate, simplify, and serialize the analysis of band structure and Fermi surface, especially for high throughput calculations. Solution method: Implement a Python library able to handle, combine, parse, extract, plot, and even repair data from density functional calculations from diverse electronic structure packages. PyProcar uses color maps on the band structures or Fermi surfaces to give a simple representation of the relevant characteristics of the electronic structure. Additional comments including restrictions and unusual features: PyProcar can produce high-quality figures of band structures and Fermi surfaces (2D and 3D), projection of atomic orbitals, atoms, and/or spin components. [ABSTRACT FROM AUTHOR]

This paper contributes an open source software - SMIwiz, which integrates seismic modelling, reverse time migration (RTM), and full waveform inversion (FWI) into a unified computer implementation. SMIwiz has the machinery to do both 2D and 3D simulation in a consistent manner. The package features a number of computational recipes for efficient calculation of imaging condition and inversion gradient: a dynamic evolving computing box to limit the simulation cube and a well-designed wavefield reconstruction strategy to reduce the memory consumption when dealing with 3D problems. The modelling in SMIwiz runs independently: each shot corresponds to one processor in a bijective manner to maximize the scalability. A batchwise job scheduling strategy is designed to handle large 3D imaging tasks on computer with limited number of cores. The viability of SMIwiz is demonstrated by a number of applications on benchmark models. Program Title: SMIwiz CPC Library link to program files: https://doi.org/10.17632/tygszns27k.1 Developer's repository link: https://github.com/yangpl/SMIwiz Licensing provisions: GNU General Public License v3.0 Programming language: C, Shell, Fortran External dependencies: MPI [1], FFTW [2] Nature of problem: Seismic modelling and imaging (FWI and RTM) Solution method: High-order finite-difference time-domain (FDTD) for modelling on staggered grid; Quasi-Newton LBFGS algorithm for nonlinear optimization; line search to estimate step length based on Wolfe condition [1] https://www.mpich.org/ [2] http://fftw.org/ [ABSTRACT FROM AUTHOR]

This paper introduces ElecTra , an open-source code which solves the linearized Boltzmann transport equation in the relaxation time approximation for charge carriers in a full-band electronic structure of arbitrary complexity, including their energy, momentum, and band-index dependence. ElecTra stands for 'ELECtronic TRAnsport' and computes the electronic and thermoelectric transport coefficients electrical conductivity, Seebeck coefficient, electronic thermal conductivity, and mobility, for semiconductor materials, for both unipolar and bipolar (small bandgap) materials. The code uses computed full-bands and relevant scattering parameters as inputs and considers single crystal materials in 3D and 2D. The present version of the code (v1) considers: i) elastic scattering with acoustic phonons and inelastic scattering with non-polar optical phonons in the deformation potential approximation, ii) inelastic scattering with polar phonons, iii) scattering with ionized dopants, and iv) alloy scattering. The user is given the option of intra- and inter-band scattering considerations. The simulation output also includes relevant relaxation times and mean-free-paths. The transport quantities are computed as a function of Fermi level position, doping density, and temperature. ElecTra can interface with any DFT code which saves the electronic structure in the '.bxsf' format. In this paper ElecTra is validated against ideal electronic transport situations of known analytical solutions, existing codes employing the constant relaxation time approximation, as well as experimentally well-assessed materials such as Si, Ge, SiGe, and GaAs. Program title: ElecTra – Electronic Transport simulation lab CPC Library link to program files: https://doi.org/10.17632/ycgx2fjzb6.1 Licensing provisions: GPLv3 Programming Language: MATLAB® Nature of the problem: computing the electronic and thermoelectric charge transport coefficients of materials with arbitrary complex full-band electronic structures, considering the carrier energy-, momentum-, and band-dependence of the scattering rates. Solution method: Semiclassical Linearized Boltzmann transport equation, with electronic structures (DFT or analytical) as input, formed into constant-energy surfaces, with scattering rates evaluated using Fermi's Golden Rule. Additional comments including restrictions and unusual features: • Programming interface: any DFT code which saves data in the '.bxsf' format. • RAM: a case study for a half-Heusler bandstructure on a 51 × 51 × 51 k -mesh, 2 Gb per processor is needed • Running time: for the example above, depending on the number and complexity of the scattering mechanisms and the number of simulated Fermi levels and temperatures considered, the time needed varies from ∼ 1 hour on a desktop PC or laptop (light simulations), to 5-10 hours on an HPC with 30-45 cores (heavy simulations). Using the constant relaxation time and constant mean-free-path approximations on a desktop PC or laptop, the running time is of the order of minutes. [ABSTRACT FROM AUTHOR]

Machine learning has emerged as a promising paradigm to study the quantum dissipative dynamics of open quantum systems. To facilitate the use of our recently published ML-based approaches for quantum dissipative dynamics, here we present an open-source Python package MLQD (https://github.com/Arif-PhyChem/MLQD), which currently supports the three ML-based quantum dynamics approaches: (1) the recursive dynamics with kernel ridge regression (KRR) method, (2) the non-recursive artificial-intelligence-based quantum dynamics (AIQD) approach and (3) the blazingly fast one-shot trajectory learning (OSTL) approach, where both AIQD and OSTL use the convolutional neural networks (CNN). This paper describes the features of the MLQD package, the technical details, optimization of hyperparameters, visualization of results, and the demonstration of the MLQD 's applicability for two widely studied systems, namely the spin-boson model and the Fenna–Matthews–Olson (FMO) complex. To make MLQD more user-friendly and accessible, we have made it available on the Python Package Index (PyPi) platform and it can be installed via ▪. In addition, it is also available on the XACS cloud computing platform (https://XACScloud.com) via the interface to the MLatom package (http://MLatom.com). Program Title: MLQD CPC Library link to program files: https://doi.org/10.17632/yxp37csy5x.1 Developer's repository link: https://github.com/Arif-PhyChem/MLQD Code Ocean capsule: https://codeocean.com/capsule/5563143/tree Licensing provisions: Apache Software License 2.0 Programming language: Python 3.0 Supplementary material: Jupyter Notebook-based tutorials External routines/libraries: Tensorflow, Scikit-learn, Hyperopt, Matplotlib, MLatom Nature of problem: Fast propagation of quantum dissipative dynamics with machine learning approaches. Solution method: We have developed MLQD as a comprehensive framework that streamlines and supports the implementation of our recently published machine learning-based approaches for efficient propagation of quantum dissipative dynamics. This framework encompasses: (1) the recursive dynamics with kernel ridge regression (KRR) method, as well as the non-recursive approaches utilizing convolutional neural networks (CNN), namely (2) artificial intelligence-based quantum dynamics (AIQD), and (3) one-shot trajectory learning (OSTL). Additional comments including restrictions and unusual features: 1. Users can train a machine learning (ML) model following one of the ML-based approaches: KRR, AIQD and OSTL. 2. Users have the option to propagate dynamics with the existing trained ML models. 3. MLQD also provides the transformation of trajectories into the training data. 4. MLQD also supports hyperparameter optimization using MLATOM's grid search functionality for KRR and Bayesian methods with Tree-structured Parzen Estimator (TPE) for CNN models via the HYPEROPT package. 5. MLQD also facilitates the visualization of results via auto-plotting. 6. MLQD is designed to be user-friendly and easily accessible, with availability on the XACS cloud computing platform (https://XACScloud.com) via the interface to the MLATOM package (http://MLatom.com). In addition, it is also available as a pip package which makes it easy to install. Future outlook: MLQD will be extended to more realistic systems along with the incorporation of other machine learning-based approaches as well as the traditional quantum dynamics methods. [ABSTRACT FROM AUTHOR]

This paper introduces OPSimTool, a set of additions to the Geant4 toolkit that simplify the development of optical photon applications and enhance the flexibility and maintainability of developed applications. The tool also provides interfaces for creating reusable and portable material build code. This tool has been developed according to users' needs and perspectives, considering frequently asked questions, most encountered challenges, and evolving needs over time in the optical category of the Geant4 official forum page. Program title: OPSimTool CPC Library link to program files: https://doi.org/10.17632/6jtbxdnpm4.1 Developer's repository link: https://github.com/mkandemirr/OpSim Licensing provisions: GNU General Public License 3 Programming language: C++ External routines/libraries: Geant4, CMake Nature of problem: Although the toolkit provided by Geant4 is sufficient to perform optical photon simulations, providing additional tools will be highly beneficial for developing more flexible and sustainable applications. Solution method: We have developed a set of C++ classes in the spirit of Geant4 users and made them available to the public. • OPSimTool is a set of additions to the Geant4 toolkit that simplifies the development of optical photon applications. • OPSimTool increases the flexibility and maintainability of the developed code. • OPSimTool provides interfaces for creating reusable and portable material build code. [ABSTRACT FROM AUTHOR]

The purpose of analytic continuation is to establish a real frequency spectral representation of single-particle or two-particle correlation function (such as Green's function, self-energy function, spin and charge susceptibilities) from noisy data generated in finite temperature quantum Monte Carlo simulations. It requires numerical solutions of a family of Fredholm integral equations of the first kind, which is indeed a challenging task. In this paper, an open source toolkit (dubbed ACFlow) for analytic continuation of quantum Monte Carlo data is presented. We first give a short introduction to the analytic continuation problem. Next, three popular analytic continuation algorithms, including the maximum entropy method, the stochastic analytic continuation, and the stochastic optimization method, as implemented in this toolkit are reviewed. And then we elaborate on the major features, implementation details, basic usage, inputs, and outputs of this toolkit. Finally, four representative examples, including analytic continuations of Matsubara self-energy function, Matsubara and imaginary time Green's functions, and current-current correlation function, are shown to demonstrate the usefulness and flexibility of the ACFlow toolkit. Program Title: ACFlow CPC Library link to program files: https://doi.org/10.17632/th6w74gwjm.1 Developer's repository link: https://github.com/huangli712/ACFlow Licensing provisions: GNU General Public License Version 3 Programming language: Julia Nature of problem: Most of the quantum Monte Carlo methods work on imaginary axis. In order to extract physical observables and compare them with the experimental results, analytic continuation must be done in the post-processing stage to convert the quantum Monte Carlo simulated data from imaginary axis to real axis. Solution method: Three well-established analytic continuation methods, including the maximum entropy method, the stochastic analytic continuation (both A. W. Sandvik's and K. S. D. Beach's algorithms), and the stochastic optimization method, have been implemented in the ACFlow toolkit. Additional comments including restrictions and unusual features: The ACFlow toolkit is written in pure Julia language. It is highly optimized and parallelized. It can be executed interactively in a Jupyter notebook environment. [ABSTRACT FROM AUTHOR]

We develop the interface tool wan2respack, which connects RESPACK (software that derives the low-energy effective Hamiltonians of solids) with Wannier90 (software that constructs Wannier functions). wan2respack converts the Wannier functions obtained by Wannier90 into those used in RESPACK, which is then used to derive the low-energy effective Hamiltonians of solids. In this paper, we explain the basic usage of wan2respack and show its application to standard compounds of correlated materials, namely, the correlated metal SrVO 3 and the high- T c superconductor La 2 CuO 4. Furthermore, we compare the low-energy effective Hamiltonians of these compounds using Wannier functions obtained by Wannier90 and those obtained by RESPACK. We confirm that both types of Wannier functions give the same Hamiltonians. This benchmark comparison demonstrates that wan2respack correctly converts Wannier functions in the Wannier90 format into those in the RESPACK format. Program title: wan2respack CPC Library link to program files: https://doi.org/10.17632/6zfj2dkv5b.1 Licensing provisions: GNU General Public License version 3 Programming language: Fortran and python3 External routines/libraries: Quantum ESPRESSO (version 6.6), Wannier90 (version 3.0.0), RESPACK (version 20200113), tomli. Nature of problem: Using RESPACK, one can derive low-energy effective Hamiltonians of solids from maximally localized Wannier functions. However, due to the differences in the representation of Wannier functions, the Wannier functions obtained by Wannier90 cannot be directly used in RESPACK. Solution method: wan2respack converts the Wannier functions in the Wannier90 format into those in the RESPACK format. Using the converted Wannier functions, one can derive the low-energy effective Hamiltonians using RESPACK. [ABSTRACT FROM AUTHOR]

A common feature of computational modelling and simulation research is the need to perform many tasks in complex sequences to achieve a usable result. This will typically involve tasks such as preparing input data, pre-processing, running simulations on a local or remote machine, post-processing, and performing coupling communications, validations and/or optimisations. Tasks like these can involve manual steps which are time and effort intensive, especially when it involves the management of large ensemble runs. Additionally, human errors become more likely and numerous as the research work becomes more complex, increasing the risk of damaging the credibility of simulation results. Automation tools can help ensure the credibility of simulation results by reducing the manual time and effort required to perform these research tasks, by making more rigorous procedures tractable, and by reducing the probability of human error due to a reduced number of manual actions. In addition, efficiency gained through automation can help researchers to perform more research within the budget and effort constraints imposed by their projects. This paper presents the main software release of FabSim3, and explains how our automation toolkit can improve and simplify a range of tasks for researchers and application developers. FabSim3 helps to prepare, submit, execute, retrieve, and analyze simulation workflows. By providing a suitable level of abstraction, FabSim3 reduces the complexity of setting up and managing a large-scale simulation scenario, while still providing transparent access to the underlying layers for effective debugging. The tool also facilitates job submission and management (including staging and curation of files and environments) for a range of different supercomputing environments. Although FabSim3 itself is application-agnostic, it supports a provably extensible plugin system where users automate simulation and analysis workflows for their own application domains. To highlight this, we briefly describe a selection of these plugins and we demonstrate the efficiency of the toolkit in handling large ensemble workflows. Program Title: FabSim3 CPC Library link to program files: https://doi.org/10.17632/6nfrwy7ptj.1 Licensing provisions: BSD 3-clause Programming language: Python 3 Nature of problem: Many aspects are crucial for obtaining reproducible and robust simulation results. For instance, we need to curate all the inputs and outputs for later scrutiny, scrutinize the model behaviour under slightly perturbed circumstances, quantify the propagation of key uncertainties from input data and known parameters and analyze the sensitivity for any parameters for which the exact specification eludes us. Solution method: FabSim3 uses a range of methods to provide automation. These primarily include: (i) SSH + Fabric2 to enable remote execution of SSH commands, (ii) an internal parameter state space using primarily Python dict objects that can be customized with machine- plugin- and user-specific modifications, (iii) Python templating to quickly enable the insertion of state space variables into supercomputing scripts, (iv) multiprocessing and/or QCG-PilotJob to enable efficient submission and execution of job arrays and (v) a system of flexibly installable and modifiable Python3 plugins which allows users to create and customize application-specific functionalities without modifying the core code base. In addition to the written code, FabSim3 also relies on a set of user conventions to maintain a separation of concerns (particularly between machine-, user- and application-specific settings). Additional comments including restrictions and unusual features: This paper serves as the definitive reference for FabSim3. [ABSTRACT FROM AUTHOR]

This paper introduces JAX-FEM, an open-source differentiable finite element method (FEM) library. Constructed on top of Google JAX, a rising machine learning library focusing on high-performance numerical computing, JAX-FEM is implemented with pure Python while scalable to efficiently solve problems with moderate to large sizes. For example, in a 3D tensile loading problem with 7.7 million degrees of freedom, JAX-FEM with GPU achieves around 10× acceleration compared to a commercial FEM code depending on platform. Beyond efficiently solving forward problems, JAX-FEM employs the automatic differentiation technique so that inverse problems are solved in a fully automatic manner without the need to manually derive sensitivities. Examples of 3D topology optimization of nonlinear materials are shown to achieve optimal compliance. Finally, JAX-FEM is an integrated platform for machine learning-aided computational mechanics. We show an example of data-driven multi-scale computations of a composite material where JAX-FEM provides an all-in-one solution from microscopic data generation and model training to macroscopic FE computations. The source code of the library and these examples are shared with the community to facilitate computational mechanics research. Program Title: JAX-FEM CPC Library link to program files: https://doi.org/10.17632/hgwshjbcw6.1 Developer's repository link: https://github.com/tianjuxue/jax-am/tree/main/jax%5fam/fem Licensing provisions: GPLv3 Programming language: Python Nature of problem: Implementation of the finite element method (FEM) with several appealing features that classic FEM software typically does not have: realized with pure Python; running on CPU/GPU; differentiable for solving PDE-constrained optimization problems; seamless integration with machine learning. Solution method: Our framework JAX-FEM is based on Google JAX, a high-performance numerical computing library with automatic differentiation features and supporting both CPU/GPU. Unlike classic FEM software written in Fortran or C/C++, JAX-FEM is implemented with pure Python and can easily be installed as a Python package. We demonstrate our software by solving problems including forward PDE prediction, inverse design/optimization, and data-driven analysis. [ABSTRACT FROM AUTHOR]

Quantum optimal control includes a family of pulse-shaping algorithms that aim to unlock the full potential of a variety of quantum technologies. The Quantum Optimal Control Suite (QuOCS) unites experimental focus and model-based approaches in a unified framework. Easy usage and installation presented here and the availability of various combinable optimization strategies is designed to improve the performance of many quantum technology platforms, such as color defects in diamond, superconducting qubits, atom- or ion-based quantum computers. It can also be applied to the study of more general phenomena in physics. In this paper, we describe the software and the toolbox of gradient-free and gradient-based algorithms. We then show how the user can connect it to their experiment. In addition, we provide illustrative examples where our optimization suite solves typical quantum optimal control problems, in both open- and closed-loop settings. Integration into existing experimental control software is already provided for the experiment control software Qudi (Binder et al., 2017 [41]), and further extensions are investigated and highly encouraged. QuOCS is available from GitHub , under Apache License 2.0, and can be found on the PyPI repository. Program Title: QuOCS - Quantum Optimal Control Suite CPC Library link to program files: https://doi.org/10.17632/wjjch757fk.1 Developer's repository link: https://github.com/Quantum-OCS/QuOCS Licensing provisions: Apache-2.0 Programming language: Python External routines: NumPy [1], SciPy [1], JAX [2] Nature of problem: Quantum systems are typically controlled by time-dependent electromagnetic fields to perform a certain set of quantum operations. Those operations may in turn provide building blocks for various quantum information processing tasks such as quantum computation, communication, simulation, sensing, and metrology. Numerous control strategies exist to design and improve such operations [3]. While some strategies are constructed to target a rather specific problem with high efficiency, others are more general to solve a wide range of applications [4,5]. To access the different algorithms, one has to download different optimization suites with different input and output parameters, making them hard to compare and combine. To benefit from the variety of algorithms, we have devised a customizable and intuitive optimization suite that simultaneously provides access to some of the most popular quantum optimal control algorithms. Solution method: We combine, in a unified framework, some of the frequently used optimal control algorithms which are the dressed Chopped Random Basis method (dCRAB) [6], and Gradient Ascent Pulse Engineering (GRAPE) [7], with an extension to make use of Automatic Differentiation (AD) [8]. The software is able to connect to both models of quantum dynamics in simulations and real-time quantum experiments to perform open- and closed-loop optimization, respectively. With minimal knowledge of optimal control theory, the user can manage to run optimizations of quantum processes using a variety of additional features such as stopping criteria and drift compensation. Logging and data management of the optimization progress and results are also handled by the suite. Its modular structure allows for extensions that accommodate customized algorithms and can be implemented by the user straightforwardly. Additional comments including unusual features: The connection to the experiments is performed by an extension that enables a direct integration to a laboratory control software Qudi [9]. [1] T.E. Oliphant, Comput. Sci. Eng. 9 (2007) 10, http://www.scipy.org/. [2] J. Bradbury, et al., JAX: composable transformations of Python+NumPy programs, http://github.com/google/jax , 2018. [3] S. Glaser, U. Boscain, T. Calarco, et al., Eur. Phys. J. D 69 (2015) 279. [4] C.P. Koch, U. Boscain, T. Calarco, et al., EPJ Quantum Technol. 9 (2022) 19. [5] Schaefer, Ido, Ronnie Kosloff, Phys. Rev. A 101 (2) (2020). [6] N. Rach, M.M. Müller, T. Calarco, S. Montangero, Phys. Rev. A 92 (2015) 6. [7] N. Khaneja, et al., J. Magn. Reson. 92 (6) (2015) 296–305. [8] N. Leung, et al., Phys. Rev. A 95 (2017) 4. [9] J.M. Binder, et al., SoftwareX 6 (2017) 85–90. [ABSTRACT FROM AUTHOR]

This paper delivers a software - libEMM - for 3D controlled-source electromagnetics (CSEM) modelling in fictitious wave domain, based on the newly developed high-order finite-difference time-domain (FDTD) method on non-uniform grid. The numerical simulation can be carried out over a number of parallel processors using MPI-based high performance computing architecture. The FDTD kernel coded in C has been parallelized with OpenMP for speedup using local shared memory. In addition, the software features a GPU implementation of the same algorithm based on CUDA programming language, which can be cross-validated and compared in terms of efficiency. A perspective of libEMM on the horizon is its application to 3D CSEM inversion in land and marine environment. Program Title: libEMM CPC Library link to program files: https://doi.org/10.17632/p769t7c5bk.1 Developer's repository link: https://github.com/yangpl/libEMM Licensing provisions: GNU General Public License v3.0 Programming language: C, CUDA, Fortran, Shell External dependencies: MPI [1], FFTW [2], CUDA [3] Nature of problem: Controlled-source electromagnetics (CSEM) Solution method: High-order finite-difference time-domain (FDTD) on non-uniform grid by fictious wave domain transformation [1] https://www.mpich.org/ [2] http://fftw.org/ [3] https://developer.nvidia.com/cuda-toolkit [ABSTRACT FROM AUTHOR]

URANOS, a massively parallel GPU-accelerated compressible flow solver for high-fidelity modeling of compressible wall flows, is presented. URANOS is based on modern high-fidelity and high-resolution discretization strategies for time-accurate compressible flow predictions. The solver provides six different convective scheme implementations, a cutting-edge method for viscous terms treatment, and three different frameworks for turbulence modeling (DNS, LES, and innovative WMLES), while utilizing a high-order finite-difference approach, ranging from second to sixth order spatial accuracy. This paper details all of these numerical models and implementation issues. Computationally, URANOS combines multiple three-dimensional MPI parallelization strategies with the open standard, OpenACC, for machine wide, on node, and on GPU parallelism, tailoring the software to match the state-of-the-art HPC computing facilities. Special attention is given to the GPU porting and data management, detailing the solver scaling properties and performance for multi-node/-GPU systems on three distinct architectures. In these experiments the different MPI strategies are compared for both GPU-aware MPI/GPU (Host-based MPI) and results are provided proving, consistently, that the GPU-aware MPI outperforms the GPU (Host-based MPI) approach. Furthermore, the GPU version is compared to the CPU only demonstrating over three times speed-up for a node-to-node comparison, even at large scales, with an efficiency of about 80% while using 1024 GPUs. Finally, the manuscript presents several validation benchmarks, from simple academic comparisons to turbulent channel and boundary layer configurations. URANOS is compared with the best DNS data available in the literature across various Mach numbers, ranging from almost incompressible conditions to hypersonic regimes, illustrating the solver's capability in treating a wide range of complex wall-flows problems using DNS, wall-resolved, and wall-modeled LES approaches. Thus, using OpenACC as a paradigm, URANOS provides a straightforward and efficient platform that can efficiently exploit the most modern GPU-accelerated computing architectures in a totally open-source and non-vendor-specific way. The solver represents a framework where the CFD community can explore the limits of modeling, test new models/methods all across a broad range of Mach and Reynolds numbers flows. The solver is released under a BSD license. Program title: Unsteady Robust All-around Navier-StOkes Solver (URANOS) CPC Library link to program files: https://doi.org/10.17632/pw5hshn9k6.1 Developer's repository link: https://gitlab.com/fralusa/uranos%5fgpu Licensing provisions: BSD License 2.0 Programming language: Fortran 90, OpenACC, MPI Nature of problem: Solving the compressible Navier-Stokes system of equations in a three-dimensional Cartesian framework from low to high Mach and Reynolds numbers conditions. Solution method: Convective terms are treated with several high-order high-resolution shock-capturing schemes (WENO/TENO) in hybrid and non-hybrid versions. The system dynamics is advanced in time with a three-stage, third-order total variation diminishing Runge-Kutta method. Three-dimensional MPI parallelization is implemented in several optimized arrangements and coupling OpenACC directives in a genuinely multi-GPU logic. [ABSTRACT FROM AUTHOR]

FITEVT is a FORTRAN program designed to analyze recorded arrival times of nuclear-decay events affected by dead-time. The primary goal of the program is precise and accurate determination of half-lives. Its method involves imposition of a known sufficiently long extending dead-time to the recorded event sequence, so that the original dead-time effects are completely obliterated and the remaining live-times of the survived events are known exactly. Upon completion of the analysis, the arrival-time spectrum and the live-time spectrum are predicted and compared to those constructed from the survived events. Program title: FITEVT Licensing provisions: MIT CPC Library link to program files: https://doi.org/10.17632/scg6p9jxjk.1 Programming language: FORTRAN (using double precision) Nature of problem: Accurate determination of the ideal event rate from the observed event rate in a nuclear decay can be a challenging task due to the inevitable presence of detection system's dead-time, whose nature and extent are typically unknown. Consequently, the results of nuclear half-life measurements may depend on the method used to correct for event losses due to dead-time. Therefore, there is a need for an exact method of data analysis and the means to apply it in order to ensure reproducibility, accuracy and optimized precision of the results. Solution method: FITEVT performs arrival-time analysis of the recorded events, in which a known, sufficiently large extending dead-time is imposed by means of software, so that in the resulting set of survived events the original dead-time effects are completely replaced by the effects of the imposed dead-time. As a result, the dead-time following each survived event and the remaining live-time preceding each surviving event are known exactly. This allows for application of the maximum-likelihood method of estimation, in which the half-lives as well as the other parameters of the ideal-decay-rate function can be accurately determined. Additional comments including restrictions and unusual features: In its original form the program can handle contributions from a constant event rate (i.e. , a typical background) plus up to 4 different exponentially-decaying event rates. One of these 4 contributions is allowed to be negative, so that the program can be applied to the general case involving a single two-component decay chain. The employed method of analysis produces accurate results even when the product of the ideal event rate (ρ) and the extending dead-time parameter (τ e) is as large as 51.2 [1]. Example used in the present paper involves simulated events having initial rate of 10 5 s − 1 , to which extending dead-time of 64 μs is imposed. Data analysis is based on maximum-likelihood principle, in which minimization of the deviance involves calculations in double precision and determination of its derivatives is based on analytical expressions. This is done in order to optimize precision and accuracy of the results as well as the program execution time. With the provided input data and a typical contemporary laptop computer, the program execution typically lasts about 5 minutes. Reducing the imposed dead-time to zero increases the number of survived events approximately by a factor of 6, but the program execution time increases by about a factor of 3. [1] V. Horvat, J.C. Hardy, Nucl. Instrum. Methods Phys. Res., Sect. A 713 (2013) 19. [ABSTRACT FROM AUTHOR]

With the arrival of high luminosity B-factories like the Belle II experiment, τ decay measurements have become more precise than ever, allowing rarer processes to be explored, and finer details of τ decays to be studied. These are important to understand the spectrum of intermediate particles produced in τ decays. Therefore Monte Carlo generators, like the TAUOLA program, have to facilitate precision analysis as well as confront new models that constantly emerge with the availability of high statistics experimental data. New decay channels and models may lead to large variation of matrix elements size within the available phase space, as in the case when e + e − pairs are present in final state. It requires appropriate presampler of the phase space generator and a proper documentation to help users introduce their own models. While releasing a new update, it is important for the TAUOLA Monte Carlo library to maintain the general structure of the previous versions to preserve backward compatibility. The aim is to minimize changes from the user perspective. This paper presents a demonstration of new models implementation facilitated by the current update. Program Title: tauola-bbb CPC Library link to program files: https://doi.org/10.17632/3hyw3f7v32.1 Licensing provisions: GPLv2 Programming language: FORTRAN/C++ Journal reference of previous version: Comput. Phys. Comm. , 232:220–236, 2018 Does the new version supersede the previous version?: No Reasons for the new version: Meeting the needs of present day experiments. Summary of revisions: Phase space presamplers enriched with the possibility to generate narrow peaks of e + e − pairs, if present in matrix elements of 4- and 5-body decay channels and due to electromagnetic or New Physics interactions. The examples of physical models are implemented for: τ − → π − e − e + ν τ , τ − → ν ¯ μ μ − e − e + ν τ and τ − → ν ¯ e e − e − e + ν τ channels, which are used for the collected new algorithm validations. Nature of problem: Present day experiments, in particular Belle II, have the capability to measure extremely rare, not yet measured τ decays, as well as precise measurements of known decay channels. They require a Monte Carlo generator capable of generating all desired decays. They also need the possibility to modify and test new models for such decays. At the same time the default initialization of the event generator should contain decent modeling of known τ decays. Solution method: The new version supplements previous publications on TAUOLA. Phase-space presamplers and new decay channels with additional light lepton pairs are introduced. Additional comments including restrictions and unusual features: TAR BALL of the future versions of the program may become available through: http://wasm.web.cern.ch/wasm/Welcome.html ; its sub-pages http://tauolapp.web.cern.ch/tauolapp/ or http://wasm.web.cern.ch/wasm/f77.html [ABSTRACT FROM AUTHOR]

The LisbOn KInetics Monte Carlo (LoKI-MC) is an open-source simulation tool that solves the electron kinetics for low-temperature plasmas excited by uniform DC electric fields from different gas mixtures, using Monte Carlo techniques. Following the strategy and data organization of the LisbOn KInetics Boltzmann (LoKI-B) solver, the program easily addresses any complex mixture of atomic/molecular species, describing electron collisions with any target state (electronic, vibrational and rotational), characterized by any user-prescribed population. LoKI-MC is written in C++, benefiting from a highly-efficient object-oriented structure. On input, the code requires the working conditions, the gas-mixture composition, the distributions of populations for the levels of the atomic/molecular gases considered, and the relevant sets of electron-scattering cross sections obtained from the open-access website LXCat. On output, it yields the electron energy and velocity distribution functions, the electron swarm parameters, the collision rate-coefficients, and the electron power absorbed from the electric field and transferred to the different collisional channels. This paper presents LoKI-MC and gives examples of results obtained for different model and real gases, verifying and benchmarking the simulation tool against analytical solutions and other available codes, and assesses its computational performance. Moreover, the effects of the gas temperature, anisotropic ionization scattering (induced by momentum conservation) and superelastic collisions are analyzed in real gases. Program title: LoKI-MC CPC Library link to program files: https://doi.org/10.17632/n7t6ctp2st.1 Developer's repository link: https://github.com/IST-Lisbon/LoKI-MC Licensing provisions: GPLv3 Programming language: C++17 Nature of problem: Simulation of the electron kinetics in non-equilibrium low-temperature plasmas, excited from arbitrarily complex gas-mixtures, under static and uniform electric fields. Solution method: Monte Carlo sampling techniques. [ABSTRACT FROM AUTHOR]

In this work, we introduce an open-source Julia project, express, an extensible, lightweight, high-throughput, high-level workflow framework that aims to automate ab initio calculations for the materials science community. express is shipped with well-tested workflow templates, including structure optimization, equation of state (EOS) fitting, phonon spectrum (lattice dynamics) calculation, and thermodynamic property calculation in the framework of the quasi-harmonic approximation (QHA). It is designed to be highly modularized so that its components can be reused across various occasions, and customized workflows can be built on top of that. Users can also track the status of workflows in real-time, and rerun failed jobs thanks to the data lineage feature express provides. Two working examples, i.e., all workflows applied to lime and akimotoite, are also presented in the code and this paper. Program Title: express CPC Library link to program files: https://doi.org/10.17632/bbzzrxsm4b.1 Developer's repository link: https://github.com/MineralsCloud/Express.jl Licensing provisions: GNU General Public License v3.0 Programming language: Julia Nature of problem: High-performance ab initio calculation is gaining more and more popularity when investigating the physical and chemical properties of materials in the scientific community. There are several ab initio programs in the market, but they are often not user-friendly to new users because of their intrinsic complexity. Even for familiar users, dealing with daily preparation and post-analysis could be trivial and fallible. Therefore, plenty of workflow frameworks have been developed to solve this problem. However, most of them cannot meet our expectations for several reasons. They are either too complex to read and modify, or too heavy for simple tasks. Plus, they put little focus on addressing the real pain points of everyday calculations, such as data preparation and output parsing. Solution method: We developed a workflow framework that can simplify this process, i.e., most of the mundane work can be replaced by writing a few lines of configurations. We also automated the three most-used work procedures into configurable workflows: equations of state fitting (structural optimization), phonon spectrum calculation, and thermodynamics calculation. [ABSTRACT FROM AUTHOR]

In this paper we present a new release of the FIESTA program (Feynman Integral Evaluation by a Sector decomposiTion Approach). FIESTA5 is performance-oriented — we implemented improvements of various kinds in order to make Feynman integral evaluation faster. We plugged in two new integrators, the Quasi Monte Carlo and Tensor Train. At the same time the old code of FIESTA4 was upgraded to the C++17 standard and mostly rewritten without self-made structures such as hash tables. There are also several essential improvements which are most relevant for complex integrations — the new release is capable of producing results where previously impossible. Program title: FIESTA5 CPC Library link to program files: https://doi.org/10.17632/kyzw4zkwsd.2 Developer's repository link: https://bitbucket.org/feynmanIntegrals/fiesta Licensing provisions: GPLv3 Programming language: Wolfram Mathematica 8.0 or higher, C++ Supplementary material: The article, usage instructions in the program package, https://bitbucket.org/feynmanIntegrals/fiesta Journal Reference of previous version: A.V. Smirnov, FIESTA4: Optimized Feynman integral calculations with GPU support, Comput. Phys. Commun. 204 (2016) 189–199, https://doi.org/10.1016/j.cpc.2016.03.013 Does the new version supersede the previous version?: Yes Reasons for the new version: The code was not able to produce results in some cases where the competitive code, pySecDec could; moreover we were not happy with the performance of the algorithm having multiple inefficient parts of the code. Summary of revisions: New integrators, improved sector decomposition strategies, improvement of contour transformation algorithm, code optimization especially in physical regions (might be 100 times faster or more), possibility to work in some situations where previously impossible, update of the code to modern standard. Nature of problem: Sector decomposition is a well-known approach to the numerical evaluation of Feynman integrals. Feynman integrals in 4 space-time dimension are divergent and have to be regulated. Sector decomposition is used to resolve pole singularities and consists of different stages — sector decomposition itself, contour transformation (in case of physical kinematics meaning base functions changing sign therefore leading to integration in complex numbers), pole resolution, epsilon expansion and numerical integration. Solution method: Most stages are performed in Wolfram Mathematica [1] (required version is 8.0 or higher), this part is parallelized by the use of Mathematica subkelnels in shared memory. As a result a database on hard disk is produced with the use of the KyotoCabinet [2] database engine. The integration stage is written in C++ and can be run on personal computers as well as on supercomputers via MPI. It can make use of installed graphical processor units. As default integrator we use Vegas from the Cuba library [3], but also it can be switched to QMC [4] or Tensor Train [5]. The mimalloc memory allocator [6] can be used for improved performance. Additional comments including restrictions and unusual features: The complexity of the problem is mostly restricted by CPU time required to perform the integration and to obtain the desired precision. [1] http://www.wolfram.com/mathematica/ , commercial algebraic software. [2] http://fallabs.com/kyotocabinet/ , open source. [3] http://www.feynarts.de/cuba/ , open source. [4] https://github.com/mppmu/qmc/ , open source. [5] https://bitbucket.org/vysotskylev/c-tt-library , open source. [6] https://github.com/microsoft/mimalloc.git , open source. [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]