diff --git a/docs/source/notebook_luminosity_function.ipynb b/docs/source/notebook_luminosity_function.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..ce85368a47ff9ee7bb0fba67962b4e3ac9e257ba
--- /dev/null
+++ b/docs/source/notebook_luminosity_function.ipynb
@@ -0,0 +1,511 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Stellar luminosity function\n",
+    "\n",
+    "In this notebook we compute the luminosity function of main-sequence, single stars by running a population of stars using binary_c."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make an object instance of the `Population` object, and add configuration via the `.set()` function.\n",
+    "\n",
+    "There are three categories of options that the Population object can set:\n",
+    "- BSE (stellar evolution) options: these options will be used for the binary_c calls, and are recognized by comparing the arguments to a known list of available arguments of binary_c. To see which options are available, see section [`binary_c parameters` in the documentation](https://ri0005.pages.surrey.ac.uk/binary_c-python/binary_c_parameters.html). You can access these through `population.bse_options['<bse option name>']` after you have set them. \n",
+    "\n",
+    "- Grid options: these options will be used to configure the behaviour of the Population object. To see which options are available, see section [`Population grid code options` in the documentation](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html). They can be accessed via `population.grid_options['<grid option name>']` after you have set them. \n",
+    "\n",
+    "- Custom options: these options are not recognized as either of the above, so they will be stored in the custom_options, and can be accessed via `population.custom_options['<custom option name>']`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=15000 to BSE_options\n",
+      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/lumfunc to custom_options >>>>\n",
+      "1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "example_pop = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "example_pop.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "example_pop.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=15000,  # maximum stellar evolution time in Myr\n",
+    "    data_dir = '/tmp/lumfunc', # directory for data\n",
+    " )\n",
+    "\n",
+    "# We can access the options through\n",
+    "print(example_pop.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f8d46d19-633d-4911-821d-a59daed31816",
+   "metadata": {},
+   "source": [
+    "After configuring the population, but before running the actual population, its usually a good idea to export the full configuration (including version info of binary_c and all the parameters) to a file. To do this we use `example_pop.export_all_info()`.\n",
+    "\n",
+    "On default this exports everything, each of the sections can be disabled:\n",
+    "  - population settings (bse_options, grid_options, custom_options), turn off with include_population\n",
+    "      settings=False\n",
+    "  - binary_c_defaults (all the commandline arguments that binary c accepts, and their defaults).\n",
+    "      turn off with include_binary_c_defaults=False\n",
+    "  - include_binary_c_version_info (all the compilation info, and information about the compiled\n",
+    "      parameters), turn off with include_binary_c_version_info=False\n",
+    "  - include_binary_c_help_all (all the help information for all the binary_c parameters),\n",
+    "      turn off with include_binary_c_help_all=Fase\n",
+    "      \n",
+    "On default it will write this to the custom_options['data_dir'], but that can be overriden by setting use_datadir=False and providing an outfile=<>"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "b9c2471a-a5b0-48b7-a50b-2f0d22100926",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Writing settings to /tmp/lumfunc/simulation_20210908_102035_settings.json\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'/tmp/lumfunc/simulation_20210908_102035_settings.json'"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "example_pop.export_all_info()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (See below for full examples of all of these). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "In some cases it could be easier to set up a for loop that sets that parameter and calls the evolve function several times, e.g. when you want to vary a prescription (usually a discrete, unweighted parameter) \n",
+    "\n",
+    "\n",
+    "A notable special type of grid variable is that of the Moe & di Stefano 2017 dataset (see further down in the notebook).\n",
+    "\n",
+    "To add a grid variable to the population object we use `example_pop.add_grid_variable` (see next cell)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(example_pop.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, but sampling in log mass. The commented grid variables are examples of the mass ratio sampling and the period sampling."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add grid variables\n",
+    "resolution = {\"M_1\": 10}\n",
+    "massrange = [0.0, 100.0]\n",
+    "total_probability = 1.0\n",
+    "\n",
+    "# Mass\n",
+    "example_pop = Population()\n",
+    "example_pop.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "On default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c). Or, we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. \n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging, and a parse function to handle that output"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement: in this case we will log when the star turns into a compact object, and then terminate the evolution.\n",
+    "custom_logging_statement = \"\"\"\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "   /* Note that we use Printf - with a capital P! */\n",
+    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
+    "          stardata->model.time, // 1\n",
+    "          stardata->common.zero_age.mass[0], // 2\n",
+    "          stardata->star[0].mass, // 3\n",
+    "          stardata->star[0].luminosity, // 4\n",
+    "          stardata->model.probability // 5\n",
+    "      );\n",
+    "};\n",
+    "\"\"\"\n",
+    "\n",
+    "example_pop.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "from binarycpython.utils.functions import bin_data\n",
+    "    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }\n",
+    "\n",
+    "def convfloat(x):\n",
+    "    \"\"\"\n",
+    "    convert scalar x to a float if we can\n",
+    "    \"\"\"\n",
+    "    try:\n",
+    "        y = float(x)\n",
+    "        return y\n",
+    "    except ValueError:\n",
+    "        return x\n",
+    "    \n",
+    "def datalinedict(line,parameters):\n",
+    "    \"\"\"\n",
+    "    convert a line of data to a more convenient dictionary \n",
+    "    \"\"\"\n",
+    "    return {param:convfloat(value) for param, value in zip(parameters, line.split())}\n",
+    "    \n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "        \n",
+    "        # Check the header and act accordingly\n",
+    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
+    "            \n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "example_pop.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `example_pop.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 0.9999999999999999\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-497443180adf46c7af8b1bb75d6309a2 finished! The total probability was: 1.0. It took a total of 0.8296694755554199s to run 10 systems on 2 cores\n",
+      "There were no errors found in this run.\n",
+      "OrderedDict([('luminosity distribution', OrderedDict([(4.25, 0.1), (4.75, 0.1), (2.75, 0.1), (6.25, 0.1), (5.25, 0.2), (5.75, 0.4)]))])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "example_pop.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=2,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = example_pop.evolve()  \n",
+    "\n",
+    "# Show the results\n",
+    "print (example_pop.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '497443180adf46c7af8b1bb75d6309a2', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0, 'total_count': 10, 'start_timestamp': 1631089236.3068738, 'end_timestamp': 1631089237.1365433, 'total_mass_run': 500.0, 'total_probability_weighted_mass_run': 50.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 0, '$\\\\log_{10}$ ($L_\\\\mathrm{ZAMS}$ / L$_{☉}$)')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "\n",
+    "# set the figure size (for a Jupyter notebook in a web browser) \n",
+    "sns.set( rc = {'figure.figsize':(20,10)} )\n",
+    "\n",
+    "# get the luminosity distribution and a sorted list of keys (x-values) \n",
+    "ldist = example_pop.grid_results['luminosity distribution'] # saves typing\n",
+    "lkeys = sorted(ldist.keys(), key = lambda x: float(x)) # sorted list of the luminosities (the keys of the dictionary)\n",
+    "\n",
+    "# pad with zeros\n",
+    "min = lkeys[ 0] - binwidth['luminosity']\n",
+    "max = lkeys[-1] + binwidth['luminosity']\n",
+    "l = min\n",
+    "while l <= max:\n",
+    "    ldist[l] = ldist.setdefault(l,0.0)\n",
+    "    l += binwidth['luminosity']\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "74a4c26c-0476-49cd-95b8-fab30f110b11",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d2c7e930-6f77-487e-b92b-8df9dac9eb45",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## "
+   ]
+  }
+ ],
+ "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.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}