A Multi-Resolution Interpolation Scheme for Pathline Based Lagrangian Flow Representations

Transcription

1 A Multi-Resolution Interpolation Scheme for Pathline Based Lagrangian Flow Representations Alexy Agranovsky a, Harald Obermaier a, Christoph Garth b, and Kenneth I. Joy a a University of California, Davis, 1 Shields Ave, Davis, Ca. USA b University of Kaiserslautern, Gottlieb-Daimler-Straße 47, Kaiserslautern, Germany ABSTRACT Where the computation of particle trajectories in classic vector field representations includes computationally involved numerical integration, a Lagrangian representation in the form of a flow map opens up new alternative ways of trajectory extraction through interpolation. In our paper, we present a novel re-organization of the Lagrangian representation by sub-sampling a pre-computed set of trajectories into multiple levels of resolution, maintaining a bound over the amount of memory mapped by the file system. We exemplify the advantages of replacing integration with interpolation for particle trajectory calculation through a real-time, low memory cost, interactive exploration environment for the study of flow fields. Beginning with a base resolution, once an area of interest is located, additional trajectories from other levels of resolution are dynamically loaded, densely covering those regions of the flow field that are relevant for the extraction of the desired feature. We show that as more trajectories are loaded, the accuracy of the extracted features converges to the accuracy of the flow features extracted from numerical integration with the added benefit of real-time, non-iterative, multi-resolution path and time surface extraction. Keywords: Flow Map, Lagrangian, Trajectory, Multi-Resolution, Integral Line, Surface 1. INTRODUCTION Flow fields are the output of some of the most widely used simulations to date. In the context of Computational Fluid Dynamics (CFD) simulations they are used to represent material transport in a wide range of application fields such as airplane engineering or climate simulations. To visualize the spatial and time-varying transport of fluid material in a post-processing step, it is necessary to be able to trace individual particles present in the flow domain. Given the classic representation of flow fields as static meshes with different velocity information per time step, the so-called Eulerian representation, this tracing requires the numerical computation of solutions to the underlying discretized differential equation, hereby restricting tracing to numerical integration. Due to the unpredictability of particle movement, it is difficult to determine which sections of the vector field data will be needed as the particle is advected through the field. Solutions that load the entire mesh, or load data on demand, have to take special care not to exceed memory (large amounts of data) and time (large amounts of I/O operations) constraints. 1 Flow fields can be represented in a Lagrangian way, where the discretization is no longer static with respect to a stationary mesh. In essence this representation corresponds to a dense sampling of the flow field with particle trajectories. Such data can be, for example, output of modern CFD simulation tools (cf. Smooth Particle Hydrodynamics 2 ), or the output of another post-processing techniques such as Finite-Time Lyapunov Exponent (FTLE) computations. The availability of a full Lagrangian representation in the form of a set of dense particle trajectories opens up new possibilities for integration-based flow visualization. In order to trace an arbitrary particle through the flow field, one no longer has to perform numerical integration, but can interpolate within the given set of flow trajectories. Not bound by the iterative constraint of time-varying integration, the trajectory of this particle can be extracted at a variety of time intervals. Therefore the trajectory can be represented with fewer point positions but cover the same time frame, reducing Further author information: (Send correspondence to A.A.) A.A.: aagranovsky@ucdavis.edu H.O.: hobermaier@ucdavis.edu C.G.: garth@cs.uni-kl.de K.I.J.: kijoy@ucdavis.edu

2 the computation necessary to present the particle s path. The predictive nature of interpolation combined with the spatial coherency properties of continuous flow allows for the use of a local interpolation neighborhood to extract the trajectory over all time steps. This locality assures a bound on the information needed to perform interpolation, with the advantage of reducing I/O to only those trajectories needed for the interpolation neighborhood. We demonstrate how the particle trajectory representation can be used to construct adaptive integral surface representations and compare the results to traditional integration-based surface generation with respect to matched accuracy, improved speed, and a reduced memory footprint. The advantages of a Lagrangian representation of fluid flow are further exemplified by a real-time, interactive data set exploration technique. By segmenting the flow map representation into multiple resolutions, the coarsest resolution allows for real-time surface reconstruction, while finer resolutions refine a specific surface with on-demand trajectory loading. This technique gives users the ability to explore the entire flow data set for a desired surface, and once located, the surface is refined to the best possible accuracy defined by the total set of trajectories. While a large number of trajectories over the entire data set is required to meet the accuracy standards accepted with Eulerian advection, our technique only loads in those trajectories needed to reconstruct any given surface accurately, thereby lowering the memory footprint of surface reconstruction while maintaining accuracy with respect to traditional numerical integration techniques. In summary, the main contributions of this work to the field of visualization are: A multi-resolution flow map organization for dense particle trajectory sets. Efficient interpolation of arbitrarily seeded trajectories. Accurate and efficient extraction of integration-based flow geometry at multiple levels of detail, allowing real-time flow field exploration. Location specific I/O for a reduction in memory cost during integral surface representation. 2. BACKGROUND The following sections provide an insight into the two fundamental representation techniques of flow fields, their properties with respect to integration based techniques, and their impact on this work to establish a solid background for the remainder of the paper. 2.1 Vector Fields In the following, a vector field is a continuous, vector-valued function v over a four-dimensional (space-time) domain of definition Ω [0,T ] R 3 that maps a point (t,x) to a vector v(t,x) R 3. Typical applications of vector fields center on the description of vector-valued physical quantities such as velocity in fluid flows, where a vector describes the instantaneous velocity of the fluid at a given point in space and time. A vector field is called stationary if v does not depend on t, and time-dependent otherwise. The classic representation of a vector field as a stationary mesh that holds vector data at its nodes for every time step of a simulation is called Eulerian. In this representation the spatial discretization of the flow domain is generally either static in time, or does not reflect fluid transport. An alternative representation, frequently used in Smoothed Particle Hydrodynamics (SPH) 2 and other mesh-free methods, is the representation as collection of dynamically moving flow particles, called Lagrangian representation. In this representation, the frame of reference is locally moving with the flow field, i.e., the spatial discretization of the flow field is attached to participating material in the fluid transport. A comparison of both views is shown in Figure 1. A continuous representation of the flow field is achieved by performing interpolation on the mesh or moving particle set, allowing for a different notion of time-varying features such as particle trajectories or pathlines.

3 2.2 Flow Trajectories Trajectories of massless particles are identified by a point (t i,x i ) it contains, commonly called its seed point. All subsequent points then form a pathline, a trajectory represented in 4D. Mathematically, trajectories are solutions to the ordinary differential equation d I(t) = v(t,i(t)) dt (1) I(t i ) = x i (t i,x i ) Ω (2) Like the vector fields over which they are defined, trajectories typically possess a straightforward connection to physical aspects of a given application: e.g., in the case of fluid flow, integral curves describe the trajectories of massless particles embedded in a flow. φ t Eulerian: v( ) = Lagrangian: φ t ( ) = Figure 1. Eulerian vs. Lagrangian descriptions. The Eulerian view describes a flow field in terms of the instantaneous velocity v of particles, while the Lagrangian view considers the evolution of all particles over a time interval t and is specified in terms of the flow map φ. 3. RELATED WORK Classic integral surface generation relies on the numeric solution of ODEs and makes heavy use of numerical integration techniques such as Euler integration or higher-order adaptive Runge-Kutta Methods. 3 These surface generation methods 4 have the advantage of adaptive resolution and accuracy control 5 7 but require high numbers of computationally expensive and iterative evaluation of vector fields. Non-adaptive surfaces with comparatively low accuracy may, however, be computed on the GPU as well. 8 To increase computational efficiency, different approaches such as stream function generation with subsequent isosurface extraction, 9, 10 or path-volume construction from integrated time-surfaces, 11 or hierarchical construction of the integral curves, 12 or neighborhood tracking for trajectory interpolation 13 have been taken in the past. Other flow structure construction techniques 14 make direct use of sample trajectories as well, but do not aim at the creation of adaptive integral surface structures. These approaches do not, however, easily extend to 3D space + time. In similar contexts, other research 15 formulates time-varying integral surfaces as tangent curves in high-dimensional spaces, 16 significantly increasing pre-computation and memory requirements. Memory reduction has been achieved in the form of vector field sub-sampling and compression 17 with topology conservation but it is difficult to estimate the impact on trajectory advection. A class of visualization techniques that makes heavy use of pre-sampled vector fields is the field of Lagrangian flow analysis with the help of Finite-Time Lyapunov Exponent maps. 18 Here, densely sampled flow fields are the basis for the approximation of flow stretching. 19, 20 These approaches are suitable for direct execution on massively parallel machines

4 due to locality of trajectory integration. To a lesser degree, this locality can assist curve integration in parallel. Massively parallel stream line integration covering seeding strategies has been implemented and analyzed, 1 with a strong focus on I/O, citing computational hardship due to block loading of the vector field because of the inability to predict a particle s position over all time steps prior to advection. Focusing directly on pre-sampled vector fields, our proposed method restructures trajectory information to allow for dynamic loading of pre-determined blocks, eliminating I/O due to the position unpredictability of particle advection. With I/O limited to desired areas of interest, we are therefore able to present a method for path and time surface extraction that has real-time, interactive character even for large data sets. 4. A SYSTEM FOR EFFICIENT PATHLINE INTERPOLATION To begin the discussion of interpolating/extracting arbitrary trajectories within a set of particle trajectories, we first look at the given Lagrangian representation and the capabilities it provides as input for the purposes of flow visualization. Given a Lagrangian representation of the data, a particle s position is tracked within a set of moving flow particles. Thus, we replace traditional numerical integration by interpolation over a set of densely sampled flow trajectories. The Lagrangian representation defines a flow field through a number of given tracers, trajectories that trace the path of a particle through a finite time interval. If a particle were to be placed within a neighborhood of these tracers and its position tracked as time progressed, the newly placed particle would follow a path similar to that of the nearby tracers. The outcome of the interpolation is highly determined by the trajectories chosen, therefore, a large overall number of tracers in the Lagrangian representation is preferred to support an accurate pathline reconstruction. This ensures that any particles seeded into the flow field will be surrounded by tracers within close proximity. 4.1 System Outline The efficiency gained through interpolation during pathline creation allows for an exploratory environment to aid in flow field analysis, instantly presenting rough results while progressively improving them over time. In our work, we present an environment that extracts pathlines in real-time on the CPU. These pathlines are used to construct path surfaces and time surfaces to allow more complex feature extraction while navigating the data set. The initial surface reconstruction relies on pathlines interpolated from a low resolution sampling of the flow map. Once a feature of interest is located, additional tracers within the seeding vicinity are loaded to improve the surface reconstruction. By organizing trajectories into varying levels of resolution, only those tracers with seeding positions within a specified spatial area are located and loaded by the algorithm. This process may be repeated any number of times during data set exploration, loading trajectory information only when requested. The central steps of our algorithm are captured in a flow diagram in Figure 2 and are as follows. 1. Pre-Process Lagrangian Flow Field Representation: The Lagrangian representation is sub-sampled into multiple levels of detail and written out to file. This file representation is designed to allow efficient local and on-demand streaming of trajectory data, following a hierarchy based on grid resolution. 2. Base Resolution: An initial coarse resolution is loaded and kept in memory for fast trajectory exploration and interpolation. 3. Efficient Interpolation: (a) Interactive Extraction: During exploration, a preview version of the desired path- or time-surface is extracted in real time from the coarse level Lagrangian representation. For this matter, individual pathlines are interpolated from the existing set of flow map tracers. (b) Spatial Refinement: On demand or after sufficient idle time has passed, higher resolution trajectory data is streamed from the file system. The existing surface representation is refined by taking novel trajectory data into account during pathline interpolation. The next section describes these steps in detail, beginning with a in-depth description of the data representation created by the pre-processing step and finishing up with the specific aspects of retrieving tracer information dynamically for interpolation.

5 Figure 2. Program flow. The process begins from the interactive environment that interpolates pathlines using a coarse resolution flow map. Once a feature of interest is located, the algorithm enters the refinement pipeline, loading additional tracers from finer resolutions. At this time, additional time step information may be loaded for the selected tracers. Once the seeding points are moved from the refined location, the process begins anew. 5. PRE-PROCESSING AND CREATING THE SET OF TRAJECTORIES We begin with an in-depth description of the data representation created by the pre-processing step, with a look at how tracer information is organized on the hard drive. 5.1 Organizing the Lagrangian Flow Representation With only a small number of tracers may be required to interpolate the path of a seeded particle, loading the tens of millions of tracer positions is a burden to the memory footprint of the algorithm. Therefore, the given Lagrangian representation is first pre-processed to segment the tracers into multiple levels of resolution of varying density. Additionally, segmenting each resolution with a regular grid will allow for fast spatial location. Essentially, the entire Lagrangian representation is sub-sampled into smaller, separate, more computationally manageable representations. Each level of resolution breaks the data set up into a number of square voxels, or cells, of varying size, one uniform size per resolution resulting in uniform grids of increasing resolution. An arbitrary time step τ is chosen to represent the entire set of tracers, using a tracer s 3D position at τ to locate its designated cell. Beginning from the coarsest resolution, tracers are randomly binned into these spatial cells until all tracers are exhausted and all resolution levels are filled. Resolution Specification The Lagrangian representation is broken up into multiple levels of resolution using the data set defined dimensions, DIM xyz and the number of trajectories given, N total. The first resolution to be created is the coarsest, providing a general subsampling over the entire domain. Each dimension is sampled by 100 cells, defining the cell width, CW c. If the data set does not have equal dimensions, the longest axis is represented by 100 cells, setting the resolution s cell width. The number of points within each cell of the course resolution, n c, is chosen to be 10, with enough points in one cell to form a neighborhood for interpolation. To limit the amount of information mapped by the I/O, a value M is chosen where M represents the maximum number of points that should be mapped by the file system during pathline refinement. Setting a limit to the amount of information mapped at once assures that all resolutions store the same maximum amount of tracers. The number of levels, L, is defined by: L = N total N c M (3)

6 where the numerator holds the number of trajectories left to be stored outside of the coarsest resolution (N c being the total number of tracers in the coarsest resolution). Next, the cell size of each resolution is determined as CW i = CW c i where i is the current resolution. With cell size known, the algorithm can now determine how many tracers will be binned into each cell subject to the constraint, n i M (DIM x /CW i ) (DIM y /CW i ) (DIM z /CW i ) (4) where i is the current resolution. The values n i will be used during the binning process to sort tracers into the various resolution levels. While the advantage of tracer location may be obtained by segmenting the entire data set into only one resolution, there are two main objectives behind using multiple levels. First, sectioning the tracers into different levels lightens the load of the file system as resolutions are read in by the algorithm. Second, the varying density between resolutions helps ensure that loaded tracers may benefit more than one seeded particle if a group of particles is seeded near one another. Figure 3. Resolutions file layout. Resolutions are written in order with each resolution writting out its cells by collapsing the 3D representation into a linear one. Binning of Trajectories For the purpose of locating a tracer position within 3D space, the input set of trajectories must be binned into cells of multiple resolutions. The procedure begins binning from the coarsest resolution to the finest, in other words, the largest cells are filled first. As the binning process progresses, the 3D position of a tracer at time τ is used to determine which cell of the current resolution contains the tracer. A list of contained tracers is created for each cell from which a subset will be selected for the cell. Unfortunately, simply binning the n number of tracers can lead to an unbalanced cell. Therefore, a trajectory s spatial location determines whether or not it is chosen. Each cell has a designated radius r = 3 3 CWi 3 8 n i that is used for spacing binned tracers where CW i 3 is the cell dimensions divided by the number of trajectories to be binned. An empirically found factor of 3 8 is applied to calculate the radius within the allotted space. If the list is exhausted before the n c criteria is met, trajectories furthest from those already selected are chosen to fill the cell. Any remaining tracers continue to the next resolution where they are once again sorted into empty cells. Note, tracers that have been binned prior do not appear in the current cell list. n i Generating Resolution-Dependent Trajectory Files The next step is to write out each level of resolution, split between multiple time steps. At the conclusion of the binning process, cells within all levels of resolution will contain indicies of their enclosed tracers. The files will be written out following resolution and cell order, one for each time step as trajectory information spreads out across multiple files. The order in which the trajectories appear in the file is based on their resolution and cell placement. Resolution levels are written in order from coarse to fine, while cells are laid out in the traditional xyz fashion with the x axis running fastest and the z axis slowest, shown in Figure 3. Trajectory information for the current time step is written out strictly according to this layout, a size of 16 bytes per tracer, or one 32-bit integer and 3 floats. The integer holds the index of the tracer and the 3 floats hold its 3D position in Cartesian coordinates. An additional integer holds the number of tracers within the current cell. The memory layout is presented in Figure 4. The first file to be written is the time step τ. Recall that all tracers were binned into the resolution cells using their spatial position at time τ. Even though a tracer s 3D position may be different at a future time step, the tracer s location

7 Figure 4. Cell contents within a resolution for one time step file. Each cell begins with an int which holds the number of trajectories within the cell, afterwhich each trajectory is represented by its index and 3D position. within any time step file remains static, specified by the binning process. It is possible that a tracer with a valid position at τ may have ceased to exist during the fluid simulation and therefore may not have position information for an arbitrary future time step t i. To preserve the uniform layout between time step files, dummy values are put in place to make up for the missing 16 bytes of information. With prior knowledge of tracer location, every file can then be opened and the specific tracer quickly found with one seek operation. However, to reduce the number of seek operations, the entire contents of a cell are loaded, covering a specific area. The required prior knowledge comes from a reference file output simultaneously with the first time step file τ. The reference file is structured similarly to the time step files, ordered by resolution and cell number. However, the reference file holds the number of bytes to be read into a time step file to locate a given cell. The reference file allows for the flexibility of reading and storing only specified tracers, reducing the overall memory footprint and I/O computation time. The aforementioned process is part of a pre-processing step that does not run in real-time due to intense data reshuffling and writing to disk. Generating the complete set of resolution-dependent trajectory files takes approximately 8 minutes for 25 million tracers, with 44 seconds taken by resolution creation and binning. Reading and writing the multiple time step files (40 in this example case) is the majority of the computational effort. Figure 5. Reference file. Ordered by resolutions, one int is written out per cell to indicate how many bytes into the time step files must be skipped to reach the cell s contents. Fetching Trajectories The interactive environment in which the data set is explored relies heavily on the files put out by the pre-processing step. As mentioned in the previous section, the coarsest resolution provides the trajectory sub-sampling used for initial pathline interpolation. Once a suitable location for the seeding curve is found, refinement begins by loading additional tracers in the vicinity of the rake. These additional tracers all come from the levels of finer resolution, making it necessary to determine which resolution cells the rake intersects. The reference file provided along with the restructured input set holds the dimensions and cell sizes for all resolutions. Combining this information with the 3D positions of rake seed points, the cells enclosing the rake are found and sorted into a list for each resolution. Additionally, the adjacent neighbors of these cells are also sorted into the list. These lists are simply sorted by cell index, where the lowest indexed cell comes before all the rest in the time step files. Knowing the indicies of the first and last cells in the lists makes it possible to intelligently memory map the tracer files. Using the beginning and end index of the cell list, the memory mapper maps only just enough of the resolution to cover the desired cells, exemplified in Figure 6. While a chunk of memory is mapped, only the desired cells are read in since the

8 reference file provides exact byte offsets for the file pointer to follow. Figure 6. Memory mapped section of file. The rake, shown as a black line, is located within the blue cells. While information is only read from these cells, the entire area in red must be mapped for the file pointer to jump cell to cell, accessing the needed trajectory information. As new trajectories are added to the pool of known tracers, pathlines are re-interpolated and a new visualization is formed. The non-iterative nature of using interpolation for path-reconstruction is readily configured for parallelism (multiple threads) during this process. Loading and interpolating position information for every rake seed point is done in parallel. To be able to perform an interpolation step on the scattered set of trajectory positions, we need a viable neighborhood of tracers. During the exploration stage, this is achieved by sorting all known tracers (from the coarsest resolution) into a spatial data structure. Because the coarsest resolution is sub-sampled somewhat uniformly, a nearest neighbor search using a radius provides a neighborhood of tracers suitable for interpolation. As new tracers are loaded, they are added to this neighborhood which is subsequently filtered by a k nearestneighbor approach since its uniformity is drastically altered. By the completion of the refinement process, the rake seed points will be surrounded by the k nearest trajectories over the entire input set of tracers, providing the best possible accuracy for scattered data interpolation. 5.2 Pathline Interpolation For complete flow field exploration, pathlines from arbitrarily seeded particles must be extracted throughout the domain. Such pathlines are interpolated from the input set of tracers provided by the Lagrangian representation. To begin interpolation, the seed location x is found within the current set of tracers at time τ, which form its neighborhood. A weight function based on Euclidean distance is applied to express the seed point as a function of its neighbors, x = f (x j (τ)), where x j are trajectories in the neighborhood. The function is then applied at a later time step, conditioned by the neighborhood at τ, to interpolate the seed point s new location, x(τ + i) = f (x j (τ + i)). Therefore, given a particle position and its neighborhood of tracers, scattered data interpolation can interpolate the particle s position at any time step during which the tracers exist. For the results presented in this paper, we have chosen to use the Moving Least Squares (MLS) 21 method because of its continuous properties and local interpolation ability. The advantage of interpolation over integration when it comes to pathline construction is in the speed of position calculation. For the Eulerian framework, advecting a pathline to a time τ + i involves computationally expensive numerical integration for each previous time step. The position of the particle at times τ + [1,2,...,i 2,i 1] must be calculated before its position at τ + i can be computed. In contrast, only one scattered data reconstruction using the Lagrangian representation is needed to achieve the same position information, lowering the computational cost. We can further reduce the computational cost of pathline representation by choosing the frequency in which position information is calculated. That is, if the goal is to draw a pathline between times τ and τ + i, it may not be necessary to connect the positions of all intermediate time steps to get a sense of the fluid flow in the region, but only a subset of positions. A value κ defines the time interval at which position values are calculated. Therefore, the number of interpolations needed to visually represent a pathline goes down from i to κ i per seeded particle. 5.3 Interactive Data Exploration The previous section touched upon the computational efficiency gained by interpolation over integration during pathline construction, allowing for real time pathline creation. We exemplify the advantage of fast position calculation by offering an interactive seeding environment to explore the data set. The environment allows for the placement and movement of a

9 Figure 7. Path surfaces reconstructed using interpolation (left and middle) and integration (right). The left surface represents a real time interpolated reconstruction from trajectory information, which captures the general shape of the actual surface. The middle image serves to show how the interpolated reconstruction converges to the same surface when the flow map resolution is increased by dynamic loading of new sample trajectories. The same surface extracted with numerical integration is shown on the right. The color is for illustration purposes only and serves to differentiate the interpolated and integrated surfaces. rake, or group of seed points from which pathlines will be computed. Hereby, the environment gives way to the viewing of flow behavior at any data set position in real time, and allows for the seeking out of flow features such as salient structures. To reduce the memory footprint of the exploration environment and to promote real time rake manipulation, only a subset of the input tracers are loaded by the algorithm. More specifically, the tracers within the coarsest resolution are used to convey the data set since they were selected to cover the entire domain. The motivation behind allowing a rake to move through the flow field in real time is to locate areas suitable for further analysis. Because interpolation occurs within only a subset of the available tracers, additional trajectories within the rake neighborhood exist in the finer resolutions. Once an area of interest is found, these trajectories will be loaded in to improve the interpolation quality of the pathline. In other words, the pathlines will be interpolated from the closest possible trajectories to the seed point, thereby improving the accuracy of the reconstruction. 6. RESULTS AND ANALYSIS Let C be a univariate space curve parametrized in s R. A path-surface is the union of all pathlines passing through such a user-defined seeding curve, where s designates a specific pathline seeded at C(s). Creating visual connections between these curves along the s and t directions creates the path-surface. 6 The space curve C is what we have referred to as the rake. If the rake forms a surface instead of a curve, it becomes a two-dimensional family of pathlines with a seed surface S(u,v) R 2, otherwise referred to as a time-surface. Points seeded in this fashion jointly traverse the flow, able to present a snapshot of the surface s deformation at a time t i. Stitching these coordinates along the (u,v) axis forms a visual surface through time. 7 Both types of surfaces can be computed using the trajectory interpolations performed by the algorithm, with the only difference being the seeding strategy employed by the rake. For the presented results, the interpolation neighborhood was set to the 12 nearest neighbors and curves created with a value of κ = 4. All computations were done on an Intel Core i7 processor with 7200 RPM and 8GB of RAM. The colors chosen are for illustration purposes only and differ to simply differentiate between interpolated and integrated surfaces. 6.1 Karman Vortex Street We begin by exploring a data set exhibiting a Karman Vortex Street. The given trajectories have a total time step length of 1 36 and the data set is scaled to fit into a unit cube and contains 1,656 trajectories per 100 of a unit cube, split into 6 levels of resolution. The time step τ chosen for the pre-processing step is randomly selected from the middle of the simulation, giving a snapshot of the flow after a significant amount of time.

10 The Karman data set has one inflow boundary on the left hand side and one outflow boundary on the right where the first quarter of the data set, from left to right, holds a cylindrical object lodged in the flow. As the fluid flows over the cylinder, it pushes downward towards the middle which in turn pushes particles on the side outward and up. Figure 8 exemplifies this trend through a time surface representation. The rake begins as a rectangle, densely packed with points, which is then interpolated through time and visualized at intervals of κ. For this image, the rake is positioned above the obstacle and the resulting time surfaces also head downwards. For a close look directly behind the cylinder, an area that exhibits extremely high turbulence, Figure 9 shows three different images of the moving plane in the same location. The first two are reconstructed at the course and refined resolutions using our approach while the final surface is an Eulerian based advection using adaptive Runge Kutta 4/5. Figure The first image shows the path surface reconstruction during interactive exploration, revealing the general shape of the surface. The center image shows the surface reconstructed after additional trajectories in the vicinity of the rake are loaded from all levels of resolution. The increased density of trajectory drastically improves the accuracy of the reconstruction. Below each image in Figure 9 are reconstruction metrics measuring accuracy, performance, and I/O. Accuracy is measured as the Euclidean distance between the trajectories that make up the surface reconstructed through interpolation and the surface created through numerical integration. We treat the advected surface as the ground truth and show that our method can achieve comparable accuracy. The left-most and center image show that as additional trajectories are loaded, the accuracy improves and the difference in surfaces, when compared to the ground truth, diminishes. While not as accurate, the course reconstruction allows for a surface preview with the benefit of real-time visualization. To match ground truth accuracy, loading additional tracers takes 1,143ms, which is slightly above half the time it takes for the Eulerian surface (1,936ms). Additional trajectories are only loaded in the vicinity of the plane, resulting in a total of Figure 8. Time surfaces behind the cylinder. Time surfaces are extracted at an interval of κ = 4, showing the downward tend of trajectories from the top of the data set towards the bottom. Figure 9. Path surface comparison directly behind the cylinder in the Karman data set. Surface extracted with 100 seed points over 36 time steps. Path-surfaces reconstructed using interpolation (left and middle) and integration (right).

11 25.7MB necessary to perform the reconstruction. When compared to the 84.8MB of velocity field information needed to perform advection, our approach uses over 3 times less memory to create a near identical surface. More over, our method also took less time to construct the surface, reaching comparable accuracy faster and with less memory than the Eulerian representation. 6.2 The Jet We continue with a look at the Jet data set. The given trajectories have a total time step length of 30 and the data set 1 is scaled to fit into a unit cube and contains 1,656 trajectories per 100 of a unit cube, split into 4 levels of resolution. An overall turbulent data set, the Jet has an inflow boundary at the bottom in the form of four jets in the center. A prominent feature of interest is the plume that forms towards the top of the jet. Figure 7 is a path-surface extracted near this plume. The rake is seeded as a circle that captures trajectories spreading out as they curl in on themselves. To explore the plume in further detail, we switch to a time surface to better capture the curl of the structure. Figure 10 shows three surfaces, two of which are extracted using interpolation and the final using numerical integration with adaptive Runge Kutta 4/5. All images look up at the bottom of the forming plume, capturing it folding in on itself. As additional trajectories are loaded from finer resolutions, the interpolated surface matches up visually to the integrated surface. This is shown numerically through the average distance error metric below the images, which decreases with refinement. Figure 10. Time surface comparison of the forming plume from the jet data set. Surface extracted with 10,000 seed points after 30 time steps. Time-surfaces reconstructed using interpolation (left and middle) and integration (right). For a time surface, refinement loading is constant because position information is required at only one time step. With numerical integration however, all seed points must be advected to the representative time thereby making computation time linear. In Figure 10, the time-surface was extracted after 30 time steps, taking numerical integration 10,941ms, while completely refined interpolation took only 2,362ms. Figure 10 also shows that through the refinement step, the Lagrangian representation loaded 27.4MB of memory, compared to the 737MB loaded with numerical integration. Our method needs to only load 2 time steps when extracting time surfaces, which significantly reduces the computation time and I/O of creating the surface when compared with advection through the Eulerian representation. 7. CONCLUDING REMARKS The effort of our work culminates to placing a Lagrangian representation of a flow field on par with a Eulerian approach with respect to accuracy when constructing pathlines. The main contribution is a novel file system together with interpolation techniques that provide advantages over classic time-varying integration, exemplified here through an exploration environment. We show that using a set of tracers as input reduces computational effort in such a way as to provide a real-time, interactive tool for exploring fluid flow. While the overall process involves a pre-processing step for a given time step τ, this step need only be done once to gain the benefits of a Lagrangian flow map representation over the entire data set. For future work, we plan to extend the pre-processing stage to include multiple time steps from which the interpolation begins.

12 REFERENCES [1] Camp, D., Garth, C., Childs, H., Pugmire, D., and Joy, K., Streamline integration using mpi-hybrid parallelism on a large multicore architecture, IEEE Transactions on Visualization and Computer Graphics 17(11), (2011). [2] Monaghan, J., An introduction to SPH, Computer Physics Communications 48(1), (1988). [3] Cash, J. R. and Karp, A. H., A variable order runge-kutta method for initial value problems with rapidly varying right-hand sides, ACM Trans. Math. Softw. 16, (1990). [4] McLouglin, T., Laramee, R. S., Peikert, R., Post, F. H., and Chen, M., Over two decades of integration-based geometric flow visualization, Computer Graphics Forum 29(6), (2010). [5] Hultquist, J. P. M., Constructing stream surfaces in steady 3d vector fields, in [Proceedings of IEEE Visualization 1992], (1992). [6] Garth, C., Krishnan, H., Tricoche, X., Bobach, T., and Joy, K., Generation of accurate integral surfaces in timedependent vector fields, IEEE Transactions on Visualization and Computer Graphics 14(6), (2008). [7] Krishnan, H., Garth, C., and Joy, K., Time and streak surfaces for flow visualization in large time-varying data sets, IEEE Transactions on Visualization and Computer Graphics 15(6), (2009). [8] Burger, K., Ferstl, F., Theisel, H., and Westermann, R., Interactive streak surface visualization on the GPU, IEEE Transactions on Visualization and Computer Graphics 15(6), (2009). [9] van Wijk, J. J., Implicit stream surfaces, in [VIS 93: Proceedings of the Conference on Visualization 93], (1993). [10] Westermann, R., Johnson, C., and Ertl, T., A level-set method for flow visualization, in [Proceedings of IEEE Visualization 2000], (2000). [11] Obermaier, H., Hering-Bertram, M., and Hagen, H., Topological flow volume extraction from time-surface maps, Computer Aided Geometric Design 30(6), (2013). [12] Hlawatsch, M., Sadlo, F., and Weiskopf, D., Hierarchical line integration, IEEE Transactions on Visualization and Computer Graphics 17(8), (2011). [13] Chandler, J., Obermaier, H., and Joy, K., Interpolation-based pathline tracing in particle-based flow visualization, IEEE Transactions on Visualization and Computer Graphics 99 (2014). [14] Salzbrunn, T., Wiebel, A., and Scheuermann, G., Efficient construction of flow structures, in [The Seventh IASTED International Conference on Visualization, Imaging and Image Processing], (2007). [15] Weinkauf, T. and Theisel, H., Streak lines as tangent curves of a derived vector field, IEEE Transactions on Visualization and Computer Graphics 16(6), (2010). [16] Theisel, H. and Seidel, H.-P., Feature flow fields, in [Proceedings of the Symposium on Data Visualisation], (2003). [17] Lodha, S., Renteria, J., and Roskin, K., Topology preserving compression of 2d vector fields, in [Proceedings of Visualization 2000], (2000). [18] Haller, G., Distinguished material surfaces and coherent structures in three-dimensional fluid flows, Physica D: Nonlinear Phenomena 149(4), (2001). [19] Sadlo, F. and Peikert, R., Efficient visualization of lagrangian coherent structures by filtered AMR ridge extraction, IEEE Transactions on Visualization and Computer Graphics 13(6), (2007). [20] Garth, C., Gerhardt, F., Tricoche, X., and Hagen, H., Efficient computation and visualization of coherent structures in fluid flow applications, IEEE Transactions on Visualization and Computer Graphics 13(6), (2007). [21] Levin, D., The approximation power of moving least-squares, Mathematics of Computation 67, (1998).