Features

Portage supports three types of remap:

• Intersection-based remap is a conservative scheme that relies on exact intersection of source and target meshes. It first identifies the candidate source cells that may potentially overlap each target cell. It then computes two moments of intersection (volume and centroid) between each target cell and overlapping source cells (Figure 2). Finally, it interpolates the target cell value from the candidate source cells values using the moments of intersection as weights [2].
• Advection-based remap is a conservative scheme specifically designed for meshes with the same topology but with different node positions. As described earlier, this need arises from ALE hydrodynamic simulations when the mesh is slightly smoothed to prevent cell distortion induced by the Lagrangian fluid motion. Here, the remap is formulated as an advection or fluxing of integral quantities in/out of each cell through its faces. Any quantity that is fluxed out of a cell is added into one of its neighbors, so the method is intrinsically conservative. In this algorithm, the interpolation weights are deduced from the flux volumes, which is less expensive – but less accurate – than the previous remap scheme [9].
• Particle remap is a specific scheme for point clouds. In this method, source fields are reconstructed by means of local regression [10]. Here a shape function is attached to each source point (scatter form) or each target point (gather form). The algorithm first identifies the source points included in the support of the shape function of a target point (Figure 3) which are included in the zone delimited by the user-defined smoothing lengths which control the number of points used for the local regression. It then computes the weights by evaluating the shape function and its derivatives on each point. Finally, it approximates the value on each target point using those weights. Despite its high accuracy, this remap method is not conservative.

Each step can be processed in parallel with the granularity of a single point or cell.

Design

Portage has a modular design. It relies on extensive C++ templating of all remap steps, allowing client codes to extend, adapt or replace them by customized ones. Besides, most of its core methods are designed to have no side-effects to ease their parallelization and their individual reuse. Portage’s components and their interactions are given in Figure 4.

Portage takes the source and target domains along with fields data as inputs, and then outputs remapped fields on the target domain. Here a domain can be a mesh or a point cloud. For multi-material fields, it requires the material volume fractions on the source domain as depicted in Figure 5, and which corresponds to the proportion of each material on each cell. The remap workflow consists of six stages:

1. Redistribution: this optional step is only necessary for distributed domains with a mismatch between the source and target partitions. In that case, some source entities (points or cells) are reassigned among MPI ranks such that each target subdomain is overlapped by the corresponding source subdomain. This eliminates the need for communications in the remaining steps.
2. Interface reconstruction: this optional step is only required for multi-material fields and is performed by a dedicated plugin called Tangram. It recovers the interface between different materials by computing the material polygons on each source cell, given their volume fractions and, optionally, their centroids for a second-order remap accuracy.
3. Search: this step identifies and retrieves the source entities that are necessary to interpolate the value of a given target entity. The algorithm depends on the remap scheme:
   • intersection: collects the source cells that may overlap the target cell.
   • advection: collects the source cell itself and a subset of its neighbors.
   • particle: collects the source points included in the support of the shape function of a target point in scatter form, and vice-versa for gather form.
4. Computation of weights: this step computes the contribution weights of each identified source entity to reconstruct the value on a given target entity. Again, the algorithm depends on the remap scheme:
   • intersection: computes the moments of intersection (volume and centroids) of each candidate source cell that overlaps the target cell.
   • advection: computes the moments of each swept polyhedron (volume and centroids) formed by the displacement of each face of the source cell.
   • particle: computes and accumulates the values of the shape functions and their derivatives on each point given by the search step.
5. Interpolation: this step reconstructs the target entity values by interpolating them using the computed weights. For mesh remap, the gradient of the source field is required to achieve a second-order accurate reconstruction. It is computed in Portage by a least-squares method. Here, values can be limited using Barth-Jespersen’s limiter [11], except at domain boundaries because boundary conditions are not yet supported. For particles, we use the term estimation as recovered values may pass near the data not necessarily through it.
6. Repair: this step is only necessary in case of mismatch between source and target mesh boundaries. Here, remapped values are fixed to enforce the conservation of integral quantities. Portage exposes three options to fix partially overlapped cells:
   • constant-preserving: no field value perturbations but not conservative.
   • locally-conservative: conservative but perturbations may occur: constant fields may not remain constant.
   • shifted-conservative: conservative with minimal perturbations but values are shifted: constant field remains constant but with a different value.

It is also possible to extrapolate values to empty cells in the target mesh.

Driver

A driver is the interface that exposes the remap capabilities to the client simulation code. Writing a driver allows client codes to mix, match, or extend specialized remap components for their particular needs. Portage comes with a few drivers to ease the design of custom ones and several apps to show common remap use cases. Each driver is templated on core components (interface reconstruction, search, weight computation, interpolation) for each remap method (intersection, advection, particle) and on mesh type. If the simulation code provides a mesh with a set of queries that conforms with the mesh wrapper interface, then no data recopy is involved. Portage embeds five built-in drivers:

• uberdriver: an easy to use mesh remap class.
• coredriver: a low-level mesh driver that allows finer control on remap steps.
• mmdriver: a legacy monolithic mesh remap driver.
• driver_swarm: a dedicated particle remap driver.
• driver_mesh_swarm_mesh: a mesh remap driver that relies on particle kernels.

A basic example of a single-material mesh remap using coredriver methods (using default parameters where possible) is given in Listing 1. A list of available options for remap components is given in Table 1. Each of them is templated on source and target domains as well as field entity types.