Abstract: We present a novel methodology based on Physics-Informed Neural Networks (PINNs) for solving systems of partial differential equations admitting discontinuous solutions. Our method, called Gradient-Annihilated PINNs (GA-PINNs), introduces a modified loss function that forces the model to partially ignore high-gradients in the physical variables, achieved by introducing a suitable weighting function. The method relies on a set of hyperparameters that control how gradients are treated in the physical loss. The performance of our methodology is demonstrated by solving Riemann problems in special relativistic hydrodynamics, extending earlier studies with PINNs in the context of the classical Euler equations. The solutions obtained with the GA-PINN model correctly describe the propagation speeds of discontinuities and sharply capture the associated jumps. We use the relative l(2) error to compare our results with the exact solution of special relativistic Riemann problems, used as the reference ''ground truth'', and with the corresponding error obtained with a second-order, central, shock-capturing scheme. In all problems investigated, the accuracy reached by the GA-PINN model is comparable to that obtained with a shock-capturing scheme, achieving a performance superior to that of the baseline PINN algorithm in general. An additional benefit worth stressing is that our PINN-based approach sidesteps the costly recovery of the primitive variables from the state vector of conserved variables, a well-known drawback of grid-based solutions of the relativistic hydrodynamics equations. Due to its inherent generality and its ability to handle steep gradients, the GA-PINN methodology discussed in this paper could be a valuable tool to model relativistic flows in astrophysics and particle physics, characterized by the prevalence of discontinuous solutions.

Abstract: We describe the main features of a new and updated version of the program PArthENoPE, which computes the abundances of light elements produced during Big Bang Nucleosynthesis. As the previous first release in 2008, the new one, PArthENoPE2.0, is publicly available and distributed from the code site, http://parthenope.na.infn.it . Apart from minor changes, which will be also detailed, the main improvements are as follows. The powerful, but not freely accessible, NAG routines have been substituted by ODEPACK libraries, without any significant loss in precision. Moreover, we have developed a Graphical User Interface (GUI) which allows a friendly use of the code and a simpler implementation of running for grids of input parameters. New Version program summary Program Title: PArthENoPE2.0 Program Files doi : http://dx.doi.org/10.17632/wvgr7d8yt9.1 Licensing provisions: GPLv3 Programming language: Fortran 77 and Python Supplementary material: User Manual available on the web page http://parthenope.na.infn.it Journal reference of previous version: Comput. Phys. Commun. 178 (2008) 956 971 Does the new version supersede the previous version?: Yes Reasons for the new version: Make the code more versatile and user friendly Summary of revisions: (1) Publicly available libraries (2) GUI for configuration Nature of problem: Computation of yields of light elements synthesized in the primordial universe Solution method: Livermore Solver for Ordinary Differential Equations (LSODE) for stiff and nonstiff systems

Abstract: The KM3NeT Collaboration runs a multi-site neutrino observatory in the Mediterranean Sea. Water Cherenkov particle detectors, deep in the sea and far off the coasts of France and Italy, are already taking data while incremental construction progresses. Data Acquisition Control software is operating off-shore detectors as well as testing and qualification stations for their components. The software, named Control Unit, is highly modular. It can undergo upgrades and reconfiguration with the acquisition running. Interplay with the central database of the Collaboration is obtained in a way that allows for data taking even if Internet links fail. In order to simplify the management of computing resources in the long term, and to cope with possible hardware failures of one or more computers, the KM3NeT Control Unit software features a custom dynamic resource provisioning and failover technology, which is especially important for ensuring continuity in case of rare transient events in multi-messenger astronomy. The software architecture relies on ubiquitous tools and broadly adopted technologies and has been successfully tested on several operating systems.

Abstract: Monte Carlo methods provide detailed and accurate results for radiation transport simulations. Unfortunately, the high computational cost of these methods limits its usage in real-time applications. Moreover, existing computer codes do not provide a methodology for adapting these kinds of simulations to specific problems without advanced knowledge of the corresponding code system, and this restricts their applicability. To help solve these current limitations, we present PenRed, a general-purpose, standalone, extensible and modular framework code based on PENELOPE for parallel Monte Carlo simulations of electron-photon transport through matter. It has been implemented in C++ programming language and takes advantage of modern object-oriented technologies. In addition, PenRed offers the capability to read and process DICOM images as well as to construct and simulate image-based voxelized geometries, so as to facilitate its usage in medical applications. Our framework has been successfully verified against the original PENELOPE Fortran code. Furthermore, the implemented parallelism has been tested showing a significant improvement in the simulation time without any loss in precision of results. Program summary Program title: PenRed: Parallel Engine for Radiation Energy Deposition. CPC Library link to program files: https://doi .org /10 .17632/rkw6tvtngy.1 Licensing provision: GNU Affero General Public License (AGPL). Programming language: C++ standard 2011. Nature of problem: Monte Carlo simulations usually require a huge amount of computation time to achieve low statistical uncertainties. In addition, many applications necessitate particular characteristics or the extraction of specific quantities from the simulation. However, most available Monte Carlo codes do not provide an efficient parallel and truly modular structure which allows users to easily customise their code to suit their needs without an in-depth knowledge of the code system. Solution method: PenRed is a fully parallel, modular and customizable framework for Monte Carlo simulations of the passage of radiation through matter. It is based on the PENELOPE [1] code system, from which inherits its unique physics models and tracking algorithms for charged particles. PenRed has been coded in C++ following an object-oriented programming paradigm restricted to the C++11 standard. Our engine implements parallelism via a double approach: on the one hand, by using standard C++ threads for shared memory, improving the access and usage of the memory, and, on the other hand, via the MPI standard for distributed memory infrastructures. Notice that both kinds of parallelism can be combined together in the same simulation. Moreover, both threads and MPI processes, can be balanced using the builtin load balance system (RUPER-LB [30]) to maximise the performance on heterogeneous infrastructures. In addition, PenRed provides a modular structure with methods designed to easily extend its functionality. Thus, users can create their own independent modules to adapt our engine to their needs without changing the original modules. Furthermore, user extensions will take advantage of the builtin parallelism without any extra effort or knowledge of parallel programming. Additional comments including restrictions and unusual features: PenRed has been compiled in linux systems withg++ of GCC versions 4.8.5, 7.3.1, 8.3.1 and 9; clang version 3.4.2 and intel C++ compiler (icc) version 19.0.5.281. Since it is a C++11-standard compliant code, PenRed should be able to compile with any compiler with C++11 support. In addition, if the code is compiled without MPI support, it does not require any non standard library. To enable MPI capabilities, the user needs to install whatever available MPI implementation, such as openMPI [24] or mpich [25], which can be found in the repositories of any linux distribution. Finally, to provide DICOM processing support, PenRed can be optionally compiled using the dicom toolkit (dcmtk) [32] library. Thus, PenRed has only two optional dependencies, an MPI implementation and the dcmtk library.

Abstract: This paper describes CosmoGattice, a modern package for lattice simulations of the dynamics of interacting scalar and gauge fields in an expanding universe. CosmoGattice incorporates a series of features that makes it very versatile and powerful: i) it is written in C++ fully exploiting the object oriented programming paradigm, with a modular structure and a clear separation between the physics and the technical details, ii) it is MPI-based and uses a discrete Fourier transform parallelized in multiple spatial dimensions, which makes it specially appropriate for probing scenarios with well -separated scales, running very high resolution simulations, or simply very long ones, iii) it introduces its own symbolic language, defining field variables and operations over them, so that one can introduce differential equations and operators in a manner as close as possible to the continuum, iv) it includes a library of numerical algorithms, ranging from O(delta t(2)) to O(delta t(10)) methods, suitable for simulating global and gauge theories in an expanding grid, including the case of 'self-consistent' expansion sourced by the fields themselves. Relevant observables are provided for each algorithm (e.g. energy densities, field spectra, lattice snapshots) and we note that, remarkably, all our algorithms for gauge theories (Abelian or non-Abelian) always respect the Gauss constraint to machine precision. Program summary Program Title:: CosmoGattice CPC Library link to program files: https://doi .org /10 .17632 /44vr5xssc6 .1 Developer's repository link: http://github .com /cosmolattice /cosmolattice Licensing provisions: MIT Programming language: C++, MPI Nature of problem: The phenomenology of high energy physics in the early universe is typically characterized by non-linear dynamics, which cannot be captured accurately with analytical techniques. In order to fully understand the non-linearities developed in a given scenario, one needs to carry out lattice simulations. A number of public packages for lattice simulations have appeared over the years, but most of them are only capable of simulating scalar fields. However, realistic models of particle physics do contain other kind of field species, such as (Abelian or non-Abelian) gauge fields, whose non-linear dynamics can also play a relevant role in the early universe. Tensor modes representing gravitational waves are also naturally expected in many scenarios. Solution method: CosmoGattice represents a modern code for lattice simulations of scalar-gauge field theories in an expanding universe. It allows for the simulation of the evolution of interacting (singlet) scalar fields, charged scalar fields under U(1) and/or SU(2) gauge groups, and the corresponding associated Abelian and/or non-Abelian gauge fields. From version 1.1 onward, CosmoGattice also allows to simulate the production of gravitational waves. Simulations can be done either in a flat space-time background, or in a homogeneous and isotropic (spatially flat) expanding FLRW background. CosmoGattice provides symplectic integrators, with accuracy ranging from O (delta t(2)) up to O(delta t(10)), to simuate the non-linear dynamics of the appropriate fields in comoving three-dimensional lattices. The code is parallelized with MPI, and uses a discrete Fourier Transform parallelized in multiple spatial dimensions, which makes it a very powerful code for probing physical problems with well-separated scales. Moreover, the code has been designed as a `platform' to implement any system of dynamical equations suitable for discretization on a lattice.