id
stringlengths 11
27
| chunk_id
stringlengths 11
27
| text
stringclasses 8
values | start_text
int64 248
8.66k
| stop_text
int64 281
8.79k
| code
stringclasses 8
values | start_code
int64 0
4.38k
| stop_code
int64 75
4.86k
| __index_level_0__
int64 0
17
|
|---|---|---|---|---|---|---|---|---|
ice_on_incline-0 | ice_on_incline-0 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 7,284 | 7,346 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 1,231 | 1,242 | 0 |
ice_on_incline-1 | ice_on_incline-1 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 1,230 | 1,284 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 393 | 404 | 1 |
ice_on_incline-2 | ice_on_incline-2 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 2,536 | 2,618 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 415 | 566 | 2 |
ice_on_incline-3 | ice_on_incline-3 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 2,985 | 3,035 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 641 | 669 | 3 |
ice_on_incline-4 | ice_on_incline-4 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 7,111 | 7,281 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 1,157 | 1,229 | 4 |
ice_on_incline-5 | ice_on_incline-5 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 661 | 717 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 80 | 187 | 5 |
ice_on_incline-6 | ice_on_incline-6 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 3,665 | 3,725 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 722 | 737 | 6 |
ice_on_incline-7 | ice_on_incline-7 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 1,173 | 1,221 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 190 | 391 | 7 |
ice_on_incline-8 | ice_on_incline-8 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 4,328 | 4,366 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 796 | 811 | 8 |
ice_on_incline-9 | ice_on_incline-9 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 7,349 | 7,485 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 1,244 | 1,277 | 9 |
ice_on_incline-10 | ice_on_incline-10 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 7,491 | 7,575 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 1,279 | 1,325 | 10 |
ice_on_incline-11 | ice_on_incline-11 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 5,556 | 5,639 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 959 | 982 | 11 |
ice_on_incline-12 | ice_on_incline-12 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 5,506 | 5,549 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 941 | 957 | 12 |
ice_on_incline-13 | ice_on_incline-13 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 2,668 | 2,774 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 579 | 629 | 13 |
ice_on_incline-14 | ice_on_incline-14 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 3,557 | 3,604 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 674 | 720 | 14 |
ice_on_incline-15 | ice_on_incline-15 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 4,190 | 4,228 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 750 | 794 | 15 |
ice_on_incline-16 | ice_on_incline-16 | Ice on an incline
This activity can be run by students after a live experiment with "glacier goo" used on various slopes. In this notebook, we use a numerical simulation to study the difference in ice flow between bed of various slopes.
First, we set up the tools that we will use. You won't need to modify these.
The essentials
Now we set up our first slope and tell the model that we want to study a glacier there. We will keep things simple: a constant slope, constant valley width, and simple formulation for adding and removing ice according to altitude.
The glacier bed
We will use a helper function to create a simple bed with a constant slope. This requires as input a top and bottom altitude, and a width.
We have to decide how wide our glacier is. For now, we will use a default RectangularBedFlowline shape with an initial_width width of 300 m. The "rectangular" cross-sectional shape means that the glacial "valley" walls are straight and the width w is the same throughout:
In this image, the black lines signify the walls of the "valley". The blue line shows the surface of the glacier.
What do you think *h* means in the picture? Click for details
We set up a glacier bed with the specified geometry:
Let's plot the bed to make sure that it looks like we expect. The GlacierBed object has a built in method for this which provide us with a side and top-down view of the glacier domain.
Check out the glacier bed length. How do you think that the length is computed out of the parameters above? Click for details
We have now defined an object called GlacierBed and assigned it to the variable bed, which stores all the information about the bed geometry that the model uses.
Notice that bed does not include any information about the ice. So far we have only set up a valley. We have defined its slope, its width, its transverse shape - the geometry of the habitat where our glacier will grow. Now we want to add the climate processes that will put ice into that habitat.
Adding the ice
Now we want to add ice to our incline and make a glacier. Glaciologists describe the amount of ice that is added or removed over the entire surface of the glacier as the "mass balance". Here's an illustration from the OGGM-edu website:
A linear mass balance is defined by an equilibrium line altitude (ELA) and a mass balance gradient with altitude (in [mm mβ1]). Above the ELA, we add ice (from snow) and below the line we remove ice (melting it). We will learn more about this in the accumulation and ablation notebook.
The mass balance model mb_model gives us the mass balance for any altitude we want. We will plot it below.
Glacier initialisation
We can now take our bed and the mass balance and create a glacier which we can then perform experiments on.
Similarly to the bed, the Glacier object is storing some information that we can recover just by calling it:
Since we just created the glacier, there's still no ice! We need some time for ice to accumulate. For this, the mass balance is the relevant process:
What did you notice in the graph? What are the axes? At what altitudes is ice added to the glacier (positive mass balance)? At what altitudes does ice melt?
Running the numerical model
When we did our experiments in the laboratory, we had a slope and some material to pour our "glacier". We also decided how long to let the goo flow -- that is, the "runtime" of our experiment. Setting up our glacier model on the computer is very similar. We have gathered our bed geometry (bed), our mass balance (mb_model), and now we will tell the model how long to run (runtime).
First we run the model for one year:
Let's take a look. The Glacier object also has a built-in method for us to plot.
Here we can see that there is a very thin cover of ice from the top and partway down the glacier bed. Study both plots and interpret what they are showing. How far down the glacier bed does the ice cover reach?
We can also take a look at some of statistics of the glacier again to get some more details:
The modeled "glacier" already reaches down to the ELA (dashed line)...but it is extremely thin. Looks like we need some more time for the glacier to grow.
Let's now run the model for 150 years.
In the following code, can you identify where we tell the model how many years we want to study?
Let's see how our glacier has changed.
Now we can clearly see the difference between the surface of the glacier and the bedrock. Let's print the same set of statistics about the glacier as before:
Compare this "numerical glacier" with the "glacier goo" we made in the lab:
How long does it take for the glacier goo to "grow" and flow down the slope? How long does the numerical glacier need?
Below the ELA (3000 m) something happens for the numerical glacier (and for real glaciers too) that did not happen in the glacier goo experiment. What is it?
If we want to calculate changes further in time, we have to set the desired date.
Try editing the cell below to ask the model to run for 500 years instead of 150.
Based on this information, do you think you modified the cell correctly?
It is important to note that the model will not go back in time. Once it has run for 500 years, the model will not go back to the 450-year date. It remains at year 500. Try running the cell below. Does the output match what you expected?
Accessing the glacier history
Lucky for us, the Glacier object has also been storing a history of how the glacier has changed over the simulation. We can access that data through the history:
And we can quickly visualise the history of the glacier with the .plot_history() method
What is going on in this image?
The length of the glacier is a step function in the first year of simulation because, above the equilibrium line altitude (ELA), only accumulation is happening. After that, at first the length of the glacier remains constant. The ice is not very thick, so the portion that reaches below the ELA does not survive the melting that occurs there. But no matter how thick the glacier is, the part above the ELA is always gaining mass. Eventually, there is enough ice to persist below the ELA. We will learn more about ELA in the accumulation and ablation notebook.
Equilibrium state
After several centuries, the glacier reaches a balance with its climate. This means that its length and volume will no longer change, as long as all physical parameters and the climate stay roughly constant. The Glacier object has a method which can progress the glacier to equilibrium .progress_to_equilibrium(). More on this in later notebooks.
Can you identify an equilibrium state in the plots above?
A first experiment
Ok, we have seen the basics. Now, how about a glacier on a different slope? Glaciers are sometimes very steep, like this one in Nepal.
Let's adjust the slope in the model to observe a steeper glacier:
In the following code, can you identify where we tell the model the new slope we are going to use?
What slope did we use for the first experiment? Look for that information at the beginning of the notebook.
Comparing glaciers
We can now introduce the GlacierCollection. This is a utility which can store multiple glaciers and can be used to easily compare and run experiments on multiple glaciers.
We can get a quick look at the collection by simply calling it:
Before we compare the glaciers in the collection, let's make sure to progress them to the same year with the .progress_to_year() method.
Now let's compare the glacier we studied first with our new glacier on a different slope. Do you think the new glacier will have more or less ice than the first?
Let's make sure we understand what is going on:
Explore the characteristics (thickness, length, velocity...). Can you explain the difference between the two glaciers? Click for details
Activity
Now, try to change the slope to another value, and run the model again. What do you see? | 248 | 281 |
from oggm_edu import MassBalance, GlacierBed, Glacier, GlacierCollection
top_elev = 3400 # m, the peak elevation
bottom_elev = 1500 # m, the elevation at the bottom of the glacier
bed_width = 300 # m, the constant width of the rectangular valley
bed_slope = 10 # degrees, the slope of the bed
bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=bed_slope)
bed.plot()
bed
ELA = 3000 # equilibrium line altitude in meters above sea level
altgrad = 4 # altitude gradient in mm/m
mb_model = MassBalance(ELA, gradient=altgrad)
mb_model
glacier = Glacier(bed=bed, mass_balance=mb_model)
glacier
glacier.plot_mass_balance()
runtime = 1
glacier.progress_to_year(runtime)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(150)
glacier.plot()
glacier
runtime = 150
glacier.progress_to_year(runtime)
glacier.plot()
glacier
glacier.progress_to_year(450)
glacier
glacier.history
glacier.plot_history()
new_slope = 20
new_bed = GlacierBed(top=top_elev, bottom=bottom_elev, width=bed_width, slopes=new_slope)
new_glacier = Glacier(bed=new_bed, mass_balance=mb_model)
collection = GlacierCollection()
collection.add([glacier, new_glacier])
collection
collection.progress_to_year(600)
collection.plot_side_by_side(figsize=(10, 5))
collection.plot_history()
collection
| 3 | 76 | 16 |
ice_flow_parameters-0 | ice_flow_parameters-0 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 1,436 | 1,578 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 252 | 316 | 0 |
ice_flow_parameters-1 | ice_flow_parameters-1 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 1,581 | 1,657 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 329 | 391 | 1 |
ice_flow_parameters-2 | ice_flow_parameters-2 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 1,725 | 1,744 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 428 | 446 | 2 |
ice_flow_parameters-3 | ice_flow_parameters-3 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 587 | 609 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 79 | 233 | 3 |
ice_flow_parameters-4 | ice_flow_parameters-4 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 2,077 | 2,197 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 564 | 659 | 4 |
ice_flow_parameters-5 | ice_flow_parameters-5 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 919 | 970 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 236 | 250 | 5 |
ice_flow_parameters-6 | ice_flow_parameters-6 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 1,663 | 1,718 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 393 | 426 | 6 |
ice_flow_parameters-7 | ice_flow_parameters-7 | Influence of ice flow parameters on glacier size
Goals of this notebook:
The student will be able to create a glacier and change Glen's creep parameter and basal sliding parameter.
The student will be able to explain the influences of the two parameters on glacier shape.
The motion of glaciers is determined by two main processes: One is internal deformation of ice due to gravity and the other is basal sliding. These processes can be described by parameters. In this notebook we will examine their influence on glaciers.
First, we have to import the relevant classes from OGGM Edu
Let's create a glacier
Glen's creep parameter
We start with looking at the internal deformation of the ice, which results in so called creeping. To describe it we use Glens's creep parameter. Our glacier, and OGGM, defaults to set Glen's creep parameter to the "standard value" defined by Cuffey and Paterson, (2010): 2.4 β
10β24. We can check this by accessing the .creep attribute
The parameter relates shear stress to the rate of deformation and is assumed to be constant. It depends on crystal size, fabric, concentration and type of impurities, as well as on ice temperature (Oerlemans, 2001) (you can find a more detailed description of it here).
Next we will change the creep parameter and see what happens. An easy way to do this is to create a GlacierCollection and change the creep parameter for some of the glaciers in the collection. Here we will also introduce the .fill() method of the GlacierCollection, which is useful to quickly create a collection with multiple glaciers.
We can then change the creep parameter of the glaciers within the collection
And progress the glaciers within the collection to year 800:
And plot the collection
Sliding parameter
Basal sliding occurs when there is a water film between the ice and the ground. In his seminal paper, Hans Oerlemans uses a so-called "sliding parameter" representing basal sliding. For our glacier this parameter is available under the .basal_sliding attribute. By default it is set to 0, but it can be modified
Change the basal sliding parameter of one of the glaciers in the collection to 5.7 β
10 β 20 and progress the collection
Take a look at the glaciers
Initially the glacier with higher basal sliding is advancing down the bed quicker compared to the glacier without basal sliding. However, at a certain point in time the larger volume of Glacier 0 lead to a stronger ice flow, and the glacier can extend further down.
If you want to learn more about the processes of glacier flow, we recommend to go through these two pages:
Deformation and sliding
Stress and strain
In the documentation of OGGM you find also information about the theory of the ice flow parameters and the application. | 1,946 | 2,025 |
from oggm_edu import GlacierBed, MassBalance, Glacier, GlacierCollection
bed = GlacierBed(top=3400, bottom=1500, width=300)
mass_balance = MassBalance(ela=3000, gradient=4)
glacier = Glacier(bed=bed, mass_balance=mass_balance)
glacier.creep
collection = GlacierCollection()
collection.fill(glacier, n=3)
collection
collection.change_attributes({"creep": ["* 10", "", "/ 10"]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
glacier.basal_sliding
collection = GlacierCollection()
collection.fill(glacier, n=2)
collection.change_attributes({'basal_sliding':[0, 5.7e-20]})
collection.progress_to_year(800)
collection.plot()
collection.plot_history()
| 476 | 498 | 7 |
End of preview. Expand
in Dataset Viewer.
- Downloads last month
- 4