dataesr/scientific-paragraphs-categorization huggingface dataset:
An advantage of LiDAR is its ability to adapt to changes in light, which is a strong disadvantage for imaging. As a consequence, the two types of sensors must be used in a complementary way. In conclusion, SLS-Fusion is an effective obstacle detection solution for low and high cost LiDAR when combined with a stereo camera; an optimal cost-effective solution is achieved with the most economical four-beam LiDAR component. To better generalize the SLS-Fusion model and find the optimal balance between obstacle detection performance and the cost of the LiDAR component, it is desirable to test the model on various datasets and environments, such as waymo  [55] , nuScenes  [56] , or argoverse2  [57].
The normality of residuals was veri ed by QQ plots for both ANOVA tests. All generalized linear models integrated multiple comparisons if justi ed, adjusted with a Bonferroni correction. The time comparison of each step between astronauts and the surgical control was performed with non-parametric two-tailed Mann-Whitney tests because of the small number of samples. The level of signi cance was always set to 0. 05 in order to reject the null hypothesis. All statistics were performed using SPSS software (V. 27, IBM SPSS, Inc. , Chicago, IL, USA).
Declarations Tables  Table 1. Descriptive analysis of three different parameters: safe zones respected, steps respected and total surgical time (blue background). Quantitative variables were analyzed in terms of central tendency (mean and median) and dispersion by the range (Min-max). Some meaningful sub-criteria depending on those main three parameters are also mentioned and described (white background). Descriptive data from astronauts are subdivided according to their knowledge group (A) and their learning conditions (B) (both in bold green). Times are expressed in minutes. n: sample size. EVA: extravehicular activity. Table  2. Poisson regressions testing model effects. Different dependent variables included respecting safe zones (a) and steps (b). df: degree of freedom. Table  3. One-way ANOVA test for repeated measures determining a difference between steps within astronauts' group (a).
Acknowledgements The authors would like to deeply thank  Dr. Shannon Rupert  as well as the  Mars Desert Research Station committee  and the  Mars Society  to welcome the crew in the Utah desert for the simulation and for the opportunity to execute this research in a Mars analogue environment. This work was supported by a F. S. R. Fund  ( « Fonds Spéciaux de Recherche », Belgium , Ref. ADi/16568. 2021 ), a  « Student Angel Fund »  ( Ref. 304907648 val-31. 05. ), both granted by M. A. R. S. UCLouvain crew 2022 and a F. N. R. S. Aspirant Fund granted by  Dr. Julie Manon  ( « Fonds National de la Recherche Scienti que » , Application  ID 40004991 , Belgium ,). The authors also want to thank  Kouamé Jean-Eric Kouassi  for his PhD thesis about the creation of the new EZExFix as well as Lies Fievé and  Christine de Ville de Goyet  for their help to create arti cial broken legs.
Context. The exascale super-computers becoming available rely on hybrid energy-efficient architectures that involve an accelerator such as a graphics processing unit (GPU). Leveraging the computational power of these machines often means a significant rewrite of the numerical tools each time a new architecture becomes available. Aims. We present IDEFIX, a new code for astrophysical flows that relies on the KOKKOS meta-programming library to guarantee performance portability on a wide variety of architectures while keeping the code as simple as possible to the user. Methods. IDEFIX is based on a Godunov finite-volume method that solves the nonrelativistic hydrodynamical (HD) and magnetohydrodynamical (MHD) equations on various grid geometries. IDEFIX includes a large choice of solvers and several additional modules (constrained transport, orbital advection, nonideal MHD), allowing users to address complex astrophysical problems.
Results. IDEFIX has been successfully tested on Intel and AMD CPUs (up to 131 072 CPU cores on Irene-Rome at TGCC) as well as NVidia and AMD GPUs (up to 1024 GPUs on Adastra at CINES). IDEFIX achieves more than 10 8 cell s -1 in MHD on a single NVidia V100 GPU and 3 × 10 11 cell s -1 on 256 Adastra nodes (1024 GPUs) with 95% parallelization efficiency (compared to single node). For the same problem, IDEFIX is up to six times more energy efficient on GPUs compared to Intel Cascade Lake CPUs. Conclusions. IDEFIX is now a mature exascale-ready open-source code that can be used on a large variety of astrophysical and fluid dynamics applications.
In this approach, each GPU is made of thousands of cores all working synchronously following the single instruction multiple data (SIMD) paradigm. This change in hardware architecture means that codes should at the very least be ported to these new architectures. Making things even more complicated, each hardware manufacturer tends to push its own programming language or library for its own hardware, often as an extension of Fortran or C (NVidia Cuda, AMD HIP Rocm or Apple Metal to name a few). This situation has a dramatic impact on the numerical astrophysics community. It is already a long process to write a new code, but support and maintenance are often scarce because of the limited staff available, and the low recognition of support activities. It is therefore almost impossible to develop and maintain n versions of a code for n architecture variants given the human resources available.
Nevertheless, our community must find ways to exploit these architectures as they will dominate in the future, not only in exascale machines but also in university clusters because of the constraints imposed by energy sobriety. To address some of these issues, we have developed a new code based on a high-order Godunov scheme that relies on the KOKKOS  (Trott et al. 2022)  metaprogramming library. This allows us to exploit a performance-portability approach, where a single source code can be compiled for a large variety of target architectures, with minimal impact on performance. While our original intention was to port the PLUTO code, we thought it more efficient in the long run to write a code from scratch using modern C++. This allowed us to leverage class encapsulation, polymorphism, exception handling, and C++ containers, which are all absent from the C standard.
(  3 ), where η O is the Ohmic diffusivity, J ≡ ∇ × B is the electrical current, x H is the Hall parameter, and x AD is the ambipolar diffusion parameter. This set of equations is completed by the total energy Eq. (  4 ) where E is the total energy density E = e + ρv 2 2 + B 2 2 , (6) with e being the internal energy density, and κ the thermal diffusion coefficient (assumed to be a scalar). We note that IDEFIX does not assume any explicit physical units. The user is free to choose the physical units depending on the problem at hand, keeping in mind that the equations effectively solved by the code are the ones shown above.
Method of solution This set of conservative equations can be reformulated using a generalized vector of conserved quantities U = (ρ, ρu, B, E) as ∂ t U + ∇ • F = S , ( 7 ) where F is the flux of conserved quantity U, and S is a source term that cannot be included in the divergence term. IDEFIX is fundamentally a Godunov-type finite-volume code designed to model astrophysical plasmas. Hence, IDEFIX primarily evolves the cell-averaged conserved quantities ⟨U⟩, which are computed using the face-and time-averaged fluxes ⟨F⟩  (Toro 2009 ). While we omit the ⟨ ⟩ symbol in the remainder of the manuscript for simplicity, this distinction should be kept in mind. The algorithm is relatively standard and follows the reconstruct-solve-average (RSA) approach similar to other codes available, such as PLUTO, ATHENA, RAMSES, and NIRVANA to name a few.
The implementation design of this algorithm in IDEFIX is intentionally close to that of the PLUTO code to simplify the portability of physical setups from one code to the other (see Sect. 3. 2). Therefore, we do not go into the details of the algorithm, which may be found in the papers mentioned above, but instead focus on the main stages of the algorithms, and the differences with PLUTO. The full algorithm with its various steps and loops is represented graphically in Fig. 1  for reference.
This can be encountered for particularly long simulations running for billions of time steps, and is even more prevalent when a Runge-Kutta-Legendre super-time-stepping scheme is used in conjunction with CT (see Sect. 2. 8). Hence, IDEFIX allows the user to split the induction equation into two parts: ∂ t A = -E, (9) B = ∇ × A. ( 10 ) By defining the vector potential A on cell edges, the resulting algorithm is mathematically equivalent to the original CT algorithm. However, it prevents roundoff errors from accumulating in ∇ • B, guaranteeing that the solenoidal condition is always satisfied, even at late times. The only drawback of this vector potential approach is the extra cost of storing A in memory, and the need to code an initial condition for A instead of B. As our gauge choice is so that A = E dt, there is a possibility of overflowing the vector potential in physical problems where a large-scale constant EMF is present.
Grid and geometry IDEFIX can run problems in Cartesian, polar/cylindrical, and spherical geometry. In all of these geometries, the grid is rectilinear, but its spacing may be parameterized as piecewise functions of coordinates. While this approach is clearly not as flexible as adaptive mesh refinement, it allows refinement around regions of interest at a reduced computational cost and code complexity. In polar and spherical geometry, we choose the conserved quantity in the azimuthal direction to be the vertical component of the angular momentum. This guarantees the conservation of angular momentum to machine precision. Great care has been taken for spherical domains extending up to the axis. A special "axis" boundary condition is provided, which guarantees regularity of solutions around the axis, following  Zhu & Stone (2018).
When enabled, the RKL scheme directly calls the same routines, which are used to compute the parabolic terms in the main time integrator, so that no code is duplicated. Finally, in order to retain global second accuracy in time, the RKL stages are called alternatively before and after the main time integrator at each integration cycle. While testing the RKL scheme for Ohmic and ambipolar diffusions, we noted that the roundoff error on ∇ • B tends to accumulate rapidly: while the standard explicit time integrator yields ∇ • B = O( √ n), with n the number of integration cycles, we find ∇ • B = O(n) with the RKL scheme. This issue can lead to relatively large values of ∇ • B for long simulations, which may become problematic. Hence, it is recommended to use the vector potential formulation of the induction Eq.
Implementation 3. 1. Performance portability using the KOKKOS library IDEFIX was designed with performance portability in mind, which means that a single source code can be compiled on a wide variety of target architectures, with excellent performance being achieved on each of them. To this end, IDEFIX uses the KOKKOS library  (Trott et al. 2022). KOKKOS sources are bundled as a git submodule by IDEFIX and are compiled alongside it. Hence, IDEFIX can be compiled and run out of the box. Technically speaking, IDEFIX always assumes it is running on a machine that consists of a host and a device. The host is the CPU on which the code is launched, while the device can be any valid KOKKOS target: CPU, GPU, and so on. In special cases where no supported target is detected, the device code will be compiled as a host code, allowing IDEFIX to run seamlessly on systems without accelerators with very little overhead.
Setup portability from PLUTO The interface of IDEFIX is very close to that of PLUTO. Parameter files follow the same format and use identical keywords when possible. Variable names (grid variables, hydro variables), and several preprocessor macros have been kept to simplify the portability of PLUTO setups to IDEFIX as our research group has been using and developing physics setups for PLUTO for more than a decade. Similarly, outputs (VTK 3  files) follow the same format and variable naming convention as PLUTO. However, we note that restart dumps are not compatible between the two codes. In addition, while PLUTO relies on C arrays, IDEFIX is based on C++ objects and uses C++ containers. This allows for more flexibility and simpler development of physics modules.
Inputs and outputs IDEFIX uses a text input file -following the input file format of PLUTO -that is read at runtime. Most of the code options (time integrator, Riemann solvers, physical modules) are enabled in this input file. IDEFIX outputs come in two formats: an internal dump file format that contains the raw data required to restart a simulation, and the VTK file format, which is used for visualization and analysis. The user can easily add new fields computed on the fly in IDEFIX VTK outputs to simplify visualization and post-processing. The VTK outputs produced by IDEFIX can be directly loaded in Paraview or Visit  (Childs et al. 2012 ) for instantaneous visualization. Python routines are provided with the code to load IDEFIX VTK and dump files into numpy arrays. Both VTK and dump files can also be analyzed with the yt Python library  (Turk et al.
2011 ) with the yt_idefix extension 4. We note that the VTK file format imposes that data be written in single precision and only contain cell-averaged quantities (reconstructed from face-averaged quantities when storing B). This reduces storage requirements but also prevents the code from restarting from VTK files, hence the necessity for dump files. Internally, IDEFIX relies on MPI I/O routines to write all of the data from all of the MPI processes to a single file (either VTK or dump). Therefore, no external I/O library is required to compile and run IDEFIX. We find this property useful when moving setups on different machines as it greatly simplifies the portability.
(2007)  to set up the problem, with a smooth transition for the angular velocity and density between the rotor and the ambient medium. In addition, we use two versions of the test in Cartesian and polar geometries to check the validity of our curvilinear implementation. The resulting tests are presented in Fig. 9. The Cartesian test is computed on a 512 2 grid with a Roe Riemann solver, RK2 time integrator, a CFL parameter set to 0. 2, and the E c EMF reconstruction scheme. The polar test is computed on a N R × N φ = 256 × 1024 grid extending from A9, page 9 of 17. Convergence rate of the four linear wave types for various reconstruction techniques using the HLLD Riemann solver. The code exhibits a slightly higher convergence rate than second order for LimO3. However, we highlight the lack of convergence at high resolution for PPM, which is also observed in ATHENA++ (dashed lines).
13 ) using FARGO3D (Benítez-Llambay & Masset 2016) as a reference. The agreement between the two codes is excellent. We notice that FARGO3D produces more small-scale waves between the main spiral shocks launched from the planet. Ambipolar diffusion isothermal C-shock. This test consists of a "shock" (which is actually continuous) and is driven by ambipolar diffusion. We follow Mac  Low et al. (1995)  and use a stationary shock with an upstream Mach number M = 50, an Alfvénic Mach Number A = 10, and an inclination angle   Balsara & Spicer (1999) , on the left using a Cartesian geometry and on the right using a polar geometry. We note the close resemblance of the iso-surfaces, indicating the excellent behaviour of the code in these two geometries. of θ = π/4 (Fig. 14 ). The characteristic length of the shock is L ≡ η A /v A where η AD ≡ x AD B 2 is the ambipolar diffusivity and v A is the Alfvén speed.
74885 0. 6 B z 0 0 2018 6 ). The results are presented in Fig. 15. We find the solution computed with IDEFIX to be in excellent agreement with the analytical solution. The relative error decreases by a factor of 3-4 by doubling the resolution, which indicates a convergence rate that is slightly lower than second order for this test, which is due to the high diffusivity induced by grid-scale whistler waves. We note that it is possible to strictly recover the second-order convergence using the LimO3 or PPM reconstruction schemes (not shown). magneto-rotational instability (MRI) in the context of accretiondisk physics  (Balbus & Hawley 1991; Hawley et al. 1995). We implemented the shearing box specific shear-periodic boundary conditions in IDEFIX, both in hydro and MHD. This module is also compatible with the orbital advection module, allowing a significant speedup in large boxes, where the shear flow is largely supersonic.
Comparison between FARGO3D and IDEFIX for the density deviation map in the planet-disk interaction problem with orbital advection enabled at t = 4 planetary orbits. We note the presence of small wave-like patterns in FARGO3D that are absent from IDEFIX. n r (t) = 3/2Ωt ∼ 15, so that the wave is effectively resolved by about 17 points. Similar results were obtained with the ATHENA code using PPM reconstruction  (Balbus & Hawley 2006) , and so they are not necessarily surprising, but illustrate the difficulty of following shearing waves on long timescales, even at relatively high resolutions.
Performance In order to test the performances of the code on CPUs and on GPUs, we used an extension of the Orszag Tang problem in three dimensions. We consider a periodic Cartesian domain of size L x = L y = L z = 1 with constant initial pressure P = 5/(12π) and density ρ = 25/(36π). We add a velocity perturbation u =sin(2πy)e x + [sin(2πx) + cos(2πz)]e y + cos(2πx)e z and a magnetic perturbation B = -B 0 sin(2πy)e x + B 0 sin(4πx)e y + B 0 [cos(2πx) + sin(2πy)]e z with B 0 = 1/ √ 4π, both of which are initially divergence free. This physical setup is run until t = 1. 0 and the result is compared to that obtained with PLUTO to check for convergence. The test is executed for both codes with the HLLD Riemann solver, second-order (linear) reconstruction, the E c EMF reconstruction scheme, and RK2 time-stepping in double precision.
We ran this test problem on Intel Cascade Lake CPUs and NVidia V100 GPUs in the Jean Zay cluster hosted by IDRIS (CNRS); on AMD Rome CPUs in the Irene Rome cluster hosted by TGCC (CEA); and on AMD Mi250 GPUs in the Adastra cluster hosted by CINES. The details of the configuration and compilation options are given in Table  3. We note that we use the Intel compiler on CPUs, which allows us to benefit from auto-vectorization. An analysis of the executable file produced with Intel Vtune shows that more than 86% of the integration loops are being automatically vectorized with avx2 instructions. We first present the single node performances in Table  4  along with an estimation of the energy efficiency. The code typically performs better than 10 Mcell s -1 on a single Intel 20-core CPU and 20 Mcell s -1 on a single AMD 64-core CPU, which is similar to other CPU codes available.
When we compare Intel CSL nodes to GPU nodes, we find an acceleration of a factor 19. 3 on NVidia V100 and 49. 6 on AMD Mi250, demonstrating that performance portability is extremely good. We then analyzed the parallelism efficiency of the code by running the same problem on up to 512 NVidia GPUs (128 nodes), 1024 AMD GPUs (256 nodes), and 131 072 CPU cores (1024 nodes). Measured performances are presented in Fig. 18  for various resolutions. On CPUs, we find that scaling and overall performance are very close to those of PLUTO. This is not surprising as the algorithms are similar. However, we note that IDEFIX performs slightly better beyond 10 000 cores, which is probably explained by the packing/unpacking strategy when exchanging boundary elements used in IDEFIX (see Sect. 3. 4). On GPUs, IDEFIX exhibits an excellent scaling with above 80% parallelization efficiency with subdomains of 256 3 on Nvidia V100 (Jean Zay), and remarkably above 95% on AMD Mi250 (Adastra), probably thanks to the AMD Slingshot interconnect used in the latter.
Discussions and conclusions In this paper, we present IDEFIX, a new performance-portable code for compressible magnetised fluid dynamics. The code follows a standard finite-volume high-order Godunov approach, where inter-cell fluxes are computed by dedicated Riemann solvers. For MHD problems, IDEFIX uses constraint transport to evolve the magnetic field components on cell faces, satisfying the   & Hawley (2006). The analytical solution is the dashed line, while the IDEFIX solution computed with 256 3 points is shown as a plain line. time-stepping for parabolic terms (viscosity, thermal, ambipolar, and ohmic diffusion). A conservative orbital-advection scheme (Fargo-type) is also implemented to accelerate the computation of rotation-dominated flows. The code is parallelized using domain decomposition and the MPI library.
Finally, several additional physical modules are currently in development for IDEFIX, including a multigeometry self-gravity solver and a particle-in-cell module, which will be discussed in dedicated papers. All features in IDEFIX are implemented in a performanceportable way, meaning that they are available for every target architecture supported by KOKKOS (CPU or GPU). In contrast to other codes where only a fraction of an algorithm is running on a GPU, the philosophy behind IDEFIX is that all data structures and loops live in device space, while the host system is only responsible for input and output operations. Benchmarks show that IDEFIX performs similarly to PLUTO and other similar Godunov codes on CPU architectures, with an efficiency of above 80% on up to 131 072 CPU cores. On GPU, the speed-up is significant (an AMD Mi250 node being 50 times faster than an Intel Cascade Lake CPU node), and the code is also significantly more energy efficient, that is, by up to a factor of about 6, comparing Intel Cascade Lake CPUs to AMD Mi 250 GPUs.
However, these performances are only achievable for sufficiently large subdomains (typically more than 64 3 ), which is an intrinsic limitation of GPU architectures. Finally, IDEFIX reaches a peak performance of 3 × 10 11 cell s -1 in MHD on AdAstra at Cines (1024 GPUs), with a parallelization efficiency of above 95%. IDEFIX is not the only code that proposes performance portability. K-ATHENA  (Grete et al. 2021 ) is similar to IDEFIX in terms of algorithm and also uses KOKKOS, but is limited to Cartesian and ideal-MHD problems. For these problems, the performances of IDEFIX and K-ATHENA are quantitatively similar, but IDEFIX allows the user to address more complex physics. PARTHENON  (Grete et    framework on which several Godunov codes are being developed, including PKATHENA, which would be similar to IDEFIX.
The performance of PARTHENON has only been reported for hydro problems, and is similar to that of IDEFIX. However, we note that PARTHENON provides an AMR framework that is not present in IDEFIX. It is not clear at this stage whether PARTHENON will support non-Cartesian geometry and all of the features present in IDEFIX in the future, but IDEFIX exhibits some clear advantages at the moment. The current development of IDEFIX is tracked on a private git repository, from which a public version 7 is forked. The public version is progressively enriched by new modules once they are published and is distributed under a CECILL license (French Open Source License). IDEFIX development is achieved in a collaborative way with modern versioning tools (git). The code master branches (public and private) are validated daily for CPU and GPU targets on a large number of tests (including the ones presented in this paper).