Papers
Topics
Authors
Recent
Search
2000 character limit reached

FlowSlider: CFD & Generative Methods

Updated 5 July 2026
  • FlowSlider is a term for two distinct methods in CFD and generative modeling, each defined by unique mathematical frameworks and evaluation criteria.
  • In computational fluid dynamics, FlowSlider employs a mortar-based sliding interface for DGSEM that ensures conservation, free-stream preservation, and efficient MPI communication.
  • In generative modeling, FlowSlider enables training-free continuous image editing via a fidelity-steering decomposition that maintains edit fidelity while allowing slider-style control.

FlowSlider is a term that appears in two distinct technical contexts in the arXiv literature. In computational fluid dynamics, it denotes a high-order, mortar-based sliding-mesh interface for DGSEM, introduced as an efficient implementation for discontinuous Galerkin compressible Navier–Stokes solvers and demonstrated in large-scale turbomachinery LES (Dürrwächter et al., 2020). In generative modeling, it denotes a training-free method for continuous image editing in Rectified Flow, based on a fidelity-steering decomposition of FlowEdit’s update that enables slider-style control without post-training (Endo et al., 2 Apr 2026). The shared name therefore refers not to a single framework, but to two domain-specific constructions with different mathematical objects, implementation constraints, and evaluation criteria.

1. Name, scope, and disciplinary usage

In the current literature represented here, “FlowSlider” names two separate methods.

Usage Domain Core characterization
FlowSlider Computational fluid dynamics High-order, mortar-based sliding-mesh interface for DGSEM
FlowSlider Generative modeling Training-free continuous image editing via fidelity-steering decomposition

The CFD usage is embedded in the theory and implementation of sliding meshes for deformed domains, where different parts of the domain are in relative motion. Its primary concerns are non-conforming interface coupling, conservation, free-stream preservation, and efficient MPI communication in a dynamically changing mesh topology. The image-editing usage is embedded in Rectified Flow-based prompt-pair editing on real images, where the central problem is continuous edit-strength control under fidelity constraints.

A recurrent source of ambiguity is therefore terminological rather than methodological. The two methods share a label but operate on different state spaces: DG face and mortar representations in one case, and latent ODE trajectories and guided velocity fields in the other.

2. Mortar-based sliding interfaces for DGSEM

In the CFD setting, FlowSlider is defined as a high-order, mortar-based sliding-mesh interface for DGSEM with minimal overhead in both computation and MPI communication (Dürrwächter et al., 2020). At each non-conforming interface between a static and a moving sub-domain, a layer of 2D mortar elements is introduced, and each DG face Ω\Omega is split into two mortars Ξ1,Ξ2\Xi_1,\Xi_2. The coupling consists of three operations: projecting the DG solution, and its gradients for viscous terms, from the face onto the mortars; computing a unique numerical flux via a Riemann solver on each mortar; and projecting that flux back onto the two faces.

For the projection Ω→Ξ\Omega \to \Xi, with ℓi\ell_i denoting the 1D Lagrange basis on [−1,1][-1,1] at the Gauss–Lobatto nodes, the face representation is written as

Uk(ξ)≃∑i=0NU^ik ℓi(ξ).U^k(\xi) \simeq \sum_{i=0}^N \hat U_i^k\,\ell_i(\xi).

On the mortar Ξ\Xi, a local coordinate z∈[−1,1]z \in [-1,1] is introduced, with a linear mapping ξ=ξ(z)\xi=\xi(z) depending on the hanging-node position σ\sigma. The un-weighted L2L^2 projection onto Ξ\Xi yields

Q^iΞ,L/R=(M−1SΩ→Ξ)ij U^j≡PijΩ→Ξ U^j,\hat Q_i^{\Xi,L/R} = (M^{-1}S^{\Omega\to\Xi})_{ij}\,\hat U_j \equiv P^{\Omega\to\Xi}_{ij}\,\hat U_j,

where

Mij=∫−11ℓi(z) ℓj(z) dz,SijΩ→Ξ=∫−11ℓi(ξ(z)) ℓj(z) dz.M_{ij} = \int_{-1}^1 \ell_i(z)\,\ell_j(z)\,dz,\qquad S^{\Omega\to\Xi}_{ij} = \int_{-1}^1 \ell_i(\xi(z))\,\ell_j(z)\,dz.

The operator PΩ→ΞP^{\Omega\to\Xi} depends only on σ\sigma and NN and can be precomputed for planar interfaces or assembled on the fly for curved ones.

For the back-projection Ξ→Ω\Xi \to \Omega, after computing a unique flux FΞ,L/R(z)\mathfrak{F}^{\Xi,L/R}(z) on the mortar, FlowSlider enforces

∫Ω(FΩ(ξ)−FΞ(z(ξ))) ℓj(ξ) dξ=0,\int_{\Omega} \bigl(\mathfrak{F}^{\Omega}(\xi)-\mathfrak{F}^{\Xi}(z(\xi))\bigr)\,\ell_j(\xi)\,d\xi = 0,

which yields

F^Ω=PΞ→Ω F^Ξ=(1−σ2M−1SΞ1→Ω+1+σ2M−1SΞ2→Ω) F^Ξ.\hat{\mathfrak{F}}^\Omega = P^{\Xi\to\Omega}\,\hat{\mathfrak{F}}^\Xi = \Bigl(\frac{1-\sigma}{2}M^{-1}S^{\Xi_1\to\Omega} +\frac{1+\sigma}{2}M^{-1}S^{\Xi_2\to\Omega}\Bigr)\,\hat{\mathfrak{F}}^{\Xi}.

For straight faces, conservation follows because SS and MM are exact for polynomials of degree ≤N\le N, so that

∑mortars∫Ξℓi(z) dz=∫Ωℓi(ξ) dξ.\sum_{\text{mortars}}\int_{\Xi}\ell_i(z)\,dz = \int_{\Omega}\ell_i(\xi)\,d\xi.

The free-stream test is also exact: for U(ξ)=constU(\xi)=\mathrm{const}, one has U^j=U∗\hat U_j = U^\ast for all jj, and therefore

Q^i=(M−1S)ij U∗=U∗∑j(M−1M)ij=U∗,\hat Q_i = (M^{-1}S)_{ij}\,U^\ast = U^\ast\sum_j(M^{-1}M)_{ij} = U^\ast,

with back-projection again returning U∗U^\ast. This establishes constant-state preservation on plane interfaces.

3. Three-dimensional algorithmics, MPI workflow, and scaling

For the general curved-interface case, FlowSlider represents surface mortars as 2D curved patches. In DGSEM, each mortar is represented by tensor-product polynomials of degree NN in both mortar directions, and the 2D projections decompose into two successive 1D operations along each coordinate line (Dürrwächter et al., 2020). In the planar-interface specialization, interfaces are Cartesian in one movement-parallel direction and possibly curved in the other two. If the movement is pure rotation about a fixed axis or pure translation, hanging-node positions σ\sigma are identical for all faces at a given time, so PΩ→ΞP^{\Omega\to\Xi} and PΞ→ΩP^{\Xi\to\Omega} are shared.

The implementation uses explicit connectivity and storage structures. Each static face is indexed by (i∥,i⊥)(i_{\parallel}, i_{\perp}), and each mortar has a sub-index sub∈{0,1}\mathrm{sub}\in\{0,1\}. A one-to-one map mortarID=m(i∥,i⊥,sub)\mathrm{mortarID}=m(i_{\parallel}, i_{\perp}, \mathrm{sub}) stores process-local ordering. The principal arrays are Uprimarysm[mortarID,(N+1)×vars]U_{\mathrm{primary}}^{sm}[\mathrm{mortarID}, (N+1)\times \mathrm{vars}], Ureplicasm[… ]U_{\mathrm{replica}}^{sm}[\dots], Fprimarysm[… ]F_{\mathrm{primary}}^{sm}[\dots], and Freplicasm[… ]F_{\mathrm{replica}}^{sm}[\dots]. The parameter σ\sigma is updated every stage or time-step; if σ\sigma crosses ±1\pm 1, hanging indices i∥i_{\parallel} shift by one and the sorting is recomputed only then.

Parallelization emphasizes a priori communication partner determination. During initialization, for each static face (i∥,i⊥)(i_{\parallel}, i_{\perp}), the MPI rank rmove(i∥,i⊥)r_{\mathrm{move}}(i_{\parallel}, i_{\perp}) of the adjacent moving-subdomain process is looked up and broadcast, and the moving side stores rstat(i∥,i⊥)r_{\mathrm{stat}}(i_{\parallel}, i_{\perp}). This global exchange is performed once. To satisfy the conditions that partners and message size are known a priori, data are contiguous, and ordering is identical on send and receive, a local index array AA of tuples (rank_partner,i∥,i⊥,sub,localFaceID)(\mathrm{rank\_partner}, i_{\parallel}, i_{\perp}, \mathrm{sub}, \mathrm{localFaceID}) is built and sorted lexicographically by (rank_partner,i∥,i⊥,sub)(\mathrm{rank\_partner}, i_{\parallel}, i_{\perp}, \mathrm{sub}). The sorted column index is mortarID\mathrm{mortarID}, which defines both packing of UreplicasmU_{\mathrm{replica}}^{sm} before MPI_Isend and unpacking of incoming UprimarysmU_{\mathrm{primary}}^{sm} after MPI_Irecv. The inverse map m(localFaceID,sub)=mortarIDm(\mathrm{localFaceID}, \mathrm{sub})=\mathrm{mortarID} is retained for fast packing and unpacking during projection.

The per-stage or per-time-step workflow computes local σ\sigma; checks whether ⌊σ⌋\lfloor \sigma \rfloor has changed and, if so, recomputes AA and the sorting; interpolates Uface→UreplicasmU_{\mathrm{face}}\to U_{\mathrm{replica}}^{sm} using m( )m(\,); exchanges replica and primary data by nonblocking MPI; overlaps the exchange with local DG interior work; waits for the arrival of UprimarysmU_{\mathrm{primary}}^{sm}; computes the mortar flux FprimarysmF_{\mathrm{primary}}^{sm} on the static side via a Riemann solver; exchanges flux data; and finally projects Freplicasm→FfaceF_{\mathrm{replica}}^{sm}\to F_{\mathrm{face}} on the moving side and Fprimarysm→FfaceF_{\mathrm{primary}}^{sm}\to F_{\mathrm{face}} on the static side.

Performance data were reported on Hazel Hen, a Cray XC40 with 24 cores per node, at DG order N=5N=5. Strong scaling up to 12 288 cores achieved efficiency >80%>80\% for ≥10 000\ge 10\,000 DOF/core. Weak scaling from 36 to 288 elements/core achieved efficiency ≳90%\gtrsim 90\%. Relative to static DGSEM, PID degrades by approximately 15%15\% due to ALE flux and mortar operations. Additional memory scales as O(#mortars×(N+1)×vars)O(\#\mathrm{mortars}\times (N+1)\times \mathrm{vars}), and for a typical rotor-stator partition it adds approximately $5$–8%8\% to total memory.

4. Validation and turbomachinery application

The CFD FlowSlider was validated by both analytical and application-oriented studies (Dürrwächter et al., 2020). In a 2D isentropic vortex crossing a curved interface, L2L_2 errors of ρ\rho at t=4.0t=4.0 showed rates approximately N+1N+1 for N=2…5N=2\ldots 5. In a 3D manufactured sine wave with a planar sliding interface, L2L_2 errors at t=1.0t=1.0 recovered full order. These results support the stated high-order accuracy of the mortar-based interface treatment.

A large-scale practical application was a wall-resolved implicit LES of the 1½-stage Aachen turbine. The mesh comprised 966 288 hexahedral elements, 24 layers in span, 5th-order curved geometry, and approximately 208 M DOF with sixth-order polynomials. Sliding interfaces were placed between stator–rotor and rotor–stator, with periodicity in pitch. Boundary conditions were measured inflow (ρ,p,v)(\rho,p,v) at the stator inlet, pressure outflow with sponge, and adiabatic no-slip walls. Time integration used a 4-stage low-storage RK scheme with μ=1.8e−5 kg/m s\mu=1.8\mathrm{e}{-5}\,\mathrm{kg}/\mathrm{m\,s}, R=287 J/kg KR=287\,\mathrm{J}/\mathrm{kg\,K}, γ=1.4\gamma=1.4, and Pr=0.72\mathrm{Pr}=0.72.

The reported compute cost was approximately 27 000 CPU h per rotor period on 4800 cores, with PID≈1.3 μs/DOF/stage\mathrm{PID}\approx 1.3\,\mu\mathrm{s}/\mathrm{DOF}/\mathrm{stage}. Phase-averaged surface pressure on stator 1, rotor, and stator 2 matched URANS and experiments at trailing edges. Instantaneous λ2\lambda_2-isosurfaces revealed transition on the stator suction side, wake–rotor interaction, and vortex shedding. Rotor blade lift versus phase showed maxima and minima when the stator wake impinged on the pressure side and suction side, and the lift spectrum exhibited a dominant 3rd harmonic of the blade-passing frequency and peaks near stator-wake shedding frequency.

Taken together, these results support the concluding characterization that the mortar approach achieves high-order accuracy O(ΔxN+1)O(\Delta x^{N+1}) across moving interfaces, provable conservation and free-stream preservation, excellent strong and weak scaling with only approximately 15%15\% overhead, and practical utility in expensive LES of turbomachinery.

5. Continuous image editing in Rectified Flow

In the generative-modeling setting, FlowSlider is a training-free method for continuous image editing in Rectified Flow that requires no post-training (Endo et al., 2 Apr 2026). Rectified Flow models define a learnable ODE via the straight-line interpolation

zt=(1−t)⋅z1+t⋅z0,t∈[0,1],z_t = (1-t)\cdot z_1 + t\cdot z_0,\qquad t\in[0,1],

with learned velocity Vt(zt)≃dzt/dtV_t(z_t)\simeq dz_t/dt. Conditioning by classifier-free guidance is written as

Vcfg(zt,t,c)=V(zt,t,∅)+ω⋅[V(zt,t,c)−V(zt,t,∅)],V_{\mathrm{cfg}}(z_t,t,c) = V(z_t,t,\varnothing) + \omega\cdot [V(z_t,t,c)-V(z_t,t,\varnothing)],

where ω≥0\omega\ge 0 is the guidance scale.

The immediate precursor is FlowEdit, which extends Rectified Flow from single-prompt generation to prompt-pair editing (csrc→ctar)(c_{\mathrm{src}}\to c_{\mathrm{tar}}) on real images without inversion. At each integration time tt, FlowEdit forms a noisy source state

ztsrc=(1−t)xsrc+tϵ,z_t^{\mathrm{src}} = (1-t)x_{\mathrm{src}} + t\epsilon,

maintains an edit trajectory zteditz_t^{\mathrm{edit}} initialized to znmax⁡srcz_{n_{\max}}^{\mathrm{src}} at the chosen edit-start step, anchors a target state

zttar=ztedit+(ztsrc−xsrc),z_t^{\mathrm{tar}} = z_t^{\mathrm{edit}} + (z_t^{\mathrm{src}} - x_{\mathrm{src}}),

computes the difference update

VΔ(t)=V(zttar,t,ctar)−V(ztsrc,t,csrc),V^\Delta(t) = V(z_t^{\mathrm{tar}}, t, c_{\mathrm{tar}}) - V(z_t^{\mathrm{src}}, t, c_{\mathrm{src}}),

and advances zteditz_t^{\mathrm{edit}} by dz/dt=VΔ(t)dz/dt = V^\Delta(t).

The motivation for FlowSlider is that FlowEdit, at its default strength s=1s=1, produces high-fidelity edits, but naively scaling VΔV^\Delta by s>1s>1 amplifies both semantic change and residual noise, leading to artifacts and drift, including ringing and structural collapse. FlowSlider addresses this by introducing an additional term V(zttar,t,csrc)V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}}) and decomposing

VΔ(t)=[V(zttar,t,ctar)−V(zttar,t,csrc)]+[V(zttar,t,csrc)−V(ztsrc,t,csrc)]≡Vsteer(t)+Vfid(t).V^\Delta(t) = \bigl[V(z_t^{\mathrm{tar}}, t, c_{\mathrm{tar}})-V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}})\bigr] + \bigl[V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}})-V(z_t^{\mathrm{src}}, t, c_{\mathrm{src}})\bigr] \equiv V_{\mathrm{steer}}(t)+V_{\mathrm{fid}}(t).

In compact form,

Δx=VΔ(t)=F(x,x0,t)+S(x,t),\Delta x = V^\Delta(t) = F(x,x_0,t)+S(x,t),

with

S(x,t)≡Vsteer(t)=V(zttar,t,ctar)−V(zttar,t,csrc)S(x,t)\equiv V_{\mathrm{steer}}(t) = V(z_t^{\mathrm{tar}}, t, c_{\mathrm{tar}}) - V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}})

and

F(x,x0,t)≡Vfid(t)=V(zttar,t,csrc)−V(ztsrc,t,csrc).F(x,x_0,t)\equiv V_{\mathrm{fid}}(t) = V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}}) - V(z_t^{\mathrm{src}}, t, c_{\mathrm{src}}).

Within this formulation, the fidelity term FF acts as a source-conditioned stabilizer because both velocities use the same prompt csrcc_{\mathrm{src}} and differ only in state, while the steering term SS isolates the cross-prompt velocity difference at the same state zttarz_t^{\mathrm{tar}}. The strength-parameterized update is then defined as

VsΔ(t)=F(x,x0,t)+s⋅S(x,t),V_s^\Delta(t) = F(x,x_0,t) + s\cdot S(x,t),

or, in shorthand,

Δx(s)=F+s S.\Delta x(s)=F+s\,S.

This recovers FlowEdit exactly at s=1s=1 and permits attenuated edits for s<1s<1 and amplified edits for s>1s>1 without retraining.

6. Fidelity-steering geometry, inference-time procedure, and empirical behavior

A central claim of the image-editing FlowSlider is geometric: the instantaneous angle θ(t)\theta(t) between Vfid(t)V_{\mathrm{fid}}(t) and Vsteer(t)V_{\mathrm{steer}}(t) is measured by

cos⁡θ(t)=⟨Vfid(t),Vsteer(t)⟩∥Vfid(t)∥⋅∥Vsteer(t)∥,\cos \theta(t) = \frac{\langle V_{\mathrm{fid}}(t),V_{\mathrm{steer}}(t)\rangle} {\|V_{\mathrm{fid}}(t)\|\cdot \|V_{\mathrm{steer}}(t)\|},

and empirically clusters near 90∘90^\circ (Endo et al., 2 Apr 2026). Under the scaled update VsΔ=F+s⋅SV_s^\Delta = F+s\cdot S, the squared norm becomes

∥VsΔ∥2=∥F∥2+s2∥S∥2+2s ∥F∥ ∥S∥cos⁡θ.\|V_s^\Delta\|^2 = \|F\|^2 + s^2\|S\|^2 + 2s\,\|F\|\,\|S\|\cos\theta.

When cos⁡θ≈0\cos\theta \approx 0, varying ss changes the steering magnitude almost independently of the fidelity component. The reported projections are

pfid(s,t)=⟨VsΔ,F^⟩=∥F∥+s∥S∥cos⁡θ≈∥F∥,p_{\mathrm{fid}}(s,t) = \langle V_s^\Delta,\hat F\rangle = \|F\| + s\|S\| \cos\theta \approx \|F\|,

and

psteer(s,t)=⟨VsΔ,S^⟩=s∥S∥,p_{\mathrm{steer}}(s,t) = \langle V_s^\Delta,\hat S\rangle = s\|S\|,

which formalize the claim that steering grows linearly in ss while fidelity remains stable.

Implementation is entirely at inference time. At each solver step, three guided velocity fields are evaluated: V(zttar,t,ctar)V(z_t^{\mathrm{tar}}, t, c_{\mathrm{tar}}), V(zttar,t,csrc)V(z_t^{\mathrm{tar}}, t, c_{\mathrm{src}}), and V(ztsrc,t,csrc)V(z_t^{\mathrm{src}}, t, c_{\mathrm{src}}). Relative to FlowEdit’s two calls, this adds one extra network call but introduces no new weights and no training. With T=28T=28 ODE steps, as in the experiments, and one RK2 or Euler step per tt, the velocity evaluations are the only stated overhead. The operational loop initializes zsrcz^{\mathrm{src}} and zeditz^{\mathrm{edit}} at tnmax⁡t_{n_{\max}}; for i=nmax⁡→1i=n_{\max}\to 1, recomputes z(i)srcz^{\mathrm{src}}_{(i)}, forms z(i)tar=z(i)edit+(z(i)src−xsrc)z^{\mathrm{tar}}_{(i)} = z^{\mathrm{edit}}_{(i)} + (z^{\mathrm{src}}_{(i)}-x_{\mathrm{src}}), computes SS and FF, forms V(s)Δ←F+s⋅SV^\Delta_{(s)} \leftarrow F+s\cdot S, and updates z(i−1)edit←z(i)edit+Δt⋅V(s)Δz^{\mathrm{edit}}_{(i-1)} \leftarrow z^{\mathrm{edit}}_{(i)} + \Delta t \cdot V^\Delta_{(s)} before returning xedit=z(0)editx^{\mathrm{edit}} = z^{\mathrm{edit}}_{(0)}.

The experiments used FLUX.1-dev and Stable Diffusion 3 Medium as Rectified Flow backbones. Evaluation included a 250-image continuous-editing benchmark spanning season, weather, decay, style, and portrait attributes, together with PIE-Bench general editing for out-of-distribution evaluation. Edit quality was measured by CLIP-dir and DreamSim, while slider behavior was measured by Monotonicity, defined as the fraction of consecutive ss steps where CLIP-T↑\uparrow and DreamSim↑\uparrow, and by Smoothness, defined as the worst-case normalized triangle deficit over LPIPS distances. Baselines included learning-based sliders, namely Kontinuous Kontext and SliderEdit, as well as heuristic alternatives such as CFG-scale tuning, edit-window tuning (nmax⁡)(n_{\max}), naive VΔV^\Delta scaling, and linear interpolation of velocities.

On the FLUX.1 backbone, averaged over s∈{1…5}s\in\{1\ldots 5\}, FlowSlider achieved the highest Mono≈0.83\mathrm{Mono}\approx 0.83 and lowest Smooth≈0.01\mathrm{Smooth}\approx 0.01, together with top-tier edit quality at DreamSim≈0.09\mathrm{DreamSim}\approx 0.09 and CLIP-dir≈0.40\mathrm{CLIP\text{-}dir}\approx 0.40. Qualitatively, it yielded artifact-free, smoothly intensifying edits across the stated tasks. The paper identifies several advantages: no fine-tuning, no extra data, plug-in compatibility with Rectified Flow editors, exact recovery of FlowEdit at s=1s=1, and bidirectional editing by s<0s<0. It also states clear limitations: at very large s≫5s \gg 5, orthogonality breaks down and structure can collapse, so practical s∈[0,5]s\in[0,5] is recommended; and discrete concept changes such as “rabbit →\to cat” saturate at s≈1s\approx 1, after which further scaling yields artifacts. The stated future directions are adaptive step-size or higher-order integrators, combination with learned inversion or latent-space adapters, and extension to multi-instruction editing by decomposing additional steering axes in a similar fidelity-steering subspace.

Topic to Video (Beta)

No one has generated a video about this topic yet.

Whiteboard

No one has generated a whiteboard explanation for this topic yet.

Follow Topic

Get notified by email when new papers are published related to FlowSlider.