Integrated Computation of Finite Time Lyapunov Exponent During ...

Integrated Computation of Finite Time Lyapunov Exponent Fields During 

DNS of Unsteady and Turbulent Flows 

Justin Finn & Sourabh Apte 

Computational Flow Physics Laboratory, Oregon State University 

65th Annual APS-DFD Meeting 

San Diego, CA 

November 18-20, 2012

Introduction 

Finite Time Lyapunov Exponent (FTLE) 

Avg. stretching rate of initially adjacent tracers over finite time. 

Ridges show strong correspondence with Lagrangian coherent 

structures (LCS): Invariant transport barriers, skeleton of tracer 

patterns. [Haller, 2001, Shadden et al., 2005] 

Relatively modern FTLE/LCS theory contributed new understanding to 

many fields 

Typically computed via algorithmically simple, computationally 

expensive post-processing of experimental/numerical data 

Enormous number of particle advections 

Careful memory management. 

Fewer velocity fields ⇒ more uncertainty. 

Speedup possible: AMR [Miron et al., 2012], Ridge 

tracking [Lipinski and Mohseni, 2010], GPU 

acceleration [Conti et al., 2012], 

Repelling 

trajectories [Shadden et al., 2005] 

Atmospheric events [Lekien and Ross, 2010] Granular flow in a tumbler [Christov et al., 2011] 

Startup of a swimming 

fish [Conti et al., 2012] 

Finn & Apte FTLE & DNS Integration 2

Main Goal: Enhance DNS capability 

Typical direct numerical simulation code 

̌□ Simulation resolves all space/time scales of the flow 

̌□ Massive parallelism, and rapidly growing processing power: New applications, 

larger simulations, complex configurations are possible. 

̌□ Particle/scalar tracking, interpolations, gradient calcs, etc... 

̌□ Low cost, high quality, on-the-fly FTLE computations 









One of our interests: How do porescale flow 

features affect mixing and transport in packed 

bed reactors 









Outline 

1 Definitions 

2 Our Integrated Approach 

3 2D & 3D examples 

4 Cost analysis 

One of our interests: How do porescale flow 

features affect mixing and transport in packed 

bed reactors 


Definition and typical computation of the FTLE 

1 Release a grid of tracers and see where they go: This gives us the The flow map, 

Φ(x 0 , t 0 , ) 

∫ t1 

Φ t 1 

t0 

(x 0 , t 0 ) = x 0 + u(x(τ), τ)dτ (1) 

t 0 




Φ(x 0 , t 0 , ) 

∫ t1 

Φ t 1 

t0 

(x 0 , t 0 ) = x 0 + u(x(τ), τ)dτ (1) 

t 0 

2 Differentiate the flow map W.R.T. x 0 : Then, compose the right Cauchy-Green deformation 

tensor, ∆ 

⎡ 

⎤∗ ⎡ ⎤ 

∆ t 1 

t0 

(x 0 , t 0 ) = ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ , (2) 

dx 0 

dx 0 




Φ(x 0 , t 0 , ) 

∫ t1 

Φ t 1 

t0 

(x 0 , t 0 ) = x 0 + u(x(τ), τ)dτ (1) 

t 0 


tensor, ∆ 

⎡ 

⎤∗ ⎡ ⎤ 

∆ t 1 

t0 

(x 0 , t 0 ) = ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ , (2) 

dx 0 

dx 0 

3 Determine the largest eigenvalue of this tensor. This is then used to compute the 

(maximum) FTLE field. 

√ 

σ t 1 

1 

t0 

(x 0 , t 0 ) = 

|t 1 − t 0 | log λ max (∆ t 1 

t0 

(x 0 , t 0 )) (3) 




Φ(x 0 , t 0 , ) 

∫ t1 

Φ t 1 

t0 

(x 0 , t 0 ) = x 0 + u(x(τ), τ)dτ (1) 

t 0 


tensor, ∆ 

⎡ 

⎤∗ ⎡ ⎤ 

∆ t 1 

t0 

(x 0 , t 0 ) = ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ , (2) 

dx 0 

dx 0 



√ 

σ t 1 

1 

t0 

(x 0 , t 0 ) = 

|t 1 − t 0 | log λ max (∆ t 1 

t0 

(x 0 , t 0 )) (3) 

4 Detect FTLE ridges visually or analytically: Forward time ridges ⇒ repelling LCS 

candidates. Backward time ridges ⇒ attracting LCS candidates. Recent, more exact 

theory [Haller, 2011] 




Φ(x 0 , t 0 , ) 

∫ t1 

Φ t 1 

t0 

(x 0 , t 0 ) = x 0 + u(x(τ), τ)dτ (1) 

t 0 


tensor, ∆ 

⎡ 

⎤∗ ⎡ ⎤ 

∆ t 1 

t0 

(x 0 , t 0 ) = ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ ⎣ dΦt 1 

t0 

(x 0 , t 0 ) 

⎦ , (2) 

dx 0 

dx 0 



√ 

σ t 1 

1 

t0 

(x 0 , t 0 ) = 

|t 1 − t 0 | log λ max (∆ t 1 

t0 

(x 0 , t 0 )) (3) 

4 Detect FTLE ridges visually or analytically: Forward time ridges ⇒ repelling LCS 

candidates. Backward time ridges ⇒ attracting LCS candidates. Recent, more exact 

theory [Haller, 2011] 

Note: Separate computations for forward (t 1 > t 0 ) and backward (t 1 < t 0 ) time 

Note: Let T be the absolute value of the integration time, |t 1 − t 0 | 

We can then write forward and backward time T flow maps as Φ t 0+T 

t and Φ t 0−T 

0 

t 0 


The flow solver 

Originally developed for DNS/LES on very large grids in complex 

configurations [Moin and Apte, 2006], 

Distributed Memory (MPI) parallelization and good scalability to more than 1000 

processors. 

Co-Located (u, p known at cell centers), finite volume discretization 

Arbitrary cell shapes possible: Hex, tet, pyramid, etc... 

Fractional time-stepping, and Algebraic Multigrid (AMG) solver for pressure 

Poisson equation [Falgout and Yang, 2002] 

Extensions for Multiphase flow problems: Subgrid scale Euler-Lagrange 

models [Shams et al., 2010], Resolved rigid body motion with fictitious domain 

approach [Apte et al., 2009] 


Computing the forward time flow map, Φ t 0+T 

t 0 

(3) Communicate 

Φ t0+T = x(t = t 

t0 0 + T ) 

to takeoff cell 

(2) Tracer advection 

to time t = t 0 + T 

The Lagrangian Treatment: 

1 Launch tracer from each 

cell center at t = t 0 

2 Update tracer position 

dx 

dt 

= u(x, t) (4) 

3 Communicate tracer 

position to launch cell 

(1) Launch tracers 

from cell centers, 

x(t = t 0 ) = x cv 


Computing the forward time flow map, Φ t 0+T 

t 0 

(3) Communicate 

Φ t0+T = x(t = t 

t0 0 + T ) 

to takeoff cell 

(2) Tracer advection 

to time t = t 0 + T 

The Lagrangian Treatment: 

1 Launch tracer from each 

cell center at t = t 0 

2 Update tracer position 

dx 

dt 

= u(x, t) (4) 

3 Communicate tracer 

position to launch cell 

(1) Launch tracers 

from cell centers, 

x(t = t 0 ) = x cv 

Nothing new here, but what do we do about backward time 


Computing the backward time flow map, Φ t 0 

t0 +T 

The Eulerian Treatment [Leung, 2011]: A natural way to evolve the backward time 

flow map in forward time. Treat each component of backward time flow map as an 

Eulerian scalar field on the fixed grid. 

dΦ t 0 

t0 +T ,i 

+ (u · ∇)Φ t 0 

t0 +T ,i 

= 0 (5) 

dt 

Solve three level-set equations using a simple, semi-Lagrangian 

scheme [Staniforth and Côté, 1991] 

At time t = t 0 , set 

Φ t0 

t0+T = x cv everywhere 

Evolve each 

scalar up to 

t = t 0 + T by 

solving level set 

equation. 

At time t = t 0 + T , Φ t0 

t0+T 

is the backward time T 

flow map. 


Efficient composition of evolving FTLE fields 

When computing evolving FTLE fields, redundant tracer integrations eliminated by splitting time T 

flow map into N time h substeps. 

Φ t 0+T 

t 0 

Φ t 0+T 

t 0 

= Φ Nh 

(N−1)h ◦ · · · ◦ Φt 0+2h 

t 0 +h ◦ Φt 0+h 

t 0 

(6) 

= IΦ t 0+Nh 

t 0 +(N−1)h ◦ · · · ◦ IΦt 0+2h 

t 0 +h ◦ Φt 0+h 

t 0 

(7) 

[Brunton and Rowley, 2010] 


Efficient composition of evolving FTLE fields 

Evolve time h flow maps during the simulation, store them on hard disk, construct time T flow 

maps as needed 

Approximate reconstruction of Φ t 0+2h+T 

t 0 +2h 

Approximate reconstruction of Φ t 0+h+T 

t 0 +h 

Approximate reconstruction of Φ t 0+T 

t 0 

}Fwd. time 

constructions 

Exact Φ t 0+T 

t 0 

t 0 t 0 +h t 0 +2h . . . . . . t 0 +T-h t 0 +T t 0 +h+T t 0 +2h+T 

Simulation 

Time (t) 

Exact Φ t 0 

t0 +T 

Approximate reconstruction of Φ t 0 

t0 +T 

Approximate reconstruction of Φ t 0+h 

t 0 +h+T 

}Bkwd. time 

constructions 

Approximate reconstruction of Φ t 0+2h 

t 0 +2h+T 


Computational flow of the integrated computations 

Main Flow Solver 

• t n+1 = t n + dt 

• Advance u n to u n+1 

Update time h flow maps 

• Advance time h 

Lagrangian tracers (fwd) 

• Advance time h Eulerian 

fields (bkwd) 

u n+1/2 mod (t n+1 , h) ≠ 0 

• Handle flow map B.C. 

RETURN 

mod (t n+1 , h) = 0 

FTLE Computation 

• Map current tracer positions to 

launch cells to obtain time h 

forward flow map 

• Write time h flow maps to disk 

• Construct time T flow maps 

from sequence of N time h flow 

maps 

• Compute FTLE fields 

• Re-initialize time h flow maps 

on fixed grid. 

Block diagram showing the flow of the FTLE/DNS integration. 


Demonstration 

We have tested our implementation for a number of flows: 

1 

Time dependent double gyre flow 

2 

The Karman vortex street behind a fixed cylinder 

3 

The oscillating cylinder problem 

4 

The traveling vortex ring 

5 

Unsteady flow through a randomly packed bed 


Moving Boundaries: Inline Oscillation of a circular cylinder 

Re = UmD 

ν 

= 100 (6) 

KC = Um 

fD = 2πA 

D = 5 (7) 

Integraton time = 1.5 periods 

Temporal FTLE resolution , h = T /30 

x c(t) = −A m sin(2πft) (8) 

U c(t) = −2πAf cos(2πft) (9) 

Fictitious domain 

representation [Apte et al., 2009] 

Backward FTLE 

Forward FTLE 


Three dimensional flows: Traveling vortex ring 

Three dimensional ring generated by 

circular inflow pulse 

660 × 241 × 241 stretched Cartesian 

grids (37M cells) 

FTLE computed for T = 1.5s: Ring 

travels 10% of the domain 

Temporal FTLE resolution, h = 0.1s 

2D Cross section of 3D FTLE field 

shows LCS candidates 

Backward FTLE 

Forward FTLE 


Complex configurations: Flow through a randomly packed bed 

Weakly turbulent: Pore Reynolds 

number, Re = UD 

ɛν = 600 

Cartesian grid fictitious domain 

approach with grid spacing D/80 

in porespace 

integration time of T = 3U/D 

using a flow map sub-step of 

h = T /7 

3D FTLE field visualized on 2D 

slices 

More detail in gallery of fluid 

motion poster 

Backward FTLE 

Forward FTLE 


Computational expense 

Simulation Time to compute evolving FTLE fields with T = 2400dt and h = T /12 

Fixed Cylinder (36 proc.) 

26.5% 

Oscillating Cylinder (24 proc.) 

22.8% 

Vortex Ring (660 proc.) 

14.2% 

Packed Bed (1200 proc.) 

16.1% 

0% 5% 10% 15% 20% 25% 30% 

Percentage of total simulation time 

Disk space and RAM: 

Largest case (Packed bed) required roughly 25GB or hard disk to store 

intermediate flow maps 

Minimal additional simulation RAM: Typically 10% or less of total computation 


Conclusions 

1 We can compute evolving forward and backward time FTLE fields during direct 

numerical simulation of unsteady and turbulent flow 

2 The integration allows for high resolution FTLE computations, using the native 

space and time resolution of the simulation 

3 We have tested the implementation for 2D and 3D flows with both fixed & moving 

boundaries as well as complex configurations 

4 The FTLE computations contribute to 26% or less of the total simulation time, and 

require only moderate amounts of RAM/disk space. 

Future Work 

1 Precise extraction of LCS from developing theory 

2 Extension to inertial particles 

3 Simulations of FTLE based control 


[Apte et al., 2009] Apte, S., Martin, M., and Patankar, N. (2009). 

A numerical method for fully resolved simulation (frs) of rigid particle-flow 

interactions in complex flows. 

Journal of Computational Physics, 228(8):2712–2738. 

[Brunton and Rowley, 2010] Brunton, S. and Rowley, C. (2010). 

Fast computation of finite-time lyapunov exponent fields for unsteady flows. 

Chaos: An Interdisciplinary Journal of Nonlinear Science, 20(1):017503. 

[Christov et al., 2011] Christov, I., Ottino, J., and Lueptow, R. (2011). 

From streamline jumping to strange eigenmodes: Bridging the lagrangian and 

eulerian pictures of the kinematics of mixing in granular flows. 

Physics of Fluids, 23:103302. 

[Conti et al., 2012] Conti, C., Rossinelli, D., and Koumoutsakos, P. (2012). 

Gpu and apu computations of finite time lyapunov exponent fields. 

Journal of Computational Physics, 231(5):2229–2244. 

[Falgout and Yang, 2002] Falgout, R. and Yang, U. (2002). 

hypre: A library of high performance preconditioners. 

Computational ScienceICCS 2002, pages 632–641. 

[Haller, 2001] Haller, G. (2001). 

Distinguished material surfaces and coherent structures in three-dimensional fluid 

flows. 


Physica D: Nonlinear Phenomena, 149(4):248–277. 

[Haller, 2011] Haller, G. (2011). 

A variational theory of hyperbolic lagrangian coherent structures. 

Physica. D, 240(7):574–598. 

[Lekien and Ross, 2010] Lekien, F. and Ross, S. (2010). 

The computation of finite-time lyapunov exponents on unstructured meshes and for 

non-euclidean manifolds. 

Chaos, 20(1):017505–1. 

[Leung, 2011] Leung, S. (2011). 

An eulerian approach for computing the finite time lyapunov exponent. 

Journal of computational physics, 230(9):3500–3524. 

[Lipinski and Mohseni, 2010] Lipinski, D. and Mohseni, K. (2010). 

A ridge tracking algorithm and error estimate for efficient computation of lagrangian 

coherent structures. 

Chaos, 20(1):017504–1. 

[Miron et al., 2012] Miron, P., Vétel, J., Garon, A., Delfour, M., and Hassan, M. (2012). 

Anisotropic mesh adaptation on lagrangian coherent structures. 

Journal of Computational Physics. 

[Moin and Apte, 2006] Moin, P. and Apte, S. (2006). 

Large-Eddy Simulation of Realistic Gas Turbine-Combustors. 


AIAA Journal, 44(4):698–708. 

[Shadden et al., 2005] Shadden, S., Lekien, F., and Marsden, J. (2005). 

Definition and properties of lagrangian coherent structures from finite-time lyapunov 

exponents in two-dimensional aperiodic flows. 

Physica D: Nonlinear Phenomena, 212(3-4):271–304. 

[Shams et al., 2010] Shams, E., Finn, J., and Apte, S. (2010). 

A numerical scheme for euler–lagrange simulation of bubbly flows in complex 

systems. 

International Journal for Numerical Methods in Fluids, 67:1865–1898. 

[Solomon and Gollub, 1988] Solomon, T. and Gollub, J. (1988). 

Chaotic particle transport in time-dependent rayleigh-benard convection. 

Physical Review A, 38(12):6280. 

[Staniforth and Côté, 1991] Staniforth, A. and Côté, J. (1991). 

Semi-lagrangian integration schemes for atmospheric models- a review. 

Monthly Weather Review, 119(9):2206–2223. 


Double Gyre flow: [Solomon and Gollub, 1988] 

u = −πA sin(πf (x)) cos(πy) (10) 

v 

f 

a 

b 

= πA cos(πf (x)) sin(πy) ∂f 

∂x 

(x, t) = a(t)x 2 + b(t)x 

(t) = ɛ sin(ωt) 

(t) = 1 − 2ɛ sin(ωt) 

(11) 

ɛ = 0.1, A = 0.1, ω = 2π 

10 

512 × 256 Cartesian grid: 

0 ≤ X ≤ 2, 0 ≤ Y ≤ 1 

Time dependent 2d flow model in the X-Y plane 




v 

f 

a 

b 


∂x 

(x, t) = a(t)x 2 + b(t)x 


(t) = 1 − 2ɛ sin(ωt) 

(11) 

Eulerian flow map captures sharp 

features. 

(a) t = 0 (b) t = 1.25 

ɛ = 0.1, A = 0.1, ω = 2π 

10 


0 ≤ X ≤ 2, 0 ≤ Y ≤ 1 

(c) t = 2.5 (d) t = 5 

(e) t = 10 (f) t = 15 




v 

f 

a 

b 


∂x 

(x, t) = a(t)x 2 + b(t)x 


(t) = 1 − 2ɛ sin(ωt) 

ɛ = 0.1, A = 0.1, ω = 2π 

10 


0 ≤ X ≤ 2, 0 ≤ Y ≤ 1 

(11) 

Eulerian and Lagrangian results are 

equivalent 

(g) Backward time Lagrangian 

(h) Forward time Lagrangian 

(i) Backward time Eulerian (j) Forward time Eulerian 

(k) Backward time relative 

error 

(l) Forward time relative 

error 


Flow past a fixed cylinder 

Backward FTLE 

Forward FTLE

Integrated Computation of Finite Time Lyapunov Exponent During ...

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?