# Part 1: Tsunami and Meteo-Tsunami Modelling - ChEESE CoE Training

https://www.youtube.com/watch?v=IpaXW6e-4l0

[00:07] starting our first you know training
[00:10] course in in tsunami highy and uh and
[00:13] the Very for the very first time also in
[00:15] Meto tsunami HEC and these two days and
[00:18] um I don't know if you are aware that we
[00:20] did already some weeks ago a training
[00:23] course within the the the umbrella of gu
[00:26] inquire project in that case the the
[00:30] course was devoted to a very brief and
[00:33] easy introduction to Tsunami highy code
[00:36] and in the second day to installing the
[00:40] the basic version of the code in in your
[00:43] local computer or in the in the also in
[00:45] the cloud so for those of you that are
[00:47] interested in these two topics h i I
[00:51] encourage you to to have a look through
[00:53] the G inquire web page and and look
[00:56] through this to this content also was
[00:58] recorded and this material available for
[01:01] for you so now the the the the subject
[01:05] for today is going a little further in
[01:08] in tsunami highy code dealing not all
[01:10] not only with uh with inundation
[01:14] propagation simulation but also
[01:16] performing inundation high resolution
[01:18] inundation that require the construction
[01:21] of nestic geds that is I mean a
[01:25] critical issue so uh for this first part
[01:29] of today we have Carlos Sanchez from the
[01:31] University of Malaga that have prepares
[01:33] some slides again the all this material
[01:37] will be available after the the course
[01:40] and and also the the recording and and
[01:44] we will learn today how to perform this
[01:46] H high resolution uh inundation for
[01:48] tomorrow for tomorrow we have uh for the
[01:51] very first time as I said Metro High SE
[01:53] because it's a code that we are develop
[01:55] developing within the the framework of
[01:57] cheese 2 project and um we will have um
[02:01] CLA from IRB in
[02:04] Croatia doing an introduction to Metro
[02:06] tsunamis as far as I think and in the
[02:09] second part we will have Alex gonal from
[02:12] the university the Malaga who is working
[02:14] in developing this Meto highy code that
[02:18] starting from our experience in hey
[02:21] codes H implemented implement the you
[02:24] know the the effects of the pressure
[02:26] winds and so to perform this Metro Ami
[02:30] simulation um I don't want to take more
[02:33] time and after that brief introduction
[02:37] uh I'm giving the floor to Carlos
[02:38] Sanchez that uh will do this short brief
[02:44] one day introduction to Tsunami highy
[02:47] Carlos you want thank you thank you for
[02:50] for the presentation let me share the
[02:54] screen
[02:58] okay okay
[03:01] okay okay so I think you can see my
[03:05] screen right
[03:07] okay so
[03:11] um yes you can see my the first slide
[03:14] yes we can see it so thank you thank you
[03:16] very much hello everyone and and thank
[03:19] you for for being for being here as uh
[03:23] hor
[03:25] mention okay as J mentioned um I'm my
[03:29] name is Carlos Sanchez I'm Professor
[03:31] here at the University of Malaga and
[03:33] member of the adania team for the past
[03:38] 10 or 12 years so well I cannot consider
[03:42] myself among the youngest members but
[03:45] nether among the veterans so um yide um
[03:49] welcome to this introduction course
[03:51] about tsunami High SE well we will see
[03:54] later that it's not so introductory
[03:56] course because well my intention today
[03:59] is show
[04:00] you how to set up and perform tsunami
[04:03] simulation not only the easy examples
[04:06] like propagation in small domains but
[04:10] more advanced setups like a real big
[04:13] domain simulation Saving Time
[04:17] series preprocessing with the building
[04:20] of nested meshes inundation simulation
[04:23] and a bit of postprocessing analysis of
[04:26] the of the results so let's uh start
[04:30] this is more or less the outline for for
[04:33] today uh small introduction about the
[04:36] Tsunami High models some tips about uh
[04:40] installation on a HPC machine we will
[04:44] work today on a on a small cluster in
[04:46] order to show you how to proceed with
[04:50] this tsunami simulations and we talk
[04:53] about the Main Ingredients uh that we
[04:57] need to perform uh a simul
[05:00] and uh a kind of handson session not
[05:03] literally handson but I will show you
[05:07] some examples from propagation to high
[05:11] resolution inundation okay so let's
[05:14] start let me start talking about
[05:16] tsunamis what they are and which are the
[05:18] the main difficulties in its modeling
[05:21] and the numerical simulation as you know
[05:24] tsunami are unpredictable events and
[05:26] catastrophic in their potential for
[05:28] destruction of human lives and also the
[05:31] economy and this unpredictability of
[05:33] their occurrence is um let's say a
[05:37] challenge to the tsunami Community
[05:38] because uh it's very difficult to obtain
[05:41] from the tsunami genic records an
[05:44] estimation of the recurrence rate and
[05:46] also the severity so accurate and
[05:49] efficient mathematical and computational
[05:51] modeling is necessary to uh provide
[05:55] tsunami forecast and hazard assessment
[05:57] so tsunami simulation in the framework
[06:00] of tsunami early warning system uh let's
[06:03] say it's it's a quite recent achievement
[06:05] but it's still limited uh regarding the
[06:09] size of the problem and restricted at
[06:12] the moment to tsunami wave propagation
[06:14] so uh because faster than real time
[06:17] simulation require greatly improved and
[06:21] high efficient computational method to
[06:24] achieve uh extremely fast and effective
[06:27] uh calculations so this very important
[06:30] to uh use HPC resources to achieve this
[06:35] this challenge okay here you can see we
[06:38] we can introduce uh the tsunami highy
[06:40] models which approximates the non uh
[06:44] linear 2D equation for shallow water in
[06:47] in this case in longitude and latitude
[06:49] coordinates the shallow water equation
[06:51] written in in this spherical coordinates
[06:53] are displayed here uh we will now go
[06:58] deeper into the specific of this
[07:00] equation in this course instead we will
[07:02] focus as mentioned earlier on the
[07:05] practicals practical application and the
[07:08] results of the use more or less of the
[07:10] use of tsunami Hey Okay so let's move on
[07:14] to explore the the capabilities and and
[07:18] more just a couple of slides showing the
[07:21] the numerics aspect of the model
[07:24] highlighting for example the
[07:26] models uh high order accuracy this is we
[07:30] balance at let's say that it's uh
[07:33] efficient computational implementation
[07:36] on on gpus this is will be an important
[07:40] side of of the
[07:41] problem um we can say that we also
[07:46] enrich the model with with other nice
[07:49] numerics properties we use a hybrid
[07:53] finite difference and finite volume
[07:55] scheme we use a styed lip frog type
[07:58] scheme for the propag part and a flux
[08:01] limited TBD W type scheme for the for
[08:04] the inundation part again I'm not going
[08:06] into the numerics details but uh this
[08:09] model the the scheme presents a high
[08:12] level of parallelism and scalability
[08:15] this is would be very very important and
[08:19] let's uh in this slide let's highlight
[08:22] some key features of the tsunami highy
[08:24] model for example the the CET
[08:27] deformation model we incorporate the
[08:30] model for the for the CD bed deformation
[08:34] allowing for the you know the
[08:36] instantaneous transmission to the to
[08:38] waterfree
[08:40] surface uh tsunami highy model supports
[08:43] multiple okada segments synchronous or a
[08:47] synchron rure and several filtering
[08:51] techniques and additionally it works uh
[08:55] for rectangular but also with tri
[08:58] triangular form FS
[09:01] okay uh as I mentioned before it is
[09:04] massively uh parallel the model is
[09:07] designed for parallel computation using
[09:09] Cuda and MPI allowing you know efficient
[09:13] utilization of gpus and multi GPU setups
[09:18] and another capabilities including NES
[09:22] meshes Tod the composition with L
[09:25] balancing uh direct output of Time
[09:28] series resum a store simulation and and
[09:32] the the input output files save or store
[09:35] as net CDF format we will see later the
[09:38] the the the thing of of this output
[09:44] files and this is the workflow in case
[09:48] of the occurrence of a tsunami event
[09:51] first we are able to optain some way
[09:54] some parameters of the source given for
[09:57] example by detection sensors
[09:59] we know the magnitude more or less the
[10:02] location we can estimate the the okada
[10:05] parameters and in our site we can we are
[10:09] able to set up our computational domain
[10:12] and perform the simulation we then we
[10:15] obtain the result and all the stuff with
[10:17] the postprocessing an more or less this
[10:20] is the workflow okay so well um I would
[10:25] like to spend some time discussing how
[10:28] you can install tsunami I see on on an
[10:31] HBC cluster such as for example the
[10:34] cluster Picasso in in Malaga the power9
[10:37] at the Barcelona super competing Center
[10:40] cha machine in Italy or similar
[10:43] facilities so I will try to demonstrate
[10:46] the installation process using the
[10:48] source code from of tsunami highy I mean
[10:52] the installation of the com compiling
[10:54] tsunami I from the scratch from the
[10:57] source code um I'm going to to
[11:00] demonstrate the stallation on thika Thea
[11:02] is a small cluster of the Andalusian
[11:06] somewhere Computing Network here in
[11:08] Spain Sika sorry Sika only only has six
[11:14] gpus but it will sufficient to to
[11:16] illustrate how to launch simulation and
[11:19] get started with tsunami high so um we
[11:23] are going to to connect th and I will
[11:26] show you how to how to you to can
[11:28] install uh tsunami I see from the
[11:30] scratch so let me access
[11:34] thika okay so in this you can see my
[11:37] screen right um I'm going to access the
[11:45] cluster and uh I'm going take a a
[11:53] while okay so I'm into the cluster and
[11:56] as you can see here I have several uh
[12:00] folders one is Project the other one is
[12:02] software I'm going to access to software
[12:05] uh directory and you can see here
[12:08] different versions of tsunami highy I'm
[12:12] going to uh work with the latest uh one
[12:16] that is
[12:20] 4.3.0 uh but in order to show you how to
[12:23] install I'm going to remove this one
[12:26] that I recently created for this course
[12:35] folder okay and I'm going
[12:39] to um install or or compile tsunami
[12:42] highy in this new folder from the
[12:45] scratch so I'm going to create again
[12:48] this folder going to name as uh High see
[12:54] version
[12:57] 4.3.1 and I'm going to allocate here the
[13:02] tsunami highy source code these two
[13:06] folders contain the source code for uh
[13:10] compiling tsunami highy and also the
[13:12] source code for the low out
[13:15] balancing um stuff that we will talk
[13:18] about this uh later so I'm going also
[13:22] open file FIA you can use uh terminal
[13:26] commands to to transfer files but it's
[13:29] easy for me to show you how you can
[13:32] upload directly to
[13:35] your to your HPC account or whever the
[13:40] source code of tsunami IC I'm going to
[13:43] upload to the recently created
[13:47] folder it's take a while and the first
[13:53] uh thing that you should do in in before
[13:57] compiling the
[13:59] the the version of tsunami I
[14:03] see here we have the The Source folders
[14:08] and then you need to load some modules
[14:11] that are necessary okay so first we are
[14:14] have created the highy folder and then
[14:18] we need to load some modules that uh we
[14:22] we need PR to to to compile the version
[14:26] okay so first I'm going to remove or
[14:29] push or the
[14:32] um module
[14:36] is sorry
[14:38] mod Rel so we have no modules load but
[14:43] in order to compile before compiling we
[14:46] need to load the necessary modules
[14:48] including module
[14:51] load load cake should be one of the
[14:56] modeles that we need cakes uh uh uh uh
[14:59] uh 10 for example okay we need to module
[15:05] load also net
[15:08] CDF um in this one is if I remember what
[15:14] yes uh net
[15:16] cvf we need to load module load uh
[15:22] parallel net
[15:23] CDF okay we also need to load module
[15:28] load
[15:30] uh open
[15:33] NPI NPI I think it's version 4 well yes
[15:38] open MPI and also Cuda okay so these are
[15:42] the modu that we need uh to load before
[15:45] compiling modu
[15:47] load uh
[15:50] Cuda Cuda I think the vers nine okay so
[15:56] if we let me clear in order to show
[15:59] better clear module list these are the
[16:04] modules that are currently loaded okay
[16:08] and um additional we will load also uh
[16:12] python in case we need the for
[16:15] processing TX module load
[16:20] python
[16:22] version remember the person this one
[16:27] okay okay so we are all the we have all
[16:31] the modules loaded in order to compile
[16:35] the tsunami so we are now in this folder
[16:40] in where we have the source code okay we
[16:43] are going to create two folders to
[16:46] allocate the compiling version of the
[16:49] the execute table of tsunami Hy we have
[16:52] uh we need to create make deer bean and
[16:57] make deer
[16:59] being lb which means L
[17:02] balancing this one to allocate the
[17:05] tsunami Hy executable this one to create
[17:08] or compile the get lot balancing um
[17:12] binary file
[17:14] okay and this is very easy because if
[17:19] everything works uh we move to the bin
[17:22] folder and then just we run CC make
[17:29] and going to the source uh folder okay
[17:35] just type here and we open this kind of
[17:40] uh interface we type c in order to
[17:43] configurate everything should be
[17:45] detecting by the the files again
[17:50] configurate configure
[17:53] sorry and at the end we are going to
[17:56] generate the um
[17:59] the the files okay and after that we has
[18:04] here just the make file and we can just
[18:08] compile by using if you prefer clean
[18:12] before and then make make should compile
[18:18] the ver the tsunami highy and obtain the
[18:22] the execut table of tsunami Hass okay we
[18:26] will do in a while the same thing for
[18:28] the
[18:30] uh being LV to to create the getl
[18:35] balancing executable we'll see later we
[18:38] need this uh being file in order to uh
[18:44] say how we can manage the the gpus the
[18:47] different gpus in order to uh um divide
[18:51] our computational domain into several
[18:54] several gpus and it takes a while we are
[18:58] going to wait for a
[18:59] while and at the
[19:01] end we should have in our being folder
[19:07] the executable of
[19:10] tsunami let's wait for a while it's t a
[19:14] bit okay so at the end up to 10% we has
[19:18] just buil we have just buil the tsunami
[19:22] H executable that is here okay it's very
[19:26] easy and the other thing is to
[19:30] move to
[19:33] the
[19:35] bind lb directory and here just do the
[19:40] same CC
[19:42] make dot dot and point to the folder of
[19:46] the source code of the load balancing
[19:48] script this will you will get an error
[19:53] but we do the same configure configure
[19:58] again
[20:00] and then generate and after do make you
[20:04] will get an error but it's easy to to
[20:06] fixed because we need the the specify
[20:09] the version of the compiler for C++ we
[20:13] just copy
[20:15] this and we are going to edit the file
[20:22] cake p. dxt we are looking for the this
[20:28] flag
[20:29] C make make we go to the after the equal
[20:33] and then we paste
[20:36] the STD equal C++ 11 okay we save this
[20:42] modification and again we comply with
[20:45] the make Command and after that
[20:49] we build the target get loot balancing
[20:53] executed okay so at the end we have two
[20:57] execut TBL tsunami High that is the the
[21:00] main execut table to do that and also
[21:03] the get Lo balance that we use to manage
[21:08] the the the use of the composition of
[21:11] the computational domain to several gpus
[21:14] okay so this after that we have just uh
[21:19] compiled the the tsunami okay so let me
[21:23] go back to the
[21:25] slides again
[21:29] okay so all right so once we have
[21:32] tsunami High installed on our machine in
[21:35] our case on an HPC cluster how do we go
[21:38] about launching our first simulation
[21:41] what are the the main ingredients that
[21:43] we we need okay so start talking about
[21:46] the inputs and one of the main
[21:49] ingredient is the bimmetry or Topo
[21:52] bimmetry files required for tsunami High
[21:55] simulation okay so about the file format
[21:58] we just say that bimmetry file that
[22:01] contains X and Y coordinates in this
[22:04] case longitude and ltitude coordinates
[22:07] of a given H domain and also the
[22:10] corresponding elevation okay it is store
[22:13] in grd format which follows the standard
[22:19] net
[22:20] cdf4 data model and file format
[22:24] hdf5 okay and about the data precision
[22:28] the variables longitude and latitude are
[22:32] stored in in double should be stor in
[22:34] double numerical position while the
[22:37] bimmetry data the the elevation variable
[22:40] is stored in single position okay and
[22:44] just to say about the tools that we can
[22:47] use Jal if I remember where is the
[22:51] spatial data abstraction library is a
[22:54] kind of a translator library for raster
[22:57] and vector special data formats
[23:01] to I mean to to work with these
[23:04] topobathymetric
[23:06] files uh effectively okay so after in a
[23:10] while we also load the gal Library into
[23:14] our um cluster environment
[23:18] okay the second main ingredient is the
[23:20] PAR file the parameter file is a text uh
[23:25] file with the list of the parameters
[23:27] needed for the simulation okay we need
[23:30] to specify we will see later in a while
[23:33] uh we will need to specify the input
[23:35] data the parameters for the initial
[23:38] condition uh another thing like
[23:40] simulation times output variables and
[23:44] other let's say coefficient intrinsic to
[23:47] the model and as as I said we will see
[23:52] later specifically what there is in each
[23:54] line of this file okay so main first
[23:57] ingredient the symmetry second
[23:59] ingredient the parameter file and as the
[24:03] third the last main ingredient is the
[24:07] file in charge of managing the low out
[24:10] balancing for the gpus or GPU or gpus
[24:13] depending if we are going to use one car
[24:16] or more than one okay so we need also
[24:20] this uh binary file generated by the
[24:24] script get L balancing that have just
[24:27] compiled in in
[24:29] in the class okay so these are the the
[24:31] three main ingredients in order to to
[24:34] perform the our first simulation okay so
[24:38] let's go a bit deeper into the parameter
[24:40] file this is an example of one of the
[24:44] parameter file but as I mentioned
[24:46] earlier how do we know what to put on on
[24:49] each line of this parameter file well to
[24:52] to find out let's return to the to the F
[24:56] cluster and and take a look okay let me
[24:59] go back again to the P class I'm going
[25:02] to move to the
[25:05] um I'm going to move to the bean folder
[25:08] okay so I'm going to move back see the
[25:13] bean and here you can see the executable
[25:16] of tsunami High okay
[25:19] so um if we launch tsunami High SE like
[25:24] this tsunami High SE with no arguments
[25:28] followed by no no file okay we obtain
[25:33] how to fill this parameter file okay so
[25:36] I'm going to just run this command with
[25:39] no arguments and as you can see here let
[25:44] me put a bit larger this as you can see
[25:48] here you have a header of tsunami High
[25:53] which we appear here theni your research
[25:55] group University of Malaga blah blah and
[25:58] then we uh it's explain how to fill this
[26:04] second or this first argument for
[26:07] tsunami Hy so you we need to perform
[26:10] tsunami Hy followed by the parameter
[26:12] file and how we can F this parameter
[26:15] file well we just follow this list okay
[26:19] so we need to specify the Bim name is a
[26:23] kind of the the name for the experiment
[26:26] for the event or whatever then the path
[26:29] to the bimmetry
[26:31] file and then we need to choose one of
[26:35] these seven options about the
[26:38] initialization of stat let's say the
[26:41] initial condition okay so if we want to
[26:45] provide the C Surface displ displacement
[26:48] from file we put here zero if we use a
[26:51] standard oada uh parameters we put here
[26:55] one or if we need if we
[26:58] want to provide um okada but directly
[27:02] from file instead of list the parameters
[27:05] we provide a file with all the
[27:07] parameters from okada we use also
[27:10] triangular okada faults triangular okada
[27:14] from file and also we can uh provide uh
[27:18] C floor deformation from file C Flor
[27:21] Dynamic theformation from file we we
[27:25] will see later the difference between
[27:26] these two option and also
[27:30] gaussian as the initial condition
[27:33] depending on the uh initial condition
[27:37] that we put here we need to specify
[27:39] after that different parameters
[27:42] depending on on this on the on the
[27:44] Carlos I have a question for you may
[27:48] I which is the differ between the the
[27:51] the option zero C Surface displacement
[27:54] and the option five
[27:58] well the the op the option zero you need
[28:01] to provide the deformation applied to
[28:03] the floor okay so you need to put uh in
[28:08] your grd format the um let's say the the
[28:14] bimmetry resulting from this uh
[28:17] deformation of the of the of the floor
[28:20] and here you just need to to put uh the
[28:25] initial condition of the free surface
[28:27] okay
[28:30] at the end at the end in the yeah yeah
[28:32] at the end in the for from the people
[28:35] listening at the end it's uh the first
[28:37] one the zero you just uh put the ciss pH
[28:41] deformation but you don't you don't
[28:43] change the bottom no no no cure face
[28:47] deformation so is you have a a a kind of
[28:51] you know perturbation in the sea water
[28:53] surface but in the fifth one you move
[28:56] the bottom so it's more related it like
[28:58] like an earthquake take take place you
[29:01] move the button and that is transmitted
[29:03] to this isor phace yeah in the case of
[29:06] zero you maintain your original bimmetry
[29:08] that's right and in option five or six
[29:12] you obtain a kind of the format bimmetry
[29:17] okay this is more or less the the main
[29:20] difference between
[29:23] that yeah I can can I follow yeah
[29:26] continue continue yeah it's if if see
[29:28] that the the Odin is a bit shy I will
[29:30] try to make question
[29:32] myself big doubt that you know I I may
[29:35] have okay okay
[29:38] okay um okay so um after specify the the
[29:43] initial condition as I said before you
[29:46] need to specify the different uh
[29:48] parameters for each of these option okay
[29:51] so if you choose zero you need to
[29:54] provide the the uh initial State file
[29:59] the file containing the initial State
[30:01] for the water Su phace as you said
[30:03] before if you choose one H you are
[30:06] considering uh a standard okada so you
[30:08] need to specify if you want to apply
[30:11] kayura filter to the okada deformation
[30:13] with zero for no one for yes if you uh
[30:18] uh choose one you need to uh provide the
[30:21] depth in Metter to the the cura filter
[30:25] and and then you need to provide the
[30:28] number of faults and for every faults a
[30:30] line containing in this case the time
[30:33] because if you want to to go synchronous
[30:36] or asynchronous you can specify the time
[30:39] the location longitude and latitude of
[30:42] the epicenter the depth Carlos I have
[30:45] another question another question this
[30:47] of as synchronous and asynchronous what
[30:49] that is
[30:50] mean means that you can uh uh set
[30:56] different times for the rure of each
[30:58] fult okay if you consider for example 10
[31:02] fults you can specify that the first F
[31:05] Rapture is in Time Zero okay the second
[31:08] one is in time after 5 seconds and the
[31:12] third one is after 10 seconds so you can
[31:15] uh do a kind of dynamic rupture of all
[31:19] these fults that you are considering
[31:20] this in this uh uh lines okay okay you
[31:25] can specify the moment of the Rapture of
[31:28] each uh fault
[31:30] okay and well it's like you have a fault
[31:33] defined by different Two Three or very
[31:37] many segments okay with the the oada
[31:40] parameters so that's a a nice feature of
[31:42] the code yeah the same for segments or
[31:46] the same for triangular okada okay if
[31:49] you go down to the option three you see
[31:53] here that you for every fault you can
[31:58] also specify the time of the moment of
[32:01] the Rapture of this triangular F you
[32:04] specify the vertices of the triangle the
[32:06] rake and the sleep and but you can also
[32:10] specify the different moments for for
[32:13] the Rapture of these uh the different
[32:15] volts okay so this uh all these things
[32:20] are a key a key feure of for tsunami H
[32:23] because you can uh do a kind of dynamic
[32:28] um Rapture of of the event you want to
[32:31] to simulate okay and what to say more
[32:35] okay the difference between the C FL
[32:37] deformation from file and the C FL
[32:40] Dynamic deformation from file well you
[32:43] might be wondering what is the
[32:44] difference between the option five and
[32:46] option six well in both case you provide
[32:50] the accumulated deformation okay if you
[32:52] want to um uh provide a a c FL
[32:57] deformation
[32:58] from file you include a file let me go
[33:02] down to the option five option five and
[33:06] six okay could be similar but there are
[33:11] a bit difference between uh both okay so
[33:14] if you choose option five you need to
[33:17] provide if you want to apply the cura
[33:19] filter and so on and then you can
[33:21] provide the number of faults you want to
[33:24] to simulate and for every fult for every
[33:28] fult you need to provide the file with
[33:31] the accumulated deformation and but also
[33:35] you can use time specification for this
[33:40] uh accumulated deformation file okay so
[33:43] and if You observe the option six is
[33:46] similar but here here you just uh
[33:51] provide one grd uh file number of fults
[33:56] it should be one means that you only
[33:59] provide one grd uh file and this file is
[34:06] in some sense let's say that is kind of
[34:09] 3D net CDF file because it contains all
[34:12] the formation and their respective times
[34:16] and tsunami High not only applies each
[34:19] deformation from the file at the
[34:21] appropriate time but also interpolates
[34:24] the dynamic deformation in a space but
[34:26] also in time applying each deformation
[34:30] at each time step through the simulation
[34:32] this is the main difference between the
[34:34] option six because it interpolates the
[34:37] dynamic deformation in the space and
[34:39] time and the option five uh you provide
[34:42] an xdf file for each deformation you
[34:45] want to apply and tsunami highy applies
[34:47] them only only at the specific specify
[34:51] time instance okay so this is more or
[34:54] less the main diff difference between
[34:57] choose
[34:58] five or choose six okay and after that
[35:03] also you can you choose a gaussian
[35:06] initial deformation by providing the
[35:09] longitude Center the latitude Center and
[35:12] the height and sigma in kilom for this
[35:15] um representation of a gausian as
[35:18] initial deformation okay
[35:21] um after that after choosing the
[35:25] different initialization of State we can
[35:28] uh uh provide well and let me go down
[35:33] after that or better if we move to the
[35:38] to the slides it should be better let me
[35:41] again share the the slides after line uh
[35:45] after the specifying the different uh
[35:48] property or or
[35:51] uh coefficient to to put under the
[35:55] initial condition we need to
[35:58] specify a prefix a file prefix in order
[36:02] to uh name the output net CDF and align
[36:06] this is important because after specify
[36:09] the the prefix the net CDF file PR
[36:12] prefix for the output we need to provide
[36:15] a line
[36:17] specifying the variables to be stored
[36:20] okay one to save zero not do not save
[36:24] and the uh the different variables we
[36:27] want we could H store our ITA maximum
[36:32] ITA the maximum height the height
[36:34] maximum height velocities maximum
[36:37] velocities the module of of velocity the
[36:41] maximum modules of
[36:42] velocity maximum modules of mass flow
[36:46] momentum flux the maximum momentum flux
[36:49] and the arriv arrival time if you count
[36:52] them there are 10 different variables to
[36:56] save for uh our simulation okay so after
[37:02] uh put here the the output uh file
[37:05] prefix we specify which one of these
[37:09] variables we want to save okay with one
[37:12] to sa Z do not say
[37:15] okay uh and there two kind two kind of
[37:18] variable because we have the variables
[37:20] that are 2D let's say the maximum of any
[37:23] quantity and other that are time
[37:26] dependent so yeah if we store them we
[37:29] will have a a 2d in in space and also
[37:33] the time variable and we
[37:35] must so two
[37:37] different yeah we
[37:40] can for example this one the maximum
[37:42] modules of velocity sorry uh is uh just
[37:47] at one 1D let's say or 2D but the EA we
[37:51] can store every 60 second and to know
[37:56] the behavior of this simulation of this
[37:58] variable along the time okay and after
[38:02] specifying the the variables to a store
[38:04] we can uh use more than one level okay
[38:09] we we'll see later in in the case of
[38:11] nested me that we can also uh use
[38:15] different level of resolution and for
[38:17] each level we need to specify The
[38:20] refinement Rao in order to uh to nest
[38:24] with the the the finer resolution grid
[38:30] the number of submeshes and for each
[38:33] submesh we need to specify the same the
[38:35] bimmetry file the path for the bimmetry
[38:38] file then if we use uh if we have to use
[38:43] the the initial the initial condition
[38:45] number zero we need to provide also the
[38:48] initial State file for this uh subesh
[38:52] and then also specify the name of the
[38:56] file for the output
[38:57] a line specifying which variable we want
[39:00] to save for this level okay for each for
[39:03] each sub mesh and after do that for each
[39:09] level okay we also Pro provide
[39:14] um uh other uh um variables such as uh
[39:20] the Border condition condition for the
[39:22] boundaries one for open minus one for
[39:26] wall upper lower power left and right
[39:28] border condition then we put here the
[39:31] simulation time in seconds we want to
[39:34] simulate 1 hour we put see
[39:38] 3,600 seconds and also the frequency the
[39:42] frequency of saving a net cbfi
[39:47] which
[39:49] commented earlier if we put here a
[39:52] simulation time we put here the
[39:54] frequency in order to save every let's
[39:58] say 1 minute of simulation in order to H
[40:02] uh see the behavior of the simulation
[40:04] okay not only at the end but also in in
[40:10] every 60 second for example 30 or
[40:13] whatever
[40:14] okay ER it's would be nice to start this
[40:20] time step in order to let's say to to
[40:23] create a an animation and to see the
[40:26] behavior of all the simulation okay uh
[40:29] the next line is read points from file
[40:31] it means that if we um it's an option to
[40:35] read point from file to a store time
[40:37] series okay by using for example
[40:40] forecast Point virtual or real guses or
[40:43] whatever we need to specify the file
[40:45] with the points and also the frequency
[40:49] of the of saving time for for this time
[40:53] series okay okay Carlos before you go to
[40:56] the technical part that is CF can you go
[40:58] to the the previous slide yeah just a
[41:02] little uh explanation in in what is the
[41:05] levels uh the levels are the the domain
[41:09] with different resolution we are going
[41:11] to use so uh for the previous trainings
[41:15] course that we did we use just one level
[41:19] that mean we only do propagation we only
[41:21] have a a domain uh that has a given
[41:25] resolution of high meter 1 kilm or
[41:29] whatever and the different levels means
[41:33] increase resolution uh to do this
[41:36] nesting nesting grid we can have two
[41:39] three four and every time we go to move
[41:42] to a Next Level we have a increased
[41:45] resolution so we we are going to do
[41:48] probably we we will see a picture from
[41:50] from C very soon and the the important
[41:54] thing is that each level because there
[41:56] are two two concept here each level have
[41:58] may have different Su matches so we may
[42:02] have within a level two three four
[42:05] matches in that level so we will see in
[42:08] a in a in a picture but uh just make
[42:10] clear what means the this level here so
[42:14] they are resolution and pieces let's say
[42:17] of match with a given resolution that
[42:20] will help us to to get to the higher
[42:23] resolution at the end okay thank you
[42:26] sorry yeah thank you for yes I will
[42:29] illustrate this in in a couple of slides
[42:33] later okay and as uh it was the
[42:38] technical part I'm not going into the
[42:40] detail of the of the different
[42:42] parameters uh um I mean the the rest of
[42:46] the parameters has to be with the with
[42:48] the scheme the CPL uh condition for the
[42:52] stability the Epsilon H is kind of the
[42:56] threshold for the wet dry cell
[42:59] consideration also the the threshold for
[43:03] the this shet switch of a scheme I mean
[43:09] uh we need to specify the the meter for
[43:12] uh for the bimmetry um depth in order to
[43:15] switch between the uh propagation part
[43:17] of the scheme and the inundation part of
[43:20] the scheme and also the stability
[43:23] coefficient we need to specify for each
[43:26] level of resolution
[43:28] uh this um stability coefficient I mean
[43:32] we won't delve into the details of the
[43:35] intrinsic parameters of the model and in
[43:38] the in these examples uh we will use the
[43:41] the standards let's say so a better
[43:44] understanding of the numerical model
[43:45] will give us the opportunity to
[43:47] understand the behavior if we modify a
[43:50] bit this this values okay I don't know
[43:53] if you want to to add something in this
[43:56] technical
[43:58] no I I think that we we can leave it
[44:00] like that just to say that the CFL the
[44:02] standard one is 0.5 and and and if we
[44:07] increase the the scheme usually normally
[44:09] could be inable and stable but may not
[44:13] at the same time the larger the faster
[44:15] you you you move in time so has the
[44:18] advantage and the
[44:20] disadvantage but you know it's something
[44:22] that uh you must gain with the
[44:25] experience okay okay thanks uh what more
[44:30] well the friction type we can indicate
[44:33] here if we want to work with fixed or
[44:35] variable friction if we choose fixed
[44:38] friction we just put here the water
[44:41] bottom friction the the mining
[44:43] coefficient but if we uh use one we
[44:48] specify the file uh with water bottom
[44:51] friction for the course cset level the
[44:55] level zero but also if if we want to
[44:58] apply
[44:59] different uh friction terms for each sub
[45:03] mesh for each level and each sub mesh we
[45:07] can also provide uh this uh this meshes
[45:10] with the uh fix sorry with the variable
[45:14] coefficient for the for the friction
[45:16] okay the the latest version of tsunami
[45:18] Hy includes among other improvements the
[45:21] incorporation of the variable friction
[45:23] this feature involves you know assigning
[45:27] different water pH water bottom friction
[45:30] coefficient to each cell allowing the
[45:33] you know the examination the validation
[45:36] the know the the flute Behavior based
[45:39] for example on land use okay uh this
[45:43] version is not yet open let's say to the
[45:46] public because it's it's just testing
[45:49] now and validating is has been recently
[45:53] presented in in U for example I
[45:56] conducted as study on on fluing with a
[45:58] resolution of of 7.5 M along the entire
[46:02] coast of Puerto Rico analyzing the the
[46:05] influence of of the land use on tsunami
[46:08] fluing uh for many many sources 30 30
[46:13] sources and but well we can see that
[46:16] this advancment we will soon available
[46:20] so you can me I you you will be able to
[46:25] to work with this friction uh variable
[46:30] friction let's say Improvement of the
[46:33] tsunami High code okay but in this
[46:37] course in this example we will use just
[46:40] fixed
[46:42] friction a maning coefficient fix for
[46:45] all the all the levers all the the grids
[46:48] okay H what more
[46:52] um after that you can just uh put the
[46:57] other uh standard
[47:00] numbers such as the maximum load
[47:03] velocity for the water the typical
[47:05] length the typical depth and if you are
[47:08] going to store arrival time you can
[47:12] also specify the threshold for
[47:15] considering arrival time in meters so if
[47:19] uh the W the water height uh is um more
[47:24] than you know uh 10 10 cm I consider as
[47:31] Ral time so you can if you uh are put
[47:35] previous
[47:36] here a number one to consider to store
[47:40] arrival time then you can specify here
[47:43] the threshold for the arrival time okay
[47:47] so this is more or less how you can fill
[47:51] the parameter file we will see uh in an
[47:55] example in a while and this is about the
[47:59] parameter file and then about the
[48:01] management of of gpus okay the if you
[48:04] remember the the third main ingredient
[48:07] was the management of the gpus this is
[48:11] very easy because you just need to uh
[48:14] run the common get L balancing followed
[48:18] by the the PAR file and
[48:22] indicating how you want to uh
[48:27] divided divide your computational domain
[48:31] indicated the number of processes in X
[48:34] number of processing y so for example
[48:38] the low balancing program should be
[48:39] execut to create this de compos the
[48:42] composition of the domain for example
[48:44] you want if you have four gpus and you
[48:47] want to divide your computation domain
[48:50] in this for gpus you just put get lot
[48:53] balancing followed by the PAR file and
[48:55] then you put one by four or 2 by two in
[48:59] order to uh have uh or assign different
[49:03] part of your computational domain into
[49:06] each gpus that are available okay so it
[49:10] is important to run this um L balancing
[49:14] program to generate all the necessary uh
[49:17] for the Lo balancing ER for your problem
[49:21] okay so uh and also if you only one only
[49:24] has uh have one GPU
[49:27] you put one by one here and all the
[49:31] computational domain is assigning to uh
[49:34] one GPU okay but it is important to
[49:37] consider if you have more than one GPU
[49:39] you can divide your domain into into
[49:42] into them okay we will see later in in
[49:45] in the
[49:46] examples so after that we just talk
[49:50] about the ask may I ask a question about
[49:53] this uh I have one version that is the
[49:57] 4.0.0 I think uh that doesn't require
[50:02] this step and I'm a bit confused on how
[50:05] it deals with it because I I just uh I
[50:08] yeah just I was talking to Mark and he
[50:11] said oh you don't need to run the G load
[50:13] balancing with this version so is that
[50:15] just specific for that version is and
[50:18] I'm not sure how yeah I I don't know how
[50:23] Mark did yeah yeah I'm aware of that but
[50:26] I I forgot the the idea but one thing is
[50:28] that this one 14 or or or 41 or 22 uh
[50:34] maybe important because uh you don't do
[50:37] the dec composition in any in any in any
[50:41] way let's say so depending on on where
[50:44] do you have most of the
[50:46] water okay in your domain you may want
[50:49] to choose one or another that is
[50:51] difficult to explain by words very
[50:52] simple with a with a picture uh and and
[50:57] ER but it's true that it's not necessary
[51:01] in in this version but uh in that case
[51:04] you do a um uh the composition by
[51:07] default or probably automatize I don't
[51:10] remember I don't remember I don't
[51:11] remember because I I tried to run it
[51:13] like I I didn't get the the SRC lb file
[51:20] or folder so I just used the previous
[51:22] one but then I tried to run it and it
[51:24] just gave me some error that the
[51:26] friction should be some zero or
[51:29] something uh and then Mark said oh but
[51:31] you don't need to run the get load
[51:33] balancing so I was just wondering okay
[51:35] but maybe it's just that specific
[51:37] version but but don't worry we will come
[51:39] to you answering in detail okay thank
[51:44] you okay and we must we must say that uh
[51:48] she has
[51:49] a is a advanced user and and also having
[51:53] access to the very latest version the
[51:56] code so are not version that are not
[51:59] usually they're not available for for
[52:01] for all user that is the case the one
[52:03] Carlos is explaining yeah
[52:08] sorry okay so once we have all the Main
[52:11] Ingredients we
[52:13] are um we can just uh run tsunami highy
[52:17] so uh this uh slides uh well presents an
[52:22] example of how to execute tsunami highy
[52:26] in a class claster environment using
[52:28] bash script to configure the simulation
[52:30] so we need well you know A bash script
[52:33] header and just uh the
[52:36] configuration uh in order to establish
[52:39] the connection with the or the
[52:40] characteristics with the cluster just
[52:42] the JB name partition the output folder
[52:46] the number of nodes the resources we are
[52:50] going to use gpus the time limit Etc and
[52:54] then after that after this uh header
[52:57] we just need to run the execute table of
[53:01] tsunami highy n NPI run the path to
[53:05] tsunami highy and the path to the perile
[53:08] okay so if we put this in a bash script
[53:13] in order to to work work in a in a queue
[53:18] you we just run this script by using for
[53:21] example batch in in the clust we will
[53:24] see in in a while okay so that easy that
[53:27] easy once we have the Main Ingredients
[53:30] we just uh configure this script and run
[53:33] the tsunami highy so what about the
[53:36] outputs well the outputs uh after the
[53:38] simulation ends we will obtain this net
[53:42] CDF output files nit CDF it's Network
[53:45] common data form is a file format for
[53:48] storing you know the multi-dimensional
[53:50] scientific data such as water height
[53:53] velocity momentum temperature humidity
[53:56] pressure Etc all related in our case in
[54:00] our case all related with the tsunami
[54:02] outputs okay and as you probably know
[54:06] net CDF format is extensive use in
[54:09] scientific simulation because it is well
[54:12] s describing nature is close platform
[54:15] efficient storage it's flexible it
[54:18] supports a chunk compression uh
[54:22] integation with many visualization tools
[54:25] so this feature make it a robust uh
[54:28] choice for storing and analyzing uh
[54:31] simulation outputs and also we will use
[54:35] uh this Library net CDF operator NCO
[54:40] which provide a suite of command line
[54:43] tools for manipulating and analyzing and
[54:45] postr postprocess net cdfi
[54:50] okay so let's go uh uh to the matter now
[54:56] with uh the examples okay we are going
[55:00] to start with propagation examples and
[55:02] the idea is try to reproduce an event
[55:06] here in the Mediterranean this part of
[55:08] the Mediterranean very easy with low
[55:12] resolution in this case we are going to
[55:15] perform our simulation with a
[55:16] computational domain of one level and
[55:19] one me resolution great very very easy
[55:22] so we need to uh get the ingredients the
[55:26] the first one is to create the bimmetry
[55:28] we are going to create a grd uh top of
[55:32] bimmetry with the data of this uh region
[55:35] then the second step is create the the
[55:39] the PAR file the PAR file for the
[55:41] simulation the third step is to perform
[55:45] or to run the Lo balancing for our
[55:47] computational domain and at the end
[55:50] configure the the the the job the job
[55:54] the B script to Launch finally to launch
[55:57] and run the tsunami highy for our um for
[56:02] our case Okay so let's work on the Fly
[56:05] let's go back to the th cluster and
[56:09] start with this uh with this um example
[56:13] okay I'm going to create all the things
[56:15] from the scratch starting for the the
[56:19] top of a symmetry and and all the all
[56:21] the thing that we need okay so let me
[56:24] move to the project
[56:27] and here I have uh for the name CH
[56:32] training I'm going to put here and I
[56:36] have here a directory about examples but
[56:39] I'm going to create a new folder f for
[56:42] example
[56:46] propagation okay so I'm going to work
[56:48] here propagation okay before uh nothing
[56:54] we need to create our
[56:56] uh computational domain our toath metric
[56:59] data so the idea the idea is try to
[57:04] download let um put here more or less an
[57:09] overview of what we are going to to do
[57:11] now so as I mentioned before we need to
[57:15] create the top OFA symmetry as our first
[57:18] step so to create our bimmetry we can
[57:22] just go to a public service of uh of
[57:26] data top of AET data like this one a
[57:29] topo let me go to the b word to the grid
[57:34] exract and
[57:36] here just move to
[57:39] our area of interest in this
[57:43] case and then we select our uh data for
[57:49] example this one 1 minute 60 AR seconds
[57:54] okay and
[57:56] we can just select the rectangular of
[58:01] our uh region of Interest this one for
[58:04] example Okay small one and then we can
[58:09] just download our
[58:13] data okay this is a a TI getif okay I'm
[58:19] going to uh let me open and
[58:23] move here uh
[58:26] I think it's in
[58:29] files I this is the the the T I've just
[58:34] well just while for the course but it's
[58:38] more or less the the same domain I have
[58:41] here is in th format okay so the first
[58:45] thing that we need to do is let me
[58:49] back pyth to the jupyter notebook the
[58:52] first thing is to convert from th to our
[58:56] necessary format that is grd the need CD
[59:00] okay so we are going to use this command
[59:03] that is the gal Library so if we have
[59:06] here let me transfer my data to the
[59:12] cluster is
[59:15] F1 bimmetry
[59:18] and here I move to
[59:22] the sorry software no the CH
[59:28] training
[59:29] propagation and here I'm going to
[59:34] create make be
[59:38] bathri
[59:43] okay and
[59:46] here I'm going to upload
[59:50] my g f okay and here in the in the think
[59:56] I'm going to load also module load the
[01:00:00] necessary Library like
[01:00:03] Jal and I will use later also
[01:00:08] module load NCO the two the libraries in
[01:00:12] order to to work with raster and to geo
[01:00:17] geo data okay after loading these two
[01:00:21] modules we are now prare ready to
[01:00:26] uh translate our t uh raster into grd
[01:00:32] format okay so we just put here gal
[01:00:38] translate the output file should be net
[01:00:45] CDF uh the format should be format
[01:00:50] equals to net CDF
[01:00:54] for the input is a topo one bimmetry t
[01:00:59] and the output should be a topo one
[01:01:03] bimmetry
[01:01:05] dogd okay so it's so easy after that we
[01:01:11] just have our grd format bimmetry uh
[01:01:16] from this original data that was in in
[01:01:20] diff format okay and here as you can
[01:01:23] read here then we rename the band one
[01:01:26] variable to set in the grd file because
[01:01:30] if we uh use for example the net CDF
[01:01:34] info in order to know if all our Vari
[01:01:39] variables are okay we can observe here
[01:01:42] that we have the longitude in double
[01:01:46] Precision latitude and in double
[01:01:48] precision and not said but but band One
[01:01:54] in uh single position but we need to
[01:01:58] rename this variable into set by using
[01:02:02] in this case h a tool from NCO that is
[01:02:07] NC
[01:02:09] rename variable B one I'm going to
[01:02:14] rename as
[01:02:16] set and we put here the grd uh file then
[01:02:22] if we just uh run this we
[01:02:26] enter again in the information of this
[01:02:29] uh grd we can observe here that we have
[01:02:34] our set variable name as set instead of
[01:02:39] ban one okay so just uh
[01:02:43] to we have just our t uh original um
[01:02:50] raser converts into net cdf4 into GR the
[01:02:56] format okay so our first ingredient is
[01:02:59] read we have just the Symmetry file so
[01:03:03] let's continue with the second step we
[01:03:05] need to create the PAR file the PAR file
[01:03:09] for this um this experiment for this
[01:03:12] event we are going to consider for
[01:03:14] example an event like the 2003 the
[01:03:16] Algerian event and here I put here the
[01:03:20] the okada parameters okay so the other
[01:03:23] thing that we need to go now to do now
[01:03:26] is to move and to create example I'm
[01:03:30] going to name PAR file or I don't know
[01:03:35] if I put here but file
[01:03:37] prop prop. dxt
[01:03:40] okay and we need to uh fill this uh this
[01:03:46] uh parameter okay so the idea here is to
[01:03:51] uh know which
[01:03:53] uh what to put in each line of this
[01:03:56] parameter okay so how we can access to
[01:04:00] this information was as I said before we
[01:04:02] can just run
[01:04:07] the software I see version 4 3 Z
[01:04:14] being okay tsunami if we just run
[01:04:19] tsunami I with no arguments we are here
[01:04:22] the different lines in order to create a
[01:04:25] our bar file okay so let me open here a
[01:04:29] new a
[01:04:32] new uh cell in order to put here what we
[01:04:36] are going to put in our parameter file
[01:04:38] okay so the first thing is to name the
[01:04:40] experiment I'm going to put here uh
[01:04:45] propagation
[01:04:46] propagation uh met Froman okay
[01:04:52] propagation okay first line this the
[01:04:56] bimmetry
[01:04:57] name second line is the bimmetry path
[01:05:01] okay that is in the folder
[01:05:04] byri and its name if I remember well a
[01:05:08] topo
[01:05:10] one uh by symmetry do
[01:05:14] symmetry.
[01:05:16] GD okay the second the third
[01:05:24] sorry this not mark
[01:05:27] down Okay the third line we need to
[01:05:30] specify the initialization of stain in
[01:05:32] this case we are going to apply for a
[01:05:35] one segment of UHA parameters so we just
[01:05:40] put here the number
[01:05:42] one corresponding here to okada standard
[01:05:46] okada
[01:05:49] okay next line if we choose this one
[01:05:54] option yeah just go to down here and we
[01:05:58] need to a specify of these uh
[01:06:03] parameters the first thing if we are
[01:06:05] going to apply Cura filter in this case
[01:06:07] we are going to put zero we don't want
[01:06:10] to apply Cura filter then the number of
[01:06:13] faults that we are going to uh simulate
[01:06:17] in this case one fault is this one okay
[01:06:21] we put here
[01:06:24] one here comments
[01:06:30] uh
[01:06:33] you filter
[01:06:37] no then number of
[01:06:41] fals then for every fold we need to
[01:06:45] specify all these parameters that are
[01:06:48] here
[01:06:49] above so we put here 0.0
[01:06:57] 3.65 36 the location is
[01:07:00] 3383
[01:07:02] 3683 uh oh longitude latitude depth in
[01:07:08] kilometers 10 length of the four
[01:07:12] 65 with
[01:07:15] 17 54 the
[01:07:19] strike sorry strike
[01:07:22] 47
[01:07:24] 86 and and the Sleep 4.7 M okay these
[01:07:28] are the parameters the
[01:07:33] parameters
[01:07:39] here next line move down because these
[01:07:43] are the other options from here next
[01:07:46] cdfi we are going to say here is for
[01:07:50] example Carlos when we have more than
[01:07:52] one fault one segment for the fin where
[01:07:55] we can have uh uh different times for
[01:07:58] the rupture of the different segments
[01:08:01] and we need to to include all the
[01:08:03] segments yeah or or all of them at the
[01:08:06] same time we can just or all the all
[01:08:08] them at the same time of course yeah
[01:08:09] simultaneously okay if we put here
[01:08:12] number all do we need to add another
[01:08:15] another line okay different parameters
[01:08:18] and even different times okay so in this
[01:08:22] case we are going just to put one fold
[01:08:25] but as or has said we can just put
[01:08:28] several and different time uh Rapture uh
[01:08:32] for for every every forth okay uh so
[01:08:35] following this we need to specify the uh
[01:08:40] let me go back
[01:08:42] here if we use uh if we want to use
[01:08:47] Okala computation window in this case we
[01:08:49] are going to put here
[01:08:51] zero no
[01:08:56] location
[01:08:58] window
[01:09:00] window okay and just because yes we put
[01:09:06] zero we don't need to to put more okay
[01:09:09] so next line should be the next and and
[01:09:12] this okada computation window is for
[01:09:14] what is to uh restrict the okada
[01:09:18] computation to a um a radius okay so if
[01:09:22] you want to apply only the okada uh the
[01:09:26] formation applied to the uh just uh a
[01:09:31] radio
[01:09:32] sorry I think it's it's in a square no
[01:09:35] or a rectangular how it
[01:09:38] is I is a a c r CER okay okay so you put
[01:09:45] here one you need to specify the radius
[01:09:47] of the the the area in which you want to
[01:09:51] apply the the computation of the okada
[01:09:54] okay okay not not to apply not not to do
[01:09:58] the computation in in the whole domain
[01:10:00] because it's not necessary okay
[01:10:04] yeah
[01:10:05] so after that we move down to specify
[01:10:10] the net CDF Prof uh prefix so we put
[01:10:14] here that our output is going to uh
[01:10:18] store in for example in the folder
[01:10:22] simulations with the prefix or uh this
[01:10:25] event is Algerian
[01:10:28] alerian 2003 for example so the output
[01:10:32] net cvf file should be aerian 2003. NC
[01:10:38] from net CDF okay so this is the the the
[01:10:43] net CDF file prefix and then we need to
[01:10:46] specify a line specifying the following
[01:10:49] variables in order to store or not store
[01:10:52] okay so these are the variables
[01:10:56] okay and so I'm going to save ITA for
[01:11:00] example maximum ITA I don't want to know
[01:11:03] about the velocities so I put zero I
[01:11:06] don't want to know about the maximum
[01:11:08] velocities zero
[01:11:11] zero uh for example in order to just uh
[01:11:16] save the ITA maximum
[01:11:20] EA and at the
[01:11:22] end for example the Ral time so I want
[01:11:26] it I want also to only to store ITA
[01:11:29] maximum ITA and the arrival times okay
[01:11:33] if we want to also store the maximum
[01:11:36] momentum flux we put here a one if not
[01:11:39] we put a zero okay so as you can see
[01:11:42] here 3 6 n 10 values for each of these
[01:11:47] 10 variables to to okay then in this
[01:11:52] case I wanted to to perform propagations
[01:11:55] simulation so I want only one level
[01:11:59] level of resolution I put here
[01:12:02] one so I don't want to F this and then I
[01:12:07] go to this line in order to
[01:12:11] put so let me comment this line let's
[01:12:14] see
[01:12:21] Prix
[01:12:24] save number of
[01:12:27] levels and then the Border condition
[01:12:32] open open open
[01:12:42] fors and
[01:12:44] then the simulation time okay this will
[01:12:47] would be the simulation
[01:12:49] time this boundary condition this open
[01:12:52] boundary condition means that we we when
[01:12:54] we have Coast it's coast and you have
[01:12:56] inundation of course but when you have
[01:12:58] open ocean it's an open ocean so it's
[01:13:01] the normal one when you're doing
[01:13:02] simulation in a in let's say in real
[01:13:04] problems to have one one everywhere
[01:13:07] because means that the ocean is open
[01:13:09] where you cut in the middle of the ocean
[01:13:12] and when you have Coast you don't use
[01:13:15] that boundary condition you have your
[01:13:16] Coast that is is there m so it's the
[01:13:20] normal one maybe if you are working on a
[01:13:23] laboratory experiment or
[01:13:25] this kind of thing you can just put a
[01:13:28] wall in in your your computation domain
[01:13:31] but uh usually we we use in real case we
[01:13:34] use open uh uh border
[01:13:40] okay okay so continue with the
[01:13:42] simulation time you can just put here I
[01:13:46] don't know
[01:13:48] um 2
[01:13:51] hours 2 hour
[01:13:53] simulation for example
[01:13:56] and the frequency of
[01:13:59] saving just put here the simulation time
[01:14:03] we need to specify if we want uh the the
[01:14:06] frequency of the the saving time we can
[01:14:10] just put in order to see the behavior of
[01:14:13] the of the whole simulation UH 60 second
[01:14:18] okay so every minute we H um get the
[01:14:23] this kind of a snapshot of all our
[01:14:25] variables in in depending on time and uh
[01:14:30] in this first example this line should
[01:14:34] be uh would be zero in this case you
[01:14:39] don't want to store anything about time
[01:14:42] series so we put here zero and then we
[01:14:45] put here the standard
[01:14:48] values uh 0.5 for the
[01:14:52] CPL H the dep H we can just put uh I
[01:14:58] don't know
[01:15:01] uh1 this
[01:15:03] Ison H okay so here we we have a a
[01:15:07] question from phelipe in the in the chat
[01:15:09] the first one regarding the CFL I've
[01:15:11] already answer answer in the in the chat
[01:15:15] I I just hope that I did not privately I
[01:15:18] don't know uh in case I did I I I will
[01:15:21] share now to everyone about the CFL that
[01:15:24] was uh uh enough for phelipe and the
[01:15:27] second question was regarding the
[01:15:29] Epsilon Ed so we have two Epsilon the
[01:15:32] first one Carlos mentioned before is
[01:15:35] this one that is the Epsilon you use to
[01:15:40] uh to say that you have a wet or dry
[01:15:43] cell so it's a kind of technical one so
[01:15:46] this Epsilon is small and it mean that
[01:15:49] we have a certain um water a certain
[01:15:53] level of water in a Cell you consider it
[01:15:56] dry H wet okay at the end of the of the
[01:16:00] of the power file there's another
[01:16:01] Epsilon that at the beginning was used
[01:16:04] this this same one but uh we given many
[01:16:09] problems because it's used to decide
[01:16:11] when you say that the wave has arrived
[01:16:15] in order to compute the arrival times so
[01:16:17] we have two Epsilon H this one is for
[01:16:20] saying when you have a dry a still dry
[01:16:23] or already wet sell in your
[01:16:27] simulation yeah yes okay thank
[01:16:30] you you're
[01:16:33] welcome this next in our case we just
[01:16:37] put here 20 Ms in order to consider
[01:16:42] um the the the switch uh uh value in
[01:16:46] order to switch from the propagation
[01:16:50] scheme to the uh inundation scheme in
[01:16:53] our case we are going to use
[01:16:55] propagation because of the the low
[01:16:58] resolution of our computational domain
[01:17:01] and the stability coefficient should
[01:17:04] usually use
[01:17:06] 0.2 and then well let me comment this
[01:17:10] this is the
[01:17:13] trold for the um 2s or W
[01:17:21] scheme and this is the stability
[01:17:27] okay and then align uh specifying the
[01:17:33] friction in our case we are going to
[01:17:35] consider just fixed friction our Manning
[01:17:39] coefficient should be
[01:17:41] 0.03 for example and this is the maning
[01:17:49] coefficient and at the end the
[01:17:52] maximum allowed velocity of the water
[01:17:55] we can just put uh 100 I don't know uh
[01:17:59] typical
[01:18:01] length 10 kilom typical
[01:18:04] with uh 100 kilom and what H mention
[01:18:10] earlier is that we can consider
[01:18:13] different Epsilon in order to consider
[01:18:16] that the the wave is
[01:18:20] right yes or no arrive in in time so we
[01:18:24] can just put here if we
[01:18:27] consider uh more than 10
[01:18:30] cm uh the wave is is all right okay this
[01:18:34] is
[01:18:37] the this this L and this H are the
[01:18:40] parameter used to ad Dimension ad
[01:18:44] dimensionalization okay so usually for
[01:18:47] the length we think of uh 100 kilometers
[01:18:52] if you're in I don't know the
[01:18:53] Mediterranean so in meters of course and
[01:18:56] for the age is the order of 1 kilometer
[01:19:00] so more or less is the
[01:19:03] the the width the length that the the
[01:19:06] height that we the depth that we use as
[01:19:08] reference
[01:19:10] okay is it is it something you would
[01:19:13] change if you go pafic example probably
[01:19:17] you could change in the Pacific and you
[01:19:19] have one one more zero in the typical
[01:19:21] length right okay so yeah
[01:19:27] okay so we are but of course it's there
[01:19:30] because when you move to a to a
[01:19:32] experimenting in the laboratory that
[01:19:34] might be drastically change right so if
[01:19:39] for small changes is is not dramatically
[01:19:42] changes is as I said is for ad
[01:19:45] dimensionalizing ad dimensionalize the
[01:19:48] the the results and ERS and also I have
[01:19:51] the answer to your question Valentina
[01:19:52] because I think that you're using the
[01:19:54] Monte Carlo version isn't it yes so
[01:19:57] Monte Carlo version who does Monte Carlo
[01:19:59] version right use a single GPU for you
[01:20:03] the the idea is to do very many
[01:20:05] simulations using a single GPU so you
[01:20:07] don't have to do the lot balancing the
[01:20:09] lot yeah okay that makes sense the it
[01:20:12] was imagine that it was the Monte Carlo
[01:20:14] version that only needs one GPU per per
[01:20:17] job okay yeah may use one very many 64
[01:20:21] but you're using so so no need to
[01:20:23] balancing MH yeah
[01:20:26] thanks okay so this is the content of
[01:20:31] our parameter files so let me uh go back
[01:20:34] to the th cluster let me edit the part
[01:20:40] file and just copy
[01:20:43] this lines into the file for our s okay
[01:20:49] so the idea is that once we have our
[01:20:53] parameter files one we have our uh B
[01:20:56] symmetry the the the the third
[01:20:59] ingredient was do the low at balancing
[01:21:03] okay so we move to our uh execute table
[01:21:08] that is in
[01:21:10] software High
[01:21:12] c.
[01:21:15] 4.3.0 being lb get lot balancing
[01:21:20] followed by the PAR file and followed by
[01:21:23] in our case we are going to use only one
[01:21:26] GPU so we put here one by one and if
[01:21:30] everything works it's okay here we just
[01:21:34] have the information of our problem okay
[01:21:38] this is the information of our problem
[01:21:40] is very very uh small domain with just
[01:21:45] 400,000 of cells okay and as you can see
[01:21:49] here we are just created this being uh
[01:21:54] uh file that is our name okay here you
[01:21:59] have the the bimmetry name or the event
[01:22:02] of the experiment name followed by the
[01:22:05] number of levels and the number of gpus
[01:22:08] we are going to use okay
[01:22:12] so what are the content of our um uh
[01:22:18] fold we have the bar file we have also
[01:22:22] the
[01:22:22] bathymetries we need to create because
[01:22:25] we put here the folders for the outputs
[01:22:29] we need to create the simulation folders
[01:22:32] and make deer simulations
[01:22:36] simulations in order to store the ndf
[01:22:39] the
[01:22:40] output and just we need to create the
[01:22:46] job the the job job configuration the
[01:22:48] bash script in order to launch our um
[01:22:53] our simulation in the Q system okay so
[01:22:56] I'm going to just um create this uh file
[01:23:01] job using 1 dpu
[01:23:05] Dosh okay going to
[01:23:09] edit and I'm going to just copy and
[01:23:12] paste this I'm going to just put here s
[01:23:17] and you can see here
[01:23:21] sorry again
[01:23:26] okay so the job name should be my name
[01:23:31] prop or let me put
[01:23:35] here I don't
[01:23:37] know
[01:23:39] alerian GPU partition we are going to
[01:23:43] store the output of the tsunami High SE
[01:23:46] execution not the output of the
[01:23:48] simulation but the output of the tsunami
[01:23:50] has execution in this folder so we
[01:23:56] needed to we need to to create this also
[01:23:59] this uh folder we are going to use only
[01:24:02] one note only one GPU the time limit
[01:24:05] very very small just 10 minutes in order
[01:24:08] to to complete the simulation and we
[01:24:11] need to I'm going
[01:24:13] to change this because we have now in
[01:24:17] this folder projects CH training
[01:24:20] propagation and we just and um invocate
[01:24:25] the command MPI run followed by the
[01:24:28] execut table of tsunami highy and
[01:24:31] followed by the path to the PAR file
[01:24:35] that we have just created okay so I'm
[01:24:39] going
[01:24:41] to I'm going to save
[01:24:45] here
[01:24:47] and I'm going to create also the uh make
[01:24:51] the O folder in order to to save the the
[01:24:56] the output of the tsunami highy
[01:24:58] execution and all the we have already
[01:25:01] all the ingredients so we just need to
[01:25:06] uh execute the um the bash script in
[01:25:11] order to launch our
[01:25:14] simulation cross finger
[01:25:17] batch job poopy you can see here I just
[01:25:23] submit this job
[01:25:25] this job has this name and if
[01:25:29] I
[01:25:31] skew
[01:25:33] my
[01:25:35] user uh no
[01:25:41] sorry maybe something happened let
[01:25:50] me cons the job no no it's it's okay
[01:25:54] it's okay it's just end after 5.5
[01:25:59] seconds okay so we have just a simulat
[01:26:02] two hours of simulation in just 5.5
[01:26:07] seconds so maybe if we move to the
[01:26:11] simulation
[01:26:13] folder
[01:26:14] simulations here you just have the
[01:26:18] result the net CDF for this experiment
[01:26:21] Algerian 2003. n C okay so uh in just 5
[01:26:28] Seconds we have simulated two hours if I
[01:26:32] remember where yes 2 hour of simulation
[01:26:34] okay so uh one one thing that we can do
[01:26:39] directly in our cluster is to have a
[01:26:44] um visualize our simulation by using NCB
[01:26:49] command followed by the net CDF Let's uh
[01:26:54] uh open this and as you can see here we
[01:26:58] need we have this interface in which we
[01:27:03] can choose our variable we have the
[01:27:06] original bimmetry the deformed bimmetry
[01:27:09] caused by the the theault the okada
[01:27:12] standard okada fault the maximum height
[01:27:15] the arrival time and also the ITA that
[01:27:18] these are the three variables that have
[01:27:22] we uh put
[01:27:24] uh in order to to store okay so if we
[01:27:28] put here just click here we can see our
[01:27:32] computational domain okay let me share
[01:27:35] the the color map in order to see better
[01:27:40] the maybe this one yet is okay I'm going
[01:27:44] to uh put the minimum in minus two and
[01:27:49] maximum two and here you can see the
[01:27:53] initial condition okay the first uh um
[01:27:59] configuration of the the the initial
[01:28:02] condition and if you put you P here in
[01:28:05] forward uh repution you can see the
[01:28:10] um the behavior of the simulation in
[01:28:13] time okay because we have a store every
[01:28:17] six 60 seconds so we have
[01:28:20] 120 snapshots of the simulation for the
[01:28:24] H it variable okay for this I put
[01:28:29] [Music]
[01:28:32] again if we put here for example from
[01:28:36] minus one to
[01:28:40] one here you have the behavior of the
[01:28:43] simulation
[01:28:45] okay so as you can see it's very easy we
[01:28:49] we only need the top of aetric data
[01:28:53] small domain or big domain or whatever
[01:28:55] and uh just uh configure the parameter
[01:28:58] file put all the lines in in it in in in
[01:29:03] the correct uh position and just
[01:29:07] configure the job and run the the the
[01:29:10] simulation okay so let me back to the
[01:29:14] slides
[01:29:17] and stop here
[01:29:20] okay um let back to the slides and
[01:29:25] H the post processing as I mentioned
[01:29:27] before you can
[01:29:29] just open the the
[01:29:31] ncbw uh in order to just uh have an idea
[01:29:35] of how your your simulat has uh has gone
[01:29:40] and also you can try to create
[01:29:44] some plots like like this one by using
[01:29:49] python script so if you are familiar
[01:29:51] with with python you just uh need to
[01:29:54] load some libraries some uh like net CDF
[01:29:58] or M plot lip numai copy in order to to
[01:30:02] plot your your maps and then once you
[01:30:05] have read the the net cdfi you extract
[01:30:10] your longitude variable Max latitude
[01:30:12] variable and the max he Max height has
[01:30:16] variable and just well you you I can
[01:30:20] provide your this this script in order
[01:30:23] you to modify if you want and then try
[01:30:26] to uh create these kind of plots in
[01:30:30] order to to represent your your results
[01:30:34] okay so this uh first example is is very
[01:30:38] easy and one of the thing that we can do
[01:30:41] is add uh for example as an exercise add
[01:30:45] forecast point in order to to to analyze
[01:30:49] the the behavior of the the water height
[01:30:52] along this uh forecast point so how we
[01:30:56] can do that I have
[01:30:58] selected some of them and the idea is
[01:31:02] that if we have the location of this uh
[01:31:07] virtual or real uh voice we need to
[01:31:10] create this file starting the first line
[01:31:14] is the number of Po the the point of
[01:31:17] interest and then the location the
[01:31:19] longitude and latitude of each for for
[01:31:22] each of these uh points and the only
[01:31:26] thing that we need to to do is to modify
[01:31:30] our um parameter file so let me upload
[01:31:37] this file into
[01:31:39] our
[01:31:41] our folder there here I can just
[01:31:46] upload
[01:31:48] this into our um order in the in the in
[01:31:52] the sa machine and then let me show you
[01:31:57] this file this is the the file with the
[01:32:02] the point of Interest the location of
[01:32:03] the point of Interest
[01:32:06] so you can see here that is the first
[01:32:10] line is the number of Po and then the
[01:32:13] location and the longitude and latitude
[01:32:15] of each one okay so as I said we only
[01:32:20] need to modify our PAR file so let me
[01:32:24] enter again to edit the PAR file and
[01:32:28] here if you remember we put here a zero
[01:32:32] because this is the h f read file for
[01:32:39] time series okay so in this case I'm
[01:32:42] going to put here
[01:32:45] one and then if you remember we need to
[01:32:50] provide the file that is
[01:32:57] FCP med. dxt and then the frequency for
[01:33:02] Saving Time series okay so I put here
[01:33:05] for example every 30 second okay so I
[01:33:09] have just change this this line and this
[01:33:13] line okay I'm going to save
[01:33:17] again and the rest of the files are the
[01:33:20] same I'm just need to again
[01:33:25] execute by using sorry
[01:33:31] match job1 GPU Dosh
[01:33:37] okay this is um the
[01:33:42] job and it's just finished if you can
[01:33:46] see here if I
[01:33:49] uh put cut out and the job uh ending in
[01:33:57] six
[01:33:58] sorry net CDF fiction file have okay I
[01:34:03] think I think the yeah because I think
[01:34:05] the what you Chang it was like the the
[01:34:08] wrong the wrong line okay
[01:34:10] so so I wasn't entirely
[01:34:14] sure but I think before I was friction
[01:34:17] yeah so here let me put again here a
[01:34:21] zero because this is the friction yes
[01:34:24] I
[01:34:26] I this is the
[01:34:31] friction
[01:34:33] yes friction is fixed we use and this
[01:34:37] one if I remember well is
[01:34:39] the
[01:34:41] um here the line that we need to change
[01:34:45] this is the read sorry for
[01:34:47] the read file for Time series
[01:34:54] we have with
[01:34:56] FCPS me pxt and then every saving time
[01:35:01] every 30 seconds I think it's okay
[01:35:07] now
[01:35:09] okay here a small comment that when we
[01:35:12] when you want to save the 2D Fields 60
[01:35:16] one minute is too much in general and
[01:35:19] when saving the the time series uh 1
[01:35:23] minute is like the minimum let's say
[01:35:25] because you need to not to lose this
[01:35:27] time series okay
[01:35:31] so okay so I run again the the bash
[01:35:35] script in order to
[01:35:37] um to run the the
[01:35:41] simulation and 5 Second 7 second 8
[01:35:46] second that's just uh end and now if you
[01:35:51] go to the simulation folder you will see
[01:35:55] two net CDF file one for the simulation
[01:35:59] and the other one ending inore TS from
[01:36:02] time series. NC okay so this file store
[01:36:07] the simulation uh time series uh or our
[01:36:13] our points if you enter about the info
[01:36:18] for this file gbn
[01:36:21] tsnc okay here here you can observe that
[01:36:26] we have several variables but the one
[01:36:29] that uh are in is our interest is this
[01:36:33] one because it depend on time and the
[01:36:36] grid and points that are the different
[01:36:38] point of points of interest that we are
[01:36:42] interested in okay so one thing that you
[01:36:45] can do is let me go back to the slides
[01:36:49] again is use an script python script in
[01:36:53] order to plot the the time series here
[01:36:57] for example the the these point that are
[01:37:01] here okay so you just read the time
[01:37:04] values you read the ITA variable that
[01:37:07] depending on the time and the different
[01:37:11] uh Point okay and just plot the the time
[01:37:15] series okay so you just is is just uh
[01:37:20] read the net CDF file and work with is
[01:37:23] the the variables inside okay so our
[01:37:27] first easy example of propagation in a
[01:37:30] small domain even by storing um time
[01:37:35] series is completed okay so you are just
[01:37:39] ready to to do by your own so if you
[01:37:42] want an exercise here I I provide you an
[01:37:46] example of an event in the in the
[01:37:49] Pacific in um in the in the Colombian
[01:37:52] Trench with the okada parameters so if
[01:37:56] you try to do the same as I did before
[01:38:01] you should be able to obtain the result
[01:38:04] like this for the maximum height and
[01:38:07] also if you want to analyze the the time
[01:38:10] series for this Dart voice uh I can I I
[01:38:15] will provide you the the data for in
[01:38:17] order to reproduce this this exercise
[01:38:20] okay I don't know the time okay H Carlos
[01:38:24] I think a small break that was supposed
[01:38:26] to be 10 minutes ago uh for small rest
[01:38:30] we can do I don't know five 10 minutes I
[01:38:33] don't know it's yeah what do you feel
[01:38:35] but you you you're on the command what
[01:38:38] do you say 15 minutes is okay for me you
[01:38:40] know we can we can perhap we can go back
[01:38:43] at uh six
[01:38:45] 1650 in 10
[01:38:48] minutes yeah
[01:38:49] yeah so 10 minutes to five to 5 same
[01:38:54] minute to
[01:38:55] five okay then I think there are some
[01:38:59] questions but maybe after we come back
[01:39:02] we check the chat and answer the
[01:39:04] questions
[01:39:06] okay okay yeah I I tried there is just
[01:39:08] one that I left okay the rest I I was
[01:39:12] answering great okay I'll see you all in
[01:39:15] 10 minutes okay see you in 10 minutes
[01:39:18] bye
[01:39:20] bye so let's go for the final part yeah
[01:39:23] please pleas okay about the last
[01:39:27] question in the chat just to say that in
[01:39:29] the in the job uh the bash script that
[01:39:32] launched the the job to the Hue is just
[01:39:36] the well with the sbatch command you
[01:39:38] specify some characteristics for the
[01:39:41] understanding of the of the SAA machine
[01:39:43] in this case or in your HPC machine the
[01:39:46] job name the partition the output the
[01:39:48] nodes the resources if you are going to
[01:39:51] use gpus the time limit also you can
[01:39:54] specify the memory and that and the last
[01:39:57] two commands are this one is to change
[01:40:00] the directory to the the the folding
[01:40:04] which you are the your data and the last
[01:40:08] one is the important one that is the NPI
[01:40:12] run followed by the path to the
[01:40:15] executable of tsunami highy and follow
[01:40:19] by the uh PAR file the the the parameter
[01:40:23] file okay so the important one is this
[01:40:27] but the other is just to change the
[01:40:28] directory to to the to the correct uh
[01:40:33] folder to the correct diet okay okay so
[01:40:38] um let's continue continue with the let
[01:40:42] me back to the
[01:40:44] slides so we have just work on this uh
[01:40:49] thing the exercise propos and uhh I
[01:40:54] wanted also to talk about the different
[01:40:57] initial condition that we can just put
[01:41:00] in our uh parameter file for example if
[01:41:03] we we have just talk about uh them but
[01:41:07] in order to illustrate the the thing
[01:41:10] here you can see the initial
[01:41:13] deformation uh for the C Surface just uh
[01:41:19] providing well another grd file that
[01:41:25] just um must be included or the the have
[01:41:30] the same size but you can also use a
[01:41:34] small one that uh has nested that is
[01:41:38] nested with respect the the your
[01:41:40] computational
[01:41:41] domain uh we have just talk about the C
[01:41:44] FL deformation you can uh provide a grd
[01:41:48] file with the accumulated
[01:41:51] deformation um stat or dynamic
[01:41:55] deformation multiple okada only one
[01:41:58] segment okada standard okada gaan
[01:42:00] initial condition and here I wanted to
[01:42:04] wanted to illustrate how a dynamic uh
[01:42:08] multi works because in each time you can
[01:42:13] uh
[01:42:14] um um represent the rupture of different
[01:42:18] uh faults in different time uh type
[01:42:21] steps time steps okay
[01:42:23] so you can uh not only work with the
[01:42:27] standard but you can uh use different
[01:42:30] initial uh condition okay so let's uh
[01:42:34] now jump to the difficult uh part of
[01:42:38] this course the hot spot here let's say
[01:42:41] that is the nested meses algorithm in
[01:42:45] order to achieve high resolution
[01:42:47] inundation for tsunami simulation okay
[01:42:50] so uh the the idea behind nested meshes
[01:42:54] is that we let's say we typically have
[01:42:58] low resolution data over large domain
[01:43:00] for example here we have the wolf of
[01:43:03] cadii and as we can approach our area of
[01:43:07] Interest we will have better resolution
[01:43:09] data until we reach to an optimal
[01:43:13] resolution in order to evaluate the the
[01:43:16] inundation the fluting okay so uh well
[01:43:21] as I right here is important well we
[01:43:25] start from a mesh of a certain
[01:43:27] resolution and then we can build a set
[01:43:30] of nested meshes with respect to the
[01:43:33] previous one let's say uh from a
[01:43:36] refinement writer okay so it's important
[01:43:39] I can show you
[01:43:42] um a graph uh in the in the next slide
[01:43:47] to show you uh how you need to
[01:43:49] distribute the cells of each uh L when
[01:43:53] you are nesting your GDs okay so uh we
[01:43:58] start for example for example if you if
[01:44:00] you go to the previous slide Carlos here
[01:44:02] for example we have what we were saying
[01:44:04] before we have four levels of refinement
[01:44:07] four level with different resolution you
[01:44:09] see that the the black one that is Mark
[01:44:13] you see there in black is
[01:44:16] 320 uh 20 M resolution then the ratio to
[01:44:22] go to go to the next one that the blue
[01:44:24] is two that means that we divide by two
[01:44:28] the you know the the size and we
[01:44:29] increase the resolution and the next one
[01:44:32] the the this refinement ratio is four we
[01:44:36] go in the green one to 40 m and finally
[01:44:40] we we are going to do the inundation at
[01:44:43] the coast as a resolution of five Metter
[01:44:46] because finally there's a
[01:44:48] four sorry a ratio of refining of eight
[01:44:52] at very l so we get to the coast with a
[01:44:55] pixel of 5 m resolution uh for for
[01:44:58] inundation so these are the four levels
[01:45:00] in this case that we were mentioning
[01:45:02] before okay thank you we use here four
[01:45:05] levels in order to pass from 320 M up to
[01:45:10] 5 meter of resolution per pixel in the
[01:45:13] small one in red uh domain
[01:45:16] okay uh so what's I'm trying to
[01:45:20] illustrate the the process so we start
[01:45:22] with our level zero grid our let's say
[01:45:26] ambient grid and we will Nest the next
[01:45:30] level of resolution where where each new
[01:45:34] point of the grid will be located at the
[01:45:37] center of the sub cells resulting from
[01:45:40] this refinement ratio of the of the
[01:45:43] course grid
[01:45:45] so uh we establish a refinement ratio so
[01:45:50] first we Define the the the ratio and
[01:45:53] that should be must be um Power of Two
[01:45:57] Rao so we can just use two or 16 64 Etc
[01:46:03] so should must be a power of two
[01:46:05] refinement ratio and then after
[01:46:08] establish The refinement Rao we create a
[01:46:10] new sub grid
[01:46:13] so in this uh points in these points new
[01:46:18] points in blue the center the points in
[01:46:20] the center of these cells in blue we
[01:46:23] interpolate the fin the finer data onto
[01:46:28] onto this grid okay so from to pass from
[01:46:32] Level zero to one we select a redu h
[01:46:36] area or reduce extension of our domain
[01:46:39] we refin our cells we obtain new points
[01:46:43] that are in the center in this sub cells
[01:46:46] and here we interpolate our final data
[01:46:50] in order to have a find
[01:46:53] the better resolution data but now
[01:46:56] nested on our previous level in in this
[01:47:00] case okay and so on uh we all the levels
[01:47:04] we are going to consider always taking a
[01:47:08] a refinement ratio as a power of two so
[01:47:11] we are able to select a small extension
[01:47:15] of our domain in which we have better
[01:47:18] resolution data we uh refine our grid in
[01:47:23] order to obtain the points in the center
[01:47:27] of this Sub Sub sub cells consequence of
[01:47:31] their refinement and then we interpolate
[01:47:34] our data in order to have nested with
[01:47:37] our previous level and then with with
[01:47:39] the rest of the levels that we are going
[01:47:41] to to consider it is important to also
[01:47:44] to consider that there are certain uh
[01:47:46] let's say restriction of on the
[01:47:48] boundaries of the grids as the you can
[01:47:52] see here the the the edges of the grids
[01:47:54] at a certain level cannot coincide with
[01:47:57] the edges of the previous level okay so
[01:48:00] the points here in jello or the cells
[01:48:03] here in jellow are not allowed because
[01:48:05] the edges of the of the extension of the
[01:48:10] domain coincide with the previous one
[01:48:13] okay so we want we these cells in in
[01:48:18] jello or this one in jello are not
[01:48:20] allowed because the edges uh from one
[01:48:23] level to another are in the same in the
[01:48:26] same uh place okay so um here to to
[01:48:31] illustrate the example that we H show
[01:48:34] before if we want to achieve for for
[01:48:36] example in this case a resolution of
[01:48:39] let's say 5 Metter in a very specific uh
[01:48:42] you know population area in which we are
[01:48:45] interested in inundation we can consider
[01:48:47] this set of nested uh nested grids okay
[01:48:51] so starting from Level Z
[01:48:53] here I'm exaggerating the resolution
[01:48:55] right okay but uh we um set our level
[01:49:01] one in blue we refine this uh this mesh
[01:49:07] we interpolate the new data in this in
[01:49:10] um center of the inter cells consequence
[01:49:14] of the refinement then we set our level
[01:49:17] two here in green we refine them and
[01:49:20] select our data here we
[01:49:23] again uh determine our area of Interest
[01:49:27] now in red we refine the same in the
[01:49:32] same the same manner and even if we add
[01:49:35] another level of resolution we need to
[01:49:38] refine and use the finest data but that
[01:49:44] matches with the points uh consequence
[01:49:48] of this refin okay so the the best thing
[01:49:53] is to to see this in an example okay
[01:49:58] and here I present you a script on how
[01:50:02] we can Nest grids okay uh you can build
[01:50:06] your own script always following the
[01:50:08] this instruction and consideration I
[01:50:10] mentioned earlier and here I show you an
[01:50:13] script by using Python and the this uh
[01:50:18] mentioned earlier Jal Library okay so
[01:50:21] the idea is simple I'm going to show you
[01:50:25] an example
[01:50:27] of um how to Nest two different grids
[01:50:32] okay so the first thing is this uh kind
[01:50:35] of function the thing that this
[01:50:39] function um do is just a simple function
[01:50:44] that reproject the fine grid the fine GD
[01:50:49] uh the fine let's say the fine data the
[01:50:52] fine grid image raser teeth or whatever
[01:50:55] in order to match the course grid
[01:50:59] projection and resolution remember that
[01:51:01] we need to uh have the finite data in
[01:51:06] the points of these uh blue cells in the
[01:51:11] center of these blue cells in order to
[01:51:13] be nested with the previous level H in
[01:51:17] Black okay so this function is in charge
[01:51:20] of that right okay so so you you
[01:51:24] can um analyze deeper when you get the
[01:51:29] the the material but the thing that this
[01:51:32] function do is just take data usually
[01:51:37] finer and not Align data in order to
[01:51:40] match the master projection and
[01:51:42] resolution okay so it's it's very easy
[01:51:47] and the the thing the main part of the
[01:51:51] script is this one okay here you define
[01:51:56] the input parameters such as the the
[01:51:58] file paths for the course grid and the
[01:52:02] fine grid raster here I'm going I'm
[01:52:05] going to work with th but as you uh uh
[01:52:09] saw before then you can just uh convert
[01:52:13] into grd when you have the the the N
[01:52:17] diffs and you define a ratio of
[01:52:20] refinement so the idea is
[01:52:23] first you read the course
[01:52:27] Grid in order to get or extract the spal
[01:52:31] resolution okay and you crop this course
[01:52:35] grid to the extension of the uh fine
[01:52:39] grid okay so you have data H uh finer
[01:52:44] data and you crop your course level your
[01:52:48] cross Grid in in Black H according to
[01:52:52] the extension of the fine grid okay so
[01:52:56] you obtain the the the the grid here the
[01:53:00] extension of the grid here in blue okay
[01:53:04] then you apply your refinement of radio
[01:53:07] whatever radio radio Rao okay and you
[01:53:11] obtain this blue grid with the
[01:53:15] refinement ratio that you have
[01:53:16] considered dividing the resolution
[01:53:18] obtained from the course Grid in by the
[01:53:22] r IO of refinement so you has new
[01:53:26] resolution grid of XR and yr that is the
[01:53:31] uh the division of initial resolution by
[01:53:34] the rate of refining okay and then you
[01:53:39] once you have this you have the fined
[01:53:43] data original F data and your master
[01:53:48] file in which you need to reproject your
[01:53:51] F data okay so with the function that is
[01:53:55] defined uh before here with this
[01:53:58] function you just reproject your fine
[01:54:02] data into the proper Nest mesh with this
[01:54:07] refinement right okay so this output is
[01:54:12] just the in this case the ti that you
[01:54:15] put here the th nested data but with the
[01:54:19] values interpolates in the Corr
[01:54:23] sets or points for the nested uh mesh
[01:54:27] okay so you start from a course data you
[01:54:31] have find data that might be not aligned
[01:54:34] with your with your resolution of of uh
[01:54:37] previous um grid but with this function
[01:54:40] you are able to reproject this data into
[01:54:44] this master file or match file in order
[01:54:47] to have both grids nested okay after
[01:54:51] that you just convert from th to
[01:54:54] grd uh the the course one the original
[01:54:57] one the the course and also the fine one
[01:55:02] okay so if you are going to use this
[01:55:07] script you will obtain uh uh the T but
[01:55:11] also the grd output of this one okay so
[01:55:15] let me uh show you in an example we are
[01:55:18] going to start from from this with this
[01:55:21] example of of caribbe Caribbean wave
[01:55:25] lantex uh 2013 by using nested Mees so
[01:55:29] here we have the the parametersa
[01:55:34] parameters of one event located here and
[01:55:38] our uh objective our goal here is try
[01:55:42] to start from a low resolution in an
[01:55:46] ambient grid up to
[01:55:50] obtain to to try to perform
[01:55:52] inundation uh results in a resolution in
[01:55:56] a small area of computational domain
[01:55:59] with 7.5 M of resolution I chose this
[01:56:04] one because it not take long and we can
[01:56:07] just
[01:56:08] do life in a while okay so the idea here
[01:56:12] is start from an ambient GD here in
[01:56:16] Black of one nearly 2 kilm of resolution
[01:56:21] then a apply a ratio of refinement of
[01:56:24] four to obtain this region in blue of
[01:56:29] 480 M resolution then apply new level of
[01:56:35] eight rate of resolution of eight by
[01:56:38] obtaining 60 m per pixel resolution in
[01:56:42] this uh green area all the the Puerto
[01:56:46] Rico island and after that just um apply
[01:56:51] a new level
[01:56:52] by using a Rao of refinement of eight in
[01:56:55] order to obtain
[01:56:58] 75.5 M of resolution
[01:57:02] okay this is because we have data here
[01:57:05] very good data of this region this heror
[01:57:08] or whatever this town here with a
[01:57:12] resolution of 7.5 so the idea is how we
[01:57:15] can achieve this high resolution uh for
[01:57:19] this area well by using nested meod in
[01:57:22] order to have a big ambient Grid in
[01:57:26] which we uh put our initial event the
[01:57:30] the initial condition of our
[01:57:34] um fult event okay but then try to go up
[01:57:40] to 7.5 M resolution okay so let's work
[01:57:45] on the Fly let me back to the thika and
[01:57:48] I'm going to create a new
[01:57:52] folder name
[01:57:56] inundation okay so the idea let me move
[01:58:00] to this thing so the idea here is the
[01:58:04] same we need to apply for the uh well to
[01:58:08] to
[01:58:09] to to do the same First Step create the
[01:58:13] bimmetry file okay so I want to show you
[01:58:17] what are the data that I have here I
[01:58:20] have four sets of data I have data of
[01:58:28] 1,920 M I have also data of 2 140 M I
[01:58:34] have data of 30 m and this small um area
[01:58:41] is called Pon region or something like
[01:58:44] that that is 7.5 M of resolution okay
[01:58:49] all of these things are thff okay
[01:58:53] and this is the representation of this
[01:58:55] more or less this uh extension okay but
[01:59:00] if you if sorry I need to switch again
[01:59:04] to this okay so I have data here data
[01:59:08] here data here and data here but n not
[01:59:12] with this resolution uh radio okay so I
[01:59:16] have
[01:59:17] different pixel resolution here uh in to
[01:59:22] create this nested Mage okay so first of
[01:59:25] all I'm going to uh upload this data
[01:59:30] here I'm going to create a new folder as
[01:59:33] name
[01:59:37] byri trees and then I
[01:59:41] will allocate here all this uh well I'm
[01:59:46] going to to work in local so let me go
[01:59:50] back to that okay so
[01:59:52] the idea here I'm going to uh just run
[01:59:57] this script is the same that I put in
[01:59:59] the in the slides so this is to uh run
[02:00:03] the the the function and as you can see
[02:00:07] here I
[02:00:09] have the course grid is let
[02:00:15] me delete this in order to show you all
[02:00:19] the
[02:00:19] process okay so I need to specify
[02:00:27] here okay so I have to specify here the
[02:00:31] coest level that is
[02:00:34] lantex lantex
[02:00:38] 2013 uncore 1 920
[02:00:43] m. t this is my course grid
[02:00:48] okay and I have better data resolution
[02:00:52] that is this one okay this is
[02:00:57] lantex
[02:00:59] 2013
[02:01:01] 24 M do T okay and I want to create the
[02:01:09] first level of resolution that that if
[02:01:13] you
[02:01:14] remember I want to have the blue
[02:01:19] area not with to 2040 but with
[02:01:25] 4,080 M so I'm going to refine my
[02:01:29] original uh resolution that is uh 1 1920
[02:01:33] M by a Rao of four okay so in my script
[02:01:39] I put here ratio of four and the the
[02:01:43] output should be
[02:01:46] landex can put here lantex 13 underscore
[02:01:51] l one okay because I'm going to create
[02:01:55] the level one nested with the level zero
[02:02:01] okay we apply a rate of refinement and
[02:02:05] then just the the rest of the the script
[02:02:09] is is okay I'm going
[02:02:12] to run this and as you can see here
[02:02:16] create a new file nesting Grid in this
[02:02:20] case uh just a warning here nested
[02:02:23] meshes created and in this directory You
[02:02:28] observe here I have just created the
[02:02:30] lantex L1 nested nested doti and the
[02:02:35] corresponding nested
[02:02:37] dogd okay so this one that is the the
[02:02:42] original t i uh also convert it to grd
[02:02:47] and this one level one is just next test
[02:02:52] it with respect to the uh lever zero
[02:02:55] okay so so easy I'm going to change now
[02:03:01] I'm going to consider my course grid the
[02:03:05] lantex
[02:03:10] 13
[02:03:12] nested T that is this one because this
[02:03:16] one L1 is just nested with respect to
[02:03:18] the level zero okay and I'm going to
[02:03:22] consider better new new data but better
[02:03:25] in in in resolution that are the next
[02:03:28] one that is in 30 m resolution so I have
[02:03:32] data with 30 m resolution but now I want
[02:03:36] a new er grid but with 60 M resolution
[02:03:43] so I want to apply a refinement radio
[02:03:46] from the previous one the level one to
[02:03:49] obtain 60 m resol ution so so I need to
[02:03:53] put here a Rao of eight in order to
[02:03:57] obtain 60 M resolution so the only thing
[02:04:00] that I have to change here I have to put
[02:04:03] here L text to sorry L text
[02:04:09] 2013 uncore 30 m do
[02:04:13] if and the results I wanted to store as
[02:04:18] L2 okay the script added
[02:04:22] after the the theore nes. but the the
[02:04:28] original name is lantex 13. l2. tip okay
[02:04:34] but now I want a eight as The Rao
[02:04:38] refinement refinement of the the grid
[02:04:41] okay so this is the course my new course
[02:04:46] grid this is the data might be no
[02:04:50] alignment with the with the grids but
[02:04:53] what I'm going to obtain is uh do um is
[02:04:59] just align with the respect the the the
[02:05:01] previous one okay so we have to just R
[02:05:04] this creating index file nested GD
[02:05:07] nested mesh is created done okay as you
[02:05:10] can Ober here in the directory I have
[02:05:13] just the L2 nested withd L2 nested do T
[02:05:20] okay and
[02:05:23] the next step is starting from this
[02:05:27] course uh Grid in order to apply this
[02:05:31] new radio of refinment and obtain this
[02:05:35] uh region in red with 7.5 M resolution
[02:05:40] okay so the only thing that I have to
[02:05:42] change here is I'm going to start from
[02:05:47] L2 okay the data that I have now now
[02:05:52] better better data I have now to
[02:05:54] interpolate
[02:05:56] is um
[02:05:59] P do Puerto
[02:06:01] Rico uncore
[02:06:05] 75. Chief okay these are my better
[02:06:08] resolution data I want to interpolate in
[02:06:12] a grid that is uh nextest with respect
[02:06:17] this one I'm going to name L3 so I have
[02:06:22] l z that is this one this one is level
[02:06:26] zero this one is level one this one is
[02:06:30] level two and I'm going to create now
[02:06:34] the last one also we use Rao of eight
[02:06:39] and if we just run
[02:06:42] this oh no sorry what
[02:06:46] happened maybe some of
[02:06:50] this the end of meters here okay so this
[02:06:55] is correct this is now correct the
[02:06:59] result is L3
[02:07:01] okay warning blah blah blah rer created
[02:07:06] okay and this one this new raser L3 is
[02:07:10] the last level okay so now I have I'm
[02:07:15] going to uh move to the
[02:07:18] cluster to ination but symmetries I'm
[02:07:23] going to just move the label zero. grd
[02:07:28] level one level two and level three okay
[02:07:32] going to upload
[02:07:37] this okay and now I need to I have just
[02:07:43] the the main ingredient the the Symmetry
[02:07:45] data and they are all uh nested with
[02:07:48] respect the others and the second step
[02:07:52] is to create the PAR file okay so the
[02:07:55] PAR file is different uh with respect
[02:07:59] the the propagation one because we need
[02:08:01] to put that we uh are going to consider
[02:08:06] more than one levels okay so for example
[02:08:10] the ti could be caran four
[02:08:15] level
[02:08:18] sorry the path to the Petry I think it's
[02:08:23] correct the initialization type is one
[02:08:27] because we are going to uh run
[02:08:30] okada fault okada parameters we don't
[02:08:33] want to apply Cura filter the number of
[02:08:36] fault is one here we put the okada
[02:08:40] parameters we don't want to uh restrict
[02:08:44] the okada computation window the output
[02:08:48] uh is going to be for the level zero
[02:08:52] lante simulation lantex
[02:08:55] 13or
[02:08:57] l0 these are the varibles I want to to
[02:09:00] store in this case ITA maximum ITA and
[02:09:05] arrival time in this case and this is
[02:09:09] the critical part because we need to put
[02:09:11] here that we are going to use four
[02:09:13] levels
[02:09:17] okay four
[02:09:20] levels the ratio of
[02:09:25] refinement of
[02:09:29] refinement for level zero to pass from Z
[02:09:34] to one that is four remember that in our
[02:09:38] case we are going to pass from this
[02:09:40] resolution to this resolution by using a
[02:09:42] ratio of four okay and then the number
[02:09:47] of submeshes in this case we are going
[02:09:49] to use only one that is the the if you
[02:09:53] remember the the blue
[02:09:55] one so we need to put here
[02:10:01] the the name of our level one nested GD
[02:10:07] corresponding to the the next level the
[02:10:10] level one and followed by the line
[02:10:14] corresponding to the net CDF prefix in
[02:10:17] order to to save the the output and
[02:10:20] align containing the variables to save
[02:10:24] same I'm going to uh store the ITA the
[02:10:28] maximum and the arrival time so after
[02:10:32] putting here the uh bimmetry
[02:10:37] prefix and variables to
[02:10:40] save
[02:10:41] because I have put here only one submesh
[02:10:45] then we need to put the next level
[02:10:49] characteristics that are first The Rao
[02:10:52] of refinement in this case eight R of
[02:10:57] [Music]
[02:11:01] refinement refinement the number
[02:11:05] number of sub meses and also the path to
[02:11:11] the bimmetry and the simulation net CDF
[02:11:15] prefix also the variables in order to
[02:11:19] save and at the end the last level also
[02:11:23] The Rao
[02:11:25] here the number of
[02:11:30] submesh the path to the bimmetry and the
[02:11:34] uh prefix for the net CDF and the
[02:11:37] variables okay and the rest of the
[02:11:39] parameters are more or less what we are
[02:11:42] just comment in the in the propagation
[02:11:44] example bory conditions the simulation
[02:11:48] time in order to to be a bit short with
[02:11:52] the with the simulation is I'm going to
[02:11:54] put just uh one hour saving every minute
[02:11:59] and don't want to read point for for
[02:12:02] time series and the rest of the
[02:12:03] parameters are more or less the same
[02:12:07] here because we have four levels of
[02:12:10] resolution I have to specify the St
[02:12:13] stability coefficient that is something
[02:12:15] technical in order to to control the
[02:12:18] stability for the scheme for every uh
[02:12:23] level so level zero level one level two
[02:12:26] and level three the four level that we
[02:12:28] are going to consider the friction time
[02:12:31] is fixed and the rest are more or less
[02:12:34] the same okay I'm going here to consider
[02:12:37] that the arrival time is if if more than
[02:12:42] five CMS okay so you can just put this
[02:12:46] content as um let me enter in the
[02:12:52] show I'm going to create
[02:12:55] here
[02:12:57] um I don't know lantex
[02:13:01] 13 uh 4 l.
[02:13:05] dxt and here I'm going to copy this
[02:13:10] content that we just commented into this
[02:13:16] insert
[02:13:18] okay so what's
[02:13:21] ingredients we have we need also the
[02:13:25] make deer make deer
[02:13:29] simulations fold the make the O
[02:13:33] folder
[02:13:35] and in this case I need to uh first of
[02:13:42] all um the lot balancing this the the
[02:13:45] the third step so we need to run
[02:13:52] sorry
[02:13:53] software I
[02:13:55] see Z
[02:13:59] being tsunami high C followed by the no
[02:14:03] sorry Bean
[02:14:05] lb B get go balancing followed by the
[02:14:09] per file that is lantex for level.
[02:14:14] txt I'm going to use only one GPU okay
[02:14:18] so if everything works here here you
[02:14:21] have the description of your experiment
[02:14:24] of your problem here you have the
[02:14:27] different levels the simulation time the
[02:14:30] saving time every 60 second and the
[02:14:34] number of volumes and the location the
[02:14:37] extension of your four uh levs level
[02:14:41] zero level one radi of refinement four
[02:14:44] level two R of refinement 8 and level
[02:14:47] three ratio of ref refinement ratio 8
[02:14:50] okay
[02:14:51] and all the computational domain is
[02:14:54] assigned to an unique uh process okay so
[02:14:59] it creates um it creates this uh binary
[02:15:03] script so what more do we need yes the
[02:15:08] the job configuration so I'm going to
[02:15:11] create
[02:15:13] also job only one
[02:15:16] GPU
[02:15:19] Dosh and here I'm going to copy and
[02:15:22] paste more or less the same as the
[02:15:24] example before in propagation because we
[02:15:27] need to specify here I'm going to put I
[02:15:32] don't know kibbe kibbe GPU Puerto Ric
[02:15:38] job notes one one
[02:15:41] GPU we can put
[02:15:43] here 30 minutes we consider that our
[02:15:47] experiment will take a long time
[02:15:51] okay and we move to our directory that
[02:15:56] is which is training inundation MP run
[02:16:00] followed by the execut table of tsunami
[02:16:02] highy and followed by the um par five of
[02:16:08] this experiment okay so I'm going to
[02:16:11] write this and I think we are ready to
[02:16:16] to to run this okay so I'm going to
[02:16:22] bch job P
[02:16:25] GPU and if everything works start with
[02:16:30] the simulation okay so if you move to
[02:16:34] the simulation uh
[02:16:37] directory change directory
[02:16:41] simulations You observe that you obtain
[02:16:44] one net CDF file for each level okay so
[02:16:49] we put here
[02:16:51] we put here in each level net CDF uh
[02:16:56] prefix okay so for each level of
[02:17:01] resolution we will have this variable
[02:17:05] okay this examples takes a bit not so
[02:17:10] long but
[02:17:13] uh it's still running it will take uh 10
[02:17:19] minutes if I remember well something
[02:17:21] like that so I'm going to switch to the
[02:17:23] slides again in order to show you
[02:17:26] another example just uh maybe some of
[02:17:29] you know this example is uh to show you
[02:17:33] that you can uh
[02:17:35] use um this kind of computational domain
[02:17:39] with a for example in this case we use
[02:17:42] one ambient grid here and then four
[02:17:47] level of resolution but each level you
[02:17:51] including uh two sub matches okay so for
[02:17:56] the level zero we have just this ambient
[02:18:00] grid and you can see the map of the
[02:18:04] Eastern uh part of the Mediteranean okay
[02:18:08] and then the level one correspond to
[02:18:12] this extension but also this extension
[02:18:17] okay so we have level one with two sup
[02:18:23] meshes again for the level two that is
[02:18:27] this one but also this sorry but also
[02:18:33] this one mesh okay so the level two has
[02:18:38] also two sub matches and the level three
[02:18:42] correspond here and correspond to this
[02:18:47] uh area of this is katania and this is
[02:18:50] sakusa in the eastern part of Sicily and
[02:18:53] also the level three has two subes okay
[02:18:57] all of this scene can be um written in
[02:19:01] the part file okay so the experiment
[02:19:04] that we will try to simulate is an
[02:19:06] hypothetical tsunami in the Eastern
[02:19:08] Mediterranean Sea this is the
[02:19:10] characteristic the location of the
[02:19:13] earthquake the magnitude the okada
[02:19:16] parameters and we are interesting
[02:19:19] interested in obtaining aining high
[02:19:21] resolution inundation maps with a Target
[02:19:24] area combining different level of
[02:19:26] resolution with the goal of obtain
[02:19:29] inundation maps with 10 m of resolution
[02:19:35] starting from an ambient grid of
[02:19:38] 640 M of resolution we are going to use
[02:19:42] four levels with four as The refinement
[02:19:47] Rao so we are going to pass from six
[02:19:51] 140 to 160 then 240 and then to 10 m of
[02:19:58] resolution okay by using four levers in
[02:20:01] order to pass from
[02:20:03] 64
[02:20:04] 640 to 10 m okay so here I can show you
[02:20:09] the the the PAR file in this case and
[02:20:12] you canot sa here the same thing but
[02:20:15] here for example the name the path to
[02:20:19] the ambient grid
[02:20:21] the same thing we don't we are going to
[02:20:24] apply for a okada standard okada we
[02:20:26] don't want to apply um uh kayura filter
[02:20:30] we are going to use only one fault these
[02:20:33] are the okada parameters for this
[02:20:35] fault we don't want to apply or restrict
[02:20:39] the okada computation in a window this
[02:20:42] is the net CDF uh prefix for the output
[02:20:46] results and if You observe here we don't
[02:20:51] have any variables to to to save we have
[02:20:56] z z0 z z okay so for our zero for our
[02:21:02] level zero we don't want to save
[02:21:04] anything anything for our uh we don't
[02:21:07] want to know about the propagation of
[02:21:11] our level zero so we put all the variabl
[02:21:13] zero then we put the number of levels
[02:21:17] the number of resolution for the first
[02:21:19] level the level one and then here I put
[02:21:22] here two because as if you remember we
[02:21:26] have two sub meses of level one okay so
[02:21:31] we indicate here that we have two uh sub
[02:21:34] meshes so for each for each sub mesh we
[02:21:38] need to provide the Petry path the
[02:21:41] prefix the variables to save here I put
[02:21:44] again 0 0000 0 and this for the first
[02:21:48] submesh this is for the second sub mesh
[02:21:51] and we don't want to store anything with
[02:21:55] respect the level one okay then we put
[02:21:58] the refinement Rao for the level two
[02:22:01] again two submeshes one for katania with
[02:22:05] uh this data one for sakusa for this
[02:22:09] with this data again 0 we don't want to
[02:22:14] say anything about the level two and the
[02:22:18] last the level three with a refinement
[02:22:21] refinement rtio of four number of sub
[02:22:24] meshes again we are going to use one
[02:22:27] mesh for the
[02:22:29] katania region one mesh sub mesh for the
[02:22:33] sakusa region the prefix for the for the
[02:22:37] net CDF file and
[02:22:39] here I'm interested in h store the
[02:22:44] maximum height okay the maximum height
[02:22:47] only for the high resolution GD okay for
[02:22:50] the last level for the level three so I
[02:22:53] wanted to I want to to store the maximum
[02:22:57] height or Katana and also for sakuza but
[02:23:01] only in the last level okay the boundary
[02:23:05] condition I'm going to just simulate 4
[02:23:08] Hour of simulation okay these are four
[02:23:11] hours I'm going to save just the the
[02:23:15] final final State I don't want to save
[02:23:18] every time step here in this case I is
[02:23:23] interesting in in in store the time
[02:23:26] series for this uh data okay every 30
[02:23:30] second okay so I have here um points of
[02:23:35] interest for forecast point or whatever
[02:23:37] I want to uh store every 30 seconds and
[02:23:41] the rest of the of the parameters are
[02:23:44] more or less the same uh stability
[02:23:47] coefficient for each level the maximum
[02:23:49] allow velocity in this case 40 and if
[02:23:53] You observe here I have no lines
[02:23:56] regarding the arrival time because I'm
[02:23:59] not interested in store arrival time so
[02:24:02] I don't need to put anything in the in
[02:24:05] the last uh line regarding the the uh
[02:24:10] the arrival time okay so we just uh
[02:24:16] ready for run this thing and one of the
[02:24:19] thing that I want to show you is that uh
[02:24:22] how to
[02:24:25] postprocessing we can perform the
[02:24:27] processing of the results in case of
[02:24:30] high inundation high resolution
[02:24:32] inundation maps in this case the only
[02:24:34] thing that we have to take into account
[02:24:37] is how to create this um variable that I
[02:24:43] name as inundation depth because we have
[02:24:48] only the maximum height in all the M and
[02:24:51] another variable that is the original
[02:24:53] bathy or the original the original or
[02:24:56] the the formed bathy because we need to
[02:25:00] compute this uh
[02:25:03] um in in Spanish scal in in in English I
[02:25:07] think inundation depth is is okay so the
[02:25:11] flute death uh by using these two lines
[02:25:15] okay so we consider uh um
[02:25:21] where the where the bimmetry
[02:25:24] is positive I mean in in in the water we
[02:25:29] consider a non value and we calculate
[02:25:33] the inundation depth by uh subtracting
[02:25:37] in this case the maximum height uh um
[02:25:43] layer uh in this case plus because the
[02:25:46] original body
[02:25:48] is in this
[02:25:51] uh area is positive and here is negative
[02:25:54] so we can put here a plus but the idea
[02:25:57] is to get the maximum height minus the
[02:26:02] value of the elevation in this in this
[02:26:04] point so that's in in this way we can
[02:26:07] obtain the inundation depth the flute
[02:26:12] only in the um let's say in land okay
[02:26:16] not in water but in land okay so with
[02:26:19] this kind of python script you can just
[02:26:23] plot this kind of um of of graphs and
[02:26:28] well if you are um depending on your
[02:26:32] familiarity with the visualization tools
[02:26:35] python ability and and so on you can
[02:26:37] create most more sophisticated graphs
[02:26:40] for example here I include the the
[02:26:43] weight amplitude in water the inundation
[02:26:47] depth in land and also plots the time
[02:26:50] series for two uh of this uh forecast
[02:26:53] Point okay so let me go back to
[02:26:57] the to our example it's just finished so
[02:27:01] I move to the um the results and we can
[02:27:05] just use ncdu in order to for
[02:27:08] example in this case I I stored the the
[02:27:12] level zero uh variables and
[02:27:17] here I can just plot
[02:27:21] this event let me change the color Mar
[02:27:25] to yet for example okay yes and the
[02:27:30] range
[02:27:32] fromus 3us
[02:27:35] 2us 2
[02:27:39] two two sorry two two
[02:27:46] two our area of interest is more or less
[02:27:50] here this is 1 hour simulation okay but
[02:27:55] by using nested mes this is the ambient
[02:27:58] grid so you can see the behavior of the
[02:28:01] of the tsunami in our level zero
[02:28:04] computational domain as you can just
[02:28:07] visualize the level one this closer to
[02:28:11] our uh region of
[02:28:14] interest that is here
[02:28:17] so you can see approximation of the
[02:28:21] first wave how to reach this area of
[02:28:25] interest that is next level
[02:28:30] okay then I can show you also the levels
[02:28:38] two
[02:28:42] here you
[02:28:45] can this bigger with this button here
[02:28:53] and for example this
[02:29:01] yet
[02:29:02] appear here in a
[02:29:10] while here it
[02:29:12] is okay yes I I only simulate 1 hour
[02:29:16] because of the the time but at the end
[02:29:20] you can
[02:29:22] also visualize the level three that is
[02:29:25] the high resolution at
[02:29:29] 7.5
[02:29:31] M that is here and put bit here
[02:29:37] and uh visualize how the wave arrived to
[02:29:44] the cast and you can observe also more
[02:29:47] or less the ination and if if you want
[02:29:50] to plot the maximum height here You
[02:29:54] observe here the maximum height in this
[02:29:58] level three computational domain
[02:30:00] corresponding to
[02:30:02] 7.5 M resolution okay so if you want to
[02:30:08] uh plot a graph like the the previous in
[02:30:12] in katania you just uh don't load your
[02:30:15] data or you can uh so work directly in
[02:30:19] the in the clust but here I download the
[02:30:23] level three do net CDF then I calculate
[02:30:28] the inundation dep variables I apply the
[02:30:30] same script that I have shown
[02:30:33] before and if it
[02:30:36] works yes here you can see the
[02:30:40] inundation depth only uh plot in the
[02:30:44] land in land okay not in water here the
[02:30:47] inundation dep considering uh from from
[02:30:51] dry to to wet okay so it is the the
[02:30:53] flute map for this uh for the region we
[02:30:57] are interested in okay so uh I don't
[02:31:02] know if are any question on on the shat
[02:31:06] or not but let
[02:31:09] [Music]
[02:31:10] me say that that's all from my side for
[02:31:14] now I hope I didn't go too too fast with
[02:31:16] the with the explanation not to slow and
[02:31:20] well all all as I said before all this
[02:31:23] material the presentation the slides and
[02:31:25] and the files and also the scripts that
[02:31:29] uh I have been shown will be included in
[02:31:32] the in the in the material so you can
[02:31:35] practice and launch your your tsunami
[02:31:37] simulation using tsunami highy that's
[02:31:40] that was the the goal and I hope you
[02:31:42] have uh um let's say found it useful so
[02:31:47] thank you thank you all if you have any
[02:31:50] question please contact we were we were
[02:31:53] discussing with stepen about the the
[02:31:55] ratio of of refinement in the
[02:31:59] chat she was saying if eight was too too
[02:32:02] large or if 16 already too risky uh I
[02:32:07] mean we the value is four uh if you need
[02:32:12] to to increase your number of levels
[02:32:15] it's better to consider five or six
[02:32:17] level of resolution but using uh for as
[02:32:21] the refining rate in order not to to
[02:32:24] lose very the data resolution I think
[02:32:28] it's a there there are several things as
[02:32:32] I was trying to answer in the in the
[02:32:34] chat that is one one thing is where do
[02:32:37] do you have this the data which are the
[02:32:39] data at what resolution that you have so
[02:32:42] that in some sense uh make your Ned G to
[02:32:46] be one or another uh and the the other
[02:32:49] thing at the end the total size of the
[02:32:51] problem because doing this kind of of
[02:32:54] experiment you might end it with the
[02:32:57] huge problems that if you save all the
[02:33:00] files is they huge size file so you must
[02:33:04] take all that into account and probably
[02:33:08] it's it's a good practice to to move
[02:33:10] from from one level to another in in
[02:33:14] steps and probably is is the best but
[02:33:17] it's something that we we didn't do a a
[02:33:19] you know a formal study on the the
[02:33:24] eventual you know sensibility to to
[02:33:28] that well I don't know if there is more
[02:33:30] question in the in the chat uh after
[02:33:35] that let
[02:33:40] me there's a question please where we
[02:33:43] can download the 3D file where you have
[02:33:46] the inundation in the present slide
[02:33:49] which one do you
[02:33:52] mean the the one in the right side is
[02:33:55] just correspond to the I think a video
[02:34:00] uh promotional of the CH project yeah we
[02:34:02] did we have a yeah and the last one is
[02:34:06] why do you use the original vetry and
[02:34:08] not the format well the idea is you can
[02:34:11] use um the idea is better use the The
[02:34:15] Form B because it's the reality is that
[02:34:19] if you apply for a big event using okada
[02:34:22] parameters the the most probably thing
[02:34:25] that that you change your floor uh vetry
[02:34:29] vetry so in the in the last script you
[02:34:32] of course
[02:34:35] you move back here here you can use here
[02:34:41] the the format Buffy in order to
[02:34:43] calculate the inundation dep okay so but
[02:34:46] if you have a very
[02:34:49] I don't know how to say very near uh
[02:34:53] fault near to the coast maybe if you use
[02:34:56] the deform B you cannot catch the
[02:35:00] the cost line very well in order to
[02:35:04] reproduce or in order to plot the
[02:35:06] satellit
[02:35:08] image and maybe you will obtain a gap
[02:35:11] between the your original sorry your
[02:35:16] coost line uh produced after the okada
[02:35:20] fault and the cost
[02:35:23] line that you can see by using the
[02:35:26] satellit image but it's just um small
[02:35:31] different but you have to take it into
[02:35:34] account if your fault is very very near
[02:35:36] to the to the coost
[02:35:39] okay that's right when you are in the
[02:35:42] middle of the ocean that make no differ
[02:35:43] but if you are close to the coast then
[02:35:45] it's important to use the the the de
[02:35:48] form bath symmetry
[02:35:50] in order to take into account this
[02:35:52] uplifting or down lft of the of the Cod
[02:35:55] that may increase or or enhance or not
[02:35:58] the the inundation okay
[02:36:01] yeah um I would like to thank Carlos for
[02:36:04] the effort of preparing this this kind
[02:36:06] of presentation of course that is always
[02:36:08] difficult and and hard to do thank you
[02:36:11] very much and uh in the meanwhile if you
[02:36:15] have some question we can answer the the
[02:36:18] the material will be a aailable but not
[02:36:20] today tomorrow or the day after tomorrow
[02:36:24] and um and tomorrow we will be talking
[02:36:28] about met tsunamis as I said the first
[02:36:31] part will be by clear and the second
[02:36:34] part most on the result and numerical
[02:36:36] simulation will be given by by Alex so
[02:36:40] we see you tomorrow we see CLA and Alex
[02:36:43] tomorrow too and I hope you you can take
[02:36:47] advantage of this of this uh training
[02:36:49] course of cheese bred thank you thank
[02:36:51] you all