diff --git a/README.md b/README.md
index 9a392174ed7d7bbd2b30dc93427238bad9008000..9658342d5da2aab99ec4e91413c07b973117f44b 100644
--- a/README.md
+++ b/README.md
@@ -6,16 +6,19 @@ Visualization of the mean ozon concentration per grid cell on the 3rd January 20
 
 # About 
 
-The TOARgridding projects data from the TOAR database (https://toar-data.fz-juelich.de/) onto a grid. 
-The request to the database includes a statistical analysis of the requested value.
-The mean and standard deviation of all stations within a cell are computed. 
+The TOARgridding tool projects data from the TOAR-II database (https://toar-data.fz-juelich.de/) onto a grid. 
+The user can select the
+- variable, 
+- statistical aggregation,
+- temporal extends,
+- equidistant rectangular lat-lon grid of custom resolution,
+- and (optional) filtering according to the station metadata.
 
 This tool handles the request to the database over the REST API and the subsequent processing.
 The results of the gridding are provided as [xarray datasets](https://docs.xarray.dev/en/stable/generated/xarray.Dataset.html) for subsequent processing and visualization by the user.
 While this project provides ready to use examples, it is intended as a library to be used in dedicated analysis scripts. Furthermore, the long term goal is to provide the gridding as a service over a RESTful API.
 
-This project is in beta with the intended basic functionalities. 
-The documentation and this README are work in progress.
+This project is in beta with the intended basic functionalities.
 
 # Table of Content
 
@@ -24,7 +27,7 @@ The documentation and this README are work in progress.
 # Requirements
 
 This project requires python 3.10 or higher.
-TBD, see pyproject.toml
+For more information see pyproject.toml.
 
 This package relies on [netCDF](https://www.unidata.ucar.edu/software/netcdf/) and [HDF5](https://www.hdfgroup.org/) for saving data. You might need to install those as dependencies on your operation system.
 
@@ -34,7 +37,7 @@ The visualization on a map in one example relies on [cartopy](https://scitools.o
 # Installation
 
 Move to the folder you want to download this project to.
-We now need to download the source code from the [repository](https://gitlab.jsc.fz-juelich.de/esde/toar-public/toargridding/-/tree/dev?ref_type=heads) either as ZIP file or via git:
+We now need to download the source code from the [repository](https://gitlab.jsc.fz-juelich.de/esde/toar-public/toargridding/) either as ZIP file or via git:
 
 ## 1) Download with GIT
 Clone the project from its git repository:
@@ -95,13 +98,13 @@ After activating the virtual environment the notebooks can be run by calling
 ```
 as pointed out previously.
 
-## Retrieving data and visualization
+## 00: Retrieving data and visualization
 ```bash
  jupyter notebook examples/00_download_and_visualization.ipynb
 ```
-The aim of this first example is the creation of a gridded dataset and the visualization of one data point.
-For the visualization, cartopy is required, which requires dependencies, which might not be installed by `pip`. If you are experiencing any issues, do not hesitate to continue with the next examples.
-If you are still curious for the results, we have uploaded the resulting map as title image of our readme.
+The aim of this first example is the creation of a gridded dataset and the visualization of one time point.
+For the visualization, `cartopy` is required, which might need dependencies, that might not be installed by `pip`. If you are experiencing any issues, do not hesitate to continue with the next examples.
+If you are still curious for the results, we have uploaded the resulting map as title image of this README.
 
 ## 01: Retrieval of one week:
 ```bash
@@ -110,7 +113,7 @@ jupyter notebook examples/01_produce_data_one_week.ipynb
 As a first example we want to download data for ozon covering one week. We calculate the daily mean from each station before combining the results to a grid with a lateral resolution of about 1.9° and a longitudinal resolution of 2.5°.
 The results are saved as [netCDF files](https://docs.xarray.dev/en/stable/user-guide/io.html).
 
-As the gridding is done offline, it will be executed for already downloaded files, whenever the notebook is rerun. Please note, that the file name for the gridded data also contains the date of creation.
+As the gridding is done offline, it will be executed for already downloaded files, whenever the notebook is rerun. Please note, that the file name for the gridded data also contains the date of creation. Therefore you might end up with several copies.
 
 ## 02: Retrieval of several years:
 ```bash
@@ -120,7 +123,7 @@ This notebook provides an example on how to download data, apply gridding and sa
 The AnalysisServiceDownload caches already obtained data on the local machine.
 This allows different grids without the necessity to repeat the request to the TOARDB, the statistical analysis and the subsequent download.
 
-As an example we calculated *dma8epa_strict* on a daily basis for the years 2000 to 2018 for all timeseries in the TOAR database.
+As an example we calculated *dma8epa_strict* on a daily basis for the years 2000 to 2001 for all timeseries in the TOAR database.
 The first attempt for this example covered the full range of 19 years in a single request. It turned out, that an extraction year by year is more reliable. 
 The subsequent requests function as a progress report and allow working with the data, while further requests are processed.
 
diff --git a/developer_notebooks/produce_data_many_years_withOptional.ipynb b/developer_notebooks/produce_data_many_years_withOptional.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..0691d81c8973eccfa3e76b1d279b2a60c81f53b9
--- /dev/null
+++ b/developer_notebooks/produce_data_many_years_withOptional.ipynb
@@ -0,0 +1,199 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Example with optional parameters\n",
+    "Toargridding has a number of required arguments for a dataset. Those include the time range, variable and statistical analysis. The TAOR-DB has a large number of metadata fileds that can be used to further refine this request.\n",
+    "A python dictionary can be provided to include theses other fields. The analysis service provides an error message, if the requested parameters does not exist (check for typos) or if the provided value is wrong.\n",
+    "\n",
+    "In this example we want to obtain data from 2000 to 2018 (maybe change this, if you want your results faster:-)).\n",
+    "\n",
+    "The fist block contains the includes and the setup of the logging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from datetime import datetime as dt\n",
+    "from collections import namedtuple\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from toargridding.toar_rest_client import AnalysisServiceDownload, Connection\n",
+    "from toargridding.grids import RegularGrid\n",
+    "from toargridding.gridding import get_gridded_toar_data\n",
+    "from toargridding.metadata import TimeSample"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now want to include packages for logging. We want so see some output in the shell, we want to log exceptions and we maybe want to have a logfile to review everything later:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import logging\n",
+    "from toargridding.defaultLogging import toargridding_defaultLogging\n",
+    "\n",
+    "#setup of logging\n",
+    "logger = toargridding_defaultLogging()\n",
+    "logger.addShellLogger(logging.DEBUG)\n",
+    "logger.logExceptions()\n",
+    "logger.addRotatingLogFile(Path(\"log/produce_data_withOptional.log\"))#we need to explicitly set a logfile\n",
+    "#logger.addSysLogger(logging.DEBUG)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Preparation of requests\n",
+    "in the next block we prepare the request to the analysis service.\n",
+    "The dictionary details4Query adds additional requirements to the request. Here, the two fields *toar1_category* and *type_of_area* are used. Both stand for a classification of stations depending on the surrounding area. It is advised to use only one at once. \n",
+    "\n",
+    "\n",
+    "moreOptions is implemented as a dict to add additional arguments to the query to the REST API\n",
+    "For example the field *toar1_category* with its possible values Urban, RuralLowElevation, RuralHighElevation and Unclassified can be added \n",
+    "(see page 18 in https://toar-data.fz-juelich.de/sphinx/TOAR_UG_Vol03_Database/build/latex/toardatabase--userguide.pdf).\n",
+    "Or *type_of_area* with urban, suburban and rural on page 20 can be used.\n",
+    "\n",
+    "There are a many more metadata available in the user guide, feel free to look around."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#creation of request.\n",
+    "# helper to keep the configuration together\n",
+    "Config = namedtuple(\"Config\", [\"grid\", \"time\", \"variables\", \"stats\",\"moreOptions\"])\n",
+    "\n",
+    "#uncomment, what you want to test:-)\n",
+    "details4Query ={\n",
+    "    #\"toar1_category\" : \"Urban\" #uncomment if wished:-)\n",
+    "    #\"toar1_category\" : \"RuralLowElevation\" #uncomment if wished:-)\n",
+    "    #\"toar1_category\" : \"RuralHighElevation\" #uncomment if wished:-)\n",
+    "    #\"type_of_area\" : \"Urban\" #also test Rural, Suburban,\n",
+    "    \"type_of_area\" : \"Rural\" #also test Rural, Suburban,\n",
+    "    #\"type_of_area\" : \"Suburban\" #also test Rural, Suburban,\n",
+    "}\n",
+    "\n",
+    "#a regular grid with 1.9°x2.5° resolution. A warning will be issued as 1.9° does not result in  natural number of grid cells.\n",
+    "grid = RegularGrid( lat_resolution=1.9, lon_resolution=2.5, )\n",
+    "\n",
+    "configs = dict()\n",
+    "\n",
+    "# we split the request into one request per year.\n",
+    "for year in range(0,19):\n",
+    "    valid_data = Config(\n",
+    "        grid,\n",
+    "        TimeSample( start=dt(2000+year,1,1), end=dt(2000+year,12,31), sampling=\"daily\"),#possibly adopt range:-)\n",
+    "        #TimeSample( start=dt(2000+year,1,1), end=dt(2000+year,12,31), sampling=\"monthly\"),#possibly adopt range:-)\n",
+    "        [\"mole_fraction_of_ozone_in_air\"],#variable name\n",
+    "        #[ \"mean\", \"dma8epax\"],# will start one request after another other...\n",
+    "        [ \"mean\" ],\n",
+    "        details4Query\n",
+    "    )\n",
+    "    \n",
+    "    configs[f\"test_ta{year}\"] = valid_data\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now need to setup the out connection to the analysis service of the TOAR database. We also setup directories to store the data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stats_endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
+    "cache_basepath = Path(\"cache\")\n",
+    "result_basepath = Path(\"results\")\n",
+    "cache_basepath.mkdir(exist_ok=True)\n",
+    "result_basepath.mkdir(exist_ok=True)\n",
+    "analysis_service = AnalysisServiceDownload(stats_endpoint=stats_endpoint, cache_dir=cache_basepath, sample_dir=result_basepath, use_downloaded=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Download and gridding:\n",
+    "Now we come to the last step: we want to download the data, process them and store them to disc.\n",
+    "\n",
+    "CAVE: this cell runs about 45minutes per requested year. therefore we increase the waiting duration to 1h per request.\n",
+    "the processing is done on the server of the TOAR database.\n",
+    "A restart of the cell continues the request to the REST API. Data are cached on the local computer to prevent repetitive downloads.\n",
+    "The download can also take a few minutes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# maybe adopt the interval for requesting the results and the total duration, before the client pauses the requests.\n",
+    "# as the requests take about 45min, it is more suitable to wait 60min before timing out the requests than the original 30min.\n",
+    "analysis_service.connection.set_request_times(interval_min=5, max_wait_minutes=60)\n",
+    "\n",
+    "for person, config in configs.items():\n",
+    "    print(f\"\\nProcessing {person}:\")\n",
+    "    print(f\"--------------------\")\n",
+    "    datasets, metadatas = get_gridded_toar_data(\n",
+    "        analysis_service=analysis_service,\n",
+    "        grid=config.grid,\n",
+    "        time=config.time,\n",
+    "        variables=config.variables,\n",
+    "        stats=config.stats,\n",
+    "        contributors_path=result_basepath,\n",
+    "        **config.moreOptions\n",
+    "    )\n",
+    "\n",
+    "    for dataset, metadata in zip(datasets, metadatas):\n",
+    "        dataset.to_netcdf(result_basepath / f\"{metadata.get_id()}_{config.grid.get_id()}.nc\")\n",
+    "        print(metadata.get_id())"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "toargridding-8RVrxzmn-py3.11",
+   "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.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/00_download_and_visualization.ipynb b/examples/00_download_and_visualization.ipynb
index d81d8dc25588575f54f21b42d8e52356fa657523..80a9f2ff766b15e7ff8a5ef9a66d6c09c0cd5fd5 100644
--- a/examples/00_download_and_visualization.ipynb
+++ b/examples/00_download_and_visualization.ipynb
@@ -6,29 +6,21 @@
    "source": [
     "### Get Dataset from request\n",
     "\n",
-    "This cell imports all required packages and sets up the logging as well as the required information for the requests to the TOAR-DB."
+    "This cell imports all required packages and sets up the logging as well as the required information for the requests to the TOAR-DB.\n",
+    "\n",
+    "We will receive a warning as the lateral resolution of 1.9° does not result in a natural number of cells. Therefore, it is slightly adopted."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-09-12 10:49:49 [WARNING] - variables.py:103: 'Resolution 1.9 does not provide an equidistant division of the span [-90,90]'\n",
-      "2024-09-12 10:49:49 [WARNING] - variables.py:108: 'Adoption resolution 1.9 to 1.894736842105263'\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from datetime import datetime as dt\n",
     "from pathlib import Path\n",
     "\n",
     "import pandas as pd\n",
-    "import numpy as np\n",
     "\n",
     "from toargridding.grids import RegularGrid\n",
     "from toargridding.toar_rest_client import (\n",
@@ -41,69 +33,133 @@
     "\n",
     "from toargridding.contributors import contributions_manager_by_id\n",
     "\n",
-    "import logging\n",
+    "import logging\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Setup of logging\n",
+    "\n",
+    "In the next step we setup the logging, i.e. the level of information that is displayed as output. \n",
+    "\n",
+    "We start with a default setup and restrict the output to information and more critical output like warnings and errors."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "from toargridding.defaultLogging import toargridding_defaultLogging\n",
-    "#setup of logging\n",
+    "\n",
     "logger = toargridding_defaultLogging()\n",
-    "logger.addShellLogger(logging.DEBUG)\n",
-    "logger.logExceptions()\n",
+    "logger.addShellLogger(logging.INFO)\n",
+    "logger.logExceptions()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### selection of data and grid:\n",
+    "We need to select a temporal aggregation by selecting one week of data with a daily sampling.\n",
+    "With this sampling we define our metadata for the request. As variable we select ozone and as statistical aggregation a mean. \n",
+    "\n",
+    "The last step is the definition of the grid. We select a resolution of 2° in latitude and 2.5° in longitude."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "time = TimeSample(dt(2016,1,1), dt(2016,1,8), \"daily\")\n",
+    "metadata = Metadata.construct(\"mole_fraction_of_ozone_in_air\", time, \"mean\")\n",
+    "my_grid = RegularGrid(2.0, 2.5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Setting up the analysis\n",
+    "\n",
+    "We need to prepare our connection to the analysis service of the toar database, which will provide us with temporal and statistical aggregated data. \n",
+    "Besides the url of the service, we also need to setup two directories on our computer:\n",
+    "- one to save the data provided by the analysis service (called cache)\n",
+    "- a second to store our gridded dataset (called results)\n",
+    "Those will be found in the directory examples/cache and examples/results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
     "endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
-    "#starts in directory [path/to/toargridding]/tests\n",
-    "#maybe adopt the toargridding_base_path for your machine.\n",
+    "#starts in directory [path/to/toargridding]/examples\n",
     "toargridding_base_path = Path(\".\")\n",
     "cache_dir = toargridding_base_path / \"cache\"\n",
     "data_download_dir = toargridding_base_path / \"results\"\n",
     "\n",
     "cache_dir.mkdir(exist_ok=True)\n",
     "data_download_dir.mkdir(exist_ok=True)\n",
-    "analysis_service = AnalysisServiceDownload(endpoint, cache_dir, data_download_dir, use_downloaded=True)\n",
-    "my_grid = RegularGrid(1.9, 2.5)\n",
-    "\n",
-    "time = TimeSample(dt(2016,1,1), dt(2016,2,28), \"daily\")\n",
-    "metadata = Metadata.construct(\"mole_fraction_of_ozone_in_air\", time, \"mean\")\n"
+    "analysis_service = AnalysisServiceDownload(endpoint, cache_dir, data_download_dir, use_downloaded=True)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In the next step we want to download the data and store them to disc. "
+    "#### Download of data and writing to disc:\n",
+    "In the next step we want to download the data and store them to disc.\n",
+    "\n",
+    "To obtain the contributors for this dataset, we need to create a dedicated file. This can be uploaded to the TOAR database to obtain a preformatted list of contributors. The required recipe can be found in the global metadata of the netCDF file.\n",
+    "\n",
+    "The request the database can take several minutes. This duration is also dependent on the overall usage of the services. The `get_data` function checks every 5minutes, if the data are ready for download. After 30min this cell stops the execution. Simply restart this cell to continue checking for the results."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "2024-09-12 10:49:49 [INFO] - toar_rest_client.py:599: 'Loading already downloaded data to file results/mean_daily_mole_fraction_of_ozone_in_air_2016-01-01_2016-02-28_.zip'\n",
-      "2024-09-12 10:49:49 [INFO] - toar_rest_client.py:507: 'Dropping columns ([Timestamp('2015-12-31 00:00:00'), Timestamp('2016-02-29 00:00:00')]) from TOAR data to match requested date range [2016-01-01 00:00:00, 2016-02-28 00:00:00]'\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "# this cell can runs longer than 30minutes\n",
+    "# this cell can run longer than 30minutes\n",
     "data = analysis_service.get_data(metadata)\n",
     "\n",
     "# create contributors endpoint and write result to metadata\n",
     "contrib = contributions_manager_by_id(metadata.get_id(), data_download_dir)\n",
     "contrib.extract_contributors_from_data_frame(data.stations_data)\n",
     "metadata.contributors_metadata_field = contrib.setup_contributors_endpoint_for_metadata()\n",
+    "\n",
     "ds = my_grid.as_xarray(data)\n",
     "#store dataset\n",
-    "ds.to_netcdf(data_download_dir / f\"{metadata.get_id()}_by_names_inline_{my_grid.get_id()}.nc\")"
+    "out_file_name = data_download_dir / f\"{metadata.get_id()}_{my_grid.get_id()}.nc\"\n",
+    "ds.to_netcdf(out_file_name)\n",
+    "\n",
+    "print(\"Gridded data have been written to \", out_file_name)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "### Visual inspection\n",
-    "We now clean the station metadata. Therefore we remove all stations which have invalid coordinates"
+    "### Visual inspection"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We are working here with raw data and also want to visualize the station positions. Therefore, we want to distinguish stations that have valid data and those without valid data.  "
    ]
   },
   {
@@ -115,10 +171,6 @@
     "#calculation of coordinates for plotting\n",
     "#especially separation of coordinates with results and without results.\n",
     "\n",
-    "import cartopy.crs as ccrs\n",
-    "import matplotlib.pyplot as plt\n",
-    "import matplotlib.ticker as mticker\n",
-    "\n",
     "mean_data = ds[\"mean\"]\n",
     "clean_coords = data.stations_coords\n",
     "all_na = data.stations_data.isna().all(axis=1)\n",
@@ -140,7 +192,11 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "import cartopy.crs as ccrs\n",
     "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.ticker as mticker\n",
+    "import numpy as np\n",
     "\n",
     "#definition of plotting function\n",
     "\n",
@@ -216,85 +272,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "         latitude   longitude\n",
-      "id                           \n",
-      "73      50.754704    6.093923\n",
-      "250     13.775373  100.568928\n",
-      "317     29.733726  -95.257593\n",
-      "325     29.144291  -95.756601\n",
-      "329     30.236200  -95.483200\n",
-      "...           ...         ...\n",
-      "421210  55.584747   13.006230\n",
-      "421218  58.806107   17.388050\n",
-      "421219  55.606390   13.001960\n",
-      "421231  55.703336   13.180275\n",
-      "421235  59.316007   18.057807\n",
-      "\n",
-      "[5052 rows x 2 columns]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x1800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  0.   1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.\n",
-      "  14.  15.  16.  17.  18.  19.  20.  21.  22.  23.  24.  25.  26.  27.\n",
-      "  28.  29.  30.  31.  32.  39.  40.  46.  49.  51.  54.  55.  56.  57.\n",
-      "  61.  62.  63.  68.  72.  75.  81.  85.  87. 116. 147. 217. 322.  nan]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 900x1800 with 2 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "[  0.   1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.\n",
-      "  14.  15.  16.  17.  18.  19.  20.  21.  22.  23.  24.  25.  26.  27.\n",
-      "  28.  29.  30.  31.  32.  33.  34.  36.  37.  38.  39.  40.  41.  42.\n",
-      "  44.  45.  46.  47.  48.  49.  51.  52.  53.  54.  55.  56.  57.  58.\n",
-      "  59.  60.  61.  62.  63.  64.  65.  66.  68.  70.  71.  72.  73.  74.\n",
-      "  75.  76.  77.  80.  81.  82.  83.  84.  85.  86.  87.  88. 114. 115.\n",
-      " 116. 117. 146. 147. 148. 149. 150. 211. 212. 213. 214. 215. 216. 217.\n",
-      " 218. 316. 318. 319. 320. 321. 322. 323. 324. 325.  nan]\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "#example visualization for two time points\n",
     "print(not_na_coords)\n",
@@ -322,40 +302,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "<xarray.Dataset> Size: 334kB\n",
-      "Dimensions:    (latitude: 96, longitude: 144)\n",
-      "Coordinates:\n",
-      "    time       int64 8B 2\n",
-      "  * latitude   (latitude) float64 768B -90.0 -88.11 -86.21 ... 86.21 88.11 90.0\n",
-      "  * longitude  (longitude) float64 1kB -180.0 -177.5 -175.0 ... 175.0 177.5\n",
-      "Data variables:\n",
-      "    mean       (latitude, longitude) float64 111kB nan nan nan ... nan nan nan\n",
-      "    std        (latitude, longitude) float64 111kB nan nan nan ... nan nan nan\n",
-      "    n          (latitude, longitude) float64 111kB nan nan nan ... nan nan nan\n",
-      "Attributes: (12/33)\n",
-      "    id:                        o3_mean_2016-01-01T00:00:00to2016-02-29T00:00:...\n",
-      "    title:                     daily mean statistic for mole_fraction_of_ozon...\n",
-      "    summary:                   daily mean statistic for mole_fraction_of_ozon...\n",
-      "    date_created:              2024-09-12T08:49:49Z\n",
-      "    history:                   2024-09-12T08:49:49Z: File created by toargrid...\n",
-      "    geospatial_lat_min:        -90\n",
-      "    ...                        ...\n",
-      "    creator_type:              institution\n",
-      "    creator_institution:       The Tropospheric Ozone Assessment Report (TOAR...\n",
-      "    publisher_type:            institution\n",
-      "    references:                https://toar-data.fz-juelich.de/\n",
-      "    license:                   CC-BY 4\n",
-      "    acknowledgment:            This project was funded by the EU’s ERC progra...\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(data)"
    ]
diff --git a/examples/02_produce_data_manyStations.ipynb b/examples/02_produce_data_manyStations.ipynb
index b6bfa70e9abae25ad0b1731d1f6ca966bc9f1c65..9710aea37b15856fc669c55385b26dcb318ec8b9 100644
--- a/examples/02_produce_data_manyStations.ipynb
+++ b/examples/02_produce_data_manyStations.ipynb
@@ -4,7 +4,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "inclusion of packages and setting up logging"
+    "# Example  to obtain larger requests:\n",
+    "Toargridding has a number of required arguments for a dataset. Those include the time range, variable and statistical analysis. The TAOR-DB has a large number of metadata fileds that can be used to further refine this request.\n",
+    "\n",
+    "In this example we want to obtain data from 2000 to 2001.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### inclusion of packages"
    ]
   },
   {
@@ -21,24 +31,94 @@
     "from toargridding.toar_rest_client import AnalysisServiceDownload, Connection\n",
     "from toargridding.grids import RegularGrid\n",
     "from toargridding.gridding import get_gridded_toar_data\n",
-    "from toargridding.metadata import TimeSample\n",
+    "from toargridding.metadata import TimeSample"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Setup of logging\n",
     "\n",
-    "from toargridding.defaultLogging import toargridding_defaultLogging\n",
+    "In the next step we setup the logging, i.e. the level of information that is displayed as output. \n",
     "\n",
+    "We start with a default setup and restrict the output to information and more critical output like warnings and errors.\n",
     "\n",
+    "We also add logging to a file. This will create a new log file at midnight and keep up to 7 log files."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "from toargridding.defaultLogging import toargridding_defaultLogging\n",
-    "#setup of logging\n",
+    "\n",
     "logger = toargridding_defaultLogging()\n",
-    "logger.addShellLogger(logging.DEBUG)\n",
+    "logger.addShellLogger(logging.INFO)\n",
     "logger.logExceptions()\n",
-    "logger.addRotatingLogFile(Path(\"log/produce_data_manyStations.log\"))#we need to explicitly set a logfile"
+    "log_path = Path(\"log\")\n",
+    "log_path.mkdir(exist_ok=True)\n",
+    "logger.addRotatingLogFile( log_path / \"produce_data_manyStations.log\")#we need to explicitly set a logfile"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "creation of configurations for the requests to the analysis service. The full duration is split in yearly requests"
+    "#### Setting up the analysis\n",
+    "\n",
+    "We need to prepare our connection to the analysis service of the toar database, which will provide us with temporal and statistical aggregated data. \n",
+    "Besides the url of the service, we also need to setup two directories on our computer:\n",
+    "- one to save the data provided by the analysis service (called cache)\n",
+    "- a second to store our gridded dataset (called results)\n",
+    "Those will be found in the directory examples/cache and examples/results."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "stats_endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
+    "cache_basepath = Path(\"cache\")\n",
+    "result_basepath = Path(\"results\")\n",
+    "cache_basepath.mkdir(exist_ok=True)\n",
+    "result_basepath.mkdir(exist_ok=True)\n",
+    "analysis_service = AnalysisServiceDownload(stats_endpoint=stats_endpoint, cache_dir=cache_basepath, sample_dir=result_basepath, use_downloaded=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our following request will take some time, so we edit the durations between two checks, if our data are ready for download and the maximum duration for checking.\n",
+    "We will check every 45min for 12h. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "analysis_service.connection.set_request_times(interval_min=45, max_wait_minutes=12*60)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Preparation of requests\n",
+    "\n",
+    "The basic idea is to split the request into several parts, here: one year per request.\n",
+    "\n",
+    "We also use a container class to keep the configurations together (type: namedtuple).\n",
+    "\n",
+    "In the end we have wo requests, that we want to submit."
    ]
   },
   {
@@ -57,26 +137,33 @@
     "##for educational reasons the extraction of only two years is fine:-)\n",
     "#for year in range (0,19):\n",
     "for year in range (0,2):\n",
-    "    valid_data = Config(\n",
+    "    request_config = Config(\n",
     "        grid,\n",
     "        TimeSample( start=dt(2000+year,1,1), end=dt(2000+year,12,31), sampling=\"daily\"),#possibly adopt range:-)\n",
     "        [\"mole_fraction_of_ozone_in_air\"],#variable name\n",
-    "        [ \"dma8epa_strict\" ]# change to dma8epa_strict\n",
+    "        [ \"mean\" ]# change to dma8epa_strict\n",
     "        \n",
     "    )\n",
-    "    \n",
-    "    configs[f\"test_ta{year}\"] = valid_data\n"
+    "    configs[f\"test_ta{year}\"] = request_config\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## execution of toargridding. \n",
-    "CAVE: the request takes over 30min per requested year. Therefore this cell needs to be executed at different times to check, if the results are ready for download.\n",
-    "the processing is done on the server of the TOAR database.\n",
-    "A restart of the cell continues the request to the REST API. The data are stored cached on the system to speed up the following analysis.\n",
-    "The download can also take a few minutes"
+    "#### execution of toargridding and saving of results \n",
+    "Now we want to request the data from the server and create the gridded dataset.\n",
+    "Therefore, we call the function `get_gridded_toar_data` with everything we have prepared until now.\n",
+    "\n",
+    "The request will be submitted to the analysis service, which will process the request. On our side, we will check in intervals, if the processing is finished. After several request, we will stop checking. The setup for this can be found a few cells above.\n",
+    "A restart of this cell allows to continue the look-up, if the data are available.\n",
+    "\n",
+    "The obtained data are stored in the result directory (`results_basepath`). Before submitting a request, toargridding checks his cache, if the data have already been downloaded.\n",
+    "\n",
+    "This function also creates a file with the extension \".contributors\".\n",
+    "\n",
+    "Last but not least, we want to save our dataset as netCDF file.\n",
+    "In the global metadata of this file we can find a recipe on how to obtain a list of contributors with the contributors file created by `get_gridded_toar_data`."
    ]
   },
   {
@@ -86,21 +173,8 @@
    "outputs": [],
    "source": [
     "\n",
-    "stats_endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
-    "cache_basepath = Path(\"cache\")\n",
-    "result_basepath = Path(\"results\")\n",
-    "cache_basepath.mkdir(exist_ok=True)\n",
-    "result_basepath.mkdir(exist_ok=True)\n",
-    "analysis_service = AnalysisServiceDownload(stats_endpoint=stats_endpoint, cache_dir=cache_basepath, sample_dir=result_basepath, use_downloaded=True)\n",
-    "\n",
-    "\n",
-    "#here we adopt the durations before, a request is stopped.\n",
-    "#the default value is 30 minutes. \n",
-    "#waiting up to 3h for one request\n",
-    "analysis_service.connection.set_request_times(interval_min=45, max_wait_minutes=12*60)\n",
-    "\n",
-    "for person, config in configs.items():\n",
-    "    print(f\"\\nProcessing {person}:\")\n",
+    "for config_id, config in configs.items():\n",
+    "    print(f\"\\nProcessing {config_id}:\")\n",
     "    print(f\"--------------------\")\n",
     "    datasets, metadatas = get_gridded_toar_data(\n",
     "        analysis_service=analysis_service,\n",
@@ -112,8 +186,7 @@
     "    )\n",
     "\n",
     "    for dataset, metadata in zip(datasets, metadatas):\n",
-    "        dataset.to_netcdf(result_basepath / f\"{metadata.get_id()}_{config.grid.get_id()}.nc\")\n",
-    "        print(metadata.get_id())"
+    "        dataset.to_netcdf(result_basepath / f\"{metadata.get_id()}_{config.grid.get_id()}.nc\")"
    ]
   }
  ],
diff --git a/examples/03_produce_data_withOptional.ipynb b/examples/03_produce_data_withOptional.ipynb
index 422eb28192acf66a45dfc3e9088107e59f16cb8c..ff3ce3974dc6d70ef895d462d7c98c2c6a291978 100644
--- a/examples/03_produce_data_withOptional.ipynb
+++ b/examples/03_produce_data_withOptional.ipynb
@@ -13,12 +13,20 @@
     "The fist block contains the includes and the setup of the logging."
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### inclusion of packages"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
+    "import logging\n",
     "from datetime import datetime as dt\n",
     "from collections import namedtuple\n",
     "from pathlib import Path\n",
@@ -26,14 +34,20 @@
     "from toargridding.toar_rest_client import AnalysisServiceDownload, Connection\n",
     "from toargridding.grids import RegularGrid\n",
     "from toargridding.gridding import get_gridded_toar_data\n",
-    "from toargridding.metadata import TimeSample"
+    "from toargridding.metadata import TimeSample\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We now want to include packages for logging. We want so see some output in the shell, we want to log exceptions and we maybe want to have a logfile to review everything later:"
+    "#### Setup of logging\n",
+    "\n",
+    "In the next step we setup the logging, i.e. the level of information that is displayed as output. \n",
+    "\n",
+    "We start with a default setup and restrict the output to information and more critical output like warnings and errors.\n",
+    "\n",
+    "We also add logging to a file. This will create a new log file at midnight and keep up to 7 log files."
    ]
   },
   {
@@ -42,33 +56,27 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
-    "import logging\n",
     "from toargridding.defaultLogging import toargridding_defaultLogging\n",
     "\n",
-    "#setup of logging\n",
     "logger = toargridding_defaultLogging()\n",
-    "logger.addShellLogger(logging.DEBUG)\n",
+    "logger.addShellLogger(logging.INFO)\n",
     "logger.logExceptions()\n",
-    "logger.addRotatingLogFile(Path(\"log/produce_data_withOptional.log\"))#we need to explicitly set a logfile\n",
-    "#logger.addSysLogger(logging.DEBUG)"
+    "log_path = Path(\"log\")\n",
+    "log_path.mkdir(exist_ok=True)\n",
+    "logger.addRotatingLogFile( log_path / \"produce_data_manyStations.log\")#we need to explicitly set a logfile"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Preparation of requests\n",
-    "in the next block we prepare the request to the analysis service.\n",
-    "The dictionary details4Query adds additional requirements to the request. Here, the two fields *toar1_category* and *type_of_area* are used. Both stand for a classification of stations depending on the surrounding area. It is advised to use only one at once. \n",
+    "#### Setting up the analysis\n",
     "\n",
-    "\n",
-    "moreOptions is implemented as a dict to add additional arguments to the query to the REST API\n",
-    "For example the field *toar1_category* with its possible values Urban, RuralLowElevation, RuralHighElevation and Unclassified can be added \n",
-    "(see page 18 in https://toar-data.fz-juelich.de/sphinx/TOAR_UG_Vol03_Database/build/latex/toardatabase--userguide.pdf).\n",
-    "Or *type_of_area* with urban, suburban and rural on page 20 can be used.\n",
-    "\n",
-    "There are a many more metadata available in the user guide, feel free to look around."
+    "We need to prepare our connection to the analysis service of the toar database, which will provide us with temporal and statistical aggregated data. \n",
+    "Besides the url of the service, we also need to setup two directories on our computer:\n",
+    "- one to save the data provided by the analysis service (called cache)\n",
+    "- a second to store our gridded dataset (called results)\n",
+    "Those will be found in the directory examples/cache and examples/results."
    ]
   },
   {
@@ -77,48 +85,21 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "#creation of request.\n",
-    "# helper to keep the configuration together\n",
-    "Config = namedtuple(\"Config\", [\"grid\", \"time\", \"variables\", \"stats\",\"moreOptions\"])\n",
-    "\n",
-    "#uncomment, what you want to test:-)\n",
-    "details4Query ={\n",
-    "    #\"toar1_category\" : \"Urban\" #uncomment if wished:-)\n",
-    "    #\"toar1_category\" : \"RuralLowElevation\" #uncomment if wished:-)\n",
-    "    #\"toar1_category\" : \"RuralHighElevation\" #uncomment if wished:-)\n",
-    "    #\"type_of_area\" : \"Urban\" #also test Rural, Suburban,\n",
-    "    \"type_of_area\" : \"Rural\" #also test Rural, Suburban,\n",
-    "    #\"type_of_area\" : \"Suburban\" #also test Rural, Suburban,\n",
-    "}\n",
-    "\n",
-    "#a regular grid with 1.9°x2.5° resolution. A warning will be issued as 1.9° does not result in  natural number of grid cells.\n",
-    "grid = RegularGrid( lat_resolution=1.9, lon_resolution=2.5, )\n",
     "\n",
-    "configs = dict()\n",
-    "\n",
-    "# we split the request into one request per year.\n",
-    "##for educational reasons the extraction of only two years is fine:-)\n",
-    "#for year in range(0,19):\n",
-    "for year in range(0,2):\n",
-    "    valid_data = Config(\n",
-    "        grid,\n",
-    "        TimeSample( start=dt(2000+year,1,1), end=dt(2000+year,12,31), sampling=\"daily\"),#possibly adopt range:-)\n",
-    "        #TimeSample( start=dt(2000+year,1,1), end=dt(2000+year,12,31), sampling=\"monthly\"),#possibly adopt range:-)\n",
-    "        [\"mole_fraction_of_ozone_in_air\"],#variable name\n",
-    "        #[ \"mean\", \"dma8epax\"],# will start one request after another other...\n",
-    "        [ \"dma8epa_strict\" ],\n",
-    "        #[ \"mean\" ],\n",
-    "        details4Query\n",
-    "    )\n",
-    "    \n",
-    "    configs[f\"test_ta{year}\"] = valid_data\n"
+    "stats_endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
+    "cache_basepath = Path(\"cache\")\n",
+    "result_basepath = Path(\"results\")\n",
+    "cache_basepath.mkdir(exist_ok=True)\n",
+    "result_basepath.mkdir(exist_ok=True)\n",
+    "analysis_service = AnalysisServiceDownload(stats_endpoint=stats_endpoint, cache_dir=cache_basepath, sample_dir=result_basepath, use_downloaded=True)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We now need to setup the out connection to the analysis service of the TOAR database. We also setup directories to store the data."
+    "Our following request will take some time, so we edit the durations between two checks, if our data are ready for download and the maximum duration for checking.\n",
+    "We will check every 45min for 12h. "
    ]
   },
   {
@@ -127,25 +108,23 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "stats_endpoint = \"https://toar-data.fz-juelich.de/api/v2/analysis/statistics/\"\n",
-    "cache_basepath = Path(\"cache\")\n",
-    "result_basepath = Path(\"results\")\n",
-    "cache_basepath.mkdir(exist_ok=True)\n",
-    "result_basepath.mkdir(exist_ok=True)\n",
-    "analysis_service = AnalysisServiceDownload(stats_endpoint=stats_endpoint, cache_dir=cache_basepath, sample_dir=result_basepath, use_downloaded=True)"
+    "analysis_service.connection.set_request_times(interval_min=45, max_wait_minutes=12*60)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Download and gridding:\n",
-    "Now we come to the last step: we want to download the data, process them and store them to disc.\n",
+    "#### Preparation of requests with station metadata\n",
     "\n",
-    "CAVE: this cell runs about 45minutes per requested year. therefore we increase the waiting duration to 1h per request.\n",
-    "the processing is done on the server of the TOAR database.\n",
-    "A restart of the cell continues the request to the REST API. Data are cached on the local computer to prevent repetitive downloads.\n",
-    "The download can also take a few minutes"
+    "We restrict our request to one year and of daily mean ozone data. In addition we would like to only include urban stations.\n",
+    "\n",
+    "We use a container class to keep the configurations together (type: namedtuple).\n",
+    "\n",
+    "We also want to refine our station selection by using further metadata.\n",
+    "Therefore, we create the `station_metadata` dictionary. We can use the further metadata stored in the TOAR-DB by providing their name and our desired value. This also discards stations, without a provided value for a metadata field. We can find information on different metadata values in the [documentation](https://toar-data.fz-juelich.de/sphinx/TOAR_UG_Vol03_Database/build/latex/toardatabase--userguide.pdf). For example for the *toar1_category* on page 18 and for the *type_of_area* on page 20.\n",
+    "\n",
+    "In the end we have wo requests, that we want to submit."
    ]
   },
   {
@@ -154,13 +133,53 @@
    "metadata": {},
    "outputs": [],
    "source": [
+    "Config = namedtuple(\"Config\", [\"grid\", \"time\", \"variables\", \"stats\", \"station_metadata\"])\n",
+    "\n",
+    "#uncomment, if you want to change the metadata:\n",
+    "station_metadata ={\n",
+    "    #\"toar1_category\" : \"Urban\" #uncomment if wished:-)\n",
+    "    \"type_of_area\" : \"Urban\" #also test Rural, Suburban,\n",
+    "}\n",
+    "\n",
+    "grid = RegularGrid( lat_resolution=1.9, lon_resolution=2.5, )\n",
+    "\n",
+    "configs = dict()\n",
+    "request_config = Config(\n",
+    "    grid,\n",
+    "    TimeSample( start=dt(2000,1,1), end=dt(2000,12,31), sampling=\"daily\"),\n",
+    "    [\"mole_fraction_of_ozone_in_air\"],\n",
+    "    [ \"mean\" ],\n",
+    "    station_metadata\n",
+    ")\n",
+    "configs[f\"test_ta\"] = request_config\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### execution of toargridding and saving of results \n",
+    "Now we want to request the data from the TOAR analysis service and create the gridded dataset.\n",
+    "Therefore, we call the function `get_gridded_toar_data` with everything we have prepared until now.\n",
+    "\n",
+    "The request will be submitted to the analysis service, which will process the request. On our side, we will check in intervals, if the processing is finished. After several request, we will stop checking. The setup for this can be found a few cells above.\n",
+    "A restart of this cell allows to continue the look-up, if the data are available.\n",
     "\n",
-    "# maybe adopt the interval for requesting the results and the total duration, before the client pauses the requests.\n",
-    "# as the requests take about 45min, it is more suitable to wait 60min before timing out the requests than the original 30min.\n",
-    "analysis_service.connection.set_request_times(interval_min=5, max_wait_minutes=60)\n",
+    "The obtained data are stored in the result directory (`results_basepath`). Before submitting a request, toargridding checks his cache, if the data have already been downloaded.\n",
+    "\n",
+    "Last but not least, we want to save our dataset as netCDF file.\n",
+    "In the global metadata of this file we can find a recipe on how to obtain a list of contributors with the contributors file created by `get_gridded_toar_data`. This function also creates the required  file with the extension \"*.contributors\"."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
     "\n",
-    "for person, config in configs.items():\n",
-    "    print(f\"\\nProcessing {person}:\")\n",
+    "for config_id, config in configs.items():\n",
+    "    print(f\"\\nProcessing {config_id}:\")\n",
     "    print(f\"--------------------\")\n",
     "    datasets, metadatas = get_gridded_toar_data(\n",
     "        analysis_service=analysis_service,\n",
@@ -168,13 +187,12 @@
     "        time=config.time,\n",
     "        variables=config.variables,\n",
     "        stats=config.stats,\n",
-    "        contributors_path=result_basepath,\n",
-    "        **config.moreOptions\n",
+    "        contributors_path=result_basepath\n",
+    "        **config.station_metadata\n",
     "    )\n",
     "\n",
     "    for dataset, metadata in zip(datasets, metadatas):\n",
-    "        dataset.to_netcdf(result_basepath / f\"{metadata.get_id()}_{config.grid.get_id()}.nc\")\n",
-    "        print(metadata.get_id())"
+    "        dataset.to_netcdf(result_basepath / f\"{metadata.get_id()}_{config.grid.get_id()}.nc\")"
    ]
   }
  ],