Tsunami Modeling with Graphics
Processing Unit (GPU) and Radial Basis
Functions (RDF)
DAVID A. YUEN
Minnesota Supercomputing
Institute,University of Minnesota,
Minnesota
JESSICA SCHMIDT
Saint Scholastica College, Duluth, Minnesota
JESSICA SCHMIDT
Saint Scholastica College, Duluth,
Minnesota
CECIL PIRET
Institute of Applied Mathematics for
Geosciences, National Center of Atmospheric
Research, Boulder, Colorado
ERIK O.D. SEVRE
Minnesota Supercomputing
Institute University of Minnesota,
Minnesota
SPRING LIU
Minnesota Supercomputing Institute
University of Minnesota, Minnesota
NAN ZHANG
Medical School, University of
Minnesota Minnesota
NATASHA FLYER
Institute of Applied Mathematics for
Geosciences, National Center for Atmospheric
Research, Boulder, Colorado
GRADY B. WRIGHT
Dept. of Mathematics , Boise State
University, Boise, Idaho
Outline
 Introduction to Tsunamis and Tsunami Modeling
 Visualization of tsunamis with Amira visualization





package
Virtues of Graphics Accelerated Board (GPU)
Applications of GPU to Shallow-Water equations
Radial Basis Functions (RBF) Swirling Flows
Applications of GPU to RBF equations
Concluding Remarks
Background
What is a Tsunami?
(soo-NAH-mee)
Tsunami Definition & Causes
Wave types
Wave in the Ocean
Most of the waves present on the ocean’s surface are wind-generated waves.
Size and type of wind-generated waves are controlled by: Wind velocity,
Wind duration, Fetch, and Original state of sea surface.
7-5
Tsunami
 Tsunamis consist of a series of long-period waves characterized by
very long wave length (up to 100 km) and high speed (up to 760
km/hr) in the deep ocean.
 Because of their large wave length, tsunamis are shallow-water to
intermediate-water waves as they travel across the ocean basin.
 They only become DANGEROUS, when reaching coastal areas
where wave height can reach 10 m.
 Tsunamis originate from earthquakes, volcanic explosions, or
submarine landslides.
Tsunami Source (1)
Tsunami Source (2)
Tsunami Source (3)
Background
Tsunami Sources in the world
(2180 events from 1628BC to 2005)
Numerical Tsunami Modeling
Background
Seismic Tsunami Modelling
Killer Tsunamis in Historical Times
General Tsunami Modelling
1
Physical Analysis
2
Numerical Simulation
3
Visualization
4
Result Analysis and
Digestion
 Displacement Field
(initial Condition)
 Propagation
(Linear and Nonlinear
model)
 Run-up
Seismic Tsunami Modelling
Seismic Tsunami Modelling
1 Analyze the phenomenon
2 Choose Coordinates
3 Choose the equations
4 solution of grid
(Local and Far-field)
Navier-Stokes Equations System
Boussinesq Equations
Shallow Water Equations
Etopo1, Etopo2, Strm30,
or local bathymetry data
5 Boundary and initial conditions
The initial wave( From
earthquake)
6 Visualization
7Analysis results
Satellite data or tidal data
Generation, Propagation, and Run-up of Tsunamis
Generation
Propagation
Run-up/down
dispersion effect
nonlinear effect
Existing Tsunami Models
Introduction of Amira
Amira is a powerful, multifaceted software platform for
visualizing, manipulating, and understanding scientific data
coming from a all types of sources and modalities.
Multi purpose - One tool for interdisciplinary work
Flexible - Option packages to configure amira to your needs
Efficient - Exploits latest graphics cards and processors
Easy to use - Intuitive user interface and great documentation
Cost effective - Multiple options and flexible license models
Handling large data - Very large data sets are easily accessible with
specific readers
Extensible - C++ coding wizard for technical extension and customization
Support - Customer direct support with high level of interaction
Innovative - Technology always up dated to the latest innovation
Data Visualization __ Amira
Load Topography Background
Movie Maker
Highlight of Visualization with Amira 3
 This figure shows the height field with a scaled height.
Wave Propagation Visualization of Tsunami ModelingEastern China Sea
Wave Propagation Visualization of Tsunami ModelingSolomon Islands
Wave Propagation Comparison of Linear and
Nonlinear Modeling
Different Bathymetry Resolution Comparison of Nonlinear Modeling
on Shallow Part of the Ocean Part
Grids: 1201*1201
601*601
Conclusion
(1) Visualization promotes a rapid understanding
of the waves' paths from initial stages ; influences
from the initial surroundings
(2) Visualization Allows us to understand better
the subsequent events when the waves are
interacting with the coastline and off-shore islands
(3) Visualization Helps to teach people about wave
propagation for local and regional scenarios
Linear and Nonlinear Model in Yellow Sea Area
TSUNAMI SIMULATION WITH GPU PROGRAMMING
JESSICA SCHMIDT from computer science and mathematics
UNDERGRADUATE SUMMER INTERN
Tsunami Simulation with GPU
Programming
Jessica Schmidt
Undergraduate summer
intern
Overview
Why we do this project?
GPU with CUDA programming
Tsunami Simulation with CUDA
 RBF ( RADIAL BASIS
FUNCTIONS ) Summary
What does the future hold?
Viable set-up for real-time tsunami visualization
By Jessica
Earthqua
ke
Tsuna
mi
Tsunami
Simulation with
GPU
Programming
Real Tsunami
Visualization
(Interface
Window)
By Erik
Tsunami
Warning
Seismology
Bathymetric
Data
GPU
 Graphics Processing Unit
 Much faster than CPU now
 Getting more expensive, can easily now
 Outstrip the cost of a laptop itself
 Takes the load off of the CPU
Computes
many complex math problems
Faster graphics processing speed
Increased detailed and complexity without
CUDA
 Compute Unified Device Architecture
 Developed by NVIDIA
 Based on C
Benefits
Drawbacks
 Takes load off
 Difficult to find
CPU
 Easy to learn and
implement
video card , MAC is
cooler for this .
GPU Specs.
GPU
GeForce 8600M GeForce 8800
GT
Ultra
Core clock (MHz)
540
612
Shader clock (MHz)
1190
1500
Memory clock (MHz) 700
1080
Memory Amount
(MB)
256
768
Memory Interface
128-bit
384-bit
Memory bandwidth
(GB/s)
22.4
103.7
There are
other GPUs
Texture
Fill Rate
8.64that work with CUDA
39.2 as well.
- NVIDIA GeForce 8000 and above
(billion/sec)
- NVIDIA Quadro, DELUXE MODEL
- NVIDIA Tesla
Jessica’s Job This Summer
 Covert linear tsunami codes
Spring
Liu ----second Finite Difference
Method
Cecile Piret ---- Radial Basis Function
(RBF)
 Implement CUDA for Spring’s and
Cecile’s linear codes, then see if
there is speedup
2-D Shallow Water Equations
Linear
z M N


0
t x
y
M
z
 gD
0
t
x
N
z
 gD
0
t
y
Non-Linear
z M N


0
t x y
M  M 2
 MN
z  x
 (
) (
)  gD   0
t x D
y D
x 
M  MN
 N2
z  y
 (
)  ( )  gD   0
t x D
y D
y 
M, N = mass fluxes in horizontal plane
z = wave height
t = time
h = ocean water depth
D = total water depth, D = z + h
ρ = density
τx, τy = shear stress along x and y axis
athymetric Data: Etopo1
arameters of Rupture:
rom HARVARD Database ,
Miyaki Ishii
isualization: Amira
An Introduction
Radial Basis Functions (RBF) Method
The RBF method
• 70s Rolland Hardy introduces a new method for
•
•
scattered data interpolation for geological data,
the MQ method, so named for its use as basis of
the multi-quadric function. First published in JGR
70s-80s The method is generalized to more radial
functions. It is renamed the “Radial Basis
Functions (or RBF) method”.
90s Ed Kansa from UC Davis uses the RBF
method to solve partial differential equations.
• Given scattered
The data
RBF
• Define the RBF
interpolant
method
• Given scattered
The data
RBF
• Define the RBF
interpolant
method
• Given scattered
The data
RBF
• Define the RBF
interpolant
• Find
by solving the
system
method
The RBF method
Coding the RBF method is fast and
easy
RBF part of the code
The RBF method
+
•
Interpolation on scattered data. No grid necessary.
Very easy implementation in N-dimensions.
The basis functions are not orthogonal with each other,
but we are guaranteed a non-singular system for most
types of RBFs.
Spectral accuracy for infinitely smooth radial functions

High complexity. No fast algorithm.
•
•
•
-
Radial Basis Functions (RBF)--- Cecile
 Interpolating data takes the form:
 Use RBFs to model 2-D linear waves
 Cecile Piret wrote simulations using Matlab
 Convert to GPU using Jacket – developed
by Accelereyes
The comparison of GPU and CPU
------- Linear Tsunami Codes
Spring’s linear tsunami code (21600 time steps)
Grid
Size
601x601
CPU (Lilli)
GPU (laptop) Speedup
times
Approx. 240
Approx. 30
8 times
Cecile’s linear
tsunami code (400 time
steps)
minutes
minutes
Grid
Size
30x30
CPU (laptop)
GPU (laptop)
Approx. 315
seconds
Approx. 105
seconds
Lilli – an opteron-based system with 4 CPUs
GPU – nVIDIA 8600M GT graphics card
Laptop – standard MacBook Pro
Speedup
times
3 times
Results for Tsunami Simulation
beginning of simulation
middle of simulation
Simulation Movie
Comparison
Summary
 With the comparison of the computing
times of tsunami equations that be solved
by different numerical methods (Finite
Difference Method and RBF) and
different hardware surroundings (GPU
and CPU), we would provide a ideal
computing and visualization method for
tsunami simulation, that allow for hazard
preparation and timely warning for lands
in the masses in the path of tsunami
wave.
 GPU really speeds up computing time,
that is at least 3 times that of CPU for our
tsunami code.
What does the future hold?
 Complete GPU programming for
Nonlinear Shallow Water Code
with CUDA ---- Jessica
 Development of Visualization
Interface
Erik Sevre
References
Liu, Y. Numerical tsunami modeling[PowerPoint]. Minneapolis, Minnesota:
University of Minnesota.
(2008, June 7). NVIDIA CUDA compute unified device architecture. Retrieved
July 29, 2008, from NVIDIA:
http://developer.download.nvidia.com/compute/cuda/2.0Beta2/docs/Programming_Guide_2.0beta2.pdf
Piret, C. (2007). Analytical and numerical advances in radial basis functions,
(Doctoral dissertation, University of Colorado at Boulder, 2007). Retrieved
from http://amath.colorado.edu/student/piret/thesis.pdf
Sevre, E., Yuen, D. A., & Liu, Y. (2008). Visualization of tsunami waves with
Amira package.
Examples of Commonly Used Radial Basis Functions
Comparison of the 1-D Chebychev Pseudo-Spectral Basis and the
Gaussian RBF Basis and Influence of the Shape Parameter Epsilon
Comparison of the Swirling Flow for Different
Initial Conditions
Sample MATLAB Code for Solid-Body Rotation
ep = 6; % Value of epsilon to used
alpha = pi/2; % Angle of rotation measured from the
equator
a = 6.37122e6; % Mean radius of the earth (meters)
u0 = 2*pi*a/12; % Speed of rotation (m/day)-one
full revolution in 12 days
R = a/3; % Width of bell
%%% Load Nodes:
http://web.maths.unsw.edu.au/~rsw/Sphere/E
nergy/index.html%%%
load(‘me1849.dat’); x = me1849(:,1); y =
me1849(:,2); z = me1849(:,3);
%%% Compute r2 = (x_j x_k)2+ (y_j y_k)2+(z_j
z_k)2 %%%
nodes = [x,y,z];
rd2 = zeros(length(nodes),length(nodes));
for j = 1:3
xd1 = nodes(:,j); xd1 = xd1(:,ones(length(xd1), 1));
xd2 = xd10;
rd2 = rd2 + (xd1 xd2).2;
end
%%% Set-up 2D surface grids in (theta,phi) for
computing B (eqn.(11)) %%%
theta = atan2(z,sqrt(x.2+y.2)); phi = atan2(y,x); %
phi = lambda in paper
tn = theta; tn = tn(:,ones(length(xd1), 1)); tc = tn’;
pn = phi; pn = pn(:,ones(length(phi), 1)); pc = pn’;
%%% Compute differentiation matrix D %%%%
B = 2*(cos(alpha).*cos(tn).*cos(tc).*sin(pn-pc) +
sin(alpha).*(cos(tn).*cos(pn).*sin(tc) cos(tc).*cos(pc).*sin(tn)));
B = (u0/a)*B.*(-ep2*exp(-ep2.*rd2));
A = exp(-ep2.*rd2);
D = B/A;
%%% Initial Condition Cosine Bell %%%
r = a*acos(cos(theta).*cos(phi)); % initially located
at equator, (0,0)
h = 1000/2*(1+cos(pi*r/R)); % height of bell is 1000
m
h(r >= R)=0;
%%% Time-Stepping - 4th Order RK %%%
dt = 12/288*5/6; % Time-Step for 12 days revolution
for nt = 2:(1*288*6/5)
d1 = dt*D*h;
d2 = dt*D*(h + 0.5*d1);
d3 = dt*D*(h + 0.5*d2);
d4 = dt*D*(h + d3);
end
Sample MATLAB Code for Solid-Body Rotation with
GPU Implementation ( NO BIGGIE )
ep = 6; % Value of epsilon to used
alpha = pi/2; % Angle of rotation measured from the
equator
a = 6.37122e6; % Mean radius of the earth (meters)
u0 = 2*pi*a/12; % Speed of rotation (m/day)-one
full revolution in 12 days
R = a/3; % Width of bell
%%% Load Nodes:
http://web.maths.unsw.edu.au/~rsw/Sphere/E
nergy/index.html%%%
load(‘me1849.dat’); x = me1849(:,1); y =
me1849(:,2); z = me1849(:,3);
%%% Compute r2 = (x_j x_k)2+ (y_j y_k)2+(z_j
z_k)2 %%%
nodes = [x,y,z];
rd2 = zeros(length(nodes),length(nodes));
for j = 1:3
xd1 = nodes(:,j); xd1 = xd1(:,ones(length(xd1), 1));
xd2 = xd10;
rd2 = rd2 + (xd1 xd2).2;
end
%%% Set-up 2D surface grids in (theta,phi) for
computing B (eqn.(11)) %%%
theta = atan2(z,sqrt(x.2+y.2)); phi = atan2(y,x); %
phi = lambda in paper
tn = theta; tn = tn(:,ones(length(xd1), 1)); tc = tn’;
pn = phi; pn = pn(:,ones(length(phi), 1)); pc = pn’;
%%% Compute differentiation matrix D %%%%
B = 2*(cos(alpha).*cos(tn).*cos(tc).*sin(pn-pc) +
sin(alpha).*(cos(tn).*cos(pn).*sin(tc) cos(tc).*cos(pc).*sin(tn)));
B = (u0/a)*B.*(-ep2*exp(-ep2.*rd2));
A = exp(-ep2.*rd2);
D = B/A;
%%% Initial Condition Cosine Bell %%%
r = a*acos(cos(theta).*cos(phi)); % initially located
at equator, (0,0)
h = 1000/2*(1+cos(pi*r/R)); % height of bell is 1000
m
h(r >= R)=0;
D=gsingle(D); % puts matrix D on the GPU
h=gsingle(h); % puts h on the GPU
%%% Time-Stepping - 4th Order RK %%%
dt = 12/288*5/6; % Time-Step for 12 days revolution
for nt = 2:(1*288*6/5)
d1 = dt*D*h;
d2 = dt*D*(h + 0.5*d1);
d3 = dt*D*(h + 0.5*d2);
d4 = dt*D*(h + d3);
end
Results for Solid Body Rotation
CPU time
GPU time
Speed up
119 seconds
23 seconds
5.2 times
Notes:
 The CPU used was an Intel Duo Core Processor
 The GPU used was an NVIDIA GeForce 8600M GT in a MacBook Pro
 The times calculated were the RK4 loop, as that was the part on the
GPU.
 GPU implementation was facilitated by the Jacket software package
produced by AccelerEyes
Several Thousand RBF Points Laid Out On Spherical Shell
for 3-D thermal convection
Concluding Remarks and Perspectives
 GPU can make a difference in speeding up for both single
processor on your laptop or clusters of GPU's , they are much
cheaper , $10,000 can mean 50 times your present compute
power can be put in your office, whither Brutus et TU !!
 RBF's is a new method which can have a future because of its
algorithmic simplicity. Easy to learn and program. It is still in
nascent stage, like finite-elements were in the late 1960’s,
 when Paul Tackley was a babe.
 Combining GPU with RBF, we can now speed up the
nonlinear shallow-water equation by a factor close to 100, for
the same physical elapsed time so a calculation which took 30
minutes can be done in 20 seconds( on single
processor armed with GPU). This makes real-time tsunami
warning a definite possibility