dataesr/scientific-paragraphs-categorization huggingface dataset:
Numerical codes using the lattice Boltzmann methods (LBM) for simulating one-or two-phase flows are widely compiled and run on graphical process units. However, those computational units necessitate to re-write the program by using a lowlevel language which is suited to those architectures (e. g. CUDA for GPU NVIDIA or OpenCL). In this paper we focus our effort on the performance portability of LBM i. e. the possibility of writing LB algorithms with a high-level of abstraction while remaining efficient on a wide range of architectures such as multicores x86, GPU NVIDIA , ARM, and so on. For such a purpose, implementation of LBM is carried out by developing a unique code, LBM saclay written in the C++ language, coupled with the Kokkos library for performance portability in the context of High Performance Computing.
g. CUDA for GPU NVIDIA or OpenCL). In this paper we focus our effort on the performance portability of LBM i. e. the possibility of writing LBM algorithms with a high-level of abstraction, but by remaining efficient on a wide range of architectures such as multicores x86, GPU NVIDIA , ARM, and so on. The issue of performance portability has already been studied and implementation of numerical algorithms running on various architectures (GPU and so on) can be done by directive approaches (mostly OpenMP or OpenACC). Directivebased parallel programming solutions consist in decorating source code with comments that are interpreted by the compiler to derive the actual parallel code. They are useful when porting a legacy simulation code with a large number of lines, for which it is not reasonable to rewrite it from scratch.
However, those programming models deal with computational patterns (for loops, reduction loops,. ) and do not provide tools for data or memory containers. Here we present an application of a more promising approach that uses a library-based solution which offers high-level abstract programming concepts and hardware agnostic solution for a better integration into C++ codes. Among libraries sharing the same goal of performance portability (like RAJA or SYCL), the Kokkos library  [9]  is used for simulating two-phase flows with LBM. Kokkos implements a programming model in C++ for writing performance portable applications targeting all major High Performance Computing (HPC) platforms. Programming tools provide abstractions for both parallel execution of code and data management, i. e. they provide memory containers (multidimensional arrays) where the actual memory layout will be chosen by the library during compilation.
g. [35]  without LBM and  [36]  with LBM. In this work the CAC model is chosen for interface tracking in order to eliminate the curvature-driven interface motion which is implicitly contained in the CH equation (see  Section 2). Moreover, the CAC model involves only a second-order derivative and does not require to compute the fourth-order derivative (Laplacian of chemical potential) which appears in the CH equation. In this paper, we take advantage of the simplicity of LBM to develop a new portable code for simulating two phase flows with the coupled Navier-Stokes/conservative Allen-Cahn (NS/CAC) model. The new code, called LBM saclay, targets all major HPC platforms such as multi-GPUs and multi-CPUs. In this paper, we also check the capability of the NS/CAC model to simulate phase change problems in the vicinity of the critical temperature.
Numerical implementation and kernel optimization All LBM schemes of this Section were implemented in a new code called LBM saclay written in C++. The main advantage of this new code is its portability targeting all major HPC platforms and especially those based on GPU-and CPU-architectures. Actually, LBM saclay can run without modification on any architecture that Kokkos supports. The current compatibilities are indicated in  [63]  and summarized in Tab. 1. For more information, the reader can refer to the Kokkos documentation. Let us mention that the current support for AMD GPU is experimental through the C++ library HIP (Heterogeneous-Compute Interface for Portability) and it is planned to be supported at the end of 2020. Two levels of parallelism are implemented in the code. The first one is the intra-node parallelism (shared memory) with the Kokkos library, an opensource C++ library with parallel algorithmic patterns and data containers.
The source term is defined as the product of mass production rate times one term inversely proportional to densities. An additional equation on temperature completes the model. The time derivative of phase-field appears in the source term of that equation. It is interpreted as the release or absorption of latent heat at the interface. The Lattice Boltzmann schemes for all equations are implemented in a new C++ code coupled with the Kokkos library for its performance portability. The new code, called LBM saclay, can be run with good performance on several architectures such as Graphical Process Units (GPUs), Central Process Units (CPUs) and even multi-GPUs and multi-CPUs. Indeed, two levels of parallelism are developed inside the code. The first one uses Kokkos for intra-node parallelism, whereas MPI takes in charge the domain decomposition.
Preliminary comparisons between GPUs and CPUs were carried out on a simple diffusive problem. As expected from literature, those tests show clearly that best performance is obtained with GPU compared to CPU (Skylake or KNL) even for best optimization of LBM kernels (CSoA2) which has been developed for Intel Skylake. Here, comparisons were performed with the same C++ source code. No low-level language (CUDA or OpenCL) was used for GPUs. Numerical implementation was checked with several test cases to validate step-by-step the full model of fluid flows with phase change. The conservative Allen-Cahn equation is validated with two test cases: (i) Zalesak's slotted disk and (ii) interface deformation inside a vortex. The coupling with Navier-Stokes equations is also checked with two test cases: the layered Poiseuille flow and Laplace law.
In the future, a three-dimensional extension of the coupling terms is planned. Next LBM saclay could be enriched with other models requiring interface tracking such as crystal growth and demixing of ternary fluids. Besides, the range of physical parameters could be increased and the code stability could be enhanced by using alternative collision operators such as those based on the Two-Relaxation-Times and Multiple-Relaxation-Times. ∂ϑ i ∂t + c i •∇ ∇ ∇ϑ i = - ϑ i -ϑ eq i τ ϑ + S ϑ i. (C. 1) In what follows, the calculations will be performed by setting ϑ ≡ f , S ϑ i = S f i = S i and τ ϑ ≡ τ but the variable change derivation holds also for ϑ ≡ h and ϑ ≡ s. Terms that are evaluated at position x and time t are noted f i ≡ f i (x, t), f eq i ≡ f eq i (x, t) and S i ≡ S i (x, t), whereas terms evaluated at position x + c i δt and time t + δt are noted with a star: f i ≡ f i (x + c i δt, t + δt), f eq i ≡ f eq i (x + c i δt, t + δt) and S i ≡ S i (x + c i δt, t + δt).
Moreover, this kind of visualization is a challenge to obtain as social networks extracted from real-world interactions force us to face several hundreds of thousands  [3] , when not millions  [4, 5] , of nodes at once. This easily pushes the existing algorithms  [6, 7]  built to lay out more modest graphs to their limits. Thus, we propose Jasper, which stands for Just A new Space-filling Pixeloriented layout for large graph ovERview  [8]. Our initial motivation was to create quick overviews of large graphs to allow users to easily get a basic mental map of the targeted dataset before deciding to perform any further visual analytics. Furthermore, because it presents pixel-oriented characteristics and separates nodes in clusters (a. k. a. communities), we found that Jasper could be rather useful to overview propagation and dissemination phenomena in social networks  [9].
In order to ease future work comparing Jasper, we have voluntarily used general tasks (not specific to any kind of data or domain) for community visual analytics, various and freely available datasets (for reproducibility), widely known and used visualizations allowing for indirect comparison with Jasper, and basic interactions (changing the color) which should be available in all visualisation platforms. The rest of the paper is structured as follows. In Section 2, we define guidelines for designing efficient overview of community-oriented network visualizations and how these guidelines are implemented at each level of the Munzner nested model for visualization  [14]. These guidelines give precious hints and structure for looking at related work which is presented in Section 3. Section 4 recalls the algorithm of Jasper and in Section 5, we present the controlled user experiment to properly evaluate it and check if the resulting visualizations are deemed "better" than the more classical node-link and matrix visualizations.
Guideline G3. Large graphs are complex to handle and visualize but observers interested in propagation phenomena rarely care about complexity, only about the visualization on their screen. Thus, the network must be available as a whole and shown as such. We cannot only "Show the Important" first as claimed by the Visual Analytics mantra. Furthermore, a drawing of the network should appear quickly and not after several minutes of computation. After defining the guidelines from a user point of view, Munzner's next level leads us to an abstraction into operations on data types. Quite obviously, our data type is a labeled directed graph where nodes represent users of the social network and labels associated to nodes (mapped onto node's color, see below) represent the state of the node about the information propagated.
However, edges -carrying information on the connectedness of each node in the network-cannot be explicitly represented using a pixel-oriented method. Duarte et al. [27]  have encountered a similar problem. Their Nmap layout is introduced as being a neighborhood preservation space-filling algorithm able to display connected nodes close to each other. The resulting visualization is rather reminiscent of Tree-Maps  [28, 29]  which have been successfully used to visualize very large datasets containing up to a million of elements  [30]  and to perform social network analysis  [31, 32]. By achieving this spatial proximity in the representation to indicate the connection of elements from a structural point of view, as expected for G2, edges do not need to be drawn as their existence is hinted by the nodes adjacency in the visualization.
User evaluation of Jasper Following Purchase methodology  [16] , we designed a within-participants experimentation to evaluate Jasper as a compact social network overview visualization algorithm against well-known and widely used methods. The experimentation is motivated by the following research question: Is Jasper a better solution for analyzing the community structure of social network compared to two variations of node-link diagrams and a matrix visualization? Although Jasper was originally designed for generating overviews of large graphs, we expect it to allow users to successfully and quickly perform some basic community oriented tasks. As a consequence, we evaluate more general tasks involved in the study and identification of communities in social networks. Overall the experiment is composed of 4 visual conditions used with 4 datasets and 3 tasks to be able to generate 4 × 4 × 3 = 48 questions per user.
Datasets We use 4 real-world datasets of different sizes plus another small random network generated following the Wang et al. model  [53]  with 10k nodes and twice as much edges for user training purposes. The different sizes of the datasets are used to analyze the responses of users depending of the layout used, but also on both the size and density of the networks being visualized. All the following datasets are freely available as part of the Stanford Large Network Dataset Collection  [54].
Evaluation setup All users used the same computer (no updates during the experimentation), same screen (same resolution and brightness for each user), same room with the same light conditions, same mouse, same software (no recompilation). We use two different series of questions for each dataset, task, and visualization combination. The layouts are similar but the communities highlighted (i. e. , the subjects of the question) are different. This allows us to further validate the solution by using an alternative scenario to overcome a learning effect. The communities used for each task were chosen among the largest communities built by the Louvain algorithm. For T1, the large community has about 10% more nodes than the small one. For T2, the comparison was done between 3 and 4 communities. For T3, the available choices were limited by the datasets but we always chose communities connected with numerous connections between them.
Overall, the experiment is divided into 4 sets of questions, each set using only a single condition. The ordering of tasks, graphs, and conditions is managed with a Latin square to avoid identical scenarios to take place between users. To keep users attentive all along the experiment, short intermissions of up to two minutes are proposed between each set of questions. When starting the evaluation, users are not familiar with the different conditions or tasks. For users to perform at their utmost capability, we use a total of six training questions per question set. The first three are used to introduce the tasks with the current condition on the training dataset, and give users the opportunity to ask for help or additional explanations concerning the visualization. The remaining three training questions are simply standard questions, selected at random in the alternative series whose results are ignored.
T3 -Distance between highlighted communities. This task proved to be much more complicated than initially anticipated in the pilot experimentation as shown by the high error-rates. Matrix (C2) returns the lowest error rate by far, with C1 and C3 coming next. However, the average response time when using Jasper is significantly lower than all the other conditions, it even cuts by half the average time needed to answer when using C2. On a side note, while all datasets have been chosen to bring the experimentation as close as possible to a real case, the selected networks are not identical and some statistically significant variations exist for some tasks. For instance, even with a Bonferroni correction (α = 0. 025), the successful completion of T1 takes significantly less time on DBLP (D4) and the completion of T3 has been significantly more successful on Epinion (D3) -with still 49% of errors-as well as seemingly faster -but not significantly-than on the other networks.
AMR is currently used in a large amount of software  [14]  for various physical problems such as astrophysics with Enzo  [15]  or to solve PDE with Chombo  [16]. This paper introduces an efficient hybrid MPI/OpenMP parallelization taking advantage of AMR data structures to efficiently cope with highly dynamic MD simulations by reducing the imbalance between the threads and MPI processes. We leverage our previous work, based on the use of AMR techniques  [17]  to improve memory locality, multi-threading parallelism and we address the division of the domain simulation into subdomains assigned to the MPI processes. We demonstrate that the introduction of AMR techniques does not add overhead to communications between nodes. We also extend our task dependency graph to cope with irregular subdomain pattern.
We validate our approach using an extended implementation of the ExaS-TAMP  [18]  MD simulator over a cluster of 512 Intel R Xeon Phi Knight Landing (KNL). We use different input configurations and show that our approach outperforms state-of-the-art solutions while using a similar memory footprint. The main contributions of this paper are the following: • We introduce a new MD simulation code using AMR techniques able to efficiently exploit modern supercomputers; • We present a task-based dependency graph strategy for AMR in order to optimize thread-based parallelization and an MPI parallelization strategy adapted to the AMR structure; • We evaluate our implementation of the AMR using large scale productioncases and traditional benchmarks. This paper is structured as follows. In the next Section, we briefly recall the main concepts used in MD and AMR based applications then we describe the main contribution of the presented work.
Experimental Framework To validate the relevance of our approach, we evaluate the performance of our implementation against the LAMMPS package on the two selected test cases. LAMMPS is one of the most relevant classical MD simulators designed for parallel computers. It has proved to perform efficiently on benchmarks featuring several billions of atoms over tens of thousands cores. Although the standard LAMMPS version is parallelized using MPI, many packages have been developped to integrate thread parallelization such as USER-OMP or USER-INTEL. The KOKKOS package has also been integrated to optimize LAMMPS on accelerators (KNL and GPU). Load balancing can be performed by using either the shift method  [23]  or the recursive coordinate bisection  [24]  (RCB) one. Despite specific optimizations for Intel KNL processors, our experiments revealed that the OpenMP version of LAMMPS remains 10 to 15% slower than the full-MPI version  [25].
The remaining of this section is organized as follows. The first phase of our experiments consists in evaluating the performance of the two versions of ExaSTAMP against LAMMPS. We use two different test cases: the simulation of a bulk of copper (Subsection 3. 2), which is a steady state configuration, and the simulation of a micro-jetting of tin (Subsection 3. 3) which represents a more dynamic configuration. Both test cases use the Lennard Jones (LJ) potential. This potential is widely used to benchmark MD codes. Due to its low computational cost, the LJ potential highlights performance issues of non-computational parts of the code such as theards synchronizations, memory accesses or MPI communications. In a second phase, we demonstrate the benefits of our approach on a more realistic test case featuring the Modified Embedded Atom Model (MEAM) potential on the micro-jetting configuration (Subsection 3.
Bulk of Copper The first benchmark illustrated in Figure  6  consists in simulating 100 timesteps (∆t = 1fs) of a bulk material featuring 2. 048 and 16. 348 billion of atoms in thermodynamic equilibrium. This simulation has many properties such as an homogeneous density, which also remains constant throughout the whole duration of the simulation. The bulk of copper is obtained by replicating an atom pattern named lattice. A Face Centered Cubic (FCC) lattice of 3. 54 Å is used with a suitable LJ potential ( = 9. 340 x 10 -20 J and σ = 2. 27 Å). For each atom, 39 interactions with neighboring atoms are processed due to the 5. 68 Å cut-off and the symmetric property of the LJ potential. A Verlet radius of 0. 3 Å is added to avoid rebuild Verlet lists. Such a homogeneous case is not a configuration able to demonstrate the advantages of AMR in MD simulations, and we merely expect ExaSTAMP AMR to exhibit decent performances thanks to its carefully optimized code design.
RELATED WORK Many research efforts have been devoted to designing efficient MD simulations on supercomputers. LAMMPS and its associated miniMD mini application are probably the most widely used software in this domain, and have already been detailed previously. In the following, we carry on a short survey of significant MD software. dl poly 4  [26]  brings a package of subroutines, programs and data files, written in fortran 90 and designed to make MD simulations easier and is used for production. This software is designed to perform on CPU with OpenMP and MPI, as well as on GPU. In addition there are no load balancing algorithms in dl poly 4 to compensate for a bad density distribution. Gromacs  [11]  is written in C with intrinsics functions for SIMD instructions and CUDA for GPU. As LAMMPS, Gromacs contains algorithms for neighbor search based on Verlet lists.
Whereas it is designed for biochemical molecules like proteins, lipids and nucleic acids that have a lot of bonded interactions, an all-atom version provides short-range interactions such as Lennard Jones or Buckingham potentials. To balance the workload between MPI processes, Gromacs uses  [27]  the Eighth Shell Method  [28]. As miniMD, several simplified versions of complex MD codes have recently been developed to serve as a testbed for various optimizations over manycore architectures. The CoMD  [29]  software was designed to study the dynamical properties of various liquids and solids in the context of the Ex-MatEx project. The reference implementation of CoMD uses OpenMP, MPI, OpenCL, and can use either neighbor lists or cell-lists methods. A solution used in many other fields is to dynamically and locally adapts the mesh according to the physical phenomenon.
The first adaptive mesh refinement technique  [12, 13]  has been introduced for hydrodynamics applications in order to reduce the computation time by refining the discretized domain (grid) where the points need to be spaced enough to keep their stability properties. The refinement criteria are based on the density or on a Richardson extrapolation  [30]. The AMR has been declined for N-body simulations by recursively subdividing a space into equal cells as long as the refinement criteria are fullfiled. Bodies are stored in a k-d-tree data layout, which is a special case of the binary space partitioning (BSP) trees  [31]. It is used to find the nearest neighbors of a body or to improve the collision detection between two bodies. AMR is currently used in a large amount of software  [14]  for various physical problems such as astrophysics with Enzo  [15]  or to solve PDEs with BoxLib  [32]  and Chombo  [16].
CONCLUSION Performing MD simulations over supercomputers is a major step towards a better understanding of physics in many scientific fields. In this work, we propose an efficient MPI, OpenMP and vectorization parallelization using the advantages of Adaptive Mesh Refinement structures to solve nonuniform large scale MD simulations by reducing the imbalance inside and between multicore cluster nodes. The octree-based strategy enables effective optimizations by reducing the number of empty cells, improving data reuse by cache blocking, and by using a lock-free task-based algorithm. Our experiments show that our implementation outperforms the LAMMPS state-of-art implementation by a factor of 1. 38 on a micro-jetting and by a factor of 2. 61 on a steady scenario. Future works include auto-tuning to find the optimal maximum depth tree of octrees per subdomain, so as to reach the best tradeoff between the amount of parallelism and the efficiency of per-thread code sections.
Nowadays, object detection is considered as an unavoidable aspect that needs to be addressed in any robotic application, especially in industrial settings where robots and vehicles interact closely with humans and objects and therefore a high level of safety for workers and machines is required. This paper proposes an object detection framework suitable for automated vehicles in the factory of the future. It utilizes only point cloud information captured by LiDAR sensors. The system divides the point cloud into voxels and learns features from the calculated local patches. The aggregated feature samples are then used to iteratively train a classifier to recognize object classes. The framework is evaluated using a new synthetic 3D LiDAR dataset of objects that simulates large indoor point cloud scans of a factory model.