diff --git a/binarycpython/utils/functions.py b/binarycpython/utils/functions.py
index 0138fc326001a16b6de0209d77d2363b1bc2ef7e..ecf901772cd8b1ec001eb2b9021dbe8acc85963d 100644
--- a/binarycpython/utils/functions.py
+++ b/binarycpython/utils/functions.py
@@ -333,6 +333,51 @@ def imports():
             yield val.__name__
 
 
+
+def convfloat(x):
+    """
+    Convert scalar x to a float if we can, in which case return the float, otherwise just return x without changing it. Usually, x is a string, but could be anything that float() can handle without failure.
+    """
+    try:
+        y = float(x)
+        return y
+    except ValueError:
+        return x
+
+def datalinedict(line : str,
+                 parameters : list):
+    """
+    Convert a line of data to a more convenient dictionary.
+    Arguments:
+       line = a line of data as a string
+       parameters = a list of the parameter names
+
+    Note: if the parameter is a floating point number, it will be converted to Python's float type.
+    """
+    return {param:convfloat(value) for param, value in zip(parameters, line.split())}
+
+def pad_output_distribution(dist : dict,
+                            binwidth : float):
+    """
+    Given a distribution, dist (a dictionary), which should be binned every binwidth (float), fill the distribution with zeros when there is no data. Note: this changes the data in place.
+    """
+    # sorted list of the keys
+    skeys = sorted(dist.keys(), key = lambda x: float(x))
+
+    # get min and max, offset by the binwidth
+    min = skeys[ 0] - binwidth
+    max = skeys[-1] + binwidth
+
+    # pad with zeros
+    x = min
+    while x <= max:
+        dist[x] = dist.setdefault(x,0.0)
+        x += binwidth
+
+    return dist
+
+
+
 class catchtime(object):
     """
     Context manager to calculate time spent
@@ -915,7 +960,7 @@ def example_parse_output(output: str, selected_header: str) -> dict:
 
     Args:
         output: binary_c output string
-        selected_header: string header of the output (the start of the line that you want to 
+        selected_header: string header of the output (the start of the line that you want to
             process)
 
     Returns:
@@ -1812,7 +1857,7 @@ def custom_sort_dict(input_dict):
 
     When the keys of the current dictionary are of mixed type, we first find all the unique types.
     Sort that list of type names. Then find the values that fit that type.
-    Sort those and append them to the sorted keys list. 
+    Sort those and append them to the sorted keys list.
     This is done until all the keys are sorted.
 
     All objects other than dictionary types are directly return as they are
@@ -1833,7 +1878,7 @@ def custom_sort_dict(input_dict):
         # If there are multiple types, then we loop over them and do a piece wise sort
         if len(all_types_keys) > 1:
             msg = "Different types in the same dictionary key set"
-            
+
             # Create a string repr of the type name to sort them afterwards
             str_types = {repr(el):el for el in all_types_keys}
 
diff --git a/binarycpython/utils/grid.py b/binarycpython/utils/grid.py
index b33540a047016ed9519f505a5dd8ed7a177107e0..cb07a85198aff976e7db9031e08e1f9801089708 100644
--- a/binarycpython/utils/grid.py
+++ b/binarycpython/utils/grid.py
@@ -20,7 +20,7 @@ Tasks:
     - TODO: fix the correct object types for the default values of the bse_options
     - TODO: uncomment and implement the HPC functionality
     - TODO: think of a clean and nice way to unload and remove the custom_logging_info library from memory (and from disk)
-    - TODO: think of a nice way to remove the loaded grid_code/ generator from memory. 
+    - TODO: think of a nice way to remove the loaded grid_code/ generator from memory.
     - TODO: Create a designated dict for results
 """
 
@@ -366,6 +366,69 @@ class Population:
             ):
                 return grid_variable
 
+    def clean(
+        self
+    ) -> None:
+        """
+        Clean the contents of the population object so it can be reused.
+        """
+        self.grid_results = AutoVivificationDict()
+        self.grid_ensemble_results = {}
+        self.process_ID = 0
+
+    def update_grid_variable(
+        self,
+        name: str,
+        **kwargs
+    ) -> None:
+        """
+        Function to update the values of a grid variable.
+
+        Args:
+            name:
+                name of the grid variable to be changed.
+            **kwargs:
+                key-value pairs to override the existing grid variable data. See add_grid_variable for these names.
+        """
+
+        grid_variable = None
+        try:
+            grid_variable = self.grid_options["_grid_variables"][name]
+        except:
+            msg = "Unknown grid variable {} - please create it with the add_grid_variable() method.".format(name)
+            raise ValueError(msg)
+
+        for key,value in kwargs.items():
+            grid_variable[key] = value
+            verbose_print(
+                "Updated grid variable: {}".format(json.dumps(grid_variable, indent=4)),
+                self.grid_options["verbosity"],
+                1,
+            )
+
+    def rename_grid_variable(
+        self,
+        oldname: str,
+        newname: str
+    ) -> None:
+        """
+        Function to rename a grid variable.
+
+        Args:
+            oldname:
+                old name of the grid variable
+            newname:
+                new name of the grid variable
+        """
+        # note: this apparently does NOT alter the order
+        # of the self.grid_options["_grid_variables"] dictionary.
+        try:
+            self.grid_options["_grid_variables"][newname] = self.grid_options["_grid_variables"].pop(oldname)
+            self.grid_options["_grid_variables"][newname]["name"] = newname
+        except:
+            msg = "Failed to rename grid variable {} to {}.".format(oldname,newname)
+            raise ValueError(msg)
+
     def add_grid_variable(
         self,
         name: str,
@@ -972,7 +1035,7 @@ class Population:
         # Send closing signal to workers. When they receive this they will terminate
         if self.grid_options['verbosity'] >= _LOGGER_VERBOSITY_LEVEL:
             stream_logger.debug(f"Signaling stop to processes")  # DEBUG
-    
+
         for _ in range(amt_cores):
             job_queue.put("STOP")
 
@@ -2272,7 +2335,7 @@ class Population:
             + "\n"
         )
 
-        # Take into account the multiplicity fraction: 
+        # Take into account the multiplicity fraction:
         code_string += (
             indent * (depth + 1)
             + "\n"
@@ -3295,7 +3358,7 @@ class Population:
     def set_moe_di_stefano_settings(self, options=None):
         """
         Function to set user input configurations for the moe & di Stefano methods
-    
+
         If nothing is passed then we just use the default options
         """
 
@@ -3638,7 +3701,7 @@ class Population:
                 resolution=self.grid_options['m&s_options']["resolutions"]["logP"][0],
                 probdist=1.0,
                 condition='(self.grid_options["multiplicity"] >= 2)',
-                branchpoint=1 if max_multiplicity > 1 else 0, # Signal here to put a branchpoint if we have a max multiplicity higher than 1. 
+                branchpoint=1 if max_multiplicity > 1 else 0, # Signal here to put a branchpoint if we have a max multiplicity higher than 1.
                 gridtype="centred",
                 dphasevol="({} * dlog10per)".format(LOG_LN_CONVERTER),
                 valuerange=[self.grid_options['m&s_options']["ranges"]["logP"][0], self.grid_options['m&s_options']["ranges"]["logP"][1]],
@@ -3653,7 +3716,7 @@ qmax=maximum_mass_ratio_for_RLOF(M_1, orbital_period)
 """.format(
                     self.grid_options['m&s_options'].get("Mmin", 0.07)
                 ),
-            ) # TODO: change the maximum_mass_ratio_for_RLOF 
+            ) # TODO: change the maximum_mass_ratio_for_RLOF
 
             # binaries: mass ratio
             self.add_grid_variable(
@@ -3719,7 +3782,7 @@ sep = calc_sep_from_period(M_1, M_2, orbital_period)
                     resolution=self.grid_options['m&s_options']["resolutions"]["logP"][1],
                     probdist=1.0,
                     condition='(self.grid_options["multiplicity"] >= 3)',
-                    branchpoint=2 if max_multiplicity > 2 else 0, # Signal here to put a branchpoint if we have a max multiplicity higher than 1. 
+                    branchpoint=2 if max_multiplicity > 2 else 0, # Signal here to put a branchpoint if we have a max multiplicity higher than 1.
                     gridtype="centred",
                     dphasevol="({} * dlog10per2)".format(LOG_LN_CONVERTER),
                     valuerange=[
diff --git a/docs/source/notebook_luminosity_function.ipynb b/docs/source/notebook_luminosity_function.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..984e21e8ecb890093b9ad5dac1da5b7c2d531e36
--- /dev/null
+++ b/docs/source/notebook_luminosity_function.ipynb
@@ -0,0 +1,696 @@
+{
+ "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 the zero-age main-sequence by running a population of single stars using binary_c. \n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\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",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.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",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=15000,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "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 `population.add_grid_variable` (see next cell)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.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": 4,
+   "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": 5,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add grid variables\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = [0.07, 100.0] # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0\n",
+    "\n",
+    "# Mass\n",
+    "population = Population()\n",
+    "population.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": 6,
+   "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",
+    "population.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": 7,
+   "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,datalinedict\n",
+    "    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }\n",
+    "\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",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.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: `population.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": 8,
+   "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 40 stars\n",
+      "with a total probability of 1.0000000000000004\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-e9197a7369484dc9ab3e0a46d90ddae4 finished! The total probability was: 1.0000000000000002. It took a total of 2.6588425636291504s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n",
+      "OrderedDict([('luminosity distribution', OrderedDict([(0.25, 0.025), (3.75, 0.05), (4.25, 0.05), (2.25, 0.025), (3.25, 0.025), (5.25, 0.2), (4.75, 0.1), (5.75, 0.39999999999999997), (6.25, 0.125)]))])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.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 = population.evolve()  \n",
+    "\n",
+    "# Show the results\n",
+    "print (population.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": 9,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'e9197a7369484dc9ab3e0a46d90ddae4', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631110656.7371156, 'end_timestamp': 1631110659.3959582, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 10,
+     "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",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set the figure size (for a Jupyter notebook in a web browser) \n",
+    "sns.set( rc = {'figure.figsize':(20,10)} )\n",
+    "\n",
+    "# this saves a lot of typing! \n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        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",
+    "p.set(yscale=\"log\")\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
+   "metadata": {},
+   "source": [
+    "## ZAMS Luminosity distribution with the initial mass function\n",
+    "\n",
+    "We now include an initial mass function as a three-part power law based on Kroupa (2001).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Update the probability distribution to use the three-part power law IMF \n",
+    "population.update_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.2182216189410787\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-f9545fb319e04882816b3125d699dd00 finished! The total probability was: 0.21822161894107872. It took a total of 2.6835670471191406s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n",
+      "OrderedDict([('luminosity distribution', OrderedDict([(2.25, 0.0164166), (3.75, 0.0037453900000000004), (4.25, 0.0014346559999999999), (0.25, 0.189097), (3.25, 0.00515685), (5.25, 0.0007493004), (4.75, 0.001171479), (5.75, 0.00039801020000000003), (6.25, 5.2369339999999996e-05)]))])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results\n",
+    "print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 13,
+     "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": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        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",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
+   "metadata": {},
+   "source": [
+    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great. We could simply increase the resolution to compensate, but this is very CPU intensive and a waste of time. Instead, let's try sampling the masses of the stars in a more smart way."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
+   "metadata": {},
+   "source": [
+    "# A better-sampled grid\n",
+    "\n",
+    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
+    "\n",
+    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rename the old variable because we want it to be called lnM_1 now\n",
+    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
+   "metadata": {},
+   "source": [
+    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'lnM_1': {'name': 'lnM_1', 'longname': 'Primary mass', 'valuerange': [0.07, 100.0], 'resolution': '40', 'spacingfunc': 'const(math.log(0.07), math.log(100.0), 40)', 'precode': 'M_1=math.exp(lnM_1)', 'probdist': 'three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1', 'dphasevol': 'dlnM_1', 'parameter_name': 'M_1', 'condition': '', 'gridtype': 'centred', 'branchpoint': 0, 'grid_variable_number': 0}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
+    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
+    "# because  M * dprob/dM = dprob/dlnM\n",
+    "population.update_grid_variable(\n",
+    "    name=\"lnM_1\",\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    precode=\"M_1=math.exp(lnM_1)\",\n",
+    ")\n",
+    "print(population.grid_options[\"_grid_variables\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.9956307907476224\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Population-5f7b694e1e06428d803afae080c9fbfe finished! The total probability was: 0.9956307907476223. It took a total of 1.7812578678131104s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n",
+      "OrderedDict([('luminosity distribution', OrderedDict([(-0.25, 0.0268827), (1.25, 0.0104553), (0.25, 0.0212294), (2.75, 0.00321118), (-3.25, 0.0), (6.25, 7.34708e-05), (-0.75, 0.0771478), (0.75, 0.030004499999999996), (2.25, 0.00921541), (3.25, 0.0045385), (1.75, 0.014776889999999999), (3.75, 0.00283037), (4.25, 0.002380189), (4.75, 0.000869303), (5.25, 0.0007310379999999999), (5.75, 0.00036002859999999996), (-2.75, 0.1961345), (-1.75, 0.2181597), (-2.25, 0.2568974), (-1.25, 0.11973310000000001)]))])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results\n",
+    "print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 17,
+     "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": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        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",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
+   "metadata": {},
+   "source": [
+    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
+    "\n",
+    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighter than about log(*L*/L<sub>☉</sub>)=-2. \n",
+    " \n",
+    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "0c3513a3-53ef-4314-beaa-77df5e226e5b",
+   "metadata": {},
+   "outputs": [],
+   "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
+}
diff --git a/docs/source/notebook_population.ipynb b/docs/source/notebook_population.ipynb
index b6a37baa8d90a2f36c0fd19311548ed49e77f173..961a3b71a53f33b947392c6778cdddde7aca0349 100644
--- a/docs/source/notebook_population.ipynb
+++ b/docs/source/notebook_population.ipynb
@@ -1184,7 +1184,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1198,7 +1198,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,