Download presentation

Presentation is loading. Please wait.

Published byJacquelyn Ainsworth Modified about 1 year ago

1
DAVID A. YUEN Minnesota Supercomputing Institute,University of Minnesota, Minnesota JESSICA SCHMIDT Saint Scholastica College, Duluth, Minnesota ERIK O.D. SEVRE Minnesota Supercomputing Institute University of Minnesota, Minnesota NAN ZHANG Medical School, University of Minnesota Minnesota GRADY B. WRIGHT Dept. of Mathematics, Boise State University, Boise, Idaho Tsunami Modeling with Graphics Processing Unit (GPU) and Radial Basis Functions (RDF) JESSICA SCHMIDT Saint Scholastica College, Duluth, Minnesota CECIL PIRET Institute of Applied Mathematics for Geosciences, National Center of Atmospheric Research, Boulder, Colorado SPRING LIU Minnesota Supercomputing Institute University of Minnesota, Minnesota NATASHA FLYER Institute of Applied Mathematics for Geosciences, National Center for Atmospheric Research, Boulder, Colorado

2
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

3
Background

4
What is a Tsunami? (soo-NAH-mee)

5
Tsunami Definition & Causes

6
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. Wave in the OceanWave types

7
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. 7-5 Tsunami

8
Tsunami Source (1)

9
Tsunami Source (2)

10
Tsunami Source (3)

11
Tsunami Sources in the world (2180 events from 1628BC to 2005) Numerical Tsunami ModelingBackground

12
Seismic Tsunami ModellingBackground Killer Tsunamis in Historical Times

13
General Tsunami Modelling Displacement Field (initial Condition) Propagation (Linear and Nonlinear model) Run-up 1 Physical Analysis 2 Numerical Simulation 3 Visualization 4 Result Analysis and Digestion

14
Seismic Tsunami Modelling Navier-Stokes Equations System Boussinesq Equations Shallow Water Equations 1 Analyze the phenomenon 2 Choose Coordinates 3 Choose the equations 5 Boundary and initial conditions 4 solution of grid 7Analysis results Etopo1, Etopo2, Strm30, or local bathymetry data Satellite data or tidal data (Local and Far-field) 6 Visualization The initial wave( From earthquake) Seismic Tsunami Modelling

15
Generation, Propagation, and Run-up of Tsunamis

16
Existing Tsunami Models

17
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

18
Data Visualization __ Amira

19
Load Topography Background

20
Movie Maker

21
Highlight of Visualization with Amira 3 This figure shows the height field with a scaled height.

22
Wave Propagation Visualization of Tsunami Modeling- Eastern China Sea

23
Wave Propagation Visualization of Tsunami Modeling- Solomon Islands

24
Wave Propagation Comparison of Linear and Nonlinear Modeling

25
Different Bathymetry Resolution Comparison of Nonlinear Modeling on Shallow Part of the Ocean Part Grids: 1201*1201601*601

26
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

27
Linear and Nonlinear Model in Yellow Sea Area

28
TSUNAMI SIMULATION WITH GPU PROGRAMMING JESSICA SCHMIDT from computer science and mathematics UNDERGRADUATE SUMMER INTERN

29
Jessica Schmidt Undergraduate summer intern Tsunami Simulation with GPU Programming

30
Overview Why we do this project? GPU with CUDA programming Tsunami Simulation with CUDA RBF ( RADIAL BASIS FUNCTIONS ) Summary What does the future hold?

31
Viable set-up for real-time tsunami visualization Earthqua ke Tsuna mi Real Tsunami Visualization (Interface Window) Seismology Bathymetric Data Tsunami Simulation with GPU Programming By Erik By Jessica Tsunami Warning

32
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 compromising performance

33
CUDA Benefits Drawbacks Takes load off CPU Easy to learn and implement Difficult to find video card, MAC is cooler for this. Compute Unified Device Architecture Developed by NVIDIA Based on C

34
GPU Specs. GPUGeForce 8600M GT GeForce 8800 Ultra Core clock (MHz)540612 Shader clock (MHz)11901500 Memory clock (MHz)7001080 Memory Amount (MB) 256768 Memory Interface128-bit384-bit Memory bandwidth (GB/s) 22.4103.7 Texture Fill Rate (billion/sec) 8.6439.2 There are other GPUs that work with CUDA as well. - NVIDIA GeForce 8000 and above - NVIDIA Quadro, DELUXE MODEL - NVIDIA Tesla

35
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

36
2-D Shallow Water Equations LinearNon-Linear 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

37
Flow Chart: Bathymetric Data: Etopo1 Parameters of Rupture: From HARVARD Database, Miyaki Ishii Visualization: Amira

38
Radial Basis Functions (RBF) Method An Introduction

39
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.

40
Given scattered data Define the RBF interpolant The RBF method

41
Given scattered data Define the RBF interpolant The RBF method

42
Given scattered data Define the RBF interpolant The RBF method Find by solving the system

43
The RBF method Coding the RBF method is fast and easy RBF part of the code

44
+ 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. The RBF method

45
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

46
The comparison of GPU and CPU ------- Linear Tsunami Codes Grid Size CPU (laptop)GPU (laptop)Speedup times 30x30Approx. 315 seconds Approx. 105 seconds 3 times Cecile’s linear tsunami code (400 time steps) Grid Size CPU (Lilli)GPU (laptop)Speedup times 601x601Approx. 240 minutes Approx. 30 minutes 8 times Spring’s linear tsunami code (21600 time steps) Lilli – an opteron-based system with 4 CPUs GPU – nVIDIA 8600M GT graphics card Laptop – standard MacBook Pro

47
Results for Tsunami Simulation beginning of simulationmiddle of simulation Simulation Movie

48
Comparison

51
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.

52
What does the future hold? Complete GPU programming for Nonlinear Shallow Water Code with CUDA ---- Jessica Development of Visualization Interface Erik Sevre

53
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.0- Beta2/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.pdfhttp://amath.colorado.edu/student/piret/thesis.pdf Sevre, E., Yuen, D. A., & Liu, Y. (2008). Visualization of tsunami waves with Amira package.

54
Examples of Commonly Used Radial Basis Functions

55
Comparison of the 1-D Chebychev Pseudo-Spectral Basis and the Gaussian RBF Basis and Influence of the Shape Parameter Epsilon

56
Comparison of the Swirling Flow for Different Initial Conditions

57
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/Ener gy/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

58
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/Ener gy/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

59
Results for Solid Body Rotation CPU timeGPU timeSpeed up 119 seconds23 seconds5.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

60
Several Thousand RBF Points Laid Out On Spherical Shell for 3-D thermal convection

61
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

Similar presentations

© 2017 SlidePlayer.com Inc.

All rights reserved.

Ads by Google