Repository: atmtools/konrad (language: python)

Issue:
Add logo to project readme



Discussion / hints:

Fix patch:
diff --git a/.github/workflows/build-book.yml b/.github/workflows/build-book.yml
new file mode 100644
index 00000000..0fcc6c43
--- /dev/null
+++ b/.github/workflows/build-book.yml
@@ -0,0 +1,49 @@
+name: Build book
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        python-version: [3.8]
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up Python ${{ matrix.python-version }}
+      uses: actions/setup-python@v2
+      with:
+        python-version: ${{ matrix.python-version }}
+    - name: Install dependencies with pip
+      run: |
+        python -m pip install --upgrade pip
+        pip install wheel
+        TARGET=HASWELL pip install .[docs]
+        pip list
+    - name: build book
+      run: |
+        conda info
+        jupyter-book build -W -n --keep-going howto
+    - name: Archive build artifacts
+      uses: actions/upload-artifact@v2
+      with:
+        name: build
+        path: |
+          howto/_build
+
+  publish:
+    needs: build
+    if: "github.event_name == 'push' && github.ref == 'refs/heads/main' && github.repository_owner == 'atmtools'"
+    runs-on: ubuntu-latest
+    steps:
+      - name: Download compiled book
+        uses: actions/download-artifact@v2
+        with:
+          name: build
+          path: _build
+      - name: Publish book on github pages
+        uses: peaceiris/actions-gh-pages@v3
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: _build/html
diff --git a/.gitignore b/.gitignore
index c50e520a..6434cdc2 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,6 +7,11 @@
 *so.1
 .idea
 .ipynb_checkpoints
+
+# Build artefacts
+_build/
+build/
 dist/
 docs/build/
-docs/source/_autosummary
\ No newline at end of file
+docs/source/_autosummary
+konrad.egg-info/
diff --git a/README.md b/README.md
index 895c8ac6..5f246149 100644
--- a/README.md
+++ b/README.md
@@ -1,13 +1,16 @@
 [![PyPI version](https://badge.fury.io/py/konrad.svg)](https://badge.fury.io/py/konrad)
-[![Test](https://github.com/atmtools/konrad/workflows/Test/badge.svg?branch=master)](https://github.com/atmtools/konrad/commits/master)
+[![Test](https://github.com/atmtools/konrad/workflows/Test/badge.svg?branch=main)](https://github.com/atmtools/konrad/commits/main)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.1313687.svg)](https://doi.org/10.5281/zenodo.1313687)
 [![Documentation Status](https://readthedocs.org/projects/konrad/badge/?version=latest)](https://konrad.readthedocs.io/en/latest/?badge=latest)
 
-# konrad - Radiative-convective equilibrium framework
+# ![Logo](howto/images/konrad-logo_64.png) konrad
 
-The goal of ``konrad`` is to provide a simple framework to run
-radiative-convective equilibrium (RCE) simulations. It is build in an object
-oriented structure to allow simple modifications of the model setup.
+``konrad`` is a one-dimensional radiative-convective equilibrium (RCE) model.
+It is build in an object oriented structure to allow simple modifications of
+the model setup.
+
+You can find various tutorials that illustrate the usage of ``konrad`` in our
+["How to konrad"](https://atmtools.github.io/konrad) Jupyter book.
 
 ## Requirements
 ``konrad`` requires Python 3.6 or higher. The recommended way to get
diff --git a/docs/source/index.rst b/docs/source/index.rst
index a8027f8e..dba7d917 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -37,7 +37,6 @@ Model components to configure the configuration of `konrad`.
    konrad.humidity
    konrad.lapserate
    konrad.ozone
-   konrad.plots
    konrad.radiation
    konrad.surface
    konrad.upwelling
diff --git a/docs/source/konrad.convection.rst b/docs/source/konrad.convection.rst
index e1177b76..bb6db0fe 100644
--- a/docs/source/konrad.convection.rst
+++ b/docs/source/konrad.convection.rst
@@ -12,5 +12,4 @@ Convection Scheme
    Convection
    NonConvective
    HardAdjustment
-   RelaxedAdjustment
    FixedDynamicalHeating
diff --git a/docs/source/konrad.humidity.rst b/docs/source/konrad.humidity.rst
index 85d8787a..f28c7a5c 100644
--- a/docs/source/konrad.humidity.rst
+++ b/docs/source/konrad.humidity.rst
@@ -22,13 +22,7 @@ Relative humidity
 
    RelativeHumidityModel
    CacheFromAtmosphere
-   HeightConstant
    VerticallyUniform
-   ConstantFreezingLevel
-   FixedUTH
-   CoupledUTH
-   CshapeConstant
-   CshapeDecrease
    Manabe67
    Cess76
    Romps14
@@ -46,6 +40,4 @@ Stratospheric coupling
 
    StratosphereCoupler
    ColdPointCoupling
-   NonIncreasing
    FixedStratosphericVMR
-   MinimumStratosphericVMR
diff --git a/docs/source/konrad.plots.rst b/docs/source/konrad.plots.rst
deleted file mode 100644
index dfeea9fb..00000000
--- a/docs/source/konrad.plots.rst
+++ /dev/null
@@ -1,11 +0,0 @@
-Plotting
-========
-
-.. automodule:: konrad.plots
-
-.. autosummary::
-   :toctree: _autosummary
-
-   plot_overview_p_log
-   plot_overview_z
-   gregory_plot
diff --git a/docs/source/konrad.utils.rst b/docs/source/konrad.utils.rst
index d827bcda..af102603 100644
--- a/docs/source/konrad.utils.rst
+++ b/docs/source/konrad.utils.rst
@@ -11,7 +11,6 @@ Utilities
    return_if_type
    plev_from_phlev
    dz_from_z
-   get_squeezable_pgrid
    get_quadratic_pgrid
    get_pressure_grids
    ozonesquash
diff --git a/howto/_config.yml b/howto/_config.yml
new file mode 100644
index 00000000..d33b070d
--- /dev/null
+++ b/howto/_config.yml
@@ -0,0 +1,16 @@
+title: "How to konrad"
+author: "konrad developers"
+copyright: "2021"
+logo: "images/konrad-logo.png"
+html:
+  favicon: "images/konrad-logo.png"
+  use_repository_button     : true
+  use_edit_page_button      : true
+repository:
+  url                       : https://github.com/atmtools/konrad
+  path_to_book              : howto
+launch_buttons:
+  binderhub_url             : ""
+execute:
+  execute_notebooks: force
+  timeout: 90
diff --git a/howto/_toc.yml b/howto/_toc.yml
new file mode 100644
index 00000000..339f1474
--- /dev/null
+++ b/howto/_toc.yml
@@ -0,0 +1,19 @@
+format: jb-book
+root: intro
+chapters:
+- file: getting_started
+- file: netcdf_output
+- file: components
+  sections:
+    - file: atmosphere
+    - file: humidity
+    - file: lapserate
+    - file: clouds
+    - file: surface
+- file: climate_modeling
+  sections:
+    - file: forcing
+    - file: feedback
+- file: misc
+  sections:
+    - file: rrtmg_only
diff --git a/howto/atmosphere.md b/howto/atmosphere.md
new file mode 100644
index 00000000..2ec47058
--- /dev/null
+++ b/howto/atmosphere.md
@@ -0,0 +1,59 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Atmosphere
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use('typhon')
+```
+
+In the introduction we have already learned how to initialize an atmopshere component.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+```
+
+The atmosphere component is used to prescribe the gaseous composition of our model. For example,
+we can remove all ozone from our model column
+
+```{code-cell} ipython3
+atmosphere["O3"][:] = 0.0
+```
+
+Next, we can compile and run our RCE simulation
+
+```{code-cell} ipython3
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+```
+
+Finally, we can plot the equilibrated temperature profile
+
+```{code-cell} ipython3
+fig, ax = plt.subplots()
+plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
diff --git a/howto/climate_modeling.md b/howto/climate_modeling.md
new file mode 100644
index 00000000..4248dd8e
--- /dev/null
+++ b/howto/climate_modeling.md
@@ -0,0 +1,1 @@
+# Climate modeling
diff --git a/howto/clouds.md b/howto/clouds.md
new file mode 100644
index 00000000..d4c05a11
--- /dev/null
+++ b/howto/clouds.md
@@ -0,0 +1,88 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Clouds
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import numpy as np
+
+import konrad
+import typhon as ty
+
+
+ty.plots.styles.use()
+```
+
+## Clear-sky background
+
+```{code-cell} ipython3
+phlev = konrad.utils.get_quadratic_pgrid(num=256)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+rrtmg = konrad.radiation.RRTMG()
+
+
+rce = konrad.RCE(
+    atmosphere=atmosphere,
+    humidity=konrad.humidity.FixedRH(konrad.humidity.VerticallyUniform(0.8)),
+    surface=konrad.surface.FixedTemperature(temperature=300.0),
+    max_duration="100d",
+    timestep="12h",
+)
+rce.run()
+
+fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)
+ty.plots.profile_p_log(atmosphere["plev"], atmosphere["T"][-1], ax=ax0)
+ax0.set_ylabel("$p$ / hPa")
+ax0.set_xlabel("$T$ / K")
+
+ax1.axvline(0, color="k", linewidth=0.8)
+ty.plots.profile_p_log(atmosphere["plev"], rce.radiation["net_htngrt"][-1], ax=ax1)
+ax1.set_xlabel("Q / $\sf K\,day^{-1}$")
+ax1.set_xlim(-4, 0.5)
+ax1.set_ylim(bottom=phlev.max())
+```
+
+## Conceptual cloud
+
+```{code-cell} ipython3
+single_cloud = konrad.cloud.ConceptualCloud(
+    atmosphere,  # required for consistent coordinates
+    cloud_top=200e2,  # in Pa
+    depth=100e2,  # in Pa
+    phase="ice",  # "ice" or "liquid"
+    water_path=24.0,  # in g/m^3
+    cloud_fraction=0.3,  # [0-1]
+)
+
+rrtmg = konrad.radiation.RRTMG()
+rrtmg.update_heatingrates(
+    atmosphere=atmosphere,
+    cloud=single_cloud,
+)
+
+fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)
+ax0.axvline(0, color="k", linewidth=0.8)
+ty.plots.profile_p_log(atmosphere["plev"], rrtmg["net_htngrt"][-1], ax=ax0)
+ax0.set_xlabel("Q / $\sf K\,day^{-1}$")
+ax0.set_xlim(-4, 0.5)
+ax0.set_ylabel("$p$ / hPa")
+ax0.set_ylim(bottom=phlev.max())
+
+ax1.axvline(0, color="k", linewidth=0.8)
+ty.plots.profile_p_log(atmosphere["plev"], rrtmg["net_htngrt"][-1] - rrtmg["net_htngrt_clr"][-1], ax=ax1)
+ax1.set_xlabel("$\sf Q_\mathrm{cloud}$ / $\sf K\,day^{-1}$")
+ax1.set_xlim(-2.25, 2.25)
+ax1.set_ylim(bottom=phlev.max())
+```
diff --git a/howto/components.md b/howto/components.md
new file mode 100644
index 00000000..dea27e66
--- /dev/null
+++ b/howto/components.md
@@ -0,0 +1,3 @@
+# Model components
+Konrad is build in a modular way, which allows the user to alter its behaviour
+by replacing various model components.
diff --git a/howto/feedback.md b/howto/feedback.md
new file mode 100644
index 00000000..03a6c34d
--- /dev/null
+++ b/howto/feedback.md
@@ -0,0 +1,109 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+execution:
+  timeout: 300
+---
+
+# Climate feedback
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import netCDF4
+import numpy as np
+import typhon as ty
+
+import konrad
+
+
+ty.plots.styles.use()
+```
+
+## Regression method
+
+Compute the climate feedback as regression of the radiation balance over the surface temperature change (Gregory et al. 2014).
+
+```{code-cell} ipython3
+phlev = konrad.utils.get_quadratic_pgrid(1000e2, 10, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+# Initialize the setup for the radiative-convective equilibrium simulation.
+spinup = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(temperature=295.0),
+    timestep='24h',  # Set timestep in model time.
+    max_duration='150d',  # Set runtime.
+    outfile='spinup.nc',  # Specify output filename.
+)
+spinup.run()  # Start the simulation.
+
+atmosphere["CO2"][:] *= 2.0 # double the CO2 concentration
+
+perturbed = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.SlabOcean(
+        temperature=295.0,
+        heat_sink=spinup.radiation["toa"][-1],
+        depth=10.,
+    ),
+    timestep='12h',  # Set timestep in model time.
+    max_duration='300d',  # Set runtime.
+    outfile='perturbed.nc',  # Specify output filename.
+)
+perturbed.run()  # Start the simulation.
+```
+
+```{code-cell} ipython3
+with netCDF4.Dataset("perturbed.nc", "r") as root:
+    Ts = root["surface/temperature"][:]
+    olr = root["radiation/toa"][:] - root["surface/heat_sink"][0]
+        
+fig, ax = plt.subplots()
+ax.plot(Ts - Ts[0], olr, lw=4)
+p = np.polyfit(Ts[25:] - Ts[0], olr[25:], deg=1)
+ax.axline((0, p[1]), slope=p[0], ls="dashed", color="tab:orange")
+ax.set_xlabel(r"$\Delta T_\mathrm{s}$ / K")
+ax.set_ylabel(r"$\Delta F$ / $\rm Wm^{-2}$")
+ax.set_xlim(0, 4)
+ax.set_ylim(0, 5)
+
+print(f"Climate feedback: {p[0]:.3f} W/m^2/K")
+```
+
+## Fixed temperature method
+
+```{code-cell} ipython3
+phlev = konrad.utils.get_quadratic_pgrid(1000e2, 10, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+cold = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(temperature=295.0),
+    timestep='24h',  # Set timestep in model time.
+    max_duration='150d',  # Set runtime.
+)
+cold.run()  # Start the simulation.
+
+warm = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(temperature=297.0),
+    timestep='24h',  # Set timestep in model time.
+    max_duration='150d',  # Set runtime.
+)
+warm.run()  # Start the simulation.
+
+feedback = (
+    (warm.radiation["toa"][-1] - cold.radiation["toa"][-1]) /
+    (warm.surface["temperature"][-1] - cold.surface["temperature"][-1])
+)
+
+print(f"Climate feedback: {feedback:.3f} W/m^2/K")
+```
diff --git a/howto/forcing.md b/howto/forcing.md
new file mode 100644
index 00000000..68d7917b
--- /dev/null
+++ b/howto/forcing.md
@@ -0,0 +1,73 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Radiative forcing
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import numpy as np
+import typhon as ty
+
+import konrad
+
+
+ty.plots.styles.use()
+```
+
+## Reference climate
+
+In a first step, we equilibrate our model in a reference climate state.
+
+```{code-cell} ipython3
+phlev = konrad.utils.get_quadratic_pgrid(1000e2, 10, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+atmosphere["CO2"][:] = 348e-6 # Set reference CO2 concentration
+
+# Calculate reference OLR.
+spinup = konrad.RCE(atmosphere, timestep='24h', max_duration='150d')
+spinup.run()
+```
+
+After the model has converged, we store the outgoing-longwave radiation at the top-of-the-atmosphere.
+This value is our reference against which we will later compute the radiative forcing.
+
+```{code-cell} ipython3
+olr_ref = spinup.radiation["lw_flxu"][-1, -1]
+```
+
+## Instantanoues forcing
+
+The instantanoues forcing is the change in OLR that is induced by a doubling of the CO2 concentration only.
+In this defintion, no other changes to the atmospheric state - in particular the temperature - are allowed.
+
+```{code-cell} ipython3
+# Calculate OLR at perturbed atmospheric state.
+atmosphere["CO2"][:] *= 2  # double the CO2 concentration
+spinup.radiation.update_heatingrates(atmosphere)
+
+instant_forcing = -(spinup.radiation["lw_flxu"][-1, -1] - olr_ref)
+print(f"Instantanoues forcing: {instant_forcing:.2f} W/m^2")
+```
+
+## Effective forcing
+
+The effective forcing includes the so called "stratospheric adjustment". Due to a significant cooling of the stratosphere, the radiative forcing at the top-of-the-atmosphere is increased.
+The effective forcing is better description of the radiative imbalance that actually forces the troposphere.
+
+```{code-cell} ipython3
+perturbed = konrad.RCE(atmosphere, timestep='24h',max_duration='150d')
+perturbed.run()
+
+effective_forcing = -(perturbed.radiation["lw_flxu"][-1, -1] - olr_ref)
+print(f"Effective forcing: {effective_forcing:.2f} W/m^2")
+```
diff --git a/howto/getting_started.md b/howto/getting_started.md
new file mode 100644
index 00000000..07005bd0
--- /dev/null
+++ b/howto/getting_started.md
@@ -0,0 +1,68 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Getting started
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use('typhon')
+```
+
+At the heart of each `konrad` simulation is the atmosphere component, which represents the thermodynamical state of the model column.
+In a first step, we create a vertical (pressure) grid and initialize the atmosphere.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+```
+
+We can access the state variables in a dict-like way and, for example, plot the initial temperature profile.
+
+```{code-cell} ipython3
+fig, ax = plt.subplots()
+plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
+
+Next, we can compile the RCE object, which combines the different model component and allows the user to control the run.
+
+```{code-cell} ipython3
+# Initialize the setup for the radiative-convective equilibrium simulation.
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+)
+```
+
+After defining our RCE model, we can perform the actual simulation
+
+```{code-cell} ipython3
+rce.run()  # Start the simulation.
+```
+
+Finally, we can plot the RCE state and compare it to the inital (standard) atmopshere
+
+```{code-cell} ipython3
+fig, ax = plt.subplots()
+plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
diff --git a/howto/humidity.md b/howto/humidity.md
new file mode 100644
index 00000000..e1fa863a
--- /dev/null
+++ b/howto/humidity.md
@@ -0,0 +1,101 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Humidity
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use('typhon')
+```
+
+## Fixed relative humidity
+
++++
+
+By default, konrad will preserve the relative humidity in the atmospheric column.
+Internally, this is done by the `FixedRH` component, which will use a given function that presrcibes the vertical distribution of relative humidity.
+There are various pre-defined functions in `konrad.humidity`, for exmaple, a vertically uniform humidity distribution.
+
+```{code-cell} ipython3
+humidity_model = konrad.humidity.FixedRH(
+    rh_func=konrad.humidity.VerticallyUniform(0.7),
+)
+```
+
+Next, we can compile and run our RCE simulation
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    humidity=humidity_model,  # Here, we pass the humidity component that we just created
+    timestep='12h',  # Set timestep in model time.
+    max_duration='150d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+```
+
+The vertical humidity distribution is one of the largest controling factors for the net radiative heating $Q_r$ in the atmosphere.
+$Q_r$ is a decisive quantity in climate science as it destabilizies the atmosphere, which is a premise for convection of air masses.
+
+```{code-cell} ipython3
+fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)
+plots.profile_p_log(atmosphere['plev'], atmosphere['H2O'][-1, :], ax=ax0)
+ax0.set_xlabel(r"$q$ / VMR")
+ax0.set_xscale("log")
+ax0.set_ylabel("$p$ / hPa")
+
+ax1.axvline(0, color="k", linewidth=0.8)
+plots.profile_p_log(atmosphere['plev'], rce.radiation["net_htngrt"][-1, :], ax=ax1)
+ax1.set_xlim(-2, 0.5)
+ax1.set_xlabel(r"$Q_\mathrm{r}$ / (K/day)")
+```
+
+## Fixed absolute humidity
+
+There is also a special class that will keep the absolute amount of water vapor fixed. This can be used to turn off the water-vapor feedback in a simulation, or, to run a simulation without any water vapor at all.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+atmosphere["H2O"][:] = 0.0  # Remove all water-vapor from the atmospheric column
+humidity_model = konrad.humidity.FixedVMR()  # Preserve the absolute humidity
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    humidity=humidity_model,  # Here, we pass the humidity component that we just created
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+
+fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)
+plots.profile_p_log(atmosphere['plev'], atmosphere['H2O'][-1, :], ax=ax0)
+ax0.set_xlabel(r"$q$ / VMR")
+ax0.set_ylabel("$p$ / hPa")
+
+ax1.axvline(0, color="k", linewidth=0.8)
+plots.profile_p_log(atmosphere['plev'], rce.radiation["net_htngrt"][-1, :], ax=ax1)
+ax1.set_xlim(-2, 0.5)
+ax1.set_xlabel(r"$Q_\mathrm{r}$ / (K/day)")
+```
diff --git a/howto/images/konrad-logo.png b/howto/images/konrad-logo.png
new file mode 100644
index 00000000..39f74b61
Binary files /dev/null and b/howto/images/konrad-logo.png differ
diff --git a/howto/images/konrad-logo_64.png b/howto/images/konrad-logo_64.png
new file mode 100644
index 00000000..795e89ac
Binary files /dev/null and b/howto/images/konrad-logo_64.png differ
diff --git a/howto/intro.md b/howto/intro.md
new file mode 100644
index 00000000..2561e988
--- /dev/null
+++ b/howto/intro.md
@@ -0,0 +1,34 @@
+# Introduction
+
+Welcome to _"How to konrad"_! This collection of Python code is meant to serve
+as a brief introduction and overview over the usage of the one-dimensional
+radiative-convective equilibrium (RCE) model konrad.
+
+> The purpose of a model such as ours is not to produce a comprehensive
+> simluation but to gain insight into the behavior of more complex models
+> and, perhaps, into the behaviour of the climate system itself.
+>
+> _Somerville and Remer (1984)_
+
+## Idea
+
+The idea of this book is to guide the user throw their first steps of using
+konrad. The tutorials will introduce various different ways to configure RCE
+simulations and how to use them to gain conceptual insights into the climate
+system.
+
+## Installation
+
+You can install the latest konrad version directly from
+[PyPI](https://pypi.org/project/konrad/) using `pip`:
+```sh
+python3 -m pip install konrad
+```
+
+Please have a look at our [repository](https://github.com/atmtools/konrad) for
+more detailed information on how to install konrad on macOS or for Python 3.9+.
+
+## Useful links
+* [Konrad on Github](https://github.com/atmtools/konrad)
+* [Konrad on PyPI](https://pypi.org/project/konrad/)
+* [Konrad on Zenodo](https://doi.org/10.5281/zenodo.1313687)
diff --git a/howto/lapserate.md b/howto/lapserate.md
new file mode 100644
index 00000000..6f67422f
--- /dev/null
+++ b/howto/lapserate.md
@@ -0,0 +1,106 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+execution:
+  timeout: 180
+---
+
+# Lapse rate
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use('typhon')
+```
+
+After each timestep `konrad` will adjust the atmospheric temperature profile to follow a specified temperature lapse rate.
+Here, we will have a look at some of the different options in `konrad.lapserate`.
+
++++
+
+## Fixed temperature lapse rate
+
+One can specify an arbitrary temperature lapse rate.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+fig, ax = plt.subplots()
+for lapserate in [6.5, 8, 10]:
+    lapserate = konrad.lapserate.FixedLapseRate(lapserate / 1000)  # K/m -> K/km
+
+    rce = konrad.RCE(
+        atmosphere,
+        surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+        lapserate=lapserate,  # Here, we pass the lapserate component that we just created
+        timestep='12h',  # Set timestep in model time.
+        max_duration='100d',  # Set maximum runtime.
+    )
+    rce.run()  # Start the simulation.
+
+    plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
+
+### Dry-adiabatic lapse rate
+There is also a convenience class to represent the dry adiabatic lapse rate.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    lapserate=lapserate,  # Here, we pass the lapserate component that we just created
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+
+fig, ax = plt.subplots()
+plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
+
+## Moist-adiabat
+
++++
+
+There is a special class that will compute the moist-adiabatic lapse rate based on the current temperature profile.
+This way, we can account for a changing lapse rate in a warming climate
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+fig, ax = plt.subplots()
+for Ts in [280, 290, 300]:
+    rce = konrad.RCE(
+        atmosphere,
+        surface=konrad.surface.FixedTemperature(Ts),  # Run with a fixed surface temperature.
+        lapserate=konrad.lapserate.MoistLapseRate(),  # Here, we pass the lapserate component that we just created
+        timestep='12h',  # Set timestep in model time.
+        max_duration='100d',  # Set maximum runtime.
+    )
+    rce.run()  # Start the simulation.
+
+    plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :])
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel("$p$ / hPa")
+```
diff --git a/howto/misc.md b/howto/misc.md
new file mode 100644
index 00000000..c79e3711
--- /dev/null
+++ b/howto/misc.md
@@ -0,0 +1,1 @@
+# Miscellaneous examples
diff --git a/howto/netcdf_output.md b/howto/netcdf_output.md
new file mode 100644
index 00000000..9ddce9d7
--- /dev/null
+++ b/howto/netcdf_output.md
@@ -0,0 +1,62 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+---
+
+# Store netCDF output
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import netCDF4
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use("typhon")
+```
+
+During the configuration of an RCE simulation we can specify an output netCDF file.
+Konrad will create the file and store a snapshot of the instantaneous model state at a given output frequency.
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+    outfile="my_rce_output.nc",  # Specifiy the output file
+    writeevery="5d",  # Set the output frequency
+)
+rce.run()
+```
+
+## Read and visualize model output
+
+After the run has finished, we can use the `netCDF4` package to read the data again.
+Here, we plot the temporal evolution of the temperature profile from the inital US standard atmosphere towards the equilibrium RCE state.
+
+```{code-cell} ipython3
+with netCDF4.Dataset("my_rce_output.nc", "r") as root:
+    p = root["plev"][:]
+    T = root["atmosphere/T"][:]
+
+sm = plt.cm.ScalarMappable(norm=plt.Normalize(0, T.shape[0]), cmap="magma")
+
+fig, ax = plt.subplots()
+for i, temp in enumerate(T):
+    plots.profile_p_log(p, temp, linestyle="solid", color=sm.to_rgba(i))
+ax.set_xlabel(r"$T$ / K")
+ax.set_ylabel(r"$p$ / hPa")
+```
diff --git a/howto/rrtmg_only.md b/howto/rrtmg_only.md
new file mode 100644
index 00000000..d687ad82
--- /dev/null
+++ b/howto/rrtmg_only.md
@@ -0,0 +1,78 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3
+  language: python
+  name: python3
+---
+
+# RRTMG interface
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+import typhon as ty
+
+import konrad
+
+
+konrad.enable_logging()
+
+# Create an atmosphere component.
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 201)
+atmosphere = konrad.atmosphere.Atmosphere(plev)
+
+# It is possible to explicitly set different species (e.g. CO2).
+atmosphere['CO2'][:] = 348e-6
+
+# Create a surface component (T and p of the lowest atmosphere level are interpolated).
+surface = konrad.surface.SlabOcean.from_atmosphere(atmosphere)
+
+# Create cloud component (here clear-sky).
+cloud = konrad.cloud.ClearSky.from_atmosphere(atmosphere)
+
+# Setup the RRTMG radiation component (choose zenith angle and solar constant).
+rrtmg = konrad.radiation.RRTMG(zenith_angle=47.88)
+rrtmg.calc_radiation(atmosphere, surface, cloud)  # Actual RT simulation
+```
+
+## Plot radiative fluxes
+
+```{code-cell} ipython3
+plt.style.use(ty.plots.styles('typhon'))
+fig, ax = plt.subplots()
+ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['sw_flxu'][-1, :],
+                       label='SW Up', color='skyblue', ls='solid')
+ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['sw_flxd'][-1, :],
+                       label='SW Down', color='skyblue', ls='dashed')
+ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['lw_flxu'][-1, :],
+                       label='LW Up', color='orangered', ls='solid')
+ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['lw_flxd'][-1, :],
+                       label='LW Down', color='orangered', ls='dashed')
+ax.legend(loc='upper right')
+ax.set_xlabel('Radiative flux [$\sf W/m^2$]')
+```
+
+## Plot radiative heating
+
+```{code-cell} ipython3
+# Plot the calculated fluxes.
+plt.style.use(ty.plots.styles('typhon'))
+fig, ax = plt.subplots()
+ax.axvline(0, color='black', linewidth=0.8)
+ty.plots.profile_p_log(atmosphere['plev'], rrtmg['sw_htngrt'][-1, :],
+                       label='SW', color='skyblue')
+ty.plots.profile_p_log(atmosphere['plev'], rrtmg['lw_htngrt'][-1, :],
+                       label='LW', color='orangered')
+ax.legend(loc='upper right')
+ax.set_xlabel('Radiative heating [K/day]')
+ax.set_xlim(-12, 12)
+```
+
+```{code-cell} ipython3
+
+```
diff --git a/howto/surface.md b/howto/surface.md
new file mode 100644
index 00000000..b8e61adf
--- /dev/null
+++ b/howto/surface.md
@@ -0,0 +1,81 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.10.3
+kernelspec:
+  display_name: Python 3 (ipykernel)
+  language: python
+  name: python3
+execution:
+  timeout: 180
+---
+
+# Surface
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+from typhon import plots
+
+import konrad
+
+
+plots.styles.use('typhon')
+```
+
+## Fixed surface temperature
+
+The simplest representatio of a surface in `konrad` is the fixed surface temperature.
+It is defined by an albedo and a prescribed temperature.
+
+```{code-cell} ipython3
+surface = konrad.surface.FixedTemperature(288., albedo=0.3)
+```
+
+When using a fixed surface temperature, the atmosphere component will converge to a consistent equilibrium quite fast (order of ~100 days)
+
+```{code-cell} ipython3
+plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 128)
+atmosphere = konrad.atmosphere.Atmosphere(phlev)
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=konrad.surface.FixedTemperature(288.),  # Run with a fixed surface temperature.
+    timestep='12h',  # Set timestep in model time.
+    max_duration='100d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+```
+
+## Adjustable slab ocean
+
+In addition, `konrad` provides a slab surface component. In contrast to the fixed surface temperature, the slab surface will adjust it's temperature depending on the net energy budget at the surface layer.
+This energy consists of the net radiative fluxes as wel las an enthalpy sink that can be thought of as heat transport in the ocean layer (e.g. by ocean currents to the extra-tropics).
+The value of the heat sink can be chosen to tune the energy budget. Here, we set it equal to the net energy balance at top-of-the-atmosphere from the previous fixed temperature run. This way, the model should be in equilibrium even if the surface temperature is allows to change.
+
+```{code-cell} ipython3
+slab = konrad.surface.SlabOcean(
+    temperature=rce.surface["temperature"][-1],
+    heat_sink=rce.radiation["toa"][-1],
+)
+```
+
+Using the slab surface we can force our model with a doubling of CO2 and see the temperature slowly changing.
+
+```{code-cell} ipython3
+atmosphere["CO2"][:] *= 2
+
+print("Initial temperature: ", slab["temperature"][0])
+
+rce = konrad.RCE(
+    atmosphere,
+    surface=slab,  # Run with a fixed surface temperature.
+    timestep='12h',  # Set timestep in model time.
+    max_duration='300d',  # Set maximum runtime.
+)
+rce.run()  # Start the simulation.
+
+print("Temperature after 300 days: ", slab["temperature"][0])
+```
diff --git a/konrad/__init__.py b/konrad/__init__.py
index 61b22e2b..6fe34bfc 100644
--- a/konrad/__init__.py
+++ b/konrad/__init__.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This package aims to provide a framework to run radiative-convective
 equilibrium (RCE) simulations.
 
@@ -11,7 +10,7 @@
 """
 import logging
 import warnings
-from os.path import (join, dirname)
+from os.path import join, dirname
 
 # Mute annoying `FutureWarning` within Sympl.
 warnings.filterwarnings(
@@ -20,7 +19,7 @@
     module="sympl",
 )
 
-__version__ = open(join(dirname(__file__), 'VERSION')).read().strip()
+__version__ = open(join(dirname(__file__), "VERSION")).read().strip()
 
 from . import atmosphere
 from . import cloud
@@ -33,7 +32,6 @@
 from . import netcdf
 from . import ozone
 from . import physics
-from . import plots
 from . import radiation
 from . import surface
 from . import upwelling
@@ -51,7 +49,7 @@ def enable_logging():
     """
     logging.basicConfig(
         level=logging.INFO,
-        datefmt='%Y-%m-%d %H:%M:%S',
-        style='{',  # Allows to use format string syntax in the next line.
-        format='{asctime} {processName}:{levelname}:{name}:{message}',
-        )
+        datefmt="%Y-%m-%d %H:%M:%S",
+        style="{",  # Allows to use format string syntax in the next line.
+        format="{asctime} {processName}:{levelname}:{name}:{message}",
+    )
diff --git a/konrad/cloud.py b/konrad/cloud.py
index c743a54a..6fa68c57 100644
--- a/konrad/cloud.py
+++ b/konrad/cloud.py
@@ -47,16 +47,16 @@
 
 
 __all__ = [
-    'get_rectangular_profile',
-    'Cloud',
-    'ClearSky',
-    'DirectInputCloud',
-    'PhysicalCloud',
-    'HighCloud',
-    'MidLevelCloud',
-    'LowCloud',
-    'ConceptualCloud',
-    'CloudEnsemble',
+    "get_rectangular_profile",
+    "Cloud",
+    "ClearSky",
+    "DirectInputCloud",
+    "PhysicalCloud",
+    "HighCloud",
+    "MidLevelCloud",
+    "LowCloud",
+    "ConceptualCloud",
+    "CloudEnsemble",
 ]
 
 
@@ -89,14 +89,22 @@ class Cloud(Component, metaclass=abc.ABCMeta):
     #: number of shortwave bands used in the radiation scheme
     num_shortwave_bands = 14
 
-    def __init__(self, numlevels, cloud_fraction=0, mass_ice=0, mass_water=0,
-                 ice_particle_size=20, droplet_radius=10,
-                 lw_optical_thickness=0, sw_optical_thickness=0,
-                 forward_scattering_fraction=0, asymmetry_parameter=0.85,
-                 single_scattering_albedo=0.9,
-                 rrtmg_cloud_optical_properties='liquid_and_ice_clouds',
-                 rrtmg_cloud_ice_properties='ebert_curry_two',
-                 ):
+    def __init__(
+        self,
+        numlevels,
+        cloud_fraction=0,
+        mass_ice=0,
+        mass_water=0,
+        ice_particle_size=20,
+        droplet_radius=10,
+        lw_optical_thickness=0,
+        sw_optical_thickness=0,
+        forward_scattering_fraction=0,
+        asymmetry_parameter=0.85,
+        single_scattering_albedo=0.9,
+        rrtmg_cloud_optical_properties="liquid_and_ice_clouds",
+        rrtmg_cloud_ice_properties="ebert_curry_two",
+    ):
         """Create a cloud. Which of the input parameters are used and which
         ignored depends on the set-up of the radiation scheme.
 
@@ -167,22 +175,23 @@ def __init__(self, numlevels, cloud_fraction=0, mass_ice=0, mass_water=0,
         self.numlevels = numlevels
 
         self.coords = {
-            'mid_levels': np.arange(self.numlevels),
-            'num_longwave_bands': np.arange(self.num_longwave_bands),
-            'num_shortwave_bands': np.arange(self.num_shortwave_bands),
+            "mid_levels": np.arange(self.numlevels),
+            "num_longwave_bands": np.arange(self.num_longwave_bands),
+            "num_shortwave_bands": np.arange(self.num_shortwave_bands),
         }
 
         physical_props = {
-            'mass_content_of_cloud_liquid_water_in_atmosphere_layer':
-                (mass_water, 'kg m^-2'),
-            'mass_content_of_cloud_ice_in_atmosphere_layer':
-                (mass_ice, 'kg m^-2'),
-            'cloud_area_fraction_in_atmosphere_layer':
-                (cloud_fraction, 'dimensionless'),
-            'cloud_ice_particle_size':
-                (ice_particle_size, 'micrometers'),
-            'cloud_water_droplet_radius':
-                (droplet_radius, 'micrometers'),
+            "mass_content_of_cloud_liquid_water_in_atmosphere_layer": (
+                mass_water,
+                "kg m^-2",
+            ),
+            "mass_content_of_cloud_ice_in_atmosphere_layer": (mass_ice, "kg m^-2"),
+            "cloud_area_fraction_in_atmosphere_layer": (
+                cloud_fraction,
+                "dimensionless",
+            ),
+            "cloud_ice_particle_size": (ice_particle_size, "micrometers"),
+            "cloud_water_droplet_radius": (droplet_radius, "micrometers"),
         }
 
         for name, (var, unit) in physical_props.items():
@@ -190,16 +199,27 @@ def __init__(self, numlevels, cloud_fraction=0, mass_ice=0, mass_water=0,
             self[name] = dataarray.dims, dataarray
 
         cloud_optics = {
-            'longwave_optical_thickness_due_to_cloud':
-                (lw_optical_thickness, 'dimensionless', False),
-            'cloud_forward_scattering_fraction':
-                (forward_scattering_fraction, 'dimensionless', True),
-            'cloud_asymmetry_parameter':
-                (asymmetry_parameter, 'dimensionless', True),
-            'shortwave_optical_thickness_due_to_cloud':
-                (sw_optical_thickness, 'dimensionless', True),
-            'single_scattering_albedo_due_to_cloud':
-                (single_scattering_albedo, 'dimensionless', True),
+            "longwave_optical_thickness_due_to_cloud": (
+                lw_optical_thickness,
+                "dimensionless",
+                False,
+            ),
+            "cloud_forward_scattering_fraction": (
+                forward_scattering_fraction,
+                "dimensionless",
+                True,
+            ),
+            "cloud_asymmetry_parameter": (asymmetry_parameter, "dimensionless", True),
+            "shortwave_optical_thickness_due_to_cloud": (
+                sw_optical_thickness,
+                "dimensionless",
+                True,
+            ),
+            "single_scattering_albedo_due_to_cloud": (
+                single_scattering_albedo,
+                "dimensionless",
+                True,
+            ),
         }
 
         for name, (var, unit, is_sw) in cloud_optics.items():
@@ -209,62 +229,62 @@ def __init__(self, numlevels, cloud_fraction=0, mass_ice=0, mass_water=0,
         self._rrtmg_cloud_optical_properties = rrtmg_cloud_optical_properties
         self._rrtmg_cloud_ice_properties = rrtmg_cloud_ice_properties
 
-    def get_p_data_array(self, values, units='kg m^-2'):
+    def get_p_data_array(self, values, units="kg m^-2"):
         """Return a DataArray of values."""
         if isinstance(values, DataArray):
             return values
         elif isinstance(values, np.ndarray):
             if values.shape != (self.numlevels,):
                 raise ValueError(
-                    'shape mismatch: Shape of cloud parameter input array '
-                    f'{values.shape} is not compatible with number of model '
-                    f'levels ({self.numlevels},).'
+                    "shape mismatch: Shape of cloud parameter input array "
+                    f"{values.shape} is not compatible with number of model "
+                    f"levels ({self.numlevels},)."
                 )
         elif isinstance(values, numbers.Number):
-            values = values * np.ones(self.numlevels,)
+            values = values * np.ones(
+                self.numlevels,
+            )
         else:
             raise TypeError(
-                'Cloud variable input must be a single value, '
-                '`numpy.ndarray` or a `sympl.DataArray`'
+                "Cloud variable input must be a single value, "
+                "`numpy.ndarray` or a `sympl.DataArray`"
             )
 
-        return DataArray(values, dims=('mid_levels',), attrs={'units': units})
+        return DataArray(values, dims=("mid_levels",), attrs={"units": units})
 
-    def get_waveband_data_array(self, values, units='dimensionless', sw=True):
+    def get_waveband_data_array(self, values, units="dimensionless", sw=True):
         """Return a DataArray of values."""
         if isinstance(values, DataArray):
             return values
 
         if sw:
-            dims = ('mid_levels', 'num_shortwave_bands')
+            dims = ("mid_levels", "num_shortwave_bands")
             numbands = self.num_shortwave_bands
         else:
-            dims = ('mid_levels', 'num_longwave_bands')
+            dims = ("mid_levels", "num_longwave_bands")
             numbands = self.num_longwave_bands
 
         if isinstance(values, numbers.Number):
             values = values * np.ones((self.numlevels, numbands))
         elif isinstance(values, np.ndarray):
             if values.shape == (self.numlevels,):
-                values = np.repeat(
-                    values[:, np.newaxis], numbands, axis=1)
+                values = np.repeat(values[:, np.newaxis], numbands, axis=1)
             elif values.shape == (numbands,):
-                values = np.repeat(
-                    values[np.newaxis, :], self.numlevels, axis=0)
+                values = np.repeat(values[np.newaxis, :], self.numlevels, axis=0)
             elif not values.shape == (self.numlevels, numbands):
                 raise ValueError(
-                    f'shape mismatch: input array of shape {values.shape} '
-                    'is not supported. Allowed shapes are: '
-                    f'({self.numlevels},), ({numbands},), or '
-                    f'({self.numlevels}, {numbands}).'
+                    f"shape mismatch: input array of shape {values.shape} "
+                    "is not supported. Allowed shapes are: "
+                    f"({self.numlevels},), ({numbands},), or "
+                    f"({self.numlevels}, {numbands})."
                 )
         else:
             raise TypeError(
-                'Cloud variable input must be a single value, '
-                '`numpy.ndarray` or a `sympl.DataArray`'
+                "Cloud variable input must be a single value, "
+                "`numpy.ndarray` or a `sympl.DataArray`"
             )
 
-        return DataArray(values, dims=dims, attrs={'units': units})
+        return DataArray(values, dims=dims, attrs={"units": units})
 
     @classmethod
     def from_atmosphere(cls, atmosphere, **kwargs):
@@ -275,11 +295,10 @@ def from_atmosphere(cls, atmosphere, **kwargs):
                 Atmosphere component.
 
         """
-        return cls(numlevels=atmosphere['plev'].size, **kwargs)
+        return cls(numlevels=atmosphere["plev"].size, **kwargs)
 
     @abc.abstractmethod
-    def update_cloud_profile(self, atmosphere, convection, radiation,
-                             **kwargs):
+    def update_cloud_profile(self, atmosphere, convection, radiation, **kwargs):
         """Return the cloud parameters for the radiation scheme.
         Parameters:
             atmosphere (konrad.atmosphere.Atmosphere): atmosphere model
@@ -289,15 +308,15 @@ def update_cloud_profile(self, atmosphere, convection, radiation,
 
     def overcast(self):
         """Set cloud fraction in cloud layers to ``1`` (full overcast)."""
-        cloud_fraction = self['cloud_area_fraction_in_atmosphere_layer'][:]
+        cloud_fraction = self["cloud_area_fraction_in_atmosphere_layer"][:]
         cloud_mask = (cloud_fraction > 0).astype(float)
 
-        self['cloud_area_fraction_in_atmosphere_layer'][:] = cloud_mask
+        self["cloud_area_fraction_in_atmosphere_layer"][:] = cloud_mask
 
 
 class ClearSky(Cloud):
-    """No cloud.
-    """
+    """No cloud."""
+
     def update_cloud_profile(self, *args, **kwargs):
         return
 
@@ -309,8 +328,16 @@ class PhysicalCloud(Cloud):
     and particle size.  To be used with
     cloud_optical_properties='liquid_and_ice_clouds' in climt/RRTMG.
     """
-    def __init__(self, numlevels, cloud_fraction, mass_water, mass_ice,
-                 ice_particle_size, droplet_radius):
+
+    def __init__(
+        self,
+        numlevels,
+        cloud_fraction,
+        mass_water,
+        mass_ice,
+        ice_particle_size,
+        droplet_radius,
+    ):
         """Initialize a cloud component.
 
         Parameters:
@@ -332,30 +359,38 @@ def __init__(self, numlevels, cloud_fraction, mass_water, mass_ice,
             mass_water=mass_water,
             ice_particle_size=ice_particle_size,
             droplet_radius=droplet_radius,
-            rrtmg_cloud_optical_properties='liquid_and_ice_clouds'
+            rrtmg_cloud_optical_properties="liquid_and_ice_clouds",
         )
 
     def update_cloud_profile(self, *args, **kwargs):
-        """Keep the cloud fixed with pressure. """
+        """Keep the cloud fixed with pressure."""
         return
 
 
 class DirectInputCloud(Cloud):
-    """ To be used with cloud_optical_properties='direct_input' in climt/RRTMG.
-    """
+    """To be used with cloud_optical_properties='direct_input' in climt/RRTMG."""
+
     direct_input_parameters = {
-        'cloud_area_fraction_in_atmosphere_layer',
-        'longwave_optical_thickness_due_to_cloud',
-        'cloud_forward_scattering_fraction',
-        'cloud_asymmetry_parameter',
-        'shortwave_optical_thickness_due_to_cloud',
-        'single_scattering_albedo_due_to_cloud',
+        "cloud_area_fraction_in_atmosphere_layer",
+        "longwave_optical_thickness_due_to_cloud",
+        "cloud_forward_scattering_fraction",
+        "cloud_asymmetry_parameter",
+        "shortwave_optical_thickness_due_to_cloud",
+        "single_scattering_albedo_due_to_cloud",
     }
 
-    def __init__(self, numlevels, cloud_fraction, lw_optical_thickness,
-                 sw_optical_thickness, coupling='convective_top',
-                 forward_scattering_fraction=0, asymmetry_parameter=0.85,
-                 single_scattering_albedo=0.9, norm_index=None):
+    def __init__(
+        self,
+        numlevels,
+        cloud_fraction,
+        lw_optical_thickness,
+        sw_optical_thickness,
+        coupling="convective_top",
+        forward_scattering_fraction=0,
+        asymmetry_parameter=0.85,
+        single_scattering_albedo=0.9,
+        norm_index=None,
+    ):
 
         """Define a cloud based on properties that are directly used by the
         radiation scheme, namely cloud optical depth and scattering parameters.
@@ -395,7 +430,7 @@ def __init__(self, numlevels, cloud_fraction, lw_optical_thickness,
             forward_scattering_fraction=forward_scattering_fraction,
             asymmetry_parameter=asymmetry_parameter,
             single_scattering_albedo=single_scattering_albedo,
-            rrtmg_cloud_optical_properties='direct_input'
+            rrtmg_cloud_optical_properties="direct_input",
         )
 
         self._norm_index = norm_index
@@ -405,18 +440,12 @@ def __init__(self, numlevels, cloud_fraction, lw_optical_thickness,
     def __add__(self, other):
         """Define the superposition of two clouds in a layer."""
         name_map = (
-            ('cloud_fraction',
-             'cloud_area_fraction_in_atmosphere_layer'),
-            ('lw_optical_thickness',
-             'longwave_optical_thickness_due_to_cloud'),
-            ('sw_optical_thickness',
-             'shortwave_optical_thickness_due_to_cloud'),
-            ('forward_scattering_fraction',
-             'cloud_forward_scattering_fraction'),
-            ('asymmetry_parameter',
-             'cloud_asymmetry_parameter'),
-            ('single_scattering_albedo',
-             'single_scattering_albedo_due_to_cloud'),
+            ("cloud_fraction", "cloud_area_fraction_in_atmosphere_layer"),
+            ("lw_optical_thickness", "longwave_optical_thickness_due_to_cloud"),
+            ("sw_optical_thickness", "shortwave_optical_thickness_due_to_cloud"),
+            ("forward_scattering_fraction", "cloud_forward_scattering_fraction"),
+            ("asymmetry_parameter", "cloud_asymmetry_parameter"),
+            ("single_scattering_albedo", "single_scattering_albedo_due_to_cloud"),
         )
 
         # The superposition of two clouds is implemented following a
@@ -424,8 +453,8 @@ def __add__(self, other):
         # For each cloud layer, the properties of the bigger cloud (in terms
         # of cloud fraction) is used.
         other_is_bigger = (
-                other['cloud_area_fraction_in_atmosphere_layer']
-                > self['cloud_area_fraction_in_atmosphere_layer']
+            other["cloud_area_fraction_in_atmosphere_layer"]
+            > self["cloud_area_fraction_in_atmosphere_layer"]
         )
 
         kwargs = {}
@@ -439,7 +468,7 @@ def __add__(self, other):
         return summed_cloud
 
     def interpolation_function(self, cloud_parameter):
-        """ Calculate the interpolation function, to be used to maintain the
+        """Calculate the interpolation function, to be used to maintain the
         cloud optical properties and keep the cloud attached to a normalisation
         level (self._norm_index). A separate interpolation function is required
         for each cloud parameter that needs to be interpolated.
@@ -489,7 +518,8 @@ def shift_cloud_profile(self, norm_new):
         for varname in self.direct_input_parameters:
             if varname not in self._interp_cache:
                 self._interp_cache[varname] = self.interpolation_function(
-                    cloud_parameter=self[varname])
+                    cloud_parameter=self[varname]
+                )
 
             self[varname][:] = self.shift_property(
                 cloud_parameter=self[varname],
@@ -497,60 +527,28 @@ def shift_cloud_profile(self, norm_new):
                 norm_new=norm_new,
             )
 
-    def update_cloud_profile(self, atmosphere, convection, radiation,
-                             **kwargs):
-        """Keep the cloud profile fixed with model level (pressure). """
-        if self.coupling == 'convective_top':
-            self.shift_cloud_profile(
-                norm_new=convection.get('convective_top_index')[0]
-            )
-        elif self.coupling == 'freezing_level':
+    def update_cloud_profile(self, atmosphere, convection, radiation, **kwargs):
+        """Keep the cloud profile fixed with model level (pressure)."""
+        if self.coupling == "convective_top":
+            self.shift_cloud_profile(norm_new=convection.get("convective_top_index")[0])
+        elif self.coupling == "freezing_level":
             self.shift_cloud_profile(
                 norm_new=atmosphere.get_triple_point_index(),
             )
-        elif self.coupling == 'subsidence_divergence':
-            Qr = radiation['net_htngrt_clr'][-1]
+        elif self.coupling == "subsidence_divergence":
+            Qr = radiation["net_htngrt_clr"][-1]
             self.shift_cloud_profile(
                 norm_new=atmosphere.get_subsidence_convergence_max_index(Qr),
             )
-        elif self.coupling == 'pressure':
+        elif self.coupling == "pressure":
             return
         else:
             raise ValueError(
-                'The cloud class has been initialized with an invalid '
-                'cloud coupling mechanism.'
+                "The cloud class has been initialized with an invalid "
+                "cloud coupling mechanism."
             )
 
 
-class HighCloud(DirectInputCloud):
-    """Representation of a high-level cloud.
-
-    High-level clouds are coupled to the convective top by default. Another
-    reasonable option is a coupling to the level of maximum diabatic
-    subsidence divergence (`"subsidence_divergence"`).
-    """
-    def __init__(self, *args, coupling='convective_top', **kwargs):
-        super().__init__(*args, coupling=coupling, **kwargs)
-
-
-class MidLevelCloud(DirectInputCloud):
-    """Representation of a mid-level cloud.
-
-    Mid-level clouds are coupled to the freezing level.
-    """
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, coupling='freezing_level', **kwargs)
-
-
-class LowCloud(DirectInputCloud):
-    """Representation of a low-level cloud.
-
-    Low-level clouds are fixed in pressure coordinates.
-    """
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, coupling='pressure', **kwargs)
-
-
 class ConceptualCloud(DirectInputCloud):
     def __init__(
         self,
@@ -559,9 +557,9 @@ def __init__(
         depth,
         cloud_fraction,
         water_path=100e-3,
-        particle_size=100.,
-        phase='ice',
-        coupling='pressure'
+        particle_size=100.0,
+        phase="ice",
+        coupling="pressure",
     ):
         """Initialize a conceptual cloud.
 
@@ -587,7 +585,7 @@ def __init__(
 
         """
         super().__init__(
-            numlevels=atmosphere['plev'].size,
+            numlevels=atmosphere["plev"].size,
             cloud_fraction=np.nan,
             lw_optical_thickness=np.nan,
             sw_optical_thickness=np.nan,
@@ -609,27 +607,30 @@ def get_cloud_optical_properties(self, water_content):
         cld_opt_props = EchamCloudOptics()
 
         return cld_opt_props.get_cloud_properties(
-            self.particle_size, water_content, self.phase)
+            self.particle_size, water_content, self.phase
+        )
 
     @classmethod
     def from_atmosphere(cls, atmosphere, **kwargs):
-        return cls(atmosphere['plev'].size, **kwargs)
+        return cls(atmosphere["plev"].size, **kwargs)
 
     def update_cloud_top_plev(self, atmosphere, convection=None, radiation=None):
         """Determine cloud top pressure depending on coupling mechanism."""
-        if self.coupling.lower() == 'pressure':
+        if self.coupling.lower() == "pressure":
             return
-        elif self.coupling.lower() == 'convective_top':
+        elif self.coupling.lower() == "convective_top":
             if convection is not None:
-                self.cloud_top = convection.get('convective_top_plev')[0]
-        elif self.coupling.lower() == 'freezing_level':
+                self.cloud_top = convection.get("convective_top_plev")[0]
+        elif self.coupling.lower() == "freezing_level":
             self["cloud_top"][:] = atmosphere.get_triple_point_plev()
             self["cloud_top"][:] -= self.depth / 2  # Center around freezing level
-        elif self.coupling.lower() == 'subsidence_divergence':
+        elif self.coupling.lower() == "subsidence_divergence":
             if radiation is not None:
-                Qr = radiation['net_htngrt_clr'][-1]
-                self["cloud_top"][:] = atmosphere.get_subsidence_convergence_max_plev(Qr)
-        elif self.coupling.lower().startswith('temperature'):
+                Qr = radiation["net_htngrt_clr"][-1]
+                self["cloud_top"][:] = atmosphere.get_subsidence_convergence_max_plev(
+                    Qr
+                )
+        elif self.coupling.lower().startswith("temperature"):
             # Retrieve target temperature from keyword.
             threshold = float(self.coupling.split(":")[-1])
 
@@ -643,8 +644,8 @@ def update_cloud_top_plev(self, atmosphere, convection=None, radiation=None):
             self["cloud_top"][:] = atmosphere["plev"][idx]
         else:
             raise ValueError(
-                'The cloud class has been initialized with an invalid '
-                'cloud coupling mechanism.'
+                "The cloud class has been initialized with an invalid "
+                "cloud coupling mechanism."
             )
 
     def update_cloud_top_temperature(self, atmosphere):
@@ -654,30 +655,99 @@ def update_cloud_top_temperature(self, atmosphere):
 
         self["cloud_top_temperature"][:] = T[np.abs(p - self["cloud_top"]).argmin()]
 
-    def update_cloud_profile(self, atmosphere, convection=None, radiation=None, **kwargs):
+    def update_cloud_profile(
+        self, atmosphere, convection=None, radiation=None, **kwargs
+    ):
         """Update the cloud profile depending on the atmospheric state."""
         self.update_cloud_top_plev(atmosphere, convection, radiation)
         self.update_cloud_top_temperature(atmosphere)
 
         is_cloud = np.logical_and(
-            atmosphere['plev'] > self["cloud_top"],
-            atmosphere['plev'] < self["cloud_top"] + self.depth,
+            atmosphere["plev"] > self["cloud_top"],
+            atmosphere["plev"] < self["cloud_top"] + self.depth,
         ).astype(bool)
 
-        self['cloud_area_fraction_in_atmosphere_layer'][:] = (
+        self["cloud_area_fraction_in_atmosphere_layer"][:] = (
             self.cloud_fraction * is_cloud
         )
 
         water_content_per_Layer = self.water_path / np.sum(is_cloud)
 
         cloud_optics = self.get_cloud_optical_properties(
-            water_content=water_content_per_Layer)
+            water_content=water_content_per_Layer
+        )
 
         for name in cloud_optics.data_vars:
             self[name][:, :] = 0
             self[name][is_cloud, :] = cloud_optics[name]
 
 
+class HighCloud(ConceptualCloud):
+    """Representation of a high-level cloud.
+
+    High-level clouds are coupled to the maximum diabatic subsidence divergence.
+    """
+
+    def __init__(self, atmosphere, **kwargs):
+        """Initialize a conceputal high cloud."""
+        default_kwargs = dict(
+            cloud_top=175e2,
+            depth=100e2,
+            cloud_fraction=0.1,
+            water_path=10.0,
+            particle_size=100,
+            phase="ice",
+            coupling="subsidence_divergence",
+        )
+        default_kwargs.update(kwargs)
+
+        super().__init__(atmosphere, **default_kwargs)
+
+
+class MidLevelCloud(ConceptualCloud):
+    """Representation of a mid-level cloud.
+
+    Mid-level clouds are coupled to the freezing level.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize a conceputal mid-level cloud."""
+        default_kwargs = dict(
+            cloud_top=550e2,
+            depth=100e2,
+            cloud_fraction=0.1,
+            water_path=100.0,
+            particle_size=100,
+            phase="ice",
+            coupling="freezing_level",
+        )
+        default_kwargs.update(kwargs)
+
+        super().__init__(atmosphere, **default_kwargs)
+
+
+class LowCloud(ConceptualCloud):
+    """Representation of a low-level cloud.
+
+    Low-level clouds are fixed in pressure coordinates.
+    """
+
+    def __init__(self, *args, **kwargs):
+        """Initialize a conceputal low-level cloud."""
+        default_kwargs = dict(
+            cloud_top=850e2,
+            depth=100e2,
+            cloud_fraction=0.1,
+            water_path=100.0,
+            particle_size=10.0,
+            phase="liquid",
+            coupling="pressure",
+        )
+        default_kwargs.update(kwargs)
+
+        super().__init__(atmosphere, **default_kwargs)
+
+
 class CloudEnsemble(DirectInputCloud):
     """Wrapper to combine several clouds into a cloud ensemble.
 
@@ -692,10 +762,10 @@ class CloudEnsemble(DirectInputCloud):
     >>> cloud_ensemble.cloud_area_fraction_in_atmosphere_layer
 
     """
+
     def __init__(self, *args):
         if not all([isinstance(a, DirectInputCloud) for a in args]):
-            raise ValueError(
-                'Only `DirectInputCloud`s can be combined in an ensemble.')
+            raise ValueError("Only `DirectInputCloud`s can be combined in an ensemble.")
         else:
             self._clouds = np.asarray(args)
 
@@ -705,7 +775,7 @@ def __init__(self, *args):
         self.coords = self._superposition.coords
 
     def __getattr__(self, name):
-        if name.startswith('__'):
+        if name.startswith("__"):
             raise AttributeError
 
         return getattr(self._superposition, name)
@@ -730,7 +800,7 @@ def data_vars(self):
     @property
     def netcdf_subgroups(self):
         """Dynamically create a netCDF subgroup for each cloud."""
-        return {f"cloud-{i}": cloud for i, cloud in enumerate( self._clouds)}
+        return {f"cloud-{i}": cloud for i, cloud in enumerate(self._clouds)}
 
     def update_cloud_profile(self, *args, **kwargs):
         """Update every cloud in the cloud ensemble."""
@@ -742,9 +812,7 @@ def update_cloud_profile(self, *args, **kwargs):
     def get_combinations(self):
         """Get all combinations of overlapping cloud layers."""
         if not all([isinstance(c, ConceptualCloud) for c in self._clouds]):
-            raise TypeError(
-                'Only `ConceptualCloud`s can be combined.'
-            )
+            raise TypeError("Only `ConceptualCloud`s can be combined.")
 
         bool_index, combined_weights = utils.calculate_combined_weights(
             weights=[cld.cloud_fraction for cld in self._clouds]
@@ -753,12 +821,14 @@ def get_combinations(self):
         clouds = []
         for (i, p) in zip(bool_index, combined_weights):
             if not any(i):
-                clouds.append(DirectInputCloud(
-                    numlevels=self.coords['mid_levels'].size,
-                    cloud_fraction=0.,
-                    lw_optical_thickness=0.,
-                    sw_optical_thickness=0.,
-                ))
+                clouds.append(
+                    DirectInputCloud(
+                        numlevels=self.coords["mid_levels"].size,
+                        cloud_fraction=0.0,
+                        lw_optical_thickness=0.0,
+                        sw_optical_thickness=0.0,
+                    )
+                )
             else:
                 composed_clouds = np.sum(self._clouds[i])
                 composed_clouds.overcast()
diff --git a/konrad/cloudoptics.py b/konrad/cloudoptics.py
index bbaf2894..1a34b2f5 100644
--- a/konrad/cloudoptics.py
+++ b/konrad/cloudoptics.py
@@ -1,5 +1,5 @@
 """Cloud optical properties from ECHAM."""
-from os.path import (dirname, join)
+from os.path import dirname, join
 
 import numpy as np
 import xarray as xr
@@ -8,29 +8,30 @@
 
 class EchamCloudOptics:
     """Interface to interpolate cloud optical properties used in ECHAM."""
+
     def __init__(self):
         self.database = xr.open_dataset(
-            join(dirname(__file__), 'data', 'ECHAM6_CldOptProps.nc')
+            join(dirname(__file__), "data", "ECHAM6_CldOptProps.nc")
         )
 
-    def interp_ice_properties(self, particle_size=100., kind='linear'):
+    def interp_ice_properties(self, particle_size=100.0, kind="linear"):
         x = self.database.re_crystal
 
         r = interp1d(
             x,
-            self.database[f'co_albedo_crystal'],
+            self.database[f"co_albedo_crystal"],
             axis=1,
             kind=kind,
         )
         s = interp1d(
             x,
-            self.database[f'asymmetry_factor_crystal'],
+            self.database[f"asymmetry_factor_crystal"],
             axis=1,
             kind=kind,
         )
         t = interp1d(
             x,
-            self.database[f'extinction_per_mass_crystal'],
+            self.database[f"extinction_per_mass_crystal"],
             axis=1,
             kind=kind,
         )
@@ -42,26 +43,26 @@ def interp_ice_properties(self, particle_size=100., kind='linear'):
             t(particle_size)[:16],  # LW bands
         )
 
-    def interp_liquid_properties(self, particle_size=10., kind='linear'):
+    def interp_liquid_properties(self, particle_size=10.0, kind="linear"):
         x = self.database.re_droplet
 
         r = interp1d(
             x,
-            self.database[f'co_albedo_droplet'],
+            self.database[f"co_albedo_droplet"],
             axis=1,
-            kind='linear',
+            kind="linear",
         )
         s = interp1d(
             x,
-            self.database[f'asymmetry_factor_droplet'],
+            self.database[f"asymmetry_factor_droplet"],
             axis=1,
-            kind='linear',
+            kind="linear",
         )
         t = interp1d(
             x,
-            self.database[f'extinction_per_mass_droplet'],
+            self.database[f"extinction_per_mass_droplet"],
             axis=1,
-            kind='linear',
+            kind="linear",
         )
 
         return (
@@ -71,42 +72,44 @@ def interp_liquid_properties(self, particle_size=10., kind='linear'):
             t(particle_size)[:16],
         )
 
-    def get_cloud_properties(self, particle_size, water_path, phase='ice'):
-        if phase == 'ice':
-            ssa, asym, tau_sw, tau_lw = self.interp_ice_properties(
-                particle_size)
-        elif phase == 'liquid':
-            ssa, asym, tau_sw, tau_lw = self.interp_liquid_properties(
-                particle_size)
+    def get_cloud_properties(self, particle_size, water_path, phase="ice"):
+        if phase == "ice":
+            ssa, asym, tau_sw, tau_lw = self.interp_ice_properties(particle_size)
+        elif phase == "liquid":
+            ssa, asym, tau_sw, tau_lw = self.interp_liquid_properties(particle_size)
         else:
-            raise ValueError(
-                'Invalid phase. Allowed values are "ice" and "liquid".')
+            raise ValueError('Invalid phase. Allowed values are "ice" and "liquid".')
 
         cld_optics = xr.Dataset(
             coords={
-                'num_shortwave_bands': np.arange(14),
-                'num_longwave_bands': np.arange(16),
+                "num_shortwave_bands": np.arange(14),
+                "num_longwave_bands": np.arange(16),
             },
         )
 
-        cld_optics['single_scattering_albedo_due_to_cloud'] = (
-            ('num_shortwave_bands',), ssa.ravel(),
+        cld_optics["single_scattering_albedo_due_to_cloud"] = (
+            ("num_shortwave_bands",),
+            ssa.ravel(),
         )
 
-        cld_optics['cloud_asymmetry_parameter'] = (
-            ('num_shortwave_bands',), asym.ravel(),
+        cld_optics["cloud_asymmetry_parameter"] = (
+            ("num_shortwave_bands",),
+            asym.ravel(),
         )
 
-        cld_optics['cloud_forward_scattering_fraction'] = (
-            ('num_shortwave_bands',), asym.ravel() ** 2
+        cld_optics["cloud_forward_scattering_fraction"] = (
+            ("num_shortwave_bands",),
+            asym.ravel() ** 2,
         )
 
-        cld_optics['shortwave_optical_thickness_due_to_cloud'] = (
-            ('num_shortwave_bands',), water_path * tau_sw.ravel()
+        cld_optics["shortwave_optical_thickness_due_to_cloud"] = (
+            ("num_shortwave_bands",),
+            water_path * tau_sw.ravel(),
         )
 
-        cld_optics['longwave_optical_thickness_due_to_cloud'] = (
-            ('num_longwave_bands',), water_path * tau_lw.ravel()
+        cld_optics["longwave_optical_thickness_due_to_cloud"] = (
+            ("num_longwave_bands",),
+            water_path * tau_lw.ravel(),
         )
 
         return cld_optics
diff --git a/konrad/component.py b/konrad/component.py
index e93f8b79..b37ee21a 100644
--- a/konrad/component.py
+++ b/konrad/component.py
@@ -31,6 +31,7 @@ class Component:
     {'variable': (('dimension',), [42])}
 
     """
+
     def __new__(cls, *args, **kwargs):
         instance = super().__new__(cls)
         instance._attrs = {}
@@ -63,11 +64,11 @@ def from_netcdf(cls, ncfile, timestep=-1, *args, **kwargs):
     def __setattr__(self, name, value):
         object.__setattr__(self, name, value)
 
-        if not name.startswith('_') and name != 'coords':
+        if not name.startswith("_") and name != "coords":
             self._attrs[name] = value
 
     def __getattr__(self, name):
-        if name.startswith('__'):
+        if name.startswith("__"):
             raise AttributeError
 
         try:
@@ -117,26 +118,26 @@ def netcdf_subgroups(self):
 
         Type: dict-like
         """
-        raise AttributeError('No netCDF subgroups defined.')
+        raise AttributeError("No netCDF subgroups defined.")
 
     def __repr__(self):
-        dims = ', '.join(f'{d}: {np.size(v)}' for d, v in self.coords.items())
-        return f'<{self}({dims}) object at {id(self)}>'
+        dims = ", ".join(f"{d}: {np.size(v)}" for d, v in self.coords.items())
+        return f"<{self}({dims}) object at {id(self)}>"
 
     def __str__(self):
         return self.__class__.__name__
 
     def __hash__(self):
         # Prevent hashing by default as components are most likely mutable.
-        raise TypeError(f'unhashable type: {type(self).__name__}')
+        raise TypeError(f"unhashable type: {type(self).__name__}")
 
     def hash_attributes(self):
         """Create a hash from all **hashable** component attributes."""
-        attrs_sorted_by_key = sorted(self.attrs.items(),
-                                     key=operator.itemgetter(0))
+        attrs_sorted_by_key = sorted(self.attrs.items(), key=operator.itemgetter(0))
 
-        hashable_values = tuple(item[1] for item in attrs_sorted_by_key
-                                if isinstance(item[1], Hashable))
+        hashable_values = tuple(
+            item[1] for item in attrs_sorted_by_key if isinstance(item[1], Hashable)
+        )
 
         # Include the class name to distinguish between different
         # inheriting classes using the same attributes.
@@ -145,11 +146,9 @@ def hash_attributes(self):
     def to_dataset(self):
         """Convert model component into an `xarray.Dataset`."""
         if self.coords is None:
-            raise Exception(
-                "Could not create `xarray.Dataset`: `self.coords` not set."
-            )
+            raise Exception("Could not create `xarray.Dataset`: `self.coords` not set.")
         else:
-            self.coords['time'] = [0]
+            self.coords["time"] = [0]
             return xr.Dataset(
                 coords=self.coords,
                 data_vars=self.data_vars,
@@ -176,12 +175,12 @@ def create_variable(self, name, data=None, dims=None):
         if dims is None:
             try:
                 # Try to determine default dimensions for common variables.
-                dims = constants.variable_description[name].get('dims')
+                dims = constants.variable_description[name].get("dims")
             except KeyError:
                 # It is not possible to create variables without dimension.
                 raise ValueError(
                     f'Could not determine default dimensions for "{name}". '
-                    'You can provide them using the `dims` keyword.'
+                    "You can provide them using the `dims` keyword."
                 )
 
         if len(dims) == 2 and data.ndim == 1:
@@ -225,4 +224,3 @@ def get(self, variable, default=None, keepdims=True):
                 raise KeyError(f"'{variable}' not found and no default given.")
 
         return values if keepdims else values.ravel()
-
diff --git a/konrad/constants.py b/konrad/constants.py
index 65d35b32..92872352 100644
--- a/konrad/constants.py
+++ b/konrad/constants.py
@@ -1,6 +1,4 @@
-# -*- coding: utf-8 -*-
-"""Physical constants.
-"""
+"""Physical constants.  """
 import scipy.constants as spc
 import typhon.constants as tyc
 
@@ -25,276 +23,275 @@
 # Variable descriptions
 variable_description = {
     # Atmospheric variables
-    'plev': {
-        'units': 'Pa',
-        'standard_name': 'air_pressure',
-        },
-    'phlev': {
-        'units': 'Pa',
-        'standard_name': 'air_pressure_at_halflevel',
-    },
-    'time': {
-        'standard_name': 'time',
-        'units': 'hours since 0001-01-01 00:00:00.0',
-        'calendar': 'gregorian',
-        },
-    'T': {
-        'units': 'K',
-        'standard_name': 'air_temperature',
-        'arts_name': 'T',
-        'dims': ('time', 'plev'),
-        },
-    'z': {
-        'units': 'm',
-        'standard_name': 'geopotential_height',
-        'description': 'Geopotential height calculated from atmospheric state',
-        'arts_name': 'z',
-        'dims': ('time', 'plev'),
-        },
-    'lapse': {
-        'units': 'K / m',
-        'standard_name': 'air_temperature_lapse_rate',
-    },
-    'H2O': {
-        'units': '1',
-        'standard_name': 'humidity_mixing_ratio',
-        'arts_name': 'abs_species-H2O',
-        'dims': ('time', 'plev'),
-        },
-    'N2O': {
-        'units': '1',
-        'standard_name': 'nitrous_oxide_mixing_ratio',
-        'arts_name': 'abs_species-N2O',
-        'dims': ('plev',),
-        },
-    'O3': {
-        'units': '1',
-        'standard_name': 'ozone_mixing_ratio',
-        'arts_name': 'abs_species-O3',
-        'dims': ('time', 'plev'),
-        },
-    'O2': {
-        'units': '1',
-        'standard_name': 'oxygen_mixing_ratio',
-        'arts_name': 'abs_species-O2',
-        'dims': ('plev',),
-    },
-    'CO2': {
-        'units': '1',
-        'standard_name': 'carbon_dioxide_mixing_ratio',
-        'arts_name': 'abs_species-CO2',
-        'dims': ('time', 'plev',),
-        },
-    'CO': {
-        'units': '1',
-        'standard_name': 'carbon_monoxide_mixing_ratio',
-        'arts_name': 'abs_species-CO',
-        'dims': ('plev',),
-        },
-    'CH4': {
-        'units': '1',
-        'standard_name': 'methane_mixing_ratio',
-        'arts_name': 'abs_species-CH4',
-        'dims': ('plev',),
-        },
-    'CFC11': {
-        'units': '1',
-        'standard_name': 'cfc11_mixing_ratio',
-        'arts_name': 'abs_species-CFC11',
-        'dims': ('plev',),
-    },
-    'CFC12': {
-        'units': '1',
-        'standard_name': 'cfc12_mixing_ratio',
-        'arts_name': 'abs_species-CFC12',
-        'dims': ('plev',),
-    },
-    'CFC22': {
-        'units': '1',
-        'standard_name': 'cfc22_mixing_ratio',
-        'arts_name': 'abs_species-CFC22',
-        'dims': ('plev',),
-    },
-    'CCl4': {
-        'units': '1',
-        'standard_name': 'carbon_tetrachloride_mixing_ratio',
-        'arts_name': 'abs_species-CCl4',
-        'dims': ('plev',),
-    },
-    'diabatic_convergence_max_plev': {
-        'units': 'Pa',
-        'standard_name': 'diabatic_convergence_max_plev',
-        'description': 'Pressure level of maximum diabatic convergence',
-        'dims': ('time',),
-    },
-    'diabatic_convergence_max_index': {
-        'units': '1',
-        'standard_name': 'diabatic_convergence_max_index',
-        'description': 'Level index of maximum diabatic convergence',
-        'dims': ('time',),
+    "plev": {
+        "units": "Pa",
+        "standard_name": "air_pressure",
+    },
+    "phlev": {
+        "units": "Pa",
+        "standard_name": "air_pressure_at_halflevel",
+    },
+    "time": {
+        "standard_name": "time",
+        "units": "hours since 0001-01-01 00:00:00.0",
+        "calendar": "gregorian",
+    },
+    "T": {
+        "units": "K",
+        "standard_name": "air_temperature",
+        "arts_name": "T",
+        "dims": ("time", "plev"),
+    },
+    "z": {
+        "units": "m",
+        "standard_name": "geopotential_height",
+        "description": "Geopotential height calculated from atmospheric state",
+        "arts_name": "z",
+        "dims": ("time", "plev"),
+    },
+    "lapse": {
+        "units": "K / m",
+        "standard_name": "air_temperature_lapse_rate",
+    },
+    "H2O": {
+        "units": "1",
+        "standard_name": "humidity_mixing_ratio",
+        "arts_name": "abs_species-H2O",
+        "dims": ("time", "plev"),
+    },
+    "N2O": {
+        "units": "1",
+        "standard_name": "nitrous_oxide_mixing_ratio",
+        "arts_name": "abs_species-N2O",
+        "dims": ("plev",),
+    },
+    "O3": {
+        "units": "1",
+        "standard_name": "ozone_mixing_ratio",
+        "arts_name": "abs_species-O3",
+        "dims": ("time", "plev"),
+    },
+    "O2": {
+        "units": "1",
+        "standard_name": "oxygen_mixing_ratio",
+        "arts_name": "abs_species-O2",
+        "dims": ("plev",),
+    },
+    "CO2": {
+        "units": "1",
+        "standard_name": "carbon_dioxide_mixing_ratio",
+        "arts_name": "abs_species-CO2",
+        "dims": (
+            "time",
+            "plev",
+        ),
+    },
+    "CO": {
+        "units": "1",
+        "standard_name": "carbon_monoxide_mixing_ratio",
+        "arts_name": "abs_species-CO",
+        "dims": ("plev",),
+    },
+    "CH4": {
+        "units": "1",
+        "standard_name": "methane_mixing_ratio",
+        "arts_name": "abs_species-CH4",
+        "dims": ("plev",),
+    },
+    "CFC11": {
+        "units": "1",
+        "standard_name": "cfc11_mixing_ratio",
+        "arts_name": "abs_species-CFC11",
+        "dims": ("plev",),
+    },
+    "CFC12": {
+        "units": "1",
+        "standard_name": "cfc12_mixing_ratio",
+        "arts_name": "abs_species-CFC12",
+        "dims": ("plev",),
+    },
+    "CFC22": {
+        "units": "1",
+        "standard_name": "cfc22_mixing_ratio",
+        "arts_name": "abs_species-CFC22",
+        "dims": ("plev",),
+    },
+    "CCl4": {
+        "units": "1",
+        "standard_name": "carbon_tetrachloride_mixing_ratio",
+        "arts_name": "abs_species-CCl4",
+        "dims": ("plev",),
+    },
+    "diabatic_convergence_max_plev": {
+        "units": "Pa",
+        "standard_name": "diabatic_convergence_max_plev",
+        "description": "Pressure level of maximum diabatic convergence",
+        "dims": ("time",),
+    },
+    "diabatic_convergence_max_index": {
+        "units": "1",
+        "standard_name": "diabatic_convergence_max_index",
+        "description": "Level index of maximum diabatic convergence",
+        "dims": ("time",),
     },
     # Convective quantities
-    'convective_heating_rate': {
-        'units': 'K / day',
-        'standard_name': 'convective_heating_rate',
-        'dims': ('time', 'plev'),
-    },
-    'convective_top_plev': {
-        'units': 'Pa',
-        'standard_name': 'convective_top_plev',
-        'description': 'Pressure level of the top of convection',
-        'dims': ('time',),
-    },
-    'convective_top_temperature': {
-        'units': 'K',
-        'standard_name': 'convective_top_temperature',
-        'description': 'Temperature at the top of convection',
-        'dims': ('time',),
-    },
-    'convective_top_index': {
-        'units': 'model_level_index',
-        'standard_name': 'convective_top_index',
-        'description': 'Model level index at the top of convection '
-                       '(interpolated, between levels)',
-        'dims': ('time',),
-    },
-    'convective_top_height': {
-        'units': 'm',
-        'standard_name': 'convective_top_height',
-        'description': 'Altitude of the top of convection',
-        'dims': ('time',),
+    "convective_heating_rate": {
+        "units": "K / day",
+        "standard_name": "convective_heating_rate",
+        "dims": ("time", "plev"),
+    },
+    "convective_top_plev": {
+        "units": "Pa",
+        "standard_name": "convective_top_plev",
+        "description": "Pressure level of the top of convection",
+        "dims": ("time",),
+    },
+    "convective_top_temperature": {
+        "units": "K",
+        "standard_name": "convective_top_temperature",
+        "description": "Temperature at the top of convection",
+        "dims": ("time",),
+    },
+    "convective_top_index": {
+        "units": "model_level_index",
+        "standard_name": "convective_top_index",
+        "description": "Model level index at the top of convection "
+        "(interpolated, between levels)",
+        "dims": ("time",),
+    },
+    "convective_top_height": {
+        "units": "m",
+        "standard_name": "convective_top_height",
+        "description": "Altitude of the top of convection",
+        "dims": ("time",),
     },
     # Radiative quantities
-    'lw_htngrt': {
-        'units': 'K / day',
-        'standard_name': 'tendency_of_air_temperature_due_to_longwave_heating',
-        },
-    'lw_htngrt_clr': {
-        'units': 'K / day',
-        'standard_name': ('tendency_of_air_temperature_'
-                          'due_to_longwave_heating_assuming_clear_sky'
-                          ),
-        },
-    'lw_flxu': {
-        'units': 'W / m**2',
-        'standard_name': 'upwelling_longwave_flux_in_air',
-        },
-    'lw_flxd': {
-        'units': 'W / m**2',
-        'standard_name': 'downwelling_longwave_flux_in_air',
-        },
-    'lw_flxu_clr': {
-        'units': 'W / m**2',
-        'standard_name': 'upwelling_longwave_flux_in_air_assuming_clear_sky',
-        },
-    'lw_flxd_clr': {
-        'units': 'W / m**2',
-        'standard_name': 'downwelling_longwave_flux_in_air_assuming_clear_sky',
-        },
-    'sw_htngrt': {
-        'units': 'K / day',
-        'standard_name':
-            'tendency_of_air_temperature_due_to_shortwave_heating',
-        },
-    'sw_htngrt_clr': {
-        'units': 'K / day',
-        'standard_name': ('tendency_of_air_temperature_'
-                          'due_to_shortwave_heating_assuming_clear_sky'
-                          ),
-        },
-    'sw_flxu': {
-        'units': 'W / m**2',
-        'standard_name': 'upwelling_shortwave_flux_in_air',
-        },
-    'sw_flxd': {
-        'units': 'W / m**2',
-        'standard_name': 'downwelling_shortwave_flux_in_air',
-        },
-    'sw_flxu_clr': {
-        'units': 'W / m**2',
-        'standard_name': 'upwelling_shortwave_flux_in_air_assuming_clear_sky',
-        },
-    'sw_flxd_clr': {
-        'units': 'W / m**2',
-        'standard_name':
-            'downwelling_shortwave_flux_in_air_assuming_clear_sky',
-        },
-    'net_htngrt': {
-        'units': 'K / day',
-        'standard_name':
-            'tendency_of_air_temperature_due_to_radiative_heating',
-        },
-    'deltaT': {
-        'units': 'K / day',
-        'standard_name': 'tendency_of_air_temperature',
-        },
+    "lw_htngrt": {
+        "units": "K / day",
+        "standard_name": "tendency_of_air_temperature_due_to_longwave_heating",
+    },
+    "lw_htngrt_clr": {
+        "units": "K / day",
+        "standard_name": (
+            "tendency_of_air_temperature_" "due_to_longwave_heating_assuming_clear_sky"
+        ),
+    },
+    "lw_flxu": {
+        "units": "W / m**2",
+        "standard_name": "upwelling_longwave_flux_in_air",
+    },
+    "lw_flxd": {
+        "units": "W / m**2",
+        "standard_name": "downwelling_longwave_flux_in_air",
+    },
+    "lw_flxu_clr": {
+        "units": "W / m**2",
+        "standard_name": "upwelling_longwave_flux_in_air_assuming_clear_sky",
+    },
+    "lw_flxd_clr": {
+        "units": "W / m**2",
+        "standard_name": "downwelling_longwave_flux_in_air_assuming_clear_sky",
+    },
+    "sw_htngrt": {
+        "units": "K / day",
+        "standard_name": "tendency_of_air_temperature_due_to_shortwave_heating",
+    },
+    "sw_htngrt_clr": {
+        "units": "K / day",
+        "standard_name": (
+            "tendency_of_air_temperature_" "due_to_shortwave_heating_assuming_clear_sky"
+        ),
+    },
+    "sw_flxu": {
+        "units": "W / m**2",
+        "standard_name": "upwelling_shortwave_flux_in_air",
+    },
+    "sw_flxd": {
+        "units": "W / m**2",
+        "standard_name": "downwelling_shortwave_flux_in_air",
+    },
+    "sw_flxu_clr": {
+        "units": "W / m**2",
+        "standard_name": "upwelling_shortwave_flux_in_air_assuming_clear_sky",
+    },
+    "sw_flxd_clr": {
+        "units": "W / m**2",
+        "standard_name": "downwelling_shortwave_flux_in_air_assuming_clear_sky",
+    },
+    "net_htngrt": {
+        "units": "K / day",
+        "standard_name": "tendency_of_air_temperature_due_to_radiative_heating",
+    },
+    "deltaT": {
+        "units": "K / day",
+        "standard_name": "tendency_of_air_temperature",
+    },
     # Radiation
-    'toa': {
-        'units': 'W / m**2',
-        'standard_name':
-            'radiation_budget_at_top_of_the_atmosphere',
-    },
-    'frequency': {
-        'units': 'Hz',
-        'standard_name': 'frequency',
-        },
-    'outgoing_longwave_radiation': {
-        'units': 'W / m**2 / Hz',
-        'standard_name': 'spectral_outgoing_longwave_radiation_at_top_of_the_atmospher',
-        },
+    "toa": {
+        "units": "W / m**2",
+        "standard_name": "radiation_budget_at_top_of_the_atmosphere",
+    },
+    "frequency": {
+        "units": "Hz",
+        "standard_name": "frequency",
+    },
+    "outgoing_longwave_radiation": {
+        "units": "W / m**2 / Hz",
+        "standard_name": "spectral_outgoing_longwave_radiation_at_top_of_the_atmospher",
+    },
     # Surface parameters
-    'albedo': {
-        'units': '1',
-        'standard_name': 'surface_albedo',
+    "albedo": {
+        "units": "1",
+        "standard_name": "surface_albedo",
     },
-    'pressure': {
-        'units': 'Pa',
-        'standard_name': 'surface_pressure',
+    "pressure": {
+        "units": "Pa",
+        "standard_name": "surface_pressure",
     },
-    'temperature': {
-        'units': 'K',
-        'standard_name': 'surface_temperature',
+    "temperature": {
+        "units": "K",
+        "standard_name": "surface_temperature",
     },
-    'c_p': {
-        'units': 'J / kg / K',
-        'standard_name': 'specific_heat_capacity_sea_water',
+    "c_p": {
+        "units": "J / kg / K",
+        "standard_name": "specific_heat_capacity_sea_water",
     },
-    'rho': {
-        'units': 'kg / m**3',
-        'standard_name': 'surface_density',
+    "rho": {
+        "units": "kg / m**3",
+        "standard_name": "surface_density",
     },
-    'depth': {
-        'units': 'm',
-        'standard_name': 'surface_depth',
+    "depth": {
+        "units": "m",
+        "standard_name": "surface_depth",
     },
-    'heat_capacity': {
-        'units': 'J / K',
-        'standard_name': 'surface_heat_capacity',
+    "heat_capacity": {
+        "units": "J / K",
+        "standard_name": "surface_heat_capacity",
     },
     # Ozone quantities
-    'ozone_source': {
-        'units': 'ppv / day',
-        'dims': ('time', 'plev'),
+    "ozone_source": {
+        "units": "ppv / day",
+        "dims": ("time", "plev"),
     },
-    'ozone_sink_ox': {
-        'units': 'ppv / day',
-        'dims': ('time', 'plev'),
+    "ozone_sink_ox": {
+        "units": "ppv / day",
+        "dims": ("time", "plev"),
     },
-    'ozone_sink_nox': {
-        'units': 'ppv / day',
-        'dims': ('time', 'plev'),
+    "ozone_sink_nox": {
+        "units": "ppv / day",
+        "dims": ("time", "plev"),
     },
-    'ozone_transport': {
-        'units': 'ppv / day',
-        'dims': ('time', 'plev'),
+    "ozone_transport": {
+        "units": "ppv / day",
+        "dims": ("time", "plev"),
     },
-    'ozone_sink_hox': {
-        'units': 'ppv / day',
-        'dims': ('time', 'plev'),
+    "ozone_sink_hox": {
+        "units": "ppv / day",
+        "dims": ("time", "plev"),
     },
     # Upwelling
-    'w': {
-        'units': 'm / day',
-        'dims': ('time', 'plev'),
-    }
+    "w": {
+        "units": "m / day",
+        "dims": ("time", "plev"),
+    },
 }
diff --git a/konrad/convection.py b/konrad/convection.py
index 8bcfe90c..70298463 100644
--- a/konrad/convection.py
+++ b/konrad/convection.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This module contains a choice of convective adjustments, which can be used
 in the RCE simulations.
 
@@ -30,14 +29,13 @@
 
 
 __all__ = [
-    'energy_difference',
-    'latent_heat_difference',
-    'interp_variable',
-    'Convection',
-    'NonConvective',
-    'HardAdjustment',
-    'RelaxedAdjustment',
-    'FixedDynamicalHeating',
+    "energy_difference",
+    "latent_heat_difference",
+    "interp_variable",
+    "Convection",
+    "NonConvective",
+    "HardAdjustment",
+    "FixedDynamicalHeating",
 ]
 
 
@@ -60,7 +58,7 @@ def energy_difference(T_2, T_1, sst_2, sst_1, phlev, eff_Cp_s):
     dT = T_2 - T_1  # convective temperature change of atmosphere
     dT_s = sst_2 - sst_1  # of surface
 
-    term_diff = - np.sum(Cp/g * dT * np.diff(phlev)) + eff_Cp_s * dT_s
+    term_diff = -np.sum(Cp / g * dT * np.diff(phlev)) + eff_Cp_s * dT_s
 
     return term_diff
 
@@ -78,7 +76,7 @@ def latent_heat_difference(h2o_2, h2o_1):
     """
 
     Lv = constants.Lv  # TODO: include pressure/temperature dependence?
-    term_diff = np.sum((h2o_2-h2o_1) * Lv)
+    term_diff = np.sum((h2o_2 - h2o_1) * Lv)
 
     return term_diff
 
@@ -99,14 +97,14 @@ def interp_variable(variable, convective_heating, lim):
          float: interpolated value of 'variable'
     """
     positive_i = int(np.argmax(convective_heating > lim))
-    contop_index = int(np.argmax(
-        convective_heating[positive_i:] < lim)) + positive_i
+    contop_index = int(np.argmax(convective_heating[positive_i:] < lim)) + positive_i
 
     # Create auxiliary arrays storing the Qr, T and p values above and below
     # the threshold value. These arrays are used as input for the interpolation
     # in the next step.
-    heat_array = np.array([convective_heating[contop_index - 1],
-                           convective_heating[contop_index]])
+    heat_array = np.array(
+        [convective_heating[contop_index - 1], convective_heating[contop_index]]
+    )
     var_array = np.array([variable[contop_index - 1], variable[contop_index]])
 
     # Interpolate the values to where the convective heating rate equals `lim`.
@@ -115,6 +113,7 @@ def interp_variable(variable, convective_heating, lim):
 
 class Convection(Component, metaclass=abc.ABCMeta):
     """Base class to define abstract methods for convection schemes."""
+
     @abc.abstractmethod
     def stabilize(self, atmosphere, lapse, surface, timestep):
         """Stabilize the temperature profile by redistributing energy.
@@ -130,12 +129,14 @@ def stabilize(self, atmosphere, lapse, surface, timestep):
 
 class NonConvective(Convection):
     """Do not apply convection."""
+
     def stabilize(self, *args, **kwargs):
         pass
 
 
 class HardAdjustment(Convection):
     """Instantaneous adjustment of temperature profiles"""
+
     def __init__(self, entrainment=None, etol=1e-4):
         """Initialize the convective adjustment.
 
@@ -159,8 +160,8 @@ def netcdf_subgroups(self):
         return {"entrainment": self._entrainment}
 
     def stabilize(self, atmosphere, lapse, surface, timestep):
-        T_rad = atmosphere['T'][0, :]
-        p = atmosphere['plev']
+        T_rad = atmosphere["T"][0, :]
+        p = atmosphere["plev"]
 
         # Find convectively adjusted temperature profile.
         T_new, T_s_new = self.convective_adjustment(
@@ -172,8 +173,8 @@ def stabilize(self, atmosphere, lapse, surface, timestep):
         # get convective top temperature and pressure
         self.update_convective_top(T_rad, T_new, p, timestep=timestep)
         # Update atmospheric temperatures as well as surface temperature.
-        atmosphere['T'][0, :] = T_new
-        surface['temperature'][0] = T_s_new
+        atmosphere["T"][0, :] = T_new
+        surface["temperature"][0] = T_s_new
 
     def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
         """
@@ -200,8 +201,9 @@ def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
         # fixed surface temperature. In this case, energy is not conserved.
         if isinstance(surface, FixedTemperature):
             T_con = self.convective_profile(
-                atmosphere, surface['temperature'], lapse, timestep=timestep)
-            return T_con, surface['temperature']
+                atmosphere, surface["temperature"], lapse, timestep=timestep
+            )
+            return T_con, surface["temperature"]
 
         # Otherwise we should conserve energy --> our energy change should be
         # less than the threshold 'near_zero'.
@@ -212,15 +214,16 @@ def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
         # Find the energy difference if there is no change to surface temp due
         # to convective adjustment. In this case the new profile should be
         # associated with an increase in energy in the atmosphere.
-        surfaceTpos = surface['temperature']
+        surfaceTpos = surface["temperature"]
         T_con, diff_pos = self.create_and_check_profile(
-            atmosphere, surface, surfaceTpos, lapse, timestep=timestep)
+            atmosphere, surface, surfaceTpos, lapse, timestep=timestep
+        )
 
         # For other cases, if we find a decrease or approx no change in energy,
         # the atmosphere is not being warmed by the convection,
         # as it is not unstable to convection, so no adjustment is applied.
         if diff_pos < near_zero:
-            return T_con, surface['temperature']
+            return T_con, surface["temperature"]
 
         # If the atmosphere is unstable to convection, a fixed surface
         # temperature produces an increase in energy, as convection warms the
@@ -233,7 +236,7 @@ def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
         # surface temperature change.
         surfaceTneg = atmosphere["T"][0, 0]
         eff_Cp_s = surface.heat_capacity
-        diff_neg = eff_Cp_s * (surfaceTneg - surface['temperature'])
+        diff_neg = eff_Cp_s * (surfaceTneg - surface["temperature"])
         if np.abs(diff_neg) < near_zero:
             return T_con, surfaceTneg
 
@@ -244,12 +247,14 @@ def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
         while diff_pos >= near_zero and np.abs(diff_neg) >= near_zero:
             # Use a surface temperature between our upper and lower bounds and
             # closer to the bound associated with a smaller energy change.
-            surfaceT = (surfaceTneg + (surfaceTpos - surfaceTneg)
-                        * (-diff_neg) / (-diff_neg + diff_pos))
+            surfaceT = surfaceTneg + (surfaceTpos - surfaceTneg) * (-diff_neg) / (
+                -diff_neg + diff_pos
+            )
             # Calculate temperature profile and energy change associated with
             # this surface temperature.
             T_con, diff = self.create_and_check_profile(
-                atmosphere, surface, surfaceT, lapse, timestep=timestep)
+                atmosphere, surface, surfaceT, lapse, timestep=timestep
+            )
 
             # Update either upper or lower bound.
             if diff > 0:
@@ -262,9 +267,7 @@ def convective_adjustment(self, atmosphere, lapse, surface, timestep=0.1):
             # to avoid getting stuck in a loop if something weird is going on
             counter += 1
             if counter == 100:
-                raise ValueError(
-                    "No energy conserving convective profile can be found"
-                )
+                raise ValueError("No energy conserving convective profile can be found")
 
         return T_con, surfaceT
 
@@ -291,7 +294,7 @@ def get_moist_adiabat(atmosphere, surfaceT, lapse, **kwargs):
         ph = atmosphere["phlev"]
         Ts = surfaceT
 
-        r = ode(lapse).set_integrator('lsoda', atol=1e-4)
+        r = ode(lapse).set_integrator("lsoda", atol=1e-4)
         r.set_initial_value(Ts, ph[0])
 
         T = np.zeros_like(p)
@@ -316,15 +319,15 @@ def convective_profile(self, atmosphere, surfaceT, lapse, **kwargs):
         # Combine radiative and convective temperature profiles.
         if np.any(T_con > T_rad):
             contop = np.max(np.where(T_con > T_rad))
-            T_con[contop+1:] = T_rad[contop+1:]
+            T_con[contop + 1 :] = T_rad[contop + 1 :]
         else:
             return T_rad
 
         return T_con
 
-
-    def create_and_check_profile(self, atmosphere, surface, surfaceT, lapse,
-                                 timestep=0.1):
+    def create_and_check_profile(
+        self, atmosphere, surface, surfaceT, lapse, timestep=0.1
+    ):
         """Create a convectively adjusted temperature profile and calculate how
         close it is to satisfying energy conservation.
 
@@ -341,13 +344,18 @@ def create_and_check_profile(self, atmosphere, surface, surfaceT, lapse,
             float: energy difference between the new profile and the old one
         """
         T_rad = atmosphere["T"][-1]
-        T_con = self.convective_profile(atmosphere, surfaceT, lapse,
-                                        timestep=timestep)
+        T_con = self.convective_profile(atmosphere, surfaceT, lapse, timestep=timestep)
 
         eff_Cp_s = surface.heat_capacity
 
-        diff = energy_difference(T_con, T_rad, surfaceT,
-                                 surface['temperature'], atmosphere["phlev"], eff_Cp_s)
+        diff = energy_difference(
+            T_con,
+            T_rad,
+            surfaceT,
+            surface["temperature"],
+            atmosphere["phlev"],
+            eff_Cp_s,
+        )
         return T_con, float(diff)
 
     def update_convective_top(self, T_rad, T_con, p, timestep=0.1, lim=0.2):
@@ -368,7 +376,7 @@ def update_convective_top(self, T_rad, T_con, p, timestep=0.1, lim=0.2):
             lim (float): Threshold value [K/day].
         """
         convective_heating = (T_con - T_rad) / timestep
-        self.create_variable('convective_heating_rate', convective_heating)
+        self.create_variable("convective_heating_rate", convective_heating)
 
         if np.any(convective_heating > lim):  # if there is convective heating
             # find the values of pressure and temperature at the convective top,
@@ -382,16 +390,18 @@ def update_convective_top(self, T_rad, T_con, p, timestep=0.1, lim=0.2):
             # warm (normally) or cool (at certain times during the diurnal
             # cycle) the lower troposphere. Therefore, we search for the
             # convective top index from the top going downwards.
-            contop_index = (len(convective_heating) -
-                            np.argmin(convective_heating[::-1] <= 0))
+            contop_index = len(convective_heating) - np.argmin(
+                convective_heating[::-1] <= 0
+            )
 
         else:  # if there is no convective heating
             contop_index, contop_p, contop_T = np.nan, np.nan, np.nan
 
-        for name, value in [('convective_top_plev', contop_p),
-                            ('convective_top_temperature', contop_T),
-                            ('convective_top_index', contop_index),
-                            ]:
+        for name, value in [
+            ("convective_top_plev", contop_p),
+            ("convective_top_temperature", contop_T),
+            ("convective_top_index", contop_index),
+        ]:
             self.create_variable(name, np.array([value]))
 
         return
@@ -403,73 +413,18 @@ def update_convective_top_height(self, z, lim=0.2):
             z (ndarray): height array [m]
             lim (float): Threshold convective heating value [K/day]
         """
-        convective_heating = self.get('convective_heating_rate')[0]
+        convective_heating = self.get("convective_heating_rate")[0]
         if np.any(convective_heating > lim):  # if there is convective heating
             contop_z = interp_variable(z, convective_heating, lim=lim)
         else:  # if there is no convective heating
             contop_z = np.nan
-        self.create_variable('convective_top_height', np.array([contop_z]))
+        self.create_variable("convective_top_height", np.array([contop_z]))
         return
 
 
-class RelaxedAdjustment(HardAdjustment):
-    """Adjustment with relaxed convection in upper atmosphere.
-
-    This convection scheme allows for a transition regime between a
-    convectively driven troposphere and the radiatively balanced stratosphere.
-    """
-    def __init__(self, tau=None, *args, **kwargs):
-        """
-        Parameters:
-            tau (ndarray): Array of convective timescale values [days]
-        """
-        super().__init__(*args, **kwargs)
-        self.convective_tau = tau
-
-    def get_convective_tau(self, p):
-        """Return a convective timescale profile.
-
-        Parameters:
-            p (ndarray): Pressure levels [Pa].
-
-        Returns:
-            ndarray: Convective timescale profile [days].
-        """
-        if self.convective_tau is not None:
-            return self.convective_tau
-
-        tau0 = 1/24  # 1 hour
-        tau = tau0*np.exp(p[0] / p)
-
-        return tau
-
-    def convective_profile(self, atmosphere, surfaceT, lapse, timestep):
-        """
-        Assuming a particular surface temperature (surfaceT), create a new
-        profile, which tries to follow the specified lapse rate (lp). How close
-        it gets to following the specified lapse rate depends on the convective
-        timescale and model timestep.
-
-        Parameters:
-            atmosphere (konrad.atmosphere.Atmosphere): Atmosphere model.
-            surfaceT (float): surface temperature [K]
-            lapse (konrad.lapsereate.LapseRate): Callable `f(p, T)` that
-                returns a temperature lapse rate in [K/day].
-            timestep (float/int): model timestep [days]
-
-        Returns:
-             ndarray: convectively adjusted temperature profile [K]
-        """
-        T_con = self.get_moist_adiabat(atmosphere, surfaceT, lapse)
-
-        tau = self.get_convective_tau(atmosphere["plev"])
-        tf = 1 - np.exp(-timestep / tau)
-
-        return atmosphere["T"][0] * (1 - tf) + tf * T_con
-
 class FixedDynamicalHeating(HardAdjustment):
-    """Adjustment with a fixed convective (dynamical) heating rate.
-    """
+    """Adjustment with a fixed convective (dynamical) heating rate."""
+
     def __init__(self, heating=None, *args, **kwargs):
         """
         Parameters:
@@ -484,5 +439,5 @@ def stabilize(self, atmosphere, lapse, surface, timestep):
         T_new = T_rad + timestep * self._heating
 
         self.update_convective_top(T_rad, T_new, p, timestep=timestep)
-        
-        atmosphere["T"][-1] = T_new
\ No newline at end of file
+
+        atmosphere["T"][-1] = T_new
diff --git a/konrad/core.py b/konrad/core.py
index fa4100e6..c2ff7793 100644
--- a/konrad/core.py
+++ b/konrad/core.py
@@ -8,22 +8,22 @@
 from konrad import utils
 from konrad import netcdf
 from konrad.radiation import RRTMG
-from konrad.ozone import (Ozone, OzonePressure)
+from konrad.ozone import Ozone, OzonePressure
 from konrad.humidity import FixedRH
-from konrad.surface import (Surface, SlabOcean, FixedTemperature)
-from konrad.cloud import (Cloud, ClearSky)
-from konrad.convection import (Convection, HardAdjustment, RelaxedAdjustment)
-from konrad.lapserate import (LapseRate, MoistLapseRate)
-from konrad.upwelling import (Upwelling, NoUpwelling)
+from konrad.surface import Surface, FixedTemperature
+from konrad.cloud import Cloud, ClearSky
+from konrad.convection import Convection, HardAdjustment
+from konrad.lapserate import LapseRate, MoistLapseRate
+from konrad.upwelling import Upwelling, NoUpwelling
 
 logger = logging.getLogger(__name__)
 
 __all__ = [
-    'RCE',
+    "RCE",
 ]
 
 
-class RCE():
+class RCE:
     """Interface to control the radiative-convective equilibrium simulation.
 
     Examples:
@@ -38,11 +38,11 @@ class RCE():
     def __init__(
         self,
         atmosphere,
-        timestep='6h',
-        max_duration='500d',
+        timestep="12h",
+        max_duration="200d",
         outfile=None,
-        experiment='RCE',
-        writeevery='24h',
+        experiment="RCE",
+        writeevery="24h",
         delta=0.0,
         delta2=0.0,
         post_count=365,
@@ -110,7 +110,7 @@ def __init__(
                 Defaults to :class:`konrad.humidity.FixedRH`.
 
             surface (konrad.surface): Surface model.
-                Defaults to :class:`konrad.surface.SlabOcean`.
+                Defaults to :class:`konrad.surface.FixedTemperature`.
 
             cloud (konrad.cloud): Cloud model.
                 Defaults to :class:`konrad.cloud.ClearSky`.
@@ -147,65 +147,67 @@ def __init__(
                 Default (`None`) is keeping the given timestep fixed.
         """
         # Sub-model initialisation
-        
+
         # Atmosphere
         self.atmosphere = atmosphere
-        
+
         # Radiation
         if radiation is None:
             self.radiation = RRTMG()
         else:
             self.radiation = radiation
-        
+
         # Ozone
-        self.ozone = utils.return_if_type(ozone, 'ozone',
-                                          Ozone, OzonePressure())
-        
+        self.ozone = utils.return_if_type(ozone, "ozone", Ozone, OzonePressure())
+
         # Humidity
         self.humidity = FixedRH() if humidity is None else humidity
-        
+
         # Surface
-        self.surface = utils.return_if_type(surface, 'surface',
-                                            Surface, SlabOcean())
-        
+        self.surface = utils.return_if_type(
+            surface, "surface", Surface, FixedTemperature()
+        )
+
         # Cloud
-        self.cloud = utils.return_if_type(cloud, 'cloud',
-                                          Cloud,
-                                          ClearSky(self.atmosphere['plev'].size)
-                                          )
-        
+        self.cloud = utils.return_if_type(
+            cloud, "cloud", Cloud, ClearSky(self.atmosphere["plev"].size)
+        )
+
         # Convection
-        self.convection = utils.return_if_type(convection, 'convection',
-                                               Convection, HardAdjustment())
-        
+        self.convection = utils.return_if_type(
+            convection, "convection", Convection, HardAdjustment()
+        )
+
         # Critical lapse-rate
-        self.lapserate = utils.return_if_type(lapserate, 'lapserate',
-                                              LapseRate, MoistLapseRate())
-        
+        self.lapserate = utils.return_if_type(
+            lapserate, "lapserate", LapseRate, MoistLapseRate()
+        )
+
         # Stratospheric upwelling
-        self.upwelling = utils.return_if_type(upwelling, 'upwelling',
-                                              Upwelling, NoUpwelling())
-        
+        self.upwelling = utils.return_if_type(
+            upwelling, "upwelling", Upwelling, NoUpwelling()
+        )
+
         # Diurnal cycle
         self.diurnal_cycle = diurnal_cycle
-        
+
         # Time, timestepping and duration attributes
         self.timestep = utils.parse_fraction_of_day(timestep)
         self.time = datetime.datetime(1, 1, 1)  # Start model run at 0001/1/1
         self.max_duration = utils.parse_fraction_of_day(max_duration)
         self.niter = 0
         self.timestep_adjuster = timestep_adjuster
-        
+
         # Output writing attributes
         self.writeevery = utils.parse_fraction_of_day(writeevery)
         self.last_written = self.time
         self.outfile = outfile
         self.nchandler = None
         self.experiment = experiment
-        
+
         # Logging attributes
         self.logevery = logevery
-        
+
         # Attributes used by the is_converged() method
         self.delta = delta
         if delta != 0.0 and delta2 == 0.0:
@@ -219,29 +221,30 @@ def __init__(
         self.counteq = datetime.timedelta(microseconds=0)
         self.post_count = utils.parse_fraction_of_day(post_count)
         self.converged = False
-        
+
         # Attributes used by the time-step adjuster
         self.oldT = 0
         self.deltaT = 0
-        
+
         # Attributes for experiments with varying carbon dioxide following
         # Romps (2020)
         self.co2_adjustment_timescale = co2_adjustment_timescale
         if not np.isnan(co2_adjustment_timescale) and not isinstance(
-                surface, FixedTemperature):
+            surface, FixedTemperature
+        ):
             raise TypeError(
                 "Runs with adjusting CO2 concentration "
                 "require a fixed surface temperature."
-                )
-        
-        logging.info('Created Konrad object:\n{}'.format(self))
+            )
+
+        logging.info("Created Konrad object:\n{}".format(self))
 
     def __repr__(self):
-        retstr = '{}(\n'.format(self.__class__.__name__)
+        retstr = "{}(\n".format(self.__class__.__name__)
         # Loop over all public object attributes.
-        for a in filter(lambda k: not k.startswith('_'), self.__dict__):
-            retstr += '    {}={},\n'.format(a, getattr(self, a))
-        retstr += ')'
+        for a in filter(lambda k: not k.startswith("_"), self.__dict__):
+            retstr += "    {}={},\n".format(a, getattr(self, a))
+        retstr += ")"
 
         return retstr
 
@@ -264,7 +267,7 @@ def timestep_days(self):
 
     def is_converged(self):
         """Check if the atmosphere is in radiative-convective equilibrium.
-        
+
         Here is implemented a convergence criterion using the first and a
         pseudo-second order time derivatives of the energy flux at the TOA.
         Using only the first can lead to false convergence, hence the second
@@ -273,16 +276,16 @@ def is_converged(self):
         Returns:
             bool: ``True`` if converged, else ``False``.
         """
-        
+
         # Calculates the change in the energy flux imbalance at the TOA
         self.newDN = self.radiation["toa"][-1] - self.oldN
         # Calculates a second order difference of the imbalance at the TOA
         self.newDDN = np.abs(self.newDN) - np.abs(self.oldDN)
-        
+
         # Checks whether the difference is below the threshold
         test1 = (np.abs(self.newDN) / self.timestep_days) <= self.delta
         # Checks whether the second order difference is below the threshold
-        test2 = (np.abs(self.newDDN) / self.timestep_days**2) <= self.delta2
+        test2 = (np.abs(self.newDDN) / self.timestep_days ** 2) <= self.delta2
 
         # Stores the above-calculated value for the next iteration
         self.oldDN = self.newDN
@@ -291,7 +294,7 @@ def is_converged(self):
         #     in one timestep
         # In any other case it reduces the count in one timestep or maintains
         #     it at zero
-        if ( test1 and test2 ):
+        if test1 and test2:
             self.counteq += self.timestep
         else:
             if self.counteq > datetime.timedelta(microseconds=0):
@@ -302,12 +305,13 @@ def is_converged(self):
         # Displays information about convergence
         if self.logevery is not None and self.niter % self.logevery == 0:
             d_txt = "Days within equilibrium conditions: {0:3.2f}"
-            logger.debug(d_txt.format(self.counteq.total_seconds() /
-                                      (60 * 60 * 24)))
+            logger.debug(d_txt.format(self.counteq.total_seconds() / (60 * 60 * 24)))
             d_txt = "Delta N (TOA): {0:2.2e} (Threshold: {1:2.2e})"
             logger.debug(d_txt.format(self.newDN / self.timestep_days, self.delta))
             d_txt = "Delta (Delta N (TOA)): {0:2.2e} (Threshold: {1:2.2e})"
-            logger.debug(d_txt.format(self.newDDN / self.timestep_days**2, self.delta2))
+            logger.debug(
+                d_txt.format(self.newDDN / self.timestep_days ** 2, self.delta2)
+            )
 
         # If the equilibrium is larger than the threshold count, it declares
         #     convergence
@@ -324,8 +328,9 @@ def check_if_write(self):
         if self.outfile is None:
             return False
 
-        if ((self.time - self.last_written) >= self.writeevery
-           or self.time == datetime.datetime(1, 1, 1)):
+        if (
+            self.time - self.last_written
+        ) >= self.writeevery or self.time == datetime.datetime(1, 1, 1):
             self.last_written = self.time
             return True
         else:
@@ -333,29 +338,29 @@ def check_if_write(self):
 
     def run(self):
         """Run the radiative-convective equilibrium model."""
-        logger.info('Start RCE model run.')
+        logger.info("Start RCE model run.")
 
         # Initializes surface pressure to be equal to lowest half-level
         # pressure. This is consistent with handling in PSrad.
-        self.surface.pressure = self.atmosphere['phlev'][0]
+        self.surface.pressure = self.atmosphere["phlev"][0]
 
         # Main loop to control all model iterations until maximum number is
         # reached or a given stop criterion is fulfilled.
         while self.runtime <= self.max_duration:
             if self.logevery is not None and self.niter % self.logevery == 0:
                 # Writes every 100th time step in loglevel INFO.
-                logger.info(f'Enter iteration {self.niter}.')
+                logger.info(f"Enter iteration {self.niter}.")
                 if self.timestep_adjuster is not None:
-                    logger.info(f'Model timestep: {self.timestep}.')
-            
+                    logger.info(f"Model timestep: {self.timestep}.")
+
             # Saves the old radiative imbalance at the TOA (convergence check)
             if self.niter != 0:
                 self.oldN = self.radiation["toa"][-1]
-            
+
             # Adjusts solar parameters if diurnal cycle is active
             if self.diurnal_cycle:
                 self.radiation.adjust_solar_angle(self.get_hours_passed() / 24)
-            
+
             # Performs radiative calculations with the present state
             self.radiation.update_heatingrates(
                 atmosphere=self.atmosphere,
@@ -365,13 +370,13 @@ def run(self):
 
             # Applies heating rates and fluxes to the the surface
             self.surface.adjust(
-                sw_down=self.radiation['sw_flxd'][0, 0],
-                sw_up=self.radiation['sw_flxu'][0, 0],
-                lw_down=self.radiation['lw_flxd'][0, 0],
-                lw_up=self.radiation['lw_flxu'][0, 0],
+                sw_down=self.radiation["sw_flxd"][0, 0],
+                sw_up=self.radiation["sw_flxu"][0, 0],
+                lw_down=self.radiation["lw_flxd"][0, 0],
+                lw_up=self.radiation["lw_flxu"][0, 0],
                 timestep=self.timestep_days,
             )
-            
+
             # If it uses Romps (2020) idea, adjusts the carbon dioxide
             if not np.isnan(self.co2_adjustment_timescale):
                 # Adjusts CO2 concentrations to find a equilibrium state using
@@ -379,15 +384,18 @@ def run(self):
                 n0 = getattr(self.surface, "heat_sink", 66.0)
                 A = 5.35
                 tau = self.co2_adjustment_timescale
-                self.atmosphere['CO2'] += self.timestep_days * (
-                    n0 - self.radiation['toa'][0]) / (A * tau
-                                                      ) * self.atmosphere['CO2']
+                self.atmosphere["CO2"] += (
+                    self.timestep_days
+                    * (n0 - self.radiation["toa"][0])
+                    / (A * tau)
+                    * self.atmosphere["CO2"]
+                )
 
             # Saves the old temperature (time step adjustment)
-            self.oldT = self.atmosphere['T'][0].copy()
+            self.oldT = self.atmosphere["T"][0].copy()
 
             # Applies radiative heating rates to the temperature profile
-            self.atmosphere['T'] += (self.radiation['net_htngrt'] * self.timestep_days)
+            self.atmosphere["T"] += self.radiation["net_htngrt"] * self.timestep_days
 
             # Performs the convective adjustment of the temperature profile
             self.convection.stabilize(
@@ -396,30 +404,29 @@ def run(self):
                 timestep=self.timestep_days,
                 surface=self.surface,
             )
-            
+
             # Applies cooling due to stratospheric upwelling
             self.upwelling.cool(
                 atmosphere=self.atmosphere,
                 convection=self.convection,
                 timestep=self.timestep_days,
             )
-            
+
             # Updates height and other diagnostic quantities
             # TODO: Consider implementing an Atmosphere.update_diagnostics()
             # method to include e.g. convective top in the output
             self.atmosphere.update_height()
-            z = self.atmosphere.get('z')[0, :]
-            if isinstance(self.convection, HardAdjustment) or isinstance(
-                    self.convection, RelaxedAdjustment):
+            z = self.atmosphere.get("z")[0, :]
+            if isinstance(self.convection, HardAdjustment):
                 self.convection.update_convective_top_height(z)
-            
+
             # Updates the ozone profile
             self.ozone(
                 atmosphere=self.atmosphere,
                 convection=self.convection,
                 timestep=self.timestep_days,
                 upwelling=self.upwelling,
-                zenith=self.radiation.current_solar_angle
+                zenith=self.radiation.current_solar_angle,
             )
 
             # Updates the humidity profile
@@ -428,7 +435,7 @@ def run(self):
                 convection=self.convection,
                 surface=self.surface,
             )
-            
+
             # Updates the cloud profile
             self.cloud.update_cloud_profile(
                 atmosphere=self.atmosphere,
@@ -437,8 +444,8 @@ def run(self):
             )
 
             # Calculates temperature change (time step adjustment)
-            self.deltaT = self.atmosphere['T'][0].copy() - self.oldT
-            
+            self.deltaT = self.atmosphere["T"][0].copy() - self.oldT
+
             # Adjusts the time step
             if self.timestep_adjuster is not None:
                 self.timestep = self.timestep_adjuster(
@@ -449,24 +456,27 @@ def run(self):
             if self.check_if_write():
                 if self.nchandler is None:
                     self.nchandler = netcdf.NetcdfHandler(
-                        filename=self.outfile, rce=self)
+                        filename=self.outfile, rce=self
+                    )
 
                 self.nchandler.write()
 
             # Checks if the model run has converged to an equilibrium state
             if self.is_converged():
                 # If the model is converged, skip further iterations. Success!
-                logger.info(f'Converged after {self.niter} iterations.')
+                logger.info(f"Converged after {self.niter} iterations.")
                 break
             # Otherwise increase the iteration count and go on
             else:
                 self.niter += 1
                 self.time += self.timestep
         else:
-            logger.info('Stop. Reached maximum runtime.')
+            logger.info("Stop. Reached maximum runtime.")
+
 
 class TimestepAdjuster:
     """Callable object to adjust the model timestep."""
+
     def __init__(
         self,
         increment=None,
diff --git a/konrad/humidity/__init__.py b/konrad/humidity/__init__.py
index f5688ae5..e20af690 100644
--- a/konrad/humidity/__init__.py
+++ b/konrad/humidity/__init__.py
@@ -3,7 +3,7 @@
 
 from konrad.component import Component
 from konrad.utils import prefix_dict_keys
-from konrad.physics import (relative_humidity2vmr, vmr2relative_humidity)
+from konrad.physics import relative_humidity2vmr, vmr2relative_humidity
 from .stratosphere import *
 from .relative_humidity import *
 
@@ -13,13 +13,14 @@
 
 class FixedRH(Component):
     """Preserve the relative humidity profile under temperature changes."""
+
     def __init__(self, rh_func=None, stratosphere_coupling=None):
         """Create a humidity handler.
 
         Parameters:
             rh_func (callable): Callable that describes the vertical
                 relative humidity distribution.
-                If `None`, assume a :class:`HeightConstant` relative humidity.
+                If `None`, assume a :class:`VerticallyUniform` relative humidity.
             stratosphere_coupling (callable): Callable that describes how the
                 humidity should be treated in the stratosphere.
         """
@@ -29,7 +30,7 @@ def __init__(self, rh_func=None, stratosphere_coupling=None):
             self._stratosphere_coupling = stratosphere_coupling
 
         if rh_func is None:
-            self._rh_func = HeightConstant()
+            self._rh_func = VerticallyUniform()
         else:
             self._rh_func = rh_func
 
@@ -38,17 +39,19 @@ def __init__(self, rh_func=None, stratosphere_coupling=None):
     @property
     def netcdf_subgroups(self):
         return {
-            'rh_func': self._rh_func,
-            'stratosphere_coupling': self._stratosphere_coupling,
+            "rh_func": self._rh_func,
+            "stratosphere_coupling": self._stratosphere_coupling,
         }
 
     def hash_attributes(self):
         # Make sure that non-``Component`` attributes do not break hashing.
-        return hash(tuple(
-            attr.hash_attributes()
-            for attr in (self._rh_func, self._stratosphere_coupling)
-            if hasattr(attr, 'hash_attributes')
-        ))
+        return hash(
+            tuple(
+                attr.hash_attributes()
+                for attr in (self._rh_func, self._stratosphere_coupling)
+                if hasattr(attr, "hash_attributes")
+            )
+        )
 
     @property
     def rh_func(self):
@@ -67,26 +70,26 @@ def adjust_humidity(self, atmosphere, **kwargs):
         Returns:
             ndarray: Water vapor profile [VMR].
         """
-        atmosphere['H2O'][-1, :] = relative_humidity2vmr(
+        atmosphere["H2O"][-1, :] = relative_humidity2vmr(
             relative_humidity=self._rh_func(atmosphere, **kwargs),
-            pressure=atmosphere['plev'],
-            temperature=atmosphere['T'][-1]
-
+            pressure=atmosphere["plev"],
+            temperature=atmosphere["T"][-1],
         )
         self._stratosphere_coupling.adjust_stratospheric_vmr(atmosphere)
 
 
 class FixedVMR(Component):
     """Keep the water vapor volume mixing ratio constant."""
+
     def __init__(self, *args, **kwargs):
         if len(args) + len(kwargs) > 0:
             # Allow arguments to be passed for consistent interface but
             # warn the user.
-            logger.warning(f'All input arguments to {self} are ignored.')
+            logger.warning(f"All input arguments to {self} are ignored.")
 
         # Set both attributes for consistent user interface and netCDF output.
-        self.rh_func = 'FixedVMR'
-        self.stratosphere_coupling = 'FixedVMR'
+        self.rh_func = "FixedVMR"
+        self.stratosphere_coupling = "FixedVMR"
 
     def adjust_humidity(self, atmosphere, **kwargs):
         return
diff --git a/konrad/humidity/relative_humidity.py b/konrad/humidity/relative_humidity.py
index 203ac81c..b328a975 100644
--- a/konrad/humidity/relative_humidity.py
+++ b/konrad/humidity/relative_humidity.py
@@ -9,6 +9,19 @@
 from konrad.utils import gaussian
 
 
+__all__ = [
+    "RelativeHumidityModel",
+    "CacheFromAtmosphere",
+    "VerticallyUniform",
+    "Manabe67",
+    "Cess76",
+    "Romps14",
+    "PolynomialCshapedRH",
+    "PerturbProfile",
+    "ProfileFromData",
+]
+
+
 class RelativeHumidityModel(Component, metaclass=abc.ABCMeta):
     def __call__(self, atmosphere, **kwargs):
         """Return the vertical distribution of relative humidity.
@@ -40,7 +53,7 @@ def __call__(self, atmosphere, **kwargs):
         return self._rh_profile
 
 
-class HeightConstant(RelativeHumidityModel):
+class VerticallyUniform(RelativeHumidityModel):
     """Fix the relative humidity to a single value throughout the atmosphere."""
 
     def __init__(self, rh_surface=0.8):
@@ -60,158 +73,6 @@ def __call__(self, atmosphere, **kwargs):
         return self._rh_cache
 
 
-class VerticallyUniform(RelativeHumidityModel):
-    """Use a single value of relative humidity up to the convective top and
-    then a linearly decreasing value towards the cold point."""
-
-    def __init__(self, rh_surface=0.5, rh_tropopause=0.3):
-        """
-        Parameters:
-            rh_surface (float): relative humidity from the first pressure level
-                (surface) up to the convective top
-            rh_tropopause (float): relative humidity at the tropopause
-        """
-        self.rh_surface = rh_surface
-        self.rh_tropopause = rh_tropopause
-        self.convective_top = 300e2
-        self.cold_point = 100e2
-
-    def __call__(self, atmosphere, convection, **kwargs):
-        p = atmosphere["plev"]
-        self.convective_top = convection.get("convective_top_plev")[0]
-        self.cold_point = atmosphere.get_cold_point_plev()
-
-        rh = (self.rh_tropopause - self.rh_surface) / (
-            self.cold_point - self.convective_top
-        ) * (p - self.convective_top) + self.rh_surface
-        rh[p > self.convective_top] = self.rh_surface
-
-        return rh
-
-
-class ConstantFreezingLevel(RelativeHumidityModel):
-    """Constant relative humidity up to the freezing level and then
-    decreasing."""
-
-    def __init__(self, rh_surface=0.77):
-        """
-        Parameters:
-            rh_surface (float): Relative humidity at first
-                pressure level (surface)
-        """
-        self.rh_surface = rh_surface
-
-    def __call__(self, atmosphere, **kwargs):
-        plev = atmosphere["plev"]
-        rh_profile = self.rh_surface * np.ones_like(plev)
-
-        fl = atmosphere.get_triple_point_index()
-        rh_profile[fl:] = self.rh_surface * (plev[fl:] / plev[fl]) ** 1.3
-
-        return rh_profile
-
-
-class FixedUTH(RelativeHumidityModel):
-    """Idealised model of a fixed C-shaped relative humidity distribution."""
-
-    def __init__(self, rh_surface=0.77, uth=0.75, uth_plev=170e2, uth_offset=0):
-        """Couple the upper-tropospheric humidity peak to the convective top.
-
-        Parameters:
-            rh_surface (float): Relative humidity at first
-                pressure level (surface).
-            uth (float): Relative humidity at the upper-tropospheric peak.
-            uth_plev (float): Pressure level of second humidity maximum [Pa].
-            uth_offset (float): Offset between UTH peak and convective top.
-        """
-        self.rh_surface = rh_surface
-        self.uth = uth
-        self.uth_plev = uth_plev
-        self.uth_offset = uth_offset
-
-        self._rh_base_profile = None
-
-    def get_relative_humidity_profile(self, atmosphere):
-        p = atmosphere["plev"]
-
-        # Use Manabe (1967) relative humidity model as base/background.
-        if self._rh_base_profile is None:
-            manabe_model = Manabe67(rh_surface=self.rh_surface)
-            self._rh_base_profile = manabe_model(atmosphere)
-
-        # Gaussian upper-tropospheric UTH peak in ln(p) coordinates
-        x = p / (self.uth_plev + self.uth_offset)
-        uth = self.uth * np.exp(-np.log(x) ** 2 * np.pi)
-
-        return np.maximum(self._rh_base_profile, uth)
-
-    def __call__(self, atmosphere, **kwargs):
-        return self.get_relative_humidity_profile(atmosphere)
-
-
-class CoupledUTH(FixedUTH):
-    """Idealised model of a coupled C-shaped relative humidity distribution.
-
-    This relative humidity works in the same way as ``FixedUTH`` but the
-    ``uth_plev`` is updated automatically depending on the convective top.
-    """
-
-    def __call__(self, atmosphere, convection, **kwargs):
-        self.uth_plev = convection.get("convective_top_plev")[0]
-
-        return self.get_relative_humidity_profile(atmosphere)
-
-
-class CshapeConstant(RelativeHumidityModel):
-    """Idealized model of a C-shaped RH profile using a quadratic equation."""
-
-    def __init__(self, uth_plev=200e2, rh_min=0.3, uth=0.8):
-        self.uth_plev = uth_plev
-        self.rh_min = rh_min
-        self.uth = uth
-        self.rh_surface = uth
-
-    def __call__(self, atmosphere, convection, **kwargs):
-        self.uth_plev = convection.get("convective_top_plev")[0]
-
-        x = np.log10(atmosphere["plev"])
-        xmin = np.log10(self.uth_plev)
-        xmax = x[0]
-
-        a = (self.uth - self.rh_min) * 4 / (xmin - xmax) ** 2
-        b = (xmin + xmax) / 2
-        c = self.rh_min
-
-        return np.clip(a * (x - b) ** 2 + c, a_min=0, a_max=1)
-
-
-class CshapeDecrease(RelativeHumidityModel):
-    """Idealized model of a C-shaped RH profile using a quadratic equation."""
-
-    def __init__(self, uth_plev=200e2, rh_min=0.3, uth=0.8):
-        self.uth_plev = uth_plev
-        self.rh_min = rh_min
-        self.uth = uth
-        self.rh_surface = uth
-
-    def __call__(self, atmosphere, convection, **kwargs):
-        self.uth_plev = convection.get("convective_top_plev")[0]
-
-        x = np.log10(atmosphere["plev"])
-        xmin = np.log10(self.uth_plev)
-        xmax = x[0]
-
-        a = (self.uth - self.rh_min) * 4 / (xmin - xmax) ** 2
-        b = (xmin + xmax) / 2
-        c = self.rh_min
-
-        rh = np.clip(a * (x - b) ** 2 + c, a_min=0, a_max=1)
-
-        rh[x < xmin] *= (10 ** x / 10 ** xmin)[x < xmin]
-
-        return rh
-
-
 class Manabe67(RelativeHumidityModel):
     """Relative humidity model following Manabe and Wetherald (1967)."""
 
@@ -278,14 +139,16 @@ def __call__(self, atmosphere, **kwargs):
 
 
 class PolynomialCshapedRH(RelativeHumidityModel):
-    """
-    Defines a C-shaped polynomial model, that depends on T in the upper troposphere.
-    The RH increases linearly in the boundary layer from the surface.
-    Between the top of the boundary layer and the freezing level (T=273.15K), the rh is a quadratic function of p,
-    defined by its values at these to points, and a zero derivative at the freezing level.
-    Above the freezing level, the rh is a quadratic function of T, defined by its values at the freezing level and
-    at a chose upper-tropospheric T-value or at the cold point (see `top_peak_T` argument), and a zero derivative
-    at the freezing level.
+    """Defines a C-shaped polynomial model, that depends on T in the upper troposphere.
+
+    The RH increases linearly in the boundary layer from the surface.  Between
+    the top of the boundary layer and the freezing level (T=273.15K), the rh is
+    a quadratic function of p, defined by its values at these to points, and a
+    zero derivative at the freezing level.  Above the freezing level, the rh is
+    a quadratic function of T, defined by its values at the freezing level and
+    at a chose upper-tropospheric T-value or at the cold point (see `top_peak_T`
+    argument), and a zero derivative at the freezing level.
+
     """
 
     def __init__(
@@ -374,7 +237,7 @@ class PerturbProfile(RelativeHumidityModel):
 
     def __init__(
         self,
-        base_profile=HeightConstant(),
+        base_profile=VerticallyUniform(),
         shape="square",
         center_plev=500e2,
         width=50e2,
diff --git a/konrad/humidity/stratosphere.py b/konrad/humidity/stratosphere.py
index 48969e6a..08ab4baa 100644
--- a/konrad/humidity/stratosphere.py
+++ b/konrad/humidity/stratosphere.py
@@ -6,8 +6,16 @@
 from konrad.component import Component
 
 
+__al__ = [
+    "StratosphereCoupler",
+    "ColdPointCoupling",
+    "FixedStratosphericVMR",
+]
+
+
 class StratosphereCoupler(Component, metaclass=abc.ABCMeta):
     """Define the coupling of tropospheric and stratospheric water vapor."""
+
     @abc.abstractmethod
     def adjust_stratospheric_vmr(self, atmosphere):
         """Adjust stratospheric water vapor VMR values.
@@ -18,29 +26,21 @@ def adjust_stratospheric_vmr(self, atmosphere):
         Parameters:
             atmosphere (``konrad.atmosphere.Atmosphere``):
                 Atmosphere component.
-            """
+        """
         return
 
 
 class ColdPointCoupling(StratosphereCoupler):
     """Keep stratospheric VMR constant from the cold point on."""
-    def adjust_stratospheric_vmr(self, atmosphere):
-        cp_index = atmosphere.get_cold_point_index()
-        atmosphere['H2O'][-1, cp_index:] = atmosphere['H2O'][-1, cp_index]
 
-
-class NonIncreasing(StratosphereCoupler):
-    """Prevent the VMR from increasing with height anywhere in the column."""
     def adjust_stratospheric_vmr(self, atmosphere):
-        h2o = atmosphere['H2O'][-1, :]
-        h2o_grad = np.diff(h2o)
-        if not np.all(h2o_grad < 0):
-            index = np.argmax(h2o_grad > 0)
-            atmosphere['H2O'][-1, index+1:] = atmosphere['H2O'][-1, index]
+        cp_index = atmosphere.get_cold_point_index()
+        atmosphere["H2O"][-1, cp_index:] = atmosphere["H2O"][-1, cp_index]
 
 
 class FixedStratosphericVMR(StratosphereCoupler):
     """Keep stratospheric VMR fixed at a constant value."""
+
     def __init__(self, stratospheric_vmr=5e-6):
         """
         Parameters:
@@ -50,27 +50,4 @@ def __init__(self, stratospheric_vmr=5e-6):
 
     def adjust_stratospheric_vmr(self, atmosphere):
         cp_index = atmosphere.get_cold_point_index()
-        atmosphere['H2O'][-1, cp_index:] = self.stratospheric_vmr
-
-
-class MinimumStratosphericVMR(StratosphereCoupler):
-    """Prevent stratospheric VMR from decreasing below a fixed minimum value."""
-    def __init__(self, minimum_vmr=5e-6):
-        """
-        Parameters:
-            minimum_vmr (float): Minimum water vapor amount [VMR].
-        """
-        self.minimum_vmr = minimum_vmr
-
-    def adjust_stratospheric_vmr(self, atmosphere):
-        vmr = atmosphere['H2O'][-1, :]
-
-        # If the VMR falls below the stratospheric background...
-        if np.any(vmr < self.minimum_vmr):
-            # ... set all values equal to the background from there.
-            vmr[np.argmax(vmr < self.minimum_vmr):] = self.minimum_vmr
-        else:
-            # Otherwise find the smallest VMR and use the background value
-            # from there on, this at least minimizes the discontinuity at
-            # the transition point.
-            vmr[np.argmin(vmr):] = self.minimum_vmr
+        atmosphere["H2O"][-1, cp_index:] = self.stratospheric_vmr
diff --git a/konrad/lapserate.py b/konrad/lapserate.py
index 02916115..82d53ec3 100644
--- a/konrad/lapserate.py
+++ b/konrad/lapserate.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """Contains classes for handling atmospheric temperature lapse rates.
 These are used by the convection sub-model to set the temperature profile in
 the troposphere.
@@ -166,4 +165,3 @@ def get_moist_adiabat(p, p_s=None, T_s=300.0, T_min=155.0):
         i += 1
 
     return T.clip(min=T_min)
-
diff --git a/konrad/netcdf.py b/konrad/netcdf.py
index 924b4864..e0f4b293 100644
--- a/konrad/netcdf.py
+++ b/konrad/netcdf.py
@@ -4,12 +4,12 @@
 import netCDF4
 import numpy as np
 
-from konrad import (constants, __version__)
+from konrad import constants, __version__
 from konrad.component import Component
 
 
 __all__ = [
-    'NetcdfHandler',
+    "NetcdfHandler",
 ]
 
 logger = logging.getLogger(__name__)
@@ -30,7 +30,7 @@ def convert_unsupported_types(variable):
     if isinstance(variable, str):
         return np.asarray([variable])
 
-    if hasattr(variable, 'values'):
+    if hasattr(variable, "values"):
         return variable.values
 
     return variable
@@ -52,11 +52,12 @@ class NetcdfHandler:
         >>> nc.write()  # write (append) current RCE state to file
 
     """
+
     def __init__(self, filename, rce):
         self.filename = filename
         self.rce = rce
 
-        self.udim = 'time'
+        self.udim = "time"
         self.udim_size = 0
         self.groups = []
         self._component_cache = {}
@@ -64,13 +65,15 @@ def __init__(self, filename, rce):
         self.create_file()
 
     def create_file(self):
-        with netCDF4.Dataset(self.filename, mode='w') as root:
-            root.setncatts({
-                'title': self.rce.experiment,
-                'created': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
-                'source': f'konrad {__version__}',
-                'references': 'https://github.com/atmtools/konrad',
-            })
+        with netCDF4.Dataset(self.filename, mode="w") as root:
+            root.setncatts(
+                {
+                    "title": self.rce.experiment,
+                    "created": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                    "source": f"konrad {__version__}",
+                    "references": "https://github.com/atmtools/konrad",
+                }
+            )
 
         logger.debug(f'Created "{self.filename}".')
 
@@ -101,14 +104,13 @@ def append_description(self, variable):
         desc = constants.variable_description.get(variable.name, {})
 
         for attribute_name, value in desc.items():
-            logger.debug(
-                f'Added attribute "{attribute_name}" to "{variable.name}".')
+            logger.debug(f'Added attribute "{attribute_name}" to "{variable.name}".')
             setattr(variable, attribute_name, value)
 
     def create_group(self, component, groupname):
-        with netCDF4.Dataset(self.filename, 'a') as root:
+        with netCDF4.Dataset(self.filename, "a") as root:
             group = root.createGroup(groupname)
-            group.setncattr('class', type(component).__name__)
+            group.setncattr("class", type(component).__name__)
 
             for attr, value in component.attrs.items():
                 self.create_variable(group, attr, value)
@@ -127,20 +129,21 @@ def create_group(self, component, groupname):
             self.groups.append(groupname)
 
     def append_group(self, component, groupname):
-        with netCDF4.Dataset(self.filename, 'a') as root:
+        with netCDF4.Dataset(self.filename, "a") as root:
             group = root[groupname]
 
             for varname, (dims, data) in component.data_vars.items():
                 if self.udim not in dims:
                     continue
 
-                s = [self.udim_size if dim == self.udim else slice(None)
-                     for dim in dims]
+                s = [
+                    self.udim_size if dim == self.udim else slice(None) for dim in dims
+                ]
 
                 group.variables[varname][tuple(s)] = data
 
     def expand_unlimited_dimension(self):
-        with netCDF4.Dataset(self.filename, 'a') as root:
+        with netCDF4.Dataset(self.filename, "a") as root:
             self.udim_size = root.dimensions[self.udim].size
 
             desc = constants.variable_description.get(self.udim, {})
@@ -155,11 +158,11 @@ def get_components(self):
         if len(self._component_cache) == 0:
             # Ensure that the atmosphere component is stored first as it holds
             # the common coordinates `plev` and `phlev`.
-            self._component_cache['atmosphere'] = self.rce.atmosphere
+            self._component_cache["atmosphere"] = self.rce.atmosphere
 
             for attr_name in dir(self.rce):
                 attr = getattr(self.rce, attr_name)
-                if attr_name.startswith('_') or not isinstance(attr, Component):
+                if attr_name.startswith("_") or not isinstance(attr, Component):
                     continue  # Only cache (#1) non-private (#2) components.
 
                 if hasattr(attr, "netcdf_subgroups"):
@@ -176,7 +179,7 @@ def initialize_file(self):
         for name, component in self.get_components().items():
             self.create_group(component, name)
 
-        with netCDF4.Dataset(self.filename, 'a') as root:
+        with netCDF4.Dataset(self.filename, "a") as root:
             root.variables[self.udim][:] = 0
 
     def append_to_file(self):
diff --git a/konrad/ozone.py b/konrad/ozone.py
index 0fc6128e..2bc0c021 100644
--- a/konrad/ozone.py
+++ b/konrad/ozone.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This module contains classes handling different treatments of ozone.
 The ozone models can either be used in RCE simulations, or it may be of
 interest to run the :py:class:`Cariolle` or :py:class:`Simotrostra` models with
@@ -44,13 +43,13 @@
 from konrad.component import Component
 
 __all__ = [
-    'Ozone',
-    'OzonePressure',
-    'OzoneHeight',
-    'OzoneNormedPressure',
-    'OzoneRedistributed',
-    'Cariolle',
-    'Simotrostra',
+    "Ozone",
+    "OzonePressure",
+    "OzoneHeight",
+    "OzoneNormedPressure",
+    "OzoneRedistributed",
+    "Cariolle",
+    "Simotrostra",
 ]
 
 logger = logging.getLogger(__name__)
@@ -64,7 +63,7 @@ def __init__(self):
         Parameters:
             initial_ozone (ndarray): initial ozone vmr profile
         """
-        self['initial_ozone'] = (('plev',), None)
+        self["initial_ozone"] = (("plev",), None)
 
     @abc.abstractmethod
     def __call__(self, atmosphere, convection, timestep, zenith):
@@ -84,27 +83,30 @@ def __call__(self, atmosphere, convection, timestep, zenith):
 
 class OzonePressure(Ozone):
     """Ozone fixed with pressure, no adjustment needed."""
+
     def __call__(self, **kwargs):
         return
 
 
 class OzoneHeight(Ozone):
     """Ozone fixed with height."""
+
     def __init__(self):
         self._f = None
 
     def __call__(self, atmosphere, **kwargs):
         if self._f is None:
             self._f = interp1d(
-                atmosphere['z'][0, :],
-                atmosphere['O3'],
-                fill_value='extrapolate',
+                atmosphere["z"][0, :],
+                atmosphere["O3"],
+                fill_value="extrapolate",
             )
-        atmosphere['O3'] = (('time', 'plev'), self._f(atmosphere['z'][0, :]))
+        atmosphere["O3"] = (("time", "plev"), self._f(atmosphere["z"][0, :]))
 
 
 class OzoneNormedPressure(Ozone):
     """Ozone shifts with the normalisation level."""
+
     def __init__(self, norm_level=None, coupling="convective_top"):
         """
         Parameters:
@@ -119,12 +121,11 @@ def __init__(self, norm_level=None, coupling="convective_top"):
         self._f = None
         self.coupling = coupling
 
-
     def get_norm_level(self, atmosphere, convection):
-        if self.coupling == 'convective_top':
+        if self.coupling == "convective_top":
             # TODO: what if there is no convective top
-            return convection.get('convective_top_plev')[0]
-        elif self.coupling == 'cold_point':
+            return convection.get("convective_top_plev")[0]
+        elif self.coupling == "cold_point":
             return atmosphere.get_cold_point_plev(interpolate=True)
         else:
             raise ValueError("Invalid coupling mechanism.")
@@ -135,55 +136,58 @@ def __call__(self, atmosphere, convection, **kwargs):
 
         if self._f is None:
             self._f = interp1d(
-                atmosphere['plev'] / self.norm_level,
-                atmosphere['O3'][0, :],
-                fill_value='extrapolate',
+                atmosphere["plev"] / self.norm_level,
+                atmosphere["O3"][0, :],
+                fill_value="extrapolate",
             )
 
         norm_new = self.get_norm_level(atmosphere, convection)
 
-        atmosphere['O3'] = (
-            ('time', 'plev'),
-            self._f(atmosphere['plev'] / norm_new).clip(min=0).reshape(1, -1)
+        atmosphere["O3"] = (
+            ("time", "plev"),
+            self._f(atmosphere["plev"] / norm_new).clip(min=0).reshape(1, -1),
         )
 
 
 class OzoneRedistributed(Ozone):
     """Ozone redistribution following method by Hardiman et al. (2019)"""
+
     def __init__(self):
         self._f = None
-    
+
     def get_tropopause_index(self, atmosphere):
         """Get thermal and ozone tropopause indexes"""
         z = atmosphere["z"][0, :] / 1000
         T = atmosphere["T"][0, :]
         lapse_rate_K_per_km = np.gradient(T, z)
-        
+
         mask1 = np.where(lapse_rate_K_per_km > -2)[0]
         thermal_tropopause = False
-        i=0
+        i = 0
         while not thermal_tropopause:
             index = mask1[i]
-            limit_test = np.where(z-z[index] >= 2)[0][0]
-            region = lapse_rate_K_per_km[index:limit_test + 1]
+            limit_test = np.where(z - z[index] >= 2)[0][0]
+            region = lapse_rate_K_per_km[index : limit_test + 1]
             if np.all(region >= -2):
                 thermal_tropopause = index
             i += 1
-        
-        ozone_tropopause = np.where(z-z[thermal_tropopause] > -1)[0][0]
-        ozone_tropopause_sub = np.where(z-z[ozone_tropopause] > -2)[0][0]
-        ozone_tropopause_super = np.where(z-z[thermal_tropopause] > 2)[0][0]
-        
-        return [thermal_tropopause, 
-                ozone_tropopause_sub, 
-                ozone_tropopause, 
-                ozone_tropopause_super]
-        
+
+        ozone_tropopause = np.where(z - z[thermal_tropopause] > -1)[0][0]
+        ozone_tropopause_sub = np.where(z - z[ozone_tropopause] > -2)[0][0]
+        ozone_tropopause_super = np.where(z - z[thermal_tropopause] > 2)[0][0]
+
+        return [
+            thermal_tropopause,
+            ozone_tropopause_sub,
+            ozone_tropopause,
+            ozone_tropopause_super,
+        ]
+
     def redistribute_ozone(self, atmosphere):
         """Redistribute ozone according to Hardiman"""
         from typhon.physics import density as rhopT
         import copy
-       
+
         tropopause = self.get_tropopause_index(atmosphere)
         ozone = copy.deepcopy(atmosphere["O3"][0, :])
         ozone_val = 1.32e-7 * (28.9644 / 47.9982)
@@ -191,47 +195,50 @@ def redistribute_ozone(self, atmosphere):
         if ozone[tropopause[2]] > ozone_val:
             mask1 = ozone - ozone_val > 0
             mask2 = np.where(ozone)[0] <= tropopause[2]
-            mask1 = np.logical_and(mask1,mask2)
+            mask1 = np.logical_and(mask1, mask2)
             ozone_n[mask1] = ozone_val
-            
+
         elif ozone[tropopause[2]] < ozone_val:
-            plevs = atmosphere["plev"][tropopause[1]:tropopause[2] + 1]
+            plevs = atmosphere["plev"][tropopause[1] : tropopause[2] + 1]
             logO30 = np.log(ozone[tropopause[1]])
             logO31 = np.log(ozone_val)
             m = (logO31 - logO30) / (plevs[-1] - plevs[0])
             O3 = np.exp((m * (plevs - plevs[0])) + logO30)
-            ozone_n[tropopause[1]:tropopause[2] + 1] = O3
-            
-        plevs = atmosphere["plev"][tropopause[2] + 1:tropopause[3] + 1]
+            ozone_n[tropopause[1] : tropopause[2] + 1] = O3
+
+        plevs = atmosphere["plev"][tropopause[2] + 1 : tropopause[3] + 1]
         logO30 = np.log(ozone_val)
         logO31 = np.log(ozone[tropopause[3]])
         m = (logO31 - logO30) / (plevs[-1] - plevs[0])
         O3 = np.exp((m * (plevs - plevs[0])) + logO30)
-        ozone_n[tropopause[2] + 1:tropopause[3] + 1] = O3
-        
-        rho = rhopT(atmosphere["plev"],atmosphere["T"][0, :])
-        dp = np.hstack((np.array([atmosphere["plev"][0] - 
-                                  atmosphere["phlev"][0]]), 
-                        np.diff(atmosphere["plev"])))
+        ozone_n[tropopause[2] + 1 : tropopause[3] + 1] = O3
+
+        rho = rhopT(atmosphere["plev"], atmosphere["T"][0, :])
+        dp = np.hstack(
+            (
+                np.array([atmosphere["plev"][0] - atmosphere["phlev"][0]]),
+                np.diff(atmosphere["plev"]),
+            )
+        )
         odiff = ozone_n[:] - ozone[:]
-        total_odiff = - rho * odiff * dp
-        total_odiff = np.sum(total_odiff[0:tropopause[0]+1])
-        total_ozone_strato = - rho * ozone[:] * dp
-        total_ozone_strato = np.sum(total_ozone_strato[tropopause[0]+1:])
+        total_odiff = -rho * odiff * dp
+        total_odiff = np.sum(total_odiff[0 : tropopause[0] + 1])
+        total_ozone_strato = -rho * ozone[:] * dp
+        total_ozone_strato = np.sum(total_ozone_strato[tropopause[0] + 1 :])
         factor_ozone_strato = 1 + (total_odiff / total_ozone_strato)
-        ozone_n[tropopause[0]:] *= factor_ozone_strato
+        ozone_n[tropopause[0] :] *= factor_ozone_strato
 
         return ozone_n
 
     def __call__(self, atmosphere, **kwargs):
         ozone_new = self.redistribute_ozone(atmosphere)
 
-        atmosphere['O3'] = (('time', 'plev'), ozone_new.reshape(1, -1))
+        atmosphere["O3"] = (("time", "plev"), ozone_new.reshape(1, -1))
 
 
 class Cariolle(Ozone):
-    """Implementation of the Cariolle ozone scheme for the tropics.
-    """
+    """Implementation of the Cariolle ozone scheme for the tropics."""
+
     def __init__(self, w=0, is_coupled_upwelling=False):
         """
         Parameters:
@@ -268,7 +275,7 @@ def ozone_transport(self, o3, z, upwelling):
             w = self.w
             numlevels = len(z)
             w_factor = np.ones(numlevels)
-            w_array = w*w_factor
+            w_array = w * w_factor
 
         do3dz = np.gradient(o3, z)
 
@@ -276,13 +283,13 @@ def ozone_transport(self, o3, z, upwelling):
 
     def get_params(self, p):
         cariolle_data = Dataset(
-            os.path.join(os.path.dirname(__file__),
-                         'data/Cariolle_data.nc'))
-        p_data = cariolle_data['p'][:]
+            os.path.join(os.path.dirname(__file__), "data/Cariolle_data.nc")
+        )
+        p_data = cariolle_data["p"][:]
         alist = []
         for param_num in range(1, 8):
-            a = cariolle_data[f'A{param_num}'][:]
-            alist.append(interp1d(p_data, a, fill_value='extrapolate')(p))
+            a = cariolle_data[f"A{param_num}"][:]
+            alist.append(interp1d(p_data, a, fill_value="extrapolate")(p))
         return alist
 
     def __call__(self, atmosphere, timestep, upwelling, **kwargs):
@@ -297,31 +304,30 @@ def __call__(self, atmosphere, timestep, upwelling, **kwargs):
                 "https://gitlab.com/simple-stratospheric-chemistry/simotrostra"
             )
 
-        T = atmosphere['T'][0, :]
-        p = atmosphere['plev']  # [Pa]
-        o3 = atmosphere['O3'][0, :]  # moles of ozone / moles of air
-        z = atmosphere['z'][0, :]  # m
+        T = atmosphere["T"][0, :]
+        p = atmosphere["plev"]  # [Pa]
+        o3 = atmosphere["O3"][0, :]  # moles of ozone / moles of air
+        z = atmosphere["z"][0, :]  # m
 
-        o3col = overhead_molecules(o3, p, z, T
-                                   ) * 10 ** -4  # in molecules / cm2
+        o3col = overhead_molecules(o3, p, z, T) * 10 ** -4  # in molecules / cm2
 
         A1, A2, A3, A4, A5, A6, A7 = self.get_params(p)
         # A7 is in molecules / cm2
         # tendency of ozone volume mixing ratio per second
-        do3dt = A1 + A2*(o3 - A3) + A4*(T - A5) + A6*(o3col - A7)
+        do3dt = A1 + A2 * (o3 - A3) + A4 * (T - A5) + A6 * (o3col - A7)
 
         # transport term
         transport_ox = self.ozone_transport(o3, z, upwelling)
 
-        atmosphere['O3'] = (
-            ('time', 'plev'),
-            (o3 + (do3dt * 24 * 60**2 + transport_ox) * timestep).reshape(1, -1)
+        atmosphere["O3"] = (
+            ("time", "plev"),
+            (o3 + (do3dt * 24 * 60 ** 2 + transport_ox) * timestep).reshape(1, -1),
         )
 
 
 class Simotrostra(Cariolle):
-    """Wrapper for Ed Charlesworth's simple chemistry scheme.
-    """
+    """Wrapper for Ed Charlesworth's simple chemistry scheme."""
+
     def __init__(self, w=0, is_coupled_upwelling=False):
         """
         Parameters:
@@ -355,14 +361,15 @@ def simotrostra_profile(self, o3, atmosphere, timestep, zenith, upwelling):
             ndarray: new ozone profile
             list of ndarrays: source and sink terms
         """
-        z = atmosphere['z'][-1, :]
-        p, phlev = atmosphere['plev'], atmosphere['phlev']
-        T = atmosphere['T'][-1, :]
+        z = atmosphere["z"][-1, :]
+        p, phlev = atmosphere["plev"], atmosphere["phlev"]
+        T = atmosphere["T"][-1, :]
         source, sink_ox, sink_nox, sink_hox = self._ozone.tendencies(
-            z, p, phlev, T, o3, zenith)
+            z, p, phlev, T, o3, zenith
+        )
         transport_ox = self.ozone_transport(o3, z, upwelling)
         do3dt = source - sink_ox - sink_nox + transport_ox - sink_hox
-        o3_new = o3 + do3dt*timestep
+        o3_new = o3 + do3dt * timestep
 
         # prevent concentrations getting too low - set tropospheric value
         o3_new.clip(min=4e-8, out=o3_new)
@@ -375,12 +382,13 @@ def store_sink_terms(self, sink_terms):
             sink_terms (list of ndarrays): source and sink terms [ppv / day]
         """
         source, sink_ox, sink_nox, transport_ox, sink_hox = sink_terms
-        for term, tendency in [('ozone_source', source),
-                               ('ozone_sink_ox', sink_ox),
-                               ('ozone_sink_nox', sink_nox),
-                               ('ozone_transport', transport_ox),
-                               ('ozone_sink_hox', sink_hox)
-                               ]:
+        for term, tendency in [
+            ("ozone_source", source),
+            ("ozone_sink_ox", sink_ox),
+            ("ozone_sink_nox", sink_nox),
+            ("ozone_transport", transport_ox),
+            ("ozone_sink_hox", sink_hox),
+        ]:
             if term in self.data_vars:
                 self.set(term, tendency)
             else:
@@ -388,11 +396,11 @@ def store_sink_terms(self, sink_terms):
 
     def __call__(self, atmosphere, timestep, upwelling, zenith, **kwargs):
 
-        o3 = atmosphere['O3'][-1, :]
-        o3_new, sink_terms = self.simotrostra_profile(o3, atmosphere,
-                                                      timestep, zenith,
-                                                      upwelling)
+        o3 = atmosphere["O3"][-1, :]
+        o3_new, sink_terms = self.simotrostra_profile(
+            o3, atmosphere, timestep, zenith, upwelling
+        )
 
-        atmosphere['O3'] = (('time', 'plev'), o3_new.reshape(1, -1))
+        atmosphere["O3"] = (("time", "plev"), o3_new.reshape(1, -1))
 
         self.store_sink_terms(sink_terms)
diff --git a/konrad/plots.py b/konrad/plots.py
deleted file mode 100644
index b63cb64a..00000000
--- a/konrad/plots.py
+++ /dev/null
@@ -1,149 +0,0 @@
-# -*- coding: utf-8 -*-
-"""Plotting related functions.
-"""
-from matplotlib.ticker import FuncFormatter
-import matplotlib.pyplot as plt
-import numpy as np
-import typhon.plots
-
-
-__all__ = [
-    'plot_overview_p_log',
-    'plot_overview_z',
-    'gregory_plot',
-]
-
-
-@FuncFormatter
-def _percent_formatter(x, pos):
-    return '{:.0f}\N{SIX-PER-EM SPACE}%'.format(x * 100)
-
-
-def plot_overview_p_log(data, lw_htngrt, sw_htngrt, axes, **kwargs):
-    """Plot overview of atmopsheric temperature and humidity profiles.
-
-    Parameters:
-        data:
-        lw_htngrt:
-        sw_htngrt:
-        axes (list, tuple or ndarray): Three AxesSubplots.
-        **kwargs: Additional keyword arguments passed to all calls
-            of `atmospheric_profile`.
-    """
-    if len(axes) != 3:
-        raise Exception('Need to pass three AxesSubplot.')
-    ax1, ax2, ax3 = np.ravel(axes)
-
-    # Plot temperature, ...
-    typhon.plots.profile_p_log(data['plev'], data['T'].ravel(),
-                               ax=ax1, **kwargs)
-    ax1.set_xlabel('Temperature [K]')
-    ax1.set_xlim(140, 320)
-
-    # ... water vapor ...
-    typhon.plots.profile_p_log(data['plev'], data['H2O'].ravel(),
-                               ax=ax2, **kwargs)
-    ax2.set_xlabel('$\mathsf{H_2O}$ [VMR]')
-    ax2.set_xlim(0, 0.04)
-
-    typhon.plots.profile_p_log(data['plev'], lw_htngrt,
-                               ax=ax3, label='Longwave')
-    typhon.plots.profile_p_log(data['plev'], sw_htngrt,
-                               ax=ax3, label='Shortwave')
-    typhon.plots.profile_p_log(data['plev'], sw_htngrt + lw_htngrt, ax=ax3,
-                               label='Net rate', color='k')
-    ax3.set_xlabel('Heatingrate [°C/day]')
-    ax3.legend(loc='upper center')
-
-
-def plot_overview_z(data, lw_htngrt, sw_htngrt, axes, **kwargs):
-    """Plot overview of atmopsheric temperature and humidity profiles.
-
-    Parameters:
-        data:
-        lw_htngrt:
-        sw_htngrt:
-        axes (list, tuple or ndarray): Three AxesSubplots.
-        **kwargs: Additional keyword arguments passed to all calls
-            of `atmospheric_profile`.
-    """
-    if len(axes) != 3:
-        raise Exception('Need to pass three AxesSubplot.')
-    ax1, ax2, ax3 = np.ravel(axes)
-
-    # Plot temperature, ...
-    typhon.plots.profile_z(data['Z'], data['T'], ax=ax1, **kwargs)
-    ax1.set_xlabel('Temperature [K]')
-    ax1.set_xlim(140, 320)
-
-    # ... water vapor ...
-    typhon.plots.profile_z(data['Z'], data['H2O'], ax=ax2, **kwargs)
-    ax2.set_xlabel('$\mathsf{H_2O}$ [VMR]')
-    ax2.set_xlim(0, 0.04)
-
-    typhon.plots.profile_z(data['Z'], lw_htngrt, ax=ax3, label='Longwave')
-    typhon.plots.profile_z(data['Z'], sw_htngrt, ax=ax3, label='Shortwave')
-    typhon.plots.profile_z(data['Z'], sw_htngrt + lw_htngrt, ax=ax3,
-                           label='Net rate', color='k')
-    ax3.set_xlabel('Heatingrate [°C/day]')
-    ax3.legend(loc='upper center')
-
-
-def gregory_plot(temperature, forcing, draw_fit=True, ax=None, **kwargs):
-    """Gregory plot to estimate climate sensitivity.
-
-    Parameters:
-          temperature (ndarray): Surface temperatures [K].
-          forcing (ndarray): Radiation budget at top of atmosphere [W//m^2].
-          draw_fit (bool): Whether to draw the linear regression.
-          ax (AxesSubplot): Axes to plot in.
-          **kwargs: Additional keyword arguments are passed to ``plt.plot``.
-
-    Returns:
-          float, float: Estimated climate sensitivty [K / (W/m^2)],
-            effective forcing [W / m^2].
-
-    Examples:
-        >>> temperature = np.linspace(300, 304, 25)
-        >>> forcing = np.linspace(3.7, 0., temperature.size)
-        >>> gregory_plot(temperature, forcing)
-        (1.0810810810810814, 3.6999999999999993)
-
-    """
-    # If no axis is passed, use current axis (will create one, if needed).
-    if ax is None:
-        ax = plt.gca()
-
-    # Default keyword arguments to control the plot appearance later.
-    default_kwargs = {
-        'marker': 'o',
-        'linestyle': 'none',
-    }
-    default_kwargs.update(kwargs)
-
-    # Convert temperatures into change in temperature.
-    t_change = temperature - temperature[0]
-
-    # Plot radiative forcing against surface temperature change.
-    line, = ax.plot(t_change, forcing, **default_kwargs)
-    ax.set_xlabel('Surface temperature change [K]')
-    ax.set_ylabel('Radiation budget TOA [W/m$^2$]')
-    ax.grid(True)
-
-    # Find the maximum radiative forcing. This way, possible adjustment
-    # processes during the first timesteps are not taken into account.
-    max_forcing = np.argmax(forcing)
-    sensitivity, eff_forcing = np.polyfit(t_change[max_forcing:],
-                                          forcing[max_forcing:], 1)
-
-    # Create x-values for "Gregory" fit. Values are plotted between zero
-    # temperature change and zero forcing.
-    x = np.linspace(0, - eff_forcing / sensitivity, 10)
-
-    if draw_fit:
-        # Plot linear "Gregory" fit into same axis.
-        ax.plot(x, eff_forcing + sensitivity * x, color=line.get_color())
-
-    # Return the estimated climate sensivity in units of K / (W/m^2) and the
-    # effective forcing in W / m^2.
-    return -1 / sensitivity, eff_forcing
diff --git a/konrad/radiation/__init__.py b/konrad/radiation/__init__.py
index 7dbebd7d..2435f9c3 100644
--- a/konrad/radiation/__init__.py
+++ b/konrad/radiation/__init__.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This module defines methods required for a radiation scheme to be used in
 a radiative-convective simulation and also contains a wrapper for RRTMG.
 
@@ -29,4 +28,4 @@
 from .common import *
 
 
-__all__ = [s for s in dir() if not s.startswith('_')]
+__all__ = [s for s in dir() if not s.startswith("_")]
diff --git a/konrad/radiation/arts.py b/konrad/radiation/arts.py
index b6dc93ca..99f554e1 100644
--- a/konrad/radiation/arts.py
+++ b/konrad/radiation/arts.py
@@ -100,8 +100,7 @@ def cloudbox_agenda(workspace):
 
         # Read lookup table
         abs_lookup = os.getenv(
-            "KONRAD_LOOKUP_TABLE",
-            join(dirname(__file__), "data/abs_lookup.xml")
+            "KONRAD_LOOKUP_TABLE", join(dirname(__file__), "data/abs_lookup.xml")
         )
 
         if not isfile(abs_lookup):
@@ -128,7 +127,7 @@ def cloudbox_agenda(workspace):
         if threads is not None:
             self.ws.SetNumberOfThreads(threads)
 
-    def calc_lookup_table(self, filename=None, fnum=2**15, wavenumber=None):
+    def calc_lookup_table(self, filename=None, fnum=2 ** 15, wavenumber=None):
         """Calculate an absorption lookup table.
 
         The lookup table is constructed to cover surface temperatures
@@ -182,7 +181,7 @@ def calc_lookup_table(self, filename=None, fnum=2**15, wavenumber=None):
         atmosphere["O2"][:] = 0.2095
         atmosphere["CO2"][:] = 1.5 * 348e-6
 
-        h2o = 0.01 * (p_grid / 1000e2)**0.2
+        h2o = 0.01 * (p_grid / 1000e2) ** 0.2
         atmosphere["H2O"][:] = h2o[:-1]
 
         # Convert the konrad atmosphere into an ARTS atm_fields_compact.
@@ -203,14 +202,17 @@ def calc_lookup_table(self, filename=None, fnum=2**15, wavenumber=None):
         self.ws.abs_lookupSetup(p_step=1.0)  # Do not refine p_grid
         self.ws.abs_t_pert = np.arange(-160, 61, 20)
 
-        nls_idx = [i for i, tag in enumerate(self.ws.abs_species.value)
-                   if "H2O" in tag[0]]
+        nls_idx = [
+            i for i, tag in enumerate(self.ws.abs_species.value) if "H2O" in tag[0]
+        ]
         self.ws.abs_speciesSet(
-                abs_species=self.ws.abs_nls,
-                species=[", ".join(self.ws.abs_species.value[nls_idx[0]])],
+            abs_species=self.ws.abs_nls,
+            species=[", ".join(self.ws.abs_species.value[nls_idx[0]])],
         )
 
-        self.ws.abs_nls_pert = np.array([10**x for x in [-9, -7, -5, -3, -1, 0, 0.5, 1, 1.5, 2]])
+        self.ws.abs_nls_pert = np.array(
+            [10 ** x for x in [-9, -7, -5, -3, -1, 0, 0.5, 1, 1.5, 2]]
+        )
 
         # Run checks
         self.ws.abs_xsec_agenda_checkedCalc()
@@ -237,9 +239,11 @@ def set_atmospheric_state(self, atmosphere, t_surface):
             variable_vmrs = np.zeros(t3_shape)
 
         for species in atm_fields_compact.grids[0]:
-            if (species.startswith("abs_species-")
+            if (
+                species.startswith("abs_species-")
                 and "H2O" not in species
-                and "CO2" not in species):
+                and "CO2" not in species
+            ):
                 atm_fields_compact.scale(species, 1 - variable_vmrs)
 
         # Compute the N2 VMR as a residual of the full atmosphere composition.
@@ -276,9 +280,7 @@ def calc_spectral_irradiance_field(self, atmosphere, t_surface):
 
         # get the zenith angle grid and the integrations weights
         self.ws.AngularGridsSetFluxCalc(
-            N_za_grid=self.nstreams,
-            N_aa_grid=1,
-            za_grid_type="double_gauss"
+            N_za_grid=self.nstreams, N_aa_grid=1, za_grid_type="double_gauss"
         )
 
         # calculate intensity field
@@ -389,32 +391,32 @@ def calc_radiation(self, atmosphere, surface, cloud):
         def _reshape(x, trim=-1):
             return x[:trim].reshape(1, -1)
 
-        self['lw_flxu'] = _reshape(Fu, trim=None)
-        self['lw_flxd'] = _reshape(Fd, trim=None)
-        self['lw_flxu_clr'] = _reshape(Fu, trim=None)
-        self['lw_flxd_clr'] = _reshape(Fd, trim=None)
-        self['sw_flxu'] = _reshape(
-            sw_fluxes['upwelling_shortwave_flux_in_air'].data)
-        self['sw_flxd'] = _reshape(
-            sw_fluxes['downwelling_shortwave_flux_in_air'].data)
-        self['sw_flxu_clr'] = _reshape(
-            sw_fluxes['upwelling_shortwave_flux_in_air_assuming_clear_sky'].data)
-        self['sw_flxd_clr'] = _reshape(
-            sw_fluxes['downwelling_shortwave_flux_in_air_assuming_clear_sky'].data)
-
-        self['lw_htngrt'] = np.zeros((1, atmosphere["plev"].size))
-        self['lw_htngrt_clr'] = np.zeros((1, atmosphere["plev"].size))
-        self['sw_htngrt'] = np.zeros((1, atmosphere["plev"].size))
-        self['sw_htngrt_clr'] = np.zeros((1, atmosphere["plev"].size))
+        self["lw_flxu"] = _reshape(Fu, trim=None)
+        self["lw_flxd"] = _reshape(Fd, trim=None)
+        self["lw_flxu_clr"] = _reshape(Fu, trim=None)
+        self["lw_flxd_clr"] = _reshape(Fd, trim=None)
+        self["sw_flxu"] = _reshape(sw_fluxes["upwelling_shortwave_flux_in_air"].data)
+        self["sw_flxd"] = _reshape(sw_fluxes["downwelling_shortwave_flux_in_air"].data)
+        self["sw_flxu_clr"] = _reshape(
+            sw_fluxes["upwelling_shortwave_flux_in_air_assuming_clear_sky"].data
+        )
+        self["sw_flxd_clr"] = _reshape(
+            sw_fluxes["downwelling_shortwave_flux_in_air_assuming_clear_sky"].data
+        )
+
+        self["lw_htngrt"] = np.zeros((1, atmosphere["plev"].size))
+        self["lw_htngrt_clr"] = np.zeros((1, atmosphere["plev"].size))
+        self["sw_htngrt"] = np.zeros((1, atmosphere["plev"].size))
+        self["sw_htngrt_clr"] = np.zeros((1, atmosphere["plev"].size))
 
         self.coords = {
-            'time': np.array([0]),
-            'phlev': atmosphere['phlev'],
-            'plev': atmosphere['plev'],
+            "time": np.array([0]),
+            "phlev": atmosphere["phlev"],
+            "plev": atmosphere["plev"],
         }
 
         if self.store_spectral_olr:
-            self.coords.update({'frequency': f})
+            self.coords.update({"frequency": f})
             self.create_variable(
                 name="outgoing_longwave_radiation",
                 data=irradiance_field[:, -1, 0, 0, 1].reshape(1, -1),
@@ -430,24 +432,24 @@ def fluxes(net_fluxes, pressure):
             f = PchipInterpolator(np.log(pressure[::-1]), Q[::-1])
             return f(np.log(atmosphere["plev"]))
 
-        self['sw_htngrt'][-1] = fluxes(
-            net_fluxes=self['sw_flxu'][-1] - self['sw_flxd'][-1],
-            pressure=atmosphere['phlev'],
+        self["sw_htngrt"][-1] = fluxes(
+            net_fluxes=self["sw_flxu"][-1] - self["sw_flxd"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['sw_htngrt_clr'][-1] = fluxes(
-            net_fluxes=self['sw_flxu_clr'][-1] - self['sw_flxd_clr'][-1],
-            pressure=atmosphere['phlev'],
+        self["sw_htngrt_clr"][-1] = fluxes(
+            net_fluxes=self["sw_flxu_clr"][-1] - self["sw_flxd_clr"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['lw_htngrt'][-1] = fluxes(
-            net_fluxes=self['lw_flxu'][-1] - self['lw_flxd'][-1],
-            pressure=atmosphere['phlev'],
+        self["lw_htngrt"][-1] = fluxes(
+            net_fluxes=self["lw_flxu"][-1] - self["lw_flxd"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['lw_htngrt_clr'][-1] = fluxes(
-            net_fluxes=self['lw_flxu_clr'][-1] - self['lw_flxd_clr'][-1],
-            pressure=atmosphere['phlev'],
+        self["lw_htngrt_clr"][-1] = fluxes(
+            net_fluxes=self["lw_flxu_clr"][-1] - self["lw_flxd_clr"][-1],
+            pressure=atmosphere["phlev"],
         )
 
         self.derive_diagnostics()
diff --git a/konrad/radiation/common.py b/konrad/radiation/common.py
index 9f7258ba..83d5cd51 100644
--- a/konrad/radiation/common.py
+++ b/konrad/radiation/common.py
@@ -3,7 +3,7 @@
 from konrad import constants
 
 
-def fluxes2heating(net_fluxes, pressure, cp=None, method='diff'):
+def fluxes2heating(net_fluxes, pressure, cp=None, method="diff"):
     r"""Calculate radiative heating from net fluxes
 
     .. math::
@@ -24,9 +24,9 @@ def fluxes2heating(net_fluxes, pressure, cp=None, method='diff'):
     if cp is None:
         cp = constants.isobaric_mass_heat_capacity_dry_air
 
-    if method == 'diff':
+    if method == "diff":
         dfdp = np.diff(net_fluxes) / np.diff(pressure)
-    elif method == 'gradient':
+    elif method == "gradient":
         dfdp = np.gradient(net_fluxes, pressure)
     else:
         raise ValueError(f'Method has to be "diff" or "gradient".')
diff --git a/konrad/radiation/radiation.py b/konrad/radiation/radiation.py
index df5e4fd3..82b0372d 100644
--- a/konrad/radiation/radiation.py
+++ b/konrad/radiation/radiation.py
@@ -16,22 +16,23 @@
 logger = logging.getLogger(__name__)
 
 __all__ = [
-    'Radiation',
+    "Radiation",
 ]
 
 # Subclasses of `Radiation` need to define a `Radiation.calc_radiation()`
 # method that returns a `xr.Dataset` containing at least following variables:
 REQUIRED_VARIABLES = [
-    'net_htngrt',
-    'lw_flxd',
-    'lw_flxu',
-    'sw_flxd',
-    'sw_flxu',
+    "net_htngrt",
+    "lw_flxd",
+    "lw_flxu",
+    "sw_flxd",
+    "sw_flxu",
 ]
 
 
 class Radiation(Component, metaclass=abc.ABCMeta):
     """Abstract base class to define requirements for radiation models."""
+
     def __init__(self, zenith_angle=42.05, bias=None):
         """
         Parameters:
@@ -55,22 +56,22 @@ def __init__(self, zenith_angle=42.05, bias=None):
 
         self._bias = bias
 
-        self['lw_htngrt'] = (('time', 'plev'), None)
-        self['lw_htngrt_clr'] = (('time', 'plev'), None)
-        self['lw_flxu'] = (('time', 'phlev'), None)
-        self['lw_flxd'] = (('time', 'phlev'), None)
-        self['lw_flxu_clr'] = (('time', 'phlev'), None)
-        self['lw_flxd_clr'] = (('time', 'phlev'), None)
-        self['sw_htngrt'] = (('time', 'plev'), None)
-        self['sw_htngrt_clr'] = (('time', 'plev'), None)
-        self['sw_flxu'] = (('time', 'phlev'), None)
-        self['sw_flxd'] = (('time', 'phlev'), None)
-        self['sw_flxu_clr'] = (('time', 'phlev'), None)
-        self['sw_flxd_clr'] = (('time', 'phlev'), None)
-
-        self['net_htngrt'] = (('time', 'plev'), None)
-        self['net_htngrt_clr'] = (('time', 'plev'), None)
-        self['toa'] = (('time',), None)
+        self["lw_htngrt"] = (("time", "plev"), None)
+        self["lw_htngrt_clr"] = (("time", "plev"), None)
+        self["lw_flxu"] = (("time", "phlev"), None)
+        self["lw_flxd"] = (("time", "phlev"), None)
+        self["lw_flxu_clr"] = (("time", "phlev"), None)
+        self["lw_flxd_clr"] = (("time", "phlev"), None)
+        self["sw_htngrt"] = (("time", "plev"), None)
+        self["sw_htngrt_clr"] = (("time", "plev"), None)
+        self["sw_flxu"] = (("time", "phlev"), None)
+        self["sw_flxd"] = (("time", "phlev"), None)
+        self["sw_flxu_clr"] = (("time", "phlev"), None)
+        self["sw_flxd_clr"] = (("time", "phlev"), None)
+
+        self["net_htngrt"] = (("time", "plev"), None)
+        self["net_htngrt_clr"] = (("time", "plev"), None)
+        self["toa"] = (("time",), None)
 
     @abc.abstractmethod
     def calc_radiation(self, atmosphere, surface, cloud):
@@ -93,24 +94,24 @@ def update_heatingrates(self, atmosphere, surface=None, cloud=None):
 
         # self.correct_bias(rad_dataset)
 
-        self['sw_htngrt'][-1] = fluxes2heating(
-            net_fluxes=self['sw_flxu'][-1] - self['sw_flxd'][-1],
-            pressure=atmosphere['phlev'],
+        self["sw_htngrt"][-1] = fluxes2heating(
+            net_fluxes=self["sw_flxu"][-1] - self["sw_flxd"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['sw_htngrt_clr'][-1] = fluxes2heating(
-            net_fluxes=self['sw_flxu_clr'][-1] - self['sw_flxd_clr'][-1],
-            pressure=atmosphere['phlev'],
+        self["sw_htngrt_clr"][-1] = fluxes2heating(
+            net_fluxes=self["sw_flxu_clr"][-1] - self["sw_flxd_clr"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['lw_htngrt'][-1] = fluxes2heating(
-            net_fluxes=self['lw_flxu'][-1] - self['lw_flxd'][-1],
-            pressure=atmosphere['phlev'],
+        self["lw_htngrt"][-1] = fluxes2heating(
+            net_fluxes=self["lw_flxu"][-1] - self["lw_flxd"][-1],
+            pressure=atmosphere["phlev"],
         )
 
-        self['lw_htngrt_clr'][-1] = fluxes2heating(
-            net_fluxes=self['lw_flxu_clr'][-1] - self['lw_flxd_clr'][-1],
-            pressure=atmosphere['phlev'],
+        self["lw_htngrt_clr"][-1] = fluxes2heating(
+            net_fluxes=self["lw_flxu_clr"][-1] - self["lw_flxd_clr"][-1],
+            pressure=atmosphere["phlev"],
         )
 
         self.derive_diagnostics()
@@ -120,9 +121,7 @@ def check_dataset(dataset):
         """Check if a given dataset contains all required variables."""
         for key in REQUIRED_VARIABLES:
             if key not in dataset.variables:
-                raise KeyError(
-                    f'"{key}" not present in radiative transfer results.'
-                )
+                raise KeyError(f'"{key}" not present in radiative transfer results.')
 
     def correct_bias(self, dataset):
         """Apply bias correction."""
@@ -134,7 +133,7 @@ def correct_bias(self, dataset):
                 x = self._bias[zdim].values
                 y = self._bias[key].values
 
-                f_interp = interp1d(x, y, fill_value='extrapolate')
+                f_interp = interp1d(x, y, fill_value="extrapolate")
                 bias_dict[key] = f_interp(dataset[zdim].values)
 
             self._bias = bias_dict
@@ -144,17 +143,15 @@ def correct_bias(self, dataset):
                 if key not in dataset.indexes:
                     dataset[key] -= value
 
-
     def derive_diagnostics(self):
         """Derive diagnostic variables from radiative transfer results."""
         # Net heating rate.
-        self['net_htngrt'] = self['lw_htngrt'] + self['sw_htngrt']
-        self['net_htngrt_clr'] = self['lw_htngrt_clr'] + self['sw_htngrt_clr']
+        self["net_htngrt"] = self["lw_htngrt"] + self["sw_htngrt"]
+        self["net_htngrt_clr"] = self["lw_htngrt_clr"] + self["sw_htngrt_clr"]
 
         # Radiation budget at top of the atmosphere (TOA).
-        self['toa'] = (
-            (self['sw_flxd'][:, -1] + self['lw_flxd'][:, -1]) -
-            (self['sw_flxu'][:, -1] + self['lw_flxu'][:, -1])
+        self["toa"] = (self["sw_flxd"][:, -1] + self["lw_flxd"][:, -1]) - (
+            self["sw_flxu"][:, -1] + self["lw_flxu"][:, -1]
         )
 
     @staticmethod
@@ -185,8 +182,8 @@ def adjust_solar_angle(self, time):
         """
         # The local zenith angle, calculated from the latitude and longitude.
         # Seasons are not considered.
-        solar_angle = np.rad2deg(np.arccos(
-            np.cos(np.deg2rad(self.zenith_angle)) * 
-            np.cos(2 * np.pi * time)))
+        solar_angle = np.rad2deg(
+            np.arccos(np.cos(np.deg2rad(self.zenith_angle)) * np.cos(2 * np.pi * time))
+        )
 
         self.current_solar_angle = solar_angle
diff --git a/konrad/radiation/rrtmg.py b/konrad/radiation/rrtmg.py
index e0bee7b6..9389d363 100644
--- a/konrad/radiation/rrtmg.py
+++ b/konrad/radiation/rrtmg.py
@@ -11,15 +11,14 @@
 from konrad.cloud import ClearSky, CloudEnsemble
 
 __all__ = [
-    'RRTMG',
+    "RRTMG",
 ]
 
 
 class RRTMG(Radiation):
     """RRTMG radiation scheme using the CliMT python wrapper."""
 
-    def __init__(self, *args, solar_constant=551.58, mcica=False,
-                 **kwargs):
+    def __init__(self, *args, solar_constant=551.58, mcica=False, **kwargs):
         """
         Parameters:
             zenith_angle (float): angle of the Sun [degrees].
@@ -61,97 +60,110 @@ def __init__(self, *args, solar_constant=551.58, mcica=False,
 
     def init_radiative_state(self, atmosphere, surface):
 
-        climt.set_constants_from_dict({"stellar_irradiance": {
-                "value": self.solar_constant, "units": 'W m^-2'}})
+        climt.set_constants_from_dict(
+            {"stellar_irradiance": {"value": self.solar_constant, "units": "W m^-2"}}
+        )
         if self._is_mcica:
-            overlap = 'maximum_random'
+            overlap = "maximum_random"
         else:
-            overlap = 'random'
+            overlap = "random"
         self._rad_lw = climt.RRTMGLongwave(
             cloud_optical_properties=self._cloud_optical_properties,
             cloud_ice_properties=self._cloud_ice_properties,
-            cloud_liquid_water_properties='radius_dependent_absorption',
+            cloud_liquid_water_properties="radius_dependent_absorption",
             cloud_overlap_method=overlap,
-            mcica=self._is_mcica)
+            mcica=self._is_mcica,
+        )
         self._rad_sw = climt.RRTMGShortwave(
             ignore_day_of_year=True,
             cloud_optical_properties=self._cloud_optical_properties,
             cloud_ice_properties=self._cloud_ice_properties,
-            cloud_liquid_water_properties='radius_dependent_absorption',
+            cloud_liquid_water_properties="radius_dependent_absorption",
             cloud_overlap_method=overlap,
-            mcica=self._is_mcica)
+            mcica=self._is_mcica,
+        )
         state_lw = {}
         state_sw = {}
 
-        plev = atmosphere['plev']
-        phlev = atmosphere['phlev']
+        plev = atmosphere["plev"]
+        phlev = atmosphere["phlev"]
         numlevels = len(plev)
 
         for state0 in state_lw, state_sw:
-            state0['mid_levels'] = DataArray(
-                    np.arange(0, numlevels),
-                    dims=('mid_levels',),
-                    attrs={'label': 'mid_levels'})
+            state0["mid_levels"] = DataArray(
+                np.arange(0, numlevels),
+                dims=("mid_levels",),
+                attrs={"label": "mid_levels"},
+            )
 
-            state0['interface_levels'] = DataArray(
-                    np.arange(0, numlevels+1),
-                    dims=('interface_levels',),
-                    attrs={'label': 'interface_levels'})
+            state0["interface_levels"] = DataArray(
+                np.arange(0, numlevels + 1),
+                dims=("interface_levels",),
+                attrs={"label": "interface_levels"},
+            )
 
-            state0['air_pressure'] = DataArray(
-                    plev,
-                    dims=('mid_levels',),
-                    attrs={'units': 'Pa'})
+            state0["air_pressure"] = DataArray(
+                plev, dims=("mid_levels",), attrs={"units": "Pa"}
+            )
 
-            state0['air_pressure_on_interface_levels'] = DataArray(
-                    phlev,
-                    dims=('interface_levels',),
-                    attrs={'units': 'Pa'})
+            state0["air_pressure_on_interface_levels"] = DataArray(
+                phlev, dims=("interface_levels",), attrs={"units": "Pa"}
+            )
 
-            state0['time'] = datetime.datetime(2000, 1, 1)
+            state0["time"] = datetime.datetime(2000, 1, 1)
 
         ### Aerosols ###
         # TODO: Should all the aerosol values be zero?!
         # Longwave specific
         num_lw_bands = self._rad_lw.num_longwave_bands
 
-        state_lw['longwave_optical_thickness_due_to_aerosol'] = DataArray(
-                np.zeros((num_lw_bands, numlevels)),
-                dims=('num_longwave_bands', 'mid_levels'),
-                attrs={'units': 'dimensionless'})
-        state_lw['surface_longwave_emissivity'] = DataArray(
+        state_lw["longwave_optical_thickness_due_to_aerosol"] = DataArray(
+            np.zeros((num_lw_bands, numlevels)),
+            dims=("num_longwave_bands", "mid_levels"),
+            attrs={"units": "dimensionless"},
+        )
+        state_lw["surface_longwave_emissivity"] = DataArray(
             surface.longwave_emissivity * np.ones((num_lw_bands,)),
-            dims=('num_longwave_bands'),
-            attrs={'units': 'dimensionless'})
+            dims=("num_longwave_bands"),
+            attrs={"units": "dimensionless"},
+        )
 
         # Shortwave specific changes
         num_sw_bands = self._rad_sw.num_shortwave_bands
 
         num_aerosols = self._rad_sw.num_ecmwf_aerosols
-        state_sw['aerosol_optical_depth_at_55_micron'] = DataArray(
-                np.zeros((num_aerosols, numlevels)),
-                dims=('num_ecmwf_aerosols', 'mid_levels'),
-                attrs={'units': 'dimensionless'})
-        state_sw['solar_cycle_fraction'] = DataArray(
-            0, attrs={'units': 'dimensionless'})
-        state_sw['flux_adjustment_for_earth_sun_distance'] = DataArray(
-            1, attrs={'units': 'dimensionless'})
-
-        for surface_albedo in ['surface_albedo_for_diffuse_near_infrared',
-                               'surface_albedo_for_direct_near_infrared',
-                               'surface_albedo_for_diffuse_shortwave',
-                               'surface_albedo_for_direct_shortwave']:
-            state_sw[surface_albedo] = DataArray(
-                np.array(float(surface.albedo)),
-                attrs={'units': 'dimensionless'})
+        state_sw["aerosol_optical_depth_at_55_micron"] = DataArray(
+            np.zeros((num_aerosols, numlevels)),
+            dims=("num_ecmwf_aerosols", "mid_levels"),
+            attrs={"units": "dimensionless"},
+        )
+        state_sw["solar_cycle_fraction"] = DataArray(
+            0, attrs={"units": "dimensionless"}
+        )
+        state_sw["flux_adjustment_for_earth_sun_distance"] = DataArray(
+            1, attrs={"units": "dimensionless"}
+        )
 
-        for quant in ['shortwave_optical_thickness_due_to_aerosol',
-                      'single_scattering_albedo_due_to_aerosol',
-                      'aerosol_asymmetry_parameter']:
+        for surface_albedo in [
+            "surface_albedo_for_diffuse_near_infrared",
+            "surface_albedo_for_direct_near_infrared",
+            "surface_albedo_for_diffuse_shortwave",
+            "surface_albedo_for_direct_shortwave",
+        ]:
+            state_sw[surface_albedo] = DataArray(
+                np.array(float(surface.albedo)), attrs={"units": "dimensionless"}
+            )
+
+        for quant in [
+            "shortwave_optical_thickness_due_to_aerosol",
+            "single_scattering_albedo_due_to_aerosol",
+            "aerosol_asymmetry_parameter",
+        ]:
             state_sw[quant] = DataArray(
                 np.zeros((num_sw_bands, numlevels)),
-                dims=('num_shortwave_bands', 'mid_levels'),
-                attrs={'units': 'dimensionless'})
+                dims=("num_shortwave_bands", "mid_levels"),
+                attrs={"units": "dimensionless"},
+            )
 
         return state_lw, state_sw
 
@@ -159,29 +171,27 @@ def update_cloudy_radiative_state(self, cloud, state0, sw=True):
 
         # Take cloud quantities from cloud class.
         props = (
-           'cloud_ice_particle_size',
-           'mass_content_of_cloud_liquid_water_in_atmosphere_layer',
-           'mass_content_of_cloud_ice_in_atmosphere_layer',
-           'cloud_water_droplet_radius',
-           'cloud_area_fraction_in_atmosphere_layer',
+            "cloud_ice_particle_size",
+            "mass_content_of_cloud_liquid_water_in_atmosphere_layer",
+            "mass_content_of_cloud_ice_in_atmosphere_layer",
+            "cloud_water_droplet_radius",
+            "cloud_area_fraction_in_atmosphere_layer",
         )
 
-        lw_props = (
-            'longwave_optical_thickness_due_to_cloud',
-        )
+        lw_props = ("longwave_optical_thickness_due_to_cloud",)
 
         sw_props = (
-            'cloud_forward_scattering_fraction',
-            'cloud_asymmetry_parameter',
-            'shortwave_optical_thickness_due_to_cloud',
-            'single_scattering_albedo_due_to_cloud',
+            "cloud_forward_scattering_fraction",
+            "cloud_asymmetry_parameter",
+            "shortwave_optical_thickness_due_to_cloud",
+            "single_scattering_albedo_due_to_cloud",
         )
 
         for varname in props + sw_props if sw else props + lw_props:
             state0[varname] = cloud[varname]
 
     def update_radiative_state(self, atmosphere, surface, state0, sw=True):
-        """ Update CliMT formatted atmospheric state using parameters from our
+        """Update CliMT formatted atmospheric state using parameters from our
         model.
 
         Parameters:
@@ -194,47 +204,45 @@ def update_radiative_state(self, atmosphere, surface, state0, sw=True):
             dictionary: updated state
         """
 
-        state0['air_temperature'] = DataArray(
-            atmosphere['T'][0, :],
-            dims=('mid_levels',),
-            attrs={'units': 'degK'})
+        state0["air_temperature"] = DataArray(
+            atmosphere["T"][0, :], dims=("mid_levels",), attrs={"units": "degK"}
+        )
 
-        vmr_h2o = atmosphere['H2O'][0, :]
+        vmr_h2o = atmosphere["H2O"][0, :]
         specific_humidity = vmr2specific_humidity(vmr_h2o)
-        state0['specific_humidity'] = DataArray(
-            specific_humidity,
-            dims=('mid_levels',),
-            attrs={'units': 'g/g'})
+        state0["specific_humidity"] = DataArray(
+            specific_humidity, dims=("mid_levels",), attrs={"units": "g/g"}
+        )
 
         # CliMT/konrad name mapping
         gas_name_mapping = [
-            ('mole_fraction_of_methane_in_air', 'CH4'),
-            ('mole_fraction_of_carbon_dioxide_in_air', 'CO2'),
-            ('mole_fraction_of_nitrous_oxide_in_air', 'N2O'),
-            ('mole_fraction_of_ozone_in_air', 'O3'),
-            ('mole_fraction_of_cfc11_in_air', 'CFC11'),
-            ('mole_fraction_of_cfc12_in_air', 'CFC12'),
-            ('mole_fraction_of_cfc22_in_air', 'CFC22'),
-            ('mole_fraction_of_carbon_tetrachloride_in_air', 'CCl4'),
-            ('mole_fraction_of_oxygen_in_air', 'O2'),
+            ("mole_fraction_of_methane_in_air", "CH4"),
+            ("mole_fraction_of_carbon_dioxide_in_air", "CO2"),
+            ("mole_fraction_of_nitrous_oxide_in_air", "N2O"),
+            ("mole_fraction_of_ozone_in_air", "O3"),
+            ("mole_fraction_of_cfc11_in_air", "CFC11"),
+            ("mole_fraction_of_cfc12_in_air", "CFC12"),
+            ("mole_fraction_of_cfc22_in_air", "CFC22"),
+            ("mole_fraction_of_carbon_tetrachloride_in_air", "CCl4"),
+            ("mole_fraction_of_oxygen_in_air", "O2"),
         ]
 
         for climt_key, konrad_key in gas_name_mapping:
             vmr = atmosphere.get(konrad_key, default=0, keepdims=False)
             state0[climt_key] = DataArray(
-                vmr,
-                dims=('mid_levels',),
-                attrs={'units': 'mole/mole'})
+                vmr, dims=("mid_levels",), attrs={"units": "mole/mole"}
+            )
 
         # Surface quantities
-        state0['surface_temperature'] = DataArray(
-            np.array(surface['temperature'][-1]),
-            attrs={'units': 'degK'})
+        state0["surface_temperature"] = DataArray(
+            np.array(surface["temperature"][-1]), attrs={"units": "degK"}
+        )
 
         if sw:  # properties required only for shortwave
-            state0['zenith_angle'] = DataArray(
+            state0["zenith_angle"] = DataArray(
                 np.array(np.deg2rad(self.current_solar_angle)),
-                attrs={'units': 'radians'})
+                attrs={"units": "radians"},
+            )
 
         return state0
 
@@ -254,7 +262,8 @@ def radiative_fluxes(self, atmosphere, surface, cloud):
             self._cloud_optical_properties = cloud._rrtmg_cloud_optical_properties
             self._cloud_ice_properties = cloud._rrtmg_cloud_ice_properties
             self._state_lw, self._state_sw = self.init_radiative_state(
-                    atmosphere, surface)
+                atmosphere, surface
+            )
             self.update_cloudy_radiative_state(cloud, self._state_lw, sw=False)
             self.update_cloudy_radiative_state(cloud, self._state_sw, sw=True)
 
@@ -263,10 +272,8 @@ def radiative_fluxes(self, atmosphere, surface, cloud):
             self.update_cloudy_radiative_state(cloud, self._state_lw, sw=False)
             self.update_cloudy_radiative_state(cloud, self._state_sw, sw=True)
 
-        self.update_radiative_state(atmosphere, surface, self._state_lw,
-                                    sw=False)
-        self.update_radiative_state(atmosphere, surface, self._state_sw,
-                                    sw=True)
+        self.update_radiative_state(atmosphere, surface, self._state_lw, sw=False)
+        self.update_radiative_state(atmosphere, surface, self._state_sw, sw=True)
 
         lw_fluxes = self._rad_lw(self._state_lw)
         sw_fluxes = self._rad_sw(self._state_sw)
@@ -275,16 +282,17 @@ def radiative_fluxes(self, atmosphere, surface, cloud):
 
     def calc_cloudy_nomcica_radiation(self, atmosphere, surface, cloud):
 
-        cloud_fraction = deepcopy(cloud['cloud_area_fraction_in_atmosphere_layer'][:])
+        cloud_fraction = deepcopy(cloud["cloud_area_fraction_in_atmosphere_layer"][:])
 
         if self._state_sw is None:  # first time only
             cf_cloudy = cloud_fraction[cloud_fraction != 0]
             if cf_cloudy.size > 0:
                 if not np.all(cf_cloudy == cf_cloudy[0]):
                     logging.warning(
-                        'The konrad implementation of nomcica with partial '
-                        'cloud fraction is only suitable for a single '
-                        'rectangular cloud. Consider using mcica instead.')
+                        "The konrad implementation of nomcica with partial "
+                        "cloud fraction is only suitable for a single "
+                        "rectangular cloud. Consider using mcica instead."
+                    )
 
         cf_max = np.max(cloud_fraction)
 
@@ -292,22 +300,20 @@ def calc_cloudy_nomcica_radiation(self, atmosphere, surface, cloud):
         # Make all the cloudy layers overcast, so that the nomcica version of
         # RRTMG can be used in the shortwave - all wavelengths see cloud.
         # Use the same approach for the longwave for consistency.
-        cloud['cloud_area_fraction_in_atmosphere_layer'][cloud_fraction != 0] = 1
-        lw_overcast, sw_overcast = self.radiative_fluxes(
-            atmosphere, surface, cloud
-        )
+        cloud["cloud_area_fraction_in_atmosphere_layer"][cloud_fraction != 0] = 1
+        lw_overcast, sw_overcast = self.radiative_fluxes(atmosphere, surface, cloud)
         lw_fluxes, sw_fluxes = lw_overcast[1], sw_overcast[1]
 
         # Combine overcast and clear sky fluxes and heating rates to get the
         # all sky fluxes and heating rates.
         for fluxes in lw_fluxes, sw_fluxes:
             for key in fluxes.keys():
-                if 'clear_sky' not in key:
-                    clear_part = fluxes[key + '_assuming_clear_sky'][:]
+                if "clear_sky" not in key:
+                    clear_part = fluxes[key + "_assuming_clear_sky"][:]
                     fluxes[key][:] *= cf_max  # weighted by cloud area fraction
                     fluxes[key][:] += (1 - cf_max) * clear_part
 
-        cloud['cloud_area_fraction_in_atmosphere_layer'][:] *= cloud_fraction
+        cloud["cloud_area_fraction_in_atmosphere_layer"][:] *= cloud_fraction
 
         return lw_fluxes, sw_fluxes
 
@@ -329,7 +335,8 @@ def calc_radiation(self, atmosphere, surface, cloud):
                 sw_fluxes = {}
                 for weight, cloud_case in zip(weights, cloud_combinations):
                     lw_temp, sw_temp = self.radiative_fluxes(
-                        atmosphere, surface, cloud_case)
+                        atmosphere, surface, cloud_case
+                    )
 
                     for key, value in lw_temp[1].items():
                         if key not in lw_fluxes.keys():
@@ -345,40 +352,58 @@ def calc_radiation(self, atmosphere, surface, cloud):
 
             else:
                 lw_fluxes, sw_fluxes = self.calc_cloudy_nomcica_radiation(
-                    atmosphere, surface, cloud)
+                    atmosphere, surface, cloud
+                )
         else:
             lw_dT_fluxes, sw_dT_fluxes = self.radiative_fluxes(
-                atmosphere, surface, cloud)
+                atmosphere, surface, cloud
+            )
             lw_fluxes = lw_dT_fluxes[1]
             sw_fluxes = sw_dT_fluxes[1]
 
-        self['lw_htngrt'] = np.expand_dims(
-                lw_fluxes['air_temperature_tendency_from_longwave'].data, 0)
-        self['lw_htngrt_clr'] = np.expand_dims(
-                lw_fluxes['air_temperature_tendency_from_longwave_assuming_clear_sky'].data, 0)
-        self['lw_flxu'] = np.expand_dims(
-                lw_fluxes['upwelling_longwave_flux_in_air'].data, 0)
-        self['lw_flxd'] = np.expand_dims(
-                lw_fluxes['downwelling_longwave_flux_in_air'].data, 0)
-        self['lw_flxu_clr'] = np.expand_dims(
-                lw_fluxes['upwelling_longwave_flux_in_air_assuming_clear_sky'].data, 0)
-        self['lw_flxd_clr'] = np.expand_dims(
-                lw_fluxes['downwelling_longwave_flux_in_air_assuming_clear_sky'].data, 0)
-        self['sw_htngrt'] = np.expand_dims(
-                sw_fluxes['air_temperature_tendency_from_shortwave'].data, 0)
-        self['sw_htngrt_clr'] = np.expand_dims(
-                sw_fluxes['air_temperature_tendency_from_shortwave_assuming_clear_sky'].data, 0)
-        self['sw_flxu'] = np.expand_dims(
-                sw_fluxes['upwelling_shortwave_flux_in_air'].data, 0)
-        self['sw_flxd'] = np.expand_dims(
-                sw_fluxes['downwelling_shortwave_flux_in_air'].data, 0)
-        self['sw_flxu_clr'] = np.expand_dims(
-                sw_fluxes['upwelling_shortwave_flux_in_air_assuming_clear_sky'].data, 0)
-        self['sw_flxd_clr'] = np.expand_dims(
-                sw_fluxes['downwelling_shortwave_flux_in_air_assuming_clear_sky'].data, 0)
-
-        self.coords={
-            'time': np.array([0]),
-            'phlev': atmosphere['phlev'],
-            'plev': atmosphere['plev'],
+        self["lw_htngrt"] = np.expand_dims(
+            lw_fluxes["air_temperature_tendency_from_longwave"].data, 0
+        )
+        self["lw_htngrt_clr"] = np.expand_dims(
+            lw_fluxes["air_temperature_tendency_from_longwave_assuming_clear_sky"].data,
+            0,
+        )
+        self["lw_flxu"] = np.expand_dims(
+            lw_fluxes["upwelling_longwave_flux_in_air"].data, 0
+        )
+        self["lw_flxd"] = np.expand_dims(
+            lw_fluxes["downwelling_longwave_flux_in_air"].data, 0
+        )
+        self["lw_flxu_clr"] = np.expand_dims(
+            lw_fluxes["upwelling_longwave_flux_in_air_assuming_clear_sky"].data, 0
+        )
+        self["lw_flxd_clr"] = np.expand_dims(
+            lw_fluxes["downwelling_longwave_flux_in_air_assuming_clear_sky"].data, 0
+        )
+        self["sw_htngrt"] = np.expand_dims(
+            sw_fluxes["air_temperature_tendency_from_shortwave"].data, 0
+        )
+        self["sw_htngrt_clr"] = np.expand_dims(
+            sw_fluxes[
+                "air_temperature_tendency_from_shortwave_assuming_clear_sky"
+            ].data,
+            0,
+        )
+        self["sw_flxu"] = np.expand_dims(
+            sw_fluxes["upwelling_shortwave_flux_in_air"].data, 0
+        )
+        self["sw_flxd"] = np.expand_dims(
+            sw_fluxes["downwelling_shortwave_flux_in_air"].data, 0
+        )
+        self["sw_flxu_clr"] = np.expand_dims(
+            sw_fluxes["upwelling_shortwave_flux_in_air_assuming_clear_sky"].data, 0
+        )
+        self["sw_flxd_clr"] = np.expand_dims(
+            sw_fluxes["downwelling_shortwave_flux_in_air_assuming_clear_sky"].data, 0
+        )
+
+        self.coords = {
+            "time": np.array([0]),
+            "phlev": atmosphere["phlev"],
+            "plev": atmosphere["plev"],
         }
diff --git a/konrad/surface.py b/konrad/surface.py
index 99d1360e..c0b12c04 100644
--- a/konrad/surface.py
+++ b/konrad/surface.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This module contains classes describing different surfaces.
 
 A surface is required by both the radiation and the convective models used
@@ -30,9 +29,9 @@
 
 
 __all__ = [
-    'Surface',
-    'FixedTemperature',
-    'SlabOcean',
+    "Surface",
+    "FixedTemperature",
+    "SlabOcean",
 ]
 
 
@@ -41,21 +40,23 @@
 
 class Surface(Component, metaclass=abc.ABCMeta):
     """Abstract base class to define requirements for surface models."""
-    def __init__(self, albedo=0.2, temperature=288., longwave_emissivity=1,
-                 height=0.):
+
+    def __init__(
+        self, temperature=288.0, albedo=0.2, longwave_emissivity=1, height=0.0
+    ):
         """Initialize a surface model.
 
         Parameters:
+            temperature (float): Surface temperature [K].
             albedo (float): Surface albedo [1]. The default value of 0.2 is a
                 decent choice for clear-sky simulation in the tropics.
-            temperature (int / float): Surface temperature [K].
             longwave_emissivity (float): Longwave emissivity [1].
-            height (int / float): Surface height [m].
+            height (float): Surface height [m].
         """
         self.albedo = albedo
         self.longwave_emissivity = longwave_emissivity
         self.height = height
-        self['temperature'] = (('time',), np.array([temperature], dtype=float))
+        self["temperature"] = (("time",), np.array([temperature], dtype=float))
 
         # The surface pressure is initialized before the first iteration
         # within the RCE framework to ensure a pressure that is consistent
@@ -63,7 +64,7 @@ def __init__(self, albedo=0.2, temperature=288., longwave_emissivity=1,
         self.pressure = None
 
         self.coords = {
-            'time': np.array([]),
+            "time": np.array([]),
         }
 
     @abc.abstractmethod
@@ -87,14 +88,14 @@ def from_atmosphere(cls, atmosphere, **kwargs):
             atmosphere (konrad.atmosphere.Atmosphere): Atmosphere model.
         """
         f = interp1d(
-            x=atmosphere['plev'],
-            y=atmosphere['T'][-1],
+            x=atmosphere["plev"],
+            y=atmosphere["T"][-1],
             kind="cubic",
             fill_value="extrapolate",
         )
 
         # The surface is placed at the lowest half-level pressure (`phlev`).
-        return cls(temperature=f(atmosphere['phlev'][0]), **kwargs)
+        return cls(temperature=f(atmosphere["phlev"][0]), **kwargs)
 
     @classmethod
     def from_netcdf(cls, ncfile, timestep=-1, **kwargs):
@@ -105,35 +106,39 @@ def from_netcdf(cls, ncfile, timestep=-1, **kwargs):
             timestep (int): Timestep to read (default is last timestep).
         """
         with netCDF4.Dataset(ncfile) as root:
-            if 'surface' in root.groups:
-                dataset = root['surface']
+            if "surface" in root.groups:
+                dataset = root["surface"]
             else:
                 dataset = root
 
-            t = dataset['temperature'][timestep].data.astype("float64")
-            z = float(dataset['height'][:])
-            alb = float(dataset['albedo'][:])
-            le = float(dataset['longwave_emissivity'][:])
+            t = dataset["temperature"][timestep].data.astype("float64")
+            z = float(dataset["height"][:])
+            alb = float(dataset["albedo"][:])
+            le = float(dataset["longwave_emissivity"][:])
 
-        return cls(temperature=t, height=z, albedo=alb, longwave_emissivity=le, **kwargs)
+        return cls(
+            temperature=t, height=z, albedo=alb, longwave_emissivity=le, **kwargs
+        )
 
 
 class SlabOcean(Surface):
     """Surface model with adjustable temperature."""
-    def __init__(self, *args, depth=50.0, heat_sink=66.0, **kwargs):
+
+    def __init__(self, depth=50.0, heat_sink=66.0, **kwargs):
         """Initialize a slab ocean.
 
         Parameters:
+            temperature (float): Surface temperature [K].
+            albedo (float): Surface albedo [1]. The default value of 0.2 is a
+                decent choice for clear-sky simulation in the tropics.
+            longwave_emissivity (float): Longwave emissivity [1].
+            height (int / float): Surface height [m].
             heat_sink (float): Flux of energy out of the surface [W m^-2].
                 The default value represents a surface enthalpy transport to
                 the extra-tropics.
             depth (float): Ocean depth [m].
-            albedo (float): Surface albedo [1].
-            temperature (float): Initial surface temperature [K].
-            longwave_emissivity (float): Longwave emissivity [1].
-            height (float): Surface height [m].
         """
-        super().__init__(*args, **kwargs)
+        super().__init__(**kwargs)
 
         self.rho = constants.density_sea_water
         self.c_p = constants.specific_heat_capacity_sea_water
@@ -158,14 +163,15 @@ def adjust(self, sw_down, sw_up, lw_down, lw_up, timestep):
 
         net_flux = (sw_down - sw_up) + (lw_down - lw_up)
 
-        logger.debug(f'Net flux: {net_flux:.2f} W /m^2')
+        logger.debug(f"Net flux: {net_flux:.2f} W /m^2")
 
-        self['temperature'] += (timestep * (net_flux - self.heat_sink) /
-                                self.heat_capacity)
+        self["temperature"] += (
+            timestep * (net_flux - self.heat_sink) / self.heat_capacity
+        )
 
         logger.debug("Surface temperature: {self['temperature'][0]:.4f} K")
 
-    @classmethod  
+    @classmethod
     def from_netcdf(cls, ncfile, timestep=-1, **kwargs):
         """Create a surface model from a netCDF file.
 
@@ -174,34 +180,43 @@ def from_netcdf(cls, ncfile, timestep=-1, **kwargs):
             timestep (int): Timestep to read (default is last timestep).
         """
         with netCDF4.Dataset(ncfile) as root:
-            if 'surface' in root.groups:
-                dataset = root['surface']
+            if "surface" in root.groups:
+                dataset = root["surface"]
             else:
                 dataset = root
 
-            t = dataset['temperature'][timestep].data.astype("float64")
-            z = float(dataset['height'][:])
-            alb = float(dataset['albedo'][:])
-            le = float(dataset['longwave_emissivity'][:])
-            hs = float(dataset['heat_sink'][:])
-            d = float(dataset['depth'][:])
-            
-        return cls(temperature=t, height=z, albedo=alb, longwave_emissivity=le, heat_sink=hs, depth=d, **kwargs)
+            t = dataset["temperature"][timestep].data.astype("float64")
+            z = float(dataset["height"][:])
+            alb = float(dataset["albedo"][:])
+            le = float(dataset["longwave_emissivity"][:])
+            hs = float(dataset["heat_sink"][:])
+            d = float(dataset["depth"][:])
+
+        return cls(
+            temperature=t,
+            height=z,
+            albedo=alb,
+            longwave_emissivity=le,
+            heat_sink=hs,
+            depth=d,
+            **kwargs,
+        )
 
 
 class FixedTemperature(Surface):
     """Surface model with fixed temperature."""
-    def __init__(self, *args, **kwargs):
+
+    def __init__(self, temperature=288.0, **kwargs):
         """Initialize a surface model with constant surface temperature.
 
         Parameters:
-            albedo (float): Surface albedo. The default value of 0.2 is a
+            temperature (float): Surface temperature [K].
+            albedo (float): Surface albedo [1]. The default value of 0.2 is a
                 decent choice for clear-sky simulation in the tropics.
-            temperature (int / float): Surface temperature [K].
-            longwave_emissivity (float): Longwave emissivity.
-            height (int / float): Surface height [m].
+            longwave_emissivity (float): Longwave emissivity [1].
+            height (float): Surface height [m].
         """
-        super().__init__(*args, **kwargs)
+        super().__init__(temperature=temperature, **kwargs)
         self.heat_capacity = np.inf
 
     def adjust(self, *args, **kwargs):
diff --git a/konrad/upwelling.py b/konrad/upwelling.py
index b094ae6e..e89bd23b 100644
--- a/konrad/upwelling.py
+++ b/konrad/upwelling.py
@@ -1,4 +1,3 @@
-# -*- coding: utf-8 -*-
 """This module contains classes for an upwelling induced cooling term.
 To include an upwelling, use :py:class:`StratosphericUpwelling`, otherwise use
 :py:class:`NoUpwelling`.
@@ -61,13 +60,18 @@ def bdc_profile(norm_level):
         callable: Brewer-Dobson circulation velocity [m / day] as a function
             of pressure [Pa]
     """
-    p = np.array([100, 80, 70, 60, 50, 40, 30, 20, 10])*100  # [Pa]
-    bdc = np.array([0.28, 0.24, 0.23, 0.225, 0.225, 0.24, 0.27, 0.32, 0.42]
-                   )*meters_per_day  # [m / day]
-    f = interp1d(np.log(p/norm_level), bdc,
-                 fill_value=(0.42*meters_per_day, 0.28*meters_per_day),
-                 bounds_error=False,
-                 kind='quadratic')
+    p = np.array([100, 80, 70, 60, 50, 40, 30, 20, 10]) * 100  # [Pa]
+    bdc = (
+        np.array([0.28, 0.24, 0.23, 0.225, 0.225, 0.24, 0.27, 0.32, 0.42])
+        * meters_per_day
+    )  # [m / day]
+    f = interp1d(
+        np.log(p / norm_level),
+        bdc,
+        fill_value=(0.42 * meters_per_day, 0.28 * meters_per_day),
+        bounds_error=False,
+        kind="quadratic",
+    )
     return f
 
 
@@ -76,7 +80,7 @@ class Upwelling(Component, metaclass=abc.ABCMeta):
 
     @abc.abstractmethod
     def cool(self, atmosphere, convection, timestep):
-        """ Cool the atmosphere according to an upwelling.
+        """Cool the atmosphere according to an upwelling.
 
         Parameters:
             atmosphere (konrad.atmosphere.Atmosphere): Atmosphere model.
@@ -87,12 +91,14 @@ def cool(self, atmosphere, convection, timestep):
 
 class NoUpwelling(Upwelling):
     """Do not apply a dynamical cooling."""
+
     def cool(self, *args, **kwargs):
         pass
 
 
 class StratosphericUpwelling(Upwelling):
     """Apply a dynamical cooling, based on a specified upwelling velocity."""
+
     def __init__(self, w=0.2, lowest_level=None):
         """Create a upwelling handler.
 
@@ -116,19 +122,19 @@ def cool(self, atmosphere, convection, timestep):
         # Ensure that the variable is initialized even if the upwelling is not
         # applied. A proper initaliziation is needed to write netCDF output.
         self.create_variable(
-            'cooling_rates',
-            dims=('time', 'plev'),
+            "cooling_rates",
+            dims=("time", "plev"),
             data=np.zeros_like(atmosphere["plev"]).reshape(1, -1),
         )
 
-        T = atmosphere['T'][0, :]
-        z = atmosphere['z'][0, :]
+        T = atmosphere["T"][0, :]
+        z = atmosphere["z"][0, :]
         Cp = atmosphere.get_heat_capacity()
 
         if self._lowest_level is not None:
             above_level_index = self._lowest_level
         else:
-            above_level_index = convection.get('convective_top_index')[0]
+            above_level_index = convection.get("convective_top_index")[0]
             if np.isnan(above_level_index):
                 # if convection hasn't been applied and a lowest level for the
                 # upwelling has not been specified, upwelling is not applied
@@ -137,13 +143,14 @@ def cool(self, atmosphere, convection, timestep):
 
         Q = cooling_rates(T, z, self._w, Cp, above_level_index)
 
-        atmosphere['T'][0, :] += Q * timestep
+        atmosphere["T"][0, :] += Q * timestep
 
-        self['cooling_rates'] = (('time', 'plev'), -Q.reshape(1, -1))
+        self["cooling_rates"] = (("time", "plev"), -Q.reshape(1, -1))
 
 
 class SpecifiedCooling(Upwelling):
     """Include an upwelling with specified cooling"""
+
     def __init__(self, Q):
         """
         Parameters:
@@ -158,12 +165,13 @@ def cool(self, atmosphere, timestep, **kwargs):
             atmosphere (konrad.atmosphere.Atmosphere): Atmosphere model.
             timestep (float): Timestep width [day].
         """
-        atmosphere['T'][0, :] += self._Q * timestep
+        atmosphere["T"][0, :] += self._Q * timestep
 
 
 class CoupledUpwelling(StratosphericUpwelling):
     """Include an upwelling based on reanalysis values for the BDC strength
     and coupled to the convective top."""
+
     def __init__(self, norm_plev=None):
         """
         Parameters:
@@ -185,26 +193,27 @@ def cool(self, atmosphere, convection, timestep):
             timestep (float): Timestep width [day].
         """
         if self._norm_plev is None:  # first time only and if not specified
-            above_level_index = convection.get('convective_top_index')[0]
+            above_level_index = convection.get("convective_top_index")[0]
             if np.isnan(above_level_index):
                 raise ValueError(
-                    'No convective top found and no input normalisation level '
-                    'for the coupled upwelling.')
-            self._norm_plev = atmosphere['plev'][above_level_index]
+                    "No convective top found and no input normalisation level "
+                    "for the coupled upwelling."
+                )
+            self._norm_plev = atmosphere["plev"][above_level_index]
 
         if self._f is None:  # first time only
             self._f = bdc_profile(self._norm_plev)
 
-        above_level_index = convection.get('convective_top_index')[0]
-        norm_plev = atmosphere['plev'][above_level_index]
-        self._w = self._f(np.log(atmosphere['plev'] / norm_plev))
+        above_level_index = convection.get("convective_top_index")[0]
+        norm_plev = atmosphere["plev"][above_level_index]
+        self._w = self._f(np.log(atmosphere["plev"] / norm_plev))
 
-        T = atmosphere['T'][0, :]
-        z = atmosphere['z'][0, :]
+        T = atmosphere["T"][0, :]
+        z = atmosphere["z"][0, :]
         Cp = atmosphere.get_heat_capacity()
         Q = cooling_rates(T, z, self._w, Cp, above_level_index)
 
-        atmosphere['T'][0, :] += Q * timestep
+        atmosphere["T"][0, :] += Q * timestep
 
-        self['w'] = (('time', 'plev'), self._w.reshape(1, -1))
-        self['cooling_rates'] = (('time', 'plev'), -Q.reshape(1, -1))
+        self["w"] = (("time", "plev"), self._w.reshape(1, -1))
+        self["cooling_rates"] = (("time", "plev"), -Q.reshape(1, -1))
diff --git a/konrad/utils.py b/konrad/utils.py
index 3899ed36..e70134ec 100644
--- a/konrad/utils.py
+++ b/konrad/utils.py
@@ -14,25 +14,24 @@
 
 
 __all__ = [
-    'append_description',
-    'append_timestep_netcdf',
-    'return_if_type',
-    'plev_from_phlev',
-    'dz_from_z',
-    'get_squeezable_pgrid',
-    'get_quadratic_pgrid',
-    'get_pressure_grids',
-    'ozonesquash',
-    'ozone_profile_rcemip',
-    'humidity_profile_rcemip',
-    'parse_fraction_of_day',
-    'standard_atmosphere',
-    'prefix_dict_keys',
-    'is_decreasing',
-    'calculate_combined_weights',
-    'gaussian',
-    'dp_from_dz',
-    'find_first_below',
+    "append_description",
+    "append_timestep_netcdf",
+    "return_if_type",
+    "plev_from_phlev",
+    "dz_from_z",
+    "get_quadratic_pgrid",
+    "get_pressure_grids",
+    "ozonesquash",
+    "ozone_profile_rcemip",
+    "humidity_profile_rcemip",
+    "parse_fraction_of_day",
+    "standard_atmosphere",
+    "prefix_dict_keys",
+    "is_decreasing",
+    "calculate_combined_weights",
+    "gaussian",
+    "dp_from_dz",
+    "find_first_below",
 ]
 
 logger = logging.getLogger(__name__)
@@ -76,23 +75,23 @@ def append_timestep_netcdf(filename, data, timestamp):
         timestamp (float): Timestamp of values appended.
     """
     # Open netCDF4 file in `append` mode.
-    with Dataset(filename, 'a') as nc:
+    with Dataset(filename, "a") as nc:
         logging.debug('Append timestep to "{}".'.format(filename))
-        t = nc.dimensions['time'].size  # get index to store data.
-        nc.variables['time'][t] = timestamp  # append timestamp.
+        t = nc.dimensions["time"].size  # get index to store data.
+        nc.variables["time"][t] = timestamp  # append timestamp.
 
         # Append values for each data variable in ``data``.
         for var in data.data_vars:
             # Append variable if it has a `time` dimension.
-            if 'time' in nc[var].dimensions:
+            if "time" in nc[var].dimensions:
                 # TODO: Find a cleaner way to handle different data dimensions.
-                if 'plev' in nc[var].dimensions:
-                    if hasattr(data[var], 'values'):
+                if "plev" in nc[var].dimensions:
+                    if hasattr(data[var], "values"):
                         nc.variables[var][t, :] = data[var].values
                     else:
                         nc.variables[var][t, :] = data[var]
                 else:
-                    if hasattr(data[var], 'values'):
+                    if hasattr(data[var], "values"):
                         nc.variables[var][t] = data[var].values
                     else:
                         nc.variables[var][t] = data[var]
@@ -115,8 +114,9 @@ def return_if_type(variable, variablename, expect, default):
         variable = default
     elif not isinstance(variable, expect):
         raise TypeError(
-            'Argument `{name}` has to be of type `{type}`.'.format(
-                name=variablename, type=expect.__name__)
+            "Argument `{name}` has to be of type `{type}`.".format(
+                name=variablename, type=expect.__name__
+            )
         )
 
     return variable
@@ -153,36 +153,7 @@ def dz_from_z(z):
     return dz
 
 
-def get_squeezable_pgrid(start=1000e2, stop=1, num=200, shift=0.5,
-                         fixpoint=0.):
-    """Create a pressure grid with adjustable distribution in logspace.
-
-    Notes:
-          Wrapper for ``typhon.math.squeezable_logspace``.
-
-    Parameters:
-        start (float): The starting value of the sequence.
-        stop (float): The end value of the sequence.
-        num (int): Number of sample to generate.
-        shift (float): Factor with which the first stepwidth is
-            squeezed in logspace. Has to be between  ``(0, 2)``.
-            Values smaller than one compress the gridpoints,
-            while values greater than 1 strecht the spacing.
-            The default is ``0.5`` (bottom heavy.)
-        fixpoint (float): Relative fixpoint for squeezing the grid.
-            Has to be between ``[0, 1]``. The  default is ``0`` (bottom).
-
-    Returns:
-        ndarray: Pressure grid.
-    """
-    grid = ty.math.squeezable_logspace(
-        start=start, stop=stop, num=num, squeeze=shift, fixpoint=fixpoint
-    )
-
-    return grid
-
-
-def get_quadratic_pgrid(surface_pressure=1000e2, top_pressure=1, num=200):
+def get_quadratic_pgrid(surface_pressure=1000e2, top_pressure=1, num=128):
     r"""Create matching pressure levels and half-levels.
 
     The half-levels range from ``surface_pressure`` to 1 Pa.
@@ -205,10 +176,10 @@ def get_quadratic_pgrid(surface_pressure=1000e2, top_pressure=1, num=200):
     i = np.linspace(0, 1, num)
     lnp = np.log(surface_pressure / top_pressure)
 
-    return np.exp(-lnp/2 * (i**2 + i) + lnp) * top_pressure
+    return np.exp(-lnp / 2 * (i ** 2 + i) + lnp) * top_pressure
 
 
-def get_pressure_grids(surface_pressure=1000e2, top_pressure=1, num=200):
+def get_pressure_grids(surface_pressure=1000e2, top_pressure=1, num=128):
     r"""Create matching pressures at full-levels and half-levels.
 
     The half-levels range from ``surface_pressure`` to 1 Pa.
@@ -227,7 +198,7 @@ def get_pressure_grids(surface_pressure=1000e2, top_pressure=1, num=200):
     phlev = get_quadratic_pgrid(
         surface_pressure=surface_pressure,
         top_pressure=top_pressure,
-        num=num+1,
+        num=num + 1,
     )
     plev = plev_from_phlev(phlev)
 
@@ -251,7 +222,7 @@ def ozonesquash(o3, z, squash):
     """
     i_max_o3 = np.argmax(o3)
 
-    sqz = (z[:i_max_o3] - z[i_max_o3])*squash + z[i_max_o3]
+    sqz = (z[:i_max_o3] - z[i_max_o3]) * squash + z[i_max_o3]
     new_o3 = copy.copy(o3)
     new_o3[:i_max_o3] = np.interp(z[:i_max_o3], sqz, o3[:i_max_o3])
     return new_o3
@@ -277,11 +248,10 @@ def ozone_profile_rcemip(plev, g1=3.6478, g2=0.83209, g3=11.3515):
 
     """
     p = plev / 100
-    return g1 * p**g2 * np.exp(-p / g3) * 1e-6
+    return g1 * p ** g2 * np.exp(-p / g3) * 1e-6
 
 
-def humidity_profile_rcemip(z, q0=18.65, qt=1e-11, zt=15000, zq1=4000,
-                            zq2=7500):
+def humidity_profile_rcemip(z, q0=18.65, qt=1e-11, zt=15000, zq1=4000, zq2=7500):
     r"""Compute the water vapor volumetric mixing ratio as function of height.
 
     .. math::
@@ -304,7 +274,7 @@ def humidity_profile_rcemip(z, q0=18.65, qt=1e-11, zt=15000, zq1=4000,
         Intercomparison Project
 
     """
-    q = q0 * np.exp(-z / zq1) * np.exp(-(z / zq2) ** 2)
+    q = q0 * np.exp(-z / zq1) * np.exp(-((z / zq2) ** 2))
 
     q[z > zt] = qt
 
@@ -334,11 +304,11 @@ def parse_fraction_of_day(time):
         datetime.timedelta(seconds=43200)
     """
     mapping = {
-        's': 'seconds',
-        'm': 'minutes',
-        'h': 'hours',
-        'd': 'days',
-        'w': 'weeks',
+        "s": "seconds",
+        "m": "minutes",
+        "h": "hours",
+        "d": "days",
+        "w": "weeks",
     }
 
     if isinstance(time, timedelta):
@@ -352,7 +322,7 @@ def parse_fraction_of_day(time):
 
 # TODO: Replace with ``typhon.physics.standard_atmosphere`` after next
 #  typhon relase (>0.6.0).
-def standard_atmosphere(z, coordinates='height'):
+def standard_atmosphere(z, coordinates="height"):
     """International Standard Atmosphere (ISA).
 
     The temperature profile is defined between 0-85 km (1089 h-0.004 hPa).
@@ -384,25 +354,23 @@ def standard_atmosphere(z, coordinates='height'):
             plt.show()
     """
     h = np.array([-610, 11000, 20000, 32000, 47000, 51000, 71000, 84852])
-    p = np.array(
-        [108_900, 22_632, 5474.9, 868.02, 110.91, 66.939, 3.9564, 0.3734]
-    )
+    p = np.array([108_900, 22_632, 5474.9, 868.02, 110.91, 66.939, 3.9564, 0.3734])
     temp = np.array([+19.0, -56.5, -56.5, -44.5, -2.5, -2.5, -58.5, -86.28])
 
-    if coordinates == 'height':
+    if coordinates == "height":
         z_ref = h
-    elif coordinates == 'pressure':
+    elif coordinates == "pressure":
         z_ref = np.log(p)
         z = np.log(z)
     else:
         raise ValueError(
-            f'"{coordinates}" coordinate is unsupported. '
-            'Use "height" or "pressure".')
+            f'"{coordinates}" coordinate is unsupported. ' 'Use "height" or "pressure".'
+        )
 
-    return interp1d(z_ref, temp + 273.15, fill_value='extrapolate')(z)
+    return interp1d(z_ref, temp + 273.15, fill_value="extrapolate")(z)
 
 
-def prefix_dict_keys(dictionary, prefix, delimiter='/'):
+def prefix_dict_keys(dictionary, prefix, delimiter="/"):
     """Return a copy of a dictionary with a prefix added to every key.
 
     Parameters:
@@ -418,8 +386,7 @@ def prefix_dict_keys(dictionary, prefix, delimiter='/'):
         {'foo.bar': 42}
 
     """
-    return {delimiter.join((prefix, key)): val
-            for key, val in dictionary.items()}
+    return {delimiter.join((prefix, key)): val for key, val in dictionary.items()}
 
 
 def is_decreasing(a):
@@ -429,9 +396,7 @@ def is_decreasing(a):
 
 def calculate_combined_weights(weights):
     """Calculate combined probabilities for a set of single probabilities."""
-    binary_table = np.array(
-        list(itertools.product([False, True], repeat=len(weights)))
-    )
+    binary_table = np.array(list(itertools.product([False, True], repeat=len(weights))))
 
     pij = np.zeros_like(binary_table, dtype=float)
     for (i, j), is_cloudy in np.ndenumerate(binary_table):
@@ -439,17 +404,19 @@ def calculate_combined_weights(weights):
 
     return binary_table, np.prod(pij, axis=1)
 
-def gaussian(x, m, s) :
-        """
-        Parameters:
-            x (float): Abscissa
-            m (float): Mean of the gaussian
-            s (float): Standard deviation of the gaussian
-
-        Returns (float) the value of a gaussian distribution of mean m and std s at point x. 
-        """ 
-        X = (x-m)**2 / (2*s**2)
-        return np.exp(-X)
+
+def gaussian(x, m, s):
+    """
+    Parameters:
+        x (float): Abscissa
+        m (float): Mean of the gaussian
+        s (float): Standard deviation of the gaussian
+
+    Returns (float) the value of a gaussian distribution of mean m and std s at point x.
+    """
+    X = (x - m) ** 2 / (2 * s ** 2)
+    return np.exp(-X)
+
 
 def dp_from_dz(dz, p, T):
     """
diff --git a/setup.py b/setup.py
index 1dfb7c6d..61f9e591 100644
--- a/setup.py
+++ b/setup.py
@@ -46,6 +46,7 @@
             'pyarts',
         ],
         'docs': [
+            'jupyter-book',
             'sphinx',
             'sphinx_rtd_theme',
         ],
diff --git a/tutorials/clouds.ipynb b/tutorials/clouds.ipynb
deleted file mode 100644
index 709f156a..00000000
--- a/tutorials/clouds.ipynb
+++ /dev/null
@@ -1,181 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 35,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 36,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np\n",
-    "\n",
-    "import konrad\n",
-    "import typhon as ty\n",
-    "\n",
-    "\n",
-    "ty.plots.styles.use()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 37,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Clear-sky background"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 38,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(100000.00000000001, 0.5829979815268262)"
-      ]
-     },
-     "execution_count": 38,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "phlev = konrad.utils.get_quadratic_pgrid(num=256)\n",
-    "atmosphere = konrad.atmosphere.Atmosphere(phlev)\n",
-    "\n",
-    "rrtmg = konrad.radiation.RRTMG()\n",
-    "\n",
-    "\n",
-    "rce = konrad.RCE(\n",
-    "    atmosphere=atmosphere,\n",
-    "    humidity=konrad.humidity.FixedRH(konrad.humidity.HeightConstant(0.8)),\n",
-    "    surface=konrad.surface.FixedTemperature(temperature=300.0),\n",
-    "    max_duration=\"100d\",\n",
-    "    timestep=\"12h\",\n",
-    ")\n",
-    "rce.run()\n",
-    "\n",
-    "fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)\n",
-    "ty.plots.profile_p_log(atmosphere[\"plev\"], atmosphere[\"T\"][-1], ax=ax0)\n",
-    "ax0.set_ylabel(\"$p$ / hPa\")\n",
-    "ax0.set_xlabel(\"$T$ / K\")\n",
-    "\n",
-    "ax1.axvline(0, color=\"k\", linewidth=0.8)\n",
-    "ty.plots.profile_p_log(atmosphere[\"plev\"], rce.radiation[\"net_htngrt\"][-1], ax=ax1)\n",
-    "ax1.set_xlabel(\"Q / $\\sf K\\,day^{-1}$\")\n",
-    "ax1.set_xlim(-4, 0.5)\n",
-    "ax1.set_ylim(bottom=phlev.max())"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Conceptual cloud"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 39,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(100000.00000000001, 0.5829979815268262)"
-      ]
-     },
-     "execution_count": 39,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 2 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "single_cloud = konrad.cloud.ConceptualCloud(\n",
-    "    atmosphere,  # required for consistent coordinates\n",
-    "    cloud_top=200e2,  # in Pa\n",
-    "    depth=100e2,  # in Pa\n",
-    "    phase=\"ice\",  # \"ice\" or \"liquid\"\n",
-    "    water_path=24.0,  # in g/m^3\n",
-    "    cloud_fraction=0.3,  # [0-1]\n",
-    ")\n",
-    "\n",
-    "rrtmg = konrad.radiation.RRTMG()\n",
-    "rrtmg.update_heatingrates(\n",
-    "    atmosphere=atmosphere,\n",
-    "    cloud=single_cloud,\n",
-    ")\n",
-    "\n",
-    "fig, (ax0, ax1) = plt.subplots(ncols=2, sharey=True)\n",
-    "ax0.axvline(0, color=\"k\", linewidth=0.8)\n",
-    "ty.plots.profile_p_log(atmosphere[\"plev\"], rrtmg[\"net_htngrt\"][-1], ax=ax0)\n",
-    "ax0.set_xlabel(\"Q / $\\sf K\\,day^{-1}$\")\n",
-    "ax0.set_xlim(-4, 0.5)\n",
-    "ax0.set_ylabel(\"$p$ / hPa\")\n",
-    "ax0.set_ylim(bottom=phlev.max())\n",
-    "\n",
-    "ax1.axvline(0, color=\"k\", linewidth=0.8)\n",
-    "ty.plots.profile_p_log(atmosphere[\"plev\"], rrtmg[\"net_htngrt\"][-1] - rrtmg[\"net_htngrt_clr\"][-1], ax=ax1)\n",
-    "ax1.set_xlabel(\"$\\sf Q_\\mathrm{cloud}$ / $\\sf K\\,day^{-1}$\")\n",
-    "ax1.set_xlim(-2.25, 2.25)\n",
-    "ax1.set_ylim(bottom=phlev.max())"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.6"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
-}
diff --git a/tutorials/data/tropical-standard.nc b/tutorials/data/tropical-standard.nc
deleted file mode 100644
index c319fabd..00000000
Binary files a/tutorials/data/tropical-standard.nc and /dev/null differ
diff --git a/tutorials/radiation_solver.ipynb b/tutorials/radiation_solver.ipynb
deleted file mode 100644
index 86bff6b6..00000000
--- a/tutorials/radiation_solver.ipynb
+++ /dev/null
@@ -1,171 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Use `konrad` as radiation solver"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline\n",
-    "import matplotlib.pyplot as plt\n",
-    "import typhon as ty\n",
-    "\n",
-    "import konrad\n",
-    "\n",
-    "\n",
-    "konrad.enable_logging()\n",
-    "\n",
-    "# Create an atmosphere component.\n",
-    "plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 201)\n",
-    "atmosphere = konrad.atmosphere.Atmosphere(plev)\n",
-    "\n",
-    "# It is possible to explicitly set different species (e.g. CO2).\n",
-    "atmosphere['CO2'][:] = 348e-6\n",
-    "\n",
-    "# Create a surface component (T and p of the lowest atmosphere level are interpolated).\n",
-    "surface = konrad.surface.SlabOcean.from_atmosphere(atmosphere)\n",
-    "\n",
-    "# Create cloud component (here clear-sky).\n",
-    "cloud = konrad.cloud.ClearSky.from_atmosphere(atmosphere)\n",
-    "\n",
-    "# Setup the RRTMG radiation component (choose zenith angle and solar constant).\n",
-    "rrtmg = konrad.radiation.RRTMG(zenith_angle=47.88)\n",
-    "rrtmg.calc_radiation(atmosphere, surface, cloud)  # Actual RT simulation"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Plot radiative fluxes"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(0.5, 0, 'Radiative flux [$\\\\sf W/m^2$]')"
-      ]
-     },
-     "execution_count": 2,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoUAAAGNCAYAAABnkgskAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nOzdeXxU9b3/8dc3ewJJSCBhU0BBy2qhRCSJ4A5qpdSFql0Uf1ip2mt7ua16vVpx77Xa1q0tIBVbq711q+JSxaoVO1EEra0CFhdA9kXIQkKWme/vjzMTEhKSTDIz58zM+/l45HGYM2fmfBKSmc98vt/v5xhrLSIiIiKS3FLcDkBERERE3KekUERERESUFIqIiIiIkkIRERERQUmhiIiIiABpbgcQL04//XT7l7/8xe0wRERERLrChPsAJYWdMMbMAGaMGDHC7VBEREREokbDx52w1i611l6Wn5/vdigiIiIiUaOkUERERESUFIqIiIiIksJOGWNmGGMWVlZWuh2KiIiISNQoKeyE5hSKiIhIMlBSKCIiIiJqSdMZtaQREZF4UFVVxY4dO2hsbHQ7FImy9PR0iouLycvLi+jzGmttRJ+wp4wxo4H7gFJgL/AgcJO11t/J4/KBXwJfx6mAPgdcZa3d3eKY04D/F3zuocHnnd+VuEpKSuzKlSvD/n5ERESiraqqiu3btzN48GCys7MxJuy+xRInrLXU1dWxefNm+vfv31FiGPYvgaeGj40xBcArgAVmAjcD/wXc1IWH/wk4EbgUmA0cC/z5oGNOB44B/grURiJmERERt+3YsYPBgweTk5OjhDDBGWPIyclh8ODB7NixI6LP7bXh4+8B2cA51toqYJkxJg+Yb4y5M7ivDWNMKTANOMFa+0Zw32bgbWPMqdbaV4KH/tha+1/B+2dG+5sRERGJhcbGRrKzs90OQ2IoOzs74lMFPFUpBM4AXjoo+fsjTqJ4QieP2x5KCAGstSuAz4L3hfYFwg1ILWlERCQeqEKYXKLx/+21pHAksLblDmvtRpyh3pHhPC5oTSeP65Ra0oiIiEgy8FpSWICzuORge4L3RfpxHTLGXGaMWWmMWblz587uPk3X1NXAcwtgT2TnB8gBn1U1sL66we0wRJJL3T7nte2LbW5HIhKW/U0BGvxhDzDGNa8lhZ5irV1orS2x1pYUFRVF92Sv/xHu/R48c190z5OkAtby5KdVPP1ZtduhiCSXN590Xtue+oXbkUgcWLJkCRMnTiQ3N5eCggImTJjAvHnzmu8//PDDufTSS1s9pqamhrS0NNprHVdeXs60adMOeb7Zs2dTUlLSZn/AWs6bdR4nnXRSD76b+OO1pHAP0N44bUHwvkg/zjvqaoJbJS3RYIEmC41+b7VgEkl4ode2Wr22ScfuuOMOLr30UqZPn85TTz3F7373O2bOnMmzzz7bfExZWRk+n6/V495++20yMzP55JNPWq3GbWhoYNWqVZSXl4cdS4oxpBlDapLN0/RaUriWg+YAGmMOB3Jof87gIR8XdKi5ht7lsb6RIiKRodc26dj999/P3Llzuf322znttNOYMWMG8+fPZ926dc3HlJeXs3btWvbsOVDvqaio4IQTTmDo0KGtEsZVq1ZRX19PWVlZt+JJTTGkJFdO6Lmk8EVgujEmt8W+84E64G+dPG6AMeb40A5jTAlwZPA+75twKgwfD5NnuB2JiEjkJFmlRbpv7969DBgwoM3+lqtsy8rKsNZSUVHRvM/n81FaWkppaWmrpNDn85GamsrkyZPDjsVaS4Pf0hQ48GEmNNT85z//mZEjR5KVlcXxxx/P6tWrw35+r/Jan8LfAFcBTxlj/hcnqZsP/LxlmxpjzMfA36y1cwCstRXGmJeB3xljfgQEgP8F3mzRoxBjzFCcptYAGcBoY8x5wD5rrbvJ4xFj4dfvuRqCiEjUaBQk5h7/pJJPqty55N3wvHRmDQ+va8dXvvIV7rvvPoYMGcJZZ51F37592xwzfvx4cnJy8Pl8nHnmmVhreeutt5g3bx75+fn86U9/aj7W5/Mxbtw4cnNz2zxPZwIWLLZNfXvDhg3MmzePW265hezsbG688UamT5/OunXryMrKCvs8XuOpSqG1dg9wCpAKLMW5kskvgBsPOjQteExL5+NUE38L/A5YBZx90DEnAY8Hv3KBWcF//zpi30R3bVwDV02Gf7zmdiQiIpGjSqF00QMPPEDv3r2ZPXs2RUVFjBkzhp/85CdUVR1oXZyWlsakSZOaK4Jr166lsrKSSZMmUVpayqpVq2hocLpMVFRUdHvo+FB27drFI488wre+9S3OOeccnnvuObZu3cqSJUsieh63eK1SiLV2NXByJ8cMa2ffXuCS4NehHrcEWNKjAKNl1TJY+zb8/WkYn1yrnUQkCahSGHPhVurcdswxx7BmzRpefvllXnrpJV599VVuueUW/vjHP/Luu+/Su3dvwBlCvueee/D7/fh8PsaMGUNeXh7jx48H4N1336V///5s3bq1W4tMOlJcXNwq0Rw6dCgTJ05kxYoVfO9734voudzgqUqhiIgkGlUKpesyMzOZMWMG999/P6tXr+bBBx9k3bp1LF68uPmYsrIy9u3bx/vvv9+qGpiens7EiRPx+XzNlcTOksK0tDT8fn+79/n9flLTWtfOiouL2xxXXFzM1q1bw/o+vUpJoefo07SIJCBVCqUb5syZQ2FhIWvXHmgkUlZWhjGmOfkrLS1tvi+02MTn8zF48GCGDh3a4fMXFRWxbVv7jdV3bNtGv6LWSWDLljct9w0cODCcb8uzlBR6hebdiEgi0mubdFF7CdfOnTuprKykf//+zfsKCgoYOXIkL7zwAmvXrm2TFFZUVODz+bo0n3DKlCls27aNFStWtNq/adMm/vneu0wua11p3LFjR6sVzhs3buTdd99l0qRJXf4+vcxzcwpFRCQRqVIoHRs3bhwzZ85k2rRpFBcXs2HDBu666y5ycnK4+OKLWx1bVlbGb3/7WwoLCzn66KOb95eWlrJlyxa2bt3K7NmzOz3n6aefTllZGWeddRY33ngjo0aNYsOGDdx6660cNmQos7757VbH9+vXj29/+9vceuutzauPi4uLu3SueKBKoddoiEVEEokqhdJFP/nJT1i/fj1XXXUV06ZN44YbbmDMmDGsWLGCI444otWx5eXlWGvb9CAcOHAgQ4cOxVrbpUphSkoKL7zwAhdccAE//elPmT59Otdeey3lxx/P0y//ldzc3q2OHzp0KHfddRfz58/nggsuIDc3l5deeikh2tGAKoXeoRdOEUlk+sArnbjyyiu58soru3TsJZdcwiWXtN9sZP369WGdNz8/n3vvvZd777231X5/wLb71nzOOedwzjnnhHWOeKFKoVdkB5trZvVyNw4RkUjSB16JUw2B1lc0SQaqFHrFlPOgvhbKD+63LSKSAFQplDgSsJa9DX7SjKEoO3nqZ0oKvSIrB0aXQV7by/qIiMQvVQol/oQ+w7T8KJMoVy3pSPKkv15X8SxcPh7+dKfbkYiIRIEqhSJep6TQK3Ztbr0VEUkEoTmFGj4W8TwlhZ0wxswwxiysrKx0OxQRkfijhSYicUNJYSestUuttZfl58fqwuL6NC0iCUiVQhHPU1LoFfo0LSKJSK9tInFDSaGIiESfKoUinqek0Gv0wikiCUWVQum6JUuWMHHiRHJzcykoKGDChAnMmzev+f7DDz+cSy+9tNVjampqSEtLY8SIEW2er7y8nGnTpnV4PmMMxhhSUlLIz8/nmGOOYd5//pCt6z8jJy25fn+VFHqFhlhEJKHpA6907I477uDSSy9l+vTpPPXUU/zud79j5syZPPvss83HlJWV4fP5Wj3u7bffJjMzk08++YQdO3Y0729oaGDVqlWUl5d3eu5XX30Vn8/Hk08+yZw5c1i2bBlTjp3A8ldejtw3GAfUvNorho2FtHQYPt7tSBKT3o9E3KEPvNJF999/P3PnzuX2229v3jdjxgxuvPHG5tvl5eU8/vjj7Nmzh4KCAgAqKio44YQTWL16NT6fj69//esArFq1ivr6esrKyjo997HHHkvv3r0BOPXUU5k7dy6nf/UsLvzmN9mwfj2xW2zqLlUKvWLs8fDnKjjre25Hktj0/iTiDk2NkU7s3buXAQMGtNlvWnywKCsrw1pLRUVF8z6fz0dpaSmlpaWtqog+n4/U1FQmT54cdixpGZnc/LOfU7l3L4899ljz/traWq666ioGDBhAVlYWxx57LC+/fKCa+NBDD9GrVy8aGxub9w0aNIi+fftig38DgUCAPn36sGjRIgDmz59Pv379eO+995g8eTI5OTlMmDCB5cuXhx13Tykp9Iqq3bDwR/DZv9yOREQkclQplC76yle+wn333cfDDz/M7t272z1m/Pjx5OTkNCd/1lreeuutQyaF48aNIzc3t1vxHDVyFIMGH8Zbb73VvO+73/0uDz30EP/zP//D008/zeGHH85Xv/pV3nzzTQCmTJlCbW0t7777LgDr1q1jx44dVFdXs3r1agDef/99KisrmTJlSvPz1tbWcvHFFzN37lyefPJJMjMzOeecc6itre1W7N2l4WOveGspPPsABAJw1a/cjkZEJLJUKYy5xz+p5JOqxkPen5VquHCEMyz62MeV7Pcf+v9oeF46s4bn87ct+6jYXnfI41INfHVoLqMLMsOO94EHHuDrX/86s2fPxhjDqFGjOPfcc/nRj35EXl4eAGlpaUyaNKk5+Vu7di2VlZVMmjSJ/Px8rrnmGhoaGsjIyKCiooKzzz477DhaGjh4MNu3bwdgzZo1PPbYYzz00ENcfPHFAEyfPp1jjjmGW265hZdeeokRI0YwcOBAli9fznHHHcfy5cv58pe/TEZGBsuXL2fMmDEsX76coqIiRo4c2Xyeuro6fvnLX3LyySc75x04kAkTJvDGG29w+umn9+h7CIcqhV7RFPzDbWpwNw4RkYhSpTCRRPN/85hjjmHNmjU8++yzXHHFFVhrueWWWygpKaGmpqb5uLKyMlasWIHf78fn8zFmzBjy8vIYP96Zk//uu+/y2WefsXXr1i4tMumIbfFh5p133sFay6xZs5r3paSkMGvWrOZKITjVwtDQ7xtvvMHUqVOZOnVqq33HH398q/NkZGRw4oknNt8ePXo0AJs2bepR/OFSpbATxpgZwIz2lrpH+ETRfX4RETepUhhzs4Z3fXHED4/p26Xjpg7qxdRBvbobUqcyMzOZMWMGM2bMAGDx4sVceumlLF68mB/84AeAkxTefvvtvP/++1RUVDQvJElPT2fixIn4fD769+8P0OOkcNuWLYwbPQqArVu30rt3b3Jyclod079/f2pra6mvryczM5MpU6Zw4403Yq1l+fLl/OxnPyMjI4MrrrgCgDfffJNrrrmm1XPk5uaSknKgTpeRkQHA/v37exR/uFQp7ETML3OnF04RSST6wCs9MGfOHAoLC1m7dm3zvrKyMowx+Hy+5kUmIaF5hT6fj8GDBzN06NBun3vd2jVs2byp+fkHDhxITU1Nm3l+27dvJycnh8xMZ8h8ypQpfPHFFyxbtozPPvuMKVOmUF5ezubNm3n55ZfZvn17q/mEXqKk0DNCL5xKCkUkEem1TTrWssdgyM6dO6msrGyu/AEUFBQwcuRIXnjhBdauXdsmKayoqMDn83WpFc2h1NfXc/2P5pHfpw8XXHAB4LStMcbwxBNPNB9nreWJJ55oNRw8btw4+vTpw2233cbIkSMpKiqioKCAsWPHctttt9G7d28mTJjQ7diiScPHXqFP0yKSiPTaJl00btw4Zs6cybRp0yguLmbDhg3cdddd5OTkNC/sCCkrK+O3v/0thYWFHH300c37S0tL2bJlC1u3bmX27NldPvc777xDdnY2tbW1fPDBByxYsID1Gzaw+JE/NvcoHDVqFBdeeCHf//73qa6uZvjw4SxatIi1a9fy61//uvm5UlJSKC8v5/nnn2fu3LnN+6dMmcIDDzzAaaedRmpqajd/StGlSqHXaPhYRBKRXtukEz/5yU9Yv349V111FdOmTeOGG25gzJgxrFixgiOOOKLVseXl5Vhr2/QgHDhwIEOHDsVaG1al8OSTT6a0tJSZM2eyaNEiTj31VN5Z9R7nzvhqq+MWLVrExRdfzM0338zMmTPZsGEDzz33XJuFI6Hh4alTp7bZd/CxXmKs/lC7pKSkxK5cuTJ6J3jl93DnRXD6HJj3YPTOk6T8AcvP3t9NioGrx/dzOxyR5PHaY3DHN+HEC+C6xzo/XrplzZo1jBo1yu0wEkpjwJICpKZ4t9rdyf972IGrUugVk86EMy6Fsy53OxIRkchTAULiSMBadu9vYk+D3+1QYkpzCjsRs5Y0eX3hP37lXP9YRCRheLfKInIoAessjQok2WcZVQo7EbOWNJ/8A87Ohz/fF93ziIi4IsneXUXikJJCr/j0n1BfB/9+x+1IREQiR6uPReKGkkKv0bwbEUlEem0T8TwlhV4R+jStF04RSSSqFIrEDSWFnqEXThFJYPrAK+J5Sgo7YYyZYYxZWFlZGZsT6oVTRBKJKoUicUNJYSditvrY6NrHIpLA9IFX4kiqgVRjyPBw4+poUJ9Cr9CnaRFJSHptk/hjjKEoy5vXJ44mVQq9onCgsy0Y4G4cIiJRoUqhdGz+/Pn069f2MqSLFy/GGMOmTZta7b/mmmswxvDII4+02r9s2TKMMfh8vnbPs379eowxPPfcc23u++CDDzDG8Nprr1HdGKDOn1y/t0oKveLLJ8L978Alt7kdiYhI5GgURHqorKwMoE2S5/P5yMnJaXd/ZmYmEydO7PY5Axb2NQWoaQx0+znikZLCTsRsoYm/CdZ/AFW7o3seERE3aE6hdNPIkSMpLCxslfw1NjaycuVKLrroonaTwokTJ5KZmRnrUOOeksJOxGyhybvL4K5L4JGbonseEZFYUqVQesgYQ2lpaavk77333gPgiiuu4IMPPqC6uhqAQCDA22+/TXl5eUTOvXGDM9T86KOP8p3vfIfc3FyKi4u56abEfK/WQhOvqHV+odkXo9Y3SUY1ChGXqVIYe9d/FVa84M65J50Jtz4fsacrKytj/vz51NXVkZ2dTUVFBRMnTmTs2LHk5+fz9ttvc+qpp/Lhhx9SWVkZsaQw5Mc//jFnnXUWTzzxBG+88QY33XQT/fr148orr4zoedymSqFX6NN0TOinLBJr+quTnisvL6exsZF33nkHcIaIS0tLMcYwefLk5ipiaBuahxgpY8aMYcGCBUyfPp3bbruNOXPmcPvttxMIJNacQ1UKO2GMmQHMGDFiRGxOqE/TIpKI9NoWexGs1Lnt2GOPJS0tDZ/Px9SpU/H5fJx//vkATJ48mb///e+AkxQeddRRFBUVRfT8Z599dqvb55xzDg8++CCbNm1iyJAhET2Xm1Qp7ETMm1frhVNEEoka80sE5OTkMH78eHw+H5s2bWLTpk3N1cDS0lLeeustrLX4fL5Oh47T0px6mN/vb3NfaF9qWuuaWXFxcbu3t27d2r1vyKOUFHqGhlhEJAFpaoxESHl5ORUVFfh8PoYNG8aAAU5f30mTJlFdXc3rr7/Oxx9/3OnQcd++fUlJSWHbtm1t7gslef2DSV/ot3fHjh2tjgvdHjhwYE++Jc9RUug5+jQtIglIoyDSQ2VlZezatYuHH36Y0tLS5v15eXmMGTOGu+66C6DTSmF2djYTJ07kmWeeaXPfM888w4ABA/jS0UeRm55C7zQnTXr66adbHffUU08xcOBADjvssJ5+W56iOYWdiNmcQg0fi0giUqVQwtDQ0MATTzzRZv8JJ5zQXAF88cUXueeee1rdX1payqJFiygoKGDUqFGdnmf+/PmcddZZXHDBBVx44YWkp6fz3HPPsWDBAn71q1+RkpJCjrFkpDq/vx9++CFz587l3HPP5Y033mDx4sXcc889pKQkVm0tLpNCY8xo4D6gFNgLPAjcZK1tO0HgwGMygNuAyUAJkGWt7fTVylq7FFhaUlLy3UjEfkijS2HEV2DKeVE9jYiIK/SBV7qgurqaWbNmtdn/2muvceKJJzJkyBA2btzYqlIITlK4cOHC5hXJnTnzzDN5/vnnue222/jmN7+J3+9n9OjRPPzww3znO98hYC076/xUNTiri++8806ee+45zj33XLKysrjhhhv4/ve/H5lv2kPiLik0xhQArwCrgZnAcOBunKHw6zt4aA5wKbAC8AEnRzfSMPUdBL9a5XYUIiIRpkqhdM38+fOZP39+h8ds2LCh3f2zZ89m9uzZYZ3vjDPO4Iwzzmj3voCFAJbG4IeZ/Px8HnvssbCePx7FY93ze0A2cI61dpm19jfATcA8Y0zeoR5krd0LFFprpwNPH+q4g8XsMnd7dsAPy+H1/4vueUREXKFKoYjXxWNSeAbwkrW2qsW+P+Ikiid09EBrwx+/iFlLmtU+5+u1xP8kIiJJRHMKReJG3A0fAyOBV1vusNZuNMbUBu9b6kpUEaNP0yKSgDSnUOLQ0KHD6EY9KW7FY6WwAGdxycH2BO+LGGPMZcaYlcaYlTt37ozkU7d3sug+v4iIG/TaJhI34jEpjBlr7UJrbYm1tiTSl8zp4KSxOY+ISCzptU3E8+IxKdwDtDfBryB4X3xSn0IRSUSqFEocStZ34nhMCtfizB1sZow5HKflzFpXIooEE/yvsAF34xARiQZ94JU4kmqcZkqpSfaZJh6TwheB6caY3Bb7zgfqgL+5E1IEpKQ624CSQhFJJEn2rioJIcUY+mWl0Scz1e1QYioek8LfAPXAU8aYU40xlwHzgZ+3bFNjjPnYGLO45QONMWcYY84Dxgdvnxf8Ghq78A+hV7DFYlaOu3GIiESFKoUSXxoClqZAcv3exl1SaK3dA5wCpOK0n7kJ+AVw40GHpgWPaenXwOPAnODtx4NfJ0Ur3i4bVQr/uQjm/NTtSEREIkdzCqWL5s+fT79+/drsX7x4McYYNm3a1Gr/NddcgzGGRx55pNX+ZcuWYYzB5/Md8lzDhg3DGIMxhszMTAYNGsSZZ57J73//ewKBAE0BS2WDn6rG5Bq9i7ukEMBau9pae7K1NttaO9Bae8PB1z221g6z1s5uZ59p52tJLONvV0oKjCmHwkFuRyIiEnmaUyjdVFZWBtAmyfP5fOTk5LS7PzMzk4kTJ3b4vN/85jepqKjg1Vdf5d5772Xw4MHMmTOHM888k4bGRiD5fm3jMilMSJvXwaWj4ZffdTsSEZHIUaVQemjkyJEUFha2Sv4aGxtZuXIlF110UbtJ4cSJE8nMzOzweQcOHMjkyZMpLy/nvPPOY9GiRTz//PMsW7aMn95+e1S+F69TUugVu7c6252bOj5ORCQeJVvJRSLGGENpaWmr5O+9994D4IorruCDDz6guroagEAgwNtvv015eXm3znXaaacxa9YsFi74Tav9r776KscddxxZWVn079+fK664gpqamub7hw4dyu0tEskFCxZgjOHee+9t3nf33XczePDgVt/XPffcw3XXXUdRURHFxcVceeWV1NfXdyv2SFBS6BUpwf+KgL/j40RE4ooqhdJzZWVl/OMf/6Curg6AiooKJk6cyNixY8nPz+ftt98G4MMPP6SysrLbSSE4ieH27dv5fMN6TPA5Tz/9dPr168eTTz7JTTfdxKOPPsp5553X/JgpU6awfPny5ttvvPEGWVlZbfZNmTKl1bnuvvtutmzZwiOPPMKPf/xjFixYwD333NPt2HsqHq99nJhCLWnUp1BEEpEqhbF3/VdhxQuHvj+3AO58zfn31SdBdQfXf5h0Jtz6PDz0P/DHOw79/5meCT9aAidd0O2w21NeXk5jYyPvvPMOU6dOxefzUVpaijGGyZMn4/P5OPXUU5uriaF5iN1x2GGHAbBzxw6OHHYEt9xyC0OHDuXZZ58lNdV5ry4sLOT888+noqKC0tJSpkyZwtVXX00gECAlJYXly5czZ84cnnjiCQCstbz55pvcfPPNrc41bNgwlixZAsD06dP5+9//zlNPPcXVV1/d7fh7QpVCrwg1r1afQhFJJJpT6GHmEP/u6mNi59hjjyUtLa056QslhUBzUhjaf9RRR9GTS9PagxLeFStWcPbZZzcnhADnnnsuaWlpvPnmmwBMnTqVqqoq3n//fdavX8+mTZu4+uqr2bVrF+vWrePDDz/kiy++aFMpnDZtWqvbo0ePbrPKOpZUKfQKDR+LSEJTpTDmbn2+68c+ubtrx11yq/MVYzk5OYwfPx6fz8emTZvYtGlTczWwtLSUu+++G2stPp+P448/vkfn2rx5MwBFxcUAbN26lf79+7c6JjU1lb59+/LFF18AzmKYfv36sXz5cgoKChg7dixDhgxh/PjxLF++nPr6evr06cPYsWNbPU+fPn1a3c7IyGD//v09ir8nlBR6hYaPRSQRqVIoEVJeXs4f/vAHfD4fw4YNY8CAAQBMmjSJ6upqXn/9dT7++OMeD72+/PLLDBgwgBFHHEFmagoDBw5kx44drY7x+/3s3r2bwsJCwFk0cvzxx7N8+XL69OnD1KlTgQNzDffv3095eTkpKd4eoPV2dMkkRcPHIpLANKdQeqisrIxdu3bx8MMPNw8dA+Tl5TFmzBjuuusugB4tMlm2bBlPPPEEl19+OYVZafRKT+G4447j6aefxu8/MJL31FNP0dTU1KoqOXXqVJYvX84bb7zRnBSG9i1fvrzN0LEXqVLoFf2HOZN+h493OxIRkchRpVDC0NDQ0Lw4o6UTTjihebj4xRdfbLNCt7S0lEWLFlFQUMCoUaO6dK6tW7fy1ltv4ff72bZtGy+99BJLlizhtNNO45prr2XX/iayUg3XX389EyZM4Otf/zqXX345mzZt4pprrmH69OmtktMpU6Ywb948tm/f3pwUHn/88XzyySfN93udkkKv6N0HHtvirNwSEUk0qhRKF1RXVzNr1qw2+1977TVOPPFEhgwZwsaNG1slY+AkhQsXLmxekdwVjz76KI8++ijp6en07duX8ePHs3jxYr71rW/RZKGxyakMjhkzhhdffJHrrruOc845h7y8PC688ELuvPPOVs83YYRk8nwAACAASURBVMIEevfuzcCBA5uHtouKihg5ciTr16+npKSkOz+SmDIHr7KR1owxM4AZI0aM+O66deuidyJrYckNcNREOP7s6J0nSTUFLHe9v5tUAz8e3/bamiISJe+9CtecAl8+CX72qtvRJKw1a9Z0uUImnWvwB9hd7yc9xdAvy7v1s07+38Mu02tOYSestUuttZfl5+dH90TbPoPHboOHr4/ueUREXKEChIjXKSn0ilArmsYGd+MQEYkkzSmUOJZsv71KCr3CqE+hiCQwTVUS8TwlhV6hPoUikohUKRSJG0oKvUJ9CkUkkalSGHVaOBo58fCTjMb/t5JCr9DwsYgkolClUAlLVKWnp1NXV+d2GAkjJTib0Mt17rq6OtLT0yP6nEoKvULDxyKSkLz8tpo4iouL2bx5M7W1taoYRkBaCvTJSCUvI9XtUNqw1lJbW8vmzZspDl6fOVK823wn2aRnOFujPF1EEpESlWjKy8sDYMuWLTQ2NrocTWLwBywphi43w46l9PR0+vfv3/z/HilKCr0iry98+0boP9TtSEREIseDb6iJKi8vL+JJQrLaVtvEko/2MrYwk7OG5rodTswoKfSSb12vSqGIJCYNaUocqWl0pnLVNSXXlC5lIJ0wxswwxiysrKyM7omshStL4EcnRPc8IiKxpEqhxCEbnO5gkmxOrJLCTsTsMnf+Jvj0fVhdEd3ziIi4QZVCiSOB4K9rSnLlhIcePjbG9KQ3igWmWWt19fOuSg3+VwT8zounPl2LSCLQa5nEodBnmGT79e1oTqEBlgOfhvmcWcA3uh1RsjLGSQz9TdDUeGA1sohIQlClUOJHc6XQ3TBirrOFJgustY+G84TGmH7A+d0PKYmFkkJ/k5JCEUkQSVZqkYQQCH6ISUmyUmFHSfBLwJZuPGd98LG7uhVRMksLdib3q8eUiCQYzSmUOBLQ8HFr1tozuvOE1tpqoFuPTXqpwaSwSUmhiCSIZHtXlYRQnJ1GRophcK/k6tyXXN+t16UpKYwW1ShEXKZKocSRATlp/PCYQg0fS2sx61MIUHQ4pGdCdu/onytJJdeft4gHJNmbqiSG6kY/z2+oYXttk9uhxFRYlUJjzHDgP4HjgALaJpXWWjs8QrF5grV2KbC0pKTku1E/2S3PQ80eyEmeS+qISJJQpVDiyLq9DXy4p57sNEP/nOQp1HS5UmiMGQe8C1wKZABHAvtwWtAMA/zAxsiHmET27oDP/ul2FCIikaeKocSRpiT9DBPO8PHNQAPwZeCU4L4fWGsHAXOBPsCVkQ0vydwzF279Bmz9zO1IREQiQxVCiUPWqiVNZ44HFlprP+LAvH0DYK1dBLwI/DSy4SWZ+lpnW7PH3ThERCItyd5cJb6FKoWpSfZrG05SmAt8Evx3Q3Dbq8X9f8dJHKW70oINq5saOj5ORCReqFIoccgfbFSYlmQXPw4nKdwODIDmXoT7gKNb3F8ApEYuNG+I6erjjCxn27A/+ucSEYklVQoljqhS2Ll/ACUtbv8N+IExZqox5kTg+8D7EYzNE6y1S621l+Xn50f/ZJnZzra+LvrnEhGJCVUKJf74gxXu1CT7MBNOUvgo0M8YE8xcuAHIB14D/oqz0OS6yIaXZDKCP9oGJYUikmiS681V4lto1kNGkpUKu9yn0Fr7f8D/tbj9njFmDHA2TjuaF621n0Y+xCSiSqGIJBrNKZQ49JV+WaQYODo/w+1QYqrTpNAYkwbMBEYAO4FnrbW7AKy1nwP3RjXCZNJcKdScQhFJMEk2DCfxrW9WKlMH9lKlsCVjTAHwOjAWp/ZvgZ8ZY6ZZa1dFPzz3GWNmADNGjBgR/ZNNORc++QeMmxL9c4mIxIIqhRKH3thay4oddfy/kX3omxXWxd/iWmdzCq8HxgHPA/8B3A/0BhZGOS7PiOlCk0lnwq9WwWFHd36siEg8CCWFqhRKHNlW24Tfwt76gNuhxFRnSeEM4C/W2q9Zax+w1v4AuBYYb4w5LPrhJZl/r4IrS2B1hduRiIhEmJJCiR/+UEuacJbjJoDOvt3DgRcO2rcU5697aFQiSmarXoZ1q6DiGbcjERGJEA0fS/wJtaRJS7IKd2dJYSbwxUH79rS4L+G50rxaq49FJNEk2ZurxLcGv65oEq6k+Pin5tUiIj2ghSYShxqCl7nL1OrjNv7LGHNBi9vpOAnhbcaYXQcda621MyMWXbJR82oRSTSB4ET9lIS7CqoksMZgUpieZJXCriSFE4JfB5vczr6E+0gY05Y0WTnOVpVCEUkU/iZnm5o8bT0k/oWGjzOSLCnscPjYWpsS5penPwoaY0YYYxYYY/5pjPEbY17v7DExHT4OVQob1bxaRBJEQEmhxJ+ctBRy01NIT7LVx8n2VzoGOBN4C2cY3FtCcwr317obh4hIpIQqhRo+ljgy+0t9wIBJsgVSSZYDs9Rae7i1dhbwYVceENPVxwUDnK1ePEUkUWj4WOLQx1UN7Kn3ux1GzIX1V2qMGQLMBY4C+tK2G6m11p4Sodgizlobdmtya+1SYGlJScl3oxBSa8PGwDWPwPDxUT+ViEhMBIJvrEoKJU7srffzwsYaBmSnMXtkH7fDiaku/5UaY84AngYygBpgd7SCSmpjyiE9w+0oREQiQ5VCiTO1Tcl1abuWwvkrvQPYBXzdWrsySvF4ijHmMuAygCFDhkT/hP4muGIC5PWFJR9H/3wiItGmpFDiTPPK4yTrUQjhzSkcCfwyWRJCAGvtQmttibW2pKioKAZnNFCzF7Z+qoavIpIYtNBE4kxdMCnMTlNS2JGdQEO0AhEgNRUyc5yEcP8+t6MREek5VQolzuz3O8PH2anJthY3vKTw98C50QpEgnJynW1ttbtxiIhEQmihiSqFEifqmpxKYVYSVgoP+dEtuNK4pSXAScaYZ4B7gM+ANuu1rbUbIxlg0snOhT3boa4aGOh2NCIiPdNY72wzstyNQ6SL6ppClUIlhS2tp+1l60I/obM6eJxnPw4aY3JwmlcDDAbyjDHnBW+/YK11v2u0KoUikkgagldoUlIocaI+EKoUJt/wcUdJ4c0k3rWMi4HHD9oXun0ETiLsruxgUlinpFBEEkDoWu5KCiVOjOqTSVVDgOF5ydce7pBJobV2fgzjiAlr7XraNtz2FlUKoyrRPuWIeF7oWu7pSgolPhyRl8ERSZgQQvJd5s77xk2FrF4weITbkSQUb38SEElgoeHj0LXdRTzulU01LPloL4EkbA13yKTQGDPIGBP2RzvjGGSMSe9ZaEnqG1fDU3tgyCi3IxER6TnNKZQ4s3pPPdtqm6htUlLY0ufAOd14zsLgY6d0K6Jkt/ljuGeu08BaRCTeaU6hxJGAtc3JYE4StqTpKCk0dH8KVvL9JCPlb/8HLz0Er/ze7UhERHpOcwoljrRMCFNM8qUync0pfMQY4w/nC9iB5vN3X3qms91X6W4cIiKRoDmFEkdqGp0ehb2SsB0NdNyS5uEePveWHj4+OakljYgkEg0fSxzZF0oK05UUtmKtvSSWgUiQWtKISCLRQhOJI/uakrtSmJzftZepUigiiURzCiWOhCqFvZO0Upic37WXqVIoIolEcwoljoTWlhRmevaKvVHV0ZxCcYMqhSKSSDSnUOLIxKJs+mWlcURucrZaVqXQa3ILnG1Tg7txiIhEguYUShypaQyQlgKpKcnXjgZUKeyUMWYGMGPEiBhddm7AEXDRzTBsTGzOJyISTZpTKHHkmfXVbKtt4qqxheQk4bzC5PuOw2StXWqtvSw/Pz82JzQGzr8GjjsrNucTEYkmzSmUOLKn3g8cmFuYbLqVFBpjMo0xg40xGZEOSIB5U2DuOAgE3I4k4airukiMaU6hxImmgKXeb0kxkJWanFlhWEmhMeYrxphXgWpgI3B8cH+xMeavxphToxBj8vl8LWz6N9RWuR1JwkjOP28Rl/mbIOCHlBRI1Wwl8baWPQpNkpYKu5wUGmPGA8uB4cDvWt5nrd0BZAMXRzS6ZKW2NCKSCBpazCdM0jdZiR/JfjUTCK9SeDPOpevGANfStvjyV2BShOJKbmpLIyKJQPMJJY4cuO5x8n6ACScpnAIsstbW0P7UrI3AoIhElexUKRSRRKD5hBJHQsPHyXo1EwgvKcwCKju4P6+HsUiIKoUikgga1aNQ4kdNkl/iDsJLCj8BJnZw/8nA6p6FI8CBpFCVQhGJZ82NqzV8LN53WK90CjNTGZGfvI1VwkkKHwW+c9AKYwtgjPkv4HTg9xGMLXnlqFIYNepJIxI7Gj6WOHJEXgaXjS5gYE5yXuIOwruiyV3AacBLwFqct9dfGGOKgAHAMuBXEY/QZTG/ognAYV9ytvn9YnfORJe884ZF3KNL3Ekc8W2rZVttE2cfkauWNJ2x1jbgJIU/AuqA/cDRwC7gauAsa23CdVuO+RVNAC64FhavhUlnxu6cIiKR1qBL3En8eGdHHf+ubKDOn7xDSl2qFBpjMoHjgK3W2l8Av4hqVMmuvg5WvADZvaHfYLejERHpnka1pJH40BSw1PktKUB2kl7NBLpeKfTj9CE8I4qxSMjfn4YF8+CJu92ORESk+zSnUOJEy5XHyTp0DF1MCq21TcA2NDMrNkK/kHu2uxuHiEhPaE6hxAm1o3GE890/DnzDGJPcP7FYyAm2fKztqC2kiIjHaU6hxIlqJYVAeKuPHwROApYZY34JrANqDz7IWrsxQrElr17BRS37qtyNIwEl7/RhERdoTqHECVUKHeEkhR/gvKca4MQOjkvtSUDCgaRQlcKI0bwHERdoTqHEiVBSmKuksMtuJgkLLa70KVSlUEQSgeYUSpxosk560yczuetaXU4KrbXzoxiHZ1lrlwJLS0pKvhuzk2pOoYgkgkbNKZT4MLl/NsVZaRzdJ3kvcQfhLTSRWGkePq4Gm3TFWRFJFA2aUyjxIWBhSG46qUncjgbCqBQaY6Z25Thr7RvdD0cASEuHc+dBwH+gPY2ISLzRnEKJA9Za/vDvSuoDlh+OK0zqPoXhzCl8na7NKUzuAflImavG1SIS5zSnUOJAQ8BS1RggydeYAOElhZcc4vHDgdnAemBBz0MSAH5/E/j+DD9/E7J7uR1NwtBgvEgMaU6hxIHqBl3NJCSchSYPH+o+Y8zPgHcjEpHHuLL6GJxrH3/yD1j/Lxg1ObbnTkDJ/Wcu4hLNKZQ4UBVsR5OfoYHOiBRLrbV7cJpbXx2J5/MSa+1Sa+1l+fn5sT1xaAWy2tJERMtPf1aLd0RiQ3MKJQ5UNvgByNP4cURXH+8Bjozg8yW35l6Fe92NI4GE0kKlhCIxojmFEgeqgsPHeaoURiYpNMZkAd8BtkXi+QTILXS21V+4G0cCUVIoEmOaUyhx4EBSqEphOC1pfnuIuwqBUqAI+HEkghIgr6+zrdrtbhwJxBjABls/apKhSPSpUihxoKoxOHyspDCs1cezD7H/C+DfwH9aax/tcUQe49pCEyWFUaNKoUiMNNY72/RMd+MQ6cCgnHSqGgIMyA4nJUpM4aw+TsoU2pXL3IGSwihQcVAkxhobnG16cl86TLztpMG9OHFQTtK3owFd5s67BgbX7KRq4mukhP7etfhYJEZUKRSPC1jL0vXV/OuLerdD8YRw5hSmApnW2toW+/oAc3DmFf7RWvuvyIeYpMZNhZuegZHqURgpBmdSoUWTCkViQkmheNzW2iY+3FPP3gY/x/TV3NdwKoULgBWhG8aYdOBN4GfAfwMrjDHjIxue+4wxM4wxCysrK2N9Yug7SC1pIkiVQpEYU1IoHlfV4momEl5SeDzwbIvb5wGjgSuBMmA7cG3kQvMG15pXN9TDvClw/ZmxPW8CU0sakRhrCs4pTNOcQvGmKjWubiWcpTYDgc9a3P4q8KG19tcAxpiFwNwIxpbcUlOddg7bPoNAAFL0C9tTSgpFYigQgKZG599aaCIeVanG1a2Ek2kYoOVP7UTgtRa3twLFEYhJAFLTnKuaBAJQoyHkSNDwsUgMNbVYeaxVneJRzZe4U49CILyk8DNgOoAxphynctgyKRwExHji3QHGmBHGmAXGmH8aY/zGmNfbOcYYY64zxnxujKkzxrzR2TxI1+YUwoG2NNVqSxNJyglFYqBRQ8fifXvqnUphQaYqhRBeUvgQMNMY8wHwHLADeKnF/ccBayMYW7jGAGcCH+E0027PtcANwP8CM4Aa4BVjzIBDPalrcwrhwKXuqnSpu0hQrUIkloIfv1QlFI8KWMveeqdSqKTQEU5SeA9wI1APvAecHWpPY4zpC0wGXoh4hF231Fp7uLV2FvDhwXcGr898LXCHtfZ+a+0rwCycV67vxzbULsovcrZ7d7gbR4IINSa1Gj8WiQHN1xBva/BbAkB+RgrpKfrwAuFd0cQCtwS/Dr5vNy7PJ7TWBjo5pAzIA/7U4jH7jDFLgTOA69t7kGuXuQOnJQ3A7s2xP3cC0kITkRjSJF7xuKy0FM4a2ps+WmTSrMczK40x/YwxR0UimCgbCfiBdQftXxO8r12uDh/3G+xsd2+J/bkTkJJCkRhSUige5w9YirLSGNxL1zwO6XJSaIy5KNh2puW+O3D6E641xvzdGJMb6QAjqACosdb6D9q/B8gxxnhvNvSxZ0LR4TBKVzWJBL1HicSSPoaJt721o46HPtrLusoGt0PxjHAqhXNpMdxsjCkBrgGWA4uAScC8iEbnMmPMZcaYlcaYlTt37ox9AKOOgz9shElqYB0JeosSiSF9ChOP27LP6aOp39ADwkkKRwD/bHF7FvAFMM1a+z3gQeAbEYwt0vYAvYPXcG6pAKi11rb5qGCtXWitLbHWlhQVFcUkyIMCgJ9+G/50Z+zPnYD0HiUSQ/qDE49TO5q2wkkK82ndh/AU4JUWydRKYEikAouCtTjNtw9eMTISd1vpHFr1Hnj1D/DHO9yOJKFYfS4UiT4TenvR35t4j9rRtC+cpHAbcBSAMaYIGI8zdBzSG2chh1f5gCqcCicAxpgcnH6FL7oVVId694G0dOeKJvtr3Y4m7hl1KhSJnVClMNBZYwiR2KtsCBAActPVjqalcJbcvApcaYz5AjgJ5+Pf8y3u/xLgWu+UYIIXmnw3GMgzxpwXvP2CtbbWGPNT4AZjzB6c6uA8nMT4vpgH3BUpKc5Ck62fwo6NMOSQi6SlC5rfo1S4EIk+DR+Lh+1RlbBd4SSFP8Hp9Rea4HartXY9gDEmDTgXeDKi0YWnGHj8oH2h20cA64Gf4iSB/w30xRnyPs1auz1GMYZvwJFOUrjtUyWFPaTBLJEYak4KVSkU7zmQFOqaxy2F07x6kzFmDDAaqLTWbmxxdw5wGfB+hOPrsmCC2mENONiA+7bgV3wYeKRz/Zitn7odSdxTpVAkhlJSnT86a8Hvh1RVZMQ7VClsX1gdG4M9/v7Vzv4q4JlIBSUtDBrubJUU9lgKusydSMwYA2kZ0FgPTQ2Qmu12RCLNirLTyEw1HJnnvRbFbgorKQy2c/kWMA3oD1xtrX3PGFOAs2Djr9ZaXZMtkgYc6Wy3fuJuHAkgNJdYg1kiMZKeeSApzFRSKN7x5b5ZHFOYiTFaZNJSl5PC4EKOl3HmFe7DGTIuCN5dhTNf77cc4hrC0k1DRjnbfZUdHyed0vCxSIylB6swDfXQy91QREKstbyyeR956Skc1z/H7XA8JZwZlvOBEuBs4EhazN8LDis/BUyPZHACDBsD//0oXH6P25HEveYrmigpFImN9Exn26TLiIl37G0IsGrnft7dtd/tUDwnnKRwFrDQWvsM7Y/AfQwMi0RQcpBJX4WAl1tAxoeUYKkwoPXHIrGRFqwUNta7G4dIC6FFJvkZWmRysHCSwkF0vLq4FsjtWTjSrl9eBldOhPUfuh1JXEtR2zSR2ApVCpUUioeoHc2hhfMT2Y3TFPpQxgBbehaOtCs0Ge6jFe7GEedCw8eaUygSI6E5hRo+Fg/5IpgUFqodTRvhJIV/BS4JLjhpxRhzBPD/gL9EKjBpIbTYZOMad+OIc82VQnfDEEkeoUphgyqF4h2hax73UVLYRjhJ4U04q43fAS7HeW893RhzB/AuUA/cEfEIBYaMdrZKCnsk1HogoPFjkdjI6u1s99e4G4dIC6oUHlqXk0Jr7cfAKUATcDPOaNyPgGuAz4FTrLWfRyPIpDc0lBSudjeOOBf6ZVefQpEYyQlOM6+tdjcOkaCAtVTWO+8CqhS2Fe4VTVYBXzbGjAVG4SSG66y170UjOAkaNMK5ZNS2z6C+Tk1gu0kLTURiLCfP2dZWuRuHSFCD3xIA+mSkkJ6ixtUH61Kl0BjT2xjziTHmhwDW2g+stY9ba/+U6AmhMWaGMWZhZaWLzaPTM2DwUU42s+kj9+KIcwcWmigrFIkJJYXiMVlpKXxtaC4zhqlZSnu6lBRaa2uAvkDSTQyx1i611l6Wn5/vbiDNi03WuhtHHAv1KVRKKBIjzUmhho/FG5oClsKsVAblhDVQmjTCWWjyFs4VTcQNJ10IxUMOJIcSNl3mTiTGVCkUj3lrex1LPtrLukq1SWpPOKnytcCrxpi3gSXWagwupqbOcr6k20KfgPSbKxIjvZQUirdsqW0ENGJ0KOEkhT8H9gAPAncaYz7BuYpJS9Zae0qkgpOD3HkRFA2BS251O5K41Fwp1MuBSGz06uNsq79wNw6RoD1qR9OhcJLCI3GS643B2/0jH44cUlMj/PURZxXyt26AjEy3I4o7zXMKlROKxEafYmdbudPdOERQO5qu6HJSaK0dFsU4pDNp6TD4aGf18cbVMGKC2xHFHV3mTiTGQknh3h3uxiECVDUECAC909WO5lC62pKmyBhznDFmeLQDkg4MH+9sP/mHu3HEqZTm4WMRiQklheIhoaHjPhnhrLFNLh3+ZIwxKcaY3wBbAR/wb2PMm8aYophEJ60pKeyR0OdCrZESiZH8fs62cicE9HFM3LW3wUkKCzR0fEidpcvfBy4DtgFPAf8CyoAFUY5L2qOkUETiSVo65BY4CaEWm4jL9mo+Yac6SwovAtYAo6y1s6y144HFwAxjTJ+oRyethZLCT9/XagkRiQ/5GkIWb+ifnUZWqmF4XobboXhWZ0nhl3B6ErZsR38fkAocHbWoPMQTl7kLKRwABf1hXyVs3+B2NHHLGE0wFomZwgHOdvcWd+OQpDe6MJMfjCtkgK5mckidJYW9gIP/kre0uC/heeYydyGjSp1t1W534xAR6YriIc52x8aOjxOJstc27+PNbQe3V5aWurIE5+BxytBtlVvc8B+/gltfgKO+4nYkcUcD7iIuKB7qbHdodEPcU9sY4O0ddby7a7/boXhaV2qoZxpjBrS4nYPz/jrLGDP+oGOttfYXEYtO2uo7EDaugc8/giEj3Y5GRKRj/YNJoaa8iIv2BFce56WrHU1HupIUfjP4dbC57eyzgJLCaNpXBdecAoePhMVr3I5GRKRjqhSKB+hKJl3TWVJ4UkyikK7L6gWZ2fD5WqjZC721CDxcmvcgEkOqFIoHVDeqUtgVHSaF1tq/xSoQ6aLUVBg2Dj5a4bSmOeYEtyMSETm0osOd7a5N4Pc7r2EiMVbV6FQKczP0+9cRpcyd8FRLmhA1se6W0DWPVSkUiaHMbOdyd02NsGeb29FIkqpuCCaFqhR2SD+dTniuJQ0oKeymUFKYqt96kdjSELK4rDpYKczTdY87pJ9OPDryy85WSWFYmoJXgUlV82qR2NJiE3FZQ7AqkK/h4w6prXc8OmIcGAMbPoTGBkjXJXu6wh8IJYUuByKSbFQpFJdNO6wX+5osvTV83CH9dOJRTi4MGuHM0dnysdvRxA1/aPhYlUKR2FKlUFzWOz2Fo/JVQOmMksJ4deF1UPq1A5eQkk75Q8PH+q0XiS1VCsVFu/c3sWjNXv6yscbtUDxPw8edMMbMAGaMGDHC7VBamzYbTrvYGUaWLlGlUMQlzZVCXf9YYm97ndOjMDSvXA5NNZNOeHL1MThzCeeMhF+2d2EZaU9zpVA5oUhshUY0dmwAvTFLjFUHL3GndjSd008oXtXXwqZ/w19/D/4mt6OJC36nI4EqhSKx1ruPMxe6rgaq97gdjSSZ5sbVSgo7pZ9QvOrdB/oPg/o6+Pwjt6OJC6Ghg7QUJYUiMWWMFpuIa0KNq/PUjqZTSgrj2VETne26Ve7GEScagy1p9GFRxAX9DnO2u7e4G4cknWpVCrtMP6FOePIydyFfOtbZrnnL3TjiRENwpUmmlh+LxF7fQc5WSaHEWPMl7nQ1k07pJ9QJzy40ARhT7mw/fNPdOOJEfTApzNDwsUjshZLCXZvdjUOSit9aapoCGFDj6i5QS5p4dnSJczWT9R9AzV5nnqG0K2AtTcFFj3pdEHGBKoXighSgb1YquekpWmTYBXp7jGcZWXD0sU6Lh9U+t6PxtOah4xSD0QuDSOz1G+xsd6tSKLFjjGHOyD6cPzzP7VDigpLCTnh6TiFA6Uxnm6Kib0fqg4tMMtSkUMQdeX2dbY1a0kjsVDf6eX5DDTuCDaylY0oKO+HpOYUA5/0XPLoJSqa5HYmnhSqFSgpFXJITfA3dV+VuHJJUVn9Rz4d76lmzt97tUOKCksJ4l5ICa9+GR27WlQI60BA4MHwsIi7oFRy+2+fRURdJSKHG1TlpSne6QmOOieDxnzltaSZOg1GT3Y7Gk+pVKRRxV69gpbBWlUKJnapQ42qtMOwS/ZQ64fk5hQDDxjrbD9Sa5lDqmpwXhmwlhSLuyOrtbOuqIRBwNxZJGupRGB7P/5SMMSOMMQuMMf80xviNMa+3c4wxxlxnjPncGFNnjHnDGDO+neNGG2P+aoypNcZsMcbcbIzp8Lo3np9TCDBuqrP95+uuhuFltcF+NNkaQhBxR2oqZPd2prnU1bgdjSSJqkZngYkqhV0TDz+lMcCZwEfAvw9xzLXADcD/AjOAGuAVY8yA0AHGmALgFcAC9nWCFwAAIABJREFUM4Gbgf8Cbopa5LHy5ZOc7T//Bk2N7sbiUaFKoeaViLgoNISseYUSA00BS22TJQXopaSwS+Lhp7TUWnu4tXYW8OHBdxpjsnCSwjustfdba18BZuEkf99vcej3gGzgHGvtMmvtb3ASwnnGmEM2MIqL4eOiw+Cwo51P3/9e6XY0nhSqFOakafhYxDU5wZdazSuUGAhd87h3egop6k/bJZ5PCq21nU0+KQPygD+1eMw+YClwRovjzgBesta2fDX6I06ieEIH5/f+8DHA+FOc7Xt/dTcOj6oNzSlUpVDEPaoUSgztCyaFhVkdzhKTFhLhHXIk4AfWHbR/TfC+lsetbXmAtXYjUHvQcfFp/MnO9h+vuhuHR9X5Q8PH+rQo4hpVCiWGBuSkMXVgDicO6uV2KHEjEZLCAqDGWntwu/I9QI4xJqPFcXvbefye4H1tGGMuM8asNMas3LlzZ8QCjorxJ0FaOmw+1LTL5KaFJiIeoEqhxJABxhVmMiBH3fe6Sj+pDlhrFwILAUpKSrzdGTqvL9z6AqRldH5sEtJCExEPUFIoMfTS5zX864t6vjuqQEPIXZQI75B7gN7ttJYpAGqttQ0tjmtvYmBB8L7495VTwd8EOze5HYmnBKylrrlSqOFjEdf06uNs97U3aCMSWZv2NWGBJl3tq8sSISlcC6QCIw7af/AcwrUcNHfQGHM4kHPQcfFr88dwzSnw02+5HYmn1DQGsECvNEOqVqCJuKd3MCmsUVIo0RWwlr0NzqyygkxVCbsqEZJCH1CF04YGAGNMDk6/whdbHPciMN0Yk9ti3/lAHfC3GMQZfYUDIDUN/vUG3Hwu/OM1XQ+ZA20JctP1wiDiKiWFEiOVDQEC1mlHk65r3neZ55NCY0yOMeY8Y8x5wGCgKHTbGJNjrd0P/BS4zhhzpTHmFOBxnO/tvhZP9RugHnjKGHOqMeYyYD7w84Pa1MSv7N5w0U1OYvjmU3D1yXDVZPj8I7cjc5UucyTiERo+lhhZX+3MHBukRSZhiYefVjFOktdS6PYRwHqcpDAF+G+gL7ASOM1auz30AGvtnmDCeD9OD8O9wC9wEsPEceF1MG02vLAInvs1fLQCrpgA370LZlwOSTh8eqBSqKRQxFWqFEqMfFrlXN3ryDwtvgyH598lrbXrrbXmEF/rg8dYa+1t1trDrLXZ1top1tr32nmu1dbak4PHDLTW3tBOK5v413cQfOdG+O1HcOp3oL4O7r8S3nmx88cmICWFIh6RW+hsq3a5G4ckNH/AsqE6lBSmuxxNfImHSqF0V698uPp3MPlrsPxxGDYWNqyGmj0wptzt6GKmOjjZWMPHIi7rO8jZ7t7qbhyS0D7f10hDwFKUlUpehuaSh0NJYTKYep7zBXDJ0bB5HZTOhCvvheIh7sYWA1WqFIp4Q8EAZ7tnGwQCkKK/SYm83mkp5GekMLl/ttuhxB39RSabb9/oLEipeAYuHQ1P3O30Nkxge+rVlkDEEzIynUb7/iao1BCyREe/7DQuH1PImMIst0OJO0oKk80p34LFa+H4c2H/Plj4I/jeeFj5stuRRUW9P0BtkyXNqFIo4gnNQ8ib3Y1DEtK/99bzi/d3s76qofODpQ29SyajfoPhJ0/ALc/BgCNgw4dw3XS44Syoq3E7uojaU+8MHffJTMUk4cprEc8ZcKSz3aTrtEtkWWv525Za6gOW/X716O0OJYXJ7LivwoOr4dL/hZxcePt5ePcVZ65Pggwpa+hYxGOGjXG2Gz50Nw5JOJ9UNbK73k9uegpH9VErmu5QUpjsMrLgG1fDQx/DrS9A6ddgwTz4Wi+4//uwK76HeJQUinjM0GBSuP4Dd+OQhLNiRx0AJUVZuqRpNykpFEdBMUw6w1kNWDwUmhrh2Qfg4uHwwH/A1k/djrBbDiSF+lUX8YQjjnG2H72jy3BKxGyobmBjTSMZKYYv99MCk+7SO6W0de5/woJ/wdRZ0FgPz9wPs0fA/LPh/dfj6oX8C1UKRbxl6GjoU8z/b++84+Sqyj7+fXZ3ttdk09umb0JCDb0FIlJEiqKIAiIIqAivoKihF0HQFwTEl+KrgvACQhAUJKBICxBqJIUkkN7r9t7mvH88d7J3J7Mt2d2Z2Xm+n8/53Jlzz9x77tm7d37znOd5Djs3JvwSnEbP4Jzjjc21ABw6JIP0ZJM2e4qNnBGZon3guqfhoUVwwrchJQDvPg9XHwd3nhft3nUJ5xw76lQUDk63lJyGERMkJcEBs/T1O89Fty9Gv2BJaQNbapvJShEOHmS5CfcGE4WdICJfFpGHKyoqot2V6DB2Olz9CDy+Hs67CQpHqvUwGIQ/3wiP3wIlm6Pdy4hUNAZpDDqyUoRMS0djGLHDLO+H5T8ehJb+t9Ko0bcsLKkHYObwLFKTzZdwbxAXR1OB0WTGjBnuo48+inY3Yoe6ajirUAViUrIGqHzpUjjwhJhZpeDz8gb+uqaKopwA35iQF+3uGIYRIhiECyfD5pVw9aNwwvnR7pERx2ys1qjjfQekWeqxtnR7MGLj29uIPzKy4a634Kiv6Pt3noNrTtLAlCdui4m1TXfUe1PHGTZ1bBgxRVISfPNaff0/V8CSt6PbHyMuWV7WwDOrKhiYnsx+A9NNEPYAJgqNPaf4ELjhWfi/9XDBL2DIGNi2Fh65Dr41Cl54IKrd21GnuRYHpVuQiWHEHCd8W1dWqqmAn82CZ3+jFkTD6AIbq5t4YV0VqyqbqGy0+6anMFFo7D0Dh+uv/kdWwe0vw5FnqiWgbCtUlcH39oMfHAh/mK3Ry019s/zQlloVhUMyzVJoGDGHCFz7FJz+Q30mPHQV/PgYWL0o2j0zYpyS+mbmrK6kxcGBhen2jO9BzKewi5hPYTdxTh/6lSVwyXQo9U0np2fBtKNh+jGw77Ew+WCNbu5BqpuC3L+klNQk4Uf7DiDJphUMI3aZ/wLcczGUbVMf5dMug2/fAlnmC2y0pbKxhf9bUUFFY5DxuQG+Oi7Xnu/t0+2BMVHYRUwU7gUNdbB4Hnz8Cnz0yu7LW804CW6fC9vWwY4NMPEgSNu7tAKhIJMx2QHOmWhfLIYR81SXw6M3wAu/02nkgiFw3s1w0oU9/qPRiE8qGlt4ckUF5Y1BhmWmcM6EPIs27hgThb2FicIepGQzLHoTFr8FS9+F6cfCZffBRVNgw3IIpMLkQ6D4MCg+VMugkWp57CJvbK7hvW11HDEkg2OGZ/XixRiG0aOs+kSX2Pz0HX0/fAJ8+1Y49usxk9nA6HvKG1p4cqVaCIdmpPCNCbmkp9j90AkmCnsLE4V9wEu/16X11izafdWUAcPg4JPgsvshPbN1erodnlhRwfrqJs4al8uEPFsY3TDiimAQ3n5Wg9Y2fq514/eHb10PR5xh4jABeWl9FYtKGhiWmcLZ400QdhEThb2FicI+pKpMLYiffQDL39dtVZmKwD9+DkvmwX3fUwvC5ENg/AH6hTF+f8jKpTnouGdRCc0Orpg2wBJXG0a80tIM/3wEHrsJdm7SupGT4Gs/hVnnQmpaNHtn9AFba5vJCSRR0xxkVUUjBw5KJ82WsesqJgp7CxOFUcQ52LRCIxTHToO3n4NfnqOJs8MZNo6aov158rAfIUXTuKg4X+vNEdkw4peGOnj5DzDnv9X3GDTrwRlXwEkXQV5hdPtn9DjNQce/N9Xwn531jM4O8E3zDd8TTBT2NCLyZeDLEyZMuHjFihXR7o4RorEeVi2Ezz9UH6RVn8DaxbvS3bx/zGXUf/3nHHvrUVBfq1bEcfvpms5F02DUFMgwX0PDiCuam+DNp+HpO2HNYq0LpKm/4Zd/oP7H9gMw7impb+bva6vYVtdCssCpY3KYUmBW4T3ARGFvYZbCOKC5CTYs57WPFrNwxKGcPq6AcdccARs/272tCAwdq/5Jl94FjQ2aeHvIGEhN7/OuG4bRDZyDD1+Gv98PH85t9UGecCCccgnMPBuy86PbR6PbBJ3jg+11zNtSS4uDvNQkzhyby1DLQ7inmCjsLUwUxgf1zUHuXVyKCPxo+kBSk4Dt62Hlf9SysO5TWLtEhWJLs35xPL0d7vu+Tk8lJamv4ph9YPRUGDUZRk7WreVMM4zYY8tq+MdD+v9bWaJ1gTQ44nRdNeWgL0KyiYpYZ2ttMy+vr2artxLV9AFpzBqRZQEle4eJwt7CRGF8sLysgefXVjEyK4VzJ3VgKWhqVD/FnAEwcBi8NUcjHTeviLzUVnIKXD8HDj0V/vZbbTNqMowqhiFFkGxL6RlGVGmsh7ee0cCUha+3Wg8LhsBx34Rjz9alOW16OeaoaGzh4aVltDjIDSRx0uhsxuVa1ogewERhb2GiMD74+9oqlpY1cNzwTA4dktn9AzTWw4bP1KK4fplaFDcsh4odcNUfYcBQXbLPTyBVrYsjPavioV+CaUf1zAUZhtF9tq+Hfz8O/3q0NaUNwODRcPRZWooPtdQ2UaS+JcjikgZyUpMoygnwj3XVDExL5vChGRZd3HOYKOwtTBTGPs1Bx32LS2kMOi6dWkBBWi9Y74JBeO0JWDbfE4yfwc6NbdvkFMCcEvjjNerzNHg0DBuvwnG4tx02Xv0XbaUGw+g9nIPlH8DrT8C8OZo4P0ThSDj6q3DYafojLmCWqb6gvjnIhzvq+GhHPQ0tjgFpyVwytSDa3eqvmCjsLUwUxj6rKhp5ZnUlg9KTuWhKHz5k6qp1KnrDcrVKjN0XjjoT/nQdPHlb+59Ly4Cb/gb7Hw/P3QvBZp2KDpX8QTbVZRg9RTAIy97TKeZ5c9r+mMvMhRknqnvIwSfr/57Ro9Q0Bfl4Zx0fe2IQYHR2gONGZDIs034c9xImCnsLE4Wxz9z1VSwsaeDIoRkcPSxG0s3UVsGWVbB5FWxe2brdsgqqy2D2k+rz9MODd/9sWkarQDz8NDj1e5qvbcNyGDjCRKNh7CnBoCbFf+c5eP9FWLe0dZ8ITDkMDj4FDjwBJh1kgSp7QXVTkLe21PBpaQOeFmRMdoAjh2UyOtvEYC9jorCnsTyF8UFL0HH/klLqWhwXFuczOCMOHuKhpfpaWuD1J2HlAk2LEypVZa1tcwfCMzvgjnN1KgxUNA4e4wnHMTBolE5LH3mmrfRgGN1hy2p4/x8qEBe9sSvfKaBZB/Y/Hg74Ahz4BRgx0X6MdULQOZqCjrTkJF5cV8WSUl1oYEJeKocOzmCUicG+wkRhb2GWwtjms/IGnltTxaD0ZC4szkf6w0O7pkJXb9i2FoaO09Vc3noGnvrl7qLRz3d/pak4rjgE6mvUd2rQKC2h14NHaTJvy+VmGG2prYIFr8KCf+p288q2+wePhgNmwfRjYfoxMLTIRKJHdVOQRSX1fFJST3VjkAuK83EOVlY2MiU/jQHplqWhjzFR2FuYKIxt5qyuZGVFI8ePyOKQwRnR7k7f4BeN29apj1RtFZz1Y8jIgcsObF0vNhJ5g+DJTTD/7/Ds3fp+4PC2ZcAwGDRSLZWGkYhsXQv/eRUW/Av+8+/WXIghCkeoOAyV0VMSSiS2OMeayiYWl9azoryRUEKvgWnJnDMxj2xbez6amCjsLUwUxi41TUF+t6QUB/xw2gCy7CGkBINQtk3F4o4NvuK9H1UMV/0vPPAjeP6+jo91xQO6UsTvLofSLWHCcbjmehw4XPM+JtAXopFgBIOaCH/Rm7D4LVgyD6pK27bJK4SpR6pf4pTDYNIMyMiOTn97kfqWIG9vqWVpWQO1zaojBJiYl8oBhekU5QT6x4xNfGOisLcwURi7fLC9jtc21TA+N8DXxtuqI90mGITPP9LcbqVbtJRsbi01FXDxr3VliK8PhmBL+8caPgEeXKjpeubcpV+GBUOgYKi3HQL5QzTfYz/8ojQSjGBQg1RCAnHRm/r/4ycpSTMSTDkMij2hOGJiXOZIrGpqYUddC2NzAry3rY43t9QCahWcNiCNaQPSyEm1KeIYwkRhb2GiMDYJOsfDS8sobwxy5tgcJudbgEWvsmmlBsSEC8dQGTAU7v8I/nIHPHl7x8f6zu1wzmz4842waqF+NiQaQwKyYKhOz6UliEuAEd84p0ErS+fD8vd0u3rh7j+kcgpgwkEa2TzhQJh4EAwbF5NW9tqmIJ9VNLC8rJH11U044IyiHEZnB1hcWs/onABDM1LMKhibmCjsaSz6OLZZXt7A82uqyEtN4tKpBSTZgyk2aGyAD+dCySadwi7dCuXb9HXZNk3H883r4Cs/gq8OhNrK9o+VlQcPfKJBM7+/GlJS24rGAs/ymD9Ev1jj0AJj9GPqa2HFx5ojMSQUw62JoEFfEw5sFYmTDtJsAlG4nyMJQYAk0enhE0dlk2lrEscDJgp7C7MUxh7OOR77vILNtc2cMDKLgwaZNSku2b5Bc8aVbW0VjWXbWkVkWgb86jX44CW468KOj3XcN2H2/2ni8A/nqn9X/mANoskbpK/zB+mXbdE+fXN9huHHOQ0AW/Fx21K2bfe2GdkwdrpOP4/bD8btC0XTISu317q3oqKBv66uahWCQFFugOL8NCbmpZJhYjCe6LYojINkboYRmY01zWyubSY9WZg+ID3a3TH2lMFeipzO+OIF+uW4bW1b0Vi2TQVlxU4YM1XbfvyKTnN3xO0va3qe606BlubdxWPeIBWQ+x2nyxMC1NVAemZMTvMZcYKIRvQPGglHnK51zqn18PMwoVi6RS2LS+e3PcbQsZ5Q3Fe3RdP0Hu3mspkl9c2sqGhkRUUjFQ1Bzp6QS4uDtGRhRFYKk/PTmJSXSroJwYTBLIVdxCyFscezqytZUdHIEUMyOGZ4jKxgYsQGDXWwdgmUb4eKHVC+o/V1xQ79Yr78AX3942N0aro9hhTBY2vg7u/Cy3/QNXLDxWPeIBWYJ12o04A7N+nyh3mFkF1gU9rGnlG+A9YsgtWLvO1CWPdp2+TaIVICGsAyaor+OBo9RcvIybt8coPOsalGheDKikZKG1p9HVOThPMm5TEoHhL/G13FLIVGYhD6hZss2LSxsTtpGTA5wtKB4QwepSvFlG1rFYzl2/XLOPR+32O17dCxkJ6lAnLnpsg5IEXU+nPBBLX+gArC7ALILVSRmFsI04/WfJIVOzX/XUZO6768QvWjNGukkT9IE2UfMKu1rqVZ11hfvVDF4uqFsH6p5ipdt1TL28+2theBoWOpHjaZ5bnj2VY4kZ1DJlM9eBLpWbmMz01lYn4qY3MCpCXbj5dExyyFnWCBJrHJy+ur+aSknv0GpnHy6Jxod8dIJOprfQLSZ4FsaoCTL9bp5TvPU4tO5c7IK88E0uC5cnjwSnjxwd33JyVrwvCCIXDRnXDIyfDyH3XN7JyBKhz9IjK3EDJzTEgmMnU1sPEz3LpPqVm9lIY1S0nZuIycHatJaieNlBs4HBk9FUYXw/CJamkcMUGt492cijZiEgs06S1s+jh2qGkK8j+fltLi4OIp+QxMN4O3EcO0NENlqQrEip26HVIEEw+EVZ/Ac/d6wnJnaxt/NPY3ZsM518KZuZoXrz0Gj4b/+Y8mK3/0Bv1Szxmwe8kdCMWH2vrY/Yj65iBrqppYXdnI6spGappbv9czXRPfzSshfdMymtYuI3XjcmT9Us0l2lgf+YBJybp833BPJIa2IyaaYIwvbPrY6P98vLOOFqeLq5sgNGKe5BQoGKwlnPH7w0/+tHt9U6Mup1Zf3ZqW5BdzYfn7KhwrS9qKzIqdKhhdED55Deb/reM+HfUVuOFZuPF0nb4OF42h10PHaYBPIFWnJYMtrfvSMswyGSWCziGAiPDW5hrmb6vDb97JCSQxNjfAuNxUinICpCcPg/HTSDvG16ilBbZ7U84blusaz5tXwqYVuuLR5lVawm0hSckwZIwKxOET2m6HFOm9YsQt9o1qxBVNQceCHfrr9tBEWePYSDwCqbp0oJ8ZX9TSHs6pSDvjCs1zV7pFl2CrKlURGXpdUwGHe1GvzU0alNPQjo8kaJRsUjJce3JYH9Paishjvgan/1ATkX/8CmTl+4TmAPWrzM5X/0kLvOkWzjm21bWwrqqRtVVNbKxpIj81mYumFFDS0IIAo7IDjPOE4KD05M6TSScna17PYePgsFPb7mush61rVCBuWgmbfdvt6zVB95bVwCttP5eUBIUjVRwOHdu6HeptB47Q8xoxi00fd4L5FMYWC3bU8c+NNQzPTOG8SXmWRd8w9gbnNHBml3gME5EpATjtMn1/3/dg61qvbcnuEbCjp8D/LoWrj4eFr7d/zrRMtVJOPwZ+db4eLztfS1bYdtKM1jRD5TvUOpmelRAWysrGFlZVqghcV9VEfUvb7+rJ+amcOTYX5xxBB8lJfTQmjQ2wdbUnEj3L4i4L4/qOXRySU9TNoT3RWDDUfjD0LOZT2FuYT2H08S9pd0ZRDsUF5hNlGFHBObUwhsRkVamKwoIhsPI/8MZTbfdVlmjATU25ioZrnlKxd+GkjkVEIBX+Wg5/uRMev1nrkpJ3F5G5A+GrP4biQ+Djf+l0aGaulqxcjeYOvc8ZEHNTnEHn2F7XwtbaZsbkBMgOJPHbxaU0Blu/n3MDSRTlBBiTE2BMTirZgRgUT02NOvW8dY3mE926Rn9IbPO2kVZy8RNI06lpv2gcNErL4NG65KX5M3YH8yk0+i8rKxopbwySn5rEpPzYeqgbRkIholHW6Zk6vexnwgFa2iM0zQ3w6Gq1MlWXa6nxttVluh1VrNbBMVNVGFSWQEOt51NZ0va4uYWazPn6L+m0eHvkDIAHF2pAzr2Xal1IMPpLVh4ccQaMnQZl2zVPoH9fZu4eJzJvDjq21DazobqJDdVNbKpp3iUAi/NTOa0oh30GpFHXHGRMToCinFTyU5Nif2YkkKpJtEPJ3sNprNfUOSHB6BeOW9doFP/Gz7VEQkStiYNHtxWL/tf5g83auBeYpbATbPo4dnhyRQXrqpuYNSKLg82f0DASk6ZG9YvcJSDLVSjue6xaDV99XNcYrq2EmkqorfC2XsnOh7vmaUDOL8/p+FzTjoK758H39tOcgOEkJak4LBwJ1/5FLVkPXqVT8iErpU9E1qZm82rWVD5LHUJL0JFZs5OmQAZNqVnkpyUzKjvAIYMzEjeBdF2NCkW/aNyxQcv2DVC6uWPLMnj+uCM6Fo6Jkwc0vqaPRWQCcDVwOLAPMM85NzOsjQCzge8DhcCHwBXOuU/C2k0Ffusdqxz4X+Bm51xLd48VCZs+ji6l9S08vKyMQBJcts8AW3bJMIy9p2SzpgPyi8ZdpQoOOQWmHg4vPgRv/mX3Ng11epykJLjtZZ3+/MmxHZ6yJquQ316/lNNenM3Ut/8AgBNB0rM0CCcjW7c5A+A7t2kS9ufvUwtbZg6kZ+vW33bkpFaLbUOdTrEm90Nh2dykU9Db1/vEYtjrcAtyJDKyI4vF0OtBo3atAhPnxN308T7AKcB7QHuOAj8HrkfF43LgKuBVEZnmnNsKICIFwKvAUuB0YDxwF7qW93XdOZYRmywrbwCgOD/NBKFhGD3DwOFaOuPUS7WE09wEtVVUNzsWNmawubqR4A/nkl6ynrT6KtLqK0ltqCKjoYrJqQ1kNlQRnHQ4/7XvQDI2HQTL5kJ1OdJQq8si1lW3Pf70Y9Sv7oEfddy/5BR4YhN88A/4zXfVmpaa3iocd4nJXI0QP/RLMP8FWDY/QhtPcA4aqUIJ9Hgi0beupQS0T6F+RaK+Vl0DIgnH0LauGtYv09IeuQPbisTwUjgi5nxTe4JoWwqTnHNB7/UcoNBvKRSRdGAbcJdz7havLgtYCzzknLvOq5sN/BQY45yr9Op+CtwEDHXOVXb1WBH6aNPHMcBjn5ezqaaZr47LYWKeBZgYhtH3OOcobWhhU00zm2uayQ4kceTQDJ5bU8XnFa3R2FkpwoisACOyUhieFWBoZgqBjqKDW1p0yrmuSi2U9dWa9HzSDBV8H/0T1i5u3Vdb5YnIKi2FIzXf5Qdz4e4LNbinvWnWo8+C656Gs4eqlbQ9RHTqPCkFZp+gYqs9S+WRZ2g+y1WfwHsvaoS5v03oc/mDOhZ0fYFz6nLQkWgs2dSxXyq0+jeGi8XBvtcFQ6Odgie+po/9tCMKjwf+DUxxzi331f8R2M85d5D3/i1gs3PuG742o4F1wGnOuRe6eqz2sOnj6OGc457FpTS0OC6fNoCsWIy6Mwyj39HY4thc08Sm2mY21TSxuaa5TWqYFIEr9x3I1rpmVpQ3MjgjheFZKeRFOygkFB3uF4511SrsphyqPnVL3oZFb7a28QvO+moVdlc/qsJx9okaBNIeIybCnz6Hn85SX82O+Mmf4NBT4fJD9Nh+oekXnJNmwNd+olP8bz0DyYHIojQ7X612PUkwqOuhh0RjpFK6pXP/xuQU7duw8d4SghNbk32PKu6LgJi4mz7ujGKgBQg30S0Dzg5r1+ZOdM6tF5Fab98L3TiWEYM0eA/izJSEcA42DCPKtDjHw8vKqG5q+8WfnZLE8KwURmSlMCEvleSkkFUwhlKl+KPDI62kAxpEM+2ozo9VOAKe2a4BPnXVu1sqa6tao80vvVsFXH21T5D6hCaoKHJOI5Hra7REYt4c+NKl8PSvdCnIjvjGbLjw9s6vpaskJWny+IHDNM1RJEL+jaEgmEjCsXy7F229bnexfMK34epHeq7PPUSsi8ICoNofLOJRBmSKSKpzrtFrVx7h82Xevu4caxcicglwCcDo0VE2eScwIsIBhek0trjYT8lgGEa/YWhGCjWBICOyUhiRFWB4Vgq5gThIDdMbBFIh4K1O0x7j99PSFZ7YGCYywwTk0LFqETzjCkjN0DRF4dbM2ioVl8Mn9Mw1dge/f+M+7bRprFdxuCksyfe2tTBycl/2tsvEuiiMKs65h4GHQaePo9ydhObEUdnR7oJhGAlEsghnjc+Ndjf6L0lJXmLxXBjYQbth4+CiX/ZZt3qU1PTWKWNO7rR5LBCLuJJkAAAS1ElEQVTrzlllQLaIhHtqFgC1PsteGZAX4fMF3r7uHMswDMMwDCPhiHVRuBxIBsJtw8XePn+7Yn8DERkFZPradfVYhmEYhmEYCUesi8J3gUrga6EKEckEvgzM9bWbC5woIjm+urOBOuDNbh7LMAzDMAwj4YiqT6Enyk7x3o4AckXkLO/9S865WhG5A7heRMpoTTidhK5eEuJB4ArgryJyJzAOzVF4dyhvoXOuvovHMgzDMAzDSDiiHWgyGHgmrC70fiyaWPoOVLjNRt1RPwJOcM5tC33AOVcmIrOA+9H0M+XAb1Bh6KfTYxmGYRiGYSQiMZO8Otax5NWGYRiGYcQR3c6dFOs+hYZhGIZhGEYfYKLQMAzDMAzDMFFoGIZhGIZhmCg0DMMwDMMwMFFoGIZhGIZhYKLQMAzDMAzDwEShYRiGYRiGgeUp7DIisgNY1wenKgR29sF5YhkbA8XGwcYghI2DYuNgYxDCxqHzMdjpnDupOwc0URhjiMhHzrkZ0e5HNLExUGwcbAxC2DgoNg42BiFsHHpnDGz62DAMwzAMwzBRaBiGYRiGYZgojEUejnYHYgAbA8XGwcYghI2DYuNgYxDCxqEXxsB8Cg3DMAzDMAyzFBqGYRiGYRgmCg3DMAzDMAxMFMYEIjJVRP4tIrUisllEbhGR5Gj3q7cQkQtExEUo3/O1ERG5RkQ2iEidiLwlIvtHs997g4hMEJGHRGSRiLSIyBsR2nTpmuP5funiOKyNcG9sjdAuLsdBRL4mIn8XkU0iUi0iH4vIORHaXSwiK0Sk3mszK0KbESLynIhUichOEblfRDL75kr2nK6MgYi80c5zIj2sXVyOAYCInCUi74pIifd3/kxErhORVF+bRHgudGUc+vVzIRzvvq72rjPbV9+r90NKT1+I0T1EpAB4FVgKnA6MB+5CBft1UexaX3A8UOd7v9r3+ufA9cDVwHLgKuBVEZnmnNvtQRAH7AOcArwHBNpp0+k194P7pSvjAPAE8Fvf+0b/zjgfh6uANcCVaOLZU4AnRKTQOfdbAE8gPQjcBLwNfAd4UUQOds4t8doEgFfQsfkGkA/c7W3P7csL2gM6HQOP14Frwj7bEHoR52MAMBB4Dfg1UA4cgv7NhwI/9NokwnOhK+MA/fu5EM6vgWogK6y+d+8H55yVKBZgNlAG5PrqfgrU+uv6UwEuAByQ3c7+dKACuMFXlwXsAH4R7f7v4TUn+V7PAd7Yk2uO9/uls3Hw6tcC/93JceJ2HIDCCHVPAGt87z8D/ugfN2Ax8Liv7hygBRjrq/s6EAQmRvs6e2AM3gDmdHKcuB2DDq7pNlQYSaI8FzobB+99v34uhF3HMUAp8BP/d2Vf3A82fRx9TgZecc5V+uqeAjKAY6PTpahzBJALPB2qcM7VAC+g4xV3OOeCnTTp6jXH9f3ShXHoKnE7Ds65SMtS/QcYDiAi44BJtL0XgsAz7H4vfOicW+Orex61nnRraau+prMx6AZxOwYdUAKEpk0T4rnQDv5x6CpxPw7eFO9vgVvYfQm7Xr8fTBRGn2LUBLwL59x6VNEXR6VHfccqEWn2/Ecu9dUXo7/+V4S1X0b/HZOuXnOi3C8XiUijiFSIyBwRGRO2v7+Nw+HA597rUP+Xh7VZBgwQkUG+duFj0AisIv7HIMQXPZ+oWhF5RUT2DdvfL8ZARJJFJFNEjgKuAB5wat5JqOdCB+MQIhGeC98D0oDfRdjX6/eD+RRGnwLURB5OmbevP7IF9Yn4AEhGfYEeFJFM59xv0Ouuds61hH2uDMgUkVTvwd+f6Oo1J8L98jfU53AjMAW4EZgnItOdcxVem34zDqIBJGcAF3pVof6HX1+Zb/8O+vcYALwJPAqsBMYA16L3wX7OubVem/4yBjWoEAD4M+ovBon3XGhvHCABngsiMhC4FTjXOdckIuFNev1+MFFo9DnOuVdQ5/AQc72IwutE5N4odcuIEZxz/+V7O09E3gU+QYMt7olOr3oHESlCfen+5px7JKqdiRLtjYFz7kZfs3ki8ipq/fiRV/oTRwCZaIDFDcD9wA+i2qPo0O44JMhz4TbgPefcS9HqgInC6FMG5EWoL6DVMpAIzEEdxIvQ684WkeSwX0QFQG0/tBJC16854e4X59wSEfkMONBXHffjICIDgLnAOuBbvl2h/ufR9td+Qdj+jsZgYc/1tPfoYAx2wzm3VUTeoev3QVyMAYBzboH38m0R2Qk8KiJ3kWDPhfbGwTm3KkLbfvVcEJF9UEv5MSKS71WHUivliUgLfXA/mE9h9FlO2By/iIxCb4Zwn6L+jPNtl6PTyhPC2uzmJ9GP6Oo1J+r94mi9RyDOx0E0j96LqCP9qc65Wt/uUP/DfX+KgVLn3A5fu/AxSAXGEf9j0B5duQ/iZgzaISSMxpLYzwX/OLRHf3ouTETTdM1HhVsZrX6FG9Hgk16/H0wURp+5wIkikuOrOxvN3/dmdLoUFc5CI63WAe8ClcDXQju9L5Avo+PVH+nqNSfc/SIi09AH3Me+6rgdBxFJQSOJJwInOee2+/c751ajARf+eyHJex9+Lxwc5mx/GuqT9XLv9L5n6GwM2vnMUOAodr8P4nIMOuBIb7uGxH4u+MdhN/rbcwHNR3pcWLnT23cKmrew9++HaOfjSfSCmnO3AP8CvgBcgiasjMt8fF285meBn6Fh86cCj6G/9i73tZmNRkpdBswC/oGKxiHR7v8eXnMmKnzPQn8Jfup7n9nVa473+6WzcQC+BDyJTiUeB3wf2IQmNvfn3IrbcQAe9u73K4DDwkqa1yaUf+86bxwe8R7o03zHCQBL0C/FU7zPbMWXyzBWS2djAOzr3f8XeNf/bdTCUQqM7g9j4PX/ZTQX3cnAF4Gbvfv4KV+bRHgudDgOifBcaGdcLiAsp29v3w9Rv2grDmAqms29zvtD3gokR7tfvXi9t6PJeWu9a/4YOC+sjaDRhhu9NvOAA6Ld97245iJapzrCS1F3rjme75fOxgEVA/9Go2ub0C/4R4Dh/WUc0CS8Hd4LXruL0cjbBnQqbVaEY41E8/JVo3ndfof3IyOWS2djAIwAXvL+ro3etT0LFPeXMfD6fisqaqtR/9EFwOVAwNcmEZ4LHY5DIjwX2hmXC9hdFPbq/RDKFG4YhmEYhmEkMOZTaBiGYRiGYZgoNAzDMAzDMEwUGoZhGIZhGJgoNAzDMAzDMDBRaBiGYRiGYWCi0DAMwzAMw8BEoWEYhmEYhoGJQsMwDMMwDAMThYZhGEY/QETSROT3IrJaRKpE5HMRuTza/TKMeCIl2h0wDMMwjB4gBV3+7Ivomrj7Aq+IyDbn3NNR7ZlhxAlmKTQMI2qIyFoRecP3fqaIOBG5oJfO16vH72IfxorI8yKyw+vLIzHSr5u8PoTKUdHqy57gnKtxzl3vnFvpnAs65z4B/g7sug4ROSzsGm+KWocNIwYxUWgYhl8s+Uu1iCwQkStFJC5mFURkf0/cFEW7Lx3wCHAscCdwHvBQVHuzO1ei/foMQERO8u6HX4Q39ImsBhHJjLD/ZREJikhhhH33i8gmEZHeuAgRCQBHA4t81SvRa7uyN85pGPFOXDzoDcPoM54EXgIEGAqcD9wNTAEu6YPzvwVkAE17+Pn9gRuBN4C1vXD8vUJE0lChcr9z7r999TOj0Z92eN45t9b3/m2gGZgZoe1x3r5U4Ajg1dAO74fEUcAS59xO/4c8IXgG8DfnnOvJzvu4H6gC/hyq8PrxuPej4Te9dF7DiFvMUmgYhp8FzrnHnXOPOed+DRwGbAS+KyKDevvk3rRfvXOuJR6P3wWGoIK7NErn7zbOuWrgQ+DgCNbAmcC/UF++mWH7DgayUIEezsHACOD5HuzqLkTkbuBw4GTnXGNvnMMw+iMmCg3DaBfnXA3wHipkxofqRSRHRH4hIu+LyE5v+nCliNzRzjTiKBF5WkQqRKRSRF4QkfER2u3mW9fVc3n+YX/y3r7umwZ/pL3ji8jJ3vsrIl2/iMz3fP8C3vs0EblGRD4VkXoRKfeu5YDOxtLrxzrv7Y2+/s1sp33Ix68owr5wX8wUEXlHRGpEpDis7SXecW7prI8d8DpqDTzSf07v/ZteOS7sMzN9nw3nTKA8tE9ELvD6OEtEbhCRdSJS5/3ND/PaHCsib3vXuEVEro/UURG5BzgBmBVuoTQMo2NMFBqG0Rkh8ea3bo0Avgt8BNwKXAUsAH4KPOf/sIjko9O2XwEeA34O1KKCIKsL5+/quf4KPOy9vh31HevMZ++fqJXr/PAdIjIRtZQ+4Zxr8oThy+j09HzUL+0OYCrwjojM6OQ6HqLVl+05X/+WdfK5TnHONQPfBBqBp7xpakRkH+AedAr45r04RUjYzfTVhSyBIVF4sIj4/54zAeftC+dM4CXnXPg0/h3otPK9Xn/HAf8UkTPQv+884CfAcuAWETnX/2ERuQ/4AnC8c25H9y7RMAycc1asWEnwQusX+A1AITAImA78zqt/P6x9KhCIcJxbvfaH+Opu9+q+E9b2Hq/+jQj9uGAPz3WBVzezk+v0H//XXt3Udo5/oPf+Su/9iWHtcoH1/uvoYJyLvGPc1IV+3eTVFUU4ztpI50OFt0P96TKAJaiYH92FvnV0vgygAXjXVzcb9dlLQX1OHfBFb18KUA18EuFYobZnRfi7LQBSffWnefVNwIywe2ILMN9XN8ZrW++dO1TmdvXvYMVKohezFBqG4edmYAewHY3a/AFqoTnd38g51+g8K483dVngRZiGAg0O9TU/A9iGz+Hf486udKib59oTHvW2u6yFXiDEuWiQxAKv+lzUQvWxiBSGCipQ/gUcJSIZe9mXvcI591fgAeAydHz2Ab7rnFu/l8etA94HZvisgTNRkdjsnFuG3jMzvX0hK2KkqeMzUOH2coR9D7i2PoDzvO37zrmPfP1pBD4AJvrq1jnnxDmX7pzL9pWTu3m5hpGwmCg0DMPPw6g/1inAz1Ar00j0S7wNIvIDEVmEWpBKUTH5hre7wNd0HLDChQV3OOe2oH5lndKNc3Ub59wS1EL1LREJPROPQa1JfiE7BSj2zh1eLgSSUStrtLkKWIVGA//eE4o9wetAABW/fn/CEG/R6lc409u+EeE4ZwKvOg1gCWe1/41zrsx7uSZC2zJgYFc6bhhG17CUNIZh+FnhnAtZ4OaKyNuoP9qDwDdCjUTkKuAu1CfvPmAz6s82As3D12M/OPvoXH9Gp7OPRy1s5wMtwOP+rgCLUdHVHj3px9ZRqpaOnt37AaO919NEJMWpz+He8jrqXjATqKTVnzDEm8BvRCTbaxNEheIuRGQkMAO4uJ1ztBcVHq1occNIKEwUGobRLs65d0XkMeB8EbnPOfeut+s81K/tZOdcMNReRE6KcJjVwEQRSfZbC0VkGJDfhW5051x7mvPuCdS38HwReQc4C/iXZ80MsQL1tXzN349eJBTYMwBfzkURSQeGoYmY2yAiuWiuyZ2oX+FtqEvAtT3Qn/moxfg4VBTWoalqQryJfqfMRK2In/gsfSHOQP9Gf++B/hiG0cPY9LFhGJ1xK2qp8ac0aUG/3HetRuFNKf48wuf/hubnC4/w/VkXz9+dc4WmJAd08dgAOI1UnYsGanwLDR55NKzZn9GE3hEthSIypDvn7AKfe9svhNVfSfvP7ofRgItznXO3A3OAn4tIeLqYbuOca0CF4UHAqWiQh9//bwlQAlxN+/kJzwTedhYZbBgxiVkKDcPoEOfcShF5CvW5O9o5Nw8VG79Ep5j/ioqobxJ5pZBfeft+LyIHAZ+i1qTDUYtWZ3TnXB+i05bXikgBUAOscc6934XzPIpGu94FVLB7YuV7UX/LX4vI8cBrqMVsNDCLVitaT/EqutTcLSIyEPWrOwpNk7PbuInIRcDZwO3Oude86ovRoI/HRWRf51zJXvbpdfQaj0BT8+zCOedEZB5qDQy19fdvAOqr+dO97INhGL2EWQoNw+gKt6FiK2Qt/DVwDRpEci8a7fpPIuT786YQj0ZF1vlo1HEmKi5qunDu7pxrPRr0kYFG4T4JfL9rl8iL6JRtLvCMc65NcI0XAf0l4L/QaeSb0aXSzkanyH/ZxfN0CW+q/TTU4nY5msMvFV03uc24eQmr7wPexSfWnHPlwDnAYFoTe+8NfqEXKf9gqK6F1sjhEKeihojnMAwjJhHnemvZScMwDCNe8FaEuRE4ENgAlPdQgEro+M8BY51z+/fUMfegDymoH+soNOL8ZufcTdHqj2HEGmYpNAzDMPwsQKOoD+vh485HLb7RZAZ6bQs6a2gYiYhZCg3DMAxEZBw6RR/iQ+dcRbT60xt40dmH+KpWO+dWt9feMBINE4WGYRiGYRiGTR8bhmEYhmEYJgoNwzAMwzAMTBQahmEYhmEYmCg0DMMwDMMwMFFoGIZhGIZhYKLQMAzDMAzDAP4fKB5TcgIm23wAAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plt.style.use(ty.plots.styles('typhon'))\n",
-    "fig, ax = plt.subplots()\n",
-    "ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['sw_flxu'][-1, :],\n",
-    "                       label='SW Up', color='skyblue', ls='solid')\n",
-    "ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['sw_flxd'][-1, :],\n",
-    "                       label='SW Down', color='skyblue', ls='dashed')\n",
-    "ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['lw_flxu'][-1, :],\n",
-    "                       label='LW Up', color='orangered', ls='solid')\n",
-    "ty.plots.profile_p_log(atmosphere['phlev'], rrtmg['lw_flxd'][-1, :],\n",
-    "                       label='LW Down', color='orangered', ls='dashed')\n",
-    "ax.legend(loc='upper right')\n",
-    "ax.set_xlabel('Radiative flux [$\\sf W/m^2$]')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Plot radiative heating"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(-12.0, 12.0)"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Plot the calculated fluxes.\n",
-    "plt.style.use(ty.plots.styles('typhon'))\n",
-    "fig, ax = plt.subplots()\n",
-    "ax.axvline(0, color='black', linewidth=0.8)\n",
-    "ty.plots.profile_p_log(atmosphere['plev'], rrtmg['sw_htngrt'][-1, :],\n",
-    "                       label='SW', color='skyblue')\n",
-    "ty.plots.profile_p_log(atmosphere['plev'], rrtmg['lw_htngrt'][-1, :],\n",
-    "                       label='LW', color='orangered')\n",
-    "ax.legend(loc='upper right')\n",
-    "ax.set_xlabel('Radiative heating [K/day]')\n",
-    "ax.set_xlim(-12, 12)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.6.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
diff --git a/tutorials/simple_rce.ipynb b/tutorials/simple_rce.ipynb
deleted file mode 100644
index c775ebb8..00000000
--- a/tutorials/simple_rce.ipynb
+++ /dev/null
@@ -1,236 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Set up and run a radiative-convective equilibrium simulation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2020-08-28 10:56:12 MainProcess:INFO:root:Created Konrad object:\n",
-      "RCE(\n",
-      "    atmosphere=Atmosphere,\n",
-      "    radiation=RRTMG,\n",
-      "    ozone=OzonePressure,\n",
-      "    humidity=FixedRH,\n",
-      "    surface=SlabOcean,\n",
-      "    cloud=ClearSky,\n",
-      "    convection=HardAdjustment,\n",
-      "    lapserate=MoistLapseRate,\n",
-      "    upwelling=NoUpwelling,\n",
-      "    diurnal_cycle=False,\n",
-      "    timestep=16:00:00,\n",
-      "    time=0001-01-01 00:00:00,\n",
-      "    max_duration=6000 days, 0:00:00,\n",
-      "    niter=0,\n",
-      "    writeevery=1 day, 0:00:00,\n",
-      "    last_written=0001-01-01 00:00:00,\n",
-      "    logevery=100,\n",
-      "    delta=0.0,\n",
-      "    deltaT=None,\n",
-      "    converged=False,\n",
-      "    outfile=None,\n",
-      "    nchandler=None,\n",
-      "    experiment=RCE,\n",
-      "    co2_adjustment_timescale=nan,\n",
-      "    timestep_adjuster=None,\n",
-      ")\n",
-      "2020-08-28 10:56:12 MainProcess:INFO:konrad.core:Start RCE model run.\n",
-      "2020-08-28 10:56:12 MainProcess:INFO:konrad.core:Enter iteration 0.\n",
-      "2020-08-28 10:56:14 MainProcess:INFO:konrad.core:Enter iteration 100.\n",
-      "2020-08-28 10:56:17 MainProcess:INFO:konrad.core:Enter iteration 200.\n",
-      "2020-08-28 10:56:19 MainProcess:INFO:konrad.core:Enter iteration 300.\n",
-      "2020-08-28 10:56:21 MainProcess:INFO:konrad.core:Enter iteration 400.\n",
-      "2020-08-28 10:56:23 MainProcess:INFO:konrad.core:Enter iteration 500.\n",
-      "2020-08-28 10:56:25 MainProcess:INFO:konrad.core:Enter iteration 600.\n",
-      "2020-08-28 10:56:28 MainProcess:INFO:konrad.core:Enter iteration 700.\n",
-      "2020-08-28 10:56:30 MainProcess:INFO:konrad.core:Enter iteration 800.\n",
-      "2020-08-28 10:56:32 MainProcess:INFO:konrad.core:Enter iteration 900.\n",
-      "2020-08-28 10:56:34 MainProcess:INFO:konrad.core:Enter iteration 1000.\n",
-      "2020-08-28 10:56:37 MainProcess:INFO:konrad.core:Enter iteration 1100.\n",
-      "2020-08-28 10:56:39 MainProcess:INFO:konrad.core:Enter iteration 1200.\n",
-      "2020-08-28 10:56:41 MainProcess:INFO:konrad.core:Enter iteration 1300.\n",
-      "2020-08-28 10:56:43 MainProcess:INFO:konrad.core:Enter iteration 1400.\n",
-      "2020-08-28 10:56:46 MainProcess:INFO:konrad.core:Enter iteration 1500.\n",
-      "2020-08-28 10:56:48 MainProcess:INFO:konrad.core:Enter iteration 1600.\n",
-      "2020-08-28 10:56:50 MainProcess:INFO:konrad.core:Enter iteration 1700.\n",
-      "2020-08-28 10:56:52 MainProcess:INFO:konrad.core:Enter iteration 1800.\n",
-      "2020-08-28 10:56:54 MainProcess:INFO:konrad.core:Enter iteration 1900.\n",
-      "2020-08-28 10:56:56 MainProcess:INFO:konrad.core:Enter iteration 2000.\n",
-      "2020-08-28 10:56:59 MainProcess:INFO:konrad.core:Enter iteration 2100.\n",
-      "2020-08-28 10:57:01 MainProcess:INFO:konrad.core:Enter iteration 2200.\n",
-      "2020-08-28 10:57:03 MainProcess:INFO:konrad.core:Enter iteration 2300.\n",
-      "2020-08-28 10:57:05 MainProcess:INFO:konrad.core:Enter iteration 2400.\n",
-      "2020-08-28 10:57:07 MainProcess:INFO:konrad.core:Enter iteration 2500.\n",
-      "2020-08-28 10:57:10 MainProcess:INFO:konrad.core:Enter iteration 2600.\n",
-      "2020-08-28 10:57:12 MainProcess:INFO:konrad.core:Enter iteration 2700.\n",
-      "2020-08-28 10:57:14 MainProcess:INFO:konrad.core:Enter iteration 2800.\n",
-      "2020-08-28 10:57:17 MainProcess:INFO:konrad.core:Enter iteration 2900.\n",
-      "2020-08-28 10:57:19 MainProcess:INFO:konrad.core:Enter iteration 3000.\n",
-      "2020-08-28 10:57:22 MainProcess:INFO:konrad.core:Enter iteration 3100.\n",
-      "2020-08-28 10:57:24 MainProcess:INFO:konrad.core:Enter iteration 3200.\n",
-      "2020-08-28 10:57:26 MainProcess:INFO:konrad.core:Enter iteration 3300.\n",
-      "2020-08-28 10:57:28 MainProcess:INFO:konrad.core:Enter iteration 3400.\n",
-      "2020-08-28 10:57:31 MainProcess:INFO:konrad.core:Enter iteration 3500.\n",
-      "2020-08-28 10:57:33 MainProcess:INFO:konrad.core:Enter iteration 3600.\n",
-      "2020-08-28 10:57:35 MainProcess:INFO:konrad.core:Enter iteration 3700.\n",
-      "2020-08-28 10:57:37 MainProcess:INFO:konrad.core:Enter iteration 3800.\n",
-      "2020-08-28 10:57:40 MainProcess:INFO:konrad.core:Enter iteration 3900.\n",
-      "2020-08-28 10:57:42 MainProcess:INFO:konrad.core:Enter iteration 4000.\n",
-      "2020-08-28 10:57:44 MainProcess:INFO:konrad.core:Enter iteration 4100.\n",
-      "2020-08-28 10:57:47 MainProcess:INFO:konrad.core:Enter iteration 4200.\n",
-      "2020-08-28 10:57:49 MainProcess:INFO:konrad.core:Enter iteration 4300.\n",
-      "2020-08-28 10:57:51 MainProcess:INFO:konrad.core:Enter iteration 4400.\n",
-      "2020-08-28 10:57:53 MainProcess:INFO:konrad.core:Enter iteration 4500.\n",
-      "2020-08-28 10:57:55 MainProcess:INFO:konrad.core:Enter iteration 4600.\n",
-      "2020-08-28 10:57:58 MainProcess:INFO:konrad.core:Enter iteration 4700.\n",
-      "2020-08-28 10:58:00 MainProcess:INFO:konrad.core:Enter iteration 4800.\n",
-      "2020-08-28 10:58:02 MainProcess:INFO:konrad.core:Enter iteration 4900.\n",
-      "2020-08-28 10:58:04 MainProcess:INFO:konrad.core:Enter iteration 5000.\n",
-      "2020-08-28 10:58:07 MainProcess:INFO:konrad.core:Enter iteration 5100.\n",
-      "2020-08-28 10:58:09 MainProcess:INFO:konrad.core:Enter iteration 5200.\n",
-      "2020-08-28 10:58:11 MainProcess:INFO:konrad.core:Enter iteration 5300.\n",
-      "2020-08-28 10:58:13 MainProcess:INFO:konrad.core:Enter iteration 5400.\n",
-      "2020-08-28 10:58:16 MainProcess:INFO:konrad.core:Enter iteration 5500.\n",
-      "2020-08-28 10:58:18 MainProcess:INFO:konrad.core:Enter iteration 5600.\n",
-      "2020-08-28 10:58:20 MainProcess:INFO:konrad.core:Enter iteration 5700.\n",
-      "2020-08-28 10:58:22 MainProcess:INFO:konrad.core:Enter iteration 5800.\n",
-      "2020-08-28 10:58:24 MainProcess:INFO:konrad.core:Enter iteration 5900.\n",
-      "2020-08-28 10:58:27 MainProcess:INFO:konrad.core:Enter iteration 6000.\n",
-      "2020-08-28 10:58:29 MainProcess:INFO:konrad.core:Enter iteration 6100.\n",
-      "2020-08-28 10:58:31 MainProcess:INFO:konrad.core:Enter iteration 6200.\n",
-      "2020-08-28 10:58:33 MainProcess:INFO:konrad.core:Enter iteration 6300.\n",
-      "2020-08-28 10:58:35 MainProcess:INFO:konrad.core:Enter iteration 6400.\n",
-      "2020-08-28 10:58:37 MainProcess:INFO:konrad.core:Enter iteration 6500.\n",
-      "2020-08-28 10:58:40 MainProcess:INFO:konrad.core:Enter iteration 6600.\n",
-      "2020-08-28 10:58:42 MainProcess:INFO:konrad.core:Enter iteration 6700.\n",
-      "2020-08-28 10:58:44 MainProcess:INFO:konrad.core:Enter iteration 6800.\n",
-      "2020-08-28 10:58:46 MainProcess:INFO:konrad.core:Enter iteration 6900.\n",
-      "2020-08-28 10:58:48 MainProcess:INFO:konrad.core:Enter iteration 7000.\n",
-      "2020-08-28 10:58:51 MainProcess:INFO:konrad.core:Enter iteration 7100.\n",
-      "2020-08-28 10:58:53 MainProcess:INFO:konrad.core:Enter iteration 7200.\n",
-      "2020-08-28 10:58:55 MainProcess:INFO:konrad.core:Enter iteration 7300.\n",
-      "2020-08-28 10:58:57 MainProcess:INFO:konrad.core:Enter iteration 7400.\n",
-      "2020-08-28 10:58:59 MainProcess:INFO:konrad.core:Enter iteration 7500.\n",
-      "2020-08-28 10:59:01 MainProcess:INFO:konrad.core:Enter iteration 7600.\n",
-      "2020-08-28 10:59:03 MainProcess:INFO:konrad.core:Enter iteration 7700.\n",
-      "2020-08-28 10:59:06 MainProcess:INFO:konrad.core:Enter iteration 7800.\n",
-      "2020-08-28 10:59:08 MainProcess:INFO:konrad.core:Enter iteration 7900.\n",
-      "2020-08-28 10:59:10 MainProcess:INFO:konrad.core:Enter iteration 8000.\n",
-      "2020-08-28 10:59:12 MainProcess:INFO:konrad.core:Enter iteration 8100.\n",
-      "2020-08-28 10:59:14 MainProcess:INFO:konrad.core:Enter iteration 8200.\n",
-      "2020-08-28 10:59:16 MainProcess:INFO:konrad.core:Enter iteration 8300.\n",
-      "2020-08-28 10:59:18 MainProcess:INFO:konrad.core:Enter iteration 8400.\n",
-      "2020-08-28 10:59:21 MainProcess:INFO:konrad.core:Enter iteration 8500.\n",
-      "2020-08-28 10:59:23 MainProcess:INFO:konrad.core:Enter iteration 8600.\n",
-      "2020-08-28 10:59:25 MainProcess:INFO:konrad.core:Enter iteration 8700.\n",
-      "2020-08-28 10:59:27 MainProcess:INFO:konrad.core:Enter iteration 8800.\n",
-      "2020-08-28 10:59:29 MainProcess:INFO:konrad.core:Enter iteration 8900.\n",
-      "2020-08-28 10:59:31 MainProcess:INFO:konrad.core:Enter iteration 9000.\n",
-      "2020-08-28 10:59:31 MainProcess:INFO:konrad.core:Stop. Reached maximum runtime.\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x7f62109a01d0>"
-      ]
-     },
-     "execution_count": 1,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "%matplotlib inline\n",
-    "import matplotlib.pyplot as plt\n",
-    "from typhon import plots\n",
-    "\n",
-    "import konrad\n",
-    "\n",
-    "\n",
-    "konrad.enable_logging()\n",
-    "\n",
-    "plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 201)\n",
-    "\n",
-    "atmosphere = konrad.atmosphere.Atmosphere(phlev)\n",
-    "\n",
-    "atmosphere.tracegases_rcemip()  # Atmosphere composition according to RCEMIP.\n",
-    "\n",
-    "# Plot the initial temperature profile (for comparison).\n",
-    "plt.style.use(plots.styles('typhon'))\n",
-    "fig, ax = plt.subplots()\n",
-    "plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :], label='Initial state')\n",
-    "\n",
-    "# Initialize the setup for the radiative-convective equilibrium simulation.\n",
-    "rce = konrad.RCE(\n",
-    "    atmosphere,\n",
-    "    radiation=konrad.radiation.RRTMG(),  # Use RRTMG radiation scheme.\n",
-    "    humidity = konrad.humidity.FixedRH(rh_func=konrad.humidity.HeightConstant()), \n",
-    "                            #Add a relative humidity profile preserved under temperature changes\n",
-    "    convection=konrad.convection.HardAdjustment(),  # Perform a hard convective adjustment.\n",
-    "    lapserate=konrad.lapserate.MoistLapseRate(),  # Adjust towards a moist adiabat.\n",
-    "    timestep='16h',  # Set timestep in model time.\n",
-    "    max_duration='6000d',  # Set maximum runtime.\n",
-    "    logevery=100,  # Print progression of model run\n",
-    ")\n",
-    "rce.run()  # Start the simulation.\n",
-    "\n",
-    "# Plot the equilibrium temperature profile.\n",
-    "plots.profile_p_log(atmosphere['plev'], atmosphere['T'][-1, :], label='RCE')\n",
-    "ax.legend()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.6.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}
\ No newline at end of file
diff --git a/tutorials/venus_rce.ipynb b/tutorials/venus_rce.ipynb
deleted file mode 100644
index 4839e1f2..00000000
--- a/tutorials/venus_rce.ipynb
+++ /dev/null
@@ -1,274 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "%matplotlib inline\n",
-    "import netCDF4\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "import matplotlib as mpl\n",
-    "import typhon as ty\n",
-    "\n",
-    "import konrad\n",
-    "\n",
-    "\n",
-    "konrad.enable_logging()"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2020-08-28 10:53:38 MainProcess:INFO:root:Created Konrad object:\n",
-      "RCE(\n",
-      "    atmosphere=Atmosphere,\n",
-      "    radiation=RRTMGVenus,\n",
-      "    ozone=OzonePressure,\n",
-      "    humidity=FixedVMR,\n",
-      "    surface=SlabOcean,\n",
-      "    cloud=ClearSky,\n",
-      "    convection=NonConvective,\n",
-      "    lapserate=MoistLapseRate,\n",
-      "    upwelling=NoUpwelling,\n",
-      "    diurnal_cycle=False,\n",
-      "    timestep=2:00:00,\n",
-      "    time=0001-01-01 00:00:00,\n",
-      "    max_duration=400 days, 0:00:00,\n",
-      "    niter=0,\n",
-      "    writeevery=1 day, 0:00:00,\n",
-      "    last_written=0001-01-01 00:00:00,\n",
-      "    logevery=100,\n",
-      "    delta=0,\n",
-      "    deltaT=None,\n",
-      "    converged=False,\n",
-      "    outfile=None,\n",
-      "    nchandler=None,\n",
-      "    experiment=RCE,\n",
-      "    co2_adjustment_timescale=nan,\n",
-      "    timestep_adjuster=None,\n",
-      ")\n",
-      "2020-08-28 10:53:38 MainProcess:INFO:konrad.core:Start RCE model run.\n",
-      "2020-08-28 10:53:38 MainProcess:INFO:konrad.core:Enter iteration 0.\n",
-      "2020-08-28 10:53:40 MainProcess:INFO:konrad.core:Enter iteration 100.\n",
-      "2020-08-28 10:53:42 MainProcess:INFO:konrad.core:Enter iteration 200.\n",
-      "2020-08-28 10:53:45 MainProcess:INFO:konrad.core:Enter iteration 300.\n",
-      "2020-08-28 10:53:47 MainProcess:INFO:konrad.core:Enter iteration 400.\n",
-      "2020-08-28 10:53:49 MainProcess:INFO:konrad.core:Enter iteration 500.\n",
-      "2020-08-28 10:53:51 MainProcess:INFO:konrad.core:Enter iteration 600.\n",
-      "2020-08-28 10:53:53 MainProcess:INFO:konrad.core:Enter iteration 700.\n",
-      "2020-08-28 10:53:55 MainProcess:INFO:konrad.core:Enter iteration 800.\n",
-      "2020-08-28 10:53:57 MainProcess:INFO:konrad.core:Enter iteration 900.\n",
-      "2020-08-28 10:53:59 MainProcess:INFO:konrad.core:Enter iteration 1000.\n",
-      "2020-08-28 10:54:01 MainProcess:INFO:konrad.core:Enter iteration 1100.\n",
-      "2020-08-28 10:54:03 MainProcess:INFO:konrad.core:Enter iteration 1200.\n",
-      "2020-08-28 10:54:05 MainProcess:INFO:konrad.core:Enter iteration 1300.\n",
-      "2020-08-28 10:54:07 MainProcess:INFO:konrad.core:Enter iteration 1400.\n",
-      "2020-08-28 10:54:09 MainProcess:INFO:konrad.core:Enter iteration 1500.\n",
-      "2020-08-28 10:54:11 MainProcess:INFO:konrad.core:Enter iteration 1600.\n",
-      "2020-08-28 10:54:13 MainProcess:INFO:konrad.core:Enter iteration 1700.\n",
-      "2020-08-28 10:54:15 MainProcess:INFO:konrad.core:Enter iteration 1800.\n",
-      "2020-08-28 10:54:17 MainProcess:INFO:konrad.core:Enter iteration 1900.\n",
-      "2020-08-28 10:54:19 MainProcess:INFO:konrad.core:Enter iteration 2000.\n",
-      "2020-08-28 10:54:21 MainProcess:INFO:konrad.core:Enter iteration 2100.\n",
-      "2020-08-28 10:54:23 MainProcess:INFO:konrad.core:Enter iteration 2200.\n",
-      "2020-08-28 10:54:25 MainProcess:INFO:konrad.core:Enter iteration 2300.\n",
-      "2020-08-28 10:54:27 MainProcess:INFO:konrad.core:Enter iteration 2400.\n",
-      "2020-08-28 10:54:29 MainProcess:INFO:konrad.core:Enter iteration 2500.\n",
-      "2020-08-28 10:54:31 MainProcess:INFO:konrad.core:Enter iteration 2600.\n",
-      "2020-08-28 10:54:34 MainProcess:INFO:konrad.core:Enter iteration 2700.\n",
-      "2020-08-28 10:54:36 MainProcess:INFO:konrad.core:Enter iteration 2800.\n",
-      "2020-08-28 10:54:38 MainProcess:INFO:konrad.core:Enter iteration 2900.\n",
-      "2020-08-28 10:54:40 MainProcess:INFO:konrad.core:Enter iteration 3000.\n",
-      "2020-08-28 10:54:42 MainProcess:INFO:konrad.core:Enter iteration 3100.\n",
-      "2020-08-28 10:54:44 MainProcess:INFO:konrad.core:Enter iteration 3200.\n",
-      "2020-08-28 10:54:46 MainProcess:INFO:konrad.core:Enter iteration 3300.\n",
-      "2020-08-28 10:54:48 MainProcess:INFO:konrad.core:Enter iteration 3400.\n",
-      "2020-08-28 10:54:50 MainProcess:INFO:konrad.core:Enter iteration 3500.\n",
-      "2020-08-28 10:54:52 MainProcess:INFO:konrad.core:Enter iteration 3600.\n",
-      "2020-08-28 10:54:55 MainProcess:INFO:konrad.core:Enter iteration 3700.\n",
-      "2020-08-28 10:54:57 MainProcess:INFO:konrad.core:Enter iteration 3800.\n",
-      "2020-08-28 10:54:59 MainProcess:INFO:konrad.core:Enter iteration 3900.\n",
-      "2020-08-28 10:55:01 MainProcess:INFO:konrad.core:Enter iteration 4000.\n",
-      "2020-08-28 10:55:04 MainProcess:INFO:konrad.core:Enter iteration 4100.\n",
-      "2020-08-28 10:55:06 MainProcess:INFO:konrad.core:Enter iteration 4200.\n",
-      "2020-08-28 10:55:08 MainProcess:INFO:konrad.core:Enter iteration 4300.\n",
-      "2020-08-28 10:55:10 MainProcess:INFO:konrad.core:Enter iteration 4400.\n",
-      "2020-08-28 10:55:12 MainProcess:INFO:konrad.core:Enter iteration 4500.\n",
-      "2020-08-28 10:55:14 MainProcess:INFO:konrad.core:Enter iteration 4600.\n",
-      "2020-08-28 10:55:16 MainProcess:INFO:konrad.core:Enter iteration 4700.\n",
-      "2020-08-28 10:55:18 MainProcess:INFO:konrad.core:Enter iteration 4800.\n",
-      "2020-08-28 10:55:18 MainProcess:INFO:konrad.core:Stop. Reached maximum runtime.\n"
-     ]
-    }
-   ],
-   "source": [
-    "class RRTMGVenus(konrad.radiation.RRTMG):\n",
-    "    \"\"\"Simple representation of radiative transfer on Venus.\n",
-    "    \n",
-    "    For the longwave radiation, the RRTMG simulations are used.\n",
-    "    The shortwave radiation is represented using\n",
-    "    a simple mathematical formulation.\n",
-    "    \"\"\"\n",
-    "    def derive_diagnostics(self):\n",
-    "        \"\"\"Derive diagnostic variables from radiative transfer results.\"\"\"\n",
-    "        def solar_flux(p, k=10, S0=self.solar_constant):\n",
-    "            return S0 * np.exp(-k * p / p[0])\n",
-    "\n",
-    "        def heating_rates(p, **kwargs):\n",
-    "            g = 10\n",
-    "            cp = 850\n",
-    "            secs_in_a_day = 60 * 60 * 24\n",
-    "\n",
-    "            F = solar_flux(p, **kwargs)\n",
-    "\n",
-    "            return g / cp * -np.diff(F) / np.diff(p) * secs_in_a_day\n",
-    "\n",
-    "        sw_flxd = solar_flux(self['phlev'])\n",
-    "        Q_sw = heating_rates(self['phlev'])\n",
-    "\n",
-    "        self['sw_htngrt'][-1, :] = Q_sw\n",
-    "        self['sw_flxd'][-1, :] = sw_flxd\n",
-    "        self['sw_flxu'][-1, :] = np.zeros_like(sw_flxd)\n",
-    "\n",
-    "        # Net heating rate.\n",
-    "        self['net_htngrt'] = self['lw_htngrt'] + self['sw_htngrt']\n",
-    "\n",
-    "        # Radiation budget at top of the atmosphere (TOA).\n",
-    "        self['toa'] = (\n",
-    "                (self['sw_flxd'][:, -1] + self['lw_flxd'][:, -1]) -\n",
-    "                (self['sw_flxu'][:, -1] + self['lw_flxu'][:, -1])\n",
-    "        )\n",
-    "\n",
-    "\n",
-    "# Create an atmosphere model.\n",
-    "plev, phlev = konrad.utils.get_pressure_grids(1000e2, 1, 201)\n",
-    "atmosphere = konrad.atmosphere.Atmosphere(plev)\n",
-    "\n",
-    "# Atmosphere composition corresponding to Venus.\n",
-    "for var in atmosphere.atmosphere_variables:\n",
-    "    if var != 'T':\n",
-    "        atmosphere[var][:] = 0\n",
-    "atmosphere['CO2'][:] = 0.999\n",
-    "\n",
-    "# Compile the RCE setup.\n",
-    "rce = konrad.RCE(\n",
-    "    atmosphere=atmosphere,\n",
-    "    humidity=konrad.humidity.FixedVMR(),\n",
-    "    radiation=RRTMGVenus(solar_constant=170, zenith_angle=0),\n",
-    "    surface=konrad.surface.SlabOcean(albedo=0.7, depth=1., heat_sink=0.),\n",
-    "    convection=konrad.convection.NonConvective(),\n",
-    "    cloud=konrad.cloud.ClearSky(numlevels=atmosphere['plev'].size),\n",
-    "    delta=0,\n",
-    "    timestep='2h',\n",
-    "    max_duration='400d',\n",
-    "    logevery=100,\n",
-    ")\n",
-    "rce.run()  # Start the simulation."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "(97155.94258793582, 5.0)"
-      ]
-     },
-     "execution_count": 3,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x444.96 with 3 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "plev = rce.atmosphere['plev'][:]\n",
-    "phlev = rce.atmosphere['phlev'][:]\n",
-    "T = rce.atmosphere['T'][-1, :]\n",
-    "sw_htngrt = rce.radiation['sw_htngrt'][-1, :]\n",
-    "lw_htngrt = rce.radiation['lw_htngrt'][-1, :]\n",
-    "sw_flxd = rce.radiation['sw_flxd'][-1, :]\n",
-    "lw_flxu = rce.radiation['lw_flxu'][-1, :]\n",
-    "    \n",
-    "plt.style.use(ty.plots.styles('typhon'))\n",
-    "fig, [ax0, ax1, ax2] = plt.subplots(ncols=3, sharey=True)\n",
-    "ty.plots.profile_p_log(plev, T, ax=ax0, color='C3')\n",
-    "ax0.set_ylim(plev.max(), plev.min())\n",
-    "ax0.set_xlabel('Temperature [K]')\n",
-    "ax0.set_xticks(np.round([T.max(), T[0]]))\n",
-    "ax0.grid(True, axis='x')\n",
-    "\n",
-    "ty.plots.profile_p_log(phlev, sw_flxd, color='C1', label='SW↓', ax=ax1)\n",
-    "ty.plots.profile_p_log(phlev, lw_flxu, color='C0', label='LW↑', ax=ax1)\n",
-    "ax1.legend(loc='upper right', fontsize='x-small')\n",
-    "ax1.set_ylim(plev.max(), plev.min())\n",
-    "ax1.set_xlabel('F [$\\sf Wm^{-2}$]')\n",
-    "ax1.set_xticks(np.round([0, sw_flxd.max(), lw_flxu.max()]))\n",
-    "ax1.grid(True, axis='x')\n",
-    "\n",
-    "ty.plots.profile_p_log(plev, sw_htngrt, color='C1', label='SW', ax=ax2)\n",
-    "ty.plots.profile_p_log(plev, lw_htngrt, color='C0', label='LW', ax=ax2)\n",
-    "ax2.legend(loc='upper right', fontsize='x-small')\n",
-    "ax2.set_ylim(plev.max(), plev.min())\n",
-    "ax2.set_xlabel('Q [K/day]')\n",
-    "ax2.set_xticks(np.round([0, sw_htngrt.max(), lw_htngrt.min()]))\n",
-    "ax2.grid(True, axis='x')\n",
-    "ax2.xaxis.set_major_formatter(mpl.ticker.StrMethodFormatter('{x:.0f}'))\n",
-    "\n",
-    "ax2.set_ylim(top=0.05e2)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "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.6.9"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
-}


Test patch:
diff --git a/konrad/test/test_atmosphere.py b/konrad/test/test_atmosphere.py
index d170a370..ccf9bfcd 100644
--- a/konrad/test/test_atmosphere.py
+++ b/konrad/test/test_atmosphere.py
@@ -1,9 +1,9 @@
-from os.path import (dirname, join)
+from os.path import dirname, join
 
 import numpy as np
 import pytest
 
-from konrad import (atmosphere, utils)
+from konrad import atmosphere, utils
 
 
 @pytest.fixture
@@ -40,7 +40,7 @@ def test_triple_point_plev(self, atmosphere_obj):
 
     def test_from_netcdf(self):
         """Test initialisation from netCDF file."""
-        ncfile = join(self.ref_dir, 'reference.nc')
+        ncfile = join(self.ref_dir, "reference.nc")
         atmosphere.Atmosphere.from_netcdf(ncfile)
 
     def test_from_netcdf_invalid_input(self):
@@ -49,12 +49,11 @@ def test_from_netcdf_invalid_input(self):
         # arguments to the ``from_*`` classmethods. This lead to unexpected
         # behaviour during initialisation.
         with pytest.raises(TypeError):
-            atmosphere.Atmosphere.from_netcdf('dummy.nc', surface=None)
+            atmosphere.Atmosphere.from_netcdf("dummy.nc", surface=None)
 
     def test_refine_plev(self, atmosphere_obj):
         """Test refinement of pressure grid."""
         phlev = np.array([1000e2, 500e2, 10e2])
         atmosphere_new = atmosphere_obj.refine_plev(phlev=phlev)
 
-        #TODO Add a proper test of values
-
+        # TODO Add a proper test of values
diff --git a/konrad/test/test_relative-humidity.py b/konrad/test/test_relative-humidity.py
index b5d6a8a3..6f0a16c4 100644
--- a/konrad/test/test_relative-humidity.py
+++ b/konrad/test/test_relative-humidity.py
@@ -1,9 +1,9 @@
-from os.path import (dirname, join)
+from os.path import dirname, join
 
 import numpy as np
 import pytest
 
-from konrad import (atmosphere, utils, humidity)
+from konrad import atmosphere, utils, humidity
 
 
 @pytest.fixture
@@ -16,16 +16,12 @@ def atmosphere_obj():
 class TestRelativeHumidity:
     rh_models = (
         humidity.CacheFromAtmosphere,
-        humidity.HeightConstant,
         humidity.VerticallyUniform,
-        humidity.ConstantFreezingLevel,
-        humidity.FixedUTH,
-        humidity.CoupledUTH,
-        humidity.CshapeConstant,
-        humidity.CshapeDecrease,
         humidity.Manabe67,
         humidity.Cess76,
         humidity.Romps14,
+        humidity.PolynomialCshapedRH,
+        humidity.PerturbProfile,
     )
 
     @pytest.mark.parametrize("rh_model", rh_models)