{ "cells": [ { "cell_type": "markdown", "id": "a1b2c3d4", "metadata": {}, "source": [ "# Setting Up and Running VPLanet Models\n", "\n", "This tutorial walks through the full workflow for running a VPLanet stellar evolution simulation:\n", "\n", "1. **Understanding VPLanet input files** — the primary control file (`vpl.in`) and body files (`star.in`)\n", "2. **Running VPLanet from the command line** — a minimal working example using the `stellar` module\n", "3. **Reading VPLanet output files** — the log file and time-series forward file\n", "4. **Running the same model through `vplanet_inference`** — a Python interface with unit-aware parameter substitution\n", "\n", "The example models a low-mass star (0.09 M☉, similar in mass to TRAPPIST-1) and tracks how its\n", "luminosity, XUV luminosity, radius, effective temperature, and rotation period evolve over 8 Gyr.\n", "\n", "---\n", "\n", "**References:**\n", "- [VPLanet documentation](https://virtualplanetarylaboratory.github.io/vplanet/)\n", "- [VPLanet GitHub repository](https://github.com/VirtualPlanetaryLaboratory/vplanet)\n", "- [vplanet_inference GitHub repository](https://github.com/jbirky/vplanet_inference)" ] }, { "cell_type": "code", "execution_count": 1, "id": "b2c3d4e5", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:46.967652Z", "iopub.status.busy": "2026-03-01T22:35:46.967549Z", "iopub.status.idle": "2026-03-01T22:35:47.812615Z", "shell.execute_reply": "2026-03-01T22:35:47.812277Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Infile directory: /home/jbirky/Tresorit/packages/vplanet_inference/infiles/stellar/\n" ] } ], "source": [ "import os\n", "import subprocess\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import vplanet_inference as vpi\n", "import astropy.units as u\n", "\n", "# vpi.INFILE_DIR points to the bundled template infile directory\n", "INFILE_PATH = os.path.join(vpi.INFILE_DIR, \"stellar/\")\n", "print(f\"Infile directory: {INFILE_PATH}\")" ] }, { "cell_type": "markdown", "id": "c3d4e5f6", "metadata": {}, "source": [ "## 1. VPLanet Input Files: The Manual Way\n", "\n", "A VPLanet simulation requires at minimum two types of input files:\n", "\n", "| File | Purpose |\n", "|------|---------|\n", "| **`vpl.in`** | Primary control file — system-level settings (units, timing, bodies, output) |\n", "| **`.in`** | One file per body — physics modules, initial conditions, and body-level parameters |\n", "\n", "VPLanet uses a consistent **option naming convention** based on the leading character(s) of each option name:\n", "\n", "| Prefix | Data type | Example |\n", "|--------|-----------|--------|\n", "| `b` | Boolean (0 or 1) | `bDoForward 1` |\n", "| `i` | Integer | `iVerbose 0` |\n", "| `d` | Double (float) | `dMass 0.09` |\n", "| `s` | String | `sStellarModel baraffe` |\n", "| `sa` | String array (multiple values) | `saBodyFiles star.in planet.in` |\n", "\n", "Everything after a `#` on a line is a comment and is ignored by the parser.\n", "Option names are case-sensitive and must be spelled exactly as documented.\n", "\n", "See the [VPLanet input options reference](https://virtualplanetarylaboratory.github.io/vplanet/options.html)\n", "for a complete listing of all available parameters." ] }, { "cell_type": "markdown", "id": "d4e5f6a7", "metadata": {}, "source": [ "### 1.1 The Primary Input File (`vpl.in`)\n", "\n", "The primary file sets system-wide options and lists the body files to load.\n", "It must always be named **`vpl.in`** and be present in the simulation directory." ] }, { "cell_type": "code", "execution_count": 2, "id": "e5f6a7b8", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:47.813968Z", "iopub.status.busy": "2026-03-01T22:35:47.813696Z", "iopub.status.idle": "2026-03-01T22:35:47.816315Z", "shell.execute_reply": "2026-03-01T22:35:47.816030Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# Primary input file for Trappist system\n", "sSystemName\tTrappist\t\t\t# System Name\n", "iVerbose\t0\t\t\t# Verbosity level\n", "bOverwrite\t1\t\t\t# Allow file overwrites?\n", "\n", "# All space after a # is ignored, as is white space\n", "# The first lowercase letter(s) denote the cast: b=boolean, i=int, d=double,\n", "# s=string. An \"a\" indicates an array and multiple arguments are allowed/expected.\n", "\n", "# List of \"body files\" that contain body-specific parameters\n", "saBodyFiles\tstar.in\t# The host star\n", "\n", "# Array options can continue to the next line with a terminating \"$\". The $ can be\n", "# at the end of the string or not. Comments are allowed afterwards.\n", "\n", "# Input/Output Units\n", "sUnitMass\tsolar\t\t# Options: gram, kg, Earth, Neptune, Jupiter, solar\n", "sUnitLength\taU\t\t# Options: cm, m, km, Earth, Jupiter, solar, AU\n", "sUnitTime\tYEAR\t\t# Options: sec, day, year, Myr, Gyr\n", "sUnitAngle\td\t\t# Options: deg, rad\n", "sUnitTemp K\n", "\n", "# Units specified in the primary input file are propagated into the bodies. Otherwise\n", "# specifiy units on a per body basis in the body files.\n", "# Most string arguments can be in any case and need only be unambiguous.\n", "\n", "# Input/Output\n", "bDoLog\t\t1\t\t# Write a log file?\n", "iDigits\t\t6 \t# Maximum number of digits to right of decimal\n", "dMinValue\t1e-10\t\t# Minimum value of eccentricity/obliquity\n", "\n", "# Option names must be exact in spelling and case.\n", "\n", "# Evolution Parameters\n", "bDoForward\t1\t\t# Perform a forward evolution?\n", "bVarDt\t\t1\t\t# Use variable timestepping?\n", "dEta\t\t1.0e-2\t\t# Coefficient for variable timestepping\n", "dStopTime\t8.0e9\t\t# Stop time for evolution\n", "dOutputTime\t1.0e7\t\t# Output timesteps (assuming in body files)\n", "\n", "# Some options are only permitted in the primary file, some are forbidden.\n", "# That should really be documented!\n", "\n" ] } ], "source": [ "with open(os.path.join(INFILE_PATH, \"vpl.in\")) as f:\n", " print(f.read())" ] }, { "cell_type": "markdown", "id": "f6a7b8c9", "metadata": {}, "source": [ "**Key options explained:**\n", "\n", "| Option | Value | Description |\n", "|--------|-------|-------------|\n", "| `sSystemName` | `Trappist` | Prefix for all output files (e.g. `Trappist.log`, `Trappist.star.forward`) |\n", "| `iVerbose` | `0` | Verbosity level printed to terminal (0 = silent, 5 = maximum) |\n", "| `bOverwrite` | `1` | Allow output files to be overwritten on re-runs |\n", "| `saBodyFiles` | `star.in` | Space-separated list of body input files to load |\n", "| `sUnitMass` | `solar` | Mass unit for input/output (`gram`, `kg`, `Earth`, `Neptune`, `Jupiter`, `solar`) |\n", "| `sUnitLength` | `AU` | Length unit (`cm`, `m`, `km`, `Earth`, `Jupiter`, `solar`, `AU`) |\n", "| `sUnitTime` | `YEAR` | Time unit (`sec`, `day`, `year`, `Myr`, `Gyr`) |\n", "| `sUnitAngle` | `d` | Angle unit (`d` = degrees, `rad` = radians) |\n", "| `bDoLog` | `1` | Write a `.log` file summarising initial and final state |\n", "| `bDoForward` | `1` | Run the simulation forward in time |\n", "| `bVarDt` | `1` | Use adaptive (variable) timestepping |\n", "| `dEta` | `1e-2` | Coefficient controlling adaptive timestep size (smaller = more accurate, slower) |\n", "| `dStopTime` | `8e9` | Simulation end time in `sUnitTime` units (here: 8 Gyr) |\n", "| `dOutputTime` | `1e7` | Interval at which time-series data are written (here: every 10 Myr) |\n", "\n", "> **VPLanet docs:** [Primary input file options](https://virtualplanetarylaboratory.github.io/vplanet/options.html#primary-input-file)" ] }, { "cell_type": "markdown", "id": "a7b8c9d0", "metadata": {}, "source": [ "### 1.2 Body Files (`star.in`)\n", "\n", "Each body in the simulation — star, planet, or moon — has its own `.in` file.\n", "The **`saModules`** option activates the VPLanet physics modules for that body;\n", "each module introduces additional parameters specific to that physics.\n", "\n", "Here we use the `stellar` module, which models stellar evolution\n", "using the [Baraffe et al. (2015)](https://doi.org/10.1051/0004-6361/201425481) pre-main-sequence grids\n", "and the [Matt et al. (2015)](https://doi.org/10.1088/2041-8205/799/2/L23) magnetic braking prescription.\n", "\n", "See the [VPLanet modules reference](https://virtualplanetarylaboratory.github.io/vplanet/modules.html)\n", "for the full list of available modules and their options." ] }, { "cell_type": "code", "execution_count": 3, "id": "b8c9d0e1", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:47.817329Z", "iopub.status.busy": "2026-03-01T22:35:47.817215Z", "iopub.status.idle": "2026-03-01T22:35:47.819178Z", "shell.execute_reply": "2026-03-01T22:35:47.818908Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "# Host star parameters\n", "sName\t\tstar # Body name\n", "saModules \tstellar # Active modules\n", "\n", "# Physical properties\n", "dMass \t0.09 # Mass in Msun\n", "dRotPeriod -1.0 # Rotation period, negative -> days\n", "dAge 1.0e6 # Initial age [yr]\n", "\n", "# STELLAR parameters\n", "sStellarModel\t baraffe # Stellar evolution model\n", "bHaltEndBaraffeGrid 0 # Don't end sim when we reach end of grid\n", "sMagBrakingModel matt # Magnetic braking model\n", "dSatXUVFrac 1.0e-3 # XUV Saturation fraction\n", "dSatXUVTime -1.0 # XUV Saturation timescale, negative-> in Gyr\n", "dXUVBeta 1.23 # XUV decay power law exponent\n", "\n", "saOutputOrder \tTime -Luminosity -LXUVStellar -Radius Temperature -RotPer # Outputs\n", "\n" ] } ], "source": [ "with open(os.path.join(INFILE_PATH, \"star.in\")) as f:\n", " print(f.read())" ] }, { "cell_type": "markdown", "id": "c9d0e1f2", "metadata": {}, "source": [ "**Key options explained:**\n", "\n", "| Option | Value | Description |\n", "|--------|-------|-------------|\n", "| `sName` | `star` | Name of this body; must match the filename without `.in`. Used to label output files |\n", "| `saModules` | `stellar` | Physics modules active for this body |\n", "| `dMass` | `0.09` | Stellar mass in `sUnitMass` units (here: 0.09 M☉) |\n", "| `dRotPeriod` | `-1.0` | Initial rotation period. **Negative value** → units are days regardless of `sUnitTime` |\n", "| `dAge` | `1e6` | Starting age in `sUnitTime` (here: 1 Myr — the simulation starts at this age) |\n", "| `sStellarModel` | `baraffe` | Stellar evolution grid (`baraffe`, `solar`, `proxima`, `none`) |\n", "| `sMagBrakingModel` | `matt` | Magnetic braking prescription (`matt`, `reiners`, `skumanich`, `none`) |\n", "| `dSatXUVFrac` | `1e-3` | XUV saturation luminosity as a fraction of bolometric luminosity |\n", "| `dSatXUVTime` | `-1.0` | XUV saturation timescale. **Negative value** → units are Gyr |\n", "| `dXUVBeta` | `1.23` | Power-law exponent for XUV decay after saturation |\n", "| `saOutputOrder` | `Time -Luminosity ...` | Variables written to the time-series `.forward` file |\n", "\n", "#### The `saOutputOrder` option\n", "\n", "This controls what columns appear in the `.forward` output file.\n", "A **negative sign prefix** (`-Luminosity`) instructs VPLanet to output that quantity in custom units\n", "rather than the system-wide units set in `vpl.in`:\n", "\n", "```\n", "saOutputOrder Time -Luminosity -LXUVStellar -Radius Temperature -RotPer\n", "```\n", "\n", "The actual units used for each column are reported in the log file's `Output Order:` line.\n", "\n", "To check what the custom units are for a vplanet output, run the following line in the command line:\n", "\n", "```bash\n", "vplanet -h\n", "```" ] }, { "cell_type": "markdown", "id": "d0e1f2a3", "metadata": {}, "source": [ "## 2. Running VPLanet from the Command Line\n", "\n", "Once `vpl.in` and the body files are in place, run the simulation by navigating to the infile directory\n", "and calling:\n", "\n", "```bash\n", "cd /path/to/infiles/stellar/\n", "vplanet vpl.in\n", "```\n", "\n", "The argument `vpl.in` is required — it tells VPLanet which primary input file to use.\n", "From this notebook, we can do the same thing with `subprocess`:" ] }, { "cell_type": "code", "execution_count": 4, "id": "e1f2a3b4", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:47.820189Z", "iopub.status.busy": "2026-03-01T22:35:47.820081Z", "iopub.status.idle": "2026-03-01T22:35:53.233856Z", "shell.execute_reply": "2026-03-01T22:35:53.233532Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "VPLanet finished successfully.\n", "(no terminal output — iVerbose is set to 0)\n" ] } ], "source": [ "result = subprocess.run(\n", " [\"vplanet\", \"vpl.in\"],\n", " cwd=INFILE_PATH,\n", " capture_output=True,\n", " text=True,\n", ")\n", "\n", "if result.returncode == 0:\n", " print(\"VPLanet finished successfully.\")\n", " print(result.stdout if result.stdout else \"(no terminal output — iVerbose is set to 0)\")\n", "else:\n", " print(\"VPLanet encountered an error:\")\n", " print(result.stderr)" ] }, { "cell_type": "markdown", "id": "f2a3b4c5", "metadata": {}, "source": [ "With `iVerbose 0`, VPLanet produces no terminal output on a successful run.\n", "Setting `iVerbose 5` in `vpl.in` will print detailed progress messages.\n", "\n", "All simulation output is written to files — described in the next section." ] }, { "cell_type": "markdown", "id": "a3b4c5d6", "metadata": {}, "source": [ "## 3. Understanding VPLanet Output Files\n", "\n", "After a successful run, VPLanet creates the following output files in the simulation directory.\n", "The filenames are prefixed with `sSystemName` (here: `Trappist`):\n", "\n", "| File | Description |\n", "|------|-------------|\n", "| `Trappist.log` | Human-readable log with the initial and final state of every quantity, in SI units |\n", "| `Trappist.star.forward` | Time-series data for the `star` body (columns defined by `saOutputOrder`) |\n", "\n", "If you had multiple bodies (e.g. a planet named `planet`),\n", "there would be a separate `Trappist.planet.forward` file for each one." ] }, { "cell_type": "markdown", "id": "b4c5d6e7", "metadata": {}, "source": [ "### 3.1 The Log File\n", "\n", "The log file (`Trappist.log`) is written in SI units regardless of the `sUnitMass`/`sUnitLength`/`sUnitTime`\n", "settings in `vpl.in`. It is divided into four sections:\n", "\n", "1. **Header** — executable path, VPLanet version, input files used, and internal unit system\n", "2. **Formatting** — integration method, timestep information\n", "3. **Initial system properties** — complete state of every body at `t = dAge`\n", "4. **Final system properties** — complete state of every body at `t = dAge + dStopTime`\n", "\n", "The log file is the most reliable place to read initial and final values for any quantity,\n", "including quantities not listed in `saOutputOrder`. The `Output Order:` line near the end\n", "of each body's section also confirms the column order and units of the `.forward` file." ] }, { "cell_type": "code", "execution_count": 5, "id": "c5d6e7f8", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.235068Z", "iopub.status.busy": "2026-03-01T22:35:53.234953Z", "iopub.status.idle": "2026-03-01T22:35:53.237106Z", "shell.execute_reply": "2026-03-01T22:35:53.236853Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-------- Log file Trappist.log -------\n", "\n", "Executable: /home/jbirky/anaconda3/envs/vpi/bin/vplanet\n", "Version: Unknown\n", "System Name: Trappist\n", "Primary Input File: vpl.in\n", "Body File #1: star.in\n", "Allow files to be overwitten: Yes\n", "Mass Units: Grams\n", "Length Units: Meters\n", "Time Units: Seconds\n", "Angle Units: Radians\n", "\n", "------- FORMATTING -----\n", "Verbosity Level: 0\n", "Crossover Decade for Scientific Notation: 4\n", "Number of Digits After Decimal: 6\n", "Integration Method: Runge-Kutta4\n", "Direction: Forward\n", "Time Step: 3.155760e+07\n", "Stop Time: 2.524608e+17\n", "Output Interval: 3.155760e+14\n", "Use Variable Timestep: Yes\n", "dEta: 0.010000\n", "Minimum Value of ecc and obl: 1.000000e-10\n", "\n", "\n", "---- INITIAL SYSTEM PROPERTIES ----\n", "(Age) System Age [sec]: 3.155760e+13 \n", "(Time) Simulation Time [sec]: 0.000000 \n", "(TotAngMom) Total Angular Momentum [kg*m^2/sec]: 1.149304e+42 \n", "(TotEnergy) Total System Energy [kg*m^2/sec^2]: -1.877809e+39 \n", "(PotEnergy) Body's non-orbital Potential Energy [kg*m^2/sec^2]: -1.919599e+39 \n", "(KinEnergy) Body's non-orbital Kinetic Energy [kg*m^2/sec^2]: 4.178988e+37 \n", "(DeltaTime) Average Timestep Over Last Output Interval [sec]: 0.000000 \n", "\n", "----- BODY: star ----\n", "Active Modules: STELLAR\n", "Module Bit Sum: 65\n", "Color: 000000\n", "(Mass) Mass [kg]: 1.789574e+29 \n", "(Radius) Radius [Rearth]: 104.749856 \n", "(RadGyra) Radius of Gyration/Moment of Inertia Constant []: 0.444800 \n", "(RotAngMom) Rotational Angular Momentum [kg*m^2/sec]: 1.149304e+42 \n", "(RotVel) Rotational Velocity [m/sec]: 4.858597e+04 \n", "(BodyType) Type of Body (0 == planet) []: 0.000000 \n", "(RotRate) Rotational Frequency [/sec]: 7.272205e-05 \n", "(RotPer) Rotational Period [days]: 1.000000 \n", "(Density) Average Density [kg/m^3]: 143.260634 \n", "(HZLimitDryRunaway) Semi-major axis of Dry Runaway HZ Limit [m]: 3.305062e+10 \n", "(HZLimRecVenus) Recent Venus HZ Limit [m]: 2.977014e+10 \n", "(HZLimRunaway) Runaway Greenhouse HZ Limit [m]: 3.916594e+10 \n", "(HZLimMoistGreenhouse) Moist Greenhouse HZ Limit [m]: 3.939084e+10 \n", "(HZLimMaxGreenhouse) Maximum Greenhouse HZ Limit [m]: 7.572440e+10 \n", "(HZLimEarlyMars) Early Mars HZ Limit [m]: 8.258537e+10 \n", "(Instellation) Orbit-averaged INcident STELLar radiATION [kg/sec^3]: -1.000000 \n", "(CriticalSemiMajorAxis) Holman & Wiegert (1999) P-type Critical Semi-major Axis [m]: -1.000000 \n", "(LXUVTot) Total XUV Luminosity [kg/sec^3]: 2.278648e+22 \n", "(LostEnergy) Body's Total Lost Energy [kg*m^2/sec^2]: 5.562685e-309 \n", "(LostAngMom) Lost Angular Momentum due to Magnetic Braking [kg*m^2/sec]: 5.562685e-309 \n", "(EscapeVelocity) Escape Velocity [m/sec]: 1.890905e+05 \n", "----- STELLAR PARAMETERS (star)------\n", "(Luminosity) Luminosity [LSUN]: 0.059247 \n", "(LXUVStellar) Base X-ray/XUV Luminosity [LSUN]: 5.924722e-05 \n", "(Temperature) Effective Temperature [K]: 2907.334487 \n", "(LXUVFrac) Fraction of luminosity in XUV []: 0.001000 \n", "(RossbyNumber) Rossby Number []: 0.014106 \n", "(DRotPerDtStellar) Time Rate of Change of Rotation Period in STELLAR []: -8.292795e-11 \n", "(WindTorque) Stellar Wind Torque []: 4.662997e+26 \n", "\n", "Output Order: Time[year] Luminosity[LSUN] LXUVStellar[LSUN] Radius[Rearth] Temperature[K] RotPer[days]\n", "Grid Output Order:\n", "\n", "\n", "\n", "---- FINAL SYSTEM PROPERTIES ----\n", "(Age) System Age [sec]: 2.524924e+17 \n", "(Time) Simulation Time [sec]: 2.524608e+17 \n", "(TotAngMom) Total Angular Momentum [kg*m^2/sec]: 1.123683e+42 \n", "(TotEnergy) Total System Energy [kg*m^2/sec^2]: -1.904483e+39 \n", "(PotEnergy) Body's non-orbital Potential Energy [kg*m^2/sec^2]: -1.631379e+40 \n", "(KinEnergy) Body's non-orbital Kinetic Energy [kg*m^2/sec^2]: 3.864917e+32 \n", "(DeltaTime) Average Timestep Over Last Output Interval [sec]: 3.155760e+14 \n", "\n", "----- BODY: star ----\n", "Active Modules: STELLAR\n", "Module Bit Sum: 65\n", "Color: 000000\n", "(Mass) Mass [kg]: 1.789574e+29 \n", "(Radius) Radius [Rearth]: 12.325630 \n", "(RadGyra) Radius of Gyration/Moment of Inertia Constant []: 0.465000 \n", "(RotAngMom) Rotational Angular Momentum [kg*m^2/sec]: 4.299455e+38 \n", "(RotVel) Rotational Velocity [m/sec]: 141.337450 \n", "(BodyType) Type of Body (0 == planet) []: 0.000000 \n", "(RotRate) Rotational Frequency [/sec]: 1.797864e-06 \n", "(RotPer) Rotational Period [days]: 40.449143 \n", "(Density) Average Density [kg/m^3]: 8.793460e+04 \n", "(HZLimitDryRunaway) Semi-major axis of Dry Runaway HZ Limit [m]: 3.208822e+09 \n", "(HZLimRecVenus) Recent Venus HZ Limit [m]: 2.902371e+09 \n", "(HZLimRunaway) Runaway Greenhouse HZ Limit [m]: 3.813333e+09 \n", "(HZLimMoistGreenhouse) Moist Greenhouse HZ Limit [m]: 3.840324e+09 \n", "(HZLimMaxGreenhouse) Maximum Greenhouse HZ Limit [m]: 7.457113e+09 \n", "(HZLimEarlyMars) Early Mars HZ Limit [m]: 8.132979e+09 \n", "(Instellation) Orbit-averaged INcident STELLar radiATION [kg/sec^3]: -1.000000 \n", "(CriticalSemiMajorAxis) Holman & Wiegert (1999) P-type Critical Semi-major Axis [m]: -1.000000 \n", "(LXUVTot) Total XUV Luminosity [kg/sec^3]: 1.663956e+19 \n", "(LostEnergy) Body's Total Lost Energy [kg*m^2/sec^2]: 1.440930e+40 \n", "(LostAngMom) Lost Angular Momentum due to Magnetic Braking [kg*m^2/sec]: 1.123253e+42 \n", "(EscapeVelocity) Escape Velocity [m/sec]: 5.512414e+05 \n", "----- STELLAR PARAMETERS (star)------\n", "(Luminosity) Luminosity [LSUN]: 0.000558 \n", "(LXUVStellar) Base X-ray/XUV Luminosity [LSUN]: 4.326459e-08 \n", "(Temperature) Effective Temperature [K]: 2645.001971 \n", "(LXUVFrac) Fraction of luminosity in XUV []: 7.746982e-05 \n", "(RossbyNumber) Rossby Number []: 0.498844 \n", "(DRotPerDtStellar) Time Rate of Change of Rotation Period in STELLAR []: 2.326653e-11 \n", "(WindTorque) Stellar Wind Torque []: 2.862345e+21 \n", "\n", "Output Order: Time[year] Luminosity[LSUN] LXUVStellar[LSUN] Radius[Rearth] Temperature[K] RotPer[days]\n", "Grid Output Order:\n", "\n" ] } ], "source": [ "log_path = os.path.join(INFILE_PATH, \"Trappist.log\")\n", "with open(log_path) as f:\n", " print(f.read())" ] }, { "cell_type": "markdown", "id": "d6e7f8a9", "metadata": {}, "source": [ "### 3.2 The Forward File\n", "\n", "The forward file (`Trappist.star.forward`) contains one row per output timestep (`dOutputTime`),\n", "with columns corresponding to the variables in `saOutputOrder`.\n", "\n", "For this example:\n", "```\n", "saOutputOrder Time -Luminosity -LXUVStellar -Radius Temperature -RotPer\n", "```\n", "\n", "The actual units for each column are confirmed in the log file:\n", "```\n", "Output Order: Time[year] Luminosity[LSUN] LXUVStellar[LSUN] Radius[Rearth] Temperature[K] RotPer[days]\n", "```\n", "\n", "The file is plain whitespace-delimited ASCII — easy to read with `numpy.loadtxt`." ] }, { "cell_type": "code", "execution_count": 6, "id": "e7f8a9b0", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.238089Z", "iopub.status.busy": "2026-03-01T22:35:53.237990Z", "iopub.status.idle": "2026-03-01T22:35:53.241361Z", "shell.execute_reply": "2026-03-01T22:35:53.241108Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Timesteps recorded : 801\n", "Time range : 0.00e+00 – 8.00e+09 yr\n", "Luminosity : 0.0592 → 0.000558 L_sun\n", "Radius : 104.75 → 12.33 R_earth\n", "Rotation period : 1.00 → 40.45 days\n" ] } ], "source": [ "forward_path = os.path.join(INFILE_PATH, \"Trappist.star.forward\")\n", "data = np.loadtxt(forward_path)\n", "\n", "# Assign columns based on the Output Order line from the log file\n", "time_yr = data[:, 0] # Time [yr]\n", "luminosity = data[:, 1] # Luminosity [L_sun]\n", "lxuv = data[:, 2] # XUV Luminosity [L_sun]\n", "radius = data[:, 3] # Radius [R_earth]\n", "temperature = data[:, 4] # Effective temperature [K]\n", "rot_period = data[:, 5] # Rotation period [days]\n", "\n", "print(f\"Timesteps recorded : {len(time_yr)}\")\n", "print(f\"Time range : {time_yr[0]:.2e} – {time_yr[-1]:.2e} yr\")\n", "print(f\"Luminosity : {luminosity[0]:.4f} → {luminosity[-1]:.6f} L_sun\")\n", "print(f\"Radius : {radius[0]:.2f} → {radius[-1]:.2f} R_earth\")\n", "print(f\"Rotation period : {rot_period[0]:.2f} → {rot_period[-1]:.2f} days\")" ] }, { "cell_type": "code", "execution_count": 7, "id": "f8a9b0c1", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.242274Z", "iopub.status.busy": "2026-03-01T22:35:53.242175Z", "iopub.status.idle": "2026-03-01T22:35:53.633986Z", "shell.execute_reply": "2026-03-01T22:35:53.633676Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "time_gyr = time_yr / 1e9\n", "\n", "fig, axes = plt.subplots(2, 2, figsize=(10, 7), sharex=True)\n", "\n", "axes[0, 0].semilogy(time_gyr, luminosity)\n", "axes[0, 0].set_ylabel(r\"Luminosity [$L_\\odot$]\")\n", "\n", "axes[0, 1].semilogy(time_gyr, lxuv)\n", "axes[0, 1].set_ylabel(r\"XUV Luminosity [$L_\\odot$]\")\n", "\n", "axes[1, 0].semilogy(time_gyr, radius)\n", "axes[1, 0].set_ylabel(r\"Radius [$R_\\oplus$]\")\n", "\n", "axes[1, 1].plot(time_gyr, rot_period)\n", "axes[1, 1].set_ylabel(\"Rotation Period [days]\")\n", "\n", "for ax in axes[1]:\n", " ax.set_xlabel(\"Time [Gyr]\")\n", "\n", "fig.suptitle(r\"VPLanet Stellar Evolution: 0.09 $M_\\odot$ Star\", fontsize=13)\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "a9b0c1d2", "metadata": {}, "source": [ "## 4. Running the Same Model Through `vplanet_inference`\n", "\n", "`vplanet_inference` wraps VPLanet in a Python interface that handles:\n", "\n", "- **Unit conversion** — specify parameters in convenient astronomical units via `astropy.units`;\n", " `vplanet_inference` automatically converts everything to SI before substituting into the infiles. \\\n", " This means you don't have to worry about performing any unit conversions manually or setting the `vpl` \n", " file units to be consistent with your input values--you just have to specify your value with astropy units!\n", "- **Parameter substitution** — values are injected into template infiles at runtime;\n", " the template files are never modified\n", "- **Output extraction** — final-state scalar values or time-series arrays are returned\n", " as NumPy arrays in the units you request\n", "\n", "The central class is `VplanetModel`. You configure it once — specifying which parameters\n", "to vary and which outputs to collect — then call `run_model(theta)` with a parameter vector.\n", "\n", "### 4.1 Declaring Input Parameters (`inparams`)\n", "\n", "`inparams` is a dict that maps parameter names to `astropy` units:\n", "\n", "```python\n", "inparams = {\n", " \".\": ,\n", " ...\n", "}\n", "```\n", "\n", "- Use **`\"vpl.\"`** for parameters in `vpl.in`\n", "- Use **`\".\"`** for parameters in a body file, where `` matches\n", " the filename without `.in` (e.g. `\"star.dMass\"` for `star.in`)\n", "- The `` must match the VPLanet option name exactly (e.g. `dMass`, `dStopTime`)\n", "\n", "When you call `run_model(theta)`, the values in `theta` are interpreted in the declared units\n", "and converted to SI before being written to the infiles.\n", "\n", "### 4.2 Declaring Output Parameters (`outparams`)\n", "\n", "`outparams` is a dict that maps output quantity names to the `astropy` units you want back:\n", "\n", "```python\n", "outparams = {\n", " \"final..\": ,\n", " # or\n", " \"initial..\": ,\n", " ...\n", "}\n", "```\n", "\n", "- `` names match VPLanet output variable names — the same names used in `saOutputOrder`\n", " and listed in the [output variables reference](https://virtualplanetarylaboratory.github.io/vplanet/output.html)\n", "- `final.*` reads from the **Final System Properties** section of the log file\n", "- `initial.*` reads from the **Initial System Properties** section\n", "\n", "**Note:** `VplanetModel` sorts `outparams` alphabetically internally.\n", "The output array from `run_model()` follows this same sorted order, accessible via `vpm.outparams`." ] }, { "cell_type": "code", "execution_count": 8, "id": "b0c1d2e3", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.635054Z", "iopub.status.busy": "2026-03-01T22:35:53.634933Z", "iopub.status.idle": "2026-03-01T22:35:53.636964Z", "shell.execute_reply": "2026-03-01T22:35:53.636716Z" } }, "outputs": [], "source": [ "# Input parameters: which options to vary and what units the values are supplied in\n", "inparams = {\n", " \"star.dMass\": u.Msun, # stellar mass [solar masses]\n", " \"vpl.dStopTime\": u.Gyr, # simulation stop time [Gyr]\n", "}\n", "\n", "# Output parameters: which final-state quantities to collect and what units to return them in\n", "outparams = {\n", " \"final.star.Luminosity\": u.Lsun, # final bolometric luminosity [L_sun]\n", " \"final.star.Radius\": u.Rsun, # final stellar radius [R_sun]\n", " \"final.star.Temperature\": u.K, # final effective temperature [K]\n", " \"final.star.RotPer\": u.day, # final rotation period [days]\n", "}" ] }, { "cell_type": "markdown", "id": "0b5370fd", "metadata": {}, "source": [ "We can check if our units are consistent with what `vplanet` expects by running:" ] }, { "cell_type": "code", "execution_count": 9, "id": "fdaf1c77", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Parameter User unit VPLanet unit Status\n", "-----------------------------------------------------------------------------\n", "star.dMass solMass earthMass OK\n", "vpl.dStopTime Gyr yr OK\n", "\n" ] }, { "data": { "text/plain": [ "{'consistent': [('star.dMass', Unit(\"solMass\"), Unit(\"earthMass\")),\n", " ('vpl.dStopTime', Unit(\"Gyr\"), Unit(\"yr\"))],\n", " 'inconsistent': [],\n", " 'unknown': []}" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vpi.check_units(inparams)" ] }, { "cell_type": "code", "execution_count": 10, "id": "812465e5", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Parameter User unit VPLanet unit Status\n", "--------------------------------------------------------------------------------------\n", "final.star.Luminosity solLum solLum OK\n", "final.star.Radius solRad earthRad OK\n", "final.star.RotPer d d OK\n", "final.star.Temperature K (not in vplanet -H) unknown\n", "\n" ] }, { "data": { "text/plain": [ "{'consistent': [('final.star.Luminosity', Unit(\"solLum\"), Unit(\"solLum\")),\n", " ('final.star.Radius', Unit(\"solRad\"), Unit(\"earthRad\")),\n", " ('final.star.RotPer', Unit(\"d\"), Unit(\"d\"))],\n", " 'inconsistent': [],\n", " 'unknown': [('final.star.Temperature', Unit(\"K\"))]}" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "vpi.check_units(outparams)" ] }, { "cell_type": "markdown", "id": "a6b8588d", "metadata": {}, "source": [ "Note: if a parameter is marked with status \"unknown\", set the units to SI units. Ill specified parameters will return as \"inconsistent\", for example:" ] }, { "cell_type": "code", "execution_count": 13, "id": "5558a9b7", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Parameter User unit VPLanet unit Status\n", "--------------------------------------------------------------------------\n", "Luminosity m solLum INCONSISTENT ✗\n", "RotPer solLum d INCONSISTENT ✗\n", "\n" ] }, { "ename": "ValueError", "evalue": "The following parameters have incompatible units:\n\n Luminosity: user supplied Unit(\"m\"), vplanet default unit has dimension 'power/radiant flux' (e.g. solLum)\n RotPer: user supplied Unit(\"solLum\"), vplanet default unit has dimension 'time' (e.g. d)", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[13], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mvpi\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcheck_units\u001b[49m\u001b[43m(\u001b[49m\u001b[43m{\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mLuminosity\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mm\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mRotPer\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mLsun\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m\n", "File \u001b[0;32m~/Tresorit/packages/vplanet_inference/vplanet_inference/parameters.py:351\u001b[0m, in \u001b[0;36mcheck_units\u001b[0;34m(inparams, outparams)\u001b[0m\n\u001b[1;32m 345\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m key, u_unit, vp_unit \u001b[38;5;129;01min\u001b[39;00m inconsistent:\n\u001b[1;32m 346\u001b[0m lines\u001b[38;5;241m.\u001b[39mappend(\n\u001b[1;32m 347\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mkey\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m: user supplied \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mu_unit\u001b[38;5;132;01m!r}\u001b[39;00m\u001b[38;5;124m, \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 348\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mvplanet default unit has dimension \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvp_unit\u001b[38;5;241m.\u001b[39mphysical_type\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 349\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m(e.g. \u001b[39m\u001b[38;5;132;01m{\u001b[39;00mvp_unit\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m)\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 350\u001b[0m )\n\u001b[0;32m--> 351\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;130;01m\\n\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;241m.\u001b[39mjoin(lines))\n\u001b[1;32m 353\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m {\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mconsistent\u001b[39m\u001b[38;5;124m\"\u001b[39m: consistent, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124minconsistent\u001b[39m\u001b[38;5;124m\"\u001b[39m: inconsistent, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124munknown\u001b[39m\u001b[38;5;124m\"\u001b[39m: unknown}\n", "\u001b[0;31mValueError\u001b[0m: The following parameters have incompatible units:\n\n Luminosity: user supplied Unit(\"m\"), vplanet default unit has dimension 'power/radiant flux' (e.g. solLum)\n RotPer: user supplied Unit(\"solLum\"), vplanet default unit has dimension 'time' (e.g. d)" ] } ], "source": [ "vpi.check_units({\"Luminosity\": u.m, \"RotPer\": u.Lsun})" ] }, { "cell_type": "code", "execution_count": 14, "id": "c1d2e3f4", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.637816Z", "iopub.status.busy": "2026-03-01T22:35:53.637704Z", "iopub.status.idle": "2026-03-01T22:35:53.641368Z", "shell.execute_reply": "2026-03-01T22:35:53.641120Z" } }, "outputs": [], "source": [ "# Initialise the model, pointing it at the stellar template infiles\n", "vpm = vpi.VplanetModel(\n", " inparams=inparams,\n", " outparams=outparams,\n", " inpath=INFILE_PATH,\n", " outpath=\"output/\", # temporary directory for each model run (deleted after)\n", " verbose=True, # print parameter values and unit conversions\n", ")" ] }, { "cell_type": "markdown", "id": "d2e3f4a5", "metadata": {}, "source": [ "### 4.3 Running a Single Model\n", "\n", "`run_model(theta)` accepts a 1-D array `theta` with one entry per `inparams` key,\n", "in the same order as declared. It returns a 1-D NumPy array of output values\n", "in the units declared in `outparams`, sorted alphabetically by output name." ] }, { "cell_type": "code", "execution_count": 15, "id": "e3f4a5b6", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:35:53.642297Z", "iopub.status.busy": "2026-03-01T22:35:53.642201Z", "iopub.status.idle": "2026-03-01T22:36:01.399708Z", "shell.execute_reply": "2026-03-01T22:36:01.399381Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "Input:\n", "-----------------\n", "star.dMass : 0.09 [solMass] (user) ---> 1.789568883628246e+29 [kg] (vpl file)\n", "vpl.dStopTime : 8.0 [Gyr] (user) ---> 2.524608e+17 [s] (vpl file)\n", "\n", "Created file output//260827543537879/vpl.in\n", "Created file output//260827543537879/star.in\n", "Executed model output//260827543537879/vpl.in 7.884 s\n", "\n", "Output:\n", "-----------------\n", "final.star.Luminosity : 0.0005610869905956113 [solLum]\n", "final.star.Radius : 0.11299965502371712 [solRad]\n", "final.star.Temperature : 2644.995292 [K]\n", "final.star.RotPer : 47.06512731481481 [d]\n", "\n" ] } ], "source": [ "# theta = [dMass (Msun), dStopTime (Gyr)]\n", "theta = np.array([0.09, 8.0])\n", "\n", "result = vpm.run_model(theta)" ] }, { "cell_type": "code", "execution_count": 17, "id": "f4a5b6c7", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:36:01.400843Z", "iopub.status.busy": "2026-03-01T22:36:01.400717Z", "iopub.status.idle": "2026-03-01T22:36:01.403252Z", "shell.execute_reply": "2026-03-01T22:36:01.402957Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Output:\n", " final.star.Luminosity = 0.00056109 [solLum]\n", " final.star.Radius = 0.113 [solRad]\n", " final.star.Temperature = 2645 [K]\n", " final.star.RotPer = 47.065 [d]\n" ] } ], "source": [ "# vpm.outparams and vpm.out_units reflect the internal sorted order\n", "print(\"Output:\")\n", "for name, unit, value in zip(vpm.outparams, vpm.out_units, result):\n", " print(f\" {name:<35s} = {value:.5g} [{unit}]\")" ] }, { "cell_type": "markdown", "id": "a5b6c7d8", "metadata": {}, "source": [ "### 4.4 Varying Input Parameters\n", "\n", "Because `theta` is just a NumPy array, it is straightforward to sweep over parameter values\n", "or feed in samples from a prior distribution. The example below compares three different stellar masses:" ] }, { "cell_type": "code", "execution_count": 19, "id": "b6c7d8e9", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:36:01.404288Z", "iopub.status.busy": "2026-03-01T22:36:01.404181Z", "iopub.status.idle": "2026-03-01T22:36:19.863624Z", "shell.execute_reply": "2026-03-01T22:36:19.863316Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ " Mass [Msun] Lum [Lsun] Rad [Rsun] Teff [K] Prot [d]\n", " 0.09 0.000561 0.11300 2645.0 47.07\n", " 0.10 0.000873 0.12400 2812.0 47.55\n", " 0.12 0.001503 0.14500 2983.0 48.50\n" ] } ], "source": [ "masses = [0.09, 0.10, 0.12] # stellar masses [M_sun] — must be within the Baraffe grid (~0.08–1.4 M_sun)\n", "stop_time = 8.0 # Gyr\n", "\n", "vpm_sweep = vpi.VplanetModel(\n", " inparams=inparams,\n", " outparams=outparams,\n", " inpath=INFILE_PATH,\n", " outpath=\"output/\",\n", " verbose=False,\n", ")\n", "\n", "print(f\"{'Mass [Msun]':>12} {'Lum [Lsun]':>12} {'Rad [Rsun]':>12} {'Teff [K]':>10} {'Prot [d]':>10}\")\n", "for m in masses:\n", " res = vpm_sweep.run_model(np.array([m, stop_time]))\n", " lum, rad, teff, rotper = res\n", " print(f\"{m:>12.2f} {lum:>12.6f} {rad:>12.5f} {teff:>10.1f} {rotper:>10.2f}\")" ] }, { "cell_type": "markdown", "id": "c7d8e9f0", "metadata": {}, "source": [ "### 4.5 Tracking Time Evolution\n", "\n", "Pass `timesteps` (an `astropy` Quantity) to record outputs at regular intervals throughout the simulation.\n", "When `timesteps` is set, `run_model()` returns a **dict** keyed by output parameter name:\n", "\n", "```python\n", "{\n", " \"Time\": ,\n", " \"final.star.Luminosity\": ,\n", " \"final.star.Radius\": ,\n", " ...\n", "}\n", "```" ] }, { "cell_type": "code", "execution_count": 20, "id": "d8e9f0a1", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:36:19.864799Z", "iopub.status.busy": "2026-03-01T22:36:19.864690Z", "iopub.status.idle": "2026-03-01T22:36:25.235274Z", "shell.execute_reply": "2026-03-01T22:36:25.234998Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Dict keys returned: ['final.star.Luminosity', 'final.star.Radius', 'final.star.Temperature', 'final.star.RotPer', 'Time']\n", "Number of timesteps: 801\n" ] } ], "source": [ "vpm_evol = vpi.VplanetModel(\n", " inparams=inparams,\n", " outparams=outparams,\n", " inpath=INFILE_PATH,\n", " outpath=\"output/\",\n", " timesteps=1e7 * u.yr, # record output every 10 Myr\n", " time_init=1e6 * u.yr, # starting age (sets dAge in the body file)\n", " verbose=False,\n", ")\n", "\n", "evol = vpm_evol.run_model(theta)\n", "\n", "print(\"Dict keys returned:\", list(evol.keys()))\n", "print(\"Number of timesteps:\", len(evol[\"Time\"]))" ] }, { "cell_type": "code", "execution_count": 21, "id": "e9f0a1b2", "metadata": { "execution": { "iopub.execute_input": "2026-03-01T22:36:25.236397Z", "iopub.status.busy": "2026-03-01T22:36:25.236270Z", "iopub.status.idle": "2026-03-01T22:36:29.424373Z", "shell.execute_reply": "2026-03-01T22:36:29.424112Z" } }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "time_gyr = evol[\"Time\"].to(u.Gyr).value\n", "\n", "fig, axes = plt.subplots(2, 2, figsize=(10, 7), sharex=True)\n", "\n", "axes[0, 0].semilogy(time_gyr, evol[\"final.star.Luminosity\"].value)\n", "axes[0, 0].set_ylabel(r\"Luminosity [$L_\\odot$]\")\n", "\n", "axes[0, 1].plot(time_gyr, evol[\"final.star.Radius\"].value)\n", "axes[0, 1].set_ylabel(r\"Radius [$R_\\odot$]\")\n", "\n", "axes[1, 0].plot(time_gyr, evol[\"final.star.Temperature\"].value)\n", "axes[1, 0].set_ylabel(\"Effective Temperature [K]\")\n", "\n", "axes[1, 1].plot(time_gyr, evol[\"final.star.RotPer\"].value)\n", "axes[1, 1].set_ylabel(\"Rotation Period [days]\")\n", "\n", "for ax in axes[1]:\n", " ax.set_xlabel(\"Time [Gyr]\")\n", "\n", "fig.suptitle(\n", " r\"vplanet\\_inference: 0.09 $M_\\odot$ Stellar Evolution\",\n", " fontsize=13,\n", ")\n", "plt.tight_layout()\n", "plt.show()" ] }, { "cell_type": "markdown", "id": "f0a1b2c3", "metadata": {}, "source": [ "## Summary\n", "\n", "| Task | How |\n", "|------|-----|\n", "| Set up input files | Edit `vpl.in` (system settings) and `.in` (body parameters + `saModules`) |\n", "| Run from command line | `cd ` → `vplanet vpl.in` |\n", "| Read log file | Open `.log` for initial/final values of all quantities (SI units) |\n", "| Read forward file | `np.loadtxt(\"..forward\")` — columns match `saOutputOrder` |\n", "| Run from Python | `VplanetModel(inparams, outparams, inpath=...)` → `run_model(theta)` |\n", "| Specify input units | Values in `inparams` dict use `astropy.units`; converted to SI automatically |\n", "| Specify output units | Values in `outparams` dict use `astropy.units`; results returned in those units |\n", "| Vary parameters | Change entries in `theta`; no need to edit any files |\n", "| Track time evolution | Pass `timesteps=` to `VplanetModel`; `run_model()` returns a dict of arrays |\n", "\n", "**Next steps:**\n", "- Explore other VPLanet modules (tidal evolution, atmospheric escape, orbital dynamics)\n", " in the [VPLanet module documentation](https://virtualplanetarylaboratory.github.io/vplanet/modules.html)\n", "- Run parameter sweeps and Bayesian inference using `vplanet_inference.AnalyzeVplanetModel`\n", " (see the **Quickstart** section of the documentation)" ] } ], "metadata": { "kernelspec": { "display_name": "vpi", "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.10.19" } }, "nbformat": 4, "nbformat_minor": 5 }