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]

Computational fluid dynamics (CFD), in particular applied to turbulent flows, is a research area with great engineering and fundamental physical interest. However, already at moderately high Reynolds numbers the computational cost becomes prohibitive as the range of active spatial and temporal scales is quickly widening. Specifically scale-resolving simulations, including large-eddy simulation (LES) and direct numerical simulations (DNS), thus need to rely on modern efficient numerical methods and corresponding software implementations. Recent trends and advancements, including more diverse and heterogeneous hardware in High-Performance Computing (HPC), are challenging software developers in their pursuit for good performance and numerical stability. The well-known maxim "software outlives hardware" may no longer necessarily hold true, and developers are today forced to re-factor their codebases to leverage these powerful new systems. In this paper, we present Neko, a new portable framework for high-order spectral element discretization, targeting turbulent flows in moderately complex geometries. Neko is fully available as open software. Unlike prior works, Neko adopts a modern object-oriented approach in Fortran 2008, allowing multi-tier abstractions of the solver stack and facilitating hardware backends ranging from general-purpose processors (CPUs) down to exotic vector processors and FPGAs. We show that Neko's performance and accuracy are comparable to NekRS, and thus on-par with Nek5000's successor on modern CPU machines. Furthermore, we develop a performance model, which we use to discuss challenges and opportunities for high-order solvers on emerging hardware. • We introduce Neko, a modernized framework for high-fidelity CFD simulations. • We reveal Neko's inner implementation details and design decisions. • We develop a performance model, which we validate and use to project performance. [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]