Steven R. Lantz

Two-dimensional Simulations of Buoyantly Rising, Interacting Magnetic Flux Tubes

We perform two-dimensional simulations of the buoyant rise of twisted horizontal magnetic flux tubes through an adiabatically stratified layer representing the solar convection zone or other marginally stable atmosphere. The numerical calculations employ the anelastic approximation to the basic MHD equations. We confirm the results of recent compressible simulations by Moreno-Insertis & Emonet that the azimuthal component of the tube magnetic field can prevent the splitting of the tube into a vortex pair, and that most of the flux in the initial tube cross section rises in the form of a rigid body that reaches a terminal speed similar to the prediction of the often-employed thin-flux-tube model. We also study the interaction between a pair of buoyant flux tubes as they rise in proximity. In the case of two identical flux tubes that start from the same level, we find that the wake behind each tube interacts with the wake of the other, prompting mirror-symmetric vortex shedding in each wake. As a result, each tube gains around it a net circulation of the opposite sign of the most recently shed eddy; this causes a periodic, horizontal lift force that makes the tubes oscillate horizontally as they rise. The tube interactions in this case differ substantially from the inviscid limit studied previously. For two identical flux tubes that start at different levels, the resulting interactions depend upon the details of the initial configuration of the two tubes and can be very different from the interactions seen in the symmetrical case. In the asymmetric case, it becomes possible for one flux tube to be drawn into the wake of the other, leading eventually to a merger of the tubes.

The alpha dynamo parameter and measurability of helicities in magnetohydrodynamic turbulence

Alpha, an important parameter in dynamo theory, is shown to be proportional to either the kinetic, current, magnetic, or velocity helicities of the fluctuating magnetic field and fluctuating velocity field. The particular helicity to which alpha is proportional depends on the assumptions used in deriving the first‐order smoothed equations that describe the alpha effect. In two cases, viz., when alpha is proportional to either the magnetic helicity or velocity helicity, alpha can be determined experimentally from two‐point measurements of the fluctuating fields in incompressible, homogeneous turbulence with arbitrary rotational symmetry. For the other two possibilities, alpha can be determined if the turbulence is isotropic.

Magnetoconvection dynamics in a stratified layer. 2: A low-order model of the tilting instability

Simulations of nonlinear, anelastic convection in the presence of magnetic fields have revealed a complex array of dynamic phenomena, including several kinds of nonlinear oscillations (Lantz & Sudan 1993). In an attempt to identify the physical mechanism responsible for these oscillations, a simple model is proposed in which the full magnetoanelastic equations are replaced by equations for the amplitudes of only a few Fourier modes, which evolve according to more symmetric Boussinesq rules. Only one symmetry is permitted to be broken: the updown mirror symmetry, via a tilting mode that drives a shear flow in the horizontal direction (Howard & Krishnamurti 1986). The nonlinear interaction of just these few modes is shown to be adequate to reproduce qualitatively the kinds of behavior seen in simulations. Furthermore, when parameters in the magneto-anelastic equations are mapped onto rough Boussinesq equivalents, a number of quantitative comparisons can be made as well; these confirm that the low-order, truncated model is able to capture the correct numerical trends in the simulated data as the Rayleigh number and imposed horizontal magnetic field are varied. Video visualizations of fluid motions derived from the low-order equations are presented, together with their analogs from full MHD simulations.

Kalman filter tracking on parallel architectures

We report on the progress of our studies towards a Kalman filter track reconstruction algorithm with optimal performance on manycore architectures. The combinatorial structure of these algorithms is not immediately compatible with an efficient SIMD (or SIMT) implementation; the challenge for us is to recast the existing software so it can readily generate hundreds of shared-memory threads that exploit the underlying instruction set of modern processors. We show how the data and associated tasks can be organized in a way that is conducive to both multithreading and vectorization. We demonstrate very good performance on Intel Xeon and Xeon Phi architectures, as well as promising first results on Nvidia GPUs.

Traditional Tracking with Kalman Filter on Parallel Architectures

Power density constraints are limiting the performance improvements of modern CPUs. To address this, we have seen the introduction of lower-power, multi-core processors, but the future will be even more exciting. In order to stay within the power density limits but still obtain Moores Law performance/price gains, it will be necessary to parallelize algorithms to exploit larger numbers of lightweight cores and specialized functions like large vector units. Example technologies today include Intels Xeon Phi and GPGPUs. Track finding and fitting is one of the most computationally challenging problems for event reconstruction in particle physics. At the High Luminosity LHC, for example, this will be by far the dominant problem. The most common track finding techniques in use today are however those based on the Kalman Filter. Significant experience has been accumulated with these techniques on real tracking detector systems, both in the trigger and offline. We report the results of our investigations into the potential and limitations of these algorithms on the new parallel hardware.

Kalman Filter Tracking on Parallel Architectures

Power density constraints are limiting the performance improvements of modern CPUs. To address this we have seen the introduction of lower-power, multi-core processors such as GPGPU, ARM and Intel MIC. In order to achieve the theoretical performance gains of these processors, it will be necessary to parallelize algorithms to exploit larger numbers of lightweight cores and specialized functions like large vector units. Track finding and fitting is one of the most computationally challenging problems for event reconstruction in particle physics. At the High-Luminosity Large Hadron Collider (HL-LHC), for example, this will be by far the dominant problem. The need for greater parallelism has driven investigations of very different track finding techniques such as Cellular Automata or Hough Transforms. The most common track finding techniques in use today, however, are those based on a Kalman filter approach. Significant experience has been accumulated with these techniques on real tracking detector systems, both in the trigger and offline. They are known to provide high physics performance, are robust, and are in use today at the LHC. Given the utility of the Kalman filter in track finding, we have begun to port these algorithms to parallel architectures, namely Intel Xeon and Xeon Phi. We report here on our progress towards an end-to-end track reconstruction algorithm fully exploiting vectorization and parallelization techniques in a simplified experimental environment.

Kalman-Filter-based particle tracking on parallel architectures at Hadron Colliders

Power density constraints are limiting the performance improvements of modern CPUs. To address this we have seen the introduction of lower-power, multi-core processors such as GPGPU, ARM and Intel MIC. To stay within the power density limits but still obtain Moores Law performance/price gains, it will be necessary to parallelize algorithms to exploit larger numbers of lightweight cores and specialized functions like large vector units. Track finding and fitting is one of the most computationally challenging problems for event reconstruction in particle physics. At the High-Luminosity Large Hadron Collider (HL-LHC), for example, this will be by far the dominant problem. The need for greater parallelism has driven investigations of very different track finding techniques such as Cellular Automata or Hough Transforms. The most common track finding techniques in use today, however, are those based on the Kalman Filter. Significant experience has been accumulated with these techniques on real tracking detector systems, both in the trigger and offline. They are known to provide high physics performance, are robust, and are in use today at the LHC. We report on porting these algorithms to new parallel architectures. Our previous investigations showed that, using optimized data structures, track fitting with Kalman Filter can achieve large speedups both with Intel Xeon and Xeon Phi. We report here our progress towards an end-to-end track reconstruction algorithm fully exploiting vectorization and parallelization techniques in a realistic experimental environment.

Parallelized Kalman-Filter-Based Reconstruction of Particle Tracks on Many-Core Architectures

Faced with physical and energy density limitations on clock speed, contemporary microprocessor designers have increasingly turned to on-chip parallelism for performance gains. Algorithms should accordingly be designed with ample amounts of fine-grained parallelism if they are to realize the full performance of the hardware. This requirement can be challenging for algorithms that are naturally expressed as a sequence of small-matrix operations, such as the Kalman filter methods widely in use in high-energy physics experiments. In the High-Luminosity Large Hadron Collider (HL-LHC), for example, one of the dominant computational problems is expected to be finding and fitting charged-particle tracks during event reconstruction; today, the most common track-finding methods are those based on the Kalman filter. Experience at the LHC, both in the trigger and offline, has shown that these methods are robust and provide high physics performance. Previously we reported the significant parallel speedups that resulted from our efforts to adapt Kalman-filter-based tracking to many-core architectures such as Intel Xeon Phi. Here we report on how effectively those techniques can be applied to more realistic detector configurations and event complexity.

Parallelized Kalman-Filter-Based Reconstruction of Particle Tracks on Many-Core Processors and GPUs

For over a decade now, physical and energy constraints have limited clock speed improvements in commodity microprocessors. Instead, chipmakers have been pushed into producing lower-power, multi-core processors such as Graphical Processing Units (GPU), ARM CPUs, and Intel MICs. Broad-based efforts from manufacturers and developers have been devoted to making these processors user-friendly enough to perform general computations. However, extracting performance from a larger number of cores, as well as specialized vector or SIMD units, requires special care in algorithm design and code optimization. One of the most computationally challenging problems in high-energy particle experiments is finding and fitting the charged-particle tracks during event reconstruction. This is expected to become by far the dominant problem at the High-Luminosity Large Hadron Collider (HL-LHC), for example. Today the most common track finding methods are those based on the Kalman filter. Experience with Kalman techniques on real tracking detector systems has shown that they are robust and provide high physics performance. This is why they are currently in use at the LHC, both in the trigger and offine. Previously we reported on the significant parallel speedups that resulted from our investigations to adapt Kalman filters to track fitting and track building on Intel Xeon and Xeon Phi. Here, we discuss our progresses toward the understanding of these processors and the new developments to port the Kalman filter to NVIDIA GPUs.

Lattice QCD on the IBM Scalable POWERParallel Systems SP2

A 512 node IBM Scalable POWERParallel Systems SP2 was installed at the Cornell Theory Center in October 1994. During the past couple of months we have been porting and optimizing code for carrying out lattice QCD calculations. Present performance is far from ideal, however, and optimization efforts are still under way. The rate limiting step in our code involves a rather generic inversion of a large, sparse system, based on a partial differential equation in a multidimensional space. The insights we have gained so far may be useful in diagnosing performance in a wide class of applications.