From 152275949cd4bf5f53e349c9fa4c46526283ba01 Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Fri, 2 Jul 2021 15:24:30 -0700 Subject: [PATCH 01/14] Add DOI badge because I can never find it easily --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index b49c61bb5..c4591d4cd 100644 --- a/README.md +++ b/README.md @@ -1,5 +1,5 @@ -# icepack [![CircleCI](https://circleci.com/gh/icepack/icepack/tree/master.svg?style=svg)](https://circleci.com/gh/icepack/icepack/tree/master) [![codecov](https://codecov.io/gh/icepack/icepack/branch/master/graph/badge.svg)](https://codecov.io/gh/icepack/icepack) +# icepack [![CircleCI](https://circleci.com/gh/icepack/icepack/tree/master.svg?style=svg)](https://circleci.com/gh/icepack/icepack/tree/master) [![codecov](https://codecov.io/gh/icepack/icepack/branch/master/graph/badge.svg)](https://codecov.io/gh/icepack/icepack) [![DOI](https://zenodo.org/badge/45697304.svg)](https://zenodo.org/badge/latestdoi/45697304) icepack is a library for modeling the flow of ice sheets and glaciers using the finite element method. For more information and installation instructions, see the [project webpage](https://icepack.github.io). From ec4125072a06f72cc5e6c1f47c664454223339ab Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Thu, 19 Aug 2021 10:27:41 -0700 Subject: [PATCH 02/14] Move quadrature degree estimation from solver to models Before, quadrature degree setting occured inside FlowSolver. This has the unfortunate effect of leaving the adjoint solver with no way to know what quadrature degree to use (barring upstream fixes in Firedrake and pyadjoint). The adjoint solver then uses the default, conservative quadrature estimation, resulting in annoying warnings and low performance. This patch puts quadrature degree in by adding it to the metadata of all the measures (dx, ds, etc.) in the action functionals. --- icepack/models/hybrid.py | 18 +++++++++++++----- icepack/models/ice_shelf.py | 19 +++++++++++-------- icepack/models/ice_stream.py | 16 ++++++++++------ icepack/models/shallow_ice.py | 13 ++++++++----- icepack/solvers/flow_solver.py | 6 ++---- 5 files changed, 44 insertions(+), 28 deletions(-) diff --git a/icepack/models/hybrid.py b/icepack/models/hybrid.py index d5fa8d4db..99c0ad5b1 100644 --- a/icepack/models/hybrid.py +++ b/icepack/models/hybrid.py @@ -217,22 +217,25 @@ def action(self, **kwargs): ice_front_ids = tuple(kwargs.pop("ice_front_ids", ())) side_wall_ids = tuple(kwargs.pop("side_wall_ids", ())) + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) + ds_b = firedrake.ds_b(domain=mesh, metadata=metadata) + ds_v = firedrake.ds_v(domain=mesh) + viscosity = self.viscosity(**kwargs) * dx gravity = self.gravity(**kwargs) * dx friction = self.friction(**kwargs) * ds_b - ds_w = ds_v(domain=mesh, subdomain_id=side_wall_ids) - side_friction = self.side_friction(**kwargs) * ds_w + side_friction = self.side_friction(**kwargs) * ds_v(side_wall_ids) if get_mesh_axes(mesh) == "xyz": - penalty = self.penalty(**kwargs) * ds_w + penalty = self.penalty(**kwargs) * ds_v(side_wall_ids) else: penalty = 0.0 xdegree_u, zdegree_u = u.ufl_element().degree() degree_h = h.ufl_element().degree()[0] degree = (xdegree_u + degree_h, 2 * zdegree_u + 1) - metadata = {"quadrature_degree": degree} - ds_t = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) + ds_t = firedrake.ds_v(ice_front_ids, metadata={"quadrature_degree": degree}) terminus = self.terminus(**kwargs) * ds_t return viscosity + friction + side_friction - gravity - terminus + penalty @@ -243,6 +246,11 @@ def scale(self, **kwargs): The positive part of the action functional is used as a dimensional scale to determine when to terminate an optimization algorithm. """ + u = kwargs["velocity"] + mesh = u.ufl_domain() + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) + ds_b = firedrake.ds_b(domain=mesh, metadata=metadata) return self.viscosity(**kwargs) * dx + self.friction(**kwargs) * ds_b def quadrature_degree(self, **kwargs): diff --git a/icepack/models/ice_shelf.py b/icepack/models/ice_shelf.py index 1b9bd7d42..e88031ceb 100644 --- a/icepack/models/ice_shelf.py +++ b/icepack/models/ice_shelf.py @@ -1,4 +1,4 @@ -# Copyright (C) 2017-2020 by Daniel Shapero +# Copyright (C) 2017-2021 by Daniel Shapero # # This file is part of icepack. # @@ -12,7 +12,7 @@ from operator import itemgetter import firedrake -from firedrake import inner, grad, dx, ds +from firedrake import inner, grad from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g from icepack.models.viscosity import viscosity_depth_averaged as viscosity from icepack.models.friction import side_friction, normal_flow_penalty @@ -130,15 +130,16 @@ def action(self, **kwargs): ice_front_ids = tuple(kwargs.pop("ice_front_ids", ())) side_wall_ids = tuple(kwargs.pop("side_wall_ids", ())) + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) + ds = firedrake.ds(domain=mesh, metadata=metadata) + viscosity = self.viscosity(**kwargs) * dx gravity = self.gravity(**kwargs) * dx - ds_w = ds(domain=mesh, subdomain_id=side_wall_ids) - side_friction = self.side_friction(**kwargs) * ds_w - penalty = self.penalty(**kwargs) * ds_w - - ds_t = ds(domain=mesh, subdomain_id=ice_front_ids) - terminus = self.terminus(**kwargs) * ds_t + side_friction = self.side_friction(**kwargs) * ds(side_wall_ids) + penalty = self.penalty(**kwargs) * ds(side_wall_ids) + terminus = self.terminus(**kwargs) * ds(ice_front_ids) return viscosity + side_friction - gravity - terminus + penalty @@ -148,6 +149,8 @@ def scale(self, **kwargs): The positive part of the action functional is used as a dimensional scale to determine when to terminate an optimization algorithm. """ + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) return self.viscosity(**kwargs) * dx def quadrature_degree(self, **kwargs): diff --git a/icepack/models/ice_stream.py b/icepack/models/ice_stream.py index f9d2e9c17..97ce4bb73 100644 --- a/icepack/models/ice_stream.py +++ b/icepack/models/ice_stream.py @@ -12,7 +12,7 @@ from operator import itemgetter import firedrake -from firedrake import inner, dx, ds +from firedrake import inner from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g from icepack.models.viscosity import viscosity_depth_averaged as viscosity from icepack.models.friction import bed_friction, side_friction, normal_flow_penalty @@ -108,19 +108,21 @@ def action(self, **kwargs): ice_front_ids = tuple(kwargs.pop("ice_front_ids", ())) side_wall_ids = tuple(kwargs.pop("side_wall_ids", ())) + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) + ds = firedrake.ds(domain=mesh, metadata=metadata) + viscosity = self.viscosity(**kwargs) * dx friction = self.friction(**kwargs) * dx gravity = self.gravity(**kwargs) * dx - ds_w = ds(domain=mesh, subdomain_id=side_wall_ids) - side_friction = self.side_friction(**kwargs) * ds_w + side_friction = self.side_friction(**kwargs) * ds(side_wall_ids) if get_mesh_axes(mesh) == "xy": - penalty = self.penalty(**kwargs) * ds_w + penalty = self.penalty(**kwargs) * ds(side_wall_ids) else: penalty = 0.0 - ds_t = ds(domain=mesh, subdomain_id=ice_front_ids) - terminus = self.terminus(**kwargs) * ds_t + terminus = self.terminus(**kwargs) * ds(ice_front_ids) return viscosity + friction + side_friction - gravity - terminus + penalty @@ -130,6 +132,8 @@ def scale(self, **kwargs): The positive part of the action functional is used as a dimensional scale to determine when to terminate an optimization algorithm. """ + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) return (self.viscosity(**kwargs) + self.friction(**kwargs)) * dx def quadrature_degree(self, **kwargs): diff --git a/icepack/models/shallow_ice.py b/icepack/models/shallow_ice.py index 39b2ebd17..f3e3b9b09 100644 --- a/icepack/models/shallow_ice.py +++ b/icepack/models/shallow_ice.py @@ -1,4 +1,4 @@ -# Copyright (C) 2020 by Jessica Badgeley +# Copyright (C) 2020-2021 by Jessica Badgeley # # This file is part of icepack. # @@ -12,7 +12,7 @@ from operator import itemgetter import firedrake -from firedrake import inner, grad, dx +from firedrake import inner, grad from icepack.constants import ice_density as ρ_I, gravity as g, glen_flow_law as n from icepack.models.mass_transport import Continuity from icepack.utilities import add_kwarg_wrapper @@ -129,6 +129,8 @@ def action(self, **kwargs): All other keyword arguments will be passed on to the 'mass', 'gravity' and 'penalty' functionals """ + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) mass = self.mass(**kwargs) * dx gravity = self.gravity(**kwargs) * dx penalty = self.penalty(**kwargs) * dx @@ -140,13 +142,14 @@ def scale(self, **kwargs): The positive part of the action functional is used as a dimensional scale to determine when to terminate an optimization algorithm. """ + metadata = {"quadrature_degree": self.quadrature_degree(**kwargs)} + dx = firedrake.dx(metadata=metadata) return (self.mass(**kwargs) + self.penalty(**kwargs)) * dx def quadrature_degree(self, **kwargs): r"""Return the quadrature degree necessary to integrate the action functional accurately""" - u, h, s = itemgetter("velocity", "thickness", "surface")(kwargs) + u, h = itemgetter("velocity", "thickness")(kwargs) degree_u = u.ufl_element().degree() degree_h = h.ufl_element().degree() - degree_s = s.ufl_element().degree() - return int((n + 1) * degree_h + n * degree_s + degree_u) + return int((2 * n + 1) * degree_h + degree_u) diff --git a/icepack/solvers/flow_solver.py b/icepack/solvers/flow_solver.py index 241ac4b22..c9f05c130 100644 --- a/icepack/solvers/flow_solver.py +++ b/icepack/solvers/flow_solver.py @@ -1,4 +1,4 @@ -# Copyright (C) 2020 by Daniel Shapero +# Copyright (C) 2020-2021 by Daniel Shapero # # This file is part of icepack. # @@ -255,9 +255,7 @@ def setup(self, **kwargs): action = self._model.action(**self._fields, **_kwargs) F = firedrake.derivative(action, u) - degree = self._model.quadrature_degree(**self._fields) - params = {"form_compiler_parameters": {"quadrature_degree": degree}} - problem = firedrake.NonlinearVariationalProblem(F, u, bcs, **params) + problem = firedrake.NonlinearVariationalProblem(F, u, bcs) self._solver = firedrake.NonlinearVariationalSolver( problem, solver_parameters=self._solver_parameters ) From d996aa8a8bf509491e139f473c184886dd81d658 Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Fri, 3 Sep 2021 18:59:46 -0700 Subject: [PATCH 03/14] New testing environment version --- .circleci/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 2535bd28e..0fe7bfe10 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -24,7 +24,7 @@ commands: jobs: python36: docker: - - image: icepack/firedrake-python3.6:0.5.3 + - image: icepack/firedrake-python3.6:0.5.4 working_directory: ~/icepack steps: - build @@ -32,7 +32,7 @@ jobs: - realtest python38: docker: - - image: icepack/firedrake-python3.8:0.5.3 + - image: icepack/firedrake-python3.8:0.5.4 working_directory: ~/icepack steps: - build From 08b182c711fa9a97c6cad627eb339e7669805925 Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Mon, 13 Sep 2021 16:13:39 -0700 Subject: [PATCH 04/14] Fix for change of MoA URL at NSIDC --- icepack/datasets.py | 2 +- icepack/registry-nsidc.txt | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/icepack/datasets.py b/icepack/datasets.py index 3a9546c0d..926bcc321 100644 --- a/icepack/datasets.py +++ b/icepack/datasets.py @@ -135,7 +135,7 @@ def fetch_larsen_outline(): def fetch_mosaic_of_antarctica(): r"""Fetch the MODIS optical image mosaic of Antarctica""" return nsidc_data.fetch( - "moa750_2009_hp1_v01.1.tif.gz", + "moa750_2009_hp1_v02.0.tif.gz", downloader=_earthdata_downloader, processor=pooch.Decompress(), ) diff --git a/icepack/registry-nsidc.txt b/icepack/registry-nsidc.txt index e5c529570..bc50b42ba 100644 --- a/icepack/registry-nsidc.txt +++ b/icepack/registry-nsidc.txt @@ -1,6 +1,6 @@ antarctic_ice_vel_phase_map_v01.nc fa0957618b8bd98099f4a419d7dc0e3a2c562d89e9791b4d0ed55e6017f52416 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0754.001/1996.01.01/antarctic_ice_vel_phase_map_v01.nc BedMachineAntarctica_2020-07-15_v02.nc 71ff97f8fb034fbfe235cd1cad044eeea2ae1543e82115afbd886a24c1e71069 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0756.002/1970.01.01/BedMachineAntarctica_2020-07-15_v02.nc -moa750_2009_hp1_v01.1.tif.gz 90d1718ea0971795ec102482c47f308ba08ba2b88383facb9fe210877e80282c https://daacdata.apps.nsidc.org/pub/DATASETS/nsidc0593_moa2009/geotiff/moa750_2009_hp1_v01.1.tif.gz +moa750_2009_hp1_v02.0.tif.gz 90d1718ea0971795ec102482c47f308ba08ba2b88383facb9fe210877e80282c https://daacdata.apps.nsidc.org/pub/DATASETS/nsidc0593_moa2009_v02/geotiff/moa750_2009_hp1_v02.0.tif.gz greenland_vel_mosaic200_2015_2016_vx_v02.1.tif 77b8eb65a4718da055bb048b75c35b48ca43d76b5bffb650932128d60ed28598 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0478.002/2015.09.01/greenland_vel_mosaic200_2015_2016_vx_v02.1.tif greenland_vel_mosaic200_2015_2016_vy_v02.1.tif fb5dbc07d032de9b1bdb0b990ed02a384964d73a150529515038139efb1e3193 https://n5eil01u.ecs.nsidc.org/MEASURES/NSIDC-0478.002/2015.09.01/greenland_vel_mosaic200_2015_2016_vy_v02.1.tif From 144e35c3dac8e3a71b6c63af50abb34ac77b1a32 Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Tue, 14 Sep 2021 09:27:22 -0700 Subject: [PATCH 05/14] Try new testing image --- .circleci/config.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.circleci/config.yml b/.circleci/config.yml index 0fe7bfe10..57e9cc4ca 100644 --- a/.circleci/config.yml +++ b/.circleci/config.yml @@ -24,7 +24,7 @@ commands: jobs: python36: docker: - - image: icepack/firedrake-python3.6:0.5.4 + - image: icepack/firedrake-python3.6:0.5.5 working_directory: ~/icepack steps: - build @@ -32,7 +32,7 @@ jobs: - realtest python38: docker: - - image: icepack/firedrake-python3.8:0.5.4 + - image: icepack/firedrake-python3.8:0.5.5 working_directory: ~/icepack steps: - build From e3ef3dd6c8e2a1cf2344dc5e0812d5220557b114 Mon Sep 17 00:00:00 2001 From: Daniel Shapero Date: Mon, 11 Oct 2021 11:34:50 -0700 Subject: [PATCH 06/14] Make error message in solvers more informative Resolves #72 --- icepack/solvers/damage_solver.py | 5 ++++- icepack/solvers/flow_solver.py | 20 ++++++++++++++++---- icepack/solvers/heat_transport.py | 5 ++++- 3 files changed, 24 insertions(+), 6 deletions(-) diff --git a/icepack/solvers/damage_solver.py b/icepack/solvers/damage_solver.py index 3ddc23b5e..59152c527 100644 --- a/icepack/solvers/damage_solver.py +++ b/icepack/solvers/damage_solver.py @@ -48,7 +48,10 @@ def _setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) # Create symbolic representations of the flux and sources of damage dt = firedrake.Constant(1.0) diff --git a/icepack/solvers/flow_solver.py b/icepack/solvers/flow_solver.py index c9f05c130..affbd5f06 100644 --- a/icepack/solvers/flow_solver.py +++ b/icepack/solvers/flow_solver.py @@ -167,7 +167,10 @@ def setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) # Create homogeneous BCs for the Dirichlet part of the boundary u = self._fields["velocity"] @@ -236,7 +239,10 @@ def setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) # Create homogeneous BCs for the Dirichlet part of the boundary u = self._fields["velocity"] @@ -299,7 +305,10 @@ def setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) dt = firedrake.Constant(1.0) dh_dt = self._continuity(dt, **self._fields) @@ -356,7 +365,10 @@ def setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) dt = firedrake.Constant(1.0) h = self._fields["thickness"] diff --git a/icepack/solvers/heat_transport.py b/icepack/solvers/heat_transport.py index 94f6f0315..b888cee19 100644 --- a/icepack/solvers/heat_transport.py +++ b/icepack/solvers/heat_transport.py @@ -45,7 +45,10 @@ def _setup(self, **kwargs): elif isinstance(field, firedrake.Function): self._fields[name] = field.copy(deepcopy=True) else: - raise TypeError("Input fields must be Constant or Function!") + raise TypeError( + "Input %s field has type %s, must be Constant or Function!" + % (name, type(field)) + ) dt = Constant(1.0) From 9fe6a41c30a6bf02600f0aa369e9fe8a2b562e49 Mon Sep 17 00:00:00 2001 From: Andrew Hoffman Date: Thu, 27 May 2021 09:43:36 -0700 Subject: [PATCH 07/14] age solver --- icepack/models/age_transport.py | 67 +++++++++++++++++++ icepack/solvers/__init__.py | 12 ++-- icepack/solvers/age_solver.py | 115 ++++++++++++++++++++++++++++++++ icepack/utilities.py | 69 +++++++++++++++++++ 4 files changed, 258 insertions(+), 5 deletions(-) create mode 100644 icepack/models/age_transport.py create mode 100644 icepack/solvers/age_solver.py diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py new file mode 100644 index 000000000..75e6dbf7d --- /dev/null +++ b/icepack/models/age_transport.py @@ -0,0 +1,67 @@ +# Copyright (C) 2020-2021 by Andrew Hoffman +# +# This file is part of icepack. +# +# icepack is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# The full text of the license can be found in the file LICENSE in the +# icepack source directory or at . + +r"""Description of the age transport model. +""" + +import firedrake +from firedrake import ( + inner, grad, div, dx, ds, ds_t, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional +) +from icepack.constants import year +from icepack.utilities import eigenvalues, vertical_velocity, get_kwargs_alt + + +class AgeTransport: + def __init__( + self, + max_age=2000000.0 + ): + self.max_age = max_age + + + + def flux(self, **kwargs): + keys = ('thickness', 'velocity', 'age') + keys_alt = ('h','u','age') + h, u, q = get_kwargs_alt(kwargs, keys, keys_alt) + + Q = h.function_space() + U = q.function_space() + V = u.function_space() + mesh = Q.mesh() + W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) + + φ = firedrake.TestFunction(U) + + w = firedrake.interpolate(vertical_velocity(u,h),W) + + xdegree_u, zdegree_u = u.ufl_element().degree() + degree_h = h.ufl_element().degree()[0] + degree = (xdegree_u + degree_h, 2 * zdegree_u + 1) + metadata = {'quadrature_degree': degree} + ice_front_ids = tuple(kwargs.pop('ice_front_ids', ())) + ds_terminus = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) + V3D = firedrake.VectorFunctionSpace(mesh,dim=3, family='CG',degree=xdegree_u,vfamily='GL',vdegree=zdegree_u+1) + u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w))) + + n = firedrake.FacetNormal(mesh) + u_n = max_value(0, inner(u3D, n)) + f = q * u_n + q_inflow=firedrake.Constant(0.0) + flux_faces_h = (f('+') - f('-')) * (φ('+') - φ('-')) * dS_h + flux_cells = -q * div(u3D * φ) * dx + #flux_terminus = q * max_value(0, inner(u3D, n)) * φ * ds_terminus + #flux_surface = q_inflow * min_value(0, inner(u3D, n)) * φ * ds_t + flux_h = q * max_value(0, inner(u3D, n)) * φ * ds_h + flux_tb = q * max_value(0, inner(u3D, n)) * φ * ds_tb + return flux_cells + flux_faces_v + flux_h + flux_tb diff --git a/icepack/solvers/__init__.py b/icepack/solvers/__init__.py index 13e0fd672..fc4391f08 100644 --- a/icepack/solvers/__init__.py +++ b/icepack/solvers/__init__.py @@ -13,11 +13,13 @@ from .flow_solver import FlowSolver, ImplicitEuler, LaxWendroff from .heat_transport import HeatTransportSolver from .damage_solver import DamageSolver +from .age_solver import AgeSolver __all__ = [ - "FlowSolver", - "ImplicitEuler", - "LaxWendroff", - "HeatTransportSolver", - "DamageSolver", + 'FlowSolver', + 'ImplicitEuler', + 'LaxWendroff', + 'HeatTransportSolver', + 'DamageSolver', + 'AgeSolver' ] diff --git a/icepack/solvers/age_solver.py b/icepack/solvers/age_solver.py new file mode 100644 index 000000000..e4f4ccad0 --- /dev/null +++ b/icepack/solvers/age_solver.py @@ -0,0 +1,115 @@ +# Copyright (C) 2020-2021 by Andrew Hoffman +# +# This file is part of icepack. +# +# icepack is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# The full text of the license can be found in the file LICENSE in the +# icepack source directory or at . + +r"""Description of the age solver used to calculate the layer slopes +""" + +import firedrake +from firedrake import ( + dx, + LinearVariationalProblem, + LinearVariationalSolver, + max_value, + min_value +) + +class AgeSolver: + def __init__(self, model): + self._model = model + self._fields = {} + @property + def model(self): + r"""The heat transport model that this object solves""" + return self._model + @property + def fields(self): + r"""The dictionary of all fields that are part of the simulation""" + return self._fields + def _setup(self, **kwargs): + for name, field in kwargs.items(): + if name in self._fields.keys(): + self._fields[name].assign(field) + else: + if isinstance(field, firedrake.Constant): + self._fields[name] = firedrake.Constant(field) + elif isinstance(field, firedrake.Function): + self._fields[name] = field.copy(deepcopy=True) + else: + raise TypeError('Input fields must be Constant or Function!') + + # Create symbolic representations of the flux and sources of damage + dt = firedrake.Constant(1.0) + flux = self.model.flux(**self.fields) + + # Create the finite element mass matrix + q = self.fields.get('age', self.fields.get('age')) + Q = q.function_space() + φ, ψ = firedrake.TrialFunction(Q), firedrake.TestFunction(Q) + M = φ * ψ * dx + + L1 = -dt * flux + q1 = firedrake.Function(Q) + q2 = firedrake.Function(Q) + L2 = firedrake.replace(L1, {q: q1}) + L3 = firedrake.replace(L1, {q: q2}) + + dq = firedrake.Function(Q) + + parameters = { + 'solver_parameters': { + 'ksp_type': 'preonly', + 'pc_type': 'bjacobi', + 'sub_pc_type': 'ilu' + } + } + + problem1 = LinearVariationalProblem(M, L1, dq) + problem2 = LinearVariationalProblem(M, L2, dq) + problem3 = LinearVariationalProblem(M, L3, dq) + solver1 = LinearVariationalSolver(problem1, **parameters) + solver2 = LinearVariationalSolver(problem2, **parameters) + solver3 = LinearVariationalSolver(problem3, **parameters) + + self._solvers = [solver1, solver2, solver3] + self._stages = [q1, q2] + self._age_change = dq + self._timestep = dt + + def solve(self, dt, **kwargs): + if not hasattr(self, '_solvers'): + self._setup(**kwargs) + else: + for name, field in kwargs.items(): + self.fields[name].assign(field) + + δt = self._timestep + δt.assign(dt) + q = self.fields.get('age', self.fields.get('age')) + + solver1, solver2, solver3 = self._solvers + q1, q2 = self._stages + dq = self._age_change + + solver1.solve() + q1.assign(q + dq) + solver2.solve() + q2.assign(3/4 * q + 1/4 * (q1 + dq)) + solver3.solve() + q.assign(1/3 * q + 2/3 * (q2 + dq)) + + max_age = firedrake.Constant(self.model.max_age) + q.project(min_value(max_value(q + firedrake.Constant(δt), firedrake.Constant(0.0)), max_age)) + return q.copy(deepcopy=True) + + + + diff --git a/icepack/utilities.py b/icepack/utilities.py index 59e24669e..1d5483d5b 100644 --- a/icepack/utilities.py +++ b/icepack/utilities.py @@ -143,3 +143,72 @@ def wrapper(*args, **kwargs): return func(*args, **kwargs_) return wrapper + + + +@functools.lru_cache(maxsize=None) +def vertically_integrate(q,h): + r""" + q : firedrake.Function + integrand + h : firedrake.Function + ice thickness + """ + def weight(n,ζ): + norm=(1/sympy.integrate(_legendre(n,ζ)**2,(ζ,0,1)))**.5 + return sympy.lambdify(ζ,norm*_legendre(n,ζ),'numpy') + + def coefficient(n,q,ζ,ζsym,Q): + a_n=depth_average(q,weight=weight(n,ζsym)(ζ)) + a_n3d=lift3d(a_n,Q) + return a_n3d + + def recurrance_relation(n,ζ): + if n>0: + return sympy.lambdify(ζ,(1/(2*(2*n+1)))*(_legendre(n+1,ζ)-_legendre(n-1,ζ)),'numpy') + elif n==0: + return sympy.lambdify(ζ,ζ,'numpy') + if n<0: + raise ValueError("n must be positive") + + Q=h.function_space() + mesh=Q.mesh() + x,y,ζ=firedrake.SpatialCoordinate(mesh) + xdegree_q,zdegree_q=q.ufl_element().degree() + + ζsym = sympy.symbols('ζsym', real=True, positive=True) + + q_int=sum([coefficient(k,q,ζ,ζsym,Q) * recurrance_relation(k,ζsym)(ζ) for k in range(zdegree_q)]) + return q_int + +def vertical_velocity(u,h,m=0.0): + r""" + u : firedrake.Function + ice velocity + h : firedrake.Function + ice thickness + m : firedrake.Function + basal vertical velocity + """ + Q = h.function_space() + mesh = Q.mesh() + xdegree_u, zdegree_u = u.ufl_element().degree() + W = firedrake.FunctionSpace(mesh,family='CG',degree=xdegree_u,vfamily='GL',vdegree=zdegree_u) + u_div = firedrake.interpolate(u[0].dx(0)+u[1].dx(1),W) + return (m/h-vertically_integrate(u_div,h)) + + +def add_kwarg_wrapper(func): + signature = inspect.signature(func) + if any(str(signature.parameters[param].kind) == 'VAR_KEYWORD' + for param in signature.parameters): + return func + + params = signature.parameters + + def wrapper(*args, **kwargs): + kwargs_ = dict((key, kwargs[key]) for key in kwargs if key in params) + return func(*args, **kwargs_) + + return wrapper + From f89d7d3e5d4b9e14214e866e4dc867def90d622e Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Thu, 20 May 2021 15:59:33 -0700 Subject: [PATCH 08/14] initial age model test commit --- icepack/models/age_transport.py | 29 +- notebooks/tutorials/age_model_test.ipynb | 333 +++++++++++++++++++++++ 2 files changed, 354 insertions(+), 8 deletions(-) create mode 100644 notebooks/tutorials/age_model_test.ipynb diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py index 75e6dbf7d..22180c597 100644 --- a/icepack/models/age_transport.py +++ b/icepack/models/age_transport.py @@ -18,15 +18,32 @@ inner, grad, div, dx, ds, ds_t, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional ) from icepack.constants import year -from icepack.utilities import eigenvalues, vertical_velocity, get_kwargs_alt +from icepack.utilities import eigenvalues, vertical_velocity, get_kwargs_alt, add_kwarg_wrapper + +def velocity_3D(**kwargs): + keys = ('thickness', 'velocity') + keys_alt = ('h','u') + h, u = get_kwargs_alt(kwargs, keys, keys_alt) + + Q = h.function_space() + V = u.function_space() + mesh = Q.mesh() + xdegree_u, zdegree_u = u.ufl_element().degree() + W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) + w = firedrake.interpolate(vertical_velocity(u,h),W) + V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1) + u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w))) + return u3D class AgeTransport: def __init__( self, - max_age=2000000.0 + max_age=2000000.0, + velocity_3D=velocity_3D ): self.max_age = max_age + self.velocity_3D = add_kwarg_wrapper(velocity_3D) @@ -37,22 +54,18 @@ def flux(self, **kwargs): Q = h.function_space() U = q.function_space() - V = u.function_space() mesh = Q.mesh() - W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) φ = firedrake.TestFunction(U) - w = firedrake.interpolate(vertical_velocity(u,h),W) - xdegree_u, zdegree_u = u.ufl_element().degree() degree_h = h.ufl_element().degree()[0] degree = (xdegree_u + degree_h, 2 * zdegree_u + 1) metadata = {'quadrature_degree': degree} ice_front_ids = tuple(kwargs.pop('ice_front_ids', ())) ds_terminus = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) - V3D = firedrake.VectorFunctionSpace(mesh,dim=3, family='CG',degree=xdegree_u,vfamily='GL',vdegree=zdegree_u+1) - u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w))) + + u3D = self.velocity_3D(**kwargs) n = firedrake.FacetNormal(mesh) u_n = max_value(0, inner(u3D, n)) diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb new file mode 100644 index 000000000..61ba22f45 --- /dev/null +++ b/notebooks/tutorials/age_model_test.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "6e7a6fbb", + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import firedrake\n", + "import icepack, icepack.models, icepack.plot\n", + "from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "4b5215d6", + "metadata": {}, + "outputs": [], + "source": [ + "Lx, Ly = 1e3, 1e3\n", + "nx, ny = 20, 20\n", + "mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)\n", + "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "6f3d9428", + "metadata": {}, + "outputs": [], + "source": [ + "Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)\n", + "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5)\n", + "Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ded40a3b", + "metadata": {}, + "outputs": [], + "source": [ + "x, y, ζ = firedrake.SpatialCoordinate(mesh)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "9b333544", + "metadata": {}, + "outputs": [], + "source": [ + "b = firedrake.interpolate(firedrake.Constant(0.0), Q)\n", + "s = firedrake.interpolate(firedrake.Constant(1000), Q)\n", + "h = firedrake.interpolate(s - b, Q)\n", + "\n", + "ux = firedrake.Constant(40)\n", + "uy = firedrake.Constant(0)\n", + "uz = firedrake.Constant(20)\n", + "u = firedrake.interpolate(firedrake.as_vector((ux, uy)), V)\n", + "w = firedrake.interpolate(uz,Q3D)\n", + "\n", + "age = firedrake.interpolate(firedrake.Constant(0.0),Q3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "c43e4bbd", + "metadata": {}, + "outputs": [], + "source": [ + "def velocity_3D(**kwargs):\n", + " u = kwargs['velocity']\n", + " h = kwargs['thickness']\n", + " \n", + " Q = h.function_space()\n", + " V = u.function_space()\n", + " mesh = Q.mesh()\n", + " xdegree_u, zdegree_u = u.ufl_element().degree()\n", + " W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])\n", + " w = firedrake.interpolate(uz,W)\n", + " V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1)\n", + " u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w)))\n", + " \n", + " return u3D" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "679e063f", + "metadata": {}, + "outputs": [], + "source": [ + "age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D)\n", + "age_solver = icepack.solvers.AgeSolver(age_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "32dae83c", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 100/100 [00:29<00:00, 3.44it/s]\n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "num_years = 20.0\n", + "timesteps_per_year = 5.0\n", + "\n", + "δt = 1.0 / timesteps_per_year\n", + "num_timesteps = int(num_years * timesteps_per_year)\n", + "\n", + "for step in tqdm.trange(num_timesteps):\n", + " age = age_solver.solve(δt,velocity=u,thickness=h,age=age)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "5652b157", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = icepack.plot.subplots()\n", + "colors = icepack.plot.tripcolor(u, axes=axes, cmap='RdBu', vmin=0, vmax=50)\n", + "fig.colorbar(colors, label='meters/year', fraction=0.012, pad=0.04);" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "4aae38a9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n", + "ss = np.array(s.at(xs, tolerance=1e-10))\n", + "hs = np.array(h.at(xs, tolerance=1e-10))\n", + "bs = np.array(b.at(xs, tolerance=1e-10))\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.plot(xs[:, 0], bs, color='black')\n", + "axes.plot(xs[:, 0], ss - hs, color='blue')\n", + "axes.plot(xs[:, 0], ss, color='blue')\n", + "plt.show(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "3d5b6949", + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.collections import LineCollection\n", + "from matplotlib.colors import ListedColormap, BoundaryNorm\n", + "\n", + "nz=20\n", + "\n", + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", + "wM= np.array(w.at(xz, tolerance=1e-10))\n", + "wM=np.reshape(wM,(21,nz));\n", + "xz=np.reshape(xz,(21,nz,3));\n", + "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", + "hz=np.multiply(xz[:,:,2],hz);" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "40c7a3d9", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(0, 50)\n", + " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(wM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'vertical velocity.$(m\\dota^{-1})$')\n", + "axs.set_ylabel('elevation.(m)')\n", + "axs.set_xlabel('distance.(km)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "71b1bb97", + "metadata": {}, + "outputs": [], + "source": [ + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0,1.0,1.0/nz)])\n", + "ageM= np.array(age.at(xz, tolerance=1e-10))\n", + "ageM=np.reshape(ageM,(21,nz));\n", + "xz=np.reshape(xz,(21,nz,3));" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "a6b3b892", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(-30,30)\n", + " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'age $(years)$')\n", + "axs.set_ylabel('elevation (m)')\n", + "axs.set_xlabel('distance (m)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "55c71de1", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "firedrake", + "language": "python", + "name": "firedrake" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} From 3d1a918c830cf8f571a95109001c6c50d3129192 Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Wed, 2 Jun 2021 08:27:35 -0700 Subject: [PATCH 09/14] numerical part of the age model test is working --- icepack/models/age_transport.py | 6 +- icepack/solvers/age_solver.py | 5 +- notebooks/tutorials/age_model_test.ipynb | 233 +++++++++++++++++++++-- 3 files changed, 221 insertions(+), 23 deletions(-) diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py index 22180c597..59efdff2f 100644 --- a/icepack/models/age_transport.py +++ b/icepack/models/age_transport.py @@ -15,7 +15,7 @@ import firedrake from firedrake import ( - inner, grad, div, dx, ds, ds_t, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional + inner, grad, div, dx, ds, ds_t, ds_b, ds_tb, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional ) from icepack.constants import year from icepack.utilities import eigenvalues, vertical_velocity, get_kwargs_alt, add_kwarg_wrapper @@ -52,6 +52,8 @@ def flux(self, **kwargs): keys_alt = ('h','u','age') h, u, q = get_kwargs_alt(kwargs, keys, keys_alt) + u3D = self.velocity_3D(**kwargs) + Q = h.function_space() U = q.function_space() mesh = Q.mesh() @@ -63,7 +65,7 @@ def flux(self, **kwargs): degree = (xdegree_u + degree_h, 2 * zdegree_u + 1) metadata = {'quadrature_degree': degree} ice_front_ids = tuple(kwargs.pop('ice_front_ids', ())) - ds_terminus = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) + #ds_terminus = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) u3D = self.velocity_3D(**kwargs) diff --git a/icepack/solvers/age_solver.py b/icepack/solvers/age_solver.py index e4f4ccad0..bd6e16db3 100644 --- a/icepack/solvers/age_solver.py +++ b/icepack/solvers/age_solver.py @@ -28,7 +28,7 @@ def __init__(self, model): self._fields = {} @property def model(self): - r"""The heat transport model that this object solves""" + r"""The age transport model that this object solves""" return self._model @property def fields(self): @@ -83,6 +83,7 @@ def _setup(self, **kwargs): self._stages = [q1, q2] self._age_change = dq self._timestep = dt + self.flux = flux def solve(self, dt, **kwargs): if not hasattr(self, '_solvers'): @@ -108,7 +109,7 @@ def solve(self, dt, **kwargs): max_age = firedrake.Constant(self.model.max_age) q.project(min_value(max_value(q + firedrake.Constant(δt), firedrake.Constant(0.0)), max_age)) - return q.copy(deepcopy=True) + return q.copy(deepcopy=True), self.flux diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb index 61ba22f45..731db7ea1 100644 --- a/notebooks/tutorials/age_model_test.ipynb +++ b/notebooks/tutorials/age_model_test.ipynb @@ -62,9 +62,9 @@ "\n", "ux = firedrake.Constant(40)\n", "uy = firedrake.Constant(0)\n", - "uz = firedrake.Constant(20)\n", + "uz = firedrake.Constant(-40)\n", "u = firedrake.interpolate(firedrake.as_vector((ux, uy)), V)\n", - "w = firedrake.interpolate(uz,Q3D)\n", + "w = firedrake.interpolate(uz/h,Q3D)\n", "\n", "age = firedrake.interpolate(firedrake.Constant(0.0),Q3D)" ] @@ -79,13 +79,14 @@ "def velocity_3D(**kwargs):\n", " u = kwargs['velocity']\n", " h = kwargs['thickness']\n", + " uz = kwargs['uz']\n", " \n", " Q = h.function_space()\n", " V = u.function_space()\n", " mesh = Q.mesh()\n", " xdegree_u, zdegree_u = u.ufl_element().degree()\n", " W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])\n", - " w = firedrake.interpolate(uz,W)\n", + " w = firedrake.interpolate(uz/h,W)\n", " V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1)\n", " u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w)))\n", " \n", @@ -95,6 +96,16 @@ { "cell_type": "code", "execution_count": 7, + "id": "8061ed45", + "metadata": {}, + "outputs": [], + "source": [ + "u3D = velocity_3D(velocity=u, thickness=h, uz=uz)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "id": "679e063f", "metadata": {}, "outputs": [], @@ -105,7 +116,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "32dae83c", "metadata": {}, "outputs": [ @@ -113,26 +124,26 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 100/100 [00:29<00:00, 3.44it/s]\n" + "100%|██████████| 150/150 [00:47<00:00, 3.15it/s]\n" ] } ], "source": [ "import tqdm\n", "\n", - "num_years = 20.0\n", + "num_years = 30.0\n", "timesteps_per_year = 5.0\n", "\n", "δt = 1.0 / timesteps_per_year\n", "num_timesteps = int(num_years * timesteps_per_year)\n", "\n", "for step in tqdm.trange(num_timesteps):\n", - " age = age_solver.solve(δt,velocity=u,thickness=h,age=age)" + " (age, flux) = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "5652b157", "metadata": {}, "outputs": [ @@ -157,7 +168,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "4aae38a9", "metadata": {}, "outputs": [ @@ -190,7 +201,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "3d5b6949", "metadata": {}, "outputs": [], @@ -202,7 +213,7 @@ "nz=20\n", "\n", "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", - "wM= np.array(w.at(xz, tolerance=1e-10))\n", + "wM= np.array(firedrake.interpolate(w*h,Q3D).at(xz, tolerance=1e-10))\n", "wM=np.reshape(wM,(21,nz));\n", "xz=np.reshape(xz,(21,nz,3));\n", "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", @@ -211,13 +222,13 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "40c7a3d9", "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEKCAYAAADjDHn2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAjMUlEQVR4nO3de7QcZZ3u8e+zkxAUA0lAYoYwBwSWDDrc3NyEOcNNBHQAHeSIKMhhzDmKDl5GAS8DooxyRBEUWWQACYrcQVioMICAgw6RhEsICUjAQZIBIrfIiECS/Tt/1NtJs9m7u7q6d3V15/msVau73q5+q2p3Vv3y3hURmJmZNTLQ7QswM7Pqc7AwM7OmHCzMzKwpBwszM2vKwcLMzJpysDAzs6bGLFhIukDSMkkL6tKmSrpJ0sPpdUpKl6SzJC2WNF/SjnXfOSod/7Cko8bqes3MqkLSf0q6X9K9kuamtBGfn2UZy5LFhcD+w9JOAG6JiK2AW9I+wAHAVmmbCZwD2R8HOAnYBdgZOKnsP5CZWZfsFRHbR8Rg2h/t+VmKMQsWEfFL4NlhyQcDs9P72cAhdekXReZOYLKk6cC7gJsi4tmIeA64idcGIDOztcFoz89SjC/zZMC0iHgivX8SmJbebwI8XnfckpQ2WvprSJpJViphwykbvH2zTaZ38LLNrF/NW/Dg0xHxxnbyGFh/RrDypVzHxp+feQCoP3hWRMwafhjwb5ICODd9PtrzsxRlB4vVIiLSH6JT+c0CZgEMDg7G3LlzO5W1mfUxSY+1ncmql5nwV+/Ndegrd5/3Ul3V0mj2iIilkjYGbpL0YP2HnX5+5lF2b6inUvUS6XVZSl8KbFp33IyUNlq6mVmlaGBcri2PiFiaXpcB15C12Y72/CxF2cHiOqDWo+ko4Nq69CNTr6hdgeWpuHUjsJ+kKalhe7+UZmZWIepYsJC0nqRJtfdkz70FjP78LMWYVUNJugTYE9hI0hKyXk3fAC6XdAzwGHBYOvxnwIHAYuBF4GiAiHhW0leBu9Jxp0TE8EZzM7PuknKXGnKYBlwjCbJn9I8j4gZJdzHy87MUYxYsIuLwUT7aZ4RjAzh2lHwuAC7o4KWZmXWUJMZNWKcjeUXEo8B2I6Q/wwjPz7J0rYHbzKyfdLBkUUkOFmZm7epsNVQlOViYmbVJgAb6e6o9Bwszs7a5ZNGbXv4TQ4vv7PZVmNnawtVQZmbWlMRAh3pDVVV/BouJ6zGw5a7dvgozW0tkbRYuWZiZWSOuhjIzs+bEgIOFmZk1JFdDmZlZE0IMjHcDt5mZNeI2CzMza87BwszMmhFonIOFmZk1IJcsepSn+zCzMrnNwszM8hg3vr8fp/15d57uw8xKJAkNqNuXMab6M1iYmZUsrZndtxwszMw6YMAlCzMza0i4GsrMzBrLpih3sDAzs0Ykxo3zGtxmZtaESxZmZtaQ5AZuMzPLQf1dC9WnwcLTfZhZyTzOwszMGpLEuPH9XbToz2Dh6T7MrGRu4DYzs8YEA66GMjOzRjwoz8zMcvCss2Zm1ozHWZiZWTMCBsY5WJiZWSNrQcmiKx2DJX1a0gOSFki6RNK6kjaXNEfSYkmXSVonHTsx7S9On2/WjWs2M2tEA8q15cpLGifpHknXp/0Rn49lKj1YSNoE+EdgMCLeBowDPgCcBpwREVsCzwHHpK8cAzyX0s9Ix5mZVYiypVVzbDkdByyq2x/t+ViablVDjQdeJ2kF8HrgCWBv4IPp89nAycA5wMHpPcCVwPckKSJi1Nw93YeZlaiTEwlKmgG8GzgV+IyyCDPa87E0pZcsImIpcDrwe7IgsRyYBzwfESvTYUuATdL7TYDH03dXpuM3HJ6vpJmS5kqaO7Z3YGb2Wi1UQ21Ue1albeawrL4DfB4YSvsbMvrzsTSllywkTSErLWwOPA9cAezfbr4RMQuYBTA4OBie7sPMyiLBOvnnhno6IgZHzkfvAZZFxDxJe3bo8jqiG9VQ+wK/i4g/AEi6GtgdmCxpfIqeM4Cl6filwKbAEknjgQ2AZ8q/bDOzkQkxrjPVULsDB0k6EFgXWB84k9Gfj6XpRm+o3wO7Snp9qovbB1gI3Aocmo45Crg2vb8u7ZM+/0XD9gozs7IJxg0o19ZIRJwYETMiYjOyjj+/iIgjGP35WJputFnMIWuovhu4P13DLOB4ssacxWR1dOenr5wPbJjSPwOcUPY1m5k1IjoTLBoY7flYmq70hoqIk4CThiU/Cuw8wrEvAe8v47rMzIqQYHyHB+VFxG3Aben9iM/HMnkEt5lZmyS10sDdkxwszMzalFVDOViYmVkTHeoNNSYkrQe8FBGriubhYGFm1iapWsFC0gBZb6ojgJ2Al4GJkp4GfgqcGxGLW8mzP4OFp/swsxJ1cJxFp9wK3AycCCyIiCEASVOBvYDTJF0TET/Km2F/Bgszs5KNq9Ya3PtGxIrhiRHxLHAVcJWkCa1k2J/BYuJ6eLoPMytLi9N9jLmRAkWRY+pV5+7MzHpUbZxFnq38a9PxncinP0sWZmYlqlKbhaTL63eB7enAOkAOFmZmHVCVYAH8MSL+obYjqSPrXjhYmJm1qWJdZ08dtv/FTmTqYGFm1qbaRIJVEBG/A5C0UUQ8nXpAtc3BwsysTRWdG+oC4KBOZeZgYWbWAVUpWdTp6AU5WJiZtalibRY1HV0krj+Dhaf7MLMSVanNoo5LFmZmlVLNksWJncysP4OFp/swsxIJMaFi61lExAJJGwKHAS8BDwD3R8Sfi+TXn8HCzKxEAsZVrmABwDVks89+DPgtsJukRyNi61YzcrAwM2uXYKB61VAAkyLiFEnvi4i/lfT3wHZFMqpWucnMrAdlJQvl2sb8WqQ76nZfSq8vS3pdRFwF7FckX5cszMw6YKAi61lExB51u6enBY8uAy6Q9GtgcpF8HSzMzNpU1TaLVJIA+LakI4G3Ae8rkpeDhZlZmyQxflw1a/UlTYiIFRFxUTv5OFiYmXVAFUsWks4D3i1pJfBfwHxgfkR8t9W8+jNYeAS3mZVIVKfNYpi/AWZExCpJm5D1hNq2SEb9GSzMzMpUzRHcAHOADYFlEbEUWAr8rEhG/RksPILbzEpU4ZLFucDtks4nCxzzI2J5kYxaChaS1gNeiohVRU5mZtavqthmAfwImEX2rP84sK2kdSNii1YzahgsJA0AHwCOAHYCXgYmSnoa+ClwbkQsbvWkZmb9RBITqtkbaklEfL0+QdLEIhk1u7tbgS3IZi98U0RsGhEbA3sAdwKnSfpQkRObmfWLrBoq31ayeyUdV58QES8XyahZNdS+EbFieGJa0/Uq4CpJE4qc2Mysn5QxlUcB04B9JR0P3A3cB9wbEVe0mlHDYFEfKCRNATat/05E3D1SMDEzW5tUtYE7Ig6D1VVPbwX+GtgF6GywqJH0VeAjwCOsWaovgL1bPaGZWd8RVKnJQpIiYvWyqqnq6e60jXhMM3lv7zBgi4jYMyL2SlvhQCFpsqQrJT0oaZGk3SRNlXSTpIfT65R0rCSdJWmxpPmSdix6XjOzsVBb/CjP1jQvaV1Jv5F0n6QHJH0lpW8uaU56Fl4maZ0G2dwq6ZOS/nJY3utI2lvSbOCoVu4xb7BYQMGZCkdxJnBDWoBjO2ARcAJwS0RsBdyS9gEOALZK20zgnA5eh5lZ22rVUHm2HF4G9o6I7YDtgf0l7QqcBpwREVsCzwHHNMhjf2AVcImk/5K0UNKjwMPA4cB3IuLCVu4x7ziLrwP3SFqQbgSAiDiolZMBSNoA+J9k1VpExCvAK5IOBvZMh80GbgOOBw4GLkrFpTtTqWR6RDwx6kk83YeZlamD1VDpWfffaXdC2mrV/h9M6bOBkxnlP88R8RLwfeD7qRPSRsCfI+L5oteVN1jMJotq9wNDRU+WbA78AfiBpO2AecBxwLS6APAkWSs+wCbA43XfX5LSXhUsJM0kK3nw9re1vGKgmVlhLTZwbyRpbt3+rIiY9ar8pHFkz8YtgbPJ2oufj4iV6ZDac7Cp1Alp9fNS0psi4sm8F1uTN1i8GBFntZp5g3PuCHwyIuZIOpM1VU5AFlkl5W54Sd+ZRTZSkcHBwfB0H2ZWphY6Qz0dEYONDkizZGwvaTLZOtqd/B/w+cC7W/1S3oLTv0v6emqI3rG2tXqyZAnZqMI5af9KsuDxlKTpAOl1Wfp8KVmX3ZoZKc3MrDIGUK6tFana6FZgN2CypNp/8As/ByOi5UAB+YPFDsCuwL8A30rb6UVOmIo/j0t6S0raB1gIXMea1vmjgGvT++uAI1OvqF2B5Q3bK8zMSiayNos8W9O8pDemEgWSXge8k6wT0K3Aoemw+mdko7w+WetZ2q5c1VARsVcnTlbnk8DFqevXo8DRZIHrcknHAI+RddeFbDrdA4HFwIvpWDOz6lBL1VDNTAdmp3aLAeDyiLhe0kLgUklfA+4hq05qZhpwl6S7gQuAG1sZW1Gv2USCHwJ+HBEjNmpL2gKYHhF3tHLSiLgXGKnObp8Rjg3g2FbyNzMrkwpUMY0mIuaT1eYMT38U2LnFvL4k6cvAfmT/0f6epMuB8yPikVbyalay2JCsy+w8spb5PwDrkrXQ/y3wNMMap83M1kYVnO0DWN1h6EmyXqYrgSnAlZJuiojP582n2dxQZ0r6Hln/3t3JluP7M1n92Ycj4vdFb8DMrJ9UcaG8NOPskWT/sT8P+FxErEjLTzwMdCZYwOouXDelzczMhhGVnXV2KvC+iHisPjEihiS9p5WMCo85bPVEZmb9TMq3lWzd4YFC0mkAEbGolYzaWYN7J+D6Nr4/djzdh5mVrEKTztZ7J9m0SfUOGCGtqcLBIiJOKvpdM7N+kpUaqlMNJeljZGtuv1nS/LqPJgG/KpJn7mAh6R3AZrx68aOLipx0zE1cD0/3YWZlqlgD94+Bn5NNAlvfY/WFtNJpy/IufvRDsrW47yWb9hayWRCrGSzMzEpWoYIFEbEcWE42HXlH5C1ZDALbFB35Z2bWz6rWG0rSHRGxh6QXWLO6KWSXGhGxfqt55g0WC4A3MWxacDMzA1StaqiI2CO9TupUnnkb8DcCFkq6UdJ1ta1TF2Fm1uuUcyv1mqTZtUkJ0/4USRcUyStvyeLkIpmbma0NssWPun0VI9q2fnW8iHhO0mvmncoj76yzt0uaRja2AuA3EbGs0XfMzNYmVeo6W2dA0pSIeA5A0lQKDpnI2xvqMOCbZOtiC/iupM9FxJVFTmpm1k8qXLL4FvAfkq4gu8xDgVOLZJQ3wnwR2KlWmpD0RuBmslXuzMzWcqpUb6iaiLgorfe9N1mvqPdFxMIieeUNFgPDqp2eobKj2/F0H2ZWru7M+5TXBNa0rU8omkneB/4NqSfURyR9BPgp2Qp2ZmZrPUXk3kq9rmyK8ovJerRuDPxI0ieL5JW3gftzkv6ebE0LgFkRcU2RE5bC032YWdlGXlC0244BdomIP8HqGWf/A/huqxnlbhWPiKuAq1o9gZnZ2kDVDBZizRRNpPeFKsyarcHd8SHjZmb9J2BoVfPDyvcDYI6kWk3QIcD5RTJqtqxqx4eMm5n1nYhKVkNFxLcl3c6aJoSjI+KeInnlnnU2Ij7cLM3MbG1V0WooImIeMK/dfPK2Wby1fkfSeODt7Z7czKxvVChYDGs60PD3HZ91VtKJwBeA10n6Y93JXgFmtXoyM7P+VK1qqLFoOmg4ziIivp5O+s2IWD9tkyJiw4g4sdMXY2bWk4IsWOTZSqTMhyR9Oe1vKmnnInnlHWdxoqQpwFbAunXpvyxyUjOz/hJo1cpuX8RIvg8MkU338VXgv4GzWTMpbG55G7j/ATgOmEG2tOquZAM79m71hKXwdB9mVrYKVUPV2SUidpR0D6yeonydIhnlne7jOLJI9FhE7AXsADxf5IRmZn0nIv9WrhWSxpEauNMksIWiWt7eUC9FxEuSkDQxIh6U9JYiJyyFp/sws7JVs2RxFnANsLGkU8mmKP9SkYzyBoslaWm+nwA3SXoOeKzICc3M+lEVx1lExMWS5gH7kPVkPSQiFhXJK28D93vT25Ml3QpsANxQ5IRmZv2nWl1nayR9BrgsIs5uN6+8DdxnAZdGxK8j4vZ2T2pm1lciYKiSvaEmAf8m6VngMuCKiHiqSEZ5G7jnAV+S9Iik0yUNFjmZmVk/Elk1VJ6tTBHxlYh4K3AsMB24XdLNRfLKFSwiYnZEHEjWI+oh4DRJDxc5oZlZXxoayrd1xzLgSbJVTjcukkGrS6NuCWwN/A/gwSInNDPrP9XsOivp45JuA24BNgQ+GhHbFskrV7CQ9P9SSeIU4H5gMCL+rsgJ6/IcJ+keSden/c0lzZG0WNJltYEjkiam/cXp883aOa+ZWcd1cLqPNCXHrZIWSnogLY2KpKmSbpL0cHqdkuPKNgU+FRFvjYiTI2Jh0VvMW7J4BNgtIvaPiAsj4vmiJ6xzHFDfhes04IyI2BJ4jmw5QNLrcyn9jHScmVmFBBpamWvLYSXw2YjYhmy2jGMlbQOcANwSEVuRlRROaHpVESdGxL3F72uNvOMs/hX4oKQ3R8Qpkv4SeFNE/KbISSXNAN4NnAp8RpLIpg75YDpkNnAycA5wcHoPcCXwPUmKaFCe83QfZla2DjVeR8QTwBPp/QuSFgGbkD0L90yHzQZuA47vyElzyFuyOBvYDTg87b+Q0or6DvB51gw73xB4PiJqYXcJ2R+H9Po4QPp8eTr+VSTNlDRX0tw2rsvMrHWRllXNs8FGtWdV2maOlm2qdt8BmANMS4EEssbqaWN9W/Xyliw6NhmVpPcAyyJinqQ9i+QxkoiYRVpjY3BwMDzdh5mVKfL3dHo6IpoOP5D0BuAqsjaHP2YVMOlcESGp1NbyvMGiY5NRka0Fe5CkA8mmO18fOBOYLGl8Kj3MAJam45eSNdIsSSv0bUDW/cvMrCKiVmroCEkTyALFxRFxdUp+StL0iHhC0nSy7rCjfb9+pbxXfUTBlfLyVkMNn4zqDuBfWj0ZrG5wmRERmwEfAH4REUcAt5JNcgVwFHBten9d2id9/ouG7RVmZmULWqmGaii14Z4PLIqIb9d9VP8srH9GvvZyskXq1h9hm1QkUED+uaE6NhlVA8cDl0r6GnAP2R+L9PpDSYuBZ8kCjJlZZUQEsWJFp7LbHfgwcL+ke1PaF4BvAJdLOoZsItfD8mTWqYXrmq3BPbVudxlwSf1nEfFsqyesFxG3kbXoExGPAq9Z7i8iXgLe3855zMzGVueqoSLiDrL/lI9kn1by6uTCdc1KFvPIClji1fVftf03t3pCM7O+E0F0sM2ig2oL190ZEXtJ2pqCTQgNg0VEbA4gaQA4Ati8bpzF9CInNDPrS92b96mRji1cl7c31NmsWfT7FLJxFldRYNFvM7P+U9mSRccWrit9nIWZWd+p9YaqmE4uXNeNcRZjz9N9mFmZOtsbaky0u3Bd6eMszMz6T0vTfZRG0uxUDVXbnyLpgiJ5VWmcRedMXA9P92FmpYnOjuDuoG3rZwlPTQg7FMkobzUUEfEgXvDIzGxELcwNVaYBSVMi4jlYPXYu93O/XqEvmZlZvcqWLL4F3CnpcrJaoUMZi3EWZmbWXEQQK6vXwB0RF6VlG/ZKSe8t2oTgYGFm1q6KdZ2VdEdE7FE3+6zqPis066yDhZlZ26pVDRURe6TXSZ3KM2/XWTMzG01ArFqVayuTpNPypOXhYGFm1rbI5obKs5XrnSOkHVAkI1dDmZl1QoWqoSR9DPg4sIWk+XUfTQJ+VSTP/gwWnu7DzMoUwVC1ekP9GLgROA84ui79haLrEPVnsDAzK1MEsao6g/IiYjmwXNLGEVFoltnh+jNYeLoPMytRBJUKFnXmSdopIu5qN6P+DBZmZqWKqk73sQtwhKTHgD+RVjmNiG1bzcjBwsysXdUtWbyrUxk5WJiZtSkiWPVKpRq4AehUewV4nIWZWUfE0FCurUzKfEjSP6f9v5S0c5G8HCzMzNqVekPl2Ur2fWA34PC0/wJwdpGMXA1lZtYBFW2z2CUidpR0D6xe/GidIhk5WJiZtSmisr2hVkgaRzbzLJLeCBS60P4MFh7BbWYlG6pmyeIs4BpgmqRTyRY/+lKRjPozWJiZlWkoGHplZbevYiTTgNOA7cnGWBzixY/qeQS3mZUoqOwa3JOAWcCzwGXptRD3hjIza1dFe0NFxFci4q3AscB04HZJNxfJqz9LFmZmJatob6iaZcCTwDPAxkUycLAwM2tXwFAFq6EkfRw4DHgjcAXw0YhYWCQvBwszszYF1ZqivM6mwKci4t52M3KwMDNrVwRDKyo5N9SJncrLwcLMrF3VnXW2Y0rvDSVpU0m3Sloo6QFJx6X0qZJukvRwep2S0iXpLEmLJc2XtGPZ12xm1ljnekNJukDSMkkL6tJGfD6WqRtdZ1cCn42IbYBdgWMlbQOcANwSEVsBt6R9gAOArdI2Ezin/Es2MxtdRDaCO8+Ww4XA/sPSRns+lqb0aqiIeAJ4Ir1/QdIiYBPgYGDPdNhs4Dbg+JR+UUQEcKekyZKmp3xG5uk+zKxUnZsbKiJ+KWmzYcmjPR9L09VBeekPsgMwB5hWFwCeJBumDlkgebzua0tS2vC8ZkqaK2nu2F2xmdkIhmDolVW5NmCj2rMqbTNznGG052NputbALekNwFVk3br+KGn1ZxERkqKV/CJiFtmwdgYHB8PTfZhZWYJoZSLBpyNisPC5CjwfO6ErJQtJE8gCxcURcXVKfkrS9PT5dLIRhwBLyfoK18xIaWZm1RAQQ5FrK2i052NputEbSsD5wKKI+HbdR9cBR6X3RwHX1qUfmXpF7Qosb9heYWbWBUOrItdW0GjPx9J0oxpqd+DDwP2S7k1pXwC+AVwu6RjgMbIh6gA/Aw4EFgMvAkeXerVmZk1EB8dZSLqErDF7I0lLgJMY/flYmm70hrqDbF71kewzwvFBNmOimVk1RRDFSw3DsorDR/noNc/HMnkEt5lZuwJWZT2d+paDhZlZmwIYKt543RMcLMzM2tXBaqiqcrAwM+uAFsZZ9KT+DBae7sPMSpT1hnLJwszMGnGw6FET18PTfZhZaSJYtcK9oczMrIGAdkZn9wQHCzOzdkVl1+DuGAcLM7MOcJuFmZk1lK2U52BhZmaNuIHbzMyactdZMzNrJujcFOVV5WBhZtYut1n0KE/3YWal8kSCZmbWRAQMhYNF7/F0H2ZWogBe8XoWZmbWzCqXLMzMrJEA+rzJwsHCzKxdES5ZmJlZDi5ZmJlZQ0G4ZGFmZo1lvaG6fRVjy8HCzKxNbrMwM7Nc3GbRizzdh5mVKOs629/Roj+DhZlZiTzOold5ug8zK1GEp/swM7McXA1lZmYNBdDnPWcdLMzM2udBeWZm1oQbuM3MrCl3nTUzs6bWht5QA92+gLwk7S/pIUmLJZ3Q7esxM6u3KvJtzVT1WdcTwULSOOBs4ABgG+BwSdt096rMzDK1aqg8WyNVftb1SjXUzsDiiHgUQNKlwMHAwpEOfuihh9hzzz3LuzozW6t1sIG7pWddmXolWGwCPF63vwTYpf4ASTOBmWn35dtvv31BSddWpo2Ap7t9ER3Wj/cEvq9e8pZ2M3iaV248l8c2ynn4upLm1u3PiohZ6X3TZ1239EqwaCr9sWcBSJobEYNdvqSO68f76sd7At9XLxn24C4kIvbvxLVUWU+0WQBLgU3r9mekNDOzflLZZ12vBIu7gK0kbS5pHeADwHVdviYzs06r7LOuJ6qhImKlpE8ANwLjgAsi4oEGX5nV4LNe1o/31Y/3BL6vXlKZeyrwrCuNos9HHZqZWft6pRrKzMy6yMHCzMya6rtgUdWh8s1I2lTSrZIWSnpA0nEpfaqkmyQ9nF6npHRJOivd53xJO3b3DhqTNE7SPZKuT/ubS5qTrv+y1JiHpIlpf3H6fLOuXvgoJE2WdKWkByUtkrRbP/xWkj6d/v0tkHSJpHV78beSdIGkZZIW1KW1/PtIOiod/7Cko7pxL1XRV8GiykPlc1gJfDYitgF2BY5N134CcEtEbAXckvYhu8et0jYTOKf8S27JccCiuv3TgDMiYkvgOeCYlH4M8FxKPyMdV0VnAjdExNbAdmT31tO/laRNgH8EBiPibWQNrB+gN3+rC4HhYx9a+n0kTQVOIhsUtzNwUi3ArJUiom82YDfgxrr9E4ETu31dBe/lWuCdwEPA9JQ2HXgovT8XOLzu+NXHVW0j6yt+C7A3cD0gslHA44f/bmS9QHZL78en49Ttexh2PxsAvxt+Xb3+W7Fm9PDU9Le/HnhXr/5WwGbAgqK/D3A4cG5d+quOW9u2vipZMPJQ+U26dC2FpeL8DsAcYFpEPJE+ehKYlt730r1+B/g8a1ae3BB4PiJWpv36a199X+nz5en4Ktkc+APwg1S1dp6k9ejx3yoilgKnA78HniD728+jt3+req3+Pj3xu5Wl34JFz5P0BuAq4FMR8cf6zyL7701P9XWW9B5gWUTM6/a1dNB4YEfgnIjYAfgTa6o0gJ79raaQTVq3OfAXwHq8tiqnL/Ti79Nt/RYsKjtUPg9JE8gCxcURcXVKfkrS9PT5dGBZSu+Ve90dOEjSfwKXklVFnQlMllQbFFp/7avvK32+AfBMmRecwxJgSUTMSftXkgWPXv+t9gV+FxF/iIgVwNVkv18v/1b1Wv19euV3K0W/BYvKDpVvRpKA84FFEfHtuo+uA2q9MI4ia8uopR+ZenLsCiyvK2JXRkScGBEzImIzst/jFxFxBHArcGg6bPh91e730HR8pf4HGBFPAo9Lqs1Wug/ZFNI9/VuRVT/tKun16d9j7b569rcaptXf50ZgP0lTUqlrv5S2dup2o0mnN+BA4LfAI8AXu309LVz3HmTF4vnAvWk7kKwO+BbgYeBmYGo6XmQ9vx4B7ifrwdL1+2hyj3sC16f3bwZ+AywGrgAmpvR10/7i9Pmbu33do9zL9sDc9Hv9BJjSD78V8BXgQWAB8ENgYi/+VsAlZO0uK8hKgscU+X2A/53ubzFwdLfvq5ubp/swM7Om+q0ayszMxoCDhZmZNeVgYWZmTTlYmJlZUw4WZmbWlIOFlU7SyZL+SdIpkvZtcNwh3ZwIUtIOks5P70+W9E8F81lH0i/rBraZ9RwHC+uaiPjniLi5wSGHkM0e3C1fAM5qN5OIeIWsf///avuKzLrEwcJKIemLkn4r6Q7gLSntQkmHpvffULaWx3xJp0t6B3AQ8E1J90raQtJHJd0l6T5JV0l6fV0+Z0n6taRHa3mmz46XdH/6zjdS2haSbpA0T9K/S9p6hOudBGwbEfeN8NlHJf1c0usk3SbpDElzla1rsZOkq9P6B1+r+9pPgCM69gc1K5mLxTbmJL2dbKqP7cn+zd1NNptp7fMNgfcCW0dESJocEc9Luo5sxPeV6bjnI+Jf0/uvkY3K/W7KZjrZKPityaZvuFLSAWQT4+0SES+m9QkAZgH/NyIelrQL8H2yOavqDZKNYh5+L58gmzr+kIh4OZsVg1ciYlDZglXXAm8HngUekXRGRDyT8tqpyN/PrAocLKwMfwNcExEvAqQgUG858BJwvrKV9K4fJZ+3pSAxGXgDr56n5ycRMQQslFSbenpf4Ae180bEs2lW33cAV6QHPWRTWgw3nWwa8npHkk1ZfUhkE+3V1O7nfuCBSPM+SXqUbCK6ZyJilaRXJE2KiBdGuT+zynI1lHVdZGsh7Ew2e+t7gBtGOfRC4BMR8ddkcxitW/fZy3XvxegGyNZn2L5u+6sRjvvzsPwhCwabkc0+Wq927qFh1zHEq/9DNpEsKJr1HAcLK8MvgUNSHf8k4O/qP0z/298gIn4GfJpsmVKAF4BJdYdOAp5IU7nnqf+/CTi6rm1jamRrhPxO0vtTmiRtN8J3FwFbDku7B/g/wHWS/iLH+VdLVW1PDyuRmPUMBwsbcxFxN3AZcB/wc7Kp5OtNAq6XNB+4A/hMSr8U+Jyy1ei2AL5Mtnrgr8hmRm123hvIqojmSroXqHV9PQI4RtJ9wANk7RpIOkjSKem7DwIbpOBWn+cdKZ+fStoo9x8B9gJ+2sLxZpXiWWfNRiHp08ALEXFeB/K6GjghIn7b/pWZlc8lC7PRncOr2yAKUbYQ108cKKyXuWRhZmZNuWRhZmZNOViYmVlTDhZmZtaUg4WZmTXlYGFmZk39f6l2CwkIv1CmAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -233,7 +244,7 @@ "for i in range(0,nz):\n", " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(0, 50)\n", + " norm = plt.Normalize(-50, 50)\n", " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", " # Set the values used for colormapping\n", " lc.set_array(np.squeeze(wM[:,nz-1-i]))\n", @@ -250,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "71b1bb97", "metadata": {}, "outputs": [], @@ -263,13 +274,13 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 15, "id": "a6b3b892", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -285,7 +296,7 @@ "for i in range(0,nz):\n", " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(-30,30)\n", + " norm = plt.Normalize(0,30)\n", " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", " # Set the values used for colormapping\n", " lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n", @@ -302,10 +313,194 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, + "id": "7ec04407", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0.09787375, 1.2367177 , 2.6265191 , 3.90240903, 5.05507233,\n", + " 6.24031191, 7.52937117, 8.89573778, 10.24093554, 11.49638515,\n", + " 12.65536187, 13.76622265, 14.90894306, 16.14475458, 17.49079032,\n", + " 18.91334711, 20.33902995, 21.67429064, 22.83778848, 23.77062185,\n", + " 24.45180175])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ageM[:,0]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "3fcc0f39", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([40. , 0. , -0.04])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "u3D.dat.data.mean(0)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, "id": "55c71de1", "metadata": {}, "outputs": [], + "source": [ + "from firedrake import assemble\n", + "foo = assemble(flux)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4365c4a1", + "metadata": {}, + "outputs": [], + "source": [ + "bar = firedrake.interpolate(foo,Q3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "adca38d2", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "nz=20\n", + "\n", + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", + "fM= np.array(bar.at(xz, tolerance=1e-10))\n", + "fM=np.reshape(fM,(21,nz));\n", + "xz=np.reshape(xz,(21,nz,3));\n", + "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", + "hz=np.multiply(xz[:,:,2],hz);\n", + "\n", + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(-1, 1)\n", + " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(fM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'flux.$(?)$')\n", + "axs.set_ylabel('elevation.(m)')\n", + "axs.set_xlabel('distance.(km)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "09052e50", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "nz=20\n", + "\n", + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", + "fM= np.array(u3D.at(xz, tolerance=1e-10))\n", + "fM=np.reshape(fM,(21*3,nz));\n", + "xz=np.reshape(xz,(21,nz,3));\n", + "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", + "hz=np.multiply(xz[:,:,2],hz);\n", + "\n", + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(-.04, .04)\n", + " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(fM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'velocity.$(?)$')\n", + "axs.set_ylabel('elevation.(m)')\n", + "axs.set_xlabel('distance.(km)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "25352614", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "21.0" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1260/20/3" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "84472020", + "metadata": {}, + "outputs": [], "source": [] } ], From b90ed88bf093b0757b8eee006073e7c82b7df2d0 Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Wed, 2 Jun 2021 11:48:37 -0700 Subject: [PATCH 10/14] small bug fixes --- icepack/models/__init__.py | 1 + icepack/models/age_transport.py | 17 +++++++---------- icepack/utilities.py | 19 ------------------- notebooks/tutorials/age_model_test.ipynb | 13 +++++++------ 4 files changed, 15 insertions(+), 35 deletions(-) diff --git a/icepack/models/__init__.py b/icepack/models/__init__.py index 74bcd14cb..dcfee05de 100644 --- a/icepack/models/__init__.py +++ b/icepack/models/__init__.py @@ -16,6 +16,7 @@ from icepack.models.damage_transport import DamageTransport from icepack.models.heat_transport import HeatTransport3D from icepack.models.shallow_ice import ShallowIce +from icepack.models.age_transport import AgeTransport __all__ = [ "IceShelf", diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py index 59efdff2f..45b6e41a2 100644 --- a/icepack/models/age_transport.py +++ b/icepack/models/age_transport.py @@ -13,17 +13,16 @@ r"""Description of the age transport model. """ +from operator import itemgetter import firedrake from firedrake import ( inner, grad, div, dx, ds, ds_t, ds_b, ds_tb, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional ) from icepack.constants import year -from icepack.utilities import eigenvalues, vertical_velocity, get_kwargs_alt, add_kwarg_wrapper +from icepack.utilities import eigenvalues, vertical_velocity, add_kwarg_wrapper def velocity_3D(**kwargs): - keys = ('thickness', 'velocity') - keys_alt = ('h','u') - h, u = get_kwargs_alt(kwargs, keys, keys_alt) + u, h = itemgetter("velocity", "thickness")(kwargs) Q = h.function_space() V = u.function_space() @@ -48,9 +47,7 @@ def __init__( def flux(self, **kwargs): - keys = ('thickness', 'velocity', 'age') - keys_alt = ('h','u','age') - h, u, q = get_kwargs_alt(kwargs, keys, keys_alt) + u, h, q = itemgetter("velocity", "thickness", "age")(kwargs) u3D = self.velocity_3D(**kwargs) @@ -73,10 +70,10 @@ def flux(self, **kwargs): u_n = max_value(0, inner(u3D, n)) f = q * u_n q_inflow=firedrake.Constant(0.0) - flux_faces_h = (f('+') - f('-')) * (φ('+') - φ('-')) * dS_h + flux_faces_v = (f('+') - f('-')) * (φ('+') - φ('-')) * dS_v flux_cells = -q * div(u3D * φ) * dx #flux_terminus = q * max_value(0, inner(u3D, n)) * φ * ds_terminus #flux_surface = q_inflow * min_value(0, inner(u3D, n)) * φ * ds_t - flux_h = q * max_value(0, inner(u3D, n)) * φ * ds_h + #flux_h = q * max_value(0, inner(u3D, n)) * φ * ds_h flux_tb = q * max_value(0, inner(u3D, n)) * φ * ds_tb - return flux_cells + flux_faces_v + flux_h + flux_tb + return flux_cells + flux_faces_v + flux_tb diff --git a/icepack/utilities.py b/icepack/utilities.py index 1d5483d5b..7bb655faa 100644 --- a/icepack/utilities.py +++ b/icepack/utilities.py @@ -128,25 +128,6 @@ def lift3d(q2d, Q3D): return q3d -def add_kwarg_wrapper(func): - signature = inspect.signature(func) - if any( - str(signature.parameters[param].kind) == "VAR_KEYWORD" - for param in signature.parameters - ): - return func - - params = signature.parameters - - def wrapper(*args, **kwargs): - kwargs_ = dict((key, kwargs[key]) for key in kwargs if key in params) - return func(*args, **kwargs_) - - return wrapper - - - -@functools.lru_cache(maxsize=None) def vertically_integrate(q,h): r""" q : firedrake.Function diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb index 731db7ea1..be89c52af 100644 --- a/notebooks/tutorials/age_model_test.ipynb +++ b/notebooks/tutorials/age_model_test.ipynb @@ -124,7 +124,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 150/150 [00:47<00:00, 3.15it/s]\n" + "100%|██████████| 150/150 [00:45<00:00, 3.27it/s]\n" ] } ], @@ -320,11 +320,12 @@ { "data": { "text/plain": [ - "array([ 0.09787375, 1.2367177 , 2.6265191 , 3.90240903, 5.05507233,\n", - " 6.24031191, 7.52937117, 8.89573778, 10.24093554, 11.49638515,\n", - " 12.65536187, 13.76622265, 14.90894306, 16.14475458, 17.49079032,\n", - " 18.91334711, 20.33902995, 21.67429064, 22.83778848, 23.77062185,\n", - " 24.45180175])" + "array([9.78737467e-02, 1.23671770e+00, 2.62651910e+00, 3.90240903e+00,\n", + " 5.05507233e+00, 6.24031191e+00, 7.52937117e+00, 8.89573778e+00,\n", + " 1.02409355e+01, 1.14963852e+01, 1.26553619e+01, 1.37662227e+01,\n", + " 1.49089431e+01, 1.61447546e+01, 1.74907903e+01, 1.89133471e+01,\n", + " 2.03390299e+01, 2.16742906e+01, 2.28377885e+01, 2.37706219e+01,\n", + " 1.64428888e+06])" ] }, "execution_count": 16, From 849d9706cb666dc80a40373e00065e0f7fc7ecc1 Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Wed, 2 Jun 2021 16:04:34 -0700 Subject: [PATCH 11/14] added analytical solution to age model test, plus cleanup --- icepack/solvers/age_solver.py | 7 +- notebooks/tutorials/10-age-advection.ipynb | 582 +++++++++++++++++++++ notebooks/tutorials/age_model_test.ipynb | 345 +++--------- 3 files changed, 647 insertions(+), 287 deletions(-) create mode 100644 notebooks/tutorials/10-age-advection.ipynb diff --git a/icepack/solvers/age_solver.py b/icepack/solvers/age_solver.py index bd6e16db3..c178f9e59 100644 --- a/icepack/solvers/age_solver.py +++ b/icepack/solvers/age_solver.py @@ -83,7 +83,6 @@ def _setup(self, **kwargs): self._stages = [q1, q2] self._age_change = dq self._timestep = dt - self.flux = flux def solve(self, dt, **kwargs): if not hasattr(self, '_solvers'): @@ -109,8 +108,4 @@ def solve(self, dt, **kwargs): max_age = firedrake.Constant(self.model.max_age) q.project(min_value(max_value(q + firedrake.Constant(δt), firedrake.Constant(0.0)), max_age)) - return q.copy(deepcopy=True), self.flux - - - - + return q.copy(deepcopy=True) diff --git a/notebooks/tutorials/10-age-advection.ipynb b/notebooks/tutorials/10-age-advection.ipynb new file mode 100644 index 000000000..9e87be36d --- /dev/null +++ b/notebooks/tutorials/10-age-advection.ipynb @@ -0,0 +1,582 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "import matplotlib.pyplot as plt\n", + "import firedrake\n", + "import icepack, icepack.models, icepack.plot\n", + "from icepack.constants import ice_density as ρ_I, water_density as ρ_W" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "Lx, Ly = 50e3, 12e3\n", + "nx, ny = 48, 32\n", + "mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly)\n", + "mesh = firedrake.ExtrudedMesh(mesh2d, layers=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)\n", + "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from icepack.constants import (ice_density as ρ_I, water_density as ρ_W,\n", + " gravity as g)\n", + "\n", + "x, y, ζ = firedrake.SpatialCoordinate(mesh)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "b_in, b_out = 200, -400\n", + "b = firedrake.interpolate(b_in - (b_in - b_out) * x / Lx, Q)\n", + "\n", + "s_in, s_out = 850, 50\n", + "s0 = firedrake.interpolate(s_in - (s_in - s_out) * x / Lx, Q)\n", + "\n", + "h0 = firedrake.interpolate(s0 - b, Q)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "h_in = s_in - b_in\n", + "δs_δx = (s_out - s_in) / Lx\n", + "τ_D = -ρ_I * g * h_in * δs_δx" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "u_in, u_out = 0.0, 2400\n", + "velocity_x = u_in + (u_out - u_in) * (x/Lx)**2\n", + "u0 = firedrake.interpolate(firedrake.as_vector((velocity_x, 0)), V)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "age=firedrake.interpolate(firedrake.Constant(0.0),Q3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "temp = 255.0\n", + "A = firedrake.Constant(icepack.rate_factor(temp))" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "from icepack.constants import weertman_sliding_law as m\n", + "C = firedrake.interpolate((0.95 - 0.40 * firedrake.sin(10*firedrake.pi*x/Lx)) * τ_D / 20.0**(1/m),Q)\n", + "\n", + "p_W = ρ_W * g * firedrake.max_value(0, h0 - s0)\n", + "p_I = ρ_I * g * h0\n", + "ϕ = 1 - p_W / p_I" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "beta = firedrake.interpolate(C,Q)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "import icepack.models.hybrid\n", + "def friction(**kwargs):\n", + " u = kwargs['velocity']\n", + " h = kwargs['thickness']\n", + " s = kwargs['surface']\n", + " C = kwargs['friction']\n", + " \n", + " p_W = ρ_W * g * firedrake.max_value(0, h - s)\n", + " p_I = ρ_I * g * h\n", + " ϕ = 1 - p_W / p_I\n", + " return icepack.models.hybrid.bed_friction(\n", + " velocity=u, \n", + " friction=C * ϕ\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "model = icepack.models.HybridModel(friction=friction)\n", + "opts = {'dirichlet_ids': [1], 'side_wall_ids': [3, 4]}\n", + "solver = icepack.solvers.FlowSolver(model, **opts)\n", + "\n", + "u0 = solver.diagnostic_solve(\n", + " velocity=u0,\n", + " thickness=h0,\n", + " surface=s0,\n", + " fluidity=A,\n", + " friction=C\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "age_model = icepack.models.AgeTransport()\n", + "age_solver = icepack.solvers.AgeSolver(age_model)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import tqdm\n", + "import os\n", + "num_years = 2000\n", + "timesteps_per_year = .2\n", + "\n", + "δt = 1.0 / timesteps_per_year\n", + "num_timesteps = int(num_years * timesteps_per_year)\n", + "\n", + "a = firedrake.interpolate(firedrake.Constant(1.0), Q)\n", + "h = h0.copy(deepcopy=True)\n", + "u = u0.copy(deepcopy=True)\n", + "s = icepack.compute_surface(thickness=h, bed=b)\n", + "\n", + "if not os.path.exists('degree-5.h5'):\n", + " for step in tqdm.trange(num_timesteps):\n", + " h = solver.prognostic_solve(\n", + " δt,\n", + " thickness=h,\n", + " velocity=u,\n", + " accumulation=a,\n", + " thickness_inflow=h0\n", + " )\n", + " s = icepack.compute_surface(thickness=h, bed=b)\n", + " \n", + " u = solver.diagnostic_solve(\n", + " velocity=u,\n", + " thickness=h,\n", + " surface=s,\n", + " fluidity=A,\n", + " friction=C\n", + " )\n", + " \n", + " with firedrake.DumbCheckpoint(\n", + " 'degree-5', mode=firedrake.FILE_CREATE\n", + " ) as checkpoint:\n", + " checkpoint.store(h, name='thickness')\n", + " checkpoint.store(s, name='surface')\n", + " checkpoint.store(u, name='velocity')\n", + "\n", + "else: \n", + " with firedrake.DumbCheckpoint(\n", + " 'degree-5', mode=firedrake.FILE_READ\n", + " ) as checkpoint:\n", + " checkpoint.load(h, name='thickness')\n", + " checkpoint.load(s, name='surface')\n", + " checkpoint.load(u, name='velocity')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(6305,)" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "h.dat.data.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n" + ] + } + ], + "source": [ + "Q3D = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])\n", + "w=firedrake.interpolate(h*icepack.utilities.vertical_velocity(u,h),Q3D)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n", + "ss = np.array(s.at(xs, tolerance=1e-10))\n", + "hs = np.array(h.at(xs, tolerance=1e-10))\n", + "bs = np.array(b.at(xs, tolerance=1e-10))\n", + "\n", + "fig, axes = plt.subplots()\n", + "axes.plot(xs[:, 0], bs, color='black')\n", + "axes.plot(xs[:, 0], ss - hs, color='blue')\n", + "axes.plot(xs[:, 0], ss, color='blue')\n", + "plt.show(fig)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from matplotlib.collections import LineCollection\n", + "from matplotlib.colors import ListedColormap, BoundaryNorm\n", + "\n", + "nz=20\n", + "\n", + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", + "wM= np.array(w.at(xz, tolerance=1e-10))\n", + "wM=np.reshape(wM,(49,nz));\n", + "xz=np.reshape(xz,(49,nz,3));\n", + "hz=np.reshape(np.repeat(hs,nz),(49,nz));\n", + "hz=np.multiply(xz[:,:,2],hz);\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(-5, 0)\n", + " lc = LineCollection(segments, cmap='viridis', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(wM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'vertical velocity.$(m\\dota^{-1})$')\n", + "axs.set_ylabel('elevation.(m)')\n", + "axs.set_xlabel('distance.(km)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "100%|██████████| 50000/50000 [14:32:07<00:00, 1.05s/it] \n" + ] + } + ], + "source": [ + "import tqdm\n", + "\n", + "num_years = 500000.0\n", + "timesteps_per_year = 0.1\n", + "\n", + "δt = 1.0 / timesteps_per_year\n", + "num_timesteps = int(num_years * timesteps_per_year)\n", + "\n", + "for step in tqdm.trange(num_timesteps):\n", + " age = age_solver.solve(δt,velocity=u,thickness=h,age=age)\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0,1.0,1.0/nz)])\n", + "ageM= np.array(age.at(xz, tolerance=1e-10))\n", + "ageM=np.reshape(ageM,(49,nz));\n", + "xz=np.reshape(xz,(49,nz,3));" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots()\n", + "for i in range(0,nz):\n", + " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", + " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", + " norm = plt.Normalize(0,7000)\n", + " lc = LineCollection(segments, cmap='viridis', norm=norm)\n", + " # Set the values used for colormapping\n", + " lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n", + " lc.set_linewidth(2)\n", + " line = axs.add_collection(lc)\n", + "axs.set_xlim(xz.min(), xz.max())\n", + "axs.set_ylim(bs.min(), ss.max())\n", + "axs.plot(xs[:, 0], bs, color='black')\n", + "fig.colorbar(line, ax=axs,label=r'age.$(m\\dota^{-1})$')\n", + "axs.set_ylabel('elevation.(m)')\n", + "axs.set_xlabel('distance.(km)')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-6052891.767930022" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "np.min(age.dat.data)" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 2.61333974e+03, 1.17069687e+03, 7.34421997e+02, ...,\n", + " 2.28430834e+06, 8.62113463e+04, -3.96973319e+05])" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "age.dat.data" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "age_model = icepack.models.AgeTransport()\n", + "age_solver = icepack.solvers.AgeSolver(age_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Method of characteristics\n", + "We use the method of characteristics to solve the age equation, which can be written as\n", + "\n", + "$$\\vec{u}\\cdot\\nabla \\mathcal{A} + \\frac{\\partial\\mathcal{A}}{\\partial t} = 1$$.\n", + "\n", + "We want to transform this linear first-order PDE into an ODE along the appropriate curve; i.e. something of the form\n", + "\n", + "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = F(\\mathcal{A},x(s),t(s))$$\n", + "\n", + "where (x(s),t(s)) is the characteristic volume. Using the chain rule, we can rewrite this description of the age evolution as\n", + "\n", + "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = \\frac{\\partial \\mathcal{A}}{\\partial x} \\frac{d x}{d s} +\\frac{\\partial \\mathcal{A}}{\\partial y} \\frac{d y}{d s} +\\frac{\\partial \\mathcal{A}}{\\partial z} \\frac{d z}{d s} + \\frac{\\partial \\mathcal{A}}{\\partial t} \\frac{dt}{ds}.$$\n", + "\n", + "If we set $\\frac{d t}{d s} = 1$ and $\\frac{d \\vec{x}}{d s} = \\vec{u}$, we see that \n", + "\n", + "$$\\frac{d}{ds} \\mathcal{A}(x(s),t(s) = \\vec{u}\\cdot\\nabla \\mathcal{A}+ \\frac{\\partial\\mathcal{A}}{\\partial t}, $$ \n", + "\n", + "which is just the left hand side of the PDE we started with. Thus, \n", + "\n", + "$$\\frac{d \\mathcal{A}}{ds} = 1$$\n", + "\n", + "$$\\frac{d t}{ds} = 1$$\n", + "\n", + "$$\\frac{d x}{ds} = \\vec{u}$$\n", + "\n", + "and the original PDE becomes a system of ordinary differential equations that we can solve with respect to s.\n", + "\n", + "Letting $t(s=0)=0$, we know $t=s$.\n", + "\n", + "Letting $x(s=0)=x_0$, we know $x=us+x_0=ut+x_0$\n", + "\n", + "Letting $\\mathcal{A}(s=0)=f(x_0)+s$, we know $\\mathcal{A}(x(t),t)=f(x_0)+t=f(x-ut)+t$\n", + "\n", + "In 3D, this is $\\mathcal{A}(x(t),t)==f(x_0,y_0,z_0)+t=f(x-ut,y-vt,z-wt)+t$\n", + "\n", + "\n", + "$\\frac{d}{dt}(A(x(t),t)) = \\frac{\\partial}{\\partial t}(A(x(t),t) + \\frac{\\partial}{\\partial x}(A(x(t),t)x’(t)$\n", + "\n", + "$x = x_0 + ut$\\\n", + "$y = y_0 + vt$\\\n", + "$z = z_0 + wt$\\\n", + "$a = a_0 + t$" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "firedrake", + "language": "python", + "name": "firedrake" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb index be89c52af..ced95d1b8 100644 --- a/notebooks/tutorials/age_model_test.ipynb +++ b/notebooks/tutorials/age_model_test.ipynb @@ -35,7 +35,7 @@ "outputs": [], "source": [ "Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0)\n", - "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5)\n", + "V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6)\n", "Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1])" ] }, @@ -72,6 +72,19 @@ { "cell_type": "code", "execution_count": 6, + "id": "74d0d1c6", + "metadata": {}, + "outputs": [], + "source": [ + "x0=0\n", + "y0=0\n", + "z0=0\n", + "age0=0" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "id": "c43e4bbd", "metadata": {}, "outputs": [], @@ -95,7 +108,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "8061ed45", "metadata": {}, "outputs": [], @@ -105,7 +118,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "679e063f", "metadata": {}, "outputs": [], @@ -116,7 +129,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "32dae83c", "metadata": {}, "outputs": [ @@ -124,57 +137,63 @@ "name": "stderr", "output_type": "stream", "text": [ - "100%|██████████| 150/150 [00:45<00:00, 3.27it/s]\n" + "100%|██████████| 100/100 [01:34<00:00, 1.06it/s]\n" ] } ], "source": [ "import tqdm\n", + "import numpy as np\n", "\n", - "num_years = 30.0\n", + "num_years = 20.0\n", "timesteps_per_year = 5.0\n", "\n", "δt = 1.0 / timesteps_per_year\n", "num_timesteps = int(num_years * timesteps_per_year)\n", "\n", + "num_age = np.zeros((num_timesteps,1))*np.nan\n", + "ana_age = np.zeros((num_timesteps,1))*np.nan\n", + "ts = np.zeros((num_timesteps,1))*np.nan\n", + "\n", "for step in tqdm.trange(num_timesteps):\n", - " (age, flux) = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)" + " age = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)\n", + " t = step*δt\n", + " ts[step] = t\n", + " num_age[step] = age.at(x0+ux*t,y0+uy*t,z0+(1000+uz*t)/1000,tolerance=1e-10)\n", + " ana_age[step] = age0+t" ] }, { "cell_type": "code", - "execution_count": 10, - "id": "5652b157", + "execution_count": 11, + "id": "67214e26", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", "text/plain": [ - "
" + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" - } - ], - "source": [ - "fig, axes = icepack.plot.subplots()\n", - "colors = icepack.plot.tripcolor(u, axes=axes, cmap='RdBu', vmin=0, vmax=50)\n", - "fig.colorbar(colors, label='meters/year', fraction=0.012, pad=0.04);" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "4aae38a9", - "metadata": {}, - "outputs": [ + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -186,101 +205,50 @@ } ], "source": [ - "import numpy as np\n", - "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n", - "ss = np.array(s.at(xs, tolerance=1e-10))\n", - "hs = np.array(h.at(xs, tolerance=1e-10))\n", - "bs = np.array(b.at(xs, tolerance=1e-10))\n", + "plt.figure()\n", + "plt.plot(ts,num_age,label=\"numerical\")\n", + "plt.plot(ts,ana_age,label=\"analytical\")\n", + "plt.legend()\n", "\n", - "fig, axes = plt.subplots()\n", - "axes.plot(xs[:, 0], bs, color='black')\n", - "axes.plot(xs[:, 0], ss - hs, color='blue')\n", - "axes.plot(xs[:, 0], ss, color='blue')\n", - "plt.show(fig)" + "plt.figure()\n", + "plt.plot(ts,num_age-ana_age,label=\"numerical-analytical\")\n", + "plt.legend()" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 16, "id": "3d5b6949", "metadata": {}, "outputs": [], "source": [ - "import matplotlib.pyplot as plt\n", "from matplotlib.collections import LineCollection\n", "from matplotlib.colors import ListedColormap, BoundaryNorm\n", "\n", "nz=20\n", "\n", - "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", - "wM= np.array(firedrake.interpolate(w*h,Q3D).at(xz, tolerance=1e-10))\n", - "wM=np.reshape(wM,(21,nz));\n", - "xz=np.reshape(xz,(21,nz,3));\n", - "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", - "hz=np.multiply(xz[:,:,2],hz);" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "id": "40c7a3d9", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "fig, axs = plt.subplots()\n", - "for i in range(0,nz):\n", - " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", - " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(-50, 50)\n", - " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", - " # Set the values used for colormapping\n", - " lc.set_array(np.squeeze(wM[:,nz-1-i]))\n", - " lc.set_linewidth(2)\n", - " line = axs.add_collection(lc)\n", - "axs.set_xlim(xz.min(), xz.max())\n", - "axs.set_ylim(bs.min(), ss.max())\n", - "axs.plot(xs[:, 0], bs, color='black')\n", - "fig.colorbar(line, ax=axs,label=r'vertical velocity.$(m\\dota^{-1})$')\n", - "axs.set_ylabel('elevation.(m)')\n", - "axs.set_xlabel('distance.(km)')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "71b1bb97", - "metadata": {}, - "outputs": [], - "source": [ + "xs = np.array([(Lx * k / nx, 0, .5) for k in range(nx + 1)])\n", + "ss = np.array(s.at(xs, tolerance=1e-10))\n", + "hs = np.array(h.at(xs, tolerance=1e-10))\n", + "bs = np.array(b.at(xs, tolerance=1e-10))\n", + "\n", "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0,1.0,1.0/nz)])\n", "ageM= np.array(age.at(xz, tolerance=1e-10))\n", "ageM=np.reshape(ageM,(21,nz));\n", - "xz=np.reshape(xz,(21,nz,3));" + "xz=np.reshape(xz,(21,nz,3));\n", + "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", + "hz=np.multiply(xz[:,:,2],hz);" ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 17, "id": "a6b3b892", "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -311,195 +279,10 @@ "plt.show()" ] }, - { - "cell_type": "code", - "execution_count": 16, - "id": "7ec04407", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([9.78737467e-02, 1.23671770e+00, 2.62651910e+00, 3.90240903e+00,\n", - " 5.05507233e+00, 6.24031191e+00, 7.52937117e+00, 8.89573778e+00,\n", - " 1.02409355e+01, 1.14963852e+01, 1.26553619e+01, 1.37662227e+01,\n", - " 1.49089431e+01, 1.61447546e+01, 1.74907903e+01, 1.89133471e+01,\n", - " 2.03390299e+01, 2.16742906e+01, 2.28377885e+01, 2.37706219e+01,\n", - " 1.64428888e+06])" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ageM[:,0]" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "3fcc0f39", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([40. , 0. , -0.04])" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "u3D.dat.data.mean(0)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "55c71de1", - "metadata": {}, - "outputs": [], - "source": [ - "from firedrake import assemble\n", - "foo = assemble(flux)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "4365c4a1", - "metadata": {}, - "outputs": [], - "source": [ - "bar = firedrake.interpolate(foo,Q3D)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "adca38d2", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "nz=20\n", - "\n", - "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", - "fM= np.array(bar.at(xz, tolerance=1e-10))\n", - "fM=np.reshape(fM,(21,nz));\n", - "xz=np.reshape(xz,(21,nz,3));\n", - "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", - "hz=np.multiply(xz[:,:,2],hz);\n", - "\n", - "fig, axs = plt.subplots()\n", - "for i in range(0,nz):\n", - " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", - " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(-1, 1)\n", - " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", - " # Set the values used for colormapping\n", - " lc.set_array(np.squeeze(fM[:,nz-1-i]))\n", - " lc.set_linewidth(2)\n", - " line = axs.add_collection(lc)\n", - "axs.set_xlim(xz.min(), xz.max())\n", - "axs.set_ylim(bs.min(), ss.max())\n", - "axs.plot(xs[:, 0], bs, color='black')\n", - "fig.colorbar(line, ax=axs,label=r'flux.$(?)$')\n", - "axs.set_ylabel('elevation.(m)')\n", - "axs.set_xlabel('distance.(km)')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "09052e50", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZsAAAEKCAYAAADEovgeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAAsTAAALEwEAmpwYAAAqvElEQVR4nO3df5wdZXn38c83CSH+QBKCQiRoEFIRqRpcCVb7SPmNVcEWEbU1FZTyKC1qrYJaoaBVrBWhIJoCitTyQ1BJEUnDL5VWI0lAIQFMQJDwBDEkIBZiSPZ6/ph7s5PD7jlzdmbPnjP7fb9e89pz5twzc82evPbKPXPPdSsiMDMzG00TxjoAMzOrPycbMzMbdU42ZmY26pxszMxs1DnZmJnZqHOyMTOzUTdqyUbSRZIekXRnbt0OkhZJWpl+TkvrJekcSask/VzSPrlt5qX2KyXNG614zcy6gaTDJN2T/h6ePMTn20q6PH2+WNKshs9fJOl3kj7SsaALGM2ezdeBwxrWnQzcEBGzgRvSe4DDgdlpOR44H7LkBJwKzAX2BU4dSFBmZnUjaSJwHtnfxL2Ad0jaq6HZccD6iNgDOAs4s+HzLwLfH+1Y2zVqySYifgisa1h9BHBxen0xcGRu/Tci8xNgqqQZwKHAoohYFxHrgUU8M4GZmdXFvsCqiLgvIjYCl5H9fczL/x29EjhQkgAkHQn8EljemXCLm9Th4+0UEWvS64eBndLrXYAHc+1Wp3XDrX8GSceT9YqYPn36q1/04he3Hdztdz3Q9jbTn3qi7W0Adt1n77a3cXyDOhUfjCzGOsYHnfuOOxlfPPXo2oh4/ogOmEx43sxg04aix1sO5BvPj4j56fVQf/PmNuxiS5uI2CTpcWC6pA3Ax4CDga66hAadTzZbRERIqqxWTvqy5gP09fXFkiVLqtq1mdWYpJFl+bzNv2ebl721UNONyy7YEBF9pY/5TKcBZ0XE71JHp6t0Otn8WtKMiFiTLpM9ktY/BOyaazczrXsI2L9h/c0diNPMrC2aMLGK3Qz3t3CoNqslTQK2Bx4l6wEdJenzwFSgX9KGiDi3isDK6vTQ5wXAwIiyecDVufXvTqPS9gMeT5fbFgKHSJqWBgYcktaZmXURoQkTCy0t3ArMlrSbpMnAMWR/H/Pyf0ePAm5M97v/OCJmRcQs4EvAP3VLooFR7NlIupSsV7KjpNVko8o+B1wh6TjgAeDo1Pxa4I3AKuBJ4D0AEbFO0hlkXwDA6RHROOjAzGxsSZX0bNI9mBPJ/lM9EbgoIpZLOh1YEhELgAuBSyStIhuEdUzpA3eA6jjFgO/ZmFlRkpaWvYcycbud49lz/qJQ29/96F9KH68XjdkAATOzOqnonk1tOdmYmZVV0WW0OnOyMTMrSYAmuNRkM042ZmaluWfTSi2TzbIV9zN5zrFtb3fs7Te2vc1ZT93d9jYA27/2/W1v4/gGdSo+GFmMdYwPOvcddzK+SvgyWku1TDZmZh0lMWGbyWMdRVfz0GczG9eqGPq8zdSZMfUNJxVqu3bBRz302czMRsCX0VpysjEzK01McLJpysnGzKws+aHOVpxszMxKEmLCJA8QaMbJxsysLN+zacnJxsysNCebVpxszMzKEmiik00zTjZmZiXJPZuWaplsHlh6BydoVtvbdXtZDcc3qI6lcbo9Pqhn6Z5K+J5NS7VMNmZmnTZxkv+cNuNyNWY2rlVRrmbKC/aImUd9vlDbe8//83FZrsYTMJiZVUBSoaXAfg6TdI+kVZJOHuLzbSVdnj5fLGX3DCTtK+n2tPxM0lurP8uRc7/PzKwCEya0TiStSJoInAccDKwGbpW0ICJW5JodB6yPiD0kHQOcCbwduBPoi4hNkmYAP5P0nxGxqXRgFXDPxsysLIEmqNDSwr7Aqoi4LyI2ApcBRzS0OQK4OL2+EjhQkiLiyVximQJ01T0SJxszs5KyaaErSTa7AA/m3q9O64Zsk5LL48B0AElzJS0H7gBO6JZeDfgymplZeRITJxb+v/uOkvIjmOZHxPwqwoiIxcDLJb0MuFjS9yNiQxX7LsvJxsysAgV6LQPWNhmN9hCwa+79zLRuqDarJU0CtgcezTeIiLsk/Q7YG+iKobm+jGZmVpKUDRAosrRwKzBb0m6SJgPHAAsa2iwA5qXXRwE3RkSkbSZl8ejFwJ7A/VWdY1nu2ZiZVUAV/Nc9jSQ7EVgITAQuiojlkk4HlkTEAuBC4BJJq4B1ZAkJ4PXAyZKeBvqB90fE2vJRVaOWyaY/gqc2tH+ZstvLaji+QXUsjdPt8UE9S/dUpcgzNEVExLXAtQ3rPpV7vQF42xDbXQJcUkkQo6CWycbMrJMkMXGS70o043I1ZjauVVGu5jkv/IPY66/PLdR2yWmHjstyNe7ZmJmVJZhQ0WW0unKyMTMraeChThuek42ZWWmFqgOMa042ZmZlqZpCnHXmZGNmVpKACROdbJpxsjEzK8s9m5bGZGC4pA9JWi7pTkmXSpqSSi0sThMCXZ5KNQw7UZCZWTepqOpzbXU82UjaBfhbskl+9iYryTAwAdBZEbEHsJ5sgiDITRQEnJXamZl1kWKzdFZVZaAXjdVltEnAs1INn2cDa4ADgHemzy8GTgPOJ5so6LS0/krg3DRR0LBPoy5bcT+T5xzbdlDdXlbD8Q2qY2mcbo8P6lm6pwryZbSWOt6ziYiHgC8AvyJLMo8DS4HHchP95CcMGnaioDxJx0ta0jBPhJlZR/gyWnMd79lImkbWW9kNeAz4FnBY2f2myYfmw0C5movK7nJUbbzN8ZXh+MpxfIO+WsGlLQkmuzZaU2NxGe0g4JcR8RsASd8GXgdMlTQp9V7yEwa1nCjIzGwsCTFxHPdaihiLVPwrYD9Jz1Z2t+xAYAVwE9lEQJBNDHR1ej3kREEdjNfMrDnBxAkqtIxXHe/ZRMRiSVcCy4BNwG1kl7++B1wm6dNp3YVpk+EmCjIz6wqCcZ1IihiT0WgRcSpwasPq+4B9h2g75ERBZmbdQoJJTjZNuYKAmVlJkjxAoAUnGzOzkrLLaE42zfi3Y2ZWgaoGCEg6TNI9qUTXyUN8PmQJL0kHS1oq6Y7084Dqz3Lk3LMxMytJqmaAgKSJwHnAwWQPt98qaUFErMg121LCS9JAqa+3A2uBN0fE/5O0N7CQwYfjx1wtk80DS+/ghBHU6+z2shqOb1AdS+N0e3xQz9I9VajwOZt9gVURcR+ApMvIHoLPJ5vhSnjdlmuznKwk2LYR8fsqAiurlsnGzKzTJhavRLBjQ1mt+akCCuTKcyWrgbkN229VwkvSQAmvtbk2fw4s65ZEAzVNNi9+9R/ylSWdKZHmsh/ldHt80P0xOr6x12a5mrUR0Td6sejlZJfWDhmtY4xELZONmVknVficzUB5rgH50l2NbZ5RwkvSTOA7wLsj4t4qAqqKR6OZmZU0cM+mgtFotwKz02SSk8kqpixoaDNkCS9JU8kqsZwcEf9d3dlVw8nGzKwCVSSbVIj4RLKRZHcBV0TEckmnS3pLanYhMD2V8PowMDA8+kRgD+BTkm5PywtG41xHwpfRzMxKqmroM0BEXAtc27DuU7nXQ5bwiohPA5+uJIhR4GRjZlaSC3G25mRjZlaSa6O15mRjZlYB92yac7IxMyupyns2dVXLZNMfwVMbNrS9XbeX1XB8g+pYGqfb44N6lu6pgu/ZtFbLZGNm1lHu2bSkiBjrGCrX19cXSzpUrsbMepukpWXLx7z4Za+Ij3/9Pwu1PWG/WaWP14vcszEzK0nARHdsmnKyMTMrSzDBl9GacrIxMysp69k42TTjZGNmVoEJTjZNOdmYmZXkezatOdmYmZUkiUkTXa6mGScbM7MKuGfTXC2TzbIV9zN5zrFtb9ftTzo7vkF1rFbQ7fFBPaspVEH4nk0rtUw2ZmYd5QoCLbmCgJmNa1VUEJi99yvjrG/9V6G2b95rZ1cQaEXSc4ANEbF5lOIxM+tJvmfTXNPhE5ImSHqnpO9JegS4G1gjaYWkf5a0R2fCNDPrXpLYZuKEQkuBfR0m6R5JqySdPMTn20q6PH2+WNKstH66pJsk/U7SudWfZTmtzvwmYHfgFGDniNg1Il4AvB74CXCmpL8Y5RjNzLpaNkCg2NJ0P9JE4DzgcGAv4B2S9mpodhywPiL2AM4CzkzrNwD/AHykujOrTqvLaAdFxNONKyNiHXAVcJWkbUYlMjOzHlJRuZp9gVURcR+ApMuAI4AVuTZHAKel11cC50pSRPwvcEu3XnFqmmzyiUbSNGDX/DYRsWyoZGRmNp60OfR5R0n5EUzzI2J+er0L8GDus9XA3Ibtt7SJiE2SHgemA2vbjbuTCg0QkHQG8FfAvcDA8LUADhidsMzMeoigjQICa3txNFrZAWJFR6MdDeweERtHcpBGkqYCFwB7kyWtY4F7gMuBWcD9wNERsV6SgLOBNwJPAn8VEcuqiMPMrApCbDOhknI1D5FdQRowM60bqs1qSZOA7YFHqzh4nqQJwDHAu4DXAL8HtpW0Fvge8NWIWFV0f0V/O3cCU9sLtamzgesiYk/glcBdwMnADRExG7ghvYfsRtnstBwPnF9hHGZmpQ1cRiuytHArMFvSbpImk/2xX9DQZgEwL70+CrgxRueByUoHiBXt2XwWuE3SnWTZDYCIeEvhsBNJ2wP/h+yyHKm3tFHSEcD+qdnFwM3Ax8huhn0j/TJ/ImmqpBkRsWa4Yzyw9A5OyEYDtqXby2o4vkF1LI3T7fFBPUv3VKK9y2jDSvdgTgQWAhOBiyJiuaTTgSURsQC4ELhE0ipgHVlCysKQ7geeB0yWdCRwSESsYGQqHSBWNNlcTDa87g6gv+jOh7Eb8Bvga5JeCSwFTgJ2yiWQh4Gd0uuhbpjtAmyVbCQdT9bzYUcmlwzRzKy4KmujRcS1wLUN6z6Ve70BeNsw286qJIjMdpJOIBtSfUFE/HaI4xUeIFY02TwZEecU3WmBY+4D/E1ELJZ0NoOXzACIiJDUVrcwjeaYD1m5mq90qFzNxtsu6shxRsrxldftMTq+7lDDOpxXAT8mG+n2Y0lvHhiSPRJFk82PJH2W7Fph/jLaSG7UrwZWR8Ti9P5KsmTz64HLY5JmAI+kz4vcMDMzG1MTqF22mR4RHweQ9F/ADyQ9Bvwd8N6IOLqdnRVNNnPSz/1y60Y09DkiHpb0oKSXRsQ9wIFkDyytILvp9bn08+q0yQLgxPRw01zg8Wb3a8zMOk1Uc8+myzwhaVZE3B8RCyW9CHghsJ7slkpbCiWbiPiTdnfcwt8A30yjLe4D3kM2Mu4KSccBD5ANt4bs2uUbgVVkQ5/fU3EsZmblqJaX0Y4Fth14kwZpDVxVerLdnTVNNmlY239ExJCDAiTtDsyIiFvaOWhE3A4M9VDTgUO0DeAD7ezfzKyThOp4Ge0XrYZUpzI5he6vt+rZTCcb8ryUbNTYb4ApwB7AG8jKIzyjKqmZ2XhTw57NTZKuAq6OiF8NrExXpF5PdrvjJuDrRXbWqjba2alU9QHA64BXAE+RPYT5l/kAzMzGsxpO1HkY2aW0SyXtBjxG1tmYCPwX8KWIuK3ozlres0l1cBalxczMGojKqj53jfQ8z5eBL6eHN3cEnoqIx0ayvxGPn5D0ppFua2ZWN1KxpRdFxNMRsWYg0Ujaud19tDUtdIPXANeU2H7U9Efw1IYNbW/X7WU1HN+gOpbG6fb4oJ6le6pSv5HPTV0I/Gk7G4w42UTEqSPd1sysTrJeS492W0YgItpKNAAqWixU0h+Rlf/PT572jXYP2Al9fX2xpEPlasyst0laWnZ+mVfO2Seuu+lHhdq+cNpzSx+vkyT9DfDvEbG+zH6KTp52CVmp6duBgYlzAujKZGNm1mk17tjsBNwqaRlwEbBwJFMaFL2M1gfsNUpzJpiZ9bQ6jkYbEBGflPQPwCFkFVzOlXQFcGFE3Ft0P+1Mntb26AMzs3FB2XM2RZZelDoaD6dlEzANuFLS54vuo2jPZkdghaSfUnLyNDOzOurRPNKSpJOAd5NVjLkA+PuIeDpNG70S+GiR/RRNNqeNJEgzs/EgmzxtrKMYNTsAfxYRD+RXRkR/O89bFrqMFhE/AO4GtkvLXWmdmZmRDX0usvSgKY2JRtKZABFxV9GdFEo2ko4Gfko2FenRwGJJRxWP1cysvgZ6NlXcs5F0mKR7JK2S9IxCx5K2lXR5+nyxpFm5z05J6++RdGhFp3fwEOsOb3cnRS+jfQJ4TUQ8AiDp+cD1ZLNsmpmNc6pkNJqkicB5ZH/gV5MNOV4QEStyzY4D1kfEHpKOAc4E3i5pL+AY4OVkk5xdL+kPUn3LkcTyf4H3Ay+R9PPcR9sB/93u/oommwkDiSZ5lC6uzrBsxf1MnnNs29t1e1kNxzeojqVxuj0+qGfpnkpUV/dsX2BVRNwHkGYoPoJsJuMBRzB4H/1KsqHISusvi4jfA7+UtCrt78cjjOU/gO8Dn2XrqWSeiIh17e6saLK5TtJC4NL0/u1kM2iamY17ikDFH0PcUVK+xMn8iJifXu8CPJj7bDUwt2H7LW0iYpOkx8nmHtsF+EnDtrsUDapRRDwOPA68Y6T7yCs6LfTfS/pzsjltIPvlfKeKAEbDPnvNYsmSi8Y6jKY23ub4ynB85Ti+QV+t6qb90BMaD2VtL5SrkXRLRLxe0hNkFWO2fET26M3z2tlf4UKcEXEVcFU7OzczGy9UPNk08xCwa+79zLRuqDarJU0Ctie7tVFk28Ii4vXp53Yj3Ude0/sukm5JP5+Q9Nvc8oSk31YRgJlZ7wvo31xsae5WYLak3dL0y8cACxraLCCbkhngKODG9IT/AuCYNFptN2A22SjirtA02eQzW0Q8L7ds124XysystiKyy2hFlqa7iU3AicBC4C7giohYLul0SQMVWy4EpqcBAB8m3byPiOXAFWSDCa4DPjDSkWh5ki6WNDX3fpqktq9zFq76HBF/2Wqdmdl4VdFlNCLiWhoGYEXEp3KvN5A98zjUtp8BPlNJIINekZ8KOiLWS5rT7k6K3rN5ef5Nuk746nYPZmZWWxUlmy40QdK0gflsJO3ACCbebLqBpFOAjwPPyt2jEbARmD/shmZm40rUOdn8C/BjSd8i+/t/FCPoPTVNNhHxWeCzkj4bEaeMKEwzs7oLaptsIuIb6bmgA8jO9M8aKhoUUvQ5m1MkTSMb3TAlt/6H7R7QzKx+Am3eNNZBjKZtGJxFYZuR7KDoAIH3AieRjdu+HdiPrATCASM56Gh7YOkdnDBYm66wbi+r4fgG1bE0TrfHB/Us3VOZmvZs0nw27yN7zlLAv0uaHxH/2s5+it7kOQl4DfCTiPgTSXsC/9TOgczMaisiW+rpOGBuRPwvbJle4MfAqCSbDRGxIc3HsG1E3C3ppe3F2zkvfvUf8pUlS1o3rIDLfpTT7fFB98fo+LpETXs2ZL2Z/PM6mxnBxKRFk83q9FDPd4FFktYDDzTdwsxsHKnqOZsu9DWyOcy+Q5ZkjgRG56HOiHhrenmapJvIavFc1+7BzMzqqb5DnyPii5JuZrAQ87yIuL3d/RQdIHAO2TwJ/+PpoM3MGkRAf71Gow1T7Xngs1Gr+rwU+GS6T/MdssTTmZsiZmZdTtTvMlpV1Z4HFJptMyIujog3ko1Iuwc4U9LKKgMxM+tp/f3FlnGq3amd9wD2BF4MjOGAdjOzbhKDw59bLT1Gmb+Q9Kn0/kWS9m13P4WSjaTPp57M6cAdQF9EvLndgzXsc6Kk2yRdk97vJmmxpFWSLk9zOZDmZrg8rV8sjeBpTTOz0TRQrqbkFANd6svAaxmcHvoJ4Lx2d1K0Z3Mv8NqIOCwivp4vN13CSWTzNQw4EzgrIvYA1pM9SET6uT6tPyu1MzPrIoH6NxVaetDciPgAsAGyKQaAye3upOgAgX8D3inpJRFxuqQXATtHxIhmgZM0E/hTssqhH5YkstI370xNLgZOA84HjkivAa4EzlUaCjHc/vsjeGrDhrbj6vayGo5vUB1L43R7fFDP0j2V6c1eSxFPS5pIGpkm6flA2ydbtGdzHhV0o3K+BHyUwYCnA4+lWeoAVgO7pNe7AA/CllnsHk/ttyLpeElLUnVSM7POicqmhe5G55CNQt5J0meAWxhBubKiPZu5EbGPpNtgy0xtbXejACS9CXgkIpZK2n8k+xhKRMwnzbHT19cXz5oypcUWz9TtZTUcXzmOr7xuj3Ek8Ulfq+TYUd+RZjuR3b54FamCQETc1XSLIRTt2VTSjUpeB7xF0v3AZWSXz84GpqYZQCGrLv1Qev0QsGs67iSy6gWPjvDYZmajoDM9G0k7SFokaWX6OW2YdvNSm5WS5uXWf0bSg5J+18ZhtyP7j/wx6f26kcReNNkMdKNeUKYbBdncOBExMyJmkQV/Y0S8C7iJbAY4gHnA1en1gvSe9PmNze7XmJl1XNCpy2gnAzdExGzghvR+K2na5lOBucC+wKm5pPSfaV1hEfGPEfFy4APADOAHkq5vN/CitdG+KWkpcCAlulEtfAy4TNKngduAC9P6C4FLJK0iy6jHDLO9mdmYiAji6ac7cagjgP3T64uBm8n+duYdCiyKiHUAkhYBhwGXRsRP0rqRHPsR4GGyK0svaHfjpskmZcj8gS7NfzZwMiMVETeT/bKIiPsYIuNGxAbgbWWOY2Y2uqKdXsuODQOZ5qd7zkXsFBFr0uuHye6nNNoyqCrJD7hqm6T3A0cDzwe+BbxvNKaFXkrWQRTPLMgWwEvaPaCZWe1EEMWTzdqI6Bvuw3SJauchPvrE1oeMkNSJWwq7Ah8cSaXnvKbJJiJ2A5A0AXgXsFvuOZsZZQ5sZlYrFY1Gi4iDhvtM0q8lzYiINZJmkF1xavQQg5faIBtwdXOJeE4Z6bZ57Txnsx9bP2dzbhUBmJn1vqxnU2QpKT9gKj+QKm8hcIikaWlgwCFp3ZgqmmwqKVdgZlZLnRuN9jng4FSr8qD0Hkl9ki4ASPfSzwBuTcvpucECn5e0Gni2pNWSTisbUFFFH+qs8jmbUbdsxf1MnnNs29t1e1kNxzeojqVxuj0+qGfpnkp0aDRaRDxKNiq4cf0S4L259xcxxNTNEfFRsuotHVc02TQ+Z3MU8MlRi8rMrKe0NRptXFLR5yMl7cngczY3jMJzNpXp6+uLJUtcIs3MWpO0tNnosCJe/Qez4n++fGqhtlMOPrb08XpR0Z4NEXE3njDNzGxINa6NVonCycbMzIbjy2itONmYmZUUEcSmjpSr6VlONmZmZQ0MfbZhOdmYmZXmy2itONmYmZUVEJudbJpxsjEzKy0qq41WV042ZmZV8GW0pmqZbB5YegcnaFbb23V7WQ3HN6iOpXG6PT6oZ+meSkTQ79FoTdUy2ZiZdVQEsdmX0ZopXK6ml7hcjZkVVUW5mjmzXhg/OPW9rRsC2x97hsvVmJnZSITL1bTgZGNmVlbgy2gtONmYmZUUEWze6AECzTjZmJlVwJfRmnOyMTMry6PRWpow1gGYmdVBbO4vtJQhaQdJiyStTD+nDdNuXmqzUtK8tO7Zkr4n6W5JyyV9rlQwbXKyMTMrKSIbjVZkKelkspmSZwM3pPdbkbQDcCowF9gXODWXlL4QEXsCc4DXSTq8bEBF1fIyWn8ET23Y0PZ23f6ks+MbVMdqBd0eH9SzmkJV+jtzGe0IYP/0+mLgZuBjDW0OBRZFxDoASYuAwyLiUuAmgIjYKGkZMLMDMQM1TTZmZh3VH/Rv3FS09Y6S8k+dz4+I+QW33Ski1qTXDwM7DdFmF+DB3PvVad0WkqYCbwbOLnjc0mqZbCZIPGvKlLa323jbRaMQTXUcXzmOr7xuj3Ek8UlfK33coK3RaGubVRCQdD2w8xAffWKrY0aEpLZLwEiaBFwKnBMR97W7/UjVMtmYmXVUhaPRIuKg4T6T9GtJMyJijaQZwCNDNHuIwUttkF0quzn3fj6wMiK+VD7a4jxAwMysAp0YjQYsAOal1/OAq4dosxA4RNK0NDDgkLQOSZ8Gtgc+WDaQdjnZmJmVFdDf319oKelzwMGSVgIHpfdI6pN0AUAaGHAGcGtaTo+IdZJmkl2K2wtYJul2ScWqh1bAl9HMzEoKOvNQZ0Q8Chw4xPolwHtz7y8CLmposxrQaMc4HCcbM7OyIuh/2rXRmnGyMTMry1WfW+r4PRtJu0q6SdKKVDLhpLR+yDIMypwjaZWkn0vap9Mxm5k1F50aINCzxmKAwCbg7yJiL2A/4AOS9mL4MgyHA7PTcjxwfudDNjMbXkRWQaDIMl51/DJaevp1TXr9hKS7yJ5uHa4MwxHANyKbv/onkqYOjDMf7hjLVtzP5DnHth1bt5fVcHyD6lgap9vjg3qW7qmGZ+psZUzv2UiaRVYQbjHDl2EYrvTCVslG0vFkPR/0rOmjF7SZWaN+6N+4eayj6GpjlmwkPRe4CvhgRPxWGhyRN5IyDKm20HyAvr6+WLKkfmU1OsnxleP4yulkfF9V+dHAQYzrS2RFjEmykbQNWaL5ZkR8O60ergzDQ8Cuuc1npnVmZt0hIPrbLlM2rozFaDQBFwJ3RcQXcx8NV4ZhAfDuNCptP+DxZvdrzMzGQv/mKLSMV2PRs3kd8JfAHZJuT+s+TlZ24QpJxwEPAEenz64F3gisAp4E3tPRaM3MWgg/Z9PSWIxGu4XhSyYMVYYhgA+MalBmZmVEEOO411KEKwiYmZUVsNmj0ZpysjEzKymAfg8QaMrJxsysLF9Ga8nJxsysAn7OprlaJpsHlt7BCZrV9nbdXlbD8Q2qY2mcbo8P6lm6pwrZaDT3bJqpZbIxM+soJ5uWlI0srpesXM2SsQ7DzHqApKUR0VdmH3s+57kxf+9XFGr7hp/+uPTxetFYTDFgZlYrQWcqCAw379cQ7ealNislzcutv07Sz9JcYl+RNLFUQG1wsjEzKys6NnnacPN+bSFpB+BUYC6wL3BqLikdHRGvBPYGng+8rWxARTnZmJlVIDZHoaWkI8jm+yL9PHKINocCiyJiXUSsBxYBhwFExG9Tm0nAZLJOWUc42ZiZlZTN1NmRQpzDzfuVN9wcYABIWkhWVf8J4MqyARXl0WhmZmVFsPnpwuVqdpSUH8E0P83HBYCk64Gdh9juE1sfsv15v9J2h0qaAnwTOICs5zPqnGzMzMpqb+jz2maj0SLioOE+kzTcvF95DwH7597PBG5uOMYGSVeTXZbrSLLxZTQzs5ICOjVAYLh5v/IWAodImpYGBhwCLJT03JSgkDQJ+FOgY0/BumdjZlZWumfTAUPO+yWpDzghIt4bEesknQHcmrY5Pa3bCVggaVuyjsZNwFc6ETTUNNn0R/DUhg1tb9ftZTUc36A6lsbp9vignqV7qtGZQpwR8ShDz/u1BHhv7v1FwEUNbX4NvGa0YxxOLZONmVknRWT/ybXhuVyNmY1rVZSr2X2bZ8WZO7ykUNu3PbJiXJarcc/GzKwCm2v4H/cqOdmYmZUUgIs+N+dkY2ZWUoR7Nq042ZiZVcA9m+acbMzMSgrCPZsWnGzMzEoKYGPp4gD15mRjZlaS79m05mRjZlYB37NprpbJZtmK+5k859i2t+v2shqOb1AdS+N0e3xQz9I9VciGPjvbNFPLZGNm1kl+zqY1l6sxs3GtinI1u0yYEu+fsmuhtp98apXL1ZiZ2cj4MlpzTjZmZiUF4JHPzTnZmJmV5oc6W3GyMTMryQMEWnOyMTMryUOfW3OyMTMrKQI29jvZNDNhrAMoStJhku6RtErSyWMdj5lZ3uYotpQhaQdJiyStTD+nDdNuXmqzUtK8IT5fIOnOctG0pyeSjaSJwHnA4cBewDsk7TW2UZmZZQYuoxVZSjoZuCEiZgM3pPdbkbQDcCowF9gXODWflCT9GfC7soG0q1cuo+0LrIqI+wAkXQYcAawYqvE999zD/vvv37nozGxc6+AAgSOA/dPri4GbgY81tDkUWBQR6wAkLQIOAy6V9Fzgw8DxwBUdiHeLXkk2uwAP5t6vJsvaW0g6nuwXCPD7H/zgBx3tInbIjsDasQ6iYnU8J/B59ZKXlt3BWjYu/CoP7Fiw+RRJ+RIn8yNifsFtd4qINen1w8BOQ7QZ6u/lLun1GcC/AE8WPF5leiXZtJS+rPkAkpbUsRxEHc+rjucEPq9e0vCHf0Qi4rAqYgGQdD2w8xAffaLhmCGpcH9K0quA3SPiQ5JmlQpyBHol2TwE5AsPzUzrzMxqJSIOGu4zSb+WNCMi1kiaATwyRLOHGLzUBtnfy5uB1wJ9ku4n+9v/Akk3R8T+dEBPDBAAbgVmS9pN0mTgGGDBGMdkZtZpC4CB0WXzgKuHaLMQOETStDQw4BBgYUScHxEvjIhZwOuBX3Qq0UCPJJuI2AScSPZLvAu4IiKWN9mk6PXPXlPH86rjOYHPq5f00jl9DjhY0krgoPQeSX2SLgBIAwPOIPtP+q3A6QODBcZSLacYMDOz7tITPRszM+ttTjZmZjbqapdserWsjaRdJd0kaYWk5ZJOSuuHLE+hzDnpPH8uaZ+xPYPmJE2UdJuka9L73SQtTvFfngZ+IGnb9H5V+nzWmAY+DElTJV0p6W5Jd0l6bR2+K0kfSv/+7pR0qaQpvfhdSbpI0iP5kiwj+X5alX2x4mqVbHq8rM0m4O8iYi9gP+ADKfbhylMcDsxOy/HA+Z0PuS0nkQ3uGHAmcFZE7AGsB45L648D1qf1Z6V23ehs4LqI2BN4Jdm59fR3JWkX4G+BvojYG5hINvKzF7+rr5M9NZ/X1vfTquyLtSkiarOQjSNfmHt/CnDKWMc1wnO5GjgYuAeYkdbNAO5Jr78KvCPXfku7blvIxvnfABwAXAOI7Cn0SY3fG9mIw9em15NSO431OTScz/bALxvj6vXvisEnz3dIv/tryEqf9OR3BcwC7hzp9wO8A/hqbv1W7by0t9SqZ0PzMg09I12OmAMsZvjyFL10rl8CPsrgzLnTgcciG9IOW8e+5bzS54+n9t1kN+A3wNfSpcELJD2HHv+uIuIh4AvAr4A1ZL/7pfT2d5XX7vfTE99br6hbsul5ygrlXQV8MCJ+m/8ssv9e9dRYdUlvAh6JiKVjHUuFJgH7AOdHxBzgf2movtuj39U0skKPuwEvBJ7DMy9F1UIvfj+9rm7JpqfL2kjahizRfDMivp1W/zqVpaChPEWvnOvrgLekEhmXkV1KOxuYKmmgXFI+9i3nlT7fHni0kwEXsBpYHRGL0/sryZJPr39XBwG/jIjfRMTTwLfJvr9e/q7y2v1+euV76wl1SzY9W9ZGkoALgbsi4ou5j4YrT7EAeHcaSbMf8HjuEkHXiIhTImJmZCUyjgFujIh3ATcBR6Vmjec1cL5HpfZd9T/QiHgYeFDSQLXgA8mmu+jp74rs8tl+kp6d/j0OnFfPflcN2v1+hiz70umga2OsbxpVvQBvBH4B3At8YqzjaSPu15N1638O3J6WN5JdA78BWAlcD+yQ2ots5N29wB1kI4jG/DxanOP+wDXp9UuAnwKrgG8B26b1U9L7Venzl4x13MOcy6uAJen7+i4wrQ7fFfCPwN3AncAlwLa9+F0Bl5Ldd3qarCd63Ei+H+DYdH6rgPeM9Xn18uJyNWZmNurqdhnNzMy6kJONmZmNOicbMzMbdU42ZmY26pxszMxs1DnZWMdJOk3SRySdLqnZfOtHjmUhVUlzJF2YXp8m6SMj3M9kST/MPRhpNu442diYiYhPRcT1TZocSVa9e6x8HDin7E4iYiPZ8x1vLx2RWY9ysrGOkPQJSb+QdAvw0rTu65KOSq8/p2wun59L+oKkPwLeAvyzpNsl7S7pfZJulfQzSVdJenZuP+dI+h9J9w3sM332MUl3pG0G5mvfXdJ1kpZK+pGkPYeIdzvgFRHxsyE+e5+k70t6lqSbJZ0laYmyeW1eI+nbaf6TT+c2+y7wrsp+oWY9xt16G3WSXk1WquZVZP/mlpFVEx74fDrwVmDPiAhJUyPiMUkLyCoOXJnaPRYR/5Zef5rsqfB/TbuZQVaFYU+y8iNXSjqcrLDk3Ih4Ms1PAjAfOCEiVkqaC3yZrGZbXh/ZU/SN53Ii2dQPR0bE77OqLmyMiD5lE95dDbwaWAfcK+msiHg07es1I/n9mdWBk411wh8D34mIJwFSEsl7HNgAXKhsJs9rhtnP3inJTAWey9Z1qr4bEf3ACkkDpeMPAr42cNyIWJeqav8R8K2UKCArydJoBtk0AnnvJis5f2RkhSoHDJzPHcDySHXPJN1HVsjx0YjYLGmjpO0i4olhzs+stnwZzcZcZHOh7EtWPflNwHXDNP06cGJE/CFZDa8puc9+n3sthjeBbH6WV+WWlw3R7qmG/UOWTGaRVf/NGzh2f0Mc/Wz9H7ptyZKq2bjjZGOd8EPgyHSPYzvgzfkPU29j+4i4FvgQ2TTLAE8A2+WabgesSVMxFLn/sQh4T+7ezg6RzRH0S0lvS+sk6ZVDbHsXsEfDutuAvwYWSHphgeNvkS4Vrm3oEZmNG042NuoiYhlwOfAz4PtkU0HkbQdcI+nnwC3Ah9P6y4C/VzYb5u7AP5DNXvrfZJWJWx33OrJLXEsk3Q4MDF1+F3CcpJ8By8nu6yDpLZJOT9veDWyfkmN+n7ek/XxP0o6FfwnwJ8D32mhvViuu+mw2DEkfAp6IiAsq2Ne3gZMj4hflIzPrPe7ZmA3vfLa+BzMiyiby+64TjY1n7tmYmdmoc8/GzMxGnZONmZmNOicbMzMbdU42ZmY26pxszMxs1P1/55XE8qSzig0AAAAASUVORK5CYII=\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "nz=20\n", - "\n", - "xz = np.array([(Lx * k / nx, 0, i) for k in range(nx + 1) for i in np.arange(0.0,1.0,1.0/nz)])\n", - "fM= np.array(u3D.at(xz, tolerance=1e-10))\n", - "fM=np.reshape(fM,(21*3,nz));\n", - "xz=np.reshape(xz,(21,nz,3));\n", - "hz=np.reshape(np.repeat(hs,nz),(21,nz));\n", - "hz=np.multiply(xz[:,:,2],hz);\n", - "\n", - "fig, axs = plt.subplots()\n", - "for i in range(0,nz):\n", - " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", - " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(-.04, .04)\n", - " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", - " # Set the values used for colormapping\n", - " lc.set_array(np.squeeze(fM[:,nz-1-i]))\n", - " lc.set_linewidth(2)\n", - " line = axs.add_collection(lc)\n", - "axs.set_xlim(xz.min(), xz.max())\n", - "axs.set_ylim(bs.min(), ss.max())\n", - "axs.plot(xs[:, 0], bs, color='black')\n", - "fig.colorbar(line, ax=axs,label=r'velocity.$(?)$')\n", - "axs.set_ylabel('elevation.(m)')\n", - "axs.set_xlabel('distance.(km)')\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "id": "25352614", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "21.0" - ] - }, - "execution_count": 22, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "1260/20/3" - ] - }, { "cell_type": "code", "execution_count": null, - "id": "84472020", + "id": "2b99f076", "metadata": {}, "outputs": [], "source": [] From 6947c75c86a87c574c5a2ac0a1a365bc8fb3e403 Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Thu, 17 Jun 2021 14:05:17 -0700 Subject: [PATCH 12/14] age transport tests implemented, but the space test still needs debugging --- icepack/models/age_transport.py | 9 +- notebooks/tutorials/age_model_test.ipynb | 202 +++++++++++------------ test/age_transport_test.py | 176 ++++++++++++++++++++ 3 files changed, 278 insertions(+), 109 deletions(-) create mode 100644 test/age_transport_test.py diff --git a/icepack/models/age_transport.py b/icepack/models/age_transport.py index 45b6e41a2..5dc7401bc 100644 --- a/icepack/models/age_transport.py +++ b/icepack/models/age_transport.py @@ -16,7 +16,7 @@ from operator import itemgetter import firedrake from firedrake import ( - inner, grad, div, dx, ds, ds_t, ds_b, ds_tb, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional + inner, grad, div, dx, ds, ds_tb, ds_v, dS_v, dS_h, dS, sqrt, det, min_value, max_value, conditional ) from icepack.constants import year from icepack.utilities import eigenvalues, vertical_velocity, add_kwarg_wrapper @@ -62,7 +62,6 @@ def flux(self, **kwargs): degree = (xdegree_u + degree_h, 2 * zdegree_u + 1) metadata = {'quadrature_degree': degree} ice_front_ids = tuple(kwargs.pop('ice_front_ids', ())) - #ds_terminus = ds_v(domain=mesh, subdomain_id=ice_front_ids, metadata=metadata) u3D = self.velocity_3D(**kwargs) @@ -72,8 +71,6 @@ def flux(self, **kwargs): q_inflow=firedrake.Constant(0.0) flux_faces_v = (f('+') - f('-')) * (φ('+') - φ('-')) * dS_v flux_cells = -q * div(u3D * φ) * dx - #flux_terminus = q * max_value(0, inner(u3D, n)) * φ * ds_terminus - #flux_surface = q_inflow * min_value(0, inner(u3D, n)) * φ * ds_t - #flux_h = q * max_value(0, inner(u3D, n)) * φ * ds_h + flux_v = q * max_value(0, inner(u3D, n)) * φ * ds_v flux_tb = q * max_value(0, inner(u3D, n)) * φ * ds_tb - return flux_cells + flux_faces_v + flux_tb + return flux_cells + flux_faces_v + flux_tb + flux_v diff --git a/notebooks/tutorials/age_model_test.ipynb b/notebooks/tutorials/age_model_test.ipynb index ced95d1b8..1f8f9fb7c 100644 --- a/notebooks/tutorials/age_model_test.ipynb +++ b/notebooks/tutorials/age_model_test.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6e7a6fbb", "metadata": {}, "outputs": [], @@ -11,12 +11,13 @@ "import matplotlib.pyplot as plt\n", "import firedrake\n", "import icepack, icepack.models, icepack.plot\n", - "from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g" + "from icepack.constants import ice_density as ρ_I, water_density as ρ_W, gravity as g\n", + "import numpy as np" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "4b5215d6", "metadata": {}, "outputs": [], @@ -29,7 +30,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "6f3d9428", "metadata": {}, "outputs": [], @@ -41,7 +42,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "ded40a3b", "metadata": {}, "outputs": [], @@ -51,7 +52,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "9b333544", "metadata": {}, "outputs": [], @@ -66,25 +67,40 @@ "u = firedrake.interpolate(firedrake.as_vector((ux, uy)), V)\n", "w = firedrake.interpolate(uz/h,Q3D)\n", "\n", - "age = firedrake.interpolate(firedrake.Constant(0.0),Q3D)" + "num_years = 10.0" ] }, { "cell_type": "code", - "execution_count": 6, - "id": "74d0d1c6", + "execution_count": null, + "id": "b4bcc677", "metadata": {}, "outputs": [], "source": [ - "x0=0\n", - "y0=0\n", - "z0=0\n", - "age0=0" + "# create a mask assuming age propogation from upper left to lower right\n", + "x_eval_min = 0 + ux.dat.data[0] * num_years\n", + "#x_eval_max = Lx\n", + "y_eval_min = 0 + uy.dat.data[0] * num_years\n", + "#y_eval_max = Ly\n", + "#z_eval_min = 0\n", + "z_eval_max = (h.dat.data[0] + uz.dat.data[0] * num_years) / h.dat.data[0]\n", + "\n", + "#if (x_eval_max <= x_eval_min) or (y_eval_max <= y_eval_min) or (z_eval_max <= z_eval_min):\n", + "# raise ValueError('No points to evaluate.')\n", + " \n", + "mask_x = firedrake.conditional(xz_eval_max,0,1)\n", + "mask = mask_x * mask_y * mask_z\n", + "\n", + "fig, axes = icepack.plot.subplots()\n", + "colors = icepack.plot.tripcolor(firedrake.interpolate(mask, Q3D), axes=axes)\n", + "fig.colorbar(colors, label='mask')" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "c43e4bbd", "metadata": {}, "outputs": [], @@ -108,7 +124,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "8061ed45", "metadata": {}, "outputs": [], @@ -118,7 +134,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "679e063f", "metadata": {}, "outputs": [], @@ -129,95 +145,84 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "32dae83c", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 100/100 [01:34<00:00, 1.06it/s]\n" - ] - } - ], + "outputs": [], "source": [ "import tqdm\n", "import numpy as np\n", "\n", - "num_years = 20.0\n", - "timesteps_per_year = 5.0\n", + "x0=0\n", + "y0=0\n", + "z0=900\n", + "age0=0\n", + "\n", + "timesteps_per_year = [5.0, 6.0, 7.0, 8.0, 9.0, 10.0]\n", + "\n", + "L1s = []\n", + "\n", + "for tpy in timesteps_per_year:\n", + " \n", + " age = firedrake.interpolate(firedrake.Constant(0.0),Q3D)\n", + "\n", + " δt = 1.0 / tpy\n", + " num_timesteps = int(num_years * tpy)\n", + " \n", + " num_age = np.zeros((num_timesteps,1))*np.nan\n", + " ana_age = np.zeros((num_timesteps,1))*np.nan\n", + " ts = np.zeros((num_timesteps,1))*np.nan\n", "\n", - "δt = 1.0 / timesteps_per_year\n", - "num_timesteps = int(num_years * timesteps_per_year)\n", + " for step in tqdm.trange(num_timesteps):\n", + " age = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)\n", + " t = step*δt\n", + " ts[step] = t\n", + " num_age[step] = age.at(x0+ux*t,y0+uy*t,(z0+uz*t)/1000,tolerance=1e-10)\n", + " ana_age[step] = age0+t\n", + " \n", + " num_sol = firedrake.interpolate(age*mask, Q3D)\n", + " ana_sol = firedrake.interpolate((age0+t)*mask, Q3D)\n", "\n", - "num_age = np.zeros((num_timesteps,1))*np.nan\n", - "ana_age = np.zeros((num_timesteps,1))*np.nan\n", - "ts = np.zeros((num_timesteps,1))*np.nan\n", + " J = (num_sol-ana_sol) * firedrake.dx\n", + " L1 = firedrake.assemble(J)\n", + " L1s += [L1]\n", + " print(tpy, L1)\n", + " \n", + " #plt.figure()\n", + " #plt.plot(ts,num_age,label=\"numerical\")\n", + " #plt.plot(ts,ana_age,label=\"analytical\")\n", + " #plt.legend()\n", "\n", - "for step in tqdm.trange(num_timesteps):\n", - " age = age_solver.solve(δt,velocity=u,thickness=h,age=age,uz=uz)\n", - " t = step*δt\n", - " ts[step] = t\n", - " num_age[step] = age.at(x0+ux*t,y0+uy*t,z0+(1000+uz*t)/1000,tolerance=1e-10)\n", - " ana_age[step] = age0+t" + " plt.figure()\n", + " plt.plot(ts,num_age-ana_age,label=\"numerical-analytical\")\n", + " plt.legend()\n", + " plt.title(str(tpy))" ] }, { "cell_type": "code", - "execution_count": 11, - "id": "67214e26", + "execution_count": null, + "id": "74af964c", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "plt.figure()\n", - "plt.plot(ts,num_age,label=\"numerical\")\n", - "plt.plot(ts,ana_age,label=\"analytical\")\n", - "plt.legend()\n", - "\n", - "plt.figure()\n", - "plt.plot(ts,num_age-ana_age,label=\"numerical-analytical\")\n", - "plt.legend()" + "plt.plot(1/np.array(timesteps_per_year),L1s,'ko')" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, + "id": "2467b21d", + "metadata": {}, + "outputs": [], + "source": [ + "print(num_sol.dat.data.max())\n", + "print(ana_sol.dat.data.max())" + ] + }, + { + "cell_type": "code", + "execution_count": null, "id": "3d5b6949", "metadata": {}, "outputs": [], @@ -242,29 +247,16 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "a6b3b892", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "fig, axs = plt.subplots()\n", "for i in range(0,nz):\n", " points = np.array([np.squeeze(xz[:,i,0]),np.squeeze(ss-hz[:,i])]).T.reshape(-1, 1, 2)\n", " segments = np.concatenate([points[:-1], points[1:]], axis=1)\n", - " norm = plt.Normalize(0,30)\n", + " norm = plt.Normalize(0,20)\n", " lc = LineCollection(segments, cmap='RdBu', norm=norm)\n", " # Set the values used for colormapping\n", " lc.set_array(np.squeeze(ageM[:,nz-1-i]))\n", @@ -285,7 +277,11 @@ "id": "2b99f076", "metadata": {}, "outputs": [], - "source": [] + "source": [ + "fig, axes = icepack.plot.subplots()\n", + "colors = icepack.plot.tripcolor(firedrake.interpolate(num_sol-ana_sol, Q3D), axes=axes)\n", + "fig.colorbar(colors, label='masked age')" + ] } ], "metadata": { diff --git a/test/age_transport_test.py b/test/age_transport_test.py new file mode 100644 index 000000000..40d5c8162 --- /dev/null +++ b/test/age_transport_test.py @@ -0,0 +1,176 @@ +# Copyright (C) 2021 by Jessica Badgeley and +# Andrew Hoffman +# +# This file is part of icepack. +# +# icepack is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# The full text of the license can be found in the file LICENSE in the +# icepack source directory or at . + +import firedrake +from firedrake import ( + interpolate, + conditional, + Constant, + dx, + assemble, +) +import icepack +import numpy as np +import matplotlib.pyplot as plt + +# Test our numerical solver against a simple, analytical solution. +num_years = 10.0 +Lx, Ly = 1.e3, 1.e3 +ux = Constant(40.) +uy = Constant(0.) +uz = Constant(-40.) +dts = [1/5.0, 1/6.0, 1/7.0, 1/8.0, 1/9.0] +dx_constant = 50. +dxs = [100., 75., 50., 40., 30.] +dt_constant = 3./25. +age0 = 0. + +def velocity_3D(**kwargs): + u = kwargs['velocity'] + h = kwargs['thickness'] + uz = kwargs['uz'] + Q = h.function_space() + V = u.function_space() + mesh = Q.mesh() + xdegree_u, zdegree_u = u.ufl_element().degree() + W = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) + w = firedrake.interpolate(uz/h,W) + V3D = firedrake.VectorFunctionSpace(mesh, dim=3, family='CG', degree=xdegree_u, vfamily='GL',vdegree=zdegree_u+1) + u3D = firedrake.Function(V3D).interpolate(firedrake.as_vector((u[0],u[1],w))) + return u3D + +def create_mask(x, y, ζ, h): + x_min = ux.dat.data[0] * num_years + y_min = uy.dat.data[0] * num_years + ζ_max = (h.dat.data[0] + uz.dat.data[0] * num_years) / h.dat.data[0] + mask_x = conditional(x < x_min, 0, 1) + mask_y = conditional(y < y_min, 0, 1) + mask_ζ = conditional(ζ > ζ_max, 0, 1) + return mask_x * mask_y * mask_ζ + +def create_mesh_function_spaces(nx, ny): + mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly) + mesh = firedrake.ExtrudedMesh(mesh2d, layers=1) + Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0) + V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6) + Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) + return mesh, Q, V, Q3D + +def create_variables(Q, V, Q3D): + b = interpolate(firedrake.Constant(0.0), Q) + s = interpolate(firedrake.Constant(Lx), Q) + h = interpolate(s - b, Q) + u = interpolate(firedrake.as_vector((ux, uy)), V) + w = interpolate(uz/h,Q3D) + return b, s, h, u, w + +def norm(v): + return icepack.norm(v, norm_type="L2") + +def test_diagnostic_solver_convergence_time(): + nx, ny = int(Lx/dx_constant), int(Ly/dx_constant) + mesh, Q, V, Q3D = create_mesh_function_spaces(nx, ny) + b, s, h, u, w = create_variables(Q, V, Q3D) + x, y, ζ = firedrake.SpatialCoordinate(mesh) + mask = create_mask(x, y, ζ, h) + u3D = velocity_3D(velocity=u, thickness=h, uz=uz) + age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D) + age_solver = icepack.solvers.AgeSolver(age_model) + + errors = [] + + for dt in dts: + + age = interpolate(Constant(age0),Q3D) + num_timesteps = int(num_years / dt) + + for step in range(num_timesteps): + + t = step*dt + age = age_solver.solve(dt,velocity=u,thickness=h,age=age,uz=uz) + age_num = interpolate(age * mask, Q3D) + age_exact = interpolate((age0 + t) * mask, Q3D) + + #errors = [assemble((age_exact - age_num) * dx)/assemble(age_exact * dx) + #errors += [assemble((age_num - age_exact) * dx)] + errors += [norm(age_exact - age_num) / norm(age_exact)] + + print(dts) + print(errors) + + plt.figure() + plt.plot(dts, errors, 'ko') + plt.show() + + log_dt = np.log2(np.array(dts)) + log_error = np.log2(np.array(errors)) + print(log_dt) + print(log_error) + slope, intercept = np.polyfit(log_dt, log_error, 1) + + plt.figure() + plt.plot(log_dt, log_error, 'ko') + plt.show() + + print(f"error ~= {slope:g} * dt + {intercept:g}") + assert slope > 0 + +def test_diagnostic_solver_convergence_space(): + + num_timesteps = int(num_years / dt_constant) + errors = [] + + for dx_val in dxs: + + nx, ny = int(Lx/dx_val), int(Ly/dx_val) + mesh, Q, V, Q3D = create_mesh_function_spaces(nx, ny) + b, s, h, u, w = create_variables(Q, V, Q3D) + x, y, ζ = firedrake.SpatialCoordinate(mesh) + mask = create_mask(x, y, ζ, h) + u3D = velocity_3D(velocity=u, thickness=h, uz=uz) + age_model = icepack.models.AgeTransport(velocity_3D=velocity_3D) + age_solver = icepack.solvers.AgeSolver(age_model) + + age = interpolate(Constant(age0),Q3D) + + for step in range(num_timesteps): + + t = dt_constant * step + age = age_solver.solve(dt_constant,velocity=u,thickness=h,age=age,uz=uz) + + age_num = interpolate(age * mask, Q3D) + age_exact = interpolate((age0 + t) * mask, Q3D) + + #errors = [assemble((age_exact - age_num) * dx)/assemble(age_exact * dx) + errors += [assemble((age_num - age_exact) * dx)] + #errors += [norm(age_exact - age_num) / norm(age_exact)] + + print(dxs) + print(errors) + + plt.figure() + plt.plot(dxs, errors, 'ko') + plt.show() + + log_dx = np.log2(np.array(dxs)) + log_error = np.log2(np.array(errors)) + print(log_dx) + print(log_error) + slope, intercept = np.polyfit(log_dx, log_error, 1) + + plt.figure() + plt.plot(log_dx, log_error, 'ko') + plt.show() + + print(f"error ~= {slope:g} * dx + {intercept:g}") + assert slope > 0 From 6aef8a31e18b5a9f6d3c7ca76978a0c09090ecfd Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Wed, 20 Oct 2021 14:51:21 -0700 Subject: [PATCH 13/14] working on age_transport and vertical_velocity tests --- test/age_transport_test.py | 3 +- test/vertical_velocity_test.py | 50 ++++++++++++++++++++++++++++++++++ 2 files changed, 52 insertions(+), 1 deletion(-) create mode 100644 test/vertical_velocity_test.py diff --git a/test/age_transport_test.py b/test/age_transport_test.py index 40d5c8162..f3728dbe1 100644 --- a/test/age_transport_test.py +++ b/test/age_transport_test.py @@ -63,6 +63,7 @@ def create_mesh_function_spaces(nx, ny): mesh = firedrake.ExtrudedMesh(mesh2d, layers=1) Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0) V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6) + # Would this go faster if I decreased the vdegree, which would probably be okay since I'm using a constant vertical velocity) Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) return mesh, Q, V, Q3D @@ -71,7 +72,7 @@ def create_variables(Q, V, Q3D): s = interpolate(firedrake.Constant(Lx), Q) h = interpolate(s - b, Q) u = interpolate(firedrake.as_vector((ux, uy)), V) - w = interpolate(uz/h,Q3D) + w = interpolate(uz/h, Q3D) return b, s, h, u, w def norm(v): diff --git a/test/vertical_velocity_test.py b/test/vertical_velocity_test.py new file mode 100644 index 000000000..b9e27f0b1 --- /dev/null +++ b/test/vertical_velocity_test.py @@ -0,0 +1,50 @@ +# Copyright (C) 2021 by Jessica Badgeley +# +# This file is part of icepack. +# +# icepack is free software: you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation, either version 3 of the License, or +# (at your option) any later version. +# +# The full text of the license can be found in the file LICENSE in the +# icepack source directory or at . + +import firedrake +from firedrake import ( + interpolate, + conditional, + Constant, + dx, + assemble, +) +import icepack +from icepack.utilities import vertical_velocity +import numpy as np +import matplotlib.pyplot as plt + +# Test our numerical solver against a simple, analytical solution +Lx, Ly = 1.e3, 1.e3 +nx, ny = 100, 100 +mesh2d = firdrake.RectangleMesh(nx, ny, Lx, Ly) +mesh = firedrake.ExtrudedMesh(mesh2d, layers=1) + +Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0) +V = firdrake.FunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6) +Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) + +x, y, ζ = firedrake.SpatialCoordinate(mesh) +ux = x/100. +ux_range = firedrake.max(ux) - firedrake.min(ux) +uy = Constant(0.) + +b = interpolate(firedrake.Constant(0.0), Q) +s = interpolate(firedrake.Constant(100.0), Q) +h = interpolate(s - b, Q) +u = interpolate(firedrake.as_vector((ux, uy)), V) +w_analytic = interpolate((-1 * h * ux_range / Lx) / h, Q3D) + +w_numeric = vertical_velocity(u, h, m=0.0) + +print(assemble((w_numeric - w_analytic) * dx)) + From e8dd9a62108ec36c673a91cdcaefef253cd330c0 Mon Sep 17 00:00:00 2001 From: Jessica Badgeley Date: Wed, 20 Oct 2021 15:00:27 -0700 Subject: [PATCH 14/14] added original vertical_velocity_test --- test/vertical_velocity_test.py | 54 ++++++++++++++++++---------------- 1 file changed, 28 insertions(+), 26 deletions(-) diff --git a/test/vertical_velocity_test.py b/test/vertical_velocity_test.py index b9e27f0b1..ad4f78831 100644 --- a/test/vertical_velocity_test.py +++ b/test/vertical_velocity_test.py @@ -10,41 +10,43 @@ # The full text of the license can be found in the file LICENSE in the # icepack source directory or at . +import numpy as np import firedrake -from firedrake import ( - interpolate, - conditional, - Constant, - dx, - assemble, -) import icepack -from icepack.utilities import vertical_velocity -import numpy as np -import matplotlib.pyplot as plt +import icepack.utilities +from icepack.constants import (ice_density as ρ_I, water_density as ρ_W, + gravity as g, glen_flow_law as n) + +Lx, Ly = 20e3, 20e3 +nx, ny = 48, 48 -# Test our numerical solver against a simple, analytical solution -Lx, Ly = 1.e3, 1.e3 -nx, ny = 100, 100 -mesh2d = firdrake.RectangleMesh(nx, ny, Lx, Ly) +mesh2d = firedrake.RectangleMesh(nx, ny, Lx, Ly) mesh = firedrake.ExtrudedMesh(mesh2d, layers=1) Q = firedrake.FunctionSpace(mesh, family='CG', degree=2, vfamily='DG', vdegree=0) -V = firdrake.FunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=6) -Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=1+V.ufl_element().degree()[1]) +Q3D = firedrake.FunctionSpace(mesh, family='DG', degree=2, vfamily='GL', vdegree=6) +V = firedrake.VectorFunctionSpace(mesh, dim=2, family='CG', degree=2, vfamily='GL', vdegree=5) +# note we should call the families in the vertical velocity solver. x, y, ζ = firedrake.SpatialCoordinate(mesh) -ux = x/100. -ux_range = firedrake.max(ux) - firedrake.min(ux) -uy = Constant(0.) -b = interpolate(firedrake.Constant(0.0), Q) -s = interpolate(firedrake.Constant(100.0), Q) -h = interpolate(s - b, Q) -u = interpolate(firedrake.as_vector((ux, uy)), V) -w_analytic = interpolate((-1 * h * ux_range / Lx) / h, Q3D) +u_inflow=1.0 +v_inflow=2.0 +mu=.003 +mv=.001 + +b=firedrake.interpolate(firedrake.Constant(0.0),Q) +s=firedrake.interpolate(firedrake.Constant(1000.0),Q) +h = firedrake.interpolate(s-b,Q) +u=firedrake.interpolate(firedrake.as_vector((mu*x+u_inflow,mv*y+v_inflow)),V) + +m=-0.01 + +def analytic_vertical_velocity(h,ζ,mu,mv,m,Q3D): + return firedrake.interpolate(firedrake.Constant(m)-(firedrake.Constant(mu+mv)*h*ζ),Q3D) -w_numeric = vertical_velocity(u, h, m=0.0) +w=firedrake.interpolate(icepack.utilities.vertical_velocity(u,h,m=m)*h,Q3D) +w_analytic=analytic_vertical_velocity(h,ζ,mu,mv,m,Q3D) -print(assemble((w_numeric - w_analytic) * dx)) +assert(np.mean(np.abs(w.dat.data-w_analytic.dat.data))<10e-10)