Search

This work focuses on the study of ink seepage and spreading into paper to ease the deciphering of digitized ancient documents and therefore make them legible and researchable. A three-dimensional model is proposed for the simulation of ink seepage into paper at the fiber level. The model takes into account a finite volume of ink and describes the system state through gravity, cohesion and adhesion force interactions. At the mesoscopic scale, the writing paper is modeled using a discretized fiber structure generated using a numerical deposition procedure. A modified Monte Carlo method is introduced for the simulation of the ink dynamics. Finally a multiphase lattice Boltzmann method is suggested to fine-tune the mesoscopic variational model parameters and it is shown that the ink seepage behaviors predicted by the proposed model can resemble those predicted by a method relying on first principles. [ABSTRACT FROM AUTHOR]

Abstract: In this paper we present a new effective algorithm for the Schrödinger equation. This new method differs from the original Numerov method only in one simple coefficient, by which we can extend the interval of periodicity from 6 to infinity and obtain an embedded correct factor to improve the accuracy. We compare the new method with the original Numerov method by the well-known problem of Woods–Saxon potential. The numerical results show that the new method has great advantage in accuracy over the original. Particularly for the resonant state, the accuracy is improved with four orders overall, and even six to seven orders for the highest oscillatory solution. Surely, this method will replace the original Numerov method and be widely used in various area. [Copyright &y& Elsevier]

Paper-based electromigrative separations have recently gained relevance due to the rise of paper-based microfluidic devices and their combination with electrophoretic methods, used for many different analytical applications [1]. A new version of the open source toolbox electroMicroTransport for the numerical solution of electromigrative separations is presented, now featuring support for porous substrates, like paper, nitrocellulose and other materials used in paper-based microfluidics. This new version is based on a novel mathematical model for these phenomena recently published by our group. Similar to its previous versions, the toolbox was implemented using OpenFOAM®, meaning that it features native 3D problem handling, support for parallel computation, and a GNU GPL license. This new version of electroMicroTransport includes full support for electroosmotic flow and the novels mechanical and electrical dispersion effects. It is now integrated with a well-recognized electrolyte database with its own management utility, and also includes a renewed algorithm for computing and controlling the electric current drainage in arbitrary surfaces. Moreover, for the first time electroMicroTransport is available for installation as a Docker image, which means that it is able to correctly run on any operating system. Finally, new tutorial examples and a user manual are provided. This new version of electroMicroTransport will enable efficient and reliable numerical prototypes of paper-based electromigrative separations to boost the continuous growth of paper-based microfluidics. Program Title: electroMicroTransport CPC Library link to program files:: https://doi.org/10.17632/9wpvypzj9y.2 Developer's repository link: https://gitlab.com/santiagomarquezd/electromicrotransport Licensing provisions: GPLv3 Programming language: C++, Python Journal reference of previous version: Computer Physics Communications 237 (2019) 244-252 Does the new version supersede the previous version?: Yes Reasons for the new version: This new version adds several new features, including support for porous substrates, new boundary conditions, a comprehensive electrolyte database, new tutorial cases, a streamlined installation process, and a Docker installation option. Summary of revisions: • Electrolyte database – electroMicroTransport now includes an electrolyte database based on the one bundled with Simul 6, itself built from the work of Prof. Hirokawa. [2,3] – The dabatabase includes the properties of 518 components by default. – Simulation cases can directly name database components for easy initialization of electrolyte properties. – A new electrolytes command-line utility provides access the default electrolyte database to search and query for component properties—as well as to add, update and remove user-defined components. • New algorithm for electric constant current – The new boundary condition called uniformCurrentDensity replaces the earlier uniform1DCurrentDensity boundary condition [4] which was valid only for 1D domains. With this new condition, it is possible to prescribe a value for constant electric current drained from an arbitrary 3D shaped electrode. – Drained current I is calculated as the sum of all of the individual currents flowing through every cell adjacent to the electrode surface. – When using a uniformCurrentDensity boundary condition, on each iteration, electroMicroTransport will provide the user with information on the applied electric current and current density values, the target current, and the effective applied electric potential at the electrode. • Support for paper substrates – This new version of electroMicroTransport offers full support for paper-based electrophoretic devices with modified transport equations based on a recent model [5]. – Users can provide different substrate properties such as porosity, tortuosity, Darcy permeability, bias conductivity, and electrokinetic potential. – Mechanical and electrophoretically driven dispersion terms require setting values for the coefficients s f and s e. – When the user cannot provide reliable values for these parameters, default values are used which match the physical characteristics of Whatman #1 paper. – A new body force term in the momentum equation for fluid flow was introduced in order to obtain a proper representation of EOF in porous substrates [6]. • New tutorial cases showcasing the new functionality – Paper-based zone electrophoresis experiments: paperBasedZE, paperBasedZE1, paperBasedZE2 – Paper-based moving-boundary electrophoresis cases: paperBasedMBE1 (constant voltage), paperBasedMBE2 (constant current) – Paper-based free-flow isoelectric focusing case: paperBasedFFIEF • Automated test suite – The electroMicroTransport project now includes an automated test suite used by developers to validate the implementations. Test cases are written using the pytest framework. – Following best practices, the test suite is run automatically as part of the continuous integration/deployment (CI/CD) process. • User manual – A user manual of electroMicroTransport is now available, which guides users through the installation and use of the software. – The manual also covers many details of the software that might be of interest to users. • Streamlined installation process – This new version of electroMicroTransport drops the requirement of a user-writable OpenFOAM installation. This means that electroMicroTransport can now be set up to use a system-wide installation of OpenFOAM without any privileges. – To allow this, code that previously required modifications to base OpenFOAM has now been packaged into a standalone shared library. – This change will benefit users who get OpenFOAM from their system's package manager, as well as any users of shared computers where they might not be able to modify existing packages (e.g. computer clusters). – This improvement in the architecture of the program implies a significant reduction in compilation time and resources. • Docker installation option – electroMicroTransport is now also available as a Docker image for use with the Docker software [7]. This image is based on an official Docker image of OpenFOAM and contains pre-built installation of electroMicroTransport. It does not require an existing OpenFOAM installation. – Official images of the toolbox can be obtained from the microfluidica/electromicrotransport repository on Docker Hub. – All Docker images are built and tested automatically during the CI/CD process. This ensures that Docker users always have access to an up-to-date, validated version of the toolbox. – Docker allows electroMicroTransport to be used on non-Linux systems that do not natively support OpenFOAM. Nature of problem: The electroMicroTransport toolbox is intended to offer a complete suite for performing numerical simulations of electromigrative transport, including electroosmotic flow in both open channels and porous substrates. In order to perform these simulations, three partial differential equations and two non-linear conservation equations are solved. The coupled solution of this set of equations provides the different concentration fields for all electrolyte components of the system, the pH and conductivity fields, the fluid flow velocity and pressure fields (associated to the solvent, usually water), and the electric potential field over the entire calculation domain at any simulation time. Numerical simulations provided by electroMicroTransport can improve design process of microfluidic electrophoretic devices and its operational parameters as well as to contribute in basic research on developing new separation strategies for emerging analytical applications. Solution method: As was previously mentioned, electroMicroTransport numerical solutions are based on the coupled solving of three partial differential equations and two non-linear conservation equations. The solution method for the partial (in both space and time) differential equations is the Finite Volume Method whose basic methods and functions are provided by the OpenFOAM® platform. The non-linear equations are solved by using ad hoc implemented Newton–Raphson methods in native C++ language. The different equations are solved sequentially employing weak coupling and temporal sub-looping strategies. These strategies are justified by the fact that the various phenomena (chemical, electrochemical, mechanical and electrical) have different characteristic times for their evolutions. This scheme has been validated and has demonstrated both robustness and computational efficiency. Additional comments including restrictions and unusual features: Except when using the Docker image, installing and running electroMicroTransport requires an active installation of OpenFOAM. Only official OpenFOAM® releases distributed by OpenCFD Ltd. are supported by electroMicroTransport. This version of electroMicroTransport has been tested with OpenFOAM versions 1912, 2006 and 2012. [1] G. I. Salentijn, M. Grajewski, E. Verpoorte, Anal. Chem. 90 (23) (2018) 13815–13825. [2] T. Hirokawa, M. Nishino, N. Aoki, Y. Kiso, Y. Sawamoto, T. Yagi, J.-I. Akiyama, J. Chromatogr. A 271 (2) (1983) D1–D106. [3] B. Gaš, P. Bravenec, Electrophoresis (2021). [4] S. Márquez Damián, F. Schaumburg, P.A. Kler, Comput. Phys. Commun. 237 (2019) 244–252. [5] F. Schaumburg, P.A. Kler, C.L.A. Berli, Electrophoresis 41 (7–8) (2020) 598–606. [6] N. Franck, F. Schaumburg, R. Urteaga, P.A. Kler, Electrophoresis 42 (7–8) (2021) 975–982. [7] G.S. Gerlero, S.M. Damián, F. Schaumburg, N. Franck, P.A. Kler, Electrophoresis 42 (16) (2021) 1543–1551. [ABSTRACT FROM AUTHOR]

This paper introduces DEM-Engine, a new submodule of Project Chrono, that is designed to carry out Discrete Element Method (DEM) simulations. Based on spherical primitive shapes, DEM-Engine can simulate polydisperse granular materials and handle complex shapes generated as assemblies of primitives, referred to as clumps. DEM-Engine has a multi-tier parallelized structure that is optimized to operate simultaneously on two GPUs. The code uses custom-defined data types to reduce memory footprint and increase bandwidth. A novel "delayed contact detection" algorithm allows the decoupling of the contact detection and force computation, thus splitting the workload into two asynchronous GPU streams. DEM-Engine uses just-in-time compilation to support user-defined contact force models. This paper discusses its C++ and Python interfaces and presents a variety of numerical tests, in which impact forces, complex-shaped particle flows, and a custom force model are validated considering well-known benchmark cases. Additionally, the full potential of the simulator is demonstrated for the investigation of extraterrestrial rover mobility on granular terrain. The chosen case study demonstrates that large-scale co-simulations (comprising 11 million elements) spanning 15 seconds, in conjunction with an external multi-body dynamics system, can be efficiently executed within a day. Lastly, a performance test suggests that DEM-Engine displays linear scaling up to 150 million elements on two NVIDIA A100 GPUs. [ABSTRACT FROM AUTHOR]

The rise of exascale supercomputers has fueled competition among GPU vendors, driving lattice QCD developers to write code that supports multiple APIs. Moreover, new developments in algorithms and physics research require frequent updates to existing software. These challenges have to be balanced against constantly changing personnel. At the same time, there is a wide range of applications for HISQ fermions in QCD studies. This situation encourages the development of software featuring a HISQ action that is flexible, high-performing, open source, easy to use, and easy to adapt. In this technical paper, we explain the design strategy, provide implementation details, list available algorithms and modules, and show key performance indicators for SIMULATeQCD, a simple multi-GPU lattice code for large-scale QCD calculations, mainly developed and used by the HotQCD collaboration. The code is publicly available on GitHub. Program Title: SIMULATeQCD CPC Library link to program files: https://doi.org/10.17632/ytgycy9nc3.1 Developer's repository link: https://github.com/LatticeQCD/SIMULATeQCD Licensing provisions: MIT Programming language: C++, CUDA, HIP Nature of problem: Quantum chromodynamics (QCD) is the fundamental theory behind the strong force, one of the four fundamental forces in nature. It describes interactions, mediated by gluons, between quarks, the elementary particles that build up protons, neutrons and other hadrons. One of its unique features is asymptotic freedom: with increasing energy, the interaction strength or coupling between quarks and gluons weakens, which enables studying QCD with peturbation theory. At lower energy scales, however, the strong coupling between quarks and gluons causes perturbation theory to break down, and other tools, such as lattice QCD, need to be employed to obtain QCD predictions. Solution method: Lattice QCD is a technique to solve QCD non-perturbatively by discretizing space and time onto a four-dimensional grid. The QCD path integral is thereby rendered finite dimensional and can be evaluated numerically via Monte Carlo methods. In this paper, we present SIMULATeQCD, a C++ code to perform lattice QCD calculations on multiple GPUs, supporting multiple APIs. SIMULATeQCD implements various Monte Carlo sampling methods ranging from sampling of purely gluonic configurations to fully dynamical quark simulations with the Highly Improved Staggered Quark (HISQ) discretization. Modules for measuring various physical observables on these samples are also available. [ABSTRACT FROM AUTHOR]

In this paper, we propose a new adaptive cut-off function and develop a fifth-order targeted ENO scheme that achieves optimal accuracy at any order of critical points, which performs excellently in conventional compressible gas dynamics. The cut-off value C T is crucial for controlling the dissipation in TENO schemes. Adjusting C T can improve shock capture and increase dissipation for small-scale features. To address this issue, Fu et al. [27] and Peng et al. [28] developed the TENO-A and TENO-LAD schemes, respectively, with adaptive cut-off values C T. However, these adaptive cutoffs C T are computationally expensive due to additional free parameters and complexity. Furthermore, all TENO schemes, including the adaptive versions, can suffer from loss of accuracy at higher-order critical points. In this paper, a new adaptive cut-off function is proposed that uses a global smoothness indicator correction so that it can be automatically tuned between 0 and a given positive constant λ d , ensuring that the new TENO scheme achieves optimal accuracy in smooth regions and good shock-capturing in the less smooth parts. A series of benchmark simulations demonstrate that the presented scheme provides optimal accuracy, better robustness, resolution, and numerical stability, and higher resolution than existing TENO schemes while improving computational efficiency. Due to the simplicity of the new cut-off structure, it can be easily extended to improve other TENO schemes. Program files associated to this article may be found at https://github.com/fourhairs/cfd. [ABSTRACT FROM AUTHOR]

The polarimeter vector of the τ represents an optimal observable for the measurement of the τ spin. In this paper we present an algorithm for the computation of the τ polarimeter vector for the decay channels τ − → π − π + π − ν τ and τ − → π − π 0 π 0 ν τ. The algorithm is based on a model for the hadronic current in these decay channels, which was fitted to data recorded by the CLEO experiment [1]. Program Title: PolarimetricVectorTau2a1, version 1.0.1 CPC Library link to program files: https://doi.org/10.17632/z986tk5pyv.1 Developer's repository link: https://github.com/TTauSpin/PolarimetricVectorTau2a1 Licensing provisions: MIT Programming language: C++ 11 Nature of problem: The polarimeter vector h of the τ can be used to measure the τ spin orientation. The vector h is a function of the momenta of the particles produced in the τ decay and needs to be computed in the restframe of the τ lepton. While for the decay channels τ − → π − ν τ and τ − → π − π 0 ν τ expressions for h exist in the literature, no corresponding expressions exist for the channels τ − → π − π + π − ν τ and τ − → π − π 0 π 0 ν τ. Solution method: In this paper, we present an algorithm for the computation of the τ polarimeter vector h for the decay channels τ − → π − π + π − ν τ and τ − → π − π 0 π 0 ν τ. The algorithm is based on a model for the dynamics of hadronic interactions in these decay channels. The parameters of the model have been determined by a fit to data recorded by the CLEO experiment. [ABSTRACT FROM AUTHOR]

Correlation functions are becoming one of the major tools for quantification of structural information that is usually represented as 2D or 3D images. In this paper we introduce ▪ open-source package developed in Julia and capable of computing all classical correlation functions based on imaging input data. Images include both binary and multi-phase representations. Our code is capable of evaluating two-point probability S 2 , phase cross-correlation ρ i j , cluster C 2 , lineal-path L 2 , surface-surface F s s , surface-void F s v , pore-size P and chord-length p distribution functions on both CPU and GPU architectures. Where possible, we presented two types of computations: full correlation map (correlations of each point with other points on the image, that also allows obtaining ensemble averaged CF) and directional correlation functions (currently in major orthogonal and diagonal directions). Such an implementation allowed for the first time to assemble a completely free solution to evaluate correlation functions under any operating system with well documented application programming interface (API). Our package includes automatic tests against analytical solutions that are described in the paper. We measured execution times for all CPU and GPU implementations and as a rule of thumb full correlation maps on GPU are faster than other methods. However, full maps require more RAM and, thus, are limited to available RAM resources. On the other hand, directional CFs are memory efficient and can be evaluated for huge datasets – this way they are the first candidates for structural data compression of feature extraction. The package itself is available through Julia package ecosystem and on GitHub, the latter source also contains documentation and additional helpful resources such as tutorials. We believe that a single powerful computational tool such as ▪ presented in this paper will significantly facilitate the usage of correlation functions in numerous areas of structural description and research of porous materials, as well as in machine learning applications. We also present some examples as applied to ceramic, soil composite and oil-bearing rock samples based on their 3D X-ray tomography and 2D scanning electron microscope images. Finally, we conclude our paper with discussion of possible ways to further improve presented computational framework. Program Title: CorrelationFunctions.jl CPC Library link to program files: https://doi.org/10.17632/6gb9gfm3dw.1 Developer's repository link: https://github.com/fatimp/CorrelationFunctions.jl Licensing provisions: MIT Programming language: Julia Supplementary material: Numerous Jupiter notebooks with examples are available on the GitHub page Nature of problem: Correlation functions are invaluable universal statistical descriptors of structures used in numerous scientific fields such as astronomy, material science, rock and soil physics, hydrology and biology, to name just a handful of examples. While computational approaches are available in the literature for some functions, they are fragmented and are usually implemented in proprietary interpreted languages for CPU architecture alone. Solution method: We contribute an open source and cross-platform solution with well documented API for computation of all classical correlation functions from both 2D and 3D images on CPU and GPU architectures. The package computes correlation functions using two approaches: computation of correlation maps and computation along predefined directions. These two approaches can be thought of as an execution time - memory trade-off, but the choice may also depend on the application. The computations are based on a) fast Fourier transform with preprocessing steps such as cluster labeling or edge detection, and b) linear scan approach to evaluate correlation functions along predefined directions. Where justified, the algorithms can be executed on both CPU and GPU which results in high execution speed on modern hardware. [ABSTRACT FROM AUTHOR]

• The variational quantum eigensolver based on the bridge-inspired quantum circuits and gradient filter module (BG-VQE) is proposed to calculate the molecular ground state energy. • The bridge-inspired quantum circuits effectively reduces quantum gates and circuit depth overhead while preserving the representational capacity of the original quantum circuits. • The strategy of clustering and reordering the Pauli Hamiltonians to save quantum resources is transferable and versatile. • The gradient filter module is proposed to eliminate ineffective variational parameters to reduce the complexity of classical optimization. The complexity of theoretical simulation for drug molecule synthesis increases exponentially with the growth in system dimensions, posing a challenging task for precise solutions. Currently, the quantum algorithm capable of accurately simulating chemical molecule properties in the era of Noisy Intermediate-Scale Quantum (NISQ) devices is the Variational Quantum Eigensolver (VQE) algorithm. This paper introduces a variational quantum eigensolver based on the bridge-inspired quantum circuits and gradient filter module (BG), using Unitary Coupled Cluster Singles and Doubles (UCCSD) as the foundation (BG-VQE). The primary contributions are as follows: (1) The design of bridge rules among Hamiltonian quantum terms and rules for reordering Hamiltonian quantum terms based on similarity. By constructing a B-UCCSD ansatz according to the bridge rules and the new Hamiltonian pool, the quantum gate count and circuit depth are reduced without compromising the representative capacity of the original UCCSD ansatz; (2) The design of a variational parameter filtering module based on gradient values, which efficiently eliminates ineffective variational parameters based on their gradients. This reduction in the parameter counts of the B-UCCSD ansatz, at the cost of minimal precision loss, accelerates the calculation. Furthermore, we validate the transferability of the strategies proposed in this paper by empowering ADAPT-VQE with the BG strategy. Experimental calculations of ground state energies for H2, H3, H4, and H6 molecules were conducted using BG-VQE. By comparing the results with the UCCSD-VQE, ADAPT-VQE and BG-ADAPT-VQE, the effectiveness and superiority of BG-VQE are demonstrated. Furthermore, by performing BG-VQE calculations with different Trotter decomposition slice numbers, we demonstrate the feasibility of BG-VQE in computing the ground-state energies of HeH+, BeH 2 , and H 2 O molecules. The proposed approach won the championship in the Quantum Biochemical Engineering track of the 2nd CCF Origin Pilot Cup Quantum Computing Challenge in the professional group. [ABSTRACT FROM AUTHOR]

This paper presents the new 2D electrostatic particle-in-cell code FENNECS developed to study the formation of magnetized non-neutral plasmas in geometries with azimuthal symmetry. This code has been developed in the domain of gyrotron electron gun design, but solves general equations and can be applied in other domains of plasma physics. FENNECS is capable of simulating electron-neutral collisions using a Monte Carlo approach and considers both elastic and inelastic (ionization) processes. It is also capable of solving the Poisson equation on domains with arbitrary geometries with either Dirichlet or natural boundary conditions. The Poisson solver is based on a meshless Finite Element Method, called web-splines, based on b-splines of any order, and used for the first time in the domain of plasma physics. In addition, the effect of fast ions colliding with the electrodes and causing ion induced electron emission at the electrode surfaces has been implemented in the code. In this paper, the governing equations solved by FENNECS and the numerical methods used to solve them are presented. A number of verification cases are then reported. Finally, the parallelization scheme used in FENNECS and its parallel scalability are presented. [ABSTRACT FROM AUTHOR]

In this paper, we introduce the RHDLPP, a flux-limited multigroup radiation hydrodynamics numerical code designed for simulating laser-produced plasmas in diverse environments. The code bifurcates into two packages: RHDLPP-LTP for low-temperature plasmas generated by moderate-intensity nanosecond lasers, and RHDLPP-HTP for high-temperature, high-density plasmas formed by high-intensity laser pulses. The core radiation hydrodynamic equations are resolved in the Eulerian frame, employing an operator-split method. This method decomposes the solution into two substeps: first, the explicit resolution of the hyperbolic subsystems integrating radiation and fluid dynamics; second, the implicit treatment of the parabolic part comprising stiff radiation diffusion, heat conduction, and energy exchange. Laser propagation and energy deposition are modeled through a hybrid approach, combining geometrical-optics ray-tracing in sub-critical plasma regions with a one-dimensional solution of the Helmholtz wave equation in super-critical areas. The thermodynamic states are ascertained using an equation of state, based on either the real gas approximation or the quotidian equation of state (QEOS). For ionization calculations, the code employs a steady-state collisional-radiation (CR) model using the screened-hydrogenic approximation. Additionally, RHDLPP includes RHDLPP-SpeIma3D, a three-dimensional spectral simulation post-processing module, for generating both temporally-spatially resolved and time-integrated spectra and imaging, facilitating direct comparisons with experimental data. The paper showcases a series of verification tests to establish the code's accuracy and efficiency, followed by application cases, including simulations of laser-produced aluminium (Al) plasmas, pre-pulse-induced target deformation of tin (Sn) microdroplets relevant to extreme ultraviolet lithography light sources, and varied imaging and spectroscopic simulations. These simulations highlight RHDLPP's effectiveness and applicability in fields such as laser-induced breakdown spectroscopy, extreme ultraviolet lithography sources, and high-energy-density physics. [ABSTRACT FROM AUTHOR]

FlexibleSUSY is a framework for the automated computation of physical quantities (observables) in models beyond the Standard Model (BSM). This paper describes an extension of FlexibleSUSY which allows to define and add new observables that can be enabled and computed in applicable user-defined BSM models. The extension has already been used to include Charged Lepton Flavor Violation (CLFV) observables, but further observables can now be added straightforwardly. The paper is split into two parts. The first part is non-technical and describes from the user's perspective how to enable the calculation of predefined observables, in particular CLFV observables. The second part of the paper explains how to define new observables such that their automatic computation in any applicable BSM model becomes possible. A key ingredient is the new NPointFunctions extension which allows to use tree-level and loop calculations in the model-independent setup of observables. Three examples of increasing complexity are fully worked out. This illustrates the features and provides code snippets that may be used as a starting point for implementation of further observables. Program title: NPointFunctions CPC Library link to program files: https://doi.org/10.17632/kf7m8gn8vp.2 Developer's repository link: https://github.com/FlexibleSUSY/FlexibleSUSY Licensing provisions: GPLv3 Programming language: C++, Wolfram Language, Fortran, Bourne shell Journal reference of previous version:: Comput. Phys. Commun. 230 (2018) 145–217; PoS CompTools2021 (2022) 036 Does the new version supersede the previous version?: Yes Reasons for the new version: Program extension including new observables and file structures Nature of problem: Determining observables for an arbitrary extension of the Standard Model supported by FlexibleSUSY, input by the user. Solution method: Generation of the code from automated algebraic manipulations. Automatic filling and compiling of predefined template files. Additional comments including restrictions and unusual features: Vertices with a direct product of Lorentz and color structures are supported. Settings of the advanced NPointFunctions mode rely on explicit specification of topologies. [ABSTRACT FROM AUTHOR]

• The first paper on a hybrid method combining ISPH with graph neural network (ISPH_GNN) for simulating free-surface flows. • The ISPH_GNN gives satisfactory results compared with experimental data, analytical solution and other ISPH results. • Investigation of the potential of generalization of the ISPH_GNN by applying it to simulating more complex scenarios. • The ISPH_GNN can yield satisfactory results for more complex cases beyond the simple cases of training and testing data. • The ISPH_GNN takes much less computation time than the conventional ISPH for pressure prediction. The incompressible Smoothed Particle Hydrodynamics (ISPH) is a popular Lagrangian Particle method. In the conventional ISPH method for simulating free-surface flows, the pressure-projection phase, which solves the pressure Poisson's equation (PPE), is the most time-consuming. In this paper, we propose a novel hybrid method by combining the graph neural network (GNN) with the ISPH for modelling the free-surface flows. In the new hybrid method, the graph neural network (GNN) is employed to replace solving the PPE for pressure in the conventional ISPH. To the best of knowledge of the authors, this is the first attempt to combine the GNN with ISPH model in a Lagrangian formulation. The performance of the hybrid method will be evaluated by comparing its results with experimental data, analytical solution or numerical results from other methods for three benchmark test cases: dam breaking, sloshing wave and solitary wave propagation. In addition, the potential of generalization of the hybrid method will be studied by applying it with the GNN model trained on data for relatively simple cases to simulate more complex cases. It will be demonstrated that the hybrid method does not only give satisfactory results, but also shows good potential of generalization. In addition, the new method will be demonstrated to require the computation time which can be 80 times less than the conventional ISPH for estimating pressure for cases with a large number of particles that is usually needed in the practical free-surface flows simulation using ISPH. [ABSTRACT FROM AUTHOR]

This paper is devoted to fourth order compact schemes and fast algorithms for solving stationary Stokes equations with different boundary conditions numerically. One of the main ideas is to decouple the Stokes equations into three Poisson equations for the pressure and the velocity via the pressure Poisson equation (PPE). The augmented strategy is utilized to provide numerical boundary conditions for the pressure. Different velocity boundary conditions require different interpolation strategies for the augmented methods. The augmented variable is solved by the GMRES method. A new simple and efficient preconditioning strategy has also been developed to accelerate the convergence of the GMRES iteration. Numerical examples presented in this paper confirmed the designed convergence order and the efficiency of the new methods. • An augmented fourth-order approach is proposed to solve Stokes equations with various boundary conditions. • A new and efficient preconditioning strategy is developed for solving the Schur complement system in the GMRES iteration. • Non-trivial numerical examples are presented to confirm the effectiveness of the proposed method. [ABSTRACT FROM AUTHOR]

As new supercomputer architectures become more heavily focused on using hardware accelerators, in particular general-purpose graphical processors, it is therefore relevant that algorithms for computational fluid dynamics, especially those targeting scale-resolving simulations, be designed in such a way as to make efficient use of such hardware. In this paper, we propose one such hardware-accelerated Continuous Galerkin Finite Elements model, aimed at handling simulations of turbulent compressible flows over complex geometries. As this model is intended for use in Large-Eddy and Direct Numerical simulations, it is necessary that the resulting scheme introduces only small amounts of artificial (numerical) diffusion for stabilization purposes. We achieve this through a combination of Spectral Finite Elements, operator splittings on the convective term, and the use of the Entropy Viscosity stabilization model adapted to spectral elements scheme. The paper will present the resulting algorithm, how it is made to work efficiently on the accelerators, and results obtained that demonstrate its high-accuracy capabilities. [ABSTRACT FROM AUTHOR]

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 stability of colloid is closely related to the aggregation of colloidal particles and the dispersion of clusters in the system. Because aggregation changes the original state of the sol, previous studies have paid more attention to the aggregation process of the colloid. In fact, aggregation process and dispersion process coexist. The Cluster-Cluster Aggregation model has been widely used to simulate the process of colloidal agglomeration. In the aspect of cluster dispersion, people pay more attention to the simulation of cluster dispersion caused by external forces (such as shear force). In the actual system, the sudden decrease of electrolyte concentration leads to the increase of electrostatic repulsion between colloidal particles, resulting in the disintegration of the clusters. Inspired by the dimerization process of the traditional Cluster-Cluster Aggregation model, we previously proposed a dichotomy model to simulate the dispersion process of colloidal clusters. Here, we provide Java code for the dichotomy model, which can simulate dispersion caused by external forces and internal forces. This paper further elaborates the key points of the dichotomy model, mainly including: the definitions of the relevant probabilities involved in the dichotomy model, the data structures of particle, cluster and cube, and the functions of the relevant parameters related to the dichotomy model. Furthermore, the cluster's characteristics of erosion dispersion and collapse dispersion are studied respectively. Program Title: Dichotomy model CPC Library link to program files: https://doi.org/10.17632/my9xzpm8xg.1 Licensing provisions: Apache-2.0 Programming language: Java Nature of problem: Many scholars focus on the research of cluster aggregation, but ignore the cluster dispersion, and there are few programs for the simulation of cluster dispersion. The program provided in this paper can well simulate the dynamic process of cluster dispersion. Solution method: Inspiring by the idea of dimerization in the classical CCA model, the process of dispersing a larger cluster into multiple smaller clusters is transformed into the superposition of several times of one-to-two processes. The three-dimensional on-lattice model is used to simulate the process of cluster dispersion. We use the Java language to write programs, and dynamically display the simulation results through the Java3D technology. [ABSTRACT FROM AUTHOR]

The paper presents a new particle-in-cell model for fully kinetic simulations of plasma confinement regimes with high relative pressure. These regimes are considered as the most promising ones for fusion reactor proposals based on field reversed configurations, mirror and multi-cusp magnetic traps. Formation of an equilibrium high-pressure plasma with a fully excluded or reversed magnetic field cannot be investigated using the simplified magnetohydrodynamic and gyrokinetic approaches. A correct description of the electron dynamics under close proximity of zero and strong magnetic field regions can only be achieved within the framework of the kinetic theory that can be implemented most efficiently by the particle-in-cell method. The full-scale particle-in-cell simulations of modern fusion experiments require the use of finite-difference schemes in which temporal steps exceed the period of fastest electron oscillations at the plasma or even cyclotron frequencies and spatial steps do not have to resolve the Debye radius. This requirement is satisfied by implicit schemes capable of conserving the total energy of the system. The particle-in-cell model presented in this paper is based on the energy conserving semi-implicit approach as a predictive step and a new method for suppressing the electrostatic noise inherent in it as a corrective step. This two-step algorithm provides not only accurate energy conservation, but also the exact local fulfillment of the Gauss law. [ABSTRACT FROM AUTHOR]

Advancements in additive manufacturing have led to the widespread adoption of topology and shape optimization in the design process across various industrial applications. Topology optimization has emerged as a promising approach for creating ultra-lightweight structures with exceptional functionality. By designing porous structures and addressing the layout of pores, concurrent multiscale topology optimization schemes offer a means to achieve such outcomes. This paper focuses on the development of a multiscale topology optimization tool and presents a numerical investigation of the initial design domain's impact on maximizing heat conductivity through concurrent multiscale topology optimization. The study highlights the significant influence of the initial design domain in the microscale on the final microscale design. Moreover, modifying the initial micro design domain has a direct impact on the macro design domain. The findings underscore the importance of considering the initial design domain when aiming to maximize heat conductivity through concurrent multiscale topology optimization. To facilitate the replication of the results presented in this paper, comprehensive details regarding parameter settings and implementation aspects are provided. [ABSTRACT FROM AUTHOR]

Modeling multi-scale collisionless magnetized processes constitutes an important numerical challenge. By treating electrons as a fluid and ions kinetically, the so-called hybrid Particle-In-Cell (PIC) codes represent a promising intermediary between fully kinetic codes, limited to model small scales and short durations, and magnetohydrodynamic codes used large scale. However, simulating processes at scales significantly larger than typical ion particle dynamics while resolving sub-ion dissipative current sheets remain extremely difficult. This paper presents a new hybrid PIC code with patch-based adaptive mesh refinement. Here, hybrid PIC equations are solved on a hierarchy of an arbitrary number of Cartesian meshes of incrementally finer resolution dynamically mapping regions of interest, and with a refined time stepping. This paper presents how the hybrid PIC algorithm is adapted to evolve such mesh hierarchy and the validation of the code on a uniform mesh, fixed refined mesh and dynamically refined mesh. [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]

Cluster counting in drift chamber is the most promising breakthrough in particle identification (PID) technique in particle physics experiment. Reconstruction algorithm is one of the key challenges in cluster counting. In this paper, a semi-supervised domain adaptation (DA) algorithm is developed and applied on the peak finding problem in cluster counting. The algorithm uses optimal transport (OT), which provides geometric metric between distributions, to align the samples between the source (simulation) and target (data) samples, and performs semi-supervised learning with the samples in target domain that are partially labeled with the continuous wavelet transform (CWT) algorithm. The model is validated by the pseudo data with labels, which achieves performance close to the fully supervised model. When applying the algorithm on real experimental data, taken at CERN with a 180 GeV/c muon beam, it shows better classification power than the traditional derivative-based algorithm, and the performance is stable for experimental data samples across varying track lengths. [ABSTRACT FROM AUTHOR]

A recently developed computational framework for jet noise predictions is presented. The framework consists of two main components, focusing on source prediction and noise propagation. To compute the noise sources, the turbulent jet is simulated using the compressible flow solver implemented in the open-source spectral/hp element framework Nektar++, which solves the unfiltered Navier-Stokes equations on unstructured grids using the high-order discontinuous Galerkin method. This allows high-order accuracy to be achieved on unstructured grids, which in turn is important in order to accurately simulate industrially relevant geometries. For noise propagation, the Ffowcs Williams - Hawkings method is used to propagate the noise between the jet and the far-field. The paper provides a detailed description of the computational framework, including how the different components fit together and how to use them. To demonstrate the framework, two configurations of a single stream subsonic jet are considered. In the first configuration, the jet is treated in isolation, whereas in the second configuration, it is installed under a wing. The aerodynamic results for these two jets show strong agreement with experimental data, while some discrepancies are observed in the acoustic results, which are discussed. In addition to this, we demonstrate close to linear scaling beyond 100 , 000 processors on the ARCHER2 supercomputer. [ABSTRACT FROM AUTHOR]

This paper introduces PolyWeight, a Python software featuring a user-friendly graphical user interface (GUI), which offers two distinct approaches for MWD determination: an analytical relation-based method and a parametric model-based method. By utilizing dynamic moduli, users can calculate MWD as well as molecular weight averages such as M n , M w , and M z. The functionality of PolyWeight is validated using synthetic data and real data obtained from the literature, exhibiting good agreement. Log files and datasets used in this work are available on GitHub. Program Title: PolyWeight CPC Library link to program files: https://doi.org/10.17632/rn8t4mmvyd.1 Developer's repository link: https://github.com/a-minotto/PolyWeight Licensing provisions: GPLv3 Programming language: Python 3.x Nature of problem: Analytical rheology enables the determination of molecular weight distribution (MWD) by solving inverse problems. The reptation theory establishes a liaison between the viscoelastic behavior and MWD, permitting the application of mathematical resolution methods like regularization and parameterization. PolyWeight offers two solutions: a parameterization-based method that assumes a generalized exponential distribution (GEX) for the MWD, and an analytical relationship-based method that utilizes the relaxation spectrum. Solution method: The analytical relationship-based solution incorporates a mathematical formulation that considers the relaxation spectrum obtained from the dynamic moduli using the NLREG software. The numerical integration of the relaxation spectrum is performed utilizing the integrate.quad function from the SciPy library. An optimization process is employed in the parametric solution to perform a multiobjective fit of the viscoelastic models to the dynamic moduli. The integrals in this case are also calculated using the integrate.quad package from the SciPy library. The optimization procedure utilizes the lmfit library, where a Minimizer object is created based on the optimization function and subsequently utilized with the minimize function, employing the default Levenberg-Marquardt algorithm for the fit. [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]

Radiation-hydrodynamic and spectroscopic modeling are important aspects of high energy density experimental design. In this paper, we improve the performance and capabilities over those obtainable with a previous methodology used for simulating x-ray emission spectra from buried layer targets heated by short pulse lasers. The improvement incorporates post-processing HYDRA radiation-hydrodynamic output with a non-local thermodynamic equilibrium atomic-kinetics radiation transport code, Cretin. Each code uses an independent radiation field which allows decoupling HYDRA's radiation group structure from Cretin's spectral output to improve the speed and flexibility of the design methodology. The execution time decreases from 2–3 days to a few hours while the flexibility of the improved methodology allows for performing sensitivity studies including a comparison of steady-state and time-dependent atomic kinetics and differences in the radiation group structure. [ABSTRACT FROM AUTHOR]

In this paper, we develop a class of arbitrarily high-order energy-preserving time integrators for the nonlinear Klein–Gordon–Schrödinger equations. We employ Fourier pseudo-spectral method for spatial discretization, resulting in a semi-discrete system. Subsequently, we employ the Petrov-Galerkin method in time to obtain a fully-discrete system. We rigorously demonstrate that the proposed scheme preserves the original energy of the target system. Furthermore, we have proved that the mass of the system is also approximately preserved. To assess the accuracy of our method, we provide a simple estimate of the local error, revealing that the proposed approach achieves a temporal order of 2 s. Additionally, we extend the proposed methods to the damped Klein–Gordon–Schrödinger equations, and the corresponding fully-discrete scheme preserves the original energy dissipation law of the system. We present numerical examples to verify the accuracy and robustness of the proposed scheme. [ABSTRACT FROM AUTHOR]

It is known [1,2] that the sparse grid method for Particle-In-Cell (PIC) solvers acts as a filter to reduce the PIC noise. In this paper, a simple rule to discard or keep modes in Fourier space (a binary filter with values either 0 or 1) is derived using the sparse grid combination formula. Its relation to the standard sparse grid filter, which is characterized quantitatively, is explained. The relations between the sparse grid filters on grids of arbitrary levels are also outlined. Namely, in two (resp. three) dimensions and for bi-linear (resp. tri-linear) moment deposition, it is proven rigorously that the sparse grid filter, for a grid of size equal to an arbitrary power of two, can be expressed in terms of two (resp. three) unique real valued functions. The advantage of the binary filter over the standard sparse grid filter is the reduction of signal deformation introduced by the latter, for the same noise reduction capability. By applying the filter to moments of a marker distribution coming from the XTOR-K code, it appears the noise could be significantly reduced, with a moderate overhead in the moment deposition part of the algorithm. [ABSTRACT FROM AUTHOR]

In this paper, we derive and analyze the performance of optimal/quasi-optimal Schwarz Waveform Relaxation (SWR) domain decomposition methods (DDM) for the time-dependent Schrödinger equation when implement with neural network-based Partial Differential Equations (PDE) solvers. Optimal SWR methods, which are based on Dirichlet-to-Neumann operators, are known to have a higher convergence rate than classical or optimized SWR methods. However, they are usually considered prohibitive due to their computational costs with standard PDE solvers. Thanks to Physics Informed Neural Network acceleration within the Schwarz waveform relaxation process and an efficient computation of Dirichlet-to-Neumann transmission operators, we demonstrate that optimal and quasi-optimal SWR methods can be performed almost as efficiently as classical or optimized SWR methods while maintaining a faster convergence rate. We present a few numerical examples to illustrate the performance and convergence of the proposed method. [ABSTRACT FROM AUTHOR]

Heterogeneous architectures are increasingly common in modern High-Performance Computing (HPC) systems. Achieving high-performance on such heterogeneous systems requires new approaches to application development that are able to achieve the three Ps: Performance, Portability, and Productivity. In this paper, we provide an overview of the state-of-the-art for developing high-performance, portable and productive multi-physics applications with particular focus on the simulation of a plasma fusion reactor. Simulating such a complex system relies on both fluid- and particle-based simulations, and coupling interfaces between these two domains. We also review the current state-of-the-art in reasoning about the performance, portability and productivity of HPC applications. • Outlines approaches to developing high-performance numerical simulations. • Reviews the state-of-the-art in programming languages and parallel programming models. • Summarises high- and low-level domain specific languages targeting plasma fusion. • Outlines methods for coupling scientific simulations. • Describes methods for reasoning about performance, portability and productivity in HPC. [ABSTRACT FROM AUTHOR]

One-point quadrature discretization is one of the most popular discretizations for peridynamic simulation, but it suffers from poor accuracy. Employing smoothly decaying influence functions or precise volume correction can address this, but the former applies only to specific materials, and the latter may be computationally expensive and limited to square or cubic meshes. This paper discusses one-point quadrature discretization in the context of Monte Carlo integration and presents the quadrature rule, considering the smoothed acceptance-rejection method. In this context, the volume correction factor is explained as the probability of two particles interacting with each other. We summarize several volume correction algorithms from the literature and then present a new one based on the proposed quadrature rule. Numerical tests were conducted in both 2D and 3D. According to the comparison, the proposed algorithm only costs approximately 0.2% to 40% of the time that precise volume correction needs to compute the quadrature weights, while its integration accuracy is still at the same level. The results suggest that the continuity of the acceptance-rejection rule and the precision of the expectation of the horizon volume primarily matter in the accuracy of quadrature rules. [ABSTRACT FROM AUTHOR]

Graphical Processor Units (GPUs) are nowadays widely used in all-atom molecular simulations because of the advantage of efficient partitioning of atom pairs between the kernels to compute the contributions to energy and forces, thus enabling the treatment of very large systems. Extension of time- and size-scale of computations is also sought through the development of coarse-grained (CG) models, in which atoms are merged into extended interaction sites. Implementation of CG codes on the GPUs, particularly the multiple-GPU platforms is, however, a challenge due to more complicated potentials and removing the explicit solvent, forcing developers to do interaction- rather than space-domain decomposition. In this paper, we propose a design of a multi-GPU coarse-grained simulator and report the implementation of the heavily coarse-grained physics-based UNited RESidue (UNRES) model of polypeptide chains. By moving all computations to GPUs and keeping the communication with CPUs to a minimum, we managed to achieve almost 5-fold speed-up with 8 A100 GPU accelerators for systems with over 200,000 amino-acid residues, this result making UNRES the best scalable coarse-grained software and enabling us to do laboratory-time millisecond-scale simulations of such cell components as tubulin within days of wall-clock time. Program Title: Multi-GPU UNRES CPC Library link to program files: https://doi.org/10.17632/hz9s4nwncf.1 Developer's repository link: https://projects.task.gda.pl/eurohpcpl-public/unres Licensing provisions: GPLv3 Programming language: Fortran + C++/CUDA Nature of problem: Physics-based simulations of protein systems at biologically relevant time- and size-scale are demanding and consequently require both the simplification of biomolecule representation and substantial computational resources. UNRES (from UNited RESidue) is a physics-based reduced model of polypeptide chains with which to run large-scale coarse-grained simulations of protein structure and dynamics. It enables the researchers to study protein folding, protein dynamics, and protein-protein interactions in a physically realistic manner and further unveil biological processes' mechanisms. Examples of biological applications include studies of amyloid formations, signaling mechanism, and action of molecular chaperones. Solution method: The presented Multi-GPU UNRES relies on a highly optimized GPU implementation of non-central forces using modern CUDA constructs. Fundamentally, it is possible by proposed efficient partitioning and assignment of the interaction domain onto GPU resources. We moved as many computations as possible to the device (GPU) side. In most cases, computations are defined and scheduled as CUDA graphs. In selected cases, scheduling kernels manually yields slightly better performance. To maximize parallelism, multiple CUDA streams are used. Furthermore, the code visibly benefits from a tree-based allreduce shared-memory-based algorithm. Additionally, if present within hardware, peer memory access is enabled between all GPUs and the allreduce algorithm takes advantage of it. This feature has made the UNRES coarse-grained protein model with implicit solvent scalable for multi-GPUs so that we could achieve almost 5-fold speed-up with 8 A100 GPU accelerators for systems with over 200,000 amino-acid residues. • UNRES coarse-grained protein model with implicit solvent made scalable for multi-GPUs. • Efficient partitioning and assignment of the interaction domain onto GPU resources. • Highly optimized GPU implementation of non-central forces using modern CUDA constructs. [ABSTRACT FROM AUTHOR]

In this paper, we present a new static and time-dependent MagnetoHydroDynamic (MHD) equilibrium code, TokaMaker, for axisymmetric configurations of magnetized plasmas, based on the well-known Grad-Shafranov equation. This code utilizes finite element methods on an unstructured triangular grid to enable capturing accurate machine geometry and simple mesh generation from engineering-like descriptions of present and future devices. The new code is designed for ease of use without sacrificing capability and speed through a combination of Python, Fortran, and C/C++ components. A detailed description of the numerical methods of the code, including a novel formulation of the boundary conditions for free-boundary equilibria, and validation of the implementation of those methods using both analytic test cases and cross-code validation is shown. Results show expected convergence across tested polynomial degree for analytic and cross-code test cases. [ABSTRACT FROM AUTHOR]

• An efficient and reliable three-dimensional (3D) ghost cell method is presented for complex rigid and flexible boundary flows. • An improved implicit interface representation method is developed to track the arbitrary complex interfaces. • A GPU-CUDA parallel framework is developed to greatly accelerate the present solver. • The present solver can achieve hundreds of acceleration ratio for 2D grids and thousands of acceleration ratio for 3D grids. • Uniform flows around an 3D body with arbitrary geometries are simulated, and salient 3D wake structures are captured. This paper presents an efficient and reliable three-dimensional (3D) ghost cell method for complex rigid or flexible boundary flows. An improved implicit interface representation method is developed to treat the arbitrary complex interfaces including the thin or sharp boundaries. This method is robust and avoids the solving of a large dense matrix, and thus the computational efficiency is greatly enhanced. The ghost cell method with a unified eight-node interpolation scheme is adopted to enforce the no-slip boundary conditions on complex boundaries. To perform 3D high-resolution simulation on a desktop computer, a GPU parallel framework in CUDA environment is developed to significantly accelerate the computational efficiency of the present solver. The horizontal oscillations of a two-dimensional (2D) cylinder and a 3D sphere in the rest fluid are simulated to validate the accuracy and computational performance of the present model. Spatial accuracy of near second-order on the boundary treatment and good grid convergence are confirmed. Also, the present solver can achieve hundreds of acceleration ratios for 2D grids and thousands of acceleration ratios for 3D grids. Then, uniform flows around a 3D arbitrary rigid or flexible object such as a stationary cylindrical cylinder, a stationary square cylinder, an oscillating airfoil, and a swimming carangiform are simulated. The accuracy and capability of the present model for 3D complex geometries with large-amplitude movement or deformation is satisfactorily validated. Moreover, typical 3D wake structures are well captured. [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]

Identifying and reconstructing hadronic τ decays (τ h) is an important task at current and future high-energy physics experiments, as τ h represent an important tool to analyze the production of Higgs and electroweak bosons as well as to search for physics beyond the Standard Model. The identification of τ h can be viewed as a generalization and extension of jet-flavour tagging, which has in the recent years undergone significant progress due to the use of deep learning. Based on a granular simulation with realistic detector effects and a particle flow-based event reconstruction, we show in this paper that deep learning-based jet-flavour-tagging algorithms are powerful τ h identifiers. Specifically, we show that jet-flavour-tagging algorithms such as LorentzNet and ParticleTransformer can be adapted in an end-to-end fashion for discriminating τ h from quark and gluon jets. We find that the end-to-end transformer-based approach significantly outperforms contemporary state-of-the-art τ h reconstruction and identification algorithms currently in use at the Large Hadron Collider. [ABSTRACT FROM AUTHOR]

H Φ [ aitch-phi ] is an open-source software package of numerically exact and stochastic calculations for a wide range of quantum many-body systems. In this paper, we present the newly added functions and the implemented methods in vers. 2 and 3. In ver. 2, we implement spectrum calculations by the shifted Krylov method, and low-energy excited state calculations by the locally optimal block preconditioned conjugate gradient (LOBPCG) method. In ver. 3, we implement the full diagonalization method using ScaLAPACK and GPGPU computing via MAGMA. We also implement a real-time evolution method and the canonical thermal pure quantum (cTPQ) state method for finite-temperature calculations. The Wannier90 format for specifying the Hamiltonians is also implemented. Using the Wannier90 format, it is possible to perform the calculations for the ab i n i t i o low-energy effective Hamiltonians of solids obtained by the open-source software RESPACK. We also update Standard mode—simplified input format in H Φ —to use these functions and methods. We explain the basics of the implemented methods and how to use them. Program Title: H Φ [ aitch-phi ] CPC Library link to program files: https://doi.org/10.17632/vnfthtyctm.2 Developer's repository link: https://github.com/issp-center-dev/HPhi Licensing provisions: GPLv3 Programming language: C, Fortran Journal reference of previous version: Comput. Phys. Commun. 217 (2017) 180–192 Does the new version supersede the previous version?: Yes. The latest version has compatibility with the old versions. Although most functions are available in newer versions, some redundant/unnecessary functions were abolished in newer versions. Reasons for the new version: Implementation of new functions and methods, development of utilities, and bug fixes. Summary of revisions: We added new functions to obtain excited spectrum, low-energy excited states, and time-dependent physical quantities. We also implemented the full diagonalization method by using MAGMA on GPGPUs and finite-temperature simulations by using the canonical thermal pure quantum state method. In addition, we developed utilities for connection with RESPACK and a submodule for a generator of input files. Nature of problem: Physical properties in quantum lattice models with finite system sizes Solution method: In H Φ , we implemented several numerical methods such as the Lanczos method, the full diagonalization method, the locally optimal block preconditioned conjugate gradient (LOBPCG) method, the real-time evolution method based on the Taylor expansion, the shifted Krylov method, and the microcanonical/canonical thermal pure quantum state method. [ABSTRACT FROM AUTHOR]

Fuel cells/electrolyzers are efficient and clean electrochemical devices that convert chemical energy directly into electricity and vice versa. They have attracted sustainable attention over the past decade from multiple experimental and numerical studies. However, detailed experimental investigations are typically expensive and challenging for providing a number of operating conditions and designs. Computational analysis offers an alternative approach for these studies. With the steadily increasing high-performance computing resources available, the limitations of numerical simulations have substantially decreased. This contribution details the design choice and code structure of modern electrochemical devices, which have been implemented as a versatile C++ library named openFuelCell2 within the open-source platform OpenFOAM, allowing for large-scale parallel calculations to be performed. The solver considers the major transport phenomena in a typical electrochemical device, including fluid flow, heat and mass transfer, species and charge transfer, and electrochemical reaction. This enables numerical simulations on popular electrochemical devices, such as fuel cells and electrolyzers, to be conducted. The paper also describes the domain decomposition, and parallel performance issues, as well as future applications. Program Title: openFuelCell2 CPC Library link to program files: https://doi.org/10.17632/cvmb5xgy7h.1 Developer's repository link: https://github.com/openFuelCell2/openFuelCell2 Licensing provisions: GPLv3 Programming language: C++ Journal reference of previous version: S.B. Beale, H.-W. Choi, J.G. Pharoah, H.K. Roth, H. Jasak, D.H. Jeon, Open-source computational model of a solid oxide fuel cell, Computer Physics Communications 200 (2016) 15–26. Does the new version supersede the previous version?: No Reasons for new version: This new version aims to account for additional electrochemical applications. Summary of revisions: The new version employs new code structure designs and is capable of considering two different electric potential fields and two-phase flows. Nature of problem: This software library provides a set of models for simulating electrochemical devices, such as fuel cells and electrolyzers, as well as other similar devices. These systems consist of multiple components with distinct features but are coupled through properties such as temperature, species concentrations, and electric current/potentials. This software utilizes a computational fluid dynamics (CFD) approach to enable the simulation of multiregion and multiphysics problems, accounting for heat and mass transfer, single and two-phase flow, multicomponent diffusion, electron and ion transfer, and electrochemical reactions. This toolbox provides researchers with a powerful tool for studying electrochemical devices in a comprehensive and efficient manner. Solution method: This software utilizes the finite volume method (FVM) to discretize and solve all conserved variables governed by partial differential equations. It employs a variant of the SIMPLE and PISO algorithms, known as PIMPLE, to solve the pressure-velocity coupling. All of the transport equations are solved sequentially, except for the enthalpy equation which is solved in an implicitly coupled manner within the global domain. Additional comments including restrictions and unusual features: • The two-phase flow consists of continuous and dispersed phases, without resolving the phase interfaces. • The two-phase flow is solved with an Eulerian-Eulerian approach. • A local-time-stepping method was typically used in the two-phase solution. • The electrochemical reactions take place in volumetric regions. • Species diffusion is described by Fick's law. [ABSTRACT FROM AUTHOR]

The Lie and Darboux methods to obtain Liouvillian first integrals of rational second order ordinary differential equations (rational 2ODEs) are very powerful. Nevertheless, there are cases where these procedures may encounter difficulties. Namely, when the Darboux polynomials present in the integrating factor of the 2ODE have a very high degree and/or when the 2ODE does not admit point symmetries. In [3,4] we developed a method (S-function method) that is successful in treating certain classes of rational second order ordinary differential equations that are particularly 'resistant' to canonical Lie methods and to Darbouxian approaches. However, although determining the S-function is in general much more efficient than determining Darboux polynomials or nonlocal symmetries, for very complicated rational 2ODEs, even finding the S-function itself can be quite hard. In this work we present a simple way of (in almost all cases) computing the S-function with a very efficient procedure. Program Title: InSyDE – Invariants and Symmetries of (rational second order ordinary) Differential Equations. CPC Library link to program files: https://doi.org/10.17632/4ytft6zgk7.2 Licensing provisions: CC by NC 3.0 Programming language: Maple 17 Journal reference of previous version: Comput. Phys. Commun. 234 (2019) 302–314 Does the new version supersede the previous version?: Yes. Nature of problem: Determining Liouvillian first integrals of rational second order ordinary differential equations. Solution method: The method is explained in the body of the paper. Reasons for new version: The InSyDE package depends, in order to work, on determining the S-function. The problem is that, for very complicated 2ODEs, this can be very costly (computationally) or even unrealizable (within time and memory limits). We have developed a computationally cheaper way of determining the S-function that, in addition to being very efficient, is also surprisingly broad. Summary of revisions: We have, based on important new theoretical results presented on Appendix A: Supplementary Material, modified and improved the command Sfunction. [ABSTRACT FROM AUTHOR]

Metasurfaces are metamaterials with two-dimensional (2D) or planar structures. Compared to traditional metamaterials, metasurfaces have the advantage of being lightweight, easy to control and simple to design. This paper outlines the phase matching principle and constitutive parameter theory of electromagnetic (EM) metasurfaces, as well as the constitutive parameter analysis and model equations for metasurface cloaks. Due to the singularity of the metasurface cloak, an Adaptive Edge Finite Element Method (AEFEM) is developed in this paper. In addition, the convergence theory of the AEFEM for the time-harmonic Maxwell's equations with one sign-changing coefficient is established under the T-coercivity assumption. Numerical simulations of the arc-shaped metasurface cloak have confirmed the accuracy of our model and numerical theory. Furthermore, we have used our numerical method to design a triangular-shaped metasurface cloak with fewer singularities. [ABSTRACT FROM AUTHOR]

Convergence rates of iterative algorithms for solving non-linear fixed-point (or root-finding) problems depend on the quality of the solution guess done in each iteration, which is used as the starting value in the next step. To avoid instabilities and oscillations, that guess is usually constructed (mixed) as a linear combination of the newly calculated value with values from the previous iterations. The mixing algorithm constitutes a crucial component for electronic structure calculation methods based on iterative seeking for a self-consistent state. This paper reviews several mixing algorithms for electronic structure calculations. The most important numerically confirmed finding is that the calculation speed depends more on the choice of the so-called "mixing coefficient" than on the choice of a particular algorithm. Then a new method allowing an automatic adaptation of this coefficient is proposed, implemented, and tested on various solid-state structures within three electronic structure calculation codes. In our testing cases, the newly designed Adaptive Anderson Algorithm exhibits better convergence for a broader range of initial mixing coefficients, and similar or better robustness, in comparison to the standard Anderson method. The Fortran implementation of the new algorithm and its Python wrapper are briefly described in the paper and made available for public use. [ABSTRACT FROM AUTHOR]

Many practical problems, including modeling composite materials, nuclear waste disposal, oil reservoir simulations, and flows in porous medium, commonly involve interface problems. However, the solution to interface problems with discontinuous coefficients of PDEs using fully decoupled numerical methods is challenging. The main objective is to solve the interface problems with fully decoupled numerical methods. This paper proposes an efficient decoupled numerical method for solving degenerate interface problems with double singularities. First, we divide the whole domain into singular and regular subdomains. Then, we use the Deep Neural Network (DNN) to find the solution on the singular subdomain and approximate the solution on the regular subdomain using the finite difference method. The scheme combines the solutions of singular and regular subdomains, which is an exciting idea. The key to the new approach is to split nonlinear degenerate partial differential equations with an interface into two independent boundary value problems based on deep learning. In this way, the expansion of the solution on the singular domain does not contain undetermined parameters, and two independent boundary value problems can be solved with any well-known traditional numerical methods. The main advantage of the proposed scheme is that we not only get the order of convergence of the degenerate interface problems on the whole domain, but we also can calculate VERY BIG jump ratio (such as 10 12 : 1 or 1 : 10 12) for the interface problems including degenerate and non-degenerate cases. Finally, with examples, we demonstrate the efficiency and accuracy of methods for 1 and 2D problems. It is also interesting that the proposed method is valid for the interface problems with degenerate and non-degenerate cases, we show it with some examples. • A fully decoupled numerical method for solving nonlinear degenerate interface problems (NDIP) is provided. • The key step is to split NDIP into two independent non-degenerate BVPs based on deep neural networks. • The convergence order on whole domain is determined by the finite difference scheme which used on the regular subdomains. • VERY BIG jump ratio (such as 10 12 : 1 or 1 : 10 12) for NDIP including degenerate and non-degenerate cases can be calculated. • The flexibility, accuracy and efficiency of the method are validated from various experiments in both 1D and 2D. [ABSTRACT FROM AUTHOR]

The Mercedes-Benz (MB) water model is a simple two-dimensional toy model of water that can reproduce many of the anomalous properties of water. Within the model, the water particles are represented as Lennard-Jones disks with explicitly added orientation-dependent interactions that mimic the formation of hydrogen bonds. Due to the simple implementation of the MB model in Monte Carlo simulations, it was mainly studied with Monte Carlo simulations in different ensembles. The implementation of the model in molecular dynamics simulations is not trivial. In this paper we present the code for molecular dynamics simulations. The structural and thermodynamic properties of the model were calculated using molecular dynamics and compared with data from Monte Carlo simulations to confirm that the molecular dynamics code works correctly. We also used molecular dynamics to calculate the dynamic properties of the model. The Fortran source code of our molecular dynamics simulation of the MB water model is provided. [ABSTRACT FROM AUTHOR]

ENDFtk is a recently developed C++ and Python interface to interact with ENDF-6 formatted nuclear data files. It provides a robust and complete interface, allowing the reading and writing of all formats currently part of the ENDF-6 formats manual, as well as some non-ENDF formats used by the NJOY processing code. It provides an interface that mimics the names in the ENDF-6 formats manual as well as an equivalent interface using human-readable attribute names. It is robust and powerful enogh for nuclear data experts to develop complex applications, while also simple enough to be used non-experts to retrieve and manipulate evaluated nuclear data. ENDFtk offers the ability to easily interrogate and manipulate data either in large-scale code projects or in simple Python scripts. In this paper, a brief overview of the interface is given, as well as more substantial examples demonstrating plotting simple data, interacting with more complex data, and writing new data to files. ENDFtk is open source and available for download via GitHub (https://github.com/njoy/ENDFtk). Program title: ENDFtk 1.0 CPC Library link to program files: https://doi.org/10.17632/9p4kxc2cvd.1 Developer's repository link: https://github.com/njoy/ENDFtk Licensing provisions: BSD-3 clause Programming language: C++ and Python External routines/libraries: pybind11, ranges-v3, spdlog Nature of problem: Provide an interface to read, write and manipulate nuclear data files using the ENDF-6 format. This interface can be integrated into other libraries requiring access to nuclear data, or be used directly using the Python interface. Solution method: Library of C++ routines, with their Python bindings, to be integrated in higher-level codes and scripts [ABSTRACT FROM AUTHOR]

We present a Python-based open-source library named Jiezi, which provides the means of simulating the electronic transport properties of nanoscaled devices on the atomistic level. The key feature of Jiezi lies in its core algorithm, i.e., self-consistent orchestration between the non-equilibrium Green's function (NEGF) method and a Poisson's equation solver. Beyond the construction of the tight-binding (TB) Hamiltonian with empirical parameters for conventional materials, the package offers a comprehensive framework for constructing the Wannier-based Hamiltonian matrix, enabling the investigation of novel materials and their heterostructures. To expedite the solution of NEGF systems, a methodology based on renormalization theory is proposed for reducing the dimension of the Hamiltonian matrix. Additionally, we adopt a non-linear Poisson equation solver with no analytical approximation in this software. The software facilitates seamless integration with external tools for geometry and mesh generation and post-processing. In this paper, we present the main capabilities and workflow by demonstrating with a simulation for the carbon nanotube field-effect transistor (CNTFET). Program Title: Jiezi CPC Library link to program files: https://doi.org/10.17632/nk79kbtww4.1 Developer's repository link: https://github.com/Jiezi-negf/Jiezi Licensing provisions: GPLv3 Programming language: Python Nature of problem: Simulates the quantum transport property of nano-scaled transistors based on the predefined device structure and the material composition. Solution method: Solves the coupled Schrödinger equation and Poisson equation by NEGF and finite element method. [ABSTRACT FROM AUTHOR]

It is essential to precisely determine the evolving concentrations of radioactive nuclides within transmutation problems. It is also a crucial aspect of nuclear physics with widespread applications in nuclear waste management and energy production. This paper introduces CNUCTRAN, a novel computer program that employs a probabilistic approach to estimate nuclide concentrations in transmutation problems. CNUCTRAN directly simulates nuclei transformations arising from various nuclear reactions, diverging from the traditional deterministic methods that solve the Bateman equation using matrix exponential approximation. This approach effectively addresses numerical challenges associated with solving the Bateman equations, therefore, circumventing the need for matrix exponential approximations that risk producing nonphysical concentrations. Our sample calculations using CNUCTRAN shows that the concentration predictions of CNUCTRAN have a relative error of less than 0.001% compared to the state-of-the-art method, CRAM, in different test cases. This makes CNUCTRAN a valuable alternative tool for transmutation analysis. Program Title: CNUCTRAN CPC Library link to program files: https://doi.org/10.17632/b484w2vx52.1 Developer's repository link: https://github.com/rabieomar92/cnuctran/releases Licensing provisions: MIT Programming language: C++ Nature of problem: CNUCTRAN simulates the transmutation of various nuclides such as decays, fissions, and neutron induced reactions using a direct simulation approach. It has the capability of predicting the final concentration of a large system of nuclides altogether after a specified time step, t f. Solution method: CNUCTRAN works based on the novel probabilistic method such that it does not compute the final nuclide concentrations by solving Bateman equations. Instead, it statistically tracks nuclide transformations into one another in a transmutation problem. The technique encapsulates various possible nuclide transformations into a sparse transfer matrix, T , whose elements are made up of various nuclear reaction probabilities. Next, T serves as a matrix operator acting on the initial nuclide concentrations, y (0) , producing the final nuclide concentrations, y. [ABSTRACT FROM AUTHOR]

Accurate particle simulations are essential for the next generation of experiments in astroparticle physics. The Monte Carlo simulation library PROPOSAL is a flexible tool to efficiently propagate high-energy leptons and photons through large volumes of media, for example in the context of underground observatories. It is written as a C++ library, including a Python interface. In this paper, the most recent updates of PROPOSAL are described, including the addition of electron, positron, and photon propagation, for which new interaction types have been implemented. This allows the usage of PROPOSAL to simulate electromagnetic particle cascades, for example in the context of air shower simulations. The precision of the propagation has been improved by including rare interaction processes, new photonuclear parametrizations, deflections in stochastic interactions, and the possibility of propagating in inhomogeneous density distributions. Additional technical improvements regarding the interpolation routine and the propagation algorithm are described. Program Title: PROPOSAL. CPC Library link to program files: https://doi.org/10.17632/g478pjdcxy.2. Developer's repository link: https://github.com/tudo-astroparticlephysics/PROPOSAL. Licensing provisions: LGPL. Programming language: C++, Python. Journal reference of previous version: Comput. Phys. Commun. 242 (2019) 132. Does the new version supersede the previous version?: Yes. Reasons for the new version: Substantial addition of features. Various bugfixes. Summary of revisions: The library now also treats photons and has the corresponding processes implemented. New parametrizations for photonuclear interaction have been implemented. The angular deflection in stochastic energy losses has been implemented in addition to the already existing multiple scattering implementation, which has been improved to reduce the runtime. The implementation of the Landau-Pomeranchuk-Migdal effect has been corrected. The propagation algorithm has been improved, including the support of inhomogeneous density distributions. Nature of problem: Three-dimensional propagation of charged leptons and photons through different media. Particles lose energy stochastically by ionization, bremsstrahlung, pair production, and photonuclear interaction for charged leptons (including annihilation with atomic electrons for positrons) and Compton scattering, pair production, photoelectric effect and photohadronic interaction for photons. Additionally, they are deflected while propagating through the medium due to both multiple elastic Coulomb scattering as well as deflections in individual stochastic interactions. Unstable particles eventually decay, producing secondary particles. Solution method: Monte-Carlo simulation. The library samples the next interaction point, the type of interaction process, the energy lost in this interaction process, and the energy lost until this point. Particles are propagated until they decay, lose all their kinetic energy (for photons: reach a lower energy limit defined by the validity of the underlying cross sections), or until a user-defined termination criterion is reached. For each propagation step, the angular deflection and endpoint shift due to multiple scattering is calculated. To improve the performance and deal with the divergence of the bremsstrahlung cross section for small photon energies, energy losses below a predefined relative or absolute energy threshold are treated continuously. The computation time is improved by the use of interpolation tables. [ABSTRACT FROM AUTHOR]

We propose a parallel (distributed) version of the spectral proper orthogonal decomposition (SPOD) technique. The parallel SPOD algorithm distributes the spatial dimension of the dataset preserving time. This approach is adopted to preserve the non-distributed fast Fourier transform of the data in time, thereby avoiding the associated bottlenecks. The parallel SPOD algorithm is implemented in the PySPOD library and makes use of the standard message passing interface (MPI) library, implemented in Python via mpi4py. An extensive performance evaluation of the parallel package is provided, including strong and weak scalability analyses. The open-source library allows the analysis of large datasets of interest across the scientific community. Here, we present applications in fluid dynamics and geophysics, that are extremely difficult (if not impossible) to achieve without a parallel algorithm. This work opens the path toward modal analyses of big quasi-stationary data, helping to uncover new unexplored spatio-temporal patterns. Program Title: PySPOD CPC Library link to program files: https://doi.org/10.17632/jf5bf26jcj.1 Developer's repository link: https://github.com/MathEXLab/PySPOD Licensing provisions: MIT License Programming language: Python Nature of problem: Large spatio-temporal datasets may contain coherent patterns that can be leveraged to better understand, model, and possibly predict the behavior of complex dynamical systems. To this end, modal decomposition methods, such as the proper orthogonal decomposition (POD) and its spectral counterpart (SPOD), constitute powerful tools. The SPOD algorithm allows the systematic identification of space-time coherent patterns. This can be used to understand better the physics of the process of interest, and provide a path for mathematical modeling, including reduced order modeling. The SPOD algorithm has been successfully applied to fluid dynamics, geophysics and other domains. However, the existing open-source implementations are serial, and they prevent running on the increasingly large datasets that are becoming available, especially in computational physics. The inability to analyze via SPOD large dataset in turn prevents unlocking novel mechanisms and dynamical behaviors in complex systems. Solution method: We provide an open-source parallel (MPI distributed) code, namely PySPOD, that is able to run on large datasets (the ones considered in the present paper reach about 200 Terabytes). The code is built on the previous serial open-source code PySPOD that was published in https://joss.theoj.org/papers/10.21105/joss.02862.pdf. The new parallel implementation is able to scale on several nodes (we show both weak and strong scalability) and solve some of the bottlenecks that are commonly found at the I/O stage. The current parallel code allows running on datasets that was not easy or possible to analyze with serial SPOD algorithms, hence providing a path towards unlocking novel findings in computational physics. Additional comments including restrictions and unusual features: The code comes with a set of built-in postprocessing tools, for visualizing the results. It also comes with extensive continuous integration, documentation, and tutorials, as well as a dedicated website in addition to the associated GiHub repository. Within the package we also provide a parallel implementation of the proper orthogonal decomposition (POD), that leverages the I/O parallel capabilities of the SPOD algorithm. [ABSTRACT FROM AUTHOR]

The Fourier pseudo-spectral method is well suited to solve PDEs under the periodic boundary condition due to its high-order accuracy and easy-to-implement feature. In this paper, we explore as well as comparatively study four classes of Fourier pseudo-spectral schemes for solving the rotation-two-component Camassa–Holm system which possibly owns peakon solitons. Via exploiting inherent structural properties of the system, we reformulate it into two kinds of different equivalent forms and then apply the Fourier pseudo-spectral method to derive two spatial semi-discrete systems, both of which are proved to preserve the corresponding invariants including mass, momentum and energy. Subsequently, we construct two linearly implicit schemes based on Strang splitting technique and two nonlinear schemes, respectively, for both semi-discrete systems. Owing to the different equivalent forms in the structure, one of the nonlinear schemes preserves discrete mass and momentum, while the other one is shown to preserve all three invariants. Numerical results under the situation of smooth/nonsmooth initial values are provided for distinct types of solutions to test the accuracy in long time simulation and to verify the capacity of predicting water wave propagation, as well as advantages in preserving these invariants. For instance, the present schemes are shown to be at least 14 significant digits, improving upon 10 from ones in previous references. [ABSTRACT FROM AUTHOR]

This study introduces GeoTaichi, an open-source high-performance numerical simulator designed for addressing multiscale geophysical problems. By leveraging the power of the Taichi parallel language, GeoTaichi maximizes the utilization of modern computer resources on multicore CPU and GPU architectures. It offers robust and reliable modules for the discrete element method (DEM), material point method (MPM), and coupled material point-discrete element method (MPDEM). These modules enable efficient solving of large-scale problems while being implemented in pure Python. The design philosophy of GeoTaichi focuses on creating a framework that is readable, extensible, and user-friendly. This paper highlights the coupling procedure of MPDEM, the code structures, and the most important features of GeoTaichi. Rigorous benchmark tests have been conducted to verify the validity and robustness of GeoTaichi. Additionally, the performance of GeoTaichi is compared with similar software tools in the field, underscoring a notable improvement in both computational efficiency and memory savings when compared to existing alternatives. Program title: GeoTaichi CPC Library link to program files: https://doi.org/10.17632/858bmcf7j6.1 Developer's repository link: https://github.com/Yihao-Shi/GeoTaichi Licensing provisions: GNU General Public License v3.0 Programming language: Python Nature of problem: The simulations of large-deformation geophysical flows and their interaction with structures play a crucial role in the field of geophysics. To address the complexities of these nonlinear problems, the discrete element method (DEM), material point method (MPM), and their coupling (MPDEM) have proven to be highly suitable numerical schemes. However, these schemes impose substantial computational demands, necessitating the development of an efficient framework that can harness modern computer resources on multicore CPU and GPU architectures. Solution method: The open-source code GeoTaichi implements the DEM, MPM, and coupled MPDEM, encompassing a range of constitutive models and contact laws for different geologic materials. The clump particle model is also introduced in DEM to solve granular mechanics involving complex-shaped particles. One significant advantage of GeoTaichi is its utilization of the Taichi parallel language, which is designed to be user-friendly and easily extensible for customized applications. [ABSTRACT FROM AUTHOR]