Gravity-darkened model

Gravity-darkened model#

GravityDarkenedModel implements the transit model of Barnes (ApJ 705, 683, 2009) for a fast-rotating, oblate, gravity-darkened star.

The physics#

A rapidly rotating star is not a sphere and not uniformly bright. Centrifugal force flattens it, so its equatorial radius exceeds its polar radius. The flattening reduces the effective surface gravity at the equator, and by von Zeipel’s theorem the local effective temperature scales as a power of the local gravity,

\[T_\mathrm{eff} \propto g^{\beta},\]

so the equator is cooler and dimmer than the poles. This is gravity darkening.

For a transit this changes everything. The stellar disk is no longer circular, its brightness is no longer radially symmetric, and the light curve depends on where the planet’s path crosses the star relative to the stellar spin axis. A transit across the hot pole is deeper than one across the cool equator, and the light curve becomes asymmetric unless the orbit is aligned with the stellar equator. That asymmetry carries information about the spin-orbit angle.

Because the disk is not radially symmetric, none of the other PyTransit models apply: they all assume a radially symmetric intensity profile. This model discretises the stellar surface and integrates numerically instead.

Parameters#

Beyond the usual transit parameters, the model takes

Name

Description

rho

Stellar density in g/cm³.

rperiod

Stellar rotation period in days. This sets the oblateness.

tpole

Effective temperature at the stellar pole in K.

phi

Stellar obliquity to the plane of the sky in radians.

beta

Gravity darkening exponent. About 0.25 for radiative envelopes, 0.08 for convective ones.

l

Orbital azimuth angle in radians, i.e. the projected spin-orbit angle.

Because the surface brightness varies with temperature, the model needs to convert temperature to flux in the observed passband. The filters argument takes an effective wavelength, a Filter, or a list of filters, and the model argument selects the stellar spectra used: 'blackbody', 'husser2013', or 'bt-settl'. See Stellar spectra and Contamination.

Usage#

from numpy import pi, linspace
from pytransit import GravityDarkenedModel
from pytransit.contamination import BoxcarFilter

time = linspace(-0.12, 0.12, 500)

tm = GravityDarkenedModel(filters=BoxcarFilter('TESS', 600, 1000),
                          model='blackbody', tmin=6000, tmax=9000)
tm.set_data(time)

flux = tm.evaluate(k=0.1, rho=0.5, rperiod=0.5, tpole=8000.0, phi=0.3, beta=0.25,
                   ldc=[0.2, 0.1], t0=0.0, p=2.0, a=5.0, i=0.5*pi, l=0.4)

Unlike the other models, evaluate takes a single parameter vector per call.

Note

Before PyTransit 2.11 the model had no evaluate method, and evaluate_ps was its only entry point. evaluate_ps is deprecated and will be removed in PyTransit 3.0; evaluate takes the same arguments, and additionally accepts a scalar k and a list ldc.

Accuracy and resolution#

The model integrates numerically over a discretised stellar surface and planet, so its accuracy is set by three resolutions: sres for the star, pres for the planet, and tres for the orbit. For a radius ratio of 0.1, measured against the analytic Mandel & Agol model for a non-rotating star, and against the brute-force evaluation for a rapidly rotating star with misaligned orbits (whose own error at 1500 pixels is 10 to 15 ppm):

sres, pres, tres

Non-rotating star

Rotating star

Time per 1000 points

160, 20, 60 (default)

30 ppm

50 ppm

3 ms

160, 40, 240

10 ppm

26 ppm

24 ms

sres sets the accuracy of the normalising stellar flux, and pres that of the mean stellar intensity behind the planet, which matters most at ingress and egress. Before PyTransit 2.11 the defaults were sres=80, pres=5, which gave errors of about 165 ppm.

evaluate_brute renders the stellar disk as an image and sums the pixels behind the planet. It is far slower, but its only approximation is the image resolution, which makes it the reference for checking the fast model in a new region of parameter space.

Visualisation#

visualize draws the gravity-darkened stellar disk with the planet’s path across it, which is by far the quickest way to check that a parameter set means what you think it means.

tm.visualize(k=0.1, p=2.0, rho=0.5, b=0.3, e=0.0, w=0.0, alpha=0.4,
             rperiod=0.5, tpole=8000.0, istar=0.3, beta=0.25, ldc=[0.2, 0.1])

API#

class pytransit.models.gdmodel.GravityDarkenedModel(filters, rstar=1.0, sres=160, pres=20, tres=60, model='blackbody', tmin=5000, tmax=7000, accurate_mu=True)[source]#

Bases: TransitModel

Transit model for a gravity-darkened fast-rotating oblate star.

Transit model for a gravity-darkened fast-rotating oblate star following Barnes (ApJ, 2009, 705).

__init__(filters, rstar=1.0, sres=160, pres=20, tres=60, model='blackbody', tmin=5000, tmax=7000, accurate_mu=True)[source]#
Parameters:

  • filters – Either the effective wavelength [nm], a Filter object, or a list of Filter objects.

  • rstar – Stellar radius [R_Sun]

  • sres – Stellar discretization resolution. Sets the accuracy of the normalising stellar flux.

  • pres – Planet discretization resolution. Sets the accuracy of the mean stellar intensity behind the planet, mostly at ingress and egress.

  • tres – Orbit discretization resolution.

  • model – The stellar model to use. Can be either ‘blackbody’, ‘husser2013’, or ‘bt-settl’.

  • tmin – Minimum allowed temperature [K].

  • tmax – Maximum allowed temperature [K].

Notes

With the default resolution the model error is 30 to 50 ppm for a radius ratio of 0.1. sres=160, pres=40, tres=240 brings it to 10 to 25 ppm at roughly eight times the cost.

visualize(k, p, rho, b, e, w, alpha, rperiod, tpole, istar, beta, ldc, figsize=(5, 5), ax=None, ntheta=18, vmin=0.0, vmax=1.0, passband=0)[source]#

Plot the gravity-darkened stellar disk with the planet’s path across it.

The quickest way to check that a parameter set means what you think it does: the plot shows the oblateness of the star, the temperature gradient from the hot poles to the cool equator, and where the planet crosses.

Parameters:

  • k – Physical parameters, as in evaluate_ps.

  • p – Physical parameters, as in evaluate_ps.

  • rho – Physical parameters, as in evaluate_ps.

  • rperiod – Physical parameters, as in evaluate_ps.

  • tpole – Physical parameters, as in evaluate_ps.

  • beta – Physical parameters, as in evaluate_ps.

  • ldc – Physical parameters, as in evaluate_ps.

  • e – Physical parameters, as in evaluate_ps.

  • w – Physical parameters, as in evaluate_ps.

  • b (float) – Impact parameter, used in place of the inclination.

  • alpha (float) – Projected spin-orbit angle in radians.

  • istar (float) – Stellar inclination in radians.

  • figsize (tuple, optional) – Figure size in inches, used only when ax is not given.

  • ax (matplotlib.axes.Axes, optional) – Axes to draw into. A new figure is created if this is None.

  • ntheta (int, optional) – Number of azimuthal samples used to draw the stellar surface.

  • vmin (float, optional) – Colour scale limits for the surface brightness.

  • vmax (float, optional) – Colour scale limits for the surface brightness.

  • passband (int, optional) – Index of the passband to draw.

Returns:

matplotlib.figure.Figure – The figure, or None when drawing into supplied axes.

evaluate(k, rho, rperiod, tpole, phi, beta, ldc, t0, p, a, i, l=0.0, e=0.0, w=0.0, copy=True)[source]#

Evaluate the transit model for a single set of parameters.

Parameters:

  • k (float or array-like) – Radius ratio as a float, or one radius ratio per passband as a 1D array.

  • rho (float) – Stellar density [g/cm^3].

  • rperiod (float) – Stellar rotation period [d].

  • tpole (float) – Temperature at the pole [K].

  • phi (float) – Star’s obliquity to the plane of the sky [rad].

  • beta (float) – Gravity darkening exponent.

  • ldc (array-like) – Quadratic limb darkening coefficients, two per passband, as a 1D array or a list.

  • t0 (float) – Zero epoch.

  • p (float) – Orbital period [d].

  • a (float) – Scaled orbital semi-major axis [R_star].

  • i (float) – Orbital inclination [rad].

  • l (float, optional) – Orbital azimuth angle, the projected spin-orbit angle [rad].

  • e (float, optional) – Orbital eccentricity.

  • w (float, optional) – Argument of periastron [rad].

  • copy (bool, optional) – Kept for compatibility with the transit model API; currently unused.

Returns:

ndarray – Modelled flux as a 1D ndarray.

Notes

Unlike the other transit models, this model evaluates one parameter vector per call.

evaluate_brute(k, rho, rperiod, tpole, phi, beta, ldc, t0, p, a, i, l=0.0, e=0.0, w=0.0, copy=True, plot=False, res=300)[source]#

Evaluate the model by brute-force integration over a rendered stellar image.

Renders the gravity-darkened stellar disk onto a res x res image and sums the pixels the planet covers at each time. This is far slower than evaluate_ps but makes no approximations beyond the image resolution, which makes it the reference for checking the fast model.

The physical parameters are the same as in evaluate_ps.

Parameters:

  • res (int, optional) – Side length of the rendered stellar image in pixels. Higher is more accurate and slower.

  • plot (bool, optional) – Draw the rendered star with the planet’s path across it.

  • copy (bool, optional) – Kept for compatibility with the transit model API; currently unused.

Returns:

ndarray – Modelled flux as a 1D array.

See also

evaluate_ps

the fast model this one validates.