radphen-iadpython 0.7.0__py3-none-any.whl

iadpython/quadrature.py

@@ -0,0 +1,172 @@
+"""Module for obtaining quadrature points and weights.
+
+Three types of gaussian quadrature are supported: normal Gaussian,
+Radau quadrature, and Lobatto quadrature.  The first method does not
+include either endpoint of integration, Radau quadrature includes one
+endpoint of the integration range, and Lobatto quadrature includes both
+endpoints.
+
+Example::
+
+    >>> import iad.quadrature
+
+    >>> n=8
+    >>> x, w = iad.quadrature.gauss(n)
+    >>> print(" i        x         weight")
+    >>> for i,x in enumerate(xi):
+    >>>     print("%2d   %+.12f %+.12f" % (i, x[i], w[i]))
+
+    >>> x, w = iad.quadrature.radau(n)
+    >>> print(" i        x         weight")
+    >>> for i,x in enumerate(xi):
+    >>>     print("%2d   %+.12f %+.12f" % (i, x[i], w[i]))
+
+    >>> x, w = iad.quadrature.lobatto(n)
+    >>> print(" i        x         weight")
+    >>> for i,x in enumerate(xi):
+    >>>     print("%2d   %+.12f %+.12f" % (i, x[i], w[i]))
+
+"""
+
+import functools
+import scipy.special
+import scipy.optimize
+import numpy as np
+
+__all__ = (
+    "gauss",
+    "radau",
+    "lobatto",
+)
+
+
+def _gauss_func(n, x):
+    """Zeroes of this function are the Gaussian quadrature points."""
+    return scipy.special.legendre(n)(x)
+
+
+def _radau_func(n, x):
+    """Zeros of this function are the Radau quadrature points."""
+    return (scipy.special.eval_legendre(n - 1, x) + scipy.special.eval_legendre(n, x)) / (1 + x)
+
+
+def _lobatto_func(n, x):
+    """Zeros of this function are the Lobatto quadrature points."""
+    return scipy.special.legendre(n - 1).deriv(1)(x)
+
+
+def gauss(n, a=-1, b=1):
+    """Return abscissas and weights for Gaussian quadrature.
+
+    The definite integral ranges from a to b.  The default
+    interval is -1 to 1.  The quadrature approximation is
+    just the sum of :math:`w_i f(x_i)`.  Neither a nor b is included
+    in the list of quadrature abscissas.
+
+    The result should be exact when integrating any polynomial
+    of degree 2n-1 or less.
+
+    If -a=b, then abscissas will be symmetric about the origin
+
+    Args:
+        n: number of quadrature points
+        a: lower limit of integral
+        b: upper limit of integral
+    Returns:
+        x: array of abscissas of length n
+        w: array of weights of length n
+    """
+    x, w, _ = scipy.special.roots_legendre(n, mu=True)
+
+    # scale for desired interval
+    x *= 0.5 * (a - b)
+    x += 0.5 * (a + b)
+    w *= 0.5 * (b - a)
+
+    return np.flip(x), np.flip(w)
+
+
+def radau(n, a=-1, b=1):
+    """Return abscissas and weights for Radau quadrature.
+
+    The definite integral ranges from a to b.  The default
+    interval is -1 to 1.  The quadrature approximation is
+    just the sum of :math:`w_i f(x_i)`.  The upper endpoint b is include
+    in the list of quadrature abscissas.
+
+    The result should be exact when integrating any polynomial
+    of degree 2n-2 or less.
+
+    Args:
+        n: number of quadrature points
+        a: lower limit of integral
+        b: upper limit of integral
+    Returns:
+        x: array of abscissas of length n
+        w: array of weights of length n
+    """
+    x = np.zeros(n)
+    w = np.zeros(n)
+    x[0] = -1
+
+    # the roots of P_{n} bracket the roots of P_{n}':
+    brackets = scipy.special.roots_legendre(n)[0]
+
+    f = functools.partial(_radau_func, n)
+    for i in range(n - 1):
+        x[i + 1] = scipy.optimize.brentq(f, brackets[i], brackets[i + 1])
+
+    pp = scipy.special.legendre(n - 1).deriv(1)
+    w[0] = 2 / n**2
+    w[1:] = 1 / pp(x[1:]) ** 2 / (1 - x[1:])
+
+    # scale for desired interval
+    x *= 0.5 * (a - b)
+    x += 0.5 * (b + a)
+    w *= 0.5 * (b - a)
+
+    return np.flip(x), np.flip(w)
+
+
+def lobatto(n, a=-1, b=1):
+    """Return abscissas and weights for Lobatto quadrature.
+
+    The definite integral ranges from a to b.  The default
+    interval is -1 to 1.  The quadrature approximation is
+    just the sum of w_i f(x_i).  Both endpoints a and b are include
+    in the list of quadrature abscissas.
+
+    The result should be exact when integrating any polynomial
+    of degree 2n-3 or less.
+
+    If -a=b, then abscissas will be symmetric about the origin
+
+    Args:
+        n: number of quadrature points
+        a: lower limit of integral
+        b: upper limit of integral
+    Returns:
+        x: array of abscissas of length n
+        w: array of weights of length n
+    """
+    x = np.zeros(n)
+    w = np.full(n, 2 / n / (n - 1))
+    x[0] = -1
+    x[-1] = 1
+
+    # The roots of P_{n-1} bracket the roots of P_{n-1}':
+    brackets = scipy.special.roots_legendre(n - 1)[0]
+
+    f = functools.partial(_lobatto_func, n)
+    for i in range(n - 2):
+        x[i + 1] = scipy.optimize.brentq(f, brackets[i], brackets[i + 1])
+
+    pp = scipy.special.legendre(n - 1)(x)
+    w[1:-1] = w[1:-1] / pp[1:-1] ** 2
+
+    # scale for desired interval
+    x *= 0.5 * (a - b)
+    x += 0.5 * (a + b)
+    w *= 0.5 * (b - a)
+
+    return np.flip(x), np.flip(w)

iadpython/redistribution.py

@@ -0,0 +1,318 @@
+r"""Module for calculating the redistribution function.
+
+The single scattering phase function ..math:`p(\nu)` for a tissue determines the
+amount of light scattered at an angle nu=cos(theta) from the direction of
+incidence.  The subtended angle nu is the dot product incident and exiting
+of the unit vectors.
+
+The redistribution function ..math:`h[i,j]` determines the fraction of light
+scattered from an incidence cone with angle `\nu_i` into a cone with angle
+..math:`\nu_j`.  The redistribution function is calculated by averaging the phase
+function over all possible azimuthal angles for fixed angles ..math:`\nu_i` and
+..math:`nu_j`,
+
+Note that the angles ..math:`\nu_i` and ..math:`\nu_j` may also be negative (light
+travelling in the opposite direction).
+
+When the cosine of the angle of incidence or exitance is unity (..math:`\nu_i=1` or
+..math:`\nu_j=1`), then the redistribution function is equivalent to the phase
+function ..math:`p(\nu_j)`.
+"""
+
+import scipy.special
+import scipy.integrate
+import warnings
+import numpy as np
+from numpy.polynomial.legendre import legvander, leggauss
+from scipy.special import eval_legendre
+import pandas as pd
+from scipy.interpolate import interp1d, CubicSpline
+
+__all__ = ('hg_elliptic',
+           'phase_legendre',
+           'legendre_coeffs_from_df')
+
+
+def _prepare_moments(pf_data, n_needed):
+    """Validate and normalize a ``pf_type='MOMENTS'`` array.
+
+    Shared by ``phase_legendre`` and ``Sample._deltaM_forward_fraction`` so
+    both consumers of a supplied moments array agree on the same validation
+    and normalization convention -- rather than each re-deriving it and
+    risking drift.
+
+    Parameters
+    ----------
+    pf_data  : array-like, Legendre moments a_l (index 0 = a_0)
+    n_needed : minimum number of moments required
+
+    Returns
+    -------
+    a_raw : ndarray, shape (n_needed,), normalized so a_0 = 1 (matching
+            legendre_coeffs_from_df's convention; an identically-zero
+            spectrum -- matched-index / no-scattering limit -- stays zero
+            instead of raising a division-by-zero).
+
+    Raises
+    ------
+    TypeError  if pf_data is DataFrame-like (np.asarray would otherwise
+               silently coerce it instead of failing).
+    ValueError if pf_data is not 1-D once materialized, or has fewer than
+               n_needed entries.
+    """
+    if hasattr(pf_data, "iloc"):
+        raise TypeError("pf_type='MOMENTS' requires a plain array, not a DataFrame")
+    a_raw = np.atleast_1d(np.asarray(pf_data, dtype=float))
+    if a_raw.ndim != 1:
+        raise ValueError(
+            "MOMENTS pf_data must be 1-D once materialized for a single "
+            "wavelength, got shape %s" % (a_raw.shape,)
+        )
+    if a_raw.size < n_needed:
+        raise ValueError(
+            "pf_type='MOMENTS' needs at least %d moments, got %d" % (n_needed, a_raw.size)
+        )
+    a_raw = a_raw[:n_needed].copy()
+    a0 = a_raw[0]
+    if np.isclose(a0, 0.0):
+        a_raw[:] = 0.0
+    else:
+        a_raw /= a0
+    return a_raw
+
+def legendre_coeffs_from_df(
+        df, *, quad_pts=8, n_mom=None, spline_bc='not-a-knot'):
+    """
+    Exact Legendre moments a_l (no ½(2l+1) factor) for a phase function
+    tabulated on μ = cosθ.
+
+    Parameters
+    ----------
+    df        : pandas.DataFrame
+                index = μ (strictly monotonic), columns = spectra
+    quad_pts  : kept only for API symmetry (default 8)
+    n_mom     : highest Legendre order (default 2*quad_pts)
+    spline_bc : boundary condition passed to CubicSpline
+
+    Returns
+    -------
+    a_raw : ndarray, shape (n_mom, nλ)
+            Legendre moments  a_l = ∫_{-1}^1 p(μ) P_l(μ) dμ ,  l=0…n_mom-1
+            *normalised* so that a_0 = 1 for every spectrum.
+    """
+    # ---------- sanity -------------------------------------------------
+    if not isinstance(df, pd.DataFrame):
+        raise TypeError("df must be a pandas DataFrame.")
+    
+    df = df.sort_index()                  # ascending μ for CubicSpline
+    mu = df.index.to_numpy()              # ascending version
+    p  = df.to_numpy().T                  # shape (nλ, Nμ)
+
+    if n_mom is None:
+        n_mom = 2 * quad_pts + 1          # Wiscombe default
+
+    nλ = p.shape[0]
+
+    # Adaptive quadrature: use fewer points for smaller n_mom
+    nquad = max(32, min(128, 4 * n_mom))
+    g_x, g_w = leggauss(nquad)
+
+    # Evaluate Legendre polynomials once at quadrature nodes
+    P_all = np.array([eval_legendre(l, g_x) for l in range(n_mom)])   # (n_mom, nquad)
+
+    # Vectorized spline evaluation: build all splines and evaluate at once
+    vals_all = np.zeros((nquad, nλ))
+    for col, y in enumerate(p):
+        f = CubicSpline(mu, y, bc_type=spline_bc)
+        vals_all[:, col] = f(g_x)
+
+    # Vectorized integration: compute all moments for all spectra at once
+    a_raw = P_all @ (vals_all * g_w[:, None])  # (n_mom, nquad) @ (nquad, nλ) = (n_mom, nλ)
+    
+    # Normalize so a_0 = 1 for each spectrum.  When the supplied phase
+    # function is identically zero (matched-index / no-scattering limits),
+    # leave all moments at zero instead of creating NaNs.
+    a0 = a_raw[0, :]
+    zero_mask = np.isclose(a0, 0.0)
+    if np.any(~zero_mask):
+        a_raw[:, ~zero_mask] /= a0[~zero_mask]
+    if np.any(zero_mask):
+        a_raw[:, zero_mask] = 0.0
+
+    return a_raw
+
+# ----------------------------------------------------------------------
+# unified HG / tabulated redistribution via Legendre polynomials
+# ----------------------------------------------------------------------
+def phase_legendre(sample, *, deltam=True):
+    """
+    Build (hp, hm) single-scatter redistribution blocks.
+
+    Modes
+    -----
+    * pf_type == 'HG'          : analytic Henyey–Greenstein (fast)
+    * pf_type == 'TABULATED'   : DataFrame in sample.pf_data
+                                 → Legendre coeffs via helper above
+    * pf_type == 'MOMENTS'     : Legendre moments a_l supplied directly in
+                                 sample.pf_data (bypasses the spline+
+                                 quadrature TABULATED needs -- for callers
+                                 that can evaluate their phase function
+                                 exactly at arbitrary angles and integrate
+                                 it themselves, e.g. via Gauss-Legendre
+                                 quadrature on mu=cos(theta))
+    Parameters
+    ----------
+    sample : iadpython.Sample   (must have quad_pts, nu, etc.)
+    deltam : bool               apply δ-M forward-spike split
+
+    Returns
+    -------
+    hp, hm : ndarray (N × N)
+    """
+
+    if sample.nu is None:
+        sample.update_quadrature()
+
+    mu  = sample.nu
+    n   = sample.quad_pts
+    P   = legvander(mu, 2*n).T                  # (2N+1, N)
+    w   = sample.twonuw / (2*mu)
+
+    pf_type = getattr(sample, "pf_type", "HG").upper()
+
+    # ---------------------------------------------------- HG fast path
+    if pf_type == "HG":
+        g   = float(sample.g)
+        if g == 0.0:
+            hp = hm = np.ones((n, n))
+            return hp, hm
+        a_raw = g ** np.arange(2*n+1)           # analytic a_ℓ = g^ℓ
+
+    # -------------------------------------------- Custom tabulated path
+    elif pf_type == "TABULATED":
+        df = sample.pf_data
+        a_raw = legendre_coeffs_from_df(df,
+                                        quad_pts=n,
+                                        n_mom=2*n+1)  # (2N+1 , nλ=1)
+        a_raw = a_raw.squeeze()                  # 1-D
+
+    # ----------------------------------------------- Direct moments path
+    elif pf_type == "MOMENTS":
+        a_raw = _prepare_moments(sample.pf_data, 2*n+1)
+
+    else:
+        raise ValueError(f"Unknown pf_type '{pf_type}'")
+
+    # -------------------------------------------- optional δ-M trunc
+    if deltam:
+        f_spike_end = 1 - 1E-10
+        f_spike = float(np.clip(a_raw[n], 0.0, f_spike_end)) # order-n moment; matches Sample._deltaM_forward_fraction (HG: g**n)
+        a_use = (a_raw[:n] - f_spike) / (1.0 - f_spike)
+        Lmax    = n
+        P_use   = P[:Lmax]
+
+    else:
+        a_use   = a_raw[:2*n+1]
+        Lmax    = 2*n+1
+        P_use   = P[:Lmax]
+
+    chi = (2*np.arange(Lmax) + 1) * a_use       # χ_ℓ weights
+
+    # -------------------------------------------- assemble blocks
+    hp = np.ones((n, n))
+    hm = np.ones((n, n))
+
+    for k in range(1, Lmax):
+        pk  = P_use[k]
+        add = chi[k] * np.outer(pk, pk)
+        hp += add
+        hm += (-1)**k * add
+    return hp, hm
+
+
+def hg_elliptic(sample):
+    """Calculate redistribution function using elliptic integrals.
+
+    This is the result of a direct integration of the Henyey-
+    Greenstein phase function.
+
+    It is not terribly useful because we cannot use the
+    delta-M method to more accurate model highly anisotropic
+    phase functions.
+    """
+    if sample.nu is None:
+        sample.update_quadrature()
+
+    n = sample.quad_pts
+    g = sample.g**n
+    if g == 0:
+        h = np.ones([n, n])
+        return h, h
+
+    hp = np.zeros([n, n])
+    hm = np.zeros([n, n])
+    for i in range(n):
+        for j in range(i + 1):
+            ni = sample.nu[i]
+            nj = sample.nu[j]
+            gamma = 2 * g * np.sqrt(1 - ni**2) * np.sqrt(1 - nj**2)
+
+            alpha = 1 + g**2 - 2 * g * ni * nj
+            const = 2 / np.pi * (1 - g**2) / (alpha - gamma) / np.sqrt(alpha + gamma)
+            arg = np.sqrt(2 * gamma / (alpha + gamma))
+            hp[i, j] = const * scipy.special.ellipe(arg)
+
+            alpha = 1 + g**2 + 2 * g * ni * nj
+            const = 2 / np.pi * (1 - g**2) / (alpha - gamma) / np.sqrt(alpha + gamma)
+            arg = np.sqrt(2 * gamma / (alpha + gamma))
+            hm[i, j] = const * scipy.special.ellipe(arg)
+
+    # fill symmetric entries
+    for i in range(n):
+        for j in range(i + 1, n):
+            hp[i, j] = hp[j, i]
+            hm[i, j] = hm[j, i]
+
+    return hp, hm
+
+def legendre_moments(g=None, custom_phase_function=None, max_order=16):
+    """
+    Compute the Legendre expansion coefficients (chi_k) of a phase function.
+
+    If custom_phase_function is provided, compute chi_k via integration over [-1, 1].
+    Otherwise, use Henyey-Greenstein with parameter g.
+    If both are None, assume isotropic scattering (g=0) and issue a warning.
+
+    Arguments:
+        g: Anisotropy factor for Henyey-Greenstein (float).
+        custom_phase_function: Function of mu (float in [-1, 1]) returning P(mu).
+        max_order: Number of Legendre moments to compute (int).
+
+    Returns:
+        chi: array of chi_k coefficients.
+    """
+    chi = np.zeros(max_order)
+
+    if custom_phase_function is not None:
+        if g is not None:
+            warnings.warn("custom_phase_function is set; g will be ignored.")
+
+        for k in range(max_order):
+            integrand = lambda mu: custom_phase_function(mu) * scipy.special.legendre(k)(mu)
+            chi[k], _ = scipy.integrate.quad(integrand, -1, 1)
+            chi[k] *= (2 * k + 1) / 2
+
+    elif isinstance(g, (float, int)):
+        for k in range(max_order):
+            chi[k] = (2 * k + 1) * (g ** k - g ** max_order) / (1 - g ** max_order)
+
+    elif g is not None:
+        raise TypeError("g must be a float or int if provided.")
+    
+    else:
+        warnings.warn("Neither g nor custom_phase_function provided. Proceeding with isotropic Henyey-Greenstein (g=0).")
+        g = 0
+        for k in range(max_order):
+            chi[k] = (2 * k + 1) * (g ** k - g ** max_order) / (1 - g ** max_order) if g != 1 else 0
+
+    return chi

iadpython/rxt.py

@@ -0,0 +1,201 @@
+"""Module for reading rxt files.
+
+This reads an input rxt file and saves the parameters into an
+Experiment object.
+
+Example::
+
+    >>> import numpy
+    >>> import matplotlib.pyplot as plt
+    >>> import iadpython
+    >>>
+    >>> filename = 'ink.rxt'
+    >>> exp = iadpython.read_rxt(filename)
+    >>> if exp.lambda0 is None:
+    >>>     plt.plot(exp.m_r)
+    >>> else:
+    >>>     plt.plot(exp.lambda0, exp.m_r)
+    >>> plt.ylabel("measured reflectance")
+    >>> plt.title(filename)
+    >>> plt.show()
+"""
+
+import os
+import re
+import numpy as np
+import iadpython
+
+__all__ = ("read_rxt", "read_and_remove_notation")
+
+
+def read_and_remove_notation(filename):
+    """Read file and remove all whitespace and comments."""
+    s = ""
+
+    if not os.path.exists(filename):
+        raise ValueError('input file "%s" must end in ".rxt"' % filename)
+
+    with open(filename, encoding="utf-8") as f:
+        for line in f:
+            line = re.sub(r"\s*#.*", "", line)
+            line = re.sub(r", ", " ", line)
+            s += line
+
+    if len(re.findall("IAD1", s)) == 0:
+        raise ValueError("Not an .rxt file. (Does not start with IAD1)")
+
+    s = re.sub(r"IAD1", "", s)
+    s = re.sub(r"\s+", " ", s)
+    s = s.rstrip()
+    s = s.lstrip()
+    return s
+
+
+def fill_in_data_fixed(exp, data_in_columns):
+    """Read data the old way by fixed column position."""
+    col = 0
+    if data_in_columns[0, 0] > 1:
+        exp.lambda0 = data_in_columns[:, 0]
+        col = 1
+    exp.m_r = data_in_columns[:, col]
+    if exp.num_measures >= 2:
+        exp.m_t = data_in_columns[:, col + 1]
+    if exp.num_measures >= 3:
+        exp.m_u = data_in_columns[:, col + 2]
+    if exp.num_measures >= 4:
+        exp.r_sphere.r_wall = data_in_columns[:, col + 3]
+    if exp.num_measures >= 5:
+        exp.t_sphere.r_wall = data_in_columns[:, col + 4]
+    if exp.num_measures >= 6:
+        exp.r_sphere.r_std = data_in_columns[:, col + 5]
+    if exp.num_measures >= 7:
+        exp.t_sphere.r_std = data_in_columns[:, col + 6]
+    if exp.num_measures > 7:
+        raise ValueError("unimplemented")
+
+
+def fill_in_data_variable(exp, data_in_columns, column_letters_str):
+    """Read data and interpret according to column_letters_str."""
+    for col, letter in enumerate(column_letters_str):
+        if letter == "a":
+            exp.default_a = data_in_columns[:, col]
+        elif letter == "b":
+            exp.default_b = data_in_columns[:, col]
+        elif letter == "B":
+            exp.d_beam = data_in_columns[:, col]
+        elif letter == "c":
+            exp.fraction_of_rc_in_mr = data_in_columns[:, col]
+        elif letter == "C":
+            exp.fraction_of_tc_in_mt = data_in_columns[:, col]
+        elif letter == "d":
+            exp.sample.d = data_in_columns[:, col]
+        elif letter == "D":
+            exp.sample.d_above = data_in_columns[:, col]
+            exp.sample.d_below = data_in_columns[:, col]
+        elif letter == "E":
+            exp.sample.b_above = data_in_columns[:, col]
+            exp.sample.b_below = data_in_columns[:, col]
+        elif letter == "e":
+            exp.error = data_in_columns[:, col]
+        elif letter == "g":
+            exp.default_g = data_in_columns[:, col]
+        elif letter == "t":
+            exp.m_t = data_in_columns[:, col]
+        elif letter == "L":
+            exp.lambda0 = data_in_columns[:, col]
+        elif letter == "n":
+            exp.n = data_in_columns[:, col]
+        elif letter == "N":
+            exp.n_above = data_in_columns[:, col]
+            exp.n_below = data_in_columns[:, col]
+        elif letter == "r":
+            exp.m_r = data_in_columns[:, col]
+        elif letter == "R":
+            exp.r_sphere.r_std = data_in_columns[:, col]
+        elif letter == "S":
+            exp.num_spheres = data_in_columns[:, col]
+        elif letter == "T":
+            exp.t_sphere.r_rstd = data_in_columns[:, col]
+        elif letter == "u":
+            exp.m_u = data_in_columns[:, col]
+        elif letter == "w":
+            exp.r_sphere.r_wall = data_in_columns[:, col]
+        elif letter == "W":
+            exp.t_sphere.r_wall = data_in_columns[:, col]
+        else:
+            raise ValueError('unimplemented column type "%s"' % letter)
+
+
+def read_rxt(filename):
+    """Read an IAD input file in .rxt format.
+
+    Args:
+        filename: .rxt filename
+
+    Returns:
+        Experiment object
+    """
+    s = read_and_remove_notation(filename)
+    x = s.split(" ")
+
+    # Remove single-letter entries and save them
+    column_letters = [item for item in x if len(item) == 1 and item.isalpha()]
+    x = [item for item in x if not (len(item) == 1 and item.isalpha())]
+    column_letters_str = "".join(column_letters)
+
+    x = np.array([float(item) for item in x])
+
+    sample = iadpython.Sample(a=None, b=None, g=None)
+    sample.n = x[0]
+    sample.n_above = x[1]
+    sample.d = x[2]
+    sample.d_above = x[3]
+
+    # try and save people from themselves
+    if sample.d_above == 0:
+        sample.n_above = 1
+    if sample.n_above == 1:
+        sample.d_above = 0
+    if sample.n_above == 0:
+        sample.n_above = 1
+        sample.d_above = 0
+    sample.d_below = sample.d_above
+    sample.n_below = sample.n_above
+    exp = iadpython.Experiment(sample=sample)
+
+    exp.d_beam = x[4]
+    exp.rstd_r = x[5]
+    exp.num_spheres = x[6]
+    exp.method = "substitution"
+
+    if exp.num_spheres > 0:
+        exp.r_sphere = iadpython.Sphere(x[7], x[8], x[9], x[10], 0, x[11])
+
+    if exp.num_spheres > 0:
+        exp.t_sphere = iadpython.Sphere(x[12], x[13], x[14], x[15], 0, x[16])
+
+    # Read data
+    if column_letters_str == "":
+        # old style data format
+        exp.num_measures = x[17]
+        data = x[18:]
+        columns = int(exp.num_measures)
+        if data[0] > 1:
+            columns += 1
+        data_in_columns = data.reshape(-1, columns)
+        fill_in_data_fixed(exp, data_in_columns)
+    else:
+        # new style variable header format
+        exp.num_measures = 0
+        if "r" in column_letters_str:
+            exp.num_measures += 1
+        if "t" in column_letters_str:
+            exp.num_measures += 1
+        if "u" in column_letters_str:
+            exp.num_measures += 1
+        data = x[17:]
+        columns = len(column_letters_str)
+        data_in_columns = data.reshape(-1, columns)
+        fill_in_data_variable(exp, data_in_columns, column_letters_str)
+
+    return exp