Hello there, my name is Dr. Lee Orff. I am an atmospheric scientist at the University of Wisconsin-Madison and I study tornadoes and thunderstorms as my research and I am going to provide to you today a lecture on some example usage of the CM1 computer model in my own work on supercomputers. I understand that the class that I'm lecturing to is a freshman class, programming class focusing on Python primarily. Good choice of language, by the way. And I'm here more to show you sort of the world that is possible with a sophisticated cloud model.
So I have a lot of material to cover today. I'm going to try to get through it, and this lecture will be available to you after this class. You can watch it as many times as you like, slow it down, and go through it again if you so desire.
So in this 45-minute pre-recorded lecture, I'm going to cover a few things. First, I'm going to talk about, or I'm going to show you a video I created that sort of goes into the background of cloud modeling over the past 30 years or so to give you some context for what I actually do. Because what I actually do is spend my time on supercomputers trying to simulate thunderstorms that produce tornadoes and downbursts or that don't produce tornadoes and downbursts in order to understand the nature and the predictability of supercells. Can we predict whether...
tornado forms or not with any skill. And this is something that we're not really able to do very well. When I say we, I mean the meteorological community, the National Weather Service, all the folks who are trying to understand and do a better job at predicting severe weather.
So after my background, I will, background video that I produced for the Computing Museum of America. I will talk specifically about CM1. So CM1 is a model used, or it's a model developed by a scientist at the National Center for Atmospheric Research, George Bryan. And he is a world-class researcher on thunderstorms. And he has made his model available to the rest of the scientific community.
That means people like me or you even can use it. And one nice thing about models like CM1, you can do some example things on your laptop even, if you want to at least test how things work. In this lecture, I'm not going to ask you to do that.
There's just too much material to cover, too much background material. So this is more designed to give you a whirlwind tour of what a model can do if you know what you're doing and you have a big supercomputer to play with. So I'm going to show you a lot of visualized output.
If you're familiar with my work, I have a YouTube channel. You can look at some of the animations that I have produced in the past. I'm going to show you plenty of those today. Again, I want to get you familiar with how the models kind of work, or at least a model like CM1 works, but realizing that there's only so much I can do in 45 minutes.
So you're not going to be compiling code, you're just going to be watching it happen, in other words. But that's okay. If you're interested and excited about this work, you can rewatch the lecture or even send me an email. I don't mind at all.
So I will show you a lot of stuff that CM1 can do and sort of how it's done. I'll show you my work in action, and then I'll just sort of wrap up with why... Why do we do this anyway? I mean, I could sort of introduce that.
The idea being, of course, we're trying to predict severe weather better because that's good for society. But, you know, it's an approach that not everybody who's in meteorology really likes or even cares to do. So numerical modeling, which is what I do, is a specific area of science in general.
You've got physicists, you've got all sorts of people, astronomers, geologists simulating phenomena, whether they're... on earth or in space. There's a lot of mathematics and physics that go into these models.
The models themselves are supposed to represent the physical world the best that we humans can program to do. So that's how it goes. I'll give you five minutes of questions at the end of this. This again is pre-recorded so I can get it right the first time.
And I will now start with talking a little bit about myself. Might as well know about me. So I've been simulating storms since the 1990s, and I'm focusing primarily on downbursts and tornadoes. So I'm interested in the severe phenomena because it causes damage and death all across the world.
In 2014, I conducted what would be called a breakthrough simulation. Breakthrough has a specific term, I guess you could say, to the funding agencies. It's something that was kind of novel and new.
I simulated a tornado in a thunderstorm that... was at very high fidelity and it sort of started my second career as a thunderstorm modeler. That's all I really do now.
I used to be a college professor teaching classes like this and other classes. I was at UNC Asheville and Central Michigan University for 12 years and in 2015 came here back to UW-Madison where I was, where I got my degrees as well, my undergrad and graduate degrees. So I'm back here doing... what I would consider pretty exciting science.
And it's been a lot of fun and other things as well. So since this time, I've dedicated my career and my research towards simulating damaging thunderstorms with the best possible fidelity. And that means using some of the most powerful supercomputers available to scientists like me in order to get this work done. So that's a little bit about myself. What I would like to do next is share with you a little video I produced.
It's about seven minutes long. that goes into the history of high resolution cloud modeling. So this won't talk about CM1 specifically, although you will see some CM1 simulation data in this, but this is sort of to give you a little bit of background on sort of how these supercomputers are used in atmospheric science.
I'll come back to you after this clip. Hello, my name is Lee Orff and I'm an atmospheric scientist at the University of Wisconsin. In my research, I use powerful supercomputers to simulate the world's most violent thunderstorms. The United States is home to some of the most severe weather found on planet Earth. Powerful thunderstorms, known as supercells, tear across central and southeastern United States each spring, producing heavy rain, large hail, and powerful tornadoes.
Since the dawn of the digital computing age in the mid-20th century, atmospheric scientists have utilized computers to simulate the weather. ENIAC, the first electronic general-purpose programmable computer, made its first rudimentary weather forecast in 1950. In the 1960s, Control Data Corporation became the first manufacturer of what would become known as supercomputers. Supercomputers performed significantly more calculations faster than regular computers, and the CDC 6600 and 7600, while considered primitive by today's standards, served as workhorses for many scientific studies in the 1960s and 70s.
Some of the earliest simulations of supercell thunderstorms were conducted on the CDC 6600. The CDC 7600, considered the world's fastest computer in the early 1970s, enabled, for the first time, fully three-dimensional representations of simulated supercell thunderstorms. In 1972, Seymour Cray left control data to form Cray Corporation. Computers such as the Cray XMP contained enough processing power and memory to simulate thunderstorms at unprecedented resolution revealing more detailed structure in both space and time. In 1989, scientists at the University of Illinois conducted a breakthrough supercell simulation on the Cray XMP.
The simulation, covering over two hours of the storm's life, was brought to life in a five-minute long video that took four scientific animators almost one year to create using the latest silicon graphics hardware. Throughout the 1980s, supercomputers evolved towards massively parallel distributed memory architectures made up of separate computers connected by a fast network. This approach was also used to create relatively inexpensive computer clusters made up of consumer hardware that researchers could build themselves for their labs.
A single computer may contain multiple processors that all share the same memory. A parallel distributed architecture takes multiple computers, or nodes, and connects them together with a high-speed network. This network facilitates exchange of data between nodes during model execution and also the saving of data to disk. One early example of massively parallel distributed memory computing was the Wisconsin Model Engine, developed at the University of Wisconsin.
This computer was comprised of dozens of identical boards, each containing microprocessors called Transputers, each of which performed calculations throughout its own volume of the simulation's domain. Research conducted on the Wisconsin model engine included simulations of thunderstorms and intense thunderstorm downdrafts known as downbursts. Downbursts present a significant hazard to aircraft in the takeoff or landing phases of flight, while also causing destructive straight-line winds.
Throughout the 1990s and end of the 21st century, supercomputers have continued to increase in capacity, containing more memory, more processors, and larger amounts of disk space. These advances have allowed scientists to increase the sophistication of their models and to execute their models at higher resolution. Increasing resolution means breaking the world into smaller and smaller component volumes, allowing features such as a fully resolved tornado to occur within the model. In the early 2020s, a typical supercomputer configuration still involves racks of compute nodes connected through a high-speed network. However, the sophistication of individual nodes has increased, with dozens to hundreds of compute cores on each node, and graphical processing units, or GPUs, making up a large percentage of available computational power.
Networking speed has also increased dramatically. The Blue Waters supercomputer, which came online in 2012, required a special facility to house it. The National Petascale Compute Facility on the University of Illinois campus was designed specifically with efficient cooling of the Blue Water system in mind.
The power requirements of modern supercomputers are substantial, and this has necessitated the creation of new hardware architectures that require less power to operate, while still resulting in faster and faster machines. Some of the many examples of recent research done on supercomputers includes astrophysical simulations of stars, the life cycles of galaxies, simulations of earthquakes that are able to include important high frequency wave motion that better models the shaking effects on structures, and the formation and life cycles of the most violent tornadoes in supercell thunderstorms. Modern supercomputers enable researchers to simulate storms at high enough resolution such that realistic multiple vortex tornadoes can form within the parent supercell. By analyzing the large volumes of model output, scientists can identify the processes that result in such violent tornadoes in the model and use this information to guide field studies.
The power of modern supercomputing technology is evident when model data is brought to life with advanced visualization techniques. Time-lapse video of simulated supercells can be compared to video of observed storms as a way to test the realism of the model. Side-by-side comparisons of the cloud field show strong similarities between simulated and observed clouds, such as towering cumulus in the heart of the storm, pouch-like mematous clouds that form beneath the storm's anvil, In clouds near the ground, such as the tail cloud, which is associated with strong inflow into the storm's updraft, horizontally rotating air that forms near the ground and is drawn into the supercell's updraft has been found in model simulations to help strengthen the storm and to help support strong long-lived tornadoes. Field studies motivated by these high-resolution supercell simulations run on supercomputers have recently found similar features in the field.
A strong testament to the usefulness of supercomputer simulations to increase our understanding of the physical world. As supercomputers continue to increase in power, geophysical models exploiting this power will create increasingly realistic simulations resulting in new discoveries. Okay, so that was some background on a little bit of history of the cloud modeling. in atmospheric science, notice how it's very closely linked to the available hardware, the computer itself. And numerical modeling and computer hardware go step in step because without the supercomputers the models can only do so much.
There's only so much computing capability and memory and such available. And your laptop or your cell phone is actually sort of a supercomputer from about 25 years ago and it's amazing how much work we got done with those back then. but in 2023 we can do a lot more. So what I'm showing you here is my desktop. I have a desktop recording software and you're going to be seeing to some extent just how I work.
So on the left here I've got a document that is going to be a bit much for this class but it is a document that describes the model the CM1 model written by George Bryan himself and for the intents and purposes of this lecture. I'm only going to breezily go through this, but I want you to understand, at least conceptually, that all models are based in physics and mathematics. So I'm just going to scroll really quickly through this document.
You can google CM1, NCAR, or whatever and you'll find this. It's pretty easy to find. I just want to focus on a set of equations here. Yes, this is not a class that has calculus as a prerequisite, but I wanted to at least talk about some things. For instance, numerical models All numerical models are forecasting slices of time and space into the future.
So the models will go forward in a small slice of time, calculate the state of the atmosphere, and then go to the next time and loop over time until you're done and saving data along the way. But I just wanted to show you just a simple... well it's not that simple if you've never had calculus but on on this what you see here...
whoops um You see equations for u, v, and w. Those are the three components of the wind, east, west, north, south, and up, down. And when you see this funny-looking d, u, d, t, d, v, d, t, d, w, d, t, these are called partial differentials.
They indicate the change in something over something else. So we're looking at how u, v, w change over time. And essentially, it's a plus b equals c plus d plus c plus f. I mean, if you look at this equation, sort of just look at it, you solve for u, v, and w.
That's what the model does. and you update every time step, and then you put it into motion, and you make movies and videos or whatever, do analysis. Again, I don't want to go through this too much. This lecture is not meant to require calculus, but I do want you to at least have an appreciation for the fact that these models are based in physics.
They're not CG like you see in Hollywood. They're all based on actual physical equations that have been handed down by scientists over the years, going back to Newton, all the way back. and applying those equations to the modern supercomputers.
Now, when you actually use the model, here's where things get more confusing. Maybe if you thought that wasn't confusing enough. So what you're seeing here is, again, my desktop, but it's through what's called a VNC. So you're seeing me sitting in front of a supercomputer.
This is the supercomputer that I'm running on. And I have a window open here. These are text editors.
So when you get into things like... Python and programming, at some point you may need to open up an editor and start writing code. You might be using Jupyter Hubs and such to do it interactively, but on a supercomputer, you're probably just going to be editing files.
And I just wanted to show you, this is the CM1 model. This is the code. What you're seeing here on the bottom is what's called a terminal. These are files listed, the files that end in.f. Those files are Fortran.
Okay, that's a language that's been used for an awfully long time that is the primary, probably the primary code that runs on supercomputers. So this is Fortran code that you're looking at. This is the CM1 model.
You can see it right up here in the comments. Again, I can't expect you to understand this or even really understand what's going on too much, but I want you to at least see it. This is how someone like me doing science on a supercomputer interacts with the computer.
It's through code. It's through text. It's through terminals.
It's very... Not user-friendly. But if you're really into this sort of thing, it's worth it.
And programming can be a lot of fun. So you see all these declarations. You see all this source code. This is what's called source code. This is the textual code that is sort of written to be human understandable.
I mean, humans have to write this. And computers have to turn it into something useful. The CM1 model, like a lot of atmospheric models, is full and just full of these three-dimensional loops. So... Think of space, right?
You've got east, west, north, south, and up, down, three dimensions of space. So in the models, you have three loops, right? Going over those three spaces. So you've got J, K, and I, I, J, and K, east, west, north, south, up, down. So you're looping through space all the time in these models, updating arrays, and then going to the next time.
So it's very, very, very, very organized. A lot of effort goes into making this code fast, meaning it has to run in parallel, meaning lots of calculations are being done across the machine. Remember, supercomputers are made up of thousands and thousands of nodes.
You saw that in the video where you see some of these supercomputers. They're just these big rooms full of machines. So this code gets converted, it gets spread across that full machine and executed.
And it's a challenge, it really is. But at the heart of it, you've got stuff like this on the screen. A lot of triply nested loops where you're going over space and... and updating variables to get to the next time step. So actually running the model, that's something that probably is a bit beyond the scope of this lecture, but you will end up, let's see if I can hop around here and show you.
So this is how a scientist might do his work or her work on the computer, just kinda looking around. And I know I, I probably could have done this better ahead of time, but you'll see what's called, I'll show you how you actually get a piece of code to run. You have to tell the computer, so here I am opening a file with an editor, and these, again, it's another script with text. Again, I don't expect you to understand this, but at least you'll be exposed to it.
This is how supercomputers work, another text file with instructions, okay? And you submit this. In this case, I have a job that spans 128 nodes. 1,024 actual processors because each node has 50, what is it, 56 processors per node on the Frontera supercomputer. So again, supercomputers are just computers with a whole lot of computers, right?
They're computers that work together in parallel. These are just instructions on how long to run the model and such. And this is the actual command. So when you run the CM1 model on a supercomputer, it's being run like this, something like this.
You submit a script and it goes. Okay, so I'm going to build the model. So the model is made up of these files. These files are Fortran.
They all contain instructions. It has to be written just so. And then it's time to actually create it.
And in this case, I'm going to... use what's called the make command. You don't have to know how this works, again, but I want you to see it in action.
So I am now taking the source code. There's a series of instructions in a file that now compiles it into binary form and then creates something that we can actually run. Compilers are a very important aspect of science, period, because they convert the source code into the binary file that the computer actually knows what to do with.
A good compiler should produce code that runs fast and obviously stable. It's stable. It doesn't just stop running for some reason.
And it's not always easy. People like me spend time worrying about things like compilers because it can change the speed of your model by, say, 10%. That could be another scientific paper that could be written, perhaps, because we have limited resources on supercomputers.
So I'm actually showing you in real time how long it takes to build this code. It can be a bit... there's a lot of waiting games in computing and here I am looking at my own self doing this. This is a command that kind of tells you who's doing what on the supercomputer. I'll just look at myself.
So I'm now compiling in parallel. You notice how stuff is moving through the screen much faster. How exciting is this, right? Again, this is how actual scientists do actual research on actual supercomputers. It's not very sexy.
It's just not. But we'll get to the good part soon. In other words, what is the end result of all this effort? And again, in a freshman programming class, I can only cover so much material so fast, and I realize this is mostly just a whirlwind tour.
Okay, I did cut that short, the model compiled, and we have a file that the supercomputer can now run. So let's pretend that we ran the code. And this is from a simulation I've already done.
Simulations tend to take anywhere from a few hours to a few days on a supercomputer, depending upon how much of the computer you're using and how big your job is. So here is the output of the model. So the output of the model, there's two kinds of output that a model like CM1 will give you.
One is textual output. Notice a lot of text, just formatted text, just unformatted text that's in a file. ASCII files, they're called, are like the bread and butter of a lot of science.
So it's not like a Word file with all bold and lots of formatting, it's just unformatted text. So this is a file that's output. I'm only going to go through it quickly, but this is a file, these types of files I use a whole lot to monitor the model while it's running to make sure things are good and also to conduct statistics after the fact. So the output of the model, you notice it announces itself. This is code that I actually modified myself, so I've got some of my own language here.
noticing that this has been patched by code that I wrote, so that if someone else is using the source code, they know that. I have made modifications to the CM1 model only to its output, how it writes data to disk. I haven't actually changed the physics of the model.
So the output is very, very verbose. I have some code here that tells you how it's being mapped to the computer, how many nodes we're using in different dimensions. And when you see everything is cool, That's George Bryan. I always like to see that little phrase there. Everything is cool.
That's a good thing to know. And again, I'm just going to whip through here. Now, as the model runs, and this is really the output I'm going to be paying attention to as the model runs, it outputs statistics and also information about how often it's writing data to disk. This is my code, the history file output cycle and all that stuff. What makes my work significant specifically is the way that I deal with data and how I make the data compressed and I save it more frequently.
It allows me to do things that other scientists often can't do, but it also relies on having a supercomputer to have access to, which is not easy to get. So you'll notice it's very redundant data. All these, what time is it?
The time is in seconds. So for instance, here's one of the statistical outputs. The maximum updraft is 71 meters per second.
That's just a statistic in the domain. The updraft is the rising air in the thunderstorm that is sort of... That is the thunderstorm. I mean thunderstorms are fueled by warm moist air in environments that allow it to grow and create all sorts of precipitation, thermodynamic processes, demolishing rain and hail, and then that updraft can do all sorts of things and sometimes tornadoes form.
This is definitely not a lecture on how tornadoes form, but you will see them forming at least visually. So this is all nice and good. Sometimes you can do things like if you want to just look at... Just the updraft, you can search through the file.
There's these Unix commands that are nice. In this case, WMAX is the maximum updraft. I can see how the maximum updraft varies with time by scrolling back and down. I can say, wow, this is a pretty strong storm. You know, we've got even 100 meter per second updraft.
So meters per second, you know, you're not probably familiar using that. But, you know, we're talking about a couple hundred miles an hour, maybe even more than that. The winds and thunderstorms can be very strong.
Should be relatively obvious. Okay, so... That's the output of the model, the textual output, but when it comes to the actual, and this is, I'm not gonna spend much time here, but you really should at least have a feel for this. And this is the code that I wrote, but I'll show you the actual files, if I can type. And they're all in these directories.
These are, what are directories, are folders. And then here's the files. as they scroll by, isn't that exciting?
I will talk about what these numbers mean. Essentially, these are big files, as it might not surprise you. It's because we're talking about, you know, supercomputer simulations.
This is actually not a very big simulation for me. I can do much bigger simulations on the supercomputer, but this is, you know, you'll just have more files, and you'll have higher resolution. But yes, this looks kind of inscrutable maybe, but... But these data here, this is the size of the file.
These files vary in size because I'm compressing data and data compresses variously across the domain depending upon what's going on. Again, this is a bit high level, but what it means is you really need to be careful of how much disk space you use on a supercomputer or you will run out and they will kick you off basically. So you have to be wary with how you handle data.
And I've made it my... job to be very careful about how I handle data. So these are the files, yay, aren't they exciting? I can do things like take a look at them, and this is again some high level stuff.
Scroll by, there's information in these files that I can just take a look at for any given file. Talks about what's in there, what dimension, and the different variables. But this still isn't too useful, is it? These are a bunch of files on a supercomputer.
Well, I have also written code that turns these many split up files into a single file. And then you can do things with these single files that are, for instance, I can share them with my collaborators. I produce data that is as easy as possible for my collaborators to read and analyze. That's another big important part about doing collaborative research. Very few scientists just work on their own.
I'm Not an exception to that. I do a lot of work on my own, but I work with other people. And it's important that I can share my data so my collaborators can actually look at my data and visualize it like I am.
So that's a big part of supercomputing is just handling data. So what I'm going to do next is I'm going to shift from the logistical aspects of running CM1 and some of its output and show you what it can do. Because that's really kind of will give you. The, uh, a feel for why we go through all this, right? Because we're trying to understand physics or trying to understand thunderstorms or trying to understand how stuff works.
And that's what all this is, is designed. Computers are just what they are. Um, we have to use them. They're not always easy to use, but, um, if you take the effort to use them wisely, you can, you can get some pretty good results. CM1 a little bit, a little bit of how it actually works on the supercomputer.
Very textual based, lots of commands and arcane language and such. Now let's actually look at some output. So here's how this works. There are tools in meteorology that can view meteorological data or say volumetric data, three-dimensional data. And some of them are designed for the kind of work that I do.
So one of these tools is called Vapor. And I just opened up the tool here. You're looking at my desktop on my Linux machine.
So let's open a file. We can import a file that is called, is what we're looking at, looking for here, a netcdf file. I've got some data sitting here, a whole bunch of data, but I'm only gonna look at one timestamp right now, just to show you how this works.
I'll put it in motion in a different application shortly. But look at this, nice box here. You can rotate the cube, it's nice and smooth.
Notice how It's very smooth, I'm sitting on my desktop and I'm recording all the different frames here. Now let's look at something, so pick something new. I'm gonna start out with just two-dimensional data, so these are slices through the data. There's certain things that meteorologists look at.
Gonna look at what's called reflectivity, which is what you would see on weather radar. Just turn it on, boom. This is what it would show by default, and it doesn't look too exciting.
You see reds and blues indicating lows and highs, it's a standard color map here. The range over the data, we can change that range and notice how it changes the image. This is what data visualization is all about. Picking your thresholds and trying to, you know, highlight the features that you think are important.
Now, you can do things in visualization that can mislead people if you're not careful or if you're nefarious, shall we say. My goal is always to, you know, be very transparent about how I'm displaying the data, but say, hey, this is, this is. the features we're looking at here is how we how we found those features so you see something like a hook echo here that is uh associated with this thing here that might be a tornado we'll have to take a look let's take a look at another uh way of looking at the data we'll look at three dimensional data i really like volume rendering which is how i do most of my uh the method i use for most of my imagery so i'm going to look at what's called the updraft in the thunderstorm um the updraft is indicative of how strong the storm is, and if I can find what I'm looking for. So looking for positive values of W, the vertical component of the wind.
We can look at negative values as well, but it's sometimes useful to not follow the zero crossing threshold line when you look at stuff. So I'll just pop this up real quick. And oh, look at that.
Wow, a lot more detail now. This is what's called the mesocyclone of a supercell, this big updrafty thing. It is rotating, you can't tell from looking at it. You can sort of imply there's rotation by the circular patterns that you see near the ground especially, but this is giving you an idea of the three-dimensional updraft in this supercell, and that's one of the most important components of a supercell.
But I can do all sorts of things with the data. I can look into it, I can peer into it, I can focus on high values, I can focus on low values, I can look at where the tornado is. Oh, maybe that's the tornado. You'll notice that there's a bit of a degradation in the visualization when I change things.
That's so it will be responsive. That's something the programmers do. Otherwise, it can be really slow. And you'll see it when the next tool I use is actually as much slower for different reasons.
But it matters, you know. I really like to look at things that are sharply contrasted. So I like to change the lighting so it looks like this.
Just my preference. Maybe it has to do with being red-green colorblind. I don't know. But... Okay, so we've taken a little look here at the updraft.
I think it's a good representation of what we consider the mesocyclone. And notice the values differ quite a bit, and we're slicing through it here. Don't be fooled.
This is just a piece of the whole simulation. When I do these simulations, you saw those files. There's tons and tons of files.
They're spread all over the place. They take up a lot of space. Here, all I'm doing is taking a small piece of that full domain with my tools. So you're seeing just a piece of it.
So we can slice right through it. And that's actually kind of interesting to be able to do that. So let's see if we can find the tornado.
We're going to use what's called an isosurface, which is like a contour. Think of Python contour plots, like a three-dimensional contour. So let's take a look at the pressure perturbation, because that's where you're going to find your tornado. So, okay, we're looking for negative values of pressure now, okay?
So we have to change how we do things. So I've chosen pressure perturbation as my variable. Oh, no, I haven't.
I thought I did. Okay, now I have. The appearance, oh, I keep on choosing the wrong thing. I want to change the actual value. So the software can be confusing.
That's another issue with the software. What are you actually doing here? I actually want to keep this range, but I do want to change the isosurface value. So now I'm changing the value of the isosurface to a pressure value that is a bit higher.
Now, what's going on here? Now, why does this thing suddenly change? It's more, you know, why do we have this little lobe hanging out this tornado?
That was the question I asked myself when I first looked at this data back in 2014. What's that little lobe thing? It turns out to be potentially pretty important. This low pressure helps to, well, my colleagues in the atmospheric science world might not be convinced yet, but this region of low pressure helps to make the updraft stronger, which helps to maintain the tornado. Or perhaps it can help form it, but maybe not. These are the things that, these are the kind of questions we're trying to answer, really.
So you're actually seeing a simulation. This is like, you know... world-class simulation data on a world-class supercomputer with interesting results. So, visualization like this, this is how I discover these things, by playing with contours and playing with isosurface and saying what's going on there. Okay, we're on the home stretch now.
I want to share with you another visualization tool, show me using it interactively a little bit, and then I'm going to show you some animations showing what happens when you put it all in motion, sort of like we saw in some of the earlier, in the earlier Computer Museum of America video. So I am, again, on my desktop here. What's different about this setup is the actual machine that this is running on is in my office. I'm currently working in my basement at home, so there's a bit of network latency, but I want you to see that it's manageable.
You know, I'm able to redraw the screen pretty quickly. Now, I hope that you're looking at this image going, wow, look at the quality of that. This tool called ParaView has the ability to do very nice volume rendering using sophisticated GPU hardware.
What am I looking at here? What am I showing you? This is the top of a thunderstorm now. This is a 75 meter resolution, so not as resolved, but I'm looking at way more storm. And this is the top of the cloud.
This is the anvil of the cloud. Yes, it's clipped in the box here. You're not seeing the full simulation. There's just too much data and you don't often need to visualize your full data, just part of it. But what's this funny little sneaky feature up here?
This is what I'm trying to focus on here. This is called an above anvil cirrus plume. It's a feature that's often, well, it's sometimes observed on satellite data and it is linked to the strength of the storm. So it's something we want to understand.
These little doodads here are representations of a light source. I do a lot of work with lighting to get the lighting just right. For instance, I have the angle very low here, so I can capture these contours. If I were to use a more standard technique, I could make it look more like this.
Yeah, you know, there's just different ways to do it. Let's just put it that way. There's a whole lot you can do with light, and I have been trying to exploit that by playing with the different angles and such. So I just wanted to show you this and show you this in action. Again, in the modern world with the fast network connection, run, you can do stuff from almost anywhere, even in a coffee shop if you have a good enough internet connection.
And that is really kind of cool, to be quite honest. So I do a lot of stuff like this. I spent an awful lot of time just getting this scene to look the way I wanted it to. You're seeing different concentrations of cloud and shading the cloud based upon things like, you know, how much cloud there is.
And And getting the angles so that you cast shadows. I want to see the evidence of this feature in the surface itself. So there's a lot of artistic stuff that goes into visualization. I will freely admit that.
I really like doing this. You could argue that it's not super scientific sometimes, but I really, really enjoy this part an awful lot. It's kind of what drives me. Making these pictures and showing these contours and then being able to compare things to actual...
planes flying at that height is really exciting. And I do believe there's an awful lot of scientific value out of good visualization because it literally shows you things. It shows you things.
You don't have to write about it or explain it what you do, but it shows you, right? That's what the power of visualization is for me anyway. So how about we take a look at this sucker in motion? I did want to say one thing about the blue surface on the bottom. So you can render multiple fields for sure.
I could just turn that off for a second. And this is like the two-dimensional field we showed in the vapor movie. Notice how things are faster now?
That's because there's less data moving around over the network, so it's actually pretty smooth. You start to notice these things when you start playing with big data. But this is what's called the thunderstorm's cold pool.
So this is where the cool air that is formed when the rain evaporates and the hail melts and things like that. It creates a cold pool, and anyone who's lived through a thunderstorm has experienced the cold pool when it passes. And the...
the temperature drops and it gets cooler and maybe a little drier after the storm passes. So notice how the lighting really affects the interpretation of what's going on and the angle of the light really does matter. And I have tried very hard, again I'll show you those lights where they are, trying to show exactly what I'm doing here, this shallow angle. And this one sort of provides more just diffuse light, but I really like being able to do this.
Okay, so I want to now put this in motion, so I'm going to get this out of the way. I've made videos, so let's make a video, or let's show a video of this. And this stuff is pretty cool, so this is what I really live for, folks.
So this is an animation of the top of that cloud we just looked at, starting from the beginning of the simulation. Now this is just the cloud forming. So when we do simulations with CM1, we have to trigger the cloud. You have to actually have the cloud form. You can do that by putting a bubble of warm air or by simply forcing the air upwards.
In this case, we're putting a bubble of warm air and it rises and holy moly, look what happens. Isn't it interesting how quickly it turns into a very turbulent structure? Turbulence is when you see lots and lots of high frequency stuff going on, you know, roiling air, spinning around. That's important that we capture turbulence correctly.
And what the turbulence is, is definitely hard to... Not everyone agrees what... where the threshold is for turbulence.
But when you see this very complex flow, you can assume that turbulence is being resolved. And that's an important thing to do if you can. Now what's going on here? There's two, I'll pause it. So there's two cells here.
There's this bottom cell and this top cell. So the storms have split. This is what's called the right moving supercell.
This is what's called the left moving supercell. This is jargon in meteorology. They move to the left or right of the mean wind vector is what it means.
But I'm really interested in these fuzzy buggers up here. This is this above anvil cirrus plume. That's what has me interested, and that's why I've been focusing my visualization techniques. It's really important, again, to be clear about what you're trying to show, what you're maybe masking to see it.
In other words, there are opacity curves and things that I'm not showing you here that really show you what the data is trying to represent. But, I mean, this looks like a satellite image. I can show you satellite images of above-anvil cirrus plumes, and they look a lot like this.
So I know that I'm getting it right. The different colors above the what's called the overshooting top, that's just showing that the concentration of cloud material is very high when it blasts into the stratosphere. And up here, it's a little bit lower. It's whiter. It's more diffuse.
That's because there's less cloud up there than there is down here. And there's good physical reasons for that. But look at that.
Isn't that neat? And I can watch this stuff all day. And sometimes I do. And I get paid for it.
You know, hey, not a bad way to go. It's not an easy thing to do, though. Don't get me wrong. I've spent many decades just getting to this point, but I'm happy to share data and collaborate with people and do lectures like this.
So anyway, isn't that neat? I'll pause it again. Very well-defined above anvil cirrus plume. You can see the shadows it's casting.
You saw where I put the light sources, right? Well, that's showing the shadows. And that just highlights the features we're trying to look at. So at this point, it's a pretty mature supercell.
So yay, ParaView. That's the software I'm using to render this. I'm really, really, really happy with.
with the results. Here's going back to vapor. So here's a movie where we put some trajectories in.
Now, the field here, again, it's been clipped. We're looking at the cold pool on the surface. And then this is vorticity magnitude shaded by another field.
What's called the streamwise vorticity. Don't worry about details. Think of this as air that is spinning in some way, shape, or form.
But what I'm also doing here is I'm releasing particles. And this is what really tells you something about what's going on. So there's a feature in this storm that I talked about earlier of this little pressure thing that hangs off the updraft. The white particles there are the ones that sort of pass through that feature.
So you can see what they're doing. You can see that it looks like sort of like a tube on the ground kind of rolling on its side. But you also see that the where the air goes up has a lot to do with where it starts on the ground too, right?
You've got air, the yellow particles and the red particles, they take a different path and they end up in different parts of the updraft. But all just about everything gets slurped upwards into the sky because it's a big honking supercell. But this is really useful in showing what is actually going on with the motion of the air.
And I use this technique, this is vapor again, calculating the positions of all this data. It uses the wind data from the simulation to crunch through the trajectories. I tell it to release a slice of parcels every two seconds from these different locations, and it goes off, calculates those locations and renders them. So this is CM1 data, but this is actually doing research and analysis. using the CM1 data, which is really what I wanted to focus on in this lecture.
Because this is why we do... oh that's a little funny thing there where I moved the data, but didn't move the trajectories, and look at they actually follow a physical path. That's really neat if you're a nerd like me. What happened there is kind of cool. But it's actually showing the physics still.
It caught up to where the simulation was. The parcels aren't being released exactly where they were relative to the storm before, but you can still see the storm motion. So sometimes little errors you make are fun. In fact in science a lot of times it's what...
is going on there that's messed up, that leads to the real discoveries. It's not, we just found what we were looking for. It doesn't often work that way.
Well, folks, that's all she wrote for me. I will now pause and I'm waiting live on Zoom. So if you have any questions or you want to chat about what you just saw, go right ahead. And thank you for your attention.