diff --git a/docs/source/example_notebooks.rst b/docs/source/example_notebooks.rst index bb73b3d6fdca311d8d60ba5aa8159fb55b44bb0d..a9542b7649dea269f3bd260b306820e6ead9bc48 100644 --- a/docs/source/example_notebooks.rst +++ b/docs/source/example_notebooks.rst @@ -20,5 +20,4 @@ The order of the notebooks below is more or less the recommended order to read. examples/notebook_HRD.ipynb examples/notebook_common_envelope_evolution.ipynb examples/notebook_BHBH.ipynb - examples/notebook_massive_remnants.ipynb examples/notebook_solar_system.ipynb diff --git a/examples/notebook_massive_remnants.ipynb b/examples/notebook_massive_remnants.ipynb deleted file mode 100644 index 28227d1a1cb7536b70a32fd936026697be9cbe35..0000000000000000000000000000000000000000 --- a/examples/notebook_massive_remnants.ipynb +++ /dev/null @@ -1,761 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71", - "metadata": { - "tags": [] - }, - "source": [ - "# Example use case: Massive star luminosity\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", - "import matplotlib.pyplot as plt\n", - "\n", - "from binarycpython.utils.functions import temp_dir\n", - "from binarycpython.utils.grid import Population\n", - "\n", - "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\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", - "adding: tmp_dir=/tmp/binary_c_python-izzard/notebooks/notebook_luminosity to grid_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", - " tmp_dir=TMP_DIR,\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", - "\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' : 0.5 }" - ] - }, - { - "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": [ - "# Mass\n", - "population = Population()\n", - "population.set(\n", - " tmp_dir=TMP_DIR,\n", - ")\n", - "population.add_grid_variable(\n", - " name=\"M_1\",\n", - " longname=\"Primary mass\",\n", - " valuerange=massrange,\n", - " samplerfunc=\"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", - ")" - ] - }, - { - "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 Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n", - "\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": 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", - "\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 `num_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": [ - "Doing dry run to calculate total starcount and probability\n", - "Generating grid code\n", - "Grid has handled 40 stars with a total probability of 1\n", - "**************************************\n", - "* Total starcount for this run is 40 *\n", - "* Total probability is 1 *\n", - "**************************************\n", - "\n", - "Generating grid code\n", - "**********************************************************\n", - "* Population-b6213f2eb7f94d3196cf966b7b76b9f9 finished! *\n", - "* The total probability is 1. *\n", - "* It took a total of 6.99s to run 40 systems on 2 cores *\n", - "* = 13.98s of CPU time. *\n", - "* Maximum memory use 472.211 MB *\n", - "**********************************************************\n", - "\n", - "There were no errors found in this run.\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", - " num_cores=2,\n", - " )\n", - "\n", - "# Evolve the population - this is the slow, number-crunching step\n", - "analytics = population.evolve() \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': 'b6213f2eb7f94d3196cf966b7b76b9f9', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.9999999999999998, 'total_count': 40, 'start_timestamp': 1635760806.5066257, 'end_timestamp': 1635760813.4966016, 'total_mass_run': 2001.3999999999996, 'total_probability_weighted_mass_run': 50.03499999999999, 'zero_prob_stars_skipped': 0}\n" - ] - } - ], - "source": [ - "print(analytics)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "id": "05c6d132-abee-423e-b1a8-2039c8996fbc", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[None]" - ] - }, - "execution_count": 11, - "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 up seaborn for use in the notebook\n", - "sns.set(rc={'figure.figsize':(20,10)})\n", - "sns.set_context(\"notebook\",\n", - " font_scale=1.5,\n", - " rc={\"lines.linewidth\":2.5})\n", - " \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\")" - ] - }, - { - "cell_type": "markdown", - "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3", - "metadata": {}, - "source": [ - "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong." - ] - }, - { - "cell_type": "markdown", - "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc", - "metadata": {}, - "source": [ - "## ZAMS Luminosity distribution with the initial mass function\n", - "\n", - "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars. So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "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": 13, - "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Doing dry run to calculate total starcount and probability\n", - "Generating grid code\n", - "Grid has handled 40 stars with a total probability of 0.218222\n", - "**************************************\n", - "* Total starcount for this run is 40 *\n", - "* Total probability is 0.218222 *\n", - "**************************************\n", - "\n", - "Generating grid code\n", - "**********************************************************\n", - "* Population-4b8c7f4a86e445099d73f27dffaad94b finished! *\n", - "* The total probability is 0.218222. *\n", - "* It took a total of 7.95s to run 40 systems on 2 cores *\n", - "* = 15.89s of CPU time. *\n", - "* Maximum memory use 587.984 MB *\n", - "**********************************************************\n", - "\n", - "There were no errors found in this run.\n" - ] - } - ], - "source": [ - "# Clean and re-evolve the population \n", - "population.clean()\n", - "analytics = population.evolve() \n", - "\n", - "# Show the results (debugging)\n", - "# print (population.grid_results)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "[None]" - ] - }, - "execution_count": 14, - "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 because it's not smooth - it's spiky! \n", - "\n", - "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n", - "\n", - "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way." - ] - }, - { - "cell_type": "markdown", - "id": "673031c9-7d80-45d4-b209-301c127d3edf", - "metadata": { - "tags": [] - }, - "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": 15, - "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6", - "metadata": {}, - "outputs": [], - "source": [ - "# Rename the old variable (M_1) 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": 16, - "id": "108d470a-bb21-40b0-8387-2caa7ab0f923", - "metadata": {}, - "outputs": [], - "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", - " samplerfunc=\"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\"]) # debugging" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Doing dry run to calculate total starcount and probability\n", - "Generating grid code\n", - "Grid has handled 40 stars with a total probability of 0.995631\n", - "**************************************\n", - "* Total starcount for this run is 40 *\n", - "* Total probability is 0.995631 *\n", - "**************************************\n", - "\n", - "Generating grid code\n", - "**********************************************************\n", - "* Population-7a2e4301f5224b2cb8939d2297df0aad finished! *\n", - "* The total probability is 0.995631. *\n", - "* It took a total of 4.77s to run 40 systems on 2 cores *\n", - "* = 9.55s of CPU time. *\n", - "* Maximum memory use 621.930 MB *\n", - "**********************************************************\n", - "\n", - "There were no errors found in this run.\n" - ] - } - ], - "source": [ - "# Clean and re-evolve the population \n", - "population.clean()\n", - "analytics = population.evolve() \n", - "\n", - "# Show the results (debugging)\n", - "# print (population.grid_results)" - ] - }, - { - "cell_type": "markdown", - "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6", - "metadata": {}, - "source": [ - "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality." - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94", - "metadata": {}, - "outputs": [ - { - "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\")\n", - "plt.show()" - ] - }, - { - "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 brighten above 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 (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc." - ] - }, - { - "cell_type": "markdown", - "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162", - "metadata": {}, - "source": [ - "Things to try:\n", - "\n", - " * Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n", - " * Different initial distributions: the Kroupa distribution isn't the only one out there\n", - " * Change the metallicity and mass ranges\n", - " * What about a non-constant star formation rate? This is more of a challenge!\n", - " * What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n", - " * Binary stars! (see notebook_luminosity_function_binaries.ipynb)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "5abd0935-3957-4859-80c1-6f5d7ce4b614", - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.6.4" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/examples/notebook_solar_system.ipynb b/examples/notebook_solar_system.ipynb index 926e6d9c4a22c0ec6018ae47aadfbcc188c4e8c2..9d0e32e61aa934ee50eae11ffdaa389040ea4f6e 100644 --- a/examples/notebook_solar_system.ipynb +++ b/examples/notebook_solar_system.ipynb @@ -8,15 +8,7 @@ }, "source": [ "## Example use case: Solar system using the API functionality\n", - "We use the API interface to construct a model of the Solar system." - ] - }, - { - "cell_type": "markdown", - "id": "56886792-d379-4eac-b0d4-54508edb39c7", - "metadata": {}, - "source": [ - "First we must construct the argument string that we pass to binary_c" + "`binary_c` can evolve orbiting objects, like in our solarsystem, during the evolution of the central star. Here we use the API interface to construct a model of the Solar system" ] }, { @@ -27,10 +19,35 @@ "outputs": [], "source": [ "import os\n", + "import re\n", + "import math\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "\n", "from binarycpython.utils.functions import temp_dir\n", "from binarycpython import _binary_c_bindings\n", "\n", "TMP_DIR = temp_dir(\"notebooks\", \"notebook_solar_system\")\n", + "VERBOSITY = 1" + ] + }, + { + "cell_type": "markdown", + "id": "56886792-d379-4eac-b0d4-54508edb39c7", + "metadata": {}, + "source": [ + "First we must construct the argument string that we pass to binary_c. If you look closely you see we make use of the mass units `MMercury` etc in this argument string. `binary_c` recognizes these units, and many more! Moreover, `binary_c` formats the output for the orbiting objects automatically, so we don't have to provide a custom logging string. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "e912ffdb-68c1-4caa-8230-c8801db6fc52", + "metadata": {}, + "outputs": [], + "source": [ "M_1 = 1.0 # Msun\n", "metallicity = 0.02\n", "max_evolution_time = 15000 # Myr. You need to include this argument.\n", @@ -61,7 +78,7 @@ "\n", "\n", "output = _binary_c_bindings.run_system(argstring)\n", - "#print(output)" + "# print(output)" ] }, { @@ -76,30 +93,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 3, "id": "323aad96-408d-404a-a56f-da98d51844dd", "metadata": {}, - "outputs": [ - { - "ename": "NameError", - "evalue": "name 'pop' is not defined", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", - "\u001b[0;32m/tmp/ipykernel_216542/1241251901.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'CS1'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 17\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# remove first element of the list \"Object\" - this is superfluous\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# remove second element of the list \"index\" - this is superfluous\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'pop' is not defined" - ] - } - ], + "outputs": [], "source": [ - "import re\n", - "import pandas as pd\n", - "import math\n", - "#pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n", "data = {}\n", "for line in output.splitlines():\n", - " #print (line)\n", " match = re.search('Object (\\d+) (\\S+)',line)\n", " if match:\n", " number = match.group(1)\n", @@ -125,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 4, "id": "5be09aa5-02cf-4db5-97eb-a4aefbddfac6", "metadata": {}, "outputs": [], @@ -145,7 +145,7 @@ " 'spin of central object',\n", " 'in disc'],\n", " )\n", - " #print (dataframes['Earth'])" + "# print (dataframes['Earth']) # Uncomment to print the dataframe" ] }, { @@ -158,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 8, "id": "ff18274d-0ed7-42cc-8830-b2261a893c6f", "metadata": {}, "outputs": [ @@ -168,15 +168,15 @@ "[None]" ] }, - "execution_count": 12, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "<Figure size 1440x720 with 1 Axes>" + "<Figure size 1440x1440 with 1 Axes>" ] }, "metadata": {}, @@ -184,18 +184,15 @@ } ], "source": [ - "\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "\n", "# set up seaborn for use in the notebook\n", - "sns.set(rc={'figure.figsize':(20,10)})\n", + "sns.set(rc={'figure.figsize':(20,20)})\n", "sns.set_context(\"notebook\",\n", " font_scale=1.5,\n", " rc={\"lines.linewidth\":2.5})\n", "\n", "x = 'time'\n", "y = 'separation'\n", + "\n", "for planet in dataframes:\n", " #print (dataframes[planet])\n", " df = dataframes[planet]\n", @@ -213,7 +210,6 @@ " \n", "p.set_xlabel(\"time/Myr\")\n", "p.set_ylabel(\"separation/au\")\n", - "#p.set(xlim=(0,5)) # might be necessary?\n", "p.set(yscale=\"log\")" ] }, @@ -224,12 +220,12 @@ "source": [ "The inner objects are swallowed by the Sun when it becomes a red giant. Earth survives, although mass loss from the red-giant Sun and tides mess with its orbit somewhat. Jupiter is pushed out beyond the orbits of Saturn and Uranus, and this simple model assumes they are ejected in the interaction because Jupiter is (far) more massive. There are options to detect when its orbit is too close to Neptune, and hence possibly eject Neptune, but I'll let you explore these.\n", "\n", - "We now construct a plot of the temperature of each planet vs time. " + "We now construct a plot of the eccentricity or temperature of each planet vs time. " ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "id": "13214947-a209-4695-a6e2-692614af05dd", "metadata": {}, "outputs": [ @@ -239,15 +235,15 @@ "[None]" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "<Figure size 1440x720 with 1 Axes>" + "<Figure size 1440x1080 with 1 Axes>" ] }, "metadata": {}, @@ -255,16 +251,73 @@ } ], "source": [ + "# Plot eccentricity\n", + "# set up seaborn for use in the notebook\n", + "sns.set(rc={'figure.figsize':(20, 15)})\n", + "sns.set_context(\"notebook\",\n", + " font_scale=1.5,\n", + " rc={\"lines.linewidth\":2.5})\n", "\n", - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", "\n", + "#########\n", + "x = 'time'\n", + "y = 'eccentricity'\n", + "for planet in dataframes:\n", + " df = dataframes[planet]\n", + " p = sns.lineplot(data=df,\n", + " sort=False,\n", + " x=x,\n", + " y=y,\n", + " estimator=None,\n", + " ci=None,\n", + " legend='full'\n", + " )\n", + " xx = df.head(1).loc[0,x]\n", + " yy = df.head(1).loc[0,y]\n", + " p.text(xx,yy,planet)\n", + " \n", + "p.set_xlabel(\"time/Myr\")\n", + "p.set_ylabel(\"Eccentricity\")\n", + "p.set(yscale=\"log\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5264a6e1-f0d8-4df5-b20e-b6be8a1cfc78", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[None]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1440x1080 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot Temperature\n", "# set up seaborn for use in the notebook\n", - "sns.set(rc={'figure.figsize':(20,10)})\n", + "sns.set(rc={'figure.figsize':(20, 15)})\n", "sns.set_context(\"notebook\",\n", " font_scale=1.5,\n", " rc={\"lines.linewidth\":2.5})\n", "\n", + "\n", + "#########\n", "x = 'time'\n", "y = 'temperature'\n", "for planet in dataframes:\n", @@ -298,7 +351,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -312,7 +365,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.9.9" } }, "nbformat": 4,