From ce625367caca8593883e2f53faebc1faa8935e24 Mon Sep 17 00:00:00 2001
From: Robert Izzard <r.izzard@surrey.ac.uk>
Date: Thu, 9 Sep 2021 11:54:42 +0200
Subject: [PATCH] update logging at verbosity >= 1 to be more like binary_grid

shows:
current grid status (#/# and modulo)
estimate of time remaining and time to finish
memory use (of all processes)
time per run
---
 binarycpython/utils/functions.py              |   3 +-
 binarycpython/utils/grid.py                   | 140 +++-
 binarycpython/utils/grid_options_defaults.py  |   9 +-
 ...otebook_luminosity_function_binaries.ipynb | 736 ++++++++++++++++++
 4 files changed, 871 insertions(+), 17 deletions(-)
 create mode 100644 examples/notebook_luminosity_function_binaries.ipynb

diff --git a/binarycpython/utils/functions.py b/binarycpython/utils/functions.py
index 539601288..f16992d31 100644
--- a/binarycpython/utils/functions.py
+++ b/binarycpython/utils/functions.py
@@ -362,7 +362,7 @@ def pad_output_distribution(dist : dict,
     """
     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))
 
@@ -472,7 +472,6 @@ def verbose_print(message: str, verbosity: int, minimal_verbosity: int) -> None:
     if verbosity >= minimal_verbosity:
         print(message)
 
-
 def remove_file(file: str, verbosity: int = 0) -> None:
     """
     Function to remove files but with verbosity
diff --git a/binarycpython/utils/grid.py b/binarycpython/utils/grid.py
index c30f45c33..f53e01b87 100644
--- a/binarycpython/utils/grid.py
+++ b/binarycpython/utils/grid.py
@@ -32,6 +32,7 @@ import datetime
 import argparse
 import importlib.util
 import multiprocessing
+import resource
 from typing import Union, Any
 from collections import (
     OrderedDict,
@@ -92,6 +93,7 @@ from binarycpython.utils.distribution_functions import (
 
 from binarycpython import _binary_c_bindings
 
+secs_per_day = 86400 # probably needs to go somewhere more sensible
 
 class Population:
     """
@@ -124,6 +126,9 @@ class Population:
         # Custom options
         self.custom_options = {}
 
+        # shared memory used for logging
+        self.shared_memory = {}
+
         # Load M&s options
         self.grid_options['m&s_options'] = copy.deepcopy(moe_di_stefano_default_options)
 
@@ -550,7 +555,6 @@ class Population:
         Returns:
             dictionary containing "bse_options", "grid_options", "custom_options"
         """
-
         options = {
             "bse_options": self.bse_options,
             "grid_options": self.grid_options,
@@ -604,7 +608,6 @@ class Population:
 
         #
         all_info = {}
-
         #
         if include_population_settings:
             population_settings = self.return_population_settings()
@@ -819,6 +822,14 @@ class Population:
         # Reset population ID:
         self.grid_options["_population_id"] = uuid.uuid4().hex
 
+        # set previous logging time
+        self.shared_memory["prev_log_time"] = multiprocessing.Value('d',time.time())
+        # set previous logging system number to 0
+        self.shared_memory["prev_log_system_number"] = multiprocessing.Value('i',0)
+        # array to store memory use per-thread
+        mem = self._mem_use()
+        self.shared_memory["memory_use_per_thread"] = multiprocessing.Array('d',[1.0*mem]*self.grid_options["amt_cores"])
+
     def clean(
         self
     ) -> None:
@@ -836,7 +847,7 @@ class Population:
         """
         Entry point function of the whole object. From here, based on the settings,
         we set up a SLURM or CONDOR grid, or if no setting is given we go straight
-        to evolving the population. 
+        to evolving the population.
 
         There are no direct arguments to this function, rather it is based on the grid_options settings:
             grid_options['slurm']: integer Boolean whether to use a slurm_grid evolution
@@ -935,7 +946,7 @@ class Population:
                 )
             )
 
-        #
+        # finished!
         self.grid_options["_end_time_evolution"] = time.time()
 
         # Log and print some information
@@ -1285,6 +1296,9 @@ class Population:
         zero_prob_stars_skipped = 0
 
         total_time_calling_binary_c = 0
+        start_grid_time = time.time()
+        next_log_time = self.shared_memory["prev_log_time"].value + self.grid_options["log_dt"]
+        next_mem_update_time = start_grid_time + self.grid_options["log_dt"]
 
         total_mass_run = 0
         total_probability_weighted_mass_run = 0
@@ -1349,11 +1363,31 @@ class Population:
             # )
 
             #
-            verbose_print(
-                "Process {} is handling system {}".format(ID, system_number),
-                self.grid_options["verbosity"],
-                1,
-            )
+
+#            verbose_print(
+#                "Process {} is handling system {}".format(ID, system_number),
+#                self.grid_options["verbosity"],
+#                1,
+#            )
+
+            # save the current time (used often)
+            now = time.time()
+
+            # update memory use stats every log_dt seconds (not every time, this is likely a bit expensive)
+            if now > next_mem_update_time:
+                self.shared_memory["memory_use_per_thread"][ID] = self._mem_use()
+                next_mem_update = now + self.grid_options["log_dt"]
+
+            # calculate the next logging time
+            next_log_time = self.shared_memory["prev_log_time"].value + self.grid_options["log_dt"]
+
+            if now > next_log_time:
+                # we have exceeded the next log time : output and update timers
+                lock = multiprocessing.Lock()
+                self.vb1print(ID,now,system_number)
+                next_log_time = now + self.grid_options["log_dt"]
+                self.shared_memory["prev_log_time"].value = now
+                self.shared_memory["prev_log_system_number"].value = system_number
 
             # In some cases, the whole run crashes. To be able to figure out which system
             # that was on, we log each current system to a file (each thread has one).
@@ -1608,7 +1642,7 @@ class Population:
         # Check if there are actually arguments passed:
         if self.bse_options:
 
-            # Get argument line and 
+            # Get argument line and
             argline = self._return_argline(self.bse_options)
 
             verbose_print("Running {}".format(argline), self.grid_options["verbosity"], 1)
@@ -1623,7 +1657,7 @@ class Population:
                 population=0,
             )
 
-            # Clean up custom logging 
+            # Clean up custom logging
             if clean_up_custom_logging_files:
                 self._clean_up_custom_logging(evol_type="single")
 
@@ -4140,3 +4174,87 @@ eccentricity3=0
         )
 
         return multiplicity_fraction_dict[system_dict['multiplicity']]
+
+    def _trem(self,dt,count,dn,n):
+        """
+        Estimate time remaining (seconds) given a differential time and count (i.e. progress = $count/$n). $dt is the time since the last call, $count is the current progress count, $dn is the number run since the last call, and $n is the total number required.
+        """
+        tpr = dt / max(1,dn)
+        etasecs = tpr * (n - count)
+        (eta,units) = self._conv_time_units(etasecs)
+        return (eta,units,tpr,etasecs)
+
+    def _conv_time_units(self,t):
+        """
+        Converts time (t, in seconds, passing in as the only argument) to seconds, minutes or hours depending on its magnitude. Returns a tuple (t,units).
+        """
+        units='s'; # default to seconds
+        if t > 60:
+            t /= 60;
+            units='m';
+        if t > 60:
+            t /=60;
+            units='h';
+        return (t,units)
+
+    def vb1print(self,ID,now,system_number):
+        """
+        Verbosity-level 1 printing, to keep an eye on a grid.
+        Arguments:
+                 ID : thread ID for debugging (int)
+                 now : the time now as a UNIX-style epoch in seconds (float)
+                 system_number : the system number
+        """
+        # calculate estimated time of arrive (eta and eta_secs), time per run (tpr)
+        localtime = time.localtime(now)
+        dt = now - self.shared_memory["prev_log_time"].value
+        dn = system_number - self.shared_memory["prev_log_system_number"].value
+        (eta,units,tpr,eta_secs) = self._trem(dt,
+                                              system_number,
+                                              dn,
+                                              self.grid_options["_total_starcount"])
+        if eta_secs < secs_per_day:
+            fintime = time.localtime(now + eta_secs)
+            etf = "{hours:02d}:{minutes:02d}:{seconds:02d}".format(hours = fintime.tm_hour,
+                                                                   minutes = fintime.tm_min,
+                                                                   seconds = fintime.tm_sec)
+        else:
+            d = int(eta_secs/secs_per_day)
+            if d == 1:
+                etf = "Tomorrow"
+            else:
+                etf = "In " + d + " days"
+
+        # modulo information
+        if self.grid_options['modulo'] == 1:
+            modulo = '' # usual case
+        else:
+            modulo = '%' + str(self.grid_options['modulo'])
+
+        # add up memory use from each thread
+        mem_use = sum(self.shared_memory["memory_use_per_thread"])
+
+        verbose_print(
+            "{system_number}/{total_starcount}{modulo} {complete:5.1f}% complete {hours:02d}:{minutes:02d}:{seconds:02d} ETA={eta:7.1f}{units} tpr={tpr:2.2e} ETF={etf} mem:{mem_use:.1f}MB".format(
+                system_number = system_number,
+                total_starcount = self.grid_options["_total_starcount"],
+                complete=(100.0*system_number)/(1.0*self.grid_options["_total_starcount"]),
+                modulo = modulo,
+                hours = localtime.tm_hour,
+                minutes = localtime.tm_min,
+                seconds = localtime.tm_sec,
+                eta = eta,
+                units = units,
+                tpr = tpr,
+                etf = etf,
+                mem_use = mem_use
+            ),
+            self.grid_options["verbosity"],
+            1
+        )
+
+    def _mem_use(self):
+        """
+        Return current process memory use in MB. (Takes no arguments) Note: this is per-thread only.
+        """
+        return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0
diff --git a/binarycpython/utils/grid_options_defaults.py b/binarycpython/utils/grid_options_defaults.py
index d01f92fcc..9dbcdb705 100644
--- a/binarycpython/utils/grid_options_defaults.py
+++ b/binarycpython/utils/grid_options_defaults.py
@@ -1,14 +1,14 @@
 """
-Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries: 
+Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries:
     - grid_options_defaults_dict: dictionary containing the default values for all the options
     - grid_options_descriptions: dictionary containing the description for these options.
 
 There are several other functions in this module, mostly to generate help texts or documents:
-    - grid_options_help: interactive function for the user to get descriptions for options 
+    - grid_options_help: interactive function for the user to get descriptions for options
     - grid_options_description_checker: function that checks that checks which options have a description.
     - write_grid_options_to_rst_file: function to generate the .rst document for the docs
 
-With this its also possible to automatically generate a document containing all the setting names + descriptions. 
+With this its also possible to automatically generate a document containing all the setting names + descriptions.
 
 All the options starting with _ should not be changed by the user except when you really know what you're doing (which is probably hacking the code :P)
 """
@@ -50,6 +50,7 @@ grid_options_defaults_dict = {
     "log_file": os.path.join(
         temp_dir(), "binary_c_python.log"
     ),  # Set to None to not log to file. The directory will be created
+    "log_dt" : 5, # time between vb=1 logging outputs
     ##########################
     # binary_c files
     ##########################
@@ -534,7 +535,7 @@ moe_di_stefano_default_options = {
         "ecc": [0.0, 0.99],
     },
     # minimum stellar mass
-    "Mmin": float(return_binary_c_version_info(parsed=True)['macros']['BINARY_C_MINIMUM_STELLAR_MASS']), # We take the value that binary_c has set as the default 
+    "Mmin": float(return_binary_c_version_info(parsed=True)['macros']['BINARY_C_MINIMUM_STELLAR_MASS']), # We take the value that binary_c has set as the default
 
     # multiplicity model (as a function of log10M1)
     #
diff --git a/examples/notebook_luminosity_function_binaries.ipynb b/examples/notebook_luminosity_function_binaries.ipynb
new file mode 100644
index 000000000..eecc6b199
--- /dev/null
+++ b/examples/notebook_luminosity_function_binaries.ipynb
@@ -0,0 +1,736 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\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 this line 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 a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 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=0.1,  # 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 (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "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": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\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 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 2*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By 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. For our current purposes, it works perfectly well.\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\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\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": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\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",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\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'][int(nstar)][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": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_cd4b14dc28814364b94a8608b70990fd.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_cd4b14dc28814364b94a8608b70990fd.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 2000 stars\n",
+      "with a total probability of 0.6495098935846658\n",
+      "Total starcount for this run will be: 2000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:46:07,695 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-09 11:46:07,699 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-09 11:46:07,703 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-09 11:46:07,706 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-09 11:46:07,708 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-09T11:46:07.718767.\tUsing store memaddr <capsule object \"STORE\" at 0x149cd4efb720>\n",
+      "Process 1 started at 2021-09-09T11:46:07.722569.\tUsing store memaddr <capsule object \"STORE\" at 0x149cd4efb630>\n",
+      "Process 2 started at 2021-09-09T11:46:07.727251.\tUsing store memaddr <capsule object \"STORE\" at 0x149cd4efb0c0>\n",
+      "Process 3 started at 2021-09-09T11:46:07.731045.\tUsing store memaddr <capsule object \"STORE\" at 0x149cd4efb180>\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_cd4b14dc28814364b94a8608b70990fd.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_cd4b14dc28814364b94a8608b70990fd.py\n",
+      "Grid code loaded\n",
+      "748/2000  37.4% complete 11:46:12 ETA=    8.4s tpr=6.70e-03 ETF=11:46:20 mem:509.0MB\n",
+      "819/2000  41.0% complete 11:46:17 ETA=    1.4m tpr=7.16e-02 ETF=11:47:41 mem:460.4MB\n",
+      "886/2000  44.3% complete 11:46:22 ETA=    1.4m tpr=7.61e-02 ETF=11:47:46 mem:462.7MB\n",
+      "945/2000  47.2% complete 11:46:27 ETA=    1.5m tpr=8.61e-02 ETF=11:47:58 mem:463.5MB\n",
+      "981/2000  49.0% complete 11:46:32 ETA=    2.4m tpr=1.42e-01 ETF=11:48:57 mem:463.5MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:46:34,956 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1026/2000  51.3% complete 11:46:37 ETA=    1.8m tpr=1.11e-01 ETF=11:48:26 mem:464.5MB\n",
+      "1061/2000  53.0% complete 11:46:42 ETA=    2.2m tpr=1.43e-01 ETF=11:48:57 mem:466.7MB\n",
+      "1096/2000  54.8% complete 11:46:47 ETA=    2.2m tpr=1.47e-01 ETF=11:49:00 mem:467.2MB\n",
+      "1141/2000  57.0% complete 11:46:52 ETA=    1.6m tpr=1.13e-01 ETF=11:48:29 mem:468.1MB\n",
+      "1173/2000  58.6% complete 11:46:57 ETA=    2.2m tpr=1.58e-01 ETF=11:49:08 mem:468.3MB\n",
+      "1203/2000  60.1% complete 11:47:02 ETA=    2.3m tpr=1.70e-01 ETF=11:49:18 mem:469.2MB\n",
+      "1250/2000  62.5% complete 11:47:08 ETA=    1.4m tpr=1.13e-01 ETF=11:48:32 mem:471.2MB\n",
+      "1289/2000  64.5% complete 11:47:13 ETA=    1.6m tpr=1.37e-01 ETF=11:48:50 mem:472.6MB\n",
+      "1335/2000  66.8% complete 11:47:18 ETA=    1.2m tpr=1.11e-01 ETF=11:48:32 mem:477.3MB\n",
+      "1366/2000  68.3% complete 11:47:24 ETA=    1.9m tpr=1.79e-01 ETF=11:49:17 mem:477.8MB\n",
+      "1434/2000  71.7% complete 11:47:29 ETA=   44.1s tpr=7.79e-02 ETF=11:48:13 mem:479.5MB\n",
+      "1461/2000  73.0% complete 11:47:34 ETA=    1.7m tpr=1.86e-01 ETF=11:49:14 mem:479.5MB\n",
+      "1494/2000  74.7% complete 11:47:39 ETA=    1.3m tpr=1.54e-01 ETF=11:48:57 mem:480.2MB\n",
+      "1546/2000  77.3% complete 11:47:44 ETA=   44.1s tpr=9.70e-02 ETF=11:48:28 mem:481.0MB\n",
+      "1594/2000  79.7% complete 11:47:49 ETA=   42.4s tpr=1.04e-01 ETF=11:48:31 mem:481.2MB\n",
+      "1645/2000  82.2% complete 11:47:54 ETA=   36.3s tpr=1.02e-01 ETF=11:48:31 mem:482.9MB\n",
+      "1685/2000  84.2% complete 11:48:00 ETA=   41.6s tpr=1.32e-01 ETF=11:48:41 mem:483.2MB\n",
+      "1733/2000  86.7% complete 11:48:05 ETA=   28.4s tpr=1.06e-01 ETF=11:48:33 mem:483.4MB\n",
+      "1765/2000  88.2% complete 11:48:10 ETA=   37.8s tpr=1.61e-01 ETF=11:48:48 mem:483.4MB\n",
+      "1803/2000  90.2% complete 11:48:15 ETA=   26.0s tpr=1.32e-01 ETF=11:48:41 mem:485.0MB\n",
+      "1846/2000  92.3% complete 11:48:20 ETA=   19.8s tpr=1.28e-01 ETF=11:48:40 mem:485.0MB\n",
+      "1884/2000  94.2% complete 11:48:25 ETA=   15.6s tpr=1.34e-01 ETF=11:48:41 mem:485.0MB\n",
+      "1926/2000  96.3% complete 11:48:31 ETA=    9.1s tpr=1.22e-01 ETF=11:48:40 mem:485.2MB\n",
+      "1964/2000  98.2% complete 11:48:36 ETA=    4.8s tpr=1.34e-01 ETF=11:48:41 mem:486.1MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:48:39,930 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-09T11:46:07.708030, done at 2021-09-09T11:48:39.932656 (total: 152.224626s of which 151.9391267299652s interfacing with binary_c).\n",
+      "\tRan 495 systems with a total probability of 0.15751390762579187.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:48:39,935 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-09 11:48:39,969 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-09T11:46:07.699120, done at 2021-09-09T11:48:39.971885 (total: 152.272765s of which 151.99865984916687s interfacing with binary_c).\n",
+      "\tRan 512 systems with a total probability of 0.177316124969565.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:48:39,974 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-09 11:48:40,110 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-09T11:46:07.695606, done at 2021-09-09T11:48:40.113158 (total: 152.417552s of which 152.14919590950012s interfacing with binary_c).\n",
+      "\tRan 512 systems with a total probability of 0.1629988228713039.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:48:40,115 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-09 11:48:40,145 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-09T11:46:07.702814, done at 2021-09-09T11:48:40.148157 (total: 152.445343s of which 152.1856849193573s interfacing with binary_c).\n",
+      "\tRan 481 systems with a total probability of 0.1516810381180079.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-09 11:48:40,150 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-cd4b14dc28814364b94a8608b70990fd finished! The total probability was: 0.6495098935846687. It took a total of 152.67183566093445s to run 2000 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\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": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'cd4b14dc28814364b94a8608b70990fd', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6495098935846687, 'total_count': 2000, 'start_timestamp': 1631180767.6636574, 'end_timestamp': 1631180920.335493, 'total_mass_run': 41112.22096439228, 'total_probability_weighted_mass_run': 0.6452116023479679, '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": [
+       "[None]"
+      ]
+     },
+     "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",
+    "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",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\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": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "29c6588b-078d-42ec-9b07-63278320ca9c",
+   "metadata": {},
+   "source": [
+    "## "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "fe84d2dd-5e5f-4eaa-a09e-2bfb7559b70b",
+   "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
+}
-- 
GitLab