fabm0d: ERSEM in an aquarium

FABM’s 0d driver allows you to run biogeochemical models in a “well-mixed box” under arbitrary (time-varying) environmental forcing.

Running FABM0d tutorial

To run the model, you must first obtain or generate a set of input or forcing files. Setups for the L4 site are stored under version control and can be accessed here.

To run the tutorial, you will first need to clone the configuration files and then run FABM0d. This is done with the following:

#!/bin/bash

echo "Cloning config repo"
git clone https://github.com/pmlmodelling/ersem-setups.git

cd ersem-setups/0d-aquarium

echo "Running FABM with repo configuration"
~/local/fabm/0d/bin/fabm0d -y ../L4/fabm.yaml

Note

The following script requires matplotlib, netCDF and numpy to be installed. This can easily be done via pip in the following way:

python -m pip install matplotlib numpy netCDF

To visualise the results, we again use a python script. Running the script you will need to add a commandline argument --model-path which is the path to the output from the FABM0d run.

import argparse
import matplotlib.pylab as plt
from matplotlib import ticker
import numpy as np
import datetime
import re
import sys


try:
    import netCDF4 as nc
except ImportError:
    print("Please install the Python interface to netCDF")
    sys.exit()


def main(model_path):
    """
    Run FABM0D-ERSEM tutorial

    :param model_path: Full path to netCDF model output
    :type model_path: str

    :return: Dictionary containing output model variables for systests
    :rtype: dict
    """
    # Dictionary used to save input and output variables for testing
    test_vars = {}
    def plot_var(axes, x, y, label):
        # sets the maximum number of labels on the x axis to be 10
        xticks = ticker.MaxNLocator(10)

        var = data.variables[label]
        y = var[:].squeeze()

        long_label = '{} ({})'.format(var.long_name, var.units)
        y_label = re.sub(r'(\s\S*?)\s', r'\1\n',long_label)

        axes.plot(x, y)
        axes.set_ylabel(y_label)
        axes.xaxis.set_major_locator(xticks)
        test_vars[label] = y


    data = nc.Dataset(model_path, 'r')

    times = data.variables['time']
    dates = nc.num2date(times[:],
                        units=times.units,
                        calendar=times.calendar)
    dates = [str(d).split(" ")[0] for d in dates]
    test_vars["dates"] = dates

    # Plotting input data
    input_data = ["light_parEIR", "temp", "salt"]
    fig, ax_arr = plt.subplots(len(input_data), 1)
    DPI = fig.get_dpi()
    fig.set_size_inches(1200.0/float(DPI),800.0/float(DPI))
    for ax, label in zip(ax_arr, input_data):
        plot_var(ax, dates, data, label)
    fig.suptitle("Input data")

    # Plotting output data
    output_data = ["N1_p", "N3_n", "B1_c", "P2_c"]
    fig, ax_arr = plt.subplots(len(input_data), 1)
    DPI = fig.get_dpi()
    fig.set_size_inches(1200.0/float(DPI),800.0/float(DPI))
    for ax, label in zip(ax_arr, output_data):
        plot_var(ax, dates, data, label)
    fig.suptitle("Output data")
    plt.show()

    return test_vars

if __name__ == "__main__":

    parser = argparse.ArgumentParser()
    parser.add_argument('-p', '--model-path', type=str, required=True,
                        help='Path to FABM0D-ERSEM output')
    args, _ = parser.parse_known_args()
    model_path = args.model_path

    main(model_path)