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]

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]