How does one calculate inclination from a graph of radial velocity?

Question

If a binary star system has a non-zero inclination, how would that show up in a graph of radial velocity?

How could I then extract the inclination from the graph?

Answer 1

From its RV graph alone, with no other information, you cannot calculate inclination. This is why RV velocity measurements are typically reported as "$v \sin{i}$", because what you're actually measuring is the orbital velocity projected along the line of sight. Without other information, you cannot disentangle the orbital velocity from the viewing angle.

What additional information could be had that would allow you to disentangle? The following list is probably not exhaustive.

• If you can observe the two stars as separate objects, then you can track their relative positions through an orbit and can measure inclination that way.
• If you have "light curves" (brightness measurements over time) for the star(s) and you see periodic eclipses corresponding to the period and correct epoch from the radial velocity data, then you know the stars are aligned such that they periodically have their light blocked by one, the other, or both. In such a case, you know that the inclination must be close to 90 degrees else the eclipses could not occur.
• If you have reliable distance measurements to the stars and determine somehow that they are main sequence stars, you can determine the star's masses via theoretical stellar evolution models and calculations given a measurement of absolute luminosity (from a measurement of the apparent luminosity coupled with the distance measure). Once you know the star's masses, you can calculate the expected orbital velocity, compare with your $v\sin{i}$ measure, and determine the inclination.
• If the stars are not main sequence stars in the above scenario, then you'll need some additional information (their ages should be sufficient) to correctly extract a mass from their apparent luminosity and color.

Answer 2

@NeutronStar's excellent answer sums up the situation nicely:

From its RV (radial velocity) graph alone, with no other information, you cannot calculate inclination. This is why RV velocity measurements are typically reported as "𝑣sin𝑖", because what you're actually measuring is the orbital velocity projected along the line of sight. Without other information, you cannot disentangle the orbital velocity from the viewing angle.

After being confused, I finally convinced myself that this is the case.

From a plot of radial velocity versus time, assuming the period is fairly short, we have a cyclic plot which gives us a specific shape and amplitude as well as a period. The period gives us the combination of the semi major axis associated with the pair's orbit around their center of mass, and mass of the system. From this answer:

$$T = 2 \pi \sqrt{\frac{a^3}{m_1 + m_2}},$$

You could have a heavy system or a light system with the same period, just different size orbits. The shapes of the two orbit could still be the same, and this means the shape of the velocity profiles could be the same as well, just with different scale factors. For velocity, the vis-viva equation tells us that that for smaller orbits the velocity profile will scale as $1/\sqrt{a}$.

As @NeutronStar's answer explains, the inclination of the orbit relative to our line of sight will reduce the radial velocity by a geometrical multiplicative factor $\cos(\theta_{inc})$. This will have no effect on the shape, it's strictly a scaling factor.

So there is no way to tell the difference between the geometrical reduction of a radial velocity curve and a physical reduction of the velocity due to lower reduced mass.

In curve-fitting parlance two parameters are 100% correlated and so they can never be independently determined from radial velocity alone.

By invitation I have included a simple Python script that builds a library of unique radial velocity profiles from elliptical orbits of varying eccentricity, inclination, and orientation. It doesn't span all possible Keplerian orbits, but it covers all possible shapes.

The first plot shows a sparse sampling, for each combination of eccentricity and rotation is plotted 0 and 60 degree inclinations. They have the same shape, just different amplitude. This is illustrated by the second plot which is the 0 degree versus 60 degree velocity profile, showing slopes of 2.0

The last plot the "library" of shapes.

When curve fitting via library search, one would compare a velocity profile shape to all of these and select the best fit, then either interpolate between nearest neighbor curves or do a quick iterative fit with an orbit generator.

def deriv(X, t):
    x, v = X.reshape(2, -1)
    acc  = -x * ((x**2).sum())**-1.5
    return np.hstack((v, acc))

import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import odeint as ODEint

halfpi, pi, twopi = [f*np.pi for f in (0.5, 1, 2)]
degs, rads        = 180/pi, pi/180

eccs   = np.linspace(0, 0.7,    30)
incs   = np.linspace(0, halfpi, 19)   # not used
thetas = np.linspace(0, pi,  41)[:-1]
times  = np.linspace(0, twopi, 257)[:-1]

A = np.array([f(thetas) for f in (np.cos, np.sin, np.ones_like)]).T[:, None, :, None]
B = np.array([f(incs) for f in (np.cos, np.ones_like, np.sin)]).T[:, None, None, :, None]   # not used

# Set semimajor axis a to 1.0, period to twopi

# build small library of orbits
velocities = [] 
for ecc in eccs:
    peri   = 1. - ecc
    v0     = np.sqrt(2./peri - 1.)
    X0     = np.array([peri, 0, 0] +  [0, v0, 0])
    answer, info = ODEint(deriv, X0, times, full_output=True)
    xx, vv = answer.T.reshape(2, 3, -1)
    velocities.append(vv)

velocities  = np.array(velocities)

big_library = B * A * velocities    # not used  # build larger library of rotations
med_library = A * velocities # build medium library of rotations

# library     = big_library[...,0, :].reshape(-1, big_library.shape[-1])   # not used
library     = med_library[...,0, :].reshape(-1, med_library.shape[-1])
noinc_library     = med_library[..., 0, :].reshape(-1, med_library.shape[-1])

print library.shape

a, b = big_library[[0, 12], ::10, ::10, 0].reshape(2, 12, -1) # small sample

if True:
    plt.figure()
    for i, (c, d) in enumerate(zip(a, b)):
        plt.subplot(4, 3, i+1)
        plt.plot(c)
        plt.plot(d)
        #plt.plot(c/d)
    plt.show()

if True:
    plt.figure()
    for i, (c, d) in enumerate(zip(a, b)):
        plt.subplot(4, 3, i+1)
        plt.plot(d, c)
    plt.show()

if True:
    plt.figure()
    for v in noinc_library:
        plt.plot(times/twopi, v)
    plt.show()