Unmapped Tent Pitching (UTP) Algorithm

• UTP algorithm is a space–time domain decomposition method that solves hyperbolic PDEs directly on axis‐aligned rectangles without nonlinear mappings.
• It achieves optimal computational cost and high parallel scalability by selecting rectangular subdomains based on the maximum wave speed in both homogeneous and heterogeneous media.
• By eliminating the mapping step inherent in MTP, UTP simplifies implementation and improves load balancing, enhancing robustness in solving the one-dimensional wave equation.

The Unmapped Tent Pitching (UTP) algorithm is a space–time domain decomposition technique for parallel solution of hyperbolic partial differential equations (PDEs), particularly the second-order one-dimensional wave equation. UTP generalizes algorithms such as Mapped Tent Pitching (MTP) by eschewing the use of nonlinear mapping, instead solving the local problems directly on axis-aligned space–time rectangles. The method's design provides straightforward parallelization and efficient execution, even for problems with piecewise-constant heterogeneous media, and attains optimal computational cost when tent sizes are chosen according to the maximum wave propagation speed in the domain (Bonazzoli et al., 14 Jan 2026).

1. Mathematical Setting and Problem Formulation

UTP is defined for the scalar wave equation on a spatial interval $\Omega = (0, L)$ and temporal domain $t \in (0, T)$: $$\partial_{tt} u(x, t) = c(x)^2\ \partial_{xx} u(x, t), \quad (x, t) \in \Omega \times (0, T)$$ subject to homogeneous Dirichlet boundary conditions: $u(0, t) = u(L, t) = 0, \quad t \in (0, T]$ and initial data: $$u(x, 0) = f(x),\quad \partial_t u(x, 0) = g(x), \; x \in \Omega.$$

The wave speed $c(x)$ may be homogeneous ($c(x) = c$) or heterogeneous, e.g.,

$$c(x) = \begin{cases} c_1, & x \in (0, L/2] \ c_2, & x \in (L/2, L) \end{cases},\quad c_1>c_2>0.$$

2. Tent Pitching Paradigm and CFL Constraints

The conceptual foundation of UTP arises from the tent pitching paradigm, in which spacetime is decomposed into local computational subdomains—tents—whose slopes follow the characteristics $\pm 1/c(x)$. The MTP algorithm [Gopalakrishnan, Schöberl, Wintersteiger, 2017] constructs each tent and maps it to a tensor-product spacetime cylinder for local solution of the PDE, followed by a backward mapping to the physical domain. This mapping may introduce nonlinearities and potential singularities, especially when tent heights approach the Courant-Friedrichs-Lewy (CFL) limit.

UTP circumvents these difficulties by embedding each tent within a larger, axis-aligned spacetime rectangle. This eliminates the need for nonlinear mapping and allows all local computations to be carried out directly, albeit at the expense of redundant calculations in the region outside the true tent. The rectangle height $H_j$ over a spatial tent base $I_j$ of length $\Delta x_j$ is subject to a CFL-like bound: $H_j \leq \frac{\Delta x_j}{c_{\max}(I_j)}$ where $c_{\max}(I_j)$ is the maximum wave speed over $I_j$.

3. Construction of UTP Subdomains and Algorithmic Workflow

The UTP algorithm employs a mesh of $N$ equispaced points $x_j = j \frac{L}{N-1}$ for $j=0,\ldots, N-1$. Overlapping spatial subintervals $I_j = (x_{j-1}, x_{j+1})$ for $j=1,\dots, N-2$ are defined, colored alternately as "red" and "black". In the homogeneous case, the rectangle height is set as $H = \frac{L}{c(N-1)}$.

Tents are pitched in alternate (red/black) intervals at each iteration $k$ as follows:

• For $k=1$, rectangles $\mathcal T_j^1 = I_j \times (0, H)$ for $j$ in the red set.
• For $k \geq 2$, rectangles $$\mathcal T_j^k = I_j \times (v_j^{k-2}, v_j^{k-2} + 2H)$$, where $v_j^0 = 0$ and $v_j^k = v_j^{k-2} + 2H$.

Iteration terminates once $\cup_j\mathcal T_j^k$ covers the spacetime domain.

Within each active rectangle at iteration $k$, the local initial-boundary value problem is: $$\begin{cases} \partial_{tt} u_j^k = c(x)^2\, \partial_{xx} u_j^k & \text{in } \mathcal T_j^k, \ u_j^k = u^{k-1},\; \partial_t u_j^k = \partial_t u^{k-1} & \text{on lower and lateral inflow boundaries,} \end{cases}$$ plus Dirichlet data at $x=0, L$ if $I_j$ adjoins $\partial\Omega$.

Standard explicit or implicit finite-difference or finite-element schemes constrained by the CFL condition are applicable. Following local solution, $u_j^k$ is restricted to the true tent subregion. The global solution $u^k(x,t)$ is assembled by updating values from $u_j^k$ on the active rectangles, retaining $u^{k-1}(x,t)$ elsewhere. Iteration proceeds until full domain coverage.

4. Comparative Analysis of UTP and MTP

Feature	MTP	UTP
Local Mapping	Nonlinear tent-to-cylinder diffeomorphism	No mapping; axis-aligned rectangles
Accuracy Limits	Mapping may deteriorate accuracy (near singularity at CFL limit)	No loss of order; redundancy outside true tent only
CFL/Step Size	Mapping restricts tent height more than PDE	Usual CFL dictated by PDE
Parallelization	Tent-based; not always optimal rectangular load balance	Perfectly load-balanced (up to $2m_1$ cores)
Implementation Complexity	Requires map/unmap for each tent	Direct implementation on rectangles

MTP utilizes nonlinear mappings, which, approaching the limiting height, can produce singularities and enforce stricter height constraints than dictated by the equation. UTP dispenses with such mappings, allowing the full height possible via the CFL condition of the largest $c(x)$ in the tent base, and uses standard numerical time-stepping on the axis-aligned rectangles.

5. Extensions to Heterogeneous Media and Optimal Tent Choices

In heterogeneous media, where $c(x)$ is piecewise-constant, subintervals are divided into regions with $c_1$ and $c_2$ $(c_1 > c_2)$. Setting $m_1$ and $m_2$ as the number of left/right cells, base lengths and rectangle heights can follow local or global CFL restrictions: $$L_1 = \frac{L}{2 m_1},\ H_1 = \frac{L_1}{2 c_1};\qquad L_2 = \frac{L}{2 m_2},\ H_2 = \frac{L_2}{2 c_2}$$ or, in globally optimal strategy,

$H_2 = H_1 = \frac{L_1}{2 c_1},\quad m_2 = m_1.$

The cost of local rectangle solves is proportional to their area $$A = L_1 H_1 = \frac{L_1^2}{2c_1} = \frac{L^2}{8 m_1^2 c_1}$$. With $2m_1$ processors and $2m_1$ red and $2m_1$ black steps needed to reach $T = L/(2c_1)$, the optimal total work is: $$\mathrm{Work}_{\text{UTP}} = 2(2m_1\,A) = \frac{L^2}{2 m_1 c_1}$$

Thus, uniform spatial and temporal tent sizes based on the maximum speed $c_1$ yield optimal cost balance, eliminating the need for nonuniform tent sizing or step management at material interfaces.

6. Computational Cost, Scalability, and Accuracy

The UTP algorithm achieves perfect load balancing except for one idle processor in black steps, with wall-clock time scaling ideally to $2m_1$ parallel cores. All rectangles can leverage high-order time-stepping methods (e.g., Runge-Kutta, multistep) without further constraints. The classical CFL restriction holds based on local wave speed and rectangle size; there is no mapping-induced reduction of the maximum allowable time step.

Numerical experiments (cited but not detailed in (Bonazzoli et al., 14 Jan 2026)) confirm UTP achieves the same convergence rates as MTP, while requiring simpler implementation and yielding better parallel efficiency for piecewise-constant heterogeneous wave speeds.

7. Summary and Significance

The Unmapped Tent Pitching algorithm introduces a robust, fully parallel framework for solving the wave equation in both homogeneous and heterogeneous one-dimensional settings. By eschewing nonlinear mappings and adopting axis-aligned rectangles of uniform size determined by the fastest medium, UTP optimally balances computational work, achieves high scalability, and supports the direct use of standard time-stepping integration schemes. For piecewise-constant heterogeneous domains, the method attains minimum wall-clock cost and full accuracy, as demonstrated by analytical work-balance calculations and numerical evidence (Bonazzoli et al., 14 Jan 2026).