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 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]

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]

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]

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]

• 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]

The paper focuses on the optimization of the FEM matrix kernels with respect to user-defined parameters such as materials, initial conditions, and boundary conditions that are known during run-time only. Adapting the kernels to specific parameters can save a significant amount of execution time and increase performance. Handling them efficiently is challenging due to the exponential number of potential combinations that the user can specify. The paper presents an approach that combines (a) cross-element vectorization for the easy-to-write transformation of the original scalar code to vectorized one, (b) meta-programming for utilization of a compiler for building sub-kernels tailored for a particular set of parameters, (c) and dynamic polymorphism allowing run-time selection of sub-kernels. We show that the above techniques allow (1) straightforward code modifications, (2) efficient handling of required dynamic behavior with a minor performance penalty for most kernels, and (3) achieving up to 8-fold speedups compared to non-adapted kernels. • High productivity approach for developing and implementing new FEM matrix kernels. • Automated approach that reaches the performance of hand-tuned kernels. • Technique allowing implementation of highly optimized kernels with standard C++ language features. • Approach combining SIMD vectorization with expression optimization with significantly higher impact on performance than pure vectorization. [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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

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]

This paper presents a parallel implementation of the Discrete Unified Gas Kinetic Scheme (DUGKS) on the GPU system using the CUDA Fortran and CUDA C++ programming languages. Firstly, we conducted an extensive revision of our original CPU-based code, resulting in a threefold decrease in memory usage. This new implementation is also paired with a novel approach to compute cell face flux using trilinear interpolation. It is shown analytically that the interpolation-based approach to flux calculation is more accurate compared to the one used in the original DUGKS. The initial simulation results using this new approach suggest that trilinear interpolation can reduce numerical errors on a coarse mesh. For example, in the case of the decaying Taylor-Green vortex flow at a 1283 mesh resolution, the relative numerical error in the energy dissipation rate at t ⁎ = 2 , using the spectral simulation result as the benchmark, is approximately 30% lower than that of the original implementation. The improved GPU DUGKS method is applied to laminar and turbulent flows in periodic and wall-bounded boundary configurations. A performance comparison of the GPU implementation is also presented and compared to the previous CPU implementation. A maximum speedup of 7.64x was achieved on a desktop-level GPU compared to a 32-core CPU. The strong scaling test, conducted on an eight-GPU node, demonstrated the efficient utilization of available multiple GPU resources by the code. Program Title: DUGKS-GPU CPC Library link to program files: https://doi.org/10.17632/yykv5s9g2n.1 Developer's repository link: https://github.com/kairzhan/DUGKS-GPU Code Ocean capsule: https://codeocean.com/capsule/3b1e4f74-cdd3-4781-8923-8514d5923dfb/ Licensing provisions: GNU General Public License 3 Programming language: CUDA C++, CUDA Fortran Supplementary material: Nature of problem: DUGKS-GPU is an advanced numerical code designed to accelerate the simulation of turbulent fluid flows through the application of the kinetic method known as the Discrete Unified Gas Kinetic Scheme (DUGKS). This computational tool comprises a CUDA Fortran version, tailored for a single GPU, as well as a CUDA C++ version developed for multi-GPU platforms. Solution method: The code employs a second-order finite-volume discretization of the discrete velocity Boltzmann equation with the BGK collision model. It can be used to simulate small to medium-scale problems on modern multi-GPU platforms with CUDA architecture. [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]

In this paper we propose and benchmark an innovative implementation of the Random Sequential Addition (or adsorption) (Rsa) algorithm. It provides Mpi parallelization and is designed to generate a high number of spheres aiming for maximal compactness, without introducing any bias. Although parallelization of such an algorithm has been successfully undertaken with shared memory (and in particular with Gpu), this is seemingly the first available implementation with distributed memory (Mpi). Our implementation successfully generated more than 12 billions of spheres over 131,072 Mpi processes in 16 seconds in dimension d = 3. [ABSTRACT FROM AUTHOR]

The library provides a set of C++/Python functions for computing cross sections of ultraperipheral collisions of high energy particles under the equivalent photons approximation. Cross sections are represented through multiple integrals over the phase space. The integrals are calculated through recurrent application of algorithms for one dimensional integration. The paper contains an introduction to the theory of ultraperipheral collisions, discusses the library approach and provides a few examples of calculations. [ABSTRACT FROM AUTHOR]

This paper presents a new preprocessing algorithm to generate accurate initial conditions for particle-method-based CFD simulations with complex geometries. The algorithm is based on the improved Marching Cubes method (MC) with the newly proposed isosurface particle redistribution optimisation. It can not only produce topologically accurate isosurfaces and boundary particles that encompass the entire boundary surface but also offers a seamless method for evenly distributing internal fluid particles, eliminating the necessity for additional fluid field reconstruction algorithms. To address the issue of particle clustering on the surface boundary caused by MC intersection with sharp corners in complex geometries, we have introduced an iterative particle-moving algorithm. This algorithm aims to both achieve a uniform distribution of boundary particles across the surface and to recompute their normal vectors due to particles movement. In introducing our newly developed preprocessing algorithm, we have taken the initiative to systematically elucidate the entire process of generating boundary particles on complex surfaces using optimization theory, marking a pioneering effort in this regard. The developed particle preprocessing optimization techniques can use inputs from both the volume image data format from MRI/CT and standard CAD files, such as STL models. We have used various test cases with standard CAD geometries and complex real-world application geometries to validate and test the algorithms. The results demonstrate the impressive ability of our preprocessing toolkit1 to handle real complex geometries, along with the robustness and efficiency of the newly developed algorithms. [ABSTRACT FROM AUTHOR]

In this paper, a second-order finite volume Non-Homogeneous Riemann Solver is used to obtain an approximate solution for the two-dimensional shallow water magnetohydrodynamic (SWMHD) equations considering non-flat bottom topography. We investigate the stability of a perturbed steady state, as well as the stability of energy in these equations after a perturbation of a steady state using a dispersive analysis. To address the elliptic constraint ∇ ⋅ h B = 0 , the GLM (Generalized Lagrange Multiplier) method designed specifically for finite volume schemes, is used. The proposed solver is implemented on unstructured meshes and verifies the exact conservation property. Several numerical results are presented to validate the high accuracy of our schemes, the well-balanced, and the ability to resolve smooth and discontinuous solutions. The developed finite volume Non-Homogeneous Riemann Solver and the GLM method offer a reliable approach for solving the SWMHD equations, preserving numerical and physical equilibrium, and ensuring stability in the presence of perturbations. [ABSTRACT FROM AUTHOR]

In this paper, we present the KelbgLIP code to implement the previously obtained analytical density matrix that includes Coulomb long-range interactions. The method is based on the work of G. Kelbg, who derived a high temperature density matrix for the Coulomb potential. To include all long-range interactions in the density matrix, we use the Ewald technique, specifically the angular-averaged Ewald potential (AAEP). The solution of the Blöch equation within the AAEP has a direct analytic form that can be easily implemented in classical and quantum Monte Carlo or molecular dynamics codes, including exchange effects. The potential part of the density matrix remains finite at small distances, preventing the collapse of a two-component system. Using KelbgLIP, one can calculate the diagonal Kelbg-AAE pseudopotential and the pair density matrix. In the case of a hydrogen plasma, the code is able to calculate action, kinetic and potential energy in the path integral representation. We validated our approach by simulating a nondegenerate weakly coupled hydrogen plasma and obtained the thermodynamic limit in agreement with the Debye-Hückel approximation. In addition, we observe the agreement with classical simulations using the unbounded from below AAEP, which is possible in the weakly-coupled regime. Program Title: KelbgLIP, version 1.0 CPC Library link to program files: https://doi.org/10.17632/p773jhdz69.1 Licensing provisions: GPLv3 Programming language: C++11 Nature of problem: The calculation of thermodynamic properties of two-component Coulomb systems relies on the formalism of the density matrix to avoid the collapse due to the unbounded Coulomb potential. The direct consideration of long-range Coulomb potential interactions with periodic boundary conditions requires the solution of the Blöch equation for the density matrix in the case of the Ewald potential. However, typically only the solution for the Coulomb potential is used, omitting all long-range effects, because the Ewald potential has a sufficiently complicated form. Solution method: To account for long-range effects in solving the Blöch equation, one can use the angular-averaged Ewald potential (AAEP). This potential, with its simple analytic form, effectively captures the long-range effects and has a finite interaction range. In order to solve the Blöch equation with the AAEP, we use the Kelbg approach [1], in which the solution was obtained for the Coulomb potential in a high-temperature limit. Hence, we derive the density matrix with the Kelbg-AAE pseudopotential (Kelbg-AAEPP) that is finite at small distances [2]. Notably, this density matrix has a direct analytic form, which avoids a summation over Coulomb energy levels or squaring method [3]. The Kelbg-AAE density matrix is then used in quantum simulations via path integral Monte Carlo and in classical simulations using the diagonal Kelbg-AAEPP with a finite interaction radius. In the case of Boltzmannons, the expressions for action, kinetic and potential energy are derived. Special attention is paid to the calculation involving the non-diagonal Kelbg-AAEPP. The code calculates the diagonal Kelbg-AAEPP with possible improvement at short distances [4], pair Kelbg-AAE density matrix, as well as action, kinetic energy, and potential energy. These routines can be easily integrated into other molecular dynamics or path integral Monte Carlo codes designed for fermions and bosons, which is particularly valuable for the simulations of two-component Coulomb systems. Additional comments including restrictions and unusual features: GSL library version 2.x is required for compilation. References [1] G. Kelbg, Theorie des Quanten-Plasmas, Ann. Phys. 467 (3–4) (1963) 219–224. [2] G.S. Demyanov, P.R. Levashov, Accounting for long–range interaction in the Kelbg pseudopotential, Contrib. Plasma Phys. 62 (10) (2022) e202200100. [3] B. Militzer, Computation of the high temperature Coulomb density matrix in periodic boundary conditions, Comput. Phys. Commun. 204 (2016) 88–96. [4] A.V. Filinov, V.O. Golubnychiy, M. Bonitz, W. Ebeling, J.W. Dufty, Temperature-dependent quantum pair potentials and their application to dense partially ionized hydrogen plasmas, Phys. Rev. E 70 (2004) 046411. [ABSTRACT FROM AUTHOR]

The paper presents a new one-dimensional drift-kinetic electrostatic model based on the particle-in-cell method and capable of simulating the processes of plasma heating and confinement in mirror traps. The most of particle and energy losses in these traps occur along the magnetic field lines. The key role in limiting these losses is played by the ambipolar electric potential which creates a potential barrier for electrons and significantly reduces the heat flux that, without this barrier, would go to wall due to the classical electron thermal conductivity. However, modeling the formation of such a potential on real spatial and temporal scales of experiments is a challenging problem, since it requires a detailed description of not only ion, but also electron kinetics. In this work, we propose to solve the problem of taking into account electron kinetic effects on the time scale of plasma confinement in a mirror trap using the particle-in-cell method adapted to the approximate drift-kinetic equations of plasma motion. Unlike other electrostatic particle-in-cell models, which use fully implicit schemes to solve the nonlinear system of Vlasov-Poisson and Vlasov-Ampere equations, we propose a semi-implicit approach. By analogy with the Energy Conserving Semi-Implicit Method (ECSIM), it allows for precise conservation of energy and reduces the procedure for finding the electric field to inverting a tridiagonal matrix without multiple nonlinear iterations. Such a model will be useful for simulating not only collisional losses of hot plasma in fusion experiments, but also for studying the features of creating cold starting plasma in mirror traps using plasma or electron guns. [ABSTRACT FROM AUTHOR]

Predicting the phase diagram of solid solutions is crucial for understanding their physical behavior under various conditions and at different compositions. However, conventional sampling methods face challenges in efficiently addressing configurational and vibrational disorder for substitutional solid solutions. Additionally, a persistent obstacle has been the lack of a robust theoretical approach for determining the free energy of interstitial solid solutions characterized by the fluid-like diffusion of interstitial species. The method presented in this paper overcomes both hurdles by coupling thermodynamic integration with hybrid Monte Carlo algorithms. We validate the accuracy of the method by computing the free energies of iron alloys described by a Lennard-Jones potential. We also showcase its efficiency by determining the phase diagram of the MgO-CaO system, described by a machine-learning interatomic potential. The high efficiencies achieved with this method pave the way to the determination of the free energies of solid solutions with ab initio accuracy. • The combined use of hybrid Monte Carlo and thermodynamic integration methods allows efficient determination of the free energy of non-ideal substitutional solid solutions. • We propose a thermodynamic path for the exact computation of the free energy of superionic interstitial solid solutions without any approximations. • The achieved high efficiency paves the way to determine the free energy of solid solutions with ab initio accuracy. [ABSTRACT FROM AUTHOR]

Astrophysical turbulent flows display an intrinsically multi-scale nature, making their numerical simulation and the subsequent analyses of simulated data a complex problem. In particular, two fundamental steps in the study of turbulent velocity fields are the Helmholtz-Hodge decomposition (compressive+solenoidal; HHD) and the Reynolds decomposition (bulk+turbulent; RD). These problems are relatively simple to perform numerically for uniformly-sampled data, such as the one emerging from Eulerian, fix-grid simulations; but their computation is remarkably more complex in the case of non-uniformly sampled data, such as the one stemming from particle-based or meshless simulations. In this paper, we describe, implement and test vortex-p , a publicly available tool evolved from the vortex code, to perform both these decompositions upon the velocity fields of particle-based simulations, either from smoothed particle hydrodynamics (SPH), moving-mesh or meshless codes. The algorithm relies on the creation of an ad-hoc adaptive mesh refinement (AMR) set of grids, on which the input velocity field is represented. HHD is then addressed by means of elliptic solvers, while for the RD we adapt an iterative, multi-scale filter. We perform a series of idealised tests to assess the accuracy, convergence and scaling of the code. Finally, we present some applications of the code to various SPH and meshless finite-mass (MFM) simulations of galaxy clusters performed with OpenGadget3 , with different resolutions and physics, to showcase the capabilities of the code. [ABSTRACT FROM AUTHOR]

Particle shape plays a major role in the behaviour of most granular systems. This has led to increasing interest in the representation of arbitrarily shaped particles in discrete element method (DEM) simulations. In this paper, we present a simulation approach based on the representation of particle shapes using spherical harmonics where their radii can be calculated in spherical coordinates. An energy-conserving contact model is adopted which is based on the volume of overlap between interacting particles. Contact detection makes use of the bounding spheres of the interacting particles, simplifying its incorporation within a conventional sphere-based DEM code. The volume of overlap and other required quantities are calculated using Gaussian quadrature integration of the spherical cap formed by the bounding spheres. Both the accuracy and the computational cost increase with the number of quadrature points. The algorithm has been implemented as a LAMMPS user package, and verified by means of energy conservation. The performance and parallel scaling of the approach are illustrated, and an observed scaling limitation owing to load imbalance arising from the evaluation of the overlap volume is discussed. Program Title: SH-DEM LAMMPS package CPC Library link to program files: https://doi.org/10.17632/vk6fj6yjtf.1 Developer's repository link: https://github.com/EPCCed/lammps/tree/feature-sh-dem Licensing provisions: GPLv2 Programming language: C++ Nature of problem: Particles are often highly non-spherical. Spherical harmonics provide a natural way to represent complex particle shapes within a discrete element method (DEM) simulation. However, there is no publicly available DEM code which allows particle shapes to be represented using spherical harmonics. Solution method: The SH-DEM package extends the capabilities of LAMMPS so that irregularly shaped particles can be represented using spherical harmonics. The package includes the definition of a new 'shdem' atom style for spherical harmonic particles, a time integration scheme for these particles based on the Velocity Verlet algorithm, algorithms for detecting and evaluating contacts between spherical harmonic particles, evaluation of the contact forces between these particles and rigid walls, and two energy computes for groups of spherical harmonic particles. Additional comments including restrictions and unusual features: The SH-DEM package is applicable only to 3D simulations. In order for a particle to be defined by spherical harmonics, it is required that any line segment drawn from an origin inside the particle crosses the contour of the particle's three-dimensional surface only once. If the 'shdem' atom style is used, the current implementation requires all particles to be defined using this atom style, e.g., mixtures of sphere and shdem atom styles are not permitted. [ABSTRACT FROM AUTHOR]

In this article, we propose a modified Allen–Cahn (AC) equation with a space-dependent interfacial parameter. When numerically solving the AC equation with a constant interfacial parameter over large domains, a substantial number of grid points are essential, which leads to significant computational costs. To effectively resolve this problem, numerous adaptive mesh techniques have been developed and implemented. These methods use locally refined meshes that adaptively track the interfacial positions of the phase field throughout the simulation. However, the data structures for adaptive algorithms are generally complex, and the problems to be solved may involve challenges at multiple scales. In this article, we present a modified AC equation with a mesh size-dependent interfacial parameter on a triangular mesh to efficiently solve multi-scale problems. In the proposed method, a triangular mesh is used, and the interfacial parameter value at a node point is defined as a function of the average length of the edges connected to the node point. The proposed algorithm effectively uses large and small values of the interfacial parameter on coarse and fine meshes, respectively. To demonstrate the efficiency and superior performance of the proposed method, we conduct several representative numerical experiments. The computational results indicate that the proposed interfacial function can adequately evolve the multi-scale phase interfaces without excessive relaxation or freezing of the interfaces. Finally, we provide the main source code for the methodology, including mesh generation as described in this paper, so that interested readers can use it. [ABSTRACT FROM AUTHOR]

In reservoir simulation, the non-isothermal multiphase flow problem introduces the temperature variable to account for thermal effects, simultaneously posing challenges in efficiently solving the nonlinear systems for large-scale simulations. In this paper, we introduce and investigate a family of Schur-complement-based field-split algorithms designed for addressing non-isothermal multiphase flow problems, particularly those characterized by high heterogeneity. This algorithm involves decomposing a large system into smaller, more manageable sub-systems for solving non-isothermal multiphase flow problems with multiple physical fields, which enables parallel computation and makes it suitable for high-performance computing environments. Furthermore, a multilevel Schur-complement preconditioner, which involves applying the Schur-complement technique at each level of the hierarchy by capturing the coupling between different fields and physics, is proposed to enhance the efficiency and robustness of the parallel simulator. Large-scale simulations for both benchmark and realistic problems are conducted on a supercomputer, showcasing the method's efficacy in managing heat diffusion, significantly reducing linear iterations, and demonstrating a good parallel scalability. • Scalable parallel reservoir simulator is proposed for non-isothermal multiphase flow problems. • Multilevel Schur-complement preconditioners are presented under the domain decomposition framework. • Complex non-isothermal reservoir simulations for both benchmark and realistic problems are validated. • The parallel algorithm is efficient and scalable on the Tianhe-2 supercomputer. [ABSTRACT FROM AUTHOR]

Laser plasma instabilities (LPIs) have significant influences on the laser energy deposition efficiency and therefore are important processes in inertial confined fusion (ICF). Numerical simulations play important roles in revealing the complex physics of LPIs. Since LPIs are typically a three wave coupling process, the precise simulations of LPIs with kinetic effects require to resolve the laser period (around one femtosecond) and laser wavelength (less than one micron). In the typical ICF experiments, however, LPIs are involved in a spatial scale of several millimeters and a temporal scale of several nanoseconds. Therefore, the precise kinetic simulations of LPIs in such scales require huge computational resources and are hard to be carried out by present kinetic codes like particle-in-cell (PIC) codes. In this paper, a full wave fluid model of LPIs is constructed and numerically solved by the particle-mesh method, where the plasma is described by macro particles that can move across the mesh grids freely. Based upon this model, a two-dimensional (2D) GPU code named PM2D is developed. The PM2D code can simulate the kinetic effects of LPIs self-consistently as normal PIC codes. Moreover, as the physical model adopted in the PM2D code is specifically constructed for LPIs, the required macro particles per grid in the simulations can be largely reduced and thus overall simulation cost is considerably reduced comparing with PIC codes. More importantly, the numerical noise in the PM2D code is much lower, which makes it more robust than PIC codes in the simulation of LPIs for the long-time scale above 10 picoseconds. After the distributed computing is realized, our PM2D code is able to run on GPU clusters with a total mesh grids up to several billions, which meets the requirements for the simulations of LPIs at ICF experimental scale with reasonable cost. Program Title: PM2D CPC Library link to program files: https://doi.org/10.17632/xscj6vnkkw.1 Licensing provisions: GNU General Public License v3.0. Programming language: C++, CUDA. Nature of problem: Although the large scale simulations of laser plasma instabilities (LPIs) is of great significance for the inertial confinement fusion (ICF), there is still no suitable code to simulate these problems. PM2D code based on a GPU platform provides an effective method to simulate these large scale problems in ICF. Solution method: A fluid model for LPIs is established firstly, which contains wave equations that describe the laser propagating process, electron and ion fluid equations that describe the plasma motions, and a Poisson's equation that describes the electrostatic field induced by charge separation. The wave equation is solved on a rectangular region using absorption boundary conditions on all of four boundaries. The absorption boundary condition on the left boundary is further extended to allow the incidence of driven lasers and absorption of scattering lasers simultaneously. The fluid equations in the physical model are solved by the particle-mesh method, in which the macro particles are driven to move by fluid forces. Since macro particles can move freely within the fixed fluid grids, the PM2D code can capture the kinetic effects self-consistently. The Poisson's equation for the electrostatic field is solved by a Fourier decomposition method in the y direction, which helps to decrease the simulation cost greatly. The PM2D code is developed on a GPU platform base on CUDA toolkit, which largely increase the computational speed. [ABSTRACT FROM AUTHOR]

This contribution presents the key elements of YADE, an extensible open-source framework for dynamic simulations. During the past 19 years, YADE has evolved from "Yet Another Dynamic Engine" to a versatile multiscale and multiphysics solver, counting a large, active, and growing community of users and developers. The computationally intense parts of the source code are written in C++, using flexible object models that allow for easy implementation of new features. The source code is wrapped in Python, equipping the software with an interactive kernel used for rapid and concise scene construction, simulation control, post-processing, and debugging. The project, including documentation and examples, is hosted on https://yade-dem.org , while the source code is freely available on GitLab. Over the last decade, YADE has expanded in terms of capabilities thanks to the contribution of many developers from different fields of expertise, including soil and rock mechanics, chemical engineering, physics, bulk material handling, and mineral processing. The rapid growth of YADE can be attributed to (1) the careful and robust design of the framework core, (2) a continuous integration pipeline with fully embedded thorough tests which are executed upon each merge request, ensuring stable compilation for various operating systems, and (3) user-friendliness, facilitated by the Python interface, detailed documentation, and rigorous user support. In this paper, we review the main features of YADE, highlighting its versatility in terms of applications, its flexibility in terms of code development, as well as recent improvements in terms of computational efficiency. Program Title: YADE - Yet Another Dynamic Engine CPC Library link to program files: https://doi.org/10.17632/n4f5fw97rd.1 Developer's repository link: https://gitlab.com/yade-dev/trunk Licensing provisions: GNU General Public License 2 Programming language: C++, Python Nature of problem: Numerical simulation of many-particle systems requires accurate models for particle-to-particle interactions, efficient contact detection between objects of various shapes, and robust time integration. In addition, the flow of fluids, thermal effects, as well as other coupled problems in the presence of particles are found in many fundamental and practical applications and they need dedicated computational tools. YADE provides a computational framework to perform such simulations using the discrete element method and multiple extensions of it. Solution method: YADE simulates particulate systems using the Discrete Element Method (DEM) in a flexible platform combining C++ and Python. It provides a large variety of shape and interaction models, an explicit time-integration scheme, and many post-processing tools. YADE features dedicated solvers for both fluid and heat fluxes at the pore scale, and it supports couplings with third-party software such as Escript (finite element method) and OpenFOAM (computational fluid dynamics). • YADE is an extensible open-source software applying the Discrete Element Method. • The C++ source code is wrapped in Python to enhance user-friendliness. • Non-spherical particles can be modeled, including concave and flexible particles. • Coupled multiphase and multiphysics problems can be simulated. • OpenMP and MPI parallelization allows for the efficient simulation of large systems. [ABSTRACT FROM AUTHOR]

From batteries to biology, many important technologies and physical phenomena operate as out-of-equilibrium reactive systems. Accurately modeling the nanoscale dynamics of non-equilibrium reactive systems and how they respond to external stimuli is challenging, especially if both atomistic resolution and large scales (>105 atoms) are required. REACTER is a protocol for modeling chemical reactions during classical molecular dynamics (MD) simulations. Coupling traditional fixed-valence force fields with heuristic reactive MD is advantageous for large-scale simulations of dynamic systems that can include the complex reaction mechanisms common in organic chemistry. This paper details the current features of the LAMMPS implementation of REACTER, known as fix bond/react , and surveys recent applications of the protocol in a variety of fields, including photopolymers, high-performance composites, and membranes. Conceived as a tool for modeling polymerization processes, the scope of REACTER is expanding as it is applied to new materials and supporting features are implemented. Three new case studies are presented that highlight the capabilities of REACTER, including modeling hierarchical materials, the mechanics of molecular machines, and large-scale dynamics of heterogeneous catalysis. [ABSTRACT FROM AUTHOR]

We describe legume, a free electromagnetic solver that implements the guided-mode expansion method for patterned multilayer waveguides, or photonic crystal slabs. legume has a built-in tool for automatic differentiation, which makes it suitable for the inverse design of photonic crystal structures with desired physical properties. Compared to a previous version of the method (M. Minkov et al., 2020 [12]), here we introduce several new features of the code, we discuss additional technical aspects of the method and its numerical implementation. The novel features that are treated in this paper include: (i) the separation of modes according to their mirror symmetry with respect to a vertical symmetry plane of the photonic structure, (ii) the problem of polarization mixing in coupling to far-field radiation modes, and (iii) the description of active two-dimensional layers through a suitably formulated radiation-matter coupling Hamiltonian, allowing to describe the physics of both weakly and strongly coupled exciton-photon modes, the latter leading to photonic crystal polariton eigenmodes. Detailed and direct comparisons with rigorous coupled-wave analysis simulations are used to test the accuracy of the method and the numerical efficiency of the code. These newly added features of the legume code significantly increase the prospective applications of guided-mode expansion, making it a very practical and versatile tool enabling the design of advanced photonic structures and the description of radiation-matter interaction. Program Title: legume CPC Library link to program files: https://doi.org/10.17632/kf3cwknx4d.1 Developer's repository link: https://github.com/fancompute/legume Licensing provisions: MIT Programming language: Python Nature of problem: Dispersion and radiative losses of photonic eigenmodes in patterned multilayer waveguides/photonic crystal slabs/periodic metasurfaces. Interaction of photonic modes with exciton resonances leading to exciton-polaritons. Inverse design by optimization of the parameters. Solution method: Finite-basis expansion using a basis of guided modes of an effective homogeneous waveguide, perturbation theory to describe coupling with far-field radiation. Quantum theory of excitons, photons and their interaction to describe the occurrence of exciton-polaritons. Automatic differentiation via Autograd to implement inverse design. In this upgraded version of the legume code we implement symmetrization with respect to a vertical mirror plane and light-matter interaction for exciton-polaritons. Inverse design has been described previously, here we focus on the new features and applications of the code. • Guided-mode expansion for photonic crystal is released with new features. • Use of mirror symmetries allows describing polarization mixing effects. • Quantum treatment of photons and 2D excitons leads to photonic crystal polaritons. • The code allows for automatic differentiation and inverse design. • Various examples, benchmarks, and full documentation are included. [ABSTRACT FROM AUTHOR]

This paper presents OpenFPCI, a framework for coupling the C++ toolbox OpenFOAM-Extend, a computational fluid dynamics package, with the general purpose finite element package ParaFEM, written in Fortran and used to solve structural mechanics problems. The coupling of these two open source and scalable toolboxes, facilitates the use of high performance computing resources for the solution of fluid–structure interaction problems. The framework uses a master–slave approach, with OpenFOAM-Extend acting as the master and calling OpenFPCI plugins. The plugins are composed of a series of subroutines used to initialise and solve a specific engineering problem and make use of ParaFEM's highly parallel implementation. The plugins are wrapped by C constructs such that OpenFOAM-Extend can call these Fortran subroutines consistently and when the solution from ParaFEM is required. Each plugin solves a different solid mechanics problem, with the current features including the deformation of a linear-elastic structure undergoing small strain and the deformation of a St. Venant–Kirchhoff material. Throughout this paper the focus will lie on the large strain plugin, considering the implementation and its validation for a benchmark problem, along with assessment of parallel capabilities, which are shown to scale to three thousand cores. This paper will be of interest to OpenFOAM and ParaFEM practitioners looking to utilise multiphysics simulations for their research, along with researchers looking to integrate fluid–structure interaction into their studies. Program Title: OpenFPCI Program Files doi: http://dx.doi.org/10.17632/ntprzxk477.1 Licensing provisions: BSD 2-Clause Programming language: Fortran, C and C++ External libraries: OpenFOAM and ParaFEM Supplementary material: Example test cases are available within the OpenFPCI repository. Nature of problem: OpenFPCI was developed to solve computationally expensive fluid structure interaction problems by running on high performance computing systems. The framework was designed to enable the coupling of advanced ParaFEM capabilities to OpenFOAM-Extend. Solution method: OpenFOAM-Extend uses the classic Arbitrary Lagrangian–Eulerian formulation of the Navier–Stokes equations to deal with moving boundaries. The moving boundary is defined by using an OpenFPCI plugin, using ParaFEM's libraries, to solve the deformation of the adjoining structure. [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]

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]

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]